{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b343928b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: datasets in ./.venv/lib/python3.13/site-packages (4.3.0)\n",
      "Requirement already satisfied: tiktoken in ./.venv/lib/python3.13/site-packages (0.12.0)\n",
      "Requirement already satisfied: tqdm in ./.venv/lib/python3.13/site-packages (4.67.1)\n",
      "Requirement already satisfied: numpy in ./.venv/lib/python3.13/site-packages (2.3.4)\n",
      "Requirement already satisfied: torch in ./.venv/lib/python3.13/site-packages (2.9.0)\n",
      "Requirement already satisfied: filelock in ./.venv/lib/python3.13/site-packages (from datasets) (3.20.0)\n",
      "Requirement already satisfied: pyarrow>=21.0.0 in ./.venv/lib/python3.13/site-packages (from datasets) (22.0.0)\n",
      "Requirement already satisfied: dill<0.4.1,>=0.3.0 in ./.venv/lib/python3.13/site-packages (from datasets) (0.4.0)\n",
      "Requirement already satisfied: pandas in ./.venv/lib/python3.13/site-packages (from datasets) (2.3.3)\n",
      "Requirement already satisfied: requests>=2.32.2 in ./.venv/lib/python3.13/site-packages (from datasets) (2.32.5)\n",
      "Requirement already satisfied: httpx<1.0.0 in ./.venv/lib/python3.13/site-packages (from datasets) (0.28.1)\n",
      "Requirement already satisfied: xxhash in ./.venv/lib/python3.13/site-packages (from datasets) (3.6.0)\n",
      "Requirement already satisfied: multiprocess<0.70.17 in ./.venv/lib/python3.13/site-packages (from datasets) (0.70.16)\n",
      "Requirement already satisfied: fsspec<=2025.9.0,>=2023.1.0 in ./.venv/lib/python3.13/site-packages (from fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (2025.9.0)\n",
      "Requirement already satisfied: huggingface-hub<2.0,>=0.25.0 in ./.venv/lib/python3.13/site-packages (from datasets) (0.36.0)\n",
      "Requirement already satisfied: packaging in ./.venv/lib/python3.13/site-packages (from datasets) (25.0)\n",
      "Requirement already satisfied: pyyaml>=5.1 in ./.venv/lib/python3.13/site-packages (from datasets) (6.0.3)\n",
      "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in ./.venv/lib/python3.13/site-packages (from fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (3.13.1)\n",
      "Requirement already satisfied: anyio in ./.venv/lib/python3.13/site-packages (from httpx<1.0.0->datasets) (4.11.0)\n",
      "Requirement already satisfied: certifi in ./.venv/lib/python3.13/site-packages (from httpx<1.0.0->datasets) (2025.10.5)\n",
      "Requirement already satisfied: httpcore==1.* in ./.venv/lib/python3.13/site-packages (from httpx<1.0.0->datasets) (1.0.9)\n",
      "Requirement already satisfied: idna in ./.venv/lib/python3.13/site-packages (from httpx<1.0.0->datasets) (3.11)\n",
      "Requirement already satisfied: h11>=0.16 in ./.venv/lib/python3.13/site-packages (from httpcore==1.*->httpx<1.0.0->datasets) (0.16.0)\n",
      "Requirement already satisfied: typing-extensions>=3.7.4.3 in ./.venv/lib/python3.13/site-packages (from huggingface-hub<2.0,>=0.25.0->datasets) (4.15.0)\n",
      "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in ./.venv/lib/python3.13/site-packages (from huggingface-hub<2.0,>=0.25.0->datasets) (1.2.0)\n",
      "Requirement already satisfied: regex>=2022.1.18 in ./.venv/lib/python3.13/site-packages (from tiktoken) (2025.10.23)\n",
      "Requirement already satisfied: setuptools in ./.venv/lib/python3.13/site-packages (from torch) (80.9.0)\n",
      "Requirement already satisfied: sympy>=1.13.3 in ./.venv/lib/python3.13/site-packages (from torch) (1.14.0)\n",
      "Requirement already satisfied: networkx>=2.5.1 in ./.venv/lib/python3.13/site-packages (from torch) (3.5)\n",
      "Requirement already satisfied: jinja2 in ./.venv/lib/python3.13/site-packages (from torch) (3.1.6)\n",
      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.93)\n",
      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.90)\n",
      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.90)\n",
      "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in ./.venv/lib/python3.13/site-packages (from torch) (9.10.2.21)\n",
      "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.4.1)\n",
      "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in ./.venv/lib/python3.13/site-packages (from torch) (11.3.3.83)\n",
      "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in ./.venv/lib/python3.13/site-packages (from torch) (10.3.9.90)\n",
      "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in ./.venv/lib/python3.13/site-packages (from torch) (11.7.3.90)\n",
      "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in ./.venv/lib/python3.13/site-packages (from torch) (12.5.8.93)\n",
      "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in ./.venv/lib/python3.13/site-packages (from torch) (0.7.1)\n",
      "Requirement already satisfied: nvidia-nccl-cu12==2.27.5 in ./.venv/lib/python3.13/site-packages (from torch) (2.27.5)\n",
      "Requirement already satisfied: nvidia-nvshmem-cu12==3.3.20 in ./.venv/lib/python3.13/site-packages (from torch) (3.3.20)\n",
      "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.90)\n",
      "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in ./.venv/lib/python3.13/site-packages (from torch) (12.8.93)\n",
      "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in ./.venv/lib/python3.13/site-packages (from torch) (1.13.1.3)\n",
      "Requirement already satisfied: triton==3.5.0 in ./.venv/lib/python3.13/site-packages (from torch) (3.5.0)\n",
      "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (2.6.1)\n",
      "Requirement already satisfied: aiosignal>=1.4.0 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (1.4.0)\n",
      "Requirement already satisfied: attrs>=17.3.0 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (25.4.0)\n",
      "Requirement already satisfied: frozenlist>=1.1.1 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (1.8.0)\n",
      "Requirement already satisfied: multidict<7.0,>=4.5 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (6.7.0)\n",
      "Requirement already satisfied: propcache>=0.2.0 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (0.4.1)\n",
      "Requirement already satisfied: yarl<2.0,>=1.17.0 in ./.venv/lib/python3.13/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.9.0,>=2023.1.0->datasets) (1.22.0)\n",
      "Requirement already satisfied: charset_normalizer<4,>=2 in ./.venv/lib/python3.13/site-packages (from requests>=2.32.2->datasets) (3.4.4)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in ./.venv/lib/python3.13/site-packages (from requests>=2.32.2->datasets) (2.5.0)\n",
      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in ./.venv/lib/python3.13/site-packages (from sympy>=1.13.3->torch) (1.3.0)\n",
      "Requirement already satisfied: sniffio>=1.1 in ./.venv/lib/python3.13/site-packages (from anyio->httpx<1.0.0->datasets) (1.3.1)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in ./.venv/lib/python3.13/site-packages (from jinja2->torch) (3.0.3)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in ./.venv/lib/python3.13/site-packages (from pandas->datasets) (2.9.0.post0)\n",
      "Requirement already satisfied: pytz>=2020.1 in ./.venv/lib/python3.13/site-packages (from pandas->datasets) (2025.2)\n",
      "Requirement already satisfied: tzdata>=2022.7 in ./.venv/lib/python3.13/site-packages (from pandas->datasets) (2025.2)\n",
      "Requirement already satisfied: six>=1.5 in ./.venv/lib/python3.13/site-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.17.0)\n",
      "Requirement already satisfied: matplotlib in ./.venv/lib/python3.13/site-packages (3.10.7)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in ./.venv/lib/python3.13/site-packages (from matplotlib) (1.3.3)\n",
      "Requirement already satisfied: cycler>=0.10 in ./.venv/lib/python3.13/site-packages (from matplotlib) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in ./.venv/lib/python3.13/site-packages (from matplotlib) (4.60.1)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in ./.venv/lib/python3.13/site-packages (from matplotlib) (1.4.9)\n",
      "Requirement already satisfied: numpy>=1.23 in ./.venv/lib/python3.13/site-packages (from matplotlib) (2.3.4)\n",
      "Requirement already satisfied: packaging>=20.0 in ./.venv/lib/python3.13/site-packages (from matplotlib) (25.0)\n",
      "Requirement already satisfied: pillow>=8 in ./.venv/lib/python3.13/site-packages (from matplotlib) (12.0.0)\n",
      "Requirement already satisfied: pyparsing>=3 in ./.venv/lib/python3.13/site-packages (from matplotlib) (3.2.5)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in ./.venv/lib/python3.13/site-packages (from matplotlib) (2.9.0.post0)\n",
      "Requirement already satisfied: six>=1.5 in ./.venv/lib/python3.13/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/namit/slm/.venv/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyTorch version: 2.9.0+cu128\n",
      "CUDA available: True\n",
      "CUDA version: 12.8\n",
      "Current device: 0\n",
      "Device name: NVIDIA GeForce RTX 3050 Laptop GPU\n",
      "Flash Attention (scaled_dot_product_attention) available: True\n"
     ]
    }
   ],
   "source": [
    "!pip install -U datasets tiktoken tqdm numpy torch\n",
    "!pip install matplotlib\n",
    "\n",
    "import os\n",
    "import math\n",
    "import time\n",
    "from contextlib import nullcontext\n",
    "from dataclasses import dataclass\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.optim.lr_scheduler import LambdaLR\n",
    "\n",
    "import tiktoken\n",
    "from datasets import load_dataset\n",
    "\n",
    "print(f\"PyTorch version: {torch.__version__}\")\n",
    "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
    "if torch.cuda.is_available():\n",
    "    print(f\"CUDA version: {torch.version.cuda}\")\n",
    "    print(f\"Current device: {torch.cuda.current_device()}\")\n",
    "    print(f\"Device name: {torch.cuda.get_device_name(torch.cuda.current_device())}\")\n",
    "\n",
    "# Check for Flash Attention (PyTorch 2.0+)\n",
    "flash_available = hasattr(F, 'scaled_dot_product_attention')\n",
    "print(f\"Flash Attention (scaled_dot_product_attention) available: {flash_available}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6390db73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n",
      "Using dtype: bfloat16\n",
      "Using PyTorch dtype: torch.bfloat16\n"
     ]
    }
   ],
   "source": [
    "@dataclass\n",
    "class SLMConfig:\n",
    "    \n",
    "    block_size: int = 128\n",
    "    vocab_size: int = 50257\n",
    "    n_layer: int = 6\n",
    "    n_head: int = 6\n",
    "    n_embd: int = 384\n",
    "    dropout: float = 0.1\n",
    "    bias: bool = False \n",
    "    \n",
    "    batch_size: int = 32\n",
    "    max_iters: int = 10000\n",
    "    eval_interval: int = 500\n",
    "    eval_iters: int = 200\n",
    "    learning_rate: float = 1e-4\n",
    "    weight_decay: float = 0.1\n",
    "    beta1: float = 0.9\n",
    "    beta2: float = 0.95\n",
    "    grad_clip: float = 1.0\n",
    "    \n",
    "    warmup_iters: int = 1000\n",
    "    lr_decay_iters: int = max_iters \n",
    "    min_lr: float = 1e-5\n",
    "\n",
    "    device: str = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    dtype: str = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16'\n",
    "    compile: bool = True\n",
    "    \n",
    "    num_proc: int = 8 \n",
    "    total_batches: int = 1024 \n",
    "    \n",
    "    out_dir: str = 'out'\n",
    "    best_model_name: str = 'best_model.pt'\n",
    "\n",
    "config = SLMConfig()\n",
    "\n",
    "config.lr_decay_iters = config.max_iters\n",
    "os.makedirs(config.out_dir, exist_ok=True)\n",
    "best_model_path = os.path.join(config.out_dir, config.best_model_name)\n",
    "\n",
    "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[config.dtype]\n",
    "torch.set_default_dtype(ptdtype) \n",
    "\n",
    "print(f\"Using device: {config.device}\")\n",
    "print(f\"Using dtype: {config.dtype}\")\n",
    "print(f\"Using PyTorch dtype: {ptdtype}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc18618e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading TinyStories dataset...\n",
      "Dataset loaded: DatasetDict({\n",
      "    train: Dataset({\n",
      "        features: ['text'],\n",
      "        num_rows: 2119719\n",
      "    })\n",
      "    validation: Dataset({\n",
      "        features: ['text'],\n",
      "        num_rows: 21990\n",
      "    })\n",
      "})\n",
      "Initializing GPT-2 tokenizer...\n",
      "Tokenizing split: train...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Tokenizing train split (num_proc=8): 100%|██████████| 2119719/2119719 [00:34<00:00, 60606.58 examples/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing 473992236 tokens to /home/namit/slm/data/train.bin...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Writing /home/namit/slm/data/train.bin: 100%|██████████| 1024/1024 [05:36<00:00,  3.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished writing /home/namit/slm/data/train.bin.\n",
      "Tokenizing split: validation...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Tokenizing validation split (num_proc=8): 100%|██████████| 21990/21990 [00:00<00:00, 32472.03 examples/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing 4765918 tokens to /home/namit/slm/data/validation.bin...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Writing /home/namit/slm/data/validation.bin: 100%|██████████| 1024/1024 [00:04<00:00, 218.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished writing /home/namit/slm/data/validation.bin.\n",
      "Data tokenization complete.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "df = load_dataset(\"roneneldan/TinyStories\")\n",
    "encoding = tiktoken.get_encoding(\"gpt2\")\n",
    "if encoding.n_vocab != config.vocab_size:\n",
    "    print(f\"Warning: Tokenizer vocab size {encoding.n_vocab} != config vocab size {config.vocab_size}\")\n",
    "    config.vocab_size = encoding.n_vocab\n",
    "    print(f\"Updated config.vocab_size to {config.vocab_size}\")\n",
    "\n",
    "def processing(sample):\n",
    "    ids = encoding.encode_ordinary(sample['text'])\n",
    "    ids.append(encoding.eot_token) \n",
    "    out = {'ids': ids, 'len': len(ids)}\n",
    "    return out\n",
    "data_dir = os.path.join(os.getcwd(), 'data')\n",
    "os.makedirs(data_dir, exist_ok=True)\n",
    "\n",
    "for split in ['train', 'validation']:\n",
    "    filename = os.path.join(data_dir, f'{split}.bin')\n",
    "    \n",
    "    if os.path.exists(filename):\n",
    "        print(f\"{filename} already exists. Skipping tokenization.\")\n",
    "        continue\n",
    "\n",
    "    print(f\"Tokenizing split: {split}...\")\n",
    "    tokenized = df[split].map(\n",
    "        processing,\n",
    "        remove_columns=['text'],\n",
    "        desc=f\"Tokenizing {split} split\",\n",
    "        num_proc=config.num_proc,\n",
    "    )\n",
    "\n",
    "    arr_len = np.sum(tokenized['len'], dtype=np.uint64)\n",
    "    dtype = np.uint16 \n",
    "    arr = np.memmap(filename, dtype=dtype, mode='w+', shape=(arr_len,))\n",
    "    total_batches = config.total_batches\n",
    "    \n",
    "    print(f\"Writing {arr_len} tokens to {filename}...\")\n",
    "    idx = 0\n",
    "    for batch_idx in tqdm(range(total_batches), desc=f'Writing {filename}'):\n",
    "        batch = tokenized.shard(\n",
    "            num_shards=total_batches, \n",
    "            index=batch_idx, \n",
    "            contiguous=True\n",
    "        ).with_format('numpy')\n",
    "        \n",
    "        arr_batch = np.concatenate(batch['ids'])\n",
    "        arr[idx : idx + len(arr_batch)] = arr_batch\n",
    "        idx += len(arr_batch)\n",
    "    \n",
    "    arr.flush()\n",
    "    print(f\"Finished writing {filename}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ff3b00b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data from /home/namit/slm/data/train.bin...\n",
      "Loaded 473992236 tokens.\n",
      "Block size: 128\n",
      "Number of chunks: 3703064\n",
      "Loading data from /home/namit/slm/data/validation.bin...\n",
      "Loaded 4765918 tokens.\n",
      "Block size: 128\n",
      "Number of chunks: 37233\n",
      "\n",
      "Testing the DataLoader...\n",
      "x_batch shape: torch.Size([32, 128])\n",
      "y_batch shape: torch.Size([32, 128])\n",
      "x_batch dtype: torch.int64\n",
      "Device of batch: cpu\n"
     ]
    }
   ],
   "source": [
    "class BinDataset(Dataset):\n",
    "    def __init__(self, data_file, block_size):\n",
    "        super().__init__()\n",
    "        self.block_size = block_size\n",
    "        print(f\"Loading data from {data_file}...\")\n",
    "        self.data = np.memmap(data_file, dtype=np.uint16, mode='r')\n",
    "        self.length = len(self.data)\n",
    "        self.num_chunks = (self.length - 1) // self.block_size\n",
    "        print(f\"Loaded {self.length} tokens.\")\n",
    "        print(f\"Block size: {self.block_size}\")\n",
    "        print(f\"Number of chunks: {self.num_chunks}\")\n",
    "    def __len__(self):\n",
    "        return self.num_chunks\n",
    "    def __getitem__(self, idx):\n",
    "        start_idx = idx * self.block_size\n",
    "        chunk = self.data[start_idx : start_idx + self.block_size + 1]\n",
    "        chunk = torch.from_numpy(chunk.astype(np.int64))\n",
    "        x = chunk[:-1]\n",
    "        y = chunk[1:]\n",
    "        return x, y\n",
    "train_data_file = os.path.join(data_dir, 'train.bin')\n",
    "val_data_file = os.path.join(data_dir, 'validation.bin')\n",
    "\n",
    "train_dataset = BinDataset(train_data_file, config.block_size)\n",
    "val_dataset = BinDataset(val_data_file, config.block_size)\n",
    "cpu_generator = torch.Generator(device='cpu')\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    train_dataset,\n",
    "    batch_size=config.batch_size,\n",
    "    shuffle=True,\n",
    "    pin_memory=True,\n",
    "    num_workers=2,\n",
    "    generator=cpu_generator\n",
    ")\n",
    "\n",
    "val_loader = DataLoader(\n",
    "    val_dataset,\n",
    "    batch_size=config.batch_size,\n",
    "    shuffle=False,\n",
    "    pin_memory=True,\n",
    "    num_workers=2,\n",
    "    generator=cpu_generator\n",
    ")\n",
    "x_batch, y_batch = next(iter(train_loader))\n",
    "print(f\"x_batch shape: {x_batch.shape}\")\n",
    "print(f\"y_batch shape: {y_batch.shape}\")\n",
    "print(f\"x_batch dtype: {x_batch.dtype}\")\n",
    "print(f\"Device of batch: {x_batch.device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e20654c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing model...\n",
      "Model created. Number of parameters: 29.92M\n",
      "Moving model to device: cuda\n",
      "Compiling the model... (this may take a minute)\n",
      "Model compiled.\n",
      "\n",
      "Model setup complete.\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F\n",
    "import math\n",
    "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[config.dtype]\n",
    "ctx = nullcontext() if config.device == 'cpu' else torch.amp.autocast(device_type=config.device, dtype=ptdtype)\n",
    "\n",
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, ndim, bias):\n",
    "        super().__init__()\n",
    "        self.weight = nn.Parameter(torch.ones(ndim))\n",
    "        self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None\n",
    "\n",
    "    def forward(self, x):\n",
    "        return F.layer_norm(x, self.weight.shape, self.weight, self.bias, 1e-5)\n",
    "\n",
    "class CausalSelfAttention(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        assert config.n_embd % config.n_head == 0\n",
    "        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias)\n",
    "        self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias)\n",
    "        self.attn_dropout = nn.Dropout(config.dropout)\n",
    "        self.resid_dropout = nn.Dropout(config.dropout)\n",
    "        self.n_head = config.n_head\n",
    "        self.n_embd = config.n_embd\n",
    "        self.dropout = config.dropout\n",
    "        self.flash = hasattr(F, 'scaled_dot_product_attention')\n",
    "        if not self.flash:\n",
    "            print(\"flash attention 2.0 not available\")\n",
    "            # causal mask\n",
    "        self.register_buffer(\"bias\", torch.tril(torch.ones(config.block_size, config.block_size))\n",
    "                                        .view(1, 1, config.block_size, config.block_size))\n",
    "    def forward(self, x):\n",
    "        B, T, C = x.size()\n",
    "        q, k, v  = self.c_attn(x).split(self.n_embd, dim=2)\n",
    "        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        if self.flash:\n",
    "            y = F.scaled_dot_product_attention(q, k, v, attn_mask=None,\n",
    "                                               dropout_p=self.dropout if self.training else 0.0,\n",
    "                                               is_causal=True)\n",
    "        else:\n",
    "            att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))\n",
    "            att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\n",
    "            att = F.softmax(att, dim=-1)\n",
    "            att = self.attn_dropout(att)\n",
    "            y = att @ v\n",
    "        y = y.transpose(1, 2).contiguous().view(B, T, C)\n",
    "        y = self.resid_dropout(self.c_proj(y))\n",
    "        return y\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.c_fc    = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias)\n",
    "        self.gelu    = nn.GELU(approximate='tanh')\n",
    "        self.c_proj  = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias)\n",
    "        self.dropout = nn.Dropout(config.dropout)\n",
    "    def forward(self, x):\n",
    "        x = self.c_fc(x)\n",
    "        x = self.gelu(x)\n",
    "        x = self.c_proj(x)\n",
    "        x = self.dropout(x)\n",
    "        return x\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)\n",
    "        self.attn = CausalSelfAttention(config)\n",
    "        self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)\n",
    "        self.mlp = MLP(config)\n",
    "    def forward(self, x):\n",
    "        x = x + self.attn(self.ln_1(x))\n",
    "        x = x + self.mlp(self.ln_2(x))\n",
    "        return x\n",
    "class GPT(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        assert config.vocab_size is not None\n",
    "        assert config.block_size is not None\n",
    "        self.config = config\n",
    "        self.transformer = nn.ModuleDict(dict(\n",
    "            wte = nn.Embedding(config.vocab_size, config.n_embd),\n",
    "            wpe = nn.Embedding(config.block_size, config.n_embd),\n",
    "            drop = nn.Dropout(config.dropout),\n",
    "            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),\n",
    "            ln_f = LayerNorm(config.n_embd, bias=config.bias),\n",
    "        ))\n",
    "        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)\n",
    "        self.transformer.wte.weight = self.lm_head.weight\n",
    "        self.apply(self._init_weights)\n",
    "        for pn, p in self.named_parameters():\n",
    "            if pn.endswith('c_proj.weight'):\n",
    "                torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))\n",
    "        print(f\"Model created. Number of parameters: {self.get_num_params()/1e6:.2f}M\")\n",
    "    def get_num_params(self, non_embedding=True):\n",
    "        n_params = sum(p.numel() for p in self.parameters())\n",
    "        if non_embedding:\n",
    "            n_params -= self.transformer.wpe.weight.numel()\n",
    "        return n_params\n",
    "    def _init_weights(self, module):\n",
    "        if isinstance(module, nn.Linear):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "            if module.bias is not None:\n",
    "                torch.nn.init.zeros_(module.bias)\n",
    "        elif isinstance(module, nn.Embedding):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "    def forward(self, idx, targets=None):\n",
    "        device = idx.device\n",
    "        b, t = idx.size()\n",
    "        if t > self.config.block_size:\n",
    "            raise ValueError(f\"Cannot forward sequence of length {t}, block size is {self.config.block_size}\")\n",
    "        pos = torch.arange(0, t, dtype=torch.long, device=device)\n",
    "        tok_emb = self.transformer.wte(idx)\n",
    "        pos_emb = self.transformer.wpe(pos)\n",
    "        x = self.transformer.drop(tok_emb + pos_emb)\n",
    "        for block in self.transformer.h:\n",
    "            x = block(x)\n",
    "        x = self.transformer.ln_f(x)\n",
    "        if targets is not None:\n",
    "            logits = self.lm_head(x)\n",
    "            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)\n",
    "        else:\n",
    "            logits = self.lm_head(x[:, [-1], :])\n",
    "            loss = None\n",
    "        return logits, loss\n",
    "    @torch.no_grad()\n",
    "    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):\n",
    "        idx = idx.to(self.config.device)\n",
    "        for _ in range(max_new_tokens):\n",
    "            idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]\n",
    "            logits, _ = self(idx_cond)\n",
    "            logits = logits[:, -1, :] / temperature\n",
    "            if top_k is not None:\n",
    "                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))\n",
    "                logits[logits < v[:, [-1]]] = -float('Inf')\n",
    "            probs = F.softmax(logits, dim=-1)\n",
    "            idx_next = torch.multinomial(probs, num_samples=1)\n",
    "            idx = torch.cat((idx, idx_next), dim=1)\n",
    "        return idx\n",
    "print(\"Initializing model...\")\n",
    "model = GPT(config)\n",
    "print(f\"Moving model to device: {config.device}\")\n",
    "model.to(config.device)\n",
    "if config.compile:\n",
    "    print(\"Compiling the model... (this may take a minute)\")\n",
    "    model = torch.compile(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dc00ffb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting up AdamW optimizer...\n",
      "Setting up LR scheduler (linear warmup + cosine decay)...\n",
      "Optimizer and LR Scheduler are ready.\n"
     ]
    }
   ],
   "source": [
    "decay_params = []\n",
    "no_decay_params = []\n",
    "for pn, p in model.named_parameters():\n",
    "    if p.dim() >= 2:\n",
    "        decay_params.append(p)\n",
    "    else:\n",
    "        no_decay_params.append(p)\n",
    "param_groups = [\n",
    "    {'params': decay_params, 'weight_decay': config.weight_decay},\n",
    "    {'params': no_decay_params, 'weight_decay': 0.0}\n",
    "]\n",
    "optimizer = torch.optim.AdamW(\n",
    "    param_groups,\n",
    "    lr=config.learning_rate,\n",
    "    betas=(config.beta1, config.beta2),\n",
    "    eps=1e-8\n",
    ")\n",
    "def get_lr_multiplier(it):\n",
    "    if it < config.warmup_iters:\n",
    "        return it / config.warmup_iters\n",
    "    if it > config.lr_decay_iters:\n",
    "        return config.min_lr / config.learning_rate\n",
    "    decay_ratio = (it - config.warmup_iters) / (config.lr_decay_iters - config.warmup_iters)\n",
    "    assert 0 <= decay_ratio <= 1\n",
    "    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio))\n",
    "    multiplier = (config.min_lr + coeff * (config.learning_rate - config.min_lr)) / config.learning_rate\n",
    "    return multiplier\n",
    "lr_scheduler = LambdaLR(optimizer, lr_lambda=get_lr_multiplier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a161f7a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimating initial loss (this may take a moment)...\n",
      "Initial losses: {'train': tensor(10.8750), 'val': tensor(10.8750)}\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def estimate_loss(model, train_loader, val_loader, eval_iters, device, ctx):\n",
    "    out = {}\n",
    "    model.eval()\n",
    "    for split, loader in [('train', train_loader), ('val', val_loader)]:\n",
    "        losses = torch.zeros(eval_iters)\n",
    "        loader_iter = iter(loader)\n",
    "        for k in range(eval_iters):\n",
    "            try:\n",
    "                X, Y = next(loader_iter)\n",
    "            except StopIteration:\n",
    "                loader_iter = iter(loader)\n",
    "                X, Y = next(loader_iter)\n",
    "            X, Y = X.to(device, non_blocking=True), Y.to(device, non_blocking=True)\n",
    "            with ctx:\n",
    "                logits, loss = model(X, Y)\n",
    "            losses[k] = loss.item()\n",
    "        out[split] = losses.mean()\n",
    "    model.train()\n",
    "    return out\n",
    "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[config.dtype]\n",
    "ctx = nullcontext() if config.device == 'cpu' else torch.amp.autocast(device_type=config.device, dtype=ptdtype)\n",
    "initial_losses = estimate_loss(model, train_loader, val_loader, config.eval_iters, config.device, ctx)\n",
    "print(f\"Initial losses: {initial_losses}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3601abdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training for 10000 iterations...\n",
      "Step      0 | Train Loss: 10.8750 | Val Loss: 10.8750 | LR: 0.000000 | Time: 11.65s\n",
      "Step    500 | Train Loss: 6.7500 | Val Loss: 6.7812 | LR: 0.000050 | Time: 73.80s\n",
      "  -> New best val loss: 6.7812. Saving checkpoint to out/best_model.pt\n",
      "Step   1000 | Train Loss: 4.2812 | Val Loss: 4.3125 | LR: 0.000100 | Time: 142.33s\n",
      "  -> New best val loss: 4.3125. Saving checkpoint to out/best_model.pt\n",
      "Step   1500 | Train Loss: 3.8125 | Val Loss: 3.8750 | LR: 0.000099 | Time: 216.25s\n",
      "  -> New best val loss: 3.8750. Saving checkpoint to out/best_model.pt\n",
      "Step   2000 | Train Loss: 3.6250 | Val Loss: 3.6719 | LR: 0.000097 | Time: 318.38s\n",
      "  -> New best val loss: 3.6719. Saving checkpoint to out/best_model.pt\n",
      "Step   2500 | Train Loss: 3.5156 | Val Loss: 3.5625 | LR: 0.000094 | Time: 458.72s\n",
      "  -> New best val loss: 3.5625. Saving checkpoint to out/best_model.pt\n",
      "Step   3000 | Train Loss: 3.4375 | Val Loss: 3.4844 | LR: 0.000089 | Time: 626.02s\n",
      "  -> New best val loss: 3.4844. Saving checkpoint to out/best_model.pt\n",
      "Step   3500 | Train Loss: 3.3750 | Val Loss: 3.4375 | LR: 0.000084 | Time: 812.16s\n",
      "  -> New best val loss: 3.4375. Saving checkpoint to out/best_model.pt\n",
      "Step   4000 | Train Loss: 3.3281 | Val Loss: 3.3906 | LR: 0.000077 | Time: 1038.57s\n",
      "  -> New best val loss: 3.3906. Saving checkpoint to out/best_model.pt\n",
      "Step   4500 | Train Loss: 3.2969 | Val Loss: 3.3594 | LR: 0.000070 | Time: 1265.31s\n",
      "  -> New best val loss: 3.3594. Saving checkpoint to out/best_model.pt\n",
      "Step   5000 | Train Loss: 3.2812 | Val Loss: 3.3438 | LR: 0.000063 | Time: 1491.99s\n",
      "  -> New best val loss: 3.3438. Saving checkpoint to out/best_model.pt\n",
      "Step   5500 | Train Loss: 3.2500 | Val Loss: 3.3125 | LR: 0.000055 | Time: 1719.03s\n",
      "  -> New best val loss: 3.3125. Saving checkpoint to out/best_model.pt\n",
      "Step   6000 | Train Loss: 3.2344 | Val Loss: 3.2969 | LR: 0.000047 | Time: 1946.17s\n",
      "  -> New best val loss: 3.2969. Saving checkpoint to out/best_model.pt\n",
      "Step   6500 | Train Loss: 3.2188 | Val Loss: 3.2969 | LR: 0.000040 | Time: 2172.79s\n",
      "Step   7000 | Train Loss: 3.2188 | Val Loss: 3.2812 | LR: 0.000033 | Time: 2399.58s\n",
      "  -> New best val loss: 3.2812. Saving checkpoint to out/best_model.pt\n",
      "Step   7500 | Train Loss: 3.2188 | Val Loss: 3.2656 | LR: 0.000026 | Time: 2626.65s\n",
      "  -> New best val loss: 3.2656. Saving checkpoint to out/best_model.pt\n",
      "Step   8000 | Train Loss: 3.2031 | Val Loss: 3.2656 | LR: 0.000021 | Time: 2853.48s\n",
      "Step   8500 | Train Loss: 3.2031 | Val Loss: 3.2656 | LR: 0.000016 | Time: 3079.95s\n",
      "Step   9000 | Train Loss: 3.2031 | Val Loss: 3.2656 | LR: 0.000013 | Time: 3306.29s\n",
      "Step   9500 | Train Loss: 3.2031 | Val Loss: 3.2656 | LR: 0.000011 | Time: 3454.43s\n",
      "Step   9999 | Train Loss: 3.2031 | Val Loss: 3.2656 | LR: 0.000010 | Time: 3596.09s\n",
      "\n",
      "--- Training Complete ---\n",
      "Total training time: 59.93 minutes\n",
      "Best validation loss: 3.2656\n"
     ]
    }
   ],
   "source": [
    "import torch.amp \n",
    "import matplotlib.pyplot as plt\n",
    "train_iter = iter(train_loader)\n",
    "scaler = torch.amp.GradScaler(enabled=(config.dtype == 'float16'))\n",
    "best_val_loss = float('inf')\n",
    "train_loss_list = []\n",
    "val_loss_list = []\n",
    "print(f\"Starting training for {config.max_iters} iterations...\")\n",
    "start_time = time.time()\n",
    "for it in range(config.max_iters):\n",
    "    if it % config.eval_interval == 0 or it == config.max_iters - 1:\n",
    "        losses = estimate_loss(model, train_loader, val_loader, config.eval_iters, config.device, ctx)\n",
    "        current_time = time.time()\n",
    "        elapsed_time = current_time - start_time\n",
    "        print(f\"Step {it:6d} | Train Loss: {losses['train']:.4f} | Val Loss: {losses['val']:.4f} | LR: {optimizer.param_groups[0]['lr']:.6f} | Time: {elapsed_time:.2f}s\")\n",
    "        train_loss_list.append(losses['train'].item())\n",
    "        val_loss_list.append(losses['val'].item())\n",
    "        if losses['val'] < best_val_loss:\n",
    "            best_val_loss = losses['val']\n",
    "            if it > 0:\n",
    "                checkpoint = {\n",
    "                    'model': model.state_dict(),\n",
    "                    'optimizer': optimizer.state_dict(),\n",
    "                    'config': config,\n",
    "                    'iter': it,\n",
    "                    'best_val_loss': best_val_loss\n",
    "                }\n",
    "                print(f\"  -> New best val loss: {best_val_loss:.4f}. Saving checkpoint to {best_model_path}\")\n",
    "                torch.save(checkpoint, best_model_path)\n",
    "    try:\n",
    "        X, Y = next(train_iter)\n",
    "    except StopIteration:\n",
    "        train_iter = iter(train_loader)\n",
    "        X, Y = next(train_iter)\n",
    "    X, Y = X.to(config.device, non_blocking=True), Y.to(config.device, non_blocking=True)\n",
    "    with ctx:\n",
    "        logits, loss = model(X, Y)\n",
    "    scaler.scale(loss).backward()\n",
    "    if config.grad_clip > 0.0:\n",
    "        scaler.unscale_(optimizer)\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), config.grad_clip)\n",
    "    scaler.step(optimizer)\n",
    "    scaler.update()\n",
    "    optimizer.zero_grad(set_to_none=True)\n",
    "    lr_scheduler.step()\n",
    "end_time = time.time()\n",
    "print(\"\\n--- Training Complete ---\")\n",
    "print(f\"Total training time: {(end_time - start_time)/60:.2f} minutes\")\n",
    "print(f\"Best validation loss: {best_val_loss:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7618a32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHWCAYAAABJ4Xn8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAal5JREFUeJzt3Xd8FHXi//H3ZtPbphCSAIFQQu9VOh5IFSkKiKgUu1i4Oz31ZznQQ1TU89Q7Tr3vgXICogeCSkd6712aIaCEThrpm/n9kWNlQwhJSDKb5PV8PObB7sxnZ96bzJ28+czOWgzDMAQAAAAAcHAzOwAAAAAAuBqKEgAAAADkQVECAAAAgDwoSgAAAACQB0UJAAAAAPKgKAEAAABAHhQlAAAAAMiDogQAAAAAeVCUAAAAACAPihIAuKAxY8YoOjq6WK+dOHGiLBZLyQaqRFavXi2LxaLVq1c71hX293HixAlZLBbNmDGjRDNFR0drzJgxJbpPAEDBKEoAUAQWi6VQy7V/yUbpad68uWrWrCnDMG44pnPnzgoPD1d2dnYZJiu6jRs3auLEiUpISDA7isOMGTNksVi0fft2s6MAQJlzNzsAAJQnM2fOdHr+xRdfaPny5detb9So0S0d57PPPlNOTk6xXvvKK6/oxRdfvKXjlxejRo3Siy++qHXr1qlbt27XbT9x4oQ2bdqkp556Su7uxf9P3q38Pgpr48aNmjRpksaMGaOgoCCnbYcPH5abG/+2CQBliaIEAEVw//33Oz3fvHmzli9fft36vFJTU+Xr61vo43h4eBQrnyS5u7vfUikoT+677z699NJLmjVrVr5Fafbs2TIMQ6NGjbql49zK76MkeHl5mXp8AKiM+OcpAChhPXr0UNOmTbVjxw5169ZNvr6++n//7/9JkhYsWKABAwaoWrVq8vLyUt26dfXGG2/Ibrc77SPvZ2Kufvbl3Xff1aeffqq6devKy8tL7dq107Zt25xem99nlCwWi5566il9++23atq0qby8vNSkSRMtWbLkuvyrV69W27Zt5e3trbp16+qTTz4p1OeennrqKfn7+ys1NfW6bSNHjlRERITjfW7fvl19+vRRlSpV5OPjo9q1a2vcuHEF7j8/UVFR6tatm7755htlZWVdt33WrFmqW7euOnTooLi4OD355JNq0KCBfHx8FBoaqmHDhunEiRM3PU5+n1FKSEjQmDFjZLPZFBQUpNGjR+d72dzevXs1ZswY1alTR97e3oqIiNC4ceN08eJFx5iJEyfq+eeflyTVrl3bcQnn1Wz5fUbp559/1rBhwxQSEiJfX1/ddttt+uGHH5zGXP281dy5czV58mTVqFFD3t7e6tmzp44dO3bT911Yu3btUr9+/RQYGCh/f3/17NlTmzdvdhqTlZWlSZMmKSYmRt7e3goNDVWXLl20fPlyx5gzZ85o7NixqlGjhry8vBQZGalBgwYV6ncEACWtcvyTIwCUsYsXL6pfv3669957df/99ys8PFxS7mc+/P399Yc//EH+/v768ccf9dprrykpKUlTp0696X5nzZql5ORkPfbYY7JYLHrnnXc0dOhQ/fzzzzed9Vi/fr3mzZunJ598UgEBAfrwww9199136+TJkwoNDZWU+xfevn37KjIyUpMmTZLdbtfrr7+usLCwm2YbMWKE/v73v+uHH37QsGHDHOtTU1P13XffacyYMbJarTp37px69+6tsLAwvfjiiwoKCtKJEyc0b968mx4jP6NGjdKjjz6qpUuX6s4773Ss37dvn/bv36/XXntNkrRt2zZt3LhR9957r2rUqKETJ05o2rRp6tGjhw4ePFikGT/DMDRo0CCtX79ejz/+uBo1aqT58+dr9OjR141dvny5fv75Z40dO1YRERE6cOCAPv30Ux04cECbN2+WxWLR0KFDdeTIEc2ePVt//etfVaVKFUm64c/97Nmz6tSpk1JTU/XMM88oNDRUn3/+ue666y598803GjJkiNP4t956S25ubnruueeUmJiod955R6NGjdKWLVsK/Z5v5MCBA+ratasCAwP1pz/9SR4eHvrkk0/Uo0cPrVmzRh06dJCUWwanTJmihx9+WO3bt1dSUpK2b9+unTt36o477pAk3X333Tpw4ICefvppRUdH69y5c1q+fLlOnjxZ7JubAECxGQCAYhs/fryR9/9Ku3fvbkgy/vnPf143PjU19bp1jz32mOHr62ukp6c71o0ePdqoVauW43lsbKwhyQgNDTUuXbrkWL9gwQJDkvHdd9851v35z3++LpMkw9PT0zh27Jhj3Z49ewxJxkcffeRYN3DgQMPX19f49ddfHeuOHj1quLu7X7fPvHJycozq1asbd999t9P6uXPnGpKMtWvXGoZhGPPnzzckGdu2bStwf4V16dIlw8vLyxg5cqTT+hdffNGQZBw+fNgwjPx/9ps2bTIkGV988YVj3apVqwxJxqpVqxzr8v4+vv32W0OS8c477zjWZWdnG127djUkGdOnT3esz++4s2fPdvqZGIZhTJ061ZBkxMbGXje+Vq1axujRox3PJ0yYYEgy1q1b51iXnJxs1K5d24iOjjbsdrvTe2nUqJGRkZHhGPu3v/3NkGTs27fvumNda/r06Tf9XQ0ePNjw9PQ0jh8/7lh3+vRpIyAgwOjWrZtjXYsWLYwBAwbccD+XL182JBlTp04tMBMAlBUuvQOAUuDl5aWxY8det97Hx8fxODk5WRcuXFDXrl2Vmpqqn3766ab7HTFihIKDgx3Pu3btKin3Mqyb6dWrl+rWret43rx5cwUGBjpea7fbtWLFCg0ePFjVqlVzjKtXr5769et30/1bLBYNGzZMixYtUkpKimP9V199perVq6tLly6S5LhRwffff5/v5XJFFRwcrP79+2vhwoW6cuWKpNwZnzlz5qht27aqX7++JOeffVZWli5evKh69eopKChIO3fuLNIxFy1aJHd3dz3xxBOOdVarVU8//fR1Y689bnp6ui5cuKDbbrtNkop83GuP3759e8fPVJL8/f316KOP6sSJEzp48KDT+LFjx8rT09PxvCjnTUHsdruWLVumwYMHq06dOo71kZGRuu+++7R+/XolJSVJyv29HzhwQEePHs13Xz4+PvL09NTq1at1+fLlW8oFACWBogQApaB69epOfzG96sCBAxoyZIhsNpsCAwMVFhbmuBFEYmLiTfdbs2ZNp+dXS1Nh/mKZ97VXX3/1tefOnVNaWprq1at33bj81uVnxIgRSktL08KFCyVJKSkpWrRokYYNG+b4jFP37t119913a9KkSapSpYoGDRqk6dOnKyMjo1DHyM+oUaN05coVLViwQFLuHeROnDjhdBOHtLQ0vfbaa4qKipKXl5eqVKmisLAwJSQkFOpnf624uDhFRkbK39/faX2DBg2uG3vp0iU9++yzCg8Pl4+Pj8LCwlS7dm1Jhfud3+j4+R3r6t0W4+LinNbfynlTkPPnzys1NfWGWXJycnTq1ClJ0uuvv66EhATVr19fzZo10/PPP6+9e/c6xnt5eentt9/W4sWLFR4erm7duumdd97RmTNnbikjABQXRQkASsG1swhXJSQkqHv37tqzZ49ef/11fffdd1q+fLnefvttSSrU7aetVmu+640CvkeoJF5bWLfddpuio6M1d+5cSdJ3332ntLQ0jRgxwjHGYrHom2++cdy2+9dff9W4cePUpk0bp5moorjzzjtls9k0a9YsSbmf5bJarbr33nsdY55++mlNnjxZw4cP19y5c7Vs2TItX75coaGhpXrr7+HDh+uzzz7T448/rnnz5mnZsmWOm2iU9i3HryqL3/3NdOvWTcePH9e///1vNW3aVP/617/UunVr/etf/3KMmTBhgo4cOaIpU6bI29tbr776qho1aqRdu3aVWU4AuIqiBABlZPXq1bp48aJmzJihZ599Vnfeead69erldCmdmapWrSpvb+9874ZWlDukDR8+XEuWLFFSUpK++uorRUdHOy41u9Ztt92myZMna/v27fryyy914MABzZkzp1jZvby8dM8992jZsmU6e/asvv76a/3ud79TRESEY8w333yj0aNH67333tM999yjO+64Q126dCnWF7zWqlVL8fHx1xW7w4cPOz2/fPmyVq5cqRdffFGTJk3SkCFDdMcddzhdpnbVze4qmPf4eY8lyXH5Zq1atQq9r1sRFhYmX1/fG2Zxc3NTVFSUY11ISIjGjh2r2bNn69SpU2revLkmTpzo9Lq6devqj3/8o5YtW6b9+/crMzNT7733Xmm/FQC4DkUJAMrI1X/Vv/Zf8TMzM/WPf/zDrEhOrFarevXqpW+//VanT592rD927JgWL15c6P2MGDFCGRkZ+vzzz7VkyRINHz7cafvly5evm8lo2bKlJDldfnf8+HEdP3680McdNWqUsrKy9Nhjj+n8+fPXfXeS1Wq97rgfffTRdbdmL4z+/fsrOztb06ZNc6yz2+366KOPrjumdP3MzQcffHDdPv38/CSpUMWtf//+2rp1qzZt2uRYd+XKFX366aeKjo5W48aNC/tWbonValXv3r21YMECp1t4nz17VrNmzVKXLl0UGBgoSU63Q5dyP1NVr149x+88NTVV6enpTmPq1q2rgICAW7osEwCKi9uDA0AZ6dSpk4KDgzV69Gg988wzslgsmjlzZple/nQzEydO1LJly9S5c2c98cQTstvt+vjjj9W0aVPt3r27UPto3bq16tWrp5dfflkZGRlOl91J0ueff65//OMfGjJkiOrWravk5GR99tlnCgwMVP/+/R3jevbsKUmF/g6d7t27q0aNGlqwYIF8fHw0dOhQp+133nmnZs6cKZvNpsaNG2vTpk1asWKF49boRTFw4EB17txZL774ok6cOKHGjRtr3rx5133mKDAw0PFZm6ysLFWvXl3Lli1TbGzsdfts06aNJOnll1/WvffeKw8PDw0cONBRoK714osvavbs2erXr5+eeeYZhYSE6PPPP1dsbKz++9//ys2tZP8d9N///ne+37n17LPP6i9/+YuWL1+uLl266Mknn5S7u7s++eQTZWRk6J133nGMbdy4sXr06KE2bdooJCRE27dv1zfffKOnnnpKknTkyBH17NlTw4cPV+PGjeXu7q758+fr7NmzTpdQAkBZoSgBQBkJDQ3V999/rz/+8Y965ZVXFBwcrPvvv189e/ZUnz59zI4nKfcv64sXL9Zzzz2nV199VVFRUXr99dd16NChQt2V76oRI0Zo8uTJqlevnlq3bu20rXv37tq6davmzJmjs2fPymazqX379vryyy8dNzkoDjc3N40cOVJTp07VwIEDFRAQ4LT9b3/7m6xWq7788kulp6erc+fOWrFiRbF+9m5ublq4cKEmTJig//znP7JYLLrrrrv03nvvqVWrVk5jZ82apaefflp///vfZRiGevfurcWLFzvdWVCS2rVrpzfeeEP//Oc/tWTJEuXk5Cg2NjbfohQeHq6NGzfqhRde0EcffaT09HQ1b95c3333nQYMGFDk93Mz186cXWvMmDFq0qSJ1q1bp5deeklTpkxRTk6OOnTooP/85z+O71CSpGeeeUYLFy7UsmXLlJGRoVq1aukvf/mL44t2o6KiNHLkSK1cuVIzZ86Uu7u7GjZsqLlz5+ruu+8u8fcEADdjMVzpnzIBAC5p8ODBBd7aGQCAiobPKAEAnKSlpTk9P3r0qBYtWqQePXqYEwgAABMwowQAcBIZGakxY8aoTp06iouL07Rp05SRkaFdu3YpJibG7HgAAJQJPqMEAHDSt29fzZ49W2fOnJGXl5c6duyoN998k5IEAKhUmFECAAAAgDz4jBIAAAAA5EFRAgAAAIA8KvxnlHJycnT69GkFBATIYrGYHQcAAACASQzDUHJysqpVq3bTL+eu8EXp9OnTioqKMjsGAAAAABdx6tQp1ahRo8AxFb4oXf1m9lOnTikwMNDkNAAAAADMkpSUpKioKEdHKEiFL0pXL7cLDAykKAEAAAAo1EdyuJkDAAAAAORBUQIAAACAPChKAAAAAJBHhf+MEgAAAFyP3W5XVlaW2TFQwVitVrm7u5fI1wJRlAAAAFCmUlJS9Msvv8gwDLOjoALy9fVVZGSkPD09b2k/phaltWvXaurUqdqxY4fi4+M1f/58DR482LF93rx5+uc//6kdO3bo0qVL2rVrl1q2bGlaXgAAANwau92uX375Rb6+vgoLCyuRf/kHpNwvk83MzNT58+cVGxurmJiYm36pbEFMLUpXrlxRixYtNG7cOA0dOjTf7V26dNHw4cP1yCOPmJAQAAAAJSkrK0uGYSgsLEw+Pj5mx0EF4+PjIw8PD8XFxSkzM1Pe3t7F3pepRalfv37q16/fDbc/8MADkqQTJ06UUSIAAACUBWaSUFpuZRbpWhXuM0oZGRnKyMhwPE9KSjIxDQAAAIDyqMLdHnzKlCmy2WyOJSoqyuxIAAAAAMqZCleUXnrpJSUmJjqWU6dOmR0JAAAAuE50dLQ++OADs2PgBipcUfLy8lJgYKDTAgAAABSXxWIpcJk4cWKx9rtt2zY9+uijt5StR48emjBhwi3tA/mrcJ9RAgAAAEpSfHy84/FXX32l1157TYcPH3as8/f3dzw2DEN2u13u7jf/a3ZYWFjJBkWJMnVGKSUlRbt379bu3bslSbGxsdq9e7dOnjwpSbp06ZJ2796tgwcPSpIOHz6s3bt368yZM2ZFviUbutfW6WB3HV31X7OjAAAAuATDMHQl84opS2G/8DYiIsKx2Gw2WSwWx/OffvpJAQEBWrx4sdq0aSMvLy+tX79ex48f16BBgxQeHi5/f3+1a9dOK1ascNpv3kvvLBaL/vWvf2nIkCHy9fVVTEyMFi5ceEs/3//+979q0qSJvLy8FB0drffee89p+z/+8Q/FxMTI29tb4eHhuueeexzbvvnmGzVr1kw+Pj4KDQ1Vr169dOXKlVvKU56YOqO0fft23X777Y7nf/jDHyRJo0eP1owZM7Rw4UKNHTvWsf3ee++VJP35z38u9hSnmfzOXla1BLs2bFimmNvvNjsOAACA6VKzUuU/xf/mA0tByksp8vP0K5F9vfjii3r33XdVp04dBQcH69SpU+rfv78mT54sLy8vffHFFxo4cKAOHz6smjVr3nA/kyZN0jvvvKOpU6fqo48+0qhRoxQXF6eQkJAiZ9qxY4eGDx+uiRMnasSIEdq4caOefPJJhYaGasyYMdq+fbueeeYZzZw5U506ddKlS5e0bt06SbmzaCNHjtQ777yjIUOGKDk5WevWrSt0uawITC1KPXr0KPCHPWbMGI0ZM6bsApWyxAbR0uE9yt653ewoAAAAKEGvv/667rjjDsfzkJAQtWjRwvH8jTfe0Pz587Vw4UI99dRTN9zPmDFjNHLkSEnSm2++qQ8//FBbt25V3759i5zp/fffV8+ePfXqq69KkurXr6+DBw9q6tSpGjNmjE6ePCk/Pz/deeedCggIUK1atdSqVStJuUUpOztbQ4cOVa1atSRJzZo1K3KG8ozPKJUht1atpYV7FPjTz2ZHAQAAcAm+Hr5KeSnFtGOXlLZt2zo9T0lJ0cSJE/XDDz84SkdaWprjIyY30rx5c8djPz8/BQYG6ty5c8XKdOjQIQ0aNMhpXefOnfXBBx/IbrfrjjvuUK1atVSnTh317dtXffv2dVz216JFC/Xs2VPNmjVTnz591Lt3b91zzz0KDg4uVpbyqMLd9c6VVemc+68MtU8kysjJMTkNAACA+SwWi/w8/UxZLBZLib0PPz/nS/iee+45zZ8/X2+++abWrVun3bt3q1mzZsrMzCxwPx4eHtf9fHJK6e+NAQEB2rlzp2bPnq3IyEi99tpratGihRISEmS1WrV8+XItXrxYjRs31kcffaQGDRooNja2VLK4IopSGardeYAyrVJQmqH4A1vMjgMAAIBSsmHDBo0ZM0ZDhgxRs2bNFBERoRMnTpRphkaNGmnDhg3X5apfv76sVqskyd3dXb169dI777yjvXv36sSJE/rxxx8l5Za0zp07a9KkSdq1a5c8PT01f/78Mn0PZuLSuzLk7RuonyK91fCXdP2y7ntVa9bR7EgAAAAoBTExMZo3b54GDhwoi8WiV199tdRmhs6fP++4i/RVkZGR+uMf/6h27drpjTfe0IgRI7Rp0yZ9/PHH+sc//iFJ+v777/Xzzz+rW7duCg4O1qJFi5STk6MGDRpoy5YtWrlypXr37q2qVatqy5YtOn/+vBo1alQq78EVMaNUxs7FVJckpW3daHISAAAAlJb3339fwcHB6tSpkwYOHKg+ffqodevWpXKsWbNmqVWrVk7LZ599ptatW2vu3LmaM2eOmjZtqtdee02vv/6642ZpQUFBmjdvnn73u9+pUaNG+uc//6nZs2erSZMmCgwM1Nq1a9W/f3/Vr19fr7zyit577z3169evVN6DK7IYFfwef0lJSbLZbEpMTFRgYKDZcbRqwmDd/rcF2to2Uu23nTY7DgAAQJlKT09XbGysateuLW9vb7PjoAIq6BwrSjdgRqmM2W7rLkmq9vN5k5MAAAAAuBGKUhmL7pZ7i8Yal7KVdCbO5DQAAAAA8kNRKmMh1eroZEjuXUbiVi8wOQ0AAACA/FCUTPBr3TBJUsKW1eYGAQAAAJAvipIJ0po0kCRZ9+wzOQkAAACA/FCUTODdLvf7k8KO/GpyEgAAAAD5oSiZoHrXAZKk6Pg0ZV1JNjkNAAAAgLwoSiaIatJRl3wkjxwpbtNis+MAAAAAyIOiZAI3N6tio22SpPPrl5mcBgAAAEBeFCWTJDSsLUmy79phchIAAACUhR49emjChAmO59HR0frggw8KfI3FYtG33357y8cuqf1UJhQlk1hbt5Ek2X6KNTkJAAAACjJw4ED17ds3323r1q2TxWLR3r17i7zfbdu26dFHH73VeE4mTpyoli1bXrc+Pj5e/fr1K9Fj5TVjxgwFBQWV6jHKEkXJJGGd7pAkRcclybDbTU4DAACAG3nooYe0fPly/fLLL9dtmz59utq2bavmzZsXeb9hYWHy9fUtiYg3FRERIS8vrzI5VkVBUTJJ3U4DlO4uBWQYOrN3o9lxAAAAzGEY0pUr5iyGUaiId955p8LCwjRjxgyn9SkpKfr666/10EMP6eLFixo5cqSqV68uX19fNWvWTLNnzy5wv3kvvTt69Ki6desmb29vNW7cWMuXL7/uNS+88ILq168vX19f1alTR6+++qqysrIk5c7oTJo0SXv27JHFYpHFYnFkznvp3b59+/S73/1OPj4+Cg0N1aOPPqqUlBTH9jFjxmjw4MF69913FRkZqdDQUI0fP95xrOI4efKkBg0aJH9/fwUGBmr48OE6e/asY/uePXt0++23KyAgQIGBgWrTpo22b98uSYqLi9PAgQMVHBwsPz8/NWnSRIsWLSp2lsJwL9W944a8vf21v5qPmp5M0+l1ixTZqqvZkQAAAMpeaqrk72/OsVNSJD+/mw5zd3fXgw8+qBkzZujll1+WxWKRJH399dey2+0aOXKkUlJS1KZNG73wwgsKDAzUDz/8oAceeEB169ZV+/btb3qMnJwcDR06VOHh4dqyZYsSExOdPs90VUBAgGbMmKFq1app3759euSRRxQQEKA//elPGjFihPbv368lS5ZoxYoVkiSbzXbdPq5cuaI+ffqoY8eO2rZtm86dO6eHH35YTz31lFMZXLVqlSIjI7Vq1SodO3ZMI0aMUMuWLfXII4/c9P3k9/6ulqQ1a9YoOztb48eP14gRI7R69WpJ0qhRo9SqVStNmzZNVqtVu3fvloeHhyRp/PjxyszM1Nq1a+Xn56eDBw/Kv5TPG4qSic7Xry6dPKa07ZvMjgIAAIACjBs3TlOnTtWaNWvUo0cPSbmX3d19992y2Wyy2Wx67rnnHOOffvppLV26VHPnzi1UUVqxYoV++uknLV26VNWqVZMkvfnmm9d9ruiVV15xPI6OjtZzzz2nOXPm6E9/+pN8fHzk7+8vd3d3RURE3PBYs2bNUnp6ur744gv5/a8ofvzxxxo4cKDefvtthYeHS5KCg4P18ccfy2q1qmHDhhowYIBWrlxZrKK0cuVK7du3T7GxsYqKipIkffHFF2rSpIm2bdumdu3a6eTJk3r++efVsGFDSVJMTIzj9SdPntTdd9+tZs2aSZLq1KlT5AxFRVEyUU7zZtKKY/Ldf9jsKAAAAObw9c2d2THr2IXUsGFDderUSf/+97/Vo0cPHTt2TOvWrdPrr78uSbLb7XrzzTc1d+5c/frrr8rMzFRGRkahP4N06NAhRUVFOUqSJHXs2PG6cV999ZU+/PBDHT9+XCkpKcrOzlZgYGCh38fVY7Vo0cJRkiSpc+fOysnJ0eHDhx1FqUmTJrJarY4xkZGR2rdvX5GOde0xo6KiHCVJkho3bqygoCAdOnRI7dq10x/+8Ac9/PDDmjlzpnr16qVhw4apbt26kqRnnnlGTzzxhJYtW6ZevXrp7rvvLtbnwoqCzyiZyHZbD0lStZ/PmxsEAADALBZL7uVvZiz/u4SusB566CH997//VXJysqZPn666deuqe/fukqSpU6fqb3/7m1544QWtWrVKu3fvVp8+fZSZmVliP6pNmzZp1KhR6t+/v77//nvt2rVLL7/8coke41pXL3u7ymKxKCcnp1SOJeXese/AgQMaMGCAfvzxRzVu3Fjz58+XJD388MP6+eef9cADD2jfvn1q27atPvroo1LLIlGUTFW7213KkRSRaFfKqZ/NjgMAAIACDB8+XG5ubpo1a5a++OILjRs3zvF5pQ0bNmjQoEG6//771aJFC9WpU0dHjhwp9L4bNWqkU6dOKT4+3rFu8+bNTmM2btyoWrVq6eWXX1bbtm0VExOjuLg4pzGenp6y3+SOyo0aNdKePXt05coVx7oNGzbIzc1NDRo0KHTmorj6/k6dOuVYd/DgQSUkJKhx48aOdfXr19fvf/97LVu2TEOHDtX06dMd26KiovT4449r3rx5+uMf/6jPPvusVLJeRVEyUWh4tE6E5V79eGLtQpPTAAAAoCD+/v4aMWKEXnrpJcXHx2vMmDGObTExMVq+fLk2btyoQ4cO6bHHHnO6o9vN9OrVS/Xr19fo0aO1Z88erVu3Ti+//LLTmJiYGJ08eVJz5szR8ePH9eGHHzpmXK6Kjo5WbGysdu/erQsXLigjI+O6Y40aNUre3t4aPXq09u/fr1WrVunpp5/WAw884Ljsrrjsdrt2797ttBw6dEi9evVSs2bNNGrUKO3cuVNbt27Vgw8+qO7du6tt27ZKS0vTU089pdWrVysuLk4bNmzQtm3b1KhRI0nShAkTtHTpUsXGxmrnzp1atWqVY1tpoSiZ7Jc6YZKkpM2rzQ0CAACAm3rooYd0+fJl9enTx+nzRK+88opat26tPn36qEePHoqIiNDgwYMLvV83NzfNnz9faWlpat++vR5++GFNnjzZacxdd92l3//+93rqqafUsmVLbdy4Ua+++qrTmLvvvlt9+/bV7bffrrCwsHxvUe7r66ulS5fq0qVLateune655x717NlTH3/8cdF+GPlISUlRq1atnJaBAwfKYrFowYIFCg4OVrdu3dSrVy/VqVNHX331lSTJarXq4sWLevDBB1W/fn0NHz5c/fr106RJkyTlFrDx48erUaNG6tu3r+rXr69//OMft5y3IBbDKOQN5MuppKQk2Ww2JSYmFvmDbmVh2cO3q/f/rdaWbnXVYc0xs+MAAACUqvT0dMXGxqp27dry9vY2Ow4qoILOsaJ0A2aUTObbrpMkKezoryYnAQAAAHAVRclk1bsOkCTVOpOu7JQkk9MAAAAAkChKpqvV6Dad9bfIakgn1/1gdhwAAAAAoiiZzs3iphPRNknS+Y3LTU4DAAAAQKIouYTEhnUkSTm7dpqcBAAAoGxU8PuJwUQldW5RlFyAe5u2kqSgn2JNTgIAAFC6rFarJCkzM9PkJKioUlNTJUkeHh63tB/3kgiDWxPW6Q5Jn6rWySQZ2dmyuPNrAQAAFZO7u7t8fX11/vx5eXh4yM2Nf7dHyTAMQ6mpqTp37pyCgoIcpby4TP0b+dq1azV16lTt2LFD8fHxmj9/vtMXcxmGoT//+c/67LPPlJCQoM6dO2vatGmKiYkxL3QpqNe+r654SH5Z0rk9G1W1TTezIwEAAJQKi8WiyMhIxcbGKi4uzuw4qICCgoIUERFxy/sxtShduXJFLVq00Lhx4zR06NDrtr/zzjv68MMP9fnnn6t27dp69dVX1adPHx08eLBCfUGZj7e/dtfwUcvYNP269nuKEgAAqNA8PT0VExPD5XcocR4eHrc8k3SVqUWpX79+6tevX77bDMPQBx98oFdeeUWDBg2SJH3xxRcKDw/Xt99+q3vvvbcso5a6C/VrSLFHlb5ts9lRAAAASp2bm1uF+odvVDwue1FobGyszpw5o169ejnW2Ww2dejQQZs2bbrh6zIyMpSUlOS0lAc5LZpLknwOHjE5CQAAAACXLUpnzpyRJIWHhzutDw8Pd2zLz5QpU2Sz2RxLVFRUqeYsKbYO3SVJUccvSNwuEwAAADCVyxal4nrppZeUmJjoWE6dOmV2pEKp3e0u2S1SaIpdKSeOmh0HAAAAqNRctihdvVPF2bNnndafPXu2wLtYeHl5KTAw0GkpD6pWqaVjVXM/MnZy7UKT0wAAAACVm8sWpdq1aysiIkIrV650rEtKStKWLVvUsWNHE5OVntN1q0qSkrasNTkJAAAAULmZete7lJQUHTt2zPE8NjZWu3fvVkhIiGrWrKkJEyboL3/5i2JiYhy3B69WrZrTdy1VJOlNGkobT8tjz36zowAAAACVmqlFafv27br99tsdz//whz9IkkaPHq0ZM2boT3/6k65cuaJHH31UCQkJ6tKli5YsWVJhbyXp276T9NmPCjt22uwoAAAAQKVmMYyKfYu1pKQk2Ww2JSYmuvznlX4+vEV1Gt4mScpOuCR3W7DJiQAAAICKoyjdwGU/o1QZRddvp18DLZKkU+t+MDkNAAAAUHlRlFyIm8VNsbWDJEkXN64wNwwAAABQiVGUXExywzqSpJxdO01OAgAAAFReFCUX4966rSQp6HCcyUkAAACAyoui5GLCO/eRJNU6mSQjM9PkNAAAAEDlRFFyMTFteyvRS/KySxd2rjc7DgAAAFApUZRcjI+Xn47W8JEknV63yOQ0AAAAQOVEUXJBF+pHSZLSt28xOQkAAABQOVGUXFBOy+aSJL8DR0xOAgAAAFROFCUXFHzb7ZKkGrEXJMMwOQ0AAABQ+VCUXFCdzncqy00KSs3RleM/mR0HAAAAqHQoSi4oPLSmjoS7S5JOrVlochoAAACg8qEouajT9cIlSclb1pmcBAAAAKh8KEouKqNpQ0mS+74DJicBAAAAKh+Kkovya9dZkhR+NN7kJAAAAEDlQ1FyUVHdB0qSql3MkP3iBZPTAAAAAJULRclF1Y5upRPBFknSr+sXmZwGAAAAqFwoSi7K6mZVXHSQJOnCxhXmhgEAAAAqGYqSC0tuVFeSZOzaZXISAAAAoHKhKLkw99btJEnBP50wNwgAAABQyVCUXFh4lz6SpKhfU6SMDJPTAAAAAJUHRcmFNWjVS5d8JI8c6cL2tWbHAQAAACoNipIL8/X00+EoX0lS/FrufAcAAACUFYqSi7vUIEqSlLFji8lJAAAAgMqDouTijOYtJEl+B4+ZnAQAAACoPChKLi644+2SpKjYi1JOjslpAAAAgMqBouTi6nW6U+lWyT89R6mHD5gdBwAAAKgUKEouLjy4hg5HukuSfln3vclpAAAAgMqBolQOxNeNkCSlbFlnchIAAACgcqAolQOZTRtJkjz2cukdAAAAUBYoSuWAb4fOkqTw42dMTgIAAABUDhSlcqBm1zslSVUvZ8p+lrIEAAAAlDaKUjlQt2ZLHQu1SJJOr1tkchoAAACg4qMolQNWN6tORAdLki5u+tHkNAAAAEDFR1EqJ1Ia1819sHuXuUEAAACASsDli1JycrImTJigWrVqycfHR506ddK2bdvMjlXmPNu0lySF/BRnchIAAACg4nP5ovTwww9r+fLlmjlzpvbt26fevXurV69e+vXXX82OVqbCO/eRJFWPvyKlppqcBgAAAKjYLIZhGGaHuJG0tDQFBARowYIFGjBggGN9mzZt1K9fP/3lL3+56T6SkpJks9mUmJiowMDA0oxbqq5kpCglNEDhV6SLqxYptEc/syMBAAAA5UpRuoFLzyhlZ2fLbrfL29vbab2Pj4/Wr1+f72syMjKUlJTktFQEfl7+OhrlK0k6s36JyWkAAACAis2li1JAQIA6duyoN954Q6dPn5bdbtd//vMfbdq0SfHx8fm+ZsqUKbLZbI4lKiqqjFOXnksNakqSMrdvMTkJAAAAULG5dFGSpJkzZ8owDFWvXl1eXl768MMPNXLkSLm55R/9pZdeUmJiomM5depUGScuPUbLlpIkv0PHzA0CAAAAVHAuX5Tq1q2rNWvWKCUlRadOndLWrVuVlZWlOnXq5Dvey8tLgYGBTktFEdLxd5KkGicuSXa7yWkAAACAisvli9JVfn5+ioyM1OXLl7V06VINGjTI7EhlLua2/kp1l3wzDaUd3Gt2HAAAAKDCcvmitHTpUi1ZskSxsbFavny5br/9djVs2FBjx441O1qZi7BV16Fq7pKkX9f9YHIaAAAAoOJy+aKUmJio8ePHq2HDhnrwwQfVpUsXLV26VB4eHmZHM0V8vQhJUsrW/O/6BwAAAODWuZsd4GaGDx+u4cOHmx3DZWQ2bSz9+Is89h00OwoAAABQYbn8jBKc+bfvIkmKPHpGct3vCgYAAADKNYpSOVOzywDZLVJIcpbsp381Ow4AAABQIVGUypmYqBY6UsUiSYpfv9jkNAAAAEDFRFEqZ6xuVp2sHSxJurzxR5PTAAAAABUTRakcSmlUL/fB7t2m5gAAAAAqKopSOeTZtoMkKeTISZOTAAAAABUTRakciujcR5IUeTZVSk42OQ0AAABQ8VCUyqFGTbrr1wDJzZAubV5tdhwAAACgwqEolUP+nv46UtNPknR2w1KT0wAAAAAVD0WpnLrUoKYkKXPnNpOTAAAAABUPRamcsrRsKUkKOHjM3CAAAABABURRKqdCOv5OklQ97rKUlWVyGgAAAKBioSiVU/Xb9VWSp+SVbSh9/x6z4wAAAAAVCkWpnIoMrK6D1dwlSafXLTI5DQAAAFCxUJTKKYvFojP1IiVJKVvXm5wGAAAAqFgoSuVYZvMmkiSvfQdNTgIAAABULBSlciygfRdJUsTxs5JhmJwGAAAAqDgoSuVYdKf+ynKTbFeylXMyzuw4AAAAQIVBUSrHYqo3009hFknSmXVLTE4DAAAAVBwUpXLM3c1dJ+uESJIubV5lchoAAACg4qAolXNXGsdIkix7dpsbBAAAAKhAKErlnGebDpKk0MOnTE4CAAAAVBwUpXIuokuf3D/Pp0kJCeaGAQAAACoIilI516R+F52w5T5O2LzG3DAAAABABUFRKucCvAJ0tKafJOnshqUmpwEAAAAqBopSBXC5QU1JUtaOrSYnAQAAACoGilIFYGnVWpIUcOhnk5MAAAAAFQNFqQII7dhTklTtVIKUmWluGAAAAKACoChVAA1a36FL3pKH3VD67h1mxwEAAADKPYpSBVAtsLoOVPeQJMVvWGxyGgAAAKD8oyhVABaLRWfrRUqSrmzdaHIaAAAAoPyjKFUQ2c2aSJK89x00OQkAAABQ/lGUKoiADl0lSZHHz0k5OSanAQAAAMo3ilIFEd2xnzKskl+6XTmx3CYcAAAAuBUuXZTsdrteffVV1a5dWz4+Pqpbt67eeOMNGYZhdjSX0yCyqQ6EWyRJZ9ctMTkNAAAAUL65dFF6++23NW3aNH388cc6dOiQ3n77bb3zzjv66KOPzI7mctzd3HWqdogkKWHzanPDAAAAAOWcu9kBCrJx40YNGjRIAwYMkCRFR0dr9uzZ2rp1q8nJXFNKk/rShk2y7NlrdhQAAACgXHPpGaVOnTpp5cqVOnLkiCRpz549Wr9+vfr163fD12RkZCgpKclpqSy823SQJIUeOWVyEgAAAKB8c+kZpRdffFFJSUlq2LChrFar7Ha7Jk+erFGjRt3wNVOmTNGkSZPKMKXrqNa5r6QPFHYpXbpwQapSxexIAAAAQLnk0jNKc+fO1ZdffqlZs2Zp586d+vzzz/Xuu+/q888/v+FrXnrpJSUmJjqWU6cqz+xKk3oddSw493Hi5jXmhgEAAADKMZeeUXr++ef14osv6t5775UkNWvWTHFxcZoyZYpGjx6d72u8vLzk5eVVljFdRqBXoDbU8lO9y1d0bsMy2e682+xIAAAAQLnk0jNKqampcnNzjmi1WpXDF6re0OUG0ZKk7B3bzA0CAAAAlGMuPaM0cOBATZ48WTVr1lSTJk20a9cuvf/++xo3bpzZ0VyWW6tW0lcHFPATXzoLAAAAFJdLF6WPPvpIr776qp588kmdO3dO1apV02OPPabXXnvN7GguK7RTL0n/UeQviVJamuTjY3YkAAAAoNyxGIZhmB2iNCUlJclmsykxMVGBgYFmxyl1vySekme1mqqaKmVsXCevjl3MjgQAAAC4hKJ0A5f+jBKKrnpgDR2o7iFJOrNusclpAAAAgPKJolTBWCwWnYuJlCSlbttochoAAACgfKIoVUBZzZpKkrz2/2RyEgAAAKB8oihVQAEdukqSIn8+J9ntJqcBAAAAyh+KUgVUp0NfpbpLPpk5yjl6xOw4AAAAQLlDUaqAGoY30b4IiyTp/IblJqcBAAAAyh+KUgXkYfXQqTqhkqSEzavNDQMAAACUQxSlCiq1cX1JktuevSYnAQAAAMofilIF5d22gySpypFfTE4CAAAAlD8UpQqqeud+sluk4MQM6cwZs+MAAAAA5QpFqYJqGt1eR3I/pqSkTWvMDQMAAACUMxSlCsrmbdOxmn6SpPMbufMdAAAAUBQUpQrscsPakqTsXdtNTgIAAACULxSlCszaqrUkKfBQrMlJAAAAgPKFolSBVenYU5IUHp8kpaSYnAYAAAAoPyhKFVijpj102l9yM6SMndvMjgMAAACUGxSlCiwqMEr7q7tLks5uWGpyGgAAAKD8oChVYBaLRediqkuS0rZtMjkNAAAAUH5QlCo4e/OmkiSf/T+ZnAQAAAAoPyhKFVxgh26SpPDY81J2tslpAAAAgPKBolTB1W3XW8mekle2IeMnZpUAAACAwqAoVXANqzbW3giLJOn8huUmpwEAAADKB4pSBedp9dQvtUMlSYmbV5sbBgAAACgnKEqVQGrTBpIkt737TE4CAAAAlA8UpUrAu11HSVLYkV8kwzA5DQAAAOD6KEqVQI3beivbIgWmZEm//GJ2HAAAAMDlFasonTp1Sr9c8xfurVu3asKECfr0009LLBhKTvNa7XUoLPdx8pZ15oYBAAAAyoFiFaX77rtPq1atkiSdOXNGd9xxh7Zu3aqXX35Zr7/+eokGxK2zedt0tKafJOn8xhUmpwEAAABcX7GK0v79+9W+fXtJ0ty5c9W0aVNt3LhRX375pWbMmFGS+VBCEhvVliTZd243OQkAAADg+opVlLKysuTl5SVJWrFihe666y5JUsOGDRUfH19y6VBi3Fq2liTZfoo1OQkAAADg+opVlJo0aaJ//vOfWrdunZYvX66+fftKkk6fPq3Q0NASDYiSEdbpDklS1bMpUkKCuWEAAAAAF1esovT222/rk08+UY8ePTRy5Ei1aNFCkrRw4ULHJXlwLU0adlWcLfdxFpffAQAAAAVyL86LevTooQsXLigpKUnBwcGO9Y8++qh8fX1LLBxKTk1bTS2u5q5aidk6u2GZavyul9mRAAAAAJdVrBmltLQ0ZWRkOEpSXFycPvjgAx0+fFhVq1Yt0YAoGRaLRefrV5ckpW3fZHIaAAAAwLUVqygNGjRIX3zxhSQpISFBHTp00HvvvafBgwdr2rRpJRoQJSe7eTNJks/+wyYnAQAAAFxbsYrSzp071bVrV0nSN998o/DwcMXFxemLL77Qhx9+WKIBo6OjZbFYrlvGjx9fosepDGy3dZckhcddkDIzTU4DAAAAuK5iFaXU1FQFBARIkpYtW6ahQ4fKzc1Nt912m+Li4ko04LZt2xQfH+9Yli9fLkkaNmxYiR6nMohp1UuXvSUPuyHjwAGz4wAAAAAuq1hFqV69evr222916tQpLV26VL1795YknTt3ToGBgSUaMCwsTBEREY7l+++/V926ddW9e/cSPU5l0KhqY+2JsEiSLm5aaXIaAAAAwHUVqyi99tpreu655xQdHa327durY8eOknJnl1q1alWiAa+VmZmp//znPxo3bpwsFku+YzIyMpSUlOS0IJen1VO/1KkiSUrcvNrcMAAAAIALK1ZRuueee3Ty5Elt375dS5cudazv2bOn/vrXv5ZYuLy+/fZbJSQkaMyYMTccM2XKFNlsNscSFRVVannKo7Qm9SVJ1j37TU4CAAAAuC6LYRjGrezgl19+kSTVqFGjRAIVpE+fPvL09NR33313wzEZGRnKyMhwPE9KSlJUVJQSExNL/LLA8ug/M5/X/Q++qys+7vK7kindYGYOAAAAqGiSkpJks9kK1Q2KNaOUk5Oj119/XTabTbVq1VKtWrUUFBSkN954Qzk5OcUKfTNxcXFasWKFHn744QLHeXl5KTAw0GnBb6I69FaGVfJLy5ZOnDA7DgAAAOCS3Ivzopdffln/93//p7feekudO3eWJK1fv14TJ05Uenq6Jk+eXKIhJWn69OmqWrWqBgwYUOL7rkyaR7XVgTCp9RkpZfM6+deubXYkAAAAwOUUqyh9/vnn+te//qW77rrLsa558+aqXr26nnzyyRIvSjk5OZo+fbpGjx4td/diRcb/BPsEa3lNP7U+c0UXNq2Q/8gHzY4EAAAAuJxiXXp36dIlNWzY8Lr1DRs21KVLl245VF4rVqzQyZMnNW7cuBLfd2WU2KiOJCln106TkwAAAACuqVhFqUWLFvr444+vW//xxx+refPmtxwqr969e8swDNWvX7/E910ZWVu3kSQFHYo1OQkAAADgmop1Hds777yjAQMGaMWKFY7vUNq0aZNOnTqlRYsWlWhAlLyqHXtJmqGQi6nShQtSlSpmRwIAAABcSrFmlLp3764jR45oyJAhSkhIUEJCgoYOHaoDBw5o5syZJZ0RJaxpTGcdD859nLVzu7lhAAAAABd0y9+jdK09e/aodevWstvtJbXLW1aUe6VXFoZhaGFzTw3an63Tr05QtddL70uCAQAAAFdR6t+jhPLNYrHol6Y1c58sXWZuGAAAAMAFUZQqqcTe3SVJ4dsPSZcvm5wGAAAAcC0UpUqqXbeR2ldVsuYYyvnuO7PjAAAAAC6lSHe9Gzp0aIHbExISbiULylD36O76WxMvNTuXoctzpiv0Qb54FgAAALiqSEXJZrPddPuD/IW7XPC0eiqh3+3SqiXyX7VBSkuTfHzMjgUAAAC4hCIVpenTp5dWDpigZb+xOvWXJYpKypKxfLksd91ldiQAAADAJfAZpUqsb0w/fdco9xRI+Opzk9MAAAAAroOiVIkFeAXoVM+2kiSvH5ZILvT9VwAAAICZKEqVXN27xuiSt+SbmCpt3Gh2HAAAAMAlUJQquYFNhur7+rmPk7+aaW4YAAAAwEVQlCq5cP9w/dSloSQp59v5kmGYnAgAAAAwH0UJCh/6gNLcJduvF6T9+82OAwAAAJiOogT1bzlMy+vkPk77era5YQAAAAAXQFGCYkJjtK1dNUlS6jcUJQAAAICiBEmSz9Dhsluk0EMnpJMnzY4DAAAAmIqiBElS79tGaUNU7uOsed+YGwYAAAAwGUUJkqQ2kW20qmWgJCnxq89NTgMAAACYi6IESZLFYpFx112SpOCt+6RLl0xOBAAAAJiHogSHLreP1t6qkjXHUM5335kdBwAAADANRQkO3Wt115KmXpKkS3Omm5wGAAAAMA9FCQ4eVg8l9fudJClw1QYpLc3kRAAAAIA5KEpw0rLfWMXZJM+MbBnLlpkdBwAAADAFRQlO+tTrq+8aWSVJCXNmmBsGAAAAMAlFCU4CvAL06+/aSpK8Fi+TsrNNTgQAAACUPYoSrhMzaJwueUu+ianSxo1mxwEAAADKHEUJ17mzyWB91yD3cfJXM80NAwAAAJiAooTrVPWrqsNdGkqScr6dLxmGyYkAAACAskVRQr7ChzygNHfJdvqitG+f2XEAAACAMkVRQr4GtBquZXVzH6d9PdvcMAAAAEAZoyghX/VC6ml7++qSpLRvKEoAAACoXChKuCHfwcNlt0ghP8VJcXFmxwEAAADKDEUJN9T7tlFaXzP3cea8b8wNAwAAAJQhly9Kv/76q+6//36FhobKx8dHzZo10/bt282OVSm0jmyt1S1tkqSkr74wOQ0AAABQdly6KF2+fFmdO3eWh4eHFi9erIMHD+q9995TcHCw2dEqBYvFImPgXZKk4G37pIsXTU4EAAAAlA13swMU5O2331ZUVJSmT5/uWFe7dm0TE1U+XW8frT3hM9XirKGchQvlNnas2ZEAAACAUufSM0oLFy5U27ZtNWzYMFWtWlWtWrXSZ599VuBrMjIylJSU5LSg+LrV6qYlTb0kSZe/mn6T0QAAAEDF4NJF6eeff9a0adMUExOjpUuX6oknntAzzzyjzz///IavmTJlimw2m2OJiooqw8QVj4fVQ8n9ekqSAlZvklJTTU4EAAAAlD6LYRiG2SFuxNPTU23bttXGjRsd65555hlt27ZNmzZtyvc1GRkZysjIcDxPSkpSVFSUEhMTFRgYWOqZK6L/HvhGbToPU3SiZMyfL8vgwWZHAgAAAIosKSlJNputUN3ApWeUIiMj1bhxY6d1jRo10smTJ2/4Gi8vLwUGBjotuDV9Yvrqu8ZWSVLCVzPMDQMAAACUAZcuSp07d9bhw4ed1h05ckS1atUyKVHl5O/pr/ie7SVJXouWS9nZJicCAAAASpdLF6Xf//732rx5s958800dO3ZMs2bN0qeffqrx48ebHa3SiblrrC76SL5JqdKGDWbHAQAAAEqVSxeldu3aaf78+Zo9e7aaNm2qN954Qx988IFGjRpldrRK587Gg/V9g9zHSV/NNDcMAAAAUMpc+mYOJaEoH9hCwf7f04315seHlBgZItuvFySLxexIAAAAQKFVmJs5wLVEDH1Qqe6SLf6StHev2XEAAACAUkNRQqENaDFMy+rmPk79era5YQAAAIBSRFFCodUNqavt7WtIktK/oSgBAACg4qIooUj8h46Q3SKFHD4pnThhdhwAAACgVFCUUCS9O9yndTVzH2fO+8bcMAAAAEApoSihSFpFtNKalkGSpKQ5n5sbBgAAACglFCUUicVikTHoLklSyI4D0oULJicCAAAASh5FCUXWrcdo7Q6X3HIM5SxcaHYcAAAAoMRRlFBkXWt21ZJm3pKkS3Omm5wGAAAAKHkUJRSZh9VDyf16SpIC126WUlNNTgQAAACULIoSiqVt33GKDZI8M7JlLF1qdhwAAACgRFGUUCy96/XR942tkqTLc2aYGwYAAAAoYRQlFIufp5/ie3aQJHkvWS5lZ5ucCAAAACg5FCUUW/2BY3XBR/JNSpPWrzc7DgAAAFBiKEootgGNB+n7BrmPk776wtwwAAAAQAmiKKHYwvzCdKRr49wn3y6QDMPcQAAAAEAJoSjhlkQOeVCp7lLgmUvSnj1mxwEAAABKBEUJt2RAy2FaWi/3cerXs8wNAwAAAJQQihJuSZ3gOtrRvoYkKf2br0xOAwAAAJQMihJumf+Qe2W3SCFHTkqxsWbHAQAAAG4ZRQm3rE+H+7S2Vu7jzP/ONTcMAAAAUAIoSrhlLSNaak3LIElS0lczzQ0DAAAAlACKEm6ZxWKRZdBgSVLIzoPS+fPmBgIAAABuEUUJJaJb9we1M0JyyzFkX7jA7DgAAADALaEooUR0rdVVS5v5SJIuz5lhbhgAAADgFlGUUCLc3dx1pX8vSZJt7WbpyhWTEwEAAADFR1FCiWnbZ6x+DpI8Mu0yli41Ow4AAABQbBQllJje9fro+8ZWSdLlOdNNTgMAAAAUH0UJJcbXw1dnet0mSfJZskLKzjY5EQAAAFA8FCWUqAYDx+q8r+STnC6tW2d2HAAAAKBYKEooUQMaD9L3DXIfJ331hblhAAAAgGKiKKFEVfGtoqNdm+Q+WbBAMgxzAwEAAADFQFFCiYsc8qCueEiBZy5Lu3ebHQcAAAAoMooSStydLYZpad3cx6lzvzQ3DAAAAFAMLl+UJk6cKIvF4rQ0bNjQ7FgoQO3g2trZIUqSlP7fr0xOAwAAABSdyxclSWrSpIni4+Mdy/r1682OhJsIGHKvsi1SyNFfpOPHzY4DAAAAFEm5KEru7u6KiIhwLFWqVDE7Em6iT4f7tLZW7uPMeV+bGwYAAAAoonJRlI4ePapq1aqpTp06GjVqlE6ePHnDsRkZGUpKSnJaUPZahLfQmlbBkqSkr2aanAYAAAAoGpcvSh06dNCMGTO0ZMkSTZs2TbGxseratauSk5PzHT9lyhTZbDbHEhUVVcaJISn382SDB0uSQnYdks6dMzcQAAAAUAQWwyhfX3STkJCgWrVq6f3339dDDz103faMjAxlZGQ4niclJSkqKkqJiYkKDAwsy6iV3uoTqxXQ6Xa1iZfsn30q68OPmB0JAAAAlVhSUpJsNluhuoHLzyjlFRQUpPr16+vYsWP5bvfy8lJgYKDTAnN0qdlFy5r6SJIuz5lhbhgAAACgCMpdUUpJSdHx48cVGRlpdhTchLubu1IH9JYk2dZukVJSTE4EAAAAFI7LF6XnnntOa9as0YkTJ7Rx40YNGTJEVqtVI0eONDsaCqFt7zE6Hix5ZNllLF1qdhwAAACgUFy+KP3yyy8aOXKkGjRooOHDhys0NFSbN29WWFiY2dFQCHfU663vG7tLki7PmW5yGgAAAKBw3M0OcDNz5swxOwJuga+Hr872uk3asF4+S1dKWVmSh4fZsQAAAIACufyMEsq/hgPH6byv5JOcLq1bZ3YcAAAA4KYoSih1Axrdpe8a5D5O/OoLc8MAAAAAhUBRQqkL9Q3VsW5NJUmWBQuk8vXVXQAAAKiEKEooE9UGP6grHlLg2QRp506z4wAAAAAFoiihTNzZcpiW1Mt9nPr1LHPDAAAAADdBUUKZiA6K1q4ONSVJGf/9yuQ0AAAAQMEoSigzAUPuVbZFCj72q3TsmNlxAAAAgBuiKKHM9G1/n1ZH5z7OnPe1qVkAAACAglCUUGaahzfXutYhkqSkuTNNTgMAAADcGEUJZcZiscg6eKgkKWTnIencOZMTAQAAAPmjKKFM9ej6gLZHSm6GZF/wrdlxAAAAgHxRlFCmOkV10vLmvpKky3NmmBsGAAAAuAGKEsqUu5u7Uvv3liTZ1m2VUlJMTgQAAABcj6KEMteu9xgdC5Y8suwyliwxOw4AAABwHYoSytwddXvrhybukqTLc6abnAYAAAC4HkUJZc7Hw0dne3XMfbz0Rykry+REAAAAgDOKEkzRaOA4nfOVfFLSpTVrzI4DAAAAOKEowRT9Gw7Udw0tkqTEr74wOQ0AAADgjKIEU4T6hup4t6aSJLcFCyXDMDkRAAAA8BuKEkxTffCDSvGQAs4nSjt2mB0HAAAAcKAowTR3thimJfVyH1+ZO8vcMAAAAMA1KEowTa2gWtp9Wy1JUua8uSanAQAAAH5DUYKpAoeOVJabFHz8V+noUbPjAAAAAJIoSjBZ33YjtTo693Hm11+ZmgUAAAC4iqIEUzWr2kzrW4dKktxf+7P01FPShQsmpwIAAEBlR1GCqSwWi9IfHKV5DSU3e470979LMTHSX/8qZWaaHQ8AAACVFEUJpnugwyO6b5SXfvegtDfCIiUkSH/4g9S0qbRgAd+xBAAAgDJHUYLpmlZtqt2P75Zbz55q9aihhwdK5wOsuTd3GDxY6tlT2r3b7JgAAACoRChKcAkNqzTU8geW68ths7Woe6TqPGXXm12kTA83adUqqXVr6eGHpTNnzI4KAACASoCiBJdhsVh0b9N79dNTP+mR7r/Xa3dYVf/JHH3TzJp7+d3//V/u55fefFNKSzM7LgAAACowihJcTqBXoN7v8752PrZT1Zt30rC77eo0Ttpby0dKSZFefllq1EiaM4fPLwEAAKBUUJTgspqHN9e6sev077v+raMNq6jl6DSNGipdDPWV4uKkkSOlzp2lLVvMjgoAAIAKhqIEl+ZmcdPYVmN1+KnDerTdY5rd3KKox1I1uZeXsrw9pU2bpNtuk0aNkk6dMjsuAAAAKgiKEsqFEJ8Q/fPOf2rLw1vUuFYbvdIlQ7WezNTCjiEyLBZp1iypfn3p1VdzL88DAAAAbgFFCeVKu+rttOXhLfp7/78rNcymQX0uqe0jho40iZTS06W//CW3MM2YIeXkmB0XAAAA5VS5KkpvvfWWLBaLJkyYYHYUmMjqZtWT7Z7U4acO68EWD2pnNanBPfEa+0CAkmqESfHx0tixUrt20tq1ZscFAABAOVRuitK2bdv0ySefqHnz5mZHgYsI9w/X54M/15oxa9SkahPNqJussDHn9fdhtWQP8Jd27pS6d5fuvls6ftzsuAAAAChHykVRSklJ0ahRo/TZZ58pODjY7DhwMd1qddOux3bp3Tvelaevv55qEqfqj1/Rhv7NZLi5SfPmSY0bS88/LyUmmh0XAAAA5UC5KErjx4/XgAED1KtXr5uOzcjIUFJSktOCis/D6qE/dvqjDo0/pGGNh+msn6Eu7ffpd78PUXynZlJmpvTuu1K9etK0aVJ2ttmRAQAA4MJcvijNmTNHO3fu1JQpUwo1fsqUKbLZbI4lKiqqlBPCldQIrKG5w+Zq6f1LFRMSo9UBF1Ttjn166Q/NlRFTR7pwQXrySallS2npUrPjAgAAwEW5dFE6deqUnn32WX355Zfy9vYu1GteeuklJSYmOpZTfLdOpdS7bm/te2Kf3rj9DXl7eOutwL0Kvu+kFo6/Q0ZIiHTggNS3r9S/v3TokNlxAQAA4GIshmEYZoe4kW+//VZDhgyR1Wp1rLPb7bJYLHJzc1NGRobTtvwkJSXJZrMpMTFRgYGBpR0ZLij2cqyeWfKMvj/yvSSpqUcNzT/SSnW/XCxLdrZktUqPPy5NnChVqWJuWAAAAJSaonQDly5KycnJiouLc1o3duxYNWzYUC+88IKaNm16031QlHDVwsML9cziZxSXmHtOPRLQQ39d6S6/RStyBwQFSa+9Jo0fL3l6mhcUAAAApaLCFKX89OjRQy1bttQHH3xQqPEUJVwrNStVk9dO1tSNU5WVkyVvd2994jtC98/YJbe9e3MHxcRI/+//SX36SJGR5gYGAABAiSlKN3DpzygBJc3Xw1eTe07W3if2qmftnkrPTtfopM/VaNwV7Z/8rBQeLh09mvuFtdWq5d5W/JlnpAULuLU4AABAJVLuZpSKihkl3IhhGJp7YK5+v/T3ik+JlyTdX3uQPj5ST7Ylq3O/sPba/3m4uUlt20q9ekk9e0qdOkmFvMkIAAAAzFehL70rKooSbiYpI0kTV0/Uh1s+lN2wy8/DT+PbjVffkPa67Xi6fFZvkFaulI4ccX6ht7fUpUtuaerVS2rVKvfGEAAAAHBJFKVrUJRQWHvP7tWTPzypDac2ONZZLVa1qdZG3Wp2U2/PRup0JE1+6zbnFqf4eOcdBAVJt9/+W3GqX1+yWMr2TQAAAOCGKErXoCihKHKMHP334H/1/dHvtTZurU4knHDabpFFzcObq1vNrhqQXUcdj6QqcP02adUqKSnJeWfVq/9Wmnr2zP3MEwAAAExDUboGRQm34mTiSa2LW6c1cWu0Nm6tDl88fN2YBqEN1KNGFw1OidJtR1IVtH6btGGDlJnpPLBhw99KU48euTNQAAAAKDMUpWtQlFCSzqac1bqT67Q2bq3Wxq3V3rN7Zcj5f0LRQdHqGdFJd1+KUIefkhW8cZcsO3bkf2OInj1zl86duTEEAABAKaMoXYOihNJ0Ke2SNpzckFucTq7VjtM7ZDfsTmMi/SPVL6SDhp0PU7ufkhSycbcsh/PMTHl755alq5fqtW7NjSEAAABKGEXpGhQllKWUzBRtPLXRMeO05dctyrQ7X4IX6hOqwf5tNSw+RG0PJSpk4y5Z8rsxRI8euaWpa9fcL8H18Smz9wEAAFARUZSuQVGCmdKz07X1161aG7dWa+LWaOOpjUrNSnUaE+Dhr3vdW+qe08FqcyhBIVv2ypLfl9vWqCHVq/fbEhOT+2fdupKfXxm9IwAAgPKLonQNihJcSZY9Szvjdzou1VsXt06JGc6lyM/ipQezm+ju00FqdfCygg/+nH9xula1ajcuUQEBpfiOAAAAyg+K0jUoSnBl9hy79p/b77ir3tq4tTqfet55kCE1dY9U14wItb4SqEYJHoo6l6Eqpy/LJ+60LJcuFXyQiIj8S1S9ehL/mwAAAJUIRekaFCWUJ4Zh6PDFw47StCZujX5J+qXA1zRyC1fXrEi1SbGpYaK7ap3LVJX4BPnEnZbbhYsFHzAszLk4XfuY25cDAIAKhqJ0DYoSyjPDMHQx7aKOXzquo5eO6tilY47l6KWjupRW8GxSjFuYumZFqm1qkBoleKjW+SyFnU6Q78l4uZ07X+BrFRp6fYmqWzf3i3TDwyUPjxJ8pwAAAKWPonQNihIqsktpl3T80nFHcbq2RF1IvVDga+tYQtU1u5rapgapcaKnos9nKSw+UX5xZ+R29mzBB7ZYpKpVcz8bVa2aFBn52+Nrl6pVuc05AABwGRSla1CUUFklpCfkW6KOXTqms1cKLkI13YLVLau62qYFq8n/SlTV+GT5/XJWbmfOymK3F/h6Bze33M9IFVSmqlWTqlTJHQsAAFCKKErXoCgB10vKSHKUqLxFKj4lvsDXelk81NQtQk2zQ1Q/w1+1U71UI8VNVZPsCrmcJv8LyfI6e1GWc+dkyckpXCB399wiVVCZqlZNCgnJnc0CAAAoBorSNShKQNGkZKY4lahri9Svyb8Wej9+bt5qpnA1yQ52FKrqKRZVTcxW8KU0+V1Ikuf5i7mflSrs/w15ev5WpiIjcz9HZbPl3niioD8DApixAgAAFKVrUZSAkpORnaH4lHjFJ8frdPLp35aU007PE9ITCr3PIKufmhlV1SQ7WDHpfopO9VT1ZIvCErMVdDlNfhcS5Xn2giwXCv7MVYEsltzCVJhSde2fVx/bbJKXV/GPDwAAXAJF6RoUJaDspWalKj45XvEpeQpVniU5M7nQ+wyzBqq5UVWNsoIUk+6rmqmeCsuwKijTosDUHPml2eVzJV2eKemyJiZJCQm5S1ZWybwpb++ilav8ZrW4bBAAAFNRlK5BUQJcV0pmyvWzU/nMUKVmpRZpvz7uPgrzC1MVn1BV9whVTdlUI8dfEXYfhWd5KTTLQ8EZFgWlGfJPs8s7JV2WpP+Vq8RE5z+TC1/mCuTmVrhZrRtts9lyLz0EAADFRlG6BkUJKN8Mw1BSRlK+s1PnU8/r/JXzOp96XhdSL+j8lfPKsGcU+RhWi1WhvqEK8w1TmF+YwnzDVMW3isJ8w1TVO1SROX4Kz/ZSWLanQjOssmVI7kkpv5Wpq8Uqb8m6+rikZrV8fQtXtAICJD+/3PG+vvk/9vZmhgsAUOlQlK5BUQIqD8MwlJKZ4lScrpapC6kXch/n2ZaUkVSsY9m8bE6lKsQnREHeQbJ52XL/9M79M8jLpiDDWyEZbrKlGwpIy5F7csr1paqgP0tqVutaFstv5elGZepWH3t6UsYAAC6FonQNihKAgmRkZ+hi2sX8S9W1s1X/e34x7aJyjELe9vwGfD188y1VV59ft83dXyGZ7grKsCgwPUc+VzJlyW8G69rLBVNTc5crV5z/zCj6jFuxWa2Sj4/k4ZG7eHr+9rio62719Z6euYuPj3Oh8/Njdg0AKpGidAP3MsoEAC7Jy91L1QKqqVpAtUKNzzFydDnt8nWl6nLaZSWkJygxI9H5z/TfnqdkpkjKvdlFalaqTiefLlZmq8X6W7nytikoKEi2BldnsGoqwCtAfh5+8vXwla+Hr/w8r3ns5i3/bDf5ZVnklyX5ZBnyyTTkkZ5543J1o8c3Wnf1C4ntdiklpVjvscwVZpasuLNrfn65ZY0yBgDlCjNKAFBGsnOylZSRdF2Byvf5DdZn52SXSjZ3N/ffytSNSpbHDR5fO8bdV37ylF+2Rf5ZFvlkSR45krvdkIfdkLvdkDU7R5bs7NzPbmVlSZmZvz2+dinp9ZmZUlrab4WurGfX8hYpL69bm00riRm5q+ut1rL7WdyMxXJ9RquVogmgRDCjBAAuyN3NXSE+IQrxCSnW6w3DUGpW6o3L1f+eJ2cmO2atrmRdyf0z80q+6+xG7uzP1RJX3M9sFZWHm4c8rB7ytHo6Hjutc/eQh5eH0zZPq6fTOMc6N5/rX5/PPj2tnvJx9/mt3Ll5KSDbKr8si3yzJN//za65p2fKcnWmrCgzbHnH5p1dS04unc+bVQb5laeSuByzNIpqQespe0C5QlECgHLCYrHIz9NPfp5+hb5UsCCGYSgrJ6vAIpV33bXrndbd4DVpWWkydP2FC1k5WY5juxqrxXr9TFqQr/yq5p1Rq3LTGTg/eco/2/JbGcs05J2ZI2tauvMMWFFmyW5lXX7rMzOlnFv73F2Jyi+LYeTmzMws+zwlyd391sqWm5vZ7wAovmrVpA8/NDtFkVCUAKCSslgsjpmWIO+gUjuOPceurJwsZdozlWXPLUjX/plpz7xuXYmNv2Z9pj1Tadlp+Za9a2fX7Ia91GfXPK2e8rJ65T9DZv3fbJpvwbNkueO95eEWcOP95Ddbl+9+bjBbd4N1VotVltKaHTGM3Bm4W73ssiQu3byVfVydTbxWdnbukpZWOj87wJU1aGB2giKjKAEASpXVzSqrm1Xe7t5mRylQpj3zulmzQs+wZRfudVdn1zLtmcq0l+/ZkZtePlmUddesd3dzL14Js/5vKdJp5ibJ639LybLkGHKz58iabZc1O0du2XZZ7TmyZueuc/vfeqs9d5v71THXrLs61pqdk7svw+L435PVkudPN3dZLW6/rXNsd//fn25O493d3GW1WOXmWOcmqyV3vZuFmSuUgqAgsxMUGUUJAACp1GfXDMNQena6o0RdOwNWlNmzQq/LuX6f+R2nMMcub5dPVghXi9+tdjhDUj6TWwWxyHLTGUarxYVuAIJyIdoSrYW6z+wYRUJRAgCgDFgsFvl4+MjHw0ehCjU7TpFcvXyyOJdKFrUIltadHcs7Q4bsOfbffmYlVKrzm9k0ZPw265llwptFhVQeZ9EpSgAAoEDl5fJJFJ1hGLIb9iLPPt7qF2+j8vH18DU7QpFRlAAAACopi8Uid4u73N3c5SMfs+MALoVP6wEAAABAHhQlAAAAAMiDogQAAAAAebh8UZo2bZqaN2+uwMBABQYGqmPHjlq8eLHZsQAAAABUYC5flGrUqKG33npLO3bs0Pbt2/W73/1OgwYN0oEDB8yOBgAAAKCCshiGcf23yLm4kJAQTZ06VQ899NB12zIyMpSRkeF4npSUpKioKCUmJiowMLAsYwIAAABwIUlJSbLZbIXqBi4/o3Qtu92uOXPm6MqVK+rYsWO+Y6ZMmSKbzeZYoqKiyjglAAAAgPKuXMwo7du3Tx07dlR6err8/f01a9Ys9e/fP9+xzCgBAAAAyE9RZpTKxRfONmjQQLt371ZiYqK++eYbjR49WmvWrFHjxo2vG+vl5SUvLy8TUgIAAACoKMrFjFJevXr1Ut26dfXJJ5/cdGxRWiMAAACAiqvCfkbpqpycHKfL6wAAAACgJLn8pXcvvfSS+vXrp5o1ayo5OVmzZs3S6tWrtXTpUrOjAQAAAKigXL4onTt3Tg8++KDi4+Nls9nUvHlzLV26VHfccYfZ0QAAAABUUC5flP7v//7P7AgAAAAAKhmXL0q36uq9KpKSkkxOAgAAAMBMVztBYe5nV+GLUnJysiTxxbMAAAAAJOV2BJvNVuCYcnl78KLIycnR6dOnFRAQIIvFYmqWq19+e+rUKW5VjkLhnEFRcc6gqDhnUFScMygqVzpnDMNQcnKyqlWrJje3gm8AXuFnlNzc3FSjRg2zYzgJDAw0/SRB+cI5g6LinEFRcc6gqDhnUFSucs7cbCbpqnL5PUoAAAAAUJooSgAAAACQB0WpDHl5eenPf/6zvLy8zI6CcoJzBkXFOYOi4pxBUXHOoKjK6zlT4W/mAAAAAABFxYwSAAAAAORBUQIAAACAPChKAAAAAJAHRQkAAAAA8qAolaG///3vio6Olre3tzp06KCtW7eaHQllYMqUKWrXrp0CAgJUtWpVDR48WIcPH3Yak56ervHjxys0NFT+/v66++67dfbsWacxJ0+e1IABA+Tr66uqVavq+eefV3Z2ttOY1atXq3Xr1vLy8lK9evU0Y8aM0n57KGVvvfWWLBaLJkyY4FjH+YK8fv31V91///0KDQ2Vj4+PmjVrpu3btzu2G4ah1157TZGRkfLx8VGvXr109OhRp31cunRJo0aNUmBgoIKCgvTQQw8pJSXFaczevXvVtWtXeXt7KyoqSu+8806ZvD+ULLvdrldffVW1a9eWj4+P6tatqzfeeEPX3t+Lc6ZyW7t2rQYOHKhq1arJYrHo22+/ddpelufH119/rYYNG8rb21vNmjXTokWLSvz93pCBMjFnzhzD09PT+Pe//20cOHDAeOSRR4ygoCDj7NmzZkdDKevTp48xffp0Y//+/cbu3buN/v37GzVr1jRSUlIcYx5//HEjKirKWLlypbF9+3bjtttuMzp16uTYnp2dbTRt2tTo1auXsWvXLmPRokVGlSpVjJdeeskx5ueffzZ8fX2NP/zhD8bBgweNjz76yLBarcaSJUvK9P2i5GzdutWIjo42mjdvbjz77LOO9ZwvuNalS5eMWrVqGWPGjDG2bNli/Pzzz8bSpUuNY8eOOca89dZbhs1mM7799ltjz549xl133WXUrl3bSEtLc4zp27ev0aJFC2Pz5s3GunXrjHr16hkjR450bE9MTDTCw8ONUaNGGfv37zdmz55t+Pj4GJ988kmZvl/cusmTJxuhoaHG999/b8TGxhpff/214e/vb/ztb39zjOGcqdwWLVpkvPzyy8a8efMMScb8+fOdtpfV+bFhwwbDarUa77zzjnHw4EHjlVdeMTw8PIx9+/aV+s/AMAyDolRG2rdvb4wfP97x3G63G9WqVTOmTJliYiqY4dy5c4YkY82aNYZhGEZCQoLh4eFhfP31144xhw4dMiQZmzZtMgwj9/+w3NzcjDNnzjjGTJs2zQgMDDQyMjIMwzCMP/3pT0aTJk2cjjVixAijT58+pf2WUAqSk5ONmJgYY/ny5Ub37t0dRYnzBXm98MILRpcuXW64PScnx4iIiDCmTp3qWJeQkGB4eXkZs2fPNgzDMA4ePGhIMrZt2+YYs3jxYsNisRi//vqrYRiG8Y9//MMIDg52nENXj92gQYOSfksoZQMGDDDGjRvntG7o0KHGqFGjDMPgnIGzvEWpLM+P4cOHGwMGDHDK06FDB+Oxxx4r0fd4I1x6VwYyMzO1Y8cO9erVy7HOzc1NvXr10qZNm0xMBjMkJiZKkkJCQiRJO3bsUFZWltP50bBhQ9WsWdNxfmzatEnNmjVTeHi4Y0yfPn2UlJSkAwcOOMZcu4+rYzjHyqfx48drwIAB1/1OOV+Q18KFC9W2bVsNGzZMVatWVatWrfTZZ585tsfGxurMmTNOv2+bzaYOHTo4nTNBQUFq27atY0yvXr3k5uamLVu2OMZ069ZNnp6ejjF9+vTR4cOHdfny5dJ+myhBnTp10sqVK3XkyBFJ0p49e7R+/Xr169dPEucMClaW54fZ/62iKJWBCxcuyG63O/2lRZLCw8N15swZk1LBDDk5OZowYYI6d+6spk2bSpLOnDkjT09PBQUFOY299vw4c+ZMvufP1W0FjUlKSlJaWlppvB2Ukjlz5mjnzp2aMmXKdds4X5DXzz//rGnTpikmJkZLly7VE088oWeeeUaff/65pN9+5wX9N+jMmTOqWrWq03Z3d3eFhIQU6bxC+fDiiy/q3nvvVcOGDeXh4aFWrVppwoQJGjVqlCTOGRSsLM+PG40pq/PHvUyOAkBS7izB/v37tX79erOjwEWdOnVKzz77rJYvXy5vb2+z46AcyMnJUdu2bfXmm29Kklq1aqX9+/frn//8p0aPHm1yOriiuXPn6ssvv9SsWbPUpEkT7d69WxMmTFC1atU4Z4BrMKNUBqpUqSKr1XrdXanOnj2riIgIk1KhrD311FP6/vvvtWrVKtWoUcOxPiIiQpmZmUpISHAaf+35ERERke/5c3VbQWMCAwPl4+NT0m8HpWTHjh06d+6cWrduLXd3d7m7u2vNmjX68MMP5e7urvDwcM4XOImMjFTjxo2d1jVq1EgnT56U9NvvvKD/BkVEROjcuXNO27Ozs3Xp0qUinVcoH55//nnHrFKzZs30wAMP6Pe//71jFptzBgUpy/PjRmPK6vyhKJUBT09PtWnTRitXrnSsy8nJ0cqVK9WxY0cTk6EsGIahp556SvPnz9ePP/6o2rVrO21v06aNPDw8nM6Pw4cP6+TJk47zo2PHjtq3b5/T/+ksX75cgYGBjr8gdezY0WkfV8dwjpUvPXv21L59+7R7927H0rZtW40aNcrxmPMF1+rcufN1Xzlw5MgR1apVS5JUu3ZtRUREOP2+k5KStGXLFqdzJiEhQTt27HCM+fHHH5WTk6MOHTo4xqxdu1ZZWVmOMcuXL1eDBg0UHBxcau8PJS81NVVubs5/BbRarcrJyZHEOYOCleX5Yfp/q8rklhEw5syZY3h5eRkzZswwDh48aDz66KNGUFCQ012pUDE98cQThs1mM1avXm3Ex8c7ltTUVMeYxx9/3KhZs6bx448/Gtu3bzc6duxodOzY0bH96u2ee/fubezevdtYsmSJERYWlu/tnp9//nnj0KFDxt///ndu91xBXHvXO8PgfIGzrVu3Gu7u7sbkyZONo0ePGl9++aXh6+tr/Oc//3GMeeutt4ygoCBjwYIFxt69e41BgwbleyvfVq1aGVu2bDHWr19vxMTEON3KNyEhwQgPDzceeOABY//+/cacOXMMX19fbvVcDo0ePdqoXr264/bg8+bNM6pUqWL86U9/cozhnKnckpOTjV27dhm7du0yJBnvv/++sWvXLiMuLs4wjLI7PzZs2GC4u7sb7777rnHo0CHjz3/+M7cHr6g++ugjo2bNmoanp6fRvn17Y/PmzWZHQhmQlO8yffp0x5i0tDTjySefNIKDgw1fX19jyJAhRnx8vNN+Tpw4YfTr18/w8fExqlSpYvzxj380srKynMasWrXKaNmypeHp6WnUqVPH6Rgov/IWJc4X5PXdd98ZTZs2Nby8vIyGDRsan376qdP2nJwc49VXXzXCw8MNLy8vo2fPnsbhw4edxly8eNEYOXKk4e/vbwQGBhpjx441kpOTncbs2bPH6NKli+Hl5WVUr17deOutt0r9vaHkJSUlGc8++6xRs2ZNw9vb26hTp47x8ssvO92mmXOmclu1alW+f3cZPXq0YRhle37MnTvXqF+/vuHp6Wk0adLE+OGHH0rtfedlMYxrvoYZAAAAAMBnlAAAAAAgL4oSAAAAAORBUQIAAACAPChKAAAAAJAHRQkAAAAA8qAoAQAAAEAeFCUAAAAAyIOiBAAAAAB5UJQAAKaJjo7WBx98UOjxq1evlsViUUJCQqllAgBAoigBAArBYrEUuEycOLFY+922bZseffTRQo/v1KmT4uPjZbPZinW8ovjss8/UokUL+fv7KygoSK1atdKUKVMc28eMGaPBgweXeg4AgDnczQ4AAHB98fHxjsdfffWVXnvtNR0+fNixzt/f3/HYMAzZ7Xa5u9/8PzFhYWFFyuHp6amIiIgivaY4/v3vf2vChAn68MMP1b17d2VkZGjv3r3av39/qR8bAOAamFECANxURESEY7HZbLJYLI7nP/30kwICArR48WK1adNGXl5eWr9+vY4fP65BgwYpPDxc/v7+ateunVasWOG037yX3lksFv3rX//SkCFD5Ovrq5iYGC1cuNCxPe+ldzNmzFBQUJCWLl2qRo0ayd/fX3379nUqdtnZ2XrmmWcUFBSk0NBQvfDCCxo9enSBs0ELFy7U8OHD9dBDD6levXpq0qSJRo4cqcmTJ0uSJk6cqM8//1wLFixwzKqtXr1aknTq1CkNHz5cQUFBCgkJ0aBBg3TixAnHvq/ORE2aNElhYWEKDAzU448/rszMTMeYb775Rs2aNZOPj49CQ0PVq1cvXblypYi/NQDAraAoAQBKxIsvvqi33npLhw4dUvPmzZWSkqL+/ftr5cqV2rVrl/r27auBAwfq5MmTBe5n0qRJGj58uPbu3av+/ftr1KhRunTp0g3Hp6am6t1339XMmTO1du1anTx5Us8995xj+9tvv60vv/xS06dP14YNG5SUlKRvv/22wAwRERHavHmz4uLi8t3+3HPPafjw4Y5SFh8fr06dOikrK0t9+vRRQECA1q1bpw0bNjjK27VFaOXKlTp06JBWr16t2bNna968eZo0aZKk3Nm7kSNHaty4cY4xQ4cOlWEYBWYGAJQwAwCAIpg+fbphs9kcz1etWmVIMr799tubvrZJkybGRx995Hheq1Yt469//avjuSTjlVdecTxPSUkxJBmLFy92Otbly5cdWSQZx44dc7zm73//uxEeHu54Hh4ebkydOtXxPDs726hZs6YxaNCgG+Y8ffq0cdtttxmSjPr16xujR482vvrqK8NutzvGjB49+rp9zJw502jQoIGRk5PjWJeRkWH4+PgYS5cudbwuJCTEuHLlimPMtGnTDH9/f8Nutxs7duwwJBknTpy4YT4AQOljRgkAUCLatm3r9DwlJUXPPfecGjVqpKCgIPn7++vQoUM3nVFq3ry547Gfn58CAwN17ty5G4739fVV3bp1Hc8jIyMd4xMTE3X27Fm1b9/esd1qtapNmzYFZoiMjNSmTZu0b98+Pfvss8rOztbo0aPVt29f5eTk3PB1e/bs0bFjxxQQECB/f3/5+/srJCRE6enpOn78uGNcixYt5Ovr63jesWNHpaSk6NSpU2rRooV69uypZs2aadiwYfrss890+fLlAvMCAEoeN3MAAJQIPz8/p+fPPfecli9frnfffVf16tWTj4+P7rnnHqdL0PLj4eHh9NxisRRYTvIbb5TQZWpNmzZV06ZN9eSTT+rxxx9X165dtWbNGt1+++35jk9JSVGbNm305ZdfXretsDeusFqtWr58uTZu3Khly5bpo48+0ssvv6wtW7aodu3at/R+AACFx4wSAKBUbNiwQWPGjNGQIUPUrFkzRUREON3UoCzYbDaFh4dr27ZtjnV2u107d+4s8r4aN24sSY6bKnh6esputzuNad26tY4ePaqqVauqXr16Tsu1tzTfs2eP0tLSHM83b94sf39/RUVFScote507d9akSZO0a9cueXp6av78+UXODAAoPooSAKBUxMTEaN68edq9e7f27Nmj++67r8CZodLy9NNPa8qUKVqwYIEOHz6sZ599VpcvX5bFYrnha5544gm98cYb2rBhg+Li4rR582Y9+OCDCgsLU8eOHSXl3rFv7969Onz4sC5cuKCsrCyNGjVKVapU0aBBg7Ru3TrFxsZq9erVeuaZZ/TLL7849p+ZmamHHnpIBw8e1KJFi/TnP/9ZTz31lNzc3LRlyxa9+eab2r59u06ePKl58+bp/PnzatSoUan/rAAAv6EoAQBKxfvvv6/g4GB16tRJAwcOVJ8+fdS6desyz/HCCy9o5MiRevDBB9WxY0f5+/urT58+8vb2vuFrevXqpc2bN2vYsGGqX7++7r77bnl7e2vlypUKDQ2VJD3yyCNq0KCB2rZtq7CwMG3YsEG+vr5au3atatasqaFDh6pRo0Z66KGHlJ6ersDAQMf+e/bsqZiYGHXr1k0jRozQXXfd5fjS3sDAQK1du1b9+/dX/fr19corr+i9995Tv379SvXnBABwZjFK6kJuAADKgZycHDVq1EjDhw/XG2+8UebHHzNmjBISEm56i3IAgLm4mQMAoEKLi4vTsmXL1L17d2VkZOjjjz9WbGys7rvvPrOjAQBcGJfeAQAqNDc3N82YMUPt2rVT586dtW/fPq1YsYLP/AAACsSldwAAAACQBzNKAAAAAJAHRQkAAAAA8qAoAQAAAEAeFCUAAAAAyIOiBAAAAAB5UJQAAAAAIA+KEgAAAADkQVECAAAAgDz+P6T3NXmtfwxZAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "steps = [i * config.eval_interval for i in range(len(train_loss_list))]\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(steps, train_loss_list, 'g', label='Train Loss')\n",
    "plt.plot(steps, val_loss_list, 'r', label='Validation Loss')\n",
    "plt.xlabel(f\"Training Steps\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.title(\"Training vs. Validation Loss\")\n",
    "plt.show()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20d3d418",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading best model from out/best_model.pt...\n",
      "Model created. Number of parameters: 29.92M\n",
      "Compiling the loaded model...\n",
      "Model loaded and ready for generation.\n",
      "\n",
      "Generating text 1...\n",
      "Prompt: \"Once upon a time there was a girl.\"\n",
      "--------------------\n",
      "Once upon a time there was a girl. She was very sad but she couldn't see.\n",
      "\n",
      "When she was walking. She saw a big, big box, and was so sad. As she looked around, she heard a big tree. It was a tree that was so big. She started to go away. It got the big and went up to the water. She was so happy to find the box. She put the rock back on her. She looked around and and saw a big, big box. It was bright and big and shiny.\n",
      "\n",
      "The rabbit was so happy to have a new friend. She felt so happy and proud. She had a new toy that would be happy and always make the ball feel better.<|endoftext|>Once upon a time, there was a little girl named Lily. She was very happy. She loved to play outside in the park. One day, they saw a big, beautiful bird. The tree was scared and wanted to go on a big, so she went to the tree.\n",
      "\n",
      "--------------------\n",
      "\n",
      "Generating text 2...\n",
      "Prompt: \"A little girl went to the woods\"\n",
      "--------------------\n",
      "A little girl went to the woods that and she couldn't help her mom! She was so scared and was happy and was so happy. She looked at her family and said, \"What are you doing? I will go to the park and get the ball in the box.\"\n",
      "\n",
      "The boy looked at the bird's friends and smiled. She said, \"Yes, you can have a big new friend.\" The little girl was so happy that she decided to make a new house with her mom. The little girl made a big smile on herself. So, she was happy to do a new friend and her little girl had a great time. She was happy with her best friend and they all were very proud of herself.<|endoftext|>Once upon a time, there was a little girl named Lily. She loved to play outside in her garden. One day, she found a big, big box of flowers. She was so excited to see the big tree.\n",
      "\n",
      "Suddenly, her mom and dad took them to the house. They\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "checkpoint = torch.load(best_model_path, map_location=config.device, weights_only=False)\n",
    "saved_config = checkpoint['config']\n",
    "model = GPT(saved_config)\n",
    "state_dict = checkpoint['model']\n",
    "uncompiled_state_dict = {k[len('_orig_mod.'):] if k.startswith('_orig_mod.') else k: v for k, v in state_dict.items()}\n",
    "model.load_state_dict(uncompiled_state_dict)\n",
    "model.to(config.device)\n",
    "model.eval()\n",
    "if config.compile:\n",
    "    print(\"Compiling the loaded model...\")\n",
    "    model = torch.compile(model)\n",
    "sentence = \"Once upon a time there was a girl.\"\n",
    "context = torch.tensor(encoding.encode_ordinary(sentence), dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "print(f\"Prompt: \\\"{sentence}\\\"\")\n",
    "print(\"-\" * 20)\n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        y = model.generate(context, max_new_tokens=200, temperature=0.8, top_k=20)\n",
    "print(encoding.decode(y.squeeze().tolist()))\n",
    "print(\"-\" * 20)\n",
    "sentence = \"A little girl went to the woods\"\n",
    "context = torch.tensor(encoding.encode_ordinary(sentence), dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "\n",
    "print(f\"Prompt: \\\"{sentence}\\\"\")\n",
    "print(\"-\" * 20)\n",
    "\n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        y = model.generate(context, max_new_tokens=200, temperature=0.8, top_k=20)\n",
    "\n",
    "print(encoding.decode(y.squeeze().tolist()))\n",
    "print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50313c3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_lr_multiplier(it):\n",
    "    if it < config.warmup_iters:\n",
    "        return it / config.warmup_iters \n",
    "    if it > config.lr_decay_iters:\n",
    "        return config.min_lr / config.learning_rate\n",
    "    decay_ratio = (it - config.warmup_iters) / (config.lr_decay_iters - config.warmup_iters)\n",
    "    assert 0 <= decay_ratio <= 1\n",
    "    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio))\n",
    "    multiplier = (config.min_lr + coeff * (config.learning_rate - config.min_lr)) / config.learning_rate\n",
    "    return multiplier\n",
    "lrs = []\n",
    "for it in range(config.max_iters):\n",
    "    lr_multiplier = get_lr_multiplier(it)\n",
    "    lrs.append(config.learning_rate * lr_multiplier)\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(lrs)\n",
    "plt.title(\"Learning Rate Schedule\")\n",
    "plt.xlabel(\"Training Steps\")\n",
    "plt.ylabel(\"Learning Rate\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab204eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plotting weight histograms...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.eval()\n",
    "fig, axs = plt.subplots(2, 2, figsize=(12, 10))\n",
    "fig.suptitle('Model Weight Distributions', fontsize=16)\n",
    "\n",
    "weights_wte = model.transformer.wte.weight.detach().cpu().float().numpy()\n",
    "axs[0, 0].hist(weights_wte.flatten(), bins=100)\n",
    "axs[0, 0].set_title(\"transformer.wte (Token Embeddings)\")\n",
    "axs[0, 0].set_xlabel(\"Weight Value\")\n",
    "axs[0, 0].set_ylabel(\"Frequency\")\n",
    "\n",
    "weights_attn = model.transformer.h[-1].attn.c_proj.weight.detach().cpu().float().numpy()\n",
    "axs[0, 1].hist(weights_attn.flatten(), bins=100)\n",
    "axs[0, 1].set_title(\"transformer.h[-1].attn.c_proj\")\n",
    "axs[0, 1].set_xlabel(\"Weight Value\")\n",
    "weights_mlp = model.transformer.h[-1].mlp.c_proj.weight.detach().cpu().float().numpy()\n",
    "axs[1, 0].hist(weights_mlp.flatten(), bins=100)\n",
    "axs[1, 0].set_title(\"transformer.h[-1].mlp.c_proj\")\n",
    "axs[1, 0].set_xlabel(\"Weight Value\")\n",
    "\n",
    "weights_lmhead = model.lm_head.weight.detach().cpu().float().numpy()\n",
    "axs[1, 1].hist(weights_lmhead.flatten(), bins=100)\n",
    "axs[1, 1].set_title(\"lm_head (Output Layer)\")\n",
    "axs[1, 1].set_xlabel(\"Weight Value\")\n",
    "\n",
    "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32fc1050",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Visualizing Attention Head...\n",
      "Temporarily disabled Flash Attention for one layer to capture scores.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/namit/slm/.venv/lib/python3.13/site-packages/torch/_inductor/lowering.py:7242: UserWarning: \n",
      "Online softmax is disabled on the fly since Inductor decides to\n",
      "split the reduction. Cut an issue to PyTorch if this is an\n",
      "important use case and you want to speed it up with online\n",
      "softmax.\n",
      "\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hook removed and Flash Attention restored.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "attention_storage = {}\n",
    "\n",
    "def save_attention_hook(module, input, output):\n",
    "    attention_storage['attn_matrix'] = output\n",
    "\n",
    "final_attn_block = model.transformer.h[-1].attn\n",
    "hook_handle = final_attn_block.attn_dropout.register_forward_hook(save_attention_hook)\n",
    "original_flash_setting = final_attn_block.flash\n",
    "final_attn_block.flash = False\n",
    "sentence = \"The quick brown fox jumps over the lazy dog\"\n",
    "tokens = encoding.encode_ordinary(sentence)\n",
    "token_tensor = torch.tensor(tokens, dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "model.eval()\n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        logits, loss = model(token_tensor, targets=token_tensor)\n",
    "attn_matrix = attention_storage['attn_matrix'].cpu()\n",
    "hook_handle.remove()\n",
    "final_attn_block.flash = original_flash_setting\n",
    "print(\"Hook removed and Flash Attention restored.\")\n",
    "head_to_visualize = 0\n",
    "attn_head_matrix = attn_matrix[0, head_to_visualize, :, :]\n",
    "token_labels = [encoding.decode([t]) for t in tokens]\n",
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "cax = ax.imshow(attn_head_matrix, cmap='viridis')\n",
    "ax.set_xticks(range(len(token_labels)))\n",
    "ax.set_yticks(range(len(token_labels)))\n",
    "ax.set_xticklabels(token_labels, rotation=45, ha='right')\n",
    "ax.set_yticklabels(token_labels)\n",
    "\n",
    "fig.colorbar(cax, label=\"Attention Weight\")\n",
    "ax.set_xlabel(\"Key (Token being looked at)\")\n",
    "ax.set_ylabel(\"Query (Token doing the looking)\")\n",
    "ax.set_title(f\"Attention Heatmap (Final Layer, Head {head_to_visualize})\")\n",
    "\n",
    "for i in range(len(token_labels)):\n",
    "    for j in range(len(token_labels)):\n",
    "        ax.text(j, i, f\"{attn_head_matrix[i, j]:.2f}\", ha=\"center\", va=\"center\", color=\"white\" if attn_head_matrix[i, j] < 0.5 else \"black\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1ab01c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting benchmark...\n",
      "Device: cuda, Dtype: bfloat16, Compile: True\n",
      "Running warmup pass...\n",
      "Running timed pass (generating 200 tokens)...\n",
      "\n",
      "--- Benchmark Complete ---\n",
      "Total time: 0.28 seconds\n",
      "Tokens generated: 200\n",
      "Performance: 714.87 tokens/second\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "model.eval() \n",
    "print(\"Starting benchmark...\")\n",
    "print(f\"Device: {config.device}, Dtype: {config.dtype}, Compile: {config.compile}\")\n",
    "prompt = \"Once upon a time\"\n",
    "max_new_tokens = 200\n",
    "temperature = 0.8\n",
    "top_k = 20\n",
    "context = torch.tensor(encoding.encode_ordinary(prompt), dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "print(\"Running warmup pass...\")\n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        _ = model.generate(context, max_new_tokens=5, temperature=temperature, top_k=top_k)\n",
    "print(f\"Running timed pass (generating {max_new_tokens} tokens)...\")\n",
    "torch.cuda.synchronize()\n",
    "start_time = time.time()\n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        y = model.generate(context, max_new_tokens=max_new_tokens, temperature=temperature, top_k=top_k)\n",
    "torch.cuda.synchronize()\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "tokens_per_second = max_new_tokens / elapsed_time\n",
    "print(\"\\n--- Benchmark Complete ---\")\n",
    "print(f\"Total time: {elapsed_time:.2f} seconds\")\n",
    "print(f\"Tokens generated: {max_new_tokens}\")\n",
    "print(f\"Performance: {tokens_per_second:.2f} tokens/second\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bba4111a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`generate_streaming` function created.\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def generate_streaming(model, idx, max_new_tokens, temperature=1.0, top_k=None):\n",
    "    eot_token_id = encoding.eot_token\n",
    "    \n",
    "    for _ in range(max_new_tokens):\n",
    "        idx_cond = idx if idx.size(1) <= model.config.block_size else idx[:, -model.config.block_size:]\n",
    "        logits, _ = model(idx_cond)\n",
    "        logits = logits[:, -1, :] / temperature\n",
    "        if top_k is not None:\n",
    "            v, _ = torch.topk(logits, min(top_k, logits.size(-1)))\n",
    "            logits[logits < v[:, [-1]]] = -float('Inf')\n",
    "        probs = F.softmax(logits, dim=-1)\n",
    "        idx_next = torch.multinomial(probs, num_samples=1)\n",
    "        if idx_next.item() == eot_token_id:\n",
    "            break\n",
    "        idx = torch.cat((idx, idx_next), dim=1)\n",
    "        yield idx_next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec60b0cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running streaming inference...\n",
      "A little girl went to the woods and ran to the park. She saw a little cat and decided to go to the park. She said, \"Hello, bird. You can play with my friend.\"\n",
      "\n",
      "The dog ran away with his mom. The dog saw the dog and asked, \"Look, the dog is like a cat! It is so happy!\" The dog said, \"That's a pretty dog. It is very pretty!\" She said, \"I'll have a small dog.\"\n",
      "\n",
      "The dog was sorry for the boy who was very happy. He said, \"I do it! You can't do it.\" The girl was very happy and said, \"Yes, we can use it.\n",
      "--- Stream complete ---\n"
     ]
    }
   ],
   "source": [
    "prompt = \"A little girl went to the woods\"\n",
    "context = torch.tensor(encoding.encode_ordinary(prompt), dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "print(prompt, end='', flush=True) \n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        for token_tensor in generate_streaming(model, context, max_new_tokens=200, temperature=0.8, top_k=20):\n",
    "            token_str = encoding.decode(token_tensor[0].tolist())\n",
    "            print(token_str, end='', flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "613884e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In a galaxy far, far away. The girl was so excited, she started to get to a lot of new friends. They were a very good friends, but they had to get in a big box of books.\n",
      "\n",
      "The little girl was very happy to help her mom and dad. She hugged her to her mom and the little girl. The little girl was so happy to find her mom and dad for a special toy. She knew that she had to get some of the car and it was a special friend."
     ]
    }
   ],
   "source": [
    "prompt=\"In a galaxy far, far away\"\n",
    "context = torch.tensor(encoding.encode_ordinary(prompt), dtype=torch.long, device=config.device).unsqueeze(0)\n",
    "print(prompt, end='', flush=True) \n",
    "with torch.inference_mode():\n",
    "    with ctx:\n",
    "        for token_tensor in generate_streaming(model, context, max_new_tokens=200, temperature=0.8, top_k=20):\n",
    "            token_str = encoding.decode(token_tensor[0].tolist())\n",
    "            print(token_str, end='', flush=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}