From 7361598dc21198f0bbfe14445118910f24459817 Mon Sep 17 00:00:00 2001 From: Carlos Trujillo <59846724+cetagostini@users.noreply.github.com> Date: Mon, 8 Jun 2026 14:30:51 +0300 Subject: [PATCH 1/3] Add tiny transformer LLM notebook Add a new gallery notebook demonstrating a tiny decoder-only transformer LLM implemented with pytensor/xtensor (doc/gallery/transformers/tiny_transformer_llm.ipynb). Update .gitignore to exclude AI tool artifacts, gallery downloaded data, and JupyterLab session files. Co-authored-by: Cursor --- .gitignore | 13 + .../transformers/tiny_transformer_llm.ipynb | 1246 +++++++++++++++++ 2 files changed, 1259 insertions(+) create mode 100644 doc/gallery/transformers/tiny_transformer_llm.ipynb diff --git a/.gitignore b/.gitignore index ebe8e61bd0..d2c130f80a 100644 --- a/.gitignore +++ b/.gitignore @@ -55,3 +55,16 @@ pytensor-venv/ testing-report.html coverage.xml .coverage.* + +# ai +.ai/ +.claude/ +.cursor/ +.CLAUDE.md + +# gallery notebook downloaded data +doc/gallery/**/data/ + +# JupyterLab session artifacts +.jupyter/ +.jupyter_ystore.db \ No newline at end of file diff --git a/doc/gallery/transformers/tiny_transformer_llm.ipynb b/doc/gallery/transformers/tiny_transformer_llm.ipynb new file mode 100644 index 0000000000..5a1c3954d1 --- /dev/null +++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb @@ -0,0 +1,1246 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(Tiny_Transformer_LLM)=\n", + "# A Tiny Transformer LLM in PyTensor\n", + "\n", + "Can you train a transformer language model end-to-end in PyTensor? Yes — and that is exactly what we do in this notebook. We build a small **decoder-only GPT** on character-level Tiny Shakespeare, train it with a hand-rolled **Adam** optimizer, and sample from it. Along the way we showcase what makes PyTensor distinctive for deep learning:\n", + "\n", + "* `pytensor.xtensor` **named dimensions** drive multi-head attention, so the `(batch, head, time, head_dim)` reshape gymnastics become self-documenting code,\n", + "* a **static graph** you can inspect with `pytensor.dprint`,\n", + "* symbolic **reverse-mode auto-diff** via `pytensor.grad`,\n", + "* `pytensor.shared` parameter state with **in-graph optimizer updates**, and\n", + "* `pytensor.scan` for **autoregressive generation** — the entire sampling loop, including all forward passes and all categorical draws, runs inside a single compiled call.\n", + "\n", + "The model is intentionally tiny (~100k parameters, a few thousand training steps) so the whole notebook runs on a laptop CPU in a couple of minutes.\n", + "\n", + "## Prepare notebook" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:26.660089Z", + "iopub.status.busy": "2026-05-07T13:13:26.659993Z", + "iopub.status.idle": "2026-05-07T13:13:27.126450Z", + "shell.execute_reply": "2026-05-07T13:13:27.125234Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pytensor: 3.0.0+18.g62e079c0e.dirty | floatX: float64\n" + ] + } + ], + "source": [ + "from __future__ import annotations\n", + "\n", + "import time\n", + "import urllib.request\n", + "from dataclasses import dataclass\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import pytensor\n", + "import pytensor.tensor as pt\n", + "import pytensor.tensor.random as ptr\n", + "import pytensor.xtensor as px\n", + "\n", + "\n", + "plt.style.use(\"seaborn-v0_8\")\n", + "\n", + "%config InlineBackend.figure_format = \"retina\"\n", + "\n", + "rng_np = np.random.default_rng(0)\n", + "floatX = pytensor.config.floatX\n", + "print(\"pytensor:\", pytensor.__version__, \"| floatX:\", floatX)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data — Tiny Shakespeare\n", + "\n", + "We download Andrej Karpathy's 1.1 MB **Tiny Shakespeare** corpus into a local cache directory and use a character-level vocabulary (~65 unique characters). To keep training fast on a laptop, we slice off only the first ~50,000 characters — plenty for the model to learn the shape, rhythm, and common words of Shakespearean English." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.129250Z", + "iopub.status.busy": "2026-05-07T13:13:27.128943Z", + "iopub.status.idle": "2026-05-07T13:13:27.134375Z", + "shell.execute_reply": "2026-05-07T13:13:27.133378Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full corpus: 1,115,394 characters\n", + "Used slice : 50,000 characters\n", + "\n", + "--- First 200 characters ---\n", + "\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": [ + "DATA_DIR = Path(\"data\")\n", + "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", + "DATA_FILE = DATA_DIR / \"tinyshakespeare.txt\"\n", + "DATA_URL = (\n", + " \"https://raw.githubusercontent.com/karpathy/char-rnn/\"\n", + " \"master/data/tinyshakespeare/input.txt\"\n", + ")\n", + "\n", + "if not DATA_FILE.exists():\n", + " print(\"Downloading\", DATA_URL)\n", + " urllib.request.urlretrieve(DATA_URL, DATA_FILE)\n", + "\n", + "full_text = DATA_FILE.read_text()\n", + "print(f\"Full corpus: {len(full_text):,} characters\")\n", + "\n", + "# Use a small slice so training is fast in a notebook.\n", + "text = full_text[:50_000]\n", + "print(f\"Used slice : {len(text):,} characters\")\n", + "print(\"\\n--- First 200 characters ---\\n\")\n", + "print(text[:200])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.136096Z", + "iopub.status.busy": "2026-05-07T13:13:27.135971Z", + "iopub.status.idle": "2026-05-07T13:13:27.143040Z", + "shell.execute_reply": "2026-05-07T13:13:27.141910Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vocab_size = 59\n", + "first 20 ids: [15, 41, 50, 51, 52, 1, 12, 41, 52, 41, 58, 37, 46, 7, 0, 11, 37, 38, 47, 50]\n", + "round-trip : 'First Citizen:\\nBefor'\n" + ] + } + ], + "source": [ + "chars = sorted(set(text))\n", + "vocab_size = len(chars)\n", + "stoi = {c: i for i, c in enumerate(chars)}\n", + "itos = {i: c for i, c in enumerate(chars)}\n", + "\n", + "def encode(s: str) -> np.ndarray:\n", + " return np.array([stoi[c] for c in s], dtype=\"int64\")\n", + "\n", + "def decode(arr: np.ndarray) -> str:\n", + " return \"\".join(itos[int(i)] for i in arr)\n", + "\n", + "data_ids = encode(text)\n", + "print(f\"vocab_size = {vocab_size}\")\n", + "print(f\"first 20 ids: {data_ids[:20].tolist()}\")\n", + "print(f\"round-trip : {decode(data_ids[:20])!r}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mini-batches of `(context, next-char)` pairs\n", + "\n", + "The transformer reads a window of `block_size` characters and predicts the next character at every position, so a batch element is a pair `(x, y)` of `block_size`-length sequences where `y[t] = x[t + 1]`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.145023Z", + "iopub.status.busy": "2026-05-07T13:13:27.144920Z", + "iopub.status.idle": "2026-05-07T13:13:27.149354Z", + "shell.execute_reply": "2026-05-07T13:13:27.148415Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x[0]: 'renowned Coriola'\n", + "y[0]: 'enowned Coriolan'\n" + ] + } + ], + "source": [ + "def get_batch(rng: np.random.Generator, batch_size: int, block_size: int):\n", + " \"\"\"Sample `batch_size` random windows of length `block_size + 1` from the corpus.\"\"\"\n", + " starts = rng.integers(0, len(data_ids) - block_size - 1, size=batch_size)\n", + " x = np.stack([data_ids[s : s + block_size] for s in starts])\n", + " y = np.stack([data_ids[s + 1 : s + 1 + block_size] for s in starts])\n", + " return x, y\n", + "\n", + "x_demo, y_demo = get_batch(rng_np, batch_size=2, block_size=16)\n", + "print(\"x[0]:\", repr(decode(x_demo[0])))\n", + "print(\"y[0]:\", repr(decode(y_demo[0])))\n", + "assert (x_demo[:, 1:] == y_demo[:, :-1]).all(), \"y is x shifted by one\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hyper-parameters and parameter init\n", + "\n", + "A tiny GPT-style transformer with a few thousand parameters. Note that `block_size` is *static* in the PyTensor graph (it appears in the causal-mask shape), while `batch_size` is left symbolic so we can train on `B=16` and sample at `B=1` with the **same** compiled graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.151290Z", + "iopub.status.busy": "2026-05-07T13:13:27.151119Z", + "iopub.status.idle": "2026-05-07T13:13:27.156816Z", + "shell.execute_reply": "2026-05-07T13:13:27.156272Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Config(vocab_size=59, block_size=32, n_embd=64, n_head=4, n_layer=2)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@dataclass\n", + "class Config:\n", + " vocab_size: int\n", + " block_size: int = 32\n", + " n_embd: int = 64\n", + " n_head: int = 4\n", + " n_layer: int = 2\n", + "\n", + " @property\n", + " def head_dim(self) -> int:\n", + " assert self.n_embd % self.n_head == 0, \"n_embd must be divisible by n_head\"\n", + " return self.n_embd // self.n_head\n", + "\n", + "cfg = Config(vocab_size=vocab_size)\n", + "cfg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.158183Z", + "iopub.status.busy": "2026-05-07T13:13:27.158078Z", + "iopub.status.idle": "2026-05-07T13:13:27.167215Z", + "shell.execute_reply": "2026-05-07T13:13:27.166803Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 shared variables, 104,768 total parameters\n" + ] + } + ], + "source": [ + "def init_params(cfg: Config, rng: np.random.Generator) -> dict[str, np.ndarray]:\n", + " D = cfg.n_embd\n", + " p: dict[str, np.ndarray] = {}\n", + "\n", + " p[\"tok_embed\"] = rng.normal(0, 0.02, (cfg.vocab_size, D)).astype(floatX)\n", + " p[\"pos_embed\"] = rng.normal(0, 0.02, (cfg.block_size, D)).astype(floatX)\n", + "\n", + " for i in range(cfg.n_layer):\n", + " p[f\"l{i}.ln1_g\"] = np.ones(D, dtype=floatX)\n", + " p[f\"l{i}.ln1_b\"] = np.zeros(D, dtype=floatX)\n", + " p[f\"l{i}.W_qkv\"] = rng.normal(0, 0.02, (D, 3 * D)).astype(floatX)\n", + " p[f\"l{i}.W_proj\"] = rng.normal(0, 0.02, (D, D)).astype(floatX)\n", + " p[f\"l{i}.ln2_g\"] = np.ones(D, dtype=floatX)\n", + " p[f\"l{i}.ln2_b\"] = np.zeros(D, dtype=floatX)\n", + " p[f\"l{i}.W_fc\"] = rng.normal(0, 0.02, (D, 4 * D)).astype(floatX)\n", + " p[f\"l{i}.W_proj2\"] = rng.normal(0, 0.02, (4 * D, D)).astype(floatX)\n", + "\n", + " p[\"ln_f_g\"] = np.ones(D, dtype=floatX)\n", + " p[\"ln_f_b\"] = np.zeros(D, dtype=floatX)\n", + " return p\n", + "\n", + "# Wrap each numpy array in a `pytensor.shared` so the optimizer can update it in-graph.\n", + "init_arrays = init_params(cfg, np.random.default_rng(42))\n", + "params = {name: pytensor.shared(arr, name=name) for name, arr in init_arrays.items()}\n", + "\n", + "n_params = sum(arr.size for arr in init_arrays.values())\n", + "print(f\"{len(params)} shared variables, {n_params:,} total parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The model with named-dimension attention\n", + "\n", + "Multi-head attention is the place in transformer code where axis bookkeeping bites the hardest: `(B, T, D)` becomes `(B, T, H, hd)` and then `(B, H, T, hd)`, and you have to remember every transpose. We build attention with [`pytensor.xtensor`](../../library/xtensor.rst), which gives every dimension a **name**, so each operation is driven by what the axis *means* rather than its index. The xtensor sub-graph is lowered to ordinary tensor ops at compile time, so the same Numba / JAX / C / MLX backends still apply.\n", + "\n", + "Layernorm, MLP, embeddings, and the residual stream stay as plain `pytensor.tensor`, where named dimensions add little. Every component is a Python function that **builds a symbolic graph** from its inputs; these functions run *once* at graph-construction time, so there is no per-batch Python overhead during training." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.168815Z", + "iopub.status.busy": "2026-05-07T13:13:27.168689Z", + "iopub.status.idle": "2026-05-07T13:13:27.173978Z", + "shell.execute_reply": "2026-05-07T13:13:27.173296Z" + } + }, + "outputs": [], + "source": [ + "from pytensor.xtensor.shape import stack as xstack\n", + "\n", + "\n", + "def layernorm(x, gamma, beta, eps=1e-5):\n", + " mu = x.mean(axis=-1, keepdims=True)\n", + " var = x.var(axis=-1, keepdims=True)\n", + " return (x - mu) / pt.sqrt(var + eps) * gamma + beta\n", + "\n", + "\n", + "def causal_self_attention(x, p, n_head, head_dim, block_size):\n", + " \"\"\"Multi-head causal self-attention with named dimensions.\n", + "\n", + " Inputs/outputs are plain `(B, T, D)` tensors. Internally we wrap them as\n", + " xtensors with named dims and reshape `W_qkv` to expose ('qkv', 'head', 'hd')\n", + " as named axes — from then on every op is pure semantics: contract over\n", + " 'embd', contract over 'hd' (head_dim), softmax over 'time_k'.\n", + " \"\"\"\n", + " D = n_head * head_dim\n", + " x_x = px.as_xtensor(x, dims=(\"batch\", \"time\", \"embd\"))\n", + " Wqkv = px.as_xtensor(\n", + " p[\"W_qkv\"].reshape((D, 3, n_head, head_dim)),\n", + " dims=(\"embd\", \"qkv\", \"head\", \"hd\"),\n", + " )\n", + " Wproj = px.as_xtensor(p[\"W_proj\"], dims=(\"embd\", \"embd_out\"))\n", + "\n", + " qkv = px.dot(x_x, Wqkv, dim=\"embd\") # (batch, time, qkv, head, hd)\n", + " q = qkv.isel(qkv=0).rename(time=\"time_q\")\n", + " k = qkv.isel(qkv=1).rename(time=\"time_k\")\n", + " v = qkv.isel(qkv=2).rename(time=\"time_k\")\n", + "\n", + " scale = np.sqrt(head_dim).astype(floatX)\n", + " scores = px.dot(q, k, dim=\"hd\") / scale # (batch, head, time_q, time_k)\n", + "\n", + " mask = px.as_xtensor(\n", + " pt.tril(pt.ones((block_size, block_size), dtype=\"bool\")),\n", + " dims=(\"time_q\", \"time_k\"),\n", + " )\n", + " scores = px.where(mask, scores, np.float64(-1e9))\n", + " attn = px.math.softmax(scores, dim=\"time_k\")\n", + "\n", + " out = px.dot(attn, v, dim=\"time_k\") # (batch, head, time_q, hd)\n", + " out = xstack(out, embd=(\"head\", \"hd\")) # merge heads back\n", + " out = px.dot(out, Wproj, dim=\"embd\").rename(time_q=\"time\", embd_out=\"embd\")\n", + " return out.transpose(\"batch\", \"time\", \"embd\").values\n", + "\n", + "\n", + "def mlp(x, p):\n", + " h = pt.tanh(x @ p[\"W_fc\"]) # tanh keeps the toy model simple\n", + " return h @ p[\"W_proj2\"]\n", + "\n", + "\n", + "def block(x, params, layer: int, n_head: int, head_dim: int, block_size: int):\n", + " p = {k.split(\".\", 1)[1]: v for k, v in params.items() if k.startswith(f\"l{layer}.\")}\n", + " x = x + causal_self_attention(\n", + " layernorm(x, p[\"ln1_g\"], p[\"ln1_b\"]), p, n_head, head_dim, block_size\n", + " )\n", + " x = x + mlp(layernorm(x, p[\"ln2_g\"], p[\"ln2_b\"]), p)\n", + " return x\n", + "\n", + "\n", + "def forward(tokens, params, cfg: Config):\n", + " \"\"\"Returns logits of shape (B, T, vocab_size). Uses tied embeddings.\"\"\"\n", + " h = params[\"tok_embed\"][tokens] + params[\"pos_embed\"]\n", + " for i in range(cfg.n_layer):\n", + " h = block(h, params, i, cfg.n_head, cfg.head_dim, cfg.block_size)\n", + " h = layernorm(h, params[\"ln_f_g\"], params[\"ln_f_b\"])\n", + " return h @ params[\"tok_embed\"].T # tied output head" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we build the symbolic logits graph and inspect it. The whole forward pass is a single `TensorVariable`, with the named-dimension attention sub-graph showing up as a wrapped xtensor block. The `lower_xtensor` rewrite (which runs automatically at compile time) replaces those xtensor ops with plain tensor ops." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.175559Z", + "iopub.status.busy": "2026-05-07T13:13:27.175439Z", + "iopub.status.idle": "2026-05-07T13:13:27.284973Z", + "shell.execute_reply": "2026-05-07T13:13:27.284421Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logits type: Tensor3(float64, shape=(?, 32, ?))\n", + "\n", + "--- forward graph (truncated) ---\n", + "Matmul [id A]\n", + " ├─ Add [id B]\n", + " │ ├─ Mul [id C]\n", + " │ │ ├─ True_div [id D]\n", + " │ │ └─ ExpandDims{axes=(0, 1)} [id E]\n", + " │ └─ ExpandDims{axes=(0, 1)} [id F]\n", + " │ └─ ln_f_b [id G]\n", + " └─ ExpandDims{axis=0} [id H]\n", + " └─ MatrixTranspose [id I] 'tok_embed.T'\n", + " └─ tok_embed [id J]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_sym = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + "logits = forward(X_sym, params, cfg)\n", + "print(\"logits type:\", logits.type)\n", + "print(\"\\n--- forward graph (truncated) ---\")\n", + "logits.dprint(depth=4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:27.286619Z", + "iopub.status.busy": "2026-05-07T13:13:27.286405Z", + "iopub.status.idle": "2026-05-07T13:13:30.359631Z", + "shell.execute_reply": "2026-05-07T13:13:30.359060Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input shape : (4, 32)\n", + "logits shape: (4, 32, 59)\n" + ] + } + ], + "source": [ + "# Sanity check: compile the forward pass and feed a real batch.\n", + "f_forward = pytensor.function([X_sym], logits)\n", + "x_batch, _ = get_batch(rng_np, batch_size=4, block_size=cfg.block_size)\n", + "out = f_forward(x_batch)\n", + "print(\"input shape :\", x_batch.shape)\n", + "print(\"logits shape:\", out.shape)\n", + "assert out.shape == (4, cfg.block_size, cfg.vocab_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss and gradients\n", + "\n", + "We use cross-entropy averaged over `(B, T)`, computed with `pt.special.log_softmax` for numerical stability and advanced indexing to gather the log-prob assigned to the true target at every position.\n", + "\n", + "Because the forward graph contains xtensor ops (inside attention) and `pytensor.grad` runs *before* compile-time lowering, we explicitly lower the xtensor sub-graph first with `rewrite_graph(..., include=(\"lower_xtensor\",))`. From there one line of PyTensor gives us the gradients of the loss with respect to **every** parameter — as a *new symbolic graph*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:30.361026Z", + "iopub.status.busy": "2026-05-07T13:13:30.360867Z", + "iopub.status.idle": "2026-05-07T13:13:30.435791Z", + "shell.execute_reply": "2026-05-07T13:13:30.435284Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss is a Scalar(float64, shape=())\n", + "pytensor.grad returned 20 gradient graphs (one per shared variable).\n" + ] + } + ], + "source": [ + "from pytensor.graph.rewriting.utils import rewrite_graph\n", + "\n", + "Y_sym = pt.tensor(\"Y\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + "\n", + "log_probs = pt.special.log_softmax(logits, axis=-1) # (B, T, V)\n", + "B_sym = X_sym.shape[0]\n", + "T_sym = X_sym.shape[1]\n", + "batch_idx = pt.arange(B_sym)[:, None] # (B, 1)\n", + "time_idx = pt.arange(T_sym)[None, :] # (1, T)\n", + "nll = -log_probs[batch_idx, time_idx, Y_sym] # (B, T)\n", + "loss = nll.mean()\n", + "\n", + "# Lower xtensor ops to plain tensor ops so `pytensor.grad` can pull back through them.\n", + "loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n", + "\n", + "flat_params = list(params.values())\n", + "grads = pytensor.grad(loss, flat_params)\n", + "print(f\"Loss is a {loss.type}\")\n", + "print(f\"pytensor.grad returned {len(grads)} gradient graphs (one per shared variable).\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adam optimizer\n", + "\n", + "The optimizer is just a function that returns a list of `(shared_var, new_value)` updates. PyTensor weaves those updates into the same compiled function as the forward and backward pass, so there is no Python overhead per step — the entire forward/backward/update is one C/Numba call." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:30.437214Z", + "iopub.status.busy": "2026-05-07T13:13:30.437105Z", + "iopub.status.idle": "2026-05-07T13:13:30.487164Z", + "shell.execute_reply": "2026-05-07T13:13:30.486661Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adam adds 61 updates (20 params x 3 + 1 step counter).\n" + ] + } + ], + "source": [ + "def adam_updates(\n", + " params, grads, lr=3e-3, b1=0.9, b2=0.999, eps=1e-8\n", + "):\n", + " t = pytensor.shared(np.array(0.0, dtype=floatX), name=\"adam_t\")\n", + " t_new = t + 1\n", + " updates = [(t, t_new)]\n", + " for p, g in zip(params, grads):\n", + " m = pytensor.shared(np.zeros_like(p.get_value()), name=p.name + \"_m\")\n", + " v = pytensor.shared(np.zeros_like(p.get_value()), name=p.name + \"_v\")\n", + " m_new = b1 * m + (1 - b1) * g\n", + " v_new = b2 * v + (1 - b2) * pt.square(g)\n", + " m_hat = m_new / (1 - b1 ** t_new)\n", + " v_hat = v_new / (1 - b2 ** t_new)\n", + " p_new = p - lr * m_hat / (pt.sqrt(v_hat) + eps)\n", + " updates += [(m, m_new), (v, v_new), (p, p_new)]\n", + " return updates\n", + "\n", + "updates = adam_updates(flat_params, grads, lr=3e-3)\n", + "print(f\"Adam adds {len(updates)} updates ({len(flat_params)} params x 3 + 1 step counter).\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compile the train step and train\n", + "\n", + "The first call to `pytensor.function` takes a few seconds while PyTensor optimises and compiles the graph. Each subsequent call is a pure C / Numba invocation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:30.488447Z", + "iopub.status.busy": "2026-05-07T13:13:30.488361Z", + "iopub.status.idle": "2026-05-07T13:13:44.104011Z", + "shell.execute_reply": "2026-05-07T13:13:44.103622Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compilation took 2.0s\n", + "Initial loss = 4.078 (random baseline = 4.078)\n" + ] + } + ], + "source": [ + "t0 = time.time()\n", + "train_step = pytensor.function([X_sym, Y_sym], loss, updates=updates)\n", + "print(f\"Compilation took {time.time() - t0:.1f}s\")\n", + "\n", + "# Initial loss should be near ln(vocab_size) for a randomly initialised model.\n", + "x_init, y_init = get_batch(rng_np, batch_size=4, block_size=cfg.block_size)\n", + "initial_loss = float(train_step(x_init, y_init))\n", + "print(f\"Initial loss = {initial_loss:.3f} (random baseline = {np.log(vocab_size):.3f})\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:13:44.105474Z", + "iopub.status.busy": "2026-05-07T13:13:44.105383Z", + "iopub.status.idle": "2026-05-07T13:14:19.641951Z", + "shell.execute_reply": "2026-05-07T13:14:19.641513Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0 recent-mean loss = 3.886\n", + "step 100 recent-mean loss = 2.835\n", + "step 200 recent-mean loss = 2.398\n", + "step 300 recent-mean loss = 2.234\n", + "step 400 recent-mean loss = 2.129\n", + "step 500 recent-mean loss = 2.050\n", + "step 600 recent-mean loss = 1.984\n", + "step 700 recent-mean loss = 1.930\n", + "step 800 recent-mean loss = 1.884\n", + "step 900 recent-mean loss = 1.833\n", + "step 1000 recent-mean loss = 1.793\n", + "step 1100 recent-mean loss = 1.770\n", + "step 1200 recent-mean loss = 1.728\n", + "step 1300 recent-mean loss = 1.705\n", + "step 1400 recent-mean loss = 1.674\n", + "step 1499 recent-mean loss = 1.650\n", + "\n", + "Total training time: 32.8s\n" + ] + } + ], + "source": [ + "BATCH_SIZE = 32\n", + "N_STEPS = 1500\n", + "LOG_EVERY = 100\n", + "\n", + "losses = []\n", + "t0 = time.time()\n", + "for step in range(N_STEPS):\n", + " x_b, y_b = get_batch(rng_np, BATCH_SIZE, cfg.block_size)\n", + " losses.append(float(train_step(x_b, y_b)))\n", + " if step % LOG_EVERY == 0 or step == N_STEPS - 1:\n", + " recent = np.mean(losses[-LOG_EVERY:])\n", + " print(f\"step {step:>4d} recent-mean loss = {recent:.3f}\")\n", + "print(f\"\\nTotal training time: {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:14:19.643434Z", + "iopub.status.busy": "2026-05-07T13:14:19.643321Z", + "iopub.status.idle": "2026-05-07T13:14:19.739221Z", + "shell.execute_reply": "2026-05-07T13:14:19.738756Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABWIAAAMOCAYAAACULH/wAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3Qd8E/X/x/FPmw5KWS2UvffeIAiIigoIKKgMcf5EERXFievvwoGiCO69QdkgUxAQBBmy95a9aQuF7vV/fL4lIW2TzjRt2tfz8cgj6d3l7nK5BvrO5z5fr+Tk5GQBAAAAAAAAAOQZ77xbNQAAAAAAAABAEcQCAAAAAAAAQB4jiAUAAAAAAACAPEYQCwAAAAAAAAB5jCAWAAAAAAAAAPIYQSwAAAAAAAAA5DGCWAAAAAAAAADIYwSxAAAAAAAAAJDHCGIBAAAAAAAAII8RxAIAAAAAAABAHiOIBQAAAAAAAIA8RhALAAAAAAAAAHmMIBYAAAAAAAAA8hhBLAAAAAAAAADkMYJYAAAAAAAAAMhjBLEAAAAAAAAAkMcIYgEAAAAAAAAgjxHEAgAAAAAAAEAeI4gFAAAAAAAAgDzmk9cbAAAAgPutXbtW7r33Xpesq1+/fvLuu+9Kfjh27Jh069bNPG7fvr388ssveX688vP1AgAAoPCiIhYAAAAAAAAA8hgVsQAAAIVQ9erVZeTIkU7nb9++XebPn28eV6tWTe68806ny9arVy9P9hEAAAAoSrySk5OT83snAAAA4F4zZsyQF198Mc8v+QcAAACQgtYEAAAAAAAAAJDHCGIBAAAAAAAAII/RIxYAAABZcv3118vx48elc+fO8t1338nChQvls88+k0OHDklQUJC0aNFCHn30UWnYsKHtOdoFa8mSJbJs2TLZvHmznD17Vi5duiTFixeX4OBg85ybb75Zrr32WofbPHbsmHTr1s1pC4V77rlH/v33X6lVq5b88ccfEhcXJ1OnTpUFCxbIf//9JxcvXpSyZctKmzZtpH///tKhQweH21m7dq3ce++95nG/fv3k3XffzfC162v47bffZNGiRXLkyBGJjo6W8uXLm/Vrv90mTZpkejz1uOnr+eeff+TEiRPi6+srNWrUkJ49e8rdd98tAQEB0qxZM/OaXNE+4syZMzJlyhT5+++/zbHRfS5ZsqQ0aNBAunfvLrfffrv4+/une57OV1WqVJGlS5dmuA3rcVJ79uxJNe+TTz6RTz/91DxeuXKlxMbGmuO8atUq89pr1qwpvXr1kg8++MDM8/HxkRUrVpjzJCPjxo2TL7/80jx+4okn5LHHHku3THh4uEyePFmWL18uhw8floiICCldurTUrVvX7POAAQPM8QYAAMhLBLEAAADINg1hR4wYYYJWderUKXMbPny4bZkDBw7Ik08+KXv37k33fA3C9KZh5O+//y5dunSRjz76SAIDA3P8bhw9etQEwWm3d/LkSZk7d665DRo0SF5//XXx8vLK8XZ0oLPHH3/chKdpt6+36dOnm2MzbNgwp+vQZV577TWJj4+3TdPwcceOHeamgenXX38trvLTTz/J2LFjzTbSBpRr1qwxN13m888/lzp16kheu3DhggwdOtQW2ioN6lu3bm2Cdx1ILiEhwZxnGQ0kp/R9Vfqe3nrrrenmz5kzR0aNGmXON3vnzp0zN33t33zzjQmAnQX1AAAArkAQCwAAgGyHaK+++qothLXSAK9+/frm8enTp2Xw4MFy/vx583NISIh07drVVFV6e3ubcFSrHa1BnD7WoFDXmxNRUVHy4IMPmmC3VKlScsMNN0j16tVN+KYVuVoFqSZNmiSNGjUygWxO6OvSADE0NNS8Jq2mrFy5sgn0tCJXK36TkpJMlaZWxWrAnJZW7L7yyiu246dVmVoRrFXCu3btkr/++stU2d53332SmJgouaVVqFqNaqXHRd8LrTTV4FjDzsjISHPstCpYg/Fy5cpJXtJKWPsQ1qpHjx7mnNEgVul9RkGshrdaNa206rlq1aqp5k+cONGEsPbVvVdffbWp4Nb3Sitk9VjrYz1/vvjiC4fvGQAAgCsQxAIAACBbtm3bZu41PBw5cqRUqlRJdu7cKWFhYbZlPvzwQ1sIe80115ggsFixYqnWoxWPGshZL7mfOXOmWV/a5bIakCqtptR1ahhr9eyzz8rLL79s1q9++OGHHAex+/btM/cDBw4067S/lP+ZZ54xFcF62b11O2lDPd3Pd955xxbCamWtVvFqOG21e/duefjhh02FcW5t3brV1g7Aeum+VupaLJZU+z1kyBCzXQ2UNRAfPXq05CUN3jXIfuONN0wVqp472uZBW1Vo+KxBsO7L+vXrzTGrUKFChtWwKm01rFYuW1+Hvk963Hv37p1qmRdffNG0mtDzVauT9VzRthaZtUMAAADICQbrAgAAQLZp5asGfFoFq5Wcbdu2lZtuusnM096jWh1qDcA0DHMUrmoPUA1eraGpVrVq79Kc0h6j48ePTxXCKg0dtQLV2vZAKz+1IjentF+rBohp+6lqj1H76kvtXZu2olV76urrtIa5Gtzah7BKe+xqWwLtm5pb3377rS301b6z2j/VPoRVGnrqe6nvh/VSfq2QzWsazmtwru9LtWrVTBisdP+sgalWF2sw6ogeW+s8Pz8/U01rT1tdWFs/6PuVNoS1bksrnLV6W+mXBz///LOLXykAAEAKglgAAABkmw585Swo1PBLq0U14NKgMaPL3DVAq127tu3n3ASAOtiUrs8RDfvsB9DSS9FzSqtpnfWY1dYLerMeB23jYKWh4p9//mkea+ip1bDO6CX0jvqdZocO8qWVp9btPfLII06X1SBUg8p27dpJ3759U+13XmjcuLG0atXK6Xz71z5v3jyHy2hvV62aVdddd12qAF6raK2vvWLFiuY1ZcT+2MyePTsbrwQAACDraE0AAACAbGvZsqXTeRqI6Sj0WaH9Pa0VotZ2BTnVvHnzDOfbX26uIWVebsfa/9R+cCxt6WBt39CsWTNzaX5GunfvLtOmTcvxfm7atMl2bHV7mfV9fe+996QgnD/WoFarrnXgNW2voL1sNSzOaluCdevW2SqBtSdwZoOz6XuhAbq+b3rLqB0CAABAThHEAgAAINvSDoqUGQ22tCWADoykt/3795uBqdK2CEg7AFh2ZBY0ausA++pUd2/HOmCYsg5qlhGtis0N+2OrA4J52vmj4er7779vq4rV3rb2Qbq1urhMmTKmD7E9Pb+sdPCz7B7LEydOEMQCAACXI4gFAABAtqXtw+pIaGio6VGqPUczagWgfTrT9lLNiewM8pWbwNc+aM3OdvR4WJUsWTLT5wYFBUlu2A+elpX3y52ysj99+vQxg2jpuZE2iF22bJlcvHjRPO7Vq1e6Nhm5ba2Q160ZAABA0UQQCwAAgOz/J/LywE7ObNiwQR599FEz+JE97eGqg2ppRahent6pUyd57bXXzMBWhZ19O4SsVOTmJizObZuHnMrqPqcdMMwRbQ3QsWNHWblypWlRoFWu1srejNoSKPtgX9fRpUsXyY5atWpla3kAAICsIIgFAACAS4WHh5uBqKwhrPbovPvuu6V169ZSo0aNdCFcdHR0kXgHSpcubXscERGR6fJZWSYj9lW31urRvA5Z7XviusItt9xiglilVbEjRoyQS5cumYpYpaF+ixYtMqy41fB2yJAhLt0vAACAnPDO0bMAAAAAJ6ZOnWq7DL9JkyYyZcoUueOOO6R27doOKyHtL6HPbRVoQWbfp9W+h6kzWVkmI/aDW/3333+ZLr9ixQp58cUX5bPPPjMDZFl5e3tnaYCz+Pj4dBXQuXXTTTdJ8eLFzWNrT9jFixfbAl9H1bBpX3tWj6N+gVCYzz8AAJD/CGIBAADgUlu2bLE97tu3r2lH4MyxY8fMKPWuGESroGvWrJktVNy+fXuqnrGOLF26NFfb09YP1hBVg9XM+p4uWrRIZsyYIR9//LHs27cvXe9dfX5G78/OnTtd0us3bT/e7t27m8e6T0ePHpU//vjD/Ozl5WUqZh1p27ZtqjYZ9mG/I2fOnDHtC7S6tmfPnpkuDwAAkBMEsQAAAHAp+8pJrTLMyOjRo/O9r6m7+Pv7y80332x7nV988YXTZU+cOCHTp0/P1fZKlCgh1113ne09+f77750uq8HjggULzGMd+Oqaa66xzatUqZKt4nXt2rVO1/HVV19JXrCvetXesKtWrTKP27RpI1WrVnX4nDp16kjz5s1tr33cuHEZbmP8+PHm9WmlbWBgoAQHB7v0NQAAACiCWAAAALhUw4YNbY9/++03OXLkSLplNKDVfp96mXlR6hf78MMPm0BWTZgwQb777rt0l8Nr1edDDz0kkZGRud7esGHDbO0gvv76a5k4cWK6ZbSdgL4X1j6yWsUcEhJim9+hQwfb43feeSdduK5B59tvvy1LliyRvHDVVVfZwmB9DZm1JbB64oknTNWs0vYY7733Xrr2ChqIf/7556lCb+1vDAAAkBcYrAsAAAAuNWDAAPnpp59MYKahXa9evUyvTx2JXoMw7Ve6fPlyWyimFZhajahc3WO0oKlevbqMHDlS3nzzTRPAjhkzRmbNmmUqULWCVfuZajgdExNjLsu3BtPWQDG7tCr0qaeekg8++MC0FRg1apRMmjTJXIavg4dpa4iFCxfa2hbo4FfPPfdcqnXcddddMnnyZBNa7t2717QK6NGjh1SsWFFOnTplAthz586ZAbJ0e9bBtVxF2yv06dPHhLBRUVFmmra70H3IiL5GDaKtlcdaETx//nxTJVyhQgXTjkD74mrwbaWDynXt2tWl+w8AAGBFEAsAAACX0oGSxo4dK88++6wJFDVw1UvK09JwUUNbHdDr1VdfNdN27NhR6N8NDfv0uFgvh9dwU2/26tevL0OGDJHnn3/e/JxRn93MaHWt9qbV0Fe362h71p6yH330kQlo017mr8996aWXzPM1tNVg1p4Gm/p6tL2Bq4NYa5WuBrFWGqZq8JuZJ598UsqWLWvORw21NTjWKu20tGr4wQcfNKE1AABAXiGIBQAAgMvdeOONMnv2bFMZu3r1atPzVAdy0v6bWhWqgyLdfvvt0qhRIzl9+rSpetSKzT///FNefvll26BWhZWGflp5qaHgP//8Y6ozNZiuXbu29O7dWwYPHixr1qyxLZ/b46FVrTfccIP8+uuvJijVSthLly6Z0FUHEdOKUx2kytrGIC2tam7VqpX88ssvpppZ308fHx/zXup7rfur67L2mXU1DYObNm1qBjnLSlsCe/fcc495bRoe67E+dOiQCZO1RYR+aaCtDwYOHGi2AQAAkJe8ktM2pQIAAACQ7/QyemuFpgap1qphAAAAeCYqYgEAAAA30cvry5cvb6ovtRI1I/btA7S/LgAAADwbQSwAAADgJtOnTzeXxmsbAr3EX3urOqK9WKdNm2b7uV27drxHAAAAHs47v3cAAAAAKCo6dOhg7rU72KhRoyQqKirdMtq/9LHHHpOzZ8+an9u3by8NGzZ0+74CAADAtegRCwAAALiJDpKlA2NZA9gyZcrI9ddfL1WqVJH4+Hgzf+nSpbb5JUuWlJkzZ5pBpQAAAODZCGIBAAAAN9q4caMZhOvUqVMZLle/fn35+OOP6Q8LAABQSBDEAgAAAG6mFa+zZs2SJUuWyJ49e+T8+fPi7+9vBvKqW7eu3HrrrdK1a1fx9fXlvQEAACgkCGIBAAAAAAAAII8xWBcAAAAAAAAA5DGCWAAAAAAAAADIYwSxAAAAAAAAAJDHCGIBAAAAAAAAII8RxAIAAAAAAABAHiOIBQAAAAAAAIA8RhALAAAAAAAAAHmMIBYAAAAAAAAA8phPXm8A+ePs2YuF+tAHBRUXHx+LJCQkSnh4VH7vDgoJzitwXsGT8JkFzit4Ej6zwHkFT8HnFeyFhJQUV6IiFh7Jy8sr1T3AeYWCis8rcG7Bk/CZBc4teBI+s8B5BU9DEAsAAAAAAAAAeYwgFgAAAAAAAADyGEEsAAAAAAAAAOQxglgAAAAAAAAAyGMEsQAAAAAAAACQxwhiAQAAAAAAACCPEcQCAAAAAAAAQB4jiAUAAAAAAACAPEYQCwAAAAAAAAB5jCAWAAAAAAAAAPIYQSwAAAAAAAAA5DGCWAAAAAAAAADIYwSxAAAAAAAAAJDHCGIBAAAAAAAAII8RxAIAAAAAAABAHiOIBQAAAAAAAIA8RhALAAAAAAAAAHmMIBYAAAAAAAAA8hhBLAAAAAAAAADkMYJYAAAAAAAAAMhjBLEAAAAAAAAAkMcIYgEAAAAAAAAgjxHEAgAAAAAAAEAeI4gFAAAAAAAAgDzmk9cbQP7YuPFf2bRpXa7X07r1VdKqVVun8xcs+F1OnDiW6+3cfHNfqVSpitP5P/zwpSQlJdp+9vLysj1OTk7O8nb+979HxNvb8fcPZ8+eltmzp0luhYRUlFtuud3p/O3bN8vatf/kejvNmrWU9u07OZ2/ePECOXz4v1xv54YbbpYaNWo5nT9x4vcSExOd6+3cddcQKVasmMN558+Hy/Tpv+Z6G2XKBMvtt9/pdP7WrVtl0aKF2T6v0mrQoIl07nyt0/l//71E9u3bLbnVtesNUrduA6fzp06dIBERF3K9nQED7pGSJUs5nBcVFSm//fZjrrcRGFhCBg26z+n8//7bL3/9lfLe5Ebt2vXkuutucjp/9eoVsnPn1lxvp2PHa6Rx42ZO58+aNUVCQ8/mejv9+g2U4OByDufFx8fLzz9/nett+Pr6yb33PuR0/rFjR2Thwjm53k7VqjWke/feTuevX79WtmxZn+vttG3bQVq0aON0/rx5s+TUqeO53k6vXv2kYsXKTud///0XkpyclKtt6L+Fzz//vNP5p0+fkrlzp0tuVahQSXr3vs3p/K1bN8m6datyvZ3mzVtLu3Ydnc7/8895cuTIoVxv58Ybe0n16jWdzp8w4TuJjY3J9XbuuedB8fPzdzgvPDxMZsz4LdfbCAoqK7fdNsjp/N27d8g//yzL1jod/R+rUaOmcvXVXZ0+Z9myP+XAgb2SW9dee6PUqVPf6fzJk3+WS5cu5no7AwfeKyVKlHQ4T9ev28ktXb9uxxk9XnrcckuPlx43Z1atWi67dm3P9XY6dbpWGjZs4nT+jBmTJDw8NMN1ZOX/77fddqcEBQU7nBcXFyu//PKt5Ja/fzG5++4hTufr54x+3uSWfs7o540z69atlq1bN+Z6O+3aXS3Nm7dyOn/u3Bly+vTJXG+nd+/bpUKFik7nf/fdZ7nehpeXtzzwwCNO5586dULmzZuZ5jnZ/7uwYsUq0qtXX6fzt2zZIOvXr5HcatGirbRte5XT+QsXzpVjxw7nejvdu/eRqlWrO53/88/fSHx8XK63c++9Q8XX19fhvLCwczJz5uRcb6Ns2RDp23eA0/k7d26T1av/zvV2GjduLh07dnE6f+7cObJ79+5c/1143XXdpXbtuk7nT5r0k0RGXpLcuvPO+6V48UCH8y5ejJApU37J9TZKlSot/fvf7XT+/v17ZPnyxbneTr16DeWaa7o5nb9y5TLZs2dHrrfTufN10qBBY6fzp0//Tc6fDzOPX3jhBXElgthCKiEhQWJjY3O9nsTEhAzn6x/6rthOUlLGf4zqNuyD2LyQlJTskteS2T9yCQmJLtmOvscF5b1xxXZEnP8Dp//4uWIbcXEZvzeJiYkSE5P7P74TEuLd8t7o/rrjvcnoPx+uem98fBz/p87+PHTN72d8pu+dO94bPRdd8/uZ8X8M3bENd703+u+Raz47EzP9DM/r3xulQV9u/mOftX1IctNnZ0Ih+3ctxkX/rhWE96Zw/Z/DVZ+dmXHFNpyF8O7/dy3Bo/5dy+wLKne8/5733iQUmvfGPlR1vA+e9fdaQfpb2hVBbMb7kOxh/65l/PsZFxfvkr8L3fW3tDv+XstsHa56b+IL2d9rjtCaAAAAAAAAAADyGEEsAAAAAAAAAOQxWhMUUj4+PuLvn/ElUVlhsWR8imiPGFdsx1nfVivdhit6xGa8D14ueS3aTzEjPj4Wl2xH3+OC8t7kts9hCueXIun77YrX4ueX8XtjsVhsfWpzc15ldpm9q94b3d+M6DZcsZ2MLhNz1XuT2Tr0PHTN76dvpu+dO94bPRdd8/uZ8SV87vhMc9d7o/8eueaz05Lp683r3xtrj0JX9IjNeL63mz47fQrZv2uO+5W7kvvem+z/n8PR/7EKynvjqs/OzLjjvXHfv2s+Bebftaz8/11/NzLimv9zFCtk742PW35v3PHeZLYNR//vzMnfhe76e60g/S2d2f8Zc78P7vt7zTX/58j499PPz9clfxdm5b3JrE2Cp/y95qr3xreQ/b3miFdyXjcoQ744ezb3AxkUZMHBgWKxeEtiYpKEhUXm9+6gkOC8AucVPAmfWeC8gifhMwucV/AUfF7BXkiI4wE+c4rWBAAAAAAAAACQxwhiAQAAAAAAACCPEcQCAAAAAAAAQB4jiAUAAAAAAACAPEYQm0ZUVJR0795dGjRoIJ988kmOD+yxY8fktddek27duknTpk2lQ4cOct9998ncuXNz+54BAAAAAAAA8DA++b0DBc27774rhw4dytU6tm7dKvfff79ERkbapoWHh8uaNWvMbeHChTJu3Djx8eHwAwAAAAAAAEUBFbF2li1bJpMnT87VAT116pQMHTrUhLA1a9aUr776SlavXm0qYQcMGGCWWbRokYwdOzZ37xwAAAAAAAAAj0EQe1lYWJi8/PLLuT6gX3/9tal+LVWqlPzyyy9y7bXXSnBwsNSrV0/efPNNeeCBB8xyOk/bFwAAAAAAAAAo/AhiL/u///s/OXfunNx22205PpgREREybdo08/iee+6R8uXLp1tm+PDhJqSNj4+XWbNm5XhbAAAAAAAAADwHQayITJ06VZYsWSJVqlTJVVXs2rVrJTY21jzWQbocCQwMlI4dO5rHixcvzvG2AAAAAAAAAHiOIh/EHjlyRN555x3x8vKS0aNHS4kSJXJ8MHft2mXudRCuhg0bOl2uUaNG5n7v3r0SFxeX4+0BAAAAAAAA8AxFOohNTEyUkSNHSlRUlNx7771y1VVX5Wp9x48fN/cVK1YUi8XidLnKlSvbtq+DewEAAAAAAAAo3HykCPvqq69k06ZNUqdOHXnmmWdyvT4dpEuVLl06w+VKlixpe3zhwgXJC0FBxU2Vb2Hl7e1luw8ODszv3UEhwXkFzit4Ej6zwHkFT8JnFjiv4Cn4vEJeKrJB7Pbt2+Xzzz83bQTGjBkj/v7+uV6ntT9sZusqVqxYuue4mo+P84rcwkTDZoul8AbOyB+cV+C8gifhMwucV/AkfGaB8wqegs8r5IUiGcTGxMTIc889J/Hx8fL4449L06ZNXbLejNoRuFtCQmKhr4jV15ecnCxJScn5vTsoJDivwHkFT8JnFjiv4En4zALnFTwFn1ewZ7G4tqtrkQxitQL2v//+k2bNmsmwYcNctt6AgIAsVblqEOyoOtaVwsOjpDDTdgRaCashbFhYZH7vDgoJzitwXsGT8JkFzit4Ej6zwHkFT8HnFeyFhFxpL+oKRW6wrhUrVsjEiRNN+4D33nvPtCZwlVKlSpn7S5cuZbhcRESE7XFQUJDLtg8AAAAAAACgYCpyFbHz5s2zVa3efPPNGS776aefmptasmSJVK1aNcPla9asae5PnjxpLpl31hpA5ysNgUNCQnL0OgAAAAAAAAB4jiJXEZuX6tevb+7j4uJk//79TpfbuXOnua9bt674+fm5bf8AAAAAAAAA5I8iVxE7atQoeeWVVzJcpnXr1ub+4YcfNjdVvHjxTNfdvn170yc2Ojpali5dKvXq1Uu3TFRUlKxZs8Y87tKlSw5fBQAAAAAAAABPUuQqYrUCNTAwMMObla+vr22aszYD9nS5G2+80Tz+/vvv5cSJE+mW+eSTT0yPWF333Xff7eJXBwAAAAAAAKAgKnJBrCv06NHD3EaOHJlu3tNPP22qZ8+fPy933XWXLFy4UMLCwuTAgQPy6quvmoBW3XPPPVKxYsV82HsAAAAAAAAA7lbkWhO4wsGDB829o4G2KlWqJB9//LE8/vjjpiL2iSeeSLeMhrjPPfecW/YVAAAAAAAAQP4jiM0D2vt13rx58vXXX8vKlSvl9OnTpiVCw4YN5fbbb5fbbrstS60OAAAAAAAAABQOBLEO7NmzJ1fzVZUqVeSNN97I+TsDAAAAAAAAoNCgRywAAAAAAAAA5DGCWAAAAAAAAADIYwSxAAAAAAAAAJDHCGIBAAAAAAAAII8RxAIAAAAAAABAHiOIBQAAAAAAAIA8RhALAAAAAAAAAHmMIBYAAAAAAAAA8hhBLAAAAAAAAADkMYJYAAAAAAAAAMhjBLEAAAAAAAAAkMcIYgEAAAAAAAAgjxHEwuPEJyTJ5r1nJTo2Ib93BQAAAAAAAMgSglh4nPCLMbLrUJicOHspv3cFAAAAAAAAyBKCWHgcLy8vc5+YlJzfuwIAAAAAAABkCUEsPI7F+3IQm0gQCwAAAAAAAM9AEAuP4305iE1KJogFAAAAAACAZyCIhccGsYlJSfm9KwAAAAAAAECWEMTC49CaAAAAAAAAAJ6GIBYex5vBugAAAAAAAOBhCGLhsRWxSUn0iAUAAAAAAIBnIIiFx6FHLAAAAAAAADwNQSw8OIilIhYAAAAAAACegSAWHtkjVsPYxESCWAAAAAAAAHgGglh4JBPEUhELAAAAAAAAD0EQC48dsIvBugAAAAAAAOApCGLhsUEsFbEAAAAAAADwFASx8OCK2KT83g0AAAAAAAAgSwhi4ZG8vb2piAUAAAAAAIDHIIiFR6I1AQAAAAAAADwJQSw8ksXiJYmJyfm9GwAAAAAAAECWEMTCgyti6RELAAAAAAAAz0AQC4/kbQbroiIWAAAAAAAAnoEgFh7J4u1tgtjkZMJYAAAAAAAAFHwEsfBI3t4iGsFSFAsAAAAAAABPQBALj62IVUn0iQUAAAAAAIAHIIiFxw7WpRIpiQUAAAAAAIAHIIiFZwexifSIBQAAAAAAQMFHEAuP5E1FLAAAAAAAADwIQSw8ko8l5dRNpEcsAAAAAAAAPABBLDySxZLSmiCB1gQAAAAAAADwAASx8EgW78sVsYlJ+b0rAAAAAAAAQKYIYuHRFbGJSQzWBQAAAAAAgIKPIBYeycdWEUsQCwAAAAAAgIKPIBae3SOWwboAAAAAAADgAQhi4ZEs3ilBbBIVsQAAAAAAAPAABLHwSBZLyqlLRSwAAAAAAAA8AUEsPJKPdbAuKmIBAAAAAADgAQhi4dGtCRKTGKwLAAAAAAAABR9BLDySxTvl1E1MTMrvXQEAAAAAAAAyRRALj25NkEBrAgAAAAAAAHgAglh4JG9rRWwSFbEAAAAAAAAo+Ahi4dmDddEjFgAAAAAAAB6AIBYeycvLywzYlUCPWAAAAAAAAHgAglh4LIvFWxLpEQsAAAAAAAAPQBALj6UVsbQmAAAAAAAAgCcgiIXHsli8JJHWBAAAAAAAAPAABLHwWD4Wb0lgsC4AAAAAAAB4AIJYeHRrgiQqYgEAAAAAAOABCGLhsSzeVMQCAAAAAADAMxDEwmP50CMWAAAAAAAAHoIgFh7Loj1iE5MlOTk5v3cFAAAAAAAAyBBBLDy6R6xKIogFAAAAAABAAUcQC4/lY0k5fRMTqYgFAAAAAABAwUYQC49lsaRUxCYmEcQCAAAAAACgYCOIhce3JiCIBQAAAAAAQEFHEAuPHqxLEcQCAAAAAACgoCOIhcfy8bb2iE3K710BAAAAAAAAMkQQC4/vEZtEj1gAAAAAAAAUcASx8Fj0iAUAAAAAAICnIIiFx/K53CM2gYpYAAAAAAAAFHAEsfD41gT0iAUAAAAAAEBBRxALj2W5PFhXUnJyfu8KAAAAAAAAkCGCWBSCiliCWAAAAAAAABRsBLHw+B6xifSIBQAAAAAAQAFHEAuPZfG+XBFLEAsAAAAAAIACjiAWHstiq4hNyu9dAQAAAAAAADJEEAuP5WOtiKVHLAAAAAAAAAo4glh4/mBdtCYAAAAAAABAAUcQC49l8U45fZMIYgEAAAAAAFDAEcTCY3l7e4m3lxcVsQAAAAAAACjwCGLh0bwtXlTEAgAAAAAAoMAjiIVHs3hTEQsAAAAAAICCjyAWHh/EJiUn5/duAAAAAAAAABkiiIXnB7EM1gUAAAAAAIACjiAWHs3b25vBugAAAAAAAFDgEcTCo1m8hYpYAAAAAAAAFHg+UsQtWrRIpkyZItu2bZPIyEgpV66ctGrVSgYMGCAdO3bM0Tp//PFHGT16dKbLPfDAA/L888/naBtIQUUsAAAAAAAAPEGRDWLj4+PlueeekwULFqSafvLkSXObP3++DBw4UN544w3x8vLK1rq3b9/u4r2FMwzWBQAAAAAAAE9QZIPYsWPH2kLYHj16mOrUqlWryvHjx+W7776TP/74QyZPniyVKlWSRx55JFvr3rlzp7kfOnSoDBs2zOlyvr6+uXwV0CA2kcG6AAAAAAAAUMAVyR6xp0+flgkTJpjHvXr1ko8++khatGghZcuWlebNm5ufr7/+ejP/+++/l9jY2CyvOyoqSg4ePGgea4uDwMBApzc/P788eoVFrCI2KVmSk5Pze1cAAAAAAAAAp4pkEPvXX3+Z1gTqsccec7jMLbfcYu4jIiJswWpW7Nq1S5KSkszjZs2auWR/4Zy3xcuEsOSwAAAAAAAAKMiKZGuCQYMGybXXXmsC1jp16mS6vI+PT7bbEmhLg5CQkFztJzJn8U75LkHbE3h7Z6+XLwAAAAAAAOAuRTKIVRUrVjQ3R7Ra9tdffzWPq1SpIjVr1szyenfs2GHumzZtagb8mj59umzbts20LNDtXXPNNfLggw9K5cqVXfRKijZtTaC0PQEAAAAAAABQUBXZIDYtDUrPnDkjGzdulB9//FH27NljBtN6/fXXs1URaw1ily1bJn/++WeqeUePHpWJEyfKjBkzzGBh3bp1c/nrKKpBLAN2AQAAAAAAoCAjiL3soYcekvXr19sOjLYWGD9+vLRs2TLLB1MH9frvv/9sVbU9evSQe++9V2rVqmV6zS5atEi++OILE/qOGDHChLI6SBhyztqOIIkmsQAAAAAAACjAvJIZbt647rrr5MSJE6kOTqNGjeT//u//pG3btlk6mNpzdsiQIXLq1Cl59NFHZfjw4emW2bx5s9x9990mqNX2Bdq6IC8kJCSKl5dXoQ5g9fVt239Wtuw7Jz071pQyJf3ze7dQSM4r/Vik3QU4r1DQ8ZkFzit4Ej6zwHkFT8HnFexZLCljE7kKQexlWslatWpVuXTpkixZskQ++OADOX/+vBQrVkx++OEHad26dZYPqoas2tbAmTfffFMmTJhgHv/+++/SsGHD3L6PRdbOg6Gyee9Z6d6hhpQtHZDfuwMAAAAAAAA4RGuCy2rXrm3ug4ODpX///qZlwB133CExMTEyZswYmTRpkmRVRiGs0t6w1iB269ateRLEFpWKWG8vL1O5GBefKImJSfm9W/BwfPMJzit4Ej6zwHkFT8JnFjiv4Cn4vEJeVsQSxDpRv359ueWWW2Tq1KmyadMmCQsLMyGtK2j/WStdb14ID4+Swiw4OFAsFg1jRaKj4yQsLFJ86BMLF51XGu7rOQW4AucV8grnFjiv4En4zALnFTwFn1ewFxJSUlzJtbFuIdOkSRPb42PHjmX5eZm13dXWBVYBAVxOnxuWy4N1JSZlfMwBAAAAAACA/FQkg9ivv/5aBg8e7HAwLXuxsbG2x9orNjPvv/++dOzY0fSTtX9uWvv377c9rlmzZpb3G+lZvFNOYQZWAgAAAAAAQEFWJIPYM2fOyIYNG+Svv/6S06dPO11uxYoV5j4wMDBLgWlQUJBpNRAVFSVr1qxxutycOXPMffHixaVNmzY5eg1IQUUsAAAAAAAAPEGRDGK196tKSEiQsWPHOlxm3rx5snLlSvO4X79+4ufnl+l6e/bsaRuoSwf4iouLS7fM3LlzZenSpebxoEGDpESJErl6LUWd9vNUtCYAAAAAAABAQVYkg9jmzZtL3759zePff/9dhg0bZipktZp13759JkR97rnnzPwaNWrI448/nur5PXr0MLeRI0emml6lShV54IEHbO0HBgwYIMuXL5dz587JgQMH5IMPPpDnn3/ezK9Tp0669SL7fH1STuGExCQOHwAAAAAAAAosHymi3nzzTdNCYNGiRaZFgd7SatSokXz66adSpkyZVNMPHjxo7kNCQtI958knn5Tz58/L5MmTZdeuXTJ06FCH6/3qq69MawK4KIhNIIgFAAAAAABAwVVkg1htNfDJJ5/I4sWLZerUqbJ161aJiIgwrQI0KO3Vq5epmrW2Gsgqb29vGTVqlGlT8Ntvv8mmTZskPDzc9JmtV6+eWW///v3Fx6fIHnqX8rVYzH08FbEAAAAAAAAowIp8GnjDDTeYW3bs2bMn02U6duxobshbPpcrYuMTkjnUAAAAAAAAKLCKZI9YFB4+Fi/x8vKiRywAAAAAAAAKNIJYeDQNYTWMZbAuAAAAAAAAFGQEsfB4vj4WesQCAAAAAACgQCOIhcfz1YrYhKT83g0AAAAAAADAKYJYeDwfi7ckJDJYFwAAAAAAAAouglh4PB8fb4lPSMzv3QAAAAAAAACcIoiFx/O1eEtiUrIkJVEVCwAAAAAAgIKJIBaFojWBik+kTywAAAAAAAAKJoJYeDxfn5TTOIEgFgAAAAAAAAUUQSwKTRAbF09FLAAAAAAAAAomglh4PD/fy0EsA3YBAAAAAACggCKIhcfz9bGY+3gqYgEAAAAAAFBAEcTC4/lfbk0QS0UsAAAAAAAACiiCWHg8X18qYgEAAAAAAFCwEcTC4/ldroiNjkuQ5OTk/N4dAAAAAAAAIB2CWBSawboOn7oom/efy+/dAQAAAAAAANIhiIXHs3hfOY01jI2OTZDImPh83ScAAAAAAADAHkEsChV/X4ss/PeI/LnuaH7vCgAAAAAAAGBDEItCpWRxv/zeBQAAAAAAACAdglgUCh2aVDT3ycJgXQAAAAAAACh4CGJRKFQMLi4B/j6STA4LAAAAAACAAshHCpDVq1fLnj17pHjx4tKmTRupU6dOfu8SPIi3t5ckJl1JYpOSk8Xbyytf9wkAAAAAAABwexC7fft2mThxogQFBcnIkSNt08PDw+WRRx6RLVu22KZ5eXlJ79695a233hI/P/p+InMWby9Jsg9ik5LF20IQCwAAAAAAgCIUxGoAq6GqatasWap5r7zyimzevDnVtOTkZJkzZ45ERkbKZ5995q7dhAfT6te4xCTbzyaUteTrLgEAAAAAAADu6xF7+PBhGT16tAlX9ebtfWWzBw4ckMWLF5sK2MDAQHn11Vflww8/lJYtW5plly5dKsuXL3fHbqIQtCZIVRFLw1gAAAAAAAAUpSB20qRJkpCQID4+PjJu3Djzs9W8efNsj5999lkZPHiw3HzzzfLzzz9L1apVzfTZs2e7YzdRCFoTJCalqYgFAAAAAAAAikoQu2rVKlPx2qdPH+nZs2eqeVrxqiwWi/Tq1cs2XfvC3n777aYqNm3bAsBZRWxCon1FLMcJAAAAAAAARSiIPXXqlLlv06ZNqulnzpyR3bt3m5C2efPmUqpUqVTzrRWx586dc8duohD0iNXg3up0eJSs3nFKEuz6xgIAAAAAAACFNojVAbdU2qB15cqVtsdXX311uudFR0ebe/ueskBGrQnsbTsQKqfDouRkaBQHDQAAAAAAAPnKLQlnUFCQuT9x4kSq6cuWLbM9vuaaa9I9b+fOneY+JCQkz/cRhaM1gSOx8Ylu3xcAAAAAAADA7UFss2bNzCXjOuhWfHy8mXb8+HFZvny5aUtQvnx505rA3sGDB2XmzJlmvj4fyAxBLAAAAAAAAAoqH3ds5NZbbzWDcu3atUsGDhwoHTp0kD/++ENiY2NN0Nq3b1/bskePHpXFixfLF198YZuvg3YBWekR60hsHBWxAAAAAAAAKAJBbPfu3eW6666Tv/76y4SxerOqUqWKDB061PbzTz/9JBMnTrT9rCGto/6xQGY9Yq2iYxM4WAAAAAAAAMhXbhsF66OPPpKHH37YDNilbQp0AK4bbrjBhK6BgYG25WrXrm3m+/v7y2OPPSZvv/22u3YRhbQ1QRRBLAAAAAAAAIpCRazy8/OTp556Sp588kkJCwuTkiVLmmlpdezYUd577z259tprpXTp0u7aPRTiitiEhCS37wsAAAAAAACQL0GslfZ8LVu2rNP5tWrVMjfAVT1ik5KTOZgAAAAAAAAoWkFsRg4fPix79+6V4sWLS9OmTamIhUtaEyQlEcQCAAAAAACgCAWxp0+flqlTp0pAQIAMGTLENj02NlZeeuklmT9/vm1asWLF5P7775cRI0a4cxdRCFsTaA6rfYe1GhsAAAAAAAAo1IN1/fnnn3LTTTfJZ599JkuWLEk1780335R58+aZsMx6i46Oli+//FJee+01d+0iCmlFrDmn3L43AAAAAAAAgJuD2LNnz8pzzz0ncXFxJhQLDQ21zTt+/LhMnz7dVCv6+PiYStmnn35aqlWrZpadMmWKbNiwwR27CQ/nJIc1aE8AAAAAAACAQh/E/vrrrxITE2MeP/vsszJ37lzbPGslrHr88cdNYDt06FDTwsA6qNeMGTPcsZsopBWxynqOAQAAAAAAAIU2iF25cqWpeL3hhhvkwQcfFF9fX9u8pUuXmnudf9ttt9mmlylTRvr3728CtPXr17tjN+Hh/HwsTuclJbl1VwAAAAAAAAD3B7HHjh0z9507d041/fz587J161YTwjZs2FBCQkJSza9Zs6a5P3PmjDt2Ex4uqKS/03mJOmIXAAAAAAAAUJiD2IsXL5r7oKCgVNNXrVolSZdLFTt16pTueYmJiebeugyQ09YESbQmAAAAAAAAQGEPYkuWLGkbtMvesmXLbI+7dOmS7nn79+8399ZesUBmbmxXTRrXDE43ffH6o3I6LIoDCAAAAAAAgMIbxDZu3Nj0el20aJFtWnh4uK0/bOnSpaVt27apnhMWFibTpk0zbQuaNGnijt1EIRBYzFfqVysjvj4pp7a315Uq2bU7T+fjngEAAAAAAKAoc0sQ27NnT3P/77//yrBhw2TixIkyZMgQuXTpkglae/fuLd7eKbsSFRVlAts77rjD1tJA5wPZUSGoeLqWBLQnAAAAAAAAQH7xccdG+vXrJ1OnTpUtW7bI8uXLzc1Kq2EfeeQR289jxoyRyZMn237W3rHdu3d3x26iEGlWp6xoMayfr0UOHL9gmx4TlyA+Fm+xeHuZLwEAAAAAAACAQlMRa7FY5Ntvv7VVvmqbAr01atRIfv7551Q9YGvXrm2b37dvX/nkk0/csYsoZPx9LdKmQXkpEeCbavrxs5Eyd9UhOXw6pdoaAAAAAAAAKDQVsdYBuz744AN5+eWX5ejRo1KmTBmpXr16uuW0V+wTTzxhqmDr1Knjrt1DIWXfI1YdPBmRcn8iQmpWLJVPewUAAAAAAICixm1BrFVQUJC5ZTSwl94AV0jbfSAqNiFlureX6RmbNqgFAAAAAAAACkUQa+/s2bMSGhpqBugKCAiQChUqSHBwcH7uEgoZb+/UQWtSUsrgXecvxpoWBbd0qpVPewYAAAAAAICixO1B7PHjx+WHH36QxYsXy+nTp9PN136x1113nTzwwANSqxYhGXJHB+VyRkNZ7UXMoF0AAAAAAAAoFIN1WU2fPl169eolEydOlFOnTtkG5bK/nTt3TqZNmya33XabTJ482Z27h0Ios9YDiZcrZAEAAAAAAIBCURE7c+ZMM1CXVh9q4KqDdbVp00aqVasmxYoVM+0JDh8+LJs3b5YLFy5IdHS0vP766xIYGCi9e/d2126ikNFesFZ+vhaJi09MNT8uPkl8LG79PgIAAAAAAABFkFuC2DNnzsioUaPMYw1dn332WRkwYID4+vqmWzYuLs5Uwn744YcmjH3llVekY8eOpmUBkF32nQlKBPhKWJogNj4xiYMKAAAAAACAPOeWUsAJEyaYUNXb21s+/fRTueuuuxyGsMrPz0/uueces5xWz8bExJiWBkBuWxM0q11W6lUtk2p+fJpgFgAAAAAAAPDYIHbFihUmVO3evbt06tQpS8/R5XR5bWOgA3sBOeFtVxIbVNJfmtQKThXOUhELAAAAAACAQhPEHjt2zNx37tw5W8/r0qVLqucDrhisq361Mql6xAIAAAAAAACFIoiNjY019wEBAdl6nnX5yMjIPNkvFK2KWKsG1cvI1U0rmsdUxAIAAAAAAKDQBLHlypUz93v27MnW86zLM1AXcspBDmvaZBTzTxmnjh6xAAAAAAAAKDRBbKtWrUyv12nTpklERESWnqPLTZ061YRm+nwgJ/T8ccTPJ+XUj0ugNQEAAAAAAAAKSRB7xx13mPuwsDAZNmyYuc9IaGhoquX69u3rjt1EEWlNoHwvB7HxBLEAAAAAAABwg5Trs/NYx44d5frrr5elS5fKpk2bpGfPnnLLLbdIhw4dpFq1aqYXbHR0tBw9elTWrFkjs2fPNhWxWs3YtWtX26BdgCsG61IWb2/x87VIdFwCBxUAAAAAAACFI4hV7733nqly3bBhg1y4cEEmTJhgbo5oGwPVokULGTt2rLt2EYWQdwY138WL+UhUDEEsAAAAAAAACklrAlWyZEn54YcfZMSIEVK6dGkTtjq7BQUFyeOPPy4TJ06UwMBAd+0iCmlFbNlSxaRJreB08wKL+Up0bIKcDovKl30DAAAAAABA0eG2iljl5+cnjzzyiAwZMkQ2b95sbtoHNjIy0rQnKFeunDRr1kzatGljlgVyS9tbdGlR2WlFrFq945Rc37qqlArknAMAAAAAAEAhCGKtNGRt3769uQH5pbj/ldM/Lj6RNwIAAAAAAACFK4gFciopOUm2ndslJ44dlxplqsjV1drmeF2BlytiVXxiEm8KAAAAAAAAPCOIXbduneSVdu3a5dm64Tlm7Jsrfx1baft5w4ltck/9QTlaV0iZAKlduZT8dyJC4uIJYgEAAAAAAOAhQew999xjenK6mq5z586dLl8vPMvFuEupQli15thGub5yV6lSolKOzqsq5UqYIJaKWAAAAAAAAOQlb1evMDk5OU9ugAaxjvx34XCOD46vb8qvQDw9YgEAAAAAAOApFbHDhw935eqAVMr4l3J4RE5HncnxkfK1XA5i6RELAAAAAACAPEQQC49R3Le4lPANlEvxkammn446m+N1+lkrYhPoEQsAAAAAAAAPak0A5KUKxUPSTTsTmfMg1uLtLRZvL4kjiAUAAAAAAEAeIoiFxwexoTHhEp+UkON1+vpYqIgFAAAAAABAniKIhUcp7yCITZZkORt1Lsfr9PXxJogFAAAAAABAniKIhUepGFje4fTc9IkliAUAAAAAAEBeI4iFx1fEuiaITczFXgEAAAAAAAAZI4iFRylXLFi8vdKftmdyEcT6+XhLYlKyJCQm5XLvAAAAAAAAAMcIYuFRLN4WCQkom276qagzuaqIVfEJBLEAAAAAAADIGwSx8DgVi6fvE3vy0ilJSs5ZkOrrYzH38VTEAgAAAAAAII8QxMLjVC5RKd20uKR4ORt1LncVsfFUxAIAAAAAAMCDg9j33ntP9uzZ445NoQioWrKyw+nHLp3M0fp8LZeDWCpiAQAAAAAA4MlB7A8//CB9+/aVPn36yHfffSenT592x2ZRSFV1UBGrjl06kaP1+fmm/BrExSfmar8AAAAAAACAfG9NkJycLPv27ZMPPvhArrvuOrn//vtl5syZEhkZ6a5dQCERXCxIAnyKpZt+nIpYAAAAAAAAFOUg9s8//5QRI0ZI7dq1TSCblJQka9eulZdeekk6deokzzzzjCxfvtxMBzLj7eUtNcpUSTf92MWcVcT6+qYM1pWQwPkHAAAAAAAADw5iq1WrJo888ojMnz9fZsyYIf/73/8kJCTEhLIxMTFm+rBhw6Rz587y9ttvy7Zt29yxW/Bg1UtXTTftQlyEXIy7lOMesXEEsQAAAAAAAMgjPuJmjRs3NreRI0eaqtg5c+bIokWL5OLFixIWFiYTJkwwt5o1a8qtt95q+spWqZK++tFVdNtTpkwx4a+2SShXrpy0atVKBgwYIB07dszxeo8dOybffPONrFy50vTELVGihDRo0ED69+8vvXv3dulrKIpqlkkfxFqrYhuVrZ+tdfn6XB6siyAWAAAAAAAAecQrWctS81lcXJz8/fffsmTJEnMfGhqasnNeXua+devWZrCvnj17mkDTFeLj4+W5556TBQsWOF1m4MCB8sYbb9j2I6u2bt1qeuA663970003ybhx48THJ+9y8LNnL0phdt4rVF5e8l666b1rdZeetbpla136KzB/zWHxsXjLda2qiN/lVgUoeoKDA8Vi8ZbExCQJC6N/NTivULDxmQXOK3gSPrPAeQVPwecV7IWElPTMwboy4ufnJzfccIOMHj3aBKP33XefLaTUkGzjxo3y6quvSpcuXcz90aNHc73NsWPH2kLYHj16mKrYVatWydSpU83PavLkyfLll19ma72nTp2SoUOHmhBWq3q/+uorWb16tcydO9dU2VqrcHX7yLnqpSuLr8U33fSDEYezvS4N2pvWKivRsQmydtdpScr/7yYAAAAAAABQyBSIIPbcuXOmHcEDDzxgBu/6+eefJSEhwYSwGshWr17dPI6OjjZBqbYrmDhxYo63p60CdHuqV69e8tFHH0mLFi2kbNmy0rx5c/Pz9ddfb+Z///33Ehsbm+V1f/311xIeHi6lSpWSX375Ra699loJDg6WevXqyZtvvmleo9J52r4AOePj7SO1g6qnm37owhFzrmRX9QolpFr5khJ6IUYiIuN4WwAAAAAAAFA4gthLly7J9OnTzcBdXbt2NYN0aeWotgzQIK1Jkyby8ssvm1YFCxcuNBWluqy/v78Z4Outt96SefPm5Wjbf/31l9mOeuyxxxwuc8stt5j7iIgIOXjwYJbWq8tOmzbNPL7nnnukfPny6ZYZPny4CWl1+7NmzcrR/iNF/bK10h2KyIQoORt9LkdVscGl/M1jesUCAAAAAADAowfr0spS7QOrAeqKFStsYai1grFixYqm2lX7wdapUyfVc+vWrSvPP/+8aWFw9913m+foYFha0ZpdgwYNMpWqGrCm3Y4jWe3lqoOPWatnu3Vz3Kc0MDDQDAKm4fLixYtNMIucqecgiFUHLxyR8sVDsr0+7RGrCGIBAAAAAADgkUHs8uXLTUWrhrDaXsA+fA0ICDCDV2n42qFDh0wHxmrTpo3Ur19f9uzZI4cOHcrxPmnoqzdHNCD+9ddfzeMqVaqYXq9ZsWvXLltw27BhQ6fLNWrUyASxe/fuNQOVaY9cZF/9crUdTj8YcUSuqtQm2+vz9UkJYhMSk3g7AAAAAAAA4HlB7MMPP2wCVmv46u3tbULXW2+9Vbp3727C2OzQ9gRKe6+6SlRUlJw5c8YMDPbjjz+aoNfX11def/31LFfEHj9+3NxrwGuxWJwuV7lyZXOfmJhoBvfSHrjIvuCAMlI2IEhCo8NTTf/vQs4Ceh9LypcAVMQCAAAAAADAY1sTaAir7QW096oGsBUqVMjxurQqVlsL6MBarvLQQw/J+vXrbT9XqlRJxo8fLy1btszyOnSQLlW6dOkMlytZsqTt8YULF3K0v7jSniD0WOog9sSlUxKTECPFfIpl6zD5+qSE51TEAgAAAIBn27hxvTzxxDDzeOnSVfLDD9/I3Lm/S2RkpMkj/ve/oXLTTT3M/DVrVsmff/4hO3Zsk7CwMImPj5MSJUpK3br15Prrb5SePXvbCrS0iKtXr27mStoHHxwm99//YLptjxnztsyePdM8/vXXaVK9euqrbJOSkqR37xslIuKCPPnks3LHHYPccEQAFJkgVgeu0vC1adOmLlmf9op1tRMnTqT6+eTJk6Ya9v/+7/+kbdu2WVqHtT+stWLXmWLFiqV7jqsFBRXPtM2DJ/P2TnltDcrVljXHNqaalyzJEpp8VpoFO28P4YhfgJ8EBPhJseJ+Ehwc6NL9hWedV3rPOQDOKxR0fGaB8wqehM8suPu8KlXqypW3X331kUyePNn289GjR6Rhw9oSEOAtzzzztCxbtizdusPDw2TdurXmtmzZYvn222/Nla+6Hc0IdLDxLVs2SHDwiHTP3bRpg+3x3r07pGXLJqnmb968yYSwqlevHvztUcDweQWPD2JffvllKei+++47qVq1qly6dMn0sv3ggw9Mz9chQ4bIDz/8IK1bt850HRm1I3A3n8vVnYVdw5C6DqfvC/tPWlZunK11FfP3MR+4iYnJYrk8cBeKJv0Sw3K5VQXAeYWCjs8scF7Bk/CZBXedV9YwTWkIq20Rn376adOC8O+//zZX2o4aNcoWwuqg4LfffrtpNai5wI4dO+TTTz+V/fv3y9q1a2T+/HlmbBulV+hqELt582aJi4tN1W5RWxZq0Gu1fv06ufPO1BWvK1euNPc6/k316tU4KQooPq/g0a0J0jp9+rRs2bJFzp07Zz7kgoKCpHz58ibwtL90311q165t6zvbv39/adGihdxxxx0SExMjY8aMkUmTJmW6DuuHb2ZVrrpOR9WxrpSQkFjoK2L19VUvXUX8LX4SmxiXav7uswckMZuDbmn0mpSULPuOnpeSxf2kQY0gF+81POW80lYqei4AnFcoyPjMAucVPAmfWXD3eWX/sw7C/f77H9jaCwwYMFDOn78gkydPMT/r3/4vvXSlgKx06TJSpUpVadWqtXTvfpP5G17D2z59bjHzu3S5RkaPHm3aE/z77zrp3Lmz7bn//LPK3JcqVdpUvf7777/p/jbVdamuXa/N9t+tyHt8XsGeqwv13B7E/v7776bCVAfDclZVetVVV8kjjzyS5ZYAeUG/mdJ+tlOnTpVNmzaZPjGZDQ5WqlQpc6/BckYiIiJsjzWAzgvh4VFSmOnlIPqNp7d4S/WSVWXf+f9Szd8XelDOhV4Ub6/s/cJER6cEuv9sPiYhJf1cus/wnPNK/9MWFhaZ37uDQoLzCpxb8CR8ZoFzq+DYcyRcjp0tvP8nrRoSKA2qB+XZZ1ZERLTtcefOXSUiQgumrhRNnTp1RgYOHCwnT56Qvn0HOvz/v8VSXKpVqy779u2V06fP2pYpVSpEqlatLseOHZG//vpbGjduZXvO33+nVLv263eH/PTTd2ZQ8C1bdpn1WFseaLWtat36Kv7uKID4txD2QkJcWyzqtuuvNZy866675IUXXjAhrH5j5eiWkJAgq1atMn1lX3nlFclPTZpc6eNy7NixTJevWbOmrb+svhZndL7Sb+NCQkJcsq9FWZ3SqRufq5jEWDl+6VS+7A8AAAAAoOCoV69BumnaguCRRx6XUaNGS82atdLNj4uLky1bNkl0dMoVrYmJianmd+qUUgW7YcO/qaZv3LjO3F97bTdTVas2b74yrsnatatNXlCmTJA0adLMJa8PgOdwS0WsfmANGzZMNmzYYLscv1u3bqYNQeXKlc3POvKghp26zF9//WVK/KdNmyZ+fn4uD2S//vpr0wdGK1y154sz9i0GstJCQKtorR/Y2kemXr16DpfbuXOnua9bt655fcid2mVqihxOP31P+D6pVrIyhxcAAACAx9Fq0dxWjCKFhp4ZOXz4kAlLjxw5LCdOHJOjR4/K0aOHU4WvaYutOnbsLJMn/2qqZS9cOG/aGfz33wEJDQ2V0qVLS9269aR585Zy/Pgx2bx5g/Tpk9Jfds2alNYFHTt2Em9vxiYBihq3BLEaqK5fv970btHeq+PGjZNKlSo5XPa+++4zH3ojRowwgeWvv/4qN9xwg3Ts2NFl+6OXBmjgqxWp2qu2QoUKDpdbsWKFuQ8MDLRVu2akffv2pk9sdHS0LF261GEQq4HzmjVrzOMuXbrk+rVApHbpGqYFQVJy6t46O87tlhuqd+UQAQAAAEAR5qwA6tSpkzJ69CjZsCGlitWe9nht3bqt7N27W06cOJ5ufosWraR48UCJioqUDRvWy/XX32BbT8uWrU3+oc9fsGCubNqUUhGblJQk69al5AGdOpEHAEWRW75+mTVrlrnX6tfvvvvOaQhrVa1aNdNH1nrZ/sSJE126P9r7VWkbhLFjxzpcZt68ebaRDPv165elylUNbG+88Ubz+Pvvv5cTJ06kW+aTTz4xPWJ1pEYdlRG5F+AT4LA9wf4LByU64crAaFlRNaSE7XFSBu0lAAAAAACe6+LFizJ8+FATnmpl6tVXdzatCsaMGS9Tpvwu8+cvkbfeek/Kli3n8Pn6N327du3N4/Xr16ZqU6ABrGrVKuX+zJnTpjJ2166dcuHCBfPc9u07uOmVAihyQezevXvNt0GDBg0yYWVWaCn/nXfeacr/rS0NXKV58+bSt29f2+Bh1rYJOiDXvn37ZMyYMfLcc8+Z+TVq1JDHH3881fN79OhhbiNHjky37qefflqKFy8u58+fNz1xFy5caNZ74MABefXVV01Aq7QHrvakgWs0Lpu+549WyO4J35+t9bRtWF5qVkwZdC0+gdErAQAAAKAwmjlzqqmIVW+++a4JYO+66z4TyFauXMW2nLYdcEbbE6j16/811a5btmxOFcDq3/zWPrGbNq2XNWv+sVXMajUtgKLHLa0J9ANJValy5cMsK2rVqmW7nN/V3nzzTbPeRYsWmZ60ekurUaNGpodsmTJlUk0/ePCguXc00JZW+3788ccmvNWK2CeeeCLdMhriWoNeuEaTsg3l9wML0k3X9gQtQ5pma12+vt62INbf18JbBAAAAACFzPbtW829/r3ftev1DpfRStajR4+Yx44G5NY+r1p0pq0L/vnnb7l4McL0o61du45tGa2O1WrYTZs2mB60irYEQNHllopYbTWgtNo0O44fP56jADcrtNWAtgn47LPP5NprrzUDd2nPWP0Q1n60b731lkydOlWqVk359io7tPertjbQCmB9vl52oJXAbdq0kXfeeUfGjx9PU24XqxxYUcr4l043PbsVscrPJ+XXIi4+pTH7uQvRknj5ywQAAAAAgOezWFKKbrR1YGjoOYeDd7/77pu2AFYHFE9L2xY0aNDIPP7++6/NfatWbVItY21ToIN07d69yzzu1Okal78eAJ7BLRWx2pP1gw8+MANvDRw4MEuX5OuAV5MmTTLfLvXq1SvP9k0HAtNbduzZsyfTZTQ8fuONN3KxZ8gOPU8aBdeX1SdTN1kPjQmTiLiLUsqvZJbX5eeT8g9yfGKSnA6PktXbT0m18iWlTYP0FdAAAAAAAM/Tvn1HWbFiubmCd+TIp+TRR58wlayaRWzbtkV+/fVnOXDgSmGPsyt1tSp29+6dsm/f3lTBq5X1Z+0Nq3QblSpVzsNXBkCKekXs/fffL+3atTMfPNobddu2bRkuHxoaavq2Hjt2TOrWrSsPPvigO3YTHq62gwG71MELKZd/ZJXP5YrY2LhEuRSd8q3n2fPRLthDAAAAAEBB0Lv3raZXq9qzZ5eMGPGI9OlzkwwYcKu8+earJoStUaOm3HhjD7PMqVMnzIDfaWlPWXtpg1itmq1ZM6XtoqIaFija3FIRu27dOnnggQfk3Llzpr+qVsVqMNupUyepWbOmuWw/Li5OTp06JZs2bZLFixebb5t05MK2bdvKN99843Tdw4cPd8dLgAeoXbq6w+n7zx+UFtnoE2ttTbBx71lpUK2M035AAAAAAADPpC0Ex437TKZM+VWWLFlk+rdq+4GSJUuZ4PS6626Q3r1vkd27d8uff/4hMTExsnbt6nT9XRs2bCzBwWUlLCxUypYta8LbtHTwrkOHDjoMbgEULV7JbkiYGjZsaC4dt9JN2v+cVmbz7e3aldJjBamdPXuxUB+S4OBAsVi8JTExScLCIs20pOQkeX7FGxKVkLp6tUqJSvJS+6eyvO6ExCSZu+qQeVytfAk5euaS+Pla5OYONVz8KuAJ5xXAeYWCis8scF7Bk/CZBc4reAo+r2AvJCTrrS4LTGsCa7hqvaX9Oe0ts/n2ywG2k9nLW+oH1U13QI5fOikXYiOyfKB8LN7Sql5KP9iExCvnIwAAAAAAAFCgWxP8/PPP7tgMII2D68vms+l7EO8O2ydXVUo9emVGfCwpFdlxCYkcVQAAAAAAAHhGENu+fXt3bAaQhsH1HB6FXWF7sxfE2g3YpSiIBQAAAAAAgEe0JgDcoWxAsJQvXs5hEKs9ZLPK13I5iI23BrG0JgAAAAAAAEABr4hNKy4uTjZs2CDbtm2Tc+fOSXR0tBQrVkwqVKggDRo0kHbt2pmfgZxoFFxfzkSdSzXtUnyknIo8I5VLVMxyn1gVn5AS3hLDAgAAAAAAwGOCWK0q/Oabb+THH3+U8PBwp8sFBgbKkCFD5OGHHxZvb4p2kT0NgurJ8mOr0k0/cOFgtoPYKydvmh+Tk+XEuUgpHxQgvj4W3iIAAAAAAABkyG0pZ0xMjNx///0ybtw4E8JqkOXsdunSJfn444/lnnvuMc8DsqNOmZoOp+8/fzDL6/D1SRmsyyptReypsChZt/uMbNhzljcHAAAAAAAABaci9vnnn5e1a9eaxyVKlJC+fftKhw4dpFq1ahIQECBRUVFy6NAhWbNmjcyZM0ciIyNl48aN8sorr8j777/vrt1EIVDCN1AqBlaQU5GnU00/cP5QltdhSVMRa/2SwMsrJaCNjEkw9+cvxblknwEAAAAAAFC4uSWIXb16tSxcuNCEWM2bN5dPPvlEypcvn265hg0bSo8ePeSRRx6Rxx9/XLZu3Spz586VwYMHS6tWrdyxqygk6paumS6IDY89L6HR4VI2ICjT53t7eZn2BAmJVwb4SkxKFh9LShCblJRSI+udunAWAAAAAAAAyL/WBDNmzDD3QUFB8vXXXzsMYe3poF26XHBwsPl5ypQp7thNFCJ1ytRyOF37xGZV2j6xR05fsj3W6ljlRRILAAAAAACAghLEbtiwwVTD9u/fX0qXLp2l55QpU8Ysr4GXVsYC2VHXSRC7O2xfltdhrX612nrgnC2AjUtIslXOAgAAAAAAAAUiiA0NDTX3DRo0yNbzrMufOHEiT/YLhVdwsSApWyx9C4Lt53ZJYlJiltbh45P+10PbE6jYuJR1eFMRCwAAAAAAgIISxPr6+pr76OjobD3PuryPj9vGFEMh0rRc43TTIhOi5L8LWRu0yzdNawIVf7kSNjY+MVWvWAAAAAAAACDfg9hq1aqZ+3/++Sdbz1u5cqW5r1KlSp7sFwq3FuWaOJy+O3x/lp5fsrifuff18ZYG1YNSBbHW1gTWnwEAAAAAAIB8D2I7d+5semv+8ccfsmbNmiw9Z/Xq1bJw4ULTW1afD+SkT6yfJSVMtbcnLGtBbPmgAFvYqmGs9bF9a4L4RIJYAAAAAAAAFJAg9u677xZ/f38Txj766KMyZcoUSUhIcLisTp88ebI89thjkpSUJH5+fub5QHZZvC0OB+06fPGoRCfEZPr8cqWLmftifj7iZw1iE5PMeRx3uTVBYmIS7QkAAAAAAACQKbc0X61QoYI8//zzMmrUKNP39bXXXpNx48ZJmzZtTNuCgIAAM/3o0aOyYcMGOX/+vAm7tBpWn1exYkV37CYKoQZBdWVn6J5U05KSk2T/+f+kmYMesvZ8LN5ybasq4udjkQuRsbaKWG1LkJR8pTeshrP+3pY8egUAAAAAAAAoDNw2CtbgwYPN/TvvvGOqXsPDw2XJkiXpltMA1jrAl4aw1ucBOdEgqJ7D6XvC92caxKoyJfzNfVRMvLmPS0i0tSWw0nDW35cgFgAAAAAAAPncmsBKQ1Xt+3rnnXdK5cqVTeia9qbVr3fddZfMnTuXlgTItSolKkoJ38Ac94m1svaITUhIkpjLbQkC/FO+x2DALgAAAACAOyUmpi4QAuAZ3FIRGxMTI8WKpfTbrFKlimlNoM6dOyehoaESGRkpxYsXl3Llypkb4CreXt5SL6iObDqzNdX0E5GnJCLuopTyK5ml9fj6WGyhq7UitkSAr0THJkgCA3YBAAAAQIEzfvwHMm3apEyXe+qp5+T22wemm65X886cOU0WLZovhw4dvFw8VlmuueZaGTToLilVqrTkh3Xr1srEiT/J+PGf58v2C6KNG9fLE08MM48//vhLad26rW1e584pj//3v4dkyJCHbdPffvt1WbBgrlSsWEmmTZuTD3uNosgtQewzzzwjZ8+elQEDBsgdd9xhm07wCnf1iU0bxKq9YfulbcVW2aqI1f6wsfFXgtiz56OpiAUAAACAAmjPnl05fm5sbKw888zjsnnzxlTTDx36z9zmz58jH374idSuXVfc6fffZ8j7779jwkMAnsctQey2bdtMENuoUaNUQSzgriDWkV1h+7IcxPpYvMTby0suRceLn29KKFuiuK+5pzUBAAAAABQsSUlJsn//PvP4mWdekO7db3a6rJ+fX7pp77zzhglhfXx85IEHhsqNN/YQX18/Wb16pXz++cdy7txZef75p+XnnyebAcjdRbcL1wgKCpYqVapKSEh5DikKVxCrA3Optm2vlIYD7hISUFaCiwVJWEzKeWi1M2yPJCUnmfYFmfHy8pIqISXk6JmLEhYRY6uIVfG0JgAAAACAAuXIkcMSHR1lHjdv3tK0Q8yq3bt3ypIli8zjJ598Vvr2vVJQ1qdPX2nQoKE8/PD/5OTJEzJ16m9y770P5MErQF579NEnzA0odIN1aV9Ydfz4cXdsDkgXojYu2yDdUdEesccuncjy0WpQvYztsY/FWwL8fGwDeAEAAAAACo69e3ebe61WrVmzVrae+9tvE8x9pUpVpE+ffunm16/fUHr06GUez5nzu0v2F0DR4JaK2IcfflhefPFF+eGHH+Tqq6+W5s2bu2OzgE3Tsg1l5fE16Y7IjnN7pHrJqlk6Uv6XWxKkPLaYMFbFxCXK+t1npF7V0lK6hD9HHQAAAADy2Z49u22hqcWSMvhyVuiAXGvXrjaPO3Xq7PS5nTt3lTlzZsnJk8dl3769Uq9e/Wzv444d22XGjCmyZcsmCQ09Z1oklC9fQdq0aS/9+w8yl81baU9abZdgderUSdsgVGkHp9LXsHjxQlm4cL45DpcuXZRSpUpJ48bN5JZb+knHjp2cvKaUdXzwwcfm9Xz33VeyevU/cuHChcv71VYGD7431X5l1R139DH7/Pzz/ycVKlSUzz77SI4cOSQlS5aSNm3ayWuvvWVbNjLykhkk7e+/l5ll4uLiTBuBli1bSb9+A6Rp02biCs4G65o5c6a8/PJLUrlyZZkyZbbs3LldJk2aaN6niIgLZl/atm0vd911n9SoUdPp+jdsWCdTpvxqzo/z589LhQoV5Prrb5S7775fpk2bLF999am0bNlaPv306yzv8/DhQ03LDB147L77hpjB6P74Y74cO3ZE/P39zfl+zz3/s50P//13QCZM+NHsi+57uXLl5dprrzfPd1YlHh0dbc7L5cv/MpXlcXGxUrZsiLRt204GDrwrwy82oqIize/FmjWrzLZ1mz4+vhIcHCzNmrWQ227rL40bN83wdelt9uwZsmDBPDl8+KAZNK9aterSrdtN5vfC37+YeDK3BLH9+vUzja7feecdGTRokHTo0EHatGkjtWvXNh8GjvqxpNWuXTt37CoKqfpBdcXHyyIJySkDbVntDNstPWt1y9I6NHj19vaSpKRk8fez2AbwOnQqwtxfiIyTbm2y/w8SAAAAACBvBuqqV6+BzJ49UxYtWiD79u2R+PgEqVSpkglSBw++R0qXvnLlo9J2AxpcqgYNGjldf/36DVJtK7tBrA669cEHo01oahUfHy8HD/5nbr//Pl3eeGO0XHPNtdla78WLF+Xll5+TjRvXp5oeGhoqK1YsM7fu3XvKCy+8Kr6+Ke320jp16oS8++6bqfrRatCntz/+mCejRr0rnTp1kZzYsWObjB37rgnXVFhYaKoeuxpOv/LK83LmzOlUzzt9+pQsXLjA3AYMuFOGD39KvL3z/iLvWbOmy7hxYyQx8UqWoPumwbiG3e+//5EJktPSoPm3335JNe3o0SPy00/fydKlf8pVV12dq/2KjY2Rxx9/WLZt22KbFhMTI+vWrTXv/TvvfCBJSYny+usvmzzOSr840P3aunWzfPbZN6YHsr0DB/bLyJFPmuNtT583Z85x87off/wpueOOQQ5beowc+ZR5T+3peX38eJQcP37MfDmgYXzv3rc6fF267FNPDZcNG/5NNV3DbL3psfv002+y1WqkSAaxTZs2tTXL1tvq1avNLTuXlu/cuTMP9xCFnb/FT+oF1ZFdYXtTTT944Yhcio+UEr6BWToP/XwsEhOXIMX8tCLWy0yz/sNp8fbKs/0HAAAAUHTsDtsnq0+uk9DoMCmsygYES8dK7aRhcD2Xr1v/RtPQVWmgqeGOvcOHD5nbvHmz5d13P0xVYalVm1aVKlV2vv9ly5kQSwNFDW+zQ7cxfvz7Zj81kNMes9WqVZO4uHjZunWTfPbZeBOcahiqVYjFiwfKTTf1lGuv7Sa//PKDuWlV6S+/TDHr00pIpWHhiy8+YyoLtZJ30KC7zSBl5cqVk9OnT8vcubNkxoypJswsVixAnnvuJYf7pyGiVkX269df7rhjoCmgW7/+X/n0U92vcybo/fnnSVK9uvNqUGfmzv3dVNe++OIrUrdufRPMVq6cUtB07NhRee65EaaKUl/z/fc/KF27XiclSpQwAeEPP3wjmzZtkClTfjMDpz3yyOOSl86dO2dC2GrVashDDw0zvYY17NQw+scfvzWVumPGvC2TJs002YDV1KmTbCGsVs4++OAwU9GpQaS+dytWLDevNTemTZtiKlX79r1dbrttgHmPVq1aac4r3S8Nu/U4ansNPU5NmjST8PAw+f77r+Wvvxab47506WK56aYeqV7vk08+apYrUyZIhgx52FRPa1Cux1/3XYPe8eM/MPNvuKF7qkpYHbxOQ9jg4LIydOijptq3ZMmScubMGfMFwK+//myO30cfjTXVrY4GudMKX12mZ8/eJuzVL02OHj0q33zzuTkH9+7dI5MnTzRVs57KLUGs9ZsOK/tvfAB3aVK2YbogNlmSZXfoXmlbsVW21qWtCfSDVqti4+JTvhnTcBYAAAAAchvCfrblOzOwcGF2MOKIbDyzVR5rMcTlYayGXJGRkbY84tZbbzO9XjXU0SBx0aI/TFB2/ny4Cf6+++4XqVw5ZWwbvYTcSi+bd0arMTUs1LDr4sWUqySz6p9/VphwWIOo0aM/SHWVcMWKPSUkpLypdtR1a/DVtev1JvS13pT+PZq2KlAvs9cQVo0aNdo8z6pUqdLy1FMjTbisgapW5N5yy21m4LG0NITVEM4+7Lrxxh7mkvIHHrjLHNsvvvhERo8eKznx4ouvSrt2V5nHWpls9eWXn5jXrMdD2y00bHilIlkvtW/RopX83/89bwv1NGSuXbuO5BUNNPW8+Oqr7yUwsIRtuh4XPUa6DxquavsH675GRESYlg5KQ/YxY8bZ2lto9bVWqo4a9Yr8+ecfudy3WBk4cLA8/vjTtmnadkKrRmfOnGqqdsuVC5HPP//GvPeqTJkypgXE9u1b5ezZM7J+/dpUQewXX3xsQlg977/66odULSj0+GuwqiG8Bskapnbpcq3tSwBtj6C/W+qtt94zobWVvm6tGC9RoqR8/PFYM4ieVvK2b98h3evSEFa/QBg+/EnbtCZNSsuYMeNl0KB+5nVpkEwQm4nhw4fn5LwCXKpJ2QYybV/66dtDd2c7iLWGrtquwBrEWnvGAgAAAEBOaSVsYQ9hrfR16ut1dRCrIZNWXeql9Rr6aXWdfSg0bNhwadSosbz88kgTon7++Ufy1ltjbAGXlTVkcsY6XwO77IiPj7NVsF64cN4Er/ZatWpjAlqtetVqzOxcRq80MLMPYe3173+n6U+qVblz5syUBg1eTLeMBnBapeto+oABg01lqvaOvXTpkqlWzQ4NBbVKNC09DtqTVGmFp30Ia6WB5siRL8natavMMddqZw2X89Lttw9IFcJaaWsGDWKtl+1b93flyuWmtYUG5U899Vy6HsM6/cknn5Xly5dm+7xJS3vUptWiRUsTxKo+ffraQlgrDfJ1X/V3xL71hAbIS5YsMo+1CtpRH2D98uGxx540QawGtvpatbJV6e+b9n/VVo72IWza89pKvwRxRLdxzz33p5uu4byG91rFnt0K9CJZEUsQi4KgfPEQCQkoK2ejU/cr0SpZ/Q+At1fmQapW0CrL5dBV2xNYJSQVjf8sAQAAAEBBptV7M2bMM1WnzvqgalB59dVdZNWqFWZQKA2i9PJub++8v9JRg1KlQdyDD94r/frdIVdf3dn0s7Ve4q7Vhtmhl4bv3WsdoKyBREVFOV22UaMmJojVPqGOaAsEZ4OUdep0jQlitdJ48+YNqSpas0IrI+0v47fasmWz7epp3b4zKYN2tZF//11tq/7NS44GlkrZj6BUVZxW1oHeatWqLVWrVnP4XP0ywPoackorm7UFQPr9CnbYx9ieVnIr+yBYq2StV7PXrVvP6fmj2yxbtqxpnaHnjzWI7dz5GnNzRlsW7Nix1fazfc9de9qmIm3f5rSvzf54eyK3BLG5oQf45MmTUquW81HZgKxqXLahLD/2T6pp2iP26MXjUqOU4w/JVC531bD+uxEReeWDKyGBlhsAAAAAckf7puol+0WhKlaLYfT15hVnIaxVly5dTRCrY9ns2bNT2rXrIAEBV0Zkt6+OdcQ6CJK1MlaDRL1k3Rmt6kupSGxsqg61MlUv5/722y/NTYOm9u2vMgGx3hz10HRGcxN9HUp7qOotM2kHxLKqU6eu0+doL9srzz8j2aWXxzvelyuDQ9WsmXH+U7NmTRNiph1QKi9oL1RHtEeto/ab1h7D2hM2IzVqpLyGnHIWVtqH3I4qeZWjQc5OnDhme6yV4lnh6PzRMFf7+OqXAseOHTPr1X7M9tW3GbUsDQpy/Lrsf589vd2pW4LY66+/3rzRo0aNkquvzvrIcAsWLJBnnnlGypcvL8uWLcvTfUTRaU+QNohVO0P3ZCmILR9UXI6euSglA1I+AGpWLCWHTkWYXrFUxAIAAADILb1MX/umMlhX3tNL/63Cw1N6w2ofSyu99N4ZDT21CtU+FNMQrn//W5w+56WXXpObb+5jHj/55HOmMlbDWK0s1PXp5d46kJberINVDR58T5ZeS2Sk8311/pyU/U/L/hik5e9fLFfb9PPzz3RfMgugdaAxlVHo7SrWnrxZdeHCBXNfrNiV4+RIdkJ2RzJbv6vOhew8Rwf/+uijD2y9Yu3DYQ2etbp4wYK5Ga7TYinw9aK55pZXeOLECXPgc/JLoh9GOnIb4Ar1ytQWH28fSUhKPYDcjtA90rPWDZk+v0XdslKjQgkpVyblQ7N53bLStHaw/L3lhCQmeva3MgAAAAAKThjr6r6pRZFWzjm6DN5KWxdYWSth7Xuynjp1Spo3d/xcDZusl3LbB7rZoZfg6y08PNwMyqWDJ+m99u/UkFd71/r5+ZrR47MTzD377AvSt+8dklMZVQLb5zrOqjJzIiCgeKptZNR71nrZvKvDSFew7lNUVMb5V0xM3ofI2WF/LCdOnGaC0+zQnrevvfai+Z3TKuKuXa+TBg0aSY0atcyAaiVLljSD6C3IJIgtClwaxGqPCGtpviNhYWEmlM1K+Kr9WSZOnGh+DgxM6V8B5Jafxc+EsdoX1t6hiCMSGR8lgb6pR51MSwfksoawytvLS7wtXmZ6VEzqcBcAAAAA4H5vvPF/5rLv4sVLyNSpvztd7tCh/2yPrQFsuXLlpHTp0qaycd++PalGlbe3Z09KP1b7Xpzat3PlyvXZ3l/tN6rb0ZsGWRrGvvbaS2YgMa2YzUoQW758xVRtCnITUJ84cdzpvCNHDtseV6pUSVylYsUr6zp06KA0bdos0/fN/jkFRdWqVWX//r1y7NiRDJfTULIgsf8yQQfDyiiIdXT+fPHFp2Z6pUpV5Ntvf3IY0p8/n1J1XtS5NIhdtGiRaT+QlvUNevXVV7O9Tn1uc2dfQQE50Lhsg3RBrA7CtSN0t7SvmNI0Pbt00K5EBusCAAAAgHynl9ZrkKq3gwf/MwMnpaWh0eLFC20Bqn3w1KFDJ1m4cL7pH/voo084DC3/+edvc1+2bDmpW7d+tvZv/Pj3zaBO9es3lDfeeCfVPN1W+/YdpHv3m2XatEmmOjbtfGe9V2vWrG1CSt23YcOGO1xWC9/uvXegabvQpk1beeWVN9Mts2bNKhk8+F6H21m5crm519YJLVrk7O9nR5o1a2FaWur+LVu2xGkQq+0btmzZZB43bVrwsqJWrdrIsmVLTZisgXblylUcVvRqH9WCpHnzlrbjr+9xhw6O24pq+4277+5vBu3q3/9O6d9/kAlYrcHztdde77RSesOGf22Prf2Mi6LMh4nPhjvvvFNat25tPtBcddNRC5999llX7iaKuMbBjkcO1Ib4OaUVsQmJKecsAAAAACD/2Fexas9KR3+nTZjwk+zbl1KgM2jQ3alCy549e5t7HWRo5sxp6Z6rAxH98cc883jAgDszrC51REOoo0ePmKDXUWWk7q9WVaoqVaqmmmexWNK1VbC65Za+5l5DwN9++8XhtqdO/c3M18GTNLh1ZOPG9bJiRfpxevR4aDisunW7yQw+5ipaFayDp6kZM6bI7t27HB63sWPfNa9dj3nv3rdKQXPjjT1N/1d9Dz/5ZJzDwPHrrz9zS3/b7NBgtVOnLubx3Lm/m77Faelr+fjjDyUmJsaEzA0bNkp1TqatMre3f/8+8ztnlZCQ/vwtKlzeI3b06NEye/bsVNM+/fRT80vSs2dPqV3b8S+6PV1WT9yKFSuawb2cjaoH5ESF4iFSsXh5ORWV+pvFXaF7JCYhVor5OG4enhGLt7f5oE1MSjbVsQAAAACA/KHVlTfc0N1UvK5f/6+MGPGI/O9/D5ngUQPIGTOmypw5M20VjP36pe6n2rZte+nc+RpZufJvE+RqVaqGftpHc/Xqf+Tzzz82YaBehp32uVmhrQY07NIw7sknH5UhQx42FYlaZaoB15Qpv8rmzRvNsrfd1j/Vc7VtggoLC5V169ZIgwaNxd/f39y0L6wGxHv37jH7qMFpv379pXLlynL27FmZP3+2TJnym3l+1arVM2x5oK0RHnhgqNxwQw/Tp1arZL/44hOzz7oPDz/8mLjao4+OkA0b1sulSxdlxIhhct99D5peo9ov9sCB/fLTT9/bqio1PG/UqIkUNFpM+MADD8tnn403Yfbzzz9lXkf16tXl9OlTMmnSRFNtbZXdED8vPfbYkyaE10G4nn56uNxzz//k+utvlJIlS8nhwwdlwoQfzfmvbryxh/k9U9r/Vd+LXbt2mPnjx38gffvebsL1M2fOmArnyZMnmgA3bZ/fosjlQayeXMOHD08XxKpevXpJt27dXL1JIFv0g651hRYy/+CfqaYnJCfK/vP/SdNyKd/qZIevT8qHZ0JikqmOBQAAAADknxdffEWio6Pkn39WmHBJb2lp4PrOO++bS7LTeuml1+WZZ4bLrl075ZdffjC3tBWE48Z9asLT7KpevYa88MIr8s47b5hLvd9++3WHy2mYlXbQLW0HoBWIiYmJ8tRTKdnLSy+9Jjff3MdUqL7//kfywgvPmFBs3rzZ5paWhrBjx35sCuAcufrqLrJ16yb58stPzc1e+fIVZMyY8XlSMKfVvx9++Im8+OIzZgwiHaxMb2lpCJsXQbCrDBp0lxw9elhmz55pgklreGnfU9jX10927NiWqpo0v1WtWk3Gjv1EXnrpORP0f/PNF+bm6Px4/vn/SzXtmWeel8cfH2Z+57Rq2lo5bU+/zFi//l9zzh89WrB65Hp0EOuINZjNSjUs4A7NyjVKF8SqPeH7cxTEWi6Hr9qeAAAAAACQv/z9i8m7735oRnPXMFIDVa20LFWqtOnp2rNnL1M166wiUSsbv/jie9OaYNGiBaa6ND4+TipUqGQu4b777vskKCg4x/t30009zX5oYKXVr1otqZd+6zq10rBPn74mKE5L+92+/vrb8uOP35owSyth7QdB0p61X375vdnnxYsXmTYKEREXTDVvrVp1TA9PreLV4+NMgwYN5amnnpPvvvvK9LLVcK1KlWpy3XXd5LbbBphjk1caN24qv/46XaZPnyIrViw3gaZWH4eEVJCWLVvJrbfeViArYe3pOTVy5Mum1/CsWdNkz55dppJYBxfT9/3OO+82Ybny88v+Fbl5Sfvu6vGfOXOqqQjXwdmioiJNVWyjRo2lZ88+cv31N6R7XsOGjeX77yeYLyw0bA0NPSc+Pj7mfNT3S9+31q3byrvvvmmqwbUtR0JCglmmqPFKpqlloXT27EUpzIKDA034mZiYJGFhkdl+flJykrywYpREJqQuh9eWBa90yH5P4j1HwmXX4XC5tlUVKVOiYH2Qwn3nFcB5BXfiMwucV/AkfGaB86rg69y5rbnXNg7aLqGocsfn1dCh98vOndulV69b5MUXsz+wPdwnJKSkS9fHNdQokry9vKV+cN1007Vv7IlLp7K9Pl+fyw3TE4ruyH8AAAAAABRl2rdXW0388suPDgfqUtorVXuuqho1arp5D5Hf3FoDvGvXLpk+fbps27ZNIiIiTBmysxMzbVn34sWL3bKPKDqal2ssm85sTTddp1UuUTFb6/LzTflOI44gFgAAAACAIsli8ZEFC+aax40bN5E2bdqlW0YHrtIBsVS7dh3cvo8oIkHs119/LePHjzcjy1tltStCQRpFDoWrT6yPl8UM0mVv49lt0qv2Tdlal59vSkVsXHzqdQEAAAAAgKKhefOWphesDkj1xhv/Z1o8aBgbGFjC9AH+44+5pv+t6tGjl9SrVz+/dxmFMYjdvHmzjBs3LlXwGhgYKCVKlChQI8ShaAnwCZBGZRvItnM7U00/FXlajl86KVVKVMryuvx9LlfEEsQCAAAAAFAk6eBTb7wxWp599gkJCwuV999/x+FyXbp0laefHun2/UMRCWJ/+eUXE8JqZWvfvn3lsccek6pVq7pj00CGWpdvni6IVWtOrpfb6/XJfkUsrQkAAAAAACiymjRpKr/+Ok2mTPlNVq/+R44fPyaJiQlStmw5qVu3ntx8cx/p3LkrV38XUW4JYtetW2dOsKuuukpGjx7tjk0CWdKsXGPx9faR+KSEVNP/PbVRbqnT08zLCl8qYgEAAAAAHmzlyvX5vQuFRlBQsDz88GPmBthLuZ46j4WHh5v7Xr16uWNzQJYF+BSTVuWbp5t+KT7SYaWsMz4Wb3OLi8988DkAAAAAAAAUPW4JYoODg219YYGC5upK7R1O/+f42mytR9sTxCYwWBcAAAAAAADyKYht0aKFud+2bZs7NgdkS90ytaR88XLppu8O3yfnosOyvB4/X2+Ji0uU4+ciJZ5AFgAAAAAAAO4OYu+66y5zP3XqVDl58qQ7NglkmfYvdlYVu+bkuiyvx9/HIlGxCbJu12lZs+M07wAAAAAAAADcG8TqIF1Dhw6VS5cuyd133y1//fWXJCXRSxMFx1WV2oi3V/pfh9Un10tSctbO1cAAX9vj0IgYSUpKduk+AgAAAAAAwHNlbUj4XPryyy8lICBAatWqJQcPHpRHH31U/Pz8pEaNGlKyZEmxWCyZViz+9NNP7thVFFGl/EpK83KNZfPZ7ammn4+9IDtD90jTco0yXUeZEn6pn3spVoJLFXP5vgIAAAAAAMDzuCWIHT9+vAlTlfU+NjZW9u3bl+lzk5OTbc8B8tLVldunC2LVqhP/Zi2ILemf6ufYeAbuAgAAAAAAgBtbE1gDVfubo2mOboC7NAquL0H+ZdJN33pup5yOOpvp80vatSZQcfG03wAAAAAAAIAbK2J3797tjs0AuaI9YjtWaivzDy1ONT1ZkmXBwSVyf5NBGT5fK7dvaldNLkbFy+odp6iIBQAAAAAAgPsrYgFPaU/g45W+Z/GGM5tNv9jMFC/mKyWKp1TGxiXQmgAAAAAAAAApCGIBO0HFykinKlelOyZJyUmy+MjyLB0rP5+UIJfWBAAAAAAAAHBra4K0wsPDZfXq1bJ9+3YJCwuTqKgo+fjjj828jRs3mvnXX389g3QhX3Srdo38fWy1aUlgT6ddV7WLlA0IyvD5PhYv8fb2kjgG6wIAAAAAAEB+BLEauL7//vsyc+ZMiY2NNdN0QC7trWn1119/ybfffis1a9aUt99+W1q3bu3OXQSkbECwtCzfTDad2ZrqaCQmJ8qqk/9Kn9rdMzxKej5rVWxcQspgXbHxiSaULVncj6MLAAAAAABQRLmtNcHZs2fltttuk0mTJklMTIwJYPWW1rFjx8z0gwcPyr333ivLli1z1y4CNn1q3WQG70pr9Yl/JT4xPtMj5efrLWERMXL41EVZseWELNlwTBKTUoJZAAAAAAAy8/bbr0vnzm1l+PChheJgnTx5wrwevc2fP0eKAuvr/e67rxy+t3fc0Sff9g2FOIjVYPWRRx6RQ4cOmcft27eX9957T1544YV0yw4aNEjatm1rHickJMjIkSMlNDTUHbsJ2FQILC/NyzVOd0QuxF2U5cdXZXqkIiLjzP2mfWflUnRKcBsRmXmACwAAAAAAgMLJLUHs77//bvrB6iXbzzzzjPz8889y6623StWqVdMte9VVV8mECRPk0UcfNT9fvHhRfv31V3fsJpBKp8rpB+1Siw79JVHx0RkerQbVypj7Yn5Xun+cv5TSjgMAAAAAABRdQUHBUqVKValYsVJ+7woKYxA7b948c9+qVSt56KGHsvScJ554wvSH1Qra5cuzNlo94EqNgutLjVLV0k2PTIiSP49k3DKjUc1gCS5VLNU0glgAAAAAAPDoo0/I5Mmz5NNPv+ZgFDFuCWJ37dplqmFvvvnmbD2ve/eUQZG0pQHgbnrO9q3j+Jz96+hKuRAbkeHzfX28JSYuwfbzpShaEwAAAAAAABRVV66bzkPnz5839+XKlcvW80JCQsx9bCyXdCN/1A+qI43LNpCdoXtSTY9PijdhbN+6zr9c8PNJ/T1HbHxinu0nAAAAACDFxo3r5YknhpnHS5eukh9++Ebmzv1dIiMjpUKFCvK//w2Vm27qYTtca9askj///EN27NgmYWFhEh8fJyVKlJS6devJ9dffKD179hYfn9TxiQ429c47b5hLy6dNmyM7d26XSZMmypYtmyQi4oK59Lxt2/Zy1133SY0aNZ2+Ndu3b5XJk3+VXbt2mG2XL19BunW7Ue6++/5M307NSnQ/lixZJP/9d0Cio6OkdOky0rRpM+ndu6906HC1w+fpIFHq44+/lFq16siECT/IihXL5dy5s+b5rVu3lQceGGounVerVq2UKVN+lT17dpttVq9eQ2699Tbp1++OXJ1yJ04cl++//1r+/XeNXLp0UcqXryidO18jgwffI8HBZZ0+T1/r7NkzZfPmjXL69CmJioqUwMASZn/1NffvP0hKlSqd7nl6xfXSpYvljz/myu7du8z7VKJECalWrYZ06tRF+vXrb352ZvXqf2Tu3Fmyffs289zAwECpX7+R9OzZS264obsp5soqHaxrwYK5tvPH1efVqVOnZMqUibJ27WpzjLy8vKVy5SrmdQ4cONi8zyjEQWyZMmXMgFtnzpzJ1vOOHTtmez6QX26t3VN2he6VZElONf3v46vkumqdpbR/KacVsfbiEpLydD8BAAAAAKl9/PFYmTVruu3no0ePSOXKlc3jmJgYefXVF2XVqhXpDlt4eJisW7fW3BYvXigffvipWCwWh4dX1z9u3BhJTLxSfHPmzGkTqulz33//I2nTpl265/3447fy7bdfppp27NgR+emn72T58r9McOaMvo4XX3xWDh36L9V0DVOXLVtqbhrovvTS6+Lv7+9wHUeOHJI33ng51QDpZ8+ekYUL55sA77vvfjGv7Zdffkj1vP3798rYse/K8ePHZPjwJyUnNGAcP/4DE6Lav/ZJkyaYsPO998ZJixat0j1Pg1sN1jVUtachpd400J43b7Z88cV3UqFCxVTLvPnmq7Jo0YJU0y5cuCAXLmw1gfiMGVNNOB0c3CjVMnFxcSY41cA7bdHhv/+uNjd9r9966z0TCLtKTs8rnffOO6MkLi51UeOBA/vM7fffp8s774yVFi1aumxfUcBaEzRs2ND8ksyfPz/Lz0lISJAZM2aYbxT0+UB+qVqysrQMaZpuemxinMw+8IfT5/larvx6Wby9JC4+UZLS/GMBAAAAAMg7GmZde203+e23GabC8NlnX5CmTZubeZ9//pEthL399gHy/fcTZM6cP03vzlGj3pWaNWubeRs2rEsX4FmFhYWasEyrKt9+e4zMmbNIpk6dLUOGPGyCWw3xxox5O11wqGGaNYTVwFF7hc6bt1h++GGiqcDVgNVRQKwuXDgvTz/9uFnG19dX7r33AZkwYarMn79EvvzyB7n22uvNckuW/GmqK535+ONxcunSJROmTps2VyZNmin9+99p5p0/Hy5PPfWYCWG1ivLrr3806//ss2+kTp16ZpmpU38z1ZY5fV8SEuLl4YcfM+/LrFl/yMiRL0vJkqXMPj3//FNy7ty5VM/566/FJojVY9mu3VUmNJ01a4G56eOrr+5sCyu/++6rVM/VimfrezhgwJ3y00+TzPHW82Lo0EfNe6Uh9IcfvpduX997701bCNunTz/57rsJMn/+UnPM77//QfMeaGD/2msvpXufcyqn59W6dWtk1KhXTAhbt259eeedD8xz9fi+8cY7UrVqdRM+P/fcCBPmo5BWxPbo0UNWrlwpW7ZskW+++SbTAbs07X/llVdMb1gNYm+66SZ37Cbg1E01rpNNZ7elm/7v6Y3Sveb1Ur54+rYbvj5Xvi0tXcJfwiJiTBhbzC/jXzsd1OvCpTipUbEk7wgAAABQhG3c+K9s2rQu1+tp3foqadUq5XJ0RxYs+F1OnEi5IjU3br65r1Sq5LyK84cfvpSkpJTqvlat2knr1u0lr1WqVFlef/1tW2uBvn1TLqfXsE8vb1d9+vSVp54aaXtOUFCQucxdKwYHDLjVXI6vFaIakKalgZhWrn711fepqiH/97+HJDo6Wn799WdTOaqX9TdsmFJpGRsbI19++al53Lx5Sxk//nMT5im9ZPzll1+XkiVLypQpvzl8Tb/88qOcPHnc5CVvvvmeuZzfStsSvPXWGBk//n2ZNm2yCRB79LhZOnbs7GDfY+Xdd8dK585dbdNGjHhG1q9fKwcP/idHjhw2l/q/++6HtsvuNTTWQO/uu/ub7EbbQDg6LlkxatToVNu+5ZZ+Ur9+Axk27AHz/mhl8DPPPG+br8dS1apV21TM+vn52eaVKxciLVu2lgcfvFf27t1t3i97WmGs2rRpL0888Yxtuh5vDbK1GFBD3vXr/zUhdNmyZW0h/MKFKQGuBtaDBt1te26pUqXkwQeHSb169eXll0eaFhd///2XdO2aEoTnRk7OK30/xox5R5KSkqRRoyYm3Levhu7W7SYTYD/wwN1y6tRJ+fTTceY4ohBWxN52221Sr149k9R/+OGHMmLECFm+fLnpWWEVHx8vx48fl5kzZ8odd9whs2bNMr/oNWrUkH79+rljNwGnqpeqKu0qpL8sIik5Sf44tCTT1gRlSxUz9yu3njRhbEaWbToum/adlYREWhkAAAAARZmGQxoC5vaWmHhlEGFH9O9xV2xHA6CM2C+rr80drrnm2nT9XZUGfQMH3mV6wOq9I2XLljP9UJWGc85oNa2jS9K1ktRKg1OrDRvWm4pH9cgjj9tCWHtaKap9atPSY6yX3quuXa9LFcLae/TREbY+qzNnXmnNYK9mzVqpglArDYetBg++N13vU32etZeqtkLIiauv7uJw2w0bNpbu3VPGYvnzzwW2y/L1detzevToJfff/1CqENbK29tbWrZs5fD90r6/KiLivMNzT/vDvv/+eFPlan/cZ86cZgv0BwwY7PC1aPDarFkL83j27FniKtk9rzR8PnnyhO28ctSSQnvn3nffEFvv39DQ1FXHKCQVsfrL8MUXX8jgwYNNn9hFixaZm7L+QjdvnnJpgJWGtqVLl5bPPvvM4Ycm4G631ukpm85slYTk1EHqutObpEfNbumqYu2D2AD/lHP4UnS8HDwZIQ2qB2W6PVdd0gAAAAAARVW9eg0cTq9YsaIJqzKqSNR+o9HRMeZn+z6daTVunL6VnbWy1kr70VpplaXSMNMa4KXl719Mrrqqg2kvYE97fF68GGEea8sFZzSo7NKlq/z++wzZsmWj+fsybaDqfL+DbY/r13fcKrJ48UATZutxyglr+wRHOnbsZMJmXf/+/fukQYOGJlfSalBnNKjVVg3WIDLt+9WiRWv5558Vsm/fXhk69H5TBa3VvhqwWt8ra9WwfQalA4JZzyP79zAtbXexbdsW2b59i8NjnRPZPa82bdpge6yDsEVFRTl8vrWCVvdT9zmj8wiu57aEs2rVqqbK9dVXX5UlS5akCpn0BE0bOrVv315Gjx4tVao4v6wBcKegYmXk6srt5e/jqx1Wxd7beGCq6RbLlQ9eP98roWx07JV/EE6FRZlessGl/M3vgX0P2Uy+TAYAAAAAZKJMmcyLYA4fPmQCN70UX1s0HD16VI4ePZwqzMuoUMbZNnx9/Rw+X3uYqsqVq2a4XzVq1Eo37fTp0xnOd/T8yMhIE2pquwN7elm+I/YhorXyNS0NRnPDWmnsiPYxtdJL6DWItafVxOvXrzPBq16er7fDhw+aS/aduf32/rJs2RIzSJi2LtDBxqz70b59R1NZ3Lp121SvS4+btbJWWw7cdFNKe4OMODvWOZHd88q+vUifPjdmaRvWcxHu49ZS0+DgYPn000/l4MGDsnDhQtMzVj9E9EQtVqyY6cHRrFkz6datW7oKWaCg9IpddeLfLFXFWgfrKlc6QPzsqmPDL10ZuXDNjlO26tmmtcpK2dIpLQxUYlL6f+h3HAwzy9av5vgfTAAAAACFh1bmORvxPjssloz/9NdL412xnczCOd2GtUesu658dXQJu33IN3r0KFuFatpLuDWY09DuxIkrl387kt3XcunSRXOvOUhGHIWgUVGRtsfFixfP8PkBAQG2x9HRUenCwcy2n5eKFbuybxntt7axsH/8yScfypw5s9JVvPr5+Zv3SytjrVWsaSuMdaCxqVN1kK7fTfiuNHzX27Rpk0x17DPPvCA335wSYmqgmhOacbkiiM3ueaXbza6cPAe5ky/X/NeqVUuGDRuWH5sG3FYVG1yqmHRsUtHcR8bE26ZHRMaZ/q/xCVdKXvWx9oWtEHTlH1L76lirfcfOm3uCWAAAAKDw08Gs3DGgVc+et4o7/O9/BScHuHjxogwfPtSEsRog62XqOhCVXtKtPVB1oCT1yCNDMg1is0sHeVIxMc4rOJWjy/7tQ0pnl55fmR+ZpeAzP9gHrBntd8mSV8Lo119/SVasWG4eN2jQyLQw0PdLM6bq1Wua4PLrrz93GMRav3AYPPgeczt69Ij8++8aMziXBvG6TW1r8MILT0vNmpNMkaB9UH3XXfdl2MqiILDur/YGnj17YX7vDpyg+SrgoqrYf09tlB41r5fyxUNs0yoEpwSrZUr4y9VNK0poRKzsORIu63adkdPh6f/RtJ+WlJQssXGJEhWbIEEl/ekZCwAAAAAuMnPmVBPCqjfffNfpSPcXLqQUw7hShQqVzL22QNAKTmeVxI4C4IoVU56r9HL8evXqO93OoUMHzX1gYKAt/C0oTp06IU2aOO6Baq1WVVWqVDP32svUGsLecccgefLJZ3P1flWrVt3cdEAsDbxnzZpuqm11IK9Jk1KCWD1meuy0alT3NyOu6gubGxUqVLQdA23TYB/ao+DIXVMPF1i8eLE0atRIGjdunN+7AmSrKjatZEmWPw4tdfq88kHFpXyZlA9CRyGs/eBe1orYNTtPyfLNxyU6NsFhqwIAAAAAQPZt377V3JcpU8ZpCKv9M7Vy0tWDKWv1rbVdgFZkOqIBrVZsplW7dl0pUSLlsnfteeqMhosrV/5tHjdpUvBaPzp6bVbLli21VXZae8lu25byfqlbbunn9Jht3Lg+1c/WAa2efnq49Ot3s8yYMdVh+4oBA+40x9a+D68Gq82btzSP1637N8PBup555nHp0+cmGTHi0XwrotIByZS2bVi1aoXT5RYt+kNuvLGL3H33ANmyZbMb9xAFIohVepIyQjw8rSrWx8uSbrpWxZ6JOuv0eaVL+Im3k2/JihfzTfWzVsSGX0y5XONMeHSqVgYAAAAAgJyzWFL+nouIiJDQ0HMOL51/9903bVlFfPyVdnO51bJla6laNaXS87PPxqe6FN9q8uRfbRW7afe7V69bzOPly/+Sf/5xHLh9+eUnEh4eZh736eOe1hPZsWjRAtm1a0e66WvXrpbly5emC1x9fCzpKn3T+uGHb2zBuf17ppfsnz17xtx+/32Gw7YIeh6cPp1yvLVS1qpPn5R9iIi4IJ9//pHD7er7oMGyHm8dcD6/KmN1wDENr9WXX34q4eEpA43ZO3/+vHz33ZemYlYHPcuoohqFOIgFikpVrI/FW0IuV8WmFeBvSRfElg70s1XQxicSxAIAAACAK7Rv3/Hy311JMnLkU6ZPqAZp2g5g4cL5MnTofamqNjPrx5od2org2WdfNIHdgQP7TR/a1av/MZeU62X5eom8hn7WsDit++4bYloUaEj8f/83Ur755gvzPA0Ld+7cLq+++qJMmfKbWfbaa7vJddfdIAWNHvennnrMBKPnzp2V06dPya+//iIvvfSseV0aVA8efK9t+bZtr7IFnOPGjTFBrlYs63M1vNX3UINYe/bvmXVdBw7sM9vV51jDWT32WjGrg3PpMR84cIDteV26dJWrr+5sHms17YsvPmOqSPW9OnLkkPz447fyxhv/Z6uufuCBoZJftLJ3xIiUlg3a7/ahh+6VBQvmmteox0kDbu2LfPz4MbPMsGHDMx3wDa5Hj1jAxb1i157aILVL15DOVTo4fF6tyqUctiYo7u+TrjWB9R+aqJgEiY/PWRBr1nP5sgoAAAAAgEjv3rfKkiWLzMBOe/bskhEjHkl3WGrUqCn16zeUP//8w/QI1f6h2R3J3pm2bdvLyy+/bqpuNYx97rkRqeZXqlRZrrnmWlMZm5b2Lh037jN5/vmn5MiRw/LTT9+ZW1rdu/eUZ599qUC+3UOHPirfffeVvP/+O/L++6nnValSVcaO/SRVSFi7dh0zYNaECT+awHzUqFfSrbNEiRLSu3dfmTRpgvn52LEjEhQUZB737NlbduzYLrNmTZOtWzebVgKOBvMaOfLlVFWi+nf066+/La+//rKsWrXS9Km19qq1p5Wo7747VsqVuzJmTH7o1u1GuXgxQsaPf99UVL/99uvpltHXdP/9Dzpt8YC8RRAL5KIqtmPl9rLi+Op0837bM0MCfAKkTYUW6eZVDC4uHZtUlNU7TqWa7md3qYXSlrDWKljtD5u2Inbv0fNisXhJncqlne5jfEKizFt9WGpVKiUt6pbL9msEAAAAgMJIQzcNM6dM+dUEshpo6qXsJUuWkpo1a5kq0t69b5Hdu3ebIFb7g2oVZadOXVy2Dz169JKGDRvLb7/9Ips2bTBVi0FBwaYKUysrf/99ptPn6uXzP/74m8yZM1P++muJ/PffAYmJiTZBYKNGTaRPn74m7C2o2rRpJ1dddbV8//3XJgzX41u1alW5/vobZeDAuxwONKUVnA0aNDQDa+3Zs9v02NXlKleuKldd1dEMvKX9c2fPnmnaPWjLgGbNrvxN/uyzL5j3b+7cWbJr104T6GqwHhJSXtq1u8oMAmbflsCqePFAGTNmvKxYsUwWLJhnqo61ItbHx9csry0B9LkFZUC0vn1vN69n6tRJpgextlzQLxHKli0nLVq0kjvuGGjOEeQPr+R8bs6qg3UNHz7cJPK7du3Kz10pVM6evSiFWXBwoFgs3pKYmCRhYen76bhLeMx5eWPNGIlPSkg3z8/iJyPbPi6VAiukm6e/dr+vTN3XplmdsrLtQKjt53aNKsjWA+ckNi7R9I9tVCNINuw5Y+bd2rmW7fl9u9R2un/nL8XKsk3HM10OBeu8QuHCeQXOLXgSPrPAuQVPwmcWOK+Q10JCUgbHcxV6xAK5rIrtV7e3w3lxiXHy7fYJDkNaR20C/NNUxO45Em5CWJWYlJRqsC5tN2CV0Xcp+fs1CwAAAAAAAKwIYoFcuqZKR9Mv1pFTkadl8p6ZkpSceX9XH5/Uv44RkXG2x4mJyabNgFVC4pWENS6D3rEa4AIAAAAAACD/5XuP2DZt2sjPP/+c37sB5JhWt95ap6dExUfJyhNr081ffXKdeHt5yaAGt4m3V86++0hITJLDpy/ZftbBu6yi4xLE38/xaJoa4AIAAAAAACD/5XtFrI5g1759e3MDPNkd9W+VqiUqO5z3z4l/ZdzGL+RCbITT5weX9DeBbbXyJRzOj4qJtz1evjml76uKjk3f+sA+wAUAAAAAAED+y/cg1io2NlamTp0qb731lowbN05WrFiR37sEZIuvt4/c02iAuXfkvwuHZeyGz+VsVMqAXFc3qyRlSvrb5vv5WuSWzrWkVqXsjbQYHZtoC2r/2XYyVTBr38IAAAAAAAAARaQ1wcKFC2XChAlSuXJlee+992zTjx49KkOGDDH3Vl9//bVpW/Dpp59KmTJl8nS/li9fLtOnT5fNmzdLWFiY+Pn5SY0aNaRr165y7733SnBwcLbX+eOPP8ro0aMzXe6BBx6Q559/Pod7joKmasnK8lCz++TrrT9KQvKVnq5WoTFhMnbjZ/JAk8FSP6iuJFYrI2t3nk61jMU7/UBeVpXLBcqJc5GpplmD17PnY+Ts+Whzq14hZVS/eCpiAQAAAAAAilZF7NixY+XJJ5+U9evXy759+1LNe/HFF+XIkSNm9Hf724YNG+SRRx7Js31KSEiQZ599VoYOHWpC4tOnT0t8fLxERkbKzp075YsvvpDevXvLpk2bsr3u7du358k+o+BrUraBPNTsXvHxcty39WLcJflo09fy/faJEhGXvlWBVwZBrJ9P+nWGXYwx9wmXB+aKjb8SACcSxAIAAAAAABSditgdO3bIt99+a8JVHx8fqV69um3e1q1bTTirAx6VK1fOtCbQClhd/s8//zRVqvPmzZNevXrlSTg8Z84c87hbt27y4IMPSq1ateTs2bOmSvbzzz+X0NBQGTZsmMyePVsqVKiQ5XVrkKs05NXnO+Pr6+uCV4KCpmm5RvJYyyHy087Jcj72gsNlNpzZIlvP7pTyXvWkYUAr23TtE+uMn2/6707OX4yVxKQk28Bc9kGss4rYv7eckMSkZLmuVZVsvS4AAAAAAAAU4IrYadOmmRC2WLFi8vPPP8v48eNt8xYsWGB7/Nxzz5l2AC1atJBPPvlE6tevb6ZrEOtqWv2q+6L69OljQtfWrVubwcN0uw899JCZr8Hx+fPn5auvvsryuqOiouTgwYPmcatWrSQwMNDpTdsgoHDS1gMvtn9Sapa68sVDWvHJ8XI8aacsiZwo32z7xVTLpm1NUCWkRKo+svZCygSYQPXCpTjbwFyxcYnpesSmDXfDImLkwqXYdPuz61CYbD2Q0sMWAAAAAAAAHhbErl271lS83n777SbstPfXX3+Zew0kb7zxxlTzbrnlFhPgWqtLXWnx4sWmNYF66qmnHC7TrFkzueGGG8zjZcuWZXndu3btkqTLl4nrOlB0lfANlMdbPiSNglO+VMjI5rPbZOyGz+R45AnbtBvbVZNguwG9fC2pf2Wtg31pn9gEBxWxCQkp56GzIlv9/bK35+h5+e/EBUlKMx0AAAAAAAAeEMSeOXPGYSipg3MdOnTIhLQa0AYEBKSaX6lSJXOvA2jlxT5pha62Q6hSxfnl2Tpol/1ryAprcKz7HxIS4oK9hScr5uMvj7Z4QO6od4sUsxTLcNmz0aEyfvNnsilhvkQmnxcfb2/xtquQtX+sAvxSuotoCJvoqCL28hcCzmLVuMtBbVpRMSlfUgAAAAAAAMCDesTGxqZcAq3Bp70VK1bYHnfq1Cnd8y5cSOmtqe0BXE2rYPV26dKlDJc7fPiwuS9dunS2euKqpk2byvz582X69Omybds207KgYsWKcs0115h+tJUrV87lq4Cn8PbyluuqdZY2FVrIrP3zZe2pDU6XTZZkOZd8RMITTkrIiQtSw7ex3XpSL+vvl9KqQNsSJCRZK2KvhKsJCSnTkpKSTZVr2hYFcVo9myxmXrHL61IXo+KkREBK/2LtP2vxdtu4fgAAAAAAAIWSW9IVrTpVR44ccdiWQGk4mZYO1KU0vMwrJUpc6b/pqI+sdR/btGmT7SBW2xlo2Lty5UoTKsfHx5sq4IkTJ8rNN98sS5YsccErgCcp5VdS7m08UF5u/7R0qnyV+Hg7/5IhUeLl9/8WyKd7x8mexH8kMTkhVUVsvaplpEQxa0Vs0pUesfGJttYC1mnWMNb+3rrsgrWHZeG/R1ItGxEZZ+61j+zcVYflTHiUC48CAAAAAABA0eOWIFbbDmgvSq0MvXjxoq2P6qpVq0xbgurVq9sG5rJav369GaTL2rbA3XR/X331VVs17+DBg7P0PF3+v//+M481eO3Ro4f8+uuvsnr1alm4cKE888wzUrx4cYmOjpYRI0bIli1b8vR1oGCqXKKiDG54u7x61XNSpURKCw5nkpKT5EjSNtmcuEBik6Jt05vUChYfn5Rf4Xi7IFbPXW0toGFsvF3rAR3UK+X+yjT76tlou5YGoREx5j7sYqxZ36mwK9sFAAAAAABAAW1NcMcdd5hQVSti+/TpIy1atDAhbGJiogla+/fvb1t269atMnv2bJk8ebKZ7+3tLQMGDBB3Gz16tG2Art69e0uHDh2y9LwTJ05IhQoV5NSpU/Loo4/K8OHDbfOCg4Nl6NCh0r59e7n77rtNUDtq1CgTULtaUFBxc2wLK2tlqN4HBweKpwqWQHmn4vMyZ8+f8vvuRRKfFO902bDk4/L57s+kic91UtG3tnndgXEJEhDgJ8dDU4JSfaz+2XFa6lQpLd4+3rZppUsHSPFivhIdk/Ic5V/M1/Z4/d5ztseRsUlSvIS/ePlYzLTYxGSzvaOnL8qO/0KlW7vq4ns5BC5MCst5hYKF8wqcW/AkfGaBcwuehM8scF7B07gliO3YsaMMHDjQhKsaUOol/9bR2hs3biz333+/bdkFCxaYS/et8x966CFp3ry5uItu991335WffvrJ/KyVuhqWZlWtWrVk6dKlJmT19U3psZlWy5YtzfGYMGGCbN++XXbv3i0NGzYUV/LxudLvszDTsNli8ezAOcDiLwOa9ZYb6naWiVtmyorD/zpdNjI+UtbFz5P23r3FYmkk/n4+6Qbwsjp4MsLc2+abY+UtyV5Xpl2Kjrc91opZfRxSJkDOno+Ws+djJDImpR3Chcg4M+DXqm0nzbJhETFSOcR5Ww9PVxjOKxQ8nFfg3IIn4TMLnFvwJHxmgfMKnsItQax64403zOBVGrIePHhQypQpYy7bf+KJJ1INxlW7dm0ThmpVqV66f9ttt7lrFyUuLk5efvllU5Gr6tSpI99//70EBma/Ms5ZCGvVrVs3E8Raq4BdHcQmJKRUGxdWGg7q69Nzxb7nqScr7VdKHm13n7Sr3FJ++He2hCeecjqY17rI+bLqcHm5qmpK24/L31tkKC4uURL9k8y99ZiFXohJd/xKl/CT02FREhUdLxGXYi/PT5az4VG2ZXWQr0S7nrKFRWE8r5D/OK/AuQVPwmcWOLfgSfjMAucV8poWtLmSV7K19LSA0GpZHdCqVatWYrG4r6rz/Pnzpo3AunXrzM9NmjSRb7/91rQTyAsaRmsQrXRAr2HDhrl0/WfPpvTiLaz0snH9ZdAwMCwsUgqbk6GRcuDiXpl+eLrEJaYMnOXINVWuFsvphuLjldJSwBFtRxAVEy9VQ0pI24blTTXr31tOmHnW0NFes9plZdt/odKgepDsO3ZefC3eZlCvxjWDZffhcNN7tnX9EKleoaQUNoX9vEL+4LwC5xY8CZ9Z4NyCJ+EzC5xXyGshIa7NPgpck0ethG3btq1bQ1jtXautAqwhbJcuXeSXX37JVQibWb6trQusAgICcrwdFE6VygZK55qt5IW2T0iVQOeDef19fJWsTpgiEcnnnC4TWCyl4vzY2Uty/lKsbN5/Lt15elXjCleWD0ip5o6MjjdVoeWDiou3l5ccOX0l3NdgFgAAAAAAAB4axK5evVp+/PFHmTJlihw4cMAt29y3b58JYQ8dOmR+1oHBvvzyyxy1I1Dvv/++6YnbunVriY2Ndbrc/v37bY9r1qyZo22h8KsQWF5ebP+kdKp8ldNlYuSSrEuYJYcSN0ticvrBvopfDmLVP9tOSkRk+gpbf1+LBBZLCWCL+6csHxWbYO6L+VukTEl/009Wq2FVbBxBLAAAAAAAQIHsEat0YCrtERsUFCQjR460TQ8PD5dHHnlEtmzZYpuml0z37t1b3nrrLfHzc37ZdW5oC4T//e9/EhYWZn7WnrSPPvportapr826vjVr1kjXrl0dLjdnzhxzX7x4cWnTpk2utonCTX8XBjXoJwlJCbL21AaHyyRJguxLWiMHkzZKVe/GUtu7jVi8UoLVxMQr1dnxCUnpWhaoYn4WuaZFZTkfGSsli/uaXktRMSlBrLYm0IrZBWsO254bQxALAAAAAABQMCtiNYDt37+/zJo1S9avX59q3iuvvCKbN2++POhQyi0pKcmEldo/NS9oa4Ann3xSzp49a35+8cUXcx3Cqp49e9oG6hozZowZACytuXPnytKlS83jQYMGSYkShXf0ebiGt5e33N2ov9xR7xbx9Xb+/UmCxMmhpM2yNmG6XEoOk2rlS0q9qqUdLlsiIGU9GroG+PuIv59FKgQVN8Gvr4+3xMRdDmJ9vE3FbDG/K9ulNQEAAAAAAEABDGIPHz4so0ePtoWs3t5XNqstCBYvXmzCH20H8Oqrr8qHH34oLVu2NMtqYLl8+XKX79PkyZNNha41PNWQODIyMsObPR1oS2/2lb2qSpUq8sADD9jaD2irA93/c+fOmdf6wQcfyPPPP2/m16lTRx5//HGXvzYU3jD2umqd5bm2j0vt0hm3s4iU87ImYarsTlou4hsrHZtUTLdM9fIlpXK5QLm+dVXz+2fPz+dKj2YNYpW/r7dLglj9vT565pIkJF6pzgUAAAAAACjs3NKaYNKkSZKQkCA+Pj6mh6oGn1bz5s2zPX722WflzjvvNI9vuOEGufnmm+X48eMye/Zsp5f459RPP/1ke7xgwQJzy8yePXtsjw8ePGjuQ0JC0i2nlbbnz583Ye+uXbtk6NCh6ZZp1KiRfPXVV6Y1AZAdVUpUkidbPSzT9s2Wv4+vdrpcsiTLqpP/mtv/s/ceYI5c55nuV8jonHOYnpw55AzDMEmUGCxTEukgyUm+tteWc7av7We9Xtu7ey35WXsfyddah7V9ZVm7irailSjGITnDGU7O3TPTOaO70Y1GBuo+/wEOcKpQSJ0m/S8FAahw6lQAevDVd76/u7ILrcn7UG/rMBTlemBXtkiXihRf1dcuZ1acjcZWLqIOTwVwqn9GuHUP7sj9/DAMwzAMwzAMwzAMw9yJbIgj9o033hCOu/e9730GEZaQQ/TtdjueffbZzHTKhf2hH/oh4Z6j2IK1hDJch4eHsV6Q4/dP//RPReGxZ555Bi0tLSKuoK6uDvfffz/++I//GF/84hfR2motgjFMMew2Oz604weEILupuqfo8iPLoziR+BrGk9mbCXab0QWbV4i123KWTySTmFsMi89nuSwGU3EdgVBubAfDMAzDMAzDMAzDMMydyoY4YicnJ8WzuSjV9PQ0Ll++LETa/fv3o6amxjC/q6tLPNOw/rWkoaHB4G5dCaWsf/jwYfFgmPViW/0W/M6hX8bl+X58+uLn4Y8uFlhax4XES/AlR1CvdWAxVoMaNFkuKcVXwpEWZSlLVi369eqZcWzvrsPuTQ1l9VkWDFPFXoZhGIZhGIZhGIZhmDudDVFCZL6qWWg9cuRI5vXDDz+cs14oFBLPaqYswzBG6EbGrobt+IMHfgMHW+4pengm9QFcSr6Kj5387/jC1a8glkwV5VJxKXmwUpS1mXJkifFZY3ZyOUKsI93u9EIIL58eQzAcE++TSZ3zYxmGYRiGYRiGYRiGuePYEIWzvr5ePI+Pjxumv/zyy5nXjz/+eM56Fy9ezJvDyjCMkWpXFX5m74/jtw/+MnbUby16eJJI4uXR1/Ffj/0FvtT/NUwuT2XmVXldmddOC0esJJoWVeeXIkiaYgootmBUKco1sxASIqsUYmWBsJGpJSwsRXDsYmr79Pz1NwZXFHvAMAzDMAzDMAzDMAxzVwux+/btE6IKFd2KxVKuNyrC9corrwgxhjJUKZpAhYph/du//ZuYT+szDFMam2t78Wv3fgR/cvj3cG9z8c/ObMiHF0dew0ePfxwXfanIjfpqd2a+zIa1csRGYwmMzS7jldNjuDI0n5lO4uuNiSWcuDKNMwOzYpnXz03g/A0fIrFEZhnCnS4C5l9OZcZOzQfF81Io9V3BMAzDMAzDMAzDMAxzJ7AhQuxzzz0nni9duoQPfehD+PM//3N8+MMfRiQSEdOff/75zLIjIyP4p3/6J7GcnE9FuxiGKY8mbyN+dt+H8YHtz8FhKx4HTREFf33mH/DW5EnUVmYdsdK52teRihZprPUY1vMHUp/TybmUgEq8cGIUZ6/NZtyyi+llZv1hBCOpKIR42hkbT2adr6oLloqBMQzDMAzDMAzDMAzD3ClsSLGuZ555Bk888QReeuklIcbSQ9LZ2YmPfOQjmfef+tSn8JnPfCbznkRaq/xYhmFK451dj2BPw068NHoE52cvwReeK7j8py5+FoFoAM11W2HTsvdqSJx9/rHN6B9dgM+fK5Imkroo4NXWUIFwNJs7S3EEKcmVXLA6EmknrHTEyvdyvsTnj2BTG59lhmEYhmEYhmEYhmHuDDasCtbHP/5x/PzP/7wo2EWuNyrA9eSTTwrRtbKyMrPc5s2bxXy3241f/uVfxn/7b/9to7rIMHcszRWN+OD25/CnD/8+fvfQr6DJ01Bw+S8NfB39tlfxwO7cfGa7qXheNJYSUgOhmHCxXhw0Cr3C8KpnowwksbToqoqvMj9WLBvPLqtC0QbXxvycIcswDMMwDMMwDMMwzG3FhjhiCZfLhd/8zd/Eb/zGb2Bubg7V1dVimpnDhw/jYx/7GN75zneitrZ2o7rHMHcNm2p68IcP/jaOTp7AZ6/8W97ljk+dRKXTK6INVBx2Y1asdLbmg4p40X/mZTOO2GR2WjCSzYVdDsVwYXAOu3rrDfm0Jy5Pi8JfLqcd3S1VJewxwzAMwzAMwzAMwzDMXSTEqnmTjY2Neef39fWJB8Mw64fT7sRjnYfxYNtBfPrS53Fy+qzlci+Pvg5feB5PdD2KHQ1bxTS73eiIDUetnatqNIES/ZqBMmLJ/a46YoPhbKQBOWz7RxZQ7XWKgmEt9V44HXYsBVNirSz6xTAMwzAMwzAMwzAMczuw4UKsJBqN4uLFi5idnUUoFILX60VLSwu2bt2KioqKm9UthrmrcNld+A97fwJ9I6/hS/1fs1zm3OxF8TjYcg9+fNcHchyxah4s3Wgh0VR1voqMWKUgF1HhdoiiXZQrSw9JKF3IS2VkOiAcsK0NFTi8h0NjGYZhGIZhGIZhGIa5PdlwIfb06dP4m7/5G7z++uuIx3NFF7vdjgceeAC/9Eu/hEOHDm109xjmruRd3Y+h0VOPf7rwvxFL5n4uibenz2AyOI0PbPpQXkdsldeJR/a14ejFKSwsRTLRBOb4gkqvUwixNF2dpzpi1YgCYiGQao9hGIZhGIZhGIZhGOZ2ZMOKdRGf+MQn8GM/9mN45ZVXEIvFxLBk84PE2TfffBM/+ZM/ib/8y7/cyO4xzF3NPc178eFdRpHVzFhgAv/z4v9Ef+IY4npUTFOF1JpKFzwuBza31xSMLyDBVhbnSqjRBBaOWGmY1WDKplUKezEMwzAMwzAMwzAMw9zqbJgj9m//9m/xyU9+MvN+27ZtojBXd3c3PB4PgsEghoaGcOzYMVy7dk2Isn//93+P+vp6/PRP//RGdZNh7moOtt6DaDKGz1/5N/FsRSQZwSBOYTLZjx32R9Fi25SZV1ORElidDuM9HtXparNp8LpTXz2UD6sW61q2cMTK+Uq9LkFMEYAvD80Lly0V75rwLcPttKOhxlPu7jMMwzAMwzAMwzAMw9zeQuzg4CD+6q/+SuRHkrD6Z3/2Z3jHO96Rd/kXX3wRf/iHf4i5uTn8xV/8BZ566il0dXVtRFcZ5q7ncPsh7KzfKgp1vTL6BmJ5BNkwAjiT+BYqErWo0hpQozVjt+tRMc9pKui1HM624XHaYU/nzJLISmKs22VHJJpAML1chceZeS3zZU06rHDTivm6jsvD8+I1CbHHLk6J188/tvmuP5cMwzAMwzAMwzAMw9xl0QSf+cxnROSAw+HAP/zDPxQUYYl3vetdYjmn04lEIoEvfOELG9FNhmHS1Hvq8ANbn8V/fOC30FFZuEBWEH5M6zcwkHwLf33pE/jni5/DfMyXd3mXyw6HLfXVE40lhfudxFkJuVndzuxXkyzmRTdyCFperBtPxR2QgCuR81bD/FIY3zk2ZFk4jGEYhmEYhmEYhmEY5pYWYinzlUSU5557Drt27SppHVqOlidh5bXXXlv3PjIMk0tzRSN+++Av48G2gyUdnrgex7HJt/H/nv8kBhOnkdBz3bSqIzYSS4moLkWIrfA4MqKrAS0ltEonrHxW82elaLsa3jgzDp8/jMGJxVW3xTAMwzAMwzAMwzAMs6FC7MTEhHg+dOhQWevdf//94nlsbGxd+sUwTHE8Djd+cveH8DsHfwXb6jaXLMj2J4/i5fincCb+HUwk+zPFvSiGwG7TDJEFHldWiK30OGGzEGK1tNBKUQRiGxkhNutcVQt/rZRQNFccXmvUPjMMwzAMwzAMwzAMc3ewIUIsxQsQFE1QDnZ7SgiJRlMCDsMwN4++2h78+r0/j5/Y9UFUOipKWieJOKb16zif+B5eif8zriVOwOXQYE9nyA6M+jPirISKbqWTCwyQS5aiDCRWjli1gNdSMCpiC7782nUMTS4J9+033hzEyHRAvJbrm4mmXbqrl3StGZtdxreODWN4ammdtsAwDMMwDMMwDMMwzF0rxLa2torns2fPlrWeXL65uXld+sUwTHmQGErFvP7ood/F81u+H+2OPjjgLlmUvZ48gf9v+K/x6uTLGYcsQQW7JO2NFZbRBDRJFVqj8aQQTa8ML2SmqeLq994exaV0Ea9T/TOYmQ+J+W9fmcY3jw7hxOXpnG2oGbP5hNrVMjG7nHr2BdelfYZhGIZhGIZhGIZhbk3Ks6iuEIokGBoawpe+9CX8zM/8DNraChf/kXEGX/ziF4UgIyMKGIa5NahyVeKp3neienknJn1BxF0LGHYcwzX/jaLrBhPLeGn8JVTgJO5xfB8ccKGtsRlVnkZUeh2oq3LnjSaQQ/ptNg3xRBLnrvsMw/zNQ/5JfBXralom0kAyNZ8rhKoFutZLiJW9sIrBZRiGYRiGYRiGYRjmzmVDHLE/8iM/Ip6DwaAQYq9du1Zw+YGBAbEcLU988IMf3IhuMgxTJtu76sRzi6cNv3XwF/Hr934EfTW9Ja0bhB9vxj+H1+Kfxv9z+v/B9+a+DG9VVmjNQdMQDKfmdzVXiWeKGVBRYwrU4l0yX1alwp17H0q2X6oQOzDmx40yi3pJ162V2MwwDMMwDMMwDMMwzJ3Lhjhi9+3bJ8TUz3/+87hx4waee+45PP7443jooYfQ3d0Nr9eLUCiEkZERHD16FK+++qrIlSUX2w/+4A/innvu2YhuMgxTJg01Hhze04aqCqd4v71+K3774BaMLI3h9Mx5nJ45h6ngTNF2EnoCZ2cvYCwwgV898HNCODVD04Jpx2pnc2UmY5WKe/W0VuHS0DzCiqPV4JDVstmvEjXmwNIRm862LsT56z7x3FznRZU3dQyKYXbmMgzDMAzDMAzDMAxzd7AhQizxh3/4hwgEAvj3f/93xONxvPTSS+JRyDH29NNP40/+5E82qosMw6yA1gZj4S66gdJT0yUe79v8DC7OXcHnrvwbfOFUXmshfOE5/PHRj2Fn5T1o0++DU3MbvhdCacdqU60HXrdDCKcVHgccDpulIzbTJ4t5lEtLbap5tIbCX2VEE7xwYgT3bW9GT2t18YXTOqxVDi7DMAzDMAzDMAzDMHcuGxJNQLhcLvzlX/4l/vzP/xxbt24VAki+x7Zt2/DRj34Un/jEJ+BwbJhWzDDMGkNi457GnfjDB38bP7HzA2j01Je03uXlMzgR/wqieirjFeloAXLEelwO2G02bO6oyUQMOO2FhViKNYiYHLH0XaMWCTM7YuNlZsSO+1JFuIohDbFW6QsMwzAMwzAMwzAMw9y5bLjK+f73v188xsbGcObMGfh8PiwvL4t4gubmZhFjQHEFDMPcObjsLhzuuB8HWvbi05e+gDMz54uuE8AcXol/Cr22e7DV9gCSulNkuJIDltjSWQuXw462hgr4FsNiWshUrEtCmqdZiCWo4Jcz7aYlZLQBRS0sL0cL9k869yVUtGxyLij6U1I0AQuxDMMwDMMwDMMwDHNXsSFCLDlhk8kkfuAHfgBbtmwR0zo7O8WDYZi7B6/Di5/b+2H0L1zDl84cQVhfhk8fhi7H61swlDwjHrYlO3ps+7DZtQn+SBVq3TXobUtFAZijCQ7tbMHsQhiDk6lCWpQCELFwyy6HYmKd+mp3RsilQmGUO7vgz7pxS816PXphEs8/trngehkdlqMJGIZhGIZhGIZhGOauYkOE2G9961uiENfAwAD+5m/+ZiM2yTDMLQoJkFTUa1c6TuDB/XX418F/w0XflYLrJZHAYPI0BudP48XXv4y+ml68d/PT2NmwDY70OH9ZkKuxxoNAMGZYP2QhxJ4amBVi7AO7WkXm7PjMMio8TricdssMWZWEKdagVDKiM9fsYhiGYRiGYRiGYZi7ig3JiJ2amhLPTz311EZsjmGY24gGby1+af/P4Nfv/XnUuWtLXu/G4hD+6vTf458u/G/EtZBBMHXYbYbIASq8lUhkM1/lPBJhiSsjC7g25hev66pdcDls6QzZ/DmxlFm7EqQj1spRyzAMwzAMwzAMwzDMncuGCLHV1anhw7GY0aHGMAzjcGhpl+wW/M7BXy5LjCVOTJ3Gn538Cyy6r2WmOeyaQYg1Q9myKkvBKKLxlGP24f0dmXWFgJvMirGUAXuqf0aItKUIsbMLIZwZmDXkycrXyRUKuQzDMAzDMAzDMAzD3J5siBD7/PPPC/HhU5/6FJaWljZikwzD3CbYbdmvoXpPHX774C+h2lFTVhvRRBRHl76Ds8lvY1tvhRB2CwmxTqdxHomi/kAUHpcdHpcjs+7ozDK+9vogpueDmQzYockl9I/6hXhbjCPnJnBjYhFLaeet2FYZjtjz1314+8pM0eUYhmEYhmEYhmEYhrn12RAh9jd+4zfw7LPP4saNG3j/+98vcmJPnDiBubk5dskyzF3KPVubsLUz1/3a4KnHf9j8K3jE8WPY4rgXXru35DanEjfwyYG/xFeufROaLTdWYPemBvHc1VyVMy8SS2SKflFGLDE0lbpxdGlo3rDsxcE5HLuYilwpBZsSmyAjEkpx1A6M+TEyffNuXlGBM9XNyzAMwzAMwzAMwzDMLV6s6yMf+Yh4drvdmJiYwMc//vGy1id328WLF9epdwzD3Az62msKCpcVWg12OR/Gbz30o3jx4iVcnhmEza7DU+/H8alTBdv+ztBLeHvyLDYlH0aDrVNMI5frtq5abGqrFqLreYv1KFtWLku4nXaRIzu/FCm6P7ROPm1Vdb9SEbC1iiag2ATVUbyW0D6/cnpMiNfbu+vWZRsMwzAMwzAMwzAMczexIULsG2+8IcRU6axihxXDMIVQC28RTe5mdNjcaKj24PE9HXik4wH868DXMbw0lrcNX8QHH74GJIBmbRN2Og5C0zYJt6vqRqUognA0bhBgZYZsKJKaThQq3EU01nowPRcSLlK3y5hBq4quMnN2tULs3GIYr54Zx73bmtHblsrhXksmfcvieWQ6wEIswzAMwzAMwzAMw9wuQuz999+/EZthGOZOQzMO7a9wp76yttVvwe/d/+t4efR1fKn/a0jqhUXSGX0QM6FBLJ27iu/vexLN7pbMPBJNpRCbccSmM2TLEWKpj+R8/eaxIRzc0YLulqo8QmzqdWKFQ/6pH9TP6flQJr5gPYTYYCRhOOYMwzAMwzAMwzAMw6yODfmF/elPf3ojNsMwzB2KzZYWYj3Gr6x3dj2Czso2fPrSF+ALzxVt5/TMOfF4rOMwXPpe2DQ7HHYNdrtNZLdKIVY6YlVkpEDePiou3v7RBYMQG0+LryTISlFWX4EjdtYfwpGzE7hve3Omr7F4EhduzKG53ouWutLzdIshRWgvC7EMwzAMwzAMwzAMc/sU62IYhikHHUaRMuOINQmx0h37x4f/b/zi/p9Gb3V3Se2/Nv4mTiS+grAegN2miYcaTSCfVYo6YtNtEIvLUcM8Kb7KWILU6/KF2ElfUDzfmFiEw5HaHrl5Sfi9cN2HtSRkimtgGIZhGIZhGIZhGGZ1bPgv7OPHj+OP/uiP0N/fnzMvEAjgkUcewe/8zu/g7bff3uiuMQxzqzti87gzbZoNe5t24XcO/TJ+eNv7YddyHa1m/Po03oh/Dq/6v4aJROr7iNyxKxZiTbm2aha2FF1VV205GbGZYl/pTdA7h6lIl2eNnavSEcuZ3gzDMAzDMAzDMAyzNmxY+F8wGMTv/u7v4sUXXxTv77vvPmzbts2wzOjoKHw+H77xjW+Ixw//8A/jj//4j2G3FxdVGIa5c+loqkQwHEdDjafgciTIPtH9KLbVbcY3B78nYggKkUAMI5EBjGAArdoW7NZ/KCPEqgUGS4kmMOmwCEdTGauq6BpTxNxyDLGiH5oG+i81ISXGrieyz6usKcYwDMMwDMMwDMMwzEYKsSQi/OIv/iLeeuutjLAxOTmZs1wymcS+fftw/vx5sdwXv/hFRKNRfOxjH9uIbjIMc4shhccqrxMHtjWVvF5XdQd+bt+Hxeu3Bobx8uhrGNMvIK5ni2+ZmdKv4eMX/hyv+HbjZ+/7MeGOjcX1FUUTEJFYrhAbj6vRBMb2ZhZCqK5wwuNKfS2rIjAtSpGwMrJBt3CqluOwLYbaNjtiGYZhGIZhGIZhGOY2iib4+te/jmPHjonX5IL9P//n/+AXfuEXcpbbvXs3vvCFL+Bb3/oWDh06JASAr371qzhy5MhGdJNhmDuQQ5u78TP3/iB+7/5fQ4u3uJh7evIi/uCFj2JRM94soqJY5UQTRBRHbDaawNoRS9NfPzeBbx0bzkxTZVUphsalMKzr9D/r+II1QM2vXcNmGYZhGIZhGIZhGOauZkOE2C9/+cviua2tDZ/73Odw7733Fly+t7cXf/M3f4OWlhbx/rOf/exGdJNhmFuFNRT/yKnaVOtFR1Ub/u/7fxUHW+4pus5SNIA3gl/GfHIi43RVhVWiraHCuB1TNIGlI9aUEZsRWBWBNhCKGdYRr9PLReOpNoOReGa5cgTTWDyBsdnlsoTYtRR4b5a7lrZ7/oYPs/7QTdk+wzAMwzAMwzAMw2yYEHvx4kWRt/ijP/qjqKgwihf5qKqqwgc/+EHxA/r06dPr3keGYW4dHDQOH4Dbtbb50F6HFz+z98fxW/f9EjxaVcFlk0jiROIreDXyGZyJfwc3lgaxpPswnxxHWA9g96YGPH5PR0nRBDKGQAqutH/03SZ1STWlYHIuaBEPYHTl0nP/6IKxv4p4SoKrlej55oUpHL80hbnFcMF9TyiC8VqJp6f6Z/CVIzduihhLhccGRv04cnZiw7fNMAzDMAzDMAzDMBuaERsIBMRzV1dXWev19fWJZ7/fvy79Yhjm1qS7tQrBcAyb2mvWpf0tdZvwfVU/jZHgIK7b3sB8zJd32RAWEdIX8fXp64bpQxe68UzXM5mvUbrZVCiagARIWazL7bQLUZbcpjZoBtfpwlJELDvhSwmyhJxfKB5BLkMi66tnxrFvSyO2dNQalpECbNSiHdGfpA6X027oz1rppkOTS5ljQfm7GwmnKzAMwzAMwzAMwzB3jSO2ublZPE9NTZW13vz8fMYdyzDM3QPlre7a1ACvex3vFWlAg60TP9r903hv39Nlrz4cGME/XPlHDCTeQlyP5mbEKo7Y6fmQcINSQS7C5bQZIgBUN+v8UgSDk0s4eXUmM03OzyfE2u22zDK0LWJwIiV8ZtpQFFVzzALx4skx/PvRoVS/DFm2eo679MuvXc8Iq/kgMdmqwBkX/2IYhmEYhmEYhmHuVjZEiN28eXOm8Fa5Rb7IZbZ9+/Z16xvDMHcnUja1a068p+9J/NUTH8V97fvKaiOpJ3EjeRJH4v8bb/heQULP5rYuh+OZ1wuBiHieTLtcyRFLfPPoEC4NzhnEzuVwDD6/MTpAzpYZsSoP7m5FTYUzI8RKPZjaXApGhWg6OhPAUjBmKRJLyIFcSkas7BtFDahOW7MwOzwVwNffGBTCsuGYFa55xjAMwzAMwzAMwzB3LBsixP7AD/yAeL58+TL+63/9ryU5oj7+8Y9nsmGfeYaG/zIMw6wdMkpAfhvZNBt+7cGfwT1tu8puK4YwjvmO4KX4P2EkcQERPShE0Hx4FKfvlZGFjIhKsQDSdapCYmjKYaqjvtptmFfhcQo3rtROMxEJejZv9vz1OYSVNq2E2My2kjriihBr/rrWzFXJAFwdXcDpgVnDd7vMsJ1K90Hdl43mJtUIYxiGYRiGYRiGYZiNz4h9+umnhav16tWr+MxnPoOTJ0+Kwl333XcfOjo64PF4EA6HMTExIcTXz3/+8zhz5oxYt6enBx/4wAc2opsMw9xFZJIEFJXO7XDhDx77Fbw29BaOD5/DqemziCWNomghdCRxOfmaeCAOuFABF7xotW3GJtsB2LSU0FphilyQQmyV14m5WAIhU3QACbOVHocQOmsqXCKyYXx2ObMfVChMCpwZHVanLNbUvTaKCFBzYa2iCVQ3rBqVoL6WhcDMUGSCLD6W3X7q2ZTYcJOEWFZiGYZhGIZhGIZhmLtEiHU6nfjkJz+JD33oQ/D5fLh06RL+6I/+qOgP58bGRvzt3/6tWJ9hGGYtyeiwpuk2mw2P9jyA3VV78H/t/hGcnj6Hf73wMjRoqNTqsazPY1YfLmkbUQTFI5D04VryOLpte9Fs60FSqzQsJx2oJLbOLQLhqFH8PXZxCtu76zJ5sGp0ALlhhSM2PU1qjvRWZrTSs5ovGy4oxCYNGbFmDTMaM+bH0rbj6bZp3eVwAtUVroz4aS5iZhZ2NwLWYRmGYRiGYRiGYZi7Roglurq6RObrxz72MZEVmywQFEhCyFNPPYX/9J/+U6bQF8MwzJpiiibIx4GWfehwbhERAjIfdUmfxXz1aVyZHyhrkyPJ8+Jxuv9baMN2bLM/CJfmxfTiImaTw6gHfd95LcVKKuBFOO0a4omsuElJAZot6zRVC2SpoqnqZDVHE6iOURJ5VaHX7CZVc2op7oCiEaTIe3FwHjcmFvHw3rZMVIIq6hI3QYdlRyzDMAzDMAzDMAxzdwmxRH19PT760Y/i937v9/Dqq6/i3LlzwiHr9/tFPAE5YPfs2YPHHnsMnZ2dG9k1hmHuMnb31uPNC5PobqkqumxLfQWa67xCiD1ybgLVWhN+4sDP4fTMefzzxc8imswWuiq1yNc4LmMqPoAK1OG712fF9FNjQKPWjb32d8OleQzrSLGTHLGalhVDNcURK3NkCXodVQTXQCjlsq30OA3TU/3JL8SaowRiirgbiiRSQmxabKWiYAQV6NLTErecl2kvqWMxGMXSchSdzVWifZomYxTWg5sh/jIMwzAMwzAMwzDMTRViVUH2ueeeEw+GYZibQWtDBZ5/bHPJy5Pg2VTnNby/t2UfdtRvwdeufwevjb2ZER9LJYE4lpASYSU+fQSvxP8/Ich6UIV6W7totUZrQpXWIARLEl6z/UjFExCkmUoHKgmcEcW96ltMuXkpX3ZuKfVaEo9n+x2NJjDhS+XPyjZV1DbVImJif9LP6nqqK1esk9TxyumxjMB9YXAOgxOLePbwJjgdtg3PiCXRmPpDLl7qD8MwDMMwDMMwDMPcUUIswzDMnUKFswIf2vE8DtQ9gK9fOoLp5HWEEUAc0VW1S4IsMZa4lJlWozXDG3hMiLQGRyzlE6SFUZk3S9qjKoIGwzEh2HpcdiGG0kOup7pWT16dQTCSzag1i5iqI1ZsL5ESY+V72SeZG5vjiFXao4gEEmGJWX8I7Y3G7Ny1olCBsKGpVOTD1RE/C7EMwzAMwzAMwzDMusJCLMMwTBkc2NZkcKRKGtz12GI/JB4kTJIYef+uRnzl4hH4EmOYtw0jklidOLuoz+Cro/8qCodRpEGrbQsGF6lgVq2YT+KqzIileAESOqu8ToQicfHe6bTBbk/1fW4xLHJnqyuchoJaqggrIg/MxbqUol+0PbUImITEVyl+mueroigVJatwO8Q2p+dLF2LJxUoacm2Ve9XFutJa9IbnyAZCMTjtNrhd9g3dLsMwDMMwDMMwDHPzYCGWYRimDDa11VhON8YFpF5Xeb34yCPvSU9MYnBxBC+OvIYzM+dXdcwpAmEZ87iePIFPnDmBbs9mtCcP4PKkAyO+AJxICZShcBwNNR4RRzCzEILdZhMPgrJui+Fw2HLcpGqxLhJp1eJgmWWi2WXMQmwwnBV6I9EEXC67EGIXApGS919GG5QaLVFIZJXnaqNjZF84MQK7TcP7Hunb4C0zDMMwDMMwDMMwNwsWYhmGYdYAOcxfxeuyK0WobNha1yceV+cH8LnTL8KvTyOE1ND81TASvo4RXMdb/an3LnhRodWhVmvBlkQfeus6oM/rIp7AkXbElgL13axhqsKqnscRS6KvKtwuh7PFzM4MZDNxw9FEJsKA3LXrRSGzq9TPC8UXrJREMmm5bSkMq0XRGIZhGIZhGIZhmDsfFmIZhmHWAIu0grzFp7bXb8W+9Lx7ttfh7SvTIm4g0ngRx6ZPIK5nhcuVEEUIUT2EBX0CQ/NngHnACQ/abdvRlXys5Hacdg2RWCpm4NLQPHz+sBBMab9IgE1lxOYKseRwJadpQ7VbFAn77vFU3q2ZcCyRLfS1jqJkIZFVLXS21nzv7TEhfv/Mc/tK7g/DMAzDMAzDMAxz58JCLMMwzBqg5qwWmiahbFASIStdHjg0l5j2vr5nsdXxAK5OTSKkLyKg+0Qu7LR+Y9X9iyGM4eRZ/NPgWXhQBbdWiWatF5VaPZq0Xtg0m6UjlsTSxeUo+kcWMtOdDntGiLVyxBJ1VS5UeJxCiM0HRRPIYl4rEWIHxvy4NubHk4e6MpELZTtiM8usvThKIqwV6+n+ZRiGYRiGYRiGYW5dWIhlGIZZYx7e154R+PLxzP09Iut1YSlqiDfwODyo0urFoxm9mXkkFC7Bh/mq07i6MLCq/oURQFgPwK9PifckzO61vwv1tg7DctQf0ifNrleX04ZgOCVwSiHVDOXS5nMES0QRsfT6UpwcnloSInVrfUXR/Th/3Zfan2gClR7b6jJiN1Ab5UgChmEYhmEYhmGYu5PCv5IZhmGY0lCUvJY6L5rrvIW/fG1aqniWktlKw+TV92bBsEZrwi/t/w/4oe4fRaPWvWZnhoTZE4mv4nz8RfiTU0K4vHdbs4hbIIHU7OB0pQVWmp7PEUsirFwuHxRhoIqTNyYWcfLqDE5emSlLVM0nelM27atnxrEUjN2UjNh8sCOWYRiGYRiGYRjm7oQdsQzDMGuAZlGsq6Qv4Uwxr7Q4WyDOQC6/pXorFh214v0zh9vx3avHcWl6GAnE4U9OIoC5FfVlQr+KicRVODQnAnP3oDmxG7pemePgdDns4llEEyTyC7FOZ2EhNhpLZF7TNihmIF/hM4mVXppvpP/AqB9zi2HxKNYeFR7bKNgRyzAMwzAMwzAMc3fCQizDMMwaUFPhwt6+RrTUF3bCmrEroiO9zueIVZ2xqlbrdXixr/4Akr4u8f6+Xc1oa3TjX14/hhgi2NzjxsnZUxheGi25T1Qs7OjkCWg4iR32h3Eg8URONIF0dsbzOGJJrHUqIrMVqpuWnK6BUCxHnC5FxJRu1vmliDg2dVVu8b7YsVTXXU8d1uziVbdF8wplCa+URDKJk1dnsaWjBg01njVvn2EYhmEYhmEYhikfFmIZhmHWiK1dteV/CZujCQoUnZICJS2nor6nfFWXw4UGW6d4/0TPJjzV9ximgzO4PNePF4ePYCY8W1LfdCRxOXEEHz1/BNVoEoJhFRrRrj+RERQLRhM4U85ZMyIL1+XIX8xKES5JqJz1h9FU6xHbt4oQkEP9Xzk9Jp6ff2yzeI5Ek8X3cY0E2CvD86ivdqPFItvWLPKq0QQkLKvXABGOxjE8FRDXk/lcl8rUXAhjMwHxePfBLlRXpArCMQzDMAzDMAzDMDcPFmIZhmFuIqrwSpqb6pClnNmZhZB4vW9zIyo8DssYBHUov4wNMIu3LRXN4nFP3UF8/eQFJJGAq2kSb04fRSyZP0NVsoRZUmaxiBn88/BlNGm9qAw+Ane83nJ5yofN54h9xz0dOHvdlxFiaZ9Vp6saEzA2s4wTV6ZFATTK3rXKV82XuUrFwApxun8Wg5OLqTYsFNmlYBRVXqcQgCk24erIAp481J1ThIwiFi4NzRtE4EL9I7eqUYg1Ln/s4pRw93pcdvS0VmMlqNv83tujeP+jfSsWdRmGYRiGYRiGYZi1gYVYhmGYm4gqopLgpw6np4JZ3zk+LF5v6cy6bc0Rqur7Km/qa/3Rfe2IKBmsEhIRK7U68fo9W+/Dk32P4ttD38ObEyeQ1Is7SCWz+hC+PDGU2iYaUa01wqtVw61VwoNqRFGNaqe1Q9hutxkEZ7fTnincRf1TdUt/MCqew+n5+RyxVtOthFhajgRJcp1KEdYqPmDCtywE0d2bGrC9uw7nrvvEdBKPa9PRB5LlcO521PZyoglURyxl7Jqcw/JYxBMrt+smLbZpKyGqgWEYhmEYhmEYhlk/WIhlGIa5hVAFynwGRnMxK/W9M22vbKrz5hVB1azXRlc9fmznD+PJnnfiX8+8gcXELIail8vqcwA+BHSfcMxKTp37BvY37kWtfi88WmXOPhpcvK6sEEuOXrUA2HI6N1ZGIOTLiI3FkkahUwNC0TwCqaZhbHbZ1IZxubnFiHgen13G5o6agvtvFbGg6qBmIVbdh/g6hdNaCbGwTopgGIZhGIZhGIZhNggWYhmGYW5RIdYsuErMxZ2iighZTvtqOy0VTfj5h94npr09dRr/eOF/Y7Wc9Z2HA1exzX4YdVorYnoENVqTiEtQIxkoxkDidNoQjSdyhNhoWohVYwskNCmirBNPJIWb1Cqy4MxAytlqPrJmsVQeexJN5xbDhm2ZkY5Y9XiqYmvBjFgr12t60mqSBJT0g3Qf1rEaGcMwDMMwDMMwDFMSLMQyDMPcqpmxeZYx67PVFU7xTMPoi7efX92TQuLB1gOIJuP47OV/RVwvnLNajDiiuJR4xTDtrTcrcaDyUTj1Ljg0pyHXlkTZpbRQSeJoIC3EUpQAZataOWJpmuqIJUetXK/S48Sy4lgdnloSz60NxqJaZp1SHidqm/JazSIqib0EicrBtBBLma7m5eR+qKi7IKIJ1gGzCG0WZhmGYRiGYRiGYZiNh4VYhmGYWwg1I1a+bqjxGJYxF12i+c880GMQAguJrY/ub4fXXfjr/3D7IXiD3bg4No6+xjZM+oLw65MYTV7CpN4PXc0hKJNAbBlHFr6d2hfY8VTseeh6k+gbCZtSQwxFEhnhdWhyCVNzIRza0ZzTHrlkVRdtPJ5EIJgSX2urXAYhVhKOGvNzSSyV+bGiXxkhNmkQYqWo+t3jI0Lwff8jfaKol1oYrSxHrIWwvBbeVSkU306OWOozHRtXOjOXztsb5yZxcEdzzmeAYRiGYRiGYRjmdoSFWIZhmJvMk4e6MwKfGkdA7tjve7DHIPBZRRMQxYRVlaZa6/xYM06bExVaLRKJ1DbrtHbU2drxkfuew+eOv4llLGBZX8C8Pg4dK7NcJpHAt2e+hCo0YJP9AFr0PUgmE1iILCISMu4TuWLPpotmGdrQdSRiWaGR8mSXpBBb6RI5r2aoLTPklm2s8aC6wpURS+l5PqA4YnVdCIayEBq1M5cWao3ia35HrLoc9S0QjqG3tRoLSxE01pYvOFL7JCyr18DtKMR+480hsS/PP7ZZvL8xsSjEWCqU9o4DnTe7ewzDMAzDMAzDMKuGhViGYZibTJU3FS1AOEzRAR5X7td0vuzYtUbqvb50Rio5aWkYfktlNbrtezPLxW3LmIwPwZ+cxpxtEOFENlO1VAKYw/nEizg/+aJ4/8LrgNdegYZkD9ptO1CntQkxeHE55T7NiSZIZ8gS5FRdCkXhdNjyCtQRkyOWON0/i7pqN955oDMjlsp2adsp1ywV8sru34QvmBFajdmvyfzRBMpyQxSVMJV6fe6aD90tVTnLF6N/1I+Lg3N4dF97pkgbZeSqWGXrqswuhMR1RX0jMdhK7F9vzPutpcM5bn0JmWEYhmEYhmEYpjRYiGUYhrmFKEUA2yAdNtMXEsjotXDS1uYu11bdBIe/El223XjPg71wu+w4PXMen7vyb1iMpjJZV0IoEcQYLmMscRkabGjTtgrXbFgPCCdtk9YDm2YXoqkaTUDiKTlEK9yOgpm4VpAr9Xtvj6LJ5Ex1O+3C/UpCpT8dRSD6GEk5a2lbJABLDO5Yk1mY4g7MSIF5ZDqQcUCX6mKldYhZf1gRYo3bsIpAkND5PXJuIvP+nq1N6GuvsVyWjgEJ3GqW8bohTx0rsQzDMAzDMAzD3CGwEMswDHMLIUU41SV7sxyxhQpOSWqr3Di0sxnfOjYs3pNIRxxo3os9DTtw3ncZL1w+jcH4uVX1haIPJvSrmIhfzUxzoQI9tr2IXNsJt5YtvkVu0ERCh8dpL3ispMtV9Hdbk3DEEjLzVYXEZSHE6rpBcJXHyOGwZeIK1OnidQFHrEQW/Er1P9W+voK0ByEUL0cNfbTqg4rab2JuMYK+9tzlaP/pPLc3VuLB3a3YKG6WDjvhW8ZCIIpdvfU3qQcMwzAMwzAMw9xpsBDLMAxzC0FC5rsOdsFboPCWHLK93qhFqvLR01Il3KISVfh02p24t2UfJm/UYJv2CJJ6El0tlfA0zuHzl7+G+djcqvoXRRADybfEg3BpbjShDz3hp4QQSeJoIUdshceB5VAqS3ZTWw0u3JjLRBGoUQeE25l2qSZ1g8NVCpxOu024TqV7OFEgI9bKnCr7YVyufAny+vgizt+wytHNv85iOk+32HapeJoUKDeCzJm7Sfm2xy6mMiNYiGUYhmEYhmEYZq1gIZZhGOYWo6bCVXD+RowKJ3b21OHIuVBRB2+xOAUpHO/b3IRtXXUA2lEZ68TrA1dwI3ESs/oQkiss9qUS1SMYx2X8w+BlbLYdhD2xA7pWlXf5SkWIJWi4fSzdD/PQfrfTkdEEVaFSZrGS6EvQPLuWylrNJ4JaxQQE0xEH+Zaj9qhQ2eaOmoLXR8BC0BX9LqDELplyd9V8W0MbZQqiVGyLjseWDos8iwJIMTsTjYGbC+2D7SZk5pq5NubHwJgfTx7q2phoCIZhGIZhGIZh1hwWYhmGYW4zNkoUorzRB3a14q1L6WpSFtjtpfdFFWwdNjtqtGbc43gG9+2uxb+ffxsL+iRiznlMRsZW3ffrybdxffZtvDDnhitZjWqtCW7NixbbZnhRgwRJro6s6Gd28+YIsa6s0GooypXMOmLF/KQOeqmKqIWKdZnd0KoTVxV8KW5gcGIRLocNuzc15N1vr9vaSV3IXbtkcsTmy5Mt15h6ZiAV9VCuECvF7JVud62h82Ur4zpfL85d92WcyVVeFmIZhmEYhmEY5naEhViGYZjbjI2saO8pEJGgZtqmlrX+k5LpriKoqZEBXnsF2mxb0Yat2NFVjyvD80IUDSdCiFUP48zSUSzHgyvqfyQZAf23pM+K7d9InsrOHM++nDm3F224nyRXy3Zk/EIqmkB1xCYNx4FETGdOvi5KEjrrq92Yns86kOf8YeFwpbzgWLoYWSRqzHM1k8/4WqhYV6mFvcp1xK4Uin6gw3nzpc+N3e9S2ahifQzDMAzDMAzDrD1sqWAYhrnN2MhRyUWF2LQq9OzhTWLItBVZHTYraKnuU1mYbHNHbUZkIiHTpXlwf9ND+K+P/Ec82vhu1GntaNH64EH+uIGVcnrmPL619E+4lHgVQd2fX4glR6xuIcQ6tEzRLRJPDbECORmxeQqfVboNx8W3GMYLJ0bEa+mUDRcTYtPbfXRfOyqVgm/5XLhW/cknxBYSc9dSyJT9kQL+zRZC1UzgWwNWYhmGYRiGYRjmdoUdsQzDMLcZlA/50J62jIC5nriLCLH2tBOUhtXnRWZ95nPEuh1478ObxDTKwDRs32mHy+7EwYYH4V3clpn+7oNd8EWn8bnTL2MuOYoAVlf4SzKavCgeBAm+FGmw1f4A3K42S0csiZMknsrMzlfPpGy2+zY3ZpdJJBEIRsV+yjZkvIQqgpLo7XLYEY7m5sVS8TEiHMsvxJJgKcVSEmHVc1JIyzQLrPlE2/gKhVhz1EDR5U3b2WgZdno+CLfi7l6pAL1eqDc0yoUKrdVWulDhWf/vDoZhGIZhGIZhcmEhlmEY5jakraFiQ7ZDAiOJrfm25yghO9NKg9NM46vl0H5z/q105JqzaEm07aruwA77w4AduH9vPb4z/k2cmTmPWDJXyFwJYQQQ1gPwxUfgnpoC9D4x9F8VTxOJlKiqCstEVMl6vXDdh4VAFO+8rysTW0DirXB6KpoaCbUknoaNtbMMjthC0QSib2nR0NyfQhmxZuFzKRhF/+hCurBa/uVKJR7XYS9cf86AdMBmIjg2WAd94/xkycdOuqKpqxtVQGulBuFoLIFjF6fEtff+R/rWulsMwzAMwzAMw5QAC7EMwzBMQd738KaSMmLzkYkmUBSkfPKtOjSfcKUjARwmkYtEOlVsrHFX4qf3/BgSyQS+cOQClnQfJpynMBU2imorIYkEXh5/BQ68CfjfDT3qhi+5hGqtEROhCQSSCxicAm7EBtGgdaLO1obYXDXmkzHUaE2YW3SJ/RoYXcCurlrhbqXjlkgmDW5LEmKpGJcZOm5xKcTGEkIYtCrYRm3J9szHcXhqCe2NFZY5vlYC64UbczlCLPW34HFKC8xmLg7NYc+mhsy5LIbZgVqu7ji3GBbHqb2xssw1rfexmBD79TcGUeF24OkHerARFOtPseO6UkGdYRiGYRiGYZjVw0IswzAMs/I/IiU5YnOXyZf7aV5UZrOaHbEk+KntSkHYbrPDo1WJx/t23I95TODl89ewoE+l2hcPO2qrHJiNT2AiOIFSiSOKl2e/aT1zMfU0rl/GeOIyLs4r+7DkxT7vOxGb7hZCLDkT7XYdD+5ux4kr01gOxcRyXrfdMuKBBDQZTUDHjVyxMubAuBwJu6nlhEitHOL5pQgGRv3Yq0QmZNYrUdgj928+JueCOHohJXrT0Pcn7svmBQ9NLsFPjuB7O0vajtQJM9dImcKjjId4/6N9loJ1IaTzWEUvQbgMRkpzYfuXo/AHIuhprS6rX4b+sI7KMAzDMAzDMLctLMQyDMMwK6ac4diqgJRPS8obTaA4LR/c3ZoRaCVWAqbT4cDOmq24YrOjHdsz0w/vbUNTrQfLoTi+/fYAfPooPE0+vD11Vrhf15qIHsKJ4DehBTW8/Eo1IokIdCQwMXIPnt7xJI6eTuXi0j5ZOYxJuFUFQnJ7WgmxMr/WLFKrIqAVpTokVacqDXG/f1cLpuaCGJpaEvED6nbMQvtCICL2oxRXrOyPfF6p7hiKxFFZZhaqlRC7lgbSl06OiueOpsqS3ORW3OziZQzDMAzDMAzDrBwWYhmGYZiyocxYckFaDUU3YxX1WVflFs/7tjTmFWKfe7QvIyjKomCE1ZBzcyYq4XDYLAVJGkZOAjL13al50KZtxfN7nsY2+2EcnXwL08kbCMCH9SiytJxYzIqZk2+LhxMetNm24JFQbY7zl4jEkkYhNk9OrIwmsDoWxGKwPCGWBD/1+FHRMbXoUzAcF4KsFdFYrqBJrt58QqwqLtJr6pMsDiZn0bRwNIEKT2n/dAkEY2sjxBZQYtV+n+qfEe5f9botZb1yWemq5WxzZiEkCuc9sKtlw7JvGYZhGIZhGOZugIVYhmEYpmwe2tNWsrCTkaSU5cn9+fxjm3OXVUREQ/RAEcHXSvjKt4p0z5rnVzursMV+SDxEm9Uz6I+fwI3FIawnMYQxkryAPzl6EVsrd6FNv09EKxgcsYoISmJkPgcpPfIJZyTg0sOddhmb17fKIrWrQqzpfBfSGsklWyz7VUU39ec7x0cQjhqH+18ZWcCV4Xk8fk8HGmo8KEYgFEMrsGohtlB0g7pPJMJaHTcrisTtrouIW46z9/VzqciOmYVw0cKAdMzevjqN3ZsaUFNRRlU2hmEYhmEYhrkLYZsDwzAMsyKKuf4kzfVe8VyTdsEW/KNUXqSnJbLIlHn4/jMP9ODQzpZMwarc/hvf72neid8++Et4/+bvg5a3vNjaOmb7ly/i9fhncS1xAgk9nsqEjSUyxboIs0ApxUB6DicjWMYCYknrzFK/hSvWLDRKl7MaN2CVEUur5Rtef3FwrrwIBGUWCZnqPtJxIUiEJa6OLFg3oeuYmg9m3i+ls3fXMyPWap/yiayqgLrSglurWVddjwqazS6EVi360vG6PDyPSV8wrzuaYRiGYRiGYZgs7IhlGIZh1hVyyrU3VKKxtriLsdziSlbs6WsQDzMkzHY1Vxne7+1rtOxXa0MFNnfUCLH2mU3vwu6GHfiXky9Ac8SQiAP+5AyWMQ87nNjuPYBnth7Gdy+eRV9zM5aWgKnQJAaTpxFGrjO0GEnEcT15QjyIo1eq4dXr0GTvQmWiGRcWxnAxughfaA4jgXHMh/xwoxLuOTfmEzNCujz5Zi12Ox5FJboNbS8tR9FS5y0oJm7pqEX/6ALiySTcsOd1tNJ7ctfGQ6XZOwsJsapImOOc1YHlcMxQeMyKcV8Qxy9N5RWsS0F1Hlv1rRSXb77l1biGmxNNkFvQzMqVXg7fems4E1nB0bUMwzAMwzAMUxwWYhmGYZh1hcTVUkRYczSBiswF7W4xVpt/572dq/Kqbu2qzZnWWOPB4T1thmndNZ3YZX8s5dwkbdJOTtK4cMo2V1ZiW3MHug+3CbctDet2RRvR69qNhfgsYs4lLCZnMRMbEQJuuQTiSwhgCTOJkdSE2dxlgvAjqCQWLET8eCPyDey0PYpu+97M9EWLgl1mgdSRzqlVXbhWoiOt5yyj4FTBaAKDI9Y6ZkAis2PNLJscsGYH73pkxFqJrvmWDynC8GoKgK04mmAtq45Z5AZzETGGYRiGYRiGKQ4LsQzDMMwtQ75oAhI4nz3cayjapRb9WhvKE6rsmsPg4pWRB/LZ63IhmWiG19kpnKOUzxoKpYTQbX1ujMWv4pWxN4Roul5cTh7BpD6AffYnUWmvzinYJQpjmXZbxg3ETUKmKrpJYa+QuFpMCCTHqs8fRmdzlbFYl1nwTRfvUtsxFxKjofZqLIHV9kohGs8thFaoGSuxN58jVs32Ne/P+OwyOpsr88Z9GIuZYUWsRCgtZxV2xDIMwzAMwzBMcViIZRiGYW4ZCkUTOB3GIlOl8uSh7vJEqDIttjJTVeJ12zMFyaRLk8TNRw514BuvXRPva9212NP1BJ7e9ATmwwv4yrVv4vjUKawHC/okXov/C5rQju2BR6HrHRnBjw6L+dhkhdis8EqvzZmrlC1L0yu9Tuzb3IijFybF9Nb6CoMoSoW1SCg1i7YvnRwT+bd11W44lAJjhVymdKxFUTJTQSw51N7Qv+T6OWIpuqHC7UCFx1nS8gQJ8Vb7eGFwDtfG/AhHGy0d2ublC0UlkOOZjr3MSd5IoZQdsQzDMAzDMAxTHBZiAbzyyiv40pe+hNOnT2Nubg4ulwu9vb14xzvegZ/8yZ9EQ0Nu1mApjI6O4u///u9x5MgRTE1NoaqqCjt27MAHPvABvPe9711RmwzDMHcypRYAK4cqb65YZkU5QpUUBMVrU59lkTCXMysu2m2ayJ2lZc0Oz3pPHX5qz49ie/1WfO7KvyKu57oy14LZ+ARm8QUsn72CrQ29SCQTmF+MYiSxALdWgUatG16tOhtNoAixZwZmc4b+0z7QMnVeN1rTBdnM+035wHT831oM5wiUJMLKdpJagYxYZZrTYROCJjlRi6UirJkQa7owaJ8v3EgVI3tsf4fF8sX7ox4LGRehxi/ktKksX+g6vTbux9DkkshCNherW0mRr3LWWE0BMoZhGIZhGIa5W7irhdh4PI7f//3fx9e+9jXD9FgshosXL4rH5z//efz1X/817r333rLaPnv2LH7qp34Ky8vLmWnz8/M4evSoeHz729/G//gf/wMOx119ChiGYW5LyDUaTSbyOGJT3+tuxcFLQixxYFsTTl6dQbOpYBbxcMf9uKd5D14YfgWvDb2NEBaL9sMOBypQKwQzHUlRQKwYZ3xnxSMfYyO7Ua/fg3ii2VAIy0pYFIKoXTMI6KpzmY6N3HcpRN6YWEQ0LcJmogZs+cVQWk1qfJRJG0GiJJF1JUKsZfEt0zS1WBi5gostn5m+iniBZLI052k4ksi7TL5p6rkjN62VGF0KrMMyDMMwDMMwTHHuahXwL/7iLzIi7Lvf/W787M/+LPr6+jAzMyNcsp/85Cfh8/nwC7/wC/jqV7+K1tbWktqdnJzERz7yESHCbtq0CX/wB3+A/fv3i7b++Z//WYi73/nOd8T2f+/3fm+d95JhGOb24WYOb5ZD8sl1WXRZm4ZonlzbploPNnfUoK2xEkNTS6ll0gv1tFaLRz4qnRV4bst7oI/vEO/v3daMN65eRwwRtDU7MBOaxfTiEiq0WtRprXDBC00z9jdYMYg3F7+DpL4yQe3iwkX6fxy/7EbFNQ8aPPVwavXwJFuEa1Zm49LwfBIX1VgBwm1yAst9l0IkuWvN4qdD8V6ac1pTObZZR6xcpxgJVb0sESsR1ez0pJiFQsvnu4YNubBWomgB/6m6v4U+IrIgmNXhsZ5mjHh483wqXqKkjZlgPyzDMAzDMAzDFOeuFWIpKoBEUeJ973sf/vt//++ZefX19di+fTseeugh/MiP/AgWFhbwt3/7t/ijP/qjktr+u7/7O+F+rampwac//Wm0tLSI6RRx8F/+y38REQX/+I//KOb9+I//OLq6utZpLxmGYW4vZDEuyt/caHb01Ilh5zt76osuqxYNM0cTkKC7f0sTlsPZoeY2k1hZjMfv6RBD1UnIpLgAL6rRW1mPDk8vBpYLF/fa5N6Fe+/pwv97+n9hNUSTEUQjkXQxsUHDvHZtO5r8PQjrAQSClXDOdCKuO+HQnHA5FUesluuINZMqvlXAEasUBZNCbCmFuKwKaa1IiE3qOHF5GqMzATz/2GYsBFISPOXDluKgzfQnjxBbShpHqRmxsiBYqQIxadWFIh70db6JQp83EuoLZUMzDMMwDMMwzJ1Eeb8M7yBeeOEFEU1A/OZv/qblMvv27cOTTz4pXr/88ssltbu4uIgvfvGL4vWHP/zhjAir8iu/8itCpKUIhC9/+cur2AuGYZg7i9pKF+7f2YLH7snN3lxvSEC9Z2sT3K7yioJpZkusnK5U/ZJiZKlQgStyzjoUdy6Jv2b3qeTQjhbUV7vF62gsiV0N2/FXT3wUT/W8E3Wu4sJyuUzoV3Eu8QL6k0fx5sL38Hfn/lkUBBtNXBRuYQnpaxlHbD6BUnG8ElZD4xPpvFoZe6CKmv5ANipApRSxNmedPFEDJMLK10FFYLfahlVcgblty74V6G4pjlgSNWXkg6XomscRu1aspKmvvzGIV0/nFlpjGIZhGIZhmDuVu1aInZ6ehsfjQVNTEzo7O/MuR0W75PKlcOzYMUQikUzcgRWVlZU4fPhwRhBmGIZhsnRaFBq61VCFrnxuPnWyOUe2VFThlYpoqcKsZN/mRnS1VKGjqVK8l2KcTbPh+a3fj//26B/gTw//AR5qPwRtHf/sxxHBpeSr+OiF/4LJ5IA4RsLtqDhi8wmdhRyxYpoUYtP2zVfPjIsiV5TX+tKpMcv+mIuiqZEFC/nE2yJD+mnd5XA8c5wp79Zqf2gfgunl1OkSdX9VwT4fhnXzKLbSDZtvP/Qy3LsyN7YccXWlsSL5zgXDMAzDMAzD3InctUIsuWDPnDkjimYVYmhoSDzX1taW1O6lS5fEMxXh2rlzZ97ldu3aJZ6vXr2KaFQmDTIMwzC3KlSJXqJKTvlSB1SBtlxHrMTgiLXZhBibs0xanHSl3aIRCyGz0VuPD+/6IH5x+69ii+1+7KrdgwNVj2C//SnUa+2i6NdaQm7ZV+KfwrfGvo7p0FRGGI1buV3Valx5hNh4whhNQKLfyf4ZLIey7tRSc2LPXZvDy6fGMOsPlZ0RS+IqOU9TfUoa8mKzywPnb/jw0qlRw/aLZ8TmJ5+IqxKKxMvKuk21lUeILTJ/NURiCXz3+Aim53MLwDEMwzAMwzDMnc6tbTnaACivtVCO7EsvvSReHzx4sKT2xsZSzpy2tjbY7fmHt3Z0pIbdJhIJUdyrp6enzJ4zDMMwG8mhnS3CKTgyvWQQw9RiRyrqZLuFgFoKTrtRzDUX5iKkONtS7xXP+zc35m1vc3MrNt84iK7KKpFhOx+JoNW2BU21XswsBDGjDyJUPYDp0CyQtCEciyOMVMGxcokhjFNzJ8WjRduM1ugziCdyC5WRaEi6YUyPIIEYYnFnzjJSwFULqdFxJ1HPChKnSSglkdfc2sTcsnj2B6Jiv819seqfxL9c/MYpOU/nFiNCUA5FEtC0BALBmFGIVbejZYuUxeKJTPxCvriDfHECqiPWSkC1Wu07x0fw6L52NNUZj4NeYFskPkfjSbQ1VGAl0LGga8+3eGs5YcdmAhj3BXFoR3PGEcwwDMMwDMMwa81dL8Tmg37EUHEuGTPwYz/2YyUdUCrSVYqDtro6+2PU7y9ceIVhGIa5Nci4X9VognwZsWvgiFWLgpGYa9fzO2IpzoGKSRWClqmrdmNqPmhw7NJL6m+L1ofn73u3QXR76fQQ/Po0+vE6FhNzK9qPaf06/mX0f+KIvxexeAWqtEa027bBqbkxHBjGqzdewFg8dSPTseTEJtu9qNXa4NEq4UFVxoVqEGLtGsJ5hFhaTgqxNPTd7bRn4i6kcG4Zk1Bk2lKwsANXxihQoTWCBMdTV2cRjsZF7m8hUXTSF8Q3jw7j/Y/2rd4RW+K+EReH5vG4WYhNL6uuQtPGZpZx4koqqmlHCUXtrJCiMonOtwp0bI5fns7cyCg3J/pWZ2YhJNzcvW25N0IYhmEYhmGYjYWF2Dz82Z/9WaZA13vf+1489NBDJR1QKdy63amiKfmgfFrzOmtJfX3FHe3okMIHPTc0pHIRGYavK2a9qa0JwOuPwON2QE+rsrW1XsvvIRICvV5XqmCVpq3o+4qERGqDaGqoFE5F+V7S2FiJhvrS3Ynbextw7ppPvPam3ZcVFS54IylhTO1jRZUbVVcrUYU+PNC8D4vxebw9eRqz8REx32OrQm9TA96aeguxpDET1YrBpVTcD+3IleQRVGg1CA4Zc1bjiGEg+ZZxxVS6AU7eaIQXTehx7oGjohMz8TnMOaYQ1UNI6HE0ObpQbWtEXY0XWIqgusaLb74xKNb90ad3iOeqKrc4d5WV7pzz4fE4c7ImaDmvN/V3OhxPnVMSsxeWrP92JzQt1Q6Jvk4HNLtNrBOKpdYVfaj2ZLZN07ze7LGT00n4lH/Hl5V1q5V11b+FDpcjs0xNTe41ORuI5lw7cvtqX1TUbY1NB3BheCGzzPDMcs7ypVzfoUTqmnZ7XJn1b/bf8Ulfdl+qa72o8ua6sm9nvn1iVDwf2NVa0r8N+d9YzHrB1xbD1xVzu8DfV8x6wkKsCfrh89GPfhSf+tSnxPvt27fjT//0T0s+oIXiCDYSh8XQxjsR+kGx0iG/DMPXFVMubY2VuDbmR0dzJW6MpwREGkquOlfV7yf5jziav5LvK/qTIttwuRxiFLvZgetxOSy3n4/OlmpcuGF0tuow9lXidTuV7dvx2PbtWPaTYPWAmPbw/g5saq/B0MIT+MsXP4uJ2LWy9i+o5xa7KoQvTAKyD6OxK0jrq0akNppOU7h8bCsWghQnoGHk9WpE4hFMLSwilojj+BUP+nzt8Nhd8EeWsBgJYM4fEf8OqLTVocnRiUZHJ3TUZI7B3FJEOGsba72iWJgVJNDK5cmJaOWYJi1MHmcyu6rL0HRyi3711evYt7UJU76giMOQy6SuI+P5phgEcutm2rFYRlMKpxlnZPuSOz/bTt71FUq9DqkdulFhdc3dDELRRKYvZNi92f1ZazL7Bi3joC8F/jcWs17wtcXwdcXcLvD3FbMesBCrQEWz/uN//I/46le/Kt5v2bIF//iP/4jKytKdGl6vtySXazgctnTHrhXxOOXS3bkCJf2ooP2jH8z5qj4zDF9XzFrT1VKFdx/qRqXHiWujqVgZ+h5KpIfOq8jvJ+GIta38+0quo0EXzlpzG9S+1fbzUVPpymmD1pfTctrSU0O3Sb6prXThB9+5BV98cUDMqvY6xfJd1R14rueDGJ1eQssWHz51+gtIoLhDdr25Op/qJzE9YZy3GAQmhlNxCGbmEhMYiaWKb05O3IdNycOwaakbnM31XiGI5zuXPn/27/vwpHW+LkU+vPDWEO7f3Sb+Xqtt0fGcXwyLqAF6Hpo0OYbjicw5kn8Lv37kuhh6nl0mmXMeaZpVn+WyIqvXND+eyG5LvUbyUcp1SKIxtUOZtvmuOXKCn7w8je09daitKjzCaC2IxbJ9iUTjSCTuLEes3LdwJAabVnzf+N9YzHrB1xbD1xVzu8DfV4zKWt+kZyE2zcLCAn7lV34Fx48fF+/37NmD//W//hcaGhrKOqA1NTXiORAIFFxucTH7w6q+fmU5a4WYv8OrEdMwRnKW0Y+LuXThFYbh64rZCOjPsN8fRCiUckRGQtG830O0DA15plzSlX5fye0s+sMia1a+lwQWw4iFYytq89COFpH52dRZg7Gp1N8lcx+jUSqglRTr0LxEMvWaWFoKIRlLCYC7u2uxrb0aHlcPRpy1WNRnsVh1HpcWLuN25rz/JK7iErpsu9Fi24w+vQrBYCTnPJgzasl5qOa2GtrsnxHPvvmguC5C6UxZMc0XwPjssmjfvxjK2Y5/MZw5R/JvIYmw6nILC0FUuYz/YPT7c9sibEhdl+RQzdmWP5TZFv27otA+E4Wub7puFpaiIj+X2lnQsteheT0qnHWufxpXBn34/od6UQ5Lwaj4nFSk4yHMDIz6MTS1hCfu68zkJM8p++abW4YtWfqNjZvByaszIvv4Xfd1lbS83LepmYC4mVIM/jcWs17wtcXwdcXcLvD3FaPS3Ly2OfssxJJjZXgYP/dzP4fBwdQ4x8ceewwf//jHy3LCSjZt2iSeJyYmDPluZmi+OAEOB5qbm1dzDhmGYZgNRv1ub6zNP6qBxCDyoumZOvQrx2G3jjZYSTzLO+/tFEIOOXzpMbsQyrus3WZDDMlMwTG1yJdDyVOl5eyK+FejNeH5HT+B+cQU/s/JlxDQfVjQp6Dj1ha5rIgihOvJt8VjfKwXre5ujMQn4dBcqNPa0aZtgaYp+17pEk7TUHpwDBV/ikQThrvq5AKleANzYah4QkcwLeBa6YHSWU3ieD6sCnPJAlw509NuSSu3qzpJtvng7lYcu5gO7TVBwvMrp8dx345mtJgKgL19ZUYIzN0tVeJ9tFCxrvQ1FjUVYyMR1eu2o7O5KlMMjaIi1Gvye2+n8lDzFa47fyOVjxyLJTPHXnXkysJwtzLDU9ZO62LcSgXSGIZhGIZh7lbueiG2v78fP/mTP4m5uVRe3gc/+EH85//8n4VAuhIoU1bGHAwMDGDbtm2Wy128eFE8b926FS5XcXcCwzAMc+ug1nOijNZ81FW5ML8cw0KgsJOwFEhwVQWnuiq3EFOlQFoOtC49StquzPFUMkolDkfhbZP411vTjZ32RzPvZ/QhjCTPYUn3UTItWj1t2F6/BeGZJtRUeDC2PIaQvogp/ToW9VQl+1uJ4eCQeAh0YBQXMaZdxC77O1Cp1YnJ5Dr0KxmyXpfDIMSqwp86XQqBMmbASjylSW9dnsKkL4gff88ueBXnZ3tjJSZ8y5ZCbL5YATm5mHhLcQFSRH54bxveOD+Ze2ymlhCOxnG6fxZP399tmEciLBFKF4UjITQfVtc09UWKqCTE0jH67vERdDRV4oFdrTn9LYZ6cyRuiIa4c+OOCon3TBYR06HrZeXpMgzDMAzDlMpdLcSOjIzgp3/6pzMi7K//+q/jl37pl1bV5gMPPCByYkOhEF588UVLITYYDOLo0aMZ9y3DMAxze0GCaHOdF00F3LBET2s15q/PoaXeuybblCJopdeJx+5pF6LReueBS8etlZCnCsMq3S3VosCUx238Zwb1tUXbhBbbJvS11+DGxCK6G6vR1liB47NT2NJUh0TYg80dNbg2dkCss7OnHpeH58Xrh++tw6dPfBeL+gyqHbWoSDbCg2pEEMSyPoc5fRx+3ejWtMGOGmcdwvEIonoITrjh0aqR0GMIYXFNsmzn9Qm8Ef+s2NYW2yHsdr0LoUjW6epx24FAKm+sWM6qiAhIO2JjebKHSYSVRabc6RsB5DSl642EWCs9Mp8EJwVYa/dt7nKkkeYb9k8Fw4hSLkkr4VditT5lylq5O6XAq4rFpaDuryq+ltPG7QYLsaXx3RMj4jOYz1XNMAzDMAyzGu5aITYWi+E3fuM3MDOTymn7gz/4A/zUT/3UqtulOIOnnnpKFPyiQl/ve9/70NHRYVjmr/7qr0RGrNPpxE/8xE+sepsMwzDMxkKC4iP72osu19ZQge6OWtRUusty66k8fk+HyNWUgut7H94khCoRBbABhi3pTrQSqPKJwPdub8I9WxstHWVupx3veahXCHEkxFKmJw0xJ2qq3HjfI5vEkP1rY6liaGobjRV12GK/P7Nt3Zbbp/c90ovzEzfw1sAI+uo7EPA7cc/WJnQ1V+HNC5OiUBY5Vmn4vygcpSdwYGsL6mpt+M7bN2CrmcXpwBvwR41FskohiQT6k8fw8f5jsMMhYgtI9J1crsRyQkeVXocqNGWcs1aQk1ZGE1gJZ+ppoGtKLkPHSQrjVmJvvutPLmvpolWmyeXoust33kdnUvn4hXRYK3E5X59U5DUi0U3zqICeOcpAbC+ezHGTm/ctfotFE1AfLg7OYVtXnYheuNWEWDp284uRgrEstzP5sp0ZhmEYhmHWgrtWiP3c5z6H8+fPi9fvec978IEPfADLy4WLqKiZsd/3fd8nnvfv348///M/Nyz3W7/1W3jhhRdEAbAf//Efx+///u/j/vvvx/z8PD71qU+JbRMf/vCH0dbWtg57xzAMw9wqVFe4hBNypUOeG2o84iFZj+Gy5LCVTlYzJLyZh28Xg0Qvm5Jde9/2ZlFgSBaykssQFK+QXS+9rjI0Xc3ApXnSbZtPWLTb7Oit7cYNmw3OJMUvpOIbaLvVFU4hxLqcdtRVuzE0uQSbZhcClcdeCY9Wha01nfjggXdhcnkK3xp8CSemTq8o15actj59RCiGYzLSM92MFzXose2DQ3OiQesS25WcuDxdUDhT95vyZKWwKYTY9HGzjiYo5ogtLN7K+eIcFYnDMAu1qrhptU+Tc0Ehvm/vTgnUVpeajGuQfaEMXgndqBBCrKltWuc7x4extbMWezc3GuapNxbU17eCENs/6sf18UWxXw/vLX7DZ6OF2PPX53B93C/ygikOg2EYhmEYhimdu1aIJUFU8s1vflM8inHlypXM6xs3bohnq0Jb7e3t+MQnPoFf/dVfxfj4OH7t134tZxkScn/3d393FXvAMAzDMGsDue7IpepKi6Qqnc2VmPWHRBTDSqEh8yS0DYz5RcZoMQFPdS86leVp/sEdzUJMNTskVeR+yDxSuU0pAgvhVcn2jcQSGUFSS4uMbZWt+Kk9P4K6uQcQ0OcwmryI2eSwiDNYLdTGleTrhmmt2hZstx82iLLWQmxKICWhl8RIKUhSMTd52KR+Sg5VEi3p+BdyxJL4aO2INS5HkAhbbizxcihWsGDU0QupvNltXbUpp7OyYcqcpXOlCrGvn5+Azx/OvJc3OVQhlvo7v5Rahq47EmLVGINkHvF1LaIJEsmkOAckMF8ZXhDu8Kba0j8/0tlbrC+FisJK1PNqFqpXCsVfEMshdo4yDMMwDMOUy10pxFIm7PDw8Lpug7Jfv/GNb+Dv/u7vcOTIEUxNTYmiXDt37sQP/dAP4Qd/8AfXPdePYRiGYUqFIgOs2NRWLTJuyXEoObynrfD4cwsyxZ4KqHjyz6I9jyNWks+RKbNLyfEqRTwpUqqiLgmcqugcjWWFSKvc2yqtIVVwzA583+EOnBy5huNDV3E1+SbWiin9GmbiQ8Ip22nbCQdcuBo+henEoFH8Hcm+fOllwOPwoEpvRmBpN+pr7zeIjNJdmxJi82/7m0eHUFWRWzhUFUQT6Qbo3BT794t59rziei7kyqRzYNc0g3j4rWPDePfBLuEOledHFWFF39L9jCnRBBTxMDwdyAjw/kAEb12ashRijY7Y1Qux1Gfaz8Yaj4jeODPgE/tQKrIPxdzvdJiK/VNS3c+1csRKQVfe2FgvSGi+NDQvIl7UUQEMwzAMwzC3M3elENvQ0GBwt66EUtbv7OzEn/zJn6xqOwzDMAxzMyHRTRVhidaGirLbqauimACgtUDhMitHrJUYZSXm7tvcKARHOV8tjCWXp1gDckfu39qYEfakI1aKjsXcniR89lZvwrTdi27bXiSar+LliVewFiQRx2DylHiUSjgeRhgjeHFqBEdmXkIvDqIv8TCu+4cwlbyOmeQNfPfFvxHLuuBFo9aFTfZ7hbisCpEkVBZ2xGbPUdFoAtP7ucXctq0gZyudbrMT9Htvj2Zei/NqEkvJgWp2fJ69Nov5pdR2nQ67OMfGfTMKsXQjgpaRba0GKXiSGKy+l+Ii9YuiMfIVu5N9KHTTQu6DrcgdEfVYxhLZY0CfDdr8SkwBCRmHsc5CLBV/uzqyIB5cOIthGIZhmDuFu1KIZRiGYRhmY+lprUKl1yFcgvmQklA6ljavECuFQHLkdTZVYXByEc313oxDj8Qll8OeccTKnNsKjwPPHt4kXnvdKZFMDgWXepVc1gpyBovtpztK+bJPdD0J5+wuLCSnMKn3Y1GfgV/POi83kmgyin68if7BN4FBi/kIYULvx0S8HxWoxT7Hk6jRciOWCmXECkesxbJUWKp/dCH1Ji3ukQBJbmTfotHBmo9wLIGZhZBlTIK5HyqZaALVERvInl9yP5ubNEcTuKQQuwaOWLVd0T9F3B2ZDoi85J099djZW1/EPb56oVPdT/maXLokbu/paxDnbcWssABhqaw2JoKE8JdOjorCiiuJVikl+oFhGIZhGKZcWIhlGIZhGGbdIUGjWE6m1Dyk0EpOXBkroCKdgiSe7d/SKIo8kciqQqJsOJo/3qCmwoX3PrwJr5+bEFmyUizTTNqXdNbeu60ZvW25xcykKFtna0UdWsXrJx5oxtmJazgzNAYHnNjb3Y4Tw1dxI3kacZTmDl1vgvDjWPxL4nWztgl1WjtssMOjVSKBGCJ6EHqoAweSDbBpNiEqhvWAKFymabkxFup50tJF2F4+NYbdmxpERiwVrSMBsBDnrvmEEEvL5sNKpM1EE6gZscpydC2Y1zMU60rocHvs4lyvR7Eual+KetKlO+MPYSeshVjZB6trXyVf7q9h2wYhNvUshXFymq5GiF1nHdZSdC+HwYlUpAfl9K5MiC0e/cAwDMMwDFMuLMQyDMMwDHNTqPQ6DYWc5FBtcgI+eagbbicJgLlijBRqPc6UeGYWYQk1A9aRZ4g3uW2pUNlCIJopPGQeLk7vk9DzClBWxcdq3dXYUbsdPluN6F9fTQtm7ZXotR1AQJtFJBmGvWIJby+9Bt3U9s1gRh8UDzP988ALL/+rYdqpo5V4d8/jSOrdQqCVGNybGoSgSlwemhfPFW5HUSFWxkUUWy7fUPlIzFpEJSHW7K4kYXYxGMXCUkSI8CTu0/WwFsW6VOj6oP6FowkhTutl5ilTkbLXzo6L6I2OpkrTPpTpiJUF6coNeM7XtoUSSyJysWzbUlkrUXyln7FSoh8YhmEYhmHKhYVYhmEYhmFuCu++r0uIJF97PSUCqsOAq7wyl9aY7ak6Yt0u6wJjhNOpiIQFhKFN7TUYn13G1fSwerMQK9+qopMq66gFi2jdXZtSLsemOi/62muEizYUiWf2rxrNqLYBm+pq8H8d+n4sRQPoX7iOF4ZexkhgHOXQ6G7GcjyAcCIlem4EgdgyvnLtm5n3Gmwi3qAu/CR0vRKaZpSu4smEcNGS4F0MOpahFRiGpXCpRhMUE/VIoHxRyZ4l8ZCuq1LFv1g8IUTS2nT2cT7cDhuCiSReOT0uojJKKTol4xFot/zLEXH9UKGx9z/aZ7g+Lw3OY2dvHTwuR2mOWJNwKt/O+kM4e82HB3e35uRBm1GPj1mHnV4I4c3zk3jivk7hOF8tsVUKsaW6Wem6IaeyOft6vR2/DMMwDMPcnbAQyzAMwzDMTSHlbNUKCidSRO1qrsqul17QU0CIpYzYTBsFih4113qEoCudueZCVPK9KmLJRWg9VYjdt6VRiK+yj/dsbRKvI9GEpVBMjtJadw0OtR4QD19oHlfm+0WhrfG5RSRjTtRqLWjTtorc2XFcgdthR1N8O2ptrdjd1yTiGb438CauxF7HcnwZGw2JrNS3Lwx/Rryv1zpQt1yHyrgLQ/ExBPRZIbYfn6iBN9GIZtsmUSgsqccRRwwOuMU+kkhtdZxKgVzTV4bn82bRkuhqdlabRUm6RuhcqgW/CnFmwIfRmQDecaBTXIck5JFj1RwXQOcnGIln8oqlWFzIlSodvtRHtTkqXlVbmRU4KRuZcpfN8QJTc0Gc6p/FE/d2GhyxsiCdmWtji1hcjuJ0/6zIUy2EKnabjyF9hmj/A8HY2gixJZ6L1XL04hTmFsPiXNZXu8uKfmAYhmEYhikXFmIZhmEYhrklsCqMQ4KmuWJ6xhHrLCTEqsPmtYLb9LocGREwR4hN90lXNKG2hgps665Db2u1waFodtNKGms9QuChLNtjF1OFvHpaqnKX89bjYe8DeLjjAbxxfgLT81mnK2W4Njs6hbOURDMiHk+KofVbKvfgQzsP45uDL+CN0ZNiH7bVbkFysUkU5SLHahxRXE4cwZR+DevJvD6O+cg4zFG4S/FFLGER04kbOes44EKnbRc69V2o1LKi4pbOWlwb8xfd5vR8UIidhjbtNuzqrce56z4hGNKxUjFHEFCOMAmqc4uRgsIgxSe8cnosM21oagljMwEx75kHenKuSVWoJ/QS3JqybyScqv0kZ6wqxBIUeSDnUf/pen776owQTMd9y6hUYjvMOqx8K6MEfP7iRdVUodqsU8r3axXvsB55vVaQCCuPoVGI3ZDNMwzDMAxzl8FCLMMwDMMwtwSlpjHaSogmqFCGWBerfK46a82aLWVz0rDw9qYKQ3t7NjXktJNvMyR0kduOoKJfJAwXKkiV6kduY7RdVVCc9YcRiSWwuaMWVa5K/PC298MxuRedzVXCQUz9lrjgxX7HUwCewrw2jBn7VQyFBnArQCLxUPKMeBBdtj3osu1GlTflKC5nCDsJ1SSo1VS6hJBLBamoSFVcVqqS65jyZCnj1u10IJ4I5c05ffPCZEa0k5B4KZ2bJPiaRUizMFuKuCcFyFR72X5KV61ZiKU+vXpmXAjPO3rqDXEaxmJd1huX7aYcuHoZ0QTmqAN9TQVUeVzz3eAoTnq9EgVV8/5YZeAyDMMwDMOsFhZiGYZhGIa5JSjVSVeKI7a3rQrBcKykNtWMTbMjloabmx25+Sgm+Kb6VV1SW+Z+pNo3io4kONJyUiSm7ZOgSPpRoWHdbc4+/PSD70QsGcenX3sTCcTg0aoQ1UNY0CcR0YOIIYJqVyWuRc5hoxlNXhCP2dFt8CZ7UaO1wIGUsO6EJ+c4q/tKGad0XKorUsvTsilHrG5ZGEy9puxue0bcrPLmCrFmEVaNESDouJvFTrMjtlCOrVk8pSeZF0uEIrnrhiNxzC2lXLw3JpaEECuFS4ooaKj2FBUWVTdxMfFRjXgo5Iil2IamWk/B/NpiSEFXK+BoLwWKrPjO8RE8fX93weXMe3636bAkRI/7guKaopsYDMMwDMOsDyzEMgzDMAxzUyGxrJw8RilSFhJ5SJDcu7mxpPaMjtiViz6r1ItMbeU2RiKflcBa6XVCl9mjWkpMK1ToSOaTOm0O/NChB4WYSI5KmtyIrFhVV+nGPtc7EQhFxTmq8NhQ3TmD7428ionlrNt2vRhY6gdAD2OMwRbb/ai3tQtRlh52LXUd6HoStdV21FTWoqe1KnOt0LVldmkumYRYOm5S2CeHaLZYXGEMIiZFCWi5GbH53K6qKEzngAp/hc3tKcLu7EIIXx6eN7RHorG8VmSbUqimaAs13kLOz7SZdsCat1kI9TiaRVv5nlzCEyIWwYmnioifZkTshgaRMZt1xGLVpG7KJMX3ghk6fuY8XoKyje8mZhZCOJ520ZOjvtCIA4ZhGIZhVg4LsQzDMAzD3FSoyvrE7DLqqkor8EMZrcthGn5emlhWDE/aCblSIVYKyWvpoLNy1+ZzudJw/GBaiJXCYyFHrCpsmTNHVciNSUKj7Ivd5sDhjvvxUPsh/Mtrx7GsL4iCW0F9AU2Ndlyc6UcIS5n1SSSt1VqxpM8iguU1izG4knwdSGaFWQ+q4dTcomjYCzcSaPE24bD9fjzuOZwWpnOHy5MwZzwmWkZ4krmr5SKct8kE5pPjQsSjXF81q1hFdbq+cGJEPJPzmq5rtT3VcWtVjIxEY3kTQ4qo+YRLOV8+0/9HY0mD2FvMQV5KNEEoHXWwbDrGxaD1Xzw5mjkW8mZCKU7zUlgOpSIrcqDmdav9wV0FXQuStcr5ZRiGYRgmFxZiGYZhGIa5qZD7raan9CrrDTUe8Vgr1IiDqvSQ9nJw2DXE4oVdqOWiGvfInUYOzzfOT+btfzD9mkQrckGahZR3HezCjfFF3JhYtBS2aAi9WbxdCqaKgpmH1dP61VqTeEie3taNb88PYU4fR8weQF9DG5ZnqZiZXQicm7fF8C9nv45oMoJ6VwPs8SohnJKYG830fmXCbAA+w7jy6dAsvnL9m+Jhgx1JJFDvaIE94RUxDNTvDn0HqrVG+JKj8OkjiPibcbjqoFhfFm4jIXTCF0R7Y4UQakmoo7bIgUuvUwJ8ElGExXZOTL+NVydfgy/hy/Tl6kgP2pL3oc7WZux3IolLg3OIKYJsLJ5AUBFiaRvyPFJ0gpU4RtOkeEsC6+vnJnJiFwjKvM0IsYrCaM6dpWJlLc1J2O020c6p/hmRkywzc9VogmS+aAJlGbre+tprUAoUKaEir8eVioJmxy5dz1ZCbOrzkHsj5W7LiFX31/x6dDogvoesIlMYhmEYhikPFmIZhmEYhrmrkYWzKL+1UO5sPpz2lIi5llXepTOXRKJDO1sM86iyOz0m5lMOSVVYlWIpDQ9XqfI4MxEMVgZDKiY2OLGIgTF/zrzmOq8YtkyFwfJBwp2m2dCodYnh352eagxoqbbo/Y6GrTjkeE6Ii5vba3F9PLudgD6HyWQ/FvVZzOvjQuxcK2Rb8/HpzDTaxnDyrGG5oVng7YU3sVV/FHNBF+anbuB719/EWGgUXocXkWQoFRWA3IJZGQZzJ40EhzGCYbgTlWjSulGh1YloCPuyC2PLDUIUJrFaHIdQ3OAiTRUZSwliFJXgp2H7FkjBnAQzOk9WkNAunb6qsBlJi51SiKcCb/5wHI/f24Wj5ycwPLkkIga2d9eJ5dRicfmKW6ntnxmYRUdjZUnD3H2LqaxbiRR9yRUshW8VEq0pt7erJRVDYcYcs7AUtHbokraYsChWpt9lrlD1dKrn8MrwAq4Mz4s4D6sihQzDMAzDlAcLsQzDMAzD3NWQyPXMAz2GrNhyaKmvwODkIirca/fPKuk8k4XJiJ7WaiG0PrSnTWRwSiG21Pak0GLliKVjsK27LkeIpRzeTW3VeQU+idpPErCkgKjOkyIXRUrIXE6xba0BW+0PprZXGcfFxTOYSF5FELmi8HqyHF/GGXwbZ0a+bZgeiJc3xN4KimYY0y/nVIQiJ22PbR822e4VIqwUCylbNhVNoGduFuQXYov3j24wkOOU2sy4HamoW1pcp/Mci6faH58JiGcZiyCdqZRRe1nJqDU7RrOO2Fxn9fkbS9i/pRFOhz2z7ttXZtDbWiU+P8R8uuhYvjxau+m6PX55SqxDn9umOm9RITZfVIL8PNCxVte4y3RYQyaueuyk0K+6tRmGYRiGWTksxDIMwzAMc9dDOasrhQSm9qYKtFiIQat1xNrtWfHpvu3Nq+qvFELzDS+2ysfd3FGDCk/xuAZViFUFRPM+EOSwpGnJeK7S1d3QhPDyQfTZ7sP993rx9ZPnsaT7MJg8hTsRcuwOJk+Lx6vnbCJX12uvQlu8D92xLbgQHsBofAQTgVY06Pvg1ipz2jDHC1ghHakUu2DIiE2LrCRmLmXzLcSTuQjYkXMThjZzilulJ5gjOo5dmhJiLom9e/pSjkoShcdmAsKJK4VY6biWrnRVDKTX6XSEDLLvU/MhIcRS7i+tIgutmYViNVZBRV6dVMzL4Ii9y6IJ1N01HHv5vcGpBAzDMAyzJrAQyzAMwzAMswpI2GxNi0lr74i1LvZEWZfdrdXY0lWbvw3FdUpIbSVf7SPzpqiQ19bO2oKFvyQiQmFHC66MLAgHneo+dJgaJiGWMket2m2q9aB/JNVeV3UH2mxhtGErttkfhLc6gmv+QSHMziaHEcSCYV2P3Y1wwuiqvJ1IIokIgogkglhITONy9Fhm3sLiBBy4KAqAOeCEDQ5UaLVos22FV6su2rYUN7/91nAmioOQ50B1g8vLw5ZWPvNltEqhkrJk6ZzLxcxOVLmNVEE7XeTQUq6yOi/1OiXEyrXVdiKxJL7x5hC2dNaKzFqivsqN5VAMs/6UW/s7x7NFz6z6TUJrQUds0pgTa9ZhSTymaRWe0n4+XR1ZEI7dB3TE4FgAAIvGSURBVHe3Yj2h4zQ1HxRFDFdT2CxfRqyeXHkhQ4ZhGIZhcmEhlmEYhmEY5hZFdZqqkCjy6D0dIpvVPBRcQm5DNdc144jNI6io0zd3kODVIIQdl9MmiqN1NuW6MVUoq3PWHxaiHGV3ZvYhLbrJglNetz1T/MmM12X8pym5G2XxqSZvE0JLbvF6h/1h8bytqxbjC/M4vKsLVR4PlqIBnJ+9hMvz/bjuH8JcODuU/naHCpPN6kPZCTowkEyJte32LXi44wFokSoszFFer5b3OpJDzel6iKbFTzXDNePGTq9D2cFUsMwM6Zz+QAQvnRoT76mYU7GbC/2jflwcnBN5zKr4qjpc5XWqCqmykNe1MX9GiJW7GIokLN2rZkFYdWmryHZSQqy1I3Z6IYQ3zk0IQfup+7vzXr8qVDRvbqn0+JBSoWNOn3vp/KUc3qGpJZElXewcrMYRa5XRe+LKtHDqy76sJxRVQTEc9P3x6ulx3Lu9WeRXMwzDMMztBguxDMMwDMMwtxhSCDEP6y8GZd1SUSYqrkPC6InL07mO2DzrqkILaXDyPT0/fk9HSdu3MvBKQe/JQ93CAUntmfeLxL/9WxszTkkJrUPD6W9MLKKtsQIj00uG+eSQ3NOXEuaIalcVDnfcLx7Ea+eGcX1uHM2eZnjcTgz6hzCrDyOo+5FADDE9jCX4Sto3B1xwoQJurQIueBBHDAHdhxiicKMCHbYdovgWFSyjAlxhPQBv+zhOjF4VBcJ0rF0xNzMTiWv40sg18ZriDaq0erTZtqFD2wmbZssbRxGLSUes8pNAyxVv3zw/mbMuuT1JpDULvPmgc0zOTWJ2IWzhiE1mrv1FctgqYqBVvmvGgSsE5dxja3bEqrnFeTNiVTFSWWbSl+o33dgYn10Wec3FoIgG2gerQmOrQQrf0vk7PJ3K9F1tsUBVeDa4Y9PHzfzZvjQ0J264nL/uE7nVq4XOORWDo5s+ojhYMGYoVHi6fxajMwF0NFUiGInj5NUZ8X3HMAzDMLcbLMQyDMMwDMPcYshh1Pkcsfmg7Fh6kDCyELAepp9PlFNZqXAUs8h9le7BVN/S00yqzr4tjdjUVmNw8ErIrbmzt15kgJbbT7fDjVpbC9wOF5yaDQ22TjSgM2e57k1JXAtdgD+8hLk5oLeuTQz9X/AnoUETUQD1zgaD4EfiZaF8Vo9WhWc3Pw19cjsiehAz+iB0PYld7V0YDw/h1PwJRJOrLwRmJoYw5vUJzCcmcAmvokZrxuz8FlTpW0WfVCLxhBBIZXSB6ojVSnBmGt7nKSYmoWYzBb3S4l7UQoileS++PWpYl0Q4MxnnbCJpWUgq1xGbJ5pAzjdFEwxPLqGh2i2u32Akljk2JAaWJMRmHL7540DWgmJO99LbsRaxk3nal8uU8n1SCvKck8B8aSjlZFeF2Im5lBhOcRTm/q4V5LienAvi4b1tayqeMwzDMIwKC7EMwzAMwzC3GHIYdblCrIpZINnRUycEpf2bm/KuI6MOVqpBWDkXrfbBXGxMijxmR6yK05EVC7PrFe6PbJeOBQ2H9ymRCaqQ2lHRjoPdW4UA/rXXB9HlqRJZpUkt5TZURUMSaN51X6dwRkrBKB9ShCYXbZe2W7w+2NGJJ6vvw4f15zG+PIlXx97EifFzaUFNQwTLWEsW9Rmc8s/AhhPosu1Gr21/RpAl97TTae2YzecgXSkkjEpRT0YSkAOSoH0vJYvY3J4UBF85nXKJFnTE5okmkEosnXvVCUqCK727f2eLiD+gonU0LJ6cwLRcMeFT7iP1oxSxcno+CJ8/jB299XnbNufcqjcu8mX5rsgRq7QlJ2u2PELsOgqWqpt4I2TRmYWQeKy3eM4wtxOLy1HxHbYRESQMc7fAQizDMAzDMMwthhQ58hXrKgWzAEqux4d2Fx5CTEJoIrFy0cNqPat4hf1bGtDRVIFjF6fEeylUFRJ1rETaYq41OZuaJxcjZZ2Se3JkJgCXwy7yStXt0vGm40bDyq2gTEoqvkQCq6alHHrFoKxeVWSUxZ6o751V7fjRHT+IlsADYmg/LXtwfwW+ePZlkW9bpTUgiQQ8dQFcnb+GhJ7rGC6VJOIYTp4VDwfcouhX5UItHDYnpsdbEUpWQ4eOcLQKo/4qzISmENRD8KJmTdyBdE3LGwzy+qbjQmIbDau3ynktuD95lpfiXbLEYl26IuiamyQBgiA3dm2lGw01biGWLi1HUVuVtnfn6YMUfvP108y563OZomd7+hoslzGL1RTbkdm/fEKzBdQnOj5q1q16uKwKd+U4YsvYXjHynXtVEM1sPv2CrtVSePPCJOqq3NjVWy+2c3l4Ab2tVUJYNyPPWaniOcPcDbx4MutWZxhmbWAhlmEYhmEY5haFhLmVshKnWkr4TZQlvKlizn07mnH80rQhFsEcQyDdrdUVrmxf06JHoe1azSu2j5lh9uln2m5tFT3cmEoPdRbzFdGFlkll2VqfD7m/pbqVK9wO+OPZYfsui3OaLWhmQ1tlCw5WP46peLZ/zx/YjGAshE+/8TrOJV5Ydd5sHBHxCCcDIgx1anYwO9MPvPatr2TeelCFWq0N1VoDaiu82N/Zh7HrbuhlyvXksDVHOZDIR6KXVcZrMfLoqqI9cUNBURbp/OdzjMrJIiPWJO5Jpy49yMVN+aXE3FKkoBCrCstmQTjv/qSXV13bue2aXb7JgkIzXeM01H7/lkbD54eiHoanlvDs4d6M09zoiFX6lXG+AldHFsTNiPpqd8aNaxUnUi7q+Vf7Qftks+U64VPLFW+X2qJjQA8SYid8QZE/OzodEEXXzMTTO16qeM4wzM2BRibQSAi6MdreWLiQKMPcirAQyzAMwzAMc4uxd3PKEZfPGbdeQqx0nZYqQ+zsqUdfR03mfaXHiXu2NhmGiudzllWmnaGpvmanv/tgV0lV6YliuyjFJ6tjoYqvNgsHq5XQqk4r1THn9Tgy+akHtjVZCsqyXSnIWu1XhdOLVttmtNo+gqSeFEW43nWoHS6nDVPBaUwuT+Pi7DWcmTkvcmLXijACCOsDmKKLIgC8feUV2OFAi9YnBNoarQk1WgviiCKoLyCMZYR0P+xwodbWiio0iL6SCGsVPxCNpYTOcjGLZZVep8gPzQigyny6rmkbJCqaz5tcjkS46+PZ4mMEzaHCUNLJLLN0i/VXnV+K05eWoZiIYm2b56nxEfSa9mXWH0ZzrUdcZ+QGJSiWg1yhEhJhiUAojvpqKcRm21XFY/mS4hkGJ1PH57lH+xBKH5foGgixct9T21P2KaHDmf6aMH9uSjmuZuFatk3n9Kuv30BjjQeP7GvPcfmWKp4zhaEbctUVzlWN7GAYK+R32LWxRRZimdsSFmIZhmEYhmFuMSi/VC1UsxKoyNXBHS3CvVYqUhDMV9jIDP3IVgs9ie06bSWJpaqwogqcqlO2GMWcu9LhaLWY2ktVnCMhluILdIsoBFXQLSZ0dzanclh3dNdj0hfEo/vb0VTrtVxWuoYd8vgrQtChHbnXAQmbhMvuhMfhQG9Nt3g82H4QoehzuDh/Cdfmh3F+8gZ8ydz81NWSQBwTer94FCQJuOBFt20vPMEDQtQLYQluVMKhpYaGR+MJLIQDiOohuDTj8dnWVYcbE4sG56fMZ80RYj0OIcTSsXOajqHTnhLXr08sYmtnrZh2bdwvhvZL0W1hKSIeBvSs0Ohx2bOfj6SOl06NobXei92bGgo6PEvR9Gh5+ZlT9zVf7qxE/ZzSa8os7h9ZEOIiOVclFKegCrGSlEPZbelEzfRfiW5QBU7Zz0hsde5s0YbilFZF0NXm3pqFa/l9QftKu0t5sFbHU26X3LNSROzrqDYIitMLIdRVuuAyff/d7tCxGZxcQldzpWUud6nMLYbx6plxdDVXrfpvGcOYyWRXc4IIc5vCQizDMAzDMMwdSndLSgwsFelEXU2hJrMwUUrMQd5CSmv0Y83SEatMU18LR6woWJbr4rIVccTeu60ZtVUuIVDLbZIQXixbTzphZZtSCNrSWYuuAufQ6th6XW4cbD0gHh/cCVyZG8DnLn8NU+EJ3AyiCOFa8jiuLR63nP/dt7Kv3ZoXTt0Lj1aNJX0Wrw8DHd4uNMX3o1przIhlNoc9k+2aWTd93X3r2LAQIlVBz+N2CBfk+es+4YKkc3Lumq+os1kUbFOKUsnzRH3wByLiYSXEqgIgrT82E8BiMIae1irhut3eXWe4gSHdpcWF2GTenNalYCwTayDbk+5ucsnStaR+zmk75HK1zohVjkH6Q2Qlzkox99LgHHZZHAcSut++Oo39W5oKFvoxOGKVXTTES5i2XUp6gFm4LmZil997UuRXi/GJQodbmjJOzzfOTYhr6bF7OgxtUM7vyaszeGBXa05RwluZWX9IRE+0NVTi7LVZEefw0J7CmeKFCIRShRsnlAgYhlkr5PfSehYLZJj1hMcJMAzDMAzDMGU5YqXbjpy7ZkjkaaxNZWkShX4mbe5IiUOlChal5rLCJNpYaKpGUVVpltyTtP9WQ66LRRNQTAA5D8k5V07OrnTayXXk8S+2v6X8CN3RsBU/teVn8bDjQ+iz3Ys6rQ023JouvogeQgBzmNWHEMEygollDASu4Fj8i7icOILp5A1E4imR0XyvQBU2SVCiH+okuJJ41qRcj+TAVSk0DF0U3coUztMyx7uYC1QVTElMPH55WrgrhyaXcG3Mj1dOjxuWJwe2um6+jFJzETmZaUqQu1PuCy1HfZdCLRUbM7vlxfRIdroxIza3WJdBXDb178rIgmV/Lw/PY3o+hBdOjGSGEhcTYlXx1fA9lL7UZT9KuXVTbuSFFMGtrgk6dxJyXufL8z17zSfyK/Mdk1uVI2cnxLkaSsdPkLC/JnDeLrMOyO8gq7/tDHM7cPvcpmMYhmEYhmHWFXvaEVtsSPADu1owtxgxCK4qj+3vwDePDQlHXCFBct/mBmzuqCnoljP3L5EsPZNS7oW1I1Z5rQielOkqjwHFJNDw84Exf0HxVu3fSpBOS4kq/hWiVK2X9r9Sq8dW+4OZaTJntqk1gbBrChcHfXBrFdCdMVHIK5IMYzYxiMVE1hV4s6CIiZHkeYzgPM688W00eRuRiDrgSHrRoHWhzbYFuq0y50d6TYVLXF8kgkpEHEGJ4hAtJkU5OkcyQ9ks5paaESudqiSM0nT52ZBCJGUsL4djGdevmXjcKJCaneTSATs+syxuksj9NH+eSbQmMVEVgNUl1OMjVzXHQ4h2XHZxPOU0En6pD1TAi2Ie1P6RS/TALmuHpXo81W0bHbGasR8FziG5d88M+HK+VwqJ7jRPzqdncwYt9YXapZsmcr+sPu+ZIdO4TVkjh2E2BmJNmmNuEqVkMd8MCo12YZjbARZiGYZhGIZhmNQ/DDOO2MI/vig7sLWhYtUZbvRjvVQRVvYvVfaqNNRh5aXmvbY3VIicTaK20oWtXbUZIVYVRi2Lea3wR6FsKzMMPH38ixUtK/VHqCo0Z9dNtd3obsKmtj4ERobFe6/LJQRnOnaNVe9GyDGDo6Nn4bZ5sLevCYP+YZycPgedAmBvErOhVKwAMaMP4kryCF65DtRqLeiy7YYvqGE6MY2RBRsWRvrQru0wCIJm5FD9gteQTcs4l81u6WMXp4TrVg7/V52r6mvVZUiCo7xe5LbJGU5CbCyeLVKlDvU+f8Nn6JfZuU43Diibk5yaqlvTLEDK60wWIlOnmQVQGQGhiqqyvd7WaiHEDk0t4eyATxTzevr+Hhy9OInF5WjJec8xxWFcLCNWHqtC+tDIdMDSgVvo/pJBaBaiq25ZWM7rzl4rdPzJKUvF0FLt5wq4Zmh+/6hffH/S94t5Hp1n+k4sx1G/lpi3SsciEI6JmxpltZNu6NaU8ZhSuVXPn7xhw0Isc7vCQizDMAzDMAxjcGYWyqksFXLGkWBVbpxAIdoaK3Iq25c0fLGII1btIg1nl85C85B3tR1LcXeF+2peS+Zxmp2yOeutwaEVQ+7z9NvhsKGnqgc+uxcVbgfe1d0DdAP1rw7Ap4+K7NeAPockUsIkFeFqt21DjdaCsL6EadtVLMSz4uF649en4U9MAzKWMgBc7j+HGmcttiYfQ6Oty1KMban3Ynx22dKJKwU5Ek3peNN5J0FOQkLkhG9ZPDJCrOKIlVmZMj9UQmK71NmzQqw97+fPfN2rsQmSaq9TCLFmEiZxMFOAK6ELtzANo29vzDqK1fxd+RlS+yT3j46FM12cj0RYmTVKImy2GFhxVLE6XzSB+VrXy8ycpv0o5IhV16HjZSXEktOXxHJViD/VP4OOJipsZcPX3xjMxqHk+WwuhWK4ODgnHubs6OGpgGjvwDa6OVKDtYYyjckpLaMpLDEJqGeuzQqx+R0HOssq/KitgaOSHNvkHm9SCs+VA0VE0FdbrUWhOqY01POnuvhvNtm/7Te7JwyzMliIZRiGYRiGYQRUUX7CF8TezanCSKvh8J42UfG+ULGpctnb14jW+gq8eWGyzIIeufNU8dFcuOvRfe04PTArhF91XrGM2GLCaalIR6xapd2KUn8US2GNhLPve7AH84EI3jw/melzPlcROZDlPqlF2KiQWZPWgyZbjzjGQfhF7qxXSzkDJY+3PYqW9ji+feE0RoPDIvKgocaDAf91g6O2wlaFeDIhCnutB4sxP07hG9iPp9Fi68uZ73HZ8fDeNryRPiYZlGgCOt90vOlZHUqviqvE9EII80tZMTSguGANIqPyWoqAMnPZSoh1mq4tMVTetFxFOlbDcth92q1J15TcNk2TBanUgmE0nwTmRWXf1D6RICmPictmFPWWlbgDs/BJ7+320qMcrIp1WS0nIRH6wuCcuMbMjE4HhPiZDzVvN+U2zm3/8tA89m9pRNjkiCahksTYQkJvtt/559G1I57nQysSYukGDp23Co/Tct5Lp8bEjaX3PNSbtw3zd8HYTOoGBYnr5Qixa+GkfOHtEXFM3/vwpqKjA6x45fSYeC5WLPFugATt7xwfEcUFqVhgqajXK72+VYTP7IgbrWjBPopRKjaCh2E2GhZiGYZhGIZhGAH9gH/mgZ41ORo0vHbfGgi6KiT8NNVZ59KW+2NNZk7KdlXIQUUOMPPQdYMj1kqIXSP3Lzk0J+eCZcU2lOoeIkHVo4iqDpstb79puhRAqBCZFXRMKlGXV9TprGrHrioNDdFUPMBTe7qFKBZPxnB2eAJbWloQCicRikSRqJnApalhuOBBu20HKtqmcWL2BKbDU6s+BuRuPZP4NpqSPajQarGsLyCBOOxwYMRXj0eq7oGuG4V3kXsq3cnpY0TCtMxFlQ5HlTfOTRjeq45YFSvnJwnC+YpMBWMRLOmzItu3UqsDdcvs/FTFcgm5H6m9U1dnMTK9JEQtKRiqzldDsS5dxytnxg1FvtRtyUxbOr8OR+q40HGjNmQhK/M+yvfOEoqbWa5v8RmemgsaBBa6QUNtLYdynbhWkRSGvpmiF+R5V6HPJAnNlV7jT2iKjLg2noovUTpsuZ1SxNpikOt4aDKAe7c3GYTT0/10jgN48lB3zneHzBeWInpRTI7DUnOV13I/ZRv03bsSIfZOhM4DnZJynakkRhJ0M6IcIdZcuM92i6QfF3OeS45enILPH8bj93RY3qBhmJsFC7EMwzAMwzDMbUM5mXByUSunqmo2Laaf0nBkcj6qIoaVELvavDr5k/fQzpayHWglFTbJiInZnadjk6/bjXVeyCVdFsWjSj7+yrEiQWVHT70Q7a6NLSOR0ISw53G50F27B7HZbEGnB1sewL0Nh/D6xWEMJU/Dr89QWAA02BDU/QhT9kCZzOrDOXY9X2AEly+cRau2GdvtD8OjZV3cqiM2tS90RLLXwZh/BgF9XsQzfPKVKwjrAcQRFWKyR6vGctCL8cSoEHxbbJtRpdWn+hH04ejMFXxv+FWEYzFAt+HCcD20eDWcM9vQm2zCfGQBgWgQl+auYtA/IoRjyUtvAJX2aniSdUKYpaJlbmdLzv6SyzYSjQgRlqBjLaMKVK0sE8GQzgdWRVizUCuH5lPMsLwu5Px8wnNqG9aRJ6oQa8iIVcRRq0uUhFfV7VisyKAVcri16vhNFeayboviFmTRNhXVUSz6qxWPYbDqixS8TlyeFqMJ2hShWYqhR86mxP6+9mqDuEQiLLEQiOQIscUKzOVDfqeVmzCwljWerKIm7kbIof7i26PiBqeMQSmVlf5pUs+j+GyW/2fgphbrIhFWvXnEMLcKLMQyDMMwDMMwtw3lOIEObG0WDqCdPbkOIHMcQSFoyDcJsTTMUWL1A3CtHLEkVq6le0cOWW+pT4k6qpBEfbba/x299Wip84qcxXxuy1JR3WzO9GvaJuVqkquRqK5w5hxTEj/p4dTc2Gp/UAjTsj8kWoU947ix3I8JvT+TU7sapvTrmIpfz7yviTfj7HgFwnEdydHNeLz7IXG8onoY0/p1jCevwD9exK2rRM9Spm6lcOMu4rtncsWl8VDqWIyNXQZSo6oLN51YwjKW4NNHMIxzOH32m2jUulCjNaNWaxPFy9wOY74muXml2Km6HOPxpBA7RaG2Iiqa6og1O6VDBXJh8xUBVEVCoyCqRBbkaVO49NLXTakuORU53FrdLk3L5+gUwraSEZy/Xev1zXESVswshMVyozMBg9BMIpyhaJppGzLb2spRbTXNsn+m/ZbfDaU6YukGEsVdNNSsXS5rqX2/05mZT0VXULG3coXYlSqx6nlfyY2O9UJ+vkqO51nn/jBMubAQyzAMwzAMw9yRkABJ7lIrVNGvWJGtA1ubcPaar+iQzrXKiF1rmuu8eHR/O+rSRWtUYdRqyO/2nnrcu70Zc3PLokgXOWjrqsqrmi6dxITqzlOPNcUiRNICKg35NguxKZE4+76zqSojxNIP8K01O7CtZgc6mysxujyCF6+fEFm1FD1Qp7XBX30OF+YvYKUs6jOQta++NzqM742+LJytqjO1XJZ18xD2tYWKqNFD4vVVoFJvQrOtD25U4HujV3AifBpRPQhXvAIOuBDUFxCLRURcR02iGfc73wVdrxHvKbeXjimJ4dI9GlWKdZmd0rECIqWVI1YUHVPERcNrdVh0HhGIBGTzTYJyhsWTuETXpCoS0zRzITQJZayac4HztbtSd6cUays9TpGzTWLYlo7aHLexeRN0Lki0VIuJWTlxC4lYUpCWTctFShVDaSg4uampMNhaUchFvJ7RCLcaWRfoxm8z9frmHlO6NsXNOS17s+hWyaxlmHJhIZZhGIZhGIa561B/wGklCIoP7m41TLNyxK40mqCmMiVyNq1jhl1TrdfSuStfU64kDfVOWmSMfv9DPSXtm/yBTMLYrt569LalinflE3HVqAcSic2bkD+6M8tUu4Q4tZweNk/zDu5oTu2HvRc77MbtPLv9g/ji9S/i1Mw5rBWrEWFvBqFkECEMYzYxnJqgGHhjeiQnR9efnMYLi5/N214FauGccohIhLExLw6170uJthbOyaSeEG3aNYdF/msCsWQMS4GkEHjoOiO3LhXNiutRsR6Jo5SJO7BwA1eip7GcWEQ1GkXEg1uryAibLlPwrBSKS2FmISQcvmpUSapYVzLvzZZ8Im0p7l+j87ZwFXr6XjgzMCte91kU7yIRWoXcycth+lxZOGKVaa+cHhfZxu97eFPB/hGyfyTE0nGh9WrT31eFMBajS+LElWns6K5fUdyKKgLTjRhyzxfLjM0Xg3E7kxUfy/87U4oTu9A2U69x06Dz+fU3BkVUx0N72jIC8U3WhhlmxbAQyzAMwzAMw9x1qALfSn7Yktv23m3NYgju994eXXE7RHdLFTxux7oKsSpqP2VeLLlWye0XiiUtnKmlFcoRw9oTuogf6GuvMRQ/s0KKPps7arCzpz5TNV7tp8G5rGk4vLcNL5wYSW9P6aPFsfc4nfgPe38Cb04cx5f6v4ZwYu1cencrQfhFRK4fPkz5gYv+88JVa4NDOJEpG5eKioWQyqRVefHbDuxq3o758BzGlibFNBcq0KB1oM3RiWAiiv7hGQzFr0NHEi8PAaCHicvJIyLPt89+EOdmA2iorMLm2t4VOffeupRSpqmavLFIW34htRRRK9/6qkBLbTkLZC+TGC0JmjJo5frmaAKZY1vIVUoZsvkwO3ZVR+wpUQxsSRQyzCeoyns8at9IQCOm50J4/6N9ebedt09pIZb269Uz49jRXYedvams5VL3404g62Quf92Vxgrot0g0gSw2RwXzVIG45M86K7bWN0L11M1WZuNhIZZhGIZhGIa5rWitr0BVhVX99dJZiyGN0vG5WkhwpDzWm4Hqjs38qC3x2Ny3vRnXxvyor/ZgcHJRCLFaMpXrqkICr/psprulWrhorYRsdRK1KwTjtHuyWLwECVPU5sMdD+Bw+/24Mj+A1wYuYjEYEfmpjVq3EBbnKs7iyuIlg/B166Gh3dUDpwMYDg6LmAGKDAhh8WZ3TBQnA6Ii7qCYm/j8zEXDtCiCmNQHMBkaSE0o3EROnu/Rq9lpFEdB59SleVGJOtg1JxJ6DF6tBm5UFrxRsqwM+18KxkS2tMrBHS14+8p0yUP0rYbGU7TA9Yns+aK2CgqxyqasxFNanzJZx2eXsaOnLqM1yQxfEq1oGbrRYxVXYOXIlSKz2XGYcg6nBN7Us7UQK9uzEu1KzZnN2c90n2hfqM/kyi2Gun01R/h2JvP1vBJHrOl8TM8HcezSNN59XycqPM7Si3XdJMzfzeyIXT3fPJq6y6XmUDMbBwuxDMMwDMMwzG0FuSJXy0rdq3caauGucjMIG2s96GmtxtWRhfT6uhB2rdZ/z0O9OdPJhXhleF4MNTZvd1tXHSo9DoOzTp4zKaqo4qtZiKX3qpOX1t3ZsA2L1TUYj2QraJFg947eH4a7MoJPHPsM5pR81VLQYEOVvRbba3YgulglCmVRtmpAn8eCPomoHqJB9iJrVc1uVcXDXfbHsbm+E/fuqsfn3n4Ns9FJ7OhsQXdVB6LJGMbmFhCabcCulk5xzE9cmYRNSwl43d0aLodOYDY8j8XoEnyhOTHk/26Ejjc98kHnusXWh3bbDlRqxrznQDrugiDXpxkSM+k6j5ZQqIugiAUzL54cNYhZNyaWsKcv68QtJJ7JbGTDNhJJ0SbR1liRaZtEZVr+6IXUsehqrrTMWaV9IYG3taEifx/S66kuW1lwz4piedvlIBz2ST0jfsvvJ8qgLUuIpRzgWzS/uxyscnvp+7uUv2VmF/fpAV+6INxywexzVTy/mRmx5k2X7YhlcrJ2mZsLC7EMwzAMwzAMc5eiipWZH/olWmKlm1Z1m1F2o9WPPCs3LAkAqgigtiMFKmM0gXE5dZ7q7FWHaef2OXe61+VAY0UVDjreK3JThYCKEPoaWxGaq0IMEbRsWsDE8hRuzE0JN2611oQmrRf1Wht6WmvR114thk1n2tRq0IxeQzV7yj4N1l/A2zOn4HG40Ws7gPbkbiGkOBw2eB0e7K7ZjwnfVjzbtymzf1/uv44KLZ2ZK4Tu1LGsrnDhnu4OHLRnh3tTpuq5iRt49epFISpP6zcsj8PdyDIWcCN5SjxatS3Ya383bFrqegiGi2f/Uj7scijXWWqFpSPUNK1/dEG46tVidobl9cJCrOrOFQXH0u3TkONXTo8ZBFcrJ+/r5yeEo/bxezpy5pHwen18MSf+QOxbAfFrLfUd+i6JJhOZPsjjYRXTkNNHpd90XAoYj28b1CJrVAztpVNj4nuSblqVez3G4omC35PZbeZvYyMxu6n1dF9K7RLLtSnoe+Abbw6KUSilZlUz6wMLsQzDMAzDMAyzCh7Y1briYbc3GxKXVhpNIEXNtJYlfrRTka5iP+7zoVmoOIaiaiYnrCG2wLRqvmI+6v5KvO6sSuPU3GjWUgJqX1UdrswvwA4n3tWzX0yj4klUyd64LS2TtSupcDsyghENPxfuNc2F9/Y+i5qFe7G3rxEXh+aQ1HRDf6kwHJ2HK0PzaKrziiJmkq7mKkOBs3cf7MrZFxIWOys70G3X0I096OzWcXTwghimv6WlGcPTS/BolXDBi0V9FkkkhIvXgyrMOgZwLXYCSwl/dt/gEtEDNLSfxGnKbr0TmNKvYTp+A01aD9xaJbzBauFOppxb2ucA5hDRg+J1ldaQEftL/ZyXOoybhvznFWKVNuYWwznzzS7XfEIZFbezEmJJhFWjDMycvTZbtF9m1lLQkTdXzI5YUdQtkcTcUgRvnJvAD7xrG5rqUq5eOj/nrvngUXIvb+aQ+nIg8ZviJHpbqy2PYzaaAJiaD2Vc1SsTYlPHtFjRM9VxmrylHLFy+u1xbtcC+u6/MryA3Zvqi563Qm2YXf90LVA0ELOxsBDLMAzDMAzDMKugo6nytjt+HpdD/PBXXaXZaILCYgo5MZeC0YxQIp/1VebmWrnpDPEDJiFW/QluFi4ceax5VtPpWFjhtPhxaiXkkptVdeRSIaMDW5uEY02sY9Owo6deCG5ZcSlhEIhkRAQJuMSVkQVcG1/MuBVpfYolmEoXqymE6mhu8bQIUZZ4rK8bLy2MZUSYZs143W5y7cYDLQdxbXxevJfOW3mtuBw2+BNzCCYCQrx0NU/i0sIFTIdmDdvOl7Vrh0NEOaQyZUuntaIFFeFukSc7lryEtYJE5Rl9sCS73KWjLdjqOASv3l3iUPDCjT68tw1vnJ/ErD9sKGxXSGiVQ/Uz8xVxlT67NI8+m+QGVV2jlE1bKNu2XO20kLC5llmssq2sEGssXkaxJsS1UX9GiKV9pRsllUruqTqMndZT55UKOZKpQGO+nGsrEskkAsGYKFZI/aKoFXntTPiW4fOHMTDmx6GdLeImy6mrs5iaD4roh87mqvyOWHI5px2t9JksBAnW9J2jXo/q+SsmUqvi680UtM3blt8xxXpEx/tOEWvpJiDlQdP5LBRpUgirQoNRFmJvCizEMgzDMAzDMMxdBrkprYYdE8W0FBIH1Zy5jPiyyh+8ViKOKirK2RnhV/lxbl7X7FDNTJfisd2W+VGaLy/PSuSwEthIOFGFWHKoedKCqhRZySlMkIBNhE3Fk2R/e1qrhEORhq3TMfalnZDStWvlGjZTX+PGprYa0ZYqyJEzl1zMMaTOnVncoGNIQpMUYCXy0JILq97WBK+ecuC9o2svPrjrWbxw+hqG/KPoqm5HaDm13wk9Ls7d4T0dcDnsePXMKCoqPGK78UQcwVAYbfU1eHBPM4LxEK7M3sDLVy+g3lONymg3drR1YHDSj02dHuzqasO33xoW7e60PYoZ2wA8dcsYmplDBMuI6aljRIXX1suxOxWcxhT+HV5Uo89+EB3admjSCl6CA9F8rFvqK4RoSkPMJaHEMkaTFzGXHIdb86IqVAtnsgrVWoOIumio9mDWn3JCEurnl8Qm2iYVsqPP9pdfu56ZR5mxVsW6SoWupdoqlxCCxL4U+JiXo8N+7+1RIW4e3tNWUASUQqx6DEN5oiSku1cVseW5GPcFcfzSFA5saxL7VCrRdNQD3Uh58lC34XhLZ6LV8O6jF6aE45mKGp68OoOdPfXYmf4eOHZxKrPcpcF5IcTKnOKF5Sg6mwtlxGqIpbOKC40+kPEF92xtEqKw1XVTLG5Anb3RQiwdU8plbq7zGr6jj1+eFq5ouUxpbeG2R+ZTW+U9l4rVDRnx3ZDHlU+MzS6jttKV17nPrAwWYhmGYRiGYRjmLoN+wJt/xJOTc2YxgupKV1nrSgFitT92rZyGaqSrFFvlYqqIQALUvs2NOHfdZ5kZa94GiaOJAtrUju46y+GaLfVeTPiCQkCSw8XJJatuj94b82ttOa+lkGB26pJYSm6nuiqXEByk+EWRBWL9EpQu2jaJTWI7vmxhMtpn6by1OlfUtHpeSTgioWNkZjkjFmvKilIcqXBUoNHWLXJ25xIRUUzJrqX7S0XTREGhbLsk9FJUAh1fh82BGlc19jfvwdi1KtS53ViIRUQ/KGbBAS9Op4+BXLdV34Gnt3bjO/Mjhv73tntxcqwfMYSFOEvOW6c3ipb6SlzxXcNkKH8hr1IJYQkXEy/jCo5gs+0QXJoHs8mRlLMWGhxwol5rhzdZiYUrVehfuI650DyQdIhIiErUo8HWgYEFDXaHhsCyjstz/fjqtW9haEnZHzrMimZSo7Vgd2wf3I4WOGM14jqOxEyO2HSxPDPL4bhhWTPFBDb6bG1qqxaFvYYml9bMEUs3JeSNCSvkpUZuUroO1T3IlxMbTk+Pq27hdH+p/0T/qL8sIVbeNKF+SM5dn8P1cb8QZklsPXvNh6fv7858TknspOnEdDpG4Nq4PyPEqsjvMYpTINE83zHJZsSmXIxEoSHl5KgnhqaWMk572bdSz70xmgAlQ85eEu/yjTYohVAkgUtD8+Kh5hiPzQSU/pXWVqmCLX2nXxicw0O7V18Q9FbEsmhfAbc8Cbd084J4/rHN69q3uw0WYhmGYRiGYRiGwf4tjSAfY1drdVnuJym9rNZ0ZBlNoBbrshmnmTMLt3TWigJDlImZL0NPruGw2RCBtRL76L52kc9qlcvZ3liJtoYKXBycz8wXjlglsoDEUlVANsxL76TZEWvuLzkmaQg17QshBZ5yR36rTjIS76Tz1kqYoPkGITYtGo3OLmdFVcWhLJuW4jY9P3WoS/yw/+bRofQ61sXbCHVb8pxKsUy6keeWwlhIF6qq9DqFUEVYnd8KlweNNmNubl9jjXAELgaj+Jfj38PVxJtCqF0tCcTRnzyaMz2KOKb067QABseMc6J6EIuYwUTiKi6cfDk763Tx7S3q0zjq/5547UE12mxbsDl4AHZ4xLkcWhrC2fAbSMbDiI7sRW1lL/zLsUwupJotnLMvRT7rJN7TuSXXphBiC4haBUzCBtTrj2I66AaEGbkdisUg4dUQTVDEEav2MSN0pkVLeQ3Rvlwense77uu03L7EfNOEIBGWeOFEVjwf9y1jS0eteE35tRL5mbWKWEj1L2mYv7BkLcTK00SfFblsoa8DKQSTIBqOJCyPneqUtULtaql/E+g7683zk0L8ffqBHqyUuNK3fJdcMYGVjo9ehmD75oXJTEGre3e14tCuW0+QLTf8gz4L5MDuaa22jiYo8N1wu2bf3w6wEMswDMMwDMPclbzrYNeaZhquN+udd0fiVktDZVpYK2M7mWQCfc0dseo0+VqKmYWEgXyOWNlHEpf2bm5EvVIMSyJ/quZzm1E/1ObpuBkcsOb3as5t+nWOI9YkLJJI+eShLnzlyA3x3pt2lpU7PNheYnZuar+shzrLfRH7oRZIMxVNk8OzzfurbvOJg904OzCD4VDUcL2Yzxfl7hJShJVCWkaIteinlTgr26U+dNh2oE3biq27onh99BSuzg+I3NnbjTCWMJg8jcHIafTY9ok4g+Tl9PUUBb7Yn4ol2FazHQ2x7fAEewt+NgvlxxIULaFeB4WEWzVKpBBqG0vBGBpqLIRYZRnKU1WvTeGItehGyMIpK9tRt0n7fKp/RryenAuhuyU3k7WQEGvF3GIEW9LGTdWRay6Gli+2Qi6XLzJGPYdSWC90LmR7FKeiiprkkM7Xl0LbVEU5yqqmwmJ08878vS2vp3yu5VIx5NrmuX5L/ZNTqqCofm9fHpy/JYXYcqHvTDpf9KBRI+U4Ym+XQne3IyzEMgzDMAzDMHclNRWFh+DfalABKCke3Eqsp5RtFU0gBUCr34hZobWwI5bEg62dKfdavjYK5S+qLk/pGFTnafmiCdLuWLO4Y1UEjNp4bH+HcHPKvsjtSodsMcxu1KZaj8idpbw/dai1WNbkiM32I9uWZfE0GU1hsU0R06C8b2+qxI20m1B1aZo1+FSkQTbH1ywY0DbJIUvPcih3ISFWngOKNqAYhDZHH94ITCKux9Bc78LVuUEsOUcRiAUQTAZQozWiq6USk8FpDC0aIxBuJYaT5/LO61+8CuCqiENosvXAA8qbbUSt1mrIAS4mxHrS+cSZz53pgze7EML1iUWRhVrsZgytm8oJzm6Tru+GGk/mPTnNSWintuR1SmItRadIKP7C6iaaWfQU20z3Sd0mFbuqq3ILBzYV96JM5kM7WlBjEctidq9TwSQrSCyWqNtSxWFyoFoJs7S8dCbmEw2llkr7TS7h1LR8y+qZc0HD0VXBlWID1OUKka+wFzlHpWu+nAJm5UBO6cy2TcfkHQc68eqZ8ZIF1lKXK6UQ30qh64Cyrsmhn69AXyHyFUEshnqTy+qzHluFW55ZOSzEMgzDMAzDMMxtQG9btXic7p9FY21WuLjprNGPV6uffEZHLIzCn8WPa/m70UrYNKxToMtyESlKWomear/MAqDZ3an2hfpOD7MwQPEGVtB5Vs81iVH0Q57iEUrB3JcdvfVC9CK3msyfzexTnn5knMgiCzc3TiCbEZzaJ7MbWF2H2L+1CdOzAezelK38LWIN7u/Gd4+PZNow5/hu7qgx9PmpQ90ZcYOwdPNmirOZTrjMCtacqPFUodnWi721u4R7jIQ/Oqfv3b1JLLMUDeCF4VfE43ZkGfNYTs4bptVpbeiz3SdE2UKxBeqQfishlgTBI+cmxGu6saFe1rQ83eyScRNSFHTb7AaBR70hQNcQCWzymqB8WppPApIhmiASR5Unt3iQFChV5LbiisOSCh9RzjP1TUaMkCBLny0V2qbaP2r/rXRmphk6jvS5pmtX3b+QIrySG1V1y6rrmkVUsygovzNocmafkknxGaDPmergVwU32h65S+nGBQm+qpAcL+qILV+UU3t9bcwvImNWgroP5q96ilug+JKi+mp6cEepztl8MSprgYyKoBzzlQixK/1zqxfJiI2wI/amwEIswzAMwzAMw9xGyEJMtwrr+NvVIOpJYYKKWZGjbW9fY35HbJ5OySH+1RYVoEnIIFeaKvhSMR6ZV2rol9K+WQCU4qd085m7QqJgMm5UBvIJx2boGJTzI96sP9A+tTZUiHzM3MYp49PKmZvN1TWIyund1gq4zmSxLnre3lOXEbYf2dees6wqAtN+yhxfEo4f2t0qjjMJeyTOWR17q7iCbF+N+6U6baXQSOKrFNVVAbvaVYUf2PosdnsfxL/3vyyiAMLIFgwqBLlQK7RauD3AYnwey7H8UQg22JFEAu3aNvTZ7xM5tNPJG8KpOxuZxlqyoE/iVOLfxevXhp2wwyn66YBLFBsjB22VlhLKZcGlTCSIYYh6SlwS05O6YR5FGnS3VhmE2O8cH8H7Ht5kEEXV/FLVLUqfZem2JAFJNk1OaXKUW90goQJP+aMJsuec2jNfr+S6Na937NKUGNJdqH21v/T9QcdLHVZvcHXHEpauRPUYiG1T4TWT4ib7LwqzyX1K6OJGBOVJ040Mdf8kJL6SiErfY+QCVotdFXXEKsfI8saXxfrqJBId6fuGvgvLRXXAq9sRN7PSow7yObDNQnapsTnrmVQkz0m+m27rhbrrVtdeoWtAPf90HeUbacKUDwuxDMMwDMMwDMPcdGoqnKKgSFeBvEaCBJiH9+YKeeoPR1mUykxfR434EW+VCUmVuUemA2ip82am5RMQVIHYnCUrBSsSPUiINUcA0I9Z8w/i9fqBK/tiFq2snF+0TyRQU0X5juZKw3TZllksVZ+ttA5RrEvT8L5H+tDQkG3TClVIpe6RI5ZwOW2ZY2x2gquCqdo32j8SGGTfzMPY5XrVQth1ZMR7KyFWUuPxCoF0k+1e7NxpF1mtRy7eEI5TNwUAaB344MP34cWrpzA440NXRS8QSe3zA9ta0dFUiengDM7OXsTV+WsYXZoQgmJ3VTfcoQ60apsNkQFim/Zm3Lf1WTQ22HHBdxlf6v8aAjHrofErJYGYeFAxMWJWHxKFyKrRhF77fgwsRrGjYWvmhgIdVxJlFpejIuZC/eypwo2IsjCLiUJQ1Q3ipMwSpWNx4opRcE45o+nzknKbEm6HDcFEMuczRP2ycvdKnUkVR2ldWp6E/Ef3d+DswCzml8JC7JQO7umFkEGEFX0s4h4mIVkIsXmKYNF2rdqgG0vqdUury8uZjhe5Xq2ybukcELKoHxE3HRt6nSBh12bPuUGVz+VK7mCz49RKsLMSOM3TRORCmUIs7Ze6D+p1JW8G0aVl1fsrw/O4NDSPZx7oyd4kKtHNu56Z8fL6W/F3vWkXyMk96w9je3fqBlc+1H2nY2oekWF1bKjoZWONO2ddFmLXDhZiGYZhGIZhGIZZMWuVq0ftUM7kaigWTWAr4Cgl0XVXb31J21FH25sdsVLkbKn3YnQmkCl2pC4fypoEBev1A5eExgd2tRryNUUfLQ4PnUY6B2bHtVyUjqkqOsv9lG1ZiTL5iqaV4n6WrbkLVLQ3RkQYXcpWRZbIOUg013mxf0sT2hsrMhXuSbyXbVgJ1VKUp212VXWIYzt0xShYVzg92F6zC/G5OdhiGpLpvfCkXbwtFc14sucd4kHiGUUxbG2uxcBoKjfXCjqGlc4KPNB2H/Y37cbfn/s0Ls/3Wy7b4elGa3UdTs3kz44tlSXM4nziRZw/m3IFv6fnadoDIeJcGV4Quarmz54hmkCzFraoAB2J0pJwWogdGPcbclZFGyT+O1I3LmTbdA2SeGsuakXnu5BrU12ehF0SIal/NMy9IZ2dHAzHxXnNF3NgVQyswu3ApvYaXBycy1xzcsi/FFbVSASr65KmS3c27Rsd4/M3fFhYiorc2uvj/ow7WBV5za5eytt98e1RcX2bhe7mWm/ODSorwZiOk4wAUaMarETbG5NL6GurRoUSE2EW9qbnQ+KzI787SNymG1737Wi2vD5IBKbtSyc2fd7MjtjMdIvzTSIsod4kWM9oAjpPk76gGD0hoZtvV0cWsHtTfWY/pCO2kHNfnPfrc+hprRI38gohIzxoWfqMmCNgJOpngj5HtGxVhTPzWTMfQ7ruz15LnX915AIJ6qVmkzPF4SPJMAzDMAzDMMyKoaxForW+tNzS9URP/2CnYe3riSog5HNbkuuWxILW+qwokm9oajmCZbmoolchwSGfoJ5xldq0jKAopqefyaU6NLVkEH8KbacUaJNSfDE7jvNBYjaJVuSmk8O61V169vCmbJyCponMWcKTriJPIqwUxK2OhRRxCSl6UM4tCXBiHSlMW2SpqsdNIoU1K2Eu3zH0ODz45QP/AV+98BrOzFxESF+ES6tAe3UzKpZ7cbh7l3DILUaX8NLIEZycPI/ZyOoL/FFO7ucH/lUU/tKWn0ADerL74bILMfWs7wxe9x+DPz4HNypQh0bM+bqh611wa9nvhpgewY2ZlKvXATfC0ZSgJt2aJBzJwkR0GqQQKwUjeeNDZq3GklH8+9UX8dK1o5iI+YS71wWPiFtotm1CX/Ad6EW1IQ6B2gvHwwgjhKSeFGKqFFqlECvPy8N720S2K4mDUjRWoZtHUniV0QrS8UvCFeUOq85Xq1xW6Yj1uB0pITapC6FsMRjDrD8V/yCdtIWyWmUOqXxWqa9x5xYKU46JZCF9Y4JQNTo1KkDSP7KAwYlF8dmSmIW9y8PzmPGHROFBtdDXtu46IYJbCbGqEE7Xv6FJTXmyOBT0GRZxDMq+lRpNsJKvK3kTReYDE6PTAQxPLYnCaO95sFdMkw5f9YaRGTrnJLrTMXju0T7LZcy7Mj4bFMLp4b1tln+D1cuFxGASgg/vaRPXwksnR3OEc/Vzos4rlCXLlA8LsQzDMAzDMAzDrBjK7aQq1tUV5ecArjXZaIJ1DPsrMoRVHbJvFYFgVVRqo4d8WvU/3y7J6SQ+qvmscj8pToIEUCtRZcX9U5yEVsfLClqO4iVIdHnx5Fiqj0rpoHztUN8ph7ap1oPxdIar1XBdVRCVwjmJnlT8iHJQ5WxVVKdjRIXVSGCzOufkUJSORfO+SOHGLNLbNBv21h8A5rMOvM31NbgeWsz0scZVjee2vAd7PQ/jxLURxLUg7DULOO47WnK+rRUUw/Cd2X8Vrxu1bizr80jEo4jpUSBVZ00Qo63E5jA61S/OAQm4LZ42jIYHEYU63F9DjdaEwVN1CEeTmInNIoQl6Ejte+V4FTqcW9Cp7cFr0ydxOd4Pj98FLe4Vgitl3X73ktFFS4SQEj8DyTn83eBJYDA1vUPbAY9WjWujixgMXhOZvJeOt+P7Ot5LR1oIYeSo3Lu1DiOBEYT0JKq8PRm9z6rYEQlb8uzSuqf6Z9DWWJER2xeDQQThhxc1wvlq5eLMOGLTny9ahqapEQ6FxFN5s8JcCIy2LwXchmoPpueNUQt0ndONi9MDs3hwV6v4fKtOUhErIPc93bZZ1MyJiLDQPM1OZ5gKetH+buuqM8QtSOj6V4+Z/EyLaAKLYymFWOGAFt9R8moqn6HJRXQ1F47KkXz1yA0xmoCiXeTfHxLzpUArj2Whm4RyPwsJx+brRwrXo9PLlkKs2RFLUS90jKq8ttT3rKk9Q2yB8jpa5IYRUx4sxDIMwzAMwzAMsyrMQ99vNuuZ9UdYFbV6eF87gkpWYz6sBMH1Fo4L9V8WKct3zLJCrJYpbGWm2DDasvtHlefLFNWpfzl5tVrpAq7MBS3FQaf2KVPcLX1MVeF0S2eNZVE5VSij4fC5+2JDLC0fWQ05NrvqpIvNLNo21XmFG/Xw9t5UfuniVoRscxiPXRdC5pI+izk9JVqXi09PK69FzIbkbg1gDoHwnOXcRX0GiwvWrt3lRAD9iTPoxxlSVwV+o05XFuP6lVR/FT1yLDCBf7z6v4SH9+h1OzxaFT7/Vlq5BXD6eBW2Vm/FVDyIsxNBzMfmhJhcgVp4tRq4p/fhodb7My5OX3IEp6fPYynpQ9gXMAiIbw550eHpgZaoRoPWhTpbqyHyIOOSjkexFF3GbHIci/oU4oiJ4mkkJCeSuRKOdMmqbkbpyJVCLN0oMQuitN7bV2fgD0RwbdwvHN5q0TI1e5ZcuxQpULTAl8V8OTxfRX7GqKAXQUKslUitm7OHpSNWRBPk/2yqURRypIQVFFNBWavtjZU5buPXz4zjsXs64CnxO+jCjTkhxKrHgMRx+o6VDutCjuZC6HmOrzyO+b6z1GNH+1qZHsFCiLxYk0ptKDSn7kee3GNmZbAQyzAMwzAMwzDMHcU667CWQ1hTRb5yh+cXc7+SK3K9heNC/VczF62Q00ngUB2xhaCYAqs8zXL6JwWHYseGcizJRaf2n8TVcLT8yAfpVsunldDwXxJt1HNoLgiWr4CYFW6nDfPKUHBz/0W7FvtgdtXlc8+S+Pa+RzYJMVcOoa61N6OvvkvkWhLkag3YpoWIl9TjGLWdQSC+hLsJEovJ7UuQOK0SiAVweu506o0iApPLNaj78fXBEXx98N9Rq7UgoM8hgXjebYSTQVwPXhbvr+E4VUoTMQ6OcReWsQAMp5b97lvW/byEV0HNt2pbUKnVo82WeibnLAluZseuvHYoboFem29qiJxcGQmRnqYKmBTJoAqKb5uKqVlhJabK+BrDchYfMrO7VvZRVydnPm/Woqb8bFKUQqZYVwHt861L0yLKgW6kWbUnbmB4S5PN5E0TtRn6XLmcQDgtiFsdH0kpCQrmLhZbR50vM2IlVjm7qgtbPUcrFZAZa1iIZRiGYRiGYRjmjmKl2aSlUmoV7lIcsYUyAzcm4zb1nK8XqiO21LxWtcjLao9xMTHVqvjag7tbMTDmF4VsykEW0pEZpWZo6K95+G/GEZsRrG0lR05IB2ROP5Rrwmr/zYKaFL2tsmilOKRl8nGBe7c145zNJ4rJkZD3A4f24zvHUw7X9257HPO2YQSiAVzzD+LU9DkkdB6WXAy/XlyktCKCoHiUw5R+TSin15MnUI0mtNq24BvXB3B68goi6bzZZq0XiPdA1+tEPIb5WqJrk8Q18/WlCm5z6ZgCWsZKJC31u9HqhoQ5K/fbbw1jT1+DZXuGaALFEVuoQKCavVzI4S6L9VH+r1XsQymuegk5omk/upRIGilsy+NnFTdhXtYKeQzMBdbkdHqmG1LHL0/joT2tmUxrs9CqngsR+2DOiM0jvq7mbx6TCwuxDMMwDMMwDMPcsrQ2VJRcbEWSz925VsghwCvJdpVCrMxBXe/CYsWEaieJgZF43mOWdXpunHOXjsv+LU0ib9OqCFgxqEr7AaXie6lIEacc0UEeE6togpULsdn1LB2xpnazQmyBn/d6dog8bffQzhYhxBKqwF7hdqGvfr94/XjXw3j/5nl8of8rODd7seC+MDeHJcxiKTmLgSHj9Hl9HFf9b6LO2YAm5xMIxPYark2Xw2a8zvX8zke6XshhqmY358Pqq5rapPgDdaiCWZCka/jE5emiAmXWwV9YYJWRDPn6RP1RC1DRMlZu1XK/82g/1CgE6jv1U+b3FnKWWgrBaeRxJ3ewut9qn6mg3FIwiv5Rf+b7z7xL6o1Aq4zYeD5HbIG+MeXDQizDMAzDMAzDMLcsVOG5VGSRo2JDwleLdExSBmO5yB/CJHzSb/yb7YitqXCmRIlYvHA0wTq7jFVIrOhtqxaPm3FcytH9s45Y5AqxRQqN5Yt6UMUSewlCrBSdrByxErlPVqdRbc/lMLbR6K3HL+z/KSHEfvb8NxHSA0jqNAA/YnAON7qa0IX92FG9F/fuqsVSNICXBt/EqenzOQXCqHBVu20bYhWTGAlkM2rtcKLN3QXEPFjWF7CgT6AUPFoltrkPoUPfLfKqJxbm0Y8jGI9fw93OQmwOn736JXzu6r9iV91uNOuH4NK84gaMyLTWjOebBNJKrxPbu+rEjRAS/ZxODcFIfrcmZUzT58DpsBuEvaZar8iZJRfnS6eMWcTlDHW3cormy4iVAq9aaIz6NOsPiYJl8saG7I967Rdyq5aD6iqlvtP2s45WfUWOWLkePasF1eThpmcZf+BVvgfMYrVBiLWId1AFV/VcysxuZm1gIZZhGIZhGIZhmDuCdxzoxPR8aN2Lh3W3VMEfiGJbV23Z68qq30Qqt/HmOmIpP5JYXLYuNKaZhsO/58HevEP3V8uhHS04c20WjTUe3AykqFqOA1sK1bIAmjEjVlu1I9YybsCiXdquVSE4s6iiOp8pwoEyMFWoqroV+5p2Y6KiCsG0+5Ycy5s7ajDlX8SrZ8awv6dNxEE4bHbUuKrF49neZ1E1fwAJPYbebhf6RxZFJqotLf699+AmnB0bxFs3BuBBFZpcrWirrxZOXToHrqYZjEUGMbOwDI+9AnV6B547cD9ePTMuio1psMFbZYNT96YcjYlU0TkSGh+pei/eeW+naOfNa/24MR6Ay+6Gty6AsdlFVGtNaG+oQqDiOr479PIdH79An9mLCxeopBR22B7BDlH4K/s9GUmGMRuaw2xsCoGkD1O+JfTHJ0TkQmw+jBqtGXVau4g8oDxcu5Ya+k78+9GUHff5xzYbXJR0TVoNfy/XYRmLWxXrso4QkSIoiZLyUh+dDmB4akkUBKNr9sjZrMAvhUj6fNDrjqZK0efZpVQg8EpGAaiCbixBbtjShvgXEmKly5bEc7X/Gaesrmc+yySI59ueenPIZhE5kc8RS68XAhG8fGoMD+1py8RdMCuDhViGYRiGYRiGYe4IaEg6PdYbGqZPRaJWS0O1WxRU2mhUp1NNevuUb1iKI7bUgl0rgbIV1XzFjUbuazlxiOuREavm41pFRjgsbK0US1AokkOKy+oiVCneDA1ZL0XAl9XXK5weODV3OsvTuEwmrkFzotHTiFHNeGBp/zqq2tCW3qTL4cysQ/uyo2YXnm67X+TXCsFIo2PmgE2zwYaUiOjW3EKOo/2j4y3XV9s50LUZ0xPD2NZZh6YaD+Jzk2JetaMKT2x+Bt+/6UkcH7mCc4OTcGtVcMIFJ7xobbGjpQUIRIN468q42G4d2uHWKlFdrcHeNI4Ls5exEPGLIenxOFCp1aFaa8SO2t1oq63BlVGfEJ/r6oErc9dR/f+3dx9wblTXHsePtldv87p3415wo4Pp3aGGElpCKCEYAqEFQngEAuEB4YWWQAo1YEICDoHQwYDpoRp3jLsN7t273qr3OXf3yqPRjKRdrawtv+/no8/K0mg0Gl2Pdv86c25ulqypWC/rg8ulMrhVOucXSppkytbaLbK1eqtIMF16ZPeVQE2uZEq2BCRdenTJlndXT5f6sFmrmm9+/fsyf8P75nrn2p6yrm6liGapzvYGleGP2RJcay7L5CuzXbul7yW90oab+3Tf6+RlM9bOli/XLpAVtRukXmqlpnq4lAZ6S2195JjS0PPrjd/IjNrXZU1wseRJkQxM30O6BgZIwDY09ggHnZPjebZBaAx4tUdsqNVI44Ibtu6QtFUBU6Xr/n9hK2gbWrBIi7Suadieeql19HV198YNe1y0tgWN22mrXt3bH3QEwM4vkiJaEzjbnnhUFdt9rfvZWS2r15euapjEb8HyTSaIramtk/nLNpnWJoN7F/tuOyIRxAIAAADALmIDIv2DuCUmtWqO7MaKKf1junNRjqlA1UoxLztPud/1lbu72s7wrgmPcQRDzp/xtCbwa21hK1v9WjN49Y2NFZDbTCVW/+Ro4XFYENv4hYcNuzQo0qo95+qd19Nclbj6hYluizP41XU5l9M8Tqv7dJwuX9PQ3sCGrTas1uDNbpe5z+N9yMvJkGP36WtCcmcFoN329LR0GVG+m6xaFl6JXZpdLENKS82p9csXhH9BkJOeI/v12k8O6rWf+feXC9bJklVbQvd3ysiV/MxcyQk0TAbVKatAuqXtJoXpWZKf3kf6y1hz+zHj+oZ69GolsPZJLczJkq31DRWZav+e3eXkoUfKk5++LWsq1prbtmQsk/XV6yRRJoRtohqpkrl1082lQMpkm6w3t38wM3y5VZu+MT9zA4WmHUWaZJgzArSS+b0Fq6SybuckZRrkzqx7Q+ZIphQESqUmWCXFga7SI22olNcN2LlSx5jyqlx3TmblPu1ev/jwq3avqqnfOSYcz2FDXA3aNawtKoh9toUzOK7RINYx5jQs1W1w/j/Uf2/eXh1WSfv18k1me+0xwI53d4WrfY3O1xU2yVa01gRePWIbH+vuB6zXnV9uqC+/WS8rG/tM66SJ0SryEY4gFgAAAAB2kZ6d82Xd5kIZ2KPpbQ1aioZ2R+7Zx5yGrgHrAbv38F02FT1iU6V7aZ5pOzGgCe9NqDVBILJtQKxexRoQeunTtdBMUtatzPv0X61+Hda3xAR4OkFPw23Rg1gb1Pi9jaWdcmTDlh1Rg1pnEJPXGCKHqojrG0IfZwAaFqoGwrfftsRwThSm+86Z99vHh01eFgiY/VpVX+dZKRx6H1wv1J6u7Qx+bTsJpdujVe7aekEr/pzr8Do93R2GuxfRGeydp2/bLzKqa8O3O6yCuHEl7up0vV3D4oG5w6VTVUOp6piBx0h6wTZ5f+kXsmzdJhnSpbfsWFcq24LrZWPwO9keWCeB7EpZ3RjcJosNYaPRyt9KaaimDPHpBKEtJzYHV5vrFcFN8m3dfNm0ZXfpFRxnKq/t3vKtiI1SVapBodeEXGEVsenh67XLfzx3tWzaWiWHTegd86wL5zZoCDtnw3yZXfuJZASyTMVvfbCfpDe+1xu3VplKUw3xndX0c5ZsMD9tEBurp251Y5BsttmxbNTJurQiNqJHbMN6dFiG9Yh1fMmiPzU4tiGs0mOHTqyJ+BDEAgAAAMAuosHL2EHlKd/f8U405hUwtuf3ZvyQLk16jN0rXgFgrInY/KpYdRXaqzKaIX1KZEvFzqrJWNVoGgpqlZ1fyHzA6O4xO//aoFDHjrsFgK1E9AtinfvFGT46tzvDnBYeiBrEmgnuMtJCE5Q5OStinVWNTs6g2R3WalXfynXbd97f+P7pY9wVgpHrbfhZXJhtKs71/XMGWXZdzsDM+Tjzehu3x92306tSW0O73oU95JCexfLBxlXSN6uTLAlskexAnpRJb9Ny5OCxPWXBpkXy4FePSFXdzrHS1nxTNUO+kRlSIKUypkYrkHs29IjVKmwzEdeOUF9pW7np9V7pbX7tn+14Mj1tHQvZ9WgIq/T/0LjB0Y/fNsysCG6WqctfkxVVixruCIosk5my+KP3ZI9uY2TxphWyfNMaUyHcNW2ApNdlyLbgBskJFEiPtCGSG2g4S0FfY7SxZyt2Q88fjFYRu/OY47WfbFsFvS+8NUG9+TJA6b7f1njsGdS72Hxxoe8BQWz8CGIBAAAAAJ40dNOAK8vxBzw8KmIbkz9nuBdrIjZn6HjIuF4y7fMVTdq1fkGnX8XrpH37+bYe0NcRK2q3wUxBbkbENtjenM6gM6y6NazyUzyDWA0rnY/3Crd1PTmZ6bK9MnJyuYbHNz42yuuwAZRXi4fwID28bUL0MGxn9ew+I7uZ6zpBVGhdjet1nxofFjz7vIfuU8IbHhe+jVu3hwettr/w4JKB8vNxF8uzC543oWxbtk02yHtbX5BZ70+XvfKPkmB9iSxZtdVUhWuFuP2SoTA301RseoWtfhXfziBWHDm4mQSusdJbf9rAU/v1zlk/X2bUvt0YpA6ULoH+UiXbZUXFN7K6drlsDH4rQcdEXda6Hevl5SVvhr+2ekdlcVBkUf1nkiV5Mve/xVKcXSTf1W6VqqC2cghIl7R+0jNtmAls3dsfsyLW8eWQbU3gbJUQ6hErO8e7/f+ys890QKobvyzQ1jZbt+ftkt7s7QlBLAAAAADA08CenaRP1wL6/8USOm3XuyI0Fg0Re5UXmD6hTa1WNs8VR+uIWJOHxVJelGMmQRrWt9TxvBIW4Hi1FnBfDwtWtdVARkPv1oYesZGPd1Zj6005PvtHX18o6IyyO2yoak8Pd9/nuZ0x9q9tM6EhoNdj/EJ5r3DVze6H8P67Df8ozMs0+2/9lh3hj3GsTCtnLx93kazdvl6e+ORtWVj/iQSdaWOjDMkyAV9ZYZ707lws5Zk9pFC6SGlhjrz0xWxZVj9LVgXnS13Qp6/ALqKTo71a9bR0DvSR4jXHm/d84eYl8un2RTK3drmkbw9KZU2lVEul1Eu9lAZ6yvD0A2XNxp3r0MfUyA6dUkzqpFpqqrKlJlgv1cFcyQzs7BW8ZXuVrN3+nayuW2wmKdtYsVVmfvWqzNvwtdTU76xCXV23sMVfZ7VUyIptevk2IrT9NjBHxsnxZnI4N68esSP7l5mw1nlssUNEl0l3faESlGBoPdoKRK+H/msFdrZy0D62e49o+OIB8SOIBQAAAAB40t6W6VlMwuKvsUqsmePHGUKOG1Ju+pTGO+mNs4bVK1RsaSP6l5qLV9hsQ5vwiljnxFvOMDV8W7VnbE1tdcOM9WHLRU4U557gy0n3YU1jBWK0+l4NbHWfx6qIDbvu3r+uSkOd7E6X1x7Dsdblxy+495qALDTpX0a6DOldIrMWh/dq1TYPbuX5ZdI/faz0SxsjE8bmyjuzFkmgJk+yJd/sr/RAQzw0qLRYRjjC9oodNWYCreHpE+XEAYfLa6tekq83L/Dc1j5po80kW2vrl8rGwHLZUd/Q09ZPcaCblAV6m2B4c3CN6Q9bK/G1UVgXXCb/3vCwZASzZPtaR8rqKpZeG1wi79Quka6BgSacrQ5WynbZFP4mNmaq7y8U6ZnbRwrre8rm+jXy3CxXwKqdK3Z2r0iZHXWVsixtpgxLPyDivvCK2IbrZUU5UlIYPtGYHU/aVSTd9YVKqBI4TfsTN1bEOh5n22f4/V9EdASxAAAAAAA0Q+jU32bmoNqSQCd20jBSpWXEv6KmVsQmyuu0btM/NRDYWRHrUwWbFmVbi/KzZGtFtamyC+RFVpQ6e+3qOp0TfIVvi/d1v8pgr1YDfq0lYu1f3S7tMeu3Lmc1sl63+ytsHT7PYdfjVz3bszw/FMTqJGo64Vi07dX1aJVsj+x62VIbGXpGTnS2c9tLckvk3KE/lJc+my9pkiaZkuM5LvRUfa3wrpRNMnv1EskLFEuBlEid1MqW4FrzszBQGuqD6gwOtQXB6vqFsiq4wEz0FU1VcLtpBxCP1cH4qlZXVi7TxhLS2tUFI9tzKB1btvWGs4rVzY4R5/8D2+JAbzNV41ql3tgv1tlWw7Ym8Pu/iOgIYgEAAAAASICzAjM/p+F08XjoqcLxtiJwCz/dP3WVaRrUhCb58QlDndvnDvr09Hqlk4+Vl+RGtiZwLR+tCi/WhGNmfY3Bbm3jBGPu1+Lu6+q1DTvrA/2FtSZwhbKeQaxjh2nAZU//trvOq22Dco4fnQBOg1i/ClztpWqX92tV4Z6YT5fTsFWDOBvM5QSiTyZnlWZ3lm5pjtPhJV3KAr18l9fnKZQyKUwvk32KJ8o3G5bJf+umSls/NmRKrtRIZVzjJl5d0vp73v7tuu3y6uZlcvTefXf2efVIYkNBbGPAqstW7LA9cBtaE5iK2Mbxaqve9T4dm7ZaFk1HEAsAAAAAQDOECmIdecThe/TeJftyV1fE+jEVc3aSH58WBH4hourROV/mLt1oKkqd94VaE7gCQ78qPM2TnBMK+bGn7dvwuCUqYr2Ehc+OcNNZ4evkfI7crJ1BbGhCuCgTex04pqds31Eji77dEvE6nIb0KYm5He5QX59Xv1jQ7XH38Y0l3v3Wp2th2ORmqrggR77Xd4zkfVlk+tour58lbUl+WqGUSl/pnTbS9HIdNbBUPvhmgfTumS61NemyeU2OHDqur6yqWi6LtiyRmrpa6ZpfLpW1O2TemqWyastGM+GXVg875UonmbTbobJpaVff57aVrTv/P0QuE2pN0LiMjh973bQm0CA20BC2VtcEpbaxClb7yGooqxM4Rvt/Bn8EsQAAAAAANIPzdN1dzRmCpLIyTcMaWy3nV6saHtCG31eYlyWT9u1nXsNSRxin/U+9XptWfXqJ952wAaQNj538KnebE8RGq4j1XN6xY7RVxebt1WHr8Zqsy9L+n3pZuHJzw/P5hKxOftvhVbWpEzaZILaxOjYeulg843JonxLp3bUgIojVh+rYyAxky9D0/eXag86RWevmykOznpDqeu/T8rXitiCzQLbUNOyHZBpSsptUby6U+qxtsnLHUtPbNk0ypCTQXYbnTZDhnQeFgnFVnJ8jhYEy6Z5ZIjWBetkW2GzCzKEFg2Ro2aDwdeeOlf/OXR2aVEwnUisvzpM1m7abXr4H9OonLyxdEnMb7Qj3es/suLL/d7dV7tyn+rz6RYWOER2XGsrW2orY+oaK2KxM+sM2F0EsAAAAAAAJSEVlWKupiA2IVDVWy3lOgNUY5kTbVzYUdC5n2zu4A8PyohwZ0rtYVm2okGpnlmoqYhufI8r26oRjGjo5q0NDryWsIta73615qjhS32g9Yr04C1EL8jJl9cbw5/arMA7bLo/X4b993tuhFY9umRq67Wh4TV6nue8xtIvMWbpRtjeGeaWdcmRY31L5bn3s/q26rX6nzrtbfIzsPEyunnCpPPbVVFmxY2cQ2SWrh4wtHS8167rKQaP7yOdfr5VvK1bIsvpZsjW4Tipli9RLnQk00yVT8gJFUhAokRzpJOmSIdVSYSYY2ybrfdsHdMvsJ3n1JbJfv9GyV5/h5rZ/v7dYepYWyPqtFbKxcrNkS56kBdKlODs7rGVEXk6meU+Vto6wrUzc1d7u9htmcjppaNfRvaxA1m+uatg3PscbZ9sL/RmM1pqg8aagK4jV1ipaHVtdW2deg77nGsLa9dZpOFxbH3o9aDqCWAAAAAAAmiGe4C9ZwibDSmEQq9WutqrOHbIeuWcfU4FaUxtfvapXEOuuqtTnGNav1IS/qzftCN3evXOeLPku+uROSqssD5vg3T4irIVAlL62Te/hG0drAsfytm9u+P3eFcZhQpMzxd7eTJ+J4bwqhbUiVjX0iI18jAaKGh5q7JqdmS4Td+/ReHvkcwzoUSQ9yvLkvZnfNb6ugOc+sa9h3ODy0PhSPQq6ybFdT5N5K1fLDtkmOZIvg7t1Nf8HFwe2SF5Ohvn/UJTWVUalNZy+79WyIj83MxQcq4Hpe8hhe3WVz5YtlMVrN5pKVH1cSW1fyUrLkfLiHFmzsVJWLRP5Lr9CupXmNaxT909ahuQGCkPranhNO79IOGKP3mZdOqa1D6vuI+d+jXzxkTd1cfRP1teh74Xt42p7wTrf9uqaeqmPY7KuT+atMeGr7jelAasGsTU19dIpL828h/XOILYuaCbrsq8BTUcQCwAAAABAM9jquVS0SgyfDCu1rQms0sLssPtsVWB9fUPPylicAWMo/PMJLvMcFYcnHbybbN+6QxZ/tyWh9yMsPHVWxDarR6x3v1n/ilhHEJubFXF/eEWs9/aEAsd4ts+1HZ2LcmXd5krpVhY5EZfty6uBqVfIq69VT7OPZzvr6uvDnjuQ5l2da/eH9o+NuC8gkhXIkSzJMf/WoFD7oup25GSlR/x/2GNoV5m5eL1UVe8chwN6dDLLaXXn7MUbzG0FWfnSJ7+f7NhUGgo4K+uqG6p2HevcuK0qFIx6nvYfCEinvIb30LmcjlkNYu2kZ37jyj7Wuf8Lc8PD+YbnDUpRfpZs3NpQKWsDWVVTWxcaD94VsYFQJaxetFezrlP3n1lXcGdrAtMiobHqfUd1bShURvMQxAIAAAAA0Byh3CMVrQlaR0WsfW4NZvSUdO9l4lyXR7sFZ2Wqk/PUb63O297C70dYkNqcIDa9iT1inSG0R8gV1orCL4i1y8axfRmu1zSwZyfZd2Q3z7HUu0uBqXjVbfeqbdbX57XNzn6++h5pWKoVlWH9dwPegaTfa/QKPzWA1IBTWwAEPNbXq0uBuWzYskOmz/i28fWnSd9uhbJ6Q0XMthMB1/YsWL4ptP+8hoYO2bKiHNl/VHcpdnw5kZuTIWs2VEpOdrp/NWxj8HrCAQPknS9XmpBVJ2/T1zV2UHnEFxMFuTuDWGflsE6Ap+077PZEbmP4erRlgr5H7urt0KRejeu2gazfpHmIjSAWAAAAAIBmCAVfKZ48PD2FG2ADmvLiXN9AON4eut49Zr0fm5udntT3I9Gg2z5Gwy3nqfem36rX83k81n97vJ8z2IQd4A6ENUj1e516Gr49Fd8rqdQK1075WSJrGyomvSo7d9+tsyxYsUmG9yuJK3CNFt5rkOmk1ZsVO2pMVa/ZHsfr0MpXy/lFgX2tOY5A37w8nx6x7u3UoDNaRazqXLyznYDKTE8326ptA/z6wzptqWhonaDVqkqDYzd9rbrvdZyt3VQZut2GsLG20dq6vVoK8rLCbtcxom0IovWxRdOx5wAAAAAAaI4U9oh1SmVF7NaKavPTrxq2KdvnFcr5VaPmZUf2Uc3NagjV7OnVLcU9gVU81YD6Wg4Z18tcnKfe92oM1dw0LNOwUqsoPassXeuOJp697X5P4q1w9GtN0KdrQcTtzvdBw8IDx/Q0VavO/eH3UqK9Rvdp+lrNqdWgts+ps63B6IGdfV5Hw888V6jr9bx6k984jNZ/1c0G8hpW+/UKdhrZv9T8vxrYsyjivq6Nwbh+IaFjbL9R3X3XE8826v7LyWyovA1tb0aa1DYGsbofQ2G8CWKpiG0uKmIBAAAAAGiGUPVcqitiUxjE+vWHlSYEh9GW86umdVdFqpEDSiU/N0MG9ogMrhJhqz01KK2sqpVBvYrif1wjfaxWiDpP13fr372helOfI1pw5hf07ZyUKva2uZdJpMKxoTdrRsSp8379YuPpvxttzOjp+M7H20m3QkGs63R6J90mu59s1aduu6061UC5TgKhfsOhx0Wp9nauL9q229etp/cX5sXe3zoe7JhwmzCkXIb2KQ5r0eHHu0ds5HI6Np23a/uFUQPLpHx9rvTrXijrt+ycHC/Lp7IbsRHEAgAAAADQDDZ/CaQ4iU1pj9hAwJxu7Qwdm6spLQW8wiUN1Qb1Kk5oG7qV5UVUwO7Wq8j0SY0n9PJjAzXtkxpLrNYEfvtpZ2eCQJP3X3MqHDXAdFZ3ep06rwHnt+u2h/WQdb4+v231Cz7dbSm016rdp3YCN/vFhI7LWPT5j9qrT+jfWq2754huEUGs35cdXjf7vSZnv+N4KmKj0ecodE3qFW1ZN6/WCNrewPneaEVsQW6mGf/uMUNFbPMRxAIAAAAAkIgOXBF7yPheZjZ6v0momsIvONPXp4GQ2/ETB0hGC58ivffwbhG3aQCVSAjrXldzlnHuX9/JumLnjp7h3BF79G5WmH/w2J6mLUBmlPdgwtAuUldXHx7EhlXKNvwcN7jcvP9fLlgXdnusbXde17YH5rGND3ZOXhWhCfvKvc0HjO4h7371rX//VZ//Cs5K4Jb4/5IIryBYK2KdVcTuCcXS4+h1jNgIYgEAAAAASKgiVjpsRawGpF4hqduYQZ1DPVz9+AVnk/bt5xl4mX6j6Wkm6Gsr4qn69QryupTkxqy47FGWJ9+s3CzFUdpEhJ7DsQobYDaVBnfRWi00PE9A0qIEtc5+rioUxMYY04dN6G3Gy8dzVoduc/eI9WpNoKF+rVY8N+G/jO5v5/Y4x3ugKRWxjmAz1UGsO2RVhXmZsnV7Q5sHr6pZ5xc+2fSIbTaCWAAAAAAAmmFE/1L5dP4az8l0OlqP2Fj6dfPudelUWphjQq5hfUvCbo/nVPu2Ip7Q3KviNZ6we3j/UunTrdD0oo2lS0meaSfh3tfx6FVeYE5bbwl+1b2xKoft/rC7UytubZ9b+//BK9jff3R3Wbhys/Qo8540zYuuzfm2xWqt4Nsj1nnaf4KtCbzoa1u1vkK+21AR6pvrx1mhrEYNKJMuxbmyrWLn4zJd2+j8IoWK2OYjiAUAAAAAoBlKCrPl8Am9U77v4p0Mq7XTcEgrHdsz+045Z6CPWMbn/dQ2EDuq66KOg3hCWLuvDxnXS5pD2w20FL+hG++QtuFmVmZ6aL+5A1mn4oJsGT+k6duvvWPdz6n0ajDe1gSOx3n1aE1U56Jcc1m7qTLmss6K3OH9SkNfJoX1iHVtY8/yfJm1eH27OuakAkEsAAAAAABtGJlI26Fh4XH79Y/5nk3cvYfkuE7715C1k39+2yb5BXrxToBnJ/VyVnhqqFhVUy+DGieZSpS2egikJV4R6ww2bVicqqpr57Y4e786t90dxGqfZJ10rrYNtQJpjQhiAQAAAABow9rTqfsdQTxBWWmnHOkIEu1vbINDZ89TDRBHDyyTlmo/om01Vqzd5nm/13+9eFoTZCWxx2pc7S+cla+OEl7npmd5TMi1+26dW2ITOzSmOQMAAAAAAMAul+gp7vbh7p6nLaV3lwKzbr8+zF5fgvhNYOZsR+AVcqaqZ3R4q4Wd13NiTK6H5iGIBQAAAAAAwC6XaI/YYGODVmdFbEuyIaUNXN3Bq9d25mV7B5jOFgDZmamtiPXbrnq7Q5E0BLEAAAAAALRBvbsUSpeS3FRvBtBiepYXhPqRxqOuPpjUilg7SVewMaB0R5ymgtSVXebmeG97hrM1QRKD2NEDyqSsKMdU4BblZzWpItZOBtcpjseheagzBgAAAACgDRo/pDzVmwAkxF2AOX5wuYwaUBr3afF1jRNHuSeWainuitdY/45eEbtrJuvKy8mUA0b3aHLYrPp2LZQNW3bIqBbqsYtIVMQCAAAAAABgl9mtZ5Fn5aueVt+U3qT1jRWxztPrW5JtRRAKjN2tCSJqZP1DYWflabIqeJsjrGVCVrrsPaKb5OdkpnSb2jMqYgEAAAAAALDLjBxQZi6Jsq0JnFWdLeHIvfvK1u3VoX8HG/sPuNuvNmWuMWcQ6zXJFzqG1hPBtxK33HKLDBkyRKZOnZrQeh599FGznliX22+/vcW2HQAAAAAAoKPYGcS2bLBZVpQrvbsWhv6dmdHQ07UwLyuiR6wtli0uyJb9R3f3XWdrC19t5XFL7ztER0WswxtvvCFPPvmktIRZs2a1yHoAAAAAAACw64JYtx5leTJmUGfpXpYffofjaXt0zpfORbEnz2stweeBY3rIhq1VEeEykosgttG0adPk8ssvl/r6hkbPiZozZ475eeGFF8pFF13ku1xmJn03AAAAAAAAmioYTG6PWGc1a79unRJez9F7941ob5Aq2p+3p8/EYkieDr/HNXi9//775YEHHmixELaiokIWL15sro8dO1by813fmAAAAAAAACAhowd2lq8WrpPSwpxduie1JUF9MGgm8Ro7qLN8sWCd9O5SEPNx2ZkNLQ7QcXXoIPbdd9+VO+64Q77++mvz7xEjRsjs2bMTXu/cuXNDoe6oUaMSXh8AAAAAAADCDejRyVx2tYCWtdZpEBuU8uJcOWKP3rw1iEuHDmLPP//8UHsAbR9w3HHHyeGHH95ibQm6d+8u5eXlCa8PAAAAAAAArYPJYUVMVSzQFB06iNUeHxq8am/YgQMHyooVK1pkvbaqduTIkfLSSy/Js88+KzNnzjQtC7p16yYTJ040IXCPHj1a5PkAAAAAAACw6/IkRQ6LpurQQezLL78s/fv3b/H12iD27bffltdffz3svuXLl8uTTz4pU6dOlbvuuksOPfTQFn9+AAAAAAAAJK9HrKIiFk2VJh1YMkLYqqoqWbRokbleU1MjRx11lEyZMkU+/PBDefXVV+XKK6+UvLw8qayslMsuu0xmzJjR4tsAAAAAAACA5OhV3jApe1F+FrsYTdKhK2KT4dtvv5WuXbvKqlWr5OKLL5ZLLrkkdF9paalceOGFsueee8pZZ51lgtqbb77ZtC5oaSUleaFS+fYoTRuyNP4sLW04AAKMK7RGHK/A2EJbwjELjC20JRyzkKpxtX9xnowZ1k06EcSiiQhik1BlO23aNBOy6iRgXsaMGSOnnXaaPPHEEzJr1iyZN2+eDB06tEW3IyMjXToCDZvT09tv4IzUYFyBcYW2hGMWGFdoSzhmgXGF9nC8Sk8XKcnsGLkLWhZBbJL4hbCW9obVIFZ99dVXLR7E1tbWtfuKWH19wWBQ6uuZpRCMK7ReHK/A2EJbwjELjC20JRyzwLhCsqWnt2xXV4LYFOnevXvo+oYNG1p8/Rs3Vkh7pqcH6DdTGsJu2LA91ZuDdoJxBcYV2hKOWWBcoS3hmAXGFdoKjldwKi8vlJbUoSfrSiat1IxGWxdYubm5u2CLAAAAAAAAAKQKQWwLu/POO2WfffaRcePGSVVVle9y33zzTeh6v379WnozAAAAAAAAALQiBLEtrKSkxLQaqKiokI8++sh3uRdeeMH8zMvLk/Hjx7f0ZgAAAAAAAABoRQhiW9jRRx8dmqjrjjvukOrq6ohl/vOf/8i0adPM9dNPP10KCgpaejMAAAAAAAAAtCIEsc101FFHmcs111wTdnvPnj3lxz/+caj9wKmnnirvvPOOrFu3ThYuXCi/+93v5Be/+IW5f+DAgXLppZcm+h4CAAAAAAAAaOUyUr0BbdXixYvNz/Ly8oj7Lr/8ctm0aZM8/fTTMnfuXLnwwgsjlhk2bJj86U9/Mq0JAAAAAAAAALRvBLFJkJaWJjfffLNpU/DUU0/JF198IRs3bpT8/HwZNGiQHHvssXLKKadIRga7HwAAAAAAAOgISAIdevXqJfPnz49rx8Wz3D777GMuAAAAAAAAADo2esQCAAAAAAAAQJIRxAIAAAAAAABAkhHEAgAAAAAAAECSEcQCAAAAAAAAQJIRxAIAAAAAAABAkhHEAgAAAAAAAECSEcQCAAAAAAAAQJIRxAIAAAAAAABAkhHEAgAAAAAAAECSEcQCAAAAAAAAQJIRxAIAAAAAAABAkhHEAgAAAAAAAECSEcQCAAAAAAAAQJIRxAIAAAAAAABAkhHEAgAAAAAAAECSBYLBYDDZTwIAAAAAAAAAHRkVsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZASxAAAAAAAAAJBkBLEAAAAAAAAAkGQEsQAAAAAAAACQZBnJfgKgpcyfP1/++te/yscffywbNmyQ4uJiGTlypJxxxhkyceJEdnQH984778izzz4rX375pRkfWVlZ0rdvXznwwAPlnHPOkdLSUs/H1dTUyFNPPSXPP/+8LFy4UILBoPTs2VMOO+wwOffcc804i4Zx2XFUVFTIiSeeKEuWLJFLLrlELr30Us/lGFOIZdu2bfL444/LG2+8IcuWLZOqqirp0aOHOV6dd9550rVr16jj8JFHHpFXXnnFPDY9Pd0c644++mhzrMvJyYn63J9++qk8+uij8vnnn8uWLVvMsXH8+PHmsWPHjuXNa8M+/PBDeeKJJ2TGjBmyadMmyc/Pl6FDh5rj1nHHHSdpad71Fxyz4HbLLbfI3/72N7ntttvkpJNOirqDUjl+En1utN5xpWNBj2dvv/22LF261HxOlpSUyO677y6nnHKK+byMhnHVcTRlXHn5xz/+ITfccENo3ETDuEJLCQT1Ewto5d5880257LLLzC9cXs4++2z51a9+tcu3C6lXW1sr1157rbzwwgu+y5SVlckf/vCHiJBBf6k7//zz5b///a/n47p06SIPPfSQDB482PN+xmXH8j//8z/y9NNPm+t+QSxjCrHMmzdPLrjgAlmzZo3n/Roc/OUvf5HRo0dH3Ldx40Y588wzTeDgZcCAASZk9Qtyn3zySfnNb35jwgo3DemuuuoqEwSj7bn99tvl4Ycf9r1///33N5+D7qCeYxbc9Asi/Xyrr6+PGWykcvwk+txoveNKvzDU37P0M8+PfsF06623mi8j3RhXHUdTxpUXDflPOOEE8yV3rCCWcYWWRGsCtHpz5syRK664wvySNmrUKPON10cffSTPPPOM+cZb6W36ByY6nrvuuisUwh566KGmMkLHh96moUJeXp6sX79eLrroIlm9enXYY6+77jrzC3xmZqb8/Oc/Nx+w7777rvlmtaioyAQl+jj74ezEuOxYtCLDhrDRMKYQzdq1a+WHP/yhObYUFhaacH/atGny2muvmbGTm5trKhknT55sqmad9I+Mn/70pyaE1UrHG2+8UaZPny5vvfWWXH311ZKdnS2LFi0yf7zqsl5nDeixTUPYAw44QP75z3+aY6V+dk6YMME85s477zTrQ9ui76UNYceMGWPC+Pfff9+cJTJp0iRz+3vvvSc333xzxGM5ZsFJj0eXX3655zHESyrHTyLPjdY7rlatWmXeNw1h9YtJ/azT91aPYXo2iH5eqX/961/y+9//PuLxjKuOo6nHK7e6ujq55ppr4jpGMK7Q4rQiFmjNLrzwwuDgwYODhx9+eHDbtm1h99XX1wd/9rOfmfv33HPP4NatW1O2ndj1Vq1aFRw+fLh5/6+88krPZb766qvQMjfddFPY7XqbXqZMmRLxuNmzZwdHjBhh7n/ggQci7mdcdhzr168P7rvvvqHxopd77703YjnGFGK54oorzPgZM2aMGS9ub731VmiMPfHEE2H3vfzyy6H73nnnnaiPff755yM+KydNmmTuO/3004M1NTVh91dVVQVPO+00c/+RRx4ZrKur481sQw477DDz3ul7vGPHDt9xN2TIEPO5aXHMgqX/5++5557g0KFDwz7rnn32Wd+dlMrxk+hzo/WOqxtvvNEsM2rUqOC8efMi7texMXnyZLOMvserV68Ou59x1f41Z1x5ue+++8Ierxc/jCu0NCpi0app5Y9Woqmf/OQnpgrIKRAImNPS9ZRKrSJ6/fXXU7SlSNXpKNqaQGk1hBetsrCVFXYsKf1WXfXq1UtOPfXUiMcNHz7cnKpiq42cGJcdi54WuW7dupinOzGmEI2OoZdfftlc18pWPTa5HXTQQdKvXz9T4TV79mzP8bXHHnt49k3Ux+67776hfmdOWkn09ddfm+t6GnBGRvgUAdpTW6tq1eLFi81poWgb9Hcf7RWstA+sVka7/eAHPzA/tRr6q6++Ct3OMQtKq0iPP/5407pCK8tGjBgR145J5fhJ5LnRusfVq6++an4ee+yxMmTIkIj7dWxoFaTSamqt/rcYV+1fc8eVm34WPvDAA6ZdzzHHHBN1WcYVkoEgFq3+YGs/dA8++GDPZbp37y7Dhg0LBXPoOPS0M/0A7dy5s5mcwY9OZGOXt3+M2rGl48qrv5RtdaBWrFhh+jpajMuOQ/+A01PidHxdf/31vssxphDPH5d6Gpy2HzjrrLN8l9NJZ2bNmiW//e1vQ7dpEKETMDmPS17sfRqkbt68OawtgerUqZMJcr2MGzfOTISi+CxtO5wTcNkvJt002HcvzzELlvZZ1S9qdJxor8W777475s5J5fhJ9LnReseV7Qmr48KrT7rVp0+f0HVnv3XGVfvXnHHlVllZab581s9MbY+i/fWjYVwhGQhi0arNnTvX/NTZpP1mvbfffCt3BRHaN62C1XDCfnserRG70p5h9pdynS1cRfsm1Y4rpcGIxbjsGLTKTMMw/YNAJwAoKCjwXZYxhVhsJaJWwmrvaifnRDVeFY0aItgJtqIds2xooVUi2s/M+Xg1dOhQ39BCx7l9PJ+lbYeG61pFrV588UWprq6OWEZ7xSr9w9VWYnPMgvP//hFHHCH//ve/TY9pZ7jvJ5XjJ9HnRusdV/pl4Icffmg+L6OdhWTPArDHQItx1f41Z1x5TW65ZMkS2XvvveWcc86JuTzjCskQfm4a0MqsXLkydOpRNPqLnG3wrt9uuU+7RPsWLSDTCbrs5DPjx48PG1exxlZ5ebn5w1VDEv3F32Jctn/OBv46udJee+0VdXnGFGJZsGCB+WlDM620fuKJJ+TLL78040yPN9pGRdsWdO3atVnjy3lmQCLHLOdj0fpdeeWVpuWEjrFzzz3XVAkNGjTITA6nEx3ZVhU6tnQmecUxC5a2TOnfv3+Tdkgqx0+iz43WO66c7XKi+fvf/x66bn+3V4yr9i+RcWXPENKJnXXCVC2y0GA3FsYVkoGKWLRq9hQVW8noRw+mSiuG7LfkgI4HnZW8qqrK7IwzzjgjbFy5v0l3029Zbd8y57hiXLZ/f/rTn+SLL76QgQMHmpAjFsYUYrGnT+rnmR6XLr74Yvnggw9Cs/VqaKZ/HGifTx17zRlfzi+lEjlm8Tnatmh10P33329Cfm1LoV8eab9g7aOnIaye4q0VQJMnTw49hmMWrOaEGqkcP4k+N3aNRMKyaPTzccqUKea6ttoZPHhw6D7GVfuXyLjasGFDqM2Y/rRf9MTCuEIyEMSiVbMBmtepmk7aJ9TyOi0PHZN+02kng5g0aZI5BcU5rtxjx4sde87HMC7bNz2F8Y9//KOpvLnjjjtiHn8UYwqxbN++3fx87rnn5Omnn5YJEyaYakU9BVNPxdRwVlsWaD9YDWmdfe/iHV/O+5pzzPI63qFt2LZtW0TLC2v9+vXy+eefmz9CLY5ZSEQqx0+iz422a9GiReYLJT1rSd9bnUzViXGFaPT3LP3SW88+OvHEE+PeWYwrJANBLFo1v152QDRaOaEh7GOPPWb+rd+W33zzzS02rhiX7deOHTtMA389lVFP4x05cmRcj2NMIZ6xpfSPAG118eijj5owVv+Y1B6JZ555pvz5z382VVwamOl1xhficcstt5hWKtoX+Ac/+IG89NJLMnPmTJk+fboJKvQ0Xw3/dZK4devWccxCwlL5mcfvYB3TN998Y6r99YslddNNN5m+506MK/jRXumvv/66lJWVyW9+85sm7SjGFZKBIBatms4uHU+Vq/0DV8VTvYb2S8eK/kGqIYfSU8sffvjh0OlpznEVT5WEvd9ZdcG4bL+0AlYrLnRCm4suuijuxzGmEIvzGHLttdeGzWRv6WmWBx54oLn+2muvNXl8OT8Lm3PMirfqA62Htrf429/+Zq5rG5Vf//rX5nNPw1ftNXz22Webymutll24cKH83//9n1mWYxYSkcrxk+hzo+3Rliv6ZaU9U+SXv/ylZ0Uj4wpeli9fLrfeequ5roU50SYI9MK4QjIQxKJVs72htm7dGnU52/tJv7GK1W8K7Zee0vvjH/9Ynn/++dBsujoZjk7Y4OTsKRZtbOnM4/Z0Yp3J1WJctk/vvvuuCSz0jz3tp9iUSf8YU4jFfhmkxw/nbN5ue+65Z2iiQT3d3D2+7G1enMezRI5ZzseidbMTcWkf2PPOO89zGa0aO/300811nWm6srKSYxYSksrPvESfG22L/k6vkxDq7/h6xohWM2plrBfGFbyOA1qgo8eCk046ybQlaCrGFZKBIBZtoiH3t99+G3W57777zvzU6g/9kEbHs2zZMjnttNPkk08+Mf8+4IADTJWQ17eedtbyWGNLTyHWU9TtH7kW47J9evHFF0MVNMccc4wMGTIk4mLpxDj2Np2NmTGFWOzs3rGqTZ0TbtlqMOf4cs4Y7uY8niVyzIp3Aguk3pIlS8zP3XffPerpkzbg15nn9fOSYxYSkcrxk+hzo+3Qfv3aLkorp7UqUX/3OvXUU32XZ1zBTY8R2iNdTZ061fN3ex1Xlr1Nz1xiXCGZSKzQqtmZMPWUgmhVQNoXTQ0bNmyXbRtajwULFpgQ1v5Bqr+kPfjgg2HtCJy6dOkixcXFYWPHy+zZs0PXnRVsjEswptBU9vNJ+79G+zyzPTy1dYH9ImnQoEESCATM9blz5/o+1h7PdFln7zx7zJo3b57poe1Fb7fr5rO07bBBU1MmKtVl+RxEIlI5fhJ9brQN2gP2nnvuMdc7d+4sjz/+uBx66KFRH8O4QjIwrpAMBLFo1WyvPJ0d8+233/b9ttz+8ahVkOhY9Jd4PWXJzgZ92WWXmdOWYp1WbseWjiu/YGLatGnmp7Y2cIYajMv2SftG6bfm0S7WT37yk9BtPXv2NLcxphDNQQcdFDpN7o033vBd7v333zc/R48eHaoA0yrZ8ePHhx2XvNj79LE2qFATJ040P3WSky+//NLzsTqWN27caK7zWdp22Aowff+ihbHaY1HpZ2Pfvn3NdY5ZSEQqx08iz4220a9/ypQpoQrov//97+ZzLRbGFdz0d/RYv9vr7/SWvc05yTPjCslAEItWrXfv3qE/Pu+7776IXlD6y9f//u//mj9stf/T8ccfn6ItRaoqgS6//HJz+pm67rrr5OKLL47rsbbJv07MZH/Zc9Iqi+eee85c115UthpNMS7bJ53cRquoo10srVa0t9mxwZhCNPvtt18otP/9738fqnx1euWVV0KBmXsikhNOOMH8fO+99zyDC71NJ25SP/rRj8Lu22uvvULPrX/gugM7/ffvfve7UPUtQWzboW1UlPZP1HHlN9u4/ZzTUN722OSYhUSkcvwk8txo3XRm+4ceeigUwmrvfh0v8WBcwU3/78f63d45eaq9Tf8mYFwhmQhi0eppuKZVQXra+RlnnGH+CNXqRz3l6NJLLzV/uCq9rrMCo+N4+umnZdasWeb60UcfLaeccoppxh7tYu2zzz5yyCGHmOs6k6b+AavVtRrqPvPMM6bKVoNe7ev4gx/8IOK5GZdwY0whGq1E1AoL/TxbtWqVaaGiEyfppFza91XbqVx11VVm2TFjxphJJZz03/b0Wq38f/jhh8169KLX9TbbK/Soo44Ke6w+px6zlFZ66KSGn332mamA1Z/6b71d/2C54oorCC3aEP3s23vvvc11HQf6u5D2Stffk7R/tfZK19+dKioqzIQjOmmJxTELiUjl+En0udE66ZeCelab0iBMvzjU3rDRfq93f7HIuEIyMK7Q0gJBv/M5gFZEm2vfcMMNZpIJL/oLl7OpNjqGww8/3Ew60hTz588PXd+8ebOZZXrmzJmey2pPKq20sKdxujEuOx47Ydcll1xi/jh0Y0whnknhfvnLX4Ym4nIbMWKEmaCkW7duEfdpYKvVXRo4+J2mrscsr0kK1R/+8Ae59957Pe/TEFa365xzzuFNbGN0ZnkN4m1FtN/nmb73tgrR4pgFNw3wbS/O2267LeJLodYyfhJ9brS+caVfTjq/LIqH1+9jjKuOoynHKz9alW8n7HL+nejGuEJLit5EEWgl9KCqf5zqqSoff/yx6XOn346PHDnSfIt+2GGHpXoTsYtp1URTQ1i3oqIieeqpp8zlhRdekIULF5pv1vUU3oMPPlguuOACKSsr83084xKMKTTVscceK2PHjpVHHnlEpk+fbipas7OzTYh63HHHycknnyw5OTmej9Vjk/6h+uijj8qrr75qAlntsahBw5FHHmlCC79JCtXkyZNNmwKd9EQrYfV0dj1NXbdH2xnsueeevKFtkL6H+vvRa6+9Zk7H1jNF9L3VcaSn9mrl4Jlnnmk+89z4HEQiUjl+En1utD4zZsxokfUwrpAMjCu0JCpiAQAAAAAAACDJ6BELAAAAAAAAAElGEAsAAAAAAAAASUYQCwAAAAAAAABJRhALAAAAAAAAAElGEAsAAAAAAAAASUYQCwAAAAAAAABJRhALAAAAAAAAAElGEAsAAAAAAAAASUYQCwAAAAAAAABJRhALAAAAAAAAAElGEAsAAAAAAAAASUYQCwAAAAAAAABJRhALAAAAAAAAAElGEAsAAAAAAAAASUYQCwAAAAAAAABJRhALAAAAAAAAAElGEAsAAIBmCQaDMmXKFFm7dm1K9+DHH38sQ4YMMZf77ruvxdc/derU0Pr1ekf2yiuvyLx581K9GQAAAG0SQSwAAACabOnSpXLWWWfJTTfdJFVVVezBdm7dunUyefJkueyyy2Tz5s2p3hwAAIA2iSAWAAAATfb888/Lp59+yp7rIKZPny5vvPFGqjcDAACgTctI9QYAAAAAidhrr71k/vz5SduJJ510krkAAAAAiaAiFgAAAAAAAACSjCAWAAAAAAAAAJIsENTpbgEAAIA43HfffXL//fd73tezZ0+ZNm1a2HLp6ekyZ84c+de//iV/+tOfZMWKFVJSUiKjRo2S3/3ud5KXlxd6/BdffCEvvPCCfPLJJ7JmzRrZtm2b5OfnS7du3Uz7gTPPPFP69esX8bwff/yxnHPOOeb6JZdcIpdeemnovqlTp8p1111nrr/zzjtSWloqTz31lLz44ouyZMkSqa6ull69esmhhx4q5557rhQXF0es37mO2267LaxNgft16jY//vjj8uqrr8ry5ctFf9Xu37+/HHXUUXL22WdLbm6u777VZV9++WV55plnZPbs2bJ9+3bp2rWrHHzwwXLBBReY67rfdJvdrzNeq1atkieeeELee+89M+FabW2t2SfDhw+XI444Qo477jjzWrxeuxevlhCrV682z6F9ZfX91ufo0qVL6D0cNmyY57qcz/Xaa69J586d5c9//rO88sor8t1330l2draMGDFCTj31VDnmmGOa/NoBAABSjR6xAAAASCoNPn/961+H/q0hq15sCFtVVSW/+MUvTAjptnnzZnPRwG/KlCly6623ygknnNCs7diwYYP89Kc/NYGp04IFC8zlH//4hzz22GMyePDgZq1/8eLFcv7555vw0UlDVb3885//NAGlBqpuGq5eeeWVJoB00nX97W9/k3//+9++AXi8PvjgA5k8ebJUVFREhLN60RD9kUceMZeysrJmPcdzzz0nN910U8RzLFu2zFyeffZZufDCC+Xyyy+XQCAQ9b3SbdX3xdJx8uGHH5qLhrN33XWXZGZmNms7AQAAUoEgFgAAAHHTSkStaNSK0pdeesncdvPNN5vgLicnJ2L5+vp6+e1vfyudOnWSH/3oR6b69LPPPjOVndb1118fCmF79OhhgtbevXtLWlqaqSrVatqVK1eaysobb7xR9tlnH88wM5YrrrjChKUatJ544omm0larQjXg1WBYw79rrrnGPF+0kNCvmvWiiy4ywem4cePMftJKUw2QNYjesmWLCSI1kH7ggQciHn/11VeHQtjy8nI5/fTTZcCAASYg1QrZhQsXmhBZ90Fz6GvT8FMD0qysLDn55JNl9913N1Wmus0aEuv26fZqVapWoqq9995b/vCHP8hHH31kAmF12WWXeYbVGhZfe+21Zl9oQPq9731P9thjD/N8X3/9tXkd69evlwcffFDq6urkqquu8t1e3QZ9r7SS9owzzpA+ffqYfaDv1caNG03FsT6HhrEAAABtBUEsAAAA4jZw4EBzmTt3bui2/fbbzwSsXjSUq6mpMSHemDFjzG3HH3986P558+aZdgRq9OjRZjl3oPuTn/zEXLSic8eOHfL666/LWWed1eR3TYO973//+yY4dp5+r7dpMLt27VrzumbNmhUWFMdDA2dtdeBuGXDsscea16vtDHTb33rrLROKakhraZsArfBUeur9ww8/HNYiQV+rVgzb4Ls5nn/+eVNZrG6//faIU/u1tYMGnlq5qy0cNADXMFyDcb1okGyNHz/etBlwtyPQkFnfbw3l9TUMHTo0bJnzzjvPVMN++eWX8te//lUOO+yw0Jjweq+89sVpp51mtlX39X/+8x8TWGvYCwAA0BYwWRcAAACSSqsq/QI356n4WrHqVVWrFZUa4lkawjWHBoRaUesMYW0FqvYdtWbOnNms9WulsFffVg2utUes0qDSvX6tELWv85577onoU6u3a29aDUabS4NN68ADD4y4X/e79qHt27ev7L///qbqtCmefPLJUDuCW265JSKEVUVFRSYE1kpW3Q8PPfSQ7/q0l67233XvC62EvvPOO0P/1qAWAACgrSCIBQAAQFJNmDDB9z49nV8rPXUiL3eVpZOz4raysrJZ26GTXmmo6WXIkCGh61u3bm3W+nWyKz9+69cq1c8//9xcP+SQQ3zDVg1KdaKr5nIGmhqAes3Xe/TRR5tgXO/X6uSmsBW9Gnbrfvajk61pRa2tBPZrtaDbopO/edFts8G+tkzQ/roAAABtAa0JAAAAkFTa69SPBqO23YGbhoXav1QrSPWUfmcbgObweg6rsLAwdF1bKSRz/c7wUfvlar9Uteeee0Zdf7SgOhatyNWwW/ep9nzV8FuD44kTJ5pQMyOj+X8WaPWs9tpVBQUF8uabb0Zd3lY9awXtokWLPPvN7rvvvlHXoX14tcWBrkP72ja1lQQAAEAqEMQCAAAgqZwhpB8NV7W68eOPPzbhnLYf0D6lXtWvXtWciW6Hs11BstfvDJJ1kjBLe7FGoxNWNZe2TdBJtu6+++5QqwINZvWi2619fjWYPfTQQz3bQ0TjfA0ayE6ePDnux+rkXX6Vs9E495XfOgAAAFobglgAAAAklV87AGvGjBly3XXXycKFC6Oezv7ss88mtB3u3rAtrTnr37RpU+h6rAC0qQGp209/+lNT/aoTZX344YehSlxtlaCtBfRSUlIiN9xwg5lkLF7btm1r9jZt377d8/b8/Py490Uizw8AALArEcQCAAAgZebNmyc//OEPQ5Wv2hdUT8HXnqq77babDB8+XEpLS2XZsmUJB7GtkTNQtJNd+dmxY0fCz7fPPvuYy4YNG2T69Ony/vvvm1B27dq1oTYDV155pWkx4DWpl9/EWtYxxxwjv//97xPezlh9X537SsNjAACAtoAgFgAAAClzxx13hEJYPXVeqzYDgUDEclu2bJH2qGvXrqHrK1eujLpsrPubQsPtE044wVy0FYP2W/3jH/9owln99wMPPBB3EKsTdFk20E3U6tWrZejQob73a+9gq0uXLi3ynAAAAMmWlvRnAAAAADxUVVXJBx98YK736tVLLr74Ys8QVs2dOzfhHq6tkbYKsD7//POoy+rEXs2h++vll1+W+++/Xx599NGI+3Wfjx071gSxNtTUCbCaEibbx82aNStmZa9WzF5//fUm7N28ebPnMvHuCw2Bo02SBgAA0JoQxAIAAKDJnIFpc4NRDeHsY/Py8nyXq6mpkSeffDL079raWmkvunfvLrvvvru5/tZbb8l3333nuZy+5qeeeqrZ79Vdd90l9913nwlb/U77z8zMDPVmdfdoTUtL85xszNJJvpRWN0+ZMsV3W3QStr/85S/yzDPPyGOPPebbC/a5557znKhNffrppzJ79mxz/eCDDw7bNgAAgNaM31oAAADQZM6+oH5VjfGcHm8D2G+++caz4lPDuGuuuSasIlYraduT888/P9QD9uc//3nE5FMafN56663y9ddfN/s5jjrqqNB79dvf/tYzPH/jjTdk8eLF5vqECRN8e9l6tYnQPr8a5Kp77rlHpk2bFrGMPu5nP/tZaJKws88+WzIyvDulrVq1Sn71q19FhO7anuEXv/iFua7PZ/cdAABAW0CPWAAAADRZt27dQtdvu+02OfPMM0OTNcX9i2hGhkyaNEn+8Y9/mLDxvPPOk1NOOUVGjBhhwroFCxbICy+8IOvWrQt73NatW9vVO3bEEUeYitI333xTvvjiC7MPTzvtNOnfv7957VodqhWg6enpoRCzqVWgP/7xj+Wf//ynbNq0yVTWzpgxQ44++mgzOZqGsxqCv/TSS2bZ7Oxsueiii3zfb62s1apa3RZ9//R91G3VwFwDY71Pe/3qazrooINMaK9Bu77POkmY0v6v0UJUreL9z3/+Y8bA97//fencubMJ43Xb7fuvz6HPCwAA0FYQxAIAAKDJ9t13XykuLjbBnp4qrhcNzzR4i9ZmwO3qq6+WmTNnmpBNq18ff/zxiGU0GPzlL39pgjwNJBOpDG2ttHWA9sjVnrk6UdW9994bdn9JSYlMnjxZbrnlFvPvrKysJlcfP/jggya83Lhxo8yZM8dc3Dp16iS33357xERZGo737dtXli5dasLRq666ytw+atSoUI/Wc845xwTE+ngNYzVY1otXX1xtkaDvq58LLrjABNDaq1bDXScdZ3ZiNwAAgLaE1gQAAABoMg0Gtcfn/vvvb8I7rYosLy/37XHqRx/797//3QR7I0eONCGurktDXu2dqpWZr776qpx++umy9957m8doVeVHH33Urt41rRp9+OGH5Y477jAhtwaneuq9TmKmp/1rtepuu+0WWr6oqKjJz6ETcul6NMTU67qP7b7WfX/ppZeaSb0OOeSQiMfqtjzyyCNy5JFHmvdeH6cTZa1ZsyZsubPOOsu8X1rtOmzYMCksLDTLakXrxIkT5c477zQ9ZPWx0Wilq1ZDn3vuuaZqV59fx5etoCaEBQAAbVEg2J6mnQUAAADaqRdffFGuuOIKc10nvNJgsz2ZOnWqXHfddaF2FyeddFKqNwkAAKBF0ZoAAAAASCGt+tQKWK2EPfnkk32Xs6f566n5Wm0KAACAtoUgFgAAAEghnSxLe8O+/fbbsscee0ifPn0iltGWAq+88oq5vtdee5nT9AEAANC2EMQCAAAAKaT9b2+44QbZtm2bnHjiiXLcccfJ8OHDJT8/3/Rgfffdd+X9998X7SiWk5Mjv/71r3m/AAAA2iCCWAAAACCFTjnlFFmwYIE8/vjjJozVyay8dOvWTe6++24zkRUAAADaHoJYAAAAIIW05+v1118v3/ve9+SZZ56Rzz77TFauXCm1tbWmBUHv3r3lmGOOkUmTJklBQQHvFQAAQBsVCOo5TgAAAAAAAACApElL3qoBAAAAAAAAAIogFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAkowgFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAkowgFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAkowgFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAkowgFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAkowgFgAAAAAAAACSjCAWAAAAAAAAAJKMIBYAAAAAAAAAJLn+H3fPiQDWCravAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 391, + "width": 689 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "ax.plot(losses, lw=0.6, alpha=0.5, label=\"raw\")\n", + "win = 50\n", + "ax.plot(\n", + " np.arange(len(losses) - win + 1),\n", + " np.convolve(losses, np.ones(win) / win, mode=\"valid\"),\n", + " lw=2, label=f\"{win}-step rolling mean\",\n", + ")\n", + "ax.axhline(np.log(vocab_size), color=\"grey\", ls=\"--\", label=\"random baseline\")\n", + "ax.set_xlabel(\"training step\")\n", + "ax.set_ylabel(\"cross-entropy loss\")\n", + "ax.legend()\n", + "ax.set_title(\"Training curve\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sampling — the autoregressive loop lives inside `pytensor.scan`\n", + "\n", + "For inference we feed the model a context window and sample the next character from the predicted distribution over the vocabulary. PyTensor lets us push the entire autoregressive loop **into the compiled graph** with `pytensor.scan`: every forward pass, every categorical draw, all the context-window bookkeeping becomes a single C/Numba call. We use `pt.random.shared_rng` so the RNG state advances **inside** the compiled function — each call returns an independent draw. This pattern matches the one in the [scan tutorial](../scan/scan_tutorial.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:14:19.741016Z", + "iopub.status.busy": "2026-05-07T13:14:19.740900Z", + "iopub.status.idle": "2026-05-07T13:14:22.515333Z", + "shell.execute_reply": "2026-05-07T13:14:22.514743Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROMEO:\n", + "He have shut thing disp: eat fitorer, which bee spose!\n", + "Thaction wranter toge. A godd some; at, powarth libout quh e and such arothy to prome-cany be frie thing.\n", + "\n", + "COMINIUS:\n", + "Now ust, pry state more veily, the cry mam fors,\n", + "Our fithy done for thy baraddy at, doubt ithen\n", + "diesws sagch.\n", + "\n", + "MENENIUS:\n", + "Node most\n", + "Rele's buths is ather shencered honours\n", + "To made the neme of then you thums,\n", + "Them heate the me the\n" + ] + } + ], + "source": [ + "rng_sym = ptr.shared_rng(seed=2026, name=\"rng_sample\")\n", + "\n", + "\n", + "def gen_step(context, rng):\n", + " \"\"\"One generation step inside the scan loop.\n", + "\n", + " `context` is a length-`block_size` int64 vector. We forward through the model, sample the\n", + " next token, then shift the context window left by one and append the new token.\n", + " \"\"\"\n", + " logits_step = forward(context[None, :], params, cfg)[0, -1, :] # (V,)\n", + " probs_step = pt.special.softmax(logits_step)\n", + " next_rng, next_tok = rng.categorical(p=probs_step)\n", + " new_context = pt.concatenate([context[1:], next_tok[None]])\n", + " return new_context, next_tok, next_rng\n", + "\n", + "\n", + "init_ctx_sym = pt.vector(\"init_ctx\", dtype=\"int64\")\n", + "n_new_sym = pt.iscalar(\"n_new\")\n", + "\n", + "ctx_seq, tok_seq, rng_final = pytensor.scan(\n", + " fn=gen_step,\n", + " outputs_info=[init_ctx_sym, None, rng_sym],\n", + " n_steps=n_new_sym,\n", + " return_updates=False,\n", + ")\n", + "\n", + "generate_fn = pytensor.function(\n", + " [init_ctx_sym, n_new_sym],\n", + " tok_seq,\n", + " updates={rng_sym: rng_final},\n", + ")\n", + "\n", + "\n", + "def generate(prompt: str, n_new_tokens: int = 400) -> str:\n", + " \"\"\"Run autoregressive generation. The Python wrapper only handles text ↔ ids;\n", + " every forward pass and every sample lives inside the compiled scan.\n", + " \"\"\"\n", + " ids = list(encode(prompt)) or [stoi[\"\\n\"]]\n", + " pad_id = stoi[\"\\n\"]\n", + " init_ctx = np.full(cfg.block_size, pad_id, dtype=\"int64\")\n", + " init_ctx[-len(ids):] = ids[-cfg.block_size:]\n", + " sampled = generate_fn(init_ctx, n_new_tokens)\n", + " return prompt + decode(sampled)\n", + "\n", + "\n", + "print(generate(\"ROMEO:\\n\", n_new_tokens=400))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling up: a deeper model on more data\n", + "\n", + "The sections above used a 50 K-character slice and a small 2-layer model. Now we double both and train a 4-layer transformer on a 100 K-character slice (and double `block_size`), still on the default Numba backend. We then compare the two models head-to-head on a held-out slice of Shakespeare that neither has seen — the training losses on their own are not directly comparable because the corpora, vocabularies, and context windows differ.\n", + "\n", + "## Re-tokenize a 100 K-character slice and rebuild the model\n", + "\n", + "We use a fresh `Config` and a freshly initialised parameter dict so this section is independent of everything above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "corpus slice: 100,000 chars, vocab: 61\n", + "cfg_full : Config(vocab_size=61, block_size=64, n_embd=64, n_head=4, n_layer=4)\n", + "params : 205,760\n" + ] + } + ], + "source": [ + "text_full = full_text[:100_000]\n", + "chars_full = sorted(set(text_full))\n", + "vocab_size_full = len(chars_full)\n", + "stoi_full = {c: i for i, c in enumerate(chars_full)}\n", + "itos_full = {i: c for i, c in enumerate(chars_full)}\n", + "data_full = np.array([stoi_full[c] for c in text_full], dtype=\"int64\")\n", + "\n", + "cfg_full = Config(\n", + " vocab_size=vocab_size_full,\n", + " block_size=64,\n", + " n_embd=64,\n", + " n_head=4,\n", + " n_layer=4,\n", + ")\n", + "print(f\"corpus slice: {len(data_full):,} chars, vocab: {vocab_size_full}\")\n", + "print(f\"cfg_full : {cfg_full}\")\n", + "\n", + "init_arrays_full = init_params(cfg_full, np.random.default_rng(7))\n", + "print(f\"params : {sum(a.size for a in init_arrays_full.values()):,}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compile a fresh `train_step` and train\n", + "\n", + "We wrap the now-familiar pattern — fresh `shared` params, symbolic loss, lower the xtensor sub-graph, `pytensor.grad`, Adam updates, compile — into a small helper so this section reads top-to-bottom." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def build_train_step(cfg, init_arrays, *, lr=3e-3):\n", + " p = {n: pytensor.shared(arr.copy(), name=n) for n, arr in init_arrays.items()}\n", + " X = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + " Y = pt.tensor(\"Y\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + " logits = forward(X, p, cfg)\n", + " log_probs = pt.special.log_softmax(logits, axis=-1)\n", + " bidx = pt.arange(X.shape[0])[:, None]\n", + " tidx = pt.arange(X.shape[1])[None, :]\n", + " loss = (-log_probs[bidx, tidx, Y]).mean()\n", + " # Lower xtensor ops before grad (see the smaller-model section above).\n", + " loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n", + " grads = pytensor.grad(loss, list(p.values()))\n", + " upd = adam_updates(list(p.values()), grads, lr=lr)\n", + " t0 = time.time()\n", + " fn = pytensor.function([X, Y], loss, updates=upd)\n", + " return fn, p, time.time() - t0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compilation took 4.9s\n" + ] + } + ], + "source": [ + "BATCH_FULL = 32\n", + "N_STEPS_FULL = 1500\n", + "\n", + "train_step_full, params_full, ct_numba = build_train_step(cfg_full, init_arrays_full)\n", + "print(f\"Compilation took {ct_numba:.1f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0 recent-mean loss = 4.141\n", + "step 100 recent-mean loss = 2.934\n", + "step 200 recent-mean loss = 2.462\n", + "step 300 recent-mean loss = 2.297\n", + "step 400 recent-mean loss = 2.163\n", + "step 500 recent-mean loss = 2.051\n", + "step 600 recent-mean loss = 1.962\n", + "step 700 recent-mean loss = 1.884\n", + "step 800 recent-mean loss = 1.822\n", + "step 900 recent-mean loss = 1.763\n", + "step 1000 recent-mean loss = 1.722\n", + "step 1100 recent-mean loss = 1.688\n", + "step 1200 recent-mean loss = 1.658\n", + "step 1300 recent-mean loss = 1.628\n", + "step 1400 recent-mean loss = 1.598\n", + "step 1499 recent-mean loss = 1.569\n", + "\n", + "Total training time: 211.8s\n" + ] + } + ], + "source": [ + "rng_full = np.random.default_rng(123)\n", + "losses_full: list[float] = []\n", + "t0 = time.time()\n", + "for step in range(N_STEPS_FULL):\n", + " starts = rng_full.integers(0, len(data_full) - cfg_full.block_size - 1, size=BATCH_FULL)\n", + " xb = np.stack([data_full[s : s + cfg_full.block_size] for s in starts])\n", + " yb = np.stack([data_full[s + 1 : s + 1 + cfg_full.block_size] for s in starts])\n", + " losses_full.append(float(train_step_full(xb, yb)))\n", + " if step % 100 == 0 or step == N_STEPS_FULL - 1:\n", + " print(f\"step {step:>4d} recent-mean loss = {np.mean(losses_full[-100:]):.3f}\")\n", + "print(f\"\\nTotal training time: {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 391, + "width": 766 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 4))\n", + "ax.plot(losses_full, alpha=0.4, label=\"raw\")\n", + "rolling = np.convolve(losses_full, np.ones(50) / 50, mode=\"valid\")\n", + "ax.plot(np.arange(len(rolling)) + 49, rolling, lw=2, label=\"50-step rolling mean\")\n", + "ax.axhline(np.log(cfg_full.vocab_size), ls=\"--\", color=\"gray\", label=\"random baseline\")\n", + "ax.set_xlabel(\"training step\")\n", + "ax.set_ylabel(\"cross-entropy loss\")\n", + "ax.set_title(\"Training curve — deeper model on 100 K characters\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A fair side-by-side: held-out perplexity\n", + "\n", + "The two training losses (≈ 1.65 vs ≈ 1.57) aren't directly comparable. The models saw different corpus slices (50 K vs 100 K characters), have different vocabularies (59 vs 61), and — most importantly — a different `block_size` (32 vs 64). Doubling the context window alone tends to drive per-token cross-entropy down, even at equal model quality.\n", + "\n", + "To get an honest comparison we evaluate both models on the same 10 K-character slice that **neither** of them saw during training (`full_text[100_000:110_000]`). For the small model we simply skip the handful of characters that aren't in its vocabulary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "held-out CE (small, 2-layer, block 32): 1.841 ppl = 6.31\n", + "held-out CE (large, 4-layer, block 64): 1.738 ppl = 5.69\n" + ] + } + ], + "source": [ + "def build_eval_fn(cfg, params_dict):\n", + " \"\"\"Compile a forward + cross-entropy function that reads from the shared params.\"\"\"\n", + " X = pt.tensor(\"X_eval\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + " Y = pt.tensor(\"Y_eval\", shape=(None, cfg.block_size), dtype=\"int64\")\n", + " log_probs = pt.special.log_softmax(forward(X, params_dict, cfg), axis=-1)\n", + " bidx = pt.arange(X.shape[0])[:, None]\n", + " tidx = pt.arange(X.shape[1])[None, :]\n", + " loss = (-log_probs[bidx, tidx, Y]).mean()\n", + " loss = rewrite_graph(loss, include=(\"lower_xtensor\",))\n", + " return pytensor.function([X, Y], loss)\n", + "\n", + "\n", + "def held_out_loss(eval_fn, cfg, stoi_local, holdout_text):\n", + " \"\"\"Mean per-token cross-entropy over non-overlapping windows of `holdout_text`.\n", + " Characters absent from `stoi_local` are skipped (vocabularies can differ slightly).\"\"\"\n", + " ids = np.array([stoi_local[c] for c in holdout_text if c in stoi_local], dtype=\"int64\")\n", + " starts = np.arange(0, len(ids) - cfg.block_size - 1, cfg.block_size)\n", + " total, n = 0.0, 0\n", + " for i in range(0, len(starts), 64):\n", + " batch = starts[i : i + 64]\n", + " xb = np.stack([ids[s : s + cfg.block_size] for s in batch])\n", + " yb = np.stack([ids[s + 1 : s + 1 + cfg.block_size] for s in batch])\n", + " total += float(eval_fn(xb, yb)) * len(batch)\n", + " n += len(batch)\n", + " return total / n\n", + "\n", + "\n", + "holdout_text = full_text[100_000:110_000]\n", + "L_small = held_out_loss(build_eval_fn(cfg, params), cfg, stoi, holdout_text)\n", + "L_full = held_out_loss(build_eval_fn(cfg_full, params_full), cfg_full, stoi_full, holdout_text)\n", + "\n", + "print(f\"held-out CE (small, 2-layer, block 32): {L_small:.3f} ppl = {np.exp(L_small):.2f}\")\n", + "print(f\"held-out CE (large, 4-layer, block 64): {L_full :.3f} ppl = {np.exp(L_full ):.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A sample from the deeper model\n", + "\n", + "On held-out text the deeper model is genuinely better — about 0.10 nats per character lower cross-entropy, or **~10% lower perplexity** (5.69 vs 6.31). At this scale and training budget that is *not* enough to make the samples *look* coherent: both models still produce Shakespearean gibberish at the word level. What you can see in the sample below is firmer speaker-name structure and slightly more believable rhythm. We reuse the same `pytensor.scan` generator pattern — the entire autoregressive loop still lives inside one compiled call." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROMEO:\n", + "\n", + "Has remie my with to by many shots is ded thet.\n", + "\n", + "VIRGILILIA:\n", + "Let know Come, peopl! It mile, my which has men\n", + "As mark'd throw abe wors way aur palwind;' lis feed to Romme to\n", + "Come turn as pestile; and tgide for your to to the\n", + "a plutten tike kitie will it. Him awill, as; wheirs be\n", + "Our mocke.\n", + "\n", + "VIRLERIA:\n", + "The't deather, lor good! till.\n", + "\n", + "VIRILess!\n", + "\n", + "CICINIUS:\n", + "Net trimine eneman we aske,\n", + "That I mile appir\n" + ] + } + ], + "source": [ + "rng_full_sym = ptr.shared_rng(seed=2027, name=\"rng_full\")\n", + "\n", + "\n", + "def gen_step_full(context, rng):\n", + " logits_step = forward(context[None, :], params_full, cfg_full)[0, -1, :]\n", + " probs_step = pt.special.softmax(logits_step)\n", + " next_rng, next_tok = rng.categorical(p=probs_step)\n", + " new_context = pt.concatenate([context[1:], next_tok[None]])\n", + " return new_context, next_tok, next_rng\n", + "\n", + "\n", + "init_ctx_full = pt.vector(\"init_ctx_full\", dtype=\"int64\")\n", + "n_new_full = pt.iscalar(\"n_new_full\")\n", + "\n", + "_, tok_seq_full, rng_final_full = pytensor.scan(\n", + " fn=gen_step_full,\n", + " outputs_info=[init_ctx_full, None, rng_full_sym],\n", + " n_steps=n_new_full,\n", + " return_updates=False,\n", + ")\n", + "\n", + "generate_full_fn = pytensor.function(\n", + " [init_ctx_full, n_new_full],\n", + " tok_seq_full,\n", + " updates={rng_full_sym: rng_final_full},\n", + ")\n", + "\n", + "\n", + "def generate_full(prompt: str, n_new_tokens: int = 400) -> str:\n", + " ids = list(np.array([stoi_full[c] for c in prompt], dtype=\"int64\")) or [stoi_full[\"\\n\"]]\n", + " pad_id = stoi_full[\"\\n\"]\n", + " init_ctx = np.full(cfg_full.block_size, pad_id, dtype=\"int64\")\n", + " init_ctx[-len(ids):] = ids[-cfg_full.block_size:]\n", + " sampled = generate_full_fn(init_ctx, n_new_tokens)\n", + " return prompt + \"\".join(itos_full[int(i)] for i in sampled)\n", + "\n", + "\n", + "print(generate_full(\"ROMEO:\\n\", n_new_tokens=400))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "* A full **decoder-only transformer** — embeddings, multi-head causal attention, MLP, layernorm, tied softmax head, cross-entropy loss, and Adam — fits in roughly 100 lines of PyTensor. No custom `Op`, no backend-specific code.\n", + "* `pytensor.xtensor` named dimensions turned the trickiest part of the model (multi-head attention) into self-documenting code. The named-dim sub-graph is lowered to plain tensor ops at compile time — we just had to call `rewrite_graph(loss, include=(\"lower_xtensor\",))` once before `pytensor.grad` so the gradient pass walks the lowered graph.\n", + "* `pytensor.grad` gave us back-propagation through the entire stack as a *new symbolic graph*. We optimised that graph and compiled it into a single C/Numba `train_step`.\n", + "* `pytensor.shared` plus `updates=` made Adam a 15-line helper. Optimizer state lives next to the parameters in the graph, not in Python.\n", + "* `pytensor.scan` let us push autoregressive generation entirely inside the compiled graph — the Python wrapper only translates between text and ids; every forward pass and every categorical draw lives inside one C/Numba call.\n", + "\n", + "## Where to go from here\n", + "\n", + "* Swap `mode=\"NUMBA\"` (default) for `mode=\"JAX\"` to train on a GPU/TPU.\n", + "* Replace `tanh` with a real GELU and try a longer training run on the full 1.1 M-character corpus.\n", + "* Use `pytensor.dprint(train_step)` to inspect the optimised post-rewrite graph and see how many ops PyTensor's rewriter fused away.\n", + "\n", + "## Authors\n", + "\n", + "* Authored by the PyTensor developers in May 2026.\n", + "\n", + "## Watermark" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-07T13:16:56.512277Z", + "iopub.status.busy": "2026-05-07T13:16:56.512148Z", + "iopub.status.idle": "2026-05-07T13:16:56.518894Z", + "shell.execute_reply": "2026-05-07T13:16:56.518316Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The watermark extension is already loaded. To reload it, use:\n", + " %reload_ext watermark\n", + "Last updated: Fri, 22 May 2026\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.14.4\n", + "IPython version : 9.13.0\n", + "\n", + "pytensor: 3.0.0+18.g62e079c0e.dirty\n", + "\n", + "matplotlib: 3.10.9\n", + "numpy : 2.4.3\n", + "pytensor : 3.0.0+18.g62e079c0e.dirty\n", + "\n", + "Watermark: 2.6.0\n", + "\n" + ] + } + ], + "source": [ + "%load_ext watermark\n", + "%watermark -n -u -v -iv -w -p pytensor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{include} ../page_footer.md\n", + ":::\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3", + "path": "/Users/carlostrujillo/Library/Python/3.9/share/jupyter/kernels/python3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 5334e87f977bb0505da43e2225f5b54e07e7b33c Mon Sep 17 00:00:00 2001 From: Carlos Trujillo <59846724+cetagostini@users.noreply.github.com> Date: Mon, 8 Jun 2026 15:19:03 +0300 Subject: [PATCH 2/3] push --- .../transformers/tiny_transformer_llm.ipynb | 512 +++++------------- pytensor/xtensor/__init__.py | 9 +- 2 files changed, 129 insertions(+), 392 deletions(-) diff --git a/doc/gallery/transformers/tiny_transformer_llm.ipynb b/doc/gallery/transformers/tiny_transformer_llm.ipynb index 5a1c3954d1..f6fe713e65 100644 --- a/doc/gallery/transformers/tiny_transformer_llm.ipynb +++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb @@ -31,15 +31,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.125234Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pytensor: 3.0.0+18.g62e079c0e.dirty | floatX: float64\n" - ] - } - ], + "outputs": [], "source": [ "from __future__ import annotations\n", "\n", @@ -53,8 +45,7 @@ "\n", "import pytensor\n", "import pytensor.tensor as pt\n", - "import pytensor.tensor.random as ptr\n", - "import pytensor.xtensor as px\n", + "import pytensor.xtensor as ptx\n", "\n", "\n", "plt.style.use(\"seaborn-v0_8\")\n", @@ -86,33 +77,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.133378Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Full corpus: 1,115,394 characters\n", - "Used slice : 50,000 characters\n", - "\n", - "--- First 200 characters ---\n", - "\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" - ] - } - ], + "outputs": [], "source": [ "DATA_DIR = Path(\"data\")\n", "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", @@ -147,17 +112,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.141910Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "vocab_size = 59\n", - "first 20 ids: [15, 41, 50, 51, 52, 1, 12, 41, 52, 41, 58, 37, 46, 7, 0, 11, 37, 38, 47, 50]\n", - "round-trip : 'First Citizen:\\nBefor'\n" - ] - } - ], + "outputs": [], "source": [ "chars = sorted(set(text))\n", "vocab_size = len(chars)\n", @@ -196,16 +151,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.148415Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x[0]: 'renowned Coriola'\n", - "y[0]: 'enowned Coriolan'\n" - ] - } - ], + "outputs": [], "source": [ "def get_batch(rng: np.random.Generator, batch_size: int, block_size: int):\n", " \"\"\"Sample `batch_size` random windows of length `block_size + 1` from the corpus.\"\"\"\n", @@ -240,18 +186,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.156272Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "Config(vocab_size=59, block_size=32, n_embd=64, n_head=4, n_layer=2)" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "@dataclass\n", "class Config:\n", @@ -281,15 +216,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.166803Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20 shared variables, 104,768 total parameters\n" - ] - } - ], + "outputs": [], "source": [ "def init_params(cfg: Config, rng: np.random.Generator) -> dict[str, np.ndarray]:\n", " D = cfg.n_embd\n", @@ -344,9 +271,6 @@ }, "outputs": [], "source": [ - "from pytensor.xtensor.shape import stack as xstack\n", - "\n", - "\n", "def layernorm(x, gamma, beta, eps=1e-5):\n", " mu = x.mean(axis=-1, keepdims=True)\n", " var = x.var(axis=-1, keepdims=True)\n", @@ -359,34 +283,40 @@ " Inputs/outputs are plain `(B, T, D)` tensors. Internally we wrap them as\n", " xtensors with named dims and reshape `W_qkv` to expose ('qkv', 'head', 'hd')\n", " as named axes — from then on every op is pure semantics: contract over\n", - " 'embd', contract over 'hd' (head_dim), softmax over 'time_k'.\n", + " 'embd', contract over 'hd' (head_dim), softmax over 'time_k'. The `assert`s\n", + " on `.dims` aren't just documentation: PyTensor xtensors carry their dim\n", + " names symbolically, so they're always available for introspection.\n", " \"\"\"\n", " D = n_head * head_dim\n", - " x_x = px.as_xtensor(x, dims=(\"batch\", \"time\", \"embd\"))\n", - " Wqkv = px.as_xtensor(\n", + " x_x = ptx.as_xtensor(x, dims=(\"batch\", \"time\", \"embd\"))\n", + " Wqkv = ptx.as_xtensor(\n", " p[\"W_qkv\"].reshape((D, 3, n_head, head_dim)),\n", " dims=(\"embd\", \"qkv\", \"head\", \"hd\"),\n", " )\n", - " Wproj = px.as_xtensor(p[\"W_proj\"], dims=(\"embd\", \"embd_out\"))\n", + " Wproj = ptx.as_xtensor(p[\"W_proj\"], dims=(\"embd\", \"embd_out\"))\n", "\n", - " qkv = px.dot(x_x, Wqkv, dim=\"embd\") # (batch, time, qkv, head, hd)\n", + " qkv = ptx.dot(x_x, Wqkv, dim=\"embd\")\n", + " assert qkv.dims == (\"batch\", \"time\", \"qkv\", \"head\", \"hd\")\n", " q = qkv.isel(qkv=0).rename(time=\"time_q\")\n", " k = qkv.isel(qkv=1).rename(time=\"time_k\")\n", " v = qkv.isel(qkv=2).rename(time=\"time_k\")\n", "\n", " scale = np.sqrt(head_dim).astype(floatX)\n", - " scores = px.dot(q, k, dim=\"hd\") / scale # (batch, head, time_q, time_k)\n", + " scores = ptx.dot(q, k, dim=\"hd\") / scale\n", + " assert scores.dims == (\"batch\", \"time_q\", \"head\", \"time_k\")\n", "\n", - " mask = px.as_xtensor(\n", + " mask = ptx.as_xtensor(\n", " pt.tril(pt.ones((block_size, block_size), dtype=\"bool\")),\n", " dims=(\"time_q\", \"time_k\"),\n", " )\n", - " scores = px.where(mask, scores, np.float64(-1e9))\n", - " attn = px.math.softmax(scores, dim=\"time_k\")\n", - "\n", - " out = px.dot(attn, v, dim=\"time_k\") # (batch, head, time_q, hd)\n", - " out = xstack(out, embd=(\"head\", \"hd\")) # merge heads back\n", - " out = px.dot(out, Wproj, dim=\"embd\").rename(time_q=\"time\", embd_out=\"embd\")\n", + " scores = ptx.where(mask, scores, np.float64(-1e9))\n", + " attn = ptx.math.softmax(scores, dim=\"time_k\")\n", + "\n", + " out = ptx.dot(attn, v, dim=\"time_k\")\n", + " assert out.dims == (\"time_q\", \"batch\", \"head\", \"hd\")\n", + " out = ptx.stack(out, embd=(\"head\", \"hd\"))\n", + " assert out.dims == (\"time_q\", \"batch\", \"embd\")\n", + " out = ptx.dot(out, Wproj, dim=\"embd\").rename(time_q=\"time\", embd_out=\"embd\")\n", " return out.transpose(\"batch\", \"time\", \"embd\").values\n", "\n", "\n", @@ -431,37 +361,7 @@ "shell.execute_reply": "2026-05-07T13:13:27.284421Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "logits type: Tensor3(float64, shape=(?, 32, ?))\n", - "\n", - "--- forward graph (truncated) ---\n", - "Matmul [id A]\n", - " ├─ Add [id B]\n", - " │ ├─ Mul [id C]\n", - " │ │ ├─ True_div [id D]\n", - " │ │ └─ ExpandDims{axes=(0, 1)} [id E]\n", - " │ └─ ExpandDims{axes=(0, 1)} [id F]\n", - " │ └─ ln_f_b [id G]\n", - " └─ ExpandDims{axis=0} [id H]\n", - " └─ MatrixTranspose [id I] 'tok_embed.T'\n", - " └─ tok_embed [id J]\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "X_sym = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n", "logits = forward(X_sym, params, cfg)\n", @@ -481,16 +381,7 @@ "shell.execute_reply": "2026-05-07T13:13:30.359060Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "input shape : (4, 32)\n", - "logits shape: (4, 32, 59)\n" - ] - } - ], + "outputs": [], "source": [ "# Sanity check: compile the forward pass and feed a real batch.\n", "f_forward = pytensor.function([X_sym], logits)\n", @@ -523,16 +414,7 @@ "shell.execute_reply": "2026-05-07T13:13:30.435284Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loss is a Scalar(float64, shape=())\n", - "pytensor.grad returned 20 gradient graphs (one per shared variable).\n" - ] - } - ], + "outputs": [], "source": [ "from pytensor.graph.rewriting.utils import rewrite_graph\n", "\n", @@ -575,15 +457,7 @@ "shell.execute_reply": "2026-05-07T13:13:30.486661Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Adam adds 61 updates (20 params x 3 + 1 step counter).\n" - ] - } - ], + "outputs": [], "source": [ "def adam_updates(\n", " params, grads, lr=3e-3, b1=0.9, b2=0.999, eps=1e-8\n", @@ -626,16 +500,7 @@ "shell.execute_reply": "2026-05-07T13:13:44.103622Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Compilation took 2.0s\n", - "Initial loss = 4.078 (random baseline = 4.078)\n" - ] - } - ], + "outputs": [], "source": [ "t0 = time.time()\n", "train_step = pytensor.function([X_sym, Y_sym], loss, updates=updates)\n", @@ -658,32 +523,7 @@ "shell.execute_reply": "2026-05-07T13:14:19.641513Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step 0 recent-mean loss = 3.886\n", - "step 100 recent-mean loss = 2.835\n", - "step 200 recent-mean loss = 2.398\n", - "step 300 recent-mean loss = 2.234\n", - "step 400 recent-mean loss = 2.129\n", - "step 500 recent-mean loss = 2.050\n", - "step 600 recent-mean loss = 1.984\n", - "step 700 recent-mean loss = 1.930\n", - "step 800 recent-mean loss = 1.884\n", - "step 900 recent-mean loss = 1.833\n", - "step 1000 recent-mean loss = 1.793\n", - "step 1100 recent-mean loss = 1.770\n", - "step 1200 recent-mean loss = 1.728\n", - "step 1300 recent-mean loss = 1.705\n", - "step 1400 recent-mean loss = 1.674\n", - "step 1499 recent-mean loss = 1.650\n", - "\n", - "Total training time: 32.8s\n" - ] - } - ], + "outputs": [], "source": [ "BATCH_SIZE = 32\n", "N_STEPS = 1500\n", @@ -711,23 +551,7 @@ "shell.execute_reply": "2026-05-07T13:14:19.738756Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 391, - "width": 689 - } - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(figsize=(8, 4))\n", "ax.plot(losses, lw=0.6, alpha=0.5, label=\"raw\")\n", @@ -750,7 +574,11 @@ "source": [ "## Sampling — the autoregressive loop lives inside `pytensor.scan`\n", "\n", - "For inference we feed the model a context window and sample the next character from the predicted distribution over the vocabulary. PyTensor lets us push the entire autoregressive loop **into the compiled graph** with `pytensor.scan`: every forward pass, every categorical draw, all the context-window bookkeeping becomes a single C/Numba call. We use `pt.random.shared_rng` so the RNG state advances **inside** the compiled function — each call returns an independent draw. This pattern matches the one in the [scan tutorial](../scan/scan_tutorial.ipynb)." + "For inference we feed the model a context window and sample the next character from the predicted distribution over the vocabulary. PyTensor lets us push the entire autoregressive loop **into the compiled graph** with `pytensor.scan`: every forward pass, every categorical draw, all the context-window bookkeeping becomes a single C/Numba call. We use `ptx.random.shared_rng` so the RNG state advances **inside** the compiled function — each call returns an independent draw. This pattern matches the one in the [scan tutorial](../scan/scan_tutorial.ipynb).\n", + "\n", + "We keep the context window and the categorical sampling as **xtensor** ops: that way the sliding window is a named-dim `concat` rather than positional `pt.concatenate`, and `categorical` consumes a `probs` xtensor with a `vocab` core dim. `pytensor.scan` itself only carries plain tensor variables across iterations, so we cross the xtensor↔tensor boundary in four places: convert to tensor before passing into the scan, back to xtensor at the top of the body, back to tensor before returning, and back to xtensor as soon as we get the scan outputs out.\n", + "\n", + "We also turn this into a **while-scan**: `pytensor.scan` accepts a `(outputs, until(cond))` return from the body and stops as soon as `cond` becomes true. Here we stop on the first newline — Tiny Shakespeare uses `\\n` as a hard break between speakers — capped by `n_new_sym` as a safety net." ] }, { @@ -764,69 +592,73 @@ "shell.execute_reply": "2026-05-07T13:14:22.514743Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ROMEO:\n", - "He have shut thing disp: eat fitorer, which bee spose!\n", - "Thaction wranter toge. A godd some; at, powarth libout quh e and such arothy to prome-cany be frie thing.\n", - "\n", - "COMINIUS:\n", - "Now ust, pry state more veily, the cry mam fors,\n", - "Our fithy done for thy baraddy at, doubt ithen\n", - "diesws sagch.\n", - "\n", - "MENENIUS:\n", - "Node most\n", - "Rele's buths is ather shencered honours\n", - "To made the neme of then you thums,\n", - "Them heate the me the\n" - ] - } - ], + "outputs": [], "source": [ - "rng_sym = ptr.shared_rng(seed=2026, name=\"rng_sample\")\n", + "from pytensor.scan import until\n", + "\n", + "EOS_ID = stoi[\"\\n\"]\n", + "rng_sym = ptx.random.shared_rng(seed=2026, name=\"rng_sample\")\n", "\n", "\n", - "def gen_step(context, rng):\n", + "def gen_step(context_t, rng):\n", " \"\"\"One generation step inside the scan loop.\n", "\n", - " `context` is a length-`block_size` int64 vector. We forward through the model, sample the\n", - " next token, then shift the context window left by one and append the new token.\n", + " `context_t` arrives as a length-`block_size` int64 *tensor* — scan only\n", + " carries tensor variables across iterations — and we immediately wrap it\n", + " as an xtensor with a `time` dim. The forward pass is tensor-native, so\n", + " we dip back to tensor land for that single call, then go back to\n", + " xtensor for the sample + window slide.\n", " \"\"\"\n", - " logits_step = forward(context[None, :], params, cfg)[0, -1, :] # (V,)\n", - " probs_step = pt.special.softmax(logits_step)\n", - " next_rng, next_tok = rng.categorical(p=probs_step)\n", - " new_context = pt.concatenate([context[1:], next_tok[None]])\n", - " return new_context, next_tok, next_rng\n", + " context = ptx.as_xtensor(context_t, dims=(\"time\",))\n", + " assert context.dims == (\"time\",)\n", "\n", + " logits_step = ptx.as_xtensor(\n", + " forward(context_t[None, :], params, cfg)[0, -1], dims=(\"vocab\",)\n", + " )\n", + " probs_step = ptx.math.softmax(logits_step, dim=\"vocab\")\n", + " next_rng, next_tok = rng.categorical(probs_step, core_dims=\"vocab\")\n", + " assert next_tok.dims == ()\n", + "\n", + " new_context = ptx.concat(\n", + " [context.isel(time=slice(1, None)), next_tok.expand_dims(\"time\")],\n", + " dim=\"time\",\n", + " )\n", + " assert new_context.dims == (\"time\",)\n", "\n", - "init_ctx_sym = pt.vector(\"init_ctx\", dtype=\"int64\")\n", + " return (\n", + " [new_context.values, next_tok.values, next_rng],\n", + " until(pt.eq(next_tok.values, EOS_ID)),\n", + " )\n", + "\n", + "\n", + "init_ctx_x = ptx.xtensor(\n", + " \"init_ctx\", dims=(\"time\",), shape=(cfg.block_size,), dtype=\"int64\"\n", + ")\n", "n_new_sym = pt.iscalar(\"n_new\")\n", "\n", - "ctx_seq, tok_seq, rng_final = pytensor.scan(\n", + "ctx_seq_t, tok_seq_t, rng_final = pytensor.scan(\n", " fn=gen_step,\n", - " outputs_info=[init_ctx_sym, None, rng_sym],\n", + " outputs_info=[init_ctx_x.values, None, rng_sym],\n", " n_steps=n_new_sym,\n", " return_updates=False,\n", ")\n", + "tok_seq = ptx.as_xtensor(tok_seq_t, dims=(\"step\",))\n", + "assert tok_seq.dims == (\"step\",)\n", "\n", "generate_fn = pytensor.function(\n", - " [init_ctx_sym, n_new_sym],\n", - " tok_seq,\n", + " [init_ctx_x, n_new_sym],\n", + " tok_seq.values,\n", " updates={rng_sym: rng_final},\n", ")\n", "\n", "\n", "def generate(prompt: str, n_new_tokens: int = 400) -> str:\n", " \"\"\"Run autoregressive generation. The Python wrapper only handles text ↔ ids;\n", - " every forward pass and every sample lives inside the compiled scan.\n", + " every forward pass and every sample lives inside the compiled scan, which\n", + " stops early at the first newline or after ``n_new_tokens`` steps.\n", " \"\"\"\n", - " ids = list(encode(prompt)) or [stoi[\"\\n\"]]\n", - " pad_id = stoi[\"\\n\"]\n", - " init_ctx = np.full(cfg.block_size, pad_id, dtype=\"int64\")\n", + " ids = list(encode(prompt)) or [EOS_ID]\n", + " init_ctx = np.full(cfg.block_size, EOS_ID, dtype=\"int64\")\n", " init_ctx[-len(ids):] = ids[-cfg.block_size:]\n", " sampled = generate_fn(init_ctx, n_new_tokens)\n", " return prompt + decode(sampled)\n", @@ -852,17 +684,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "corpus slice: 100,000 chars, vocab: 61\n", - "cfg_full : Config(vocab_size=61, block_size=64, n_embd=64, n_head=4, n_layer=4)\n", - "params : 205,760\n" - ] - } - ], + "outputs": [], "source": [ "text_full = full_text[:100_000]\n", "chars_full = sorted(set(text_full))\n", @@ -922,15 +744,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Compilation took 4.9s\n" - ] - } - ], + "outputs": [], "source": [ "BATCH_FULL = 32\n", "N_STEPS_FULL = 1500\n", @@ -943,32 +757,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step 0 recent-mean loss = 4.141\n", - "step 100 recent-mean loss = 2.934\n", - "step 200 recent-mean loss = 2.462\n", - "step 300 recent-mean loss = 2.297\n", - "step 400 recent-mean loss = 2.163\n", - "step 500 recent-mean loss = 2.051\n", - "step 600 recent-mean loss = 1.962\n", - "step 700 recent-mean loss = 1.884\n", - "step 800 recent-mean loss = 1.822\n", - "step 900 recent-mean loss = 1.763\n", - "step 1000 recent-mean loss = 1.722\n", - "step 1100 recent-mean loss = 1.688\n", - "step 1200 recent-mean loss = 1.658\n", - "step 1300 recent-mean loss = 1.628\n", - "step 1400 recent-mean loss = 1.598\n", - "step 1499 recent-mean loss = 1.569\n", - "\n", - "Total training time: 211.8s\n" - ] - } - ], + "outputs": [], "source": [ "rng_full = np.random.default_rng(123)\n", "losses_full: list[float] = []\n", @@ -987,23 +776,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 391, - "width": 766 - } - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(figsize=(9, 4))\n", "ax.plot(losses_full, alpha=0.4, label=\"raw\")\n", @@ -1032,16 +805,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "held-out CE (small, 2-layer, block 32): 1.841 ppl = 6.31\n", - "held-out CE (large, 4-layer, block 64): 1.738 ppl = 5.69\n" - ] - } - ], + "outputs": [], "source": [ "def build_eval_fn(cfg, params_dict):\n", " \"\"\"Compile a forward + cross-entropy function that reads from the shared params.\"\"\"\n", @@ -1091,66 +855,52 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ROMEO:\n", - "\n", - "Has remie my with to by many shots is ded thet.\n", - "\n", - "VIRGILILIA:\n", - "Let know Come, peopl! It mile, my which has men\n", - "As mark'd throw abe wors way aur palwind;' lis feed to Romme to\n", - "Come turn as pestile; and tgide for your to to the\n", - "a plutten tike kitie will it. Him awill, as; wheirs be\n", - "Our mocke.\n", - "\n", - "VIRLERIA:\n", - "The't deather, lor good! till.\n", - "\n", - "VIRILess!\n", - "\n", - "CICINIUS:\n", - "Net trimine eneman we aske,\n", - "That I mile appir\n" - ] - } - ], + "outputs": [], "source": [ - "rng_full_sym = ptr.shared_rng(seed=2027, name=\"rng_full\")\n", + "EOS_ID_FULL = stoi_full[\"\\n\"]\n", + "rng_full_sym = ptx.random.shared_rng(seed=2027, name=\"rng_full\")\n", "\n", "\n", - "def gen_step_full(context, rng):\n", - " logits_step = forward(context[None, :], params_full, cfg_full)[0, -1, :]\n", - " probs_step = pt.special.softmax(logits_step)\n", - " next_rng, next_tok = rng.categorical(p=probs_step)\n", - " new_context = pt.concatenate([context[1:], next_tok[None]])\n", - " return new_context, next_tok, next_rng\n", + "def gen_step_full(context_t, rng):\n", + " context = ptx.as_xtensor(context_t, dims=(\"time\",))\n", + " logits_step = ptx.as_xtensor(\n", + " forward(context_t[None, :], params_full, cfg_full)[0, -1], dims=(\"vocab\",)\n", + " )\n", + " probs_step = ptx.math.softmax(logits_step, dim=\"vocab\")\n", + " next_rng, next_tok = rng.categorical(probs_step, core_dims=\"vocab\")\n", + " new_context = ptx.concat(\n", + " [context.isel(time=slice(1, None)), next_tok.expand_dims(\"time\")],\n", + " dim=\"time\",\n", + " )\n", + " return (\n", + " [new_context.values, next_tok.values, next_rng],\n", + " until(pt.eq(next_tok.values, EOS_ID_FULL)),\n", + " )\n", "\n", "\n", - "init_ctx_full = pt.vector(\"init_ctx_full\", dtype=\"int64\")\n", + "init_ctx_full = ptx.xtensor(\n", + " \"init_ctx_full\", dims=(\"time\",), shape=(cfg_full.block_size,), dtype=\"int64\"\n", + ")\n", "n_new_full = pt.iscalar(\"n_new_full\")\n", "\n", - "_, tok_seq_full, rng_final_full = pytensor.scan(\n", + "_, tok_seq_full_t, rng_final_full = pytensor.scan(\n", " fn=gen_step_full,\n", - " outputs_info=[init_ctx_full, None, rng_full_sym],\n", + " outputs_info=[init_ctx_full.values, None, rng_full_sym],\n", " n_steps=n_new_full,\n", " return_updates=False,\n", ")\n", + "tok_seq_full = ptx.as_xtensor(tok_seq_full_t, dims=(\"step\",))\n", "\n", "generate_full_fn = pytensor.function(\n", " [init_ctx_full, n_new_full],\n", - " tok_seq_full,\n", + " tok_seq_full.values,\n", " updates={rng_full_sym: rng_final_full},\n", ")\n", "\n", "\n", "def generate_full(prompt: str, n_new_tokens: int = 400) -> str:\n", - " ids = list(np.array([stoi_full[c] for c in prompt], dtype=\"int64\")) or [stoi_full[\"\\n\"]]\n", - " pad_id = stoi_full[\"\\n\"]\n", - " init_ctx = np.full(cfg_full.block_size, pad_id, dtype=\"int64\")\n", + " ids = list(np.array([stoi_full[c] for c in prompt], dtype=\"int64\")) or [EOS_ID_FULL]\n", + " init_ctx = np.full(cfg_full.block_size, EOS_ID_FULL, dtype=\"int64\")\n", " init_ctx[-len(ids):] = ids[-cfg_full.block_size:]\n", " sampled = generate_full_fn(init_ctx, n_new_tokens)\n", " return prompt + \"\".join(itos_full[int(i)] for i in sampled)\n", @@ -1195,30 +945,7 @@ "shell.execute_reply": "2026-05-07T13:16:56.518316Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The watermark extension is already loaded. To reload it, use:\n", - " %reload_ext watermark\n", - "Last updated: Fri, 22 May 2026\n", - "\n", - "Python implementation: CPython\n", - "Python version : 3.14.4\n", - "IPython version : 9.13.0\n", - "\n", - "pytensor: 3.0.0+18.g62e079c0e.dirty\n", - "\n", - "matplotlib: 3.10.9\n", - "numpy : 2.4.3\n", - "pytensor : 3.0.0+18.g62e079c0e.dirty\n", - "\n", - "Watermark: 2.6.0\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext watermark\n", "%watermark -n -u -v -iv -w -p pytensor" @@ -1235,10 +962,13 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "pytensor-dev", "language": "python", - "name": "python3", - "path": "/Users/carlostrujillo/Library/Python/3.9/share/jupyter/kernels/python3" + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.14.4" } }, "nbformat": 4, diff --git a/pytensor/xtensor/__init__.py b/pytensor/xtensor/__init__.py index 22de7642f1..c2ab4126f5 100644 --- a/pytensor/xtensor/__init__.py +++ b/pytensor/xtensor/__init__.py @@ -1,7 +1,14 @@ import pytensor.xtensor.rewriting from pytensor.xtensor import linalg, math, random, signal from pytensor.xtensor.math import dot, where -from pytensor.xtensor.shape import broadcast, concat, full_like, ones_like, zeros_like +from pytensor.xtensor.shape import ( + broadcast, + concat, + full_like, + ones_like, + stack, + zeros_like, +) from pytensor.xtensor.type import ( as_xtensor, xtensor, From b70edb7b01031e09cd0abbf05feda9a1d2114c06 Mon Sep 17 00:00:00 2001 From: Carlos Trujillo <59846724+cetagostini@users.noreply.github.com> Date: Tue, 16 Jun 2026 14:54:42 +0300 Subject: [PATCH 3/3] Update tiny_transformer_llm.ipynb --- .../transformers/tiny_transformer_llm.ipynb | 394 ++++++++++++++++-- 1 file changed, 348 insertions(+), 46 deletions(-) diff --git a/doc/gallery/transformers/tiny_transformer_llm.ipynb b/doc/gallery/transformers/tiny_transformer_llm.ipynb index f6fe713e65..2f1e8771e9 100644 --- a/doc/gallery/transformers/tiny_transformer_llm.ipynb +++ b/doc/gallery/transformers/tiny_transformer_llm.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:26.660089Z", @@ -31,7 +31,15 @@ "shell.execute_reply": "2026-05-07T13:13:27.125234Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pytensor: 3.0.5+30.g1bb3ee02f | floatX: float64\n" + ] + } + ], "source": [ "from __future__ import annotations\n", "\n", @@ -68,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.129250Z", @@ -77,7 +85,34 @@ "shell.execute_reply": "2026-05-07T13:13:27.133378Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt\n", + "Full corpus: 1,115,394 characters\n", + "Used slice : 50,000 characters\n", + "\n", + "--- First 200 characters ---\n", + "\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": [ "DATA_DIR = Path(\"data\")\n", "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", @@ -103,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.136096Z", @@ -112,7 +147,17 @@ "shell.execute_reply": "2026-05-07T13:13:27.141910Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vocab_size = 59\n", + "first 20 ids: [15, 41, 50, 51, 52, 1, 12, 41, 52, 41, 58, 37, 46, 7, 0, 11, 37, 38, 47, 50]\n", + "round-trip : 'First Citizen:\\nBefor'\n" + ] + } + ], "source": [ "chars = sorted(set(text))\n", "vocab_size = len(chars)\n", @@ -142,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.145023Z", @@ -151,7 +196,16 @@ "shell.execute_reply": "2026-05-07T13:13:27.148415Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x[0]: 'renowned Coriola'\n", + "y[0]: 'enowned Coriolan'\n" + ] + } + ], "source": [ "def get_batch(rng: np.random.Generator, batch_size: int, block_size: int):\n", " \"\"\"Sample `batch_size` random windows of length `block_size + 1` from the corpus.\"\"\"\n", @@ -177,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.151290Z", @@ -186,7 +240,18 @@ "shell.execute_reply": "2026-05-07T13:13:27.156272Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Config(vocab_size=59, block_size=32, n_embd=64, n_head=4, n_layer=2)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "@dataclass\n", "class Config:\n", @@ -207,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.158183Z", @@ -216,7 +281,15 @@ "shell.execute_reply": "2026-05-07T13:13:27.166803Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 shared variables, 104,768 total parameters\n" + ] + } + ], "source": [ "def init_params(cfg: Config, rng: np.random.Generator) -> dict[str, np.ndarray]:\n", " D = cfg.n_embd\n", @@ -260,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.168815Z", @@ -352,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.175559Z", @@ -361,7 +434,37 @@ "shell.execute_reply": "2026-05-07T13:13:27.284421Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logits type: Tensor3(float64, shape=(?, 32, ?))\n", + "\n", + "--- forward graph (truncated) ---\n", + "Matmul [id A]\n", + " ├─ Add [id B]\n", + " │ ├─ Mul [id C]\n", + " │ │ ├─ True_div [id D]\n", + " │ │ └─ ExpandDims{axes=(0, 1)} [id E]\n", + " │ └─ ExpandDims{axes=(0, 1)} [id F]\n", + " │ └─ ln_f_b [id G]\n", + " └─ ExpandDims{axis=0} [id H]\n", + " └─ MatrixTranspose [id I] 'tok_embed.T'\n", + " └─ tok_embed [id J]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "X_sym = pt.tensor(\"X\", shape=(None, cfg.block_size), dtype=\"int64\")\n", "logits = forward(X_sym, params, cfg)\n", @@ -372,7 +475,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:27.286619Z", @@ -381,7 +484,16 @@ "shell.execute_reply": "2026-05-07T13:13:30.359060Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input shape : (4, 32)\n", + "logits shape: (4, 32, 59)\n" + ] + } + ], "source": [ "# Sanity check: compile the forward pass and feed a real batch.\n", "f_forward = pytensor.function([X_sym], logits)\n", @@ -405,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:30.361026Z", @@ -414,7 +526,16 @@ "shell.execute_reply": "2026-05-07T13:13:30.435284Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss is a Scalar(float64, shape=())\n", + "pytensor.grad returned 20 gradient graphs (one per shared variable).\n" + ] + } + ], "source": [ "from pytensor.graph.rewriting.utils import rewrite_graph\n", "\n", @@ -448,7 +569,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:30.437214Z", @@ -457,7 +578,15 @@ "shell.execute_reply": "2026-05-07T13:13:30.486661Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adam adds 61 updates (20 params x 3 + 1 step counter).\n" + ] + } + ], "source": [ "def adam_updates(\n", " params, grads, lr=3e-3, b1=0.9, b2=0.999, eps=1e-8\n", @@ -491,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:30.488447Z", @@ -500,7 +629,16 @@ "shell.execute_reply": "2026-05-07T13:13:44.103622Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compilation took 3.5s\n", + "Initial loss = 4.078 (random baseline = 4.078)\n" + ] + } + ], "source": [ "t0 = time.time()\n", "train_step = pytensor.function([X_sym, Y_sym], loss, updates=updates)\n", @@ -514,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:13:44.105474Z", @@ -523,7 +661,32 @@ "shell.execute_reply": "2026-05-07T13:14:19.641513Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0 recent-mean loss = 3.886\n", + "step 100 recent-mean loss = 2.835\n", + "step 200 recent-mean loss = 2.398\n", + "step 300 recent-mean loss = 2.234\n", + "step 400 recent-mean loss = 2.129\n", + "step 500 recent-mean loss = 2.050\n", + "step 600 recent-mean loss = 1.984\n", + "step 700 recent-mean loss = 1.930\n", + "step 800 recent-mean loss = 1.884\n", + "step 900 recent-mean loss = 1.833\n", + "step 1000 recent-mean loss = 1.793\n", + "step 1100 recent-mean loss = 1.770\n", + "step 1200 recent-mean loss = 1.728\n", + "step 1300 recent-mean loss = 1.705\n", + "step 1400 recent-mean loss = 1.674\n", + "step 1499 recent-mean loss = 1.650\n", + "\n", + "Total training time: 32.3s\n" + ] + } + ], "source": [ "BATCH_SIZE = 32\n", "N_STEPS = 1500\n", @@ -542,7 +705,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:14:19.643434Z", @@ -551,7 +714,23 @@ "shell.execute_reply": "2026-05-07T13:14:19.738756Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 391, + "width": 689 + } + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(figsize=(8, 4))\n", "ax.plot(losses, lw=0.6, alpha=0.5, label=\"raw\")\n", @@ -583,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:14:19.741016Z", @@ -592,7 +771,17 @@ "shell.execute_reply": "2026-05-07T13:14:22.514743Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROMEO:\n", + "He have shut thing disp: eat fitorer, which bee spose!\n", + "\n" + ] + } + ], "source": [ "from pytensor.scan import until\n", "\n", @@ -682,9 +871,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "corpus slice: 100,000 chars, vocab: 61\n", + "cfg_full : Config(vocab_size=61, block_size=64, n_embd=64, n_head=4, n_layer=4)\n", + "params : 205,760\n" + ] + } + ], "source": [ "text_full = full_text[:100_000]\n", "chars_full = sorted(set(text_full))\n", @@ -718,7 +917,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -742,9 +941,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compilation took 10.3s\n" + ] + } + ], "source": [ "BATCH_FULL = 32\n", "N_STEPS_FULL = 1500\n", @@ -755,9 +962,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0 recent-mean loss = 4.141\n", + "step 100 recent-mean loss = 2.934\n", + "step 200 recent-mean loss = 2.462\n", + "step 300 recent-mean loss = 2.297\n", + "step 400 recent-mean loss = 2.163\n", + "step 500 recent-mean loss = 2.051\n", + "step 600 recent-mean loss = 1.962\n", + "step 700 recent-mean loss = 1.884\n", + "step 800 recent-mean loss = 1.822\n", + "step 900 recent-mean loss = 1.763\n", + "step 1000 recent-mean loss = 1.722\n", + "step 1100 recent-mean loss = 1.688\n", + "step 1200 recent-mean loss = 1.658\n", + "step 1300 recent-mean loss = 1.628\n", + "step 1400 recent-mean loss = 1.598\n", + "step 1499 recent-mean loss = 1.569\n", + "\n", + "Total training time: 185.1s\n" + ] + } + ], "source": [ "rng_full = np.random.default_rng(123)\n", "losses_full: list[float] = []\n", @@ -774,9 +1006,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 391, + "width": 766 + } + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(figsize=(9, 4))\n", "ax.plot(losses_full, alpha=0.4, label=\"raw\")\n", @@ -803,9 +1051,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "held-out CE (small, 2-layer, block 32): 1.841 ppl = 6.31\n", + "held-out CE (large, 4-layer, block 64): 1.738 ppl = 5.69\n" + ] + } + ], "source": [ "def build_eval_fn(cfg, params_dict):\n", " \"\"\"Compile a forward + cross-entropy function that reads from the shared params.\"\"\"\n", @@ -853,7 +1110,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -903,9 +1160,25 @@ " init_ctx = np.full(cfg_full.block_size, EOS_ID_FULL, dtype=\"int64\")\n", " init_ctx[-len(ids):] = ids[-cfg_full.block_size:]\n", " sampled = generate_full_fn(init_ctx, n_new_tokens)\n", - " return prompt + \"\".join(itos_full[int(i)] for i in sampled)\n", - "\n", - "\n", + " return prompt + \"\".join(itos_full[int(i)] for i in sampled)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROMEO:\n", + "But be teak of the thus.\n", + "\n" + ] + } + ], + "source": [ "print(generate_full(\"ROMEO:\\n\", n_new_tokens=400))" ] }, @@ -936,7 +1209,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2026-05-07T13:16:56.512277Z", @@ -945,7 +1218,28 @@ "shell.execute_reply": "2026-05-07T13:16:56.518316Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last updated: Tue, 16 Jun 2026\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.14.4\n", + "IPython version : 9.13.0\n", + "\n", + "pytensor: 3.0.5+30.g1bb3ee02f\n", + "\n", + "matplotlib: 3.10.9\n", + "numpy : 2.4.3\n", + "pytensor : 3.0.5+30.g1bb3ee02f\n", + "\n", + "Watermark: 2.6.0\n", + "\n" + ] + } + ], "source": [ "%load_ext watermark\n", "%watermark -n -u -v -iv -w -p pytensor" @@ -967,7 +1261,15 @@ "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.14.4" } },