diff --git "a/notebooks/01_baseline_fmnist.ipynb" "b/notebooks/01_baseline_fmnist.ipynb"
new file mode 100644--- /dev/null
+++ "b/notebooks/01_baseline_fmnist.ipynb"
@@ -0,0 +1,876 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Baseline: Fashion-MNIST\n",
+    "\n",
+    "**Goal:** prove the pipeline works before scripting it.\n",
+    "\n",
+    "**Plan:**\n",
+    "- Load **Fashion-MNIST** (`torchvision.datasets.FashionMNIST`) with train/test splits.\n",
+    "- Build a **3-layer CNN**: `Conv → ReLU → MaxPool → Conv → ReLU → MaxPool → FC`.\n",
+    "- Train for **5–10 epochs**.\n",
+    "- Track **accuracy** and **loss**.\n",
+    "- Produce a **confusion matrix** (10×10).\n",
+    "- Log training with **TensorBoard**.\n",
+    "- Save artifacts:\n",
+    "  - **Best model weights** → `checkpoints/baseline_fmnist_best.pt`\n",
+    "  - **Metrics JSON** → `reports/metrics.json`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import torch\n",
+    "from torch.utils.data import DataLoader\n",
+    "import torchvision as tv\n",
+    "from torchvision import transforms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "device: cpu\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATA_DIR = Path(\"../data\")\n",
+    "DATA_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "BATCH_SIZE = 128\n",
+    "NUM_WORKERS = 2\n",
+    "SEED = 41\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "print(\"device:\", device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "FASHION_MNIST_MEAN = 0.2860\n",
+    "FASHION_MNIST_STD = 0.3530\n",
+    "\n",
+    "train_tf = transforms.Compose([\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize((FASHION_MNIST_MEAN,), (FASHION_MNIST_STD,))\n",
+    "])\n",
+    "\n",
+    "test_tf = transforms.Compose([\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize((FASHION_MNIST_MEAN,), (FASHION_MNIST_STD,))\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 26.4M/26.4M [00:06<00:00, 4.36MB/s]\n",
+      "100%|██████████| 29.5k/29.5k [00:00<00:00, 334kB/s]\n",
+      "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.85MB/s]\n",
+      "100%|██████████| 5.15k/5.15k [00:00<00:00, 665kB/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "classes: ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
+      "train size: 60000 test size: 10000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_ds = tv.datasets.FashionMNIST(\n",
+    "    root=DATA_DIR, train=True, download=True, transform=train_tf\n",
+    ")\n",
+    "test_ds = tv.datasets.FashionMNIST(\n",
+    "    root=DATA_DIR, train=False, download=True, transform=test_tf\n",
+    ")\n",
+    "\n",
+    "classes = train_ds.classes\n",
+    "print(\"classes:\", classes)\n",
+    "print(\"train size:\", len(train_ds), \"test size:\", len(test_ds))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_ds_cifar = tv.datasets.CIFAR10(root=\"data\", train=True, download=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = torch.Generator().manual_seed(SEED)  # reproducible shuffling\n",
+    "\n",
+    "train_loader = DataLoader(\n",
+    "    train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS, generator=g\n",
+    ")\n",
+    "test_loader = DataLoader(\n",
+    "    test_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "batch shape: torch.Size([128, 1, 28, 28])\n",
+      "labels shape: torch.Size([128])\n",
+      "labels min/max: 0 9\n",
+      "dtype: torch.float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "xb, yb = next(iter(train_loader))\n",
+    "print(\"batch shape:\", xb.shape)\n",
+    "print(\"labels shape:\", yb.shape)\n",
+    "print(\"labels min/max:\", int(yb.min()), int(yb.max()))\n",
+    "print(\"dtype:\", xb.dtype)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# invert the normalization for visualization\n",
+    "def denorm(x):\n",
+    "    return x * FASHION_MNIST_STD + FASHION_MNIST_MEAN\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 5, figsize=(10,4))\n",
+    "for ax, img, lab in zip(axes.ravel(), xb[:10], yb[:10]):\n",
+    "    ax.imshow(denorm(img[0]).cpu().numpy(), cmap=\"gray\")\n",
+    "    ax.set_title(classes[int(lab)])\n",
+    "    ax.axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Random image saved to ../input/random_image_label_Ankle boot.png\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "from PIL import Image\n",
+    "\n",
+    "# Define the output folder\n",
+    "output_folder = Path(\"../input\")\n",
+    "output_folder.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# Select a random image from the dataset\n",
+    "random_idx = random.randint(0, len(train_ds) - 1)\n",
+    "image, label = train_ds[random_idx]\n",
+    "\n",
+    "# Save the image\n",
+    "output_path = output_folder / f\"random_image_label_{classes[label]}.png\"\n",
+    "image_pil = transforms.ToPILImage()(image)\n",
+    "image_pil.save(output_path)\n",
+    "\n",
+    "print(f\"Random image saved to {output_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SmallCNN on cpu\n",
+      "logits shape: torch.Size([128, 10])\n",
+      "params: total=50,186 trainable=50,186\n",
+      "prob row sum (sample 0): 1.0000001192092896\n",
+      "top-3 classes (sample 0): [3, 1, 2]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "torch.manual_seed(SEED)\n",
+    "\n",
+    "class SmallCNN(nn.Module):\n",
+    "    def __init__(self, num_classes: int = 10):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1)\n",
+    "\n",
+    "        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+    "\n",
+    "        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)\n",
+    "\n",
+    "        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+    "\n",
+    "        self.fc = nn.Linear(64 * 7 * 7, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = F.relu(self.conv1(x))\n",
+    "        x = self.pool1(x)\n",
+    "        x = F.relu(self.conv2(x))\n",
+    "        x = self.pool2(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        logits = self.fc(x)\n",
+    "        return logits\n",
+    "\n",
+    "model = SmallCNN(num_classes=10).to(device)\n",
+    "print(type(model).__name__, \"on\", device)\n",
+    "\n",
+    "xb_device = xb.to(device)\n",
+    "with torch.no_grad():\n",
+    "    out = model(xb_device)\n",
+    "print(\"logits shape:\", out.shape)\n",
+    "\n",
+    "total_params = sum(p.numel() for p in model.parameters())\n",
+    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+    "print(f\"params: total={total_params:,} trainable={trainable_params:,}\")\n",
+    "\n",
+    "probs = torch.softmax(out, dim=1)\n",
+    "print(\"prob row sum (sample 0):\", float(probs[0].sum()))\n",
+    "print(\"top-3 classes (sample 0):\", probs[0].topk(3).indices.tolist())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "loss_fn = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)\n",
+    "\n",
+    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode=\"min\", factor=0.5, patience=2)\n",
+    "\n",
+    "def accuracy(logits, targets):\n",
+    "    preds = logits.argmax(dim=1)\n",
+    "    return (preds == targets).float().mean().item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "import time, json\n",
+    "from pathlib import Path\n",
+    "\n",
+    "RUN_NAME = f\"baseline_fmnist_{int(time.time())}\"\n",
+    "writer = SummaryWriter(log_dir=f\"../runs/{RUN_NAME}\")\n",
+    "\n",
+    "CHECKPOINTS_DIR = Path(\"../checkpoints\"); CHECKPOINTS_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "REPORTS_DIR = Path(\"../reports\"); REPORTS_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "EPOCHS = 8\n",
+    "best_val_acc = -1.0\n",
+    "best_state = None\n",
+    "\n",
+    "for epoch in range(1, EPOCHS + 1):\n",
+    "    # train\n",
+    "    model.train()\n",
+    "    train_loss_sum, train_count = 0.0, 0\n",
+    "    train_acc_sum = 0.0\n",
+    "\n",
+    "    for xb, yb in train_loader:\n",
+    "        xb, yb = xb.to(device), yb.to(device)\n",
+    "\n",
+    "        optimizer.zero_grad()\n",
+    "        logits = model(xb)\n",
+    "        loss = loss_fn(logits, yb)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # stats\n",
+    "        batch_size = yb.size(0)\n",
+    "        train_loss_sum += loss.item() * batch_size\n",
+    "        train_acc_sum  += accuracy(logits, yb) * batch_size\n",
+    "        train_count    += batch_size\n",
+    "\n",
+    "    train_loss = train_loss_sum / train_count\n",
+    "    train_acc  = train_acc_sum / train_count\n",
+    "\n",
+    "    # eval\n",
+    "    model.eval()\n",
+    "    val_loss_sum, val_count = 0.0, 0\n",
+    "    val_acc_sum = 0.0\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        for xb, yb in test_loader:\n",
+    "            xb, yb = xb.to(device), yb.to(device)\n",
+    "            logits = model(xb)\n",
+    "            loss = loss_fn(logits, yb)\n",
+    "\n",
+    "            batch_size = yb.size(0)\n",
+    "            val_loss_sum += loss.item() * batch_size\n",
+    "            val_acc_sum  += accuracy(logits, yb) * batch_size\n",
+    "            val_count    += batch_size\n",
+    "\n",
+    "    val_loss = val_loss_sum / val_count\n",
+    "    val_acc  = val_acc_sum / val_count\n",
+    "\n",
+    "    scheduler.step(val_loss)\n",
+    "\n",
+    "    # logging\n",
+    "    writer.add_scalar(\"Loss/train\", train_loss, epoch)\n",
+    "    writer.add_scalar(\"Loss/val\",   val_loss,   epoch)\n",
+    "    writer.add_scalar(\"Acc/train\",  train_acc,  epoch)\n",
+    "    writer.add_scalar(\"Acc/val\",    val_acc,    epoch)\n",
+    "    writer.add_scalar(\"LR\", optimizer.param_groups[0][\"lr\"], epoch)\n",
+    "\n",
+    "    print(f\"Epoch {epoch:02d} | \"\n",
+    "          f\"train_loss={train_loss:.4f} acc={train_acc:.4f} | \"\n",
+    "          f\"val_loss={val_loss:.4f} acc={val_acc:.4f}\")\n",
+    "\n",
+    "    # Save best by val_acc\n",
+    "    if val_acc > best_val_acc:\n",
+    "        best_val_acc = val_acc\n",
+    "        best_state = {\n",
+    "            \"epoch\": epoch,\n",
+    "            \"model_state\": model.state_dict(),\n",
+    "            \"optimizer_state\": optimizer.state_dict(),\n",
+    "            \"val_acc\": val_acc,\n",
+    "            \"val_loss\": val_loss,\n",
+    "        }\n",
+    "        torch.save(best_state, CHECKPOINTS_DIR / \"baseline_fmnist_best.pt\")\n",
+    "\n",
+    "# close TB writer\n",
+    "writer.close()\n",
+    "print(\"Best val_acc:\", best_val_acc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wrote ../reports/metrics.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "metrics = {\n",
+    "    \"dataset\": \"FashionMNIST\",\n",
+    "    \"epochs\": EPOCHS,\n",
+    "    \"batch_size\": BATCH_SIZE,\n",
+    "    \"lr\": 1e-3,\n",
+    "    \"weight_decay\": 1e-4,\n",
+    "    \"best_val_acc\": float(best_val_acc),\n",
+    "}\n",
+    "with open(REPORTS_DIR / \"metrics.json\", \"w\") as f:\n",
+    "    json.dump(metrics, f, indent=2)\n",
+    "print(\"Wrote\", REPORTS_DIR / \"metrics.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collected: 10000 preds\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchmetrics.classification import MulticlassConfusionMatrix\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from pathlib import Path\n",
+    "import json\n",
+    "\n",
+    "FIG_DIR = Path(\"../reports/figures\"); FIG_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "model.eval()\n",
+    "all_preds, all_targets = [], []\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for xb, yb in test_loader:\n",
+    "        xb = xb.to(device)\n",
+    "        logits = model(xb)\n",
+    "        preds = logits.argmax(dim=1).cpu()\n",
+    "        all_preds.append(preds)\n",
+    "        all_targets.append(yb)\n",
+    "\n",
+    "all_preds = torch.cat(all_preds)\n",
+    "all_targets = torch.cat(all_targets)\n",
+    "print(\"Collected:\", all_preds.shape[0], \"preds\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved figure to: ../reports/figures/confusion_matrix.png\n",
+      "Updated ../reports/metrics.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_classes = 10\n",
+    "cm_metric = MulticlassConfusionMatrix(num_classes=num_classes)\n",
+    "cm = cm_metric(all_preds, all_targets)  # shape [C, C], row=true, col=pred\n",
+    "cm = cm.numpy()\n",
+    "cm_norm = cm / cm.sum(axis=1, keepdims=True)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 6))\n",
+    "im = ax.imshow(cm_norm, interpolation=\"nearest\", cmap=\"coolwarm\")\n",
+    "ax.figure.colorbar(im, ax=ax)\n",
+    "\n",
+    "ax.set(\n",
+    "    xticks=np.arange(num_classes),\n",
+    "    yticks=np.arange(num_classes),\n",
+    "    xticklabels=classes,\n",
+    "    yticklabels=classes,\n",
+    "    ylabel=\"True label\",\n",
+    "    xlabel=\"Predicted label\",\n",
+    "    title=\"Fashion-MNIST Confusion Matrix (row-normalized)\"\n",
+    ")\n",
+    "\n",
+    "# rotate x tick labels for readability\n",
+    "plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n",
+    "\n",
+    "# annotate cells with percentages\n",
+    "for i in range(num_classes):\n",
+    "    for j in range(num_classes):\n",
+    "        val = cm_norm[i, j]\n",
+    "        ax.text(j, i, f\"{val*100:.1f}%\", ha=\"center\", va=\"center\", fontsize=8)\n",
+    "\n",
+    "fig.tight_layout()\n",
+    "fig_path = FIG_DIR / \"confusion_matrix.png\"\n",
+    "plt.savefig(fig_path, dpi=200)\n",
+    "plt.show()\n",
+    "print(\"Saved figure to:\", fig_path)\n",
+    "\n",
+    "# save both raw counts and normalized values\n",
+    "np.save(FIG_DIR / \"confusion_matrix_counts.npy\", cm)\n",
+    "np.save(FIG_DIR / \"confusion_matrix_norm.npy\", cm_norm)\n",
+    "\n",
+    "metrics_path = REPORTS_DIR / \"metrics.json\"\n",
+    "try:\n",
+    "    with open(metrics_path) as f:\n",
+    "        metrics = json.load(f)\n",
+    "except FileNotFoundError:\n",
+    "    metrics = {}\n",
+    "\n",
+    "metrics.update({\n",
+    "    \"confusion_matrix_counts_path\": str(FIG_DIR / \"confusion_matrix_counts.npy\"),\n",
+    "    \"confusion_matrix_norm_path\": str(FIG_DIR / \"confusion_matrix_norm.npy\"),\n",
+    "    \"confusion_matrix_figure\": str(fig_path),\n",
+    "})\n",
+    "with open(metrics_path, \"w\") as f:\n",
+    "    json.dump(metrics, f, indent=2)\n",
+    "\n",
+    "print(\"Updated\", metrics_path)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working dir: /Users/stefanoracca/Desktop/projects/computer-vision-explainable-cnn\n",
+      "Using checkpoint: checkpoints/smallcnn_aug_fmnist/best.ckpt\n",
+      "Saved: reports/smallcnn_aug_fmnist/explain_direct\n",
+      "Saved: reports/smallcnn_aug_fmnist/explain_direct\n",
+      "Saved: reports/smallcnn_aug_fmnist/explain_direct\n",
+      "Saved overlays: ['reports/smallcnn_aug_fmnist/explain_direct/gradcam_top1_class3_Dress.png', 'reports/smallcnn_aug_fmnist/explain_direct/gradcam_top1_class4_Coat.png', 'reports/smallcnn_aug_fmnist/explain_direct/gradcam_top1_class8_Bag.png']\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAJOCAYAAAAUIdaGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXdxJREFUeJzt3QeYXFd9N/47OzvbtKtuFcsq7h0bGxMMmOLQQgu9mkBIcCAFCCUkIW9ICOUfyBuS0E0NLYRqSoCYJDg2GAO2sQ3uvUlWX7XtM/N/zvCukGzB78j3spbQ5/M8i/Dsd885c2fmnju/OfdOrd1utwsAAAAAKKGrzB8DAAAAQKLIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbItA/4m7/5m6JWq92nv/34xz/e+dtbb721+FVJbac+Ul8AMFPMjwDwc+ZF9geKTCVcddVVxVlnnVUsW7as6O3tLQ4++ODihS98Yed27r0znP4ZGBgoVqxYUTzlKU8pPvaxjxXj4+P39xABqJD5ce9cfvnlne21fPnyzvaaP39+8ZjHPKYzRzabzV9Zv+973/u8EQCYAebF+/a+saurq1i6dGnx5Cc/ubj44ovv7+GRqdZut9u5YX7uS1/6UvH85z+/cyD4e7/3e8Whhx7aqdx+5CMfKTZu3Fh89rOfLZ7+9KdntTU1NdX56evr2+txpIPPycnJzs7qvla1I+l+pfuXDnZf8pKX3Kedxd/+7d8W73//+4vBwcFOUemuu+4q/vM//7O46KKLigc84AHF17/+9c7BNQD7N/Pj3vnwhz9cvPzlLy8WL15cvOhFLyqOPPLIYtu2bcV///d/F//xH/9RvOUtbyn+8i//svhVOOGEE4qFCxcW559//q+kfQDMi2XeN7ZareKOO+4oPvShDxWrV68ufvjDHxYnn3zyr2TsVKe7wrYOGDfddFPnQPCwww4rLrjgguKggw7a+btXvepVxRlnnNH5/ZVXXtnJ/CI7duwoZs2aVXR3d3d+7ot6vd752R8861nP6hzMTvvrv/7r4tOf/nTxO7/zO8Wzn/3ssDo9MjLSWQUFwL7J/Lh30ryXCkynn3568Y1vfKMYGhra+btXv/rVxSWXXFL89Kc/vV/HCMB9Z16s5n3j0572tM4HI5///OcVmfYDTpe7D975znd2Ch7nnHPObjuKJL0YPvjBD3Z2BO94xzvutfTv6quvLl7wghcU8+bNKx7+8Ifv9rtdjY6OFq985Ss77aWDzqc+9amd1T8pl/K/7NzaVatWdZYUfve73y0e/OAHdyrdaaf1iU98Yrc+Nm3aVLzuda8rTjzxxE6lePbs2cVv/dZvFVdccUW4DVIV/Nprry3WrFlTlJGWif7+7/9+8YMf/KD49re/vfP2Rz3qUZ0dyaWXXlo84hGP6BSXpj/JTSuh3vSmNxVHHHFEpxKfVkD92Z/92b1Ou0vtpW08d+7czv07+uij7/Vp8Lvf/e7i+OOP77SfHpMHPehBxWc+85lS9wngQGV+3Lv5MX1am8aYPnDZtcA0Lc1Ju34SnLbda1/72p2n1aV57R/+4R+Key5KT58gn3nmmcWiRYs6ueOOO67zqfCu0rZIp2n87//+787TEtLcC0B1zIvVvG9csmRJ599dC2wTExOdRQunnnpqMWfOnE4RLhXtvvOd79zr79OKsVTMS+NO7w1f/OIXd8bu+lG/GlYy3Qdf+9rXOi/I9CTek1QUSb9Py9zvKa3YSUvh3/a2t93roHBX6aDyc5/7XOfF8JCHPKRzEPikJz0pe4w33nhjpwKclmSmF9FHP/rRTpvpRZiKKsnNN99cnHvuuZ0xpWWNa9eu7ezoHvnIR3Z2aulc4V8k7biOPfbYTttlX5jpPqYd73nnnVc89rGP3W1nkHZez3ve8zrnMKdTCdKSybTjTDvCs88+uzOGn/zkJ8W73vWu4vrrr+/cnyQdOKcdZjoV781vfnPnIDttk+9973s720/LLtMOOW2n9EnC2NhY51OEVPBKO3QA9o75MX9+TG860ilxaZuk6xRG0jZJ8186eE5jT5/kptPOX//613f6TPPgtFRQSvcl5dMBeXpc/vAP/7Azh/7RH/1RJ/NP//RPxZ/8yZ903iy88Y1v7NyW5lkAqmNevG/vG1NRK0nzVvr7v/u7v+sUwJ7znOfszGzdurVzynk6FfFlL3tZ51TzdAri4x//+N1Oq0ttpGsBp9te8YpXFMccc0zxla98pTMefkXSNZnINzw8nF7h7d/+7d/+pbmnPvWpndzWrVs7//2mN72p89/Pf/7z75Wd/t20Sy+9tPPfr371q3fLveQlL+ncnvLTPvaxj3Vuu+WWW3betnLlys5tF1xwwc7b1q1b1+7t7W2/9rWv3Xnb2NhYu9ls7tZHaifl3vzmN+92W2ov9XXP21784hf/0u2w6/1bv379Hn+/efPmzu+f/vSn77ztkY98ZOe2D3zgA7tlP/nJT7a7urraF1544W63p1zKf+973+v897ve9a5f2meSHsPjjz8+HD8AMfPj3s2PV1xxRSf3qle9qp3j3HPP7eTf8pa37Hb7s571rHatVmvfeOONO28bGRm5198//vGPbx922GG73ZbmwDTfAlA98+J9f994z5+5c+e2v/Wtb+2WnZqaao+Pj9/rfeXixYvbL33pS3fe9sUvfrHTxj/90z/tvC3dlzPPPPNeY6UaTpfbS6lCmuxpWfuupn+fKqy7StdeiHzrW9/q/Js+ddxV+sQxV1oav2vFPC3PTMvqUxV6Wlrdk67YP30huLRyaPq0sssuu+yXtp8q7qmiXsXywtTnrtt21/H97u/+7m63pfNwUyU8VaA3bNiw8yedFpBML49MyyCTVKVO1es9SZk777yz+NGPflT6PgAc6MyPezc/Tt//aHtNS9dsStfSSCtwd5VOn0v9ffOb39x5W39//87/v2XLls48mT5tTvcx/TcAv3rmxfv+vvGLX/xi59In6UyXdAr4UUcdVTzzmc/sfGnUtDQn9vT0dP5/er+XVj+li6KnU813HVPaRo1Go7PaaVq6L9Mre6meItNemt4J3LMgkrtTScsLI7fddlvniX/PbLoGUa49Lb1P5/Nu3rx553+nF2NaXp+WYaYdRzqPN+1U0iljM3kQun379j1uq/QVn9M7jmk33HBD51S4NM5df9KOJ1m3bl3n3+c+97nFwx72sM71ntLy/3TKXVpGumvB6Q1veENn55jOP07bIO1odj2dDoB85se9k64LkbO9dr3v6XSEe2639MHL9O+npbnsMY95TOf6FOkDlTT26WsSKjIBzAzz4n2XTiNM81i6lEo6dS+dXp62zz2LZ//6r//auTxKOpVuwYIFnTGlUw93HVPaRkuXLr3XF0jtzTZi7ygy7aV0UbH0JE0vqF8m/T4VSaYPIvf06eKv0i/65oBdz+dN5/e+5jWv6byIP/WpT3Wu7ZAqxunc21+0+udXYfqbc+75Qt/TtkrjShecS+Pc0890FT/9bfoGh//6r//a+Y0NqfCUdlSp+j59YH7dddd1vjY0XUwvVczTv+mi4gDsHfPj3klzXrpeUrquYNXfZPSbv/mbndVL//iP/9g52E5j/9M//dPO72dyfgc4kJkXq5MWBvzGb/xGZ4VSulB6ksaRClCHH35451pMacVSGlM6w8Vcd/9y4e/7IF1QOl00Ol18evpK/7u68MILO1ft/4M/+IP71P7KlSs7L4xbbrmlUy3e9aJsVfrCF75QPPrRj+68KHc1PDy821dG/qp98pOf7PybLtIWSTuR9E0A6QD6nt+scE+pqp9y6ScdaKedY7q4aTqlLlXGk/Qpbyo+pZ/0DQXPeMYzire+9a3FX/zFX3Qq4gDkMz/mS5+opgPh//mf/ynuuOOOzjfGRfc9fXCSPvHe9dPu9I0907+fvshs+rbVr371q7t9Or2nb9uJ5lEAyjEvViedCjd9Fkx6D5fGlL4J70tf+tJu89k9FwykbZTmwPSFG7uuZqp6G/FzVjLdB+mbXFJlOe0M0vmou0rngqbzZ9MTOOXui+liy/ve977dbn/3u99dVF21vuc3FaRrHqUr+M/EV1Emn/nMZzrfCnD66ad3ikGR9I0CaXxpZ31P6es7pyvb099IsKvpbxhIB9/JPR+7dGpeOic5bZN0/wDYO+bHvZsf04Fw6ietuJ0+dXxXl156aedUgOSJT3xiZyXue97znt0y6fSFdHCdvo11euzJruNPpw2ka1rcUzpIT28QAPjVMC9W874xbat0PaYlS5YUixYt2jmmZNdxpW8J//73v3+vbZTGsOv7x1SYe+9733ufx8MvZyXTfZCqxOmg74UvfGHn1K30dY/pPNhUhU7V3bRE/d/+7d86q27ui/R1kenCZunrhdPOaPqrKK+//vpKP3lMlfU3v/nNnYtrP/ShD+0s2f/0pz/dqQhH7stXUaZqc1rqmFYMpb9PyyzTdSNOOumkzk4qRzoQT9dWSjvkVJFO111KB91px5VuT22mi72l+5VOl0tf35mq1+laTWnne8ghh+z8FOFxj3tcZ0eV2kjXbbrmmms6B+/pb3IvxArAz5kf925+TG2ng9x0qnf6Qos0x6VtmFYrnX/++Z3VSG95y1s62fT1y+lT5LQiN23PNHemC6KmL7h49atfvXObprktfWiS8ulNTSpepQPrdFB+zwP8tD3f//73d/pIp++lzPQXaQBQnnmx3PvGVEBavXp1Z1ula0R94AMf2Hmf0pjSKqanP/3pnfdvaTVX+n1aNLDrBzdPe9rTOtfgTV+UkVYvpfk2za/TixKs6q2eItN99OxnP7vzBH3729++cweRLjaWDgDTxTVPOOGEUu1/4hOf6BRA0k7ny1/+cuf0rn//93/vXMG/qtO40jjTyp+0mii1fcopp3Su3fDnf/7nxa/CK17xis6/afxpWWVaWfTRj360eMELXtC5gFyOdArcueee2/nkNm2jtG1S9T/t4F71qlftvAD4U5/61M7OO7WfHpvUX/pmnb/927/tnB+dpIPvtHNMp9KlHVEqQKVv7fmrv/qrX8n9BzgQmB/3TpqLTjvttOL//t//27lv69ev7xxYpz7T6qOzzjpr5/yXDor/+q//ujOm9Lv0jT3vfOc7OwfO09J2SAfnaS573ete19lWaf5NF0N96Utfulvfqa10QdR3vOMdncJWmicVmQCqZV687+8bp1fdpot7p0uapG05LV2P6e677y4++MEPdhYapOJSuk5TWryQPqiZllY8pbGm94qp4Jfm01SYSquJ02IDl0ipXq19z3Vv7LMuv/zy4oEPfGDnxZOq4QCA+REAdmVejKWFC6nYlK6XlYpNVMc1mfZR6fpC95SWQabKa7qqPwAciMyPAPBz5sW930bpcivpulXpG/3Sqiyq5XS5fVRaup4u+JmWUaavOP7mN7/Z+Tn77LPDb6ABgF9X5kcA+DnzYuxP/uRPOoWm9GVT6Uug0rWc0oXE07ePpwuzUy2ny+2jvv3tb3euH3T11Vd3rheUvoY4XRA0XfAz7TwA4EBkfgSAnzMvxtK1pNK1D9OFv8fGxjpfdpGu+/THf/zH9/fQfi0pMgEAAABQmmsyAQAAAFCaIhMAAAAApSkyAQAAAFBa9pXAHtv17PK9kaX9sJOzcrVmKw5dfGXcTm9vPKbx8bivrnqcaTXjZh5wTNxOJxjXSFuXX53XFr/Ut1ufv7+HAPuEA34urNXizAxf6rF71YowM3za0kr66oqnsKKdsYn6103EfX0vnr9z51WqYS6Enzng50I4gH07Yy60kgkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0rrLN0HV6tvGsnJbjp0bZoYujttpT04VlWg1K2lmfNGsrFzf6m2V9AewX+uqx5l2q5q+2u1ipqx5zUOzcu0zhsPM9nXx/e/eEh8S9W6qhZlGxtS05uG9YWbBnx8WN1QUxfy/6gkz7R9fFWZq3fH9bzeb1TxHarV96rkGAFTHSiYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKC07vJNULXWlddm5QaHTq6ow2axL5maVc/KtW667Vc+FoB9XlX78FotjvT2hpn2+HiY2fzi08PM2IO3F1nG40OZ2nj8mVrPcHz/J+a2w0yrEbczcFc8nq3L+oocff9fvJ36Hx+3027Gz6NadyNuZ2oy7gwA+LVlJRMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBad/kmqFrXycdl5W59dTPMrPhesd9Zc3o9K3fkDSvDTPPq6ysYEcABoBZ/7tSenKqkq95trTDTnMybC1o7GmGmb0PcVn087qvnzlqYmZwVt9O7pR1mdozF9yvZ3OgPM3EiPbjxmNpTk5W0U9Rq1WRy+wMAZoyVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACU1l2+Caq29iFzsnI9jeEwM/yi08PM3E9+v6hCfW487pv/9Pi4oRUjWf1tOX5emBm8OqspgP1XrRZn2u0402oWM2XbsnqYmfe/fVlt1TKGvfUJ28PM9nX9cUOzJ8NId088oK5LZoWZed/tjcdTFMWOZRnb6SEPiDMXX1nN8yjn+Vjr2qeejwBAdaxkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASusu3wRV65rMy43/YF6ciSPF+pefHmZ6t7bDzPARcc1y1l1xO9t6+oscU31ZMQAqMvGE08LMugc2wszUydvDTE/PVNaYWj+cG2Z6fzAYZv7sZV8KM7835+4w87u3nxFmbvvIUWFm7Wm9RY5mXzyv3vrkWWFm3hEPiTNfuSrMtLZtCzNF0YojtVpGO0VRtOP7D+yb6rNnh5nm1q1ZbdVOPT4O/fTGMNIeHy8OZN2HrgwzzYXx41abbIaZ1uVXZ4+L/YuVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGnd5Zugao3RdlZue18tzPSvi9tqNeK+RhbH9cje4bidWjPONHvz7v/cG0aycgDE6scfHWZufVo87/Stjvvq/cFgmNm+shU3VBTFP73042HmtV9+cZgZafWGmefc/Jth5g+XfifMvPIBJ4aZB//2T4ocPzo3bivHhgfGc++OpXFfB7/zokrGA+zfxp7y4DDzzn95b5j54NpHZ/XXVbs1zDxlfrxf/Z+tx4WZY/rXhJkbRheHmau2LA0zKwc3FTk2js8KMz9dE/dXr8dz7ztO+nyYmWzHZYbrxuLxbJiMjxeSO0bnhZk5jdFKtuP2yfh44c7huWGmnfGWd6h/PA4VRfHSQ+O59xmDN4SZR7/79UUVrGQCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABK6y7fBFVr1WtZuWZvO8xMzo7bqo+2K8k0++O+Wo0wUhSLxjNCRTE1EDfmCQ782mvH++cc6x46P8z0rY73843tcV/Nvjgz+8a8z8Hecv2TwkyrEW+jL971wDBzztGfDjOvueVZYWZ8QTyei247tMjRMxVnaq04M+vOeHtPzM4Y0EMeEGcuvjLO1PKOhYB9U++miTDzttufHGZOn39zVn8bJgfDzI9HVoWZRq0ZZm4ZPyjMLO/bFGau2bokzPz3hScVOdoZ75+OXLYuzJw4d3WYuWTHYWFmpNUTZvq6JsNMq503Fyzv3xxmThuMn0ufW3tamLnu+mVhptYfT84PPTIez4Pm3FrkGM94k33zVPyY1DKOKXJYyQQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJTWXb4Jqtau5+VaPe2MVC2jnTiTNZ6McTcmi8qMLGmEmdnVdQfwa23HsnguqGXsw9s5H19lTF/18Zw5riiarXjc866OM5vuPDjMfPuQY+J2PrAyHk93fN/Wzu8rcgxubVdyXDE5GG+j7h1xO2sfPBhmFl8ct1O08x5/YB/Vil/D2yZ740wzb1+4dSrOfeGKU8JMz0A80Z22/PYws7RnOMxsGY/HfNBx64sczVY8+a7eGr8zesqSK8PMldsPCTMr+zaFmQ9995FhpjGc98a4dnjGBHVkHFk5EI97zap4Oy6dtTXMrB+N58s1/XOLHPWiFWZu6F4SZvrXVzP3WskEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACU1l2+Cao2sriWlas140x9tB1mmv21SvrK0WrEmXp3XmcTg3nbCeBAVz/ysDAzNRDPF12TcV+1VrxvbuyI22k18vbx8/vHwszdT9gaZiZunB1mPnDdGWFmx8Pi7fiQU64PMy9fcFWR473LHxVmuj63IMyMzY/7aozEmYk5caZ7+SFhZuqOO+OGgH1W12R8PH/ivOpe5/31eILqarTCTDvehReX3Lm8kvH8yaHfCTNvvfq34gEVRdHXmAozT14Zzys3jC4OMwf1bA8z4+24zHD6STeEmSvuPrjI0WrFa2du2LYozDxl0RVh5o7BeWHm0ltWhJk/OSV+/Cfb9SLHbaMLw8zTZ60JM+/qLSphJRMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBad/kmqFqzt8K2+mthplWP26k340xXRqZdj8czNZ73tJyaFbcFQFGMHLkgzLS72mGmPhZ/NjW2qBVmum+N2+nZHo8nWdC3o6jCHa3ZYWbH7XGmeySem676wrFh5vvHHVHkaAyNh5mepfGY2hlTb9dkUYnh0w8JM4N33FlNZ8D9oxnvw/vr8U6lXovnlE6uiHOvP+W8MHP1yMFhplGL3/ScOCveh31p/Slh5neO/EGR49ItK8PMZDt+07djKn4jeuJAfN9un4iPOx4278Yw86j514WZTn/jcX+nD94QZv5t3UPCzJnzrw0zp865vZLn0dfWPKDI8bjF14SZyaI5Y/O8lUwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlNZdvgmqVmvm5erjcaZVz2hnIs60M9rJ0erJ6Gs072k5MVR+PAAHgi2HNsJMrdUOMz1b4r4ap8ahbV1zwkzvZbW4s6IobvnIUWFmYEM8sc6fE9//DQ+MxzP75jjT2NEKMyOnTcYNFUVx0Bf7w8z6U+L7NjUQZ3o3xZ9N1qbCSNH2ESf8+st4nddr8b4w13grnuduGlsUZg7rX19JX2+/4glh5hGrbgozk62890UPmxu39dW7HxBmbrrroDDTe2y8o+/PeIN5a3NhmJnMfBP6kMH4/v/p5383zCx64Now84h58Xw5WB8LM/+7KT5+ufmmxUWOL4z1hZmXz7syzGQ+3UKmeQAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoLTu8k1QtXY9L9c1UYszzWr6a/bEmVpGXznq2+qVbieAA92OZe0wUx+tVbLf7enOmAy64/E0e+PxJJNDcW5sQXy4U5/I6a0VJiZm1yrJDF40kDOgotnbquR4oT0v43GrVfPZ5OiCuJ2hSnoC7i+1yXifctGGw8LMilmbs/pb2rclzGxv9oaZehHPT9/bdHiYmfe1eB9+xl9dF2Yu27GqyHFc/11h5o6Nc+OGNsdv+m7eviDMPPqg+L7dNrowzKzs3xBmOm1NxG2t+vpomHnUk64KM9ubfWFmYffWMDMylfEGux4/H5OpZjyv1ov4WKDVKCphJRMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBad/kmqNrE3FZWrrEtrhE2e+J2as2iEu16RiajrNk1ldff+PKJvCDAr7H6gvlhptnfDjONbbUwM7Ikbqd23sIw0z8YRorJjEyurox5rj4e37dWT8Z23B5nxufG27p3c9xOMjY/nlgPujzeADuWxJP46EHxeHq2xZmpgTgD7N9qY5NhppGxc57fsyOrv/FW/La21Y73vXPqcX/rR2aFmXW/Ee/DF3XHO8x53SNFjgu3HhVmxrf0hZmuBeNh5rT5t4WZDZNDYWZuI75vkxmPa7Kl2R9mbvidRph5Sn0szHTV4vfqd04sCDNX33pwmCkynrPJsQvXhplGLZ7nW428/iJWMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKV1l2+CqrUXTOQFt/WFkVb3zFUac/pq9rfDTK2Z19/BB2+K2+rtDTPt8fG8DgH2Qc3Dl8WhWhzpHoszo33xPvzgj18VZla/+IQwMzlYZGnsqGZ+qrXiTHsgZ4KKZ9XukWrGnJ3LePzHFsahqVnx49+zJW6nXY/H071kcRxKY7p7bVYOmGG1eF8wt2c0zAzW847TN08NhJl5jXjne+fEgjDz6CU3hJnb52wMMz/YcXiYmZMzYRRFcf66I8NMfUu8812yPB53joWNbWFmw+RQmNnS7M/qb049fi4958E/CjM3jC4KM0f2rwszl21ZHmba4/Hxwukn3FjkWNY/HGbG2lNhJuNllMVKJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoLTu8k2wN7oPWxVm6o1WZf21euJMrVVNpl2PM83eONMzXCuqUuuOn+Lt8fHK+gOYaWOL+8NM9454v1ofa4eZdsb81Ny2LczMursZZjaekDGppPs2Us1cONUXb6NaVfNzxjQ31Z83F+bMq7N/fHeY2XbIsjAzeshUmGmvaxRVaC5flBe8e20l/QHVavfGx+CrBjaGmVbODrMoiolW3F9vLd6H3T0xO8ws6x0OMyv6N1Vy3zZPzSpy3HrHQWFm1Ulrwsy7jvhcmPny1lPCzB1j88PM7O6xMNNq5z3+9Yw3qzltNWrx8clAV/ze8bYt8f1fvHxzmHnjsm8UOT608Yww8+Px+LnUqmYKt5IJAAAAgPIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAorbt8E+yN5vzBODOZV/vrqrcrGFFRtBq1uK/JjHZ64vG0+ltxQ8P1OFMUxUH9O8LMxLIlcUPX35TVH8C+aNsh8T6z1YjbGVsYzwX1OfFk0L1yeZjp3dIMM63e3M/BqpnD2hnd1Tb2VNNOxlTYNZU3x0/Mje//1C23hZklF8bHJ1sf1Btmmr3xk60Vb8ZicnZGyIEs7LPaPfGrc3sz3qf0Fxk78JTrmiiqsKRna5gZydiJ3TqyIMysGtgYZpb1bi5yPOb4a8LMqUO3hplPb35ImPnajSeEmVULN4WZJy3+aZi5aeygIkdzKp58B+rxc2T12NwwM9mOj7sesfTGMHNY//ow8y/rzixynHfpiWGm9yFTYWZysJr6gpVMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAad3lm2BvTMztDTP1RjOrrVZFj14to7t2RqYZ37WiPRA31K7X44aKohjonggzo/NnZbUFsL/qmoozrZ52mBlb0gozC+bsCDNTt94eZrqXzgsztclGUZVWRlO1Wpypj8ehdj2jofjhKGoZmaQrngqz1K67JcwcuWx+mLll9fIw0874iHN8Xt5BjgNZ2Dd1jU6GmR+tXxFmxiby5oLFQ9vCzJMW/zTMXDOyNMycOnhrmFk2f3OY2TA5FGau3H5IkaPVjueeLc2BMPPNW48LM+0bBsNMvIWKYmxRvAfvzTnIybSosTXMHN67Nsxcsv3QMDPVjt/Pfn/48Oruf8Yxw+KM+99uZB58BKxkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKC07vJNsDemZtUzUs2stlo97TBTa9bCTLset9Ou1yoZT3ffVEZfPUWOocZYmLl7sBFm4gTAvqt7NGMuiHe9Rasvbmf0woUZI7o+bmdpX5hp50yXnbknI1Ov5lO3qf54G031xfNlrVVUMu8mzXhTFl0nHRtmWldcE2auvz1up5axjbom4vs2cFc8xwP7tzm98ev8oIEdWW0dObguzIxkTBgr+zaGma+tOynMXHXX0jDz2pO/HWbq/RkTRlEUPxpeGWY++L9nhpm3PfZzYea7y48KM8fOWh1mNkwOhZk59dEix3g7Lmt86ANPCTMLnnpnmHnK0ivDzLqJ2WHmok+cEmb+v1d9pMix+PStYeasOT8JM+/pflxRBSuZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0rrLN8HeGFlYDzPNybzaX3ugFWa6RuK2Wt21MFNrZgyo3g4j3Y24odpERl9FUczuHgszYwsaYSZOAOzD4l1v0dgezwXNoXj/vPTi0aIKOxbF46mPxXNT0so4kqllbKOujLmnayqjr3hqzppT23l3P2tMdz98XphZdEXczpzLesPM1qPiO9fYET/+tXbGgwbss1p98c75NxbcGmZ6axk7uaIoNk7OCjM3jiwKM8cP3hVmXnrwhWHmX970vDDzjpc+Psx88uEfLnJ84JJHhJnu+eNhpitjEuvuivfz4634HdZFGw4LM73deY//Bw/9Qpj55NEPDzONTy8LM8e88T/DzFdWnxRmxh+xLcxsbA4WOa7dtjjMrJ4bvybbjYyDmAxWMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKV1l2+CvbHpAe3qGutphZH2VC3ONDMy9YxxD02GkTmzRsPM1mIo7qsoit6uqTAzMRjfN4D9Was73s81ezL24e24nZ6b14eZeM9cFKOL4r4ydvE/M4O7+VYj3o7trmrGXB/LG1NObsch1Rx7zL0pnudHHjYeZmp3D4aZ8fm9WWPKSwEzrdaM9zvfufuoMPPoJddn9ddfj/dP/3nbsWFm/YJ4/7Tq4A1hZuvrt4WZ9p1zw8xV44cUOZ7xgB+HmRNn3Rn3Nxr318o4Xphs18PMDXcuCjM9/fHjmvxB8aww86eP+laYedesx4SZ7+84Isz89sFXhJmBQybCzDWjBxc5DhkYLqpQH61mDZKVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGnd5Ztgb9QPGgszUzsaWW01hsbDzOREX5hp19thptVdCzP1RivM9HVPhZkt9SLL+onBMDOyJB73grzuAPZJ9cl4H941mfGZUne8D5+6a008ntmzw8zkUDzmvo3x/jvpmogzU/0ZDWV0V2vFoVq8GYuuyYrGnLZ3fFhR1OKpt6gfdXiYGfjudWGm+YK4ne6Mp+PkrLzPQXuzUsBM61o/HGZ6uzMP+jNcv31RmBnd0RNmbqrF7ww+U/+NMPOiVT8MM2sOnhNmfrpjWZGjtyve0X913UlFFQ6dtTHMXLtjSZjp7o3HPL41by9/a8+8MLN2Tnx88oKT48dtS8YE3VXExznf3XpE3NdE3sHAyfPuDDMXjx4WN7Q046Aig5VMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAad3lm2BvDAyMh5mtY3kPy9CssTAzPFUPM62iEWbaPbUwM9A3GWYWDWwLM3fHQ+44uHdLmJmY285rDGA/NTEU759bjXhf2NXbjDtrxZnNTz4uzNRacVe1jOEk7Yw5I6e/ImO6aPXGDbUa8ed3tXY196uTyzhkqI/Fz5GpBYNhpnb9TWGmNREPfGpWvAGm+n0OCvuqroGBMLPj5GVh5s2HfijMDDfjvpI3LPhxmLkmHlLxvzuOCTPbmn1h5qEDN4SZxUMTYWaoK28yGKj1hJkXjT42zLz1kK+GmcX1eOJpZkyqWw6OJ/p/Xv+IIseVw/GDu3Z8dpg5dejWMHNc311h5sTGSJj5kx1PDDOPO/jSIsfD+uP5+fie/jDz9zviukAOMzgAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBad/km2BvL5mwJM1s3zcpqq1FvhZme3qkwMzYaPw3aGePpbUyGmSV9W8PMj3tzesvTXBCPCWB/1rc53meOLow/U6rd1lfJeLauivvqiafCotbM66/Vk9FWu6L+ahmReGou2rUK7389o7+MzMiy+PHPOTrpvSN+QOpjcTs92zM3ADDjWiccXkk7b3/q8+JQd96aiPdnZNoZbXVtGYkb2hxPYj+oHxJmat0Zb8VrGRNGum8D8T68PdAbZl655YVhprVhUzX3rR1PmK3RjAkjzSuttWHm9qn4feEd3cvCzLld8WPbNXdOmGmuXRdmvjyU91r7cnNVmKn1NMLMUcM/ijv7vThiJRMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBad/km2BtHDK0PMzcOLMxqa8XszWFme/9ImLlhclGYmdrRCDPzB0bDzHEDq8PM1wdbRY7FjS1hZvb8HVltAeyvaq12mBldNRlmGuurOSSYGojH0zVZCzO1vKmgaNXjTDsj0xVvoqLobcbjacTbsVbhR3y1eEhFLX5Iik3HxhtpVsZ46mNxZuSweGPPWp33fBzISgGV+uFPwkhvRjOZu/kZlbFL/bW2Lz4mM6k9OVFJO8216yppp7VtW1GZuCxQGSuZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAACitu3wT7I3xVrzJe3qaWW1tn+ytYERFMTAwHma27miEmUZXPO4tzYGiKmsn54SZRUPbK+sPYF805wd3hZl21yFhpm/jRDFT6mNxppY3FRZd7TjTbmWMKZ4Ki2Iq/myukTHttOtxppWRSbomMzIZ23Kqr6jEyi+tCzMjR8wLM7Ouip/XyVRWCgCYKVYyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApXWXb4K98eg514aZS9Yuz2rrtSv+M8yMtRtxQxnd/eVPnx5mBhvjYeYNC24IM/97/JFFVb5w9OfCzHOK0yvrD2CmTd1xZ5gZzMhk6arHmVocafZmdDWZN6R2RR+XtTPGvXjZ5jAzvHpRmGlsq2Yb5ea6pjIaqlXz+DevuzHM9F4Xd5UzZABg32MlEwAAAAClKTIBAAAAUJoiEwAAAAClKTIBAAAAUJoiEwAAAAClKTIBAAAAUJoiEwAAAAClKTIBAAAAUFp3+SbYG3/11eeFmVNOvz6rrd8/7/fCzNGvviLMrP39U+N2nn9dmLn8zmVh5mH//AdhZtOx9SLH77zw+2Hmke94bZhZXFyU1R/APqlWy8hU9JlSqxlGVnxzNB5Osx1mmgN5hyit7vj+tzMyje1TYWZ4x0FhZvkN8f3vGo/7atfzHrNasxVm6tvGMvqL595WxuOfo9bbG49nMt5GHRWNCQCohpVMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAabV2u90u3wwAAAAABzIrmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmQAAAAAoTZEJAAAAgNIUmfYRL3nJS4pVq1bd38M4oNjmAPsW++WZZ5sD7Fvsl2eebV6tA77IdMsttxR//Md/XBx11FHFwMBA5+e4444r/uiP/qi48sori33V1q1bi7/9278tTjrppGJwcLDo7+8vTjjhhOINb3hDsXr16j3+zXOe85yiVqt1Mnty/vnnd36ffj71qU/tMfOwhz2s8/vUV66vf/3rxROe8IRiwYIFRV9fX2dbv+51rys2btyY3QYAvzrmwp8zFwIcmMyFP2cupIwDusiUnuTpRfHJT36yeMxjHlO8613vKv75n/+5+K3f+q3iG9/4RnHyyScXt912W7Gvufnmmztj+7u/+7vOju/v//7vi3/5l38pHv3oRxcf+chHikc96lF73Pl87Wtf61Ro/+3f/q1ot9u/sP30gv/MZz5zr9tvvfXW4qKLLur8PlfaaTzlKU8p7r777s5O7D3veU9nW6d/047wuuuu24t7DkDVzIV7Zi4EOHCYC/fMXMh90j5A3Xjjje1Zs2a1jz322Pbq1avv9fvJycn2P//zP7dvv/32X9rO9u3bKxnPi1/84vbKlSvDXBrXSSed1B4YGGhfeOGF9/r9li1b2n/5l395r9s/+tGPthuNRvt//ud/0l6kff75598r853vfKfzu2c84xnt7u7u9vr163f7/Vvf+tb24sWL2w9/+MPbxx9/fDjWz3zmM532nvvc57anpqZ2+90PfvCDzn048cQTO/dpJk0/ZrnbHODXlbnQXGguBA505kJzobmwWgfsSqZ3vOMdxY4dO4qPfexjxdKlS+/1++7u7uKVr3xlsXz58t3O1UxLEG+66abiiU98YjE0NFS88IUv7PzuwgsvLJ797GcXK1asKHp7ezt/96d/+qfF6Ojovdo+99xzO5XyVPlN/375y1/OHvcXv/jF4oorrije+MY3Fg9/+MPv9fvZs2cXb33rW+91+6c//enisY99bKeqfeyxx3b++xf57d/+7c59+PznP7/b7amKnZZW1uv1rLGmZZvz5s0rzjnnnHv9zYMf/OBOBfsnP/lJ8YUvfKFzW1qemrbvyMjIvdp6/vOfXyxZsqRoNps7b/vmN79ZnHHGGcWsWbM6j8WTnvSk4qqrrtrt737ZY7Yn//AP/1A89KEP7SzhTEtNTz311J3jm/bIRz6yU23fk6OPPrp4/OMfn7V9AO5v5kJz4Z6YC4EDibnQXLgn5sL7rutAXhJ5xBFHFL/xG7+xV383NTXVebIsWrSo88R75jOf2bk9vfDSi+AVr3hF8e53v7uTSf/+zu/8zm5/f95553X+Jp2/+va3v7142tOeVvzu7/5ucckll2T1/9WvfrXz74te9KLsMadzcb/zne90XpBJ+je9QCYmJvaYT+cfpx1KWj45Le3A0gv1BS94QVafN9xwQ2fJY2on7eD2ZHrbpMciee5zn9vZwf/Hf/zHbrm0XdOSzmc961k7d0ppKWvaeaQdRVoW+n/+z/8prr766s4ONi3fzHnM9iQti33gAx9YvPnNby7e9ra3dSaVNEnsOqa07dN52T/96U93+9sf/ehHxfXXX1+cddZZWdsI4P5mLjQX7om5EDiQmAvNhXtiLiyhfQBKSwfTXX/a0552r99t3ry5sxxw+mdkZGTn79IyuvR3f/7nf36vv9s1N+3tb397u1artW+77badt5188sntpUuXtoeHh3fedt5553XazVmi98AHPrA9Z86c9t74h3/4h3Z/f39769atnf++/vrrO/19+ctf3uOyyM9//vPtr3/9652xTy8Lff3rX98+7LDDOv//kY98ZLgs8txzz+209a53veuX5mbPnt0+5ZRTOv+/1Wq1ly1b1n7mM5+5W+Zzn/tcp60LLrig89/btm1rz507t/2yl71st9zdd9/d2Ta73v7LHrM9LYu85+M4MTHRPuGEE9pnnnnmztvSY9fX19d+wxvesFv2la98ZWepbVVLZQF+lcyF5sLp35kLgQOVudBcOP07c2F1DsiVTOliZ0mqdt5TujjaQQcdtPPnve99770yqSp9T2kJ3bRUdd2wYUNneV26kNqPf/zjzu1r1qwpLr/88uLFL35xMWfOnJ35tFwxXagtd+xpad/eSEsgU3V3+u+OPPLIznK/X7Y08nGPe1wxf/784rOf/WznPqR/pyveObZt29b5Nxpr+v3045Gq+Kk6nC6ut3379p2Zf//3fy+WLVu2cxnot7/97WJ4eLgznrSdp39SNTt9ApGq8zmP2Z7s+jhu3ry52LJlS2fp5WWXXbbz9vTYTVf0py+Ul5ZrpnGmTyDSMk2AfZ250Fz4i5gLgQOFudBc+IuYC++7A7LINP0E3/UJO+2DH/xg58n6i76qMS2TO+SQQ+51++233945zzO9ANNOKu2I0jmaSXpCJtPfSJBezHs6Z3NX69ev71x5f/pneqxpieH0CzXHNddc09mZpa+YvPHGG3f+pJ1mWo44/UK+p0aj0Xlhp/NtL7jgguKOO+7IXhK56zaOxpp+v+sOJy2NTOcrTy//TPc77VzSWNLOZnrJZXLmmWfutuNPP2nZ6bp167Iesz1J2+QhD3lI57zo9FimNt///vfvfAx3XdKZHvN0znXyX//1X8XatWv3arkqwP3JXGgu/EXMhcCBwlxoLvxFzIX3XXdxAEoVx3RRt3ueO5lMn4t7z/M3p6ULn3V17V6bS9XKVHXetGlT56JlxxxzTKdqedddd3V2MK1Wa6/HeNppp+32NZlvetObir/5m7/ptJ12DunFvevF536R6Z1iuthc+tnTBePSub97knYeH/jABzr9pgua5VbVk3QRuSSdo/qLpPuXdma7tpteyOnrND/3uc91+k/n3KadS9rJTJvenun823TRt3tKO4/oMduTtGN46lOfWjziEY8o3ve+93WeI2mnmi4CeM+v7kzn8i5evLizfVM+/ZvGkr6GE2B/YC78OXPhz5kLgQOJufDnzIU/Zy4s54AsMiVpmeCHP/zh4oc//GHnivZlpCvhpwt7/eu//utuF3RLle9drVy5creK667SxdB2lZYs7voNBIcddljn36c85Smd5XjpyfsXf/EXv3RcacleehGkbw74wz/8w3v9/u/+7u86/fyinUlahpi+FeH888/vXERtbxx11FGdn/SNCemiaXtaHvmJT3yi8++Tn/zk3W5P31SQ/ibtaNJSw7RzSTuZaYcffnjn33TBtipfvGnHmirV//mf/9nZAU1LO5N7Sksw087u4x//eGfbpPv5spe9LPsbFgD2BeZCc+E9mQuBA4250Fx4T+bCktoHqHSRs4GBgc6FytKFwe7p5ptv7lwY7J3vfOduFwRLF/C6pyuvvLKT/fjHP77ztnSxsic96Umd2z/2sY9VdoG3dMGxE088sTOOiy666F6/Txdx+8u//MvO/7/wwgs77X7iE5/YY1tvfetb211dXe277rrrXhd42/VCbW9605vaq1ev3nlbzgXekk996lOd9l7wghe0p6amdvvdJZdc0rkP6eJp6T7t6tJLL+383b/8y7+0e3t723/2Z392rwv0pQvDpXHc82+TdevWhY/Z9O923eavec1rOs+JHTt27Lztlltu6dy2p5fKZZdd1rn92c9+duffNG6A/Ym50FxoLgQOdOZCc6G5sFoH7EqmdP5rquami4Sl815f+MIXdpb+pSrvLbfc0vldWkqXc85mWqqYqqive93rOksh0/mxqfqZLhB2T+nrKVO1PFWDX/rSl3aWUqavtDz++OP3eC7wPaVlel/60pc6ldq0HC9Vd9N5ten29FWSadzz5s0r3vrWt3aq0amCmvrbk7QE8I1vfGPn4m2vec1r9phJFzJLP/dF2qbp6xtT9Tl9jWT67zS2dLG0j370o8WCBQs6X5mZxr6rU045pfM1omls4+Pjuy2JTNL2TefDpvNcU/Z5z3te5xzZdC5s+krJtD3e85737PV403b6x3/8x+IJT3hCpxqdzuFNF/hLY9nT8s70lZYnnHBC52tK0zLQNBaA/Ym50Fx4T+ZC4EBjLjQX3pO5sKT2Ae7GG29sv+IVr2gfccQRna8fTF/peMwxx7Rf/vKXty+//PLdsr+s+nn11Ve3H/OYx7QHBwfbCxcu7Hxd4hVXXHGvinXyxS9+sX3sscd2qrHHHXdc+0tf+tIevzbxl0lfqfnXf/3Xnep1qqimsafq71/8xV+016xZ06nkLliwoH3GGWf80nYOPfTQztdf/qKK9Z7kVqx3rXo/9rGPbc+bN69zn9O2fu1rX9v5KtBf5I1vfGNnLCn7i6TxPv7xj+98PWW6/4cffnj7JS95Sacafl8q1slHPvKR9pFHHtkZZ3oepMcuVex/0UvlHe94R+d3b3vb2zK2BMC+yVxoLtyVuRA4EJkLzYW7Mhfed7X0P2ULVXCgStX4dOG8dEHAdJ4yABxozIUAHOjMhT+nyAT3UXrppKW0aXnnd77znft7OAAw48yFABzozIW7O2CvyQT31Y4dO4qvfvWrnR1I+gaJr3zlK/f3kABgRpkLATjQmQv3zEom2EtpCeShhx5azJ07t/MVoOliegBwIDEXAnCgMxfumSITAAAAAKV1lW8CAAAAgAOdIhMAAAAApSkyAQAAAFCaIhMAAAAApXXnBmu1U8v3RpZly5Zl5Vqt+Jrta9asDjNdXfWMvpphplaLa5btdivMLFx4UJj5WX+1MPP0k78VZs759ilFFc5+7GUz1tdMa7cvvb+HAPuEvLkw5/ObE4rq/DQjE+9791dDQ7Mrm1ermMOKopb1lceRu+66q7Ixnf30eH669aBDiiqsWn9nmDnny+ZC2J89/g+Wh5nvFw8JM9s+Pj/ubCJnjiuKM85eF2Yu/PiZWW3BTHjcS74RZs770BPzGmtfUuxLc6GVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUVmu32+2sYO3UYqY87ux1WbmDW6sr6W9118Fh5rxzFhUzZeHCg7JyixbFuauvvjrM1GpxrbHdbhUzZeXKVVm5bdu2hplNmzZVMKKiOOPsuK/Li5PDzDNbX6rk+TjTz8l2+9IZ6wv2ZXlz4bwwMXR2nMm1/UPDYabdrmZfOJMe+tCHZeWOPvroMLN1a7wPHxkZCTPbt28PM+PjY2Fm0aLFYWbp0qVFjq985SthZt385WGmdt3l1RwLHHNKnLn2kmJ/ZC6En3lKrRZmvn7q2XFDO+LIWY/4eNaYBn48EWZufeAhWW3BTOg5584wc/CL8to655MZc+8MzoVWMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKUpMgEAAABQmiITAAAAAKV1F/ugg1urs3I9461q+uvN6W9RMVM2bFiflevt7amkv3a7mu1YlZ6evPs1PLwlI/WAjMyVYeLy4uQws+0/5oeZnjNbFT0fZ/Y5CeyFnsPDyLafVNhfI973FBObKumqq6seZlqtZph5wANOCjOHH35Y1pimpibDzORknBkZGQkzs2YNhJnu7vjQavPmzWFm/vyMx7Uoimc84xlhpnXpy8LMOUefHWa6uuLPJn9/1gfivopTwgyw7zr4RXHm7OKcOHRtRmefyhpScc5Ixn7lkgflNQYz4OwXxa+Rcz75tMzWbi/2JVYyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApXUX+6B/73pOVm5W/0gl/e0oBjJS1xcz5aCDFmXlfvM3HxNmPvGJfy32N4cffnhWbuPGDWFm06YrKxhRUUxlvFQWPunuMPOl4qkVPR9n9jkJ7IWJiThzcU91/bUz+stQq8WfO7Xb7Ur6Gh8fCzNTU83MtsbDzPbt28LM5ORkmBkdHQ0zvb29lbQzkfM8KoqiXq+HmY/96JSMli4JE62MVs4pcvoC9mfnfHI/fZ234/0c7Fuvo9uL/ZGVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACU1l3sg84ovpuVO+/jT6ykv8e95BtxX8WiYqasXLkyK9fdHT98J574gDDzk59cWVShp6c3zJxxxhlhZsGCBVn9LVq0OMxs2rSpmKnn5Ew+H2f6OQnsjZ/GkfYJM9tfhna7VcyUuXPnhZlrr722snHnzIVbt24NM/39/ZXMzTfffHOYueGG64uqtuXSpQeHmTVrVhczpVbr2qeejwBAdaxkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASusu9kErPn5nXnDikhnsb1ExU5rNZlbuxhtvDDMDAwNh5kEPOi3MjI6OhpnFi+NtNDy8Ocx0d+c9LRuNRjFTsp4jM/p8nNnnJLA3WhmZK4v90aGHHhZmli9fHmZWrlxZ2Vxw0003VZJ5whOeUMk8d/31N4SZCy+8MMysWhVvo6SnpyfMnHDCCWFm4cIFYeaaa64NM1NTk2Gm3c55jQC/7hqNeP81OTmR1daiRYvDzIYNG8JMq5X3PuzX1ezZc8LMwEB/mGk24/38+vXrssfF/sVKJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoLTu8k1QtYmJiaxco9EIM9u2bQsz9Xo9zMyePTvM7NgxEmZarXYl9yvZsGFDVg6A2IIFC8PMAx/4wDAzPLw5zNx0001hZuHCBUWO3/qtJ4SZCy64MMw0m80wc80114aZgw9eGmaWLVsWZh70oNOKHD/84Q+LKqxYsTLMzJkzJ8x897vfrWQ8wP7tiCOODDMvf/nLw8yaNWuy+qvVamFmwYL5YWZ4eEuYGRjoDzOjo6NhZvv27WGmvz/uK5mYmAwzmzfH83NXV7wdjz76mDDTbrcr2UaTk/H9SsbGxsJMo9FdyXZsNqfCzPbtO8JMUcTbqKenJ6OddFxxSJhZsCA+rvrsZz9bVMFKJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoLTu8k1Qta6uvNpfo9EIM319fWFmcnKykkzOeOr1epiZPXsozOT2B0CelStXhpnh4c1hZmxsvJL999q164ocN998SyVzz7p1a8PM0UcfHWZuuunmMDM4OJgxnrz732q1wky73Q4zmzZtCjP9/f1hZunSg8PMmjWrwwywfxsdHQkzt99+e5iZM2dOVn8571W2b98RZmq1WiXzXG9vXyXjufrqa4ocs2fPDjMLFswPM4OD8fuw7du3VzI3dXXF27oo4vkr9z3v0NBQJXPv6tVrwkxPT0+YOfjgpWFmaCh+XHO399jYWCXt5LCSCQAAAIDSFJkAAAAAKE2RCQAAAIDSFJkAAAAAKE2RCQAAAIDSFJkAAAAAKE2RCQAAAIDSFJkAAAAAKK27fBNUrasrr/bX3V3Nw1ev12ds3M1ms6jK0NBQZW0BHOjmzZtXyT68VquFmXa7HWampibDTG5bq1evDjObNm0KM4sXLwkz//3f/x1m6vV4vpw1a1aRY2xsNMzUanF/fX29YWZ8fDzMrFixIsysWRM/HsD+rdXK2c9PVfbeodmM27rllpvDTE9PvC886KCFGe30hJnJyXieW7ZsWVHVXLhjx0iYWbjwoIx2toeZ3t6+MHPVVT+tZMzJ4sWLK9mW/f3xuA86KN5GfX1xO+PjE2GmtzfO5Mo5Xti2bVslfVnJBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlNZdvgmqNnv27Kxcq9UKM5OTk2Gm0WhU0leOer1eSSbp6+stZsqHDzs7Dl172cz11envkkr6A379zZ07L8z09PSEmWazGWba7Xi+GBsbr2wuyBn3Ax5wYphZu3ZdmLntttvCzJFHHhlmDjvssDAzb178mCULFiwIMz/84Q/DzODgYJgZH48ft4GBgUr62r59e5gB9l057x1mzx6qrL+urqreY7TDxIYNGysZz/Lly8PMTTfdVOTIuW9LliwJM6Ojo2Gm0eip5Fhg1apDw8zmzZuKHK1W/LiNjIyEmYULF1ZyDLN27dowc9RRR1WyHXPHNH9+fLzQ3V1NechKJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoLTu8k1QtUajuoel0WiEma6uuNbYarUqyXR11cLM5ORUkaOnpzcrB3Cgmz9/fiX757GxyTAzNDQ7zIyPbwgzo6PjRY6enp6iCjlz2MaN8bjHxyfCzMUXXxxmli1bVuTo7+8LM3PmzKnkWKDZbBZVWL58RZi55pqrK+kLuH+02+0w09VVDzO1eGrKzh199NFhZseOkUrmy4GBWWFmw4Z4Tlm+/JAix9at2yp5THL287NmxfdtfHyskrlp7ty5YeZn/cXHDENDQ2Fm/fp1YWbevLmV9FXLeNKuX7+xyLFgwYIZe/xzWMkEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGnd5Zugaq1WOys3OTkZZrq64jri1NRUJe3kqNfjp9zExERWW/39fcW+Zc79PQCAPVq4cEElc8/IyEiYOfTQQ8NMV1ctzNx6621FjvPP/06Y2b59RyVzyooVK8PM+vXrw8z4+HiYOeyww4ocP/rRJWFm5cp43L29PWFmx454OzabzTBTq8WPP/Drr8pdQc4cNjo6Fmb6+/sz+mqFmRtuuCHMLF68uLL3hXPmzKlkftq0aVOYWbFiRSXvHZvN+PFot/Pu/9DQUJg5//zzw8yqVavCzJw5c8NMvV4PM8PDw2Fm7dq1RY6c989LliypZNw5rGQCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABKU2QCAAAAoDRFJgAAAABK6y7fBFXr6qpl5ZrNqTDTarUy+otrjd3d3ZX0lWNsbCwrV6vNXI30cY/4Rpg579oHzVhfP+tvUSX9Ab/+5s6dF2YmJiYqmS/yMvUw02jkHaL09vaFmVmzBsPM1FQ8p+bo6+urJHPDDTdk9ZeznXLu26xZs4oq1DIOYQYHq+kL2HflvC/YvHk4zPT392f119vbG2aazWZRheHheNyXX/7jMPOc5zw3zGzfvj1rTAMDA5W0NTKyIyMzEmbmz4+PO8bGxsNMX1/8uCbj43FbP/3pT8LMaaedVsnzqNFoVNJOzjFV0m63Kpmf6/X4+CyHlUwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBp3eWboGoDA7OycqOjo2Gmuzt+iFutVlGFrq64Zlmr1cJMs9nM6m/BggXFTDnvJ08MM0Nnb5qxvn7mkkr6A/Zvvb19YaanpyfMbN26NczMnTs3zPzkJz8JM319fZXcr1w589zU1FQlc+r4+HiYGRgYCDMjIyNhJveY4Y477ggzW7ZsCTOzZw+FmdHRsUqej8D+LWefmvPeodFoVLafb7fbM7afP+ywwyu5bznjSbZu3VLJvDI4OBhm5syZHWYmJ6uZU1ut+DHLff/4kIecHmbq9Xol72fHM54j69atq+Q5m8yePSfM1Gpdldz/HFYyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApXWXb4KqDQ4OZuVGR0fDTL1eL2ZKTl+NRiPMtFqtrP7mzZsXZrq64jG1Ws0w03/i1jBzenFxUYULT3x4Vm70+5V0B+zncvaFtVotzExOToaZRiM+bLjsssvCzCmnnBJm+vp6ixxjY+OVzE/tdjvM9PT0FFWYmJgIM/V63ueAOfct4+EvhoaGwkxvb1+YGRmJj01qtfi+9fcPFDlGR0eycsDMypl3ct4X5L6XmZqaqmQOGx+P55QFCxaEmcHBWWFm27ZtYaa7O+/t+qZNmyrZXy5YsLyoQs62npyMH7NmM36flvs8Oeqooyp5f93f31/JYzuV8ZxdsWJFkaO3t7eS99hVHedYyQQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJSmyAQAAABAaYpMAAAAAJTWXb4J9sbs2XPCTL1er6y/nLZarVaYabfbYaarqxZmGo1GmBkZGSmq0tUV11FbrWaYGb1gdpg579olRSWOifsCmDY4OBhmxsfHw8zk5GQlc8rk5ESY2bJlS5gZHFxW5KjVJioZd878VOX8HGk0ejJz8aHcmjV3h5m5c+eFmfnz51fy2OaYMydvLhwdre6YAahOzv6yr68vo6X4PUju+5laLd7PT0zEc0pvb2/GiKq5b1NT8dycbNy4McysWLEyzBxxxBFhZtOmuK+xsfi4o7u7u5L3oEmtVpux97M5z+0dO3aEmQUL4jl1+fLlRY61a9dmjGn7jB3nWMkEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACU1l2+CfZGf39/mGk2m1ltdXVVUyPs7q6HmampeEz1evx0ajQaRVV6e3vDzODgYJgZHt4cZs7edE6YOef0s4sqnH1T3Fenv+KUSvoD9m9z584NM/V6vJ8fGhoKM/39AxntzA4zY2NjYabRqO4QJWderdVqYWb79u2VtNNutys7FhgYiB+TrVu3hJlbbrklzBx66KGVzPPd3fFj29vbF2aAfVfOvJO3n6tn9lfN+6Kenp4w02o1K5nn+vr6Knm/k6xYsSLMDA3F74vWr18fZlavXh1mZs+OjykWLFhYyXZMpqamKnmOjI9PhJl2uxVmFi5cEGb6+uK6wJo18bZObrzxpjBzzDHHZIypmrnXSiYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKC07vJNsDf6+vrCTL1ez2orNxdptVphpqurHWYajUaY6e3tzeirVlR1//v7+8PM8PDmuLOVceRxJ36jqMRUZm5dNd0B+7ecfXh3dzzdz5kzJ8wMDAyEmW3btoaZwcHBMNNsNouq5MwXtVo890xNTYaZrq6cz+/iObXdjjM/G1PupPHLbdy4McwsWLCgkjm1VuuqZP4G9l05+6bh4eEw02zm7eNy9hkLFiwMMyMjI2FmaGgozPT0xO95JifjOWXHju1Fjpw5Y2oqnlfvvvvuSjI55s+fX9GcmqfR6AkzfX3x82jbtm2VPB5bt26pZL78fz1W8l69qvqClUwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlKbIBAAAAEBpikwAAAAAlNZdvgn2Rk9PT2VtdXfHD1+r1QozXV1xrbHdjtvp7q6HmUajEWZqtbzaZ05/VW3vc370tDBzdnHujPX1M7dX0h+wf5ucnAgzrVazkv3zddddV1Rh9uyhGZ0L6vU4kyNnTsnZju12O8zUavFjltvfQQcdFGbWr18fZjZsWF/JNpqaiu/bli1bwgywf+vpyXlf0JvV1qxZA5W8L+rr6wszGzZsCDMbN24MM0cddWSYqdX6ixxbt24NM1deeWWYOe2008LMokWLwszAQPx4TE5OVjZ/57xX/eY3vxlmTj311Erm1ImJ+NjsggsuCDNPf/rTixw5c2/OuOv1atYgWckEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACU1l2+CfbG4OBgmGk2m1lt9fT0hJmJiYkwU6/Xw0yr1QoztVpXJX3l3v96PX76zpo1UFTj9jBxzo9OmbG+AKa123FmbGw8zPT19YeZW265pajC0NDsMDM1NZnVVs680s7YSDlzT7PZqqSvvDm1FmZy2zr00EPDzPr168PMrbfeFmaWLFkSZsbHR8IMsH/L2TfPmTOnkvcXuXPG6OhomJk1a1aYWbo03s99+ctfrmTeOfXUU4sc119/XSXvQ3PmnpxMztw0PDwcZrq68h7/o446MswsXbo0zFx00ffCzPOe9/wws27dujBz9NFHV3YsNDKyY8bqAjmsZAIAAACgNEUmAAAAAEpTZAIAAACgNEUmAAAAAEpTZAIAAACgNEUmAAAAAEpTZAIAAACgNEUmAAAAAErrLt8Ee2P58kMqa6u7O374ms1mmGm1WmGmqyuuR/b394eZvr7eoio5Y+rt7ausP4B9Uc6+sF6vh5l2ux1mhoc3F1WYPXsozDSb8dz0M7VipuRsx1qtVsljNjU1mTWmycmJMDNv3vyiCuvXrw8zRx11ZJjZsmVLJccUwL4rZ07ZuHFTmFmwIG//1dUV7583bFgbZiYm4n3qkiVLwswTnvCEMLNpU3z/R0ZGihyHHnpomBkYmJXR345KHtu8x39jmOnp6SlyXH/9DWHmpJNOCjO9vfF71W3btoaZRYsWVXIsMDIyWuSo6j3vxETesUfESiYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKC07vJNsDeGhmaHmfHx8ay2+vv7wszU1FSYaTabYaZer89YpqurVuSYnJwIM3PmzMlqC2B/lbMPr2o/v2PHSJhpNHrCTF9ff5jZtm1bkSPnvvX0xGPK0W63K8k0m/HhV6MRz/HJ5OSOMNNqxdto7tx5YeaOO+6o5PGo1Woz9pgB948dO+J9U1dXznqHFVn9Pfys/w0za9euDTMXfOLhYaara12YOfjgg8PMwoVnhpkXFh8ucny46+Vh5tRnfjHMrLrlzjDzyearwsxZd743zNz6uOEw8+HvP6/IccIZt4aZ4a9NhpnDDz88zExNDYWZ2WcvCjPbt28PM8PvjZ9ryeuW/jjMtF8Qvy+uPWiwqIKVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGnd5Ztgb/T29oaZycnJzLb6wkyz2SyqUK/Xw0yj0ahkzLVaXu2zpyfelgMDA1ltAeyv+vr6KtmHd3fHhwTtdivMHHXUURnttCvpK+nqqlXWVhXbqF6P5532wceEma6Mvjq52y4PM5OTU2Gmv78/zAwPbw4zU1PxcUdvb0+Y6emJM8D9o16P909Lly4NM6tWrQozv/l712aN6bjZg2FmZFk8Fx515Now8433Lwwzs2cPhZk/mvOtMPORU99a5HjRxR8OMx/60GlhZtWqh4SZ4/843tb/tT0e90u/8MEw852TDi9y3HrtQWFmYOKaMDM0FN+3xa86MsycOnBbmLnp5pvCzJr/c3qRY2hodZhZ+OX4vfr44nVFFaxkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASusu9kEfnjjl17a/gYGBMLN9+/astrq6amGmu7uR0c5kVn9xX/HTqaenJ8w0GvGYcw0ODlbWFsC+aGRkJMwMDQ2FmQ0bNlQynoULF1Yy5larndVfvV6vpK1WqxVmarV43n1Z//fCzPYn/6CSvpKBT02EmX9tnh5m5syZE2bWrFkdZjZu3BhmJifj447x8bEwA9w/DjrooErWMvz9358TZt75zi1ZY3pKcWmYOegP4vcqt0wsCDNf+efZlbxPu2Pwx2HmwyffWuQ480cfDTPfbzw7zIyP3xhmuq9fEma2j84NM9ec+5Ew875TrymybIsjrR/8MMx0dcXHFLPXHBZmTuq9KcyMjo6GmRu7H1DkuKJ9bpgZ/GwzzHz/2ceGmT9/7F+FGSuZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0hSZAAAAAChNkQkAAACA0rqLfVHPg7JiZ73k45V096mPvyQOTVxSSV8DAwNhpre3J7OtWWGmp6c3zDSbzTAzPj6e0Vc87lmzcu5/POaf9dcIM4ODg1ltAeyv2u12mFm4cGGY2bp1ayXjyZkLcuadVquV1V+9Xg8zXV21SsbUaMSHTR854RVhpvXJvPuWo3V83FbPT34SZpYuXRpmrr32mjAzNTUZZhYtWhRmhoeHwwxw/7j77jUZqbEwcczZI2HmEZ/6ftaYzhk5Jcw8bt26MHPeOUdk9HZ7UYV/Gn1OmDn7e/+Y1dY5o2eHmce97BthZtUtd8Z9/Tju6+y17w8zw8+Ojxdal+XNl8ecEs9z1/4gbqfVio8Fhj+wIcxcdvaqogrb3hc/Z5OegdEwM3xWXo2hClYyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFCaIhMAAAAApSkyAQAAAFBard1ut7OCtVOLmXLW2T/Nyg18aqKS/kbO6gkznzrnhEr6ev3rXx9m1q/fkNXW4OBgBSMqipGRkTCzdevWMLNkyZIwM2/evDBz5ZVXFjlOOCF+TDZv3hxm3ve+92b1dyBrty+9v4cA+4SZnAtz5cwFy5evqGQuuO22W8PMYx/7uDAzNjYWZlqtVpGjqyv+vKxWq8VjevzxYeYtd30rzFx76R1h5isvf2E8ns/NKXK86FkfjMfUdVyYGW0sDDMfPOu8MDNv3vwwM39+nFm3bl2RY9u2+PikKuZC+JnH/8HyStpZ9eM7w8wFDzw9q61rzxnISMXvC4Dyc6GVTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGmKTAAAAACUpsgEAAAAQGndxT5o4FMTWbmRs3pmtL8qzJkzN8xs3jyc1dby5cvDTKvVKqpwww03hJnu7vjpdMghy8LM5s2bi6ocf/zxlbUFsC/avn17mLnmmqsr6atWiz+bqtVqYabRiOeLqalm1pi6uqr5vOwPLv5QmOl702lhZvGd8Rw2dvWcMPOys/41zPy/UYWJS3/0yDBz+mnfr+Tx37x5UyUZYN913jkPqqSdx50dZ649ZyCztS1lhwNUxEomAAAAAEpTZAIAAACgNEUmAAAAAEpTZAIAAACgNEUmAAAAAEpTZAIAAACgNEUmAAAAAEpTZAIAAACgtO5iH3TOyCmZwWK/c9FFF4WZo446Kqutiy++OMx85StfCTMPetCpYeahD31YmNm4cUOYede7/inMHHzw0iLHmWf+Zpj5xCc+kdUWwK+zWq2az5Ta7VaYueqqq8JMqxW309PTkzWmrq5aRqYeZt40flqYOeaH88PMqZddF2ZuGrwpzPzfgSOLHMd+MJ7nmy/+bJj5yGcfUMnjnyPn8Wi321ltVTUmYG/cnpFZUVFfmytqB5gpVjIBAAAAUJoiEwAAAAClKTIBAAAAUJoiEwAAAAClKTIBAAAAUJoiEwAAAAClKTIBAAAAUJoiEwAAAACl1drtdrt8MwAAAAAcyKxkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKA0RSYAAAAASlNkAgAAAKAo6/8HGYY0DXfhB7UAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1500x600 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# --- Setup: move to repo root + make src importable ---\n",
+    "import os, sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "#root = Path(\"..\").resolve()   # notebook is in notebooks/, go up one level\n",
+    "os.chdir(root)\n",
+    "sys.path.append(str(root))\n",
+    "print(\"Working dir:\", os.getcwd())\n",
+    "\n",
+    "# --- Imports from your explain tool ---\n",
+    "from src.explain import load_model, get_transforms_from_meta, run_gradcam, get_device\n",
+    "\n",
+    "# --- Other deps ---\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "from torchvision.datasets import FashionMNIST\n",
+    "from torchvision import transforms\n",
+    "import json\n",
+    "import random\n",
+    "\n",
+    "# --- 1) Find the latest best checkpoint ---\n",
+    "reports = sorted(Path(\"reports\").glob(\"*fmnist\"), key=lambda p: p.stat().st_mtime)\n",
+    "assert reports, \"No Fashion-MNIST runs found in reports/. Train once with the Fashion-MNIST config.\"\n",
+    "latest = reports[-1]\n",
+    "best_json = json.loads((latest / \"best.json\").read_text())\n",
+    "best_ckpt = Path(best_json[\"ckpt_path\"])\n",
+    "print(\"Using checkpoint:\", best_ckpt)\n",
+    "\n",
+    "# --- 2) Load model & dataset transforms/classes ---\n",
+    "device = get_device(\"auto\")\n",
+    "model, classes_from_ckpt, meta = load_model(str(best_ckpt), device)\n",
+    "tf = get_transforms_from_meta(meta)\n",
+    "classes = classes_from_ckpt or default_classes\n",
+    "\n",
+    "# --- 3) Prepare some test samples (from the official test split) ---\n",
+    "test_raw = FashionMNIST(root=\"data\", train=False, download=True, transform=transforms.ToTensor())\n",
+    "\n",
+    "indices = random.sample(range(len(test_raw)), 3)  # pick any indices you want\n",
+    "outdir = Path(\"reports\") / best_ckpt.parent.name / \"explain_direct\"\n",
+    "outdir.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# --- 4) Run Grad-CAM directly (no subprocess) ---\n",
+    "overlay_files = []\n",
+    "for i in indices:\n",
+    "    img, label = test_raw[i]                      # img is tensor [1,28,28] in [0,1]\n",
+    "    pil = transforms.ToPILImage()(img).convert(\"RGB\")  # convert to PIL RGB for our tf\n",
+    "    x = tf(pil)                                   # normalized tensor [1,28,28]\n",
+    "    results = run_gradcam(model, \"conv2\", x, device, classes, outdir, topk=1)\n",
+    "    overlay_files.append(results[0][\"file\"])\n",
+    "\n",
+    "print(\"Saved overlays:\", overlay_files)\n",
+    "\n",
+    "# --- 5) Display overlays inline ---\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "\n",
+    "# Display original images\n",
+    "for i, idx in enumerate(indices):\n",
+    "    plt.subplot(2, len(indices), i+1)\n",
+    "    img, label = test_raw[idx]\n",
+    "    plt.imshow(transforms.ToPILImage()(img))\n",
+    "    plt.title(f'Original: {classes[label]}')\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "# Display overlay images\n",
+    "for i, overlay_file in enumerate(overlay_files):\n",
+    "    plt.subplot(2, len(indices), len(indices) + i+1)\n",
+    "    overlay = Image.open(overlay_file)\n",
+    "    plt.imshow(overlay)\n",
+    "    plt.title('Grad-CAM Overlay')\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working dir: /Users/stefanoracca/Desktop/projects/computer-vision-explainable-cnn\n",
+      "Using checkpoint: reports/resnet18_cifar10/best.ckpt\n",
+      "Meta: {'dataset': 'cifar10', 'model_name': 'resnet18_cifar', 'img_size': 32, 'default_target_layer': 'layer4'}\n",
+      "Saved: reports/resnet18_cifar10/explain_direct\n",
+      "Saved: reports/resnet18_cifar10/explain_direct\n",
+      "Saved: reports/resnet18_cifar10/explain_direct\n",
+      "Saved overlays: ['reports/resnet18_cifar10/explain_direct/gradcam_top1_class3_cat.png', 'reports/resnet18_cifar10/explain_direct/gradcam_top1_class0_airplane.png', 'reports/resnet18_cifar10/explain_direct/gradcam_top1_class7_horse.png']\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x600 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# --- Setup: move to repo root + make src importable ---\n",
+    "import os, sys, json\n",
+    "from pathlib import Path\n",
+    "\n",
+    "root = Path(\"..\").resolve()   # notebook is in notebooks/, go up one level\n",
+    "os.chdir(root)\n",
+    "sys.path.append(str(root))\n",
+    "print(\"Working dir:\", os.getcwd())\n",
+    "\n",
+    "# --- Imports from your explain tool ---\n",
+    "# (make sure your explain.py exposes these: load_model, get_transforms_from_meta, run_gradcam, get_device)\n",
+    "from src.explain import load_model, get_transforms_from_meta, run_gradcam, get_device\n",
+    "\n",
+    "# --- Other deps ---\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "from torchvision.datasets import CIFAR10\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "# --- 1) Find the latest CIFAR-10 best checkpoint (by reading reports/*/best.json) ---\n",
+    "reports = sorted(Path(\"reports\").glob(\"*cifar10\"), key=lambda p: p.stat().st_mtime)\n",
+    "assert reports, \"No CIFAR-10 runs found in reports/. Train once with the CIFAR config.\"\n",
+    "latest = reports[-1]\n",
+    "best_json = json.loads((latest / \"best.json\").read_text())\n",
+    "best_ckpt = Path(best_json[\"ckpt_path\"])\n",
+    "print(\"Using checkpoint:\", best_ckpt)\n",
+    "\n",
+    "# --- 2) Load model & transforms from checkpoint meta ---\n",
+    "device = get_device(\"auto\")\n",
+    "model, classes, meta = load_model(str(best_ckpt), device)\n",
+    "tf = get_transforms_from_meta(meta)\n",
+    "target_layer = meta.get(\"default_target_layer\", \"layer4\")  # ResNet18 default\n",
+    "\n",
+    "print(\"Meta:\", {k: meta.get(k) for k in [\"dataset\",\"model_name\",\"img_size\",\"default_target_layer\"]})\n",
+    "\n",
+    "# --- 3) Prepare CIFAR-10 test samples (raw tensors -> PIL -> normalized via tf) ---\n",
+    "test_raw = CIFAR10(root=\"data\", train=False, download=True, transform=transforms.ToTensor())\n",
+    "\n",
+    "# pick any indices you want\n",
+    "indices = [0, 10, 20]\n",
+    "outdir = Path(\"reports\") / latest.name / \"explain_direct\"\n",
+    "outdir.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# --- 4) Run Grad-CAM directly (no subprocess) ---\n",
+    "overlay_files = []\n",
+    "for i in indices:\n",
+    "    img, label = test_raw[i]                       # img is tensor [3,32,32] in [0,1]\n",
+    "    pil = transforms.ToPILImage()(img)             # PIL RGB\n",
+    "    x = tf(pil)                                    # normalized tensor [3,H,W] based on meta\n",
+    "    results = run_gradcam(model, target_layer, x, device, classes, outdir, topk=1)\n",
+    "    overlay_files.append(results[0][\"file\"])\n",
+    "\n",
+    "print(\"Saved overlays:\", overlay_files)\n",
+    "\n",
+    "# --- 5) Display original images and overlays inline ---\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "\n",
+    "# Display original images\n",
+    "for i, idx in enumerate(indices):\n",
+    "    plt.subplot(2, len(indices), i+1)\n",
+    "    img, label = test_raw[idx]\n",
+    "    plt.imshow(transforms.ToPILImage()(img))\n",
+    "    plt.title(f'Original: {classes[label]}')\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "# Display overlay images\n",
+    "for i, overlay_file in enumerate(overlay_files):\n",
+    "    plt.subplot(2, len(indices), len(indices) + i+1)\n",
+    "    overlay = Image.open(overlay_file)\n",
+    "    plt.imshow(overlay)\n",
+    "    plt.title('Grad-CAM Overlay')\n",
+    "    plt.axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>run_id</th>\n",
+       "      <th>val_acc</th>\n",
+       "      <th>val_loss</th>\n",
+       "      <th>epoch</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>smallcnn_aug_fmnist</td>\n",
+       "      <td>0.9161</td>\n",
+       "      <td>0.246326</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>smallcnn_fmnist</td>\n",
+       "      <td>0.9125</td>\n",
+       "      <td>0.251245</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                run_id  val_acc  val_loss  epoch\n",
+       "1  smallcnn_aug_fmnist   0.9161  0.246326     11\n",
+       "0      smallcnn_fmnist   0.9125  0.251245      7"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "import json, pandas as pd\n",
+    "\n",
+    "rows = []\n",
+    "for best in Path(\"../reports\").rglob(\"best.json\"):\n",
+    "    j = json.loads(best.read_text())\n",
+    "    # find metrics.json in same run folder\n",
+    "    metrics = json.loads((best.parent / \"metrics.json\").read_text())\n",
+    "    rows.append({\n",
+    "        \"run_id\": best.parent.name,\n",
+    "        \"val_acc\": j[\"val_acc\"],\n",
+    "        \"val_loss\": j[\"val_loss\"],\n",
+    "        \"epoch\": j[\"epoch\"],\n",
+    "    })\n",
+    "\n",
+    "df = pd.DataFrame(rows).sort_values(\"val_acc\", ascending=False)\n",
+    "df"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "vis-cnn",
+   "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.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}