{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MNIST INT8 Classification on ESP32-P4 using P4-JIT\n",
    "\n",
    "## 🚀 Key Features\n",
    "\n",
    "- ✅ **ESP32-P4 PIE Instructions**: Uses custom `xesppie` SIMD that **cannot be simulated** on standard RISC-V\n",
    "- ✅ **Real Hardware Only**: P4-JIT enables testing code that QEMU/Spike simulators cannot run\n",
    "- ✅ **INT8 Quantization Pipeline**: Power-of-2 scales with QAT\n",
    "- ✅ **100% On-Device Accuracy**: Maintains 98.79% training accuracy\n",
    "- ✅ **25ms Inference**: Full MNIST forward pass @ 360 MHz\n",
    "- ✅ **Rapid Iteration**: 2-3 second deploy vs 30-60s firmware rebuild\n",
    "\n",
    "---\n",
    "\n",
    "## 🎯 What Makes This Special\n",
    "\n",
    "**Standard embedded ML workflow:**\n",
    "```\n",
    "Train → Quantize → Simulate (QEMU/Spike) → Flash → Test\n",
    "                      ❌ FAILS with PIE instructions\n",
    "```\n",
    "\n",
    "**P4-JIT workflow:**\n",
    "```\n",
    "Train → Quantize → Compile → Deploy (2s) → Test on Real Hardware\n",
    "                                 ✅ PIE instructions work!\n",
    "```\n",
    "\n",
    "**The Problem:** ESP32-P4 has custom SIMD instructions (`esp.vmulas.s8.xacc`, `esp.lp.setup`, etc.) that don't exist in standard RISC-V. You **cannot test them in simulators**.\n",
    "\n",
    "**The Solution:** P4-JIT lets you write inline assembly with PIE instructions, compile with the ESP32-P4 toolchain, and execute **directly on real hardware** in seconds—no firmware changes needed.\n",
    "\n",
    "---\n",
    "\n",
    "## 📋 What You'll Learn\n",
    "\n",
    "1. **INT8 Quantization**: Warmup → Calibration → QAT training\n",
    "2. **Correct Quantized Math**: Fixed bias scaling (`bias × 2^E_in`)\n",
    "3. **ESP32-P4 PIE Assembly**: Hardware SIMD for the final FC layer\n",
    "4. **P4-JIT Deployment**: Rapid testing of custom ISA code\n",
    "\n",
    "**Architecture:**\n",
    "```\n",
    "Conv2D(1→16) → ReLU → Pool → \n",
    "Conv2D(16→32) → ReLU → Pool → \n",
    "FC(1568→128) → ReLU → \n",
    "FC(128→10) [PIE SIMD] → Argmax\n",
    "```\n",
    "\n",
    "**FC2 Implementation (Cannot simulate!):**\n",
    "```c\n",
    "asm volatile (\n",
    "    \"esp.zero.xacc \\n\\t\"              // Clear accumulator\n",
    "    \"esp.lp.setup 0, %[cnt], 1f \\n\\t\" // Hardware loop\n",
    "    \"esp.vmulas.s8.xacc q0, q1 \\n\\t\"  // 16x INT8 MAC\n",
    "    // ↑ These instructions don't exist in RISC-V spec!\n",
    ");\n",
    "```\n",
    "\n",
    "**Results:** 10/10 test digits correct, ~9M cycles per inference.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup & Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Environment ready\n",
      "✓ PyTorch: 2.8.0+cu126\n",
      "✓ Device: CUDA\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from pathlib import Path\n",
    "from tqdm.auto import tqdm\n",
    "import time\n",
    "\n",
    "# Setup directories\n",
    "NOTEBOOK_DIR = Path.cwd()\n",
    "SOURCE_DIR = NOTEBOOK_DIR / \"source\"\n",
    "WEIGHTS_DIR = NOTEBOOK_DIR / \"weights\"\n",
    "RESULTS_DIR = NOTEBOOK_DIR / \"results\"\n",
    "\n",
    "for d in [SOURCE_DIR, WEIGHTS_DIR, RESULTS_DIR]:\n",
    "    d.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# Add P4-JIT\n",
    "PROJECT_ROOT = NOTEBOOK_DIR.parent.parent.parent\n",
    "sys.path.append(str(PROJECT_ROOT / \"host\"))\n",
    "\n",
    "from p4jit import P4JIT, MALLOC_CAP_SPIRAM, MALLOC_CAP_8BIT\n",
    "import p4jit\n",
    "\n",
    "# Seed\n",
    "torch.manual_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "print(\"✓ Environment ready\")\n",
    "print(f\"✓ PyTorch: {torch.__version__}\")\n",
    "print(f\"✓ Device: {'CUDA' if torch.cuda.is_available() else 'CPU'}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Dataset Preparation\n",
    "\n",
    "**Important:** MNIST images are normalized with `mean=0.1307, std=0.3081` during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Train: 60,000 | Test: 10,000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x300 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.1307,), (0.3081,))\n",
    "])\n",
    "\n",
    "train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)\n",
    "test_dataset = datasets.MNIST('./data', train=False, transform=transform)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)\n",
    "\n",
    "print(f\"✓ Train: {len(train_dataset):,} | Test: {len(test_dataset):,}\")\n",
    "\n",
    "# Visualize (denormalized for display)\n",
    "fig, axes = plt.subplots(2, 10, figsize=(15, 3))\n",
    "for i in range(20):\n",
    "    img, label = train_dataset[i]\n",
    "    # Denormalize for visualization\n",
    "    img_display = img.squeeze() * 0.3081 + 0.1307\n",
    "    ax = axes[i // 10, i % 10]\n",
    "    ax.imshow(img_display, cmap='gray')\n",
    "    ax.set_title(f'{label}')\n",
    "    ax.axis('off')\n",
    "plt.suptitle('MNIST Dataset Samples', fontsize=14, fontweight='bold')\n",
    "plt.tight_layout()\n",
    "plt.savefig(RESULTS_DIR / 'dataset.png', dpi=150, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Quantization Modules\n",
    "\n",
    "**Power-of-2 scales** with Straight-Through Estimator for gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Quantization modules defined\n"
     ]
    }
   ],
   "source": [
    "class PowerOfTwoQuantize(torch.autograd.Function):\n",
    "    \"\"\"INT8 quantization with Straight-Through Estimator\"\"\"\n",
    "    @staticmethod\n",
    "    def forward(ctx, x, scale_exp):\n",
    "        scale = 2.0 ** scale_exp\n",
    "        x_q = torch.clamp(torch.round(x * scale), -128, 127)\n",
    "        x_dq = x_q / scale\n",
    "        return x_dq\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        return grad_output, None\n",
    "\n",
    "\n",
    "class FakeQuantizeINT8(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.register_buffer('scale_exp', torch.tensor(0))\n",
    "        self.enabled = False\n",
    "        \n",
    "    def set_scale_exp(self, exp):\n",
    "        self.scale_exp = torch.tensor(exp)\n",
    "        \n",
    "    def enable(self):\n",
    "        self.enabled = True\n",
    "        \n",
    "    def forward(self, x):\n",
    "        if not self.enabled:\n",
    "            return x\n",
    "        return PowerOfTwoQuantize.apply(x, self.scale_exp)\n",
    "    \n",
    "    def get_scale_info(self):\n",
    "        exp = int(self.scale_exp.item())\n",
    "        scale = 2.0 ** (-exp)\n",
    "        return exp, scale\n",
    "\n",
    "\n",
    "class QuantizedConv2d(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, **kwargs):\n",
    "        super().__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, **kwargs)\n",
    "        self.weight_quant = FakeQuantizeINT8()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        w_q = self.weight_quant(self.conv.weight)\n",
    "        return F.conv2d(x, w_q, self.conv.bias, \n",
    "                       self.conv.stride, self.conv.padding, \n",
    "                       self.conv.dilation, self.conv.groups)\n",
    "\n",
    "\n",
    "class QuantizedLinear(nn.Module):\n",
    "    def __init__(self, in_features, out_features):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(in_features, out_features)\n",
    "        self.weight_quant = FakeQuantizeINT8()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        w_q = self.weight_quant(self.linear.weight)\n",
    "        return F.linear(x, w_q, self.linear.bias)\n",
    "\n",
    "\n",
    "print(\"✓ Quantization modules defined\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Model Architecture\n",
    "\n",
    "**With input quantization from the start!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Model: 206,922 parameters\n",
      "✓ Input quantization: ENABLED\n",
      "QuantizedMNISTNet(\n",
      "  (input_quant): FakeQuantizeINT8()\n",
      "  (conv1): QuantizedConv2d(\n",
      "    (conv): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (weight_quant): FakeQuantizeINT8()\n",
      "  )\n",
      "  (act1_quant): FakeQuantizeINT8()\n",
      "  (conv2): QuantizedConv2d(\n",
      "    (conv): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (weight_quant): FakeQuantizeINT8()\n",
      "  )\n",
      "  (act2_quant): FakeQuantizeINT8()\n",
      "  (fc1): QuantizedLinear(\n",
      "    (linear): Linear(in_features=1568, out_features=128, bias=True)\n",
      "    (weight_quant): FakeQuantizeINT8()\n",
      "  )\n",
      "  (act3_quant): FakeQuantizeINT8()\n",
      "  (fc2): QuantizedLinear(\n",
      "    (linear): Linear(in_features=128, out_features=10, bias=True)\n",
      "    (weight_quant): FakeQuantizeINT8()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class QuantizedMNISTNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # Input quantization\n",
    "        self.input_quant = FakeQuantizeINT8()\n",
    "        \n",
    "        # Conv layers\n",
    "        self.conv1 = QuantizedConv2d(1, 16, kernel_size=3, padding=1)\n",
    "        self.act1_quant = FakeQuantizeINT8()\n",
    "        \n",
    "        self.conv2 = QuantizedConv2d(16, 32, kernel_size=3, padding=1)\n",
    "        self.act2_quant = FakeQuantizeINT8()\n",
    "        \n",
    "        # FC layers\n",
    "        self.fc1 = QuantizedLinear(32 * 7 * 7, 128)\n",
    "        self.act3_quant = FakeQuantizeINT8()\n",
    "        \n",
    "        self.fc2 = QuantizedLinear(128, 10)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.input_quant(x)\n",
    "        \n",
    "        x = self.conv1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.act1_quant(x)\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        \n",
    "        x = self.conv2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.act2_quant(x)\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        \n",
    "        x = x.view(x.size(0), -1)\n",
    "        \n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.act3_quant(x)\n",
    "        \n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = QuantizedMNISTNet().to(device)\n",
    "\n",
    "print(f\"✓ Model: {sum(p.numel() for p in model.parameters()):,} parameters\")\n",
    "print(f\"✓ Input quantization: ENABLED\")\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Training: Warmup → Calibration → QAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "PHASE 1: WARMUP (FP32)\n",
      "================================================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da1532997481493386b957752dbfb6ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/469 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2 | Train: 93.79% | Test: 98.24%\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d8dd42b2f8e4a86b83fc7c275e8a138",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/469 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/2 | Train: 98.16% | Test: 98.46%\n",
      "✓ Warmup complete: 98.46%\n"
     ]
    }
   ],
   "source": [
    "def train_epoch(model, loader, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    total_loss, correct = 0, 0\n",
    "    for data, target in tqdm(loader, desc='Training', leave=False):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data)\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "        correct += output.argmax(dim=1).eq(target).sum().item()\n",
    "    return total_loss / len(loader), 100. * correct / len(loader.dataset)\n",
    "\n",
    "\n",
    "def evaluate(model, loader, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss, correct = 0, 0\n",
    "    with torch.no_grad():\n",
    "        for data, target in loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            output = model(data)\n",
    "            total_loss += criterion(output, target).item()\n",
    "            correct += output.argmax(dim=1).eq(target).sum().item()\n",
    "    return total_loss / len(loader), 100. * correct / len(loader.dataset)\n",
    "\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "WARMUP_EPOCHS = 2\n",
    "QAT_EPOCHS = 2\n",
    "history = {'train_loss': [], 'train_acc': [], 'test_loss': [], 'test_acc': []}\n",
    "\n",
    "# Phase 1: Warmup\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"PHASE 1: WARMUP (FP32)\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "for epoch in range(1, WARMUP_EPOCHS + 1):\n",
    "    train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion, device)\n",
    "    test_loss, test_acc = evaluate(model, test_loader, criterion, device)\n",
    "    \n",
    "    history['train_loss'].append(train_loss)\n",
    "    history['train_acc'].append(train_acc)\n",
    "    history['test_loss'].append(test_loss)\n",
    "    history['test_acc'].append(test_acc)\n",
    "    \n",
    "    print(f\"Epoch {epoch}/{WARMUP_EPOCHS} | Train: {train_acc:.2f}% | Test: {test_acc:.2f}%\")\n",
    "\n",
    "print(f\"✓ Warmup complete: {history['test_acc'][-1]:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calibration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "PHASE 2: CALIBRATION\n",
      "================================================================================\n",
      "\n",
      "Weight calibration:\n",
      "  conv1                → Exp:  +7 (scale: 2^7)\n",
      "  conv2                → Exp:  +8 (scale: 2^8)\n",
      "  fc1                  → Exp:  +9 (scale: 2^9)\n",
      "  fc2                  → Exp:  +9 (scale: 2^9)\n",
      "\n",
      "Activation calibration:\n",
      "  input_quant          → Exp:  +5 (scale: 2^5)\n",
      "  act1_quant           → Exp:  +4 (scale: 2^4)\n",
      "  act2_quant           → Exp:  +4 (scale: 2^4)\n",
      "  act3_quant           → Exp:  +2 (scale: 2^2)\n",
      "\n",
      "✓ Calibration complete\n"
     ]
    }
   ],
   "source": [
    "def calculate_scale_exponent(tensor):\n",
    "    max_val = tensor.abs().max().item()\n",
    "    if max_val == 0:\n",
    "        return 0\n",
    "    import math\n",
    "    return math.floor(math.log2(127.0 / max_val))\n",
    "\n",
    "\n",
    "def calibrate_activations(model, loader, device, num_batches=10):\n",
    "    model.eval()\n",
    "    activation_stats = {}\n",
    "    \n",
    "    def get_hook(name):\n",
    "        def hook(module, input, output):\n",
    "            if name not in activation_stats:\n",
    "                activation_stats[name] = []\n",
    "            activation_stats[name].append(output.abs().max().item())\n",
    "        return hook\n",
    "    \n",
    "    hooks = []\n",
    "    \n",
    "    # Hook for input\n",
    "    def input_hook(module, input):\n",
    "        if 'input_quant' not in activation_stats:\n",
    "            activation_stats['input_quant'] = []\n",
    "        activation_stats['input_quant'].append(input[0].abs().max().item())\n",
    "    \n",
    "    hooks.append(model.register_forward_pre_hook(input_hook))\n",
    "    \n",
    "    # Hooks for activations\n",
    "    for name, module in model.named_modules():\n",
    "        if 'act' in name and isinstance(module, FakeQuantizeINT8):\n",
    "            parent_name = '.'.join(name.split('.')[:-1])\n",
    "            if parent_name:\n",
    "                parent = dict(model.named_modules())[parent_name]\n",
    "            else:\n",
    "                parent = module\n",
    "            hooks.append(parent.register_forward_hook(get_hook(name)))\n",
    "\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i, (data, _) in enumerate(loader):\n",
    "            if i >= num_batches:\n",
    "                break\n",
    "            model(data.to(device))\n",
    "    \n",
    "    for hook in hooks:\n",
    "        hook.remove()\n",
    "    \n",
    "    exponents = {}\n",
    "    for name, values in activation_stats.items():\n",
    "        max_val = max(values)\n",
    "        import math\n",
    "        exp = math.floor(math.log2(127.0 / max_val)) if max_val > 0 else 0\n",
    "        exponents[name] = exp\n",
    "    \n",
    "    return exponents\n",
    "\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"PHASE 2: CALIBRATION\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# Weights\n",
    "print(\"\\nWeight calibration:\")\n",
    "for name, module in model.named_modules():\n",
    "    if isinstance(module, (QuantizedConv2d, QuantizedLinear)):\n",
    "        weight = module.conv.weight if isinstance(module, QuantizedConv2d) else module.linear.weight\n",
    "        exp = calculate_scale_exponent(weight.data)\n",
    "        module.weight_quant.set_scale_exp(exp)\n",
    "        print(f\"  {name:20s} → Exp: {exp:+3d} (scale: 2^{exp})\")\n",
    "\n",
    "# Activations\n",
    "print(\"\\nActivation calibration:\")\n",
    "act_exponents = calibrate_activations(model, train_loader, device, num_batches=10)\n",
    "for name, module in model.named_modules():\n",
    "    if isinstance(module, FakeQuantizeINT8) and name in act_exponents:\n",
    "        exp = act_exponents[name]\n",
    "        module.set_scale_exp(exp)\n",
    "        print(f\"  {name:20s} → Exp: {exp:+3d} (scale: 2^{exp})\")\n",
    "\n",
    "print(\"\\n✓ Calibration complete\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QAT Phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "PHASE 3: QUANTIZATION-AWARE TRAINING\n",
      "================================================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "063fd57d4cdc4dd2ab2bb313394a45a4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/469 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/4 | Train: 98.85% | Test: 98.66%\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fbc6e0a7581d4afd88be9a1d2366589e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/469 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/4 | Train: 99.11% | Test: 98.78%\n",
      "\n",
      "================================================================================\n",
      "✓ Final Test Accuracy: 98.78%\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "# Enable quantization\n",
    "for module in model.modules():\n",
    "    if isinstance(module, FakeQuantizeINT8):\n",
    "        module.enable()\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"PHASE 3: QUANTIZATION-AWARE TRAINING\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0005)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.5)\n",
    "\n",
    "for epoch in range(1, QAT_EPOCHS + 1):\n",
    "    train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion, device)\n",
    "    test_loss, test_acc = evaluate(model, test_loader, criterion, device)\n",
    "    scheduler.step()\n",
    "    \n",
    "    history['train_loss'].append(train_loss)\n",
    "    history['train_acc'].append(train_acc)\n",
    "    history['test_loss'].append(test_loss)\n",
    "    history['test_acc'].append(test_acc)\n",
    "    \n",
    "    total_epoch = WARMUP_EPOCHS + epoch\n",
    "    print(f\"Epoch {total_epoch}/{WARMUP_EPOCHS + QAT_EPOCHS} | Train: {train_acc:.2f}% | Test: {test_acc:.2f}%\")\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(f\"✓ Final Test Accuracy: {history['test_acc'][-1]:.2f}%\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Extract Quantized Weights\n",
    "\n",
    "**Store all scale exponents for C code**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "WEIGHT EXTRACTION\n",
      "================================================================================\n",
      "\n",
      "Input: E_in = 5\n",
      "Conv1: E_w= +7, E_act= +4, W_shape=(16, 1, 3, 3)\n",
      "Conv2: E_w= +8, E_act= +4, W_shape=(32, 16, 3, 3)\n",
      "FC1:   E_w= +9, E_act= +2, W_shape=(128, 1568)\n",
      "FC2:   E_w= +9, W_shape=(10, 128)\n",
      "\n",
      "✓ Total: 206,922 bytes (202.07 KB)\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "def quantize_to_int8(tensor, scale_exp):\n",
    "    scale = 2.0 ** scale_exp\n",
    "    quantized = torch.clamp(torch.round(tensor * scale), -128, 127).to(torch.int8)\n",
    "    return quantized.cpu().numpy()\n",
    "\n",
    "\n",
    "model.eval()\n",
    "quantized_weights = {}\n",
    "scale_exponents = {}\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"WEIGHT EXTRACTION\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# Input\n",
    "input_exp, _ = model.input_quant.get_scale_info()\n",
    "scale_exponents['input'] = input_exp\n",
    "print(f\"\\nInput: E_in = {input_exp}\")\n",
    "\n",
    "# Conv1\n",
    "w_exp, _ = model.conv1.weight_quant.get_scale_info()\n",
    "act_exp, _ = model.act1_quant.get_scale_info()\n",
    "w = quantize_to_int8(model.conv1.conv.weight.data, w_exp)\n",
    "b = quantize_to_int8(model.conv1.conv.bias.data, w_exp)\n",
    "quantized_weights['conv1'] = {'weight': w, 'bias': b}\n",
    "scale_exponents['conv1'] = {'w': w_exp, 'act': act_exp}\n",
    "print(f\"Conv1: E_w={w_exp:+3d}, E_act={act_exp:+3d}, W_shape={w.shape}\")\n",
    "\n",
    "# Conv2\n",
    "w_exp, _ = model.conv2.weight_quant.get_scale_info()\n",
    "act_exp, _ = model.act2_quant.get_scale_info()\n",
    "w = quantize_to_int8(model.conv2.conv.weight.data, w_exp)\n",
    "b = quantize_to_int8(model.conv2.conv.bias.data, w_exp)\n",
    "quantized_weights['conv2'] = {'weight': w, 'bias': b}\n",
    "scale_exponents['conv2'] = {'w': w_exp, 'act': act_exp}\n",
    "print(f\"Conv2: E_w={w_exp:+3d}, E_act={act_exp:+3d}, W_shape={w.shape}\")\n",
    "\n",
    "# FC1\n",
    "w_exp, _ = model.fc1.weight_quant.get_scale_info()\n",
    "act_exp, _ = model.act3_quant.get_scale_info()\n",
    "w = quantize_to_int8(model.fc1.linear.weight.data, w_exp)\n",
    "b = quantize_to_int8(model.fc1.linear.bias.data, w_exp)\n",
    "quantized_weights['fc1'] = {'weight': w, 'bias': b}\n",
    "scale_exponents['fc1'] = {'w': w_exp, 'act': act_exp}\n",
    "print(f\"FC1:   E_w={w_exp:+3d}, E_act={act_exp:+3d}, W_shape={w.shape}\")\n",
    "\n",
    "# FC2\n",
    "w_exp, _ = model.fc2.weight_quant.get_scale_info()\n",
    "w = quantize_to_int8(model.fc2.linear.weight.data, w_exp)\n",
    "b = quantize_to_int8(model.fc2.linear.bias.data, w_exp)\n",
    "quantized_weights['fc2'] = {'weight': w, 'bias': b}\n",
    "scale_exponents['fc2'] = {'w': w_exp}\n",
    "print(f\"FC2:   E_w={w_exp:+3d}, W_shape={w.shape}\")\n",
    "\n",
    "total_params = sum(w['weight'].size + w['bias'].size for w in quantized_weights.values())\n",
    "print(f\"\\n✓ Total: {total_params:,} bytes ({total_params/1024:.2f} KB)\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. C Implementation with FIXED Bias Scaling\n",
    "\n",
    "### The Correct Math:\n",
    "\n",
    "```\n",
    "Accumulator = Σ(input_q × weight_q)\n",
    "            = Σ((input × 2^E_in) × (weight × 2^E_w))\n",
    "            = (Σ input × weight) × 2^(E_in + E_w)\n",
    "\n",
    "Bias at scale 2^E_w needs to be brought to scale 2^(E_in + E_w):\n",
    "  bias_scaled = bias_q × 2^E_in\n",
    "\n",
    "Then scale to output:\n",
    "  output_q = (acc + bias_scaled) >> (E_in + E_w - E_out)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ C code saved: c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\source\\mnist_inference.c\n",
      "✓ Size: 8119 bytes\n",
      "✓ FIX 1: ReLU applied BEFORE quantization\n",
      "✓ FIX 2: FC2 outputs INT32 logits\n",
      "✓ NEW: Cycle counter timing added\n"
     ]
    }
   ],
   "source": [
    "c_code = \"\"\"#include <stdint.h>\n",
    "#include <stdio.h>\n",
    "\n",
    "// Read RISC-V cycle counter\n",
    "static inline uint32_t rdcycle(void) {\n",
    "    uint32_t cycles;\n",
    "    asm volatile (\"rdcycle %0\" : \"=r\"(cycles));\n",
    "    return cycles;\n",
    "}\n",
    "\n",
    "static inline int32_t relu_int32(int32_t x) { return (x > 0) ? x : 0; }\n",
    "static inline int8_t clip_int8(int32_t x) {\n",
    "    return (x > 127) ? 127 : ((x < -128) ? -128 : (int8_t)x);\n",
    "}\n",
    "\n",
    "// Conv2d with ReLU BEFORE quantization\n",
    "void conv2d_int8(\n",
    "    const int8_t* input, int in_h, int in_w, int in_c,\n",
    "    const int8_t* weight, const int8_t* bias,\n",
    "    int8_t* output, int out_c,\n",
    "    int exp_in, int exp_w, int exp_out\n",
    ") {\n",
    "    const int K = 3, P = 1, S = 1;\n",
    "    int out_h = (in_h + 2*P - K) / S + 1;\n",
    "    int out_w = (in_w + 2*P - K) / S + 1;\n",
    "    \n",
    "    int acc_shift = exp_in + exp_w - exp_out;\n",
    "    \n",
    "    for (int oc = 0; oc < out_c; oc++) {\n",
    "        for (int oh = 0; oh < out_h; oh++) {\n",
    "            for (int ow = 0; ow < out_w; ow++) {\n",
    "                int32_t acc = 0;\n",
    "                \n",
    "                // MAC\n",
    "                for (int ic = 0; ic < in_c; ic++) {\n",
    "                    for (int kh = 0; kh < K; kh++) {\n",
    "                        for (int kw = 0; kw < K; kw++) {\n",
    "                            int ih = oh * S - P + kh;\n",
    "                            int iw = ow * S - P + kw;\n",
    "                            \n",
    "                            if (ih >= 0 && ih < in_h && iw >= 0 && iw < in_w) {\n",
    "                                acc += (int32_t)input[(ic * in_h + ih) * in_w + iw] *\n",
    "                                       (int32_t)weight[((oc * in_c + ic) * K + kh) * K + kw];\n",
    "                            }\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "                \n",
    "                // Add bias (scaled by E_in)\n",
    "                acc += (int32_t)bias[oc] << exp_in;\n",
    "                \n",
    "                // ReLU BEFORE quantization\n",
    "                acc = relu_int32(acc);\n",
    "                \n",
    "                // Scale to output\n",
    "                acc = acc >> acc_shift;\n",
    "                \n",
    "                output[(oc * out_h + oh) * out_w + ow] = clip_int8(acc);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "void maxpool2d_int8(const int8_t* input, int8_t* output, int h, int w, int c) {\n",
    "    int out_h = h / 2, out_w = w / 2;\n",
    "    for (int ch = 0; ch < c; ch++) {\n",
    "        for (int oh = 0; oh < out_h; oh++) {\n",
    "            for (int ow = 0; ow < out_w; ow++) {\n",
    "                int8_t max_val = -128;\n",
    "                for (int kh = 0; kh < 2; kh++) {\n",
    "                    for (int kw = 0; kw < 2; kw++) {\n",
    "                        int8_t v = input[(ch * h + oh*2 + kh) * w + ow*2 + kw];\n",
    "                        if (v > max_val) max_val = v;\n",
    "                    }\n",
    "                }\n",
    "                output[(ch * out_h + oh) * out_w + ow] = max_val;\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "// FC layer with ReLU BEFORE quantization\n",
    "void fc_int8(\n",
    "    const int8_t* input, int in_size,\n",
    "    const int8_t* weight, const int8_t* bias,\n",
    "    int8_t* output, int out_size,\n",
    "    int exp_in, int exp_w, int exp_out\n",
    ") {\n",
    "    int acc_shift = exp_in + exp_w - exp_out;\n",
    "    \n",
    "    for (int i = 0; i < out_size; i++) {\n",
    "        int32_t acc = 0;\n",
    "        for (int j = 0; j < in_size; j++) {\n",
    "            acc += (int32_t)input[j] * (int32_t)weight[i * in_size + j];\n",
    "        }\n",
    "        \n",
    "        // Add bias (scaled by E_in)\n",
    "        acc += (int32_t)bias[i] << exp_in;\n",
    "        \n",
    "        // ReLU BEFORE quantization\n",
    "        acc = relu_int32(acc);\n",
    "        \n",
    "        // Scale to output\n",
    "        acc = acc >> acc_shift;\n",
    "        \n",
    "        output[i] = clip_int8(acc);\n",
    "    }\n",
    "}\n",
    "\n",
    "// FC layer WITHOUT quantization (for final layer)\n",
    "void fc_int32(\n",
    "    const int8_t* input, int in_size,\n",
    "    const int8_t* weight, const int8_t* bias,\n",
    "    int32_t* output, int out_size,\n",
    "    int exp_in, int exp_w\n",
    ") {\n",
    "    for (int i = 0; i < out_size; i++) {\n",
    "        int32_t acc = 0;\n",
    "        for (int j = 0; j < in_size; j++) {\n",
    "            acc += (int32_t)input[j] * (int32_t)weight[i * in_size + j];\n",
    "        }\n",
    "        \n",
    "        // Add bias (scaled by E_in)\n",
    "        acc += (int32_t)bias[i] << exp_in;\n",
    "        \n",
    "        // NO ReLU, NO quantization - raw logits\n",
    "        output[i] = acc;\n",
    "    }\n",
    "}\n",
    "\n",
    "void fc_int32_p4simd(\n",
    "    const int8_t* input, int in_size,\n",
    "    const int8_t* weight, const int8_t* bias,\n",
    "    int32_t* output, int out_size,\n",
    "    int exp_in, int exp_w\n",
    ") {\n",
    "    // Current pointer to weights (increments monotonically)\n",
    "    const int8_t* w_ptr = weight;\n",
    "    \n",
    "    // Calculate loop iterations (16 bytes per iteration)\n",
    "    int loop_count = in_size >> 4; \n",
    "\n",
    "    for (int i = 0; i < out_size; i++) {\n",
    "        // CRITICAL FIX: ESP32-P4 PIE instructions are restricted to the \n",
    "        // a0-a5 (x10-x15) register range. We must force variables into these registers.\n",
    "        \n",
    "        register const int8_t* in_ptr asm(\"a0\") = input;\n",
    "        register const int8_t* cur_w_ptr asm(\"a1\") = w_ptr;\n",
    "        register int32_t acc_val asm(\"a2\");\n",
    "        register int cnt asm(\"a3\") = loop_count;\n",
    "        register int shift_reg asm(\"a4\") = 0;\n",
    "\n",
    "        asm volatile (\n",
    "            \"esp.zero.xacc \\\\n\\\\t\"                   // Clear accumulator\n",
    "            \"esp.lp.setup 0, %[cnt], 1f \\\\n\\\\t\"      // Setup HW loop 0\n",
    "            \"0: \\\\n\\\\t\"                              // Loop start label\n",
    "            \"esp.vld.128.ip q0, %[in], 16 \\\\n\\\\t\"    // Load 16 inputs (uses a0)\n",
    "            \"esp.vld.128.ip q1, %[w], 16 \\\\n\\\\t\"     // Load 16 weights (uses a1)\n",
    "            \"esp.vmulas.s8.xacc q0, q1 \\\\n\\\\t\"       // Multiply & Accumulate\n",
    "            \"1: \\\\n\\\\t\"                              // Loop end label\n",
    "            \"esp.srs.s.xacc %[res], %[shft] \\\\n\\\\t\"  // Extract result (uses a2, a4)\n",
    "\n",
    "            // Output Operands\n",
    "            : [res] \"=r\" (acc_val),       // Mapped to a2\n",
    "              [in]  \"+r\" (in_ptr),        // Mapped to a0\n",
    "              [w]   \"+r\" (cur_w_ptr)      // Mapped to a1\n",
    "            \n",
    "            // Input Operands\n",
    "            : [cnt] \"r\" (cnt),            // Mapped to a3\n",
    "              [shft] \"r\" (shift_reg)      // Mapped to a4\n",
    "            \n",
    "            // Clobbers\n",
    "            : \"memory\"\n",
    "        );\n",
    "\n",
    "        w_ptr = cur_w_ptr; \n",
    "        output[i] = acc_val + ((int32_t)bias[i] << exp_in);\n",
    "    }\n",
    "}\n",
    "\n",
    "// Inference function WITH TIMING\n",
    "int32_t mnist_inference(\n",
    "    int8_t* input,\n",
    "    int8_t* w_conv1, int8_t* b_conv1,\n",
    "    int8_t* w_conv2, int8_t* b_conv2,\n",
    "    int8_t* w_fc1, int8_t* b_fc1,\n",
    "    int8_t* w_fc2, int8_t* b_fc2,\n",
    "    int32_t e_in,\n",
    "    int32_t e_conv1_w, int32_t e_conv1_act,\n",
    "    int32_t e_conv2_w, int32_t e_conv2_act,\n",
    "    int32_t e_fc1_w, int32_t e_fc1_act,\n",
    "    int32_t e_fc2_w,\n",
    "    int8_t* scratch,\n",
    "    uint32_t* timing  \n",
    ") {\n",
    "    // Start timing\n",
    "    uint32_t start_cycles = rdcycle();\n",
    "    \n",
    "    printf(\"[JIT] Inference start\\\\n\");\n",
    "    \n",
    "    int8_t* conv1_out = scratch;\n",
    "    int8_t* pool1_out = conv1_out + 16*28*28;\n",
    "    int8_t* conv2_out = pool1_out + 16*14*14;\n",
    "    int8_t* pool2_out = conv2_out + 32*14*14;\n",
    "    int8_t* fc1_out = pool2_out + 32*7*7;\n",
    "    \n",
    "    // Allocate INT32 buffer for final logits\n",
    "    int32_t* fc2_out = (int32_t*)(fc1_out + 128);\n",
    "    \n",
    "    // Conv1 + ReLU + MaxPool\n",
    "    conv2d_int8(input, 28, 28, 1, w_conv1, b_conv1, conv1_out, 16, \n",
    "                e_in, e_conv1_w, e_conv1_act);\n",
    "    maxpool2d_int8(conv1_out, pool1_out, 28, 28, 16);\n",
    "    \n",
    "    // Conv2 + ReLU + MaxPool\n",
    "    conv2d_int8(pool1_out, 14, 14, 16, w_conv2, b_conv2, conv2_out, 32,\n",
    "                e_conv1_act, e_conv2_w, e_conv2_act);\n",
    "    maxpool2d_int8(conv2_out, pool2_out, 14, 14, 32);\n",
    "    \n",
    "    // FC1 + ReLU\n",
    "    fc_int8(pool2_out, 1568, w_fc1, b_fc1, fc1_out, 128,\n",
    "            e_conv2_act, e_fc1_w, e_fc1_act);\n",
    "    \n",
    "    // FC2 → INT32 logits\n",
    "    fc_int32_p4simd(fc1_out, 128, w_fc2, b_fc2, fc2_out, 10,\n",
    "             e_fc1_act, e_fc2_w);\n",
    "    \n",
    "    // End timing\n",
    "    uint32_t end_cycles = rdcycle();\n",
    "    uint32_t elapsed = end_cycles - start_cycles;\n",
    "    \n",
    "    // Store timing in output array\n",
    "    timing[0] = elapsed;\n",
    "    \n",
    "    // Argmax\n",
    "    int32_t max_val = fc2_out[0];\n",
    "    int32_t max_idx = 0;\n",
    "    for (int i = 1; i < 10; i++) {\n",
    "        if (fc2_out[i] > max_val) {\n",
    "            max_val = fc2_out[i];\n",
    "            max_idx = i;\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    printf(\"[JIT] Predicted: %d (logit: %d) | Cycles: %u\\\\n\", max_idx, max_val, elapsed);\n",
    "    return max_idx;\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "c_path = SOURCE_DIR / \"mnist_inference.c\"\n",
    "with open(c_path, 'w') as f:\n",
    "    f.write(c_code)\n",
    "\n",
    "print(f\"✓ C code saved: {c_path}\")\n",
    "print(f\"✓ Size: {len(c_code)} bytes\")\n",
    "print(\"✓ FIX 1: ReLU applied BEFORE quantization\")\n",
    "print(\"✓ FIX 2: FC2 outputs INT32 logits\")\n",
    "print(\"✓ NEW: Cycle counter timing added\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Prepare Test Images\n",
    "\n",
    "**Match preprocessing from training!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Test images prepared\n",
      "  Input scale: 2^5 = 32.0\n",
      "  Range: [-14, 90]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABI8AAAHvCAYAAADdOf//AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABP9UlEQVR4nO3debxVdfU//nWRWUFmxAkUw5wnEDXn1BDF1FBQQ3Iu9SM5lDlCplmWZmVqaklRGqmJkkaKiTMqKs6IEw44MSiISICc3x/+PF9I1+F6Lnc4l+fz8eDxOPe89n7vdQ4s773LffauKhQKhQAAAACAL9CkvgsAAAAAoOEyPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEABT16NEjqqqqvtSfCRMm1GpNI0eOXOZ4X9aIESOW2X/atGkrvkgAgEbM8AgAAACAVNP6LgAAaDjOOuusmDNnTvHr999/P376058Wv95zzz1jr732Wmafnj171ll9AADUPWceAQBFxxxzTJx22mnFP8ccc8wy+Q477LBMftppp8Vaa60Vo0aNir322iu6dOkSzZs3j86dO8c+++wTt99++xce59Zbb41+/fpF165do1mzZtG2bdvo2bNn7L///nHhhRfGkiVLYtq0aVFVVRVHHHHEMvsu/RG0ESNG1Oj1Lv2Rth49esTbb78dQ4cOjU6dOkXbtm1jwIABMXXq1IiIePzxx6Nfv37Rpk2baN++fRx00EHxxhtvLLPe4sWL45xzzon+/ftHz549o127dtGsWbPo2LFj7LTTTvHb3/42Fi1a9IW1XHPNNbHZZptFy5YtY5111onTTjstPvroo2U+SvhFr/fJJ5+MI488Mnr27BmtWrWK1VZbLbbaaqv46U9/Gh999NHntn/ttdfiuOOOi6985SvRqlWraNmyZay11lrxta99LU455ZR4/vnna/SeAgCNjzOPAICyffzxx7HffvvF+PHjl3l+5syZcfvtt8ftt98ep5xySlx88cXFbOTIkZ8bCH344Yfx4YcfxiuvvBK33HJLnHzyyXVS///WsMMOOyxzTaR//vOf8fDDD8dVV10VgwcPjv/+97/F7MYbb4wnn3wynnrqqWjZsmVERCxYsCDOP//8z609e/bsuP/+++P++++PW2+9NcaNGxerrLJKMT/jjDPiZz/7WfHrN998My6++OK47777YsGCBWnNV1xxRZx00kmxePHiZZ6fPHlyTJ48Of7617/GXXfdFWussUZERLz33nvRp0+fmDFjxjLbv/XWW/HWW2/Fgw8+GL169YqNNtqoGu8YALCyMDwCAMp28sknFwdHzZs3j8GDB8dXvvKVePrpp+OGG26IQqEQl1xySWyzzTZx6KGHRsSnA4/P9OnTJ/bdd99YvHhxvPHGG/Hwww8Xz3zp0KFD/OIXv4hJkybF6NGji/v84he/KD7eYYcdVthrmT17dnz88ccxbNiw+Oijj+Kaa66JiIgZM2bEAQccEKuttlqceOKJ8dprr8WNN94YEREvvvhijBkzJgYPHhwRn54Vtf7668d2220Xa621VrRv3z4WLVoUU6ZMiRtuuCEWL14c48ePj5tuuikOPvjgiIh49NFH4+c//3mxji5dusTQoUPjww8/jD/+8Y+xcOHCL6z3wQcfjBNPPDGWLFkSERHbbbdd9OvXLz788MP405/+FDNnzoznnnsuDj/88LjjjjsiIuKmm24qDo7at28fRxxxRHTs2DHeeuutmDJlStx3330r7P0EABoPwyMAoCyzZ8+OP/zhD8Wvr7zyymXOKOrUqVNcfvnlERHxy1/+sjg8WvpMmt/85jex3XbbLbPutGnTonnz5tGyZcs47bTTYuTIkcsMj0477bRaeT0REVdffXUcdthhERHx7LPPxkMPPVTMrr322hg4cGAUCoVYe+2146233oqIT4c/nw2PVl111Xj55Zfjvffei4kTJ8b06dNj/vz5sfXWW8fTTz8dzzzzTERE/Pvf/y4Oj/7whz9EoVCIiIgmTZrEf/7zn9hkk00iIqJv376fO0vrM7/85S+Lg6Ndd9017rrrrmjS5NMrEgwaNCi23XbbiIi4884746mnnorNN998mff+4IMPXuaMsIiIjz76KObNm1fu2wcANFKGRwBAWR5++OFlPi515JFHxpFHHvmF206ePDnmz58frVu3jp122imeeuqpiPj0Atzbb799fOUrX4mNN944dt5559hss83qpP7/1bRp0xg0aFDx6x49ehSHR82aNYsDDjggIj49u2i99dYrDo/ef//94j4ff/xxHH/88fHnP/+5ONj5Im+++Wbx8aRJk4qPt9lmm+LgKCLi29/+dhxzzDGf+1haRMQDDzxQfDxhwoRlPgb3vx588MHYfPPN42tf+1pUVVVFoVCI3//+9/Hoo4/GxhtvHBtuuGH07t07dtttt+jatWu6DgCwcjI8AgDKMnv27GpvWygUYtasWdG6dev46U9/Gq+88kr861//innz5sWdd94Zd955Z3HbXXbZJW677bZYddVVa6PsVJcuXaJp0//3o1Hz5s2XyZYeziy93dJDojPOOCNGjhy53GMtfe2kDz74oPj4s2sTLX2cTp06xTvvvPO5Nb7M+//ZR9W23XbbuOSSS+Kcc86JefPmxeOPPx6PP/54cbtOnTrFDTfcELvuumu11wYAGj/DIwCgLB06dFjm65NPPjnWXHPNdPvVV189IiLatm0bt99+e7z55psxceLEmDp1ajz33HNx8803x/z58+Oee+6Jiy66KH784x/Xav3/q1mzZmm29LColKU/XrfZZpvF9ddfHxtuuGE0bdo0Dj744Ljhhhs+t0+7du2Kj997771lssWLF8fMmTO/8FgdOnQobr/jjjvGN7/5zbSupa8N9f3vfz+OPfbYmDhxYjz77LPx4osvxrhx4+LFF1+MmTNnxtChQ+O1116r1usFAFYOhkcAQFn69u0bq6yySnzyyScR8enw5YuuRzRt2rR44YUXom3bthER8cwzz8SGG24Ya6+9dgwcOLC43bBhw+I3v/lNRMQyZ8P871Dns4+/NUSzZs0qPt5tt92KH0GbMWNGTJgw4Qv36d27dzz22GMR8elH2F566aXYYIMNIiLiL3/5yxd+ZC3i04HQmDFjIiLinXfeiWOPPbb4Hn/m448/jhtuuKE4PHrrrbdilVVWia5du8buu+8eu+++e0REPPHEE7H11ltHRMTrr78es2bNio4dO5bxDgAAjZHhEQBQlg4dOsSRRx4ZV199dUREXHTRRTFp0qTYYYcdomXLljF9+vSYOHFiPPHEEzF06ND4xje+ERGfXvD6kUceia9//euxzjrrROfOneOtt96Ka6+9trj20mfjrLXWWssc99BDD40ddtghmjRpEkOGDGlQ1+jZcMMNixfFvvrqq6NJkybRunXrGDVqVPGjY//rqKOOiquuuioKhUJ88sknsfPOO8fhhx8ec+fOXeaC5P/r1FNPjVtuuSUKhUK89NJLsemmm8aBBx4YXbt2jTlz5sTTTz8d99xzT3z00Udx+OGHR0TEvffeG4cddljsuOOOsdFGG8Waa64Zn3zySfzjH/8ortu8efMGO5wDAOqH4REAULZLL700Xn311Rg/fnxERPznP/+J//znP8vd7/333y/e7v5/tWzZMk466aTi19tvv31069Yt3n777YiIuOWWW+KWW26JiE/vMtaQhkdnnXVWHHLIIRHx6Vk/l156aUREdOvWLfbcc89lru30mT59+sTpp58eP/vZzyIi4u23346f//znERGx9dZbx/Tp0+Pdd9+NiCjeTS3i04+qXXbZZTFs2LBYvHhxvPHGG/HrX/96uTUuWbIk7r333rj33nu/MD/xxBOjVatW1X/RAECj12T5mwAAfLHWrVvHv//977juuuuif//+0bVr12jatGm0atUqevbsGQMHDoyrrroqLrnkkuI+P/jBD2LYsGGx3XbbxVprrRXNmzePFi1axPrrrx9Dhw6NRx55JPr06VPcvkWLFnH77bfHXnvt9bmPZTU0gwcPjr///e+xxRZbRLNmzaJjx44xaNCgmDhxYsnrQV144YVx1VVXxSabbBLNmzePbt26xYknnhh33XVXzJ07t7jd0mdkRUQcf/zx8cQTT8Sxxx4bvXr1itatW0fTpk2ja9euscsuu8Q555wTTz75ZHH7HXfcMS644ILYZ599omfPntGmTZto2rRpdO7cOb7+9a/HyJEj4+KLL17h7wsAUNmqCoVCob6LAABYmX388cdfeLbPP//5zxgwYEDx6wceeGCZi18DANQFH1sDAKhnZ555ZkyePDkGDBgQ6623XixevDgmTZoUl19+eXGb3r17x/bbb1+PVQIAKyvDIwCAelYoFGLChAnpHdk22GCDuOGGG6KqqqpuCwMACMMjAIB6t//++8e7774bDz/8cMyYMSMWLFgQ7dq1i0033TQOOOCAOProo90BDQCoN655BAAAAEDK3dYAAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwqJ706NEjqqqqoqqqquw1Ro4cWVxjxIgRK6444HP0LFQO/QqVRc9CZdGzKyfDoxoaMWJE8R99VVVVNGvWLNq1axcbbbRRDB48OMaNG1fnNU2ePDlGjBgRI0aMiAkTJnypfV966aU47LDDomvXrtGiRYvo2bNnnH766TF37tzaKRbqWGPq2XvuuSeOOuqo2GijjaJJkybF1/Rl+x4aqsbUr6NGjYqhQ4fGJptsEu3bt48WLVrEBhtsEMOGDYuZM2fWXsFQhxpTz15zzTXxjW98I9ZZZ51o1apVtGzZMtZbb734zne+E1OmTKm9gqEONaaeXdqrr74aq622WvF1bbfddiu2yJVU0/ouoLFZvHhxzJkzJ+bMmRNTpkyJ0aNHx4ABA+Kvf/1rtGnTprjdjTfeGAsWLKjRsfr37x/33XdfRESsu+66xecnT54cP/7xj4tf77rrrtVa78knn4xddtkl5syZU3zulVdeiYsuuijuuOOOuPfee5d5DdAYVHLP3nzzzfHHP/6xRjVBJankfj3mmGPiv//97zLPvfzyy/Gb3/wmxo4dG5MmTYoOHTrUqGZoaCq5Z//2t7/FXXfdtcxz06ZNi2nTpsVNN90Ujz32WPTq1atGNUNDU8k9u7TjjjsuPvrooxrVx+cZHq1Ae++9d5x55pkxe/bsGD9+fPz+97+PhQsXxtixY2PIkCExZsyY4ra9e/eu8fG6dOkSXbp0qfE6nzniiCOKg6Njjz029tlnn7j44ovj3nvvjcmTJ8d5550Xv/jFL1bY8aC+VXrPdu3aNQYOHBjbb799/P73v4+pU6eusLWhoan0fq2qqoodd9wxvv3tb0fPnj1j4sSJ8ZOf/CQWLlwYr776avz6179e5odlqHSV3rNbbLFF7LLLLrHJJpvE6quvHs8++2ycc845MXfu3Jg3b15ce+21ceGFF66w40F9q/Se/cyf/vSnuPPOO6Nly5Y1HnDxPwrUyPDhwwsRUYiIwtChQ5fJxo4dW8wiojB+/Phi1r179+LzS5s5c2bh8MMPL7Rt27aw+uqrF4YMGVKYMWNGcdvu3bsXt7322muLzw8fPvxz6/7vn8+2+SIPP/xwcbuNNtqosGTJkkKhUCi89dZbhaqqqkJEFNq3b19YuHBhjd4vqG+NpWf/V9++fYv73X333V/yXYGGqTH167///e/PPff973+/uP/ee+/9pd4baIgaU89+kWHDhhX3P+GEE770/tDQNLaefffddwsdOnQoVFVVFc4///zivn379i33LWIprnlUi/bdd9/YY489il9ff/31JbdftGhR9OvXL/785z/H3LlzY86cOTFq1Khl1qgt999/f/HxdtttV7z4Wbdu3aJHjx4REfH+++/Hs88+W+u1QH2ppJ6FlV2l9etee+31uee+8pWvFB+vuuqqdVIH1JdK69ml/fe//43HHnssbr/99uJzu+22W53XAXWpEnv2pJNOitmzZ8fxxx8fX/va1+rsuCsLw6Natv322xcfT548ueS21157bUyaNCkiItq3bx/XXHNN/P3vf1/mGkTLc+ONN8aZZ55Z/PqII46I++67L+6777448sgj0/2mTZtWfNy1a9dlsqVPJ3z11VerXQtUokrpWaDy+/Uf//hH8fHee+/9pfeHSlNpPTtlypSoqqqKli1bRu/evePFF1+Mdu3axYUXXhjf+ta3ql0HVKpK6tmxY8fG6NGjY5111vGR0lrimke1rFu3bsXHy2ucpT9Het5558VRRx0VERFt27aNfv36Vet4vXv3jmeeeab49brrrhs77rjjcvdb+oJizZs3XyZb+msXHqOxq5SeBSq7X88+++zixXi32267OPzww8taBypJJffsZ5o2bRqFQqFGa0ClqJSe/fDDD+P444+PiIgrr7zSTZ5qieFRLZs+fXrx8eqrr15y21deeaX4uG/fvsXHS098a8vSp8v/791gFi5c+IXbQWNUKT0LVG6/nnbaaXHxxRdHRMRXv/rVuPXWW6NpUz+S0fhVWs9279497rvvvpg/f35Mnjw5fvazn8XMmTPjzDPPjDZt2sSJJ55YZ7VAfaiUnr3wwgvjzTffjEMOOST69+9f68dbWfnYWi174IEHio+33HLLau/32TWH6spn1zWKiHj33XeXyd55553i4/XWW6+uSoJ6USk9C1Revy5ZsiSOO+644uBo8803jwkTJkTnzp3rpR6oa5XWs61atYodd9wx9tprr/jhD39Y7N2IiOuuu65eaoK6VCk9+9Zbb0XEp9dlqqqqiqqqqmWuS/bwww9HVVVVXHrppXVaV2NjeFSLxowZExMmTCh+PWjQoJLb9+zZs/j40UcfLT5+6KGHvtRxmzT5f3+tS5YsqdY+S58O+NBDDxVPx50+fXq8/vrrEfHpZ1c32WSTL1ULVJJK6llY2VVavy5evDiGDBkSV111VUR8+lG1CRMmfO46g9BYVVLP/ve///3Cj6Yt/QvxBx988KXqgEpTST1L3XCO9Ar03nvvxf333x+zZ8+OO++8s/gDYkTEgAEDYs899yy5//7771+8i8O5554brVq1ilVXXTVOP/30L1VH+/bti4/HjRsXO++8c7Rs2TI222yz9HTDbbfdNrbaaqt44okn4oUXXojjjjsu9t1337j44ouL3zyPOuqoaNas2ZeqBRqySu7ZiIjnnnsunnvuuYiImD17dvH5e+65J2bOnBkREQMHDvxStUBDVen9+q1vfStuvfXWiIhYZ511YsSIEcvcwXT11VePzTbb7EvVAg1ZJffsQw89FEcffXQMGTIkNt1002jbtm08/fTTccEFFxS32Xrrrb9UHdDQVXLPHnrooZ87M+qll16K3/3udxHx6UdQv//978cuu+zypWrhfxSokeHDhxciouSfffbZpzB37txl9uvevXsx/8zChQsLvXv3/tz+m2++efFx9+7di9tfe+21xeeHDx9efH7GjBmFFi1afG6du+++u+RreeKJJwqrr776F76GLbfc8nOvASpRY+rZ6rwWqGSNqV+X9zp22WWXFfCOQf1qLD179913l3wNa6yxRuHll19eUW8b1JvG0rNfZOk+7tu3bzlvD//Dx9ZWsCZNmkSbNm2iV69ecdBBB8XYsWNj7Nix1brie7NmzWLcuHExZMiQaNu2bbRt2zYOOeSQuOmmm4rbtG7dernrdOrUKcaMGRNbbbVVtGrVqtq1b7nllvHoo4/GoYceGl26dInmzZvHeuutFz/84Q/jnnvucdV6GqVK7llY2ehXqCyV2rO9evWKk046Kbbeeuvo1KlTrLLKKtGmTZvYaqut4owzzoinnnoq1l9//WqtBZWkUnuWulFVKLjXZENSKBQ+d4GxcePGxd577x0REfvtt1/ccsst9VEa8AX0LFQO/QqVRc9CZdGzjZtrHjUwQ4cOjT59+sROO+0U7du3j8cffzxOPvnkYr68C5UBdUvPQuXQr1BZ9CxUFj3buBkeNTCvv/56jBo16guzQYMGxSGHHFLHFQGl6FmoHPoVKouehcqiZxs3w6MG5pBDDonFixfHCy+8EB988EG0adMmtthii/jOd74Thx9++OdOAwTql56FyqFfobLoWagserZxc80jAAAAAFLutgYAAABAyvAIAAAAgJThEQAAAACpal8w28WtINcQLx2mZyGnZ6Gy6FmoLHoWKkt1etaZRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJBqWt8FAACUctppp5XMW7VqlWabb755mg0cOLCseq644oo0e+ihh9Js1KhRZR0PAKC+OfMIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBVVSgUCtXasKqqtmtZKa266qpp9otf/CLNjjvuuDR77LHH0uyggw5Ks9deey3NKK2abVSn9Gzj0KtXrzSbMmVKyX2HDRuWZr/97W/Lrqkx0LMNz+jRo9Ns4MCBdVhJzbz88stptscee5Tc9/XXX1/R5TQaerZmVltttTRbe+210+z4448v63h//OMfS+aTJ08ua10qh56FylKdnnXmEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACDVtL4LWNl169YtzY455pg0W7JkSZpts802abbvvvum2e9+97s0A+rHVlttlWal/jsQEfHmm2+u6HKgRkaPHp1mAwcOrJVjTpkyJc3+/e9/p9n666+fZgMGDEiznj17ptlhhx2WZhERF154YckcSllttdXS7Ac/+EGanX322Su8lu9+97sl81L/LRg2bFiazZ49u+yagNzWW29dMv/HP/6RZj169FjB1dSPvfbaK82ef/75NHvjjTdqo5wGyZlHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgFTT+i5gZdC5c+c0+9Of/lSHlQCVZsstt0yzjz76qOS+N9988wquBpavd+/eaXbAAQeUteazzz5bMt9vv/3SbObMmWk2b968NGvevHmaTZw4Mc222GKLNOvYsWOaQU2dccYZafajH/2oDiuJWGWVVUrmhx56aJrtvvvuaXbEEUek2R133LH8woAv9I1vfKNk3qJFizqqpP4MGDAgzY488sg0Gzx4cG2U0yA58wgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQalrfBTQGJ510Usl8//33T7Ntt912BVdT2s4775xmTZqUniU++eSTaXbvvfeWXROs7DbddNM0O/HEE9Ns1KhRtVEO1Ei3bt3SrKqqKs2effbZNFveLYTffvvt5Rf2JZ166qlptvHGG5e15m233VZuObBc06ZNK2u/QqGQZr/73e/SrFTPNmvWrOQxzzvvvDRbY4010uyWW25Js5///OdpdtFFF6XZ/Pnz0wwak6ZN81/9+/fvX4eVNEyPPfZYmp1yyilptuqqq6bZRx99VKOaGhpnHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAACnDIwAAAABS+f36qLZf/epXJfMlS5bUUSXLd+CBB5aVRUS89tpraTZo0KA0K3XbQyDiq1/9apqVuv3n6NGja6McqJGxY8em2QYbbJBmH374YZrNnj27RjWVY/DgwWm2vNuQQ33Yf//9y9rvhhtuSLNhw4aVWU1pTz75ZJrdfPPNadahQ4c0O+ecc9KsZ8+eaXbkkUem2aJFi9IMKs1uu+2WZttvv33JfS+66KIVXU6D0759+zTbeOON06x169Zp9tFHH9WopobGmUcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAVFWhUChUa8OqqtqupUG7/fbb02zvvfcuue+SJUtWdDklzZo1K83mzZuXZt27d6+NcmKVVVaplXUbkmq2UZ1a2Xu2kjzyyCNp1rlz5zTbdNNNS67b2G4PuiLpWSIifvCDH6TZeeedl2bNmzdPs4cffjjN9thjj5L1zJ8/v2S+MtOzy1fqPSr1s+jmm2+eZs8++2yNairHDjvskGYXXnhhmu24445lHe+6665LsyOOOKLkvosXLy7rmCsDPVs/Sv1sOGHChDQr9ftjRMQ222yTZqV+v6wkpd6fUv996datW5rNmDGjJiXVqer0rDOPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAAKmm9V1AQ7LLLruk2YYbbphmpW5/Wp28HFdeeWWa3XHHHWk2Z86cNNt9991LHvOss85afmFf4Hvf+16aXXHFFWWtCZWmR48eada7d+80mzp1app99NFHNSkJVgr77rtvmp133nlp1rx58zR777330uyMM85Is/nz56cZ1NT48ePTrNTPeA3te8mDDz6YZj/84Q/T7Lbbbkuz9u3bp9mhhx6aZmPHjk2ziIi///3vJXOoa2effXaarbrqqmnWr1+/kuvOmzev7Joakg4dOqRZqVlAbfw+X4mceQQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkGpa3wXUtR49eqTZ3/72tzTr1KlTLVQT8dprr6XZTTfdlGY//vGP02z+/PkrvJaIiGOPPTbNOnfunGYXXXRRmrVs2TLNLrvssjRbtGhRmkFDtMsuu5S134wZM1ZwJbBy6d27d5o1b968rDVHjx6dZvfcc09Za0JNPf/882m2++67r/DjHX300Wl26KGHltz397///YouJ66//vo0O/7448ta8ytf+Uq55UCtGThwYJr1798/zV566aU0mzRpUo1qqhRnnXVWmi1ZsiTNJkyYkGYffPBBDSqqLM48AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKSa1ncBda1p0/wld+rUqVaOWeq2vYMHD06zmTNn1kY5qddee61kfuGFF6bZJZdckmatW7dOs4suuijNbr311jR7+eWX0wwaos0226ys/Ur1CPCpMWPGpNlee+1V1pp//vOf0+zss88ua02oTeXeanvzzTdPs5YtW6bZZZddlmbNmjUrecxddtll+YU1AEcffXTJ/IUXXkizO++8M83mzJlTdk1w0EEHpVmp37suv/zy2iinQenRo0fJ/LDDDkuzTz75JM3OP//8NFu0aNFy62osnHkEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASFUVCoVCtTasqqrtWurEBhtskGbPP/98WWs+/vjjJfNSt1N8/fXXyzpmfejevXuajR49Os369OmTZkuWLEmzr371q2n28ssvp1l9qGYb1anG0rOVZLvttkuz2267Lc2mTZuWZl/72tfSbMGCBdWqi8/Ts5WlW7duJfMnn3wyzTp27JhmM2fOTLMddtghzRra96CVgZ5dvrZt26bZfvvtl2ZjxoxJs65du6bZY489lmZt2rRJs5XF/Pnz0+zYY49Ns1tuuaWsNRsaPVszq6++epo99dRTabbWWmulWdOmTWtUUyX46U9/WjL/4Q9/mGalZgGbbbZZ2TVViur0rDOPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAAKnGf7++L6FJk/JmaX379l3BlTRMpW5vWeq9K/d9HTFiRJoNGTKkrDWhNu2xxx5p1qFDhzQbN25cmi1YsKBGNUFjcNNNN5XMO3bsWNa6f/nLX9Ls5ZdfLmtNqC9z585Ns1L/1kuZN29emh122GFpdvDBB5dct9T3xP79+y+/sArQunXrNCv19/HMM8+k2aGHHppmzz77bPUKoyK0aNEizdZaa600u/7662ujnIrRs2fPsvct1Xt8yplHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgFTT+i6grn33u99NsyVLltRhJZVnwIABabbVVlulWan3tVQ2YsSIatUFDcUWW2yRZoVCIc1uvPHG2igHKsp+++2XZltvvXXZ606YMCHNhg8fXva6sLK77bbbysoiIlZZZZU0a9OmTVn1dO3aNc1KfQ9+7733yjpeRMSPf/zjNDvyyCPTrHXr1mm26aabptkll1ySZqeffnqaTZ48Oc1omD788MM0K/X3ufnmm6dZhw4d0mz27NnVqqsh6NKlS5oNHDiw7HXvv//+svddWTjzCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJBqWt8F1LVSt5tfGXTu3DnNNt5445L7nnnmmSu6nJgxY0aaLVq0aIUfD2pqjTXWSLOddtopzV544YU0u/nmm2tUE1SKjh07plmp7zHNmjUr+5ilbmk8b968steFlV2nTp3SrFevXiX3ffDBB9Psgw8+KKuecveriWHDhqXZ6NGj0+yKK65Is0033TTN9thjjzS78MIL02zvvfdOMxqmjz/+OM1efvnlNPvWt76VZrfddluaXXLJJdUrbAUq9W99/fXXT7MePXqkWaFQKLueJUuWlL3vysKZRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAIBU0/ougLp11llnpdkJJ5xQK8ecNm1amg0dOjTNXn/99VqoBmrmO9/5Tpp16dIlzf71r3/VQjVQWU499dQ069OnT9nrjhkzJs2GDx9e9rqwshswYECaXXrppWm25pprllx38ODBaXbLLbcst65K8OCDD6bZjjvumGaPP/54mpW6ffn222+fZv369UuziIhx48aVzGlYSn1fq6qqSrN99tknza6//voa1VSOmTNnplmhUEizTp061UY5MXLkyFpZtzFx5hEAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQKppfRfAinf77ben2YYbbliHlXzqueeeS7P777+/DiuBmuvevXtZ+73//vsruBKoPKecckqtrHviiSem2bx582rlmLAyWG211dJszTXXTLPmzZuXXPemm25Ksx133DHNJk6cWHLdSvHhhx+m2SGHHJJmDz30UJq1adMmzU4//fSS9YwbN65kTsMyZcqUNDv44IPTbMstt0yzDTbYoCYlleXGG28sa78//elPaXbYYYeVW058/PHHZe+7snDmEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACDVtL4LqGtVVVVp1qRJebO0vffeu9xy4qqrrkqzUrdALaXU61iyZElZa9bEgAED6vyYUFv23XffsvYbO3bsCq4E+EyHDh3SbNGiRXVYScScOXPSbHm1NGvWLM1WX331supp165dmp1yyillrbk8n3zySZqVumX4/Pnza6McauD6669Ps7XWWivNfv7zn5dct9TP46usssryC2vEtthiizQr9b6V8tRTT5VbDo3I5MmTy8oamldeeaVW1t10003T7JlnnqmVY1YaZx4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUk3ru4C6dsUVV6TZRRddVNaa//znP0vmS5YsKWvdcver6zUjIq688spaWRfqw4477phma6yxRh1WAlRHQ7oN9Q033JBmb7/9dsl9u3btmmaDBg0qu6aG5J133kmzCy64oA4roaauuuqqNOvXr1/JfXfbbbc0+/Of/5xm99xzT5r97Gc/S7OpU6eWrKc2DBs2LM2OPvroNOvZs2eaVVVV1agmaAxK9UFNeuSZZ54pe9+VhTOPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAAKmqQqFQqNaGjeTWkN27d0+zhx56KM06d+6cZk2alJ7BLVmyZPmFrUCl6nn33XfT7Pnnny+57rHHHptmpW4/PH/+/JLrNgbVbKM61Vh6tj5cfPHFaXbyySen2RNPPJFm2267bZp98skn1SuMFUbP1o9//OMfafbNb36zDitpXBYvXpxm5f4Mcuutt6bZpEmTylozIuK+++5Ls4kTJ6aZnq0sq622Wsn8ySefTLNu3bqlWYsWLdKs1L/1uv5ZPCKiadOmdXq8Rx99NM322WefkvvOmjVrRZejZ6k1w4cPT7Nzzjmn7HXrumcbmur0rDOPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAAKmV7n50r732WpoNHjw4zfbff/80GzZsWE1KqlMXXHBBmv3ud7+rw0qg/rRu3bpk3r9//7LWvfHGG9Psk08+KWtNaEwOPPDANPvhD3+YZs2aNauNcmKTTTZJs0GDBq3w4/3xj38smU+bNq2sdW+66aY0mzJlSllrQk3MmzevZN6zZ880Gzp0aJqV+ll90003TbM111yzZD0NyYMPPphm//73v9Ps6quvTrNZs2bVqCZoSFq2bFn2vh9//PEKrGTl48wjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQKqqUCgUqrVhVVVt11Kx+vXrVzI/9thj02zAgAFpduutt6bZVVddlWal/q6ee+65NHv99dfTjNKq2UZ1Ss/mlnfb73vuuSfN3nvvvTQ79NBD02z+/PnLL4w6o2ehsuhZlmeNNdZIs9VWWy3NSv2cfvfdd5c8Zp8+fdJs6tSpaTZp0qQ0e+ONN9Lsv//9b8l6GhI9S21555130qxp06Yl9/3JT36SZr/+9a/LrqkxqE7POvMIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkKoqVPM+im5tCDm3I4XKomehsuhZqCx6ltoyduzYNLvkkktK7nv33Xev6HIajer0rDOPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAACnDIwAAAABSVYVCoVCtDauqarsWqFjVbKM6pWchp2ehsuhZqCx6FipLdXrWmUcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIFVVKBQK9V0EAAAAAA2TM4/qSY8ePaKqqiqqqqrKXmPkyJHFNUaMGLHiigM+R89C5dCvUHn0LVQO/bpyMjyqoREjRhT/0VdVVUWzZs2iXbt2sdFGG8XgwYNj3LhxdV7T5MmTY8SIETFixIiYMGFCtff7zne+s8xr+d8/06ZNq7Waoa40pp79zNixY6Nfv37RsWPHaNGiRay99toxYMCAuPfee1d8sVCHGku/TpgwoeT316qqqujRo0et1g11pbH0bUTEJ598Er/97W+jb9++0bZt22jatGl06tQp9thjj7jppptqr2CoI42pXyMibrzxxth5552jbdu20bp169hiiy3iN7/5TXzyySe1U+xKpml9F9DYLF68OObMmRNz5syJKVOmxOjRo2PAgAHx17/+Ndq0aVPc7sYbb4wFCxbU6Fj9+/eP++67LyIi1l133eLzkydPjh//+MfFr3fdddcaHQcas0rv2dNOOy0uvvjiZZ6bPn16TJ8+Pfr27Rs777xzjWqGhqTS+7WUZs2arZB1oKGp5L497rjj4g9/+MMyz82aNSvuuuuuuOuuu+Lyyy+P733vezWqGRqSSu7X4cOHx3nnnbfMc0899VQMGzYsJk6cGNddd12N6sXwaIXae++948wzz4zZs2fH+PHj4/e//30sXLgwxo4dG0OGDIkxY8YUt+3du3eNj9elS5fo0qVLjdf5X2ussUbccMMNn3u+W7duK/xYUJ8qvWdHjx5dHByttdZaceqpp8Ymm2wS8+bNiyeffDI22GCDFXYsqG+V3K9bbbVV8QfkpV1yySVx8803R0TE/vvvv0KOBQ1JJfftBx98ENdee23x6/PPPz/69u0bf/jDH+Jvf/tbRIThEY1KJffriy++GOeff35ERKy66qrxq1/9Krp27RpnnHFGPPfcc3H99dfHgQceGAMHDlwhx1tpFaiR4cOHFyKiEBGFoUOHLpONHTu2mEVEYfz48cWse/fuxeeXNnPmzMLhhx9eaNu2bWH11VcvDBkypDBjxozitt27dy9ue+211xafHz58+OfW/d8/n22TGTp06OeOAY1NY+rZjTfeuBARhZYtWxamTp1ak7cFGqTG1K//a8GCBYVOnToVIqLQpEmTwssvv/yl9oeGqrH07euvv17crlOnTsXnn3nmmeLzX/3qV8t+n6AhaCz9etlllxW3+853vlN8/m9/+1vx+T322KPs94lPueZRLdp3331jjz32KH59/fXXl9x+0aJF0a9fv/jzn/8cc+fOjTlz5sSoUaOWWaMuvP3229GtW7do3rx5dO/ePb73ve/F22+/Xac1QH2opJ595ZVX4rnnnouIiI022ih+8YtfxNprrx2tWrWKvn37xtixY2u9BqhPldSvX+Tvf/97zJw5MyIi+vXrF+uvv3691AF1qZL6du211y6ewTtz5sy44IILYvz48fGTn/ykuM23v/3tWq8D6ksl9eucOXOKj1ddddUvfPzQQw/FkiVLar2WxszwqJZtv/32xceTJ08uue21114bkyZNioiI9u3bxzXXXBN///vfl2mG5bnxxhvjzDPPLH59xBFHxH333Rf33XdfHHnkkdVaY+HChfHOO+/EokWL4vXXX48rr7wy+vTpE2+99Va164BKVSk9+9ngKCLiiSeeiKuvvjqmT58eCxYsiEceeSS++c1vxl/+8pdq1wGVqFL69YtcfvnlxccnnHDCl9oXKlml9G1VVVXcfPPNsdlmm0VExNlnnx177rlnjB49Ojp27BiXX355nHXWWdWuAypRpfTrhhtuWHw8ZsyYmDJlSrz//vtx5ZVXFp//6KOP4v333692LXyeax7VsqWvE7S8xln6c6TnnXdeHHXUURER0bZt2+jXr1+1jte7d+945plnil+vu+66seOOO1Zr33bt2sXRRx8du+66a3Tp0iWeeOKJuOCCC2Lu3Lkxffr0OPfcc+Oaa66p1lpQqSqlZz/44INlvt5jjz3i5JNPjn//+9/xm9/8JgqFQpxyyikxaNAgF+Kl0aqUfv1fTzzxREycODEiItZff/1qHx8ag0rq2/bt28fGG28cTz/99DLPz5o1K2644YY48MADo2vXrtVaCypRpfTrgAEDolevXjF16tSYPn16bLTRRl+4XU0v8r2yc+ZRLZs+fXrx8eqrr15y21deeaX4uG/fvsXHS098a9Oll14aV199dRx22GGx5557xg9/+MO49NJLi/m//vWvOqkD6lOl9GyLFi2W+fryyy+P/v37x6WXXhprrbVWRETMmDEjnnrqqVqvBepLpfTr//rd735XfPy9730vmjTx4xgrj0rp20WLFsVuu+0Wo0ePjhYtWsRdd90V8+bNK96o4u67744hQ4bUeh1QnyqlX5s3bx533HFH7Lbbbss8v88++0TLli2LX7dr167Wa2nM/LRSyx544IHi4y233LLa+1VVVdVCNV/etttuW3w8Y8aMeqwE6kal9OzStzSNiOjevXuxjnXWWaf4/Ny5c+u0LqhLldKvS/vggw+K141o1arVl/64G1S6SunbCRMmxIsvvhgREbvvvnvsvvvuseqqq8Ypp5wSrVu3joiIO++8M+bPn1+ndUFdqpR+jfj0Z+H//Oc/MX369HjkkUfi3XffjSuuuKJ4tlH37t2XuQYSX57hUS0aM2ZMTJgwofj1oEGDSm7fs2fP4uNHH320+Pihhx76Usdd+v9gVveiYHPnzi1+g1zaww8/XHzstFwau0rq2S222GKZb4Cvv/56REQUCoV48803i88vPUiCxqSS+nVpI0eOLP6yOXjw4OjQocOXXgMqVSX17WcXtI+ImDdvXvHxggULYtGiRV+YQWNSSf26tDXXXDP69OkTXbp0iV/+8pfF5/fdd98vvRbLcs2jFei9996L+++/P2bPnh133nlnXHXVVcVswIABseeee5bcf//994/bb789IiLOPffcaNWqVay66qpx+umnf6k62rdvX3w8bty42HnnnaNly5ax2Wabpacbzp49OzbZZJM48MADY8CAAdG1a9d4/PHH44ILLihu881vfvNL1QENXSX3bMuWLWPIkCHFCwGecMIJ8f3vfz/uuOOO4vBoiy22KN4pBipdJffrZwqFQlxxxRXFr10om8aukvt2k002KT6+77774vzzz49tt902Ro4cWRwerbnmmtG5c+cvVQs0VJXcrxERxx13XLRr1y622267aNKkSYwZMyZGjhwZEZ/ede3UU0/9UnXwBQrUyPDhwwsRUfLPPvvsU5g7d+4y+3Xv3r2Yf2bhwoWF3r17f27/zTffvPi4e/fuxe2vvfba4vPDhw8vPj9jxoxCixYtPrfO3Xffnb6OV199teRr2HDDDQszZ85cUW8b1JvG0rOFQqEwa9aswoYbbviFr2G11VYrPPLIIyviLYN605j6tVAoFO64447i9n379q3p2wMNUmPq24MPPrjk6/jTn/60It4yqDeNqV+/+c1vfmH9zZo1K9x4440r4u1a6fnY2grWpEmTaNOmTfTq1SsOOuigGDt2bIwdOzbatGmz3H2bNWsW48aNiyFDhkTbtm2jbdu2ccghh8RNN91U3Oazz1iX0qlTpxgzZkxstdVW0apVq2rVvdZaa8WoUaPiwAMPjJ49e0br1q2jVatWsemmm8Y555wTjz76aHTs2LFaa0ElqdSejYjo0KFDPPjgg/H9738/unfvHs2aNYvOnTvH4MGD49FHH40+ffpUey2oBJXcrxGfXtj+M846YmVRyX3717/+NS699NLYdttto02bNrHKKqtEx44do1+/fvGvf/0rDj/88GqvBZWgkvt1//33jx122CE6deoUzZo1i27dusWhhx4ajz/+eHzrW9+q9jrkqgqFQqG+i+D/KRQKn7vA2Lhx42LvvfeOiIj99tsvbrnllvooDfgCehYqh36FyqNvoXLo18bNNY8amKFDh0afPn1ip512ivbt28fjjz8eJ598cjFf3oXKgLqlZ6Fy6FeoPPoWKod+bdwMjxqY119/PUaNGvWF2aBBg+KQQw6p44qAUvQsVA79CpVH30Ll0K+Nm+FRA3PIIYfE4sWL44UXXogPPvgg2rRpE1tssUV85zvficMPP/xzpwEC9UvPQuXQr1B59C1UDv3auLnmEQAAAAApd1sDAAAAIGV4BAAAAEDK8AgAAACAVLUvmO3iVpBriJcO07OQ07NQWfQsVBY9C5WlOj3rzCMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABINa3vAgDqWosWLUrmDzzwQJpttdVWaTZ27Ng023///ZdbFwAAQEPkzCMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgFTT+i6AhqN9+/Yl83XXXXeFH/O1115Ls5NPPjnNnnnmmTSbOnVqyWM++eSTyy+MiteiRYs0+9WvflVy3y233DLNCoVCmj322GPLrQsAAKDSOPMIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkGpa3wWw4u2zzz5ptt9++6XZrrvuWnLdDTbYoNySUlOnTk2z7t27p1mp27AvzyqrrFL2vlSOk046Kc2OPfbYkvv+5z//SbNzzz03zSZOnLj8wgCAsmyyySZp1rRpeb/WPPnkk+WWA7BSceYRAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIFXePS1ZYXr27JlmJ5xwQpodc8wxadaqVas0q6qqql5hdaRXr171XQKN1BprrFH2vuPHj0+ziRMnlr0uAFD6Z9WjjjoqzS6++OI0a9q0vF9rnn766TQrFAplrbk8Dz74YJrdeOONaTZp0qQ0+/DDD2tUE5TStm3bNLvwwgvTbNNNN02zPfbYI80WLVpUvcKoU848AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKTKu6clK8zaa6+dZsOGDavDSmrPlClT0uzZZ5+tw0pYmbRp0ybNlnf7z/Hjx6/ocqBRGThwYJodc8wxafbWW2+l2YIFC9Lsr3/9a8l63nnnnTR76aWXSu4LrHitWrUqmd98881pttdee6VZoVAou6bM5ptvXqfHi4jYYost0uy73/1umpX6mbrUbc/ffvvt6hXGSuuwww4rmV9wwQVpts4665R1zLZt26bZrFmzylqT2uXMIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAECqqlDNe1BWVVXVdi31rlOnTmk2bNiwNHvggQdKrjtu3Lg022677dLs9ttvT7OPPvoozVZdddU0u+OOO9LsmWeeSbOIiIcffjjNnnjiiTT7+OOP06zU66gktXUr15pYGXp2zTXXTLM33ngjzR588MGS6+60005l10Rl0LM188orr6RZjx496q6Q/9+HH36YZs8++2wdVlI/3nzzzTS76KKL0mzSpEm1UU6t0LMNT9++fdPssssuK7nvNttsU9YxS/0sWurn7VLuuuuuNFtvvfVK7lvqZ9wPPvggzb71rW+l2Te+8Y00K/Xf11GjRqXZ0KFD06y26NmGZ+21106zUr/LRUR07Ngxzcr9ux49enSanXjiiWk2e/bsso5HadX5e3TmEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACDVtL4LqGvl3sZ+iy22SLMDDjig7HomTpyYZltvvXWaTZs2Lc3WXXfdNCt1O98lS5akGTREZ599dn2X0KBtt912abbOOuuUteaTTz6ZZlOnTi1rTSrPMccck2abb755mj3//PNpttFGG6VZqe+HERG77rprmpXqgzfeeCPNyu2RUhYvXlwynzFjRpp169atrGO+/vrraTZp0qSy1oSI0rebX17Plrol9COPPJJm++67b5rNmjWr5DHLcf/996/wNSMixo8fn2ZXX311mh155JFptrz3HE477bQ069ChQx1W8qlBgwalWb9+/dLsggsuSLPf/va3JY+5cOHC5RdGyplHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgFTT+i6gNjRv3jzNrrvuujTbYost0uynP/1pmpW63WZNTJs2raz9St2WFxqTffbZp6z9/vCHP6zgSmrPFVdckWbLe/3t27dPs1atWpVVz9y5c9PsV7/6VZr95Cc/Ket4NEx33XVXWVkp48aNK7eckv/Wt9xyyzR77LHH0qxPnz5l15NZsGBByXzq1Klp9vzzz6dZqVssv/zyy8svDBqQ/v37p9n7779fh5XUnr333jvNDj744DqshMame/fuaXbEEUeUve5TTz2VZu+++26a7bHHHmUdb/XVV0+z0047Lc3++te/llz3nXfeKasePuXMIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIGV4BAAAAEDK8AgAAACAVNP6LqBcq622WpqdccYZabbvvvum2cyZM9Psl7/8ZZrNnz8/zYCaad26dZo1bZr/J2z69OlpNnLkyJqUlCpVz9Zbb51mN998c5qtscYaadakSen5/4wZM9Js/PjxaVaq1nXXXTfNjj322DT785//nGavvfZamkF1vP/++2l29913l7XmXXfdVW45ZfvWt76VZu3bt0+zp59+Os1Gjx5do5og8+qrr9bKugcddFCaXXXVVbVyzNqw/vrrp9k111yTZqV+xynlscceK2s/Gpctt9wyzdq0aZNm9913X8l1d9lllzRr2bJlmh1yyCFpduaZZ6ZZz54906zUz8a33HJLmkVE7L333mk2e/bskvvizCMAAAAASjA8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUvl9pRu4/fffP81+9KMfpdnrr7+eZjvttFOazZkzp1p1ASvW0UcfnWZdu3ZNs9q6ne+aa66ZZqVuVX/22WeXdby33norzUaNGlVy38svvzzN3nzzzbLqufXWW9Osf//+adatW7c0e+2118qqBSpNly5dSualerZJk/z/95133nlp5tbD1JYrrrgizTbddNOS+37ve99Ls+HDh6fZvffem2ZTpkwpecxy9OrVq2R+6qmnptkxxxyzosuJ2267Lc3OOOOMFX48Kk+LFi3SrFAopNmvfvWrso+5YMGCNLv22mvT7KCDDkqz9ddfv6xa5s+fXzJfuHBhWevyKWceAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFJN67uAcu2www5l7ffEE0+kWbm3rgZqz1ZbbVXWfi+++OIKruRTZ599dpodd9xxaVbq9qj/+c9/0uzkk09Os2effTbNakttva+wMjjhhBNK5p07d06z999/P81eeOGFsmuC2nDuueeWzEt9b99uu+3S7Prrr0+zUr8bdOvWLc169eqVZqNGjUqziIgOHTqkWanv+2+88Uaa3XDDDWl23nnnpdmHH36YZqw8DjnkkLL222effUrmY8aMKWvdUnr37r3C15w4cWLJfN68eSv8mCsTZx4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUk3ru4ByDRw4sKz9+vXrl2bDhw9Ps1tuuSXNJk+eXFYtwPKtueaadX7MUrftHTRoUFlrXn311Wk2bNiwNFu4cGFZx6sPjz/+eFkZNCZf+9rX0uxHP/pR2evuv//+afbMM8+UvS7UhlmzZpXMS90W/N57702zzTffPM1KfZ/p1q1bmrVt2zbNCoVCmkWUfp2XX355mv36179Os/fff7/kMaGU66+/Ps3222+/NOvTp0/Jdb/61a+m2WabbZZmBxxwQJq1b98+zT744IOy9jvmmGPSLCJi1KhRafbcc8+V3BdnHgEAAABQguERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQalrfBZSrc+fOabZkyZI0a9GiRZqde+65aXb22Wen2ZVXXplmERETJ05Ms3XXXTfNXnrppTR79tlnSx4zs8kmm6TZQw89VHLfN998s6xjQk20adMmzaqqqmrlmP/3f/+XZu3atUuz6667Ls2+973v1aSkBqPU38eiRYvSbOHChbVRDjQ4/fv3T7NmzZqV3Peuu+5Ks+V9j4ZKctBBB6VZhw4dylqzV69eZe03ffr0NDv++ONL7jthwoQ0+/DDD8uqB2pi/PjxaTZnzpw022yzzUquW+o29oVCYfmFfYFStZ5wwglp9s9//jPNvvKVr5Q85kknnZRm3/3ud0vuizOPAAAAACjB8AgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEg1re8CyvXLX/4yzU455ZQVfrwmTfI52/Ju47m8vKGYMWNGybzU7UgHDx68gquBT5W6/We5twZdnm7dupV1zFL7VZI111wzzY466qg0+8c//lEb5UCD06pVqzTr169fmi1cuLDkusOHD0+zRYsWLb8wWMH22muvNDv66KPTbODAgbVRTq247LLL0mzs2LF1WAnU3OzZs9Ps4IMPTrMbb7yx5Lqrr756WfX89re/TbPTTz89zRYsWJBmpX7e/NGPflSynm984xtp1rNnzzR7+eWXS667snDmEQAAAAApwyMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBVVajmva6rqqpqu5YvZZVVVkmzrbbaKs2uu+66NGvatGmarbPOOmnWpMnKMYMr9U9lxIgRaXb++efXQjUNS23dMr4mGlrPluuBBx5Is759+6bZD37wgzT71a9+VfKYHTt2TLNnnnkmzdq1a5dm5513XppdddVVaTZr1qw0qy0TJ05Ms0022STN9txzz7LWrA96lpo499xz06zU98Nx48aVXLd///7lltTo6dnlW3PNNdPsu9/9bpodffTRabbGGmukWU3+TsaPH59md9xxR5o99thjaVbqluAbb7xxmi1atCjNSv38HxExY8aMkvnKTM9Wlj322KNkfuihh6bZBx98kGalvl/OmzdvuXV9kVatWqVZqd/1IyL222+/NPvLX/6SZkOHDl1+YRWuOj27ckw9AAAAACiL4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAg1bS+CyjXJ598kmaTJk1Ks169epV1vK9//etp1qxZs5L7jhgxIs369OlTVj31oaqqKs222WabOqyExmbNNddMs27dutVhJZ+aNWtWmm299dZpduutt6bZT37ykzTr169fmu27775p9uGHH6bZ8vY9++yz02yrrbZKs/PPPz/NJk6cWLIeqCT77LNPmp1zzjlpNnfu3DQ777zzalQTXHfddWm2++67p1nnzp3LOt5///vfNLvhhhvS7Je//GXJdV999dU0W7hwYZoNHDgwzdZff/2Sx8w0b948zXr27Fly3xkzZpR1TGhoxo8fX6O8Ln388cdpNnr06JL77rfffmm22267pVmHDh3SbPbs2SWP2Zg48wgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQalrfBVSKu+66q+x9t9xyyzTr06dPmi1evDjNrr322jS7+uqr0+z73/9+mh166KFpBrXprbfeSrMXX3wxzbp3755mpW5Z/Pvf/75kPfPnz0+zt99+O81K9fO+++6bZs8//3yatWvXLs0uvvjiNIuIOOqoo9Ks1Gs8//zz0+wnP/lJyWNCJenYsWOa/eY3v0mzVVZZJc1uv/32NJs4cWL1CoPE1KlT02zQoEEr/HilvgffeeedaXbAAQeUXLdHjx5pttlmm6XZVlttVXLdckyfPj3NSn1/Bhqev//97yXz/fbbL81K/Tf0xBNPTLPzzjtv+YU1Es48AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUoZHAAAAAKSqCoVCoVobVlXVdi2N1tZbb51mjz766Ao/3t13351mu+66a5rV5O/48ssvT7P/+7//K3vdSlHNNqpTjaVn11577TS77bbb0mzTTTdNswcffLDkMS+55JI0e/vtt0vum9lnn33SbPfdd0+zvn37ptny/o5feOGFNDvrrLPS7Oabby65bmOgZ1ceq6yySppNnDgxzbbZZps0e/nll9OsX79+Ze1HaXp2+X7605+m2QknnJBmbdq0SbNSr7Eh/p1kpk+fnma77LJLmr3yyiu1Uc5KoSH++2hoPUvd23LLLdPsgQceSLOWLVum2UYbbZRmU6dOrVZdDUF1etaZRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAIBUVaGa91F0a8PytWrVKs3++Mc/ptnBBx9cG+WkPvnkk5J5qduif/vb306zjz76qOyaKoXbkdaPbt26pdndd9+dZhtssEFtlFPntzQeOXJkyfz0009Ps1mzZq3gaiqLnl159OrVK82mTJlS1prf/OY302zs2LFlrUlperZm1lprrTQbPHhwmpX6Prv77rvXqKZMud9Lb7rppjS77LLL0mzOnDnVK4wvRc9SaU499dQ0+8UvfpFm//jHP9JsyJAhafbxxx9Xr7A6Up2edeYRAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIFVVqOZ9FN3asHZ07do1za655po06927d5p16dIlzaZNm5Zmo0aNSrOIiBEjRpTMV2ZuR9rwtGvXLs0GDRpUct8NNtggzY455pg0K9Wz5f4b+cMf/pBm5d5mHD3b2HTv3j3N7rnnnjRbd9110+wHP/hBml1yySVp1hD/bTUGDfF91bOQ07NUms6dO6fZAw88kGalfm/Ycsst0+ypp56qVl11pTo968wjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQKqqUM37KLq1YcMyZMiQNNtuu+3S7Mc//nGavffeezWqaWXmdqRQWfRs43LBBRek2RlnnFHWmttuu22aTZo0qaw1KZ+ehcqiZ2lM1l133TSbNm1aml1//fVpdthhh9WkpBWuOj3rzCMAAAAAUoZHAAAAAKQMjwAAAABIGR4BAAAAkDI8AgAAACBleAQAAABAqqpQzfsourUh5NyOFCqLnq0sO+64Y8n89ttvT7PVVlutrGNuu+22aTZp0qSy1qR8ehYqi55lZXHHHXek2fbbb59mffv2TbPnnnuuRjWVozo968wjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJAyPAIAAAAgZXgEAAAAQMrwCAAAAIBU0/ouAACglJ122qlkvtpqq5W17ssvv5xm8+bNK2tNAGDlMXDgwDR78skn02yDDTZIs+eee65GNdUWZx4BAAAAkDI8AgAAACBleAQAAABAyvAIAAAAgJThEQAAAAApwyMAAAAAUk3ruwAAgNpS6ja5X//619Ns9uzZtVEOANCIzJ07N83WW2+9Oqyk9jnzCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkDI8AAAAASBkeAQAAAJCqKhQKhWptWFVV27VAxapmG9UpPQs5PQuVRc9CZdGzUFmq07POPAIAAAAgZXgEAAAAQMrwCAAAAICU4REAAAAAKcMjAAAAAFKGRwAAAACkqgoN8T6KAAAAADQIzjwCAAAAIGV4BAAAAEDK8AgAAACAlOERAAAAACnDIwAAAABShkcAAAAApAyPAAAAAEgZHgEAAACQMjwCAAAAIPX/ASy/XnO4/lCKAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x500 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_images_raw = {}\n",
    "test_images_int8 = {}\n",
    "\n",
    "input_exp = scale_exponents['input']\n",
    "input_scale = 2.0 ** input_exp\n",
    "\n",
    "for digit in range(10):\n",
    "    for img, label in test_dataset:\n",
    "        if label == digit:\n",
    "            test_images_raw[digit] = img\n",
    "            \n",
    "            # Quantize NORMALIZED image (matching training)\n",
    "            img_np = img.squeeze().numpy()  # Already normalized!\n",
    "            img_int8 = np.clip(np.round(img_np * input_scale), -128, 127).astype(np.int8)\n",
    "            test_images_int8[digit] = img_int8.flatten()\n",
    "            break\n",
    "\n",
    "print(f\"✓ Test images prepared\")\n",
    "print(f\"  Input scale: 2^{input_exp} = {input_scale}\")\n",
    "print(f\"  Range: [{test_images_int8[0].min()}, {test_images_int8[0].max()}]\")\n",
    "\n",
    "# Visualize\n",
    "fig, axes = plt.subplots(2, 5, figsize=(12, 5))\n",
    "for digit in range(10):\n",
    "    ax = axes[digit // 5, digit % 5]\n",
    "    # Denormalize for display\n",
    "    img_display = test_images_raw[digit].squeeze() * 0.3081 + 0.1307\n",
    "    ax.imshow(img_display, cmap='gray')\n",
    "    ax.set_title(f'Digit {digit}', fontweight='bold')\n",
    "    ax.axis('off')\n",
    "plt.suptitle('Test Images', fontsize=14, fontweight='bold')\n",
    "plt.tight_layout()\n",
    "plt.savefig(RESULTS_DIR / 'test_images.png', dpi=150, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Deploy to ESP32-P4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "ESP32-P4 DEPLOYMENT\n",
      "================================================================================\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m: Initializing P4JIT System...\n",
      "07:03:13 [p4jit.runtime.jit_session] \u001b[94mINFO\u001b[0m: Auto-detecting JIT device...\n",
      "07:03:13 [p4jit.runtime.device_manager] \u001b[94mINFO\u001b[0m: Connecting to COM3 at 115200 baud...\n",
      "07:03:13 [p4jit.runtime.device_manager] \u001b[94mINFO\u001b[0m: Connecting to COM6 at 115200 baud...\n",
      "07:03:13 [p4jit.runtime.device_manager] \u001b[94mINFO\u001b[0m: Connected.\n",
      "07:03:13 [p4jit.runtime.jit_session] \u001b[94mINFO\u001b[0m: Found JIT Device at COM6\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m: P4JIT Initialized.\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m: [Heap Params]\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   free_spiram    :   31388992 bytes (30653.31 KB)\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   total_spiram   :   33554432 bytes (32768.00 KB)\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   free_internal  :     383843 bytes (374.85 KB)\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   total_internal :     464119 bytes (453.24 KB)\n",
      "\n",
      "Compiling kernel...\n",
      "07:03:13 [p4jit.p4jit] \u001b[94mINFO\u001b[0m: Loading 'mnist_inference' from 'mnist_inference.c'...\n",
      "07:03:13 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Generating wrapper for 'mnist_inference'\n",
      "07:03:13 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Building wrapper binary...\n",
      "07:03:13 [p4jit.toolchain.builder] \u001b[94mINFO\u001b[0m: Discovered 2 source file(s) in c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\source\n",
      "07:03:14 [p4jit.toolchain.builder] \u001b[94mINFO\u001b[0m: Build validation passed\n",
      "07:03:14 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Wrapper build complete. Metadata saved to c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\build\\signature.json\n",
      "07:03:14 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   Code Allocated: 0x48210AE0 (4428 bytes)\n",
      "07:03:14 [p4jit.p4jit] \u001b[94mINFO\u001b[0m:   Args Allocated: 0x48211C30 (128 bytes)\n",
      "07:03:14 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Generating wrapper for 'mnist_inference'\n",
      "07:03:14 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Building wrapper binary...\n",
      "07:03:14 [p4jit.toolchain.builder] \u001b[94mINFO\u001b[0m: Discovered 2 source file(s) in c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\source\n",
      "07:03:15 [p4jit.toolchain.builder] \u001b[94mINFO\u001b[0m: Build validation passed\n",
      "07:03:15 [p4jit.toolchain.wrapper_builder] \u001b[94mINFO\u001b[0m: Wrapper build complete. Metadata saved to c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\build\\signature.json\n",
      "07:03:15 [p4jit.p4jit] \u001b[94mINFO\u001b[0m: Function loaded successfully.\n",
      "\n",
      "✓ Loaded at: 0x48210AE0\n",
      "✓ Binary: 4372 bytes (4.27 KB)\n",
      "07:03:15 [p4jit.toolchain.binary_object] \u001b[94mINFO\u001b[0m: Disassembly saved to c:\\Users\\orani\\bilel\\git_projects\\robert_manzke\\project1\\trys\\costume_p4code_binary\\P4-JIT\\notebooks\\tutorials\\t02_mnist_classification\\source\\disassembly.txt\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"ESP32-P4 DEPLOYMENT\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "jit = P4JIT()\n",
    "stats_initial = jit.get_heap_stats(print_s=True)\n",
    "\n",
    "print(\"\\nCompiling kernel...\")\n",
    "p4jit.set_log_level('INFO')\n",
    "\n",
    "func = jit.load(\n",
    "    source=str(c_path),\n",
    "    function_name='mnist_inference',\n",
    "    optimization='O3',\n",
    "    use_firmware_elf=True,\n",
    "    smart_args=True\n",
    ")\n",
    "\n",
    "print(f\"\\n✓ Loaded at: 0x{func.code_addr:08X}\")\n",
    "print(f\"✓ Binary: {func.stats['code_size']} bytes ({func.stats['code_size']/1024:.2f} KB)\")\n",
    "\n",
    "# Generate disassembly file\n",
    "disasm_path = SOURCE_DIR / \"disassembly.txt\"\n",
    "func.binary.disassemble(output=str(disasm_path), source_intermix=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Run Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "INFERENCE ON ESP32-P4\n",
      "================================================================================\n",
      "\n",
      "Scale exponents:\n",
      "  Input: 5\n",
      "  Conv1: W=7, Act=4\n",
      "  Conv2: W=8, Act=4\n",
      "  FC1: W=9, Act=2\n",
      "  FC2: W=9\n",
      "\n",
      "Running inference...\n",
      "\n",
      "✓ Digit 0: Predicted 0 | 9,088,679 cycles (25.25 ms)\n",
      "✓ Digit 1: Predicted 1 | 9,075,661 cycles (25.21 ms)\n",
      "✓ Digit 2: Predicted 2 | 9,089,163 cycles (25.25 ms)\n",
      "✓ Digit 3: Predicted 3 | 9,089,631 cycles (25.25 ms)\n",
      "✓ Digit 4: Predicted 4 | 9,088,817 cycles (25.25 ms)\n",
      "✓ Digit 5: Predicted 5 | 9,087,929 cycles (25.24 ms)\n",
      "✓ Digit 6: Predicted 6 | 9,090,541 cycles (25.25 ms)\n",
      "✓ Digit 7: Predicted 7 | 9,089,545 cycles (25.25 ms)\n",
      "✓ Digit 8: Predicted 8 | 9,089,723 cycles (25.25 ms)\n",
      "✓ Digit 9: Predicted 9 | 9,088,219 cycles (25.25 ms)\n",
      "\n",
      "================================================================================\n",
      "RESULTS\n",
      "================================================================================\n",
      "✓ Accuracy: 10/10 = 100.0%\n",
      "✓ Avg cycles: 9,087,791\n",
      "✓ Avg time: 25.24 ms\n",
      "✓ Throughput: 39.6 fps\n",
      "✓ Cycles/inference: 9,087,791\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"INFERENCE ON ESP32-P4\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# Prepare exponents\n",
    "e_in = scale_exponents['input']\n",
    "e_conv1_w = scale_exponents['conv1']['w']\n",
    "e_conv1_act = scale_exponents['conv1']['act']\n",
    "e_conv2_w = scale_exponents['conv2']['w']\n",
    "e_conv2_act = scale_exponents['conv2']['act']\n",
    "e_fc1_w = scale_exponents['fc1']['w']\n",
    "e_fc1_act = scale_exponents['fc1']['act']\n",
    "e_fc2_w = scale_exponents['fc2']['w']\n",
    "\n",
    "print(f\"\\nScale exponents:\")\n",
    "print(f\"  Input: {e_in}\")\n",
    "print(f\"  Conv1: W={e_conv1_w}, Act={e_conv1_act}\")\n",
    "print(f\"  Conv2: W={e_conv2_w}, Act={e_conv2_act}\")\n",
    "print(f\"  FC1: W={e_fc1_w}, Act={e_fc1_act}\")\n",
    "print(f\"  FC2: W={e_fc2_w}\")\n",
    "\n",
    "scratch = np.zeros(65536, dtype=np.int8)\n",
    "timing_buffer = np.zeros(1, dtype=np.uint32)  # ← NEW: Timing array\n",
    "\n",
    "results = {}\n",
    "\n",
    "print(\"\\nRunning inference...\\n\")\n",
    "\n",
    "for digit in range(10):\n",
    "    # Reset timing buffer\n",
    "    timing_buffer[0] = 0\n",
    "    \n",
    "    predicted = func(\n",
    "        test_images_int8[digit],\n",
    "        quantized_weights['conv1']['weight'],\n",
    "        quantized_weights['conv1']['bias'],\n",
    "        quantized_weights['conv2']['weight'],\n",
    "        quantized_weights['conv2']['bias'],\n",
    "        quantized_weights['fc1']['weight'],\n",
    "        quantized_weights['fc1']['bias'],\n",
    "        quantized_weights['fc2']['weight'],\n",
    "        quantized_weights['fc2']['bias'],\n",
    "        np.int32(e_in),\n",
    "        np.int32(e_conv1_w), np.int32(e_conv1_act),\n",
    "        np.int32(e_conv2_w), np.int32(e_conv2_act),\n",
    "        np.int32(e_fc1_w), np.int32(e_fc1_act),\n",
    "        np.int32(e_fc2_w),\n",
    "        scratch,\n",
    "        timing_buffer  # ← NEW: Pass timing array\n",
    "    )\n",
    "    \n",
    "    # Read timing from P4\n",
    "    cycles = int(timing_buffer[0])\n",
    "    time_us = cycles / 360.0  # ESP32-P4 @ 360 MHz\n",
    "    time_ms = time_us / 1000.0\n",
    "    \n",
    "    results[digit] = {\n",
    "        'true': digit,\n",
    "        'predicted': predicted,\n",
    "        'correct': (predicted == digit),\n",
    "        'cycles': cycles,\n",
    "        'time_ms': time_ms\n",
    "    }\n",
    "    \n",
    "    status = \"✓\" if predicted == digit else \"✗\"\n",
    "    print(f\"{status} Digit {digit}: Predicted {predicted} | {cycles:,} cycles ({time_ms:.2f} ms)\")\n",
    "\n",
    "correct = sum(1 for r in results.values() if r['correct'])\n",
    "accuracy = 100.0 * correct / len(results)\n",
    "avg_cycles = np.mean([r['cycles'] for r in results.values()])\n",
    "avg_time = np.mean([r['time_ms'] for r in results.values()])\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"RESULTS\")\n",
    "print(\"=\"*80)\n",
    "print(f\"✓ Accuracy: {correct}/10 = {accuracy:.1f}%\")\n",
    "print(f\"✓ Avg cycles: {avg_cycles:,.0f}\")\n",
    "print(f\"✓ Avg time: {avg_time:.2f} ms\")\n",
    "print(f\"✓ Throughput: {1000/avg_time:.1f} fps\")\n",
    "print(f\"✓ Cycles/inference: {avg_cycles:,.0f}\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Visualize Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion = np.zeros((10, 10), dtype=int)\n",
    "for r in results.values():\n",
    "    confusion[r['true'], r['predicted']] += 1\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n",
    "\n",
    "# Confusion matrix\n",
    "im = ax1.imshow(confusion, cmap='Blues')\n",
    "ax1.set_xticks(np.arange(10))\n",
    "ax1.set_yticks(np.arange(10))\n",
    "ax1.set_xlabel('Predicted', fontsize=12, fontweight='bold')\n",
    "ax1.set_ylabel('True', fontsize=12, fontweight='bold')\n",
    "ax1.set_title(f'ESP32-P4 Results\\nAccuracy: {accuracy:.1f}%', fontsize=14, fontweight='bold')\n",
    "\n",
    "for i in range(10):\n",
    "    for j in range(10):\n",
    "        ax1.text(j, i, confusion[i, j], ha=\"center\", va=\"center\",\n",
    "                color=\"white\" if confusion[i, j] > 0 else \"black\",\n",
    "                fontsize=11, fontweight='bold')\n",
    "\n",
    "plt.colorbar(im, ax=ax1)\n",
    "\n",
    "# Timing\n",
    "times = [results[d]['time_ms'] for d in range(10)]\n",
    "colors = ['green' if results[d]['correct'] else 'red' for d in range(10)]\n",
    "\n",
    "ax2.bar(range(10), times, color=colors, edgecolor='black', linewidth=1.5)\n",
    "ax2.axhline(avg_time, color='blue', linestyle='--', linewidth=2, label=f'Avg: {avg_time:.2f} ms')\n",
    "ax2.set_xlabel('Digit', fontsize=12, fontweight='bold')\n",
    "ax2.set_ylabel('Time (ms)', fontsize=12, fontweight='bold')\n",
    "ax2.set_title('Inference Time', fontsize=14, fontweight='bold')\n",
    "ax2.set_xticks(range(10))\n",
    "ax2.legend(fontsize=11)\n",
    "ax2.grid(True, alpha=0.3, axis='y')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(RESULTS_DIR / 'results.png', dpi=150, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Final Report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "FINAL REPORT\n",
      "================================================================================\n",
      "\n",
      "📊 Model:\n",
      "  • Architecture: Conv(1→16) → Conv(16→32) → FC(1568→128) → FC(128→10)\n",
      "  • Parameters: 206,922 bytes (202.07 KB)\n",
      "  • Quantization: INT8 weights + activations + INPUT\n",
      "\n",
      "⚡ Performance:\n",
      "  • Platform: ESP32-P4 @ 360 MHz (RISC-V)\n",
      "  • Code size: 4.27 KB\n",
      "  • Inference: 25.24 ms/image\n",
      "  • Throughput: 39.6 fps\n",
      "\n",
      "🎯 Accuracy:\n",
      "  • Training (FP32): 98.46%\n",
      "  • Training (QAT): 98.78%\n",
      "  • On-device (INT8): 100.0%\n",
      "  • Retention: 101.2%\n",
      "\n",
      "🔧 Critical Fixes:\n",
      "  1. ✅ Bias scaled by E_in (not E_in + E_w - E_out)\n",
      "  2. ✅ Input quantization from start\n",
      "  3. ✅ Proper preprocessing match\n",
      "  4. ✅ Individual exponents passed to C\n",
      "  5. ✅ Smart Args for clean interface\n",
      "\n",
      "✨ P4-JIT Advantages:\n",
      "  • 2-3 second deploy (vs 30-60s firmware rebuild)\n",
      "  • No firmware changes needed\n",
      "  • Native RISC-V execution\n",
      "  • Seamless Python ↔ C workflow\n",
      "\n",
      "================================================================================\n",
      "✓ COMPLETE\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"FINAL REPORT\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "print(\"\\n📊 Model:\")\n",
    "print(f\"  • Architecture: Conv(1→16) → Conv(16→32) → FC(1568→128) → FC(128→10)\")\n",
    "print(f\"  • Parameters: {total_params:,} bytes ({total_params/1024:.2f} KB)\")\n",
    "print(f\"  • Quantization: INT8 weights + activations + INPUT\")\n",
    "\n",
    "print(\"\\n⚡ Performance:\")\n",
    "print(f\"  • Platform: ESP32-P4 @ 360 MHz (RISC-V)\")\n",
    "print(f\"  • Code size: {func.stats['code_size']/1024:.2f} KB\")\n",
    "print(f\"  • Inference: {avg_time:.2f} ms/image\")\n",
    "print(f\"  • Throughput: {1000/avg_time:.1f} fps\")\n",
    "\n",
    "print(\"\\n🎯 Accuracy:\")\n",
    "print(f\"  • Training (FP32): {history['test_acc'][WARMUP_EPOCHS-1]:.2f}%\")\n",
    "print(f\"  • Training (QAT): {history['test_acc'][-1]:.2f}%\")\n",
    "print(f\"  • On-device (INT8): {accuracy:.1f}%\")\n",
    "print(f\"  • Retention: {accuracy/history['test_acc'][-1]*100:.1f}%\")\n",
    "\n",
    "print(\"\\n🔧 Critical Fixes:\")\n",
    "print(\"  1. ✅ Bias scaled by E_in (not E_in + E_w - E_out)\")\n",
    "print(\"  2. ✅ Input quantization from start\")\n",
    "print(\"  3. ✅ Proper preprocessing match\")\n",
    "print(\"  4. ✅ Individual exponents passed to C\")\n",
    "print(\"  5. ✅ Smart Args for clean interface\")\n",
    "\n",
    "print(\"\\n✨ P4-JIT Advantages:\")\n",
    "print(\"  • 2-3 second deploy (vs 30-60s firmware rebuild)\")\n",
    "print(\"  • No firmware changes needed\")\n",
    "print(\"  • Native RISC-V execution\")\n",
    "print(\"  • Seamless Python ↔ C workflow\")\n",
    "\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"✓ COMPLETE\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13. Cleanup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "07:03:24 [p4jit.runtime.device_manager] \u001b[94mINFO\u001b[0m: Disconnected.\n",
      "✓ Cleanup complete\n"
     ]
    }
   ],
   "source": [
    "func.free()\n",
    "jit.session.device.disconnect()\n",
    "print(\"✓ Cleanup complete\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env_dl",
   "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.9.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}