diff --git a/.gitignore b/.gitignore
index 4339a3c..e23e431 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,9 @@
 # Generated Data
 *.npz
 data/
+# Track coherences in results
+!results/stimulus_coherences/**
+!results/stimulus_coherences/
 
 # Model weights
 weights/
@@ -326,4 +329,7 @@ $RECYCLE.BIN/
 .nfs*
 
 # python-history when using pyenv
-.python-history
\ No newline at end of file
+.python-history
+
+# Ignore LLM files
+.claude/
\ No newline at end of file
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h100_mante.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h100_mante.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h100_mante.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h100_mante.png
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h100_mante_medium.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h100_mante_medium.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h100_mante_medium.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h100_mante_medium.png
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h20.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h20.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20.png
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h20_mante.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20_mante.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h20_mante.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20_mante.png
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h20_new.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20_new.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h20_new.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h20_new.png
diff --git a/results/pid_outputs/pid_task_rnn_comparison_h80.png b/elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h80.png
similarity index 100%
rename from results/pid_outputs/pid_task_rnn_comparison_h80.png
rename to elman_vs_ctrnn_comparison/figures/pid_task_rnn_comparison_h80.png
diff --git a/results/model_weights/CTRNN_ContextDecisionMaking-v0_h20.pt b/elman_vs_ctrnn_comparison/model_weights/CTRNN_ContextDecisionMaking-v0_h20.pt
similarity index 100%
rename from results/model_weights/CTRNN_ContextDecisionMaking-v0_h20.pt
rename to elman_vs_ctrnn_comparison/model_weights/CTRNN_ContextDecisionMaking-v0_h20.pt
diff --git a/results/model_weights/CTRNN_ContextDecisionMaking-v0_h80.pt b/elman_vs_ctrnn_comparison/model_weights/CTRNN_ContextDecisionMaking-v0_h80.pt
similarity index 100%
rename from results/model_weights/CTRNN_ContextDecisionMaking-v0_h80.pt
rename to elman_vs_ctrnn_comparison/model_weights/CTRNN_ContextDecisionMaking-v0_h80.pt
diff --git a/results/model_weights/CTRNN_PerceptualDecisionMaking-v0_h20.pt b/elman_vs_ctrnn_comparison/model_weights/CTRNN_PerceptualDecisionMaking-v0_h20.pt
similarity index 100%
rename from results/model_weights/CTRNN_PerceptualDecisionMaking-v0_h20.pt
rename to elman_vs_ctrnn_comparison/model_weights/CTRNN_PerceptualDecisionMaking-v0_h20.pt
diff --git a/results/model_weights/CTRNN_PerceptualDecisionMaking-v0_h80.pt b/elman_vs_ctrnn_comparison/model_weights/CTRNN_PerceptualDecisionMaking-v0_h80.pt
similarity index 100%
rename from results/model_weights/CTRNN_PerceptualDecisionMaking-v0_h80.pt
rename to elman_vs_ctrnn_comparison/model_weights/CTRNN_PerceptualDecisionMaking-v0_h80.pt
diff --git a/results/model_weights/Elman_ContextDecisionMaking-v0_h20.pt b/elman_vs_ctrnn_comparison/model_weights/Elman_ContextDecisionMaking-v0_h20.pt
similarity index 100%
rename from results/model_weights/Elman_ContextDecisionMaking-v0_h20.pt
rename to elman_vs_ctrnn_comparison/model_weights/Elman_ContextDecisionMaking-v0_h20.pt
diff --git a/results/model_weights/Elman_ContextDecisionMaking-v0_h80.pt b/elman_vs_ctrnn_comparison/model_weights/Elman_ContextDecisionMaking-v0_h80.pt
similarity index 100%
rename from results/model_weights/Elman_ContextDecisionMaking-v0_h80.pt
rename to elman_vs_ctrnn_comparison/model_weights/Elman_ContextDecisionMaking-v0_h80.pt
diff --git a/results/model_weights/Elman_PerceptualDecisionMaking-v0_h20.pt b/elman_vs_ctrnn_comparison/model_weights/Elman_PerceptualDecisionMaking-v0_h20.pt
similarity index 100%
rename from results/model_weights/Elman_PerceptualDecisionMaking-v0_h20.pt
rename to elman_vs_ctrnn_comparison/model_weights/Elman_PerceptualDecisionMaking-v0_h20.pt
diff --git a/results/model_weights/Elman_PerceptualDecisionMaking-v0_h80.pt b/elman_vs_ctrnn_comparison/model_weights/Elman_PerceptualDecisionMaking-v0_h80.pt
similarity index 100%
rename from results/model_weights/Elman_PerceptualDecisionMaking-v0_h80.pt
rename to elman_vs_ctrnn_comparison/model_weights/Elman_PerceptualDecisionMaking-v0_h80.pt
diff --git a/figures/accuracy_loss/test_accuracy_loss_bars.png b/figures/accuracy_loss/test_accuracy_loss_bars.png
new file mode 100644
index 0000000..155dbb5
Binary files /dev/null and b/figures/accuracy_loss/test_accuracy_loss_bars.png differ
diff --git a/figures/all_time_pid/CTRNN_01.png b/figures/all_time_pid/CTRNN_01.png
new file mode 100644
index 0000000..9758f9a
Binary files /dev/null and b/figures/all_time_pid/CTRNN_01.png differ
diff --git a/figures/all_time_pid/CTRNN_02.png b/figures/all_time_pid/CTRNN_02.png
new file mode 100644
index 0000000..728f056
Binary files /dev/null and b/figures/all_time_pid/CTRNN_02.png differ
diff --git a/figures/all_time_pid/CTRNN_03.png b/figures/all_time_pid/CTRNN_03.png
new file mode 100644
index 0000000..93df903
Binary files /dev/null and b/figures/all_time_pid/CTRNN_03.png differ
diff --git a/figures/all_time_pid/CTRNN_04.png b/figures/all_time_pid/CTRNN_04.png
new file mode 100644
index 0000000..3f23242
Binary files /dev/null and b/figures/all_time_pid/CTRNN_04.png differ
diff --git a/figures/all_time_pid/CTRNN_05.png b/figures/all_time_pid/CTRNN_05.png
new file mode 100644
index 0000000..6e4d2e3
Binary files /dev/null and b/figures/all_time_pid/CTRNN_05.png differ
diff --git a/figures/all_time_pid/CTRNN_06.png b/figures/all_time_pid/CTRNN_06.png
new file mode 100644
index 0000000..a732f56
Binary files /dev/null and b/figures/all_time_pid/CTRNN_06.png differ
diff --git a/figures/all_time_pid/CTRNN_07.png b/figures/all_time_pid/CTRNN_07.png
new file mode 100644
index 0000000..d4a94be
Binary files /dev/null and b/figures/all_time_pid/CTRNN_07.png differ
diff --git a/figures/all_time_pid/CTRNN_08.png b/figures/all_time_pid/CTRNN_08.png
new file mode 100644
index 0000000..64d2e00
Binary files /dev/null and b/figures/all_time_pid/CTRNN_08.png differ
diff --git a/figures/all_time_pid/CTRNN_09.png b/figures/all_time_pid/CTRNN_09.png
new file mode 100644
index 0000000..b59d239
Binary files /dev/null and b/figures/all_time_pid/CTRNN_09.png differ
diff --git a/figures/all_time_pid/CTRNN_10.png b/figures/all_time_pid/CTRNN_10.png
new file mode 100644
index 0000000..8e2f427
Binary files /dev/null and b/figures/all_time_pid/CTRNN_10.png differ
diff --git a/figures/learning_curves/.gitkeep b/figures/learning_curves/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/figures/learning_curves/context/.gitkeep b/figures/learning_curves/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/figures/learning_curves/perceptual/.gitkeep b/figures/learning_curves/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/notebooks/04_minimal_product.ipynb b/notebooks/04_minimal_product.ipynb
index 65d14e3..5ac1aa0 100644
--- a/notebooks/04_minimal_product.ipynb
+++ b/notebooks/04_minimal_product.ipynb
@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "275176ad",
    "metadata": {},
    "outputs": [
@@ -50,7 +50,7 @@
    ],
    "source": [
     "# Configuration\n",
-    "BASE_PATH = \"../src/tasks/data/mante_style\"\n",
+    "BASE_PATH = \"../data\"\n",
     "BATCH_SIZE = 1024 * 2\n",
     "SUBSAMPLE_STEP = 10 # Subsample for Elman RNN (simulate tau=10ms)\n",
     "\n",
@@ -258,7 +258,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "2cdf07a6",
    "metadata": {},
    "outputs": [
@@ -282,7 +282,7 @@
     "if device.type == \"cuda\":\n",
     "    print(f\"   GPU Name: {torch.cuda.get_device_name(0)}\")\n",
     "\n",
-    "WEIGHTS_DIR = \"../src/models/weights/mante_medium\"\n",
+    "WEIGHTS_DIR = \"../elman_vs_ctrnn_comparison/model_weights\" \n",
     "os.makedirs(WEIGHTS_DIR, exist_ok=True)"
    ]
   },
diff --git a/notebooks/05_Full_train_pipeline.ipynb b/notebooks/05_Full_train_pipeline.ipynb
index ac92110..da86f0b 100644
--- a/notebooks/05_Full_train_pipeline.ipynb
+++ b/notebooks/05_Full_train_pipeline.ipynb
@@ -76,13 +76,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "275176ad",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Configuration (paths are relative to the notebooks/ directory, i.e. repo root via \"..\")\n",
-    "BASE_PATH = \"../src/tasks/data/mante_style\"\n",
+    "BASE_PATH = \"../data\"\n",
     "BATCH_SIZE = 1024 * 8\n",
     "SUBSAMPLE_STEP = 1   # raw trials are dt=10ms; step=1 gives an effective 10ms timestep (750ms -> 75 steps)\n",
     "# Each seeded CTRNN gets its own held-out test set (train/val are shared across seeds of a task).\n",
@@ -1310,7 +1310,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "neuroai-project13",
+   "display_name": "neuroai",
    "language": "python",
    "name": "python3"
   },
diff --git a/notebooks/06_Full_PID_analysis_pipeline.ipynb b/notebooks/06_Full_PID_analysis_pipeline.ipynb
index a6af71c..f20f914 100644
--- a/notebooks/06_Full_PID_analysis_pipeline.ipynb
+++ b/notebooks/06_Full_PID_analysis_pipeline.ipynb
@@ -2,333 +2,425 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "a22658ed",
+   "id": "53af12a9",
    "metadata": {},
    "source": [
-    "# Task Integration Demand & Information Geometry\n",
-    "**Hypothesis:** Tasks requiring the integration of multiple streams (Context) will force the network to encode information synergistically. Simple accumulation tasks (Perceptual) will be solved redundantly. This effect should peak exactly at the end of the stimulus period.\n",
+    "# Full PID Analysis Pipeline\n",
     "\n",
-    "We test this by training both an Elman RNN and a CTRNN to compare how temporal architectures affect the `gaussian_pid` structure."
+    "Load the **already-trained** ensemble (20 CTRNNs = 10 seeds x 2 tasks) and its saved\n",
+    "outputs, then compute the partial-information-decomposition (PID) analyses and figures\n",
+    "for the final presentation.\n",
+    "\n",
+    "**Hypothesis.** The *context* task (integrate the cued stream, ignore the other) forces\n",
+    "the network to encode stimulus information **synergistically**, whereas the *perceptual*\n",
+    "task (accumulate a single stream) can be solved **redundantly**. This difference\n",
+    "should peak at the end of the stimulus period.\n",
+    "\n",
+    "We *reuse* the analytic Gaussian MMI-PID in `src/analysis/gaussian_pid.py` (no\n",
+    "reimplementation): a GPU-batched wrapper below is validated to reproduce its numbers\n",
+    "to ~1e-10 bits while running ~40x faster."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56c8d95c",
+   "metadata": {},
+   "source": [
+    "## Imports\n",
+    "PyTorch (GPU-batched PID), NumPy, Matplotlib and SciPy (statistics). The existing\n",
+    "analytic PID lives in `src/analysis/gaussian_pid.py` and is imported only as the\n",
+    "reference implementation the GPU path is checked against."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "7205bf02",
-   "metadata": {},
+   "id": "8d803ea5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:01.522182Z",
+     "iopub.status.busy": "2026-07-04T18:27:01.522182Z",
+     "iopub.status.idle": "2026-07-04T18:27:05.993626Z",
+     "shell.execute_reply": "2026-07-04T18:27:05.993626Z"
+    }
+   },
    "outputs": [],
    "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import copy\n",
-    "import os\n",
+    "import os, json, time               # paths, metrics JSON, timing\n",
+    "import numpy as np                  # arrays / IO\n",
+    "import torch                        # GPU-batched PID (costliest step)\n",
+    "import matplotlib.pyplot as plt     # all figures\n",
+    "from scipy import stats             # Mann-Whitney U control test\n",
     "\n",
-    "#import sys\n",
-    "#sys.path.append('../src/tasks') # Ensure Python can find data_loader.py\n",
-    "from src.tasks.data_loader import load_mante_data\n",
-    "from src.models.ctrnn import CTRNN\n",
-    "from src.models.RNN import ElmanRNN"
+    "# Reference (CPU) implementation (used ONLY to validate the GPU path numerically).\n",
+    "from src.analysis.gaussian_pid import gaussian_pid_rnn\n",
+    "# GPU Gaussian PID implementation (used for all final figures).\n",
+    "from src.analysis.gaussian_pid import gaussian_pid_rnn_gpu\n",
+    "\n",
+    "# Configuration for Mante et al. (2013) dataset generation (TIMING and DT)\n",
+    "from src.tasks.mante_config import TIMING, DT\n",
+    "# Trial timing in ms: TIMING = {\"fixation\": 300, \"stimulus\": 750, \"delay\": 0, \"decision\": 100}\n",
+    "# DT = ms per raw simulation step"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb0e3627",
+   "metadata": {},
+   "source": [
+    "## Plotting conventions\n",
+    "Constants applied to **every** figure and computation: the two task colors, the fixed\n",
+    "5-atom PID set and its order, per-atom line colors, the single analysis seed, the task /\n",
+    "seed identifiers, the nats->bits factor, and the Matplotlib house style (no top/right\n",
+    "spines; fixed font sizes)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "275176ad",
+   "execution_count": 2,
+   "id": "67cab189",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:05.997639Z",
+     "iopub.status.busy": "2026-07-04T18:27:05.997639Z",
+     "iopub.status.idle": "2026-07-04T18:27:06.003968Z",
+     "shell.execute_reply": "2026-07-04T18:27:06.003968Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ---- Task colors (defined ONCE, reused everywhere) ----\n",
+    "COLOR_CONTEXT    = 'mediumturquoise'   # context task    (the \"blue\")\n",
+    "COLOR_PERCEPTUAL = 'tomato'            # perceptual task  (the \"red\")\n",
+    "\n",
+    "# ---- PID atoms: ALWAYS all five, fixed order. total_mi = red + u1 + u2 + syn ----\n",
+    "ATOMS = ['total_mi', 'redundancy', 'unique1', 'unique2', 'synergy']\n",
+    "\n",
+    "# Distinct colors so the five atoms are separable within one panel (legend labels them).\n",
+    "ATOM_COLORS = {\n",
+    "    'total_mi':   '#020202',   # black  (dotted) — the Gaussian MMI total I(X1,X2;Y)\n",
+    "    'redundancy': '#4C78A8',   # blue\n",
+    "    'unique1':    '#F58518',   # orange\n",
+    "    'unique2':    '#54A24B',   # green\n",
+    "    'synergy':    '#E45756',   # red\n",
+    "}\n",
+    "\n",
+    "# ---- Reproducibility: one seed for bipartitions / random-neuron / kNN estimator ----\n",
+    "SEED_ANALYSIS = 0\n",
+    "\n",
+    "# ---- Tasks & 1-based zero-padded seed ids CTRNN_01 to CTRNN_10 ----\n",
+    "TASKS    = ['perceptual', 'context']\n",
+    "N_SEEDS  = 10\n",
+    "SEED_IDS = [f\"{i:02d}\" for i in range(1, N_SEEDS + 1)]\n",
+    "\n",
+    "# ---- Units: BITS everywhere. gaussian_pid returns bits when log_base=2; this factor\n",
+    "#      converts any nats quantity we might compute later (e.g. kNN MI). ----\n",
+    "NATS_TO_BITS = 1.0 / np.log(2.0)\n",
+    "\n",
+    "# ---- Significance markers for ALL statistical tests (applied to every figure) ----\n",
+    "#   *  p < 0.05    **  p < 0.01    ***  p < 0.001    ****  p < 0.0001\n",
+    "#   n.s. (not significant) when p >= 0.05\n",
+    "def p_to_stars(p):\n",
+    "    \"\"\"Map a p-value to its significance marker; 'n.s.' if p >= 0.05.\"\"\"\n",
+    "    if   p < 1e-4: return '****'\n",
+    "    elif p < 1e-3: return '***'\n",
+    "    elif p < 1e-2: return '**'\n",
+    "    elif p < 5e-2: return '*'\n",
+    "    return 'n.s.'\n",
+    "\n",
+    "# ---- Matplotlib house style (all figures) ----\n",
+    "plt.rcParams.update({\n",
+    "    'axes.spines.top':   False,   # remove top spine\n",
+    "    'axes.spines.right': False,   # remove right spine\n",
+    "    'xtick.labelsize': 12,        # axes tick/values = 12\n",
+    "    'ytick.labelsize': 12,\n",
+    "    'axes.labelsize':  16,        # axes labels = 16\n",
+    "    'legend.fontsize': 14,        # legend = 14\n",
+    "    'axes.titlesize':  16,        # subplot title = 16 (used only where a figure asks)\n",
+    "    'figure.titlesize':18,        # plot title = 18\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8729fdd8",
    "metadata": {},
+   "source": [
+    "## Input / output paths & device\n",
+    "Where the saved metrics, activations and PID-target coherences live, and where figures\n",
+    "and PID caches are written. Also select CUDA if available (the PID is the costliest\n",
+    "step and runs on the GPU)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e2e468bc",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:06.007976Z",
+     "iopub.status.busy": "2026-07-04T18:27:06.007976Z",
+     "iopub.status.idle": "2026-07-04T18:27:06.981932Z",
+     "shell.execute_reply": "2026-07-04T18:27:06.981383Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Loading Context Datasets...\n",
-      "All datasets loaded successfully!\n"
+      "Compute device: cuda - NVIDIA GeForce GTX 1050\n"
      ]
     }
    ],
    "source": [
-    "# Configuration\n",
-    "BASE_PATH = \"../data/mante_style\"\n",
-    "BATCH_SIZE = 1024 * 2\n",
-    "SUBSAMPLE_STEP = 10 # Subsample for Elman RNN (simulate tau=10ms)\n",
+    "# --- input directories (paths relative to notebooks/) ---\n",
+    "RES_METRICS_DIR = \"../results/accuracies_n_losses\"   # scalar loss/acc per CTRNN (JSON)\n",
+    "RES_ACTS_DIR    = \"../results/model_activations\"     # hidden acts [n_trials, T, n_hidden]\n",
+    "RES_COH_DIR     = \"../results/stimulus_coherences\"   # PID target: signed cued/attended coherence\n",
     "\n",
-    "# print(\"Loading Perceptual Datasets...\")\n",
-    "# per_train_loader = load_mante_data(f'{BASE_PATH}/perceptual/train.npz', batch_size=BATCH_SIZE, shuffle=True, subsample_step=SUBSAMPLE_STEP)\n",
-    "# per_val_loader = load_mante_data(f'{BASE_PATH}/perceptual/val.npz', batch_size=BATCH_SIZE, shuffle=False, subsample_step=SUBSAMPLE_STEP)\n",
+    "# --- output directories ---\n",
+    "PID_OUT_DIR = \"../results/pid_outputs\"               # cached PID arrays (+ sidecar meta)\n",
+    "FIG_ACC_DIR = \"../figures/accuracy_loss\"             # Figure 1\n",
+    "FIG_PID_DIR = \"../figures/all_time_pid\"              # Figure 2 (one PNG per seed)\n",
+    "for d in [FIG_ACC_DIR, FIG_PID_DIR,\n",
+    "          os.path.join(PID_OUT_DIR, 'context'),\n",
+    "          os.path.join(PID_OUT_DIR, 'perceptual')]:\n",
+    "    os.makedirs(d, exist_ok=True)\n",
     "\n",
-    "print(\"Loading Context Datasets...\")\n",
-    "ctx_train_loader = load_mante_data(f'{BASE_PATH}/context/train.npz', batch_size=BATCH_SIZE, shuffle=True, subsample_step=SUBSAMPLE_STEP)\n",
-    "ctx_val_loader = load_mante_data(f'{BASE_PATH}/context/val.npz', batch_size=BATCH_SIZE, shuffle=False, subsample_step=SUBSAMPLE_STEP)\n",
-    "\n",
-    "print(\"All datasets loaded successfully!\")"
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(\"Compute device:\", device,\n",
+    "      \"-\", torch.cuda.get_device_name(0) if device.type == \"cuda\" else \"CPU\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f01e82ac",
+   "id": "58edbc47",
    "metadata": {},
    "source": [
-    "### 4. Time-Resolved PID Analysis\n",
-    "We generate a large testing ensemble (200 trials), run them through the trained networks without updating weights, and calculate the Gaussian PID at *every single timestep*. We use the final trial choice as the target variable for the PID."
+    "## Trial timing & shared decision time\n",
+    "Mirror `src/tasks/mante_config.py`. The saved activations use `SUBSAMPLE_STEP=1`\n",
+    "(notebook 05), so one saved timestep equals `DT = 10 ms`. `DECISION_T` is derived (not\n",
+    "hardcoded) as the **last timestep of the stimulus period** (end of fixation+stimulus);\n",
+    "the same `DECISION_T` is reused by every later decision-time slice."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "1dff232f",
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 4,
+   "id": "dbb8c78f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:06.986767Z",
+     "iopub.status.busy": "2026-07-04T18:27:06.985957Z",
+     "iopub.status.idle": "2026-07-04T18:27:06.994282Z",
+     "shell.execute_reply": "2026-07-04T18:27:06.993262Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T = 115 steps @ 10 ms/step | stimulus steps 30..104 | DECISION_T = 104 (1040 ms)\n"
+     ]
+    }
+   ],
    "source": [
-    "def extract_hidden_trajectories(model, dataloader):\n",
-    "    \"\"\"\n",
-    "    Runs the dataset through the model and extracts the hidden state, target, and context \n",
-    "    at every timestep for every trial.\n",
-    "    \"\"\"\n",
-    "    model.eval()\n",
-    "    all_hidden = []\n",
-    "    all_targets = []\n",
-    "    all_periods = []\n",
-    "    all_ctxs = []\n",
-    "    \n",
-    "    with torch.no_grad():\n",
-    "        for obs, labels, periods, cohs, ctxs in dataloader:\n",
-    "            # We bypass the final linear layer and get the raw hidden states\n",
-    "            # Standard nn.RNN returns (output, h_n). 'output' contains all timesteps.\n",
-    "            _, hidden_states = model(obs) \n",
-    "            \n",
-    "            all_hidden.append(hidden_states.numpy())\n",
+    "# Trial timing in ms (identical to src/tasks/mante_config.py)\n",
+    "SUBSAMPLE_STEP = 1                             # notebook 05 saved acts unsubsampled\n",
+    "MS_PER_STEP = DT * SUBSAMPLE_STEP              # -> 10 ms per saved timestep\n",
+    "TOTAL_TIMESTEPS = sum(TIMING.values()) // DT   # 1150/10 = 115  (matches acts' T axis)\n",
     "\n",
-    "            # Using mean coherence as our target!\n",
-    "            if cohs.ndim > 1:\n",
-    "                all_targets.append(cohs[:, 0].numpy().astype(float))\n",
-    "            else:\n",
-    "                all_targets.append(cohs.numpy().astype(float))\n",
-    "            # Using continuous noisy coherence as our target\n",
-    "            #noisy_evidence = obs[:, :, 1] - obs[:, :, 2]\n",
-    "            #all_targets.append(noisy_evidence.numpy().astype(float)) \n",
-    "            \n",
-    "            # Using labels as our target!\n",
-    "            #all_targets.append(labels[:, -1].numpy().astype(float)) \n",
-    "            \n",
+    "# Stimulus period occupies steps [fixation, fixation+stimulus); STIM_START is its first\n",
+    "# step, DECISION_T its last step (the moment of decision we slice at everywhere).\n",
+    "STIM_START_STEP = TIMING[\"fixation\"] // DT                            # 30\n",
+    "DECISION_T      = (TIMING[\"fixation\"] + TIMING[\"stimulus\"]) // DT - 1  # 104\n",
     "\n",
-    "            all_periods.append(periods.numpy())\n",
+    "def steps_to_ms(t):\n",
+    "    \"\"\"Map a saved timestep index (or array of them) to time in ms.\"\"\"\n",
+    "    return np.asarray(t) * MS_PER_STEP\n",
     "\n",
-    "            all_ctxs.append(ctxs.numpy())\n",
-    "            \n",
-    "    # Concatenate across batches\n",
-    "    H = np.concatenate(all_hidden, axis=0)      # Shape: (Trials, Timesteps, Hidden_Size)\n",
-    "    Y = np.concatenate(all_targets, axis=0)     # Shape: (Trials,)\n",
-    "    P = np.concatenate(all_periods, axis=0)     # Shape: (Trials, Timesteps)\n",
-    "    C = np.concatenate(all_ctxs, axis=0)        # Shape: (Trials,)\n",
-    "    \n",
-    "    return H, Y, P, C"
+    "print(f\"T = {TOTAL_TIMESTEPS} steps @ {MS_PER_STEP} ms/step | \"\n",
+    "      f\"stimulus steps {STIM_START_STEP}..{DECISION_T} | \"\n",
+    "      f\"DECISION_T = {DECISION_T} ({DECISION_T*MS_PER_STEP} ms)\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "bf255d84",
+   "cell_type": "markdown",
+   "id": "1ef63aae",
    "metadata": {},
+   "source": [
+    "## Data loading\n",
+    "Thin loaders for the three saved artifacts, keyed by task and 1-based padded seed id.\n",
+    "The PID **target** is the signed, noiseless scalar coherence already reduced to the\n",
+    "relevant stream on disk: the cued modality for *context*, the single attended stream for\n",
+    "*perceptual*. It is continuous (values in [-18.75, +18.75])."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bd9fe41c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:06.998271Z",
+     "iopub.status.busy": "2026-07-04T18:27:06.997306Z",
+     "iopub.status.idle": "2026-07-04T18:27:07.141596Z",
+     "shell.execute_reply": "2026-07-04T18:27:07.140587Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Extracting hidden state trajectories for the Test Sets...\n",
-      "Perceptual Trajectories Shape: (2000, 75, 100)\n",
-      "Context Trajectories Shape:    (2000, 75, 100)\n"
+      "perceptual   acts (2000, 115, 100)  target (2000,)  target range [-18.75, 18.75]\n",
+      "context      acts (2000, 115, 100)  target (2000,)  target range [-18.75, 18.75]\n"
      ]
     }
    ],
    "source": [
-    "print(\"Extracting hidden state trajectories for the Test Sets...\")\n",
-    "\n",
-    "# Load the dedicated Test Sets (never seen during training or validation!)\n",
-    "#TEST_SET = \"test_mante\"\n",
-    "TEST_SET = \"test_uniform\"\n",
-    "per_test_loader = load_mante_data(f'{BASE_PATH}/perceptual/{TEST_SET}.npz', batch_size=BATCH_SIZE, shuffle=False, subsample_step=SUBSAMPLE_STEP)\n",
-    "ctx_test_loader = load_mante_data(f'{BASE_PATH}/context/{TEST_SET}.npz', batch_size=BATCH_SIZE, shuffle=False, subsample_step=SUBSAMPLE_STEP)\n",
+    "def load_metrics(task, seed_id):\n",
+    "    \"\"\"Scalar train/val/test loss & accuracy for one CTRNN (dict).\"\"\"\n",
+    "    with open(f\"{RES_METRICS_DIR}/{task}/CTRNN_{seed_id}.json\") as f:\n",
+    "        return json.load(f)\n",
     "\n",
-    "# Load models from savepoints (optional)\n",
-    "perceptual_model_elman = WrappedElman(input_size, hidden_size, output_size)\n",
-    "perceptual_model_elman.load_state_dict(torch.load(f\"{WEIGHTS_DIR}/elman_perceptual_best_h{hidden_size}.pth\", weights_only=True))\n",
-    "context_model_elman = WrappedElman(input_size, hidden_size, output_size)\n",
-    "context_model_elman.load_state_dict(torch.load(f\"{WEIGHTS_DIR}/elman_context_best_h{hidden_size}.pth\", weights_only=True))\n",
+    "def load_activations(task, seed_id):\n",
+    "    \"\"\"Hidden activations for one CTRNN's test set: [n_trials, T, n_hidden].\"\"\"\n",
+    "    return np.load(f\"{RES_ACTS_DIR}/{task}/CTRNN_{seed_id}.npy\")\n",
     "\n",
-    "perceptual_model_ctrnn = WrappedCTRNN(input_size, hidden_size, output_size)\n",
-    "perceptual_model_ctrnn.load_state_dict(torch.load(f\"{WEIGHTS_DIR}/ctrnn_perceptual_best_h{hidden_size}.pth\", weights_only=True))\n",
-    "context_model_ctrnn = WrappedCTRNN(input_size, hidden_size, output_size)\n",
-    "context_model_ctrnn.load_state_dict(torch.load(f\"{WEIGHTS_DIR}/ctrnn_context_best_h{hidden_size}.pth\", weights_only=True))\n",
+    "def load_coherences(task, seed_id):\n",
+    "    \"\"\"PID target = signed coherence (cued/attended), shape (n_trials,).\"\"\"\n",
+    "    z = np.load(f\"{RES_COH_DIR}/{task}/test_{seed_id}_coherences.npz\")\n",
+    "    return z['arr_0'].astype(float)     # single stored array; already the right stream\n",
     "\n",
-    "# Extract Trajectories\n",
-    "H_per_elman, Y_per_elman, P_per_elman, C_per_elman = extract_hidden_trajectories(perceptual_model_elman, per_test_loader)\n",
-    "H_ctx_elman, Y_ctx_elman, P_ctx_elman, C_ctx_elman = extract_hidden_trajectories(context_model_elman, ctx_test_loader)\n",
-    "\n",
-    "H_per_ctrnn, Y_per_ctrnn, P_per_ctrnn, C_per_ctrnn = extract_hidden_trajectories(perceptual_model_ctrnn, per_test_loader)\n",
-    "H_ctx_ctrnn, Y_ctx_ctrnn, P_ctx_ctrnn, C_ctx_ctrnn = extract_hidden_trajectories(context_model_ctrnn, ctx_test_loader)\n",
-    "\n",
-    "print(f\"Perceptual Trajectories Shape: {H_per_elman.shape}\")\n",
-    "print(f\"Context Trajectories Shape:    {H_ctx_elman.shape}\")"
+    "# quick shape sanity check on one file per task\n",
+    "for t in TASKS:\n",
+    "    H, Y = load_activations(t, '01'), load_coherences(t, '01')\n",
+    "    print(f\"{t:11s}  acts {H.shape}  target {Y.shape}  \"\n",
+    "          f\"target range [{Y.min():.2f}, {Y.max():.2f}]\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "d091e6f5",
+   "cell_type": "markdown",
+   "id": "88bdc703",
    "metadata": {},
+   "source": [
+    "## Figure 1: Test accuracy & loss bars\n",
+    "Two stacked bar subplots sharing x = seed (1-10): test **accuracy** (top) and test\n",
+    "**loss** (bottom), context vs perceptual grouped side-by-side per seed. Then a\n",
+    "Mann-Whitney U test on `test_acc` (context vs perceptual): we **expect non-significance**. This is the control showing later PID differences are not a mere accuracy artifact."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "854ab6e2",
+   "metadata": {},
+   "source": [
+    "Gather scalar metrics: Read every CTRNN's `test_acc` / `test_loss` into per-task arrays indexed by seed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "d278c6d1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:07.147597Z",
+     "iopub.status.busy": "2026-07-04T18:27:07.146596Z",
+     "iopub.status.idle": "2026-07-04T18:27:07.174075Z",
+     "shell.execute_reply": "2026-07-04T18:27:07.174075Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Y_ctx_ctrnn[:100]=array([  5.35714293, -15.68877506,   7.65306139,   8.41836739,\n",
-      "         8.80102062,  -3.44387746, -15.30612278, -13.77550983,\n",
-      "        13.77550983, -10.33163261,  -0.76530612, -11.47959137,\n",
-      "        -5.35714293, -14.54081631,  -3.44387746,  -4.97448969,\n",
-      "        -3.06122446, -11.09693909, -13.39285755,  16.83673477,\n",
-      "        10.71428585, -11.09693909,   0.        ,   6.88775492,\n",
-      "        -9.18367386,   8.80102062,   3.44387746,  -6.88775492,\n",
-      "        17.98469353,   5.73979568,   4.20918369,   2.29591846,\n",
-      "         9.56632614,  -0.76530612,   0.38265306, -16.83673477,\n",
-      "        -1.91326535,   3.82653069,  14.92346954,   1.91326535,\n",
-      "       -11.86224461, -15.30612278,  11.47959137,  13.01020432,\n",
-      "        -6.12244892, -13.77550983,   8.80102062,   6.88775492,\n",
-      "       -13.01020432,   3.82653069,   6.50510216,  14.15816307,\n",
-      "       -17.21938705,  15.68877506,  -1.14795923,  -1.91326535,\n",
-      "        12.24489784,   0.76530612, -12.24489784,   6.50510216,\n",
-      "         5.35714293,  17.60204124,  -6.50510216, -11.09693909,\n",
-      "       -15.68877506, -16.0714283 ,  -3.82653069,  17.98469353,\n",
-      "         4.20918369,   7.65306139,   0.76530612, -11.86224461,\n",
-      "       -12.62755108,   9.56632614,  18.36734772,  -7.65306139,\n",
-      "        11.86224461, -11.09693909,   2.29591846,   9.94897938,\n",
-      "        -2.29591846,  -4.20918369, -15.68877506,  17.60204124,\n",
-      "       -12.24489784, -14.54081631,  15.30612278,  11.47959137,\n",
-      "       -11.47959137, -18.75      ,   4.20918369,  -5.35714293,\n",
-      "         8.80102062, -16.83673477,  -0.38265306,   4.59183693,\n",
-      "        18.36734772,  -4.97448969,   8.41836739,  11.09693909])\n"
+      "perceptual   acc 0.887+/-0.005   loss 0.256+/-0.008\n",
+      "context      acc 0.885+/-0.005   loss 0.261+/-0.009\n"
      ]
     }
    ],
    "source": [
-    "if len(Y_ctx_ctrnn.shape) > 1:\n",
-    "    print(f\"{Y_ctx_ctrnn[:10, 24:-9]=}\")\n",
-    "else:\n",
-    "    print(f\"{Y_ctx_ctrnn[:100]=}\")"
+    "# per-task arrays over the 10 seeds\n",
+    "test_acc  = {t: np.array([load_metrics(t, s)['test_acc']  for s in SEED_IDS]) for t in TASKS}\n",
+    "test_loss = {t: np.array([load_metrics(t, s)['test_loss'] for s in SEED_IDS]) for t in TASKS}\n",
+    "for t in TASKS:\n",
+    "    print(f\"{t:11s}  acc {test_acc[t].mean():.3f}+/-{test_acc[t].std():.3f}   \"\n",
+    "          f\"loss {test_loss[t].mean():.3f}+/-{test_loss[t].std():.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a27476b2",
+   "metadata": {},
+   "source": [
+    "Accuracy-matched control (Mann-Whitney U): Non-parametric test of `test_acc` across the two task groups (n=10 each). A\n",
+    "**non-significant** result (p > 0.05) means the two ensembles are accuracy-matched, so\n",
+    "any PID difference cannot be explained by one task simply being solved better."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "cecb901e",
+   "execution_count": 16,
+   "id": "db9db1f9",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Analyzing Perceptual Elman Network...\n",
-      "Analyzing Context Elman Network...\n",
-      "Analyzing Perceptual CTRNN Network...\n",
-      "Analyzing Context CTRNN Network...\n",
-      "Succesfully calculated PID metrics\n"
+      "MWU on test_acc (context vs perceptual): U = 40.0, p = 0.4727\n",
+      "=> NON-significant at alpha=0.05: accuracy matched, PID differences are not a performance artifact.\n",
+      "MWU on test_loss (context vs perceptual): U = 71.0, p = 0.1212\n",
+      "=> NON-significant at alpha=0.05: losses matched.\n"
      ]
     }
    ],
    "source": [
-    "import numpy as np\n",
-    "from src.analysis.gaussian_pid import gaussian_pid_rnn\n",
-    "\n",
-    "mask_per_c1 = (C_per_elman == 1)\n",
-    "mask_ctx_c1 = (C_ctx_elman == 1)\n",
-    "\n",
-    "# masking\n",
-    "H_per_elman = H_per_elman[mask_per_c1]\n",
-    "Y_per_elman = Y_per_elman[mask_per_c1]\n",
+    "u_stat, p_acc = stats.mannwhitneyu(test_acc['context'], test_acc['perceptual'],\n",
+    "                                   alternative='two-sided')\n",
+    "print(f\"MWU on test_acc (context vs perceptual): U = {u_stat:.1f}, p = {p_acc:.4f}\")\n",
+    "print(\"=> NON-significant at alpha=0.05: accuracy matched, PID differences are not a \"\n",
+    "      \"performance artifact.\" if p_acc > 0.05 else\n",
+    "      \"=> SIGNIFICANT (unexpected): accuracies differ across tasks.\")\n",
     "\n",
-    "H_ctx_elman = H_ctx_elman[mask_ctx_c1]\n",
-    "Y_ctx_elman = Y_ctx_elman[mask_ctx_c1]\n",
-    "\n",
-    "H_per_ctrnn = H_per_ctrnn[mask_per_c1]\n",
-    "Y_per_ctrnn = Y_per_ctrnn[mask_per_c1]\n",
-    "\n",
-    "H_ctx_ctrnn = H_ctx_ctrnn[mask_ctx_c1]\n",
-    "Y_ctx_ctrnn = Y_ctx_ctrnn[mask_ctx_c1]\n",
-    "\n",
-    "# Run the analysis (Warning: This might take a few minutes!)\n",
-    "print(\"Analyzing Perceptual Elman Network...\")\n",
-    "pid_elman_perceptual = gaussian_pid_rnn(\n",
-    "    activations=H_per_elman,\n",
-    "    target=Y_per_elman, \n",
-    "    timestep=None,           \n",
-    "    bipartitions=\"random\",\n",
-    "    n_bipartitions=200,\n",
-    "    seed=42,\n",
-    "    log_base=2,\n",
-    "    regularization=1e-5\n",
-    ")\n",
-    "\n",
-    "print(\"Analyzing Context Elman Network...\")\n",
-    "pid_elman_context = gaussian_pid_rnn(\n",
-    "    activations=H_ctx_elman,\n",
-    "    target=Y_ctx_elman, \n",
-    "    timestep=None,           \n",
-    "    bipartitions=\"random\",\n",
-    "    n_bipartitions=200,\n",
-    "    seed=42,\n",
-    "    log_base=2,\n",
-    "    regularization=1e-5\n",
-    ")\n",
-    "\n",
-    "print(\"Analyzing Perceptual CTRNN Network...\")\n",
-    "pid_ctrnn_perceptual = gaussian_pid_rnn(\n",
-    "    activations=H_per_ctrnn,\n",
-    "    target=Y_per_ctrnn, \n",
-    "    timestep=None,           \n",
-    "    bipartitions=\"random\",\n",
-    "    n_bipartitions=200,\n",
-    "    seed=42,\n",
-    "    log_base=2,\n",
-    "    regularization=1e-5\n",
-    ")\n",
-    "\n",
-    "print(\"Analyzing Context CTRNN Network...\")\n",
-    "pid_ctrnn_context = gaussian_pid_rnn(\n",
-    "    activations=H_ctx_ctrnn,\n",
-    "    target=Y_ctx_ctrnn, \n",
-    "    timestep=None,           \n",
-    "    bipartitions=\"random\",\n",
-    "    n_bipartitions=200,\n",
-    "    seed=42,\n",
-    "    log_base=2,\n",
-    "    regularization=1e-5\n",
-    ")\n",
-    "\n",
-    "print(\"Succesfully calculated PID metrics\")"
+    "u_stat_loss, p_loss = stats.mannwhitneyu(test_loss['context'], test_loss['perceptual'],\n",
+    "                                         alternative='two-sided')\n",
+    "print(f\"MWU on test_loss (context vs perceptual): U = {u_stat_loss:.1f}, p = {p_loss:.4f}\")\n",
+    "print(\"=> NON-significant at alpha=0.05: losses matched.\" if p_loss > 0.05 else\n",
+    "      \"=> SIGNIFICANT (unexpected): losses differ across tasks.\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "4518f333",
+   "id": "9755a329",
    "metadata": {},
    "source": [
-    "### 5. Evaluating the Hypothesis (Visualization)\n",
-    "We plot the Synergy and Redundancy tracks. According to our hypothesis:\n",
-    "1. Synergy should peak around the dotted vertical line (end of stimulus).\n",
-    "2. The Context task (bottom row) should have significantly higher Synergy than the Perceptual task (top row)."
+    "Plot the bars: Grouped bars per seed, task colors, labeled legend, no titles. Saved to\n",
+    "`figures/accuracy_loss/test_accuracy_loss_bars.png` and shown inline."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "99055618",
-   "metadata": {},
+   "execution_count": 18,
+   "id": "5542820c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:07.178085Z",
+     "iopub.status.busy": "2026-07-04T18:27:07.178085Z",
+     "iopub.status.idle": "2026-07-04T18:27:07.865013Z",
+     "shell.execute_reply": "2026-07-04T18:27:07.865013Z"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1800x1200 with 4 Axes>"
+       "<Figure size 1000x700 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -336,54 +428,260 @@
     }
    ],
    "source": [
-    "# Dynamically find the End of Stimulus index (same across all models/tasks)\n",
-    "stim_end_idx = np.where(P_ctx_elman[0] == 1)[0][-1] \n",
-    "\n",
-    "# Define the grid\n",
-    "fig, axes = plt.subplots(2, 2, figsize=(18, 12), sharey=True, sharex=True)\n",
+    "seeds = np.arange(1, N_SEEDS + 1)     # x positions = seed number 1..10\n",
+    "w = 0.4                                # bar width (two grouped bars per seed)\n",
     "\n",
-    "# Add an overarching title to the entire figure specifying the hidden size\n",
-    "fig.suptitle(f\"Information Geometry: Architecture vs. Cognitive Demand (Hidden Size: {hidden_size})\", \n",
-    "             fontsize=20, fontweight='bold', y=0.96)\n",
+    "def annotate_sig(ax, x1, x2, p, data_top):\n",
+    "    \"\"\"Horizontal significance bracket x1..x2 above the bars, marker via p_to_stars(p).\"\"\"\n",
+    "    span = data_top - ax.get_ylim()[0]\n",
+    "    y, h = data_top + 0.06*span, 0.03*span\n",
+    "    ax.plot([x1, x1, x2, x2], [y, y+h, y+h, y], lw=1.2, color='black')\n",
+    "    ax.text((x1+x2)/2, y+h, p_to_stars(p), ha='center', va='bottom', fontsize=14)\n",
+    "    ax.set_ylim(top=y + 4*h)   # headroom so bracket + marker are not clipped\n",
     "\n",
-    "def plot_pid_ax(ax, data, title):\n",
-    "    \"\"\"Helper function to plot PID lines on a specific subplot axis.\"\"\"\n",
-    "    time_axis = np.arange(len(data['synergy']))\n",
-    "    \n",
-    "    ax.plot(time_axis, data['synergy'], label='Synergy', color='#54A24B', linewidth=3)\n",
-    "    ax.plot(time_axis, data['redundancy'], label='Redundancy', color='#4C78A8', linewidth=3)\n",
-    "    ax.plot(time_axis, data['unique1'], label='Unique 1', color='#F58518', linewidth=1.5, alpha=0.8)\n",
-    "    ax.plot(time_axis, data['unique2'], label='Unique 2', color='#E45756', linewidth=1.5, alpha=0.8)\n",
-    "    ax.plot(time_axis, data['mi_joint'], label='Total MI', color='#020202', linewidth='1.5', alpha=0.8, linestyle=':')\n",
-    "    \n",
-    "    # Mark the End of Stimulus\n",
-    "    ax.axvline(stim_end_idx, color='red', linestyle='--', label='End of Stimulus')\n",
-    "    ax.axvspan(0, stim_end_idx, color='gray', alpha=0.1)\n",
-    "    \n",
-    "    ax.set_title(title, fontsize=15, fontweight='bold', pad=10)\n",
-    "    ax.grid(alpha=0.3)\n",
-    "    \n",
-    "    # Only show axis labels on the outer edges to keep it clean\n",
-    "    if ax.get_subplotspec().is_first_col():\n",
-    "        ax.set_ylabel('Information (Bits)', fontsize=13)\n",
-    "    if ax.get_subplotspec().is_last_row():\n",
-    "        ax.set_xlabel('Timesteps (Subsampled)', fontsize=13)\n",
+    "fig, (ax_acc, ax_loss) = plt.subplots(2, 1, figsize=(10, 7), sharex=True)\n",
     "\n",
-    "# --- Row 1: Elman RNN ---\n",
-    "plot_pid_ax(axes[0, 0], pid_elman_perceptual, \"Elman RNN | Perceptual Task\")\n",
-    "plot_pid_ax(axes[0, 1], pid_elman_context, \"Elman RNN | Context Task\")\n",
+    "# --- top: test accuracy (context left bar, perceptual right bar) ---\n",
+    "ax_acc.bar(seeds - w/2, test_acc['context'],    w, color=COLOR_CONTEXT,    label='Context')\n",
+    "ax_acc.bar(seeds + w/2, test_acc['perceptual'], w, color=COLOR_PERCEPTUAL, label='Perceptual')\n",
+    "ax_acc.set_ylabel('Test accuracy')\n",
+    "ax_acc.legend(loc='lower right')\n",
     "\n",
-    "# --- Row 2: CTRNN ---\n",
-    "plot_pid_ax(axes[1, 0], pid_ctrnn_perceptual, \"CTRNN | Perceptual Task\")\n",
-    "plot_pid_ax(axes[1, 1], pid_ctrnn_context, \"CTRNN | Context Task\")\n",
+    "# --- bottom: test loss (same coloring) ---\n",
+    "ax_loss.bar(seeds - w/2, test_loss['context'],    w, color=COLOR_CONTEXT,    label='Context')\n",
+    "ax_loss.bar(seeds + w/2, test_loss['perceptual'], w, color=COLOR_PERCEPTUAL, label='Perceptual')\n",
+    "ax_loss.set_ylabel('Test loss')\n",
+    "ax_loss.set_xlabel('RNN seed')\n",
+    "ax_loss.set_xticks(seeds)\n",
+    "ax_loss.legend(loc='lower right')\n",
     "\n",
-    "# Add a single master legend to the first plot\n",
-    "axes[0, 0].legend(loc='upper left', fontsize=11, framealpha=0.9)\n",
+    "# --- significance bracket (MWU context vs perceptual) on top of each panel ---\n",
+    "xl, xr = seeds[0] - w/2, seeds[-1] + w/2\n",
+    "annotate_sig(ax_acc,  xl, xr, p_acc,  max(test_acc['context'].max(),  test_acc['perceptual'].max()))\n",
+    "annotate_sig(ax_loss, xl, xr, p_loss, max(test_loss['context'].max(), test_loss['perceptual'].max()))\n",
     "\n",
-    "# Adjust spacing so the main title doesn't overlap with the subplot titles\n",
-    "plt.tight_layout(rect=[0, 0, 1, 0.93])\n",
+    "fig.tight_layout()\n",
+    "fig.savefig(f\"{FIG_ACC_DIR}/test_accuracy_loss_bars.png\", dpi=300)\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "99fb8944",
+   "metadata": {},
+   "source": [
+    "## Figure 2: Time-resolved PID for all seeds\n",
+    "Compute the Gaussian MMI-PID at **every timestep** for all 10 CTRNNs of each task,\n",
+    "bipartition-averaged over 200 random 50/50 unit splits (same procedure as the existing\n",
+    "`gaussian_pid_rnn`). Cache to `all_time_PID_{context,perceptual}` shaped\n",
+    "`[n_seeds=10, T, n_atoms=5]` in bits (atom axis = `ATOMS`), persist to disk, then draw\n",
+    "one figure per seed (perceptual | context)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0928ba02",
+   "metadata": {},
+   "source": [
+    "#### 2a. GPU-batched PID (validated against `gaussian_pid_rnn`)\n",
+    "The bottleneck in `gaussian_pid_rnn` is recomputing a fresh covariance for each of the\n",
+    "200 bipartitions at each of 115 timesteps. But at a given timestep the joint covariance\n",
+    "over *all* units + target is shared across bipartitions, so we compute it **once per\n",
+    "timestep** on the GPU and only batch the small sub-block log-determinants per split. The\n",
+    "bipartition sequence is generated with the *same* regularization as `gaussian_pid_rnn`, so results\n",
+    "match to ~1e-10 bits (checked in 2b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd113224",
+   "metadata": {},
+   "source": [
+    "#### 2b. Sanity check vs the reference implementation\n",
+    "Run one seed through both paths on a handful of timesteps and confirm the GPU result\n",
+    "matches `gaussian_pid_rnn` to within numerical noise (< 1e-6 bits). This justifies using\n",
+    "the fast path for all 20 CTRNNs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e8fca5ad",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:27:07.907748Z",
+     "iopub.status.busy": "2026-07-04T18:27:07.907748Z",
+     "iopub.status.idle": "2026-07-04T18:30:00.914584Z",
+     "shell.execute_reply": "2026-07-04T18:30:00.913578Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "max |GPU - reference| over all timesteps/atoms = 3.05e-10 bits\n",
+      "OK - GPU PID reproduces gaussian_pid_rnn.\n"
+     ]
+    }
+   ],
+   "source": [
+    "_H = load_activations('context', '01'); _Y = load_coherences('context', '01')\n",
+    "_gpu = gaussian_pid_rnn_gpu(_H, _Y, n_bip=200, seed=SEED_ANALYSIS, reg=1e-5)\n",
+    "_ref = gaussian_pid_rnn(activations=_H, target=_Y, timestep=None, bipartitions='random',\n",
+    "                        n_bipartitions=200, seed=SEED_ANALYSIS, log_base=2, regularization=1e-5)\n",
+    "_ref_arr = np.stack([_ref['redundancy'] + _ref['unique1'] + _ref['unique2'] + _ref['synergy'],\n",
+    "                     _ref['redundancy'], _ref['unique1'], _ref['unique2'], _ref['synergy']], axis=1)\n",
+    "print(f\"max |GPU - reference| over all timesteps/atoms = {np.abs(_gpu - _ref_arr).max():.2e} bits\")\n",
+    "assert np.abs(_gpu - _ref_arr).max() < 1e-6, \"GPU PID diverges from reference!\"\n",
+    "print(\"OK - GPU PID reproduces gaussian_pid_rnn.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f88bfdb9",
+   "metadata": {},
+   "source": [
+    "#### 2c. Compute (or load) the cached PID arrays\n",
+    "For each task, run the time-resolved PID over all 10 seeds into\n",
+    "`all_time_PID_{task}` of shape `[n_seeds, T, 5]` (bits, atom order = `ATOMS`). If the\n",
+    "`.npy` caches already exist they are loaded instead of recomputed. Each array is\n",
+    "persisted with a JSON **sidecar** documenting axis meaning, atom order and units."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "0fe70c67",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:30:00.918613Z",
+     "iopub.status.busy": "2026-07-04T18:30:00.918613Z",
+     "iopub.status.idle": "2026-07-04T18:30:50.803451Z",
+     "shell.execute_reply": "2026-07-04T18:30:50.801439Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded cached PID arrays: (10, 115, 5) (10, 115, 5)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def compute_all_time_pid(task):\n",
+    "    \"\"\"Time-resolved PID for all seeds of a task -> (n_seeds, T, 5) in bits.\"\"\"\n",
+    "    out = np.zeros((N_SEEDS, TOTAL_TIMESTEPS, len(ATOMS)))\n",
+    "    for i, s in enumerate(SEED_IDS):\n",
+    "        H, Y = load_activations(task, s), load_coherences(task, s)\n",
+    "        out[i] = gaussian_pid_rnn_gpu(H, Y, n_bip=200, seed=SEED_ANALYSIS, reg=1e-5)\n",
+    "        print(f\"  {task:11s} CTRNN_{s}  synergy@DECISION_T = {out[i, DECISION_T, 4]:.4f} bits\")\n",
+    "    return out\n",
+    "\n",
+    "def save_pid(arr, task):\n",
+    "    \"\"\"Persist the array + a JSON sidecar describing its axes/atoms/units.\"\"\"\n",
+    "    np.save(f\"{PID_OUT_DIR}/{task}/all_time_PID.npy\", arr)\n",
+    "    meta = {\n",
+    "        \"array_file\": \"all_time_PID.npy\",\n",
+    "        \"shape\": list(arr.shape),\n",
+    "        \"axes\": [\"seed 0..9 = CTRNN_01..CTRNN_10\",\n",
+    "                 f\"timestep 0..{TOTAL_TIMESTEPS-1} ({MS_PER_STEP} ms each)\",\n",
+    "                 \"atom\"],\n",
+    "        \"atom_order\": ATOMS,\n",
+    "        \"units\": \"bits\",\n",
+    "        \"decision_t\": DECISION_T,\n",
+    "        \"note\": (\"Gaussian MMI-PID, bipartition-averaged over 200 random 50/50 unit \"\n",
+    "                 \"splits (seed=%d). total_mi = redundancy+unique1+unique2+synergy.\" % SEED_ANALYSIS),\n",
+    "    }\n",
+    "    with open(f\"{PID_OUT_DIR}/{task}/all_time_PID_meta.json\", \"w\") as f:\n",
+    "        json.dump(meta, f, indent=2)\n",
+    "\n",
+    "ctx_path = f\"{PID_OUT_DIR}/context/all_time_PID.npy\"\n",
+    "per_path = f\"{PID_OUT_DIR}/perceptual/all_time_PID.npy\"\n",
+    "if os.path.exists(ctx_path) and os.path.exists(per_path):\n",
+    "    all_time_PID_context    = np.load(ctx_path)      # cached: skip recomputation\n",
+    "    all_time_PID_perceptual = np.load(per_path)\n",
+    "    print(\"Loaded cached PID arrays:\", all_time_PID_context.shape, all_time_PID_perceptual.shape)\n",
+    "else:\n",
+    "    t0 = time.time()\n",
+    "    print(\"Computing perceptual...\");  all_time_PID_perceptual = compute_all_time_pid('perceptual')\n",
+    "    print(\"Computing context...\");     all_time_PID_context    = compute_all_time_pid('context')\n",
+    "    save_pid(all_time_PID_perceptual, 'perceptual')\n",
+    "    save_pid(all_time_PID_context,    'context')\n",
+    "    print(f\"Done in {time.time()-t0:.1f}s. Saved arrays + sidecars to {PID_OUT_DIR}/\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f9af209",
+   "metadata": {},
+   "source": [
+    "#### 2d. Per-seed time-resolved PID figures\n",
+    "One figure per seed: **left = perceptual**, **right = context**, sharing the y-axis. All\n",
+    "five atoms are drawn with their distinct `ATOM_COLORS` and a labeled legend; the panel's\n",
+    "**task color** tints the stimulus-period shading and the axis spines so the two tasks are\n",
+    "identifiable without titles. Following `plot_pid_ax`, a dashed red line marks the decision\n",
+    "time and the stimulus window is shaded. x = Time (ms), y = Information (bits). The 20\n",
+    "figures are saved (not shown)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "2b5a51b0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-04T18:30:50.808453Z",
+     "iopub.status.busy": "2026-07-04T18:30:50.808453Z",
+     "iopub.status.idle": "2026-07-04T18:30:55.819974Z",
+     "shell.execute_reply": "2026-07-04T18:30:55.818963Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved 10 per-seed PID figures to ../figures/all_time_pid/\n"
+     ]
+    }
+   ],
+   "source": [
+    "def plot_pid_ax(ax, pid, task_color, task_name):\n",
+    "    \"\"\"Draw the 5 PID atoms (bits) over time (ms) on one axis, notebook-06 style.\"\"\"\n",
+    "    t_ms = steps_to_ms(np.arange(TOTAL_TIMESTEPS))\n",
+    "    # atom curves: synergy & redundancy emphasized (lw=3), uniques thinner, total dotted\n",
+    "    ax.plot(t_ms, pid[:, 1], color=ATOM_COLORS['redundancy'], lw=3.0, label='Redundancy')\n",
+    "    ax.plot(t_ms, pid[:, 4], color=ATOM_COLORS['synergy'],    lw=3.0, label='Synergy')\n",
+    "    ax.plot(t_ms, pid[:, 2], color=ATOM_COLORS['unique1'], lw=1.5, alpha=0.8, label='Unique 1')\n",
+    "    ax.plot(t_ms, pid[:, 3], color=ATOM_COLORS['unique2'], lw=1.5, alpha=0.8, label='Unique 2')\n",
+    "    ax.plot(t_ms, pid[:, 0], color=ATOM_COLORS['total_mi'], lw=1.5, alpha=0.8, ls=':', label='Total MI')\n",
+    "    # decision-time marker + stimulus-period shading (tinted with the task color)\n",
+    "    ax.axvline(DECISION_T * MS_PER_STEP, color='red', ls='--', label='Decision time')\n",
+    "    ax.axvspan(STIM_START_STEP * MS_PER_STEP, DECISION_T * MS_PER_STEP,\n",
+    "               color=task_color, alpha=0.12)\n",
+    "    # task-colored spines to identify the panel's task without a title\n",
+    "    for side in ('left', 'bottom'):\n",
+    "        ax.spines[side].set_color(task_color)\n",
+    "        ax.spines[side].set_linewidth(2.0)\n",
+    "    ax.set_xlabel('Time (ms)')\n",
+    "    ax.set_ylabel('Information (bits)')\n",
+    "\n",
+    "    # subplot title = task name + seed id (e.g. \"Perceptual CTRNN_01\")\n",
+    "    ax.set_title(f\"{task_name.title()} (CTRNN_{SEED_IDS[i]})\")\n",
+    "\n",
+    "for i, s in enumerate(SEED_IDS):\n",
+    "    fig, (axL, axR) = plt.subplots(1, 2, figsize=(16, 6), sharey=True)\n",
+    "    plot_pid_ax(axL, all_time_PID_perceptual[i], COLOR_PERCEPTUAL, TASKS[0])   # left = perceptual\n",
+    "    plot_pid_ax(axR, all_time_PID_context[i],    COLOR_CONTEXT, TASKS[1])      # right = context\n",
+    "    axL.legend(loc='upper left')\n",
+    "    fig.tight_layout()\n",
+    "    fig.savefig(f\"{FIG_PID_DIR}/CTRNN_{s}.png\", dpi=300)\n",
+    "    plt.close(fig)                                                   # 20 figures -> don't show\n",
+    "print(f\"Saved {N_SEEDS} per-seed PID figures to {FIG_PID_DIR}/\")"
+   ]
   }
  ],
  "metadata": {
diff --git a/notebooks/Jan_example_rnn/Exercise Handout.pdf b/notebooks/Jan_example_rnn/Exercise Handout.pdf
deleted file mode 100644
index 3f941db..0000000
Binary files a/notebooks/Jan_example_rnn/Exercise Handout.pdf and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/__init__.py b/notebooks/Jan_example_rnn/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/RNN_Lorenz.pt b/notebooks/Jan_example_rnn/dyn_rnn/RNN_Lorenz.pt
deleted file mode 100644
index 85c0edf..0000000
Binary files a/notebooks/Jan_example_rnn/dyn_rnn/RNN_Lorenz.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol.pt b/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol.pt
deleted file mode 100644
index 96e4e48..0000000
Binary files a/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol_100.pt b/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol_100.pt
deleted file mode 100644
index c3ea51a..0000000
Binary files a/notebooks/Jan_example_rnn/dyn_rnn/RNN_VanDerPol_100.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/__init__.py b/notebooks/Jan_example_rnn/dyn_rnn/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/dynRNN.py b/notebooks/Jan_example_rnn/dyn_rnn/dynRNN.py
deleted file mode 100644
index 5e12f1c..0000000
--- a/notebooks/Jan_example_rnn/dyn_rnn/dynRNN.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import torch
-import torch.nn as nn
-
-
-class DynRNN(nn.Module):
-    def __init__(self, dim, system='VanDerPol'):
-        super(DynRNN, self).__init__()
-        ##############
-        ##############
-
-        # store basic info
-        self.dim = dim
-        self.system = system
-
-        # choose hidden size (you can tune these)
-        if system == 'VanDerPol':
-            hidden_dim = 300
-        elif system == 'Lorenz':
-            hidden_dim = 300
-
-        # recurrent block: simple feedforward network with 1-2 hidden layers
-        # tanh activations, final layer without activation
-        self.recurrent_block = nn.Sequential(
-            nn.Linear(dim, hidden_dim),
-            nn.Tanh(),
-            nn.Linear(hidden_dim, hidden_dim),
-            nn.Tanh(),
-            nn.Linear(hidden_dim, dim),  # output layer, no activation
-        )
-
-        ##############
-        ##############
-
-    def forward(self, x):
-        ##############
-        ##############
-
-        # x is expected to have shape (n_timesteps, dim)
-        # or (dim,) for a single state in testing mode
-        squeezed = False
-        if x.dim() == 1:
-            x = x.unsqueeze(0)
-            squeezed = True
-
-        # apply the recurrent block timestep-wise (batch dimension = time)
-        x = self.recurrent_block(x)
-
-        if squeezed:
-            x = x.squeeze(0)
-
-        ##############
-        ##############
-        return x
-
-    def calculate_jacobian(self, x):
-        """" Calculates Jacobians along trajectory x.
-        For every timestep the Jacobian is calculated as the derivative of the predictions wrt. inputs
-        and has a shape (n_dim, n_dim) at every timestep.
-        The final Jacobian (return variable) contains the concatenated Jacobians for all timesteps
-        and has a shape (n_timesteps, n_dim, n_dim).
-
-        Parameters:
-        -----------
-        x : torch.Tensor
-            trajectory values, with shape (n_timesteps, n_dim)
-
-
-        Return:
-        -----------
-        jacobian : torch.Tensor
-            computed jacobians for the given trajectory
-            shape = (n_timesteps, n_dim, n_dim)
-
-        """
-        jacobian = None
-        ##############
-        ##############
-
-        assert x.dim() == 2, "x must have shape (n_timesteps, n_dim)"
-        n_timesteps, n_dim = x.shape
-        device = x.device
-        dtype = x.dtype
-
-        # storage for all Jacobians
-        jacobian = torch.zeros(n_timesteps, n_dim, n_dim, device=device, dtype=dtype)
-
-        # start from the first point of the trajectory as initial state
-        # then always use the model's own prediction as the next state
-        state = x[0].clone().detach().requires_grad_(True)
-
-        for t in range(n_timesteps):
-
-            # prediction of the next state from the current state
-            with torch.enable_grad():
-                pred = self.forward(state)  # shape (n_dim,)
-
-                # compute Jacobian d(pred) / d(state)
-                for i in range(n_dim):
-                    grad_output = torch.zeros_like(pred)  # Partial derivative of 
-                    # predicted dim i wrt to all previous state dims
-                    grad_output[i] = 1.0 
-                    # If dim=2, grad_output is [1,0] for i=0 and [0,1] for i=1
-                    # This allows to select which output dimension to differentiate,
-                    # i.e., which predicted state (y1(t) or y2(t)) to differentiate wrt. 
-                    # the two input states (y1(t-1), y2(t-1)) hence, which row of 
-                    # the Jacobian to compute.
-
-                    grads = torch.autograd.grad(
-                        outputs=pred, # vector, shape (n_dim,)
-                        inputs=state, # vector, shape (n_dim,)
-                        grad_outputs=grad_output,
-                        retain_graph=(i < n_dim - 1),
-                        create_graph=False,
-                        allow_unused=False,
-                    )[0]  # same shape as state: (n_dim,)
-
-                    jacobian[t, i, :] = grads  # row i of the Jacobian at time t
-
-            # roll the system forward: next state is the prediction
-            state = pred.detach().requires_grad_(True)
-
-        ##############
-        ##############
-        return jacobian
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/main.py b/notebooks/Jan_example_rnn/dyn_rnn/main.py
deleted file mode 100644
index 970b877..0000000
--- a/notebooks/Jan_example_rnn/dyn_rnn/main.py
+++ /dev/null
@@ -1,147 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import matplotlib.pyplot as plt
-from notebooks.example_rnn.dyn_rnn.dynRNN import DynRNN
-
-# Define task directory
-dir = "example_rnn/dyn_rnn/"
-
-# hyperparameters
-BATCH_SIZE = 1   # not really used here, since we train on a single trajectory
-EPOCHS = 100   
-LEARNING_RATE = 1e-3
-
-# Choose dynamical system
-system = 'VanDerPol'  # 'VanDerPol' or 'Lorenz'
-
-if __name__ == "__main__":
-
-    y_true = torch.load(f'{dir}y_{system}.pt', weights_only=True)  # Size (300, 2) or (300, 3)
-    print(y_true.shape)
-
-    n_timesteps, dim = y_true.shape
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    print(f"Using device: {device}")
-    y_true = y_true.to(device)
-
-    # Create RNN
-    model = DynRNN(dim=dim, system=system).to(device)
-
-    # Optimizer and loss
-    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)  # create the optimizer
-    loss_function = nn.MSELoss()  # loss function (MSE)
-
-     # For tracking over epochs
-    training_losses = []
-    jacobian_norm_max_list = []
-
-
-    # ===== TRAINING LOOP =====
-    for epoch in range(EPOCHS):
-        model.train()
-        optimizer.zero_grad()
-
-        loss = 0.0
-
-        # Loop over the whole timeseries
-        # Teacher forcing: use true state at t as input to predict state at t+1
-        for t in range(n_timesteps - 1):
-            x_t = y_true[t]       # shape: (dim,)
-            target = y_true[t+1]  # next state
-
-            pred = model(x_t)     # predict next state
-
-            loss += loss_function(pred, target)
-
-        # Optionally normalize by number of steps
-        loss = loss / (n_timesteps - 1)
-
-        # Backpropagate once after summing over all timesteps
-        loss.backward()
-        optimizer.step()
-
-        # ---- Track Jacobian after this epoch ----
-        model.eval()
-        # do NOT use torch.no_grad() here, autograd is needed inside calculate_jacobian
-        with torch.enable_grad():
-            # detach so we don't reuse the training graph
-            x_for_jacobian = y_true.detach()
-            jacobian = model.calculate_jacobian(x_for_jacobian)   # shape: (n_timesteps, dim, dim)
-            # Frobenius norm over last two dims -> shape (n_timesteps,)
-            jacobian_norms = torch.linalg.norm(jacobian, dim=(1, 2))
-            # maximum norm over all timesteps
-            jacobian_norm_max = jacobian_norms.max().item()
-
-        # Print loss and max Jacobian norm every 50 epochs
-        training_losses.append(loss.item())
-        jacobian_norm_max_list.append(jacobian_norm_max)
-
-        if (epoch + 1) % 50 == 0 or epoch == 0:
-            print(
-                f"Epoch {epoch+1}/{EPOCHS}, "
-                f"training loss = {loss.item():.6e}, "
-                f"max Jacobian norm = {jacobian_norm_max:.6e}"
-            )
-
-    # Save trained RNN
-    torch.save(model.state_dict(), f"{dir}RNN_{system}_{EPOCHS}.pt")
-    print(f"Trained RNN saved to {dir}RNN_{system}_{EPOCHS}.pt")
-
-
-    # ===== EVALUATION: AUTOREGRESSIVE ROLLOUT =====
-    model.eval()
-    with torch.no_grad():
-        y_pred = torch.zeros_like(y_true)
-        # initial condition: first value in dataset
-        y_pred[0] = y_true[0]
-
-        # always feed prediction at n-1 as input to predict state at n
-        for t in range(n_timesteps - 1):
-            y_pred[t+1] = model(y_pred[t])
-
-        mse_eval = loss_function(y_pred, y_true).item()
-        print(f"Evaluation MSE over full trajectory: {mse_eval:.6e}")
-
-
-    # ===== PLOTTING TRUE VS PREDICTED TRAJECTORY =====
-    y_true_np = y_true.detach().cpu().numpy()
-    y_pred_np = y_pred.detach().cpu().numpy()
-    time = range(n_timesteps)
-
-    # Plot for Van der Pol system
-    if system == 'VanDerPol':
-        plt.figure(figsize=(10, 6))
-        plt.plot(time, y_true_np[:, 0], label='y1_true', c='C0')
-        plt.plot(time, y_pred_np[:, 0], '--', label='y1_predicted', c='C1')
-        plt.plot(time, y_true_np[:, 1], label='y2_true', c='C0')
-        plt.plot(time, y_pred_np[:, 1], '--', label='y2_predicted', c='C1')
-
-        plt.ylabel(f'y1, y2')
-        plt.title('Van der Pol trajectory: true vs predicted')
-        plt.xlabel('Time (s)')
-        plt.legend(loc='best')
- 
-        plt.tight_layout()
-        plt.show()
-
-    # Plot for Lorenz system
-    elif system == 'Lorenz':
-        from mpl_toolkits.mplot3d import Axes3D  # needed for 3D plotting
-
-        fig = plt.figure(figsize=(10, 6))
-        ax = fig.add_subplot(111, projection='3d')
-        ax.plot(y_true_np[:, 0], y_true_np[:, 1], y_true_np[:, 2], label='True trajectory', c='C0')
-        ax.plot(y_pred_np[:, 0], y_pred_np[:, 1], y_pred_np[:, 2], '--', label='Predicted trajectory', c='C1')
-
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        ax.set_zlabel('Z')
-        ax.set_title('Lorenz trajectory: true vs predicted')
-        ax.legend(loc='best')
-
-        plt.tight_layout()
-        plt.show()
-    
-
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/utils.py b/notebooks/Jan_example_rnn/dyn_rnn/utils.py
deleted file mode 100644
index 0791e71..0000000
--- a/notebooks/Jan_example_rnn/dyn_rnn/utils.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import numpy as np
-
-SMOOTHING_SIGMA = 2
-FREQUENCY_CUTOFF = 500
-
-
-def ensure_length_is_even(x):
-    n = len(x)
-    if n % 2 != 0:
-        x = x[:-1]
-        n = len(x)
-    x = np.reshape(x, (n,))
-    return x
-
-
-def gauss(x, sigma=1):
-    return 1 / np.sqrt(2 * np.pi * sigma ** 2) * np.exp(-1 / 2 * (x / sigma) ** 2)
-
-
-def get_kernel(sigma):
-    size = sigma * 10 + 1
-    kernel = list(range(size))
-    kernel = [float(k) - int(size / 2) for k in kernel]
-    kernel = [gauss(k, sigma) for k in kernel]
-    kernel = [k / np.sum(kernel) for k in kernel]
-    return kernel
-
-
-def kernel_smoothen(data, kernel_sigma=1):
-    kernel = get_kernel(kernel_sigma)
-    data_final = data.copy()
-    data_conv = np.convolve(data[:], kernel)
-    pad = int(len(kernel) / 2)
-    data_final[:] = data_conv[pad:-pad]
-    data = data_final
-    return data
-
-
-def fft_smoothed(x):
-    x = ensure_length_is_even(x)
-    fft_real = np.fft.rfft(x, norm='ortho')
-    fft_magnitude = np.abs(fft_real) ** 2 * 2 / len(x)
-    fft_smoothed = kernel_smoothen(fft_magnitude, kernel_sigma=SMOOTHING_SIGMA)
-
-    return fft_smoothed
-
-
-def get_average_spectrum(trajectories):
-    spectrum = []
-    for trajectory in trajectories:
-        trajectory = (trajectory - trajectory.mean()) / trajectory.std()
-        fft = fft_smoothed(trajectory)
-        spectrum.append(fft)
-    spectrum = np.nanmean(np.array(spectrum), axis=0)
-
-    return spectrum
-
-
-def power_spectrum_error_per_dim(x_gen, x_true):
-    x_gen = np.array([x_gen])
-    x_true = np.array([x_true])
-
-    assert x_true.shape[1] == x_gen.shape[1]
-    assert x_true.shape[2] == x_gen.shape[2]
-    dim_x = x_gen.shape[2]
-    pse_corrs_per_dim = []
-    for dim in range(dim_x):
-        spectrum_true = get_average_spectrum(x_true[:, :, dim])
-        spectrum_gen = get_average_spectrum(x_gen[:, :, dim])
-        spectrum_true = spectrum_true[:FREQUENCY_CUTOFF]
-        spectrum_gen = spectrum_gen[:FREQUENCY_CUTOFF]
-        BC = np.trapz(np.sqrt(spectrum_true * spectrum_gen))
-        hellinger_dist = np.sqrt(1 - BC)
-
-        pse_corrs_per_dim.append(hellinger_dist)
-
-    return pse_corrs_per_dim
-
-
-def power_spectrum_error(x_gen, x_true):
-    pse_errors_per_dim = power_spectrum_error_per_dim(x_gen, x_true)
-    return np.array(pse_errors_per_dim).mean(axis=0)
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/y_Lorenz.pt b/notebooks/Jan_example_rnn/dyn_rnn/y_Lorenz.pt
deleted file mode 100644
index 9ef58f0..0000000
Binary files a/notebooks/Jan_example_rnn/dyn_rnn/y_Lorenz.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/dyn_rnn/y_VanDerPol.pt b/notebooks/Jan_example_rnn/dyn_rnn/y_VanDerPol.pt
deleted file mode 100644
index d6bd77f..0000000
Binary files a/notebooks/Jan_example_rnn/dyn_rnn/y_VanDerPol.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/true_rnn/RNN_Lorenz.pt b/notebooks/Jan_example_rnn/true_rnn/RNN_Lorenz.pt
deleted file mode 100644
index 85c0edf..0000000
Binary files a/notebooks/Jan_example_rnn/true_rnn/RNN_Lorenz.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/true_rnn/RNN_VanDerPol.pt b/notebooks/Jan_example_rnn/true_rnn/RNN_VanDerPol.pt
deleted file mode 100644
index 96e4e48..0000000
Binary files a/notebooks/Jan_example_rnn/true_rnn/RNN_VanDerPol.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/true_rnn/__init__.py b/notebooks/Jan_example_rnn/true_rnn/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/notebooks/Jan_example_rnn/true_rnn/main.py b/notebooks/Jan_example_rnn/true_rnn/main.py
deleted file mode 100644
index 97f1d05..0000000
--- a/notebooks/Jan_example_rnn/true_rnn/main.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import matplotlib.pyplot as plt
-from notebooks.example_rnn.true_rnn.trueRNN import TrueRNN
-
-# Define task directory
-dir = "example_rnn/true_rnn/"
-
-# hyperparameters
-BATCH_SIZE = 1   # not really used here, since we train on a single trajectory
-EPOCHS = 1000   
-LEARNING_RATE = 1e-3
-
-# Choose dynamical system
-system = 'Lorenz'  # 'VanDerPol' or 'Lorenz'
-
-if __name__ == "__main__":
-
-    y_true = torch.load(f'{dir}y_{system}.pt', weights_only=True)  # Size (300, 2) or (300, 3)
-    # print(y_true.shape)
-
-    n_timesteps, dim = y_true.shape
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    y_true = y_true.to(device)
-
-    # Create RNN
-    model = TrueRNN(dim=dim, system=system).to(device)
-
-    # Optimizer and loss
-    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)  # create the optimizer
-    loss_function = nn.MSELoss()  # loss function (MSE)
-
-     # For tracking over epochs
-    training_losses = []
-    jacobian_norm_max_list = []
-
-
-    # ===== TRAINING LOOP =====
-    for epoch in range(EPOCHS):
-        model.train()
-        optimizer.zero_grad()
-
-        # Teacher forcing over the full sequence: predict x_{t+1} from x_t
-        x_in = y_true[:-1]
-        target = y_true[1:]
-        pred, _ = model(x_in)
-        loss = loss_function(pred, target)
-
-        # Backpropagate once after summing over all timesteps
-        loss.backward()
-        optimizer.step()
-
-        # ---- Track Jacobian after this epoch ----
-        model.eval()
-        # do NOT use torch.no_grad() here, autograd is needed inside calculate_jacobian
-        with torch.enable_grad():
-            # detach so we don't reuse the training graph
-            x_for_jacobian = y_true.detach()
-            jacobian = model.calculate_jacobian(x_for_jacobian)   # shape: (n_timesteps, dim, dim)
-            # Frobenius norm over last two dims -> shape (n_timesteps,)
-            jacobian_norms = torch.linalg.norm(jacobian, dim=(1, 2))
-            # maximum norm over all timesteps
-            jacobian_norm_max = jacobian_norms.max().item()
-
-        # Print loss and max Jacobian norm every 50 epochs
-        training_losses.append(loss.item())
-        jacobian_norm_max_list.append(jacobian_norm_max)
-
-        if (epoch + 1) % 50 == 0 or epoch == 0:
-            print(
-                f"Epoch {epoch+1}/{EPOCHS}, "
-                f"training loss = {loss.item():.6e}, "
-                f"max Jacobian norm = {jacobian_norm_max:.6e}"
-            )
-
-    # Save trained RNN
-    torch.save(model.state_dict(), f"{dir}RNN_{system}.pt")
-    print(f"Trained RNN saved to {dir}RNN_{system}.pt")
-
-
-    # ===== EVALUATION: AUTOREGRESSIVE ROLLOUT =====
-    model.eval()
-    with torch.no_grad():
-        y_pred = torch.zeros_like(y_true)
-        # initial condition: first value in dataset
-        y_pred[0] = y_true[0]
-
-        # always feed prediction at n-1 as input to predict state at n
-        h = None
-        for t in range(n_timesteps - 1):
-            step_pred, h = model(y_pred[t], h0=h)
-            y_pred[t+1] = step_pred
-
-        mse_eval = loss_function(y_pred, y_true).item()
-        print(f"Evaluation MSE over full trajectory: {mse_eval:.6e}")
-
-
-    # ===== PLOTTING TRUE VS PREDICTED TRAJECTORY =====
-    y_true_np = y_true.detach().cpu().numpy()
-    y_pred_np = y_pred.detach().cpu().numpy()
-    time = range(n_timesteps)
-
-    # Plot for Van der Pol system
-    if system == 'VanDerPol':
-        plt.figure(figsize=(10, 6))
-        plt.plot(time, y_true_np[:, 0], label='y1_true', c='C0')
-        plt.plot(time, y_pred_np[:, 0], '--', label='y1_predicted', c='C1')
-        plt.plot(time, y_true_np[:, 1], label='y2_true', c='C0')
-        plt.plot(time, y_pred_np[:, 1], '--', label='y2_predicted', c='C1')
-
-        plt.ylabel(f'y1, y2')
-        plt.title('Van der Pol trajectory: true vs predicted')
-        plt.xlabel('Time (s)')
-        plt.legend(loc='best')
- 
-        plt.tight_layout()
-        plt.show()
-
-    # Plot for Lorenz system
-    elif system == 'Lorenz':
-        from mpl_toolkits.mplot3d import Axes3D  # needed for 3D plotting
-
-        fig = plt.figure(figsize=(10, 6))
-        ax = fig.add_subplot(111, projection='3d')
-        ax.plot(y_true_np[:, 0], y_true_np[:, 1], y_true_np[:, 2], label='True trajectory', c='C0')
-        ax.plot(y_pred_np[:, 0], y_pred_np[:, 1], y_pred_np[:, 2], '--', label='Predicted trajectory', c='C1')
-
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        ax.set_zlabel('Z')
-        ax.set_title('Lorenz trajectory: true vs predicted')
-        ax.legend(loc='best')
-
-        plt.tight_layout()
-        plt.show()
-    
-
diff --git a/notebooks/Jan_example_rnn/true_rnn/trueRNN.py b/notebooks/Jan_example_rnn/true_rnn/trueRNN.py
deleted file mode 100644
index 15c6b65..0000000
--- a/notebooks/Jan_example_rnn/true_rnn/trueRNN.py
+++ /dev/null
@@ -1,131 +0,0 @@
-import torch
-import torch.nn as nn
-
-
-class TrueRNN(nn.Module):
-    def __init__(self, dim, system='VanDerPol', hidden_dim=None, num_layers=1):
-        super(TrueRNN, self).__init__()
-        ##############
-        ##############
-
-        # store basic info
-        self.dim = dim
-        self.system = system
-
-        # choose hidden size (you can tune these)
-        if hidden_dim is None:
-            hidden_dim = 300
-
-        self.hidden_dim = hidden_dim
-        self.num_layers = num_layers
-
-        # classic RNN cell with tanh nonlinearity and a linear readout
-        self.rnn = nn.RNN(
-            input_size=dim,
-            hidden_size=hidden_dim,
-            num_layers=num_layers,
-            nonlinearity="tanh",
-            batch_first=False,
-        )
-        self.readout = nn.Linear(hidden_dim, dim)
-
-        ##############
-        ##############
-
-    def forward(self, x, h0=None):
-        ##############
-        ##############
-
-        # x is expected to have shape (n_timesteps, dim)
-        # or (dim,) for a single state in testing mode
-        squeezed = False
-        if x.dim() == 1:
-            x = x.unsqueeze(0)
-            squeezed = True
-
-        # add batch dimension for the RNN: (seq_len, batch, dim)
-        x = x.unsqueeze(1)
-        out, hn = self.rnn(x, h0)
-        y = self.readout(out).squeeze(1)
-
-        if squeezed:
-            y = y.squeeze(0)
-
-        ##############
-        ##############
-        return y, hn
-
-    def calculate_jacobian(self, x):
-        """" Calculates Jacobians along trajectory x.
-        For every timestep the Jacobian is calculated as the derivative of the predictions wrt. inputs
-        and has a shape (n_dim, n_dim) at every timestep.
-        The final Jacobian (return variable) contains the concatenated Jacobians for all timesteps
-        and has a shape (n_timesteps, n_dim, n_dim).
-
-        Parameters:
-        -----------
-        x : torch.Tensor
-            trajectory values, with shape (n_timesteps, n_dim)
-
-
-        Return:
-        -----------
-        jacobian : torch.Tensor
-            computed jacobians for the given trajectory
-            shape = (n_timesteps, n_dim, n_dim)
-
-        """
-        jacobian = None
-        ##############
-        ##############
-
-        assert x.dim() == 2, "x must have shape (n_timesteps, n_dim)"
-        n_timesteps, n_dim = x.shape
-        device = x.device
-        dtype = x.dtype
-
-        # storage for all Jacobians
-        jacobian = torch.zeros(n_timesteps, n_dim, n_dim, device=device, dtype=dtype)
-
-        # initial hidden state
-        h = torch.zeros(self.num_layers, 1, self.hidden_dim, device=device, dtype=dtype)
-
-        # start from the first point of the trajectory as initial state
-        # then always use the model's own prediction as the next state
-        state = x[0].clone().detach().requires_grad_(True)
-
-        for t in range(n_timesteps):
-
-            # prediction of the next state from the current state
-            with torch.enable_grad():
-                h = h.detach()
-                pred, h = self.forward(state, h0=h)  # pred shape (n_dim,)
-
-                # compute Jacobian d(pred) / d(state)
-                for i in range(n_dim):
-                    grad_output = torch.zeros_like(pred)  # Partial derivative of 
-                    # predicted dim i wrt to all previous state dims
-                    grad_output[i] = 1.0 
-                    # If dim=2, grad_output is [1,0] for i=0 and [0,1] for i=1
-                    # This allows to select which output dimension to differentiate,
-                    # i.e., which predicted state (y1(t) or y2(t)) to differentiate wrt. 
-                    # the two input states (y1(t-1), y2(t-1)) hence, which row of 
-                    # the Jacobian to compute.
-
-                    grads = torch.autograd.grad(
-                        outputs=pred, # vector, shape (n_dim,)
-                        inputs=state, # vector, shape (n_dim,)
-                        grad_outputs=grad_output,
-                        retain_graph=(i < n_dim - 1),
-                        create_graph=False,
-                        allow_unused=False,
-                    )[0]  # same shape as state: (n_dim,)
-
-                    jacobian[t, i, :] = grads  # row i of the Jacobian at time t
-
-            # roll the system forward: next state is the prediction
-            state = pred.detach().requires_grad_(True)
-
-        ##############
-        ##############
-        return jacobian
diff --git a/notebooks/Jan_example_rnn/true_rnn/utils.py b/notebooks/Jan_example_rnn/true_rnn/utils.py
deleted file mode 100644
index 0791e71..0000000
--- a/notebooks/Jan_example_rnn/true_rnn/utils.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import numpy as np
-
-SMOOTHING_SIGMA = 2
-FREQUENCY_CUTOFF = 500
-
-
-def ensure_length_is_even(x):
-    n = len(x)
-    if n % 2 != 0:
-        x = x[:-1]
-        n = len(x)
-    x = np.reshape(x, (n,))
-    return x
-
-
-def gauss(x, sigma=1):
-    return 1 / np.sqrt(2 * np.pi * sigma ** 2) * np.exp(-1 / 2 * (x / sigma) ** 2)
-
-
-def get_kernel(sigma):
-    size = sigma * 10 + 1
-    kernel = list(range(size))
-    kernel = [float(k) - int(size / 2) for k in kernel]
-    kernel = [gauss(k, sigma) for k in kernel]
-    kernel = [k / np.sum(kernel) for k in kernel]
-    return kernel
-
-
-def kernel_smoothen(data, kernel_sigma=1):
-    kernel = get_kernel(kernel_sigma)
-    data_final = data.copy()
-    data_conv = np.convolve(data[:], kernel)
-    pad = int(len(kernel) / 2)
-    data_final[:] = data_conv[pad:-pad]
-    data = data_final
-    return data
-
-
-def fft_smoothed(x):
-    x = ensure_length_is_even(x)
-    fft_real = np.fft.rfft(x, norm='ortho')
-    fft_magnitude = np.abs(fft_real) ** 2 * 2 / len(x)
-    fft_smoothed = kernel_smoothen(fft_magnitude, kernel_sigma=SMOOTHING_SIGMA)
-
-    return fft_smoothed
-
-
-def get_average_spectrum(trajectories):
-    spectrum = []
-    for trajectory in trajectories:
-        trajectory = (trajectory - trajectory.mean()) / trajectory.std()
-        fft = fft_smoothed(trajectory)
-        spectrum.append(fft)
-    spectrum = np.nanmean(np.array(spectrum), axis=0)
-
-    return spectrum
-
-
-def power_spectrum_error_per_dim(x_gen, x_true):
-    x_gen = np.array([x_gen])
-    x_true = np.array([x_true])
-
-    assert x_true.shape[1] == x_gen.shape[1]
-    assert x_true.shape[2] == x_gen.shape[2]
-    dim_x = x_gen.shape[2]
-    pse_corrs_per_dim = []
-    for dim in range(dim_x):
-        spectrum_true = get_average_spectrum(x_true[:, :, dim])
-        spectrum_gen = get_average_spectrum(x_gen[:, :, dim])
-        spectrum_true = spectrum_true[:FREQUENCY_CUTOFF]
-        spectrum_gen = spectrum_gen[:FREQUENCY_CUTOFF]
-        BC = np.trapz(np.sqrt(spectrum_true * spectrum_gen))
-        hellinger_dist = np.sqrt(1 - BC)
-
-        pse_corrs_per_dim.append(hellinger_dist)
-
-    return pse_corrs_per_dim
-
-
-def power_spectrum_error(x_gen, x_true):
-    pse_errors_per_dim = power_spectrum_error_per_dim(x_gen, x_true)
-    return np.array(pse_errors_per_dim).mean(axis=0)
diff --git a/notebooks/Jan_example_rnn/true_rnn/y_Lorenz.pt b/notebooks/Jan_example_rnn/true_rnn/y_Lorenz.pt
deleted file mode 100644
index 9ef58f0..0000000
Binary files a/notebooks/Jan_example_rnn/true_rnn/y_Lorenz.pt and /dev/null differ
diff --git a/notebooks/Jan_example_rnn/true_rnn/y_VanDerPol.pt b/notebooks/Jan_example_rnn/true_rnn/y_VanDerPol.pt
deleted file mode 100644
index d6bd77f..0000000
Binary files a/notebooks/Jan_example_rnn/true_rnn/y_VanDerPol.pt and /dev/null differ
diff --git a/results/accuracies_n_losses/context/.gitkeep b/results/accuracies_n_losses/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/accuracies_n_losses/perceptual/.gitkeep b/results/accuracies_n_losses/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_activations/.gitkeep b/results/model_activations/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_activations/context/.gitkeep b/results/model_activations/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_activations/perceptual/.gitkeep b/results/model_activations/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_weights/.gitkeep b/results/model_weights/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_weights/context/.gitkeep b/results/model_weights/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/model_weights/perceptual/.gitkeep b/results/model_weights/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/pid_outputs/.gitkeep b/results/pid_outputs/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/pid_outputs/context/.gitkeep b/results/pid_outputs/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/pid_outputs/context/all_time_PID.npy b/results/pid_outputs/context/all_time_PID.npy
new file mode 100644
index 0000000..f3307a7
Binary files /dev/null and b/results/pid_outputs/context/all_time_PID.npy differ
diff --git a/results/pid_outputs/context/all_time_PID_meta.json b/results/pid_outputs/context/all_time_PID_meta.json
new file mode 100644
index 0000000..28dd910
--- /dev/null
+++ b/results/pid_outputs/context/all_time_PID_meta.json
@@ -0,0 +1,23 @@
+{
+  "array_file": "all_time_PID.npy",
+  "shape": [
+    10,
+    115,
+    5
+  ],
+  "axes": [
+    "seed 0..9 = CTRNN_01..CTRNN_10",
+    "timestep 0..114 (10 ms each)",
+    "atom"
+  ],
+  "atom_order": [
+    "total_mi",
+    "redundancy",
+    "unique1",
+    "unique2",
+    "synergy"
+  ],
+  "units": "bits",
+  "decision_t": 104,
+  "note": "Gaussian MMI-PID, bipartition-averaged over 200 random 50/50 unit splits (seed=0). total_mi = redundancy+unique1+unique2+synergy."
+}
\ No newline at end of file
diff --git a/results/pid_outputs/perceptual/.gitkeep b/results/pid_outputs/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/pid_outputs/perceptual/all_time_PID.npy b/results/pid_outputs/perceptual/all_time_PID.npy
new file mode 100644
index 0000000..9b05b09
Binary files /dev/null and b/results/pid_outputs/perceptual/all_time_PID.npy differ
diff --git a/results/pid_outputs/perceptual/all_time_PID_meta.json b/results/pid_outputs/perceptual/all_time_PID_meta.json
new file mode 100644
index 0000000..28dd910
--- /dev/null
+++ b/results/pid_outputs/perceptual/all_time_PID_meta.json
@@ -0,0 +1,23 @@
+{
+  "array_file": "all_time_PID.npy",
+  "shape": [
+    10,
+    115,
+    5
+  ],
+  "axes": [
+    "seed 0..9 = CTRNN_01..CTRNN_10",
+    "timestep 0..114 (10 ms each)",
+    "atom"
+  ],
+  "atom_order": [
+    "total_mi",
+    "redundancy",
+    "unique1",
+    "unique2",
+    "synergy"
+  ],
+  "units": "bits",
+  "decision_t": 104,
+  "note": "Gaussian MMI-PID, bipartition-averaged over 200 random 50/50 unit splits (seed=0). total_mi = redundancy+unique1+unique2+synergy."
+}
\ No newline at end of file
diff --git a/results/stimulus_coherences/context/.gitkeep b/results/stimulus_coherences/context/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/stimulus_coherences/context/test_01_coherences.npz b/results/stimulus_coherences/context/test_01_coherences.npz
new file mode 100644
index 0000000..d823218
Binary files /dev/null and b/results/stimulus_coherences/context/test_01_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_02_coherences.npz b/results/stimulus_coherences/context/test_02_coherences.npz
new file mode 100644
index 0000000..70927b6
Binary files /dev/null and b/results/stimulus_coherences/context/test_02_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_03_coherences.npz b/results/stimulus_coherences/context/test_03_coherences.npz
new file mode 100644
index 0000000..630d1ae
Binary files /dev/null and b/results/stimulus_coherences/context/test_03_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_04_coherences.npz b/results/stimulus_coherences/context/test_04_coherences.npz
new file mode 100644
index 0000000..b451a50
Binary files /dev/null and b/results/stimulus_coherences/context/test_04_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_05_coherences.npz b/results/stimulus_coherences/context/test_05_coherences.npz
new file mode 100644
index 0000000..12a8d7f
Binary files /dev/null and b/results/stimulus_coherences/context/test_05_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_06_coherences.npz b/results/stimulus_coherences/context/test_06_coherences.npz
new file mode 100644
index 0000000..44af1b6
Binary files /dev/null and b/results/stimulus_coherences/context/test_06_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_07_coherences.npz b/results/stimulus_coherences/context/test_07_coherences.npz
new file mode 100644
index 0000000..53d65e1
Binary files /dev/null and b/results/stimulus_coherences/context/test_07_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_08_coherences.npz b/results/stimulus_coherences/context/test_08_coherences.npz
new file mode 100644
index 0000000..4912ea6
Binary files /dev/null and b/results/stimulus_coherences/context/test_08_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_09_coherences.npz b/results/stimulus_coherences/context/test_09_coherences.npz
new file mode 100644
index 0000000..bb7e525
Binary files /dev/null and b/results/stimulus_coherences/context/test_09_coherences.npz differ
diff --git a/results/stimulus_coherences/context/test_10_coherences.npz b/results/stimulus_coherences/context/test_10_coherences.npz
new file mode 100644
index 0000000..b2a05f9
Binary files /dev/null and b/results/stimulus_coherences/context/test_10_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/.gitkeep b/results/stimulus_coherences/perceptual/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/results/stimulus_coherences/perceptual/test_01_coherences.npz b/results/stimulus_coherences/perceptual/test_01_coherences.npz
new file mode 100644
index 0000000..0525b53
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_01_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_02_coherences.npz b/results/stimulus_coherences/perceptual/test_02_coherences.npz
new file mode 100644
index 0000000..42b8e61
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_02_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_03_coherences.npz b/results/stimulus_coherences/perceptual/test_03_coherences.npz
new file mode 100644
index 0000000..894fafc
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_03_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_04_coherences.npz b/results/stimulus_coherences/perceptual/test_04_coherences.npz
new file mode 100644
index 0000000..c7eaf87
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_04_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_05_coherences.npz b/results/stimulus_coherences/perceptual/test_05_coherences.npz
new file mode 100644
index 0000000..bfa4cda
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_05_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_06_coherences.npz b/results/stimulus_coherences/perceptual/test_06_coherences.npz
new file mode 100644
index 0000000..12d1900
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_06_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_07_coherences.npz b/results/stimulus_coherences/perceptual/test_07_coherences.npz
new file mode 100644
index 0000000..55b64a3
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_07_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_08_coherences.npz b/results/stimulus_coherences/perceptual/test_08_coherences.npz
new file mode 100644
index 0000000..43537ee
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_08_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_09_coherences.npz b/results/stimulus_coherences/perceptual/test_09_coherences.npz
new file mode 100644
index 0000000..1516271
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_09_coherences.npz differ
diff --git a/results/stimulus_coherences/perceptual/test_10_coherences.npz b/results/stimulus_coherences/perceptual/test_10_coherences.npz
new file mode 100644
index 0000000..3df1b63
Binary files /dev/null and b/results/stimulus_coherences/perceptual/test_10_coherences.npz differ
diff --git a/size_comparison/CDM/results/ctrnn_pid_sweep_cdm.py b/size_comparison/CDM/results/ctrnn_pid_sweep_cdm.py
new file mode 100644
index 0000000..fa03d4a
--- /dev/null
+++ b/size_comparison/CDM/results/ctrnn_pid_sweep_cdm.py
@@ -0,0 +1,905 @@
+"""
+ctrnn_pid_sweep_cdm.py
+======================
+Train a CTRNN on ContextDecisionMaking-v0 across hidden sizes [20, 16, 12, 8, 4, 2],
+run time-resolved Gaussian PID analysis at each size, save all plots, and produce a
+summary comparison figure.
+
+Key differences from the PDM version
+--------------------------------------
+- ob_size = 7  (fixation + 4 stimulus channels + 2 context channels)
+- Coherences are [5, 15, 50] not Britten levels
+- Stochastic delay period → MUST be fixed for PID (set delay=0)
+- Two PID targets analysed:
+    (a) signed coherence of the RELEVANT modality  (task difficulty + direction)
+    (b) context label (0 or 1)                     (which rule is active)
+- Stim-end detection uses fixation channel (ch0) same as PDM
+
+Observation vector layout (ob_size = 7)
+-----------------------------------------
+  ch 0 : fixation signal
+  ch 1 : stim1_mod1  (relevant or irrelevant depending on context)
+  ch 2 : stim2_mod1
+  ch 3 : stim1_mod2
+  ch 4 : stim2_mod2
+  ch 5 : context1 cue  (=1 when context==0, i.e. attend modality 1)
+  ch 6 : context2 cue  (=1 when context==1, i.e. attend modality 2)
+
+Usage
+-----
+    python ctrnn_pid_sweep_cdm.py
+    python ctrnn_pid_sweep_cdm.py --hidden_sizes 20 10 5 2
+    python ctrnn_pid_sweep_cdm.py --n_train_batches 1000 --n_test_trials 200
+
+Outputs (results/pid_sweep_cdm/)
+---------------------------------
+    pid_timeseries_h{N}.png    — per hidden size: loss + two PID panels
+    comparison_summary.png     — multi-panel sweep comparison
+    sweep_results.npz          — raw arrays for further analysis
+"""
+
+import argparse
+import os
+import sys
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import neurogym as ngym
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Project module imports (with fallback)
+# ──────────────────────────────────────────────────────────────────────────────
+sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))    
+
+try:
+    from src.models.ctrnn import CTRNN
+    from src.analysis.gaussian_pid import gaussian_pid_rnn
+    from src.tasks.neurogym_wrapper import create_dataset_generator
+    from src.tasks.data_loader import load_mante_data
+    from src.tasks.mante_config import CONFIG, UNIFORM_COHS, MANTE_TEST_COHS
+    _USING_PROJECT_MODULES = True
+except Exception as exc:
+    _USING_PROJECT_MODULES = False
+    print(f"[WARN] src/ modules could not be imported: {exc}")
+    print("[WARN] using built-in fallbacks instead.")
+
+print(f"Using project modules: {_USING_PROJECT_MODULES}")
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+TASK        = 'ContextDecisionMaking-v0'
+INPUT_DIM   = 7     # fixation + 4 stim + 2 context channels
+OUTPUT_DIM  = 3     # fixate / choice1 / choice2
+DT          = 20    # ms per timestep
+from pathlib import Path
+
+RESULTS_DIR = Path(__file__).resolve().parents[3] / "results" / "size_comparison" / "CDM_results" / "pid_sweep_cdm"
+RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+DEFAULT_HIDDEN_SIZES   = [2, 4, 8, 12, 16, 20, 40, 60, 80, 100, 150, 200]
+DEFAULT_N_Batches      = 157
+DEFAULT_N_TEST         = 2000
+DEFAULT_LR             = 2e-3
+DEFAULT_BATCH_SIZE     = 1024
+DEFAULT_N_BIPARTITIONS = 50
+DEFAULT_SEED           = 42
+Default_N_EPOCHS       = 50
+
+# Fixed timing for PID evaluation
+# CRITICAL: delay must be 0 — default is stochastic TruncExp(600,300,3000)
+# which makes trials different lengths and breaks time-aligned PID.
+EVAL_TIMING = {
+    'fixation': 200,    # 10 steps @ dt=20
+    'stimulus': 1000,    # 50 steps (rounded to 38 at dt=20)
+    'delay':    0,      # 0 steps  — MUST fix stochastic delay
+    'decision': 100,    # 5  steps
+}
+# Total ≈ 58 steps → seq_len buffer = 70
+
+PALETTE = {
+    'synergy':    '#54A24B',
+    'redundancy': '#4C78A8',
+    'unique1':    '#F58518',
+    'unique2':    '#E45756',
+    'mi_joint':   '#1A1A1A',
+    'stim_end':   '#CC0000',
+    'context0':   '#7B2D8B',
+    'context1':   '#2D8B7B',
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Fallback CTRNN
+# ──────────────────────────────────────────────────────────────────────────────
+
+class _FallbackCTRNN(nn.Module):
+    """Euler-discretised CT-RNN: h(t+dt) = h + alpha*(-h + tanh(W_in u + W_rec h))"""
+    def __init__(self, input_size, hidden_size, output_size, dt=20, tau=100):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.alpha  = dt / tau
+        self.W_in   = nn.Linear(input_size,  hidden_size, bias=True)
+        self.W_rec  = nn.Linear(hidden_size, hidden_size, bias=False)
+        self.W_out  = nn.Linear(hidden_size, output_size, bias=True)
+        nn.init.orthogonal_(self.W_rec.weight)
+        nn.init.xavier_uniform_(self.W_in.weight)
+        nn.init.xavier_uniform_(self.W_out.weight)
+        nn.init.zeros_(self.W_in.bias)
+        nn.init.zeros_(self.W_out.bias)
+
+    def forward(self, x):
+        B, T, _ = x.shape
+        h = torch.zeros(B, self.hidden_size, device=x.device)
+        outputs, hiddens = [], []
+        for t in range(T):
+            h = h + self.alpha * (
+                -h + torch.tanh(self.W_in(x[:, t]) + self.W_rec(h))
+            )
+            outputs.append(self.W_out(h))
+            hiddens.append(h)
+        return torch.stack(outputs, 1), torch.stack(hiddens, 1)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Fallback Gaussian analytic PID  (MMI-PID, Barrett 2015)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _fallback_gaussian_pid(activations, target, timestep=None,
+                            n_bipartitions=50, seed=DEFAULT_SEED,
+                            regularization=1e-5, **kwargs):
+    """
+    activations : (N, T, H)
+    target      : (N,)  continuous scalar
+    Returns dict with synergy / redundancy / unique1 / unique2 / mi_joint
+    each of shape (T,) if timestep is None, else scalar.
+    """
+    rng = np.random.default_rng(seed)
+    N, T, H = activations.shape
+    y = target.astype(np.float64)
+
+    def _mi(X):
+        """Gaussian MI between multivariate X (N,d) and scalar y (N,) via R²."""
+        X_ = X - X.mean(0)
+        y_ = y - y.mean()
+        Sxx = X_.T @ X_ / N + regularization * np.eye(X_.shape[1])
+        Sxy = X_.T @ y_ / N
+        var_y = np.var(y_) + 1e-12
+        try:
+            r2 = float(Sxy @ np.linalg.solve(Sxx, Sxy)) / var_y
+            r2 = np.clip(r2, 0.0, 1.0 - 1e-9)
+        except np.linalg.LinAlgError:
+            return 0.0
+        return float(-0.5 * np.log(1.0 - r2) / np.log(2))
+
+    def _pid_at_t(h_t):
+        syn_l, red_l, u1_l, u2_l, mi_l = [], [], [], [], []
+        half = max(H // 2, 1)
+        for _ in range(n_bipartitions):
+            idx = rng.permutation(H)
+            i1, i2 = idx[:half], idx[half:half * 2]
+            mi1  = _mi(h_t[:, i1])
+            mi2  = _mi(h_t[:, i2])
+            mi_j = _mi(h_t[:, np.concatenate([i1, i2])])
+            red  = min(mi1, mi2)
+            syn  = max(mi_j - mi1 - mi2 + red, 0.0)
+            u1   = max(mi1 - red, 0.0)
+            u2   = max(mi2 - red, 0.0)
+            syn_l.append(syn); red_l.append(red)
+            u1_l.append(u1);   u2_l.append(u2)
+            mi_l.append(mi_j)
+        return {k: float(np.mean(v))
+                for k, v in zip(['syn','red','u1','u2','mi'],
+                                [syn_l,red_l,u1_l,u2_l,mi_l])}
+
+    def _wrap(r):
+        return {'synergy': r['syn'], 'redundancy': r['red'],
+                'unique1': r['u1'], 'unique2': r['u2'], 'mi_joint': r['mi']}
+
+    if timestep is not None:
+        return _wrap(_pid_at_t(activations[:, timestep].astype(np.float64)))
+
+    results = {k: [] for k in ['syn','red','u1','u2','mi']}
+    for t in range(T):
+        r = _pid_at_t(activations[:, t].astype(np.float64))
+        for k in results:
+            results[k].append(r[k])
+    return {'synergy':    np.array(results['syn']),
+            'redundancy': np.array(results['red']),
+            'unique1':    np.array(results['u1']),
+            'unique2':    np.array(results['u2']),
+            'mi_joint':   np.array(results['mi'])}
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Dataset helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def resolve_dataset_paths(data_dir=None, train_path=None, val_path=None, test_path=None):
+    if data_dir is not None:
+        train_path = train_path or os.path.join(data_dir, 'train.npz')
+        val_path   = val_path or os.path.join(data_dir, 'val.npz')
+        test_path  = test_path or os.path.join(data_dir, 'test_uniform.npz')
+
+    resolved = {
+        'train_path': train_path,
+        'val_path': val_path,
+        'test_path': test_path,
+    }
+    for name, path in resolved.items():
+        if path is not None and not os.path.exists(path):
+            raise FileNotFoundError(f"Dataset file not found: {path}")
+    return resolved
+
+
+def build_npz_loader(npz_path, batch_size, shuffle=False):
+    if npz_path is None:
+        return None
+    return load_mante_data(npz_path, batch_size=batch_size, shuffle=shuffle)
+
+
+def load_npz_split_as_tensors(npz_path, device):
+    if npz_path is None:
+        return None, None, None, None
+
+    data = np.load(npz_path)
+    obs = data['observations'].astype(np.float32)
+    labels = data['labels'].astype(np.int64)
+    cohs = np.array(data['coherences'], dtype=np.float32)
+
+    ctx_key = 'contexts' if 'contexts' in data else 'contexts'
+    ctxs = np.array(data[ctx_key], dtype=np.int32)
+
+    return (
+        torch.from_numpy(obs).to(device),
+        torch.from_numpy(labels).to(device),
+        cohs,
+        ctxs,
+    )
+
+
+def _fallback_dataset_generator(task, dt=DT, batch_size=DEFAULT_BATCH_SIZE,
+                                 seq_len=120):
+    
+    env = ngym.make(task, dt=dt, timing={'delay': 0}, use_expl_context=True)
+    env.reset(seed=DEFAULT_SEED)
+    print(type(env))
+    print(env.observation_space.shape)
+
+    def _gen():
+        obs_b, gt_b = [], []
+        for _ in range(batch_size):
+            env.unwrapped.new_trial()
+            ob = env.unwrapped.ob
+            gt = env.unwrapped.gt
+            T  = ob.shape[0]
+            t  = min(T, seq_len)
+            ob_p = np.zeros((seq_len, ob.shape[1]), dtype=np.float32)
+            gt_p = np.zeros((seq_len,), dtype=np.int64)
+            ob_p[:t] = ob[:t]
+            gt_p[:t] = gt[:t]
+            if t < seq_len:
+                ob_p[t:] = ob[-1]
+                gt_p[t:] = gt[-1]
+            obs_b.append(ob_p)
+            gt_b.append(gt_p)
+        return np.stack(obs_b, axis=1), np.stack(gt_b, axis=1)  # (T,B,F),(T,B)
+
+    return _gen
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Select implementations
+# ──────────────────────────────────────────────────────────────────────────────
+
+CTRNNImpl    = CTRNN                    if _USING_PROJECT_MODULES else _FallbackCTRNN
+pid_fn       = gaussian_pid_rnn         if _USING_PROJECT_MODULES else _fallback_gaussian_pid
+make_dataset = create_dataset_generator if _USING_PROJECT_MODULES else _fallback_dataset_generator
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Wrapped CTRNN — uniform (outputs, hidden_states) interface
+# ──────────────────────────────────────────────────────────────────────────────
+
+class WrappedCTRNN(nn.Module):
+    def __init__(self, input_dim, hidden_size):
+        super().__init__()
+        if _USING_PROJECT_MODULES:
+            self.model = CTRNNImpl(input_size=input_dim,
+                                   hidden_size=hidden_size,
+                                   output_size=OUTPUT_DIM)
+        else:
+            self.model = CTRNNImpl(input_size=input_dim,
+                                   hidden_size=hidden_size,
+                                   output_size=OUTPUT_DIM, dt=DT)
+
+    def forward(self, x):
+        if _USING_PROJECT_MODULES:
+            outputs, _, hidden_states = self.model(x, return_dynamics=True)
+        else:
+            outputs, hidden_states = self.model(x)
+        return outputs, hidden_states
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Loss — only penalise decision timesteps
+# ──────────────────────────────────────────────────────────────────────────────
+
+def masked_cross_entropy(outputs, targets):
+    mask = targets != 0
+    if mask.sum() == 0:
+        return torch.tensor(0.0, requires_grad=True, device=outputs.device)
+    return F.cross_entropy(outputs[mask], targets[mask])
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Training
+# ──────────────────────────────────────────────────────────────────────────────
+
+def train_ctrnn(hidden_size, n_batches, device, weights_dir,
+                n_epochs=5, seed=DEFAULT_SEED,
+                train_loader=None, val_loader=None):
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+
+    model     = WrappedCTRNN(INPUT_DIM, hidden_size).to(device)
+    optimizer = optim.Adam(model.parameters(), lr=DEFAULT_LR)
+
+    if train_loader is None:
+        if _USING_PROJECT_MODULES:
+            dataset = make_dataset(CONFIG)
+        else:
+            dataset = make_dataset(TASK, dt=DT)
+
+    print(f"\n  Training CTRNN  hidden={hidden_size}  epochs={n_epochs}")
+    losses = []
+
+    for epoch in range(n_epochs):
+        model.train()
+        epoch_losses = []
+
+        if train_loader is not None:
+            for batch_idx, batch in enumerate(train_loader):
+                inputs, targets, _, _, _ = batch
+                inputs = inputs.to(device)
+                targets = targets.to(device)
+
+                optimizer.zero_grad()
+                outputs, _ = model(inputs)
+                loss = masked_cross_entropy(outputs, targets)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                optimizer.step()
+
+                loss_val = loss.item()
+                epoch_losses.append(loss_val)
+                losses.append(loss_val)
+
+                if (batch_idx + 1) % 200 == 0 or (batch_idx + 1) == len(train_loader):
+                    print(f"    epoch {epoch+1}/{n_epochs} batch {batch_idx+1:>4}/{len(train_loader)}  "
+                          f"loss={np.mean(losses[-50:]):.4f}")
+        else:
+            for i in range(n_batches):
+                inputs_np, targets_np = dataset()
+                inputs  = torch.from_numpy(inputs_np).float().transpose(0, 1).to(device)
+                targets = torch.from_numpy(targets_np).long().transpose(0, 1).to(device)
+
+                optimizer.zero_grad()
+                outputs, _ = model(inputs)
+                loss = masked_cross_entropy(outputs, targets)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                optimizer.step()
+
+                loss_val = loss.item()
+                epoch_losses.append(loss_val)
+                losses.append(loss_val)
+                batch_num = epoch * n_batches + i + 1
+                if (i + 1) % 200 == 0 or (i + 1) == n_batches:
+                    print(f"    epoch {epoch+1}/{n_epochs} batch {i+1:>4}/{n_batches}  "
+                          f"loss={np.mean(losses[-50:]):.4f}")
+
+        if val_loader is not None:
+            model.eval()
+            val_losses = []
+            with torch.no_grad():
+                for inputs, targets, _, _, _ in val_loader:
+                    inputs = inputs.to(device)
+                    targets = targets.to(device)
+                    outputs, _ = model(inputs)
+                    val_loss = masked_cross_entropy(outputs, targets)
+                    val_losses.append(val_loss.item())
+            print(f"    epoch {epoch+1}/{n_epochs} validation_loss={np.mean(val_losses):.4f}")
+
+    save_path = os.path.join(weights_dir, f'ctrnn_cdm_h{hidden_size}.pt')
+    torch.save(model.state_dict(), save_path)
+    print(f"    Saved → {save_path}")
+    return model, losses
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Test batch — fixed timing, collect rich metadata
+# ──────────────────────────────────────────────────────────────────────────────
+
+def get_test_batch(n_trials, device, config, seed=DEFAULT_SEED):
+    """
+    Returns
+    -------
+    inputs          : (B, T, 7) tensor on device
+    targets         : (B, T) tensor on device
+    signed_coh_rel  : (B,) np array
+    context_labels  : (B,) np array
+    """
+
+    # Create environment using same config as training
+    dataset = create_dataset_generator(config)
+    env = dataset.env
+
+    env.reset(seed=seed)
+
+    obs_l, gt_l, coh_l, ctx_l = [], [], [], []
+
+    for _ in range(n_trials):
+
+        env.unwrapped.new_trial()
+
+        ob = env.unwrapped.ob.astype(np.float32)
+        gt = env.unwrapped.gt.astype(np.int64)
+        trial = env.unwrapped.trial
+
+        context = int(trial["context"])
+        ground_truth = int(trial["ground_truth"])
+
+        # Verify once with:
+        # print(trial.keys())
+
+        coh_0 = float(trial["coh_1"])
+        coh_1 = float(trial["coh_2"])
+
+        # Relevant modality depends on context
+        rel_coh = coh_0 if context == 0 else coh_1
+
+        sign = 1 if ground_truth == 1 else -1
+        signed_coh = sign * rel_coh
+
+        obs_l.append(ob)
+        gt_l.append(gt)
+        coh_l.append(signed_coh)
+        ctx_l.append(context)
+
+    inputs = torch.tensor(
+        np.stack(obs_l),
+        dtype=torch.float32,
+        device=device,
+    )
+
+    targets = torch.tensor(
+        np.stack(gt_l),
+        dtype=torch.long,
+        device=device,
+    )
+
+    cohs = np.array(coh_l, dtype=np.float32)
+    ctxs = np.array(ctx_l, dtype=np.int32)
+    print("Current cohs:", env.unwrapped.cohs)
+    sampled = []
+
+    for _ in range(100):
+        env.unwrapped.new_trial()
+        sampled.append(env.unwrapped.trial["coh_1"])
+
+    print("Unique sampled coherences:")
+    print(sorted(set(sampled))[:10])
+    return inputs, targets, cohs, ctxs
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Stim-end detection (shared helper)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def find_stim_end(inputs_np):
+    """
+    inputs_np : (B, T, 7)
+    Returns median timestep of last stimulus step across trials.
+    Stimulus period = fixation channel (ch0) is 0.
+    """
+    fix_ch    = inputs_np[:, :, 0]  # (B, T)
+    stim_ends = np.array([
+        np.where(fix_ch[b] < 0.5)[0][-1]
+        if (fix_ch[b] < 0.5).any() else 0
+        for b in range(fix_ch.shape[0])
+    ])
+    return int(np.median(stim_ends))
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# PID analysis — run for two targets
+# ──────────────────────────────────────────────────────────────────────────────
+
+def run_pid(model, inputs, targets, cohs, ctxs, n_bipartitions, device):
+    """
+    Runs time-resolved Gaussian PID with two different targets:
+      'coherence' — signed coherence of the relevant modality
+      'context'   — which rule is active (0 or 1)
+
+    Returns dict with keys 'coherence' and 'context', each containing
+    the standard PID atom arrays plus stim_end and seq_len.
+    """
+    model.eval()
+    with torch.no_grad():
+        _, h_seq = model(inputs)               # (B, T, H)
+    acts       = h_seq.cpu().numpy()           # (B, T, H)
+    inputs_np  = inputs.cpu().numpy()
+    stim_end   = find_stim_end(inputs_np)
+
+    results = {}
+
+    for target_name, target_vals in [('coherence', cohs.astype(float)),
+                                      ('context',   ctxs.astype(float))]:
+        print(f"    PID target: {target_name}  "
+              f"| H={acts.shape[2]}  T={acts.shape[1]}")
+
+        pid_out = pid_fn(
+            activations=acts,
+            target=target_vals,
+            timestep=None,
+            n_bipartitions=n_bipartitions,
+            seed=DEFAULT_SEED,
+            regularization=1e-5,
+        )
+
+        results[target_name] = {
+            'synergy':    np.array(pid_out['synergy']),
+            'redundancy': np.array(pid_out['redundancy']),
+            'unique1':    np.array(pid_out['unique1']),
+            'unique2':    np.array(pid_out['unique2']),
+            'mi_joint':   np.array(pid_out['mi_joint']),
+            'stim_end':   stim_end,
+            'seq_len':    acts.shape[1],
+        }
+
+        tend = stim_end
+        print(f"      Stim-end t={tend} | "
+              f"Syn={results[target_name]['synergy'][tend]:.4f}b | "
+              f"Red={results[target_name]['redundancy'][tend]:.4f}b")
+
+    results['activations'] = acts  # (B, T, H)
+    return results
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Plot — per hidden size (loss + two PID panels)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def plot_timeseries(pid_results, hidden_size, losses, save_path):
+    """
+    Three-panel figure:
+      Left  : training loss curve
+      Middle: PID with coherence as target
+      Right : PID with context as target
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(18, 5),
+                             gridspec_kw={'width_ratios': [1, 2, 2]})
+    fig.suptitle(
+        f'CTRNN  hidden={hidden_size}  —  ContextDecisionMaking-v0',
+        fontsize=13, fontweight='bold', y=1.01
+    )
+
+    # ── Loss ──
+    ax = axes[0]
+    smooth = np.convolve(losses, np.ones(20) / 20, mode='valid')
+    ax.plot(losses, alpha=0.2, color='steelblue', lw=0.8)
+    ax.plot(np.arange(19, len(losses)), smooth,
+            color='steelblue', lw=2, label='Loss (20-batch avg)')
+    ax.set_xlabel('Training batch')
+    ax.set_ylabel('Masked CE loss')
+    ax.set_title('Training loss')
+    ax.legend(fontsize=8)
+    ax.grid(alpha=0.3)
+
+    # ── PID panels ──
+    panel_cfg = [
+        ('coherence', 'PID — Target: signed coherence\n(relevant modality)'),
+        ('context',   'PID — Target: context label\n(which rule is active)'),
+    ]
+
+    for ax, (tgt_name, title) in zip(axes[1:], panel_cfg):
+        pid  = pid_results[tgt_name]
+        T    = pid['seq_len']
+        t    = np.arange(T)
+        tend = pid['stim_end']
+
+        ax.plot(t, pid['mi_joint'],   label='Total MI',   color=PALETTE['mi_joint'],   lw=2.5, ls=':')
+        ax.plot(t, pid['synergy'],    label='Synergy',    color=PALETTE['synergy'],    lw=2.5)
+        ax.plot(t, pid['redundancy'], label='Redundancy', color=PALETTE['redundancy'], lw=2.5)
+        ax.plot(t, pid['unique1'],    label='Unique 1',   color=PALETTE['unique1'],    lw=1.5, alpha=0.8)
+        ax.plot(t, pid['unique2'],    label='Unique 2',   color=PALETTE['unique2'],    lw=1.5, alpha=0.8)
+
+        ax.axvline(tend, color=PALETTE['stim_end'], ls='--', lw=1.5,
+                   label=f'Stim end (t={tend})')
+        ax.axvspan(0, tend, color='gray', alpha=0.08)
+
+        ax.set_title(title, fontsize=10)
+        ax.set_xlabel(f'Timestep (dt={DT}ms)')
+        ax.set_ylabel('Information (bits)')
+        ax.legend(fontsize=8, loc='upper left')
+        ax.grid(alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"    Saved → {save_path}")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Plot — comparison summary across all hidden sizes
+# ──────────────────────────────────────────────────────────────────────────────
+
+def plot_comparison(all_results, save_path):
+    hidden_sizes = sorted(all_results.keys(), reverse=True)
+    n    = len(hidden_sizes)
+    cmap = plt.cm.viridis(np.linspace(0.15, 0.85, n))
+
+    fig = plt.figure(figsize=(18, 16))
+    gs  = gridspec.GridSpec(4, 3, figure=fig, hspace=0.5, wspace=0.35)
+
+    # Row 0: synergy over time — coherence target (left) and context target (right)
+    ax_syn_coh = fig.add_subplot(gs[0, :2])
+    ax_syn_ctx = fig.add_subplot(gs[0, 2])
+
+    # Row 1: redundancy over time — coherence (left) and context (right)
+    ax_red_coh = fig.add_subplot(gs[1, :2])
+    ax_red_ctx = fig.add_subplot(gs[1, 2])
+
+    # Row 2: bar charts at stim-end
+    ax_bar_coh = fig.add_subplot(gs[2, 0])
+    ax_bar_ctx = fig.add_subplot(gs[2, 1])
+    ax_ratio   = fig.add_subplot(gs[2, 2])
+
+    # Row 3: scalar summaries
+    ax_loss    = fig.add_subplot(gs[3, 0])
+    ax_syn_end = fig.add_subplot(gs[3, 1])
+    ax_red_end = fig.add_subplot(gs[3, 2])
+
+    fig.suptitle(
+        'CTRNN PID Sweep — ContextDecisionMaking-v0\n'
+        'Left/Middle: coherence target  |  Right: context target',
+        fontsize=13, fontweight='bold'
+    )
+
+    stim_end_ref = all_results[hidden_sizes[0]]['coherence']['stim_end']
+
+    # ── Synergy over time ──
+    for panel, tgt in [(ax_syn_coh, 'coherence'), (ax_syn_ctx, 'context')]:
+        for i, h in enumerate(hidden_sizes):
+            pid = all_results[h][tgt]
+            panel.plot(np.arange(pid['seq_len']), pid['synergy'],
+                       color=cmap[i], lw=2, label=f'H={h}')
+        panel.axvline(stim_end_ref, color='red', ls='--', lw=1, alpha=0.6)
+        panel.set_title(f'Synergy over time — target: {tgt}')
+        panel.set_ylabel('Synergy (bits)')
+        panel.set_xlabel(f'Timestep (dt={DT}ms)')
+        panel.legend(ncol=n, fontsize=7, loc='upper left')
+        panel.grid(alpha=0.25)
+
+    # ── Redundancy over time ──
+    for panel, tgt in [(ax_red_coh, 'coherence'), (ax_red_ctx, 'context')]:
+        for i, h in enumerate(hidden_sizes):
+            pid = all_results[h][tgt]
+            panel.plot(np.arange(pid['seq_len']), pid['redundancy'],
+                       color=cmap[i], lw=2, label=f'H={h}')
+        panel.axvline(stim_end_ref, color='red', ls='--', lw=1, alpha=0.6)
+        panel.set_title(f'Redundancy over time — target: {tgt}')
+        panel.set_ylabel('Redundancy (bits)')
+        panel.set_xlabel(f'Timestep (dt={DT}ms)')
+        panel.legend(ncol=n, fontsize=7, loc='upper left')
+        panel.grid(alpha=0.25)
+
+    # ── Bar charts at stim-end ──
+    atoms       = ['synergy', 'redundancy', 'unique1', 'unique2']
+    atom_colors = [PALETTE['synergy'], PALETTE['redundancy'],
+                   PALETTE['unique1'], PALETTE['unique2']]
+    x      = np.arange(len(hidden_sizes))
+    width  = 0.18
+    offs   = np.linspace(-0.27, 0.27, 4)
+
+    for ax_bar, tgt in [(ax_bar_coh, 'coherence'), (ax_bar_ctx, 'context')]:
+        for j, (atom, color) in enumerate(zip(atoms, atom_colors)):
+            vals = [all_results[h][tgt][atom][all_results[h][tgt]['stim_end']]
+                    for h in hidden_sizes]
+            ax_bar.bar(x + offs[j], vals, width,
+                       label=atom.capitalize(), color=color, alpha=0.85)
+        ax_bar.set_xticks(x)
+        ax_bar.set_xticklabels([f'H={h}' for h in hidden_sizes], fontsize=8)
+        ax_bar.set_title(f'PID atoms at stim-end — target: {tgt}')
+        ax_bar.set_ylabel('Information (bits)')
+        ax_bar.legend(fontsize=7)
+        ax_bar.grid(axis='y', alpha=0.3)
+
+    # ── Synergy ratio: Syn/(Syn+Red) at stim-end for both targets ──
+    x2 = np.arange(len(hidden_sizes))
+    w2 = 0.35
+    for j, (tgt, color) in enumerate([('coherence', PALETTE['synergy']),
+                                       ('context',   PALETTE['context0'])]):
+        ratios = []
+        for h in hidden_sizes:
+            pid  = all_results[h][tgt]
+            tend = pid['stim_end']
+            syn  = pid['synergy'][tend]
+            red  = pid['redundancy'][tend]
+            denom = syn + red
+            ratios.append(syn / denom if denom > 1e-10 else 0.0)
+        ax_ratio.bar(x2 + (j - 0.5) * w2, ratios, w2,
+                     label=f'target: {tgt}', color=color, alpha=0.8)
+    ax_ratio.axhline(0.5, color='gray', ls='--', lw=1)
+    ax_ratio.set_xticks(x2)
+    ax_ratio.set_xticklabels([f'H={h}' for h in hidden_sizes], fontsize=8)
+    ax_ratio.set_ylim(0, 1)
+    ax_ratio.set_title('Synergy ratio at stim-end\n[Syn / (Syn+Red)]')
+    ax_ratio.set_ylabel('Synergy ratio')
+    ax_ratio.legend(fontsize=7)
+    ax_ratio.grid(axis='y', alpha=0.3)
+
+    # ── Final loss vs hidden size ──
+    final_losses = [np.mean(all_results[h]['losses'][-50:])
+                    for h in hidden_sizes]
+    ax_loss.plot([str(h) for h in hidden_sizes], final_losses,
+                 'o-', color='steelblue', lw=2, ms=8)
+    ax_loss.set_title('Final training loss vs hidden size')
+    ax_loss.set_xlabel('Hidden size')
+    ax_loss.set_ylabel('Loss (last 50 batches avg)')
+    ax_loss.grid(alpha=0.3)
+
+    # ── Synergy at stim-end vs hidden size (both targets) ──
+    for tgt, color, marker in [('coherence', PALETTE['synergy'],    'o'),
+                                ('context',   PALETTE['context0'],   's')]:
+        vals = [all_results[h][tgt]['synergy'][all_results[h][tgt]['stim_end']]
+                for h in hidden_sizes]
+        ax_syn_end.plot([str(h) for h in hidden_sizes], vals,
+                        f'{marker}-', color=color, lw=2, ms=8, label=f'target: {tgt}')
+    ax_syn_end.set_title('Synergy at stim-end vs hidden size')
+    ax_syn_end.set_xlabel('Hidden size')
+    ax_syn_end.set_ylabel('Synergy (bits)')
+    ax_syn_end.legend(fontsize=8)
+    ax_syn_end.grid(alpha=0.3)
+
+    # ── Redundancy at stim-end vs hidden size (both targets) ──
+    for tgt, color, marker in [('coherence', PALETTE['redundancy'],  'o'),
+                                ('context',   PALETTE['context1'],    's')]:
+        vals = [all_results[h][tgt]['redundancy'][all_results[h][tgt]['stim_end']]
+                for h in hidden_sizes]
+        ax_red_end.plot([str(h) for h in hidden_sizes], vals,
+                        f'{marker}-', color=color, lw=2, ms=8, label=f'target: {tgt}')
+    ax_red_end.set_title('Redundancy at stim-end vs hidden size')
+    ax_red_end.set_xlabel('Hidden size')
+    ax_red_end.set_ylabel('Redundancy (bits)')
+    ax_red_end.legend(fontsize=8)
+    ax_red_end.grid(alpha=0.3)
+
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"\nComparison figure saved → {save_path}")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Main
+# ──────────────────────────────────────────────────────────────────────────────
+
+def main(hidden_sizes, n_train_batches, n_test_trials, batch_size=DEFAULT_BATCH_SIZE,
+         data_dir=None, train_path=None, val_path=None, test_path=None, n_epochs=1):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Device      : {device}")
+    print(f"Task        : {TASK}")
+    print(f"Input dim   : {INPUT_DIM}  (fixation + 4 stim channels + 2 context channels)")
+    hidden_sizes = sorted(hidden_sizes)
+    print(f"Hidden sizes: {hidden_sizes}")
+    print(f"Train batches per model: {n_train_batches}")
+    print(f"Test trials for PID    : {n_test_trials}")
+    print(f"Eval timing (fixed)    : {EVAL_TIMING}")
+
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    weights_dir = os.path.join(RESULTS_DIR, 'weights')
+    os.makedirs(weights_dir, exist_ok=True)
+
+    # One shared test batch for all models
+    if test_path is not None:
+        print("\nLoading fixed test split from NPZ...")
+        inputs, targets, cohs, ctxs = load_npz_split_as_tensors(test_path, device)
+        print(f"  inputs : {tuple(inputs.shape)}")
+        print(f"  cohs   : range [{cohs.min():.1f}, {cohs.max():.1f}]  "
+              f"std={cohs.std():.2f}")
+        print(f"  context: {np.bincount(ctxs)}  (count per context label)")
+    else:
+        print("\nGenerating fixed test batch...")
+        inputs, targets, cohs, ctxs = get_test_batch(
+        n_test_trials,
+        device,
+        CONFIG,
+        seed=DEFAULT_SEED
+        )
+        print(f"  inputs : {tuple(inputs.shape)}")
+        print(f"  cohs   : range [{cohs.min():.1f}, {cohs.max():.1f}]  "
+              f"std={cohs.std():.2f}")
+        print(f"  context: {np.bincount(ctxs)}  (count per context label)")
+
+    all_results = {}
+
+    for h in hidden_sizes:
+        print(f"\n{'='*60}")
+        print(f"  Hidden size = {h}")
+        print(f"{'='*60}")
+
+        train_loader = build_npz_loader(train_path, batch_size=batch_size, shuffle=True) if train_path is not None else None
+        val_loader   = build_npz_loader(val_path, batch_size=batch_size, shuffle=False) if val_path is not None else None
+
+        model, losses = train_ctrnn(
+            h,
+            n_train_batches,
+            device,
+            weights_dir,
+            n_epochs=n_epochs,
+            train_loader=train_loader,
+            val_loader=val_loader,
+        )
+
+        n_bipartitions = 2 * h
+        print(f"  Running PID (n_bipartitions={n_bipartitions})...")
+        pid_data = run_pid(model, inputs, targets, cohs, ctxs,
+                           n_bipartitions, device)
+
+        all_results[h] = {**pid_data, 'losses': losses}
+
+        ts_path = os.path.join(RESULTS_DIR, f'pid_timeseries_h{h}.png')
+        plot_timeseries(pid_data, h, losses, ts_path)
+
+    # Comparison summary
+    comp_path = os.path.join(RESULTS_DIR, 'comparison_summary.png')
+    plot_comparison(all_results, comp_path)
+
+    # Save raw arrays
+    npz_path = os.path.join(RESULTS_DIR, 'sweep_results.npz')
+    save_dict = {}
+    for h, r in all_results.items():
+        for tgt in ('coherence', 'context'):
+            for atom in ('synergy', 'redundancy', 'unique1', 'unique2', 'mi_joint'):
+                save_dict[f'h{h}_{tgt}_{atom}'] = r[tgt][atom]
+            save_dict[f'h{h}_{tgt}_stim_end'] = np.array(r[tgt]['stim_end'])
+        save_dict[f'h{h}_losses'] = np.array(r['losses'])
+        save_dict[f'h{h}_activations'] = r['activations']  # (B, T, H)
+    np.savez_compressed(npz_path, **save_dict)
+    print(f"Raw results → {npz_path}")
+    print("\nDone.")
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(
+        description='CTRNN PID sweep — ContextDecisionMaking-v0')
+    p.add_argument('--hidden_sizes',    nargs='+', type=int,
+                   default=DEFAULT_HIDDEN_SIZES)
+    p.add_argument('--n_train_batches', type=int, default=DEFAULT_N_Batches)
+    p.add_argument('--n_test_trials',   type=int, default=DEFAULT_N_TEST)
+    p.add_argument('--batch_size',      type=int, default=DEFAULT_BATCH_SIZE)
+    p.add_argument('--n_epochs', type=int, default=Default_N_EPOCHS,
+                   help='Number of training epochs per model')
+    p.add_argument('--train_path', type=str, default=None,
+                   help='Path to NPZ file for training data (optional)')
+    p.add_argument('--val_path', type=str, default=None,
+                   help='Path to NPZ file for validation data (optional)')
+    p.add_argument('--test_path', type=str, default=None,
+                   help='Path to NPZ file for test data (optional)')
+    args = p.parse_args()
+
+    main(
+        hidden_sizes    = args.hidden_sizes,
+        n_train_batches = args.n_train_batches,
+        n_test_trials   = args.n_test_trials,
+        batch_size      = args.batch_size,
+        train_path      = args.train_path,
+        val_path        = args.val_path,
+        test_path       = args.test_path,
+        n_epochs        = args.n_epochs,
+    )
\ No newline at end of file
diff --git a/size_comparison/CDM/results/pid_barplot_hidden_size.png b/size_comparison/CDM/results/pid_barplot_hidden_size.png
new file mode 100644
index 0000000..a5fc0d6
Binary files /dev/null and b/size_comparison/CDM/results/pid_barplot_hidden_size.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/comparison_summary.png b/size_comparison/CDM/results/pid_sweep_cdm/comparison_summary.png
new file mode 100644
index 0000000..cba8f41
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/comparison_summary.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h100.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h100.png
new file mode 100644
index 0000000..357f2d8
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h100.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h12.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h12.png
new file mode 100644
index 0000000..ec633d5
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h12.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h150.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h150.png
new file mode 100644
index 0000000..b218bc3
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h150.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h16.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h16.png
new file mode 100644
index 0000000..106fb70
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h16.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h2.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h2.png
new file mode 100644
index 0000000..189b5e6
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h2.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h20.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h20.png
new file mode 100644
index 0000000..3081c54
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h20.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h200.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h200.png
new file mode 100644
index 0000000..49e428e
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h200.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h4.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h4.png
new file mode 100644
index 0000000..ef5c021
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h4.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h40.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h40.png
new file mode 100644
index 0000000..3888cbe
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h40.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h60.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h60.png
new file mode 100644
index 0000000..6586066
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h60.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h8.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h8.png
new file mode 100644
index 0000000..7808503
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h8.png differ
diff --git a/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h80.png b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h80.png
new file mode 100644
index 0000000..fde013e
Binary files /dev/null and b/size_comparison/CDM/results/pid_sweep_cdm/pid_timeseries_h80.png differ
diff --git a/size_comparison/CDM/results/pid_vs_hidden_size.png b/size_comparison/CDM/results/pid_vs_hidden_size.png
new file mode 100644
index 0000000..6ac6e39
Binary files /dev/null and b/size_comparison/CDM/results/pid_vs_hidden_size.png differ
diff --git a/size_comparison/CDM/results/plot_pid.ipynb b/size_comparison/CDM/results/plot_pid.ipynb
new file mode 100644
index 0000000..a623037
--- /dev/null
+++ b/size_comparison/CDM/results/plot_pid.ipynb
@@ -0,0 +1,500 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4a282ee0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keys in the NPZ file: ['h2_coherence_synergy', 'h2_coherence_redundancy', 'h2_coherence_unique1', 'h2_coherence_unique2', 'h2_coherence_mi_joint', 'h2_coherence_stim_end', 'h2_context_synergy', 'h2_context_redundancy', 'h2_context_unique1', 'h2_context_unique2', 'h2_context_mi_joint', 'h2_context_stim_end', 'h2_losses', 'h2_activations', 'h4_coherence_synergy', 'h4_coherence_redundancy', 'h4_coherence_unique1', 'h4_coherence_unique2', 'h4_coherence_mi_joint', 'h4_coherence_stim_end', 'h4_context_synergy', 'h4_context_redundancy', 'h4_context_unique1', 'h4_context_unique2', 'h4_context_mi_joint', 'h4_context_stim_end', 'h4_losses', 'h4_activations', 'h8_coherence_synergy', 'h8_coherence_redundancy', 'h8_coherence_unique1', 'h8_coherence_unique2', 'h8_coherence_mi_joint', 'h8_coherence_stim_end', 'h8_context_synergy', 'h8_context_redundancy', 'h8_context_unique1', 'h8_context_unique2', 'h8_context_mi_joint', 'h8_context_stim_end', 'h8_losses', 'h8_activations', 'h12_coherence_synergy', 'h12_coherence_redundancy', 'h12_coherence_unique1', 'h12_coherence_unique2', 'h12_coherence_mi_joint', 'h12_coherence_stim_end', 'h12_context_synergy', 'h12_context_redundancy', 'h12_context_unique1', 'h12_context_unique2', 'h12_context_mi_joint', 'h12_context_stim_end', 'h12_losses', 'h12_activations', 'h16_coherence_synergy', 'h16_coherence_redundancy', 'h16_coherence_unique1', 'h16_coherence_unique2', 'h16_coherence_mi_joint', 'h16_coherence_stim_end', 'h16_context_synergy', 'h16_context_redundancy', 'h16_context_unique1', 'h16_context_unique2', 'h16_context_mi_joint', 'h16_context_stim_end', 'h16_losses', 'h16_activations', 'h20_coherence_synergy', 'h20_coherence_redundancy', 'h20_coherence_unique1', 'h20_coherence_unique2', 'h20_coherence_mi_joint', 'h20_coherence_stim_end', 'h20_context_synergy', 'h20_context_redundancy', 'h20_context_unique1', 'h20_context_unique2', 'h20_context_mi_joint', 'h20_context_stim_end', 'h20_losses', 'h20_activations', 'h40_coherence_synergy', 'h40_coherence_redundancy', 'h40_coherence_unique1', 'h40_coherence_unique2', 'h40_coherence_mi_joint', 'h40_coherence_stim_end', 'h40_context_synergy', 'h40_context_redundancy', 'h40_context_unique1', 'h40_context_unique2', 'h40_context_mi_joint', 'h40_context_stim_end', 'h40_losses', 'h40_activations', 'h60_coherence_synergy', 'h60_coherence_redundancy', 'h60_coherence_unique1', 'h60_coherence_unique2', 'h60_coherence_mi_joint', 'h60_coherence_stim_end', 'h60_context_synergy', 'h60_context_redundancy', 'h60_context_unique1', 'h60_context_unique2', 'h60_context_mi_joint', 'h60_context_stim_end', 'h60_losses', 'h60_activations', 'h80_coherence_synergy', 'h80_coherence_redundancy', 'h80_coherence_unique1', 'h80_coherence_unique2', 'h80_coherence_mi_joint', 'h80_coherence_stim_end', 'h80_context_synergy', 'h80_context_redundancy', 'h80_context_unique1', 'h80_context_unique2', 'h80_context_mi_joint', 'h80_context_stim_end', 'h80_losses', 'h80_activations', 'h100_coherence_synergy', 'h100_coherence_redundancy', 'h100_coherence_unique1', 'h100_coherence_unique2', 'h100_coherence_mi_joint', 'h100_coherence_stim_end', 'h100_context_synergy', 'h100_context_redundancy', 'h100_context_unique1', 'h100_context_unique2', 'h100_context_mi_joint', 'h100_context_stim_end', 'h100_losses', 'h100_activations', 'h150_coherence_synergy', 'h150_coherence_redundancy', 'h150_coherence_unique1', 'h150_coherence_unique2', 'h150_coherence_mi_joint', 'h150_coherence_stim_end', 'h150_context_synergy', 'h150_context_redundancy', 'h150_context_unique1', 'h150_context_unique2', 'h150_context_mi_joint', 'h150_context_stim_end', 'h150_losses', 'h150_activations', 'h200_coherence_synergy', 'h200_coherence_redundancy', 'h200_coherence_unique1', 'h200_coherence_unique2', 'h200_coherence_mi_joint', 'h200_coherence_stim_end', 'h200_context_synergy', 'h200_context_redundancy', 'h200_context_unique1', 'h200_context_unique2', 'h200_context_mi_joint', 'h200_context_stim_end', 'h200_losses', 'h200_activations']\n",
+      "h2_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h2_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h2_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h2_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h2_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h2_coherence_stim_end: shape=(), dtype=int64\n",
+      "h2_context_synergy: shape=(115,), dtype=float64\n",
+      "h2_context_redundancy: shape=(115,), dtype=float64\n",
+      "h2_context_unique1: shape=(115,), dtype=float64\n",
+      "h2_context_unique2: shape=(115,), dtype=float64\n",
+      "h2_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h2_context_stim_end: shape=(), dtype=int64\n",
+      "h2_losses: shape=(7850,), dtype=float64\n",
+      "h2_activations: shape=(2000, 115, 2), dtype=float32\n",
+      "h4_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h4_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h4_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h4_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h4_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h4_coherence_stim_end: shape=(), dtype=int64\n",
+      "h4_context_synergy: shape=(115,), dtype=float64\n",
+      "h4_context_redundancy: shape=(115,), dtype=float64\n",
+      "h4_context_unique1: shape=(115,), dtype=float64\n",
+      "h4_context_unique2: shape=(115,), dtype=float64\n",
+      "h4_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h4_context_stim_end: shape=(), dtype=int64\n",
+      "h4_losses: shape=(7850,), dtype=float64\n",
+      "h4_activations: shape=(2000, 115, 4), dtype=float32\n",
+      "h8_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h8_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h8_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h8_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h8_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h8_coherence_stim_end: shape=(), dtype=int64\n",
+      "h8_context_synergy: shape=(115,), dtype=float64\n",
+      "h8_context_redundancy: shape=(115,), dtype=float64\n",
+      "h8_context_unique1: shape=(115,), dtype=float64\n",
+      "h8_context_unique2: shape=(115,), dtype=float64\n",
+      "h8_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h8_context_stim_end: shape=(), dtype=int64\n",
+      "h8_losses: shape=(7850,), dtype=float64\n",
+      "h8_activations: shape=(2000, 115, 8), dtype=float32\n",
+      "h12_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h12_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h12_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h12_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h12_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h12_coherence_stim_end: shape=(), dtype=int64\n",
+      "h12_context_synergy: shape=(115,), dtype=float64\n",
+      "h12_context_redundancy: shape=(115,), dtype=float64\n",
+      "h12_context_unique1: shape=(115,), dtype=float64\n",
+      "h12_context_unique2: shape=(115,), dtype=float64\n",
+      "h12_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h12_context_stim_end: shape=(), dtype=int64\n",
+      "h12_losses: shape=(7850,), dtype=float64\n",
+      "h12_activations: shape=(2000, 115, 12), dtype=float32\n",
+      "h16_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h16_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h16_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h16_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h16_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h16_coherence_stim_end: shape=(), dtype=int64\n",
+      "h16_context_synergy: shape=(115,), dtype=float64\n",
+      "h16_context_redundancy: shape=(115,), dtype=float64\n",
+      "h16_context_unique1: shape=(115,), dtype=float64\n",
+      "h16_context_unique2: shape=(115,), dtype=float64\n",
+      "h16_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h16_context_stim_end: shape=(), dtype=int64\n",
+      "h16_losses: shape=(7850,), dtype=float64\n",
+      "h16_activations: shape=(2000, 115, 16), dtype=float32\n",
+      "h20_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h20_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h20_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h20_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h20_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h20_coherence_stim_end: shape=(), dtype=int64\n",
+      "h20_context_synergy: shape=(115,), dtype=float64\n",
+      "h20_context_redundancy: shape=(115,), dtype=float64\n",
+      "h20_context_unique1: shape=(115,), dtype=float64\n",
+      "h20_context_unique2: shape=(115,), dtype=float64\n",
+      "h20_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h20_context_stim_end: shape=(), dtype=int64\n",
+      "h20_losses: shape=(7850,), dtype=float64\n",
+      "h20_activations: shape=(2000, 115, 20), dtype=float32\n",
+      "h40_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h40_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h40_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h40_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h40_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h40_coherence_stim_end: shape=(), dtype=int64\n",
+      "h40_context_synergy: shape=(115,), dtype=float64\n",
+      "h40_context_redundancy: shape=(115,), dtype=float64\n",
+      "h40_context_unique1: shape=(115,), dtype=float64\n",
+      "h40_context_unique2: shape=(115,), dtype=float64\n",
+      "h40_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h40_context_stim_end: shape=(), dtype=int64\n",
+      "h40_losses: shape=(7850,), dtype=float64\n",
+      "h40_activations: shape=(2000, 115, 40), dtype=float32\n",
+      "h60_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h60_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h60_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h60_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h60_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h60_coherence_stim_end: shape=(), dtype=int64\n",
+      "h60_context_synergy: shape=(115,), dtype=float64\n",
+      "h60_context_redundancy: shape=(115,), dtype=float64\n",
+      "h60_context_unique1: shape=(115,), dtype=float64\n",
+      "h60_context_unique2: shape=(115,), dtype=float64\n",
+      "h60_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h60_context_stim_end: shape=(), dtype=int64\n",
+      "h60_losses: shape=(7850,), dtype=float64\n",
+      "h60_activations: shape=(2000, 115, 60), dtype=float32\n",
+      "h80_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h80_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h80_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h80_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h80_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h80_coherence_stim_end: shape=(), dtype=int64\n",
+      "h80_context_synergy: shape=(115,), dtype=float64\n",
+      "h80_context_redundancy: shape=(115,), dtype=float64\n",
+      "h80_context_unique1: shape=(115,), dtype=float64\n",
+      "h80_context_unique2: shape=(115,), dtype=float64\n",
+      "h80_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h80_context_stim_end: shape=(), dtype=int64\n",
+      "h80_losses: shape=(7850,), dtype=float64\n",
+      "h80_activations: shape=(2000, 115, 80), dtype=float32\n",
+      "h100_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h100_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h100_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h100_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h100_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h100_coherence_stim_end: shape=(), dtype=int64\n",
+      "h100_context_synergy: shape=(115,), dtype=float64\n",
+      "h100_context_redundancy: shape=(115,), dtype=float64\n",
+      "h100_context_unique1: shape=(115,), dtype=float64\n",
+      "h100_context_unique2: shape=(115,), dtype=float64\n",
+      "h100_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h100_context_stim_end: shape=(), dtype=int64\n",
+      "h100_losses: shape=(7850,), dtype=float64\n",
+      "h100_activations: shape=(2000, 115, 100), dtype=float32\n",
+      "h150_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h150_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h150_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h150_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h150_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h150_coherence_stim_end: shape=(), dtype=int64\n",
+      "h150_context_synergy: shape=(115,), dtype=float64\n",
+      "h150_context_redundancy: shape=(115,), dtype=float64\n",
+      "h150_context_unique1: shape=(115,), dtype=float64\n",
+      "h150_context_unique2: shape=(115,), dtype=float64\n",
+      "h150_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h150_context_stim_end: shape=(), dtype=int64\n",
+      "h150_losses: shape=(7850,), dtype=float64\n",
+      "h150_activations: shape=(2000, 115, 150), dtype=float32\n",
+      "h200_coherence_synergy: shape=(115,), dtype=float64\n",
+      "h200_coherence_redundancy: shape=(115,), dtype=float64\n",
+      "h200_coherence_unique1: shape=(115,), dtype=float64\n",
+      "h200_coherence_unique2: shape=(115,), dtype=float64\n",
+      "h200_coherence_mi_joint: shape=(115,), dtype=float64\n",
+      "h200_coherence_stim_end: shape=(), dtype=int64\n",
+      "h200_context_synergy: shape=(115,), dtype=float64\n",
+      "h200_context_redundancy: shape=(115,), dtype=float64\n",
+      "h200_context_unique1: shape=(115,), dtype=float64\n",
+      "h200_context_unique2: shape=(115,), dtype=float64\n",
+      "h200_context_mi_joint: shape=(115,), dtype=float64\n",
+      "h200_context_stim_end: shape=(), dtype=int64\n",
+      "h200_losses: shape=(7850,), dtype=float64\n",
+      "h200_activations: shape=(2000, 115, 200), dtype=float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Load results\n",
+    "npz = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\github_neuroai\\results\\size_comparison\\CDM_results\\pid_sweep_cdm\\sweep_results.npz\",\n",
+    "    allow_pickle=True\n",
+    ")\n",
+    "\n",
+    "print(\"Keys in the NPZ file:\", npz.files)\n",
+    "\n",
+    "# Inspect contents\n",
+    "for key in npz.files:\n",
+    "    arr = npz[key]\n",
+    "    print(f\"{key}: shape={getattr(arr, 'shape', None)}, dtype={arr.dtype}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0ed36fa8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "npz = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\github_neuroai\\results\\size_comparison\\CDM_results\\pid_sweep_cdm\\sweep_results.npz\"\n",
+    ")\n",
+    "\n",
+    "h = 20\n",
+    "\n",
+    "plt.figure(figsize=(8,5))\n",
+    "\n",
+    "plt.plot(npz[f\"h{h}_coherence_synergy\"], label=\"Coherence Synergy\")\n",
+    "plt.plot(npz[f\"h{h}_coherence_redundancy\"], label=\"Coherence Redundancy\")\n",
+    "\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Information\")\n",
+    "plt.title(f\"PID Dynamics (Hidden Size = {h})\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d5e6f7a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAHqCAYAAACZcdjsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgetJREFUeJzt3Qm8zNX/x/H33Vz7vkvWJAlFCUlZI0UrSqTSqk2LdtpL/5Zfqza0IK20IYSUrUgpJTvZl6wXd5v/43PGXHOvu7rLLPf1fDzGzHznO9/vmTNfc7+f7zmfcyI8Ho9HAAAAAJALkbl5MwAAAAAQWAAAAADIE7RYAAAAAMg1AgsAAAAAuUZgAQAAACDXCCwAAAAA5BqBBQAAAIBcI7AAAAAAkGsEFgAAAAByjcACABDSrr76atWuXTvL9dasWaOIiAiNHj06z7YZSMOGDXOfBwCCBYEFAPhZsmSJLr30UtWqVUtFixZVjRo11KlTJ73yyivUUwHwnfz/3//9X6Yn09u3bw/b72Pfvn0aOnSoGjdurBIlSqhChQpq1qyZbr/9dm3cuDHQxQOADEVn/BIAFC5z5szRueeeq+OPP14DBw5U1apVtX79es2bN0//+9//dOuttwa6iEjH22+/reTk5LCom4SEBJ199tn6+++/1b9/f3fMWaDx559/auzYsbroootUvXp1t+5DDz2k++67L9BFBoAUBBYAcNiTTz6pMmXK6Oeff1bZsmVT1cvWrVuDtp7279/vrmwXVjExMQoXEyZM0K+//qoxY8boiiuuSPXawYMHFR8fn/I8Ojra3QAgWNAVCgAOW7lypU4++eSjggpTuXLllMft2rVT06ZN0623E088UV26dDmqW89bb72levXqKTY2VqeffroLXtKyq9TWDat8+fKuG1aLFi305ZdfplrH8gNsm7NmzdLNN9/synXcccelvP7aa6+pbt26KlasmM444wzNnj1b55xzjrsZu/ptQYh1q0nr33//VVRUlJ5++ukMr6Zb2QYMGHDUa3v27HFlvvvuu1OWWfcxq8/ixYurXLly7vPYVfe8ll4+xK5du9xyCxTt+7Sr/7Yso5N563Zk5bf7L774It31rFXkpZdecp/J1q1SpYpuuOEG/ffff6nWs7J0795dP/74o/sObF37Tt5///1sHYOmTZs2R71m2yldunSGORb2ee15ejdb1+fQoUOuq1X9+vXd8VizZk3de++9bjkA5AaXOgDgMMurmDt3rv744w93gpmRq666ynWVSrueBQv//POP66Liz06m9+7d605C7SRv+PDhuvjii7Vq1aqUq+3W1cVOJi2nw7q32Mn/xx9/rJ49e+qzzz5zXWD8WVBRqVIlPfLII67FwrzxxhsaNGiQ2rZtqzvvvNMFNvZ+O6n3BR8lS5Z02xo/frxeeOEFF0j4jBs3Th6PR1deeWW6n9vKau/9/PPP9eabb6pIkSKpTs7txLR3794p3ZNuu+02FyhZEGNX23///XfNnz//qCvx6YmLi0s3j8KWZ8U+Q48ePdyJ/Y033qiTTjrJBQsWXKT13Xff6ZJLLlGjRo1cQLVjxw4XOPkHaz72/VlgZ6/bZ1u9erVeffVV18Lw008/pWo5WbFihfvs1157rdvvyJEj3Yl/8+bNXWCS2TFoLAix4ygnydlWvo4dO6ZaNnnyZNf64QuMLTi68MILXd1cf/31rm4sr+jFF190x659jwBwzDwAAOe7777zREVFuVurVq089957r2fKlCme+Pj4VDW0a9cuT9GiRT1DhgxJtfy2227zlChRwrNv3z73fPXq1R77ma1QoYJn586dKetNnDjRLf/qq69SlnXo0MFzyimneA4ePJiyLDk52dO6dWvPCSeckLJs1KhR7r1nnXWWJzExMWX5oUOH3H5OP/10T0JCQsry0aNHu/XbtWuXssw+ky2bNGlSqvI3adIk1Xrp8b3Xv+ymW7dunrp166Y879Gjh+fkk0/O8ZHlq7Osbtu2bUt5T//+/T21atVKeT5hwgS3zvDhw1OWWV21bdvWLbc69GnWrJmnWrVq7jv1Pw5sPf9tzp492y0bM2ZMqvJOnjz5qOX2Plv2ww8/pCzbunWrJzY21nPXXXdl+vnj4uI8J554Ysr+r776as+7777r2bJly1HrDh061K2XkeXLl3vKlCnj6dSpU8qx8sEHH3giIyPd5/E3YsQIt62ffvop0/IBQGboCgUAh9noT9ZiYVd0f/vtN9eyYN2arBXBv0uSda+xK+K+K/wmKSnJtQJYC0HafIdevXq5VgMfa1Ew1mJhdu7cqe+//16XX365a9mwK/V2s6vntv/ly5drw4YNqbZpLSb+rQ2//PKLW9+W+/e7t9YH/30bu6ptCcB2JdvHWl+sRaFv376ZHg/t27dXxYoV3Wf1sa5AU6dOdZ/Tx7ofWdeq9Lp8ZYddTbdtpr1Za1FWvv32W1cHN910U8oyq6u0yfebNm3S4sWLXYuCfaf+x4G1YPj75JNP3Dr2mu/7sZu1QFgr0IwZM1Ktb+/3fc/GWpesm5zvO8+IdWGzVp177rnHPbcWEmv1qFatmit/drsrWSuWtS7Zd2/Hqe9Ysc9hrRQNGzZM9TnsezVpPwcA5ASBBQD4sfwH6+pjJ8sLFizQ/fff7072rVvL0qVLU9br16+f1q1b53IYzLRp07Rly5Z0T3xtlCl/vhN9X9986zZjAcrDDz/sTkD9b9YXPr3k8Tp16qR6vnbtWndv/eb92Ql22vyDyMhIF3BYtxdf1yILMqwP/2WXXZbp8WDbs65DEydOTDnJtfqy/Av/wGLIkCHuhNtyDE444QTdcsstrrtQdtl7LABKe7NchaxYXdiJuO3fn53Yp13Pt6+00q5rwd3u3btdl6K035HlraT9ftJ+577vPW0+RnosgLGg1rqy2e3dd9915bFuV48//riywwJMy9ewLmA2XK3/57Bud2k/Q4MGDYJ+kAIAwY8cCwBIh+UPWJBhNzvpsn71drXXd6JvLQmWvPvhhx+64UHt3oanTdvH3fi3LPjztXb4hkq1xGdf4ndaaQMGu7KdGxYYPffccy646NOnj8sDsYRj/yv3GbE8CsuxmDRpkmuhsVwQuwLun9BuV8WXLVumr7/+2vXztzyR119/3eWEPProowo19h1ZUOHfyuPPTs5z8p1nl+VcXHPNNa71wYIq2/8TTzyR6XtsaGRrpbBj0ua/SPs5TjnlFJdfkx5L5AaAY0VgAQBZsNGMfF1n/E8cLQnZuqo8++yz7gQ9bfek7PJdhbfk3/QCk+zwJf1a64fNxeGTmJjorno3adIk1fqWdH7qqae6E1VLVLbWl+xOAmiBlLUIWHeos846y3XjevDBB49az7qEWSuG3WyYVEtYtyF9rRXIWkfyi9XF9OnTXUuCf6uFBTpp1/NdxU8r7bo2ope1SlmCfW6DumNhrR1WBuuylhlrQbMA9Y477kg3Cd+2Yd38OnTowKzdAPIcXaEA4DDrX57eFWXrs59e9xjr9mRdW2w0HjuJzSo/ISN2JdyGg7VWAP/gxWfbtm3ZCn6sy4uNxmTBhI8FDhl1v7Hy26hINoSqvbdr167ZKq91pbKuYV999ZU++OADtz//blDG8j3StgBZ3oHVr3Wbyk/dunVzZbJRsnwsByZt4GTBkV3Rf++991w3Jx/L5fDv9mYs/8W2kV5XJNtXRkPZ5pSd9Kc3GpZ127IypT0G/dmxY+W0YM9ao9Jjr1u+jh0naR04cCBlhDEAOBa0WADAYZYcazkH1u3EuvbYVXabjduuzFueQtr5G+yKv1359yXEnnbaacdclzb/hJ0QWjcVa/mwVgzL2bBkckuCthPOzNiJu81VYJ/BEnHtBNJaKqxFxa5SpzdsqbW42PwF1g/fEp1zMtGcBRJ2om5dw6zM9vn9de7c2XUNsyv81mXsr7/+cjkC559/vkqVKqX8dMEFF7j92rC9VgcW0FgeiH/w4GNDzFqZrO6ty5El0vvm37Bg0X/uEgsgbX1L+LbPZ/VlrR32/Vv3Iwu2csuCGqtTG0DgzDPPdC0ulvBtw9VaTov/fBRp2RC4FoTad/rRRx+les1arOxmwaR1XbNheC2QtnqygMnmULHlU6ZMSWmhA4CcIrAAgMNsIjs7SbQWCpvQzgILS8K1OSNsToH0Js6zXAU7kcvOaEWZsZNfG9nJ8g8sGLAr/taSYcGL5SVkh81hYS0Czz//vOsOYzkPNpqVnXCm1/XITvjtBNk+b07L37p1a9cff/369Ue1Vhg7CbfWEuvLbyfo1t3KypF2jo/8YC0q9rmtO5DlGVhQZSfqVi9Wn/7OO+88951buayLlgVho0aNcsnpM2fOTLXuiBEj3ChQ1rL0wAMPpCTGW0tVehPaHQtLjLfBAqwlybqYWaBj3aAsCf6uu+5K1c0tLQsqLEgYPHjwUa9ZsGKBhdWNdduzeStsrgwLKm0CQwtkbb4RXxI3AByLCBtz9pjeCQBwV6p9k9GlNxJQoFmyriUWW35Det1frHXGJkiz3AwAAHKDHAsAOEZ2XcaGArVuMsEQVNjs1mmvFdlVabvqbTkc6fXJ/+abb3Ld2gIAgKErFADkkCW4Wlcb66NuV/ut20wwmDdvnms9sbkoLBl70aJFLvCxPBD/+SlWr17t5pR45513XJ6AdVsCACC3CCwAIIesL7slPlvOhfW1t/77wcD6+1vew8svv+xaKcqXL+9yQJ555hmX3O0za9Ysl4hurSw2IpIlWQMAkFvkWAAAAADINXIsAAAAAOQagQUAAACAXCt0ORY29OLGjRvdBE3pTRgFAAAAwMtGG7T5dapXr+7mwslMoQssLKiw5EYAAAAA2WMTotpkp5kpdIGFtVT4Kqd06dL5tp+EhAQ3c6rNamvDOYK6DDSOSeoy2HBMUpfBhmOSugw2CUFwPrlnzx53Ud53Dp2ZQhdY+Lo/WVCR34FF8eLF3T4ILKjLYMAxSV0GG45J6jLYcExSl8EmIYjOJ7OTQkDyNgAAAIBcI7AAAAAAkGsEFgAAAAByrdDlWAAAAByLpKQk1+cdWbN6io6O1sGDB129IXjr0XI3oqKi8mRbBBYAAABZjOO/efNm7dq1i3rKQZ1VrVrVjcLJvGHBX49ly5Z1+8ntPggsAAAAMuELKipXruxG6OFEOXsTEu/bt08lS5bMclI1BK4eLXCJi4vT1q1b3fNq1arlansEFgAAABmw7ie+oKJChQrUUw5OiOPj41W0aFECiyCvx2LFirl7Cy7sOM9NtyhCSAAAgAz4ciqspQIIV8UPH9+5zSEisAAAAMgC3Z8QziLyKH+DwAIAAABArhFYAAAAIEPDhg1Ts2bNqCFkicACyC+71ksbF2d8s9cBAIVGUrJHc1fu0MTFG9y9PS+IEa1uvfVW1a1bV7GxsapZs6YuuOACTZ8+Pd/3Hcp+++03XXjhhS6Z2RKna9eurV69eqWMnoT0MSoUkB8saHi1uZR4KON1omOlQQulsjX5DgAgzE3+Y5Me/WqpNu0+mLKsWpmiGnpBI53XOHdDfGZkzZo1atOmjZuj4LnnntMpp5ziknOnTJmiW265RX///bcCxYY5tRG3bPK3YLNt2zZ16NBB3bt3d3Vl9Wd1+eWXX2r//v0BLVt8fLyKFCmiYEWLBZAf4nZkHlQYe93WAwCEfVBx04eLUgUVZvPug265vZ4fbr75ZpeUu2DBAl1yySVq0KCBTj75ZA0ePFjz5s1LWW/dunXq0aOHmyuhdOnSuvzyy7Vly5ajtvfBBx+4K/dlypRR7969tXfv3lTDoj799NOqU6eOG7701FNP1cSJE1NenzlzpivLpEmT1Lx5c9d68uOPPx71vqZNm+rTTz896n3WwtKiRQs3elHr1q21bNmyVGX76quvdPrpp7vWhYoVK+qiiy5Kee3QoUO6++67VaNGDZUoUUItW7Z0283ITz/9pN27d+udd95xn8PKdu655+rFF190jy0oql+/vv7v//4v1fsWL17syrpixQr33B7bNqwsVu4TTjjBBSf+/vjjD3Xt2tXVfZUqVXTVVVdp+/btKa+3b99e99xzj+688073ubp06eKW23Zse/Z5rWzvvfee258NjWzBj32P/vVoJkyY4D6///eW1wgsAAAAcjqpWHxitm57DyZo6Jd/Kr1OT75lw75c6tbLzvZs39mxc+dOTZ482bVM2MlkWnYV3tiJvQUVtv6sWbM0depUrVq1ynX78bdy5Up3Yvr111+7m637zDPPpLxuwcH777+vESNG6M8//9Ttt9+uG264wa3n77777nPv++uvv9SkSZOj3mcn0H379j3qfQ8++KCef/55/fLLL66V45prrkl57ZtvvnEn7926ddOvv/7qgpAzzjgj5fVBgwZp7ty5+uijj/T777/rsssu03nnnafly5enW3c2A3ViYqK++OKLdOvbTuBt/6NGjUq1fNSoUTr77LNd0OHz6KOPukDN9mvlu/LKK11dGwsCLHCw4MU+l31fFtDZ+v6s3NZKYQGP1dPq1at16aWXqmfPnq7LltWz1Y+Pfd8W+KVXPntfqVKllF+Cr/0JAAAgiB1ISFKjR6bkybbstHXznoM6Zdh32Vp/6WNdVLxI1qdvdtXcToobNmyY6Xp2Er5kyRJ3smr5F8ZO9K1l4+eff3atAL4AZPTo0SknpXZl3d775JNPuhaBp556StOmTVOrVq3c69ayYa0Cb731lrui7vPYY4+pU6dO7nF677NcEGvJePPNN9WuXbuU99l+fM8tODn//PN18OBBd8XeXrMTaTuJ97GWD19rjJ1Q23316tXdMmu9sJN4W277T+vMM8/UAw88oCuuuEI33nijC1IsAOjXr59rVTBXX321HnnkEdcaZK9bF7OxY8ce1Yph6/Xp08c9tn29/PLL7j0W2Lz66qsuqPAvw8iRI9338M8//7gWJl+dPPvssykT5NnnP/HEE133NmOPreXD6sHnuuuucy07mzZtcrNpW27It99+6+o6P9FiAQAAEGay27JhLQd2IusLKkyjRo1ci4a95mOBgv+Vbt/Jqi+IiYuLcwGDdenxdamyK+3W+uHPujP5pPc+u1lgYy0k/qx1w3/fxrd/64JkORHpsaDJcjnsJN1/H9YiknYf/uwk3RLfrYXAgiy7tyDNtmcsSLHgxgIBX1esQ4cOudaQjMptLQlWL75yW2vDjBkzUpXLFwj6ly3tiFzWDcwX8Pn4t9D4nlu5rYuU+fDDD1WrVi3XopKfaLEAAmnbX1J1hvADgFBSLCbKtRxkx4LVO3X1qJ+zXG/0gNN1Rp3y2dp3dlj/e+uyk1cJ2jExMame27atFcPs27cvpUuS5TEYe82WV6hQIdX7/Ltlpfc+H8vByGj/vsncfPu33IyM2D6ioqK0cOFCd+/PTuQzY2W3QMFu1qpgrQvWIuE7WbdWAWu5sdwLa/3o1avXUTO0Z1VvNkKXtUak5QuecjPru5Xvtddecy0cVr4BAwbk+0SPBBZAfkhOzN56X9wkbf5DOvdBqcix/XAAAAqWnZxlpzuSaXtCJTf6kyVqp9eGYKd5VcsUdetFRebdSV/58uVdoq+dWN52221H5VlY/35rlTjppJO0fv16d/O1WixdutS9bi0X2WHrWSBg3Y183ZXs5HnPnj3uCn1O3ncsrFXAumXZiXNaFgxYi4W1ErRt2/aY92E5DvXq1Us1KpTlTFi9vvHGG65r1Q8//JCjbZ522mn67LPPXGtQTkbHsq5P1q3Jn3VbS8tyVe69917X/cq+0/79+yu/0RUKyGt2JWLmkYS2zHmkua9Kb7SSVqVOVAMAhD4LFmxIWZM2bPA9t9fzMqjwsaDCTqqtW4ydwFqysnVvshNNX05Dx44d3TC0llS8aNEi1//fcgnsRN+/21JmrIuU5S1Y4rVdzbduPLYty6/wXd3PyfteeeWVTN+X1tChQzVu3Dh3b5/Puiv5WgGsC5R9NvtMn3/+ucslsc9oSePWUpIeS063k3K7t1wH63pkLRV2Mm+J7j7WAmI5FPfff79rIWp1uE6zyxLrLZHbcjAsMLDPb8PbWoBk31tGLFnbWqKGDBniyvfxxx+7/Bfj3yJRrlw5XXzxxW5Uqc6dO+u4445TfiOwAPKS9WmddI+0YmrW69o8Fj1el0rXkP5bI71/oTRxkHRgF98JAIQRm6fijb6nuZYJf/bclufXPBaW9Gsn6pY8fdddd6lx48Yun8Gu7ttVdt+JqA0Layeh1v/eAg173/jx43O0r8cff1wPP/ywO2G3VhC7mv/dd9+54Vlz8j5LarYT/qze5++cc87RJ5984oZgtXwES7S24MHHugFZYGF1YFf7bTQlO5E//vjjM2xJse5Htr5tz5K57eTdho61rk/+rr32Wje3RHqtJVmxPA0b6cmCCDvxtwDvjjvucC1JvkTt9Fjd2FCyFihZa419l75RodJ2IfOVz38UrfwU4cludk+YsGY5G3/ZxifOrHkut2x0AIts7T9W2v51COO6nP6YNPt573Wors9KNVtmvG7xCt7J8Q7ukaY/Kv38jnd5yarS+f8nnXRB4a3HIEddUo/BhmMy/+rRRh6yq9x2MmcjEOWGzbRtORdb9x5U5VJFXU5FfrRUBAP/rlCZnSSHutmzZ7vEcetKVuXwiFGBqEdLNrcEcytH2rlHrEVo48aNmU6sl9lxnpNzZ3IsgLzy40uHgwpJ3V+QWmTz6kDR0tL5z0uNL5G+vFXasUIa31dq1EPq+pxUKu9/qAAABc+CiFb1UiczIzTZCFA2Q/ewYcNccnd+BBWZef31193IUJZgbq0eNvSszdfhY6Nt2VCzNmeIdZ0qqNm6wzeEBArSLyOlaUO9jzs+mv2gwl+t1tKNP0lnDZYioqSlE6XXzpB+HePtYgUAAIKC5XTY8K2W5D58+PAC3//y5ctdvod127LuZNZty4IcHyuTDV1rk/1ZDkhBIbAAcmvJp9LXg72PLSg4645j31ZMUanjUOn6mVK1ptLBXdLEm6UPLvLmYQAAgICzpG3LjbBhbNMOlVsQbIhb695kXZgsgdvyVPxHlrIgw7r2WT5NVsPq5iUCCyA3lk2SPr/eO7rT6ddJHR7Jm/qs1kS67ntv60d0UWnVDOn1VtLc16XkjEeKAAAACBQCC+BYrf5B+ri/5EmSmvTy5kPk5cQzUdHe1o+b5ki1zpIS4qQp90vvdpa2HpkNFQAAIBgQWADH4t+F0rg+UtIh6cTzvcPG5teoFxXqSf2/krq/KMWWljb8Io1o650rIzE+f/YJAACQQwQWQE5tWSqNuUSK3yfVaSddOtLbupCfLGixhPCb50kNukrJCdLMp6U3z5b+/SV/9w0AAJANBBZATuxcJX3QUzrwn1SjhdR7rDfhuqCUqSH1GecNZopXlLb9Jb3TUZp8vxS/v+DKAQAAkAaBBZBdezZK7/eQ9m2RKp8sXfmJFFtwIy2ksDwOm/Ni0M9Sk97exPF5r0uvnymtnFHw5QEAACCwALJp/3bp/Z7SrnVS+brSVV9IxcsHtvps/xe/KV35mVSmprds1poy4RZviwoAAEABosUCyMrB3dKHF0vbl0mla0j9JgbXbNgndJRuniudYcPeRkiLP5RePcM7wR4AIPB2rZc2Ls74Zq/nk82bN+vWW29V3bp1FRsbq5o1a+qCCy5w8xvkpXPOOUd33JGLeZxyud3Vq1friiuuUPXq1VW0aFEdd9xxbgK5v//+O8/LhIzlc8YpEOLi46SxvaVNv3lzGq6aIJU9XkEntpTU7Tmp8aXSl4Ok7f9IH/eTTrpA6vZ/UqmqgS4hABROFjS82lxKPJTxOtGx0qCFUtmaebrrNWvWqE2bNipbtqyee+45nXLKKW7StClTpuiWW24Jm5Nu+0ydOnXSiSeeqM8//1zVqlXTv//+q0mTJrmZsQMpPj5eRYoUUWFBiwWQERvK1U7O183xDvN61edSpQbBXV/Ht5RumC2dfY8UGS399ZX02hnSog8kjyfQpQOAwiduR+ZBhbHXbb08dvPNNysiIkILFizQJZdcogYNGujkk0/W4MGDNW/evJT11q1b567u2wzNpUuX1uWXX64tW7akmsW5WbNm+uCDD1S7dm2VKVNGvXv31t69e1NmoZ41a5b+97//uf3ZzYIa88cff6hr165u21WqVNFVV12l7du3u9dmzpzpTrpnz56dsq/hw4ercuXKbv+Zbdffn3/+qZUrV+r111/XmWeeqVq1armA6oknnnDPTfv27TVo0KBU79u2bZvbv6/1xj7bU089pWuuuUalSpXS8ccfr7feeivVe9avX+/qx4K18uXLu3rzL9PVV1+tnj176sknn3StJxbsmDlz5rg6tNaUFi1aaMKECe7zLF68WB6PR/Xr19f//d//pdqXvRYVFaVVq1YpVBBYAOmx2a2/uF5aMVWKLiZd8bFUrWlo1JWNUtX+Ien6WVL1U71dub4cpKixl6j4oa2BLh0AhD67UGMj8WXnlngge9u09bKzvWxeJNq5c6cmT57sWiZKlChx1Ot2YmySk5PdybGtbyfxU6dOdSeyvXr1SrW+nbjbyfDXX3/tbrbuM888416zE/9WrVpp4MCB2rRpk7tZl6vdu3erY8eOOvXUU/XLL7+48ljAYCfm/t2cLNiwdX/99Vc9/PDDeuedd1wQktF206pUqZIiIyP16aefKikpKd36uO666zR27FgdOnQkyPvwww9Vo0YNF3T4PP/88+7E38pigdlNN92kZcuWpbSMdOnSxQUdFgz99NNPLmA677zzXMuEjwUq9h6rS6urPXv2uO5n1mK0aNEiPf744xoyZEjK+hZgWDAzatQo+bPnZ599tuvGFiroCgWkZT/aX98h/fmFFBkj9f5QqtUq9OqpamPp2mnS/Dek759U5JofdG7EPEVUj5NaD5IiowJdQgAITQlx0lPV83abI8/L3noPbJSKHB0opLVixQp3Jbxhw4aZrmcnwUuWLHE5Cr6T9vfff9+1bPz88886/fTTUwKQ0aNHu5NqY8GAvdeuzFsLhl35L168uKpWrZqy/ttvv+2u0lsrQMrHHDnS7eeff/5xLSjWqmAn4Ndff71r3ejfv78uvPBCt256202PBQcvv/yy7r33Xj366KMuMDj33HN15ZVXppyUX3zxxa7FYuLEiSmBjX0ea2GwE3ufbt26uYDC2Mn/iy++qBkzZriWh/Hjx7vPZYGP7z128m9BmrW+dO7c2S2zQM7W8XWBGjFihFvf6sNaLBo1aqQNGza4gMnHyvHII4+41qUzzjjDBTEWCFkLTiihxQJIG1R895C06H0pIlK65B2pfsfQrSObuK/1rdLNc5Rc6yxFe+IVNe0R6d1O0pY/A106AEA+saAiO/766y93ou/fEmAnvnaybK/5WDchX1BhLI9h69bMW8EtULATbruq77v5Ah1rATF28j1mzBh99tlnOnjwoDuRPxbWMmOJ6rYta+X45JNPXHBkQYuxE3oLhiywMdZyYOWzE3p/TZo0SXlswYAFNL7P+dtvv7mAzerB93msO5SV2/d5jLVM+OdVWOuFbdfK4GPBgz/rNnX++eenlO+rr75yrSuXXXaZQgktFoC/H56T5r7qfXzhK9LJPcOjfsrXVdKVX+i3D4ao2dZPFbFhoXfW7rZ3eW+WOAgAyJ6Y4t6Wg+zY/Hv2WiOumSxVbZK9fWfDCSec4E6M8ypBOyYmJtVz27Zdvc/Mvn371L1793Svultg4mP5B8a6Y9ktva5b2WEn/NblyG7WEmLdluzeErt93aGsBcUSu62lwbpAWT5Gdj+nfZ7mzZu74CW97lg+x1p+K58FPxZcWfmsO5q11lhXqlBBiwXgM2+ENONJ7+PznpFO7RtedRMRoXUVz1HiDT9JDbtLyYnSrGelEW2l9QsCXToACB3WDca6I2XnZnl62WHrZWd7ft12MmNX0u3E+rXXXtP+/fuPet03WtJJJ53kEpLt5rN06VL3urVcZJddoU+b39C0aVO3LWvtsORk/5vv5Nuu9N95552um1DLli1dVyj/gCW97WaHBQTWOuL/2a0lwbpJ2b6sm5HlNeTEaaedpuXLl7vk8rSfx7ptZcS6UVl3M//8DutmlpZ1w7J6eeONN1w+Sk7LFwwILADz6xhp8uFEqnPul868KXzrpVQ1qdeH0mXvSSUqeefneLezNGmIdGhfoEsHAMgjFlTYSbl1u7GuRnZSbN2bLB/BugsZS662E27LR7DuQdbHv1+/fmrXrp07Cc8uCx7mz5/vRkiyUZ8sOLAr8NYC0adPH3cibUGEDXU7YMAAVy679e3b1wVAtsyu0v/+++8ugTqz7aZloydZArolb1sgY92V3n33XdetyJb7szJZ0rl1FbvoootyVJ9WRxUrVnTbtORty0uxrl633XabawXJiM2vYeW2PBKrf6sD3whQ/vkdNgKUdc26//77XYuT7zsKJQQWwNIvvXM/mDNvkdodGakhbNkPmXXzumWB1OxK640rzR8hvd5KWpG3kyYBQKFWvELW3U3tdVsvj1nisgULlsh81113qXHjxq5bkCVd21Vx34mtJTSXK1fOjUBkgYa9zxKVc+Luu+92J8bWymHdgmwIW+vuZCfgFkBYYrMFMDYKlOVv2ChOlvi9du1avfnmm24btr4N7/rQQw+5fIaMtpuWTYZnAYglblurh7Us2IhS9vzBBx9Mta4FOdHR0e7eP+chO6xb0g8//OCGobVkcGvtufbaa12OhQ3TmxF7zXImLACyrlhWJkvUNmnLYNuzEaYs0ApFEZ7sZveECeunZs1VNqxZZgdBblk2/7fffuuatdL210MQ1aWdRI/tJSUneLs+XfhqtpuZw6oerR5sJKxdh3+wm14hdXlSKl4+IGUNdvz/ph6DDcdk/tWjnTTalek6derk+EQ01SR5mc1TYUFFHk+OF2h2hd7Ouexcy4KIYGEtH/Xq1XMtKBaABMqYMWNc8GDno8WKHekuZ4FYhw4dXNc0G3K3oOoxs+M8J+fOJG+j8Fo3Txrf1xtUNOohXfBy2AYVWarfQbpprvT9E96Wi9/GeufwsNm8G/UsvPUCAHnBgoYwCxxCMWjcsWOHaw2xSfMKOqh4//33XUuQDY1rrTE2lK0Ne+sLKiz/wibss8kIbSQoCypCUfCEkEBB2vS7NOZy71jkNpzsxe8wr0NsSanrM9K130mVGkr7t0mfXC19dKW0ZxPHJwAgZNlkdtbVyloqbF6JgrZ582aXT2LdpyxZ3YIH/1m9x40b50aosqT5UJu7IqgCC0sssn5x1uxi/eIsaSgzL730ksuutwjPxly2L8eab4Bs275c+uAi6dBu6fhW0uUfSNFHxpsu9GqeId3wg9TuPu8Egcu+kV5rKS0cne0ZXwEACCY2y7f1/rc5JSzXo6Dde++9rhuWr8uRDSlrORs+lrRtuSgLFy50rRqhKqCBhSUGDR48WEOHDnXJRTYsmY0MkNGEKzY02H333efWt6x6y/i3bTzwwAMFXnaEKOvn+n5PKW67d7zwK8ZLRbI3JnihYomE597vDTBqNPcGYV/dLr13gbTjyCRAAAAAQRFYvPDCC246c0tesWx/a5qy6M0362BaNoFKmzZt3LBd1sphIwxYVn9WrRyAs2+r9H4Pac+/UsUG0lVfSEUzHncakqo0kq6dKnV5yjvG+prZ0hutpZ9elpISqSIAABD45G0bSsuae2ysXh/LdrdhzubOnZvue1q3bq0PP/zQBRI2JvOqVavc6A02S2FGLBnGf0IS3+yFlsRjt/zi23Z+7qOwyJO6PLBL0R/2VMTOlfKUqanEPp9KRcrYRlVY5KoeW1wv1eusqG/vVKQFF1MfVvKST5XU/X9SlcYqbPj/TT0GG47J/KvHxMRE14XG7rOaaRpH+AYdtXvqLfjr0f84T3uekJPzhoANN7tx40bXh8xaIfwnALE+aLNmzXKToaTHJnWxMY19H/7GG29MGYs5PZZdb+MYp9etyr9vG8JXVNJBtV45XOX3r9DB6DL6scFD2h8bmqMtBJzHo+N3/qDGG8YpJilOyYrS8irn65+qFyo5kjwVAOHJRugpWbKkm83a5kAAwkliYqKbyHDfvn3asmXLUa/HxcW53kJhN9yszW741FNP6fXXX3eJ3jaz4u23367HH39cDz/8cLrvsRYRy+Pwb7GwpG/rRpXf81hMnTrVTUTDPBYBrMvEg4r6+EpF7l8hT9GyirrqS7Wr3EiFUd4dk+dLe+9U8pT7FLnsa5245Us1SPxLSee/JE/NlioM+P9NPQYbjsn8rUdbbidcNmIPsscuAFuisg3O4z+7NIKzHkuUKOGGw03v/MDX2yc7AhZY2JToNpNi2sjInletWjXd91jwYN2ebDp2Y1n9+/fvd1Ok2yyG6U0cEhsb625pWcUVxAl/Qe2nMMhxXVoOwMQbpdWzpJgSiuj7mWJqNFVhlyfHZPmaUp8x0tKJ0jd3K2LHckW/3106Y6DU4REptpQKA/5/U4/BhmMyf+rRHltup13ZtZF7kDULxmyWapvNm/Og4K5HOx+3lriMApec7DdggUWRIkXUvHlzN618z5493TLrO2bPBw0alO57rCkmbfBglWEK2QTiyIr1Q5x4i/T311JUrNRnnHRcC+otr9nEgnXOlr57SPr1Q2nBW9Lf30oXvCSd0In6BhA27KSLwC377PzMAjG70k5gUXjqMaBdoayLUv/+/dWiRQuXjG1zVFgLhI0SZfr16+fyMJ5++mn3/IILLnAjSZ166qkpXaGsFcOW+wIMwM21MHmI9PtHUkSUdNloqW47Kia/FCsn9XhNanypd0jaXWulMZdKTXpJXZ72TkIYtyPj9xevUDhmpLWhjqkHAEAYC2hg0atXLzd9+SOPPOJmJGzWrJkmT56cMo35unXrUrVQ2DTsdsXA7jds2KBKlSq5oOLJJ58M4KdA0JnxpPfKuSKki0ZIDbsFukSFQ71zpZvnSt8/Kc1/Q/p9vPTPd1L8Pik5IfM5MwYtDO/gwoKKV5tLiUdGqCuU9QAACGsBT962bk8ZdX2yZG1/1v/LJsezG5Aum1/hh+e8j7s9JzW5nIoqSEVKSOc9JTW+WJo4SNr2V9bvsZNtu5IfzifU9vkyCyoKSz0AAMJawAMLFKBw74qxcLSbX8HpMNSbSIzAsHwWm7V70hBpYfoTXgIAgPBCYFFYhHtXjCWfSl/d4X3c5g6p7ZEhhhEg0UWk5v2zF1h897BU7PAs6GkHYkj13JNmWX4/T1sG731UcpLa7PxPUdtft4zOrLcZvz/LKgAAINQRWBQW4dwV458p0hc3eE/gWlwjdRwW6BIhp9b8EFJ1ZplfFe0B8QIAACkILBDa1vwofdxPSk6UTrlM6vb8kSvICB3WylTmOL/v7vB9Xj/P0XsyXj8xKUmLFv2q0047zW8W3ky2t3O19N2D2awMAABCE4EFQteGhdLYXm52bTXoKvV8Q0pnkkSEgJMvkqo3U6jwJCRo0+oYeU7qZjMHZf2GjYsLolgAAAQUZ2EITVv/kj68xDuUae223rkqooJ/4hgAAIBwRWCB0GPdSt7vKR34T6rR3DurdkzRQJcKGY00ZoMCZMZet/UKez1EFQn/egAAhDW6QiG07Nkkvd9D2rdZqtxIuvJTKbZUoEuFjNhAADbSWDgPc5yberCRo764Udr+t3Rit/CvBwBAWCOwQOiwk7IPe0q71krl6khXfSEVLx/oUiErdrLMCXPG9dDzNemdDtLSCdK/v3jnAAEAIATRFaqwCPEuKdFJBxT1US9p299SqepSv4lSqaqBLhaQexZINLvS+/jbe6TkZGoVABCSCCwKC19XjIbne5836SX1+0qKONxodemo4J0cL+GAWq56QZGbFkvFykv9JkjlagW6VEDesZnii5SSNi6SfhtLzQIAQhKBRWFiQcPWv72PT75Yqnu2dOJ53uebfgvOoCIxXlGfDVDFfcvksVyKqz6XKp0Y6FIBeatUFemcId7H04ZJB3dTwwCAkENgUZjs2SjtXClFRErHn+ldZpPKmSWfBl8XjOQkN6N25MppSoqIUdLlY6Xqpwa6VED+OOMGqcIJ0v5t0qzh1DIAIOQQWBQma37y3ldtIhUr633c4DwptrS0519p3RwFDRst5+s7pT8/lycyRgvq3CbP8a0CXSog/0QXkc57xvt4/ghp2zJqGwAQUggsCpO1P3rva591ZJnN/9Coh/fx7+MVNEHF1IelRe+51pWkniO0tUzTQJcKyH8ndPQOO5ucKE2+z/t/AQCAEEFgUZisSSewME0u997/OVFKOKiAm/1/0pxXvI8v+J88Jx0OfIDCoMtTUlSstPJ7adm3gS4NAADZRmBRWOzdLO1YISlCStulqNZZUuka0qHd0vLvFFDz35K+f+LICdZp/QJbHqCgla8jtb7V+3jy/cER7AMAkA0EFoWttaLqKUfyK3wiI6VTLg18d6jF46RJ93gftxsitbolcGUBAqntYO98LTYZpK/1DgCAIEdgUei6QbVN//VTDneHshaLA/+pwP31lTTxZu/jljdK59xf8GUAgkWRElLnx72PZz8v7f430CUCACBLBBaFPb/Cp2pjqfLJUlK8tHRigRZNK2dIn14jeZK9MxB3eVqKiCjYMgDBpvEl0vGtpcQD0ncPB7o0AABkicCiMNi7Rdqx3JtfUSuTIVt9Sdy/f1xgRdP6BdJHV3gDmpMulC542ds1CyjsLLju+qx33pk/Pz9ycQAAgCDFGVxhGmbWWiWKlct4PZdnESGt/UnatT7/y7V5iTTmUikhTqrXXrrkHSkqOv/3C4SKak2k5gO8jycNkZISA10iAAAyRGBRGGSVX+FT5rgjXaWWfJK/Zdq+QvrgIungbqnmmVKvD6Xo2PzdJxCK2j8kFS0rbflDWjgq0KUBACBDBBaFacbtWm2yXte/O1R+Tc5lrSHv95D2b/OOUnXFeG+yKoCjFS/vDS6MDcUct5NaAgAEJQKLcLdvq7R92eH8itZZr295DlFFpG1/ea+Q5kd5Pugp7flXqlBf6vvF0cPfAkjNukNVaSwd3HVknhcAAIIMgUVh6QZlJyV25TMrdpLf4LzczWlhLRIbFx99Wz1bGtnVO1FfmZpSv4lSyUrHtg+gMLHco67DvY+tO9Sm3wNdIgAAjkKmbLizRGxTOxvdoHya9JL++lJa8qnU8VEpMipnQcWrzaXEQ5mvd9EIb04HgOyx/8M2BO0fn3kTuQd8y7DMAICgQotFYZ+/Ij0ndPImi+7dlPMhLuN2ZB1UmCIlc7ZdAFKnx6SY4tK6Od4AAwCAIEJgEc72bZO2/Z39xG0fG53p5J4FP6cFgMxZK1/bwd7HNmneoX3UGAAgaBBYFIZuUDajdnbyK9J2hzI2C3fCgbwvG4Bj0+pWqWwtae9G6ccXqEUAQNAgsAhnx9INysfmlihzvBS/V1o2Kc+LBuAYxRSVznva+3jOK9LOVVQlACAoEFiEs9wEFpGRh2fiLoDJ8gDkzIndvLPVJ8VLUx6k9gAAQYHAIlzt3+6diyKn+RXpdYda/p20f0f23rM5H+a+AJBaRIR03jNSZLS07Ftp+TRqCAAQcAQWYZ9f0UgqUeHYtlG5oVS1iZScKC39Iuv1//xC+vqOY9sXgJypdKLU8kbv48n3SYnx1CAAIKAILMJVbrpB+Wtyuff+90y6Q3k80k//kz65WkpOkCIisx51qvgxBjsAjmh3r1SikrRjubTgTWoGABBQTJAXrvIqsGh8qXdYy/XzpJ2rpfJ1Ur+elChNukf6ZaT3+Rk3SK1ukQ78l/E2LagoWzN35QIgFS0jdRwmTbxFmvmsdMrlUqkq1AwAICAILMKR5UNsXZq7/Aof6wZV4zRpw0LvCDSn9TvyWkKcNOMpac1s6/TtHanmzJu8r5Wrlbv9Asiepld4A3v7PzptmHTRG9QcACAgCCzCOb+i0klSiYrHvp1d66VXmx+ZSfuXd723tKJipUtHSid1P/Z9ATg2NoJb1+ekd9pLv42VWlwj1Tyd2gQAFDhyLMJRXnWDittxJKjIzAX/I6gAAum45lKzvt7H1jUxOZnvAwBQ4AgswrnFonYuu0FlV+WTCmY/ADLWcagUW1ra+Ku0eAw1BQAocAQW4SZup7Tl8FwStXLZYgEgdJSsLLUb4n1suRYHdgW6RACAQobAImzzKxpKJSsFujQACtIZ10sVG0hx26VZw6l7AECBIrAIN2t+ypvRoACEnugi3hm5jc1rsfXvQJcIAFCIEFiEm7xK3AYQmup3kE483ztU9OQh3gksAQAoAAQW4ZpfQWABFF5dnvQOA71qpvT3N4EuDQCgkCCwCCfr5kryePtYWyJnbtkM2dGxma9jr9t6AIJH+TpS61u9j6fcLyUcCHSJAACFABPkhZO87gZVtqY0aKF3PouMWFBh6wEILm0HS7+Nk3atk+a8IrW7N9AlAgCEOQKLcLJmdt53g7KggcABCD1FSkidH5c+vUaa/YLUtA//lwEA+YquUOHiwH/SZuavAODn5Iu9I8QlHpCmPkzVAADyFYFFuFh7OL+iwglSqSqBLg2AYBARIXV9VoqIlP78Qlp9uFUTAIB8QGARLhhmFkB6qp4itbjG+3jSECkpkXoCAOQLAotwsZb5KwBk4NwHpWLlpK1/SgtHUU0AgHxBYBEODuySNv3ufcyM2wDSKl5eav+Q9/H3T0j7MxnpDQCAY0RgEap2rZc2LvbeFo/15leUOU7at8W7zF4HAJ/mA6Qqp0gHd0kznqBeAAB5juFmQ5EFDa82lxIPpV6++1/prXZHJq6zOSgYKhaAiYzyJnKP7ib9MkpqfrVUrSl1AwDIM7RYhCKbsC5tUJGWvZ7ZxHYACp/abaTGl3hbOC2R2+MJdIkAAGGEwAIACpNOj0sxxaV1c6Ulnwa6NACAMEJgAQCFSZkaUtu7vI9t0rxD+wJdIgBAmCCwAIDCptUgqVxtae8mafbzgS4NACBMEFgAQGETU1Tq8rT38dxXpR0rA10iAEAYILAAgMLoxK5SvQ5SUrw05cFAlwYAEAYILACgMIqIkM57RoqMlv6ZJC2fGugSAQBCHIFFKCpewTtPRWbsdVsPADJSqYHU8kbv48n3SYnx1BUA4JgxQV4osknvbPI7m6fiy0HS5iVSx0eluuccWceCCibHA5CVdkOk3z+WdqyQ5o+Q2txGnQEAjgktFqHKgobqzY5MlFejufe570ZQASA7ipaWOg7zPp71rLR3M/UGADgmBBahzje7Nt2eAByrpn2kGi2k+H3StEepRwDAMSGwCGXJSdKB/7yPCSwAHKvISKnbcO/j38ZK6xdQlwCAHCOwCGUHd0ueZO/j4uUDXRoAocy6U57a1/v423uk5MO/LQAAZBOBRTh0g4otI0XFBLo0AEJdh6FSbGlp02Jp8YeBLg0AIMQQWIRFfgWtFQDyQMnK0jn3eR9brsWBXVQrACDbCCxCGYnbAPLaGddLFU+U4rZ7R4kCACCbCCxCGYEFgLxm3Sq7PuN9PP9Naevf1DEAIFsILEIZgQWA/FCvvdSwu+RJkibdK3k81DMAIPgDi9dee021a9dW0aJF1bJlSy1YkPkwh7t27dItt9yiatWqKTY2Vg0aNNC3336rQokcCwD5pfMTUlSstHqW9PfX1DMAILgDi/Hjx2vw4MEaOnSoFi1apKZNm6pLly7aunVruuvHx8erU6dOWrNmjT799FMtW7ZMb7/9tmrUqKFCKW6n9545LADktfJ1pDa3eR9PeUBKOEAdAwCCN7B44YUXNHDgQA0YMECNGjXSiBEjVLx4cY0cOTLd9W35zp07NWHCBLVp08a1dLRr184FJIUSXaEA5Kez7pRK15B2rZN+epm6BgBkKloBYq0PCxcu1P3335+yLDIyUh07dtTcuXPTfc+XX36pVq1aua5QEydOVKVKlXTFFVdoyJAhioqKSvc9hw4dcjefPXv2uPuEhAR3yy++befnPqL2b3eRYWJsWXnycT+BVhB1WRhQj9RljkUUUUSHYYr+YqA8P76gxMaXSWVqckwGIf5/U4/BhmMyfOoxJ/sOWGCxfft2JSUlqUqVKqmW2/O//05/FJJVq1bp+++/15VXXunyKlasWKGbb77ZfWDrTpWep59+Wo8++uhRy7/77jvXOpLfpk6dmm/b7rB9vUpKmvvbMu1cqbCXn3VZmFCP1GWOeIqoTcmGqrjvb2398Ab9UmcQx2QQ4/839RhsOCZDvx7j4uKCP7A4FsnJyapcubLeeust10LRvHlzbdiwQc8991yGgYW1iFgeh3+LRc2aNdW5c2eVLl0638pqwY4dBJYTEhOTP7NiR/91q7s/s313qeIJClcFUZeFAfVIXR6zLbXlefdc1di1QFUalZKndluOySDD/2/qMdhwTIZPPfp6+wR1YFGxYkUXHGzZsiXVcntetWrVdN9jI0FZpfp3ezrppJO0efNm17WqSJEiR73HRo6yW1q2nYL4gvJtP0kJ0sHd3n2UqWo7UrgrqO8s3FGP1GWOHddManGt9PPbip76oHTDbCkq7/58cExyTAYbjknqMtjEBPAcKCf7DVjytgUB1uIwffr0VC0S9tzyKNJjCdvW/cnW8/nnn39cwJFeUFEoRoSKiJSKlgl0aQCEu3MfkIqVk7YulX5Jf4ANAEDhFtBRoayLkg0X+9577+mvv/7STTfdpP3797tRoky/fv1SJXfb6zYq1O233+4Cim+++UZPPfWUS+YutCNC2R/6yPQT1wEgzxQvL7V/2Pt4xhPS/sO/QQAABEOORa9evbRt2zY98sgjrjtTs2bNNHny5JSE7nXr1rmRonwsN2LKlCm688471aRJEzd/hQUZNipUocNQswAKWvOrpV9GSVuWSN8/Ll3wEt8BACB4krcHDRrkbumZOXPmUcusm9S8efMKoGRBjsACQEGz1tFuw6VRXaWFo6UWA6RqhXQeIQBAcHWFQi4QWAAIhFqtpcaX2ji00rf3Sh4P3wMAwCGwCPXkbev3DAAFqdNjUkxxaf08ackn1D0AwCGwCFW0WAAIlDI1pLZ3eR9/97B0aC/fBQCAwCJkEVgACKRWg6RydaR9m6XZz/NdAAAILEIWgQWAQIopKp33tPfx3NekHSv5PgCgkKMrVKgisAAQaA3Ok+p3lJLipSkPBLo0AIAAI7AI+eTtCoEuCYDCKiJCOu8ZKTJa+mey9M93gS4RACCACCxCvsWCUaEABFDFE6Qzb/I+nnyflBjP1wEAhRSBRShKOCAl7Pc+psUCQKCdfa9UorK0c6U0/41AlwYAECAEFqHcDcq6H8SWDnRpABR2RUtLnR71Pp41XNq7OdAlAgAEAIFFqCduWx9nAAi0Jr2lGi2k+H3StGGBLg0AIBQCi6FDh2rt2rX5UxrkMLCoSI0BCA6RkVK34d7Hv42T1s0PdIkAAMEeWEycOFH16tVThw4dNHbsWB06dCh/SoaMkbgNIBjVaC6d2tf7eNK9UnJSoEsEAAjmwGLx4sX6+eefdfLJJ+v2229X1apVddNNN7llKCDMYQEgWHUY5s392rRY+vXDQJcGABDsORannnqqXn75ZW3cuFHvvvuu/v33X7Vp00ZNmjTR//73P+3evTvvS4ojCCwABKuSlaRz7vc+nv6odGBXoEsEAAiF5G2Px6OEhATFx8e7x+XKldOrr76qmjVravz48XlXSqRGYAEgmJ0xUKp4ove3auYzgS4NACCYA4uFCxdq0KBBqlatmu68807XgvHXX39p1qxZWr58uZ588knddttteV9aeBFYAAhmUTFS18MBxYK3pK1/BbpEAIBgDCxOOeUUnXnmmVq9erXrBrV+/Xo988wzql+/fso6ffr00bZt2/K6rPAhsAAQ7Oq1lxp2lzxJ0qQh1sQd6BIBAIItsLj88su1Zs0affPNN+rZs6eioqKOWqdixYpKTk7OqzIiownyipenbgAEry5PSlGx0upZ0l9fBbo0AIBgCywefvhh1ahRI39Kg+yhxQJAKChXW2pzu/fxlAelhAOBLhEAIB9F5/QNgwcPTnd5RESEihYt6rpE9ejRQ+XLczU9X1h3AgILAKHirDulxWOl3eukn16WzhkS6BIBAIIlsPj111+1aNEiJSUl6cQTT3TL/vnnH9clqmHDhnr99dd111136ccff1SjRo3yo8yFW/w+KSne+7h4hUCXBgAyV6S41Plx6dMB0o8vSM36SGWPp9YAIAzluCuUtUZ07NjRzWFho0PZzeax6NSpk0va3rBhg84++2w3WhTyga+1IrqY9w82AAS7ky+SareVEg9K3z0U6NIAAIIlsHjuuef0+OOPq3Tp0inLypQpo2HDhmn48OEqXry4HnnkERdwIB/QDQpAqImIkLo+K0VESksnSqtmBbpEAIBgCCxsVu2tW7cetdyGl92zZ497XLZsWTdpHvIBI0IBCEVVTpZOv8772IafTUoMdIkAAMHQFeqaa67RF1984bpA2c0eX3vttW74WbNgwQI1aNAgr8sKQ4sFgFB1zv1SsfLStr+kX94NdGkAAIFO3n7zzTdd/kTv3r2VmOi94hQdHa3+/fvrxRdfdM8tifudd97J67LCEFgACFU2907rQdL0x7y3cvVUJm6NtOk3+0NyeJ0KUtmagS4pACC/AwsbCcpGhLJcCgsiVq1a5ZbXrVtXJUuWTFmvWbNmx1IW5CSwKFGR+gIQWnatl2Y9630cv08xYy/ROfZ4md860bHSoIUEFwAQ7l2hbEjZzp07a9euXS6QaNKkibv5BxXIZ7RYAAjl36/EQ5mvY6/7fucAAOGdY9G4ceOUlgoEMrBgAkIAAACEcGDxxBNP6O6779bXX3+tTZs2uZGg/G/IZ/t9gQWT4wEAACCEk7e7devm7i+88EJF2Njkh3k8Hvfc8jCQj+gKBQAAgHAILGbMmJE/JUH2EFgAAAAgHAKLdu3a5U9JkLXkZOnATu9jukIBCFdbl0rVGV0QAMI+x8LMnj1bffv2VevWrbVhwwa37IMPPtCPP/6Y1+WDv4O7JE+y97FNMgUA4ejL26Q/Pgt0KQAA+R1YfPbZZ+rSpYuKFSvm5rQ4dMg7dODu3bv11FNP5XRzyIm4w60VsaWl6CLUHYDQYi2tNk9FZiIipeQE6dNrpFnDLYGvoEoHACjorlA2KtSIESPUr18/ffTRRynL27Rp415DPmKoWQChzGbUtsnvDv+WJSQm6qeffnJ/P2J8M28XKycteEua+6o040lp+3LpwlekmKKBLTsAIO8Di2XLlunss88+anmZMmXcxHnIRyRuAwiH4MJuJiFBu4tvkKo1lWJijqzT5UmpQn3pm7ukJR9Lu9ZJvcdIJSoGrNgAgHzoClW1alWtWLHiqOWWX1G3bt2cbg45QWABoLBoMUDq+5kUW0ZaP096u7209e9AlwoAkJeBxcCBA3X77bdr/vz5bt6KjRs3asyYMW7SvJtuuimnm0NOEFgAKEzqnStdN00qV0fatVZ6t5O0YnqgSwUAyKuuUPfdd5+Sk5PVoUMHxcXFuW5RsbGxLrC49dZbc7o55ASBBYDCplID6brp0vi+0ro50pjLpG7DpdOvC3TJAAC5bbGwVooHH3xQO3fu1B9//KF58+Zp27Ztevzxx3O6KRzrqFDFGWoWQCFSooLUb4LU9ArJk+TNvZg0REpKDHTJAAC5abHwKVKkiBo1anSsb8exoMUCQGFlw9T2fF2qWF+a/pg0f4S0Y6V06UipaOlAlw4AcCyBxf79+/XMM89o+vTp2rp1q+sW5W/VqlVUbL4HFoyMAqAQioiQ2t4lla8nfXGjtGKqNLKLdMV4qezxgS4dABR6OQ4srrvuOs2aNUtXXXWVqlWr5rpGoYDQYgEA0sk9vUPWjusjbV3qHTGq9zip5unUDgCEUmAxadIkffPNN25CIxQwAgsA8KrRXBr4vTS2t7RliTT6fG9XqVMupYYAIFSSt8uVK6fy5UkeLnCWpHjw8ASExSsU/P4BINiUOU66ZrLUoKuUdEj67Fpp5rOSxxPokgFAoZTjwMJGf3rkkUfcULMoQAcOjwilCKlYWaoeAExsSe+s3K0Geetj5lPS5wOlhIPUDwAEe1eo559/XitXrlSVKlVUu3ZtxcTEpHp90aJFeVk+pO0GVaycFBlFvQCAj/0mdnlSqniCdyjaJZ9Iu9ZJvcZIJStRTwAQrIFFz54986ckyBz5FQCQueZXS+VqSx/3k9bPl95pL13xsVT5JGoOAIIxsBg6dGj+lASZI7AAgKzVPUe6dpo09nLpv9XSu52ly0ZJ9TtSewAQbDkW/fv31w8//JA/pUHGCCwAIHsqNfCOGFWrjXRojzTmcmnB29QeAARbYLF792517NhRJ5xwgp566ilt2LAhf0qGDAILRuQCgCzZb+VVX0hNr5A8SdK3d0vf3usdYQ8AkC9yHFhMmDDBBRM33XSTxo8f7xK4u3btqk8//VQJCQn5U0pIcYdHhWKoWQDInuhY79wWHQ534V3wpjSut3RwDzUIAMEQWJhKlSpp8ODB+u233zR//nzVr1/fzcRdvXp13XnnnVq+fHnel7SwoysUAORcRITUdrB0+ftSdDFpxVRpZBfpv7XUJgAEQ2Dhs2nTJk2dOtXdoqKi1K1bNy1ZskSNGjXSiy++mHelBIEFAORGox7SgG+lklWlrUuldzpI6xdQpwAQyMDCujt99tln6t69u2rVqqVPPvlEd9xxhzZu3Kj33ntP06ZN08cff6zHHnssL8sJWiwAIHdqnOZN6q56irR/mzS6u7TkU2oVAAI13Gy1atWUnJysPn36aMGCBWrWrNlR65x77rkqW5bZofMUgQUA5F6ZGtKAyd7ZuZd9K312rbRjhdRuiLfbFACg4AIL6+J02WWXqWjRohmuY0HF6tWrj71UyCR5m1GhACBXYktKvT6Upg2V5rwizXxa2r5c6vGaFJPx3zYAQB53hbIkbf+gYu3atVq6dKlrxUA+STgoxe/zPmZUKADIvcgoqfMT0gUvS5HR0h+fSu9dIO3bRu0CQH4HFiNHjtQLL7yQatn111+vunXr6pRTTlHjxo21fv36Yy0HMnPgcGuF/fErWoa6AoC80ry/1Pdz72/rvwukd9pLW5ZSvwCQn4HFW2+9pXLlyqU8nzx5skaNGqX3339fP//8s+v+9Oijjx5LGZCT/Ar6AANA3qrbTrpuulS+rrRrnfRuZ2n5NGoZAPIrsLC5KVq0aJHyfOLEierRo4euvPJKnXbaaW4W7unTp+d0/8gOErcBIH9VPMEbXNRqI8XvlcZeJs1/i1oHgPwILA4cOKDSpUunPJ8zZ47OPvvslOfWJWrz5s052Teyi8ACAPKfDY5x1QSp2ZWSJ1madI/07T1SUiK1DwB5GVjYnBULFy50j7dv364///xTbdq0SXndgooyZej/ny8YEQoACkZ0Ee/oUB2HeZ8veEsa10s6uIdvAADyarjZ/v3765ZbbnEBxffff6+GDRuqefPmqVowLIEb+WD/du89I0IBQP6zXLaz7pTK15M+v15aMc2bd3HFeKlcLb4BAMhtYHHvvfcqLi5On3/+uapWrepm3Pb3008/uUnzkA/oCgUABa/RhVLZmtLY3tK2v6S320t9xkk1z+DbAIDcBBaRkZF67LHH3C09aQMN5CECCwAIjOqnSgO/l8b1ljb/Lo3uLvV8XTrlUr4RAMjtBHkIAAILAAicMjWkAZOkE8+Xkg5Jn10rzXxG8nj4VgDAD4FFKCB5GwACK7ak1OsDqfVt3uczn5Y+u05KOMg3AwCHEViEAlosACDwIqOkzo9LF7wsRUZLf3wqvddd2rc10CUDgKBAYBHsrKmdwAIAgkfz/lLfz6WiZaR/f5be7iBtWRroUgFAwBFYBLv4/d4+vYbhZgEgONRtJ133vVS+rrR7nXc42uVTA10qAAitwCIpKUnvvvuurrjiCnXs2FHt27dPdTsWr732mmrXrq2iRYuqZcuWWrBgQbbe99FHHykiIkI9e/ZU2PK1VkQXlWKKB7o0AACfivWl66ZLtc6S4vdKYy+X5r9J/QAotHIcWNx+++3uZgGGTYjXtGnTVLecGj9+vAYPHqyhQ4dq0aJFbhtdunTR1q2Z91lds2aN7r77brVt21Zhzb8blE3aBAAIHsXLS1d9ITXrK3mSpUn3St/cLSUlBrpkABC881j4txJ8/PHH6tatW54U4IUXXtDAgQM1YMAA93zEiBH65ptvNHLkSN13333pvseCmiuvvFKPPvqoZs+erV27dilsMSIUAAS36CJSj1eliidI04ZJP78t7VwlXTbKm4cBAIVEjgOLIkWKqH79+nmy8/j4eC1cuFD3339/qon4rIvV3LlzM3yfTdJXuXJlXXvttS6wyMyhQ4fczWfPnj3uPiEhwd3yi2/bud1HxN4t7ktKLlZBSflY3mCWV3VZ2FGP1GWwCbtjsuUtiihTW1ETb1TEyunyvNNJib3GSmVr5fuuw64uA4R6pC6DTUIQ/N/Oyb4jPJ6czfDz/PPPa9WqVXr11VddfkNubNy4UTVq1NCcOXPUqlWrlOX33nuvZs2apfnz5x/1nh9//FG9e/fW4sWLVbFiRV199dWuxWLChAnp7mPYsGGuZSOtsWPHqnjx4M9ZqLt1sk7ZMFb/ljtTC2vfHOjiAACyUCZutVqueknFEv7ToehSml/nDv1X8gTqDUBIiouLc7nVu3fvVunSpfO2xcJO7GfMmKFJkybp5JNPVkxMTKrXP//8c+WXvXv36qqrrtLbb7/tgorssNYQy+Hwb7GoWbOmOnfunGXl5Da6mzp1qjp16nRUHeVE5MzF0gapWr1T1K1L3nQ/CzV5VZeFHfVIXQabsD4m91wsz8dXKHbLErVdNVxJ3f8nT+NL8213YV2XBYh6pC6DTUIQ/N/29fbJjhwHFmXLltVFF12kvGDBQVRUlLZs2ZJquT2vWrXqUeuvXLnSJW1fcMEFKcuSk5PdfXR0tJYtW6Z69eqlek9sbKy7pWVfTkF8Qbnez8H/3F1UyUqKKuR/LArqOwt31CN1GWzC8piscLx07RTp8+sV8ffXip54o7RrtXTO/fk6EEdY1mUAUI/UZbCJCeD/7ZzsN8eBxahRo5RXLF+jefPmmj59esqQsRYo2PNBgwYdtX7Dhg21ZMmSVMseeugh15Lxv//9z7VEhO+oUOUDXRIAQE4UKSFd/oE0fZj00/+kWc9KO1ZIPV6TYopRlwDCTo4Di7xm3ZT69++vFi1a6IwzztBLL72k/fv3p4wS1a9fP5eH8fTTT7t5LmyI27QtKCbt8vAbFapCoEsCAMipyEip02NShfrS13dKf3wm7Von9R4rlaxMfQIIK8cUWHz66aduyNl169a5kZ382VwUOdGrVy9t27ZNjzzyiDZv3qxmzZpp8uTJqlKlinvd9mEjRRVacdu99wQWABC6Tusnlasjje8r/fuz9HYH6YrxUpVGgS4ZAOSZHJ+xv/zyy641wU78f/31V9fKUKFCBTdSVNeuXY+pENbtae3atW5YWBsJymbf9pk5c6ZGjx6d4XvttYxGhAq7CfIAAKGrTlvvTN3l60m710nvdpb++S7QpQKAwAUWr7/+ut566y298sorLkfChoa1bPXbbrvNDUOFPGSJ6XSFAoDwUbG+dN00qXZbKX6vNK6XNP/NQJcKAAITWFjXpNatW7vHxYoVc4nTxoaBHTduXN6UCl6HdkueJO9jkrcBIDzY73nfz6VT+0qeZGnSvdI3d0tJiYEuGQAUbGBhw8Du3OlNKD7++OM1b94893j16tXK4Vx7yIqvtaJIKSn66CFzAQAhKrqIdOGr3sRuRUg/vy2NvUw6SMs/gEIUWLRv315ffvmle2y5FnfeeaebtMOSsPNqfgscxlCzABC+bD6LNrdLvT6UYopLK7/35l38tybQJQOAghkVyvIrfJPS3XLLLS5xe86cObrwwgt1ww03HFspkD4StwEg/J3UXRowSRrXW9r2t3fEKBuO9vgjA5kAQFgGFjb0q//wr71793Y35AMCCwAoHKo3kwZ+7w0uNv0mvdfdO5Fek8sDXTIAyLZjmiBi9uzZ6tu3r1q1aqUNGza4ZR988IF+/PHHY9kcMkJgAQCFR+nq3paLht2lpHjp84HS909K5C8CCNfA4rPPPlOXLl3ciFA2j4XNPWFsqNmnnnoqP8pYeBFYAEDhUqSEdPkH3twL88Nw6dNrpIQDgS4ZAOR9YPHEE09oxIgRevvttxUTE5OyvE2bNjmedRvZDCxKMDkeABQa1t3YRouyUaMio6U/P5dGd5f2bgl0yQAgbwOLZcuW6eyzzz5qeZkyZbRr166cbg6ZYXI8ACi8TrtKumqCVLSstOEX6Z0O0pY/A10qAMjbeSxWrFhx1HLLr6hbt25ON4fM0BUKAAq3Om29Sd3l60m713uHo/3nu0CXCgDyJrAYOHCgbr/9ds2fP18RERHauHGjxowZo7vvvls33XRTTjeHzBBYAAAq1JOumybVbivF75PG9ZLmjSCpG0DoDzd73333uXksOnTooLi4ONctKjY21gUWt956a/6UsrAisAAAmOLlpb6fS98Mln79QJo8RNqxXDrvWSkqx3/KASBf5PjXyFopHnzwQd1zzz2uS9S+ffvUqFEjlSxZMn9KWFglJUoHDuesFCd5GwAKvegi0oWvSBUbSFMfkX5+R9q5Srp0lBRdotBXD4DAO+bLHEWKFHEBBfLJQQsqPBbKeRP3AACIiJDa3CaVr+ud52Ll9968i8vHUDcAQiewuOaaa7K13siRI3NTHqTtBlWsLM3cAIDUTuouXTNZGttb2r5M0aO7qHwNy3PsRk0BCP7AYvTo0apVq5ZOPfVUeZgFNP/t3+69pxsUACA91ZpKA6dL43orYtNvar3iGXmWVJdOu5L6AhDcgYWN+DRu3DitXr1aAwYMUN++fVW+fPn8LV1hRuI2ACArpatLAyYp+bOBilr2jfTlzdKu1dI5D3gn2gOAApTtX53XXntNmzZt0r333quvvvpKNWvW1OWXX64pU6bQgpEfCCwAANlRpISSLhml5ZXP9z7/4Tnps2ukhAPUH4AClaPLGTasbJ8+fTR16lQtXbpUJ598sm6++WbVrl3bjQ6F/AgsaBUCAGQhIlJLa/RSYveXpcgY6c8vpNHnS3u3UHUACswxt5NGRka6oWct3yIpKSlvSwUpbqe3FsixAABkk6fpFVK/CVKxctKGhdI7HaTNf1B/AIIvsDh06JDLs+jUqZMaNGigJUuW6NVXX9W6deuYxyKv0RUKAHAsap8lXTddqlBf2r1eGtlF+mcKdQkgeAIL6/JUrVo1PfPMM+revbvWr1+vTz75RN26dXOtF8hjBBYAgGNVoZ507VSpdlspfp8bOUrz3pAY1RFAMIwKNWLECB1//PGqW7euZs2a5W7p+fzzz/OyfIUXgQUAIDcsR++qL6RvBkuL3pcm3ydt/0fqOlyKiqFuAQQusOjXr5/LqUABIbAAAOSWBRAXvCxVbCB997D0y0hp52rpstHeCVgBIFAT5KEAkbwNAMgLdlGw9a1S+brSZ9dJq2ZI73aWrhgvla9DHQPIMyRHBKPEQ1L8Xu9jRoUCAOSFhudL10yWSlWXti/zjhi1di51CyDPEFgEc2tFRJRUtEygSwMACBfVmkoDv5eqNfN2uX3/Qum3jwJdKgBhgsAi2PMryGsBAOSl0tWkAZOkky6QkuKlL26Qpj8uJSdTzwByhcAiGJG4DQDIT0WKS5e9L511p/f57P+TPrtGSjhAvQM4ZgQWwYjAAgCQ32wOqo7DpB6vS5Ex0p9fSKPPl/Zuoe4BHBMCi6AOLMoHuiQAgHB36pVSvwlSsXLShoXS2+2lzX8EulQAQhCBRTBiqFkAQEGqfZZ03XSpQn1pz7/SyC7SP1P4DgDkCIFFMIrb7r1nqFkAQEGpUE+6bppU52wpfp80rrc093XJ4+E7AJAtBBbBiBwLAEAgWHeovp9Lp/WXPMnSlPulr++UkhL4PgBkicAiGBFYAAACJSpGuuB/UucnbEIlaeEoacxl0oFdfCcAMkVgEYwILAAAgWRzKLW+Veo9VoopIa2aIb3bSdq5iu8FQIYILII6eZtRoQAAAdSwm3TNZKlUdWn7P9LbHaS1c/hKAKSLwCLYWJIcLRYAgGBRrYk08Hup+qnSgZ3S+z2kxeMCXSoAQYjAItgkxEmJB72PGRUKABAMSleTrv5WOulCKSlemnCjNP1xKTk50CUDEEQILIKNr7UiKlYqUiLQpQEAwKtIcemy96SzBnufz/4/6dMBUnwcNQTAIbAI1sCiREVv8hwAAMEiMlLqOFTq+YYUGSMtnSCNPl/auznQJQMQBAgsgk1KfgWJ2wCAINXsCqnfRO+8FxsXeZO6Ny8JdKkABBiBRdCOCFUh0CUBACBjtdtI102XKpwg7flXGnmetGwyNQYUYgQWwYYRoQAAoaJCPem6qVKddlL8Pmlcb2nua94RDgEUOgQWwYbAAgAQSqw7VN/PpOZX25jp0pQHpK/vkJISAl0yAAWMwCLYEFgAAEJNVIzU/SWp85M2bbe0cLQ05lLpwK5AlwxAASKwCDYEFgCAUGQjGbYeJPUZJ8WUkFbNlN7tJO1cFeiSASggBBZBm7zNqFAAgBB0YlfpmslS6RrS9n+8I0atnRPoUgEoAAQWwYYWCwBAqKvWRBr4vVT9VOnATum9C6XF4wJdKgD5jMAi2BBYAADCQamq0tXfSo16SMkJ0oQbpemPScnJgS4ZgHxCYBFMbHg+AgsAQLgoUly6dLTU9i7v89nPS59eLcXHBbpkAPIBgUUwObhbSk70Pi5GjgUAIAxERkodHpF6jpAiY6SlE6XR3aS9mwNdMgB5LDqvN4hjsGu9t6Vi97/e59HFpG1/H3ndZuEuW5OqBQCErmZ9pHK1pI+ulDb+Kr3dXurzkTcfA0BYILAIhqDi1eZS4qEjyxIPSG+1O/I8OlYatJDgAgAQ2mq1lgZOl8b28o4YNfI86dJ3vSNJAQh5dIUKNGup8A8q0mOv+3IvAAAIZeXrStd+J9VpJyXsl8b1kea86s0zBBDSCCwAAEDBKlZO6vuZ1HyAjVwiffeg9PUdUlIC3wQQwggsAABAwYuKkbq/KHV5yqbtlhaOlj68RDrwH98GEKIILAAAQGBEREitbpH6jJNiSkirZ0nvdJJ2rOQbAUIQgQUAAAgsS96+dopU+jhpx3LpnQ7Smp/4VoAQQ2ABAAACr+op3hGjqp/m7Q71fg9p8dhAlwpADhBYAACA4FCqqnT1N1KjHlJygjThJmnao1JycqBLBiAbCCwCzSa/s3kqMmOv23oAAIS7IsWlS0dLbe/2Pv/xBemT/lJ8XKBLBiALTJAXaDajtk1+t26u9PlAqWg5qd+E1Osw8zYAoDCJjJQ6PCxVqC99eav015fS7vXembqtVQNAUKLFIliCi+ii3scV60vVm6W+2esAABQ2zfpI/b+UipWXNv4qvd1e2vR7oEsFIAMEFsFi11rvfdnjA10SAACCR63W3qTuig2kPRukkedJf38b6FIBSAeBRbD4zxdY1Ap0SQAACC7l60rXTpXqniMl7Jc+ukKa84rk8QS6ZAD8EFgEi13rvPflCCwAADhKsbLSlZ9KzQdI8kjfPSR9dbuUlEBlAUGCwCJY0BUKAIDMRcVI3V+Uujxt03ZLi96TPrzYO+8FgIAjsAgG1pTra7GgKxQAABmLiJBa3ewdIapISWn1D9I7HaUdK6k1IMAILILB/u1Sgo3PHSGVOS7QpQEAIPideJ50zRSp9HHSjhXSOx2kNT8FulRAoUZgEUzdoEpXz3qyPAAA4FW1sTTwe6lGc293qPd7SL+OoXaAACGwCKr8ChK3AQDIkVJVpKu/kRr1lJITpIk3S9OGScnJVCRQGAOL1157TbVr11bRokXVsmVLLViwIMN13377bbVt21blypVzt44dO2a6fmgNNcscFgAA5FhMMenSUdLZ93if//ii9Ek/Kd66GQMoNIHF+PHjNXjwYA0dOlSLFi1S06ZN1aVLF23dujXd9WfOnKk+ffpoxowZmjt3rmrWrKnOnTtrw4YNCvkWC4aaBQDg2ERGSu0fki56U4oqIv31lTSqq7RnEzUKFJbA4oUXXtDAgQM1YMAANWrUSCNGjFDx4sU1cuTIdNcfM2aMbr75ZjVr1kwNGzbUO++8o+TkZE2fPl0hixGhAADIG017S/2+lIpXkDYtlt5uL236jdoFCkC0Aig+Pl4LFy7U/fffn7IsMjLSdW+y1ojsiIuLU0JCgsqXL5/u64cOHXI3nz179rh7e4/d8otv29nZR/R/a2w8KCWWqi5PPpYpVOWkLkE9FgSOSeox2HBMplG9hXT1FEWP76OIHcvlGXmeknq+KU+DrtQjx2RISQiCc6Cc7DvC47FJFAJj48aNqlGjhubMmaNWrVqlLL/33ns1a9YszZ8/P8ttWOvFlClT9Oeff7ocjbSGDRumRx999KjlY8eOdS0jAedJVvffrlOUJ1HfnfyCDhSpGOgSAQAQFqIT9+v0Na+p8t4/5FGE/qzeSysrd/XOhQEg2xfxr7jiCu3evVulS5cO3haL3HrmmWf00UcfubyL9IIKY60hlsPh32Lhy8vIqnJyG91NnTpVnTp1UkxMTMYr7tmkqMWJ8kRE6dwLr5AiQ/orCWxdgnosIByT1GOw4ZjMRFJPJX13v6IWjVbjjR+pUeVoJXUZ7s3DoB45JoNcQhCcA/l6+2RHQM9iK1asqKioKG3ZsiXVcntetWrVTN/7f//3fy6wmDZtmpo0aZLherGxse6Wln05BfEFZbmffd6k84gyxykmtli+lyeUFdR3Fu6oR+oy2HBMUpf5fIBJF7wkVW4oTXlAkYs/VKQNmtLrA6lYOY7JfMb/79Cvx5zsN6DJ20WKFFHz5s1TJV77ErH9u0alNXz4cD3++OOaPHmyWrRooZDmS9xmRCgAAPKHdX068yapz0dSkZLSmtnSOx2lHSupcSAPBbzfjXVT6t+/vwsQzjjjDL300kvav3+/GyXK9OvXz+VhPP300+75s88+q0ceecTlSNjcF5s3b3bLS5Ys6W6hOzkec1gAAJCvGnSRrpkijest7VghvdNBOv8FqXxd7+uJiSoTt8Y7ilT04VMkG12qbE2+GBScXeuluB0heUwGPLDo1auXtm3b5oIFCxJsGFlriahSpYp7fd26dW6kKJ833njDjSZ16aWXptqOzYNhidqhOzle7UCXBACA8Fe1sXTddOmjPtKGhdKn3guZxjp8nGMPlvmtHx0rDVoYtCdyCMOg4tXmUuKhkDwmAx5YmEGDBrlbeiwx29+aNWsUVmixAACgYJWqIl39jTSuj7RqRubr2gmeXT0OwpM4hKG4HSlBRSgekwGfIK/QY9ZtAAAKXkwxqcNQah4ItxaLQispUdrtHRVKZWsFujQAABQu2Z3PYtowqVhZKcOpvzJYnulUYcfynow2lcNyHct7cvhZopKTdea2rYr66P106jkPy3Us7wnW78XjkeL3KZQRWATSng2SJ0mKipVKenNKAABAkMmquxTS7RLjzmyyPwUCwgCBRVDkV9SU/BLUAQBAEGl9m1TmOGviSP/1nM7knen6Od1HgNbP4j2JSUn6/fff3Vxj0VFRQVGmnK1fENuPOHrRf2ukaaHbRY/AIhjmsGCoWQAAglfjS6TqzQJdipDiSUjQ+g1ldErTbt5JCpE9GxcrlHGZPCiGmiW/AgAAAKGNwCKQGBEKAIDAsYnGbE6AzNjrth5QEIqH9jFJV6hAoisUAACBYzmONtHY4VmOExIT9dNPP6lNmzaKCYFZjhGGyob2MUlgEUjMug0AQGDZCZrvJC0hQbuLb5CqNSUvAByTx4CuUIFisybu3eR9TPI2AAAAQhyBRaDs/tc7QUpMcalExYAVAwAAAMgLBBaBYuMU+0aEyukYygAAAECQIbAIFBK3AQAAEEYILAKFoWYBAAAQRggsAoXJ8QAAABBGCCwCha5QAAAACCMEFoFCVygAAACEEQKLQIjfL+3f5n3MHBYAAAAIAwQWgbBrvfc+toxUrFxAigAAAADkJQKLgHaDOj4guwcAAADyGoFFQBO3awVk9wAAAEBei87zLSLj7k9xO7yP1y/w3scUlzYu9j4uXkEqW5PaAwAAQEgisCiooOLV5lLiodTLl3zsvblvIlYatJDgAgAAACGJrlAFwVoq0gYVadnrvhYNAAAAIMQQWAAAAADINQILAAAAALlGYAEAAAAg1wgsAAAAAOQagQUAAACAXCOwAAAAAJBrBBYFwSa/s3kqMmOv23oAAABACGKCvIJgM2rb5HeZzVPBzNsAAAAIYQQWBRlc2A0AAAAIQ3SFAgAAAJBrBBYAAAAAco3AAgAAAECuEVgAAAAAyDUCCwAAAAC5RmABAAAAINcILAAAAADkGoEFAAAAgFwjsAAAAACQawQWAAAAAHKNwAIAAABArhFYAAAAAMg1AgsAAAAAuUZgAQAAACDXCCwAAAAA5BqBBQAAAIBcI7AAAAAAkGsEFgAAAAByjcACAAAAQK4RWAAAAADINQILAAAAALlGYAEAAAAg1wgsAAAAAOQagQUAAACAXIvO/SaQE0nJHi1YvVNb9x5U5VJFdUad8oqKjKASAQAAENIILArQ5D826dGvlmrT7oMpy6qVKaqhFzTSeY2rFWRRAAAAgDxFV6gCDCpu+nBRqqDCbN590C231wEAAIBQRWBRQN2frKXCk85rvmX2uq0HAAAAhCICiwJgORVpWyr8WThhr9t6AAAAQCgix6IAWKJ2dmzefUBzV+7IUWI3yeAAAAAIBgQWBcCChOx4/Ju/tHN/fLYTu0kGBwAAQLCgK1QBsJYHCxKyGlTWP6jIKrGbZHAAAAAEEwKLAmDdmazlweRkxgpfKvewr5YqLj5R8YnJSkhK1qGEJA37smCTwW1b1k1r4uIN7p5EcwAAAPijK1QBse5Mb/Q97ah5LMqXiNHO/QkZvs9zuOWi0SNTsr0v/2TwVvUq5LrsdLkCAABAVggsCji46NSoaqqZtzfvOag7xy/Ol/1t3XMw1wnfvi5Xads+fN20LFhicj8AAAAQWBQwO4H3b0WwbkXZ8W7/FmpRu7xrjliwZocGvr8wy/c8Pelvbdh9QJecdpyqlC6a49aHrObfsFDEXrdgKb3AhBGrqAeOh6Px/wIAEK4ILIIksdtaANI7gbfT9apliuqcEyunnLy3b1gl0/f43metIcMnL9Pz3/2jcxpUUv0qJfXWrFXZan2wXI6vf9uY7fk30na5ovsU9cDxcDT+XwAAwhnJ20Gc2O17bq/7twhk9R67vdirmYZf2kQtapVzV0in/71Vb6YTVBjP4dvgj39T/5Hzdc5zM3TSw5N158e/ZeszjJi10p0wbd93yD1nxCov6oF68MfxkJr9Ls1fvVMLt0e4ewaEQKBxTCLYJIXg7yQtFkGc2F01k3kssvuey1vU1Iqt+/S/6f/oq9+OHrbWX1x8kmb9sz3leUxUhBKSsj6IZ/2zzd1MnQrFtXnPoWPuPhUuctuNLFxQD9RD1i03UXp/+S9ZztsD5CeOSQSbySH6Oxnh8XgCHv689tpreu6557R582Y1bdpUr7zyis4444wM1//kk0/08MMPa82aNTrhhBP07LPPqlu3btna1549e1SmTBnt3r1bpUuXVn5JSEjQt99+68oVExOTb32vs/seGyb29o+yThLvdXpN9WxWQ7UrFlfFErE6+7kZmXa5Kls8Rt1OqaqFa3Zp2Za9yq7Ta5dThRKxKc896ezBd2TaIWrHRtWqVaWI1J8t/aM3421ltlZ6/xXSDQw8Wa/z3/5DWrJhj7LSuHpplS1eJJ39Zu8zZLQ8/fd7tGPHTpUvX14RfvWY4Q9ANrebcRmkvQcT9M+WfcpKvUolVDLWe53D47dN3/6OHAv+rx/ZacrrfuunXc/9m7JemuWZ7O/IPo6sn+zx6ODBgyoaW9RFian351dbhx/HJyVr78HELOuhZrliKlM8RjFRkYqJjFR0VIT38eH7aLfc9/jIa2754de8j49exz2PTP1akcPbjI6MUJFo7713/TTbP/w+/+PmWGU0IIRvywwIUXB/c8AxmZ84JsPndzIn584Bb7EYP368Bg8erBEjRqhly5Z66aWX1KVLFy1btkyVK1c+av05c+aoT58+evrpp9W9e3eNHTtWPXv21KJFi9S4cWOFU2J3Xr4nu7N/W1Dhvz2LjO3gtoPZk87B/czFp6Qc3Lvi4vX6jBV6a/bqLPfz85r/lDORWvLfVoWbPzZmHXzkrQhpT07rPv+t3LZfoSdCu+O93f/yyvr/DrhbsLLA40jAkTroSAl8UoKYI8GKLbcgJipSmrp0a6Zz8Nz9yW/67d9dbrvudyYiwt1H2n3E4e6edp/y/Mhy3zret0UoMmX9w+sc3pb/+7zreFdMtR//bad5n3uPt3CHt+H3eqr1jyz3raNU2/D/TGkeH/V5/OvgSNl9ZUhKTNTWA9LanXEqEh2T8r7IyKM/c0b15quHlLJl8r7Unzl0W11pVUWwSQrxHg8Bb7GwYOL000/Xq6++6p4nJyerZs2auvXWW3XfffcdtX6vXr20f/9+ff311ynLzjzzTDVr1swFJ6HcYpHfB+pZz36fZZL4j0PaH3Wg5iTh1Ea56vP2vCzLc02b2qpbqWTqMqTz/8P+dCUlJemPP5aoceNTFBUVddR66f23ymhb6SzMxraOXnpUbkuaBdb97PWZK5WVW86tpwZVSmW5XmZlSa886ZUpKTFJv/76q0477VRFRaW+ppDReUF26zajtf/ZslcvTP1HWbm7cwOdVK30kZMo37YOn/h49+t95DuZ8V/Pd4LkXwzfCZB/yXwnb2m3o3S2k9n+kpIS9dNPP6pNm7MUExN99P7SlOG39bt0z6e/Z1kPD3Q7SSdUKanEJI8bQMF78yjR7pM9SkhMVmKyd5m9dmQ9z+Hlfuv7bSPR3pvOa7bcJt6099q24v22aa8B2ZU2KMo4IDsSYKUOFv2CMb8A8kgA4/1PFRmZOijKOiA7Egim9759BxO0fGvWFzZOqlZKZYpl/bc83b8z2ay/gnhPQZYxOdmj7du3qVKlSscUfB5rwHos7zr2ujzG90Vk/M7/9sfr1/W7stzGuIFn5slcZWHVYhEfH6+FCxfq/vvvT1kWGRmpjh07au7cuem+x5ZbC4c/a+GYMGFCvpc3lPkSvjNrfUibJJ7Z/BsZdbnK7ihXD56f/r4yDNK2/a5upx8XFEFadgO5L37dkGU9DO50YoFdcbB61HqPujauWmD12KlRFY1bsC7LerjpnPpBeeUls7pcW0I6uXrpbNVlvUolXYCVVT1ce1adoKkHu+aUUUCSebCSrPhEz1HBij1ftPY/TVi8Mct9n31CRXfhwbqc+bqo2b031jm8zD33dl5L6cZ21DLvc6Xahm+bvm5rHrdd+7y+Ze49fttNTj7yfl+XuiP78d67sqXZxpH9eLeXdlmqx/6v+3UDdWVTxu/zL7sdl1HR0SnbSHlfmm349pO3x4uvbvw3HD7B6V+bst/VF/4itWx39obVR87Y+VgwCmhgsX37dnc1ukqVKqmW2/O///473fdYX/v01rfl6Tl06JC7+UddOvwD7E608olv2/m5j5zqcGJFvdK7qZ749m+XYO1TtUysHuza0L2eWXlbHG9RqjdSTU5KVHJS+us92PVE3frRbxkGMPZ6Zu8PhbrMjryuh9wKVD0GWz0Eqi5DtR5iIiTXKBPtG0Qw6pi3VbdCsWwFFte3ra2Wdcof834KIzsWp06dqk6d2ufowoEvUEkbkHkyC+r8gyfvRlKCK/8ALdXj9IKcVNtIvS/f4+wEZOkGg57MA07fdpZt3quXvs+6dXnQOXV1QuWSmddltmv96O8gx+855n0d4/uO4T3WsrtkyR+um3p0VFTQfr6McgfzY18mq7et2rZfb/+4Jou1pArFowvs73lO9hPwHIv8ZrkYjz766FHLv/vuOxUvXjzf928/9MFmSCNp5Z4I7UmQSsdI9UrvV9Lahfp2bd7tY0CDCH2+JlK74o9cfS1TxKOLaycf876CsS4DUQ+5FYh6DMZ6CERdhms9ZJed7JUtEqVd8fYsvZYZj8oWkbYtnadv/yr48oWDUPydDKRa2Twm6x38R1qfT91iFJ4svD29kqQtSwJdlJDSKAh/J+Pi4kIjsKhYsaLrM79ly5ZUy+25GwEoHbY8J+tbNyv/rlPWYmE5HJ07d873HAvv1aNOIdN9Jy/ZGF33Jnv0y9r/tHXvIVUuFevm1DiWbh6hXJd5WQ+5Fch6DKZ6CGRdhls9HIuY2ltcy43SbbmJ0BMXN1WXk1O3SiO8fycDjWMyf3BMhs8x6evtE/SBRZEiRdS8eXNNnz7djezkS96254MGDUr3Pa1atXKv33HHHSnL7MfUlqcnNjbW3dKyH96C+PEtqP0EI/vUZzXIuwM/VOsyr+shVOsx2OohUHUZjvWQE92bHafo6KgczduD8P+dDCSOyfzFMRn6x2ROflMC3hXKWhP69++vFi1auLkrbLhZG/VpwIAB7vV+/fqpRo0arkuTuf3229WuXTs9//zzOv/88/XRRx/pl19+0VtvvRXgTwIAyA7fgBBzV2zVd7Pnq3PblmpVv3KharlBcOGYRLA5L0R/JwMeWNjwsdu2bdMjjzziErBt2NjJkyenJGivW7fOjRTl07p1azd3xUMPPaQHHnjATZBnI0KF+hwWAFCY2B9HS9De8ZfH3Qf7H0uEP45JBJtQPCYDHlgY6/aUUdenmTNnHrXssssuczcAAAAAweFIUwAAAAAAHCMCCwAAAAC5RmABAAAAINcILAAAAADkGoEFAAAAgFwjsAAAAACQawQWAAAAAHKNwAIAAABArhFYAAAAAMg1AgsAAAAAuRatQsbj8bj7PXv25Ot+EhISFBcX5/YTExOTr/sKd9Ql9RhsOCapx2DDMUk9BhuOyfCpR985s+8cOjOFLrDYu3evu69Zs2agiwIAAACEzDl0mTJlMl0nwpOd8COMJCcna+PGjSpVqpQiIiLyNbqz4GX9+vUqXbp0vu2nMKAuqcdgwzFJPQYbjknqMdhwTIZPPVqoYEFF9erVFRmZeRZFoWuxsAo57rjjCmx/dhAQWFCXwYRjkroMNhyT1GWw4ZikLoNN6QCfT2bVUuFD8jYAAACAXCOwAAAAAJBrBBb5JDY2VkOHDnX3oC6DAcckdRlsOCapy2DDMUldBpvYEDufLHTJ2wAAAADyHi0WAAAAAHKNwAIAAABArhFYAAAAAMg1Aot88tprr6l27doqWrSoWrZsqQULFuTXrsLC008/rdNPP91NXFi5cmX17NlTy5YtS7XOOeec4yY19L/deOONAStzsBo2bNhR9dSwYcOU1w8ePKhbbrlFFSpUUMmSJXXJJZdoy5YtAS1zMLL/v2nr0W5Wd4bjMWM//PCDLrjgAjeZktXZhAkTUr1uqX2PPPKIqlWrpmLFiqljx45avnx5qnV27typK6+80o3bXrZsWV177bXat2+fCpPM6jEhIUFDhgzRKaecohIlSrh1+vXr5yaAzeo4fuaZZ1TYZHVMXn311UfV03nnnZdqHY7JrOsxvd9Muz333HMp63BMKlvnPNn5W71u3Tqdf/75Kl68uNvOPffco8TERAUSgUU+GD9+vAYPHuyy+BctWqSmTZuqS5cu2rp1a37sLizMmjXL/QeaN2+epk6d6v5odu7cWfv370+13sCBA7Vp06aU2/DhwwNW5mB28sknp6qnH3/8MeW1O++8U1999ZU++eQTV+92InLxxRcHtLzB6Oeff05Vh3ZcmssuuyxlHY7H9Nn/W/vdswss6bH/ty+//LJGjBih+fPnuxNj+420P6Q+FlT8+eefrt6//vprd0Jz/fXXqzDJrB7j4uLc35eHH37Y3X/++efuxOTCCy88at3HHnss1bF86623qrDJ6pg0Fkj419O4ceNSvc4xmXU9+tef3UaOHOkCCzsp9lfYj8lZ2TjnyepvdVJSkgsq4uPjNWfOHL333nsaPXq0u2gTUDYqFPLWGWec4bnllltSniclJXmqV6/uefrpp6nqbNq6dauNVuaZNWtWyrJ27dp5br/9duowC0OHDvU0bdo03dd27drliYmJ8XzyyScpy/766y9X13PnzqVuM2HHXr169TzJyckcjzlgx9YXX3yR8tzqr2rVqp7nnnsu1XEZGxvrGTdunHu+dOlS976ff/45ZZ1JkyZ5IiIiPBs2bCiUx2naekzPggUL3Hpr165NWVarVi3Piy++WAAlDO267N+/v6dHjx4ZvodjMnv1mJbVafv27VMt45jM+pwnO3+rv/32W09kZKRn8+bNKeu88cYbntKlS3sOHTrkCRRaLPKYRY4LFy50Tfs+kZGR7vncuXPzendha/fu3e6+fPnyqZaPGTNGFStWVOPGjXX//fe7q3Y4mnUrsabqunXruqts1lxq7Ni0KyP+x6d1kzr++OM5PrP4f/3hhx/qmmuucVffOB6P3erVq7V58+ZUx2CZMmVcl1Hfb6TdW/enFi1apKxj69tvqbVwIOPfTTs+re78Wdcn605x6qmnui4pge4qEaxmzpzpupOceOKJuummm7Rjx46U1zgmc8667XzzzTeuG2NaHJOZn/Nk52+13VtXyCpVqqSsYy2/e/bsca29gRIdsD2Hqe3bt7vmKf8v2tjzv//+O2DlCiXJycm644471KZNGxdA+FxxxRWqVauWO2H+/fffXf9ia/q3LgA4wk7QrDnU/jhaE/Ojjz6qtm3b6o8//nAndEWKFDnqxMOOT3sN6bN+xLt27XL9sDkec8d3nKX3G+l7ze7tBM9fdHS0+6PLcZo+60Zmv4l9+vRxeSk+t912m0477TRXd9Zdwi7I2O/CCy+8kMtvMrxYNyjrZlKnTh2tXLlSDzzwgLp27epO3qKiojgmj4F1zbEcgrRdbTkmsz7nyc7fartP73fU91qgEFgg6Fi/QzsJ9s8LMP79qy1Kt8TPDh06uD8C9erVC0BJg5P9MfRp0qSJCzQsIPv4449doixy7t1333X1akGtD8cjgoVd2bz88stdUvwbb7yR6jXL9/P/PbCTlRtuuMElj4bKTL4FoXfv3qn+vlhd2d8Va8WwvzPIOcuvsBZzG8TGH8dk9s55QhVdofKYddOxqxtpM/ftedWqVfN6d2Fn0KBBLlFzxowZOu644zJd106YzYoVKwqodKHJrng0aNDA1ZMdg9atx66+++P4zNjatWs1bdo0XXfddZnWM8dj9vh+BzP7jbT7tINdWPcdG5WH39H0gwo7Ti0J1L+1IqPj1OpyzZo12fzGCifrRmp/z31/Xzgmc2b27NmuR0FWv5uF/ZgclME5T3b+Vtt9er+jvtcChcAij9nVoObNm2v69OmpmrnseatWrfJ6d2HDrrTZf7AvvvhC33//vWuOzsrixYvdvbVcIGM2RKe16lg92bEZExOT6vi0H3/LweD4TN+oUaNctxwbfYPjMffs/7b90fM/Bq1PsOVO+I5Bu7c/qNbP2Md+F+y31BfA4UhQYTlVFvxaHkV2fjctVyVtVzOk9u+//7ocC9/fF47JnLfy2t8bG0GKYzLn5zzZ+Vtt90uWLEl1EcZ3caFRo0YKmICljYexjz76yI1wMnr0aDeSxPXXX+8pW7Zsqsx9pHbTTTd5ypQp45k5c6Zn06ZNKbe4uDj3+ooVKzyPPfaY55dffvGsXr3aM3HiRE/dunU9Z599NlWZxl133eXq0erpp59+8nTs2NFTsWJFN+qEufHGGz3HH3+85/vvv3f12apVK3fD0WxEN6urIUOGpFrO8Zi5vXv3en799Vd3sz8zL7zwgnvsG63omWeecb+J9v/4999/dyPH1KlTx3PgwIGUbZx33nmeU0891TN//nzPjz/+6DnhhBM8ffr0KVSHaWb1GB8f77nwwgs9xx13nGfx4sWpfjd9I8LMmTPHjQhlr69cudLz4YcfeipVquTp16+fp7DJrC7ttbvvvtuNtmO/m9OmTfOcdtpp7pg7ePBgyjY4JrP+v212797tKV68uBuhKC2Oyeyd82Tnb3ViYqKncePGns6dO7v/45MnT3b/v++//35PIBFY5JNXXnnFHRBFihRxw8/Omzcvv3YVFuwHKr3bqFGj3Ovr1q1zQUT58uVd0Fa/fn3PPffc437AkFqvXr081apVc8dejRo13HM7Efaxk7ebb77ZU65cOffjf9FFF7kfNBxtypQp7jhctmxZquUcj5mbMWNGuv+fbUhP35CzDz/8sKdKlSru/3OHDh2OquMdO3a4QKJkyZJu+MQBAwa4k5rCJLN6tBPgjH437X1m4cKFnpYtW7oTmKJFi3pOOukkz1NPPZXqZLmwyKwu7WTOTs7spMyG+LThUAcOHHjUxUCOyaz/b5s333zTU6xYMTdkalock9k758nu3+o1a9Z4unbt6urbLiDahcWEhARPIEXYP4FrLwEAAAAQDsixAAAAAJBrBBYAAAAAco3AAgAAAECuEVgAAAAAyDUCCwAAAAC5RmABAAAAINcILAAAAADkGoEFAAAAgFwjsAAAHGX06NEqW7ZspjUzbNgwNWvWLNN1rr76avXs2TMkPg8AIHcILACgEMnoRH/mzJmKiIjQrl273PNevXrpn3/+UaiYNWuW2rdvr/Lly6t48eI64YQT1L9/f8XHx4fk5wGAUERgAQA4SrFixVS5cuWQqJmlS5fqvPPOU4sWLfTDDz9oyZIleuWVV1SkSBElJSWF3OcBgFBFYAEAyFbXoWeeeUZVqlRRqVKldO211+rgwYOpXreT+MGDB7v3VahQQffee688Hk+qdZKTk/X000+rTp067mS/adOm+vTTT49qOZk+fboLFKz1oXXr1lq2bFmG39J3332nqlWravjw4WrcuLHq1avnAo23337b7SO9z1O7dm23n7Q3n/Xr1+vyyy9377FWkB49emjNmjUcKQCQCQILAECWPv74Y5dT8dRTT+mXX35RtWrV9Prrr6da5/nnn3cn8CNHjtSPP/6onTt36osvvki1jgUV77//vkaMGKE///xTd955p/r27eu6Mvl78MEH3fZsX9HR0brmmmsyLJsFFZs2bXKtFdn1888/u/fY7d9//9WZZ56ptm3butcSEhLUpUsXF0DNnj1bP/30k0qWLOmCFV/XKgBAOjwAgEKjf//+nqioKE+JEiVS3YoWLWpNC57//vvPrTdq1ChPmTJlUt7XqlUrz80335xqWy1btvQ0bdo05Xm1atU8w4cPT3mekJDgOe644zw9evRwzw8ePOgpXry4Z86cOam2c+2113r69OnjHs+YMcOVY9q0aSmvf/PNN27ZgQMH0v1MiYmJnquvvtqtU7VqVU/Pnj09r7zyimf37t0p66T9PP5uu+02T61atTxbt251zz/44APPiSee6ElOTk5Z59ChQ55ixYp5pkyZkkUNA0DhRYsFABQy5557rhYvXpzq9s4772T6nr/++kstW7ZMtaxVq1Ypj3fv3u2u/vuvYy0N1p3JZ8WKFYqLi1OnTp1cC4DvZi0YK1euTLXtJk2apDy21hGzdevWdMsWFRWlUaNGuZYH6w5Vo0YN17Jy8sknuzJl5q233tK7776rL7/8UpUqVXLLfvvtN1dWa7HwldG6Q1nXr7TlBAAcEe33GABQCJQoUUL169dPtcxOyvPbvn373P0333zjTv79xcbGpnoeExOT8tiX+2D5GZmxbV511VXu9vjjj6tBgwauy9Wjjz6a7vozZszQrbfeqnHjxqUKZKyczZs315gxY456jy/4AAAcjRYLAECWTjrpJM2fPz/Vsnnz5qU8LlOmjGtZ8F8nMTFRCxcuTHneqFEjF0CsW7fOBTb+t5o1a+bpt1CuXDlXnv3796f7urVIXHrppXrggQd08cUXp3rttNNO0/Lly90oUmnLaZ8TAJA+WiwAAFm6/fbb3RwY1rWpTZs27mq+JV/XrVs31To2cpTNIdGwYUO98MILKfNiGOtadPfdd7uEbWt9OOuss1wXKkuOLl26tJt34li8+eabrjvXRRdd5EaEsi5L1r3KymfDzqZ14MABXXDBBTr11FN1/fXXa/PmzakSwa+88ko999xzbiSoxx57TMcdd5zWrl2rzz//3I10Zc8BAEcjsAAAZMkmmLP8AjuxthP3Sy65RDfddJOmTJmSss5dd93lchosQIiMjHQjOdnJvgUPPtZFyboT2ehQq1atcsO5WguBtRwcqzPOOMONQnXjjTdq48aNLifC8ismTJigdu3aHbX+li1b9Pfff7tb9erVU71mw+PaELc2wtSQIUNca8bevXtdN6sOHTq4AAgAkL4Iy+DO4DUAAAAAyBZyLAAAAADkGoEFAAAAgFwjsAAAAACQawQWAAAAAHKNwAIAAABArhFYAAAAAMg1AgsAAAAAuUZgAQAAACDXCCwAAAAA5BqBBQAAAIBcI7AAAAAAkGsEFgAAAACUW/8PiOtEXlBqGg8AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "npz = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\github_neuroai\\results\\size_comparison\\CDM_results\\pid_sweep_cdm\\sweep_results.npz\"\n",
+    ")\n",
+    "\n",
+    "hidden_sizes = [2,4,8,12,16,20,40,60,80,100,150,200]\n",
+    "\n",
+    "coh_syn = []\n",
+    "ctx_syn = []\n",
+    "\n",
+    "for h in hidden_sizes:\n",
+    "    coh_syn.append(np.mean(npz[f\"h{h}_coherence_synergy\"]))\n",
+    "    ctx_syn.append(np.mean(npz[f\"h{h}_context_synergy\"]))\n",
+    "\n",
+    "plt.figure(figsize=(8,5))\n",
+    "\n",
+    "plt.plot(hidden_sizes, coh_syn, marker='o', label=\"Coherence Synergy\")\n",
+    "plt.plot(hidden_sizes, ctx_syn, marker='s', label=\"Context Synergy\")\n",
+    "\n",
+    "plt.xlabel(\"Hidden Size\")\n",
+    "plt.ylabel(\"Mean Synergy\")\n",
+    "plt.title(\"Synergy vs Hidden Size\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "b3cef5ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "npz = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\github_neuroai\\results\\size_comparison\\CDM_results\\pid_sweep_cdm\\sweep_results.npz\"\n",
+    ")\n",
+    "\n",
+    "hidden_sizes = [2,4,8,12,16,20,40,60,80,100,150,200]\n",
+    "\n",
+    "heatmap = np.array([\n",
+    "    npz[f\"h{h}_context_synergy\"]\n",
+    "    for h in hidden_sizes\n",
+    "])\n",
+    "\n",
+    "plt.figure(figsize=(10,6))\n",
+    "\n",
+    "plt.imshow(\n",
+    "    heatmap,\n",
+    "    aspect=\"auto\",\n",
+    "    origin=\"lower\"\n",
+    ")\n",
+    "\n",
+    "plt.colorbar(label=\"Context Synergy\")\n",
+    "\n",
+    "plt.yticks(\n",
+    "    np.arange(len(hidden_sizes)),\n",
+    "    hidden_sizes\n",
+    ")\n",
+    "\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Hidden Size\")\n",
+    "plt.title(\"Context Synergy Dynamics\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "913b032f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# -----------------------------\n",
+    "# Load data\n",
+    "# -----------------------------\n",
+    "npz = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\github_neuroai\\results\\size_comparison\\CDM_results\\pid_sweep_cdm\\sweep_results.npz\"\n",
+    ")\n",
+    "\n",
+    "hidden_sizes = [2, 4, 8, 12, 16, 20, 40, 60, 80, 100, 150, 200]\n",
+    "\n",
+    "# -----------------------------\n",
+    "# Collect summary statistics\n",
+    "# -----------------------------\n",
+    "mi = []\n",
+    "red = []\n",
+    "syn = []\n",
+    "uniq1 = []\n",
+    "uniq2 = []\n",
+    "\n",
+    "for h in hidden_sizes:\n",
+    "\n",
+    "    # Context PID\n",
+    "    mi.append(\n",
+    "        np.mean(npz[f\"h{h}_coherence_mi_joint\"])\n",
+    "    )\n",
+    "\n",
+    "    red.append(\n",
+    "        np.mean(npz[f\"h{h}_coherence_redundancy\"])\n",
+    "    )\n",
+    "\n",
+    "    syn.append(\n",
+    "        np.mean(npz[f\"h{h}_coherence_synergy\"])\n",
+    "    )\n",
+    "\n",
+    "    uniq1.append(\n",
+    "        np.mean(npz[f\"h{h}_coherence_unique1\"])\n",
+    "    )\n",
+    "\n",
+    "    uniq2.append(\n",
+    "        np.mean(npz[f\"h{h}_coherence_unique2\"])\n",
+    "    )\n",
+    "\n",
+    "mi = np.array(mi)\n",
+    "red = np.array(red)\n",
+    "syn = np.array(syn)\n",
+    "uniq1 = np.array(uniq1)\n",
+    "uniq2 = np.array(uniq2)\n",
+    "\n",
+    "# =====================================================\n",
+    "# Figure 1: Hidden Size vs PID Components (Line Plot)\n",
+    "# =====================================================\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "\n",
+    "plt.plot(hidden_sizes, mi, marker='o', label='Total MI')\n",
+    "plt.plot(hidden_sizes, red, marker='s', label='Redundancy')\n",
+    "plt.plot(hidden_sizes, syn, marker='^', label='Synergy')\n",
+    "plt.plot(hidden_sizes, uniq1, marker='d', label='Unique 1')\n",
+    "plt.plot(hidden_sizes, uniq2, marker='v', label='Unique 2')\n",
+    "\n",
+    "plt.xlabel(\"Hidden Size\")\n",
+    "plt.ylabel(\"Mean PID Value\")\n",
+    "plt.title(\"CDM Coherence PID vs Hidden Size\")\n",
+    "plt.grid(True)\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"pid_vs_hidden_size.png\", dpi=300)\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "# =====================================================\n",
+    "# Figure 2: Grouped Bar Plot\n",
+    "# =====================================================\n",
+    "\n",
+    "x = np.arange(len(hidden_sizes))\n",
+    "width = 0.16\n",
+    "\n",
+    "plt.figure(figsize=(14, 6))\n",
+    "\n",
+    "plt.bar(x - 2*width, mi, width, label='Total MI')\n",
+    "plt.bar(x - width, red, width, label='Redundancy')\n",
+    "plt.bar(x, syn, width, label='Synergy')\n",
+    "plt.bar(x + width, uniq1, width, label='Unique 1')\n",
+    "plt.bar(x + 2*width, uniq2, width, label='Unique 2')\n",
+    "\n",
+    "plt.xticks(x, hidden_sizes)\n",
+    "\n",
+    "plt.xlabel(\"Hidden Size\")\n",
+    "plt.ylabel(\"Mean PID Value\")\n",
+    "plt.title(\"CDM Coherence PID Components by Hidden Size\")\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "plt.savefig(\"pid_barplot_hidden_size.png\", dpi=300)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "neuroai",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/comparison_summary.png b/size_comparison/CDM_results/pid_sweep_cdm/comparison_summary.png
new file mode 100644
index 0000000..b290946
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/comparison_summary.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h100.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h100.png
new file mode 100644
index 0000000..501cda5
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h100.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h12.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h12.png
new file mode 100644
index 0000000..de4dd9a
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h12.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h150.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h150.png
new file mode 100644
index 0000000..0a88806
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h150.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h16.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h16.png
new file mode 100644
index 0000000..98bac21
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h16.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h2.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h2.png
new file mode 100644
index 0000000..8ee63ef
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h2.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h20.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h20.png
new file mode 100644
index 0000000..4a523ff
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h20.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h200.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h200.png
new file mode 100644
index 0000000..9fbf932
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h200.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h4.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h4.png
new file mode 100644
index 0000000..8234f27
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h4.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h40.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h40.png
new file mode 100644
index 0000000..560410f
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h40.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h60.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h60.png
new file mode 100644
index 0000000..97eee05
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h60.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h8.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h8.png
new file mode 100644
index 0000000..362eae4
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h8.png differ
diff --git a/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h80.png b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h80.png
new file mode 100644
index 0000000..053a3ec
Binary files /dev/null and b/size_comparison/CDM_results/pid_sweep_cdm/pid_timeseries_h80.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/comparison_summary.png b/size_comparison/PDM_results/pid_sweep/comparison_summary.png
new file mode 100644
index 0000000..fec11b4
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/comparison_summary.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h100.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h100.png
new file mode 100644
index 0000000..2dcbe3f
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h100.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h12.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h12.png
new file mode 100644
index 0000000..ce96f77
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h12.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h150.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h150.png
new file mode 100644
index 0000000..34f79e5
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h150.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h16.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h16.png
new file mode 100644
index 0000000..0d810f1
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h16.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h2.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h2.png
new file mode 100644
index 0000000..5706f3b
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h2.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h20.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h20.png
new file mode 100644
index 0000000..2d9fb67
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h20.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h4.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h4.png
new file mode 100644
index 0000000..155c19c
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h4.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h40.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h40.png
new file mode 100644
index 0000000..764e977
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h40.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h60.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h60.png
new file mode 100644
index 0000000..18c3600
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h60.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h8.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h8.png
new file mode 100644
index 0000000..ae93290
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h8.png differ
diff --git a/size_comparison/PDM_results/pid_sweep/pid_timeseries_h80.png b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h80.png
new file mode 100644
index 0000000..c243cbd
Binary files /dev/null and b/size_comparison/PDM_results/pid_sweep/pid_timeseries_h80.png differ
diff --git a/size_comparison/data_loading_ver/check_dataset.ipynb b/size_comparison/data_loading_ver/check_dataset.ipynb
new file mode 100644
index 0000000..0254ed1
--- /dev/null
+++ b/size_comparison/data_loading_ver/check_dataset.ipynb
@@ -0,0 +1,351 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "e96e2740",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "coherence: 9.948979\n",
+      "context: 1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "CDMdata = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\data_generation\\CDM\\seed42\\context\\train.npz\",\n",
+    "    allow_pickle=True\n",
+    ")\n",
+    "\n",
+    "obs = CDMdata[\"observations\"]\n",
+    "labels = CDMdata[\"labels\"]\n",
+    "coh = CDMdata[\"coherences\"]\n",
+    "ctx = CDMdata[\"contexts\"]\n",
+    "periods = CDMdata[\"trial_periods\"]\n",
+    "\n",
+    "i = 0  # pick trial index\n",
+    "\n",
+    "print(\"coherence:\", coh[i])\n",
+    "print(\"context:\", ctx[i])\n",
+    "\n",
+    "T = obs.shape[1]\n",
+    "\n",
+    "plt.figure(figsize=(14, 6))\n",
+    "\n",
+    "# ---- plot a few observation channels ----\n",
+    "for ch in range(min(5, obs.shape[2])):  # first 5 channels\n",
+    "    plt.plot(obs[i, :, ch], label=f\"ch {ch}\")\n",
+    "\n",
+    "# ---- overlay task periods ----\n",
+    "plt.plot(periods[i] * 0.5, label=\"period (scaled)\", alpha=0.6)\n",
+    "\n",
+    "plt.title(f\"Trial {i} | coh={coh[i]:.2f} | ctx={ctx[i]}\")\n",
+    "plt.xlabel(\"time\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "b657e36f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "coherence: 18.367348\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mod1 difference: 0.15746588\n",
+      "mod2 difference: 0.16398159\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(4, 1, figsize=(14, 8), sharex=True)\n",
+    "\n",
+    "i = 2\n",
+    "stim_period = periods[i] == 1\n",
+    "print(\"coherence:\", coh[i])\n",
+    "# observations (sum of first stimulus channels for clarity)\n",
+    "ax[0].plot(obs[i, :, 1], label=\"stim1_mod1\")\n",
+    "ax[0].axhline(np.mean(obs[i, stim_period, 1]), linestyle=\"--\",\n",
+    "              label=f\"mean stim1_mod1={np.mean(obs[i, stim_period, 1]):.3f}\")\n",
+    "ax[0].plot(obs[i, :, 3], label=\"stim1_mod2\")\n",
+    "ax[0].axhline(np.mean(obs[i, stim_period, 3]), linestyle=\"--\",\n",
+    "              label=f\"mean stim1_mod2={np.mean(obs[i, stim_period, 3]):.3f}\")\n",
+    "ax[0].set_title(\"Stimulus channels\")\n",
+    "ax[0].legend()\n",
+    "\n",
+    "ax[1].plot(obs[i, :, 2], label=\"stim2_mod1\")\n",
+    "ax[1].axhline(np.mean(obs[i, stim_period, 2]), linestyle=\"--\",\n",
+    "              label=f\"mean stim2_mod1={np.mean(obs[i, stim_period, 2]):.3f}\")\n",
+    "ax[1].plot(obs[i, :, 4], label=\"stim2_mod2\")\n",
+    "ax[1].axhline(np.mean(obs[i, stim_period, 4]), linestyle=\"--\",\n",
+    "              label=f\"mean stim2_mod2={np.mean(obs[i, stim_period, 4]):.3f}\")\n",
+    "ax[1].set_title(\"Stimulus channels\")\n",
+    "ax[1].legend()\n",
+    "\n",
+    "# labels (decision target)\n",
+    "ax[2].plot(labels[i], color=\"black\")\n",
+    "ax[2].set_title(\"Decision label\")\n",
+    "\n",
+    "# task period\n",
+    "ax[3].plot(periods[i], color=\"gray\")\n",
+    "ax[3].set_title(\"Fixation / Stimulus / Decision\")\n",
+    "ax[3].set_yticks([0,1,2])\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "stim_period = periods[i] == 1\n",
+    "\n",
+    "print(\"mod1 difference:\",\n",
+    "      np.mean(obs[i, stim_period, 1]) -\n",
+    "      np.mean(obs[i, stim_period, 2]))\n",
+    "\n",
+    "print(\"mod2 difference:\",\n",
+    "      np.mean(obs[i, stim_period, 3]) -\n",
+    "      np.mean(obs[i, stim_period, 4]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1dff6b2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: (160000,)\n",
+      "Min: -18.75\n",
+      "Max: 18.75\n",
+      "Unique values: [-18.75       -18.367348   -17.984694   -17.602041   -17.219387\n",
+      " -16.836735   -16.454082   -16.071428   -15.688775   -15.306123\n",
+      " -14.92347    -14.540816   -14.158163   -13.77551    -13.392858\n",
+      " -13.010204   -12.627551   -12.244898   -11.862245   -11.479591\n",
+      " -11.096939   -10.714286   -10.331633    -9.948979    -9.566326\n",
+      "  -9.183674    -8.801021    -8.418367    -8.035714    -7.6530614\n",
+      "  -7.270408    -6.887755    -6.505102    -6.122449    -5.7397957\n",
+      "  -5.357143    -4.9744897   -4.591837    -4.2091837   -3.8265307\n",
+      "  -3.4438775   -3.0612245   -2.6785715   -2.2959185   -1.9132653\n",
+      "  -1.5306122   -1.1479592   -0.7653061   -0.38265306   0.\n",
+      "   0.38265306   0.7653061    1.1479592    1.5306122    1.9132653\n",
+      "   2.2959185    2.6785715    3.0612245    3.4438775    3.8265307\n",
+      "   4.2091837    4.591837     4.9744897    5.357143     5.7397957\n",
+      "   6.122449     6.505102     6.887755     7.270408     7.6530614\n",
+      "   8.035714     8.418367     8.801021     9.183674     9.566326\n",
+      "   9.948979    10.331633    10.714286    11.096939    11.479591\n",
+      "  11.862245    12.244898    12.627551    13.010204    13.392858\n",
+      "  13.77551     14.158163    14.540816    14.92347     15.306123\n",
+      "  15.688775    16.071428    16.454082    16.836735    17.219387\n",
+      "  17.602041    17.984694    18.367348    18.75      ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "coh = CDMdata[\"coherences\"]\n",
+    "\n",
+    "print(\"Shape:\", coh.shape)\n",
+    "print(\"Min:\", coh.min())\n",
+    "print(\"Max:\", coh.max())\n",
+    "print(\"Unique values:\", np.unique(coh))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "38413106",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['observations', 'labels', 'coherences', 'contexts', 'trial_periods']\n",
+      "obs shape: (2000, 115, 7)\n",
+      "coh range: -18.75 18.75\n",
+      "unique contexts: [1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "PDMdata = np.load(\n",
+    "    r\"E:\\TUM\\3sem\\NeuroAI\\project\\data_generation\\PDM\\seed42\\perceptual\\test_uniform.npz\"\n",
+    ")\n",
+    "\n",
+    "print(PDMdata.files)\n",
+    "\n",
+    "obs = PDMdata[\"observations\"]\n",
+    "labels = PDMdata[\"labels\"]\n",
+    "coh = PDMdata[\"coherences\"]\n",
+    "ctx = PDMdata[\"contexts\"]\n",
+    "periods = PDMdata[\"trial_periods\"]\n",
+    "\n",
+    "print(\"obs shape:\", obs.shape)\n",
+    "print(\"coh range:\", coh.min(), coh.max())\n",
+    "print(\"unique contexts:\", np.unique(ctx))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b40fde2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "coherence: -14.158163\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "coherence = -14.158163\n",
+      "mean stim1 = 0.375027\n",
+      "mean stim2 = 0.6181635\n",
+      "difference = -0.24313653\n"
+     ]
+    },
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
+      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
+      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
+      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(4, 1, figsize=(14, 8), sharex=True)\n",
+    "\n",
+    "i = 0\n",
+    "\n",
+    "trial_coh = coh[i]\n",
+    "mean_coh = np.mean(coh)\n",
+    "\n",
+    "stim_period = periods[i] == 1\n",
+    "fig.suptitle(\n",
+    "    f\"Trial {i} | coherence={trial_coh:.3f} | dataset mean coherence={mean_coh:.3f}\",\n",
+    "    fontsize=14\n",
+    ")\n",
+    "print(\"coherence:\", coh[i])\n",
+    "ax[0].plot(obs[i, :, 1], label=\"stim1_mod1\")\n",
+    "ax[0].axhline(np.mean(obs[i, stim_period, 1]), linestyle=\"--\",\n",
+    "              label=f\"mean stim1_mod1={np.mean(obs[i, stim_period, 1]):.3f}\")\n",
+    "ax[0].plot(obs[i, :, 3], label=\"stim1_mod2\")\n",
+    "ax[0].set_title(\"Stimulus channels\")\n",
+    "ax[0].legend()\n",
+    "\n",
+    "ax[1].plot(obs[i, :, 2], label=\"stim2_mod1\")\n",
+    "ax[1].axhline(np.mean(obs[i, stim_period, 2]), linestyle=\"--\",\n",
+    "              label=f\"mean stim2_mod1={np.mean(obs[i, stim_period, 2]):.3f}\")\n",
+    "ax[1].plot(obs[i, :, 4], label=\"stim2_mod2\")\n",
+    "ax[1].set_title(\"Stimulus channels\")\n",
+    "ax[1].legend()\n",
+    "\n",
+    "ax[2].plot(labels[i], color=\"black\")\n",
+    "ax[2].set_title(\"Decision label\")\n",
+    "\n",
+    "ax[3].plot(periods[i], color=\"gray\")\n",
+    "ax[3].set_title(\"Fixation / Stimulus / Decision\")\n",
+    "ax[3].set_yticks([0, 1, 2])\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "\n",
+    "m1 = np.mean(obs[i, stim_period, 1])\n",
+    "m2 = np.mean(obs[i, stim_period, 2])\n",
+    "\n",
+    "print(\"coherence =\", coh[i])\n",
+    "print(\"mean stim1 =\", m1)\n",
+    "print(\"mean stim2 =\", m2)\n",
+    "print(\"difference =\", m1 - m2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "27f9eb2c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "neuroai",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/size_comparison/data_loading_ver/ctrnn_pid_both_tasks.py b/size_comparison/data_loading_ver/ctrnn_pid_both_tasks.py
new file mode 100644
index 0000000..9d167d5
--- /dev/null
+++ b/size_comparison/data_loading_ver/ctrnn_pid_both_tasks.py
@@ -0,0 +1,973 @@
+"""
+ctrnn_pid_both_tasks.py
+=======================
+Train a CTRNN on both PerceptualDecisionMaking and ContextDecisionMaking,
+run time-resolved Gaussian PID analysis on each, and produce comparison plots.
+
+Mirrors your colleague's notebook structure (load NPZ → train with early
+stopping → extract hidden states → PID) but CTRNN only, both tasks, with
+the full PID sweep infrastructure from ctrnn_pid_sweep_cdm.py.
+
+Key design decisions
+--------------------
+- Loads pre-generated NPZ datasets via load_mante_data (same as colleague)
+- Trains with validation loss tracking and early stopping (same as colleague)
+- CTRNN only (no Elman)
+- Both tasks: PDM (input_dim=3) and CDM (input_dim=7)
+- Two PID targets per task:
+    PDM: signed coherence + binary decision label
+    CDM: signed coherence of relevant modality + context label
+- Shared test batch used for all PID analysis (never seen during training)
+- All plots and raw arrays saved to results/
+
+Usage
+-----
+    # With pre-generated NPZ datasets
+    python ctrnn_pid_both_tasks.py \\
+        --pdm_dir data/pdm \\
+        --cdm_dir data/cdm \\
+        --hidden_size 100
+
+    # Without NPZ (falls back to on-the-fly NeuroGym generation)
+    python ctrnn_pid_both_tasks.py --hidden_size 100
+
+    # Quick test run
+    python ctrnn_pid_both_tasks.py --pdm_dir data/pdm --cdm_dir data/cdm \\
+        --hidden_size 20 --num_epochs 5 --n_test_trials 200
+
+Outputs (results/ctrnn_both_tasks/)
+-------------------------------------
+    training_curves.png          — loss curves for both tasks
+    pid_pdm.png                  — time-resolved PID for PDM
+    pid_cdm.png                  — time-resolved PID for CDM
+    comparison_4panel.png        — 2x2 grid: task x PID target
+    results.npz                  — all raw PID arrays + activations
+"""
+
+import argparse
+import copy
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import neurogym as ngym
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Project module imports
+# ──────────────────────────────────────────────────────────────────────────────
+sys.path.append(str(Path(__file__).resolve().parents[3]))
+
+try:
+    from src.models.ctrnn import CTRNN as _ProjectCTRNN
+    from src.analysis.gaussian_pid import gaussian_pid_rnn
+    from src.tasks.data_loader import load_mante_data
+    _USING_PROJECT_MODULES = True
+except ImportError as e:
+    _USING_PROJECT_MODULES = False
+    print(f"[WARN] src/ modules not found ({e}) — using built-in fallbacks.")
+
+print(f"Using project modules: {_USING_PROJECT_MODULES}")
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+RESULTS_DIR = Path(r"E:\TUM\3sem\NeuroAI\project\github_neuroai\results")
+
+WEIGHTS_DIR  = RESULTS_DIR / 'weights'
+WEIGHTS_DIR.mkdir(parents=True, exist_ok=True)
+
+DT           = 20     # ms per timestep
+OUTPUT_DIM   = 3      # fixate / choice1 / choice2
+DEFAULT_SEED = 42
+
+# Task specs
+TASKS = {
+    'pdm': {
+        'name':      'PerceptualDecisionMaking-v0',
+        'input_dim': 3,
+        'timing': {           # fixed timing for PID eval
+            'fixation': 200,  # 10 steps
+            'stimulus': 2000, # 100 steps
+            'delay':    0,
+            'decision': 100,  # 5 steps
+        },
+    },
+    'cdm': {
+        'name':      'ContextDecisionMaking-v0',
+        'input_dim': 7,
+        'timing': {
+            'fixation': 200,  # 10 steps
+            'stimulus': 1000, # 50 steps
+            'delay':    0,    # MUST be 0 — default is stochastic
+            'decision': 100,  # 5 steps
+        },
+    },
+}
+
+PALETTE = {
+    'synergy':    '#54A24B',
+    'redundancy': '#4C78A8',
+    'unique1':    '#F58518',
+    'unique2':    '#E45756',
+    'mi_joint':   '#020202',
+    'stim_end':   '#CC0000',
+    'train':      '#2196F3',
+    'val':        '#FF9800',
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Fallback CTRNN (used when src/models/ctrnn.py is unavailable)
+# ──────────────────────────────────────────────────────────────────────────────
+
+class _FallbackCTRNN(nn.Module):
+    """Euler CT-RNN: h(t+dt) = h + alpha*(-h + tanh(W_in u + W_rec h))"""
+    def __init__(self, input_size, hidden_size, output_size, dt=DT, tau=100):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.alpha = dt / tau
+        self.W_in  = nn.Linear(input_size,  hidden_size, bias=True)
+        self.W_rec = nn.Linear(hidden_size, hidden_size, bias=False)
+        self.W_out = nn.Linear(hidden_size, output_size, bias=True)
+        nn.init.orthogonal_(self.W_rec.weight)
+        nn.init.xavier_uniform_(self.W_in.weight)
+        nn.init.xavier_uniform_(self.W_out.weight)
+        nn.init.zeros_(self.W_in.bias)
+        nn.init.zeros_(self.W_out.bias)
+
+    def forward(self, x):
+        B, T, _ = x.shape
+        h = torch.zeros(B, self.hidden_size, device=x.device)
+        outputs, hiddens = [], []
+        for t in range(T):
+            h = h + self.alpha * (
+                -h + torch.tanh(self.W_in(x[:, t]) + self.W_rec(h))
+            )
+            outputs.append(self.W_out(h))
+            hiddens.append(h)
+        return torch.stack(outputs, 1), torch.stack(hiddens, 1)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Fallback Gaussian analytic PID (MMI-PID, Barrett 2015)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _fallback_gaussian_pid(activations, target, timestep=None,
+                            n_bipartitions=200, seed=DEFAULT_SEED,
+                            regularization=1e-5, **kwargs):
+    rng = np.random.default_rng(seed)
+    N, T, H = activations.shape
+    y = target.astype(np.float64)
+
+    def _mi(X):
+        X_ = X - X.mean(0)
+        y_ = y - y.mean()
+        Sxx = X_.T @ X_ / N + regularization * np.eye(X_.shape[1])
+        Sxy = X_.T @ y_ / N
+        var_y = np.var(y_) + 1e-12
+        try:
+            r2 = float(Sxy @ np.linalg.solve(Sxx, Sxy)) / var_y
+            r2 = np.clip(r2, 0.0, 1 - 1e-9)
+        except np.linalg.LinAlgError:
+            return 0.0
+        return float(-0.5 * np.log(1 - r2) / np.log(2))
+
+    def _pid_at_t(h_t):
+        s, r, u1, u2, m = [], [], [], [], []
+        half = max(H // 2, 1)
+        for _ in range(n_bipartitions):
+            idx = rng.permutation(H)
+            i1, i2 = idx[:half], idx[half:half*2]
+            mi1 = _mi(h_t[:, i1])
+            mi2 = _mi(h_t[:, i2])
+            mij = _mi(h_t[:, np.concatenate([i1, i2])])
+            red = min(mi1, mi2)
+            s.append(max(mij - mi1 - mi2 + red, 0.0))
+            r.append(red)
+            u1.append(max(mi1 - red, 0.0))
+            u2.append(max(mi2 - red, 0.0))
+            m.append(mij)
+        return {k: float(np.mean(v))
+                for k, v in zip(['syn','red','u1','u2','mi'], [s,r,u1,u2,m])}
+
+    def _wrap(d):
+        return {'synergy': d['syn'], 'redundancy': d['red'],
+                'unique1': d['u1'], 'unique2': d['u2'], 'mi_joint': d['mi']}
+
+    if timestep is not None:
+        return _wrap(_pid_at_t(activations[:, timestep].astype(np.float64)))
+
+    out = {k: [] for k in ['syn','red','u1','u2','mi']}
+    for t in range(T):
+        d = _pid_at_t(activations[:, t].astype(np.float64))
+        for k in out:
+            out[k].append(d[k])
+    return {'synergy': np.array(out['syn']), 'redundancy': np.array(out['red']),
+            'unique1': np.array(out['u1']),  'unique2':    np.array(out['u2']),
+            'mi_joint': np.array(out['mi'])}
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Select implementations
+# ──────────────────────────────────────────────────────────────────────────────
+
+_CTRNNBase = _ProjectCTRNN  if _USING_PROJECT_MODULES else _FallbackCTRNN
+_pid_fn    = gaussian_pid_rnn if _USING_PROJECT_MODULES else _fallback_gaussian_pid
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Wrapped CTRNN — uniform (outputs, hidden_states) interface
+# ──────────────────────────────────────────────────────────────────────────────
+
+class WrappedCTRNN(nn.Module):
+    def __init__(self, input_dim, hidden_size):
+        super().__init__()
+        if _USING_PROJECT_MODULES:
+            self.model = _CTRNNBase(input_size=input_dim,
+                                    hidden_size=hidden_size,
+                                    output_size=OUTPUT_DIM)
+        else:
+            self.model = _CTRNNBase(input_size=input_dim,
+                                    hidden_size=hidden_size,
+                                    output_size=OUTPUT_DIM, dt=DT)
+
+    def forward(self, x):
+        """x: (B, T, F) → outputs (B,T,3), hidden_states (B,T,H)"""
+        if _USING_PROJECT_MODULES:
+            outputs, _, hidden_states = self.model(x, return_dynamics=True)
+        else:
+            outputs, hidden_states = self.model(x)
+        return outputs, hidden_states
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Loss
+# ──────────────────────────────────────────────────────────────────────────────
+
+def masked_cross_entropy(outputs, targets, periods=None):
+    """
+    If periods is provided: mask to decision period (periods == 2).
+    Otherwise: mask to any non-zero target (targets != 0).
+    Matches both colleague's approach (periods==2) and fallback (targets!=0).
+    """
+    if periods is not None:
+        mask = (periods == 2)
+    else:
+        mask = (targets != 0)
+
+    if mask.sum() == 0:
+        return torch.tensor(0.0, requires_grad=True, device=outputs.device)
+    return F.cross_entropy(outputs[mask], targets[mask])
+
+
+def masked_accuracy_counts(outputs, targets, periods=None):
+    """Return (correct, total) for decision-period predictions."""
+    if periods is not None:
+        mask = (periods == 2)
+    else:
+        mask = (targets != 0)
+
+    if mask.sum() == 0:
+        return 0, 0
+
+    preds = outputs[mask].argmax(dim=1)
+    correct = (preds == targets[mask]).sum().item()
+    total = int(mask.sum().item())
+    return correct, total
+
+
+def compute_decision_accuracy(model, loader, device):
+    """Evaluate decision-period accuracy on a loader."""
+    model.eval()
+    correct_total = 0
+    total_total = 0
+
+    with torch.no_grad():
+        for batch in loader:
+            obs, labels, periods, cohs, ctxs = batch
+            obs = obs.to(device)
+            labels = labels.to(device)
+            periods = periods.to(device)
+            outputs, _ = model(obs)
+            c, t = masked_accuracy_counts(outputs, labels, periods)
+            correct_total += c
+            total_total += t
+
+    if total_total == 0:
+        return 0.0
+    return correct_total / float(total_total)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Fallback on-the-fly data generator (used when no NPZ provided)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _make_neurogym_generator(task_name, input_dim, batch_size=16, seq_len=130):
+    timing = {'delay': 0}
+    env = ngym.make(task_name, dt=DT, timing=timing)
+    env.reset(seed=DEFAULT_SEED)
+
+    def _gen():
+        obs_b, gt_b = [], []
+        for _ in range(batch_size):
+            env.unwrapped.new_trial()
+            ob = env.unwrapped.ob
+            gt = env.unwrapped.gt
+            T  = ob.shape[0]
+            t  = min(T, seq_len)
+            ob_p = np.zeros((seq_len, input_dim), dtype=np.float32)
+            gt_p = np.zeros((seq_len,), dtype=np.int64)
+            ob_p[:t] = ob[:t, :input_dim]
+            gt_p[:t] = gt[:t]
+            if t < seq_len:
+                ob_p[t:] = ob[-1, :input_dim]
+                gt_p[t:] = gt[-1]
+            obs_b.append(ob_p)
+            gt_b.append(gt_p)
+        # return (B, T, F) and (B, T)
+        return (np.stack(obs_b).astype(np.float32),
+                np.stack(gt_b).astype(np.int64))
+
+    return _gen
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Training — mirrors colleague's train_rnn with early stopping
+# ──────────────────────────────────────────────────────────────────────────────
+
+def train_ctrnn(
+    task_key,
+    hidden_size,
+    device,
+    train_loader=None,
+    val_loader=None,
+    num_epochs=50,
+    lr=1e-3,
+    patience=10,
+    seed=DEFAULT_SEED,
+):
+    """
+    Train a CTRNN with early stopping on validation loss.
+    Accepts either a DataLoader (NPZ path provided) or falls back to
+    on-the-fly NeuroGym generation.
+
+    Returns model (best weights restored), loss history dict.
+    """
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+
+    task_cfg  = TASKS[task_key]
+    input_dim = task_cfg['input_dim']
+
+    model     = WrappedCTRNN(input_dim, hidden_size).to(device)
+    optimizer = optim.Adam(model.parameters(), lr=lr)
+
+    # Fallback generator if no DataLoader
+    ng_gen = None
+    if train_loader is None:
+        print(f"  [INFO] No DataLoader provided — using NeuroGym on-the-fly")
+        ng_gen = _make_neurogym_generator(task_cfg['name'], input_dim)
+
+    best_val_loss     = float('inf')
+    patience_counter  = 0
+    best_weights      = copy.deepcopy(model.state_dict())
+    history           = {'train_loss': [], 'train_acc': [], 'val_loss': [], 'val_acc': []}
+
+    print(f"\n  Training CTRNN | task={task_key} | hidden={hidden_size} | "
+          f"epochs={num_epochs} | patience={patience}")
+
+    for epoch in range(num_epochs):
+        # ── Training ──
+        model.train()
+        train_losses = []
+        train_correct, train_total = 0, 0
+
+        if train_loader is not None:
+            for batch in train_loader:
+                obs, labels, periods, cohs, ctxs = batch
+                obs     = obs.to(device)
+                labels  = labels.to(device)
+                periods = periods.to(device)
+
+                optimizer.zero_grad()
+                outputs, _ = model(obs)
+                loss = masked_cross_entropy(outputs, labels, periods)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                optimizer.step()
+                train_losses.append(loss.item())
+
+                c, t = masked_accuracy_counts(outputs, labels, periods)
+                train_correct += c
+                train_total += t
+
+        else:
+            # On-the-fly: treat one epoch as n_batches mini-batches
+            n_batches = 157
+            for _ in range(n_batches):
+                obs_np, gt_np = ng_gen()
+                obs    = torch.from_numpy(obs_np).to(device)
+                labels = torch.from_numpy(gt_np).to(device)
+
+                optimizer.zero_grad()
+                outputs, _ = model(obs)
+                loss = masked_cross_entropy(outputs, labels)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                optimizer.step()
+                train_losses.append(loss.item())
+
+                c, t = masked_accuracy_counts(outputs, labels)
+                train_correct += c
+                train_total += t
+
+        avg_train = float(np.mean(train_losses))
+        avg_train_acc = train_correct / max(1, train_total)
+        history['train_loss'].append(avg_train)
+        history['train_acc'].append(avg_train_acc)
+
+        # ── Validation ──
+        model.eval()
+        val_losses = []
+        val_correct, val_total = 0, 0
+
+        if val_loader is not None:
+            with torch.no_grad():
+                for batch in val_loader:
+                    obs, labels, periods, cohs, ctxs = batch
+                    obs     = obs.to(device)
+                    labels  = labels.to(device)
+                    periods = periods.to(device)
+                    outputs, _ = model(obs)
+                    val_losses.append(
+                        masked_cross_entropy(outputs, labels, periods).item()
+                    )
+                    c, t = masked_accuracy_counts(outputs, labels, periods)
+                    val_correct += c
+                    val_total += t
+        else:
+            # Validate on a fresh set of on-the-fly trials
+            with torch.no_grad():
+                for _ in range(20):
+                    obs_np, gt_np = ng_gen()
+                    obs    = torch.from_numpy(obs_np).to(device)
+                    labels = torch.from_numpy(gt_np).to(device)
+                    outputs, _ = model(obs)
+                    val_losses.append(
+                        masked_cross_entropy(outputs, labels).item()
+                    )
+                    c, t = masked_accuracy_counts(outputs, labels)
+                    val_correct += c
+                    val_total += t
+
+        avg_val = float(np.mean(val_losses))
+        avg_val_acc = val_correct / max(1, val_total)
+        history['val_loss'].append(avg_val)
+        history['val_acc'].append(avg_val_acc)
+
+        # ── Early stopping ──
+        if avg_val < best_val_loss:
+            best_val_loss    = avg_val
+            patience_counter = 0
+            best_weights     = copy.deepcopy(model.state_dict())
+        else:
+            patience_counter += 1
+
+        if (epoch + 1) % 5 == 0 or epoch == 0:
+            print(f"    Epoch [{epoch+1:03d}/{num_epochs}]  "
+                  f"train_loss={avg_train:.4f}  val_loss={avg_val:.4f}  "
+                  f"train_acc={avg_train_acc:.3f}  val_acc={avg_val_acc:.3f}  "
+                  f"patience={patience_counter}/{patience}")
+
+        if patience_counter >= patience:
+            print(f"    Early stopping at epoch {epoch+1} "
+                  f"(best val={best_val_loss:.4f})")
+            break
+
+    print("    Restoring best weights...")
+    model.load_state_dict(best_weights)
+
+    save_path = WEIGHTS_DIR / f'ctrnn_{task_key}_h{hidden_size}.pth'
+    torch.save(model.state_dict(), save_path)
+    print(f"    Saved → {save_path}")
+
+    return model, history
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Hidden state extraction — mirrors colleague's extract_hidden_trajectories
+# ──────────────────────────────────────────────────────────────────────────────
+
+def extract_hidden_states(model, test_loader, device):
+    """
+    Run the test set through the model and collect:
+        H : (N, T, hidden_size)  hidden states
+        Y : (N,)                 signed coherence (PID target 1)
+        C : (N,)                 context label    (PID target 2, CDM only)
+        P : (N, T)               period labels    (for stim-end detection)
+    """
+    model.eval()
+    H_list, Y_list, C_list, P_list = [], [], [], []
+
+    with torch.no_grad():
+        for batch in test_loader:
+            obs, labels, periods, cohs, ctxs = batch
+            obs = obs.to(device)
+
+            _, hidden = model(obs)           # (B, T, hidden_size)
+            H_list.append(hidden.cpu().numpy())
+
+            # Signed coherence: cohs is (B,) or (B, n_cohs) depending on task
+            if cohs.ndim > 1:
+                Y_list.append(cohs[:, 0].numpy().astype(float))
+            else:
+                Y_list.append(cohs.numpy().astype(float))
+
+            C_list.append(ctxs.numpy())
+            P_list.append(periods.numpy())
+
+    H = np.concatenate(H_list, axis=0)   # (N, T, H)
+    Y = np.concatenate(Y_list, axis=0)   # (N,)
+    C = np.concatenate(C_list, axis=0)   # (N,)
+    P = np.concatenate(P_list, axis=0)   # (N, T)
+    return H, Y, C, P
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Stim-end detection
+# ──────────────────────────────────────────────────────────────────────────────
+
+def find_stim_end(periods):
+    """
+    periods : (N, T) int array with 0=fixation, 1=stimulus, 2=decision
+    Returns the modal last-stimulus-timestep across trials.
+    """
+    stim_ends = []
+    for p in periods:
+        stim_steps = np.where(p == 1)[0]
+        stim_ends.append(stim_steps[-1] if len(stim_steps) > 0 else 0)
+    return int(np.median(stim_ends))
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# PID analysis
+# ──────────────────────────────────────────────────────────────────────────────
+
+def run_pid_analysis(H, Y, C, P, task_key, n_bipartitions=200):
+    """
+    Run time-resolved PID for both targets relevant to the task.
+
+    PDM targets: coherence (Y), binary decision (derived from Y sign)
+    CDM targets: coherence (Y), context label (C)
+
+    Returns dict with keys per target name.
+    """
+    stim_end = find_stim_end(P)
+    results  = {}
+
+    # Define targets depending on task
+    if task_key == 'pdm':
+        targets = [
+            ('coherence', Y.astype(float)),
+            ('decision',  (Y > 0).astype(float)),   # binary: choice1=1, choice2=0
+        ]
+    else:  # cdm
+        targets = [
+            ('coherence', Y.astype(float)),
+            ('context',   C.astype(float)),
+        ]
+
+    for target_name, target_vals in targets:
+        print(f"    PID | target={target_name} | "
+              f"H={H.shape[2]} | T={H.shape[1]} | N={H.shape[0]}")
+
+        pid_out = _pid_fn(
+            activations=H,
+            target=target_vals,
+            timestep=None,
+            n_bipartitions=n_bipartitions,
+            seed=DEFAULT_SEED,
+            log_base=2,
+            regularization=1e-5,
+        )
+
+        results[target_name] = {
+            'synergy':    np.array(pid_out['synergy']),
+            'redundancy': np.array(pid_out['redundancy']),
+            'unique1':    np.array(pid_out['unique1']),
+            'unique2':    np.array(pid_out['unique2']),
+            'mi_joint':   np.array(pid_out['mi_joint']),
+            'stim_end':   stim_end,
+            'seq_len':    H.shape[1],
+        }
+
+        tend = stim_end
+        print(f"      stim_end=t{tend} | "
+              f"Syn={results[target_name]['synergy'][tend]:.4f}b | "
+              f"Red={results[target_name]['redundancy'][tend]:.4f}b")
+
+    return results
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Plotting helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _plot_pid_ax(ax, pid, title, stim_end=None):
+    T    = pid['seq_len']
+    t    = np.arange(T)
+    tend = stim_end if stim_end is not None else pid['stim_end']
+
+    ax.plot(t, pid['mi_joint'],   label='Total MI',   color=PALETTE['mi_joint'],   lw=2,   ls=':')
+    ax.plot(t, pid['synergy'],    label='Synergy',    color=PALETTE['synergy'],    lw=3)
+    ax.plot(t, pid['redundancy'], label='Redundancy', color=PALETTE['redundancy'], lw=3)
+    ax.plot(t, pid['unique1'],    label='Unique 1',   color=PALETTE['unique1'],    lw=1.5, alpha=0.8)
+    ax.plot(t, pid['unique2'],    label='Unique 2',   color=PALETTE['unique2'],    lw=1.5, alpha=0.8)
+
+    ax.axvline(tend, color=PALETTE['stim_end'], ls='--', lw=2,
+               label=f'Stim end (t={tend})')
+    ax.axvspan(0, tend, color='gray', alpha=0.08)
+
+    ax.set_title(title, fontsize=12, fontweight='bold', pad=8)
+    ax.set_xlabel(f'Timestep (dt={DT}ms)', fontsize=10)
+    ax.set_ylabel('Information (bits)', fontsize=10)
+    ax.legend(fontsize=8, loc='upper left')
+    ax.grid(alpha=0.3)
+
+
+def plot_training_curves(histories, save_path):
+    """Plot train/val loss and decision accuracy curves for both tasks."""
+    fig, axes = plt.subplots(2, 2, figsize=(14, 8))
+    fig.suptitle('CTRNN Training Curves', fontsize=14, fontweight='bold')
+
+    for ax_row, (task_key, history) in zip(axes.T, histories.items()):
+        epochs = np.arange(1, len(history['train_loss']) + 1)
+
+        ax_loss, ax_acc = ax_row
+        ax_loss.plot(epochs, history['train_loss'], color=PALETTE['train'], lw=2, label='Train loss')
+        ax_loss.plot(epochs, history['val_loss'], color=PALETTE['val'], lw=2, ls='--', label='Val loss')
+        ax_loss.set_title(f'{task_key.upper()} Task', fontsize=12, fontweight='bold')
+        ax_loss.set_xlabel('Epoch')
+        ax_loss.set_ylabel('Cross-entropy loss')
+        ax_loss.legend(fontsize=9)
+        ax_loss.grid(alpha=0.3)
+
+        ax_acc.plot(epochs, history['train_acc'], color=PALETTE['train'], lw=2, label='Train acc')
+        ax_acc.plot(epochs, history['val_acc'], color=PALETTE['val'], lw=2, ls='--', label='Val acc')
+        ax_acc.set_xlabel('Epoch')
+        ax_acc.set_ylabel('Decision accuracy')
+        ax_acc.set_ylim(0.0, 1.0)
+        ax_acc.grid(alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved → {save_path}")
+
+
+def plot_pid_single_task(pid_results, task_key, hidden_size, save_path):
+    """Two-panel PID plot for one task (one panel per target)."""
+    target_names = list(pid_results.keys())
+    fig, axes = plt.subplots(1, len(target_names), figsize=(8 * len(target_names), 5))
+    if len(target_names) == 1:
+        axes = [axes]
+
+    fig.suptitle(
+        f'CTRNN | {task_key.upper()} | hidden={hidden_size}',
+        fontsize=13, fontweight='bold', y=1.01
+    )
+
+    for ax, tgt in zip(axes, target_names):
+        _plot_pid_ax(ax, pid_results[tgt],
+                     title=f'PID — target: {tgt}')
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved → {save_path}")
+
+
+def plot_comparison_4panel(all_pid, hidden_size, save_path):
+    """
+    2×2 grid matching colleague's notebook layout:
+      Row 0: PDM task  (coherence | decision)
+      Row 1: CDM task  (coherence | context)
+    """
+    fig, axes = plt.subplots(2, 2, figsize=(18, 12), sharey=False)
+    fig.suptitle(
+        f'Information Geometry: Task Comparison  (CTRNN, hidden={hidden_size})',
+        fontsize=16, fontweight='bold', y=0.98
+    )
+
+    panel_map = [
+        (0, 0, 'pdm', 'coherence', 'PDM | Coherence target'),
+        (0, 1, 'pdm', 'decision',  'PDM | Decision target'),
+        (1, 0, 'cdm', 'coherence', 'CDM | Coherence target'),
+        (1, 1, 'cdm', 'context',   'CDM | Context target'),
+    ]
+
+    # Use shared stim_end reference per row
+    stim_end_pdm = all_pid['pdm']['coherence']['stim_end']
+    stim_end_cdm = all_pid['cdm']['coherence']['stim_end']
+    stim_ends    = {0: stim_end_pdm, 1: stim_end_cdm}
+
+    for row, col, task, tgt, title in panel_map:
+        ax  = axes[row, col]
+        pid = all_pid[task][tgt]
+        _plot_pid_ax(ax, pid, title, stim_end=stim_ends[row])
+
+        if col == 0:
+            ax.set_ylabel('Information (bits)', fontsize=11)
+        if row == 1:
+            ax.set_xlabel(f'Timestep (dt={DT}ms)', fontsize=11)
+
+    # Single legend on first panel
+    axes[0, 0].legend(loc='upper left', fontsize=10, framealpha=0.9)
+    for row in range(2):
+        for col in range(1, 2):
+            axes[row, col].get_legend().remove()
+
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved → {save_path}")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Main
+# ──────────────────────────────────────────────────────────────────────────────
+
+def main(
+    hidden_size,
+    pdm_dir,
+    cdm_dir,
+    num_epochs,
+    patience,
+    lr,
+    batch_size,
+    n_test_trials,
+    n_bipartitions,
+):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Device      : {device}")
+    if device.type == 'cuda':
+        print(f"GPU         : {torch.cuda.get_device_name(0)}")
+    print(f"Hidden size : {hidden_size}")
+
+    # ── Build DataLoaders ──
+    loaders = {}
+    for task_key, data_dir in [('pdm', pdm_dir), ('cdm', cdm_dir)]:
+        if data_dir is not None and _USING_PROJECT_MODULES:
+            train_path = os.path.join(data_dir, 'train.npz')
+            val_path   = os.path.join(data_dir, 'val.npz')
+            test_path  = os.path.join(data_dir, 'test_uniform.npz')
+            # fall back to test.npz if test_uniform.npz doesn't exist
+            if not os.path.exists(test_path):
+                test_path = os.path.join(data_dir, 'test.npz')
+
+            input_dim = TASKS[task_key]['input_dim']
+            loaders[task_key] = {
+                'train': load_mante_data(train_path, batch_size=batch_size, shuffle=True, input_dim=input_dim),
+                'val':   load_mante_data(val_path,   batch_size=batch_size, shuffle=False, input_dim=input_dim),
+                'test':  load_mante_data(test_path,  batch_size=batch_size, shuffle=False, input_dim=input_dim),
+            }
+            print(f"  [{task_key}] Loaded NPZ from {data_dir}")
+        else:
+            loaders[task_key] = {'train': None, 'val': None, 'test': None}
+            print(f"  [{task_key}] No NPZ path — using on-the-fly NeuroGym")
+
+    # ── Train both models ──
+    models   = {}
+    histories = {}
+
+    for task_key in ('pdm', 'cdm'):
+        print(f"\n{'='*60}")
+        print(f"  Task: {task_key.upper()}")
+        print(f"{'='*60}")
+
+        model, history = train_ctrnn(
+            task_key   = task_key,
+            hidden_size= hidden_size,
+            device     = device,
+            train_loader = loaders[task_key]['train'],
+            val_loader   = loaders[task_key]['val'],
+            num_epochs   = num_epochs,
+            lr           = lr,
+            patience     = patience,
+        )
+        test_acc = compute_decision_accuracy(model, loaders[task_key]['test'], device)
+        history['test_acc'] = test_acc
+        print(f"  Test decision accuracy: {test_acc:.3f}")
+        models[task_key]    = model
+        histories[task_key] = history
+
+    # ── Plot training curves ──
+    plot_training_curves(
+        histories,
+        save_path=RESULTS_DIR / 'training_curves.png'
+    )
+
+    # ── Extract hidden states and run PID ──
+    all_pid = {}
+
+    for task_key in ('pdm', 'cdm'):
+        print(f"\n{'='*60}")
+        print(f"  PID Analysis: {task_key.upper()}")
+        print(f"{'='*60}")
+
+        model = models[task_key].to('cpu')
+
+        if loaders[task_key]['test'] is not None:
+            print(f"  Extracting hidden states from NPZ test set...")
+            H, Y, C, P = extract_hidden_states(model, loaders[task_key]['test'], 'cpu')
+        else:
+            print(f"  Generating {n_test_trials} test trials on-the-fly...")
+            task_cfg = TASKS[task_key]
+            env = ngym.make(task_cfg['name'], dt=DT, timing=task_cfg['timing'])
+            env.reset(seed=DEFAULT_SEED + 999)
+
+            obs_l, gt_l, coh_l, ctx_l, per_l = [], [], [], [], []
+            for _ in range(n_test_trials):
+                env.unwrapped.new_trial()
+                ob    = env.unwrapped.ob.astype(np.float32)
+                gt    = env.unwrapped.gt.astype(np.int64)
+                trial = env.unwrapped.trial
+
+                # Build period array from gt
+                period = np.zeros(len(gt), dtype=np.int8)
+                fix_steps  = np.where(ob[:, 0] > 0.5)[0]
+                stim_steps = np.where((ob[:, 0] < 0.5) & (gt == 0))[0]
+                dec_steps  = np.where(gt != 0)[0]
+                period[fix_steps]  = 0
+                period[stim_steps] = 1
+                period[dec_steps]  = 2
+
+                # Coherence
+                if task_key == 'pdm':
+                    coh = float(trial.get('coh', 0.0))
+                    gt_label = int(trial.get('ground_truth', 0))
+                    signed_coh = coh if gt_label == 0 else -coh
+                    ctx = 0
+                else:
+                    context   = int(trial.get('context', 0))
+                    coh_0     = float(trial.get('coh_0', trial.get('coh_1', 0.0)))
+                    coh_1     = float(trial.get('coh_1', trial.get('coh_2', 0.0)))
+                    rel_coh   = coh_0 if context == 0 else coh_1
+                    gt_label  = int(trial.get('ground_truth', 1))
+                    sign      = 1 if gt_label == 1 else -1
+                    signed_coh = sign * rel_coh
+                    ctx = context
+
+                obs_l.append(ob)
+                gt_l.append(gt)
+                coh_l.append(signed_coh)
+                ctx_l.append(ctx)
+                per_l.append(period)
+
+            # Pad all trials to the same length
+            max_T = max(o.shape[0] for o in obs_l)
+            F     = obs_l[0].shape[1]
+            obs_pad = np.zeros((n_test_trials, max_T, F), dtype=np.float32)
+            gt_pad  = np.zeros((n_test_trials, max_T), dtype=np.int64)
+            per_pad = np.zeros((n_test_trials, max_T), dtype=np.int8)
+            for i, (ob, gt, per) in enumerate(zip(obs_l, gt_l, per_l)):
+                T = ob.shape[0]
+                obs_pad[i, :T] = ob
+                gt_pad[i,  :T] = gt
+                per_pad[i, :T] = per
+                if T < max_T:
+                    obs_pad[i, T:] = ob[-1]
+                    gt_pad[i,  T:] = gt[-1]
+                    per_pad[i, T:] = per[-1]
+
+            obs_t = torch.from_numpy(obs_pad)
+            model.eval()
+            with torch.no_grad():
+                _, h_seq = model(obs_t)
+            H = h_seq.numpy()
+            Y = np.array(coh_l, dtype=np.float64)
+            C = np.array(ctx_l, dtype=np.int32)
+            P = per_pad
+
+        print(f"  H shape: {H.shape}  Y range: [{Y.min():.1f}, {Y.max():.1f}]")
+
+        pid_results = run_pid_analysis(H, Y, C, P, task_key, n_bipartitions)
+        all_pid[task_key] = pid_results
+
+        # Per-task plot
+        plot_pid_single_task(
+            pid_results, task_key, hidden_size,
+            save_path=RESULTS_DIR / f'pid_{task_key}.png'
+        )
+
+    # ── 4-panel comparison ──
+    plot_comparison_4panel(
+        all_pid, hidden_size,
+        save_path=RESULTS_DIR / 'comparison_4panel.png'
+    )
+
+    # ── Save raw results ──
+    npz_path = RESULTS_DIR / 'results.npz'
+    save_dict = {}
+    for task_key, pid_results in all_pid.items():
+        for tgt, data in pid_results.items():
+            for atom in ('synergy','redundancy','unique1','unique2','mi_joint'):
+                save_dict[f'{task_key}_{tgt}_{atom}'] = data[atom]
+            save_dict[f'{task_key}_{tgt}_stim_end'] = np.array(data['stim_end'])
+    for task_key, history in histories.items():
+        save_dict[f'{task_key}_train_loss'] = np.array(history['train_loss'])
+        save_dict[f'{task_key}_val_loss']   = np.array(history['val_loss'])
+        save_dict[f'{task_key}_train_acc']  = np.array(history['train_acc'])
+        save_dict[f'{task_key}_val_acc']    = np.array(history['val_acc'])
+        save_dict[f'{task_key}_test_acc']   = np.array(history['test_acc'])
+
+    np.savez_compressed(str(npz_path), **save_dict)
+    print(f"\nRaw results → {npz_path}")
+    print("Done.")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# CLI
+# ──────────────────────────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(
+        description='Train CTRNN on PDM + CDM and run Gaussian PID analysis')
+    p.add_argument('--hidden_sizes', nargs='+', type=int, default=[100],
+               help='One or more hidden sizes, e.g. --hidden_sizes 20 50 100')
+    p.add_argument('--pdm_dir',        type=str,   default=None,
+                   help='Directory containing PDM train/val/test NPZ files')
+    p.add_argument('--cdm_dir',        type=str,   default=None,
+                   help='Directory containing CDM train/val/test NPZ files')
+    p.add_argument('--num_epochs',     type=int,   default=50)
+    p.add_argument('--patience',       type=int,   default=10)
+    p.add_argument('--lr',             type=float, default=1e-3)
+    p.add_argument('--batch_size',     type=int,   default=2048)
+    p.add_argument('--n_test_trials',  type=int,   default=2000)
+    p.add_argument('--n_bipartitions', type=int,   default=200)
+    args = p.parse_args()
+
+for h in args.hidden_sizes:
+    print(f"\n{'#'*60}")
+    print(f"  HIDDEN SIZE = {h}")
+    print(f"{'#'*60}")
+    
+    main(
+        hidden_size    = h,
+        pdm_dir        = args.pdm_dir,
+        cdm_dir        = args.cdm_dir,
+        num_epochs     = args.num_epochs,
+        patience       = args.patience,
+        lr             = args.lr,
+        batch_size     = args.batch_size,
+        n_test_trials  = args.n_test_trials,
+        n_bipartitions = args.n_bipartitions,
+    )
\ No newline at end of file
diff --git a/src/analysis/gaussian_pid.py b/src/analysis/gaussian_pid.py
index b6668a2..d09227a 100644
--- a/src/analysis/gaussian_pid.py
+++ b/src/analysis/gaussian_pid.py
@@ -53,7 +53,11 @@
 """
 
 import numpy as np
+import torch
 
+# nats -> bits conversion factor (change of log base). The GPU PID path computes
+# mutual information in nats and converts the returned atoms to bits with this.
+NATS_TO_BITS = 1.0 / np.log(2.0)
 
 # ----------------------------------------------------------------------------- #
 # Low-level helpers
@@ -115,6 +119,20 @@ def _gaussian_mi(cov, idx_a, idx_b):
     return 0.5 * (ld_a + ld_b - ld_ab)                 # Gaussian MI identity (nats)
 
 
+def _build_bipartitions(n_units, n_bip, seed):
+    """Reproduce EXACTLY the (idx1, idx2) split sequence gaussian_pid_rnn draws:
+    np.random.default_rng(seed).permutation(n_units), cut at n_units//2, per split."""
+    rng = np.random.default_rng(seed)
+    cut = n_units // 2
+    idx1 = np.empty((n_bip, cut), dtype=np.int64)             # group-1 unit indices
+    idx2 = np.empty((n_bip, n_units - cut), dtype=np.int64)   # group-2 unit indices
+    for b in range(n_bip):
+        perm = rng.permutation(n_units)
+        idx1[b], idx2[b] = perm[:cut], perm[cut:]
+    return idx1, idx2
+
+
+
 # ----------------------------------------------------------------------------- #
 # Core analytic PID (the function the whole project is built on)
 # ----------------------------------------------------------------------------- #
@@ -396,3 +414,104 @@ def gaussian_pid_rnn(activations, target,
             result[k] = mean_out[k]
             result[k + "_std"] = std_out[k]
     return result
+
+
+
+
+def gaussian_pid_rnn_gpu(H, Y, n_bip=200, seed=0, reg=1e-5, device=None):
+    """
+    GPU-batched, time-resolved Gaussian analytic MMI-PID over RNN activations.
+
+    Fast drop-in for `gaussian_pid_rnn(..., timestep=None, bipartitions="random")`:
+    it returns the same bipartition-averaged PID atoms at every timestep, but is
+    ~40x faster. The trick is that at each timestep the joint covariance over *all*
+    units + target is shared across bipartitions, so it is formed ONCE per timestep
+    on the GPU and only the small per-split sub-block log-determinants are batched.
+    The bipartitions come from `_build_bipartitions`, which replays the exact same
+    RNG sequence as `gaussian_pid_rnn`, so the two paths agree to ~1e-10 bits.
+
+    As in `gaussian_pid`, each column is standardized to unit variance (MI is
+    invariant to this; it only conditions the covariance) and a `reg` ridge is
+    added to the covariance diagonal before the closed-form Gaussian MI and the
+    MMI atoms (Barrett 2015) are computed.
+
+    Parameters
+    ----------
+    H : array_like, shape (n_samples, n_timesteps, n_units)
+        Hidden activations. `n_samples` (trials) is the axis over which the
+        per-timestep covariance is estimated.
+    Y : array_like, shape (n_samples,)
+        Univariate target (e.g. signed coherence / stimulus): one value per trial,
+        shared across timesteps.
+    n_bip : int, optional
+        Number of random balanced (n_units // 2) bipartitions to average over.
+    seed : int, optional
+        Seed for the bipartition RNG. Must match `gaussian_pid_rnn`'s `seed` to
+        reproduce its numbers.
+    reg : float, optional
+        Ridge added to the covariance diagonal for conditioning (the GPU analogue
+        of `gaussian_pid`'s `regularization`).
+    device : torch.device or str or None, optional
+        Torch device to run on. None (default) selects CUDA if available, else CPU.
+
+    Returns
+    -------
+    numpy.ndarray, shape (n_timesteps, 5)
+        Bipartition-averaged PID atoms per timestep, in BITS, with the atom axis
+        ordered [total_mi, redundancy, unique1, unique2, synergy]
+        (total_mi = redundancy + unique1 + unique2 + synergy).
+
+    How to call
+    -----------
+    # Full time-resolved PID profile (trials as samples), univariate target:
+    >>> pid = gaussian_pid_rnn_gpu(acts, stim)     # acts: (trials, T, units)
+    >>> pid.shape                                  # (T, 5)
+    >>> pid[:, 4]                                  # synergy over time (bits)
+    """
+    N, T, U = H.shape
+    idx1, idx2 = _build_bipartitions(U, n_bip, seed)          # identical to reference
+    # pick CUDA when available unless the caller forced a device
+    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") if device is None else device
+
+    # --- standardize each column to unit std (ddof=1); MI is scale-invariant, this
+    #     only conditions the covariance and matches gaussian_pid(standardize=True) ---
+    Ht = torch.tensor(H, dtype=torch.float64, device=dev)
+    Yt = torch.tensor(np.asarray(Y, float), dtype=torch.float64, device=dev)
+    Ht = Ht / Ht.std(dim=0, keepdim=True, unbiased=True).clamp_min(1e-12)
+    Yt = Yt / Yt.std(unbiased=True).clamp_min(1e-12)
+
+    # --- one joint covariance per timestep over [units | target]: (T, U+1, U+1) ---
+    D  = torch.cat([Ht, Yt[:, None, None].expand(N, T, 1)], dim=2)     # (N,T,U+1)
+    Dc = D - D.mean(dim=0, keepdim=True)                              # center per column
+    cov = torch.einsum('nti,ntj->tij', Dc, Dc) / (N - 1)             # sample cov (ddof=1)
+    cov = cov + reg * torch.eye(U + 1, dtype=torch.float64, device=dev)  # ridge (matches reg)
+
+    iy = U                                                            # target column index
+    # quantities that DON'T depend on the bipartition (computed once per timestep):
+    ld_full  = torch.linalg.slogdet(cov)[1]                          # logdet full joint (T,)
+    ld_units = torch.linalg.slogdet(cov[:, :U, :U])[1]               # logdet all-units block
+    ld_y     = torch.log(cov[:, iy, iy])                             # logdet 1x1 target block
+    mi_joint = 0.5 * (ld_units + ld_y - ld_full)                     # I(X1,X2;Y), same all splits
+
+    # index tensors for the per-split source blocks (+ target column appended)
+    i1  = torch.as_tensor(idx1, device=dev)
+    i2  = torch.as_tensor(idx2, device=dev)
+    i1y = torch.cat([i1, torch.full((n_bip, 1), iy, device=dev)], 1)  # group1 + target
+    i2y = torch.cat([i2, torch.full((n_bip, 1), iy, device=dev)], 1)  # group2 + target
+
+    out = np.zeros((T, 5))
+    for t in range(T):                          # loop timesteps -> tiny per-step GPU memory
+        c = cov[t]
+        def bld(idx):                           # batched logdet of (B,k,k) sub-blocks
+            sub = c[idx[:, :, None], idx[:, None, :]]
+            return torch.linalg.slogdet(sub)[1]
+        mi1 = 0.5 * (bld(i1) + ld_y[t] - bld(i1y))          # I(X1;Y) per split (B,)
+        mi2 = 0.5 * (bld(i2) + ld_y[t] - bld(i2y))          # I(X2;Y) per split
+        red = torch.minimum(mi1, mi2)                       # MMI redundancy (Barrett 2015)
+        u1, u2 = mi1 - red, mi2 - red                       # unique atoms
+        syn = mi_joint[t] - mi1 - mi2 + red                 # synergy
+        tot = red + u1 + u2 + syn                           # == mi_joint (consistency)
+        # bipartition-average, then nats -> bits
+        for j, v in enumerate([tot, red, u1, u2, syn]):
+            out[t, j] = v.mean().item() * NATS_TO_BITS
+    return out
\ No newline at end of file
diff --git a/src/models/.gitkeep b/src/models/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/training/.gitkeep b/src/training/.gitkeep
deleted file mode 100644
index e69de29..0000000