From 6016256f81725a7553dd35acd2c0993707901b88 Mon Sep 17 00:00:00 2001
From: Nina Miolane <nmiolane@gmail.com>
Date: Sat, 7 Feb 2026 03:18:50 +0000
Subject: [PATCH 1/2] fix dn

---
 notebooks/cn.ipynb               | 1159 ++++++++++++++++--------------
 notebooks/cnxcn.ipynb            |   48 +-
 notebooks/dn.ipynb               |  232 +++++-
 notebooks/sequential_cnxcn.ipynb |   48 +-
 4 files changed, 901 insertions(+), 586 deletions(-)

diff --git a/notebooks/cn.ipynb b/notebooks/cn.ipynb
index fa3bf65..e014cd5 100644
--- a/notebooks/cn.ipynb
+++ b/notebooks/cn.ipynb
@@ -1,538 +1,649 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Binary Group Composition on $C_n$\n",
-        "\n",
-        "**Group:** Cyclic group $C_n$ of order $p$ (i.e., modular addition mod $p$).  \n",
-        "**Task:** Given encodings of two group elements $a, b \\in C_p$, predict the encoding of their product $a + b \\pmod{p}$.  \n",
-        "**Sequence length:** $k = 2$ (binary composition).  \n",
-        "**Architecture:** `TwoLayerNet` with square nonlinearity.  \n",
-        "**Key result:** The network learns one Fourier mode at a time, producing a staircase in the training loss."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Imports"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "import random\n",
-        "\n",
-        "import matplotlib.pyplot as plt\n",
-        "import numpy as np\n",
-        "import torch\n",
-        "import torch.nn as nn\n",
-        "from torch.utils.data import DataLoader, TensorDataset\n",
-        "\n",
-        "import src.dataset as dataset\n",
-        "import src.model as model\n",
-        "import src.optimizer as optimizer\n",
-        "import src.power as power\n",
-        "import src.template as template\n",
-        "import src.train as train_mod\n",
-        "import src.viz as viz"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Configuration"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "TEST_MODE = os.environ.get(\"NOTEBOOK_TEST_MODE\", \"0\") == \"1\"\n",
-        "\n",
-        "seed = 0\n",
-        "random.seed(seed)\n",
-        "np.random.seed(seed)\n",
-        "torch.manual_seed(seed)\n",
-        "\n",
-        "p = 11\n",
-        "hidden_size = 20 if TEST_MODE else 200\n",
-        "epochs = 2 if TEST_MODE else 5000\n",
-        "lr = 0.01\n",
-        "init_scale = 1e-5\n",
-        "\n",
-        "FIGURES_DIR = \"figures\"\n",
-        "os.makedirs(FIGURES_DIR, exist_ok=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Template and Dataset"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "067e5bc3",
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Build a fixed Cn template with known Fourier structure\n",
-        "tpl = template.fixed_cn(\n",
-        "    group_size=p,\n",
-        "    fourier_coef_mags=[0, 12.5, 10, 7.5, 5, 2.5],\n",
-        ")\n",
-        "\n",
-        "# Mean-center the template\n",
-        "tpl = tpl - np.mean(tpl)\n",
-        "\n",
-        "# Build exhaustive dataset: all p^2 pairs\n",
-        "X, Y = dataset.cn_dataset(tpl)\n",
-        "\n",
-        "# Move to tensors and flatten\n",
-        "X_tensor, Y_tensor, device = dataset.move_dataset_to_device_and_flatten(X, Y)\n",
-        "\n",
-        "ds = TensorDataset(X_tensor, Y_tensor)\n",
-        "dataloader = DataLoader(ds, batch_size=len(ds), shuffle=False)\n",
-        "\n",
-        "print(f\"Group: C_{p}, order {p}\")\n",
-        "print(f\"Dataset: {len(ds)} samples (all {p}x{p} pairs)\")\n",
-        "print(f\"X shape: {X_tensor.shape}, Y shape: {Y_tensor.shape}\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "a26b21e6",
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Visualize template and its power spectrum\n",
-        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
-        "\n",
-        "ax1.bar(range(p), tpl, color=\"black\")\n",
-        "ax1.set_xlabel(\"Group element\")\n",
-        "ax1.set_ylabel(\"Template value\")\n",
-        "ax1.set_title(f\"Template $t$ on $C_{{{p}}}$\")\n",
-        "\n",
-        "pwr, freqs = power.get_power_1d(tpl)\n",
-        "ax2.bar(freqs, pwr, color=\"steelblue\")\n",
-        "ax2.set_xlabel(\"Frequency\")\n",
-        "ax2.set_ylabel(\"Power\")\n",
-        "ax2.set_title(\"Power spectrum of template\")\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.savefig(f\"{FIGURES_DIR}/cn_template.pdf\", bbox_inches=\"tight\")\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Model and Optimizer"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "230b324e",
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "net = model.TwoLayerNet(\n",
-        "    group_size=p,\n",
-        "    hidden_size=hidden_size,\n",
-        "    nonlinearity=\"square\",\n",
-        "    init_scale=init_scale,\n",
-        ")\n",
-        "net = net.to(device)\n",
-        "\n",
-        "criterion = nn.MSELoss()\n",
-        "opt = optimizer.PerNeuronScaledSGD(net, lr=lr, degree=3)\n",
-        "\n",
-        "print(f\"Model: TwoLayerNet(p={p}, hidden={hidden_size}, init_scale={init_scale})\")\n",
-        "print(f\"Optimizer: PerNeuronScaledSGD(lr={lr}, degree=3)\")\n",
-        "print(f\"Training for {epochs} epochs\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Training"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "loss_history, val_loss_history, param_history, param_save_epochs, final_epoch = train_mod.train(\n",
-        "    net,\n",
-        "    dataloader,\n",
-        "    criterion,\n",
-        "    opt,\n",
-        "    epochs=epochs,\n",
-        "    verbose_interval=max(1, epochs // 10),\n",
-        "    save_param_interval=1,\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Training Loss"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Compute theoretical loss plateau levels\n",
-        "theory = power.theoretical_loss_levels_1d(tpl)\n",
-        "\n",
-        "fig, ax = plt.subplots(figsize=(8, 6))\n",
-        "ax.plot(loss_history, lw=4)\n",
-        "\n",
-        "for level in theory[\"levels\"]:\n",
-        "    ax.axhline(y=level, color=\"black\", linestyle=\"--\", linewidth=2, zorder=-2)\n",
-        "\n",
-        "ax.set_xscale(\"log\")\n",
-        "ax.set_yscale(\"log\")\n",
-        "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
-        "ax.set_ylabel(\"Train Loss\", fontsize=18)\n",
-        "ax.set_title(f\"Training loss on $C_{{{p}}}$\", fontsize=20)\n",
-        "viz.style_axes(ax)\n",
-        "ax.grid(False)\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.savefig(f\"{FIGURES_DIR}/cn_loss.pdf\", bbox_inches=\"tight\")\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Power Spectrum Over Training"
-      ]
-    },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "00f9a1b5",
+   "metadata": {},
+   "source": [
+    "# Binary Group Composition on $C_n$\n",
+    "\n",
+    "**Group:** Cyclic group $C_n$ of order $p$ (i.e., modular addition mod $p$).  \n",
+    "**Task:** Given encodings of two group elements $a, b \\in C_p$, predict the encoding of their product $a + b \\pmod{p}$.  \n",
+    "**Sequence length:** $k = 2$ (binary composition).  \n",
+    "**Architecture:** `TwoLayerNet` with square nonlinearity.  \n",
+    "**Key result:** The network learns one Fourier mode at a time, producing a staircase in the training loss."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf519c5",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "55323b6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import DataLoader, TensorDataset\n",
+    "\n",
+    "import src.dataset as dataset\n",
+    "import src.model as model\n",
+    "import src.optimizer as optimizer\n",
+    "import src.power as power\n",
+    "import src.template as template\n",
+    "import src.train as train_mod\n",
+    "import src.viz as viz"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4e92d36",
+   "metadata": {},
+   "source": [
+    "## Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "931bad50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TEST_MODE = os.environ.get(\"NOTEBOOK_TEST_MODE\", \"0\") == \"1\"\n",
+    "\n",
+    "seed = 0\n",
+    "random.seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "torch.manual_seed(seed)\n",
+    "\n",
+    "p = 11\n",
+    "hidden_size = 20 if TEST_MODE else 200\n",
+    "epochs = 2 if TEST_MODE else 5000\n",
+    "lr = 0.01\n",
+    "init_scale = 1e-5\n",
+    "\n",
+    "FIGURES_DIR = \"figures\"\n",
+    "os.makedirs(FIGURES_DIR, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6877c879",
+   "metadata": {},
+   "source": [
+    "## Template and Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "067e5bc3",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Compute template power for reference lines\n",
-        "num_freqs = p // 2 + 1\n",
-        "template_ft = np.fft.rfft(tpl)\n",
-        "template_power = np.abs(template_ft)[:num_freqs]\n",
-        "\n",
-        "# Compute output power over time\n",
-        "num_points = min(500, len(param_history))\n",
-        "steps = np.unique(np.logspace(0, np.log10(max(1, len(param_history) - 1)), num_points, dtype=int))\n",
-        "powers_over_time = []\n",
-        "\n",
-        "for step in steps:\n",
-        "    net.load_state_dict(param_history[step])\n",
-        "    net.eval()\n",
-        "    with torch.no_grad():\n",
-        "        outputs = net(X_tensor)\n",
-        "        ft = np.fft.rfft(outputs.detach().cpu().numpy(), axis=1)\n",
-        "        avg_power = np.mean(np.abs(ft), axis=0)\n",
-        "        powers_over_time.append(avg_power)\n",
-        "\n",
-        "powers_over_time = np.array(powers_over_time)\n",
-        "\n",
-        "# Plot\n",
-        "colors = [\"tab:blue\", \"tab:orange\", \"tab:red\", \"tab:green\", \"tab:brown\", \"tab:purple\"]\n",
-        "fig, ax = plt.subplots(figsize=(8, 6))\n",
-        "\n",
-        "for k in range(num_freqs):\n",
-        "    color = colors[k] if k < len(colors) else f\"C{k}\"\n",
-        "    ax.plot(steps, powers_over_time[:, k], color=color, lw=4, label=rf\"$\\xi = {k}$\")\n",
-        "    ax.axhline(template_power[k], color=color, linestyle=\"dotted\", linewidth=2, alpha=0.5, zorder=-10)\n",
-        "\n",
-        "ax.set_xscale(\"log\")\n",
-        "ax.set_ylabel(\"Power\", fontsize=18)\n",
-        "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
-        "ax.set_title(f\"Power spectrum over training on $C_{{{p}}}$\", fontsize=20)\n",
-        "ax.legend(fontsize=12, title=\"Frequency\", title_fontsize=14, loc=\"upper left\", labelspacing=0.25)\n",
-        "viz.style_axes(ax)\n",
-        "ax.grid(False)\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.savefig(f\"{FIGURES_DIR}/cn_power_spectrum.pdf\", bbox_inches=\"tight\")\n",
-        "plt.show()"
-      ]
-    },
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting mode: 1 with magnitude: 12.5\n",
+      "Setting mode: 2 with magnitude: 10\n",
+      "Setting mode: 3 with magnitude: 7.5\n",
+      "Setting mode: 4 with magnitude: 5\n",
+      "Setting mode: 5 with magnitude: 2.5\n",
+      "GPU is available. Using CUDA.\n",
+      "Group: C_11, order 11\n",
+      "Dataset: 121 samples (all 11x11 pairs)\n",
+      "X shape: torch.Size([121, 22]), Y shape: torch.Size([121, 11])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Build a fixed Cn template with known Fourier structure\n",
+    "tpl = template.fixed_cn(\n",
+    "    group_size=p,\n",
+    "    fourier_coef_mags=[0, 12.5, 10, 7.5, 5, 2.5],\n",
+    ")\n",
+    "\n",
+    "# Mean-center the template\n",
+    "tpl = tpl - np.mean(tpl)\n",
+    "\n",
+    "# Build exhaustive dataset: all p^2 pairs\n",
+    "X, Y = dataset.cn_dataset(tpl)\n",
+    "\n",
+    "# Move to tensors and flatten\n",
+    "X_tensor, Y_tensor, device = dataset.move_dataset_to_device_and_flatten(X, Y)\n",
+    "\n",
+    "ds = TensorDataset(X_tensor, Y_tensor)\n",
+    "dataloader = DataLoader(ds, batch_size=len(ds), shuffle=False)\n",
+    "\n",
+    "print(f\"Group: C_{p}, order {p}\")\n",
+    "print(f\"Dataset: {len(ds)} samples (all {p}x{p} pairs)\")\n",
+    "print(f\"X shape: {X_tensor.shape}, Y shape: {Y_tensor.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a26b21e6",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## AGF Numerics\n",
-        "\n",
-        "Compare gradient descent training with the Alternating Gradient Flow (AGF) approximation.\n",
-        "AGF decomposes training into alternating utility-maximization and cost-minimization phases,\n",
-        "predicting when each Fourier mode activates."
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 2 Axes>"
       ]
-    },
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize template and its power spectrum\n",
+    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
+    "\n",
+    "ax1.bar(range(p), tpl, color=\"black\")\n",
+    "ax1.set_xlabel(\"Group element\")\n",
+    "ax1.set_ylabel(\"Template value\")\n",
+    "ax1.set_title(f\"Template $t$ on $C_{{{p}}}$\")\n",
+    "\n",
+    "pwr, freqs = power.get_power_1d(tpl)\n",
+    "ax2.bar(freqs, pwr, color=\"steelblue\")\n",
+    "ax2.set_xlabel(\"Frequency\")\n",
+    "ax2.set_ylabel(\"Power\")\n",
+    "ax2.set_title(\"Power spectrum of template\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"{FIGURES_DIR}/cn_template.pdf\", bbox_inches=\"tight\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "abe1c834",
+   "metadata": {},
+   "source": [
+    "## Model and Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "230b324e",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from tqdm import tqdm\n",
-        "\n",
-        "\n",
-        "class ModsumSubNetwork(nn.Module):\n",
-        "    \"\"\"A single neuron of the two-layer network for AGF analysis.\"\"\"\n",
-        "\n",
-        "    def __init__(self, d_in, d_out, init_scale):\n",
-        "        super().__init__()\n",
-        "        assert d_in % 2 == 0\n",
-        "        self.p = d_in // 2\n",
-        "        self.u = nn.Linear(self.p, 1, bias=False)\n",
-        "        self.v = nn.Linear(self.p, 1, bias=False)\n",
-        "        self.w = nn.Linear(1, d_out, bias=False)\n",
-        "        with torch.no_grad():\n",
-        "            self.w.weight.mul_(init_scale)\n",
-        "            self.u.weight.mul_(init_scale)\n",
-        "            self.v.weight.mul_(init_scale)\n",
-        "        self.active = False\n",
-        "        self.util_acc = 0\n",
-        "        self.c_a = 1 / self.get_norm() - 1\n",
-        "        self.normalize()\n",
-        "\n",
-        "    def get_norm(self):\n",
-        "        sqnorm = lambda x: torch.linalg.norm(x.weight) ** 2\n",
-        "        return torch.sqrt(sqnorm(self.w) + sqnorm(self.u) + sqnorm(self.v))\n",
-        "\n",
-        "    def reinitialize(self, u, v, w):\n",
-        "        with torch.no_grad():\n",
-        "            self.u.weight.copy_(u)\n",
-        "            self.v.weight.copy_(v)\n",
-        "            self.w.weight.copy_(w)\n",
-        "        self.c_a = 1 / self.get_norm() - 1\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        x1 = x[:, : self.p]\n",
-        "        x2 = x[:, self.p :]\n",
-        "        return self.w((self.u(x1) + self.v(x2)) ** 2)\n",
-        "\n",
-        "    def normalize(self):\n",
-        "        norm = self.get_norm()\n",
-        "        with torch.no_grad():\n",
-        "            self.w.weight.div_(norm)\n",
-        "            self.u.weight.div_(norm)\n",
-        "            self.v.weight.div_(norm)\n",
-        "\n",
-        "    def utility_step(self, x, residual, learning_rate):\n",
-        "        f_i = self(x)\n",
-        "        util = torch.einsum(\"nd,nd->n\", f_i, residual).mean()\n",
-        "        self.util_acc += 3 * learning_rate * util.item()\n",
-        "        norm_th = 1 / (1 + self.c_a - self.util_acc)\n",
-        "        util.backward()\n",
-        "        with torch.no_grad():\n",
-        "            self.w.weight += norm_th * learning_rate * self.w.weight.grad\n",
-        "            self.u.weight += norm_th * learning_rate * self.u.weight.grad\n",
-        "            self.v.weight += norm_th * learning_rate * self.v.weight.grad\n",
-        "            self.w.weight.grad.zero_()\n",
-        "            self.u.weight.grad.zero_()\n",
-        "            self.v.weight.grad.zero_()\n",
-        "            self.normalize()\n",
-        "\n",
-        "\n",
-        "class ModsumNetwork(nn.Module):\n",
-        "    \"\"\"Network of ModsumSubNetwork neurons for AGF simulation.\"\"\"\n",
-        "\n",
-        "    def __init__(self, d_in, d_out, init_scale, width=100):\n",
-        "        super().__init__()\n",
-        "        self.d_in = d_in\n",
-        "        self.d_out = d_out\n",
-        "        self.width = width\n",
-        "        neurons = [ModsumSubNetwork(d_in, d_out, init_scale) for _ in range(width)]\n",
-        "        self.neurons = nn.ModuleList(neurons)\n",
-        "        self.set_mode(\"utilmax\")\n",
-        "\n",
-        "    def load_init(self, U, V, W):\n",
-        "        for i, n in enumerate(self.neurons):\n",
-        "            u, v, w = U[i], V[i], W[i][:, None]\n",
-        "            n.reinitialize(u, v, w)\n",
-        "\n",
-        "    def dormant(self):\n",
-        "        return [neuron for neuron in self.neurons if not neuron.active]\n",
-        "\n",
-        "    def set_mode(self, mode):\n",
-        "        if mode not in [\"utilmax\", \"costmin\"]:\n",
-        "            raise ValueError(\"mode must be utilmax or costmin\")\n",
-        "        self.mode = mode\n",
-        "        for neuron in self.neurons:\n",
-        "            grad_on = (mode == \"utilmax\") ^ neuron.active\n",
-        "            for param in neuron.parameters():\n",
-        "                param.requires_grad = grad_on\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        active = [n for n in self.neurons if n.active]\n",
-        "        if not active:\n",
-        "            return torch.zeros(x.shape[0], self.d_out)\n",
-        "        outputs = torch.stack([n(x) for n in active], dim=0)\n",
-        "        return torch.sum(outputs, dim=0)\n",
-        "\n",
-        "\n",
-        "def train_agf(\n",
-        "    X_train, Y_train, init_sz=1e-3, agf_steps=5, from_init=None,\n",
-        "    utilmax_lr=1, costmin_lr=1, costmin_maxiter=1e4, loss_thresh=1e-4,\n",
-        "):\n",
-        "    \"\"\"Run the Alternating Gradient Flow (AGF) approximation.\"\"\"\n",
-        "    d_in, d_out = X_train.shape[-1], Y_train.shape[-1]\n",
-        "    if from_init:\n",
-        "        U, V, W = from_init[\"U\"], from_init[\"V\"], from_init[\"W\"]\n",
-        "        width = U.shape[0]\n",
-        "        agf_net = ModsumNetwork(d_in, d_out, init_sz, width=width)\n",
-        "        agf_net.load_init(U, V, W)\n",
-        "    else:\n",
-        "        agf_net = ModsumNetwork(d_in, d_out, init_sz, width=agf_steps)\n",
-        "    X_train.requires_grad = False\n",
-        "\n",
-        "    results = {\"t\": [], \"losses\": [], \"pred\": []}\n",
-        "\n",
-        "    def update_results(t):\n",
-        "        results[\"t\"].append(t)\n",
-        "        residual = (Y_train - agf_net(X_train)).detach()\n",
-        "        results[\"losses\"].append((residual**2).mean().item())\n",
-        "        results[\"pred\"].append(agf_net(X_train).detach().cpu().clone())\n",
-        "\n",
-        "    t = 0\n",
-        "    update_results(t)\n",
-        "    for _ in tqdm(range(agf_steps)):\n",
-        "        residual = (1 / d_out) * 2 * (Y_train - agf_net(X_train))\n",
-        "        residual = residual.detach()\n",
-        "        iters = 0\n",
-        "        mode = \"utilmax\"\n",
-        "        while mode == \"utilmax\":\n",
-        "            for n in agf_net.neurons:\n",
-        "                if n.active:\n",
-        "                    continue\n",
-        "                n.utility_step(X_train, residual, utilmax_lr)\n",
-        "                if n.util_acc > n.c_a:\n",
-        "                    n.active = True\n",
-        "                    mode = \"costmin\"\n",
-        "            iters += 1\n",
-        "        agf_net.set_mode(mode)\n",
-        "        t += iters\n",
-        "\n",
-        "        agf_opt = torch.optim.SGD(agf_net.parameters(), lr=costmin_lr, momentum=0.9)\n",
-        "        for _ in range(int(costmin_maxiter)):\n",
-        "            agf_opt.zero_grad(set_to_none=False)\n",
-        "            residual = Y_train - agf_net(X_train)\n",
-        "            loss = (residual**2).mean()\n",
-        "            loss.backward()\n",
-        "            agf_opt.step()\n",
-        "        agf_net.set_mode(\"utilmax\")\n",
-        "\n",
-        "        print(f\"loss: {loss.item():.5f}\")\n",
-        "        update_results(t)\n",
-        "\n",
-        "        if not agf_net.dormant() or loss.item() < loss_thresh:\n",
-        "            break\n",
-        "\n",
-        "    return results"
-      ]
-    },
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: TwoLayerNet(p=11, hidden=200, init_scale=1e-05)\n",
+      "Optimizer: PerNeuronScaledSGD(lr=0.01, degree=3)\n",
+      "Training for 5000 epochs\n"
+     ]
+    }
+   ],
+   "source": [
+    "net = model.TwoLayerNet(\n",
+    "    group_size=p,\n",
+    "    hidden_size=hidden_size,\n",
+    "    nonlinearity=\"square\",\n",
+    "    init_scale=init_scale,\n",
+    ")\n",
+    "net = net.to(device)\n",
+    "\n",
+    "criterion = nn.MSELoss()\n",
+    "opt = optimizer.PerNeuronScaledSGD(net, lr=lr, degree=3)\n",
+    "\n",
+    "print(f\"Model: TwoLayerNet(p={p}, hidden={hidden_size}, init_scale={init_scale})\")\n",
+    "print(f\"Optimizer: PerNeuronScaledSGD(lr={lr}, degree=3)\")\n",
+    "print(f\"Training for {epochs} epochs\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a9adb0e",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "dcce029b",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "if not TEST_MODE:\n",
-        "    agf_results = train_agf(\n",
-        "        X_tensor, Y_tensor,\n",
-        "        init_sz=init_scale,\n",
-        "        agf_steps=50,\n",
-        "        from_init=param_history[0],\n",
-        "        utilmax_lr=0.1,\n",
-        "        costmin_lr=0.01,\n",
-        "        costmin_maxiter=1e4,\n",
-        "        loss_thresh=1e-4,\n",
-        "    )\n",
-        "else:\n",
-        "    agf_results = None\n",
-        "    print(\"Skipping AGF in TEST_MODE\")"
-      ]
-    },
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Epoch   500/5000] loss: 0.141917 | reduction:   97.5%\n",
+      "[Epoch  1000/5000] loss: 0.103960 | reduction:   98.2%\n",
+      "[Epoch  1500/5000] loss: 0.103631 | reduction:   98.2%\n",
+      "[Epoch  2000/5000] loss: 0.103321 | reduction:   98.2%\n",
+      "[Epoch  2500/5000] loss: 0.103311 | reduction:   98.2%\n",
+      "[Epoch  3000/5000] loss: 0.103157 | reduction:   98.2%\n",
+      "[Epoch  3500/5000] loss: 0.101198 | reduction:   98.2%\n",
+      "[Epoch  4000/5000] loss: 0.095021 | reduction:   98.3%\n",
+      "[Epoch  4500/5000] loss: 0.083760 | reduction:   98.5%\n",
+      "[Epoch  5000/5000] loss: 0.069925 | reduction:   98.8%\n"
+     ]
+    }
+   ],
+   "source": [
+    "loss_history, val_loss_history, param_history, param_save_epochs, final_epoch = train_mod.train(\n",
+    "    net,\n",
+    "    dataloader,\n",
+    "    criterion,\n",
+    "    opt,\n",
+    "    epochs=epochs,\n",
+    "    verbose_interval=max(1, epochs // 10),\n",
+    "    save_param_interval=1,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7ac6780",
+   "metadata": {},
+   "source": [
+    "## Training Loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d514c9cc",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Loss: GD vs AGF"
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
       ]
-    },
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Compute theoretical loss plateau levels\n",
+    "theory = power.theoretical_loss_levels_1d(tpl)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "ax.plot(loss_history, lw=4)\n",
+    "\n",
+    "for level in theory[\"levels\"]:\n",
+    "    ax.axhline(y=level, color=\"black\", linestyle=\"--\", linewidth=2, zorder=-2)\n",
+    "\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
+    "ax.set_ylabel(\"Train Loss\", fontsize=18)\n",
+    "ax.set_title(f\"Training loss on $C_{{{p}}}$\", fontsize=20)\n",
+    "viz.style_axes(ax)\n",
+    "ax.grid(False)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"{FIGURES_DIR}/cn_loss.pdf\", bbox_inches=\"tight\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c4c5df5",
+   "metadata": {},
+   "source": [
+    "## Power Spectrum Over Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "abc64877",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "fig, ax = plt.subplots(figsize=(8, 6))\n",
-        "ax.plot(loss_history, lw=4, label=\"GD\")\n",
-        "\n",
-        "# Theory plateau levels\n",
-        "for level in theory[\"levels\"]:\n",
-        "    ax.axhline(y=level, color=\"black\", linestyle=\"--\", linewidth=2, zorder=-2)\n",
-        "\n",
-        "# AGF overlay\n",
-        "if agf_results is not None:\n",
-        "    utilmax_lr_val = 0.1\n",
-        "    f = utilmax_lr_val / lr\n",
-        "    agf_times = agf_results[\"t\"] + [epochs]\n",
-        "    agf_losses = agf_results[\"losses\"] + [agf_results[\"losses\"][-1]]\n",
-        "    ax.step(f * np.array(agf_times), agf_losses, where=\"post\", lw=2, ls=\"dashed\", color=\"k\", label=\"AGF\")\n",
-        "    ax.legend(fontsize=14)\n",
-        "\n",
-        "ax.set_xscale(\"log\")\n",
-        "ax.set_yscale(\"log\")\n",
-        "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
-        "ax.set_ylabel(\"Train Loss\", fontsize=18)\n",
-        "ax.set_title(f\"GD vs AGF on $C_{{{p}}}$\", fontsize=20)\n",
-        "viz.style_axes(ax)\n",
-        "ax.grid(False)\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.savefig(f\"{FIGURES_DIR}/cn_loss_agf.pdf\", bbox_inches=\"tight\")\n",
-        "plt.show()"
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
       ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "group-agf",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python",
-      "version": "3.12.0"
+   ],
+   "source": [
+    "# Compute template power for reference lines\n",
+    "num_freqs = p // 2 + 1\n",
+    "template_ft = np.fft.rfft(tpl)\n",
+    "template_power = np.abs(template_ft)[:num_freqs]\n",
+    "\n",
+    "# Compute output power over time\n",
+    "num_points = min(500, len(param_history))\n",
+    "steps = np.unique(np.logspace(0, np.log10(max(1, len(param_history) - 1)), num_points, dtype=int))\n",
+    "powers_over_time = []\n",
+    "\n",
+    "for step in steps:\n",
+    "    net.load_state_dict(param_history[step])\n",
+    "    net.eval()\n",
+    "    with torch.no_grad():\n",
+    "        outputs = net(X_tensor)\n",
+    "        ft = np.fft.rfft(outputs.detach().cpu().numpy(), axis=1)\n",
+    "        avg_power = np.mean(np.abs(ft), axis=0)\n",
+    "        powers_over_time.append(avg_power)\n",
+    "\n",
+    "powers_over_time = np.array(powers_over_time)\n",
+    "\n",
+    "# Plot\n",
+    "colors = [\"tab:blue\", \"tab:orange\", \"tab:red\", \"tab:green\", \"tab:brown\", \"tab:purple\"]\n",
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "\n",
+    "for k in range(num_freqs):\n",
+    "    color = colors[k] if k < len(colors) else f\"C{k}\"\n",
+    "    ax.plot(steps, powers_over_time[:, k], color=color, lw=4, label=rf\"$\\xi = {k}$\")\n",
+    "    ax.axhline(template_power[k], color=color, linestyle=\"dotted\", linewidth=2, alpha=0.5, zorder=-10)\n",
+    "\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_ylabel(\"Power\", fontsize=18)\n",
+    "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
+    "ax.set_title(f\"Power spectrum over training on $C_{{{p}}}$\", fontsize=20)\n",
+    "ax.legend(fontsize=12, title=\"Frequency\", title_fontsize=14, loc=\"upper left\", labelspacing=0.25)\n",
+    "viz.style_axes(ax)\n",
+    "ax.grid(False)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"{FIGURES_DIR}/cn_power_spectrum.pdf\", bbox_inches=\"tight\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc46f55c",
+   "metadata": {},
+   "source": [
+    "## AGF Numerics\n",
+    "\n",
+    "Compare gradient descent training with the Alternating Gradient Flow (AGF) approximation.\n",
+    "AGF decomposes training into alternating utility-maximization and cost-minimization phases,\n",
+    "predicting when each Fourier mode activates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1ea414e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "class ModsumSubNetwork(nn.Module):\n",
+    "    \"\"\"A single neuron of the two-layer network for AGF analysis.\"\"\"\n",
+    "\n",
+    "    def __init__(self, d_in, d_out, init_scale):\n",
+    "        super().__init__()\n",
+    "        assert d_in % 2 == 0\n",
+    "        self.p = d_in // 2\n",
+    "        self.u = nn.Linear(self.p, 1, bias=False)\n",
+    "        self.v = nn.Linear(self.p, 1, bias=False)\n",
+    "        self.w = nn.Linear(1, d_out, bias=False)\n",
+    "        with torch.no_grad():\n",
+    "            self.w.weight.mul_(init_scale)\n",
+    "            self.u.weight.mul_(init_scale)\n",
+    "            self.v.weight.mul_(init_scale)\n",
+    "        self.active = False\n",
+    "        self.util_acc = 0\n",
+    "        self.c_a = 1 / self.get_norm() - 1\n",
+    "        self.normalize()\n",
+    "\n",
+    "    def get_norm(self):\n",
+    "        sqnorm = lambda x: torch.linalg.norm(x.weight) ** 2\n",
+    "        return torch.sqrt(sqnorm(self.w) + sqnorm(self.u) + sqnorm(self.v))\n",
+    "\n",
+    "    def reinitialize(self, u, v, w):\n",
+    "        with torch.no_grad():\n",
+    "            self.u.weight.copy_(u)\n",
+    "            self.v.weight.copy_(v)\n",
+    "            self.w.weight.copy_(w)\n",
+    "        self.c_a = 1 / self.get_norm() - 1\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x1 = x[:, : self.p]\n",
+    "        x2 = x[:, self.p :]\n",
+    "        return self.w((self.u(x1) + self.v(x2)) ** 2)\n",
+    "\n",
+    "    def normalize(self):\n",
+    "        norm = self.get_norm()\n",
+    "        with torch.no_grad():\n",
+    "            self.w.weight.div_(norm)\n",
+    "            self.u.weight.div_(norm)\n",
+    "            self.v.weight.div_(norm)\n",
+    "\n",
+    "    def utility_step(self, x, residual, learning_rate):\n",
+    "        f_i = self(x)\n",
+    "        util = torch.einsum(\"nd,nd->n\", f_i, residual).mean()\n",
+    "        self.util_acc += 3 * learning_rate * util.item()\n",
+    "        norm_th = 1 / (1 + self.c_a - self.util_acc)\n",
+    "        util.backward()\n",
+    "        with torch.no_grad():\n",
+    "            self.w.weight += norm_th * learning_rate * self.w.weight.grad\n",
+    "            self.u.weight += norm_th * learning_rate * self.u.weight.grad\n",
+    "            self.v.weight += norm_th * learning_rate * self.v.weight.grad\n",
+    "            self.w.weight.grad.zero_()\n",
+    "            self.u.weight.grad.zero_()\n",
+    "            self.v.weight.grad.zero_()\n",
+    "            self.normalize()\n",
+    "\n",
+    "\n",
+    "class ModsumNetwork(nn.Module):\n",
+    "    \"\"\"Network of ModsumSubNetwork neurons for AGF simulation.\"\"\"\n",
+    "\n",
+    "    def __init__(self, d_in, d_out, init_scale, width=100):\n",
+    "        super().__init__()\n",
+    "        self.d_in = d_in\n",
+    "        self.d_out = d_out\n",
+    "        self.width = width\n",
+    "        neurons = [ModsumSubNetwork(d_in, d_out, init_scale) for _ in range(width)]\n",
+    "        self.neurons = nn.ModuleList(neurons)\n",
+    "        self.set_mode(\"utilmax\")\n",
+    "\n",
+    "    def load_init(self, U, V, W):\n",
+    "        for i, n in enumerate(self.neurons):\n",
+    "            u, v, w = U[i], V[i], W[i][:, None]\n",
+    "            n.reinitialize(u, v, w)\n",
+    "\n",
+    "    def dormant(self):\n",
+    "        return [neuron for neuron in self.neurons if not neuron.active]\n",
+    "\n",
+    "    def set_mode(self, mode):\n",
+    "        if mode not in [\"utilmax\", \"costmin\"]:\n",
+    "            raise ValueError(\"mode must be utilmax or costmin\")\n",
+    "        self.mode = mode\n",
+    "        for neuron in self.neurons:\n",
+    "            grad_on = (mode == \"utilmax\") ^ neuron.active\n",
+    "            for param in neuron.parameters():\n",
+    "                param.requires_grad = grad_on\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        active = [n for n in self.neurons if n.active]\n",
+    "        if not active:\n",
+    "            return torch.zeros(x.shape[0], self.d_out, device=x.device)\n",
+    "        outputs = torch.stack([n(x) for n in active], dim=0)\n",
+    "        return torch.sum(outputs, dim=0)\n",
+    "\n",
+    "\n",
+    "def train_agf(\n",
+    "    X_train, Y_train, init_sz=1e-3, agf_steps=5, from_init=None,\n",
+    "    utilmax_lr=1, costmin_lr=1, costmin_maxiter=1e4, loss_thresh=1e-4,\n",
+    "):\n",
+    "    \"\"\"Run the Alternating Gradient Flow (AGF) approximation.\"\"\"\n",
+    "    d_in, d_out = X_train.shape[-1], Y_train.shape[-1]\n",
+    "    if from_init:\n",
+    "        U, V, W = from_init[\"U\"], from_init[\"V\"], from_init[\"W\"]\n",
+    "        width = U.shape[0]\n",
+    "        agf_net = ModsumNetwork(d_in, d_out, init_sz, width=width)\n",
+    "        agf_net.load_init(U, V, W)\n",
+    "    else:\n",
+    "        agf_net = ModsumNetwork(d_in, d_out, init_sz, width=agf_steps)\n",
+    "    agf_net = agf_net.to(X_train.device)\n",
+    "    X_train.requires_grad = False\n",
+    "\n",
+    "    results = {\"t\": [], \"losses\": [], \"pred\": []}\n",
+    "\n",
+    "    def update_results(t):\n",
+    "        results[\"t\"].append(t)\n",
+    "        residual = (Y_train - agf_net(X_train)).detach()\n",
+    "        results[\"losses\"].append((residual**2).mean().item())\n",
+    "        results[\"pred\"].append(agf_net(X_train).detach().cpu().clone())\n",
+    "\n",
+    "    t = 0\n",
+    "    update_results(t)\n",
+    "    for _ in tqdm(range(agf_steps)):\n",
+    "        residual = (1 / d_out) * 2 * (Y_train - agf_net(X_train))\n",
+    "        residual = residual.detach()\n",
+    "        iters = 0\n",
+    "        mode = \"utilmax\"\n",
+    "        while mode == \"utilmax\":\n",
+    "            for n in agf_net.neurons:\n",
+    "                if n.active:\n",
+    "                    continue\n",
+    "                n.utility_step(X_train, residual, utilmax_lr)\n",
+    "                if n.util_acc > n.c_a:\n",
+    "                    n.active = True\n",
+    "                    mode = \"costmin\"\n",
+    "            iters += 1\n",
+    "        agf_net.set_mode(mode)\n",
+    "        t += iters\n",
+    "\n",
+    "        agf_opt = torch.optim.SGD(agf_net.parameters(), lr=costmin_lr, momentum=0.9)\n",
+    "        for _ in range(int(costmin_maxiter)):\n",
+    "            agf_opt.zero_grad(set_to_none=False)\n",
+    "            residual = Y_train - agf_net(X_train)\n",
+    "            loss = (residual**2).mean()\n",
+    "            loss.backward()\n",
+    "            agf_opt.step()\n",
+    "        agf_net.set_mode(\"utilmax\")\n",
+    "\n",
+    "        print(f\"loss: {loss.item():.5f}\")\n",
+    "        update_results(t)\n",
+    "\n",
+    "        if not agf_net.dormant() or loss.item() < loss_thresh:\n",
+    "            break\n",
+    "\n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "05e0d0d6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/50 [00:00<?, ?it/s]"
+     ]
     }
+   ],
+   "source": [
+    "if not TEST_MODE:\n",
+    "    agf_results = train_agf(\n",
+    "        X_tensor, Y_tensor,\n",
+    "        init_sz=init_scale,\n",
+    "        agf_steps=50,\n",
+    "        from_init=param_history[0],\n",
+    "        utilmax_lr=0.1,\n",
+    "        costmin_lr=0.01,\n",
+    "        costmin_maxiter=1e4,\n",
+    "        loss_thresh=1e-4,\n",
+    "    )\n",
+    "else:\n",
+    "    agf_results = None\n",
+    "    print(\"Skipping AGF in TEST_MODE\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15f1e058",
+   "metadata": {},
+   "source": [
+    "## Loss: GD vs AGF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75185719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "ax.plot(loss_history, lw=4, label=\"GD\")\n",
+    "\n",
+    "# Theory plateau levels\n",
+    "for level in theory[\"levels\"]:\n",
+    "    ax.axhline(y=level, color=\"black\", linestyle=\"--\", linewidth=2, zorder=-2)\n",
+    "\n",
+    "# AGF overlay\n",
+    "if agf_results is not None:\n",
+    "    utilmax_lr_val = 0.1\n",
+    "    f = utilmax_lr_val / lr\n",
+    "    agf_times = agf_results[\"t\"] + [epochs]\n",
+    "    agf_losses = agf_results[\"losses\"] + [agf_results[\"losses\"][-1]]\n",
+    "    ax.step(f * np.array(agf_times), agf_losses, where=\"post\", lw=2, ls=\"dashed\", color=\"k\", label=\"AGF\")\n",
+    "    ax.legend(fontsize=14)\n",
+    "\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.set_xlabel(\"Epochs\", fontsize=18)\n",
+    "ax.set_ylabel(\"Train Loss\", fontsize=18)\n",
+    "ax.set_title(f\"GD vs AGF on $C_{{{p}}}$\", fontsize=20)\n",
+    "viz.style_axes(ax)\n",
+    "ax.grid(False)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"{FIGURES_DIR}/cn_loss_agf.pdf\", bbox_inches=\"tight\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "group-agf",
+   "language": "python",
+   "name": "python3"
   },
-  "nbformat": 4,
-  "nbformat_minor": 5
+  "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.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
 }
diff --git a/notebooks/cnxcn.ipynb b/notebooks/cnxcn.ipynb
index 3307c24..02aab2d 100644
--- a/notebooks/cnxcn.ipynb
+++ b/notebooks/cnxcn.ipynb
@@ -11,14 +11,16 @@
     "**Sequence length:** $k = 2$ (binary composition).  \n",
     "**Architecture:** `TwoLayerNet` with square nonlinearity.  \n",
     "**Key result:** The network learns one irreducible representation at a time."
-   ]
+   ],
+   "id": "ddbaa284"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Imports"
-   ]
+   ],
+   "id": "d664cd69"
   },
   {
    "cell_type": "code",
@@ -42,14 +44,16 @@
     "import src.template as template\n",
     "import src.train as train_mod\n",
     "import src.viz as viz"
-   ]
+   ],
+   "id": "33e1bcc9"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Configuration"
-   ]
+   ],
+   "id": "39dee331"
   },
   {
    "cell_type": "code",
@@ -77,14 +81,16 @@
     "os.makedirs(FIGURES_DIR, exist_ok=True)\n",
     "\n",
     "print(f\"Group: C_{n} x C_{n}, order {group_size}\")"
-   ]
+   ],
+   "id": "dfaaf6c1"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Template and Dataset"
-   ]
+   ],
+   "id": "e436d336"
   },
   {
    "cell_type": "code",
@@ -105,7 +111,8 @@
     "\n",
     "print(f\"Dataset: {len(ds)} samples\")\n",
     "print(f\"X shape: {X_tensor.shape}, Y shape: {Y_tensor.shape}\")"
-   ]
+   ],
+   "id": "11b79001"
   },
   {
    "cell_type": "code",
@@ -125,14 +132,16 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_template.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "e2a0100f"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Model and Optimizer"
-   ]
+   ],
+   "id": "d328ec49"
   },
   {
    "cell_type": "code",
@@ -154,14 +163,16 @@
     "print(f\"Model: TwoLayerNet(group_size={group_size}, hidden={hidden_size})\")\n",
     "print(f\"Optimizer: Adam(lr={lr})\")\n",
     "print(f\"Training for {epochs} epochs\")"
-   ]
+   ],
+   "id": "3efa2863"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Training"
-   ]
+   ],
+   "id": "7e6e07cf"
   },
   {
    "cell_type": "code",
@@ -178,14 +189,16 @@
     "    verbose_interval=max(1, epochs // 10),\n",
     "    save_param_interval=max(1, epochs // 100),\n",
     ")"
-   ]
+   ],
+   "id": "d24a3efc"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Training Loss"
-   ]
+   ],
+   "id": "62833715"
   },
   {
    "cell_type": "code",
@@ -213,14 +226,16 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_loss.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "b2d40d22"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Predictions"
-   ]
+   ],
+   "id": "0f9f41e8"
   },
   {
    "cell_type": "code",
@@ -251,7 +266,8 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_predictions.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "054e6506"
   }
  ],
  "metadata": {
diff --git a/notebooks/dn.ipynb b/notebooks/dn.ipynb
index 85d2fd5..f5cda64 100644
--- a/notebooks/dn.ipynb
+++ b/notebooks/dn.ipynb
@@ -2,6 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "a6e4bcaa",
    "metadata": {},
    "source": [
     "# Binary Group Composition on $D_n$ (Dihedral Group)\n",
@@ -15,6 +16,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "210231cf",
    "metadata": {},
    "source": [
     "## Imports"
@@ -22,7 +24,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
+   "id": "e2dd1d57",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,6 +50,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "4b719115",
    "metadata": {},
    "source": [
     "## Configuration"
@@ -54,23 +58,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
+   "id": "ea401ba7",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Group: D_3, order 6\n"
+     ]
+    }
+   ],
    "source": [
     "TEST_MODE = os.environ.get(\"NOTEBOOK_TEST_MODE\", \"0\") == \"1\"\n",
     "\n",
-    "seed = 0\n",
+    "seed = 10\n",
     "random.seed(seed)\n",
     "np.random.seed(seed)\n",
     "torch.manual_seed(seed)\n",
     "\n",
-    "n = 5  # D_5 has order 2*5 = 10\n",
+    "n = 3  # D_3 has order 2*3 = 6\n",
     "group = DihedralGroup(n)\n",
     "group_size = group.order()\n",
     "\n",
     "hidden_size = 20 if TEST_MODE else 180\n",
-    "epochs = 2 if TEST_MODE else 2000\n",
+    "epochs = 2 if TEST_MODE else 5000\n",
     "lr = 0.01\n",
     "init_scale = 1e-3\n",
     "\n",
@@ -82,6 +95,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "51c08dab",
    "metadata": {},
    "source": [
     "## Template and Dataset"
@@ -89,14 +103,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
+   "id": "699c266b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Desired powers: [0.0, 30.0, 3000.0]\n",
+      "Irrep dims: [1, 1, 2]\n",
+      "Fourier coef diag values: ['0.000', '13.416', '67.082']\n",
+      "mat for irrep 0 of dimension 1 is:\n",
+      " [[0.]]\n",
+      "\n",
+      "mat for irrep 1 of dimension 1 is:\n",
+      " [[13.41640786]]\n",
+      "\n",
+      "mat for irrep 2 of dimension 2 is:\n",
+      " [[67.08203932  0.        ]\n",
+      " [ 0.         67.08203932]]\n",
+      "\n",
+      "GPU is available. Using CUDA.\n",
+      "Dataset: 36 samples (all 6x6 pairs)\n",
+      "X shape: torch.Size([36, 12]), Y shape: torch.Size([36, 6])\n"
+     ]
+    }
+   ],
    "source": [
     "# Build a template with known Fourier structure on D_n\n",
-    "# D_5 has 4 irreps: two 1D and two 2D\n",
-    "# fourier_coef_diag_values: one value per irrep\n",
-    "fourier_coef_diag_values = [0.0, 5.0, 30.0, 300.0]\n",
+    "# D_3 has 3 irreps with dimensions [1, 1, 2]\n",
+    "# Well-separated powers for clean staircase learning\n",
+    "powers = [0.0, 30.0, 3000.0]\n",
+    "\n",
+    "# Convert desired powers to Fourier coefficient diagonal values\n",
+    "# (matching src/main.py custom_fourier logic)\n",
+    "irreps = group.irreps()\n",
+    "irrep_dims = [ir.size for ir in irreps]\n",
+    "fourier_coef_diag_values = [\n",
+    "    np.sqrt(group_size * p / dim**2) if p > 0 else 0.0\n",
+    "    for p, dim in zip(powers, irrep_dims)\n",
+    "]\n",
+    "print(f\"Desired powers: {powers}\")\n",
+    "print(f\"Irrep dims: {irrep_dims}\")\n",
+    "print(f\"Fourier coef diag values: {[f'{v:.3f}' for v in fourier_coef_diag_values]}\")\n",
+    "\n",
     "tpl = template.fixed_group(group, fourier_coef_diag_values)\n",
     "\n",
     "# Build exhaustive dataset: all group_size^2 pairs\n",
@@ -112,9 +163,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
+   "id": "520c3b23",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Visualize template and its group power spectrum\n",
     "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
@@ -132,12 +195,13 @@
     "ax2.set_title(\"Power spectrum (by irrep)\")\n",
     "\n",
     "plt.tight_layout()\n",
-    "plt.savefig(f\"{FIGURES_DIR}/dihedral_template.pdf\", bbox_inches=\"tight\")\n",
+    "plt.savefig(f\"{FIGURES_DIR}/dn_template.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "d536fbd5",
    "metadata": {},
    "source": [
     "## Model and Optimizer"
@@ -145,9 +209,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
+   "id": "b30529be",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: TwoLayerNet(group_size=6, hidden=180, init_scale=0.001)\n",
+      "Optimizer: PerNeuronScaledSGD(lr=0.01, degree=2)\n",
+      "Training for 5000 epochs\n"
+     ]
+    }
+   ],
    "source": [
     "net = model.TwoLayerNet(\n",
     "    group_size=group_size,\n",
@@ -158,15 +233,16 @@
     "net = net.to(device)\n",
     "\n",
     "criterion = nn.MSELoss()\n",
-    "opt = optimizer.PerNeuronScaledSGD(net, lr=lr, degree=3)\n",
+    "opt = optimizer.PerNeuronScaledSGD(net, lr=lr)  # degree auto-inferred as 2 for TwoLayerNet\n",
     "\n",
     "print(f\"Model: TwoLayerNet(group_size={group_size}, hidden={hidden_size}, init_scale={init_scale})\")\n",
-    "print(f\"Optimizer: PerNeuronScaledSGD(lr={lr}, degree=3)\")\n",
+    "print(f\"Optimizer: PerNeuronScaledSGD(lr={lr}, degree={opt.param_groups[0]['degree']})\")\n",
     "print(f\"Training for {epochs} epochs\")"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "99594a2b",
    "metadata": {},
    "source": [
     "## Training"
@@ -174,9 +250,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
+   "id": "ade94d19",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Epoch   500/5000] loss: 5.032102 | reduction:   99.0%\n",
+      "[Epoch  1000/5000] loss: 5.044927 | reduction:   99.0%\n",
+      "[Epoch  1500/5000] loss: 5.060741 | reduction:   99.0%\n",
+      "[Epoch  2000/5000] loss: 5.080063 | reduction:   99.0%\n",
+      "[Epoch  2500/5000] loss: 5.103499 | reduction:   99.0%\n",
+      "[Epoch  3000/5000] loss: 5.127010 | reduction:   99.0%\n",
+      "[Epoch  3500/5000] loss: 5.137788 | reduction:   99.0%\n",
+      "[Epoch  4000/5000] loss: 5.143885 | reduction:   99.0%\n",
+      "[Epoch  4500/5000] loss: 5.136471 | reduction:   99.0%\n",
+      "[Epoch  5000/5000] loss: 5.138467 | reduction:   99.0%\n"
+     ]
+    }
+   ],
    "source": [
     "loss_history, val_loss_history, param_history, param_save_epochs, final_epoch = train_mod.train(\n",
     "    net,\n",
@@ -185,12 +279,14 @@
     "    opt,\n",
     "    epochs=epochs,\n",
     "    verbose_interval=max(1, epochs // 10),\n",
+    "    grad_clip=0.1,\n",
     "    save_param_interval=1,\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "31ee1553",
    "metadata": {},
    "source": [
     "## Training Loss"
@@ -198,9 +294,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
+   "id": "3e1d3b93",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing loss plateau predictions for template of shape: (6,)\n",
+      "Found  2 non-zero power coefficients.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJOCAYAAAAqFJGJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYTpJREFUeJzt3Xd8lfXd//H3Odk7BDLYBJGloCJgBWW60crtVtwK2p+1d2sdrW0FR2tbR623VRwIVYt1FzeyFcGBA2ULhBUIOYGQ5JzMk3P9/oiccjjXSQ5n5py8no9HHuZ8r+t7zudADHnnuyyGYRgCAAAAgCBYo10AAAAAgNhHsAAAAAAQNIIFAAAAgKARLAAAAAAEjWABAAAAIGgECwAAAABBI1gAAAAACBrBAgAAAEDQCBYAAAAAgkawAAAAABA0ggUAAACAoBEsAAARM2fOHFksFlksFm3bti1mXyOS4u39AIhfBAsAiCHbtm1z/5AZzAeA8Jg5c6bp/3NWq1U5OTnq3bu3zjzzTP3hD3/Q+vXro10uEFIECwAAgBD59ttvTdsNw1B1dbV27Nihjz76SA888IAGDx6s8847T6WlpZEtEggTi2EYRrSLAAD4p6mpSRs3bvR5fciQIZKk4cOHa/bs2T7vO/bYY0NeG8Jjzpw5uu666yRJJSUl6tOnT3QLQqt+8pOf6PPPP1dubq4++eQTd7vL5VJNTY127NihlStX6uWXX1ZFRYUkqbCwUJ9++qmOOuqoaJUNhATBAgDiyMFpTmPHjtXSpUujWwxCgmARO1wul7KyslRbW6sxY8Zo2bJlPu+12+265ZZb9MILL0iSjjnmGK1evVoJCQmRKhcIOaZCAQAAhMCmTZtUW1srSTr++ONbvTczM1OzZ8/W2LFjJUlr167V3Llzw10iEFYECwDowGbMmOGxoLuqqkr333+/TjjhBOXm5spisWjOnDnu+9esWaMHHnhAZ555pnr06KGUlBRlZmbq6KOP1jXXXKPPPvus1ddra4ejw+upr6/XQw89pGHDhikrK0tZWVkaOXKknnjiCTmdzqi9xqH27dunO++8UwMGDFBaWpoKCwt1+umn66233vKrnlBpbGzUk08+qfHjxys/P1/JyckqKirSOeeco5deekkul6vV/rt379ZvfvMbDRs2TDk5OUpKSlJhYaGGDBmiyy+/XHPmzFF1dXXI+kXifYX677oth66vOO6449q832q16ve//7378Ztvvhl0DUBUGQCAuCHJkGSMHTvWr/unT5/u7rNp0yajT58+7scHP2bPnm0YhmEsWbLE65rZx29+8xufrzd79mz3fSUlJa3WU1ZWZhx//PE+X+e8884zmpubo/IaB3333XdGYWGhz/7Tpk1rs562+NO/pKTEGDhwYKt/L6eccoqxb98+0/4ff/yxkZ2d3ebf7TvvvBOSfv4K9n2F8u/aH3fddZf7+VatWuVXn/r6eiM5OdmQZBQVFQX1+kC0MWIBAJAkXXTRRSotLdWtt96qBQsWaNWqVXr55Zc1YMAASZLT6VRGRoYuueQSzZw5U0uXLtXXX3+tDz/8UI888oh69+4tSfrzn//c6sJxf11wwQVat26dfvGLX2jBggX66quvNHfuXA0aNEiS9M477+jZZ5+N2mscOHBAZ511lvbu3StJuuqqq/TBBx9o1apV+ve//62TTz5ZzzzzjGbOnBlUjW2x2+2aOHGiNmzYIEmaPHmy3n77ba1atUqvvfaae6rN8uXLdd5556m5udmjf0NDgy677DJVV1crKytLd955pz744AN99dVXWrlypebOnauf//zn6t69e0j6Rep9HS4SX08HRywSEhJ0zDHH+NUnJSVF+fn5kqSKigoZLH1FLIt2sgEAhI6CGLGwWq3G/Pnzfd5rs9mMyspKn9cbGhqM008/3ZBk9O7d23A6nV73HMloQlJSkrFkyRKve/bt2+ceJRg6dGhUXsMwDOOXv/yl+3kee+wxr+tOp9M4//zzPX4rHo4Ri9tvv919/fe//73XdZfLZUyZMsV9z5NPPulxfdGiRX6NLDQ1NRlVVVVB9/NXsO/LMEL3d+2vg88zePDgI+pXXFxsSDIsFovR1NQUVA1ANDFiAQCQJF177bU644wzfF7v0qWLcnNzfV5PTk7WQw89JEnavn27z/38/XXrrbdq3LhxXu15eXnuXZK+//57VVVVRfw1Ghoa3GtPRowYof/93//1eo6EhAQ9/fTTSk1NDbi+tjQ0NOi5556T1LKr0IwZM7zusVgsevLJJ9W5c2dJ0hNPPOFxvayszP35mDFjfL5WYmKisrOzg+7nj1C8r8OF++uprKzMPXrlz/qKQ1VWVkqScnNzlZiYGNDrA+0BwQIAIEmaMmXKEd3f0NCgHTt2aN26dVqzZo3WrFnjMY1j9erVYavnxBNPlCQZhqGSkpKIv8aqVat04MABSdKVV17p8zkKCwt15plnBlxfW7766it3Hddee63PrUqzs7N1ySWXSJLWrVunPXv2uK917drV/fmRTGELtJ8/QvG+Dhfur6cjXbh9UGNjozvMFBYWBvTaQHtBsAAASJKGDh3a5j0Oh0MPPvigjjvuOGVkZKh379465phjNGTIEA0ZMkQnnHCC+96Dh38FauDAgT6v5eXluT+vqamJ+GusWbPG/fnBH0p9GT58eIDVte3QOk466aRW7z30+qH9TjnlFPXt21eS9Mtf/lIjR47Ugw8+qE8//VSNjY0+ny/Qfv4Ixfs6XLi/ngINFl9//bU7kB/6Xurr63XbbbdpzJgx6tatm1JTU1VUVKTRo0dr9uzZampqCqhOIJwYbwMASJI6derU6vVt27ZpwoQJfv9Gt66uLqh60tPTfV6zWv/7e7G2Fu2G4zUOTl2R5F5460tb14Oxf/9+9+cFBQWt3ltUVGTaLykpSe+8844uuugirV+/Xl9++aW+/PJLSVJaWprGjBmjq6++WpdeeqnHyEGg/SL1vg4X7q+nQIPF8uXL3Z8fOhXRbrfrqaee0siRIzVp0iTl5+ersrJSH3zwga6//nr9+9//1gcffOBROxBtfDUCACSpzR/+rrrqKpWUlMhisej666/XRx99pJ07d6q+vl4ul0uGYXj8UGawu01EHTyrIRCDBw/W999/r7feekvXX3+9+vXrJ6klHM6fP19TpkzRSSedpPLy8pD0i9T7iqSDwSI/P99jmlhbnn/+eUktYezQaXN5eXmqqqrSsmXL9Oyzz+pPf/qTnnrqKW3evFnjxo3TRx99pA8++CCk7wEIFsECANCmDRs2uH+zevfdd2vWrFk6/fTT3YfkHfzhr7XfGMeTQ0d3bDZbq/e2dT0Yh07hObhw2JdDF1sf2u+ghIQETZ48WbNmzdIPP/yg3bt36/nnn3dP9frqq6900003haxfpN5XJNTW1uqHH36QdGSjFfPmzdP69eslSddff717IbrUMoqSnJzs1ScxMVH/8z//I0navHlzMGUDIUewAAC0ae3ate7PL730Up/3rVq1KhLlRN2hZxR89dVXrd4bzj+TY4891v35559/3uq9X3zxhWk/X7p27arrrrtOK1eu1LBhwyRJ7777bptT3ALtd6hwvq9w+O6779wngPsbLMrLy92BKzU1Vbfffrtf/Vwulz788ENJ0Xu/gC8ECwBAm5xOp/tzh8Ph875wHwbXXgwfPlw5OTmSpJdeesnnfXv37tX8+fPDVseJJ57o3gL4n//8p/uH28PV1NTo1VdfldQyfelIpuokJSW5D6NzOp3u3ZrC1U+KzPsKpSNdX7Fnzx6PwxUff/xx9enTx/TexsZGzZgxQ9OnT9fPf/5zHXPMMfrggw903XXXaeLEiaEoHwgZggUAoE1HH320+/OD5zcc7qmnntK8efMiVFF0paam6uqrr5Ykffnll/r73//udY/L5dJNN92k+vr6sNWRkpKiG2+8UVLLjkj333+/1z2GYejnP/+5e5eun//85x7XP/nkk1an1DQ2NmrZsmWSpMzMTPdi9ED7Rep9RZK/wcIwDM2dO1cjR47UN998I0maNm2apk6d6rNPY2Oj7r33Xt133336xz/+oY0bN+r222/XM888E7L6gVBhVygAQJtOOOEEHXvssVqzZo2efvppVVZW6qqrrlLXrl21a9cuvfTSS3r99dc1evRoffrpp9EuNyJmzJih1157TWVlZfrlL3+pr776SlOmTFF+fr42b96sv//971qxYoVGjhzpnq4TjoXI99xzj958801t3bpVM2bM0Pfff6/rrrtOXbt2VUlJiZ544gktXbpUknTyySdr2rRpHv0XLVqk+++/X6eeeqomTZqkoUOHKj8/X3V1ddq0aZNmzpypr7/+WpJ0ww03uA9wC7RfpN5XJB0MFlarVc3Nze5tb10ulyorK7V37159+umneu+997RlyxZJLV8Lf/rTn/Sb3/ym1efOzMyUYRhyuVzavXu33nnnHd19991auXKl3n///SM+fBAIJ4IFAKBNFotFL774oiZMmKDKykq9+uqr7ikoBw0ZMkSvvfaaunXrFqUqIysvL08ffvihTj/9dNlsNr344ot68cUXPe659tprdeqpp7qDRThO4c7KytKiRYt09tlna8OGDXrjjTf0xhtveN03evRovf3226a7f7lcLi1btsw9wmDm/PPP14MPPhiSfv4IxfuKBJfLpe+//979+cF1Jb5YLBZNnjxZv/vd79o8A+VQVqtVPXr00M9+9jN16dJFl1xyif74xz/qL3/5S1D1A6FEsAAA+OX444/Xt99+qwcffFAffPCBdu/eraysLPXr10+XXHKJbrnllrD84NyeHXfccVq3bp3+/Oc/6+2339aOHTuUlZWlIUOGaOrUqbr88sv12GOPue8/uC4j1Pr06aPVq1fr2Wef1WuvvaY1a9aourpaeXl5OuGEEzRlyhRdccUVpmce3H777Ro6dKgWLlyob775Rrt373ZvD1tUVKSRI0fq6quv1qRJk0LSL1LvK1I2bdqk2tpa02tZWVnKy8tTXl6ehg4dqlNPPVUTJkxQcXFxUK958LyLgyM2QHthMdhoHACAsLnxxhs1a9Ys9ejRQzt37ox2OYgD69ev1+DBgzV69GiPA/aAaGPxNgAAYVJXV+de0P6Tn/wkytUglqxbt850JKS2tla33XabJOmcc86JdFlAq5gKBQBAgLZs2aK+ffuaLspubm7Wz372M/euRddcc02ky0MMe/XVV/Xoo4/qlFNOUZ8+fZSdna3S0lJ98MEH2rdvn0499VT96le/inaZgAemQgEAEKBrr71WX3zxhS677DKddNJJKigoUF1dnb777js9++yz7l2RTjvtNH300Udh2RUK8WnVqlV65plntGLFCpWWlsputysnJ0dDhw7VZZddpuuvv/6Id9oCwo1gAQBAgK699lr985//bPWe0aNHa968eercuXOEqgKA6CBYAEFyuVzat2+fR1vnzp2juksJgMjYuHGj3njjDS1cuFDbtm2TzWZTU1OTOnfurOHDh+vSSy/VZZddxvcDAB0CwQIIks1mU0FBgUdbeXn5EZ0yCwAAEOv4FQoAAACAoBEsAAAAAASNYAEAAAAgaAQLAAAAAEEjWAAAAAAIGierAH5wOBwBXQMAAOgoCBaAHzIzM6NdAgAAQLvGVCgAAAAAQWPEAvCD3W73ec1ms6m4uDiC1QAAALQ/BAvADxkZGT6v1dbWRrASAACA9ompUAAAAACCRrAAAAAAEDSCBQAAAICgESwAAAAABI1gAQAAACBoBAsAAAAAQSNYAAAAAAgawQIAAABA0AgWAAAAAIJGsAAAAAAQtMRoFwDEo483lSu3whW257daLUqyWpWYYFFSgkVJCVYlWq1KSrAoMcGqROuPbQmH3tdy3WKxhK0uAADQcREsgDD45SurlZCeE+0yTCVYLR7B47+B5Mfw8WMQSUywKsn63/ZEa0tbskm/Q0NNkvu5rUqwSglWqxIsLa9r/fG1rRaLEqwtH1bLj21WixJ+bPe+7+DzWGS1tjzXwXuTEqxKTvwxTCX+WN+Pz02IAgAgcggWgB8cDkdA19qjZpehZpehBmf4RlTaA4ukpMQfg06iVU0N9bJXV0kup9TslIxmydXs/txobpZcTmWmp2n8uDHugJKUaNWShQtUunNHS19XswxXy71yNkrNje7/nn3G6Zp2/TVKTUpQWnKCUpMSdNKJx/943SnJ8FnvSy+9pHHjxrkfL126VFdeeaVf73XXrl0ej++99149++yzbfYbO3as/vWvf3m0TZgwQZs2bWqz7z333KNp06a5H+/Zs0cjRozwq95FixZpwIAB7sdz587VnXfe2Wa/oqIirVq1yqPtpptu0nvvvddm38svv1wPPfSQR9vAgQNlt9vb7Dtz5kyde+657sdfffWVzj///Db7SdL69euVlZXlfvzoo4/q0UcfbbPfsGHD9Pbbb3u0/fSnP9XXX3/dZt/bbrtNt912m/txTU2NBg0a5Fe98+bN04knnuh+/O677+rmm29us19mZqY2bNjg0XbHHXfo5ZdfbrPvpEmT9PTTT3u0DR8+XGVlZW32/etf/6orrrjC/Xjjxo2aOHFim/0k6csvv1TXrl3dj5955hndd999bfbr37+/Fi9e7NE2ZcoULVu2rM2+U6dO1fTp0z3aevTo4Ve9fI/ge8ShIv094vCvIV8IFoAfMjMzo10CjpAhqdHpUqMkNTZLSpAlI8/n/QfHNmolvffdHs+LWQNkHTzg8C5ePmqUPpq50qMt8eL//gPhamqQ4WyQ0dQgw9koo6lBrh8fP/Jlrd7c842yUhOVmZqosh11qi48Qa4Gx48fdXI1OGQ01srVUCtXg6MlGJmoqqpSaWlpm/VWVFR4te3du9evvof/Y9vc3OxXP0lyOp0ej2tra/3ue7j9+/f71beystKrbffu3aqpqWmzb11dncfjxsZGv+s1DM8wWV1d7Vffnj17erXZbDa/+lZXV3vV4G+9jY2NHo/r6ur86nvoD0YHVVZW+tV3//79Xm1lZWV+9a2trfV47HQ6/X6vzc2e///Y7Xa/+ubkeI9GV1RU+NW3qqrKq83fehsaGrweB/r/Dd8jvPE9IrA/38MRLAAgQqxJKVJSipTmfe37fYa+37fboy3v9NZ/U2w4G6WmOo1/eKmy05KUl56kThnJ2ph+jHqccYPUYJca7DLq7T9+XiM11ko//kPWpUsXr+csLCw0/eHncIeH7YSEBHXv3r3NfpKUmOj5T096erpffYuKirza8vLy/OrbqVMnr7Zu3br59dvItDTPv7Dk5GS/3+vh0/Gys7P96pufn2/a5k/f7Oxsrxr8rTc5OdnjcVpaml99zX750qlTJ7/65uV5B36zv2sz6enpHo8TExP9fq8JCQkejzMzM/3qW1hY6NXWpUsXv/qahRJ/601JSfF67G9fszr86cv3CL5HHCmLcXhUAuCltelONptNxcXFHm09bv1Xu11jgY7NYpFy05KUl5GswuxUFWanqiA7RYVZqT8+TlFhdqrys1KUmpTQ9hMCAPAjggUQJJvNpoKCAo+2dz5br06dvX/TEwqGITUbhpzNLjU1G2pqdsnpavnc2Wwc8rlLTteP15sNNblcanL6vu5udx3yvO7n/+/rOV2e7U0/tiP+5KYnqSg7Vd1z09QzL109OqWpR6d09cxr+W9OWlK0SwQAtCMECyBIZsGivLzcdJgyXhlGy4Lww4PMwYXiLldLGDr4uNllyHXw8SHtrh8fOw9+7r5Pcrpc7s/d9zV7hqFGp8v7c+eP4cdlqMnpavVzp8vzOZqcrpZA1txSCzxlpyaqR6d09e6crr75GToqP1NH5Weqb36GslIJHQDQ0bDGAkDQLJYft51NUNxOn3G5DHfIaHK61NjsUn1Ts+qamlXX2PLfhiaXx+P6Hz9a2lw/3vPj4x/va7nHpdomp+z1TtXUO+WMkRBTXe/Uuj3VWren2utaYXaK+nbJ1FEFGRpQmKVBXbM1sGu2MlP4ZwcA4hXf4QHAD1arRSnWBKUkSkpp8/aAGUbLVsDV9U3uoGFvcKqmvknV9c5D2ppU8+Pn1fVNqqpr0n5HoyodjXI0mu8WFUl7qxu0t7pBK7fu82jv3Tldg4qyNahrtgZ3y9ZxPXJUkJ0apSoBAKHEVCggSEyFQntT39SsA7U/Bo3aRs//Ohq1z9GoCnuDyqsbVFZdr9ooB5FuOak6oVcnHd8zVyf0ytWx3XPiduQLAOIZwQIIEsECsc7e4NTe6nrtra5XeXXDj5+3/Hd3VZ127q9Thb2h7ScKkUSrRcd2z9HJR3XWT/p21vDenZTBFCoAaPcIFkCQCBboCOoam1V6oFY7K+u0a3+tdlXWaWdlrXbsr1WJzRHW6VeJVouG9MjRqKM6a8zR+RrWu5OSEqxhez0AQGAIFoAfjvQcC4IFOhLDMLS3ukFbbXZtsdm1xeZo+W+5Xbur6kP+elmpiTr16C4a179AYwfkq5A1GgDQLhAsAD8cfjJmWwgWQIvq+iZt2FOj9Xuq3R8bymrU4HSF7DWO75mrs48t0tnHdlWvzultdwAAhAXBAvADwQIIHWezSyUVDq3eVaVvd1bqmx0HtKGsJiRnhQzumq1zhhTp/OO7q2ceIQMAIolgAfiBqVBAeNU1Nuv70ip9s6NSX27br89L9qum3hnUc47sk6f/GdZd5wzpyinhABABBAsgSCzeBkKv2WVo3e5qfbZ1nz7buk+fl+yXvSGwoJGcaNU5xxZpyk96a3jvTkc8AgkA8A/BAggSwQIIv0anS19tr9TSjeVautGmjXtrAnqe/oWZmnJSb10wrLuyUhnFAIBQIlgAQSJYAJG3+0CdFq3fqw/WlOnzkv1HvD4jKyVRl43sqWtHF6t7blqYqgSAjoVgAQSJYAFE135HoxasK9P735dp+eaKIwoZCVaLzhnSVbeMP0oDi7LDWCUAxD+CBRAkggXQfthqGvTO6t36z7el+m5X1RH1nTS0q3458WgdXZgVpuoAIL4RLIAgESyA9mlzeY1eXbVLr63aqcraJr/6WCzSeUO76RcTj1a/gswwVwgA8YVgAQSJYAG0b/VNzfpwTZle+my7Vm2v9KuP1SJdOKyH7jhzgAo42RsA/EKwAPzAORZAfPh+V5WeW75V7363x6+1GBnJCfr5hKN1/Sl9lJKYEIEKASB2ESwAP3DyNhBfdh+o0/PLS/TS59tV3+Rq8/7endP1+0mDddqgAs7BAAAfCBaAHwgWQHyy1TTo6WVb9OJn29XgbDtgjB+Qrz/+zxB1Y4taAPBCsAD8wFQoIL6VV9fryaVbNPeLHWpsI2BkpiTqd5MG6bIRPRm9AIBDECyAILF4G4gfe6rq9JcPNug/3+5u897R/TrrzxcMVc+89AhUBgDtH8ECCBLBAog/X23fr3vfWdfmWRjpyQm696fH6OLhPSNUGQC0XwQLIEgECyA+uVyG3vh6l/7y4UZV2BtavfeCE7rr/snHKiMlMULVAUD7Y412AQAAtEdWq0UXD++pRbeN1YXDerR675vflOq8J5Zr3e7qCFUHAO0PwQIAgFbkpCfpkUuO0+zrRqhrju/D8rbaHJr85Kd69cudEawOANoPggUAAH4YP6BAH/1qjC4f6Xs9RaPTpTvf+E73v7vOrwP4ACCeECwAAPBTVmqSHrxgqGZeOUxZqb7XU8xaXqLr53yp6vqmCFYHANFFsAAA4AiddWxXvf+LU3Vcz1yf9yzbZNMFT67Qjn21kSsMAKKIYAEAQAB65qXrtZtO1tRTi33es7ncrgtnrtD6PSzqBhD/CBYAAAQoOdGq300arMcuPV7Jieb/pNpqGnTJ0yu1atv+CFcHAJFFsAAAIEiTT+iuV6b9RPlZKabXa+qdunLW51qysTzClQFA5BAsAAAIgRN6ddK8W0brmG7Zptfrm1ya+s9V+nBNWYQrA4DIIFgAABAi3XLT9MpNJ2t0v86m150uQ7e+/LUWrd8b4coAIPwIFgAAhFBmSqKev3aEzj62yPR6U7Ohn730tZZtskW4MgAIL4IFAAAhlpKYoCeuGKbLRpgfptfY7NK0F1ZpxeaKCFcGAOFDsAAAIAwSrBY9eMEQXTuqj+n1BqdLU19YpTWlVZEtDADChGABAECYWCwWTT9vsK78SS/T647GZl0350vtquQQPQCxj2ABAEAYWSwW3ffTY3XpcPNpUbaaBl07+0tV1TZFuDIACC2CBQAAYWa1WvSnC4bof07obnp9c7ldU19YpQZnc4QrA4DQIVgAABABCVaL/nrRUJ16dBfT619s26/p89bKMIwIVwYAoUGwAAAgQpISrHpyyjAN7mp+iN6/v9ypf32+I8JVAUBoECwAAIigrNQkzb5uhLrnpplev/edtVq1bX+EqwKA4BEsAACIsMLsVM2+boQykhO8rjU1G7r5pa9VVlUfhcoAIHAEC8APDoej1Q8AOFL9C7P0yCXHm16rsDfol698o2YX6y0AxA6LwSoxoE0Wi+WI7i8vL1d+fn6YqgEQTx79aKMeX7zZ9NqvT++vWyceHeGKACAwjFgAABBFvzytvyYOLDC99tiiH1hvASBmECwAP9jtdp8fJSUl0S4PQAyzWi169NLjTRdzN7sM/eLlbzg8D0BMIFgAfsjIyGj1AwCCkZOWpMcvP0EJVu9pl7ur6jXjnbVRqAoAjgzBAgCAduDE3p102+n9Ta+99U2pFqzbG+GKAODIECwAAGgnbh57lEYd1dn02t1vfa8DtY0RrggA/EewAACgnUiwWvToJccrKzXR65qtpkH3vrMuClUBgH8IFgAAtCNFOam659zBptfe+qZUSzaWR7giAPAPwQIAgHbmohN7aPwA87Nwps9bq/qm5ghXBABtI1gAANDOWCwWPXjBUNMpUTv21+rJJeYH6gFANBEsAABoh4pyUnX3OYNMr81ctlVbbfYIVwQArSNYAADQTl06vKdO6JXr1d7Y7NI989bKMIzIFwUAPhAsAABop6xWix6YfKxMzs3T8s0VWrSehdwA2g+CBQAA7dgx3XJ0zag+ptf+9P56NTW7IlsQAPhAsAAAoJ277fT+6pKZ4tW+tcKhuZ/viEJFAOCNYAEAQDuXlZqk28/ob3rtsYWbVFXXFOGKAMAbwQIAgBhw8fCeGliU5dVeWdvE9rMA2gWCBQAAMSDBatHvJplvP/vPldtUXl0f4YoAwBPBAgCAGHHq0fmmJ3LXN7n05NItUagIAP6LYAEAQAy56+yBsphsPzv38x3afaAu8gUBwI8IFgAAxJCBRdk6d2g3r/bGZpf+bzFrLQBED8ECAIAY88vTjjY9NO+1VTu1c39t5AsCABEsAACIOUflZ+qCYT282p0uQ898vDUKFQEAwQIAgJj0vxOPVqLJsMWrq3bKVtMQhYoAdHQECwAAYlDPvHRNPqG7V3uD06XnPy2JQkUAOjqCBQAAMermsUeZ7hD14srtnMYNIOIIFgAAxKh+BZk665gir3Z7g1MvfbY9ChUB6MgIFgAAxLD/N66fafsLK7epqdkV4WoAdGQECwAAYtiQHjk69eguXu17qxv0/vd7olARgI6KYAEAQIy74ZRi0/bnl5fIMIwIVwOgoyJYAAAQ48b2z1e/gkyv9tW7qvT1jgORLwhAh0SwAAAgxlksFl03uo/pNbaeBRApBAsAAOLABSf0UE5aklf7/DVlHJgHICIIFgAAxIG05ARdPrKXV7vTZeiNr3dFoSIAHQ3BAgCAODHlpF6mB+a9/MUOuVws4gYQXgQLAADiRM+8dJ16dL5X+/Z9tVq5dV8UKgLQkRAsAACII1eM7GnaPveLHRGuBEBHQ7AAACCOTBxUqC6ZKV7tH60tU4WdRdwAwodgAfjB4XC0+gEA7UVSglUXD+/h1d7UbOiNr1jEDSB8CBaAHzIzM31+FBebn3gLANFy2Qjz6VCvrNrJSdwAwoZgAQBAnOndOUOn9Ovi1b7V5tCa0uooVASgIyBYAH6w2+0+P0pKONUWQPtjNh1Kkt76pjTClQDoKAgWgB8yMjJa/QCA9ub0wYVKT07wan/nu91yNruiUBGAeEewAAAgDqUnJ+qsY4q82m01DVqxhTMtAIQewQIAgDg1+YTupu3/YToUgDAgWAAAEKdGHdVZ+VneZ1p8uLZMtY3OKFQEIJ4RLAAAiFOJCVb99LhuXu21jc1asG5vFCoCEM8IFgAAxLHJx5tPh3r3uz0RrgRAvCNYAAAQx47tnq2j8r13r/t4k02OBqZDAQgdggUAAHHMYrFo0pCuXu0NTpeWbCyPQkUA4hXBAgCAOHfWsd7BQpI+XFMW4UoAxDOCBeLG999/rwceeEBnnHGGunbtquTkZOXk5GjEiBG67777VFlZGe0SASAqBnXNUq+8dK/2JRvKVd/UHIWKAMQji2EYRrSLAIK1ZcsW9evXz/24W7du6tatm/bs2aPS0pb92rt27ar58+dryJAhIX1tm82mgoICj7by8nLl5+eH9HUAIBgPvr9eT3+81av9uauH67TBhVGoCEC8YcQCccEwDOXn52vGjBnasmWLSktL9eWXX2rXrl1avny5evfurT179mjy5MlqaGiIdrkAEHFnHet9CrckfcB0KAAhQrBAXOjRo4dKSko0ffp09e3b1+Pa6NGj9a9//UuStHXrVs2fPz8aJQJAVB3XI1dF2ale7QvX71VTsysKFQGINwQLxIXU1FRlZHhvp3jQ6NGjlZOTI0lav359pMoCgHbDarWYjlpU1TXp8637o1ARgHgTk8GiublZ3333nWbNmqWf/exnGj58uJKTk2WxWGSxWDRu3LiwvO6cOXPcr+Hvx4033hiWWqIhnH/ujY2NevHFF3XOOeeod+/eSk1NVdeuXTVq1Cg9/PDDqqioCKp2p9OppqYmSWo1gABAPPM1HYptZwGEQmK0CzhS//nPfzRlyhTV1tZGu5QOJZx/7hs2bNDll1+ub7/91qO9rKxMZWVlWrlypR566CHNnj1b55xzTkCv8Z///Mdd+9ixY4MtGQBi0vDenZSTlqSquiaP9iUby/WHcwdHqSoA8SLmgsWBAwfaRagYOHCgJk6c2OZ9o0aNikA14ReuP/ddu3Zp4sSJ2r17t6SWg5zGjBmjo446SjabTQsXLlRdXZ3Ky8s1efJkffjhh5owYcIR1/7rX/9aknTeeeeFfFcoAIgViQlWjemfr3dW7/Zo32pzaPs+h3p3ZkQXQOBiLlgcVFhYqBEjRrg/5s+fr7///e8Re/2TTjpJTzzxRMRer70I9Z/7FVdc4Q4VvXv31rx583Tccce5r1dUVOiyyy7TokWL1NTUpIsvvlhbtmxRbm6uX8/vdDp12WWXaceOHcrPz9fMmTMDrhUA4sGEgd7BQmo50+La0cVRqAhAvIi5YHHWWWdp+/bt6tWrl0f7559/HqWKIsPhcAS8NsButyszMzOo1w/Hn/v777+vTz75RJKUnJysd955x2s0oUuXLpo3b56GDh2qrVu3av/+/frrX/+qP/3pT20+v8vl0jXXXKP58+crKytL77zzjrp16xZwvQAQD8YcnS+LRTr8FKvFG20ECwBBibnF20VFRV4/3Ma7Tz/9VMXFxVq2bNkR912wYIH69u0bdPAKx5/7P/7xD/fn11xzjc8pShkZGbrvvvvcj59++mk5nc5Wn9swDN1www2aO3euMjIy9N577+mkk04KTeEAEMM6Z6bouB65Xu2fbd2n2sbWv7cCQGtiLlh0NOvXr9c555wjm82mSZMmafny5X73Xbx4sc4//3zZbDadddZZ2rRpUxgrPTJ2u12LFi1yP77uuutavf/CCy90j7rs379fH3/8sc97DcPQtGnTNGfOHKWnp+vdd9/VqaeeGprCASAOTBhY4NXW6HRpxeZ9UagGQLwgWLRz/fr105gxYyS1TIc6++yztWLFijb7LV26VOedd57q6uokSePHj/c6OC6aVqxY4T4BOyMjQyNGjGj1/tTUVJ188snux4sXL/Z57y233KLnnntOaWlpevvtt8O2/TAAxKrxA7yDhcS2swCCE3NrLNqLAwcO6LXXXtPatWtVVVWl7OxsdevWTSeffLKGDBkii8USktdJSkrS66+/7t4RyW636+yzz9ZHH33kc2rPJ598onPPPde9i9O5556rV155RYmJ7eev+9BD6oYMGeJXbcOGDdOCBQu8+h/qF7/4hZ566imlpqZq3rx5fu3cBQAdzTHdspWflSJbTYNH+7JNtihVBCAetJ+fNGPMvHnzNG/ePNNrRx99tO666y5df/31IQkYKSkpeuutt3Teeedp4cKFqq6u1plnnqkFCxZ4/ab/008/1TnnnCOHwyFJOvvss/X6668rKSkp6DpCaePGje7Pe/fu7VefQ9d4bNiwwev6nXfeqf/7v/9zh4rTTz89+EIBIA5ZrRaN65+v177a5dG+q7JOO/bVqlfn9ChVBiCWMRUqDH744QfdeOON+ulPf+r+AT9YB39YPni4W1VVlc444wx9/fXX7ntWrlyps88+W3a7XZJ0+umn680331RKSkpIagilffv+O4+3sLDQrz5FRf89MXb//v0e1w4eoidJ2dnZuu+++3TKKaeYfvizo9ThHA5Hqx8AEGtOObqLafunWyoiXAmAeMGIxRHq1auXLr74Yk2cOFFDhgxRfn6+mpubtWvXLi1atEiPP/64+7fp7777rq644gq99dZbslqDz3Dp6el67733dOaZZ+rTTz/VgQMHdNppp2nx4sVqbGzUWWedpZqaGkktayrmzZun1NTUoF83HA6GH0lKS0vzq8+h9x3aX5J7vYYklZeXq7zc9zzhfv36+VumW7Db9QJAe3PyUZ1N2z/dXKHLR3as3RcBhAbB4ghMnjxZV199tWlI6N+/v/r3768bbrhBN998s2bPni1JevvttzV37lxdeeWVIakhIyNDH3zwgc444wx99tlnqqys1Gmnnabm5mZVV1dLkk499VS98847fv/AHg319fXuz5OTk/3qc+jIy8FF6QeNGzdOxuGbsgMAfCrISlX/wkxt2uv5i5oVW/bJ5TJktYZmrSCAjoOpUEcgNze3zZGH5ORkPffccx7bm/7lL38JaR1ZWVn68MMPNXz4cEkt04oOHDggSRo1apTef//9gA/Ti5RDR1IaGxv96nPoqESkQ5Pdbvf5UVJSEtFaACBURvfzng6139GoDWU1UagGQKwjWISB1WrV9OnT3Y/XrFmjXbt2tdLjyOXk5OjRRx/1an/sscdiYtrOoTUePvrgy6H3Rfo9ZmRktPoBALFo9FHm6yxWsM4CQAAIFmEyZswYj52YfG2PGqh169bpoosu8mqfPHmyfvjhh5C+Vjh07vzfub179+71q09ZWZn787y8vJDXBAAdzUl985RgMuXp080ECwBHjmARJklJSerS5b+/CaqoCN036Y0bN2rixInuBcojR47U8ccfL0navXu3xo8fry1btoTs9cJhwIAB7s+3b9/uV58dO3a4Px84cGDIawKAjiYrNUlDe+R4tX9Rsl9Nza4oVAQglhEswujQbUhDNV3mhx9+0IQJE9y/vT/xxBM1f/58LVy4UEOHDpUklZaWavz48e167v+gQYPcn3///fdyOp1t9jl0a91D+wMAAmc2HcrR2KzVOw9EvhgAMY1gESZbt25179IkSd26dQv6Obds2aIJEyZo9+7dkqQTTjhBCxYsUG5urjp37qyFCxfq2GOPlSTt3LlT48eP93s0INJGjRrl3uXJ4XBo1apVrd7f0NCgzz77zP14woQJYa0PADqKUf3Mt539Ytt+03YA8IVgESbPP/+8+/OcnBz3VKVAlZSUaMKECe5F4Mcdd5wWLlyoTp06ue/Jz8/XokWLNHjwYEktU4zGjx+vnTt3BvXa4ZCZmamJEye6H8+ZM6fV+9988033GR15eXkaM2ZMOMsDgA5jWK9OSk7w/nFg1bbKKFQDIJYRLPx0+IFsrVmxYoUeeeQR9+PLLrtMiYmBHxmyY8cOTZgwwb3GYMiQIVq4cKHpAuaCggItWrTIvYahpKRE48ePV2lpacCvHy7/7//9P/fnc+bM0dq1a03vq62t1T333ON+PG3atKD+PAEA/5WalKAhJussVm3bL5eL84EA+I9goZYfai0Wi/tj27ZtXve8/vrrGjlypF544QVVVVWZPk99fb0ef/xxnXbaae4D4HJzcz22nj1Su3bt0vjx4901HXPMMVq0aJHHwvDDFRUVacmSJerfv7+klilU48eP1549ewKuIxwmTZrkPu+joaFB5557rr777juPe/bt26fJkydr8+bNklpGK+66666I1woA8WxEH+9fVFXXO7WpnPMsAPgvJn/te84557jXGRx06Fakq1atMp169P777we11uHLL7/UNddco8TERA0cOFADBw5Up06d1NzcrNLSUq1cudJjXUVaWprmzZunrl27BvyaaWlp7oXfgwYN0qJFi5Sfn99mv65du2rx4sUaN26cNm/erMzMTI9D6QIRjj/3uXPnauTIkdqzZ4+2bdum448/XmPHjtVRRx0lm82mhQsXqra2VpKUmJioV199Vbm5uUG9DwCApxF9OmnmMu/2L0v2a2BRduQLAhCTYjJYrFu3rtVFyQ6HQ6tXr/Zq9/eE57Y4nU6tWbNGa9as8XnPyJEjNWfOnKB3L+rcubMWLFigqVOn6plnnlFhYaHffbt3767Fixfrlltu0fPPP++xHiMQ4fhz79GjhxYvXqzLL79c3377rQzD0NKlS7V06VKP+/Lz8zV79myPdRkAgNAY3tv8bKAvtlXqqpP7RLYYADErJoNFNFx++eXq37+/VqxYoc8++0xbtmxRRUWF9u3bJ5fLpZycHBUXF+snP/mJLrroIp1yyikhe+3CwkK9/fbbAfXt2bNnwH0jZeDAgfr888/173//Wy+//LLWrl2rvXv3Kjc3V3379tUFF1yg6667rtXpXwCAwOWkJ2lAYZY27vWc+vRlyX4ZhiGLxfsQPQA4nMUwDFZmAUGw2WwqKCjwaCsvL/dryhoAtBe/e+t7/evzHV7tn9w5Xj3z0qNQEYBYw+JtAACgkcXm06FWbec8CwD+IVgAAAANN9kZSpK+KOE8CwD+IVgAAAB1z01T99w0r/bVOw9EvhgAMYlgAQAAJEnH98r1atu4t0Z1jc2RLwZAzCFYAAAASdIJPXO92ppdhtbsNj8YFgAORbAAAACSpONMgoUkfbvjQETrABCbCBYAAECSdGy3HCVYvc+s+HbXgcgXAyDmECwAAIAkKS05QQMKs7zaWcANwB8ECwAA4GY2HWpXZZ0q7A2RLwZATCFYAAAAN7MF3BKjFgDaRrAAAABuPhdwEywAtIFgAQAA3PoVZCojOcGrnWABoC0ECwAA4JZgtWhIjxyv9u92VckwjChUBCBWECwAAICH43rkerVV1TWp9EBd5IsBEDMIFgAAwMMx3b1HLCRp7e7qCFcCIJYQLAAAgIdjumWbthMsALSGYAEAADwUd85QuskC7nW7q6JQDYBYQbAAAAAerFaLBnX1HrVgxAJAawgWAADAi9l0qD1V9drvaIxCNQBiAcECAAB48b3OgulQAMwRLAAAgJfBXdkZCsCRIVgAAAAv/YsylWi1eLUTLAD4QrAAAABeUhIT1K8g06udqVAAfCFYAAAAU8d0854OVVLhkKPBGYVqALR3BAsAAGDKbAG3YUg/lNujUA2A9o5gAQAATA3smmXavqmsJsKVAIgFBAsAAGBqQKF5sNi4l2ABwBvBAgAAmOqcmaIumcle7ZsIFgBMECwAAIBP/U1GLTYyFQqACYIFAADwySxYlNc0qNLRGIVqALRnBAsAAODTgCIfC7iZDgXgMAQLAADgk9mIhUSwAOAt4GBx4MABffzxx/rmm2+8ru3Zs0cXXXSRcnJy1KlTJ1111VUqLy8PqlAAABB5/Qu9T9+W2BkKgLeAg8WsWbM0fvx4Pf/88x7tTqdTZ5xxht566y3V1NSoqqpKc+fO1cSJE9XYyHxMxCaHw9HqBwDEq6zUJHXPTfNq31TGIXkAPAUcLD766CNJ0uWXX+7R/sorr2jt2rVKTU3V7373Oz3wwAPKzs7WunXr9MwzzwRXLRAlmZmZPj+Ki4ujXR4AhJXZqMXGvTUyDCMK1QBorwIOFps3b5YkDRkyxKP91VdflcVi0b333qv7779fd999t55++mkZhqHXX389uGoBAEDE9TdZwF1V16TymoYoVAOgvUoMtGNFRYUyMzOVleX5zebjjz+WJE2ZMsXdNnnyZFksFq1duzbQlwOiym73PeRvs9kYtQAQ13ydwL1pb40Ks1MjXA2A9irgYFFfX6/kZM/TODdu3Kiqqir1799fXbt2dbcnJyerU6dOqq6uDrxSIIoyMjJ8XqutrY1gJQAQef0KzBdwb7U5dOrR+RGuBkB7FfBUqIKCAtXW1qqsrMzdtnDhQknSqFGjvO6vq6tTTk5OoC8HAACipG++ebDYYmMBN4D/CjhYjBgxQpL06KOPSmr5re3MmTNlsVg0ceJEj3tLS0tVV1fnMYoBAABiQ2ZKogqzU7zat9rYFQ/AfwUcLG666SYZhqFHHnlEgwYNUv/+/bV27Vrl5+frggsu8Lh3yZIlkrwXegMAgNhwlMmoxVZGLAAcIuBgceaZZ2rGjBmyWCzauHGjdu/erS5duuhf//qX0tI897ueO3euJGn8+PHBVQsAAKKib773WrPdVfWqbXRGoRoA7VHAi7cl6Z577tG1116rzz//XLm5uRo5cqTXOorGxkadfPLJOumkkzRp0qSgigUAANHRt4vvBdzHdmcNJYAgg4Uk9erVS7169fJ5PTk5WX/4wx+CfRkAABBFR/naGaqCYAGgRdDBAugIHA7fCxRbuwYA8aJvF/Ntt7eUs84CQIuAg0VjY6PKysqUnJysoqIij2t2u10zZszQggULZLVade655+ruu+/2WnsBxIrMTPPf1AFAR9E9N00piVY1OF0e7Vsr+OUKgBYBL95+7rnnVFxcrLvvvtvr2qRJk/S3v/1N33//vVavXq0//elPOvvss2UYRlDFAgCA6LBaLSo2GbVgZygABwUcLObPny9JuuKKKzza3377bX3yySeyWCyaMmWKbrzxRiUlJemTTz7Riy++GFy1QJTY7XafHyUlJdEuDwAiwnzLWYdcLn5xCCCIYLF+/XpJ0oknnujRPnfuXFksFt1111168cUX9cwzz+ixxx6TYRjubWeBWJORkdHqBwB0BEeZbDlb19Sssur6KFQDoL0JOFjYbDalp6erU6dOHu0HD8O78cYb3W1XXXWVJGn16tWBvhwAAIiyviYjFhIncANoEXCwcDgcslo9u2/btk02m009e/ZUcXGxuz0jI0O5ubnav39/4JUCAICoMltjIUnb9xMsAAQRLPLy8mS323XgwAF32+LFiyVJo0aN8rrf6XSysw4AADGsd+d00/Yd+2ojXAmA9ijgYDFs2DBJ0qxZsyRJLpdLs2bNksVi0fjx4z3utdlsstvtXtvSAgCA2JGbnqzsVO+d6rftY8QCQBDB4pprrpFhGPrNb36js88+WyNHjtTKlSuVmZmpiy++2OPeTz75RJI0aNCg4KoFAABR1cdkOtR2RiwAKIhgcemll+raa69Vc3Oz5s+fr6+//lqpqamaOXOmcnNzPe595ZVXTEcyAABAbOmV5z0dasf+Ws6qAhD4yduS9Pzzz+uGG27QihUrlJubq4kTJ6pv374e9zQ2NionJ0dXX321zjnnnKCKBQAA0WW2zqK2sVkV9kblZ6VEoSIA7UVQwUKSRo8erdGjR/u8npycrGeeeSbYlwEAAO1A7zwfO0PtcxAsgA4u6GABdAQOh++Fia1dA4B408vHzlDb99VqeJ+8CFcDoD0JSbBobGzUggULtGrVKpWXl0uSCgoKNGLECJ122mlKTk4OxcsAUcNWyQDQwteWs9v3s4Ab6OiCDhbPPPOM/vCHP6iiosL0epcuXfTAAw9o6tSpwb4UAACIssKsVKUkWtXgdHm072DLWaDDCypY3HXXXXr44YfdO0F0795dPXr0kCTt2rVLpaWlstlsuvnmm7Vlyxb9+c9/Dr5iIArsdrvPazabzeOkeQCIZ1arRb3y0vVDuef3RUYsAAS83eyyZcv00EMPyTAMXXjhhVq3bp127typlStXauXKldq5c6fWr1+viy66SIZh6KGHHnKfZwHEmoyMjFY/AKAjMZsOxVkWAAIOFv/4xz8kSTfccINee+01DRw40OueAQMG6NVXX9UNN9wgwzD0xBNPBF4pAABoF3qZ7Ay139GomvqmKFQDoL0IOFisWLFCVqtVf/zjH9u894EHHpDFYtGnn34a6MsBAIB2wucCbkYtgA4t4GBRUVGhnJwcFRQUtHlvYWGhcnNzfS7wBgAAscPXlrO7KgkWQEcWcLDIyspSTU2N6uvr27y3rq5ONTU1bNkJAEAc6NkpzbR9V2VdhCsB0J4EHCyGDh2q5uZmPf/8823e+/zzz8vpdOq4444L9OUAAEA70S3XPFiUHiBYAB1ZwMFiypQpMgxDv/71rzVr1iyf9z333HP69a9/LYvFoquuuirQlwMAAO1EenKiOmd4H37LiAXQsVmMg4dQHCGXy6WJEydq2bJlslgs6tGjh8aPH6/u3btLajnHYsmSJSotLZVhGBo3bpwWLVoki8US0jcARJvNZvNaa1ReXq78/PwoVQQA4ffTJ5bru11VHm2Du2br/f89NUoVAYi2gA/Is1qtmjdvnq6//nq9+eab2rlzp1588UWPew5mlgsvvFCzZs0iVAAAECe656Z5BQumQgEdW1Anb2dnZ+v111/XF198oVdeeUWrVq1SeXm5JKmgoEDDhw/XZZddphEjRoSkWAAA0D70MFnAXVXXpJr6JmWlJkWhIgDRFlSwOGjkyJEaOXJkq/dUV1dLagkjAAAgtnVvZQH3wCKCBdARhSRYtGXfvn3Kz8+X1WqV0+mMxEsCIeVwOAK6BgDxqkcn87MsSivrNLCIXyICHVFEgsVBAa4TB6KOM1gAwFN3zrIAcJiAt5sFAAAdl69gwQJuoOOK6IgFEKvsdrvPazabTcXFxRGsBgCiLzs1Sdmpiaqu95ziXMqIBdBhESwAP2RkZPi8VltbG8FKAKD96N4pXdV7qj3adlXyPRHoqJgKBQAAAmK2MxRToYCOi2ABAAACYnaWRYW9UfVNzVGoBkC0ESwAAEBAzIKFxM5QQEfl9xqLjz/+OOAXqaqqCrgvAABon7r5OCRvb3W9+hWwTTfQ0fgdLMaNGyeLxRLOWgAAQAwpykk1bd9TVR/hSgC0B0e0KxQH3AEAgIO6+ggWZVVMhQI6Ir+DxZIlS8JZBwAAiDH5mSmyWiTXYb93ZMQC6Jj8DhZjx44NZx0AACDGJCZYVZCVqrJqzyCxt5pgAXRE7AoFAAACVmgyHYoRC6BjIlgAAICAdc32DhZlBAugQyJYAACAgJntDLXPwSF5QEdEsAAAAAHztTNUeXVDhCsBEG1HtN0s0FE5HI6ArgFAvPN9lkWdenVOj3A1AKKJYAH4ITOTE2QBwEzXHPPTtw/fKQpA/GMqFAAACFiRyeJtiQXcQEfEiAXgB7vd7vOazWZTcXFxBKsBgPajIDvFtJ0tZ4GOh2AB+CEjI8Pntdra2ghWAgDtS2pSgjpnJGufo9GjnRELoONhKhQAAAiK2QLuPayxADqckI1Y1NfXq7KyUk1NTa3e16tXr1C9JAAAaAe65qRq7e5qj7ayqrooVQMgWoIKFrW1tfrrX/+ql19+WZs3b27zfovFIqfTGcxLAgCAdsZsxMJW0yBns0uJCUyOADqKgIPFgQMHNGbMGK1du1aGYfjVx9/7AABA7CjM8g4WLkPa72hUgY9dowDEn4CDxf333681a9YoKSlJt956q84//3x169ZNiYmsBwcAoCPJzzLfGaq8poFgAXQgAaeA//znP7JYLHrsscf0s5/9LJQ1AQCAGOJry9nymnpJOZEtBkDUBDzxsbS0VFarVdddd10o6wEAADGmwGQqlNSyzgJAxxHwiEVeXp7q6+uVmsoQJwAAHZnPqVDVBAugIwl4xOKUU05RVVWVSktLQ1kPAACIMZ0zkmWxeLeXM2IBdCgBB4u77rpLiYmJuv/++0NZDwAAiDGJCVZ1zkj2amcqFNCxBBwsTjzxRM2ZM0f//Oc/dcMNN2jr1q2hrAsAAMSQfJN1Fi2LtwF0FAGvsejbt68kKSEhQXPmzNGcOXOUl5enrKwsn30sFou2bNkS6EsCAIB2qiArRev3eLbZ7IxYAB1JwMFi27ZtXm379u3Tvn37fPaxmE3ABAAAMc9sAXd5dYMMw+Dff6CDCDhYzJ49O5R1AACAGFZgEiwanC5V1zuVk5YUhYoARFrAweKaa64JZR0AACCGmQULqWUBN8EC6BgCXrwNAABwkNnibYkF3EBHQrAAAABBK8j2PWIBoGMIeCoU0JE4HI6ArgFAR5GfSbAAOjq/gkVCQoIkaeDAgVq7dq1H25GwWCxyOp1H3A+ItszMzGiXAADtmq8RC07fBjoOv4KFYRge/z38cwAA0LGlJycqMyVR9gbPXyAyYgF0HH4FiyVLlkiS0tPTvdqAjsBut/u8ZrPZVFxcHMFqAKB9ys9K8QoWLN4GOg6/gsXYsWP9agPiVUZGhs9rtbW1EawEANqv/KwUlVR4rjtjxALoONgVCgAAhESXzGSvtv2OxihUAiAaCBYAACAkOmd4L+De72hUs4t1mUBHELLtZg3DUGVlpRwOR6sLu3v16hWqlwQAAO1IZ5MRC5chHahtVGcf29ECiB9BB4t3331Xjz/+uFauXNnmXHO2mwUAIH51zvAOFlLLqAXBAoh/QQWLO++8U4888ojfW8+yRS0AAPHLV3iosDfq6MIIFwMg4gJeY/Hhhx/q4YcfVmJioh5++GH3wXn5+fnavHmzli9frunTpysvL09dunTRO++8o5KSkpAVDgAA2hdfIxb7HOwMBXQEAQeLp59+WhaLRX/4wx902223adCgQZJaTuTu27evRo0apenTp+vbb79VTk6ObrjhBqWkMAwKAEC8MltjIbEzFNBRBBwsvvjiC0nS1KlTPdoPn+7Uo0cPPfHEEyovL9df/vKXQF8OAAC0c2a7QkktU6EAxL+Ag8W+ffuUnp6uwsL/TppMSEgwXcB9+umnKzU1Ve+9916gLwcAANq5nLQkJVgtXu377EyFAjqCgINFdna2kpKSPNpycnJkt9vlcHieumm1WpWYmKjS0tJAXw4AALRzVqtFeSbrLPYxYgF0CAEHi+7du6u6ulr19fXutv79+0uSPv30U497f/jhB9ntdiUmhuzYDAAA0A6ZLeBmjQXQMQQcLIYOHSrDMPTNN9+4204//XQZhqG7775bZWVlkiSbzaapU6fKYrFo+PDhwVcMAADaLbMF3BXsCgV0CAEHi7POOkuGYeg///mPu+2WW25Rbm6uvvnmG/Xq1Uvdu3dX165d9cknn0iS7rjjjqALBgAA7ZfZAm6mQgEdQ8DBYvLkyZo9e7ZGjx7tbisoKNB7772nnj17yul0as+ePXK5XEpPT9eTTz6ps846KyRFAwCA9slsjUVVXZOaml1RqAZAJAW86CEtLU3XXHONV/vJJ5+sLVu2aOXKldq5c6dycnJ0yimnKDs7O6hCAQBA+9fFx1kWlY5GFWSnRrgaAJEUltXUCQkJOuWUU8Lx1AAAoB3rnOn7LAuCBRDfAp4KdXAL2c2bN4eyHgAAEMPMpkJJ7AwFdARBTYVKSkpSv379QlkPAACIYb6mQu1jZygg7gU8YtGjRw81NTWFshYAABDjzHaFklqmQgGIbwEHi0mTJqm+vl7Lli0LZT0AACCG5fkasbAzYgHEu4CDxW9/+1vl5+frZz/7mfbs2RPKmgAAQIzKSklUcoL3jxeVtYxYAPEu4DUW69ev1x//+Ef96le/0uDBg3XVVVdp9OjRKigoUEJCgs9+Y8aMCfQlAQBAO2exWJSTniRbjecIRaWD6dNAvLMYhmH4c+MLL7ygtLQ0XXzxxZJadoWyWCxH9mIWi5xO55FXCUSZw+Hwec1ms6m4uNijrby8XPn5+eEuCwDapTP+tkyb9to92k4qztMrN50cpYoARILfIxbXXnutunbt6g4WkuRnJgn4fqC9yMzMjHYJABAzctO911kcqGXEAoh3RzQV6tBg4HK5Ql4MAACIfXkmwYI1FkD8C8vJ20C8sdvtPq+ZTYUCgI6sU0aSV9uB2iYZhnHE06gBxA6CBeCHjIwMn9dqa2sjWAkAtH9mU6Eam12qbWxWRgo/egDxKuDtZgEAAMx0SvcesZCYDgXEO4IFAAAIKbMRC4kF3EC8O6LxyL1797Z6RkVb2G4WAID418lHsGDEAohvRzzRkS1jAQBAa3xPhWLEAohnRxQsMjIy9Otf/zpctQAAgDjgaypUpYMRCyCeHVGwyMzM1PTp08NVCwAAiAMs3gY6JhZvAwCAkMpJMw8WLN4G4hvBAgAAhFRiglXZqd6TIhixAOIbwQIAAIRcXob3OgsWbwPxjWABAABCzmwB9wFGLIC4RrAAAAAhZ7aAm6lQQHzze1col8sVzjoAAEAcMTsk74CDqVBAPGPEAgAAhJzZVKiaBqeamvlFJRCvCBYAACDkfJ1lwZazQPwiWAAAgJDLNdkVSmIBNxDPCBYAACDkfI1Y7HcQLIB4RbAAAAAhl5tmPmJRVcdUKCBeESwAAEDI5aSZj1hU1zsjXAmASCFYAACAkPMVLBixAOIXwQIAAIQcwQLoeAgWAAAg5DJTzc/grSZYAHGLYAEAAEIuwWpRlkm4IFgA8YtgAQAAwsJsOhRToYD4RbAAAABhQbAAOhaCBQAACIvsVIIF0JEQLAAAQFgwYgF0LAQLAAAQFmbBorqeYAHEK4IFAAAIi5x072BR3+RSg7M5CtUACDeCBQAACAsOyQM6FoIFAAAIi2wOyQM6FIIFAAAIi2xGLIAOhWABAADCwtdUqOo6Z4QrARAJBAsAABAWrLEAOhaCBQAACAumQgEdi/mqKgAeHA5HQNcAoCNjxALoWAgWgB8yMzOjXQIAxByCBdCxMBUKAACERVKCVenJCV7tbDcLxCdGLAA/2O12n9dsNpuKi4sjWA0AxI6ctCTVNnqetM2IBRCfCBaAHzIyMnxeq62tjWAlABBbslOTtKeq3qONYAHEJ6ZCAQCAsDFbZ0GwAOITwQIAAISN2ZazrLEA4hPBAgAAhE12mves65p6Tt4G4hHBAgAAhE12qveIhb3RKZfLiEI1AMKJYAEAAMImK9V7xMIwWsIFgPhCsAAAAGFjFiwkpkMB8YhgAQAAwibLZCqUJNkJFkDcIVgAAICwyUzxNWLBzlBAvCFYAACAsGEqFNBxECwAAEDY+JoKVc2IBRB3CBYAACBsshmxADoMggUAAAgbXyMWBAsg/hAsAABA2PheY8FUKCDeECwAAEDYpCcnKMFq8WpnxAKIPwQLAAAQNhaLxXTLWXsDwQKINwQLAAAQVmbToZgKBcQfggUAAAgrsxGLaqZCAXGHYAEAAMIq22RnKNZYAPGHYAEAAMKKqVBAx0CwAAAAYWUeLBixAOINwQIAAISV2SF59ganDMOIQjUAwoVgAQAAwspsxKLZZaiuqTkK1QAIF4IFAAAIK7MRC4npUEC8IVgAAICwMhuxkFjADcQbggUAAAgrX8GCsyyA+EKwAAAAYeV7xIJgAcQTggUAAAgr32ssmAoFxBOCBQAACCtGLICOgWABAADCihELoGMgWAAAgLBixALoGAgWAAAgrDKTzYOFvYFgAcQTggUAAAgrq9Wi9OQEr3YHwQKIKwQLAAAQdpkp3qMWjobmKFQCIFwIFgAAIOzMgkUNIxZAXCFYAACAsMs0WcDNVCggvhAsAABA2GWYLOC2sysUEFcIFgAAIOwyTKZCsSsUEF8IFgAAIOzMzrIgWADxhWABAADCLiPFfLtZwzCiUA2AcCBYAACAsMtMSfJqc7oMNThdUagGQDgQLAAAQNhlmoxYSEyHAuIJwQIAAISd2eJtiS1ngXhCsAAAAGFndkCeJNWw5SwQNwgWAAAg7HwFC0YsgPhBsAAAAGFndvK2xBoLIJ4QLAAAQNj5WmNBsADiB8ECAACEne+pUM0RrgRAuBAsAABA2PkKFvaGpghXAiBcCBYAACDsfE+FYsQCiBcECwAAEHY+RyzYbhaIGwQLAAAQdglWi9KSvE/fZrtZIH4QLAAAQESYTYdiVyggfhAsAABARGSZnGVBsADiB8ECAABEREYKU6GAeEawAAAAEWG2gJsRCyB+ECwAAEBEECyA+EawAAAAEcHibSC+ESwAAEBEmI1YOBqcMgwjCtUACDWCBQAAiAizYNHUbKjB6YpCNQBCjWABAAAiwtfp2+wMBcQHggUAAIgIszUWkuRoaI5wJQDCgWABAAAiItPkgDxJqmloinAlAMKBYAEAACLC91QoRiyAeECwAAAAEeFrKpSdEQsgLhAsAABARPgasbAzYgHEBYIFAACICHaFAuIbwQIAAESEr8Xb9nqCBRAPCBYAACAiMpN9TYUiWADxgGABAAAiIiMlwbSdYAHEB4IFAACIiMQEq1KTvH/0YI0FEB8IFgAAIGLMFnDXECyAuECwAAAAEWMWLBixAOKD+SoqAB4cDkdA1wAAnswOySNYAPGBYAH4ITMzM9olAEBcMAsWNWw3C8QFpkIBAICIyTIJFuwKBcQHRiwAP9jtdp/XbDabiouLI1gNAMQus0PymAoFxAeCBeCHjIwMn9dqa2sjWAkAxDazxdv2BqcMw5DFYolCRQBChalQAAAgYsyCRVOzoQanKwrVAAglggUAAIgYs2AhMR0KiAcECwAAEDFmaywkFnAD8YBgAQAAIsbXiAVbzgKxj2ABAAAihqlQQPwiWAAAgIhhKhQQv9huFvCDw+EI6BoAwJOvEQuCBRD7CBaAHzIzM6NdAgDEhSwfIxassQBiH1OhAABAxGSwxgKIW4xYAH6w2+0+r9lsNhUXF0ewGgCIXUyFAuIXwQLwQ0ZGhs9rtbW1EawEAGJbRjJToYB4xVQoAAAQMVarxXTUghELIPYRLAAAQERlpCR4tbHGAoh9BAsAABBRjFgA8YlgAQAAIiozNcmrjTUWQOwjWAAAgIjKYsQCiEsECwAAEFGssQDiE8ECAABEVGaK91QoO1OhgJhHsAAAABGVlWoyFarRKZfLiEI1AEKFA/IAPzgcjoCuAQC8me0KZRhSbVOzz5O5AbR//N8L+CEzMzPaJQBA3MjwER4cDU6CBRDDmAoFAAAiKtNkKpTElrNArOPXAoAf7Ha7z2s2m03FxcURrAYAYpvZdrMSW84CsY5gAfghIyPD57Xa2toIVgIAsc/XdCd2hgJiG1OhAABARPmaCsWIBRDbCBYAACCifI1YVNc3RbgSAKFEsAAAABGVk+Z9QJ4kVdcRLIBYRrAAAAARlZNuHiwO1BIsgFhGsAAAABGVlZKoBKvFq72KEQsgphEsAABARFksFmWbLOAmWACxjWABAAAiLjc92avtAMECiGkECwAAEHHZJgu4GbEAYhvBAgAARJzZzlBVtY1RqARAqBAsAABAxOUyYgHEHfMTagB4cDgcAV0DAJgzHbGoa5LLZchqsmMUgPaPYAH4ITMzM9olAEBcMQsWLkOyNzqVnWp+zgWA9o2pUAAAIOJyfRySV8UheUDMYsQC8IPdbvd5zWazqbi4OILVAEDsM9sVSmqZDtUzwrUACA2CBeCHjIwMn9dqa2sjWAkAxAezxdsSC7iBWMZUKAAAEHFmaywkggUQywgWAAAg4nJ8rbEgWAAxi2ABAAAiLjct2bR9v4ND8oBYRbAAAAAR1znTPFjYahoiXAmAUCFYAACAiEtKsKqLSbgoq6qPQjUAQoFgAQAAoqIgK9WrbW8NwQKIVQQLAAAQFYXZKV5t5dVMhQJiFcECAABERWG294hFeU29XC4jCtUACBbBAgAAREWBSbBoajZUWcvOUIhPLpeh6vom7a2ul7PZJUkyDEO1jU5V2P87WmcYhhqczWpwNns9x8H72yNO3gYAAFFRZBIsJGn3gXp1zvSeJgWESrPLUF1TsyodjSqrrteWcru+K63Syi37VFLhiHZ5R6xLZopW/f60aJdBsAAAANHRMy/NtP28J5ZHuBIciZy0JBVmpygpwapxA/J1ct8uykhJkCRZLRYtWLdXb6/erb3V9WpwuqJcbcdw6GhHNBEsAABAVByVnxntEhCAqrom9wnpa3dX6x9LtkS5IrQXBAvADw6H72HR1q4BAHwryk5VZkqi7A3tc744gCNjMQyDrReANlgsliO6v6ioSAkJCT6vDxs2TG+//bZH209/+lN9/fXXbT73bbfdpttuu839uKamRoMGDfKrrnnz5unEE090P3733Xd18803t9kvMzNTGzZs8Gi744479PLLL7fZd9KkSXr66ac92oYPH66ysrI2+/71r3/VFVdc4X68ceNGTZw4sc1+kvTll1+qa9eu7sfPPPOM7rvvvjb79e/fX4sXL/ZomzJlipYtW9Zm36lTp2r69OkebT169PCr3pdeeknjxo1zP166dKmuvPJKv/ru2rXL4/G9996rZ599ts1+Y8eO1b/+9S+PtgkTJmjTpk1t9r3nnns0bdo09+M9e/ZoxIgRftW7aNEiDRgwwP147ty5uvPOO9vsV1RUpFWrVnm03XTTTXrvvffa7Hv55ZfroYce8mgbOHCg7HZ7m31nzpypc8891/34q6++0vnnn99mP0lav369srKy3I8fffRRPfroo23260jfI4ouvU8VSYV+1QfAt6Hrng7b94jD/53xhRELIAza+qG5Z8+eXm02m02lpaVtPnd1dbXHY8Mw/OonSY2Nnjut1NXV+dX30B+MDqqsrPSr7/79+73aysrK/OpbW1vr8djpdPr9XpubPXfSsNvtfvXNycnxaquoqPCrb1VVlVebv/U2NDR4Pfa3r1kd/vStqKjwatu7d69ffQ//gby5udnvep1Oz99O19bWBvxe9+/f71ffyspKr7bdu3erpqamzb51dXUejxsbG/2u9/Df3VVXV/vVtyN9j+h7oETKJ1gAwYrE94i2ECwAP7T2W02bzabi4mKPtrZGLPLz803bunfv3mYt2dnZHo8tFotf/SQpOTnZ43FaWppffTMzvedBd+rUya++eXl5Xm1FRUVt9pOk9PR0j8eJiYl+v9fD//wzMzP96ltY6P0DTpcuXfzqaxZK/K03JSXF67G/fc3q8Kdvly5dvNoKCwtNA9LhDv+aSEhI8LvexETPf3rS09P96mv2dZOXl+dX306dOnm1devWza8Ri7Q0zwXGycnJfr/Xw0c7s7Oz/erbkb5HHJ24T/VZKSqvaR+LT4FYFYnvEW1hKhQQJJvNpoKCAo+28vJy0x8MAADe1u2u1q9fW631e6rbvhntysUn9tCw3p2UkZIoi6S6pmY9+/FW/VDedmhH6Lx76yk6trv3L7cijWABBIlgAQChUXqgTjlpScpMYUIFoscwDBmG5HQZcrpcanS6VN/kUl1Ts+oam1Xb6FRtY7MMSXWNzWpqdqnZZaip2SWLxSJns0upSQlKSrCqsblZdY0H+zq139Gyo1ZSgkUZKYlqanbJXu9UTYNTFkmdM5PV0ORSdb1T9U3NSktO0PE9c5VgtajR2VJL6YE6OV2GEq0WnXlMkc461r9ZAJHA/7kAAKBd6J5rfq4FEEkWi0UWi5RstShZVqUnt90HLazRLgAAAABA7CNYAAAAAAgawQIAAABA0AgWAAAAAIJGsAAAAAAQNIIFAAAAgKARLAAAAAAEjWABAAAAIGgECwAAAABBI1gAAAAACBrBAgAAAEDQCBYAAAAAgkawAAAAABA0ggUAAACAoBEsAAAAAAQtMdoFALHA4XD4vFZTU+PVVlFREc5yAAAAIq5z586yWn2PS1gMwzAiWA8QkywWS7RLAAAAiKry8nLl5+f7vM5UKAAAAABBYyoU4Ae73e7z2oYNGzR8+PAIVgMAAND+ECwAP2RkZPi8lp6eHsFKAAAA2ifWWABBcjqd+uGHHzzaUlNT1bdvX0lSSUmJVzBxOBwqLi42vd7atVgR7vcQqucP5HmOpI+/97Z1Xzx/vUSi/lC8RqDPEeqvl2C+VoJ5H+0FXy9Hdm9H/t4i8W/Rkd7rz31tLd5mxAIIUmJiogYNGuTRduguUvn5+V7/cx46ynH49dauxYpwv4dQPX8gz3Mkffy9t6374vnrJRL1h+I1An2OUH+9BPO1cqT1tEd8vRzZvR35e4vEv0VHem8o3g+LtwEAAAAEjWABAAAAIGgECwAAAABBI1gAAAAACBrBAgAAAEDQCBYAAAAAgsY5FgAAAACCxogFAAAAgKARLAAAAAAEjWABAAAAIGgECwAAAABBI1gAAAAACBrBAgAAAEDQCBYAAAAAgkawAAAAABA0ggUAAACAoBEsAAAAAASNYAEAAAAgaAQLAAAAAEEjWAAAAAAIGsECAAAAQNAIFgAAAACCRrAAAKADs1gsslgsWrp0abRLARDjCBYAABxixowZ7h+2/fkAALRIjHYBAAC0V4WFhdEuAQBiBsECAAAfysrKol0CAMQMpkIBAAAACBrBAgCAEOnTp48sFovmzJmjmpoa/fa3v9WAAQOUlpamLl26aPLkyfr8889bfY7m5mY9//zzmjBhgrp06aKUlBR1795dF198sV8LrHfu3Kk777xTxx9/vHJycpSWlqajjjpK559/vl544QXV19f77FtTU6Pf//73GjhwoNLS0tS5c2ede+65rdZcWVmpe+65R8OGDVN2draSk5NVVFSkoUOH6uabb9aiRYvarBlAnDAAAIDb9OnTDUlGIP9E9u7d25BkPProo8aAAQMMSUZycrKRnZ3tfk6r1WrMmjXLtP+BAweMcePGue9NSEgwcnNzDYvF4m67/fbbfb7+Cy+8YKSmprrvTU5ONjp37mwkJia627755huPPgfb586da/Tr18+QZKSmphrp6ekezzN//nyv19u5c6fRq1cvj/fWqVMnIyEhwd02duzYI/5zBBCbGLEAACDE7r33XpWXl+vVV1+Vw+FQVVWV1q1bp7Fjx8rlcummm27S119/7dXvhhtu0NKlS5WcnKzHH39c1dXVqqys1O7du3X99ddLkh5++GHNnDnTq+97772na665RvX19Ro9erQ++eQT1dXVqaKiQg6HQ5988ommTp2q5ORk05pvueUWJScna/HixXI4HLLb7friiy80YMAANTY2atq0aXK5XB59ZsyYoR07dqhPnz5auHChGhsbtX//fjU0NGjbtm166qmn9JOf/CQEf6IAYoHFMAwj2kUAANBezJgxQ/fee6+ktneFuvTSS/X3v//d/bhPnz7avn27JGnhwoWaOHGix/11dXU67rjj9MMPP+icc87Re++95772+eefu38If/rppzVt2jSv17vooov0xhtvqEuXLtq5c6dSU1MlSU6nU/3791dJSYlOOeUULVq0yGeAONzBLXPz8/O1Zs0aFRQUeFz//vvvNXToUEnS8uXLNXr0aPe1wYMHa/369Zo7d64uv/xyv14PQPxixAIAAB/27t3b6kdVVZVpv9GjR3uFCklKS0vTHXfcIUn68MMPPfq/8sorkqQePXroxhtvNH3e+++/X5JUUVGhBQsWuNuXLFmikpISSdLf/vY3v0PFoaZNm+YVKiRpyJAhKi4uliR99913Htdyc3MlSXv27Dni1wMQfwgWAAD4YBhGqx9z5swx7TdhwgSfz3nwmsvl8pgOtWrVKknS+PHjZbWa//M8aNAgde/e3eN+SVqxYoUkqaioSMOHD/f/DR7ipJNO8nmtW7dukqT9+/d7tJ977rmSpN/85jeaNm2aPvzwQ1VXVwf0+gBiH8ECAIAQO/jDf1vXysvLvT5vra/UMqJxeN+D52307t37yIv9UVZWls9riYktx141NTV5tN9xxx265JJL1NTUpGeffVZnn322cnNzNWTIEN1xxx3auHFjwPUAiD0ECwAAYtzBdRKRlpSUpFdeeUXffvut7rnnHk2YMEHp6elas2aNHn74YR1zzDF65JFHolIbgMgjWAAAEGKlpaV+XTt0TcPBz3ft2tXqcx+8fmjfoqIiSXIvHI+04447Tvfee68WLVqkAwcOaOHChRozZoyam5t1xx13aPXq1VGpC0BkESwAAAixJUuWtHnNarXqhBNOcLcfXBuxZMkSr21dD9qwYYM7mIwYMcLdPmrUKEktU6IOXXsRDYmJiZo4caLee+89paSkyDAMLVy4MKo1AYgMggUAACG2fPly01Oy6+vr3VODzjzzTPeuSpJ02WWXSWoZ0XjuuedMn/eee+6RJHXp0kWnnXaau338+PHq27evJOlXv/qVGhsbQ/E22tTQ0ODzWkpKihISEiTJ52J0APGF/9MBAAixnJwcXXjhhXr99dfldDoltYw2TJo0SRs2bFBCQoLuu+8+jz4jR47UhRdeKEm69dZb9cQTT6i2tlZSy0jE1KlT9dprr0lq2Xb24BkWkpSQkKAnnnhCFotFy5cv18SJE7V8+XL3yEdjY6OWLl2qK6+8UuvWrQvZ++zdu7d++9vf6rPPPvMIGZs3b9aUKVNUW1srq9WqM888M2SvCaD9Sox2AQAAtFcH1y605s0333RPRTpo+vTpevrpp3XxxRcrJSVFqamp7jMrLBaLnnrqKdNtYWfNmqWKigotW7ZMt956q371q18pKytLBw4c0MHzbG+//XbdfPPNXn3PPvtszZkzR9OmTdPy5ct16qmnKiUlRZmZmaqqqnIHnNtvv/2I/xx82bt3r/785z/rz3/+s6xWq3JyclRXV6f6+nr3e33kkUc0ePDgkL0mgPaLYAEAgA979+5t8x6zaUedOnXSF198oQcffFBvvPGGdu7cqby8PI0ePVq//e1vdfLJJ5s+V05OjhYtWqR//vOfevHFF7V69WrZ7XYVFRVp1KhR+vnPf65x48b5rOXqq6/WmDFj9Pe//10fffSRtm/frrq6OvXu3VtDhgzRhRdeqEGDBvn9/tvy0UcfacmSJVq+fLl27Njh/vPq16+fTj31VN1yyy068cQTQ/Z6ANo3i3HwVyAAACAoffr00fbt2zV79mxde+210S4HACKKNRYAAAAAgkawAAAAABA0ggUAAACAoBEsAAAAAASNxdsAAAAAgsaIBQAAAICgESwAAAAABI1gAQAAACBoBAsAAAAAQSNYAAAAAAgawQIAAABA0AgWAAAAAIJGsAAAAAAQNIIFAAAAgKD9f1X90fvsSeqWAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Compute theoretical loss plateau levels\n",
     "theory_levels = gp.loss_plateau_predictions()\n",
@@ -220,12 +336,13 @@
     "ax.grid(False)\n",
     "\n",
     "plt.tight_layout()\n",
-    "plt.savefig(f\"{FIGURES_DIR}/dihedral_loss.pdf\", bbox_inches=\"tight\")\n",
+    "plt.savefig(f\"{FIGURES_DIR}/dn_loss.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "a04bf2c1",
    "metadata": {},
    "source": [
     "## Power Spectrum Over Training"
@@ -233,9 +350,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
+   "id": "13dab6c1",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing power at step 1 with output shape (1, 6)\n",
+      "Computing power at step 61 with output shape (1, 6)\n",
+      "Computing power at step 83 with output shape (1, 6)\n",
+      "Computing power at step 114 with output shape (1, 6)\n",
+      "Computing power at step 156 with output shape (1, 6)\n",
+      "Computing power at step 213 with output shape (1, 6)\n",
+      "Computing power at step 291 with output shape (1, 6)\n",
+      "Computing power at step 398 with output shape (1, 6)\n",
+      "Computing power at step 544 with output shape (1, 6)\n",
+      "Computing power at step 744 with output shape (1, 6)\n",
+      "Computing power at step 1016 with output shape (1, 6)\n",
+      "Computing power at step 1389 with output shape (1, 6)\n",
+      "Computing power at step 1899 with output shape (1, 6)\n",
+      "Computing power at step 2595 with output shape (1, 6)\n",
+      "Computing power at step 3546 with output shape (1, 6)\n",
+      "Computing power at step 4846 with output shape (1, 6)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Use model_power_over_time from src/power.py\n",
     "powers_over_time, power_steps = power.model_power_over_time(\n",
@@ -268,12 +419,13 @@
     "ax.grid(False)\n",
     "\n",
     "plt.tight_layout()\n",
-    "plt.savefig(f\"{FIGURES_DIR}/dihedral_power_spectrum.pdf\", bbox_inches=\"tight\")\n",
+    "plt.savefig(f\"{FIGURES_DIR}/dn_power_spectrum.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "62e7ee65",
    "metadata": {},
    "source": [
     "## Irreducible Representations"
@@ -281,12 +433,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
+   "id": "59d42a70",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig = viz.plot_irreps(group, show=False)\n",
-    "plt.savefig(f\"{FIGURES_DIR}/dihedral_irreps.pdf\", bbox_inches=\"tight\")\n",
+    "plt.savefig(f\"{FIGURES_DIR}/dn_irreps.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
    ]
   }
@@ -298,8 +462,16 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.12.0"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/sequential_cnxcn.ipynb b/notebooks/sequential_cnxcn.ipynb
index f957123..66e0468 100644
--- a/notebooks/sequential_cnxcn.ipynb
+++ b/notebooks/sequential_cnxcn.ipynb
@@ -11,14 +11,16 @@
     "**Sequence length:** $k = 3$ (sequential composition).  \n",
     "**Architecture:** `QuadraticRNN` with quadratic recurrence.  \n",
     "**Key result:** The RNN composes elements sequentially in $k$ steps, exploiting associativity."
-   ]
+   ],
+   "id": "1ec3cb04"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Imports"
-   ]
+   ],
+   "id": "ba41a633"
   },
   {
    "cell_type": "code",
@@ -42,14 +44,16 @@
     "import src.template as template\n",
     "import src.train as train_mod\n",
     "import src.viz as viz"
-   ]
+   ],
+   "id": "89d7e15d"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Configuration"
-   ]
+   ],
+   "id": "1ad735f7"
   },
   {
    "cell_type": "code",
@@ -83,14 +87,16 @@
     "print(f\"Group: C_{p1} x C_{p2}, order {p_flat}\")\n",
     "print(f\"Sequence length: k={k}\")\n",
     "print(f\"Device: {device}\")"
-   ]
+   ],
+   "id": "48a1e9ce"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Template and Dataset"
-   ]
+   ],
+   "id": "914f0697"
   },
   {
    "cell_type": "code",
@@ -115,7 +121,8 @@
     "print(f\"Dataset: {len(ds)} samples\")\n",
     "print(f\"X shape: {X_tensor.shape} (N, k, p1*p2)\")\n",
     "print(f\"Y shape: {Y_tensor.shape} (N, p1*p2)\")"
-   ]
+   ],
+   "id": "c3944d8b"
   },
   {
    "cell_type": "code",
@@ -143,14 +150,16 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_template.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "4d05d643"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Model and Optimizer"
-   ]
+   ],
+   "id": "1fc45af3"
   },
   {
    "cell_type": "code",
@@ -172,14 +181,16 @@
     "print(f\"Model: QuadraticRNN(p={p_flat}, d={hidden_dim}, k={k})\")\n",
     "print(f\"Optimizer: HybridRNNOptimizer(lr={lr})\")\n",
     "print(f\"Training for {epochs} epochs\")"
-   ]
+   ],
+   "id": "7261d8b6"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Training"
-   ]
+   ],
+   "id": "bc712f80"
   },
   {
    "cell_type": "code",
@@ -196,14 +207,16 @@
     "    verbose_interval=1,\n",
     "    save_param_interval=1,\n",
     ")"
-   ]
+   ],
+   "id": "5ec15ca0"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Training Loss"
-   ]
+   ],
+   "id": "05f9375b"
   },
   {
    "cell_type": "code",
@@ -229,14 +242,16 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_loss.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "87a7da40"
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Predictions"
-   ]
+   ],
+   "id": "bd1f1264"
   },
   {
    "cell_type": "code",
@@ -268,7 +283,8 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_predictions.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ]
+   ],
+   "id": "2acbc8ca"
   }
  ],
  "metadata": {

From ad3cd5700935f419dfc0b485d1bfc2d22d7db1c8 Mon Sep 17 00:00:00 2001
From: Nina Miolane <nmiolane@gmail.com>
Date: Sat, 7 Feb 2026 03:46:26 +0000
Subject: [PATCH 2/2] great seq notebook, alright for the otehrs

---
 notebooks/cn.ipynb               |  17 ++-
 notebooks/cnxcn.ipynb            | 186 ++++++++++++++++++++--------
 notebooks/sequential_cnxcn.ipynb | 204 +++++++++++++++++++++++--------
 3 files changed, 305 insertions(+), 102 deletions(-)

diff --git a/notebooks/cn.ipynb b/notebooks/cn.ipynb
index e014cd5..0cccba0 100644
--- a/notebooks/cn.ipynb
+++ b/notebooks/cn.ipynb
@@ -559,11 +559,26 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/50 [00:00<?, ?it/s]"
+      "  0%|          | 0/50 [20:29<?, ?it/s]\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m TEST_MODE:\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m     agf_results = \u001b[43mtrain_agf\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m      3\u001b[39m \u001b[43m        \u001b[49m\u001b[43mX_tensor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mY_tensor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m      4\u001b[39m \u001b[43m        \u001b[49m\u001b[43minit_sz\u001b[49m\u001b[43m=\u001b[49m\u001b[43minit_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m      5\u001b[39m \u001b[43m        \u001b[49m\u001b[43magf_steps\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m50\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m      6\u001b[39m \u001b[43m        \u001b[49m\u001b[43mfrom_init\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparam_history\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m      7\u001b[39m \u001b[43m        \u001b[49m\u001b[43mutilmax_lr\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m      8\u001b[39m \u001b[43m        \u001b[49m\u001b[43mcostmin_lr\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.01\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m      9\u001b[39m \u001b[43m        \u001b[49m\u001b[43mcostmin_maxiter\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1e4\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m     10\u001b[39m \u001b[43m        \u001b[49m\u001b[43mloss_thresh\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1e-4\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m     11\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     12\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m     13\u001b[39m     agf_results = \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 134\u001b[39m, in \u001b[36mtrain_agf\u001b[39m\u001b[34m(X_train, Y_train, init_sz, agf_steps, from_init, utilmax_lr, costmin_lr, costmin_maxiter, loss_thresh)\u001b[39m\n\u001b[32m    132\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m n.active:\n\u001b[32m    133\u001b[39m     \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m134\u001b[39m \u001b[43mn\u001b[49m\u001b[43m.\u001b[49m\u001b[43mutility_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresidual\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mutilmax_lr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    135\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m n.util_acc > n.c_a:\n\u001b[32m    136\u001b[39m     n.active = \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 48\u001b[39m, in \u001b[36mModsumSubNetwork.utility_step\u001b[39m\u001b[34m(self, x, residual, learning_rate)\u001b[39m\n\u001b[32m     46\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mutility_step\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, residual, learning_rate):\n\u001b[32m     47\u001b[39m     f_i = \u001b[38;5;28mself\u001b[39m(x)\n\u001b[32m---> \u001b[39m\u001b[32m48\u001b[39m     util = \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43meinsum\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mnd,nd->n\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf_i\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresidual\u001b[49m\u001b[43m)\u001b[49m.mean()\n\u001b[32m     49\u001b[39m     \u001b[38;5;28mself\u001b[39m.util_acc += \u001b[32m3\u001b[39m * learning_rate * util.item()\n\u001b[32m     50\u001b[39m     norm_th = \u001b[32m1\u001b[39m / (\u001b[32m1\u001b[39m + \u001b[38;5;28mself\u001b[39m.c_a - \u001b[38;5;28mself\u001b[39m.util_acc)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/anaconda3/envs/group-agf/lib/python3.12/site-packages/torch/functional.py:373\u001b[39m, in \u001b[36meinsum\u001b[39m\u001b[34m(*args)\u001b[39m\n\u001b[32m    368\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m einsum(equation, *_operands)\n\u001b[32m    370\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(operands) <= \u001b[32m2\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m opt_einsum.enabled:\n\u001b[32m    371\u001b[39m     \u001b[38;5;66;03m# the path for contracting 0 or 1 time(s) is already optimized\u001b[39;00m\n\u001b[32m    372\u001b[39m     \u001b[38;5;66;03m# or the user has disabled using opt_einsum\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m373\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_VF\u001b[49m\u001b[43m.\u001b[49m\u001b[43meinsum\u001b[49m\u001b[43m(\u001b[49m\u001b[43mequation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moperands\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# type: ignore[attr-defined]\u001b[39;00m\n\u001b[32m    375\u001b[39m path = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    376\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m opt_einsum.is_available():\n",
+      "\u001b[31mKeyboardInterrupt\u001b[39m: "
      ]
     }
    ],
    "source": [
+    "# This takes a very long time to run\n",
     "if not TEST_MODE:\n",
     "    agf_results = train_agf(\n",
     "        X_tensor, Y_tensor,\n",
diff --git a/notebooks/cnxcn.ipynb b/notebooks/cnxcn.ipynb
index 02aab2d..9059f15 100644
--- a/notebooks/cnxcn.ipynb
+++ b/notebooks/cnxcn.ipynb
@@ -2,6 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "ddbaa284",
    "metadata": {},
    "source": [
     "# Binary Group Composition on $C_n \\times C_n$\n",
@@ -11,20 +12,20 @@
     "**Sequence length:** $k = 2$ (binary composition).  \n",
     "**Architecture:** `TwoLayerNet` with square nonlinearity.  \n",
     "**Key result:** The network learns one irreducible representation at a time."
-   ],
-   "id": "ddbaa284"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "d664cd69",
    "metadata": {},
    "source": [
     "## Imports"
-   ],
-   "id": "d664cd69"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
+   "id": "33e1bcc9",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,22 +45,30 @@
     "import src.template as template\n",
     "import src.train as train_mod\n",
     "import src.viz as viz"
-   ],
-   "id": "33e1bcc9"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "39dee331",
    "metadata": {},
    "source": [
     "## Configuration"
-   ],
-   "id": "39dee331"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
+   "id": "dfaaf6c1",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Group: C_5 x C_5, order 25\n"
+     ]
+    }
+   ],
    "source": [
     "TEST_MODE = os.environ.get(\"NOTEBOOK_TEST_MODE\", \"0\") == \"1\"\n",
     "\n",
@@ -81,22 +90,36 @@
     "os.makedirs(FIGURES_DIR, exist_ok=True)\n",
     "\n",
     "print(f\"Group: C_{n} x C_{n}, order {group_size}\")"
-   ],
-   "id": "dfaaf6c1"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "e436d336",
    "metadata": {},
    "source": [
     "## Template and Dataset"
-   ],
-   "id": "e436d336"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
+   "id": "11b79001",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting mode: (1, 0) with magnitude: 9.744830944364566\n",
+      "Setting mode: (0, 1) with magnitude: 7.287346335011062\n",
+      "Setting mode: (1, 1) with magnitude: 3.5146780589270143\n",
+      "Setting mode: (2, 0) with magnitude: 7.07605138259081\n",
+      "GPU is available. Using CUDA.\n",
+      "Dataset: 625 samples\n",
+      "X shape: torch.Size([625, 50]), Y shape: torch.Size([625, 25])\n"
+     ]
+    }
+   ],
    "source": [
     "# Build a fixed CnxCn template with known Fourier structure\n",
     "fourier_coef_mags = np.random.RandomState(seed).rand(n) * 10\n",
@@ -111,14 +134,25 @@
     "\n",
     "print(f\"Dataset: {len(ds)} samples\")\n",
     "print(f\"X shape: {X_tensor.shape}, Y shape: {Y_tensor.shape}\")"
-   ],
-   "id": "11b79001"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
+   "id": "e2a0100f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Visualize template as 2D image\n",
     "tpl_2d = tpl.reshape(n, n) if tpl.ndim == 1 else tpl\n",
@@ -132,22 +166,32 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_template.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "e2a0100f"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "d328ec49",
    "metadata": {},
    "source": [
     "## Model and Optimizer"
-   ],
-   "id": "d328ec49"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
+   "id": "3efa2863",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: TwoLayerNet(group_size=25, hidden=128)\n",
+      "Optimizer: Adam(lr=0.001)\n",
+      "Training for 1000 epochs\n"
+     ]
+    }
+   ],
    "source": [
     "net = model.TwoLayerNet(\n",
     "    group_size=group_size,\n",
@@ -163,22 +207,39 @@
     "print(f\"Model: TwoLayerNet(group_size={group_size}, hidden={hidden_size})\")\n",
     "print(f\"Optimizer: Adam(lr={lr})\")\n",
     "print(f\"Training for {epochs} epochs\")"
-   ],
-   "id": "3efa2863"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "7e6e07cf",
    "metadata": {},
    "source": [
     "## Training"
-   ],
-   "id": "7e6e07cf"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
+   "id": "d24a3efc",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Epoch   100/1000] loss: 0.039540 | reduction:   94.1%\n",
+      "[Epoch   200/1000] loss: 0.039536 | reduction:   94.1%\n",
+      "[Epoch   300/1000] loss: 0.040086 | reduction:   94.0%\n",
+      "[Epoch   400/1000] loss: 0.018636 | reduction:   97.2%\n",
+      "[Epoch   500/1000] loss: 0.007016 | reduction:   99.0%\n",
+      "[Epoch   600/1000] loss: 0.006604 | reduction:   99.0%\n",
+      "[Epoch   700/1000] loss: 0.000407 | reduction:   99.9%\n",
+      "[Epoch   800/1000] loss: 0.000358 | reduction:   99.9%\n",
+      "[Epoch   900/1000] loss: 0.000289 | reduction:  100.0%\n",
+      "[Epoch  1000/1000] loss: 0.000016 | reduction:  100.0%\n"
+     ]
+    }
+   ],
    "source": [
     "loss_history, val_loss_history, param_history, param_save_epochs, final_epoch = train_mod.train(\n",
     "    net,\n",
@@ -189,22 +250,33 @@
     "    verbose_interval=max(1, epochs // 10),\n",
     "    save_param_interval=max(1, epochs // 100),\n",
     ")"
-   ],
-   "id": "d24a3efc"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "62833715",
    "metadata": {},
    "source": [
     "## Training Loss"
-   ],
-   "id": "62833715"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
+   "id": "b2d40d22",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Compute theoretical loss plateau levels\n",
     "theory = power.theoretical_loss_levels_2d(tpl_2d)\n",
@@ -226,22 +298,33 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_loss.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "b2d40d22"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "0f9f41e8",
    "metadata": {},
    "source": [
     "## Predictions"
-   ],
-   "id": "0f9f41e8"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
+   "id": "054e6506",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAN3CAYAAACLBtb0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcsBJREFUeJzt3Xt4VPW97/FPrpPbJNwCggnhKgoUqEEo94sBDIiiUkXxGKJU1CAgtrbYswUsfYLWraggolboRTaU7iLnsEEE5CIqioG0gMUKBhsbIWgxCQGCJL/zhycjQyZk1pDJ8Ivv1/PMo7NmrfX7rjDznc+stWZNmDHGCAAAAJe88FAXAAAAAP8Q3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATB7XukXbt2CgsL87q5XC61bdtWt912m95+++1Ql+ilut7Dhw/7Nb0ha0D92717tx555BGlp6frsssuU3R0tJo1a6b+/ftrzpw5KiwsDHWJAQnldu3Zs0cRERF68MEHgzbGpaS6r9Wnjz/+WM8//7wmTZqkH/zgB4qMjFRYWJjmzZvn9zpWrVqloUOHqmnTpoqPj1fPnj315JNP6ptvvgn5ciUlJWrevLn69u0rfrrcEgbfG2lpaUaSGTBggMnKyjJZWVnmxhtvNJdffrmRZMLCwsx//ud/hrpMj+p6CwoK/JpeX+sPxlio3VdffWXuvPNOExYWZiSZtm3bmpEjR5oJEyaYwYMHG5fLZSSZmJgYs2HDhlCX67dLYbsGDBhg4uPjzdGjR4Oy/kuNJFPfb2vTp0/3rPfc269+9StHy0dGRpqRI0eam2++2TRp0sRIMgMHDjQnT54M+XK/+c1vjCSzbNky//8wCBmC2/dIdQhZunSp1/RTp06Zu+66y0gyERER5uOPPw5NgeepLTQdPHjQ/P3vfzdnzpwJyvqDMRZ8O3LkiPnBD35gJJkuXbqYN954w1RVVXnNU1paaubOnWtcLpfZvn17iCp15lLYrlWrVhlJ5mc/+1m9r/tSFYzg9vLLL5uf/vSn5rXXXjN///vfzf/6X//L7+C2evVqI8kkJCSYvLw8z/Rjx455nh8PP/xwyJc7deqUSU5ONq1btzanT5+uc7sQWgS375HagpsxxpSVlZn4+HgjyeTm5jZ8cT4Ee28Xe9NC65tvvjF9+vQxksygQYPM119/fcH53333XVNWVlZv4xcVFZm5c+fWCFTnKywsNL/61a/qnK9aqLerWv/+/Y0kc+DAgXpf96UqGMHtfFlZWX4Ht2uuucZIMvPmzavx2Ntvv20kGZfLVeM50tDLGfPdnrrf/e53dW4XQovg9j1yoeBmjDFXX321kWSmTJnimXZuI3z11VfNj370I5OYmFgj8Jw8edI89dRTpm/fviYpKcm4XC5zxRVXmJ/97Gfmyy+/rLWm/fv3m/Hjx5vmzZubmJgY061bN/Ob3/zGnD17NqBDpeXl5eaZZ54xAwYMME2aNDHR0dGmbdu25vrrrzevvfaaMcaYpUuX+jz0UX3bsmWLX2MVFhaaqVOnmk6dOhmXy2USExNN//79zYsvvmjOnj3rc3vP/Xv++c9/NgMGDDBut9vExcWZ/v37m//5n//xudw//vEPk52dbdq1a2eio6NNfHy8adu2rRk9erR59dVXa/371sZp7YHWfSGPPfaYkWSSk5NNUVGR4+Uv1tixY40kc9ddd9X67/Xpp5+adu3aGUlm+fLlfq031NtljDG7d+82ksyPfvSjC87n9HV77vPgpZdeMldffbWJi4szSUlJJjMz07z33nu1jhXI68UY/17Tvuqrr+fp+fwNbp9//rmnnk8//dTnPKmpqTWeWw29XLU9e/YYSaZPnz4X3C6EHsHte6Su4NapUycjyUybNs0zrboRTJ061YSHh5uBAwea22+/3fTt29ccPnzYGGPMv/71L89u+GbNmpmMjAxz0003ecZr166dZ95zvf322569fB06dDATJkwwGRkZJioqytxyyy2Og9s///lP07VrVyPJxMXFmREjRpgJEyaYQYMGmaSkJJOWluYZNysryzP2Lbfc4jnnLysry/z973+vc6wPPvjANGvWzHPu0m233Wauu+46ExMTYySZUaNGmYqKihrbXP33fOyxx0xYWJgZMGCAue2220zPnj095xn+5S9/8Vpm7969nrDcpUsXc/PNN5sf//jHpl+/fiYhIcH07NnT579nbQKpPZC6L+Srr74yCQkJRlJAwbM+HDlyxHTr1s1IMj/+8Y9rHA7/+OOPTUpKiuc14c8et0thu4z5Ljz+7//9v2udJ5DXbfXz4KGHHjJhYWGeftC9e3fPeVW+ngeBvl78fU2fX199PU998Te4/d//+389f9va3HTTTTUOZzf0cudKTk42kkL2gQP+Ibh9j1wouP31r3814eHhNd5wqhthYmKiz0/TVVVVZsCAAUaSueeee0xpaannsW+++cY8/PDDRpIZNmyY13KnTp3yfPqbMWOG1yfuv/71r6ZFixaesf0JbpWVlaZ3795Gkhk5cqQpLi6uMd75n7YD/XLC6dOnPdPvu+8+rzf8Q4cOefbQPProozXWV71NTZo0MTt37vR6bPbs2UaSueKKK7ymZ2dn13r44+TJk2bbtm211n++QGsPpO4LqT4ZumXLluabb77xe7n6duzYMfPDH/7QSDJjx471nN+zd+9e06pVKyPJPPLII36v71LZroEDBxpJte5hCvR1W/08iI2NNZs3b/Z67MknnzSSTFJSkteXIQJ9zgXymq7v56kv/ga35557zkgyvXr1qnWeadOmGUlm/PjxIVvuXDfccIORZP7whz9caNMQYgS37xFfwe3rr782//M//2M6duxoJJk2bdqYEydOeB6vboSPP/64z3WuX7/e0yx8vVFVVlZ6Po3v3bvXM/2Pf/yjkWRSU1N9nvj/zDPPOApur7/+upFkWrdu7ff5QoEGtz/84Q+ev5WvE3n//Oc/G0nG7XabU6dOeT1WvU3PPfdcjeVOnz5tkpKSjCTzz3/+0zN99OjRRpLZvXu3X9t1IYHWHkjdFzJ8+HAjyfzkJz8JaDu2bNniqencW7du3Ryv6/jx46Zv375GkhkxYoR5++23TfPmzY0kM3v2bEfrupjtqs9tqt6bXNshs0Bft9U1zZgxw+d6q4PWr3/9a8+0QJ9zgbym6/t56ou/we3Xv/61kb79Fn9tHn30UU8wDdVy55o1a5ZnjyouXVzH7XsoOzvbc72jJk2aaMyYMTp06JA6duyodevWKT4+vsYy48eP97mu//mf/5Ek3XLLLYqMjKzxeHh4uAYPHixJevfddz3Tt27dKkm69dZbFRUVVWO5rKwsR9v0xhtvSJLuuOMOJSQkOFrWqeraJ0yYIJfLVePxm2++WU2bNlVZWZny8vJ8rmPs2LE1prlcLnXo0EGS9K9//cszvU+fPpKk+++/Xxs2bNDp06dDVruTui9k9+7dkqS+ffv6W7pPr7zyit577z3Pbfny5Y7X0aRJE23cuFGDBg3y/Perr77S/PnzNWfOHEfrqo/tuthtKi8vV3l5uSSpefPmPucJ9HVbrbbX51133SXpu+fZuf/v9Dl3Ma/p+nqeft9UP1+OHj0a4kpwITVfsWj0BgwYoE6dOkmSoqOj1bJlS/3oRz/Sdddd57OJS99eiNaXTz/9VJL0H//xH/qP//iPC4577Ngxz/9//vnnkqT27dv7nLdp06ZKSkpSSUnJBddZ7bPPPpMkXXnllX7NfzGqm35ttYeFhal9+/Y6fvx4rW8Qbdu29Tk9MTFRkrzC2c9+9jPt2LFDmzZt0nXXXaeoqCj17NlTgwcP1oQJE3TNNdc0WO1O6q7NmTNn9PXXX0uSLr/8cn/KrlW3bt30ox/96KLWIUlut1uzZs3yXIQ6LS1NU6ZMcbSO+tqui92mc18zbrfb5zyBvm6r1fb8qZ5e/fqWAn/OXcxruj6epxer+m9fHaJ9OXHihFddoVjuXNXTjx8/Xus6EHoEt++hyZMna9KkSY6WiY2N9Tm9qqpKkjRw4EB17Njxguvo1q2bozEbs/Bw/3d2x8XFaePGjdq1a5feeOMNvfvuu3r33Xf14Ycf6umnn9YDDzygRYsWBbHa7zipuzbnXtneXCJXan/zzTd1yy23KDw8XD/84Q+Vl5enYcOGaePGjWrRooVf67hUtqtJkyae/y8rK/P5Jh3s122o/13r43l6sao/7F7olzGqHzv3g3FDL3eu6tDftGnTWteB0CO44aKkpqZKkm688Ub99Kc/9Xu56j0Stf2U1Ndff+333jbpu0/YBw4c8HuZQFXXXr3XwpeCggKveevDNddc49m7dvbsWb3++uu666679MILL2j8+PEaNmxYnesIVe3nioqKUmpqqgoLC3XgwAFlZmYGvK4bb7xRX375pVq0aKEbb7xR8+fPV7NmzRyt4//8n/+jW2+9VZWVlfrjH/+o8ePHa+LEiZ6fDdq0aZMuu+yyOtdTX9t1sdsUFxen+Ph4lZeX66uvvvIZ3AJ93VYrKChQr169akyvfj2npKR4pgX6nGvI13Qw/PCHP5QkffXVVyooKPC5x/HDDz+UJF199dUhW+5cX331lSSpVatWdWwdQin0H0tgteo3p1WrVjn6lD1kyBBJ0p/+9Cefv5/3+9//3lEd1113nSTpv/7rvy54qOBc0dHRkr4NQU4MHTpUkrRy5Uqfh1xWr16t48ePy+12Kz093dG6/RUZGanx48dr1KhRkqT8/Hy/lrsUapekG264QZL029/+ts7fXTx+/LiKioq8piUlJenhhx/Wb3/7W23evFkzZ87Un/70Jw0ZMkQVFRV+17Fq1SqNHz9exhj96U9/0u23366oqCj913/9l+666y7t379fgwcP9vv3RC9mu+prm6Tv3pg/+ugjn48H+rqt9oc//OGC06ufZ+f+v9PnXCCv6UtJSkqK54OWr/MUd+zYocLCQrlcLo0ePTpky51r3759khTU1z7qQSi/GYGGVdd13HyRLnwl8srKSs/VurOysmp8Zd8YY/7973+bxYsXe3177eTJk57fSH344YdNZWWl57G9e/d6rickB5cDqb6sQ2ZmZo2Lh546dcqsW7fOa9qwYcOMJPP666/Xun21XQ6kbdu2RpK5//77vbbr008/Ne3bt6/zciC1GTJkiJG8LwK8aNEin1e//+KLLzzXGfvv//7vWtd5rkBrD6TuCyksLDRNmzY1kszNN99sjh07VmOe4uJi88QTT5jk5GS/ft3izTffdPT8/t3vfmciIiJMbGysWb9+fY3Hq6qqzL333mukb69pdujQoTrXWd/b5XSbqlVfx+2Xv/ylz8cDfd1WPw9iY2Nr/Fs//fTTnm+HfvHFF57pgT7nAnlN1/fz1Bcnv5xQ209QffnllwH9dFWwlqtW/W1qruN2aSO4fY8EI7gZ8+2FPHv16mUkmfj4eNO/f38zYcIEc/PNN5tevXqZiIgII6nGpTG2bt1q4uLijCTTsWNHM2HCBDNixAgTFRVlbr75ZscX4D18+LDp0qWLkb69WOfIkSPN7bffbgYPHuzzYp0LFy70NLmbb77Z3HPPPeaee+7xCkn+XIA3LS3N3HbbbWb06NF+X4C3Nr7eWKovHtq+fXszduxYM3HiRDNy5EgTGxtrJJnhw4c7umZYILUH4w3x3XffNa1btzbStz+0PnToUHPHHXeYcePGmR49enh+nD05OdnvdTZr1sw88MADfs376KOPmoSEBPPWW29dcL7p06cbt9tt3n33Xb/WW9/b5WSbqlX/csKFroIfyOu2+nkwY8YMExYWZgYPHmxuv/12TyiIiIgwq1atqjFWoK8Xp6/pYDxP8/LyTN++fT236mtMpqSkeE2vLexUXzstKirKXHfddeaWW27x/Oj7gAEDav2x+IZezp/nDC4NBLfvkWAFN2O+/VT94osvmmHDhpnmzZubyMhI07JlS9OrVy+Tk5NjNmzY4HO5vXv3mptvvtk0a9bMuFwuc9VVV5nc3FzzzTffBPSTV2VlZeaJJ54w11xzjXG73cblcpm0tDRzww03mBUrVnjNW1lZaXJzc023bt08byDnN/ULjfXPf/7T5OTkmA4dOpjo6GjjdrtNv379auylOFcgbyxr1641999/v/nhD39okpOTTXR0tElJSTFDhw41v/vd73xeB68uTmsP1p6Mf//73yY3N9cMGDDANG3a1ERERJj4+HjTuXNnc8stt5gXXnjB62KudWnWrJnJycnxe35fv+hxMfNVq8/tcrpN1ap/q/Sjjz6qdR6nr9tznweLFy82vXr1MrGxsSYxMdFcd9115p133ql1rEBeL8Y4e00H43la2/X1zr9daO/pypUrzeDBg01iYqKJjY013bt3N/Pnz/cZVkO1XHXg47dKL31hxlwiX+sCgIuwYcMGXXfddfrd737nuZ6Y7S5mm/785z/rxz/+sWbOnKn//M//rJd6qr85y9tG43L69GmlpqYqKipKBQUFPq+3h0sHwQ2Ade688061b99e6enpcrvdev/99/XEE0+oQ4cOev/99z1fPLFJMLZp4MCBys/P16FDh+rlm4IEt8bpN7/5jR555BEtW7bM8cXP0fAIbgCsk5ubq+XLl+uzzz7TqVOnlJKSoptuukmzZ89WUlJSqMsLSDC2ac+ePerdu7fuv/9+LVy48KJrJLg1PiUlJerQoYM6deqknTt3el2PEJcmghsAwC8ENyD0uAAvAMAvBDYg9LgALwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbrgoYWFhmjNnTqjLqFW7du10/fXXh7oMAKg37dq106RJkzz3t27dqrCwMG3durXexrjUe/v3GcGtARQUFGjq1Km64oorFBcXp7i4OHXt2lU5OTn629/+Furygq6oqEhz5sxRfn5+UNb/0Ucfac6cOTp8+HBQ1g8A51q2bJnCwsI8t5iYGF1xxRWaOnWqjh49Gury/LZu3TrCmYUiQ11AY7d27VrddtttioyM1MSJE9WzZ0+Fh4frwIED+stf/qLFixeroKBAaWlpoS41aIqKijR37ly1a9dOvXr1qvf1f/TRR5o7d66GDh2qdu3a1fv6AcCXxx9/XO3bt9fp06e1Y8cOLV68WOvWrdO+ffsUFxfXYHUMHjxYp06dUnR0tKPl1q1bp0WLFvkMb6dOnVJkJBHhUsS/ShAdOnRIEyZMUFpamjZv3qzWrVt7Pf7EE0/ohRdeUHj4hXd8lpeXKz4+PpilXlJOnjzZoE0PAAKRmZmp3r17S5ImT56s5s2b6+mnn9aaNWt0++2315g/WL08PDxcMTEx9brO+l4f6g+HSoPoySefVHl5uZYuXVojtElSZGSkpk2bptTUVM+0SZMmKSEhQYcOHdLo0aPldrs1ceJESd++6B9++GGlpqbK5XKpS5cueuqpp2SM8Sx/+PBhhYWFadmyZTXGO/+chTlz5igsLEwHDx7UpEmT1KRJEyUlJSk7O1snT570WraiokIPPfSQkpOT5Xa7dcMNN+jzzz+v82+wdetWXXPNNZKk7Oxsz6GF6vqGDh2q7t27Ky8vT4MHD1ZcXJweffRRn/VWO/f8jmXLlunHP/6xJGnYsGGe9Z9/rseOHTvUp08fxcTEqEOHDvr9739fZ+0A4MTw4cMlfXt6zIV6eVVVlRYsWKBu3bopJiZGrVq10pQpU3T8+HGv9RljNG/ePKWkpCguLk7Dhg3T/v37a4xb2zlu77//vkaPHq2mTZsqPj5ePXr00LPPPivp2/eaRYsWSZLXYd9qvvrvnj17lJmZqcTERCUkJOjaa6/Vzp07veapPoz8zjvvaObMmUpOTlZ8fLxuuukmHTt2zPkfFTWwxy2I1q5dq06dOqlv376Oljt79qxGjRqlgQMH6qmnnlJcXJyMMbrhhhu0ZcsW3XPPPerVq5c2bNign/3sZ/rXv/6lZ555JuA6b731VrVv3165ubnavXu3XnnlFbVs2VJPPPGEZ57Jkyfrj3/8o+644w71799fb731lsaMGVPnuq+66io9/vjjeuyxx3Tvvfdq0KBBkqT+/ft75vnqq6+UmZmpCRMm6M4771SrVq38rn3w4MGaNm2annvuOT366KO66qqrPONWO3jwoMaPH6977rlHWVlZevXVVzVp0iSlp6erW7dufo8FABdy6NAhSVLz5s0l+e7lkjRlyhQtW7ZM2dnZmjZtmgoKCrRw4ULt2bNH77zzjqKioiRJjz32mObNm6fRo0dr9OjR2r17t0aOHKkzZ87UWcvGjRt1/fXXq3Xr1po+fbouu+wy/f3vf9fatWs1ffp0TZkyRUVFRdq4caP+8Ic/1Lm+/fv3a9CgQUpMTNQjjzyiqKgoLVmyREOHDtW2bdtqvM89+OCDatq0qWbPnq3Dhw9rwYIFmjp1qlauXOnobwofDIKipKTESDLjxo2r8djx48fNsWPHPLeTJ096HsvKyjKSzC9+8QuvZV5//XUjycybN89r+vjx401YWJg5ePCgMcaYgoICI8ksXbq0xriSzOzZsz33Z8+ebSSZu+++22u+m266yTRv3txzPz8/30gyDzzwgNd8d9xxR411+rJr165aaxoyZIiRZF588cU6662WlpZmsrKyPPdXrVplJJktW7b4nFeS2b59u2dacXGxcblc5uGHH75g3QDgy9KlS40ks2nTJnPs2DFTWFhoVqxYYZo3b25iY2PN559/Xmsvf/vtt40k89prr3lNf+ONN7ymFxcXm+joaDNmzBhTVVXlme/RRx81krx64JYtW7x64NmzZ0379u1NWlqaOX78uNc4564rJyfH1BYDzu+/48aNM9HR0ebQoUOeaUVFRcbtdpvBgwfX+NtkZGR4jfXQQw+ZiIgI8/XXX/scD/7jUGmQlJaWSpISEhJqPDZ06FAlJyd7btW7q891//33e91ft26dIiIiNG3aNK/pDz/8sIwxWr9+fcC13nfffV73Bw0apK+++sqzDevWrZOkGmPPmDEj4DHP5XK5lJ2dXS/r8qVr166ePX2SlJycrC5duujTTz8N2pgAGr+MjAwlJycrNTVVEyZMUEJCglavXq3LL7/cM8/5vXzVqlVKSkrSiBEj9OWXX3pu6enpSkhI0JYtWyRJmzZt0pkzZ/Tggw96HcL0p+/u2bNHBQUFmjFjhpo0aeL12Lnr8ldlZaXefPNNjRs3Th06dPBMb926te644w7t2LHD835R7d577/Uaa9CgQaqsrNRnn33meHx441BpkLjdbknSiRMnajy2ZMkSlZWV6ejRo7rzzjtrPB4ZGamUlBSvaZ999pnatGnjWW+16kOCF/NiaNu2rdf9pk2bSpKOHz+uxMREffbZZwoPD1fHjh295uvSpUvAY57r8ssvd/xtKCfO3z7p2208/3wSAHBi0aJFuuKKKxQZGalWrVqpS5cuXl8289XLP/nkE5WUlKhly5Y+11lcXCzpu57euXNnr8eTk5M9Pbo21Ydsu3fv7myDanHs2DGdPHnSZ8+/6qqrVFVVpcLCQq9TTy70voKLQ3ALkqSkJLVu3Vr79u2r8Vj1uQC1XXfM5XLV+U3T2tT2aaqysrLWZSIiInxON+d86SGYYmNjHc1/oW3xJdTbB6Bx6tOnj+dbpb746uVVVVVq2bKlXnvtNZ/LJCcn12uNoULfDR6CWxCNGTNGr7zyij744AP16dPnotaVlpamTZs2qayszGuv24EDBzyPS999qvn666+9lr+YPXJpaWmqqqrSoUOHvD5xffzxx34tH8iueenbbTl/O86cOaMvvviiXtYPAA2tY8eO2rRpkwYMGHDBD63VPf2TTz7xOjx57NixOvdaVR8d2bdvnzIyMmqdz9/emZycrLi4OJ89/8CBAwoPD/e6OgKCi3PcguiRRx5RXFyc7r77bp9X03byyWP06NGqrKzUwoULvaY/88wzCgsLU2ZmpiQpMTFRLVq00Pbt273me+GFFwLYgm9Vr/u5557zmr5gwQK/lq++btH5IawuHTt2rLEdL730Uo09boGuHwAa2q233qrKykr96le/qvHY2bNnPX0sIyNDUVFRev75573eK/zpu1dffbXat2+vBQsW1OiL567L394ZERGhkSNHas2aNV5Hio4eParly5dr4MCBSkxMrLMu1A/2uAVR586dtXz5ct1+++3q0qWL55cTjDEqKCjQ8uXLFR4eXuMcCF/Gjh2rYcOG6Ze//KUOHz6snj176s0339SaNWs0Y8YMr/PPJk+erPnz52vy5Mnq3bu3tm/frn/84x8Bb0evXr10++2364UXXlBJSYn69++vzZs36+DBg34t37FjRzVp0kQvvvii3G634uPj1bdvX7Vv3/6Cy02ePFn33XefbrnlFo0YMUJ//etftWHDBrVo0aJGfREREXriiSdUUlIil8ul4cOH13oOCQCEypAhQzRlyhTl5uYqPz9fI0eOVFRUlD755BOtWrVKzz77rMaPH6/k5GT99Kc/VW5urq6//nqNHj1ae/bs0fr162v0wPOFh4dr8eLFGjt2rHr16qXs7Gy1bt1aBw4c0P79+7VhwwZJUnp6uqRvv3g2atQoRUREaMKECT7XOW/ePG3cuFEDBw7UAw88oMjISC1ZskQVFRV68skn6/ePhAsL3Rdavz8OHjxo7r//ftOpUycTExNjYmNjzZVXXmnuu+8+k5+f7zVvVlaWiY+P97mesrIy89BDD5k2bdqYqKgo07lzZ/Ob3/zG6yvXxhhz8uRJc88995ikpCTjdrvNrbfeaoqLi2u9HMixY8e8lq/+OndBQYFn2qlTp8y0adNM8+bNTXx8vBk7dqwpLCz063IgxhizZs0a07VrVxMZGel1aZAhQ4aYbt26+VymsrLS/PznPzctWrQwcXFxZtSoUebgwYM1LgdijDEvv/yy6dChg4mIiPD6WnxaWpoZM2ZMjXUPGTLEDBkypM66AeB81T1y165dtc5zoV5ujDEvvfSSSU9PN7Gxscbtdpsf/OAH5pFHHjFFRUWeeSorK83cuXNN69atTWxsrBk6dKjZt29fjR54/uVAqu3YscOMGDHCuN1uEx8fb3r06GGef/55z+Nnz541Dz74oElOTjZhYWFelwbx1dt3795tRo0aZRISEkxcXJwZNmyYeffdd/3629RWI5wLM4YzBQEAAGzAOW4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWKLBL8BbVVWloqIiud1ufqoIaADGGJWVlalNmzYB/wYuvl/o00DDctKnGzy4FRUV8ZtmQAgUFhb69SsdAH0aCA1/+nSDB7fqH0jvfO+rioiOa+jhAzK8f9tQl+DIl2UVoS7BkXe2+Pdj9ZeS44f3hroEv5mzZ3Tqw5c9rz2gLtXPlSumLFWEy44+nWFZnz5acjrUJThCnw4uJ326wYNb9W73iOg4axqCKy4h1CU4EnU2KtQlOBIeHRvqEhwLi3SFugTHOOQFf3n6tIs+HSxRZ+z6qXD6dMPwp09zwgsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYIqDgtmjRIrVr104xMTHq27evPvjgg/quCwBwkejVQOPjOLitXLlSM2fO1OzZs7V792717NlTo0aNUnFxcTDqAwAEgF4NNE6Og9vTTz+tn/zkJ8rOzlbXrl314osvKi4uTq+++mow6gMABIBeDTROjoLbmTNnlJeXp4yMjO9WEB6ujIwMvffeez6XqaioUGlpqdcNABA8Tns1fRqwh6Pg9uWXX6qyslKtWrXymt6qVSsdOXLE5zK5ublKSkry3FJTUwOvFgBQJ6e9mj4N2CPo3yqdNWuWSkpKPLfCwsJgDwkAcIA+Ddgj0snMLVq0UEREhI4ePeo1/ejRo7rssst8LuNyueRyuQKvEADgiNNeTZ8G7OFoj1t0dLTS09O1efNmz7Sqqipt3rxZ/fr1q/fiAADO0auBxsvRHjdJmjlzprKystS7d2/16dNHCxYsUHl5ubKzs4NRHwAgAPRqoHFyHNxuu+02HTt2TI899piOHDmiXr166Y033qhxEiwAIHTo1UDj5Di4SdLUqVM1derU+q4FAFCP6NVA48NvlQIAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlIkM1cEr7ZoqKjQ/V8I5MG9gu1CU4cvjrilCX4Mg72wtCXYJjZ04cD3UJfjOVZ0JdAix1eVpTa/p0Tv+0UJfgCH06+Bprn2aPGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlHAe37du3a+zYsWrTpo3CwsL0+uuvB6EsAECg6NNA4+U4uJWXl6tnz55atGhRMOoBAFwk+jTQeEU6XSAzM1OZmZnBqAUAUA/o00DjxTluAAAAlnC8x82piooKVVRUeO6XlpYGe0gAgAP0acAeQd/jlpubq6SkJM8tNTU12EMCABygTwP2CHpwmzVrlkpKSjy3wsLCYA8JAHCAPg3YI+iHSl0ul1wuV7CHAQAEiD4N2MNxcDtx4oQOHjzouV9QUKD8/Hw1a9ZMbdu2rdfiAADO0aeBxstxcPvwww81bNgwz/2ZM2dKkrKysrRs2bJ6KwwAEBj6NNB4OQ5uQ4cOlTEmGLUAAOoBfRpovLiOGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFgizBhjGnLA0tJSJSUl6Z2bM5QQFdWQQwfshZUfhboERx64rWuoS3Ck89L/DnUJjVppaakuu+wylZSUKDExMdTlwAL06eCjT+NcTvo0e9wAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALOEouOXm5uqaa66R2+1Wy5YtNW7cOH388cfBqg0AEAB6NdB4OQpu27ZtU05Ojnbu3KmNGzfqm2++0ciRI1VeXh6s+gAADtGrgcYr0snMb7zxhtf9ZcuWqWXLlsrLy9PgwYPrtTAAQGDo1UDjdVHnuJWUlEiSmjVrVi/FAADqH70aaDwc7XE7V1VVlWbMmKEBAwaoe/futc5XUVGhiooKz/3S0tJAhwQAOORPr6ZPA/YIeI9bTk6O9u3bpxUrVlxwvtzcXCUlJXluqampgQ4JAHDIn15NnwbsEVBwmzp1qtauXastW7YoJSXlgvPOmjVLJSUlnlthYWFAhQIAnPG3V9OnAXs4OlRqjNGDDz6o1atXa+vWrWrfvn2dy7hcLrlcroALBAA447RX06cBezgKbjk5OVq+fLnWrFkjt9utI0eOSJKSkpIUGxsblAIBAM7Qq4HGy9Gh0sWLF6ukpERDhw5V69atPbeVK1cGqz4AgEP0aqDxcnyoFABwaaNXA40Xv1UKAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWCIyVAMf/4+XdMbtDtXwjvxikSvUJTjywJ/2hroERzb1zwl1CY5d3jsz1CX4rerMyVCXAEvRp4OHPh18KX3GhLoEvznp0+xxAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACzhKLgtXrxYPXr0UGJiohITE9WvXz+tX78+WLUBAAJArwYaL0fBLSUlRfPnz1deXp4+/PBDDR8+XDfeeKP2798frPoAAA7Rq4HGK9LJzGPHjvW6/+tf/1qLFy/Wzp071a1bt3otDAAQGHo10Hg5Cm7nqqys1KpVq1ReXq5+/frVZ00AgHpCrwYaF8fBbe/everXr59Onz6thIQErV69Wl27dq11/oqKClVUVHjul5aWBlYpAMBvTno1fRqwh+NvlXbp0kX5+fl6//33df/99ysrK0sfffRRrfPn5uYqKSnJc0tNTb2oggEAdXPSq+nTgD0cB7fo6Gh16tRJ6enpys3NVc+ePfXss8/WOv+sWbNUUlLiuRUWFl5UwQCAujnp1fRpwB4Bn+NWraqqymsX+/lcLpdcLtfFDgMAuAgX6tX0acAejoLbrFmzlJmZqbZt26qsrEzLly/X1q1btWHDhmDVBwBwiF4NNF6OgltxcbHuuusuffHFF0pKSlKPHj20YcMGjRgxIlj1AQAcolcDjZej4Pbb3/42WHUAAOoJvRpovPitUgAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASkaEa+PcffKao2IRQDe9Iy0RXqEtw5J+Hvgp1CY5EJzQNdQmOVZ45FeoS/FZ15nSoS4ClbOrTrZvEhLoERwoL/h3qEhyxsU+fPV0e6hL8VuXgPYU9bgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWuKjgNn/+fIWFhWnGjBn1VA4AoL7Rq4HGI+DgtmvXLi1ZskQ9evSoz3oAAPWIXg00LgEFtxMnTmjixIl6+eWX1bRp0/quCQBQD+jVQOMTUHDLycnRmDFjlJGRUee8FRUVKi0t9boBAILP315NnwbsEel0gRUrVmj37t3atWuXX/Pn5uZq7ty5jgsDAATOSa+mTwP2cLTHrbCwUNOnT9drr72mmJgYv5aZNWuWSkpKPLfCwsKACgUA+Mdpr6ZPA/ZwtMctLy9PxcXFuvrqqz3TKisrtX37di1cuFAVFRWKiIjwWsblcsnlctVPtQCAOjnt1fRpwB6Ogtu1116rvXv3ek3Lzs7WlVdeqZ///Oc1QhsAoOHRq4HGy1Fwc7vd6t69u9e0+Ph4NW/evMZ0AEBo0KuBxotfTgAAALCE42+Vnm/r1q31UAYAIJjo1UDjwB43AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALBHZ0AMaYyRJ35wqb+ihA1YR+U2oS3CksuJkqEtwxJytCHUJjlWdORXqEvxW9c23tVa/9oC6WNmno8+GugRH6NPB11j7dJhp4G7++eefKzU1tSGHBCCpsLBQKSkpoS4DFqBPA6HhT59u8OBWVVWloqIiud1uhYWF1dt6S0tLlZqaqsLCQiUmJtbbeoOFeoOLer9jjFFZWZnatGmj8HDOjkDd6NPfsa1m6g2uYNXrpE83+KHS8PDwoH7qT0xMtOIfvxr1Bhf1fispKane14nGiz5dk201U29wBaNef/s0H78BAAAsQXADAACwRKMJbi6XS7Nnz5bL5Qp1KX6h3uCiXuDSY+Pz3LaaqTe4LoV6G/zLCQAAAAhMo9njBgAA0NgR3AAAACxBcAMAALAEwQ0AAMASjSK4LVq0SO3atVNMTIz69u2rDz74INQl1Wr79u0aO3as2rRpo7CwML3++uuhLumCcnNzdc0118jtdqtly5YaN26cPv7441CXVavFixerR48enosj9uvXT+vXrw91WX6bP3++wsLCNGPGjFCXAtQ7enVw2NanJXr1xbA+uK1cuVIzZ87U7NmztXv3bvXs2VOjRo1ScXFxqEvzqby8XD179tSiRYtCXYpftm3bppycHO3cuVMbN27UN998o5EjR6q8/NL88emUlBTNnz9feXl5+vDDDzV8+HDdeOON2r9/f6hLq9OuXbu0ZMkS9ejRI9SlAPWOXh08tvVpiV59UYzl+vTpY3Jycjz3KysrTZs2bUxubm4Iq/KPJLN69epQl+FIcXGxkWS2bdsW6lL81rRpU/PKK6+EuowLKisrM507dzYbN240Q4YMMdOnTw91SUC9olc3HBv7tDH0an9ZvcftzJkzysvLU0ZGhmdaeHi4MjIy9N5774WwssarpKREktSsWbMQV1K3yspKrVixQuXl5erXr1+oy7mgnJwcjRkzxuu5DDQW9OqGZVOflujVTjX4j8zXpy+//FKVlZVq1aqV1/RWrVrpwIEDIaqq8aqqqtKMGTM0YMAAde/ePdTl1Grv3r3q16+fTp8+rYSEBK1evVpdu3YNdVm1WrFihXbv3q1du3aFuhQgKOjVDceWPi3RqwNldXBDw8rJydG+ffu0Y8eOUJdyQV26dFF+fr5KSkr05z//WVlZWdq2bdsl2RAKCws1ffp0bdy4UTExMaEuB4DlbOnTEr06UFYHtxYtWigiIkJHjx71mn706FFddtllIaqqcZo6darWrl2r7du3KyUlJdTlXFB0dLQ6deokSUpPT9euXbv07LPPasmSJSGurKa8vDwVFxfr6quv9kyrrKzU9u3btXDhQlVUVCgiIiKEFQIXj17dMGzq0xK9OlBWn+MWHR2t9PR0bd682TOtqqpKmzdvvuSPk9vCGKOpU6dq9erVeuutt9S+fftQl+RYVVWVKioqQl2GT9dee6327t2r/Px8z613796aOHGi8vPzCW1oFOjVwdUY+rREr/aX1XvcJGnmzJnKyspS79691adPHy1YsEDl5eXKzs4OdWk+nThxQgcPHvTcLygoUH5+vpo1a6a2bduGsDLfcnJytHz5cq1Zs0Zut1tHjhyRJCUlJSk2NjbE1dU0a9YsZWZmqm3btiorK9Py5cu1detWbdiwIdSl+eR2u2uchxIfH6/mzZtf8uenAE7Qq4PHtj4t0asvSoN/jzUInn/+edO2bVsTHR1t+vTpY3bu3Bnqkmq1ZcsWI6nGLSsrK9Sl+eSrVklm6dKloS7Np7vvvtukpaWZ6Ohok5ycbK699lrz5ptvhrosR7gcCBorenVw2NanjaFXX4wwY4xpyKAIAACAwFh9jhsAAMD3CcENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDRclLCxMc+bMCXUZtWrXrp2uv/76UJcBAPWmXbt2mjRpkuf+1q1bFRYWpq1bt9bbGJd6b/8+I7g1gIKCAk2dOlVXXHGF4uLiFBcXp65duyonJ0d/+9vfQl1e0BUVFWnOnDnKz88Pyvo/+ugjzZkzR4cPHw7K+gHgXMuWLVNYWJjnFhMToyuuuEJTp07V0aNHQ12e39atW0c4s1BkqAto7NauXavbbrtNkZGRmjhxonr27Knw8HAdOHBAf/nLX7R48WIVFBQoLS0t1KUGTVFRkebOnat27dqpV69e9b7+jz76SHPnztXQoUPVrl27el8/APjy+OOPq3379jp9+rR27NihxYsXa926ddq3b5/i4uIarI7Bgwfr1KlTio6OdrTcunXrtGjRIp/h7dSpU4qMJCJcivhXCaJDhw5pwoQJSktL0+bNm9W6dWuvx5944gm98MILCg+/8I7P8vJyxcfHB7PUS8rJkycbtOkBQCAyMzPVu3dvSdLkyZPVvHlzPf3001qzZo1uv/32GvMHq5eHh4crJiamXtdZ3+tD/eFQaRA9+eSTKi8v19KlS2uENkmKjIzUtGnTlJqa6pk2adIkJSQk6NChQxo9erTcbrcmTpwo6dsX/cMPP6zU1FS5XC516dJFTz31lIwxnuUPHz6ssLAwLVu2rMZ455+zMGfOHIWFhengwYOaNGmSmjRpoqSkJGVnZ+vkyZNey1ZUVOihhx5ScnKy3G63brjhBn3++ed1/g22bt2qa665RpKUnZ3tObRQXd/QoUPVvXt35eXlafDgwYqLi9Ojjz7qs95q557fsWzZMv34xz+WJA0bNsyz/vPP9dixY4f69OmjmJgYdejQQb///e/rrB0AnBg+fLikb0+PuVAvr6qq0oIFC9StWzfFxMSoVatWmjJlio4fP+61PmOM5s2bp5SUFMXFxWnYsGHav39/jXFrO8ft/fff1+jRo9W0aVPFx8erR48eevbZZyV9+16zaNEiSfI67FvNV//ds2ePMjMzlZiYqISEBF177bXauXOn1zzVh5HfeecdzZw5U8nJyYqPj9dNN92kY8eOOf+jogb2uAXR2rVr1alTJ/Xt29fRcmfPntWoUaM0cOBAPfXUU4qLi5MxRjfccIO2bNmie+65R7169dKGDRv0s5/9TP/617/0zDPPBFznrbfeqvbt2ys3N1e7d+/WK6+8opYtW+qJJ57wzDN58mT98Y9/1B133KH+/fvrrbfe0pgxY+pc91VXXaXHH39cjz32mO69914NGjRIktS/f3/PPF999ZUyMzM1YcIE3XnnnWrVqpXftQ8ePFjTpk3Tc889p0cffVRXXXWVZ9xqBw8e1Pjx43XPPfcoKytLr776qiZNmqT09HR169bN77EA4EIOHTokSWrevLkk371ckqZMmaJly5YpOztb06ZNU0FBgRYuXKg9e/bonXfeUVRUlCTpscce07x58zR69GiNHj1au3fv1siRI3XmzJk6a9m4caOuv/56tW7dWtOnT9dll12mv//971q7dq2mT5+uKVOmqKioSBs3btQf/vCHOte3f/9+DRo0SImJiXrkkUcUFRWlJUuWaOjQodq2bVuN97kHH3xQTZs21ezZs3X48GEtWLBAU6dO1cqVKx39TeGDQVCUlJQYSWbcuHE1Hjt+/Lg5duyY53by5EnPY1lZWUaS+cUvfuG1zOuvv24kmXnz5nlNHz9+vAkLCzMHDx40xhhTUFBgJJmlS5fWGFeSmT17tuf+7NmzjSRz9913e8130003mebNm3vu5+fnG0nmgQce8JrvjjvuqLFOX3bt2lVrTUOGDDGSzIsvvlhnvdXS0tJMVlaW5/6qVauMJLNlyxaf80oy27dv90wrLi42LpfLPPzwwxesGwB8Wbp0qZFkNm3aZI4dO2YKCwvNihUrTPPmzU1sbKz5/PPPa+3lb7/9tpFkXnvtNa/pb7zxhtf04uJiEx0dbcaMGWOqqqo88z366KNGklcP3LJli1cPPHv2rGnfvr1JS0szx48f9xrn3HXl5OSY2mLA+f133LhxJjo62hw6dMgzraioyLjdbjN48OAaf5uMjAyvsR566CETERFhvv76a5/jwX8cKg2S0tJSSVJCQkKNx4YOHark5GTPrXp39bnuv/9+r/vr1q1TRESEpk2b5jX94YcfljFG69evD7jW++67z+v+oEGD9NVXX3m2Yd26dZJUY+wZM2YEPOa5XC6XsrOz62VdvnTt2tWzp0+SkpOT1aVLF3366adBGxNA45eRkaHk5GSlpqZqwoQJSkhI0OrVq3X55Zd75jm/l69atUpJSUkaMWKEvvzyS88tPT1dCQkJ2rJliyRp06ZNOnPmjB588EGvQ5j+9N09e/aooKBAM2bMUJMmTbweO3dd/qqsrNSbb76pcePGqUOHDp7prVu31h133KEdO3Z43i+q3XvvvV5jDRo0SJWVlfrss88cjw9vHCoNErfbLUk6ceJEjceWLFmisrIyHT16VHfeeWeNxyMjI5WSkuI17bPPPlObNm08661WfUjwYl4Mbdu29brftGlTSdLx48eVmJiozz77TOHh4erYsaPXfF26dAl4zHNdfvnljr8N5cT52yd9u43nn08CAE4sWrRIV1xxhSIjI9WqVSt16dLF68tmvnr5J598opKSErVs2dLnOouLiyV919M7d+7s9XhycrKnR9em+pBt9+7dnW1QLY4dO6aTJ0/67PlXXXWVqqqqVFhY6HXqyYXeV3BxCG5BkpSUpNatW2vfvn01Hqs+F6C26465XK46v2lam9o+TVVWVta6TEREhM/p5pwvPQRTbGyso/kvtC2+hHr7ADROffr08Xyr1BdfvbyqqkotW7bUa6+95nOZ5OTkeq0xVOi7wUNwC6IxY8bolVde0QcffKA+ffpc1LrS0tK0adMmlZWVee11O3DggOdx6btPNV9//bXX8hezRy4tLU1VVVU6dOiQ1yeujz/+2K/lA9k1L327Ledvx5kzZ/TFF1/Uy/oBoKF17NhRmzZt0oABAy74obW6p3/yySdehyePHTtW516r6qMj+/btU0ZGRq3z+ds7k5OTFRcX57PnHzhwQOHh4V5XR0BwcY5bED3yyCOKi4vT3Xff7fNq2k4+eYwePVqVlZVauHCh1/RnnnlGYWFhyszMlCQlJiaqRYsW2r59u9d8L7zwQgBb8K3qdT/33HNe0xcsWODX8tXXLTo/hNWlY8eONbbjpZdeqrHHLdD1A0BDu/XWW1VZWalf/epXNR47e/asp49lZGQoKipKzz//vNd7hT999+qrr1b79u21YMGCGn3x3HX52zsjIiI0cuRIrVmzxutI0dGjR7V8+XINHDhQiYmJddaF+sEetyDq3Lmzli9frttvv11dunTx/HKCMUYFBQVavny5wsPDa5wD4cvYsWM1bNgw/fKXv9Thw4fVs2dPvfnmm1qzZo1mzJjhdf7Z5MmTNX/+fE2ePFm9e/fW9u3b9Y9//CPg7ejVq5duv/12vfDCCyopKVH//v21efNmHTx40K/lO3bsqCZNmujFF1+U2+1WfHy8+vbtq/bt219wucmTJ+u+++7TLbfcohEjRuivf/2rNmzYoBYtWtSoLyIiQk888YRKSkrkcrk0fPjwWs8hAYBQGTJkiKZMmaLc3Fzl5+dr5MiRioqK0ieffKJVq1bp2Wef1fjx45WcnKyf/vSnys3N1fXXX6/Ro0drz549Wr9+fY0eeL7w8HAtXrxYY8eOVa9evZSdna3WrVvrwIED2r9/vzZs2CBJSk9Pl/TtF89GjRqliIgITZgwwec6582bp40bN2rgwIF64IEHFBkZqSVLlqiiokJPPvlk/f6RcGGh+0Lr98fBgwfN/fffbzp16mRiYmJMbGysufLKK819991n8vPzvebNysoy8fHxPtdTVlZmHnroIdOmTRsTFRVlOnfubH7zm994feXaGGNOnjxp7rnnHpOUlGTcbre59dZbTXFxca2XAzl27JjX8tVf5y4oKPBMO3XqlJk2bZpp3ry5iY+PN2PHjjWFhYV+XQ7EGGPWrFljunbtaiIjI70uDTJkyBDTrVs3n8tUVlaan//856ZFixYmLi7OjBo1yhw8eLDG5UCMMebll182HTp0MBEREV5fi09LSzNjxoypse4hQ4aYIUOG1Fk3AJyvukfu2rWr1nku1MuNMeall14y6enpJjY21rjdbvODH/zAPPLII6aoqMgzT2VlpZk7d65p3bq1iY2NNUOHDjX79u2r0QPPvxxItR07dpgRI0YYt9tt4uPjTY8ePczzzz/vefzs2bPmwQcfNMnJySYsLMzr0iC+evvu3bvNqFGjTEJCgomLizPDhg0z7777rl9/m9pqhHNhxnCmIAAAgA04xw0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASzT4BXirqqpUVFQkt9vNTxUBDcAYo7KyMrVp0ybg38DF9wt9GmhYTvp0gwe3oqIiftMMCIHCwkK/fqUDoE8DoeFPn27w4Fb9A+md731VEdFxDT18QP754duhLsGRpu1+EOoSHBkwrEvdM11iWrhdoS7Bb2dOluuVySM8rz2gLtXPlSumLFWEy44+/dkH2+ue6RJiW58eNPzKUJfgWHKiXX16yd0ZfvXpBg9u1bvdI6LjrGkIYZH2/ONLUnh0bKhLcCQqNiHUJTjmirPrOSGJQ17wm6dPu+jTwWJbn46Oo083BH/6NCe8AAAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUCCm6LFi1Su3btFBMTo759++qDDz6o77oAABeJXg00Po6D28qVKzVz5kzNnj1bu3fvVs+ePTVq1CgVFxcHoz4AQADo1UDj5Di4Pf300/rJT36i7Oxsde3aVS+++KLi4uL06quvBqM+AEAA6NVA4+QouJ05c0Z5eXnKyMj4bgXh4crIyNB7773nc5mKigqVlpZ63QAAweO0V9OnAXs4Cm5ffvmlKisr1apVK6/prVq10pEjR3wuk5ubq6SkJM8tNTU18GoBAHVy2qvp04A9gv6t0lmzZqmkpMRzKywsDPaQAAAH6NOAPSKdzNyiRQtFRETo6NGjXtOPHj2qyy67zOcyLpdLLpcr8AoBAI447dX0acAejva4RUdHKz09XZs3b/ZMq6qq0ubNm9WvX796Lw4A4By9Gmi8HO1xk6SZM2cqKytLvXv3Vp8+fbRgwQKVl5crOzs7GPUBAAJArwYaJ8fB7bbbbtOxY8f02GOP6ciRI+rVq5feeOONGifBAgBCh14NNE6Og5skTZ06VVOnTq3vWgAA9YheDTQ+/FYpAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWCIyVAP3+EErRcUmhGp4R0qP9Qx1CY78+9O/hroER/L/2jTUJTg2clC7UJcABN0PurW0pk+XHKVPB1PeHvp0MFVWGb/nZY8bAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUcB7ft27dr7NixatOmjcLCwvT6668HoSwAQKDo00Dj5Ti4lZeXq2fPnlq0aFEw6gEAXCT6NNB4RTpdIDMzU5mZmcGoBQBQD+jTQOPFOW4AAACWcLzHzamKigpVVFR47peWlgZ7SACAA/RpwB5B3+OWm5urpKQkzy01NTXYQwIAHKBPA/YIenCbNWuWSkpKPLfCwsJgDwkAcIA+Ddgj6IdKXS6XXC5XsIcBAASIPg3Yw3FwO3HihA4ePOi5X1BQoPz8fDVr1kxt27at1+IAAM7Rp4HGy3Fw+/DDDzVs2DDP/ZkzZ0qSsrKytGzZsnorDAAQGPo00Hg5Dm5Dhw6VMSYYtQAA6gF9Gmi8uI4bAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWCIyVAPf1SdN8W53qIZ35J3tBaEuwZEzJ46HugRH2nZsHuoSHJs2sF2oS/BbWVmpXgh1EbASfTp46NPB11j7NHvcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACzhKLjl5ubqmmuukdvtVsuWLTVu3Dh9/PHHwaoNABAAejXQeDkKbtu2bVNOTo527typjRs36ptvvtHIkSNVXl4erPoAAA7Rq4HGK9LJzG+88YbX/WXLlqlly5bKy8vT4MGD67UwAEBg6NVA43VR57iVlJRIkpo1a1YvxQAA6h+9Gmg8HO1xO1dVVZVmzJihAQMGqHv37rXOV1FRoYqKCs/90tLSQIcEADjkT6+mTwP2CHiPW05Ojvbt26cVK1ZccL7c3FwlJSV5bqmpqYEOCQBwyJ9eTZ8G7BFQcJs6darWrl2rLVu2KCUl5YLzzpo1SyUlJZ5bYWFhQIUCAJzxt1fTpwF7ODpUaozRgw8+qNWrV2vr1q1q3759ncu4XC65XK6ACwQAOOO0V9OnAXs4Cm45OTlavny51qxZI7fbrSNHjkiSkpKSFBsbG5QCAQDO0KuBxsvRodLFixerpKREQ4cOVevWrT23lStXBqs+AIBD9Gqg8XJ8qBQAcGmjVwONF79VCgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFgiMlQDN/3VvUqIigrV8I58tPS/Q12CQ9eHugBHPsm+JdQlODb/gY9CXYLfzqgq1CXAUvTpYKJPB1tj7dPscQMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAs4Si4LV68WD169FBiYqISExPVr18/rV+/Pli1AQACQK8GGi9HwS0lJUXz589XXl6ePvzwQw0fPlw33nij9u/fH6z6AAAO0auBxivSycxjx471uv/rX/9aixcv1s6dO9WtW7d6LQwAEBh6NdB4OQpu56qsrNSqVatUXl6ufv361WdNAIB6Qq8GGhfHwW3v3r3q16+fTp8+rYSEBK1evVpdu3atdf6KigpVVFR47peWlgZWKQDAb056NX0asIfjb5V26dJF+fn5ev/993X//fcrKytLH330Ua3z5+bmKikpyXNLTU29qIIBAHVz0qvp04A9HAe36OhoderUSenp6crNzVXPnj317LPP1jr/rFmzVFJS4rkVFhZeVMEAgLo56dX0acAeAZ/jVq2qqsprF/v5XC6XXC7XxQ4DALgIF+rV9GnAHo6C26xZs5SZmam2bduqrKxMy5cv19atW7Vhw4Zg1QcAcIheDTRejoJbcXGx7rrrLn3xxRdKSkpSjx49tGHDBo0YMSJY9QEAHKJXA42Xo+D229/+Nlh1AADqCb0aaLz4rVIAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEmHGGNOQA5aWliopKUkZ//mmomLjG3LogG166ZVQl+DI5b0zQ12CI0t/MSzUJTjWrokr1CX4raysVD3ap6ikpESJiYmhLgcWoE8HX0qfMaEuwZFXHxkS6hIca6x9mj1uAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJa4qOA2f/58hYWFacaMGfVUDgCgvtGrgcYj4OC2a9cuLVmyRD169KjPegAA9YheDTQuAQW3EydOaOLEiXr55ZfVtGnT+q4JAFAP6NVA4xNQcMvJydGYMWOUkZFR57wVFRUqLS31ugEAgs/fXk2fBuwR6XSBFStWaPfu3dq1a5df8+fm5mru3LmOCwMABM5Jr6ZPA/ZwtMetsLBQ06dP12uvvaaYmBi/lpk1a5ZKSko8t8LCwoAKBQD4x2mvpk8D9nC0xy0vL0/FxcW6+uqrPdMqKyu1fft2LVy4UBUVFYqIiPBaxuVyyeVy1U+1AIA6Oe3V9GnAHo6C27XXXqu9e/d6TcvOztaVV16pn//85zVCGwCg4dGrgcbLUXBzu93q3r2717T4+Hg1b968xnQAQGjQq4HGi19OAAAAsITjb5Web+vWrfVQBgAgmOjVQOPAHjcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsEdnQAxpjJElnT5c39NABM5VnQl2CI1VnToa6BEfKy8pCXYJjZREVoS7Bbyf+/9+3+rUH1IU+HXz06eBrrH06zDRwN//888+VmprakEMCkFRYWKiUlJRQlwEL0KeB0PCnTzd4cKuqqlJRUZHcbrfCwsLqbb2lpaVKTU1VYWGhEhMT6229wUK9wUW93zHGqKysTG3atFF4OGdHoG706e/YVjP1Blew6nXSpxv8UGl4eHhQP/UnJiZa8Y9fjXqDi3q/lZSUVO/rRONFn67JtpqpN7iCUa+/fZqP3wAAAJYguAEAAFii0QQ3l8ul2bNny+VyhboUv1BvcFEvcOmx8XluW83UG1yXQr0N/uUEAAAABKbR7HEDAABo7AhuAAAAliC4AQAAWILgBgAAYIlGEdwWLVqkdu3aKSYmRn379tUHH3wQ6pJqtX37do0dO1Zt2rRRWFiYXn/99VCXdEG5ubm65ppr5Ha71bJlS40bN04ff/xxqMuq1eLFi9WjRw/PxRH79eun9evXh7osv82fP19hYWGaMWNGqEsB6h29Ojhs69MSvfpiWB/cVq5cqZkzZ2r27NnavXu3evbsqVGjRqm4uDjUpflUXl6unj17atGiRaEuxS/btm1TTk6Odu7cqY0bN+qbb77RyJEjVV5+af74dEpKiubPn6+8vDx9+OGHGj58uG688Ubt378/1KXVadeuXVqyZIl69OgR6lKAekevDh7b+rREr74oxnJ9+vQxOTk5nvuVlZWmTZs2Jjc3N4RV+UeSWb16dajLcKS4uNhIMtu2bQt1KX5r2rSpeeWVV0JdxgWVlZWZzp07m40bN5ohQ4aY6dOnh7okoF7RqxuOjX3aGHq1v6ze43bmzBnl5eUpIyPDMy08PFwZGRl67733QlhZ41VSUiJJatasWYgrqVtlZaVWrFih8vJy9evXL9TlXFBOTo7GjBnj9VwGGgt6dcOyqU9L9GqnGvxH5uvTl19+qcrKSrVq1cpreqtWrXTgwIEQVdV4VVVVacaMGRowYIC6d+8e6nJqtXfvXvXr10+nT59WQkKCVq9era5du4a6rFqtWLFCu3fv1q5du0JdChAU9OqGY0uflujVgbI6uKFh5eTkaN++fdqxY0eoS7mgLl26KD8/XyUlJfrzn/+srKwsbdu27ZJsCIWFhZo+fbo2btyomJiYUJcDwHK29GmJXh0oq4NbixYtFBERoaNHj3pNP3r0qC677LIQVdU4TZ06VWvXrtX27duVkpIS6nIuKDo6Wp06dZIkpaena9euXXr22We1ZMmSEFdWU15enoqLi3X11Vd7plVWVmr79u1auHChKioqFBEREcIKgYtHr24YNvVpiV4dKKvPcYuOjlZ6ero2b97smVZVVaXNmzdf8sfJbWGM0dSpU7V69Wq99dZbat++fahLcqyqqkoVFRWhLsOna6+9Vnv37lV+fr7n1rt3b02cOFH5+fmENjQK9Orgagx9WqJX+8vqPW6SNHPmTGVlZal3797q06ePFixYoPLycmVnZ4e6NJ9OnDihgwcPeu4XFBQoPz9fzZo1U9u2bUNYmW85OTlavny51qxZI7fbrSNHjkiSkpKSFBsbG+Lqapo1a5YyMzPVtm1blZWVafny5dq6das2bNgQ6tJ8crvdNc5DiY+PV/PmzS/581MAJ+jVwWNbn5bo1Relwb/HGgTPP/+8adu2rYmOjjZ9+vQxO3fuDHVJtdqyZYuRVOOWlZUV6tJ88lWrJLN06dJQl+bT3XffbdLS0kx0dLRJTk421157rXnzzTdDXZYjXA4EjRW9Ojhs69PG0KsvRpgxxjRkUAQAAEBgrD7HDQAA4PuE4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguCGixIWFqY5c+aEuoxatWvXTtdff32oywCAetOuXTtNmjTJc3/r1q0KCwvT1q1b622MS723f58R3BpAQUGBpk6dqiuuuEJxcXGKi4tT165dlZOTo7/97W+hLi/oioqKNGfOHOXn5wdl/R999JHmzJmjw4cPB2X9AHCuZcuWKSwszHOLiYnRFVdcoalTp+ro0aOhLs9v69atI5xZKDLUBTR2a9eu1W233abIyEhNnDhRPXv2VHh4uA4cOKC//OUvWrx4sQoKCpSWlhbqUoOmqKhIc+fOVbt27dSrV696X/9HH32kuXPnaujQoWrXrl29rx8AfHn88cfVvn17nT59Wjt27NDixYu1bt067du3T3FxcQ1Wx+DBg3Xq1ClFR0c7Wm7dunVatGiRz/B26tQpRUYSES5F/KsE0aFDhzRhwgSlpaVp8+bNat26tdfjTzzxhF544QWFh194x2d5ebni4+ODWeol5eTJkw3a9AAgEJmZmerdu7ckafLkyWrevLmefvpprVmzRrfffnuN+YPVy8PDwxUTE1Ov66zv9aH+cKg0iJ588kmVl5dr6dKlNUKbJEVGRmratGlKTU31TJs0aZISEhJ06NAhjR49Wm63WxMnTpT07Yv+4YcfVmpqqlwul7p06aKnnnpKxhjP8ocPH1ZYWJiWLVtWY7zzz1mYM2eOwsLCdPDgQU2aNElNmjRRUlKSsrOzdfLkSa9lKyoq9NBDDyk5OVlut1s33HCDPv/88zr/Blu3btU111wjScrOzvYcWqiub+jQoerevbvy8vI0ePBgxcXF6dFHH/VZb7Vzz+9YtmyZfvzjH0uShg0b5ln/+ed67NixQ3369FFMTIw6dOig3//+93XWDgBODB8+XNK3p8dcqJdXVVVpwYIF6tatm2JiYtSqVStNmTJFx48f91qfMUbz5s1TSkqK4uLiNGzYMO3fv7/GuLWd4/b+++9r9OjRatq0qeLj49WjRw89++yzkr59r1m0aJEkeR32rear/+7Zs0eZmZlKTExUQkKCrr32Wu3cudNrnurDyO+8845mzpyp5ORkxcfH66abbtKxY8ec/1FRA3vcgmjt2rXq1KmT+vbt62i5s2fPatSoURo4cKCeeuopxcXFyRijG264QVu2bNE999yjXr16acOGDfrZz36mf/3rX3rmmWcCrvPWW29V+/btlZubq927d+uVV15Ry5Yt9cQTT3jmmTx5sv74xz/qjjvuUP/+/fXWW29pzJgxda77qquu0uOPP67HHntM9957rwYNGiRJ6t+/v2eer776SpmZmZowYYLuvPNOtWrVyu/aBw8erGnTpum5557To48+qquuusozbrWDBw9q/Pjxuueee5SVlaVXX31VkyZNUnp6urp16+b3WABwIYcOHZIkNW/eXJLvXi5JU6ZM0bJly5Sdna1p06apoKBACxcu1J49e/TOO+8oKipKkvTYY49p3rx5Gj16tEaPHq3du3dr5MiROnPmTJ21bNy4Uddff71at26t6dOn67LLLtPf//53rV27VtOnT9eUKVNUVFSkjRs36g9/+EOd69u/f78GDRqkxMREPfLII4qKitKSJUs0dOhQbdu2rcb73IMPPqimTZtq9uzZOnz4sBYsWKCpU6dq5cqVjv6m8MEgKEpKSowkM27cuBqPHT9+3Bw7dsxzO3nypOexrKwsI8n84he/8Frm9ddfN5LMvHnzvKaPHz/ehIWFmYMHDxpjjCkoKDCSzNKlS2uMK8nMnj3bc3/27NlGkrn77ru95rvppptM8+bNPffz8/ONJPPAAw94zXfHHXfUWKcvu3btqrWmIUOGGEnmxRdfrLPeamlpaSYrK8tzf9WqVUaS2bJli895JZnt27d7phUXFxuXy2UefvjhC9YNAL4sXbrUSDKbNm0yx44dM4WFhWbFihWmefPmJjY21nz++ee19vK3337bSDKvvfaa1/Q33njDa3pxcbGJjo42Y8aMMVVVVZ75Hn30USPJqwdu2bLFqweePXvWtG/f3qSlpZnjx497jXPuunJyckxtMeD8/jtu3DgTHR1tDh065JlWVFRk3G63GTx4cI2/TUZGhtdYDz30kImIiDBff/21z/HgPw6VBklpaakkKSEhocZjQ4cOVXJysudWvbv6XPfff7/X/XXr1ikiIkLTpk3zmv7www/LGKP169cHXOt9993ndX/QoEH66quvPNuwbt06Saox9owZMwIe81wul0vZ2dn1si5funbt6tnTJ0nJycnq0qWLPv3006CNCaDxy8jIUHJyslJTUzVhwgQlJCRo9erVuvzyyz3znN/LV61apaSkJI0YMUJffvml55aenq6EhARt2bJFkrRp0yadOXNGDz74oNchTH/67p49e1RQUKAZM2aoSZMmXo+duy5/VVZW6s0339S4cePUoUMHz/TWrVvrjjvu0I4dOzzvF9Xuvfder7EGDRqkyspKffbZZ47HhzcOlQaJ2+2WJJ04caLGY0uWLFFZWZmOHj2qO++8s8bjkZGRSklJ8Zr22WefqU2bNp71Vqs+JHgxL4a2bdt63W/atKkk6fjx40pMTNRnn32m8PBwdezY0Wu+Ll26BDzmuS6//HLH34Zy4vztk77dxvPPJwEAJxYtWqQrrrhCkZGRatWqlbp06eL1ZTNfvfyTTz5RSUmJWrZs6XOdxcXFkr7r6Z07d/Z6PDk52dOja1N9yLZ79+7ONqgWx44d08mTJ332/KuuukpVVVUqLCz0OvXkQu8ruDgEtyBJSkpS69attW/fvhqPVZ8LUNt1x1wuV53fNK1NbZ+mKisra10mIiLC53Rzzpcegik2NtbR/BfaFl9CvX0AGqc+ffp4vlXqi69eXlVVpZYtW+q1117zuUxycnK91hgq9N3gIbgF0ZgxY/TKK6/ogw8+UJ8+fS5qXWlpadq0aZPKysq89rodOHDA87j03aear7/+2mv5i9kjl5aWpqqqKh06dMjrE9fHH3/s1/KB7JqXvt2W87fjzJkz+uKLL+pl/QDQ0Dp27KhNmzZpwIABF/zQWt3TP/nkE6/Dk8eOHatzr1X10ZF9+/YpIyOj1vn87Z3JycmKi4vz2fMPHDig8PBwr6sjILg4xy2IHnnkEcXFxenuu+/2eTVtJ588Ro8ercrKSi1cuNBr+jPPPKOwsDBlZmZKkhITE9WiRQtt377da74XXnghgC34VvW6n3vuOa/pCxYs8Gv56usWnR/C6tKxY8ca2/HSSy/V2OMW6PoBoKHdeuutqqys1K9+9asaj509e9bTxzIyMhQVFaXnn3/e673Cn7579dVXq3379lqwYEGNvnjuuvztnRERERo5cqTWrFnjdaTo6NGjWr58uQYOHKjExMQ660L9YI9bEHXu3FnLly/X7bffri5dunh+OcEYo4KCAi1fvlzh4eE1zoHwZezYsRo2bJh++ctf6vDhw+rZs6fefPNNrVmzRjNmzPA6/2zy5MmaP3++Jk+erN69e2v79u36xz/+EfB29OrVS7fffrteeOEFlZSUqH///tq8ebMOHjzo1/IdO3ZUkyZN9OKLL8rtdis+Pl59+/ZV+/btL7jc5MmTdd999+mWW27RiBEj9Ne//lUbNmxQixYtatQXERGhJ554QiUlJXK5XBo+fHit55AAQKgMGTJEU6ZMUW5urvLz8zVy5EhFRUXpk08+0apVq/Tss89q/PjxSk5O1k9/+lPl5ubq+uuv1+jRo7Vnzx6tX7++Rg88X3h4uBYvXqyxY8eqV69eys7OVuvWrXXgwAHt379fGzZskCSlp6dL+vaLZ6NGjVJERIQmTJjgc53z5s3Txo0bNXDgQD3wwAOKjIzUkiVLVFFRoSeffLJ+/0i4sNB9ofX74+DBg+b+++83nTp1MjExMSY2NtZceeWV5r777jP5+fle82ZlZZn4+Hif6ykrKzMPPfSQadOmjYmKijKdO3c2v/nNb7y+cm2MMSdPnjT33HOPSUpKMm6329x6662muLi41suBHDt2zGv56q9zFxQUeKadOnXKTJs2zTRv3tzEx8ebsWPHmsLCQr8uB2KMMWvWrDFdu3Y1kZGRXpcGGTJkiOnWrZvPZSorK83Pf/5z06JFCxMXF2dGjRplDh48WONyIMYY8/LLL5sOHTqYiIgIr6/Fp6WlmTFjxtRY95AhQ8yQIUPqrBsAzlfdI3ft2lXrPBfq5cYY89JLL5n09HQTGxtr3G63+cEPfmAeeeQRU1RU5JmnsrLSzJ0717Ru3drExsaaoUOHmn379tXogedfDqTajh07zIgRI4zb7Tbx8fGmR48e5vnnn/c8fvbsWfPggw+a5ORkExYW5nVpEF+9fffu3WbUqFEmISHBxMXFmWHDhpl3333Xr79NbTXCuTBjOFMQAADABpzjBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlGvwCvFVVVSoqKpLb7eanioAGYIxRWVmZ2rRpE/Bv4OL7hT4NNCwnfbrBg1tRURG/aQaEQGFhoV+/0gHQp4HQ8KdPN3hwq/6B9KG/Xq3ImPiGHj4gT9/cNdQlOPLPr8+EugRHHnhme90zXWKK9mwMdQl+M5XfqPKjP3lee0Bd6NPBZ1ufznl2R6hLcOxfeRtCXYLfnPTpBg9u1bvdI2PiFRVrR0Nwu+368dz4yopQl+BIeHRcqEtwLCwiOtQlOMYhL/iLPh189Onga6x9mhNeAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIBBbdFixapXbt2iomJUd++ffXBBx/Ud10AgItErwYaH8fBbeXKlZo5c6Zmz56t3bt3q2fPnho1apSKi4uDUR8AIAD0aqBxchzcnn76af3kJz9Rdna2unbtqhdffFFxcXF69dVXg1EfACAA9GqgcXIU3M6cOaO8vDxlZGR8t4LwcGVkZOi9997zuUxFRYVKS0u9bgCA4HHaq+nTgD0cBbcvv/xSlZWVatWqldf0Vq1a6ciRIz6Xyc3NVVJSkueWmpoaeLUAgDo57dX0acAeQf9W6axZs1RSUuK5FRYWBntIAIAD9GnAHpFOZm7RooUiIiJ09OhRr+lHjx7VZZdd5nMZl8sll8sVeIUAAEec9mr6NGAPR3vcoqOjlZ6ers2bN3umVVVVafPmzerXr1+9FwcAcI5eDTRejva4SdLMmTOVlZWl3r17q0+fPlqwYIHKy8uVnZ0djPoAAAGgVwONk+Pgdtttt+nYsWN67LHHdOTIEfXq1UtvvPFGjZNgAQChQ68GGifHwU2Spk6dqqlTp9Z3LQCAekSvBhoffqsUAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALBFmjDENOWBpaamSkpL0zs0ZSoiKasihA/bCyo9CXYIjD9zWNdQlONJ56X+HuoRGrbS0VJdddplKSkqUmJgY6nJgAfp08NnWp6+gTwdVaWmpWvnZp9njBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJx8Ft+/btGjt2rNq0aaOwsDC9/vrrQSgLABAo+jTQeDkObuXl5erZs6cWLVoUjHoAABeJPg00XpFOF8jMzFRmZmYwagEA1AP6NNB4cY4bAACAJRzvcXOqoqJCFRUVnvulpaXBHhIA4AB9GrBH0Pe45ebmKikpyXNLTU0N9pAAAAfo04A9gh7cZs2apZKSEs+tsLAw2EMCABygTwP2CPqhUpfLJZfLFexhAAABok8D9nAc3E6cOKGDBw967hcUFCg/P1/NmjVT27Zt67U4AIBz9Gmg8XIc3D788EMNGzbMc3/mzJmSpKysLC1btqzeCgMABIY+DTRejoPb0KFDZYwJRi0AgHpAnwYaL67jBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJaIDNXAx//jJZ1xu0M1vCO/WOQKdQmOPPCnvaEuwZFN/XNCXYJjl/fODHUJfqs6czLUJcBS9OngoU8HX2Pt0+xxAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALCEo+CWm5ura665Rm63Wy1bttS4ceP08ccfB6s2AEAA6NVA4+UouG3btk05OTnauXOnNm7cqG+++UYjR45UeXl5sOoDADhErwYar0gnM7/xxhte95ctW6aWLVsqLy9PgwcPrtfCAACBoVcDjddFneNWUlIiSWrWrFm9FAMAqH/0aqDxcLTH7VxVVVWaMWOGBgwYoO7du9c6X0VFhSoqKjz3S0tLAx0SAOCQP72aPg3YI+A9bjk5Odq3b59WrFhxwflyc3OVlJTkuaWmpgY6JADAIX96NX0asEdAwW3q1Klau3attmzZopSUlAvOO2vWLJWUlHhuhYWFARUKAHDG315Nnwbs4ehQqTFGDz74oFavXq2tW7eqffv2dS7jcrnkcrkCLhAA4IzTXk2fBuzhKLjl5ORo+fLlWrNmjdxut44cOSJJSkpKUmxsbFAKBAA4Q68GGi9Hh0oXL16skpISDR06VK1bt/bcVq5cGaz6AAAO0auBxsvxoVIAwKWNXg00XvxWKQAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFiC4AYAAGCJyFAN/PsPPlNUbEKohnekZaIr1CU48s9DX4W6BEeiE5qGugTHKs+cCnUJfqs6czrUJcBSf9z1T0XH0aeDobDg36EuwRH6dHA56dPscQMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAs4Si4LV68WD169FBiYqISExPVr18/rV+/Pli1AQACQK8GGi9HwS0lJUXz589XXl6ePvzwQw0fPlw33nij9u/fH6z6AAAO0auBxivSycxjx471uv/rX/9aixcv1s6dO9WtW7d6LQwAEBh6NdB4OQpu56qsrNSqVatUXl6ufv361WdNAIB6Qq8GGhfHwW3v3r3q16+fTp8+rYSEBK1evVpdu3atdf6KigpVVFR47peWlgZWKQDAb056NX0asIfjb5V26dJF+fn5ev/993X//fcrKytLH330Ua3z5+bmKikpyXNLTU29qIIBAHVz0qvp04A9HAe36OhoderUSenp6crNzVXPnj317LPP1jr/rFmzVFJS4rkVFhZeVMEAgLo56dX0acAeAZ/jVq2qqsprF/v5XC6XXC7XxQ4DALgIF+rV9GnAHo6C26xZs5SZmam2bduqrKxMy5cv19atW7Vhw4Zg1QcAcIheDTRejoJbcXGx7rrrLn3xxRdKSkpSjx49tGHDBo0YMSJY9QEAHKJXA42Xo+D229/+Nlh1AADqCb0aaLz4rVIAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEpGhGvhve48qwlUWquEdGTmoXahLcKRXz9ahLsGR0mM9Q12CY//+9K+hLsFv5mxFqEuApf66z54+PWJAWqhLcKTnDy4LdQmOlBylTweTkz7NHjcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAASxDcAAAALEFwAwAAsATBDQAAwBIENwAAAEsQ3AAAACxBcAMAALAEwQ0AAMASBDcAAABLENwAAAAsQXADAACwBMENAADAEgQ3AAAAS1xUcJs/f77CwsI0Y8aMeioHAFDf6NVA4xFwcNu1a5eWLFmiHj161Gc9AIB6RK8GGpeAgtuJEyc0ceJEvfzyy2ratGl91wQAqAf0aqDxCSi45eTkaMyYMcrIyKhz3oqKCpWWlnrdAADB52+vpk8D9oh0usCKFSu0e/du7dq1y6/5c3NzNXfuXMeFAQAC56RX06cBezja41ZYWKjp06frtddeU0xMjF/LzJo1SyUlJZ5bYWFhQIUCAPzjtFfTpwF7ONrjlpeXp+LiYl199dWeaZWVldq+fbsWLlyoiooKRUREeC3jcrnkcrnqp1oAQJ2c9mr6NGAPR8Ht2muv1d69e72mZWdn68orr9TPf/7zGqENANDw6NVA4+UouLndbnXv3t1rWnx8vJo3b15jOgAgNOjVQOPFLycAAABYwvG3Ss+3devWeigDABBM9GqgcWCPGwAAgCUIbgAAAJYguAEAAFiC4AYAAGAJghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJaIbOgBjTGSpMozJxt66IBVnDwR6hIc+eZURahLcKTqzKlQl+CYOWvP39icPfPtf///aw+oi6dPV9Cng4U+HXyNtU+HmQbu5p9//rlSU1MbckgAkgoLC5WSkhLqMmAB+jQQGv706QYPblVVVSoqKpLb7VZYWFi9rbe0tFSpqakqLCxUYmJiva03WKg3uKj3O8YYlZWVqU2bNgoP5+wI1I0+/R3baqbe4ApWvU76dIMfKg0PDw/qp/7ExEQr/vGrUW9wUe+3kpKS6n2daLzo0zXZVjP1Blcw6vW3T/PxGwAAwBIENwAAAEs0muDmcrk0e/ZsuVyuUJfiF+oNLuoFLj02Ps9tq5l6g+tSqLfBv5wAAACAwDSaPW4AAACNHcENAADAEgQ3AAAASxDcAAAALNEogtuiRYvUrl07xcTEqG/fvvrggw9CXVKttm/frrFjx6pNmzYKCwvT66+/HuqSLig3N1fXXHON3G63WrZsqXHjxunjjz8OdVm1Wrx4sXr06OG5OGK/fv20fv36UJflt/nz5yssLEwzZswIdSlAvaNXB4dtfVqiV18M64PbypUrNXPmTM2ePVu7d+9Wz549NWrUKBUXF4e6NJ/Ky8vVs2dPLVq0KNSl+GXbtm3KycnRzp07tXHjRn3zzTcaOXKkysvLQ12aTykpKZo/f77y8vL04Ycfavjw4brxxhu1f//+UJdWp127dmnJkiXq0aNHqEsB6h29Onhs69MSvfqiGMv16dPH5OTkeO5XVlaaNm3amNzc3BBW5R9JZvXq1aEuw5Hi4mIjyWzbti3UpfitadOm5pVXXgl1GRdUVlZmOnfubDZu3GiGDBlipk+fHuqSgHpFr244NvZpY+jV/rJ6j9uZM2eUl5enjIwMz7Tw8HBlZGTovffeC2FljVdJSYkkqVmzZiGupG6VlZVasWKFysvL1a9fv1CXc0E5OTkaM2aM13MZaCzo1Q3Lpj4t0audavAfma9PX375pSorK9WqVSuv6a1atdKBAwdCVFXjVVVVpRkzZmjAgAHq3r17qMup1d69e9WvXz+dPn1aCQkJWr16tbp27Rrqsmq1YsUK7d69W7t27Qp1KUBQ0Ksbji19WqJXB8rq4IaGlZOTo3379mnHjh2hLuWCunTpovz8fJWUlOjPf/6zsrKytG3btkuyIRQWFmr69OnauHGjYmJiQl0OAMvZ0qclenWgrA5uLVq0UEREhI4ePeo1/ejRo7rssstCVFXjNHXqVK1du1bbt29XSkpKqMu5oOjoaHXq1EmSlJ6erl27dunZZ5/VkiVLQlxZTXl5eSouLtbVV1/tmVZZWant27dr4cKFqqioUERERAgrBC4evbph2NSnJXp1oKw+xy06Olrp6enavHmzZ1pVVZU2b958yR8nt4UxRlOnTtXq1av11ltvqX379qEuybGqqipVVFSEugyfrr32Wu3du1f5+fmeW+/evTVx4kTl5+cT2tAo0KuDqzH0aYle7S+r97hJ0syZM5WVlaXevXurT58+WrBggcrLy5WdnR3q0nw6ceKEDh486LlfUFCg/Px8NWvWTG3btg1hZb7l5ORo+fLlWrNmjdxut44cOSJJSkpKUmxsbIirq2nWrFnKzMxU27ZtVVZWpuXLl2vr1q3asGFDqEvzye121zgPJT4+Xs2bN7/kz08BnKBXB49tfVqiV1+UBv8eaxA8//zzpm3btiY6Otr06dPH7Ny5M9Ql1WrLli1GUo1bVlZWqEvzyVetkszSpUtDXZpPd999t0lLSzPR0dEmOTnZXHvttebNN98MdVmOcDkQNFb06uCwrU8bQ6++GGHGGNOQQREAAACBsfocNwAAgO8TghsAAIAlCG4AAACWILgBAABYguAGAABgCYIbAACAJQhuAAAAliC4AQAAWILgBgAAYAmCGwAAgCUIbgAAAJYguAEAAFji/wGEXfgBblaF2QAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 800x900 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Show a few predictions vs ground truth\n",
     "net.load_state_dict(param_history[-1])\n",
@@ -266,8 +349,7 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/cnxcn_predictions.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "054e6506"
+   ]
   }
  ],
  "metadata": {
@@ -277,8 +359,16 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.12.0"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/sequential_cnxcn.ipynb b/notebooks/sequential_cnxcn.ipynb
index 66e0468..ccec032 100644
--- a/notebooks/sequential_cnxcn.ipynb
+++ b/notebooks/sequential_cnxcn.ipynb
@@ -2,6 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "1ec3cb04",
    "metadata": {},
    "source": [
     "# Sequential Group Composition on $C_n \\times C_n$\n",
@@ -11,20 +12,20 @@
     "**Sequence length:** $k = 3$ (sequential composition).  \n",
     "**Architecture:** `QuadraticRNN` with quadratic recurrence.  \n",
     "**Key result:** The RNN composes elements sequentially in $k$ steps, exploiting associativity."
-   ],
-   "id": "1ec3cb04"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "ba41a633",
    "metadata": {},
    "source": [
     "## Imports"
-   ],
-   "id": "ba41a633"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
+   "id": "89d7e15d",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,22 +45,32 @@
     "import src.template as template\n",
     "import src.train as train_mod\n",
     "import src.viz as viz"
-   ],
-   "id": "89d7e15d"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "1ad735f7",
    "metadata": {},
    "source": [
     "## Configuration"
-   ],
-   "id": "1ad735f7"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
+   "id": "48a1e9ce",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Group: C_3 x C_3, order 9\n",
+      "Sequence length: k=3\n",
+      "Device: cuda\n"
+     ]
+    }
+   ],
    "source": [
     "TEST_MODE = os.environ.get(\"NOTEBOOK_TEST_MODE\", \"0\") == \"1\"\n",
     "\n",
@@ -68,11 +79,11 @@
     "np.random.seed(seed)\n",
     "torch.manual_seed(seed)\n",
     "\n",
-    "p1, p2 = 7, 7  # Cn x Cn dimensions\n",
+    "p1, p2 = 3, 3  # Cn x Cn dimensions\n",
     "p_flat = p1 * p2\n",
     "k = 3  # Sequence length\n",
     "hidden_dim = 50 if TEST_MODE else 200\n",
-    "epochs = 2 if TEST_MODE else 5\n",
+    "epochs = 2 if TEST_MODE else 10000\n",
     "num_samples = 100 if TEST_MODE else 10000\n",
     "batch_size = 64 if TEST_MODE else 1000\n",
     "lr = 1e-3\n",
@@ -87,25 +98,35 @@
     "print(f\"Group: C_{p1} x C_{p2}, order {p_flat}\")\n",
     "print(f\"Sequence length: k={k}\")\n",
     "print(f\"Device: {device}\")"
-   ],
-   "id": "48a1e9ce"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "914f0697",
    "metadata": {},
    "source": [
     "## Template and Dataset"
-   ],
-   "id": "914f0697"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
+   "id": "c3944d8b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset: 10000 samples\n",
+      "X shape: torch.Size([10000, 3, 9]) (N, k, p1*p2)\n",
+      "Y shape: torch.Size([10000, 9]) (N, p1*p2)\n"
+     ]
+    }
+   ],
    "source": [
     "# Build a 2D template with known Fourier structure\n",
-    "tpl_2d = template.unique_freqs_2d(p1, p2, n_freqs=5, seed=seed)\n",
+    "tpl_2d = template.unique_freqs_2d(p1, p2, n_freqs=4, seed=seed)\n",
     "\n",
     "# Build sequential dataset\n",
     "X, Y, sequence_xy = dataset.build_modular_addition_sequence_dataset_2d(\n",
@@ -121,14 +142,25 @@
     "print(f\"Dataset: {len(ds)} samples\")\n",
     "print(f\"X shape: {X_tensor.shape} (N, k, p1*p2)\")\n",
     "print(f\"Y shape: {Y_tensor.shape} (N, p1*p2)\")"
-   ],
-   "id": "c3944d8b"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
+   "id": "4d05d643",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Visualize template\n",
     "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n",
@@ -150,22 +182,32 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_template.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "4d05d643"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "1fc45af3",
    "metadata": {},
    "source": [
     "## Model and Optimizer"
-   ],
-   "id": "1fc45af3"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
+   "id": "7261d8b6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: QuadraticRNN(p=9, d=200, k=3)\n",
+      "Optimizer: HybridRNNOptimizer(lr=0.001)\n",
+      "Training for 10000 epochs\n"
+     ]
+    }
+   ],
    "source": [
     "net = model.QuadraticRNN(\n",
     "    p=p_flat,\n",
@@ -181,22 +223,49 @@
     "print(f\"Model: QuadraticRNN(p={p_flat}, d={hidden_dim}, k={k})\")\n",
     "print(f\"Optimizer: HybridRNNOptimizer(lr={lr})\")\n",
     "print(f\"Training for {epochs} epochs\")"
-   ],
-   "id": "7261d8b6"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "bc712f80",
    "metadata": {},
    "source": [
     "## Training"
-   ],
-   "id": "bc712f80"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
+   "id": "5ec15ca0",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Epoch   500/10000] loss: 0.999998 | reduction:    0.0%\n",
+      "[Epoch  1000/10000] loss: 0.545301 | reduction:   45.5%\n",
+      "[Epoch  1500/10000] loss: 0.447867 | reduction:   55.2%\n",
+      "[Epoch  2000/10000] loss: 0.224957 | reduction:   77.5%\n",
+      "[Epoch  2500/10000] loss: 0.224072 | reduction:   77.6%\n",
+      "[Epoch  3000/10000] loss: 0.223029 | reduction:   77.7%\n",
+      "[Epoch  3500/10000] loss: 0.139860 | reduction:   86.0%\n",
+      "[Epoch  4000/10000] loss: 0.045278 | reduction:   95.5%\n",
+      "[Epoch  4500/10000] loss: 0.044631 | reduction:   95.5%\n",
+      "[Epoch  5000/10000] loss: 0.044368 | reduction:   95.6%\n",
+      "[Epoch  5500/10000] loss: 0.044295 | reduction:   95.6%\n",
+      "[Epoch  6000/10000] loss: 0.044125 | reduction:   95.6%\n",
+      "[Epoch  6500/10000] loss: 0.044009 | reduction:   95.6%\n",
+      "[Epoch  7000/10000] loss: 0.043914 | reduction:   95.6%\n",
+      "[Epoch  7500/10000] loss: 0.043868 | reduction:   95.6%\n",
+      "[Epoch  8000/10000] loss: 0.043768 | reduction:   95.6%\n",
+      "[Epoch  8500/10000] loss: 0.043734 | reduction:   95.6%\n",
+      "[Epoch  9000/10000] loss: 0.043649 | reduction:   95.6%\n",
+      "[Epoch  9500/10000] loss: 0.043626 | reduction:   95.6%\n",
+      "[Epoch 10000/10000] loss: 0.043583 | reduction:   95.6%\n"
+     ]
+    }
+   ],
    "source": [
     "loss_history, val_loss_history, param_history, param_save_epochs, final_epoch = train_mod.train(\n",
     "    net,\n",
@@ -204,25 +273,36 @@
     "    criterion,\n",
     "    opt,\n",
     "    epochs=epochs,\n",
-    "    verbose_interval=1,\n",
-    "    save_param_interval=1,\n",
+    "    verbose_interval=500,\n",
+    "    save_param_interval=100,\n",
     ")"
-   ],
-   "id": "5ec15ca0"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "05f9375b",
    "metadata": {},
    "source": [
     "## Training Loss"
-   ],
-   "id": "05f9375b"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
+   "id": "87a7da40",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig, ax = plt.subplots(figsize=(8, 6))\n",
     "\n",
@@ -242,22 +322,33 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_loss.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "87a7da40"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "bd1f1264",
    "metadata": {},
    "source": [
     "## Predictions"
-   ],
-   "id": "bd1f1264"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
+   "id": "2acbc8ca",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x900 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Show predictions vs ground truth\n",
     "net.load_state_dict(param_history[-1])\n",
@@ -283,8 +374,7 @@
     "plt.tight_layout()\n",
     "plt.savefig(f\"{FIGURES_DIR}/sequential_cnxcn_predictions.pdf\", bbox_inches=\"tight\")\n",
     "plt.show()"
-   ],
-   "id": "2acbc8ca"
+   ]
   }
  ],
  "metadata": {
@@ -294,8 +384,16 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.12.0"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
   }
  },
  "nbformat": 4,