diff --git a/.agents/skills/gitnexus/gitnexus-cli/SKILL.md b/.agents/skills/gitnexus/gitnexus-cli/SKILL.md
new file mode 100644
index 0000000..849cb84
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-cli/SKILL.md
@@ -0,0 +1,82 @@
+---
+name: gitnexus-cli
+description: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\""
+---
+
+# GitNexus CLI Commands
+
+All commands work via `npx` — no global install required.
+
+## Commands
+
+### analyze — Build or refresh the index
+
+```bash
+npx gitnexus analyze
+```
+
+Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates AGENTS.md / AGENTS.md context files.
+
+| Flag           | Effect                                                           |
+| -------------- | ---------------------------------------------------------------- |
+| `--force`      | Force full re-index even if up to date                           |
+| `--embeddings` | Enable embedding generation for semantic search (off by default) |
+
+**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Codex, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated.
+
+### status — Check index freshness
+
+```bash
+npx gitnexus status
+```
+
+Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed.
+
+### clean — Delete the index
+
+```bash
+npx gitnexus clean
+```
+
+Deletes the `.gitnexus/` directory and unregisters the repo from the global registry. Use before re-indexing if the index is corrupt or after removing GitNexus from a project.
+
+| Flag      | Effect                                            |
+| --------- | ------------------------------------------------- |
+| `--force` | Skip confirmation prompt                          |
+| `--all`   | Clean all indexed repos, not just the current one |
+
+### wiki — Generate documentation from the graph
+
+```bash
+npx gitnexus wiki
+```
+
+Generates repository documentation from the knowledge graph using an LLM. Requires an API key (saved to `~/.gitnexus/config.json` on first use).
+
+| Flag                | Effect                                    |
+| ------------------- | ----------------------------------------- |
+| `--force`           | Force full regeneration                   |
+| `--model <model>`   | LLM model (default: minimax/minimax-m2.5) |
+| `--base-url <url>`  | LLM API base URL                          |
+| `--api-key <key>`   | LLM API key                               |
+| `--concurrency <n>` | Parallel LLM calls (default: 3)           |
+| `--gist`            | Publish wiki as a public GitHub Gist      |
+
+### list — Show all indexed repos
+
+```bash
+npx gitnexus list
+```
+
+Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information.
+
+## After Indexing
+
+1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded
+2. Use the other GitNexus skills (`exploring`, `debugging`, `impact-analysis`, `refactoring`) for your task
+
+## Troubleshooting
+
+- **"Not inside a git repository"**: Run from a directory inside a git repo
+- **Index is stale after re-analyzing**: Restart Codex to reload the MCP server
+- **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding
diff --git a/.agents/skills/gitnexus/gitnexus-debugging/SKILL.md b/.agents/skills/gitnexus/gitnexus-debugging/SKILL.md
new file mode 100644
index 0000000..9510b97
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-debugging/SKILL.md
@@ -0,0 +1,89 @@
+---
+name: gitnexus-debugging
+description: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\""
+---
+
+# Debugging with GitNexus
+
+## When to Use
+
+- "Why is this function failing?"
+- "Trace where this error comes from"
+- "Who calls this method?"
+- "This endpoint returns 500"
+- Investigating bugs, errors, or unexpected behavior
+
+## Workflow
+
+```
+1. gitnexus_query({query: "<error or symptom>"})            → Find related execution flows
+2. gitnexus_context({name: "<suspect>"})                    → See callers/callees/processes
+3. READ gitnexus://repo/{name}/process/{name}                → Trace execution flow
+4. gitnexus_cypher({query: "MATCH path..."})                 → Custom traces if needed
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] Understand the symptom (error message, unexpected behavior)
+- [ ] gitnexus_query for error text or related code
+- [ ] Identify the suspect function from returned processes
+- [ ] gitnexus_context to see callers and callees
+- [ ] Trace execution flow via process resource if applicable
+- [ ] gitnexus_cypher for custom call chain traces if needed
+- [ ] Read source files to confirm root cause
+```
+
+## Debugging Patterns
+
+| Symptom              | GitNexus Approach                                          |
+| -------------------- | ---------------------------------------------------------- |
+| Error message        | `gitnexus_query` for error text → `context` on throw sites |
+| Wrong return value   | `context` on the function → trace callees for data flow    |
+| Intermittent failure | `context` → look for external calls, async deps            |
+| Performance issue    | `context` → find symbols with many callers (hot paths)     |
+| Recent regression    | `detect_changes` to see what your changes affect           |
+
+## Tools
+
+**gitnexus_query** — find code related to error:
+
+```
+gitnexus_query({query: "payment validation error"})
+→ Processes: CheckoutFlow, ErrorHandling
+→ Symbols: validatePayment, handlePaymentError, PaymentException
+```
+
+**gitnexus_context** — full context for a suspect:
+
+```
+gitnexus_context({name: "validatePayment"})
+→ Incoming calls: processCheckout, webhookHandler
+→ Outgoing calls: verifyCard, fetchRates (external API!)
+→ Processes: CheckoutFlow (step 3/7)
+```
+
+**gitnexus_cypher** — custom call chain traces:
+
+```cypher
+MATCH path = (a)-[:CodeRelation {type: 'CALLS'}*1..2]->(b:Function {name: "validatePayment"})
+RETURN [n IN nodes(path) | n.name] AS chain
+```
+
+## Example: "Payment endpoint returns 500 intermittently"
+
+```
+1. gitnexus_query({query: "payment error handling"})
+   → Processes: CheckoutFlow, ErrorHandling
+   → Symbols: validatePayment, handlePaymentError
+
+2. gitnexus_context({name: "validatePayment"})
+   → Outgoing calls: verifyCard, fetchRates (external API!)
+
+3. READ gitnexus://repo/my-app/process/CheckoutFlow
+   → Step 3: validatePayment → calls fetchRates (external)
+
+4. Root cause: fetchRates calls external API without proper timeout
+```
diff --git a/.agents/skills/gitnexus/gitnexus-exploring/SKILL.md b/.agents/skills/gitnexus/gitnexus-exploring/SKILL.md
new file mode 100644
index 0000000..927a4e4
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-exploring/SKILL.md
@@ -0,0 +1,78 @@
+---
+name: gitnexus-exploring
+description: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\""
+---
+
+# Exploring Codebases with GitNexus
+
+## When to Use
+
+- "How does authentication work?"
+- "What's the project structure?"
+- "Show me the main components"
+- "Where is the database logic?"
+- Understanding code you haven't seen before
+
+## Workflow
+
+```
+1. READ gitnexus://repos                          → Discover indexed repos
+2. READ gitnexus://repo/{name}/context             → Codebase overview, check staleness
+3. gitnexus_query({query: "<what you want to understand>"})  → Find related execution flows
+4. gitnexus_context({name: "<symbol>"})            → Deep dive on specific symbol
+5. READ gitnexus://repo/{name}/process/{name}      → Trace full execution flow
+```
+
+> If step 2 says "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] READ gitnexus://repo/{name}/context
+- [ ] gitnexus_query for the concept you want to understand
+- [ ] Review returned processes (execution flows)
+- [ ] gitnexus_context on key symbols for callers/callees
+- [ ] READ process resource for full execution traces
+- [ ] Read source files for implementation details
+```
+
+## Resources
+
+| Resource                                | What you get                                            |
+| --------------------------------------- | ------------------------------------------------------- |
+| `gitnexus://repo/{name}/context`        | Stats, staleness warning (~150 tokens)                  |
+| `gitnexus://repo/{name}/clusters`       | All functional areas with cohesion scores (~300 tokens) |
+| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens)              |
+| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens)              |
+
+## Tools
+
+**gitnexus_query** — find execution flows related to a concept:
+
+```
+gitnexus_query({query: "payment processing"})
+→ Processes: CheckoutFlow, RefundFlow, WebhookHandler
+→ Symbols grouped by flow with file locations
+```
+
+**gitnexus_context** — 360-degree view of a symbol:
+
+```
+gitnexus_context({name: "validateUser"})
+→ Incoming calls: loginHandler, apiMiddleware
+→ Outgoing calls: checkToken, getUserById
+→ Processes: LoginFlow (step 2/5), TokenRefresh (step 1/3)
+```
+
+## Example: "How does payment processing work?"
+
+```
+1. READ gitnexus://repo/my-app/context       → 918 symbols, 45 processes
+2. gitnexus_query({query: "payment processing"})
+   → CheckoutFlow: processPayment → validateCard → chargeStripe
+   → RefundFlow: initiateRefund → calculateRefund → processRefund
+3. gitnexus_context({name: "processPayment"})
+   → Incoming: checkoutHandler, webhookHandler
+   → Outgoing: validateCard, chargeStripe, saveTransaction
+4. Read src/payments/processor.ts for implementation details
+```
diff --git a/.agents/skills/gitnexus/gitnexus-guide/SKILL.md b/.agents/skills/gitnexus/gitnexus-guide/SKILL.md
new file mode 100644
index 0000000..937ac73
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-guide/SKILL.md
@@ -0,0 +1,64 @@
+---
+name: gitnexus-guide
+description: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\""
+---
+
+# GitNexus Guide
+
+Quick reference for all GitNexus MCP tools, resources, and the knowledge graph schema.
+
+## Always Start Here
+
+For any task involving code understanding, debugging, impact analysis, or refactoring:
+
+1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness
+2. **Match your task to a skill below** and **read that skill file**
+3. **Follow the skill's workflow and checklist**
+
+> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first.
+
+## Skills
+
+| Task                                         | Skill to read       |
+| -------------------------------------------- | ------------------- |
+| Understand architecture / "How does X work?" | `gitnexus-exploring`         |
+| Blast radius / "What breaks if I change X?"  | `gitnexus-impact-analysis`   |
+| Trace bugs / "Why is X failing?"             | `gitnexus-debugging`         |
+| Rename / extract / split / refactor          | `gitnexus-refactoring`       |
+| Tools, resources, schema reference           | `gitnexus-guide` (this file) |
+| Index, status, clean, wiki CLI commands      | `gitnexus-cli`               |
+
+## Tools Reference
+
+| Tool             | What it gives you                                                        |
+| ---------------- | ------------------------------------------------------------------------ |
+| `query`          | Process-grouped code intelligence — execution flows related to a concept |
+| `context`        | 360-degree symbol view — categorized refs, processes it participates in  |
+| `impact`         | Symbol blast radius — what breaks at depth 1/2/3 with confidence         |
+| `detect_changes` | Git-diff impact — what do your current changes affect                    |
+| `rename`         | Multi-file coordinated rename with confidence-tagged edits               |
+| `cypher`         | Raw graph queries (read `gitnexus://repo/{name}/schema` first)           |
+| `list_repos`     | Discover indexed repos                                                   |
+
+## Resources Reference
+
+Lightweight reads (~100-500 tokens) for navigation:
+
+| Resource                                       | Content                                   |
+| ---------------------------------------------- | ----------------------------------------- |
+| `gitnexus://repo/{name}/context`               | Stats, staleness check                    |
+| `gitnexus://repo/{name}/clusters`              | All functional areas with cohesion scores |
+| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members                              |
+| `gitnexus://repo/{name}/processes`             | All execution flows                       |
+| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace                        |
+| `gitnexus://repo/{name}/schema`                | Graph schema for Cypher                   |
+
+## Graph Schema
+
+**Nodes:** File, Function, Class, Interface, Method, Community, Process
+**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS
+
+```cypher
+MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
+RETURN caller.name, caller.filePath
+```
diff --git a/.agents/skills/gitnexus/gitnexus-impact-analysis/SKILL.md b/.agents/skills/gitnexus/gitnexus-impact-analysis/SKILL.md
new file mode 100644
index 0000000..e19af28
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-impact-analysis/SKILL.md
@@ -0,0 +1,97 @@
+---
+name: gitnexus-impact-analysis
+description: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\""
+---
+
+# Impact Analysis with GitNexus
+
+## When to Use
+
+- "Is it safe to change this function?"
+- "What will break if I modify X?"
+- "Show me the blast radius"
+- "Who uses this code?"
+- Before making non-trivial code changes
+- Before committing — to understand what your changes affect
+
+## Workflow
+
+```
+1. gitnexus_impact({target: "X", direction: "upstream"})  → What depends on this
+2. READ gitnexus://repo/{name}/processes                   → Check affected execution flows
+3. gitnexus_detect_changes()                               → Map current git changes to affected flows
+4. Assess risk and report to user
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] gitnexus_impact({target, direction: "upstream"}) to find dependents
+- [ ] Review d=1 items first (these WILL BREAK)
+- [ ] Check high-confidence (>0.8) dependencies
+- [ ] READ processes to check affected execution flows
+- [ ] gitnexus_detect_changes() for pre-commit check
+- [ ] Assess risk level and report to user
+```
+
+## Understanding Output
+
+| Depth | Risk Level       | Meaning                  |
+| ----- | ---------------- | ------------------------ |
+| d=1   | **WILL BREAK**   | Direct callers/importers |
+| d=2   | LIKELY AFFECTED  | Indirect dependencies    |
+| d=3   | MAY NEED TESTING | Transitive effects       |
+
+## Risk Assessment
+
+| Affected                       | Risk     |
+| ------------------------------ | -------- |
+| <5 symbols, few processes      | LOW      |
+| 5-15 symbols, 2-5 processes    | MEDIUM   |
+| >15 symbols or many processes  | HIGH     |
+| Critical path (auth, payments) | CRITICAL |
+
+## Tools
+
+**gitnexus_impact** — the primary tool for symbol blast radius:
+
+```
+gitnexus_impact({
+  target: "validateUser",
+  direction: "upstream",
+  minConfidence: 0.8,
+  maxDepth: 3
+})
+
+→ d=1 (WILL BREAK):
+  - loginHandler (src/auth/login.ts:42) [CALLS, 100%]
+  - apiMiddleware (src/api/middleware.ts:15) [CALLS, 100%]
+
+→ d=2 (LIKELY AFFECTED):
+  - authRouter (src/routes/auth.ts:22) [CALLS, 95%]
+```
+
+**gitnexus_detect_changes** — git-diff based impact analysis:
+
+```
+gitnexus_detect_changes({scope: "staged"})
+
+→ Changed: 5 symbols in 3 files
+→ Affected: LoginFlow, TokenRefresh, APIMiddlewarePipeline
+→ Risk: MEDIUM
+```
+
+## Example: "What breaks if I change validateUser?"
+
+```
+1. gitnexus_impact({target: "validateUser", direction: "upstream"})
+   → d=1: loginHandler, apiMiddleware (WILL BREAK)
+   → d=2: authRouter, sessionManager (LIKELY AFFECTED)
+
+2. READ gitnexus://repo/my-app/processes
+   → LoginFlow and TokenRefresh touch validateUser
+
+3. Risk: 2 direct callers, 2 processes = MEDIUM
+```
diff --git a/.agents/skills/gitnexus/gitnexus-refactoring/SKILL.md b/.agents/skills/gitnexus/gitnexus-refactoring/SKILL.md
new file mode 100644
index 0000000..f48cc01
--- /dev/null
+++ b/.agents/skills/gitnexus/gitnexus-refactoring/SKILL.md
@@ -0,0 +1,121 @@
+---
+name: gitnexus-refactoring
+description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\""
+---
+
+# Refactoring with GitNexus
+
+## When to Use
+
+- "Rename this function safely"
+- "Extract this into a module"
+- "Split this service"
+- "Move this to a new file"
+- Any task involving renaming, extracting, splitting, or restructuring code
+
+## Workflow
+
+```
+1. gitnexus_impact({target: "X", direction: "upstream"})  → Map all dependents
+2. gitnexus_query({query: "X"})                            → Find execution flows involving X
+3. gitnexus_context({name: "X"})                           → See all incoming/outgoing refs
+4. Plan update order: interfaces → implementations → callers → tests
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklists
+
+### Rename Symbol
+
+```
+- [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits
+- [ ] Review graph edits (high confidence) and ast_search edits (review carefully)
+- [ ] If satisfied: gitnexus_rename({..., dry_run: false}) — apply edits
+- [ ] gitnexus_detect_changes() — verify only expected files changed
+- [ ] Run tests for affected processes
+```
+
+### Extract Module
+
+```
+- [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs
+- [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers
+- [ ] Define new module interface
+- [ ] Extract code, update imports
+- [ ] gitnexus_detect_changes() — verify affected scope
+- [ ] Run tests for affected processes
+```
+
+### Split Function/Service
+
+```
+- [ ] gitnexus_context({name: target}) — understand all callees
+- [ ] Group callees by responsibility
+- [ ] gitnexus_impact({target, direction: "upstream"}) — map callers to update
+- [ ] Create new functions/services
+- [ ] Update callers
+- [ ] gitnexus_detect_changes() — verify affected scope
+- [ ] Run tests for affected processes
+```
+
+## Tools
+
+**gitnexus_rename** — automated multi-file rename:
+
+```
+gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
+→ 12 edits across 8 files
+→ 10 graph edits (high confidence), 2 ast_search edits (review)
+→ Changes: [{file_path, edits: [{line, old_text, new_text, confidence}]}]
+```
+
+**gitnexus_impact** — map all dependents first:
+
+```
+gitnexus_impact({target: "validateUser", direction: "upstream"})
+→ d=1: loginHandler, apiMiddleware, testUtils
+→ Affected Processes: LoginFlow, TokenRefresh
+```
+
+**gitnexus_detect_changes** — verify your changes after refactoring:
+
+```
+gitnexus_detect_changes({scope: "all"})
+→ Changed: 8 files, 12 symbols
+→ Affected processes: LoginFlow, TokenRefresh
+→ Risk: MEDIUM
+```
+
+**gitnexus_cypher** — custom reference queries:
+
+```cypher
+MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"})
+RETURN caller.name, caller.filePath ORDER BY caller.filePath
+```
+
+## Risk Rules
+
+| Risk Factor         | Mitigation                                |
+| ------------------- | ----------------------------------------- |
+| Many callers (>5)   | Use gitnexus_rename for automated updates |
+| Cross-area refs     | Use detect_changes after to verify scope  |
+| String/dynamic refs | gitnexus_query to find them               |
+| External/public API | Version and deprecate properly            |
+
+## Example: Rename `validateUser` to `authenticateUser`
+
+```
+1. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
+   → 12 edits: 10 graph (safe), 2 ast_search (review)
+   → Files: validator.ts, login.ts, middleware.ts, config.json...
+
+2. Review ast_search edits (config.json: dynamic reference!)
+
+3. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: false})
+   → Applied 12 edits across 8 files
+
+4. gitnexus_detect_changes({scope: "all"})
+   → Affected: LoginFlow, TokenRefresh
+   → Risk: MEDIUM — run tests for these flows
+```
diff --git a/.claude/skills/gitnexus/gitnexus-cli/SKILL.md b/.claude/skills/gitnexus/gitnexus-cli/SKILL.md
new file mode 100644
index 0000000..c9e0af3
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-cli/SKILL.md
@@ -0,0 +1,82 @@
+---
+name: gitnexus-cli
+description: "Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: \"Index this repo\", \"Reanalyze the codebase\", \"Generate a wiki\""
+---
+
+# GitNexus CLI Commands
+
+All commands work via `npx` — no global install required.
+
+## Commands
+
+### analyze — Build or refresh the index
+
+```bash
+npx gitnexus analyze
+```
+
+Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files.
+
+| Flag           | Effect                                                           |
+| -------------- | ---------------------------------------------------------------- |
+| `--force`      | Force full re-index even if up to date                           |
+| `--embeddings` | Enable embedding generation for semantic search (off by default) |
+
+**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated.
+
+### status — Check index freshness
+
+```bash
+npx gitnexus status
+```
+
+Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed.
+
+### clean — Delete the index
+
+```bash
+npx gitnexus clean
+```
+
+Deletes the `.gitnexus/` directory and unregisters the repo from the global registry. Use before re-indexing if the index is corrupt or after removing GitNexus from a project.
+
+| Flag      | Effect                                            |
+| --------- | ------------------------------------------------- |
+| `--force` | Skip confirmation prompt                          |
+| `--all`   | Clean all indexed repos, not just the current one |
+
+### wiki — Generate documentation from the graph
+
+```bash
+npx gitnexus wiki
+```
+
+Generates repository documentation from the knowledge graph using an LLM. Requires an API key (saved to `~/.gitnexus/config.json` on first use).
+
+| Flag                | Effect                                    |
+| ------------------- | ----------------------------------------- |
+| `--force`           | Force full regeneration                   |
+| `--model <model>`   | LLM model (default: minimax/minimax-m2.5) |
+| `--base-url <url>`  | LLM API base URL                          |
+| `--api-key <key>`   | LLM API key                               |
+| `--concurrency <n>` | Parallel LLM calls (default: 3)           |
+| `--gist`            | Publish wiki as a public GitHub Gist      |
+
+### list — Show all indexed repos
+
+```bash
+npx gitnexus list
+```
+
+Lists all repositories registered in `~/.gitnexus/registry.json`. The MCP `list_repos` tool provides the same information.
+
+## After Indexing
+
+1. **Read `gitnexus://repo/{name}/context`** to verify the index loaded
+2. Use the other GitNexus skills (`exploring`, `debugging`, `impact-analysis`, `refactoring`) for your task
+
+## Troubleshooting
+
+- **"Not inside a git repository"**: Run from a directory inside a git repo
+- **Index is stale after re-analyzing**: Restart Claude Code to reload the MCP server
+- **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding
diff --git a/.claude/skills/gitnexus/gitnexus-debugging/SKILL.md b/.claude/skills/gitnexus/gitnexus-debugging/SKILL.md
new file mode 100644
index 0000000..9510b97
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-debugging/SKILL.md
@@ -0,0 +1,89 @@
+---
+name: gitnexus-debugging
+description: "Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: \"Why is X failing?\", \"Where does this error come from?\", \"Trace this bug\""
+---
+
+# Debugging with GitNexus
+
+## When to Use
+
+- "Why is this function failing?"
+- "Trace where this error comes from"
+- "Who calls this method?"
+- "This endpoint returns 500"
+- Investigating bugs, errors, or unexpected behavior
+
+## Workflow
+
+```
+1. gitnexus_query({query: "<error or symptom>"})            → Find related execution flows
+2. gitnexus_context({name: "<suspect>"})                    → See callers/callees/processes
+3. READ gitnexus://repo/{name}/process/{name}                → Trace execution flow
+4. gitnexus_cypher({query: "MATCH path..."})                 → Custom traces if needed
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] Understand the symptom (error message, unexpected behavior)
+- [ ] gitnexus_query for error text or related code
+- [ ] Identify the suspect function from returned processes
+- [ ] gitnexus_context to see callers and callees
+- [ ] Trace execution flow via process resource if applicable
+- [ ] gitnexus_cypher for custom call chain traces if needed
+- [ ] Read source files to confirm root cause
+```
+
+## Debugging Patterns
+
+| Symptom              | GitNexus Approach                                          |
+| -------------------- | ---------------------------------------------------------- |
+| Error message        | `gitnexus_query` for error text → `context` on throw sites |
+| Wrong return value   | `context` on the function → trace callees for data flow    |
+| Intermittent failure | `context` → look for external calls, async deps            |
+| Performance issue    | `context` → find symbols with many callers (hot paths)     |
+| Recent regression    | `detect_changes` to see what your changes affect           |
+
+## Tools
+
+**gitnexus_query** — find code related to error:
+
+```
+gitnexus_query({query: "payment validation error"})
+→ Processes: CheckoutFlow, ErrorHandling
+→ Symbols: validatePayment, handlePaymentError, PaymentException
+```
+
+**gitnexus_context** — full context for a suspect:
+
+```
+gitnexus_context({name: "validatePayment"})
+→ Incoming calls: processCheckout, webhookHandler
+→ Outgoing calls: verifyCard, fetchRates (external API!)
+→ Processes: CheckoutFlow (step 3/7)
+```
+
+**gitnexus_cypher** — custom call chain traces:
+
+```cypher
+MATCH path = (a)-[:CodeRelation {type: 'CALLS'}*1..2]->(b:Function {name: "validatePayment"})
+RETURN [n IN nodes(path) | n.name] AS chain
+```
+
+## Example: "Payment endpoint returns 500 intermittently"
+
+```
+1. gitnexus_query({query: "payment error handling"})
+   → Processes: CheckoutFlow, ErrorHandling
+   → Symbols: validatePayment, handlePaymentError
+
+2. gitnexus_context({name: "validatePayment"})
+   → Outgoing calls: verifyCard, fetchRates (external API!)
+
+3. READ gitnexus://repo/my-app/process/CheckoutFlow
+   → Step 3: validatePayment → calls fetchRates (external)
+
+4. Root cause: fetchRates calls external API without proper timeout
+```
diff --git a/.claude/skills/gitnexus/gitnexus-exploring/SKILL.md b/.claude/skills/gitnexus/gitnexus-exploring/SKILL.md
new file mode 100644
index 0000000..927a4e4
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-exploring/SKILL.md
@@ -0,0 +1,78 @@
+---
+name: gitnexus-exploring
+description: "Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: \"How does X work?\", \"What calls this function?\", \"Show me the auth flow\""
+---
+
+# Exploring Codebases with GitNexus
+
+## When to Use
+
+- "How does authentication work?"
+- "What's the project structure?"
+- "Show me the main components"
+- "Where is the database logic?"
+- Understanding code you haven't seen before
+
+## Workflow
+
+```
+1. READ gitnexus://repos                          → Discover indexed repos
+2. READ gitnexus://repo/{name}/context             → Codebase overview, check staleness
+3. gitnexus_query({query: "<what you want to understand>"})  → Find related execution flows
+4. gitnexus_context({name: "<symbol>"})            → Deep dive on specific symbol
+5. READ gitnexus://repo/{name}/process/{name}      → Trace full execution flow
+```
+
+> If step 2 says "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] READ gitnexus://repo/{name}/context
+- [ ] gitnexus_query for the concept you want to understand
+- [ ] Review returned processes (execution flows)
+- [ ] gitnexus_context on key symbols for callers/callees
+- [ ] READ process resource for full execution traces
+- [ ] Read source files for implementation details
+```
+
+## Resources
+
+| Resource                                | What you get                                            |
+| --------------------------------------- | ------------------------------------------------------- |
+| `gitnexus://repo/{name}/context`        | Stats, staleness warning (~150 tokens)                  |
+| `gitnexus://repo/{name}/clusters`       | All functional areas with cohesion scores (~300 tokens) |
+| `gitnexus://repo/{name}/cluster/{name}` | Area members with file paths (~500 tokens)              |
+| `gitnexus://repo/{name}/process/{name}` | Step-by-step execution trace (~200 tokens)              |
+
+## Tools
+
+**gitnexus_query** — find execution flows related to a concept:
+
+```
+gitnexus_query({query: "payment processing"})
+→ Processes: CheckoutFlow, RefundFlow, WebhookHandler
+→ Symbols grouped by flow with file locations
+```
+
+**gitnexus_context** — 360-degree view of a symbol:
+
+```
+gitnexus_context({name: "validateUser"})
+→ Incoming calls: loginHandler, apiMiddleware
+→ Outgoing calls: checkToken, getUserById
+→ Processes: LoginFlow (step 2/5), TokenRefresh (step 1/3)
+```
+
+## Example: "How does payment processing work?"
+
+```
+1. READ gitnexus://repo/my-app/context       → 918 symbols, 45 processes
+2. gitnexus_query({query: "payment processing"})
+   → CheckoutFlow: processPayment → validateCard → chargeStripe
+   → RefundFlow: initiateRefund → calculateRefund → processRefund
+3. gitnexus_context({name: "processPayment"})
+   → Incoming: checkoutHandler, webhookHandler
+   → Outgoing: validateCard, chargeStripe, saveTransaction
+4. Read src/payments/processor.ts for implementation details
+```
diff --git a/.claude/skills/gitnexus/gitnexus-guide/SKILL.md b/.claude/skills/gitnexus/gitnexus-guide/SKILL.md
new file mode 100644
index 0000000..937ac73
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-guide/SKILL.md
@@ -0,0 +1,64 @@
+---
+name: gitnexus-guide
+description: "Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: \"What GitNexus tools are available?\", \"How do I use GitNexus?\""
+---
+
+# GitNexus Guide
+
+Quick reference for all GitNexus MCP tools, resources, and the knowledge graph schema.
+
+## Always Start Here
+
+For any task involving code understanding, debugging, impact analysis, or refactoring:
+
+1. **Read `gitnexus://repo/{name}/context`** — codebase overview + check index freshness
+2. **Match your task to a skill below** and **read that skill file**
+3. **Follow the skill's workflow and checklist**
+
+> If step 1 warns the index is stale, run `npx gitnexus analyze` in the terminal first.
+
+## Skills
+
+| Task                                         | Skill to read       |
+| -------------------------------------------- | ------------------- |
+| Understand architecture / "How does X work?" | `gitnexus-exploring`         |
+| Blast radius / "What breaks if I change X?"  | `gitnexus-impact-analysis`   |
+| Trace bugs / "Why is X failing?"             | `gitnexus-debugging`         |
+| Rename / extract / split / refactor          | `gitnexus-refactoring`       |
+| Tools, resources, schema reference           | `gitnexus-guide` (this file) |
+| Index, status, clean, wiki CLI commands      | `gitnexus-cli`               |
+
+## Tools Reference
+
+| Tool             | What it gives you                                                        |
+| ---------------- | ------------------------------------------------------------------------ |
+| `query`          | Process-grouped code intelligence — execution flows related to a concept |
+| `context`        | 360-degree symbol view — categorized refs, processes it participates in  |
+| `impact`         | Symbol blast radius — what breaks at depth 1/2/3 with confidence         |
+| `detect_changes` | Git-diff impact — what do your current changes affect                    |
+| `rename`         | Multi-file coordinated rename with confidence-tagged edits               |
+| `cypher`         | Raw graph queries (read `gitnexus://repo/{name}/schema` first)           |
+| `list_repos`     | Discover indexed repos                                                   |
+
+## Resources Reference
+
+Lightweight reads (~100-500 tokens) for navigation:
+
+| Resource                                       | Content                                   |
+| ---------------------------------------------- | ----------------------------------------- |
+| `gitnexus://repo/{name}/context`               | Stats, staleness check                    |
+| `gitnexus://repo/{name}/clusters`              | All functional areas with cohesion scores |
+| `gitnexus://repo/{name}/cluster/{clusterName}` | Area members                              |
+| `gitnexus://repo/{name}/processes`             | All execution flows                       |
+| `gitnexus://repo/{name}/process/{processName}` | Step-by-step trace                        |
+| `gitnexus://repo/{name}/schema`                | Graph schema for Cypher                   |
+
+## Graph Schema
+
+**Nodes:** File, Function, Class, Interface, Method, Community, Process
+**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS
+
+```cypher
+MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
+RETURN caller.name, caller.filePath
+```
diff --git a/.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md b/.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md
new file mode 100644
index 0000000..e19af28
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md
@@ -0,0 +1,97 @@
+---
+name: gitnexus-impact-analysis
+description: "Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: \"Is it safe to change X?\", \"What depends on this?\", \"What will break?\""
+---
+
+# Impact Analysis with GitNexus
+
+## When to Use
+
+- "Is it safe to change this function?"
+- "What will break if I modify X?"
+- "Show me the blast radius"
+- "Who uses this code?"
+- Before making non-trivial code changes
+- Before committing — to understand what your changes affect
+
+## Workflow
+
+```
+1. gitnexus_impact({target: "X", direction: "upstream"})  → What depends on this
+2. READ gitnexus://repo/{name}/processes                   → Check affected execution flows
+3. gitnexus_detect_changes()                               → Map current git changes to affected flows
+4. Assess risk and report to user
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklist
+
+```
+- [ ] gitnexus_impact({target, direction: "upstream"}) to find dependents
+- [ ] Review d=1 items first (these WILL BREAK)
+- [ ] Check high-confidence (>0.8) dependencies
+- [ ] READ processes to check affected execution flows
+- [ ] gitnexus_detect_changes() for pre-commit check
+- [ ] Assess risk level and report to user
+```
+
+## Understanding Output
+
+| Depth | Risk Level       | Meaning                  |
+| ----- | ---------------- | ------------------------ |
+| d=1   | **WILL BREAK**   | Direct callers/importers |
+| d=2   | LIKELY AFFECTED  | Indirect dependencies    |
+| d=3   | MAY NEED TESTING | Transitive effects       |
+
+## Risk Assessment
+
+| Affected                       | Risk     |
+| ------------------------------ | -------- |
+| <5 symbols, few processes      | LOW      |
+| 5-15 symbols, 2-5 processes    | MEDIUM   |
+| >15 symbols or many processes  | HIGH     |
+| Critical path (auth, payments) | CRITICAL |
+
+## Tools
+
+**gitnexus_impact** — the primary tool for symbol blast radius:
+
+```
+gitnexus_impact({
+  target: "validateUser",
+  direction: "upstream",
+  minConfidence: 0.8,
+  maxDepth: 3
+})
+
+→ d=1 (WILL BREAK):
+  - loginHandler (src/auth/login.ts:42) [CALLS, 100%]
+  - apiMiddleware (src/api/middleware.ts:15) [CALLS, 100%]
+
+→ d=2 (LIKELY AFFECTED):
+  - authRouter (src/routes/auth.ts:22) [CALLS, 95%]
+```
+
+**gitnexus_detect_changes** — git-diff based impact analysis:
+
+```
+gitnexus_detect_changes({scope: "staged"})
+
+→ Changed: 5 symbols in 3 files
+→ Affected: LoginFlow, TokenRefresh, APIMiddlewarePipeline
+→ Risk: MEDIUM
+```
+
+## Example: "What breaks if I change validateUser?"
+
+```
+1. gitnexus_impact({target: "validateUser", direction: "upstream"})
+   → d=1: loginHandler, apiMiddleware (WILL BREAK)
+   → d=2: authRouter, sessionManager (LIKELY AFFECTED)
+
+2. READ gitnexus://repo/my-app/processes
+   → LoginFlow and TokenRefresh touch validateUser
+
+3. Risk: 2 direct callers, 2 processes = MEDIUM
+```
diff --git a/.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md b/.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md
new file mode 100644
index 0000000..f48cc01
--- /dev/null
+++ b/.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md
@@ -0,0 +1,121 @@
+---
+name: gitnexus-refactoring
+description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: \"Rename this function\", \"Extract this into a module\", \"Refactor this class\", \"Move this to a separate file\""
+---
+
+# Refactoring with GitNexus
+
+## When to Use
+
+- "Rename this function safely"
+- "Extract this into a module"
+- "Split this service"
+- "Move this to a new file"
+- Any task involving renaming, extracting, splitting, or restructuring code
+
+## Workflow
+
+```
+1. gitnexus_impact({target: "X", direction: "upstream"})  → Map all dependents
+2. gitnexus_query({query: "X"})                            → Find execution flows involving X
+3. gitnexus_context({name: "X"})                           → See all incoming/outgoing refs
+4. Plan update order: interfaces → implementations → callers → tests
+```
+
+> If "Index is stale" → run `npx gitnexus analyze` in terminal.
+
+## Checklists
+
+### Rename Symbol
+
+```
+- [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits
+- [ ] Review graph edits (high confidence) and ast_search edits (review carefully)
+- [ ] If satisfied: gitnexus_rename({..., dry_run: false}) — apply edits
+- [ ] gitnexus_detect_changes() — verify only expected files changed
+- [ ] Run tests for affected processes
+```
+
+### Extract Module
+
+```
+- [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs
+- [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers
+- [ ] Define new module interface
+- [ ] Extract code, update imports
+- [ ] gitnexus_detect_changes() — verify affected scope
+- [ ] Run tests for affected processes
+```
+
+### Split Function/Service
+
+```
+- [ ] gitnexus_context({name: target}) — understand all callees
+- [ ] Group callees by responsibility
+- [ ] gitnexus_impact({target, direction: "upstream"}) — map callers to update
+- [ ] Create new functions/services
+- [ ] Update callers
+- [ ] gitnexus_detect_changes() — verify affected scope
+- [ ] Run tests for affected processes
+```
+
+## Tools
+
+**gitnexus_rename** — automated multi-file rename:
+
+```
+gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
+→ 12 edits across 8 files
+→ 10 graph edits (high confidence), 2 ast_search edits (review)
+→ Changes: [{file_path, edits: [{line, old_text, new_text, confidence}]}]
+```
+
+**gitnexus_impact** — map all dependents first:
+
+```
+gitnexus_impact({target: "validateUser", direction: "upstream"})
+→ d=1: loginHandler, apiMiddleware, testUtils
+→ Affected Processes: LoginFlow, TokenRefresh
+```
+
+**gitnexus_detect_changes** — verify your changes after refactoring:
+
+```
+gitnexus_detect_changes({scope: "all"})
+→ Changed: 8 files, 12 symbols
+→ Affected processes: LoginFlow, TokenRefresh
+→ Risk: MEDIUM
+```
+
+**gitnexus_cypher** — custom reference queries:
+
+```cypher
+MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"})
+RETURN caller.name, caller.filePath ORDER BY caller.filePath
+```
+
+## Risk Rules
+
+| Risk Factor         | Mitigation                                |
+| ------------------- | ----------------------------------------- |
+| Many callers (>5)   | Use gitnexus_rename for automated updates |
+| Cross-area refs     | Use detect_changes after to verify scope  |
+| String/dynamic refs | gitnexus_query to find them               |
+| External/public API | Version and deprecate properly            |
+
+## Example: Rename `validateUser` to `authenticateUser`
+
+```
+1. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
+   → 12 edits: 10 graph (safe), 2 ast_search (review)
+   → Files: validator.ts, login.ts, middleware.ts, config.json...
+
+2. Review ast_search edits (config.json: dynamic reference!)
+
+3. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: false})
+   → Applied 12 edits across 8 files
+
+4. gitnexus_detect_changes({scope: "all"})
+   → Affected: LoginFlow, TokenRefresh
+   → Risk: MEDIUM — run tests for these flows
+```
diff --git a/.gitignore b/.gitignore
index d44e2d5..1b6dc63 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,10 @@ config_files/*
 
 # Data and solution files
 solutions/*
+remote_experiments/instances/*/
+
+# Superpowers SDD session scratch (plans/briefs/reports/diffs)
+.superpowers/
 
 # MacOS files
 .DS_Store
@@ -55,6 +59,7 @@ htmlcov/
 .cache
 nosetests.xml
 coverage.xml
+coverage.json
 *.cover
 *.py.cover
 .hypothesis/
@@ -200,6 +205,7 @@ cython_debug/
 
 # Ruff stuff:
 .ruff_cache/
+.worktrees/
 
 # PyPI configuration file
 .pypirc
@@ -215,3 +221,8 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+.gitnexus
+
+# Gurobi infeasibility diagnostics (models/model.py write_iis)
+infeas_*.ilp
+*.err
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..ecb9e7a
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.12
+    hooks:
+      - id: ruff
+        stages: [pre-push]
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..1525d12
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,155 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+This repository is script-driven (no `src/` package). Main entry points live at the top level:
+- `run.py`: orchestrates batch experiment generation/execution and postprocessing.
+- `run_centralized_model.py`, `run_faasmacro.py`, `run_faasmadea.py`: method-specific runners.
+- `generate_data.py`, `postprocessing.py`, `logs_postprocessing.py`: data creation and analysis utilities.
+- `models/`: Pyomo model definitions (`model.py`, `rmp.py`, `sp.py`, `auction_models.py`).
+- `config_files/`: JSON experiment configs.
+- `solutions/`: generated outputs, logs, and plots.
+
+## Build, Test, and Development Commands
+Use Python 3.10 in a virtual environment:
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+Key workflows:
+```bash
+python run_centralized_model.py -c config_files/manual_config.json
+python run_faasmacro.py -c config_files/manual_config.json -j 0
+python run.py -c config_files/config.json --methods centralized faas-macro --n_experiments 3
+python compare_results.py --help
+```
+Use `--disable_plotting` for faster smoke runs when validating logic changes.
+
+## Coding Style & Naming Conventions
+Follow the existing style in this codebase:
+- Python with type hints where practical.
+- `snake_case` for variables/functions/files, `PascalCase` for classes.
+- Keep the current 2-space indentation style used across scripts and `models/`.
+- Prefer small, single-purpose functions and explicit argparse options for CLI scripts.
+
+## Testing Guidelines
+There is currently no dedicated automated test suite in-tree. Validate changes with focused smoke tests:
+```bash
+python run_centralized_model.py --help
+python run_faasmacro.py --help
+python run.py --help
+```
+For behavioral changes, run at least one small experiment and verify artifacts under `solutions/` (e.g., objective CSVs, termination logs, generated plots).
+
+## Commit & Pull Request Guidelines
+Recent history uses short, imperative commit subjects (often lowercase), e.g., `avoid errors in postprocessing partial results`.
+- Keep commit messages concise and action-oriented.
+- Keep one logical change per commit.
+- In PRs, include: purpose, config used, commands executed, and a short summary of result deltas (tables/plots when relevant).
+- Link related issues and note solver assumptions (e.g., Gurobi vs GLPK) for reproducibility.
+
+## Configuration & Data Hygiene
+Do not commit large generated outputs from `solutions/` unless explicitly required for review. Keep environment-specific or absolute paths out of config JSONs.
+
+<!-- gitnexus:start -->
+# GitNexus — Code Intelligence
+
+This project is indexed by GitNexus as **DFaaSOptimizer** (2023 symbols, 5324 relationships, 165 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+
+> If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
+
+## Always Do
+
+- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `gitnexus_impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user.
+- **MUST run `gitnexus_detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows.
+- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits.
+- When exploring unfamiliar code, use `gitnexus_query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
+- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `gitnexus_context({name: "symbolName"})`.
+
+## When Debugging
+
+1. `gitnexus_query({query: "<error or symptom>"})` — find execution flows related to the issue
+2. `gitnexus_context({name: "<suspect function>"})` — see all callers, callees, and process participation
+3. `READ gitnexus://repo/DFaaSOptimizer/process/{processName}` — trace the full execution flow step by step
+4. For regressions: `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` — see what your branch changed
+
+## When Refactoring
+
+- **Renaming**: MUST use `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with `dry_run: false`.
+- **Extracting/Splitting**: MUST run `gitnexus_context({name: "target"})` to see all incoming/outgoing refs, then `gitnexus_impact({target: "target", direction: "upstream"})` to find all external callers before moving code.
+- After any refactor: run `gitnexus_detect_changes({scope: "all"})` to verify only expected files changed.
+
+## Never Do
+
+- NEVER edit a function, class, or method without first running `gitnexus_impact` on it.
+- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis.
+- NEVER rename symbols with find-and-replace — use `gitnexus_rename` which understands the call graph.
+- NEVER commit changes without running `gitnexus_detect_changes()` to check affected scope.
+
+## Tools Quick Reference
+
+| Tool | When to use | Command |
+|------|-------------|---------|
+| `query` | Find code by concept | `gitnexus_query({query: "auth validation"})` |
+| `context` | 360-degree view of one symbol | `gitnexus_context({name: "validateUser"})` |
+| `impact` | Blast radius before editing | `gitnexus_impact({target: "X", direction: "upstream"})` |
+| `detect_changes` | Pre-commit scope check | `gitnexus_detect_changes({scope: "staged"})` |
+| `rename` | Safe multi-file rename | `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` |
+| `cypher` | Custom graph queries | `gitnexus_cypher({query: "MATCH ..."})` |
+
+## Impact Risk Levels
+
+| Depth | Meaning | Action |
+|-------|---------|--------|
+| d=1 | WILL BREAK — direct callers/importers | MUST update these |
+| d=2 | LIKELY AFFECTED — indirect deps | Should test |
+| d=3 | MAY NEED TESTING — transitive | Test if critical path |
+
+## Resources
+
+| Resource | Use for |
+|----------|---------|
+| `gitnexus://repo/DFaaSOptimizer/context` | Codebase overview, check index freshness |
+| `gitnexus://repo/DFaaSOptimizer/clusters` | All functional areas |
+| `gitnexus://repo/DFaaSOptimizer/processes` | All execution flows |
+| `gitnexus://repo/DFaaSOptimizer/process/{name}` | Step-by-step execution trace |
+
+## Self-Check Before Finishing
+
+Before completing any code modification task, verify:
+1. `gitnexus_impact` was run for all modified symbols
+2. No HIGH/CRITICAL risk warnings were ignored
+3. `gitnexus_detect_changes()` confirms changes match expected scope
+4. All d=1 (WILL BREAK) dependents were updated
+
+## Keeping the Index Fresh
+
+After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
+
+```bash
+npx gitnexus analyze
+```
+
+If the index previously included embeddings, preserve them by adding `--embeddings`:
+
+```bash
+npx gitnexus analyze --embeddings
+```
+
+To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.**
+
+> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`.
+
+## CLI
+
+| Task | Read this skill file |
+|------|---------------------|
+| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
+| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
+| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
+| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
+| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
+| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
+
+<!-- gitnexus:end -->
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..ae7c313
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,101 @@
+<!-- gitnexus:start -->
+# GitNexus — Code Intelligence
+
+This project is indexed by GitNexus as **DFaaSOptimizer** (2023 symbols, 5324 relationships, 165 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+
+> If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
+
+## Always Do
+
+- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `gitnexus_impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user.
+- **MUST run `gitnexus_detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows.
+- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits.
+- When exploring unfamiliar code, use `gitnexus_query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
+- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `gitnexus_context({name: "symbolName"})`.
+
+## When Debugging
+
+1. `gitnexus_query({query: "<error or symptom>"})` — find execution flows related to the issue
+2. `gitnexus_context({name: "<suspect function>"})` — see all callers, callees, and process participation
+3. `READ gitnexus://repo/DFaaSOptimizer/process/{processName}` — trace the full execution flow step by step
+4. For regressions: `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` — see what your branch changed
+
+## When Refactoring
+
+- **Renaming**: MUST use `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with `dry_run: false`.
+- **Extracting/Splitting**: MUST run `gitnexus_context({name: "target"})` to see all incoming/outgoing refs, then `gitnexus_impact({target: "target", direction: "upstream"})` to find all external callers before moving code.
+- After any refactor: run `gitnexus_detect_changes({scope: "all"})` to verify only expected files changed.
+
+## Never Do
+
+- NEVER edit a function, class, or method without first running `gitnexus_impact` on it.
+- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis.
+- NEVER rename symbols with find-and-replace — use `gitnexus_rename` which understands the call graph.
+- NEVER commit changes without running `gitnexus_detect_changes()` to check affected scope.
+
+## Tools Quick Reference
+
+| Tool | When to use | Command |
+|------|-------------|---------|
+| `query` | Find code by concept | `gitnexus_query({query: "auth validation"})` |
+| `context` | 360-degree view of one symbol | `gitnexus_context({name: "validateUser"})` |
+| `impact` | Blast radius before editing | `gitnexus_impact({target: "X", direction: "upstream"})` |
+| `detect_changes` | Pre-commit scope check | `gitnexus_detect_changes({scope: "staged"})` |
+| `rename` | Safe multi-file rename | `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` |
+| `cypher` | Custom graph queries | `gitnexus_cypher({query: "MATCH ..."})` |
+
+## Impact Risk Levels
+
+| Depth | Meaning | Action |
+|-------|---------|--------|
+| d=1 | WILL BREAK — direct callers/importers | MUST update these |
+| d=2 | LIKELY AFFECTED — indirect deps | Should test |
+| d=3 | MAY NEED TESTING — transitive | Test if critical path |
+
+## Resources
+
+| Resource | Use for |
+|----------|---------|
+| `gitnexus://repo/DFaaSOptimizer/context` | Codebase overview, check index freshness |
+| `gitnexus://repo/DFaaSOptimizer/clusters` | All functional areas |
+| `gitnexus://repo/DFaaSOptimizer/processes` | All execution flows |
+| `gitnexus://repo/DFaaSOptimizer/process/{name}` | Step-by-step execution trace |
+
+## Self-Check Before Finishing
+
+Before completing any code modification task, verify:
+1. `gitnexus_impact` was run for all modified symbols
+2. No HIGH/CRITICAL risk warnings were ignored
+3. `gitnexus_detect_changes()` confirms changes match expected scope
+4. All d=1 (WILL BREAK) dependents were updated
+
+## Keeping the Index Fresh
+
+After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
+
+```bash
+npx gitnexus analyze
+```
+
+If the index previously included embeddings, preserve them by adding `--embeddings`:
+
+```bash
+npx gitnexus analyze --embeddings
+```
+
+To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.**
+
+> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`.
+
+## CLI
+
+| Task | Read this skill file |
+|------|---------------------|
+| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
+| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
+| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
+| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
+| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
+| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
+
+<!-- gitnexus:end -->
diff --git a/Decentralized_FaaS_coordination.pdf b/Decentralized_FaaS_coordination.pdf
new file mode 100644
index 0000000..f872c3c
Binary files /dev/null and b/Decentralized_FaaS_coordination.pdf differ
diff --git a/README.md b/README.md
index b3690c9..1452d66 100644
--- a/README.md
+++ b/README.md
@@ -43,19 +43,20 @@ methods in your work, please cite:
 
 ## Installation instructions
 
-We strongly recommend running the code in a dedicated Python virtual 
-environment. To create and activate the environment, run:
+This repository is configured as an `uv` project. To create a local
+environment and install dependencies, run:
 
 ```
-python3 -m venv .venv
-source .venv/bin/activate
+uv venv --python 3.10
+uv sync
 ```
 
-Then install the required dependencies in the new environment by running:
+Then run scripts through `uv`:
 
 ```
-pip install --upgrade pip
-pip install -r requirements.txt
+uv run run_centralized_model.py --help
+uv run run_faasmacro.py --help
+uv run run.py --help
 ```
 
 > [!NOTE]
@@ -97,7 +98,7 @@ Run LoadManagementModel (LMM)
 options:
   -h, --help            show this help message and exit
   -c CONFIG, --config CONFIG
-                        Configuration file (default: manual_config.json)
+                        Configuration file (default: config_files/manual_config.json)
   --disable_plotting    True to disable automatic plot generation for each 
                         experiment (default: False)
 ```
@@ -119,7 +120,7 @@ Run FaaS-MACrO
 options:
   -h, --help            show this help message and exit
   -c CONFIG, --config CONFIG
-                        Configuration file (default: manual_config.json)
+                        Configuration file (default: config_files/manual_config.json)
   -j PARALLELISM, --parallelism PARALLELISM
                         Number of parallel processes to start 
                         (-1: auto, 0: sequential) (default: -1)
@@ -133,6 +134,29 @@ options:
 > exploit multithreading. Keep `j` small to avoid issues with aggressive 
 > over-commitment.
 
+### Comparing approaches on planar graphs
+
+A ready-to-use configuration file is provided at
+[`config_files/planar_comparison.json`](config_files/planar_comparison.json),
+which runs all three approaches on randomly-generated planar degree-3 graphs
+with Nn ∈ {10, 20, 30, 40, 50} nodes.
+
+> [!NOTE]
+> Planar graph generation requires SageMath. Install it first via the
+> [conda instructions](#install-with-conda-required-for-planar-graphs-generation)
+> and activate the environment before running.
+
+```
+conda activate sage_venv
+python run.py \
+  -c config_files/planar_comparison.json \
+  --methods centralized faas-macro hierarchical \
+  --n_experiments 3 \
+  --loop_over Nn
+```
+
+Results are saved under `solutions/planar_comparison/`.
+
 ### Run a series of experiments with the two approaches
 
 The [`run.py`](run.py) script allows to automatically generate multiple 
@@ -155,7 +179,7 @@ Run LMM and/or FaaS-MACrO on multiple experiments
 options:
   -h, --help            show this help message and exit
   -c CONFIG, --config CONFIG
-                        Configuration file (default: config.json)
+                        Configuration file (default: config_files/config.json)
   --n_experiments N_EXPERIMENTS
                         Number of experiments to run for each 
                         configuration (default: 3)
@@ -418,7 +442,7 @@ will have a memory capacity of 8Gb, the 25% will have a memory capacity of
 
 #### Network topology
 
-The network topology can be generated in two different ways, setting in the 
+The network topology can be generated in three different ways, setting in the 
 `neighborhood` dictionary:
 - a parameter `p` that represents the probability of creating a link between 
 two nodes. If `p` is set to 1.0, the network is fully-connected.
@@ -426,6 +450,13 @@ two nodes. If `p` is set to 1.0, the network is fully-connected.
 network is generated by providing `k` as parameter `d` to the 
 [`random_regular_graph`](https://networkx.org/documentation/stable/reference/generated/networkx.generators.random_graphs.random_regular_graph.html) 
 function of NetworkX.
+- a planar degree-3 (cubic) graph, by setting `"type": "planar"` and 
+`"degree": 3`. The graph is generated using a circular ladder structure 
+(`Nn` must be even and ≥ 6):
+
+```json
+"neighborhood": { "type": "planar", "degree": 3 }
+```
 
 > [!WARNING] 
 > When setting a value `p < 1.0`, there is no guarantee that the resulting 
@@ -665,7 +696,7 @@ values of the `loop_over` parameter are provided in a unique
 `postprocessing_folders`.
 
 ```
-python compare_results.py -i solutions/varyingN/light_load/3classes-0_10-greedy \
+uv run compare_results.py -i solutions/varyingN/light_load/3classes-0_10-greedy \
                           --run compare_results \
                           --loop_over Nn \
                           --loop_over_label "Number of agents"
@@ -676,7 +707,7 @@ values of the `loop_over` parameter are provided in different subfolders
 of `postprocessing_folders`.
 
 ```
-python compare_results.py -i solutions/varyingK \
+uv run compare_results.py -i solutions/varyingK \
                           -o solutions/varyingK/postprocessing_by_k \
                           --run compare_across_folders \
                           --loop_over k \
@@ -688,7 +719,7 @@ python compare_results.py -i solutions/varyingK \
 single model in variable conditions (identified by the `loop_over` parameter).
 
 ```
-python compare_results.py -i solutions/centralized \
+uv run compare_results.py -i solutions/centralized \
                           -o solutions/centralized/postprocessing_by_TL \
                           --run compare_single_model \
                           --loop_over TL \
diff --git a/benchmark_planar_3reg.py b/benchmark_planar_3reg.py
new file mode 100644
index 0000000..85dbbc1
--- /dev/null
+++ b/benchmark_planar_3reg.py
@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import pyomo.environ as pyo
+
+from hierarchical_auction.runner import run as run_hierarchical
+from run_centralized_model import run as run_centralized
+from run_faasmacro import run as run_distributed
+
+
+DEFAULT_SIZES = [20, 40, 50]
+DEFAULT_SEEDS = [0, 1, 2, 3, 4]
+DEFAULT_SOLVER = "gurobi_direct"
+MODEL_ORDER = ["centralized", "distributed", "hierarchical"]
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run planar degree-3 benchmark across centralized, distributed, and hierarchical models",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "--sizes",
+    nargs="+",
+    type=int,
+    default=DEFAULT_SIZES,
+    help="Node counts to benchmark",
+  )
+  parser.add_argument(
+    "--seeds",
+    nargs="+",
+    type=int,
+    default=DEFAULT_SEEDS,
+    help="Seeds used to generate each graph instance",
+  )
+  parser.add_argument(
+    "--solver-name",
+    type=str,
+    default=DEFAULT_SOLVER,
+    help="MILP solver name",
+  )
+  parser.add_argument(
+    "--output-root",
+    type=Path,
+    default=Path("solutions") / "planar_benchmark",
+    help="Root output directory",
+  )
+  return parser.parse_args()
+
+
+def _require_gurobi(solver_name: str) -> None:
+  solver = pyo.SolverFactory(solver_name)
+  if not solver.available(exception_flag=False):
+    raise SystemExit(f"{solver_name} solver is not available")
+
+
+def build_base_config(output_root: Path, nn: int, seed: int, solver_name: str = DEFAULT_SOLVER) -> dict[str, Any]:
+  return {
+    "base_solution_folder": str(output_root / f"n{nn}" / f"seed{seed}"),
+    "seed": seed,
+    "limits": {
+      "Nn": {"min": nn, "max": nn},
+      "Nf": {"min": 2, "max": 2},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.5},
+        "beta_multiplier": {"min": 1.5, "max": 2.5},
+        "gamma": {"min": 0.05, "max": 0.15},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0, 1.2]},
+      "memory_capacity": {"values": [12] * nn},
+      "memory_requirement": {"values": [2, 3]},
+      "max_utilization": {"min": 0.65, "max": 0.75},
+      "load": {"trace_type": "fixed_sum", "values": [2.0 * nn, 3.0 * nn]},
+    },
+    "solver_name": solver_name,
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3, 0.15],
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 20,
+    "patience": 5,
+    "sw_patience": 5,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "max_hierarchy_depth": 3,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def _read_scalar_from_csv(csv_path: Path, preferred_column: str | None = None) -> float:
+  df = pd.read_csv(csv_path)
+  value_frame = df.loc[:, ~df.columns.astype(str).str.startswith("Unnamed")]
+  if preferred_column and preferred_column in value_frame.columns:
+    series = pd.to_numeric(value_frame[preferred_column], errors="coerce").dropna()
+    if len(series):
+      return float(series.iloc[-1])
+  numeric = value_frame.apply(pd.to_numeric, errors="coerce").dropna(axis=1, how="all")
+  if numeric.empty:
+    raise ValueError(f"no numeric data found in {csv_path}")
+  row = numeric.iloc[-1].dropna()
+  if row.empty:
+    raise ValueError(f"no numeric row found in {csv_path}")
+  return float(row.iloc[-1])
+
+
+def _read_termination_text(csv_path: Path) -> str:
+  df = pd.read_csv(csv_path)
+  return " | ".join(df.astype(str).to_numpy().ravel())
+
+
+def _collect_run_result(
+  model: str,
+  folder: str,
+  wallclock_s: float,
+) -> dict[str, Any]:
+  run_folder = Path(folder)
+  preferred_column = {
+    "centralized": "LoadManagementModel",
+    "distributed": "FaaS-MACrO",
+    "hierarchical": "HierarchicalAuction",
+  }[model]
+  return {
+    "model": model,
+    "folder": str(run_folder),
+    "objective": _read_scalar_from_csv(run_folder / "obj.csv", preferred_column),
+    "wallclock_s": round(wallclock_s, 6),
+    "termination": _read_termination_text(run_folder / "termination_condition.csv"),
+  }
+
+
+def aggregate_results(raw: pd.DataFrame) -> pd.DataFrame:
+  ordered = raw.copy()
+  ordered["model"] = pd.Categorical(ordered["model"], categories=MODEL_ORDER, ordered=True)
+  grouped = ordered.groupby(["Nn", "model"], as_index=False, observed=True).agg(
+    objective_mean=("objective", "mean"),
+    objective_std=("objective", lambda s: s.std(ddof=1) if len(s) > 1 else 0.0),
+    wallclock_mean_s=("wallclock_s", "mean"),
+    wallclock_std_s=("wallclock_s", lambda s: s.std(ddof=1) if len(s) > 1 else 0.0),
+    runs=("seed", "count"),
+  )
+  grouped["model"] = pd.Categorical(grouped["model"], categories=MODEL_ORDER, ordered=True)
+  return grouped.sort_values(["Nn", "model"]).reset_index(drop=True)
+
+
+def render_html_report(
+  summary: pd.DataFrame,
+  raw: pd.DataFrame,
+  html_path: Path,
+  meta: dict[str, object],
+) -> None:
+  display_summary = summary.rename(
+    columns={
+      "objective_mean": "Objective mean",
+      "objective_std": "Objective std",
+      "wallclock_mean_s": "Wallclock mean (s)",
+      "wallclock_std_s": "Wallclock std (s)",
+      "runs": "Runs",
+    }
+  )
+  display_raw = raw.rename(
+    columns={
+      "Nn": "Nodes",
+      "seed": "Seed",
+      "model": "Model",
+      "objective": "Objective",
+      "wallclock_s": "Wallclock (s)",
+      "termination": "Termination",
+      "folder": "Folder",
+    }
+  )
+  sizes = meta.get("sizes", [])
+  seeds = meta.get("seeds", [])
+  generated_at = meta.get("generated_at", "")
+  html = f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Planar Benchmark Report</title>
+  <style>
+    body {{ font-family: Arial, sans-serif; margin: 24px; color: #1f2937; }}
+    h1, h2 {{ margin-bottom: 0.4rem; }}
+    .meta {{ margin-bottom: 1.5rem; }}
+    .meta span {{ display: inline-block; margin-right: 16px; }}
+    table {{ border-collapse: collapse; margin-bottom: 1.5rem; width: 100%; }}
+    th, td {{ border: 1px solid #d1d5db; padding: 6px 8px; text-align: left; }}
+    th {{ background: #f3f4f6; }}
+    tbody tr:nth-child(even) {{ background: #fafafa; }}
+  </style>
+</head>
+<body>
+  <h1>Planar Benchmark</h1>
+  <div class="meta">
+    <span><strong>Generated at:</strong> {generated_at}</span>
+    <span><strong>Sizes:</strong> {sizes}</span>
+    <span><strong>Seeds:</strong> {seeds}</span>
+  </div>
+  <h2>Summary</h2>
+  {display_summary.to_html(index=False, border=0, escape=False)}
+  <h2>Raw Results</h2>
+  {display_raw.to_html(index=False, border=0, escape=False)}
+</body>
+</html>
+"""
+  html_path.write_text(html, encoding="utf-8")
+
+
+def write_report(
+  raw: pd.DataFrame,
+  summary: pd.DataFrame,
+  output_root: Path,
+  meta: dict[str, object],
+) -> None:
+  output_root.mkdir(parents=True, exist_ok=True)
+  raw.to_csv(output_root / "raw_results.csv", index=False)
+  summary.to_csv(output_root / "summary.csv", index=False)
+  render_html_report(summary, raw, output_root / "summary.html", meta)
+
+
+def run_benchmark(
+  output_root: Path,
+  sizes: list[int],
+  seeds: list[int],
+  solver_name: str = DEFAULT_SOLVER,
+) -> pd.DataFrame:
+  _require_gurobi(solver_name)
+  benchmark_root = output_root / datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  benchmark_root.mkdir(parents=True, exist_ok=True)
+  rows: list[dict[str, Any]] = []
+
+  for nn in sizes:
+    for seed in seeds:
+      config = build_base_config(benchmark_root, nn, seed, solver_name=solver_name)
+      for model_name, runner in [
+        ("centralized", run_centralized),
+        ("distributed", run_distributed),
+        ("hierarchical", run_hierarchical),
+      ]:
+        model_root = benchmark_root / f"n{nn}" / f"seed{seed}" / model_name
+        config["base_solution_folder"] = str(model_root)
+        started = time.perf_counter()
+        runner_kwargs = {"disable_plotting": True}
+        if model_name != "centralized":
+          runner_kwargs["parallelism"] = 0
+        folder = runner(config, **runner_kwargs)
+        wallclock_s = time.perf_counter() - started
+        rows.append({
+          "Nn": nn,
+          "seed": seed,
+          "model": model_name,
+          **_collect_run_result(model_name, folder, wallclock_s),
+        })
+
+  raw = pd.DataFrame(rows)
+  raw["model"] = pd.Categorical(raw["model"], categories=MODEL_ORDER, ordered=True)
+  raw.sort_values(["Nn", "seed", "model"], inplace=True)
+  raw.reset_index(drop=True, inplace=True)
+  summary = aggregate_results(raw)
+  write_report(
+    raw,
+    summary,
+    benchmark_root,
+    meta={
+      "sizes": sizes,
+      "seeds": seeds,
+      "solver_name": solver_name,
+      "generated_at": datetime.now().isoformat(timespec="seconds"),
+    },
+  )
+  return raw
+
+
+def main() -> None:
+  args = parse_arguments()
+  raw = run_benchmark(
+    output_root=args.output_root,
+    sizes=args.sizes,
+    seeds=args.seeds,
+    solver_name=args.solver_name,
+  )
+  print(json.dumps({
+    "raw_rows": len(raw),
+    "summary_rows": len(aggregate_results(raw)),
+    "output_root": str(args.output_root),
+  }, indent=2))
+
+
+if __name__ == "__main__":
+  main()
diff --git a/benchmark_summary.py b/benchmark_summary.py
new file mode 100644
index 0000000..eceec75
--- /dev/null
+++ b/benchmark_summary.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Standalone gap + runtime summary for a benchmark run.
+
+Reads the raw per-method obj.csv / runtime.csv written under each solution
+folder (mapped by <base>/experiments.json), so it does not depend on the
+run.py postprocessing, which currently assumes the default centralized model
+name and breaks with model_variant="tight".
+
+Objective is social welfare (higher is better); the centralized run is the
+reference optimum. Reported deviation, matching run.py:
+    dev% = (obj_method - obj_centralized) / obj_centralized * 100
+(negative => below the centralized optimum). Runtime is the solver time each
+method reports in runtime.csv, summed over the horizon.
+
+Usage:
+    uv run python benchmark_summary.py solutions/bench_A solutions/bench_B ...
+    uv run python benchmark_summary.py solutions/bench_A --csv out.csv
+"""
+import argparse
+import json
+import os
+import sys
+
+import numpy as np
+import pandas as pd
+
+BASELINE = "centralized"
+
+
+def _single_column_sum(path):
+  """Sum the single data column of a one-column csv (obj.csv / runtime.csv)."""
+  if not os.path.exists(path):
+    return np.nan
+  df = pd.read_csv(path)
+  if df.shape[1] == 0 or len(df) == 0:
+    return np.nan
+  # centralized files may carry the model name as column; decentralized carry
+  # the method label or "tot" -- in every case there is exactly one data column
+  col = df.select_dtypes("number")
+  if col.shape[1] == 0:
+    return np.nan
+  return float(col.iloc[:, 0].sum())
+
+
+def _resolve(base, folder):
+  if folder is None:
+    return None
+  for candidate in (folder, os.path.join(base, os.path.basename(str(folder)))):
+    if candidate and os.path.isdir(candidate):
+      return candidate
+  return folder if os.path.isdir(str(folder)) else None
+
+
+def summarize_base(base):
+  exp_path = os.path.join(base, "experiments.json")
+  if not os.path.exists(exp_path):
+    print(f"! {base}: no experiments.json (run not completed?)", file=sys.stderr)
+    return pd.DataFrame()
+  folders = json.load(open(exp_path))
+  experiments = folders.get("experiments_list", [])
+  methods = [m for m in folders if m != "experiments_list"]
+  rows = []
+  for idx, exp in enumerate(experiments):
+    for method in methods:
+      flist = folders.get(method) or []
+      folder = _resolve(base, flist[idx]) if idx < len(flist) else None
+      if folder is None:
+        rows.append({"instance": os.path.basename(base), "experiment": str(exp),
+                     "method": method, "obj": np.nan, "runtime_s": np.nan})
+        continue
+      rows.append({
+        "instance": os.path.basename(base),
+        "experiment": str(exp),
+        "method": method,
+        "obj": _single_column_sum(os.path.join(folder, "obj.csv")),
+        "runtime_s": _single_column_sum(os.path.join(folder, "runtime.csv")),
+      })
+  df = pd.DataFrame(rows)
+  if df.empty:
+    return df
+  # deviation vs the centralized baseline, per (instance, experiment)
+  df["dev_pct"] = np.nan
+  for (_, _), grp in df.groupby(["instance", "experiment"]):
+    base_row = grp[grp["method"] == BASELINE]
+    if base_row.empty or not np.isfinite(base_row["obj"].iloc[0]):
+      continue
+    ref = base_row["obj"].iloc[0]
+    if ref == 0:
+      continue
+    df.loc[grp.index, "dev_pct"] = (grp["obj"] - ref) / ref * 100.0
+  return df
+
+
+def main():
+  ap = argparse.ArgumentParser(description=__doc__,
+                               formatter_class=argparse.RawDescriptionHelpFormatter)
+  ap.add_argument("bases", nargs="+", help="benchmark base folders (solutions/bench_A ...)")
+  ap.add_argument("--csv", help="also write the full long-form table here")
+  args = ap.parse_args()
+
+  full = pd.concat([summarize_base(b) for b in args.bases], ignore_index=True)
+  if full.empty:
+    print("no results found", file=sys.stderr)
+    sys.exit(1)
+
+  pd.set_option("display.max_rows", None)
+  pd.set_option("display.width", 160)
+  # average over experiments per (instance, method)
+  agg = (full.groupby(["instance", "method"], sort=False)
+              .agg(n=("obj", lambda s: int(s.notna().sum())),
+                   obj=("obj", "mean"),
+                   dev_pct=("dev_pct", "mean"),
+                   runtime_s=("runtime_s", "mean"))
+              .reset_index())
+  for instance in agg["instance"].unique():
+    sub = agg[agg["instance"] == instance].copy()
+    sub = sub.sort_values("dev_pct", ascending=False, na_position="last")
+    print(f"\n=== {instance} (obj = welfare, higher better; dev% vs centralized) ===")
+    print(sub.to_string(index=False,
+                        formatters={"obj": "{:.4g}".format,
+                                    "dev_pct": lambda v: "baseline" if v == 0
+                                    else ("n/a" if pd.isna(v) else f"{v:+.2f}%"),
+                                    "runtime_s": lambda v: "n/a" if pd.isna(v)
+                                    else f"{v:.3f}"}))
+  if args.csv:
+    full.to_csv(args.csv, index=False)
+    print(f"\nfull table -> {args.csv}")
+
+
+if __name__ == "__main__":
+  main()
diff --git a/compare_results.py b/compare_results.py
index 015450c..adca71b 100644
--- a/compare_results.py
+++ b/compare_results.py
@@ -52,7 +52,23 @@ def parse_arguments() -> argparse.Namespace:
     "--models",
     help = "List of model names",
     nargs = "*",
-    default = ["LoadManagementModel", "FaaS-MACrO", "FaaS-MADeA"]
+    default = [
+      "LoadManagementModel", 
+      "FaaS-MACrO", 
+      "FaaS-MADeA", 
+      "HierarchicalMADeA", 
+      "FaaS-MADiG", 
+      "FaaS-MAPoD", 
+      "FaaS-MABR-S", 
+      "FaaS-MABR-R", 
+      "FaaS-MABR-O"
+    ]
+  )
+  parser.add_argument(
+  "--baseline_model",
+  help = "Name of model to be used as baseline for deviations",
+  type = str,
+  default = None
   )
   parser.add_argument(
   "--filter_by",
@@ -101,6 +117,14 @@ def get_loop_over_label(key: str) -> str:
   return None
 
 
+def get_baseline_name(key: str) -> str:
+  if key == "LoadManagementModel":
+    return "LMM"
+  elif key == "FaaS-MACrO(v0)":
+    return "LMM(s)"
+  return key
+
+
 def compare_across_folders(
     postprocessing_folders: list, 
     str_format: str, 
@@ -117,36 +141,41 @@ def compare_across_folders(
   all_runtime = pd.DataFrame()
   for postprocessing_folder in postprocessing_folders:
     print(postprocessing_folder)
-    key, key_val = parse(str_format, os.path.basename(postprocessing_folder))
-    obj, rej, runtime = compare_results(
-      os.path.join(postprocessing_folder, "postprocessing"), 
-      loop_over, 
-      get_loop_over_label(loop_over),
-      models
-    )
-    # add info
-    obj[key] = int(key_val) if key != "eef" else round(
-      float(key_val) * 100, 2
-    )
-    rej[key] = int(key_val) if key != "eef" else round(
-      float(key_val) * 100, 2
-    )
-    runtime[key] = int(key_val) if key != "eef" else round(
-      float(key_val) * 100, 2
-    )
-    if filter_by is not None and filter_by in obj and filter_by in runtime:
-      if keep_only is not None:
-        obj = obj[obj[filter_by] == keep_only]
-        rej = rej[rej[filter_by] == keep_only]
-        runtime = runtime[runtime[filter_by] == keep_only]
-      elif drop_value is not None:
-        obj = obj[obj[filter_by] != drop_value]
-        rej = rej[rej[filter_by] != drop_value]
-        runtime = runtime[runtime[filter_by] != drop_value]
-    # merge
-    all_obj = pd.concat([all_obj, obj])
-    all_rej = pd.concat([all_rej, rej])
-    all_runtime = pd.concat([all_runtime, runtime])
+    bname = os.path.basename(postprocessing_folder)
+    tokens = parse(str_format, bname)
+    if tokens is not None:
+      key, key_val = tokens
+      obj, rej, runtime = compare_results(
+        os.path.join(postprocessing_folder, "postprocessing"), 
+        loop_over, 
+        get_loop_over_label(loop_over),
+        models
+      )
+      # add info
+      obj[key] = int(key_val) if key != "eef" else round(
+        float(key_val) * 100, 2
+      )
+      rej[key] = int(key_val) if key != "eef" else round(
+        float(key_val) * 100, 2
+      )
+      runtime[key] = int(key_val) if key != "eef" else round(
+        float(key_val) * 100, 2
+      )
+      if filter_by is not None and filter_by in obj and filter_by in runtime:
+        if keep_only is not None:
+          obj = obj[obj[filter_by] == keep_only]
+          rej = rej[rej[filter_by] == keep_only]
+          runtime = runtime[runtime[filter_by] == keep_only]
+        elif drop_value is not None:
+          obj = obj[obj[filter_by] != drop_value]
+          rej = rej[rej[filter_by] != drop_value]
+          runtime = runtime[runtime[filter_by] != drop_value]
+      # merge
+      all_obj = pd.concat([all_obj, obj])
+      all_rej = pd.concat([all_rej, rej])
+      all_runtime = pd.concat([all_runtime, runtime])
+    else:
+      print(f"\tSKIPPED: {bname} does not adhere to parse format")
   # 
   if "ScaledOnSumLMM" in models:
     all_obj.rename(
@@ -196,7 +225,8 @@ def compare_results(
     key: str, 
     key_label: str,
     models: list,
-    folder_parse_format: str = None
+    folder_parse_format: str = None,
+    baseline_model: str = None
   ):
   key_values = {}
   if folder_parse_format is not None:
@@ -228,11 +258,66 @@ def compare_results(
     if rej is not None:
       rej.to_csv(os.path.join(postprocessing_folder, "rejections.csv"))
     runtime.to_csv(os.path.join(postprocessing_folder, "runtime.csv"))
+  helper_dev_cols = {"obj": [], "runtime": [], "rej": []}
+  for model in models:
+    if (
+        model != "LoadManagementModel" and 
+          "dev" in obj and f"dev_{model}" not in obj
+      ):
+      obj[f"dev_{model}"] = obj["dev"]
+      helper_dev_cols["obj"].append(f"dev_{model}")
+    if (
+        baseline_model is not None and model != baseline_model
+      ):
+      obj[f"dev_{model}-vs-{baseline_model}"] = (
+        obj[model] - obj[baseline_model]
+      ) / obj[baseline_model] * 100
+      helper_dev_cols["obj"].append(f"dev_{model}-vs-{baseline_model}")
+    if (
+        model != "LoadManagementModel" and "dev" in runtime and
+          f"dev_{model}" not in runtime
+      ):
+      runtime[f"dev_{model}"] = runtime["dev"]
+      helper_dev_cols["runtime"].append(f"dev_{model}")
+    if (
+        baseline_model is not None and model != baseline_model
+      ):
+      runtime[f"dev_{model}-vs-{baseline_model}"] = (
+        runtime[model] / runtime[baseline_model]
+      )
+      helper_dev_cols["runtime"].append(f"dev_{model}-vs-{baseline_model}")
+    if (
+        rej is not None and model != "LoadManagementModel" and "dev" in rej and
+          f"dev_{model}" not in rej
+      ):
+      rej[f"dev_{model}"] = rej["dev"]
+      helper_dev_cols["rej"].append(f"dev_{model}")
+    if (
+        baseline_model is not None and model != baseline_model
+      ):
+      rej[f"dev_{model}-vs-{baseline_model}"] = (
+        rej[model] - rej[baseline_model]
+      )
+      helper_dev_cols["rej"].append(f"dev_{model}-vs-{baseline_model}")
   dev_plot_by_key(
-    obj, runtime, rej, key, key_label, postprocessing_folder, models
+    obj, 
+    runtime, 
+    rej, 
+    key, 
+    key_label, 
+    postprocessing_folder, 
+    models,
+    baseline_model if baseline_model is not None else "LoadManagementModel"
   )
   dev_barplot_by_key(
-    obj, runtime, rej, key, key_label, postprocessing_folder, models
+    obj, 
+    runtime, 
+    rej, 
+    key, 
+    key_label, 
+    postprocessing_folder, 
+    models,
+    baseline_model if baseline_model is not None else "LoadManagementModel"
   )
   plot_by_key(
     obj, 
@@ -252,6 +337,10 @@ def compare_results(
     key_label, 
     postprocessing_folder
   )
+  obj.drop(columns = helper_dev_cols["obj"], inplace = True)
+  runtime.drop(columns = helper_dev_cols["runtime"], inplace = True)
+  if rej is not None:
+    rej.drop(columns = helper_dev_cols["rej"], inplace = True)
   return obj, rej, runtime
 
 
@@ -259,6 +348,7 @@ def compare_single_model(
     postprocessing_folders: list, 
     str_format: str, 
     key_label: str,
+    models: list,
     plot_folder: str,
     baseline = None,
     filter_by = None,
@@ -269,37 +359,45 @@ def compare_single_model(
   all_runtime = pd.DataFrame()
   for postprocessing_folder in postprocessing_folders:
     print(postprocessing_folder)
-    # -- objective function value
-    obj = pd.read_csv(
-      os.path.join(postprocessing_folder, "postprocessing", "obj.csv")
-    )
-    obj.rename(columns = {"obj": "LoadManagementModel"}, inplace = True)
-    # -- runtime
-    runtime = pd.read_csv(
-      os.path.join(postprocessing_folder, "postprocessing", "runtime.csv")
-    )
-    runtime.rename(columns= {"runtime": "LoadManagementModel"}, inplace = True)
-    # add info
-    key, key_val = parse(str_format, os.path.basename(postprocessing_folder))
-    obj[key] = int(key_val)
-    runtime[key] = int(key_val)
-    if filter_by is not None and filter_by in obj and filter_by in runtime:
-      if keep_only is not None:
-        obj = obj[obj[filter_by] == keep_only]
-        runtime = runtime[runtime[filter_by] == keep_only]
-      elif drop_value is not None:
-        obj = obj[obj[filter_by] != drop_value]
-        runtime = runtime[runtime[filter_by] != drop_value]
-    # merge
-    all_obj = pd.concat([all_obj, obj])
-    all_runtime = pd.concat([all_runtime, runtime])
+    tokens = parse(str_format, os.path.basename(postprocessing_folder))
+    if tokens is not None:
+      # -- objective function value
+      obj = pd.read_csv(
+        os.path.join(postprocessing_folder, "postprocessing", "obj.csv")
+      )
+      obj.rename(columns = {"obj": "LoadManagementModel"}, inplace = True)
+      # -- runtime
+      runtime = pd.read_csv(
+        os.path.join(postprocessing_folder, "postprocessing", "runtime.csv")
+      )
+      runtime.rename(
+        columns= {"runtime": "LoadManagementModel"}, inplace = True
+      )
+      # add info
+      key, key_val = tokens
+      obj[key] = int(key_val)
+      runtime[key] = int(key_val)
+      if filter_by is not None and filter_by in obj and filter_by in runtime:
+        if keep_only is not None:
+          obj = obj[obj[filter_by] == keep_only]
+          runtime = runtime[runtime[filter_by] == keep_only]
+        elif drop_value is not None:
+          obj = obj[obj[filter_by] != drop_value]
+          runtime = runtime[runtime[filter_by] != drop_value]
+      # merge
+      all_obj = pd.concat([all_obj, obj])
+      all_runtime = pd.concat([all_runtime, runtime])
+    else:
+      print(
+        f"\tSKIPPED: {postprocessing_folder} does not adhere to parse format"
+      )
   # plot
   os.makedirs(plot_folder, exist_ok = True)
   plot_by_key(
     all_obj, 
     all_runtime, 
     None,
-    ["LoadManagementModel"],
+    models,
     key, 
     key_label, 
     plot_folder
@@ -342,7 +440,9 @@ def compare_single_model(
         )
         df[key] = key_val
         runtime_dev = pd.concat([runtime_dev, df], ignore_index = True)
-    dev_plot_by_key(obj_dev, runtime_dev, None, key, key_label, plot_folder)
+    dev_plot_by_key(
+      obj_dev, runtime_dev, None, key, key_label, plot_folder, models
+    )
 
 
 def dev_plot_by_key(
@@ -352,10 +452,15 @@ def dev_plot_by_key(
     key: str,
     label: str,
     plot_folder: str,
-    models: list
+    models: list,
+    baseline_model: str
   ):
+  sfx = (
+    f"-vs-{baseline_model}" if baseline_model != "LoadManagementModel" else ""
+  )
+  bmn = get_baseline_name(baseline_model)
   nrows = 3 if rej is not None else 2
-  ncols = len(models) - 1
+  ncols = max(1, len(models) - 1)
   f1, axs = plt.subplots(
     nrows = nrows, 
     ncols = ncols, 
@@ -374,15 +479,16 @@ def dev_plot_by_key(
     )
     ax2 = np.atleast_2d(ax2)
     if ncols == 1:
-      ax2 = axs.T
+      ax2 = ax2.T
   cidx = 0
   for model in models:
-    if "FaaS-" in model:
+    if model != baseline_model:
+      colname = f"dev_{model}{sfx}"
       bplots = [None] * nrows
       fontsize = 21
       bplots[0] = (
-        f"dev_{model}",
-        obj[[key, f"dev_{model}"]].plot.box(
+        colname,
+        obj[[key, colname]].plot.box(
           by = key,
           grid = True,
           ax = axs[0,cidx],
@@ -394,8 +500,8 @@ def dev_plot_by_key(
         )
       )
       bplots[1] = (
-        f"dev_{model}",
-        runtime[[key, f"dev_{model}"]].plot.box(
+        colname,
+        runtime[[key, colname]].plot.box(
           by = key,
           grid = True,
           ax = axs[1,cidx],
@@ -422,20 +528,24 @@ def dev_plot_by_key(
       )
       # axis properties
       # -- y
+      ylabel = "Objective deviation"
+      if model != baseline_model:
+        ylabel += f"\n(({model} - {bmn}) / {bmn}) [%]"
       axs[0,cidx].set_ylabel(
-        f"Objective deviation\n(({model} - LMM) / LMM) [%]",
-        fontsize = fontsize
+        ylabel, fontsize = fontsize
       )
       axs[0,cidx].set_title(None)
+      ylabel = "Runtime deviation"
+      if model != baseline_model:
+        ylabel += f"\n({model} / {bmn}) [x]"
       axs[1,cidx].set_ylabel(
-        f"Runtime deviation\n({model} / LMM) [x]",
-        fontsize = fontsize
+        ylabel, fontsize = fontsize
       )
       axs[1,cidx].set_title(None)
       if rej is not None:
         bplots[2] = (
-          f"dev_{model}",
-          rej[[key, f"dev_{model}"]].plot.box(
+          colname,
+          rej[[key, colname]].plot.box(
             by = key,
             grid = True,
             ax = axs[2,cidx],
@@ -452,9 +562,11 @@ def dev_plot_by_key(
           linewidth = 2,
           color = "k"
         )
+        ylabel = "Cloud offloading deviation"
+        if model != baseline_model:
+          ylabel += f"\n({model} - {bmn}) [%]"
         axs[2,cidx].set_ylabel(
-          f"Cloud offloading deviation\n({model} - LMM) [%]",
-          fontsize = fontsize
+          ylabel, fontsize = fontsize
         )
         axs[2,cidx].set_title(None)
       # -- x
@@ -518,14 +630,14 @@ def dev_plot_by_key(
           mean.set_markeredgecolor(mcolors.TABLEAU_COLORS["tab:red"])
       cidx += 1
   f1.savefig(
-    os.path.join(plot_folder, "box.png"),
+    os.path.join(plot_folder, f"box{sfx}.png"),
     dpi = 300,
     format = "png",
     bbox_inches = "tight"
   )
   if f2 is not None:
     f2.savefig(
-      os.path.join(plot_folder, "box_iterations.png"),
+      os.path.join(plot_folder, f"box_iterations{sfx}.png"),
       dpi = 300,
       format = "png",
       bbox_inches = "tight"
@@ -647,7 +759,14 @@ def plot_by_key(
     "LoadManagementModel": mcolors.CSS4_COLORS["lightgreen"],
     "FaaS-MACrO": mcolors.CSS4_COLORS["lightpink"],
     "FaaS-MACrO(v0)": mcolors.CSS4_COLORS["lightcoral"],
-    "FaaS-MADeA": mcolors.CSS4_COLORS["lightskyblue"]
+    "FaaS-MADeA": mcolors.CSS4_COLORS["lightskyblue"],
+    "HierarchicalAuction": mcolors.CSS4_COLORS["lightsteelblue"],
+    "HierarchicalMADeA": mcolors.CSS4_COLORS["cornflowerblue"],
+    "FaaS-MADiG": mcolors.CSS4_COLORS["plum"],
+    "FaaS-MAPoD": mcolors.CSS4_COLORS["khaki"],
+    "FaaS-MABR-S": mcolors.CSS4_COLORS["mediumaquamarine"],
+    "FaaS-MABR-R": mcolors.CSS4_COLORS["sandybrown"],
+    "FaaS-MABR-O": mcolors.CSS4_COLORS["mediumpurple"]
   }
   for ridx, (keys, bplot) in enumerate(bplots):
     for cidx, bkey in enumerate(keys):
@@ -685,26 +804,31 @@ def dev_barplot_by_key(
     key: str,
     label: str,
     plot_folder: str,
-    models: list
+    models: list,
+    baseline_model: str
   ):
   nrows = len(models) - 1
   ncols = 3 if rej is not None else 2
   fontsize = 21
   f2, axs2 = plt.subplots(
-    nrows = nrows, ncols = ncols, figsize = (12 * ncols, 7 * nrows), 
+    nrows = nrows, ncols = ncols, figsize = (12 * ncols, 8 * nrows), 
     gridspec_kw = {"wspace": 0.2}
   )
   axs2 = np.atleast_2d(axs2)
   ogroup = obj.groupby(key)
   rgroup = runtime.groupby(key)
   ridx = 0
+  sfx = (
+    f"-vs-{baseline_model}" if baseline_model != "LoadManagementModel" else ""
+  )
+  bmn = get_baseline_name(baseline_model)
   for model in models:
-    if model.startswith("FaaS-"):
+    if model != baseline_model:
       data = pd.DataFrame({
         key: list(ogroup.groups.keys()),
-        "avg": ogroup.mean()[f"dev_{model}"].values.tolist(),
-        "min": ogroup.min()[f"dev_{model}"].values.tolist(),
-        "max": ogroup.max()[f"dev_{model}"].values.tolist()
+        "avg": ogroup.mean()[f"dev_{model}{sfx}"].values.tolist(),
+        "min": ogroup.min()[f"dev_{model}{sfx}"].values.tolist(),
+        "max": ogroup.max()[f"dev_{model}{sfx}"].values.tolist()
       })
       data.plot.bar(
         x = key,
@@ -715,9 +839,9 @@ def dev_barplot_by_key(
       )
       data = pd.DataFrame({
         key: list(rgroup.groups.keys()),
-        "avg": rgroup.mean()[f"dev_{model}"].values.tolist(),
-        "min": rgroup.min()[f"dev_{model}"].values.tolist(),
-        "max": rgroup.max()[f"dev_{model}"].values.tolist()
+        "avg": rgroup.mean()[f"dev_{model}{sfx}"].values.tolist(),
+        "min": rgroup.min()[f"dev_{model}{sfx}"].values.tolist(),
+        "max": rgroup.max()[f"dev_{model}{sfx}"].values.tolist()
       })
       data.plot.bar(
         x = key,
@@ -731,9 +855,9 @@ def dev_barplot_by_key(
         group = rej.groupby(key)
         data = pd.DataFrame({
           key: list(group.groups.keys()),
-          "avg": group.mean()[f"dev_{model}"].values.tolist(),
-          "min": group.min()[f"dev_{model}"].values.tolist(),
-          "max": group.max()[f"dev_{model}"].values.tolist()
+          "avg": group.mean()[f"dev_{model}{sfx}"].values.tolist(),
+          "min": group.min()[f"dev_{model}{sfx}"].values.tolist(),
+          "max": group.max()[f"dev_{model}{sfx}"].values.tolist()
         })
         data.plot.bar(
           x = key,
@@ -758,11 +882,11 @@ def dev_barplot_by_key(
       # axis properties
       # -- y
       axs2[ridx,0].set_ylabel(
-        f"Objective deviation\n(({model} - LMM) / LMM) [%]",
+        f"Objective deviation\n(({model} - {bmn}) / {bmn}) [%]",
         fontsize = fontsize
       )
       axs2[ridx,1].set_ylabel(
-        f"Runtime deviation\n({model} / LMM) [x]",
+        f"Runtime deviation\n({model} / {bmn}) [x]",
         fontsize = fontsize
       )
       if rej is not None:
@@ -773,12 +897,12 @@ def dev_barplot_by_key(
           color = "k"
         )
         axs2[ridx,2].set_ylabel(
-          f"Cloud offloading deviation\n({model} - LMM) [%]",
+          f"Cloud offloading deviation\n({model} - {bmn}) [%]",
           fontsize = fontsize
         )
       # -- common properties
       plt.setp(axs2, title = None)
-      for idx in range(len(axs2)):
+      for idx in range(ncols):
         axs2[ridx,idx].set_xlabel(
           label,
           fontsize = fontsize
@@ -786,7 +910,7 @@ def dev_barplot_by_key(
         axs2[ridx,idx].legend(fontsize = fontsize)
       ridx += 1
   f2.savefig(
-    os.path.join(plot_folder, "bars.png"),
+    os.path.join(plot_folder, f"bars{sfx}.png"),
     dpi = 300,
     format = "png",
     bbox_inches = "tight"
@@ -795,9 +919,9 @@ def dev_barplot_by_key(
 
 
 def violinplot_by_key(
-    obj: pd.DataFrame, 
-    runtime: pd.DataFrame, 
-    rej: pd.DataFrame, 
+    obj: pd.DataFrame,
+    runtime: pd.DataFrame,
+    rej: pd.DataFrame,
     models: list,
     key: str,
     label: str,
@@ -807,7 +931,14 @@ def violinplot_by_key(
     "LoadManagementModel": mcolors.CSS4_COLORS["lightgreen"],
     "FaaS-MACrO": mcolors.CSS4_COLORS["lightpink"],
     "FaaS-MACrO(v0)": mcolors.CSS4_COLORS["lightcoral"],
-    "FaaS-MADeA": mcolors.CSS4_COLORS["lightskyblue"]
+    "FaaS-MADeA": mcolors.CSS4_COLORS["lightskyblue"],
+    "HierarchicalAuction": mcolors.CSS4_COLORS["lightsteelblue"],
+    "HierarchicalMADeA": mcolors.CSS4_COLORS["cornflowerblue"],
+    "FaaS-MADiG": mcolors.CSS4_COLORS["plum"],
+    "FaaS-MAPoD": mcolors.CSS4_COLORS["khaki"],
+    "FaaS-MABR-S": mcolors.CSS4_COLORS["mediumaquamarine"],
+    "FaaS-MABR-R": mcolors.CSS4_COLORS["sandybrown"],
+    "FaaS-MABR-O": mcolors.CSS4_COLORS["mediumpurple"]
   }
   nrows = 1
   ncols = 3 if rej is not None else 2
@@ -942,6 +1073,7 @@ def violinplot_by_key(
   loop_over = args.loop_over
   loop_over_label = args.loop_over_label
   models = args.models
+  baseline_model = args.baseline_model
   filter_by = args.filter_by
   keep_only = args.keep_only
   drop_value = args.drop_value
@@ -966,13 +1098,19 @@ def violinplot_by_key(
       )
     for postprocessing_folder in postprocessing_folders:
       print(postprocessing_folder)
-      compare_results(
-        os.path.join(postprocessing_folder, "postprocessing"),
-        loop_over,
-        loop_over_label,
-        models,
-        folder_parse_format = folder_parse_format
-      )
+      if os.path.exists(os.path.join(postprocessing_folder, "postprocessing")):
+        compare_results(
+          os.path.join(postprocessing_folder, "postprocessing"),
+          loop_over,
+          loop_over_label,
+          models,
+          folder_parse_format = folder_parse_format,
+          baseline_model = baseline_model
+        )
+      else:
+        print(
+         f"\tSKIPPED: {postprocessing_folder} does not contain postprocessing/"
+        )
   elif what_to_do == "compare_across_folders":
     # for eef,
     # loop_over_label = "Edge-exposed fraction [%]"
@@ -1005,6 +1143,7 @@ def violinplot_by_key(
       postprocessing_folders, 
       folder_parse_format,
       loop_over_label,
+      models,
       common_output_folder,
       baseline = single_model_baseline,
       filter_by = filter_by,
diff --git a/config_files/eval_full.json b/config_files/eval_full.json
new file mode 100644
index 0000000..6265da3
--- /dev/null
+++ b/config_files/eval_full.json
@@ -0,0 +1,136 @@
+{
+  "base_solution_folder": "solutions/eval_full",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [
+        0.5,
+        0.3,
+        0.15
+      ],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "br_r": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "br_o": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "pg_s": {
+      "epsilon": 1e-6
+    },
+    "pg_r": {
+      "epsilon": 1e-6
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-06,
+  "limits": {
+    "Nn": {
+      "values": [
+        10,
+        20,
+        30,
+        40,
+        50
+      ]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "p": 0.3
+    },
+    "demand": {
+      "values": [
+        1.0,
+        1.2
+      ]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [
+        2,
+        3
+      ]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {
+        "min": 5,
+        "max": 10
+      },
+      "max": {
+        "min": 50,
+        "max": 100
+      }
+    },
+    "weights": {
+      "alpha": {
+        "min": 1.0,
+        "max": 1.5
+      },
+      "beta_multiplier": {
+        "min": 1.5,
+        "max": 2.5
+      },
+      "gamma": {
+        "min": 0.05,
+        "max": 0.15
+      },
+      "delta_multiplier": {
+        "min": 0.1,
+        "max": 0.2
+      }
+    }
+  }
+}
diff --git a/config_files/eval_smoke.json b/config_files/eval_smoke.json
new file mode 100644
index 0000000..e29e2e4
--- /dev/null
+++ b/config_files/eval_smoke.json
@@ -0,0 +1,89 @@
+{
+  "base_solution_folder": "solutions/eval_smoke",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3, 0.15],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "pg_s": { "epsilon": 1e-6 },
+    "pg_r": { "epsilon": 1e-6 }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "values": [10]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "p": 0.3
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 5, "max": 10},
+      "max": {"min": 50, "max": 100}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/eval_tuned_smoke.json b/config_files/eval_tuned_smoke.json
new file mode 100644
index 0000000..ff1aa14
--- /dev/null
+++ b/config_files/eval_tuned_smoke.json
@@ -0,0 +1,89 @@
+{
+  "base_solution_folder": "solutions/eval_tuned_smoke",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": 0.3,
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "pg_s": { "epsilon": 1e-6 },
+    "pg_r": { "epsilon": 1e-6 }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "values": [20]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "p": 0.3
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "repeated_values": [[0.25, 200], [0.75, 32]]
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 3, "max": 6},
+      "max": {"min": 18, "max": 24}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/mald_smoke.json b/config_files/mald_smoke.json
new file mode 100644
index 0000000..abb35df
--- /dev/null
+++ b/config_files/mald_smoke.json
@@ -0,0 +1,66 @@
+{
+  "base_solution_folder": "solutions/mald_smoke",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 4,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "dual": {
+      "alpha0": 1.0,
+      "step_rule": "sqrt",
+      "max_inner_iterations": 50,
+      "gap_tolerance": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "checkpoint_interval": 1,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "min": 10,
+      "max": 10
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "p": 0.3
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 1, "max": 2},
+      "max": {"min": 6, "max": 12}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/planar_comparison.json b/config_files/planar_comparison.json
new file mode 100644
index 0000000..89b48fc
--- /dev/null
+++ b/config_files/planar_comparison.json
@@ -0,0 +1,90 @@
+{
+  "base_solution_folder": "solutions/planar_comparison",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3, 0.15],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "pg_s": { "epsilon": 1e-6 },
+    "pg_r": { "epsilon": 1e-6 },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "values": [10, 20, 30, 40, 50]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "k": 3,
+      "shape": "planar"
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 5, "max": 10},
+      "max": {"min": 50, "max": 100}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/planar_hierarchical.json b/config_files/planar_hierarchical.json
new file mode 100644
index 0000000..bb83dd4
--- /dev/null
+++ b/config_files/planar_hierarchical.json
@@ -0,0 +1,67 @@
+{
+  "base_solution_folder": "solutions/planar_hierarchical",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3, 0.15],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "values": [10, 20, 30, 40, 50]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "k": 3,
+      "shape": "planar"
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 5, "max": 10},
+      "max": {"min": 50, "max": 100}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/plasma_comparison.json b/config_files/plasma_comparison.json
new file mode 100644
index 0000000..156a3e7
--- /dev/null
+++ b/config_files/plasma_comparison.json
@@ -0,0 +1,97 @@
+{
+  "base_solution_folder": "solutions/plasma_comparison",
+  "verbose": 1,
+  "seed": 42,
+  "max_steps": 8,
+  "min_run_time": 1,
+  "max_run_time": 1,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3, 0.15],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "pg_s": { "epsilon": 1e-6 },
+    "pg_r": { "epsilon": 1e-6 },
+    "plasma": {
+      "rounds_per_step": 20,
+      "k_sb": 10,
+      "mu": 0.1,
+      "n_sb_steps": 300,
+      "p_commit": 0.5,
+      "n_hyst": 2
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 1,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-6,
+  "limits": {
+    "Nn": {
+      "values": [10]
+    },
+    "Nf": {
+      "min": 2,
+      "max": 2
+    },
+    "neighborhood": {
+      "p": 0.3
+    },
+    "demand": {
+      "values": [1.0, 1.2]
+    },
+    "memory_capacity": {
+      "min": 12,
+      "max": 12
+    },
+    "memory_requirement": {
+      "values": [2, 3]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "sinusoidal",
+      "min": {"min": 5, "max": 10},
+      "max": {"min": 50, "max": 100}
+    },
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.5},
+      "beta_multiplier": {"min": 1.5, "max": 2.5},
+      "gamma": {"min": 0.05, "max": 0.15},
+      "delta_multiplier": {"min": 0.1, "max": 0.2}
+    }
+  }
+}
diff --git a/config_files/plasma_m7_rare.json b/config_files/plasma_m7_rare.json
new file mode 100644
index 0000000..a302c4e
--- /dev/null
+++ b/config_files/plasma_m7_rare.json
@@ -0,0 +1,140 @@
+{
+  "base_solution_folder": "solutions/plasma_m7",
+  "verbose": 0,
+  "seed": 4242,
+  "max_steps": 30,
+  "min_run_time": 0,
+  "max_run_time": 29,
+  "run_time_step": 1,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "OutputFlag": 0
+    },
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [
+        0.5,
+        0.3,
+        0.15
+      ],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "br_r": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "br_o": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "pg_s": {
+      "epsilon": 1e-06
+    },
+    "pg_r": {
+      "epsilon": 1e-06
+    },
+    "plasma": {
+      "rounds_per_step": 20,
+      "k_sb": 10,
+      "mu": 0.3,
+      "p_commit": 0.5,
+      "n_hyst": 2
+    }
+  },
+  "max_iterations": 20,
+  "patience": 5,
+  "sw_patience": 5,
+  "checkpoint_interval": 10,
+  "max_hierarchy_depth": 3,
+  "tolerance": 1e-06,
+  "limits": {
+    "Nn": {
+      "min": 10,
+      "max": 10
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "neighborhood": {
+      "m": 40
+    },
+    "demand": {
+      "values": [
+        1.0,
+        1.2,
+        0.9
+      ]
+    },
+    "memory_capacity": {
+      "min": 48,
+      "max": 144
+    },
+    "memory_requirement": {
+      "values": [
+        2,
+        3,
+        2
+      ]
+    },
+    "max_utilization": {
+      "min": 0.65,
+      "max": 0.75
+    },
+    "load": {
+      "trace_type": "clipped",
+      "min": {
+        "min": 1,
+        "max": 2
+      },
+      "max": {
+        "min": 4,
+        "max": 8
+      }
+    },
+    "weights": {
+      "alpha": {
+        "min": 1.0,
+        "max": 1.5
+      },
+      "beta_multiplier": {
+        "min": 1.5,
+        "max": 2.5
+      },
+      "gamma": {
+        "min": 0.05,
+        "max": 0.15
+      },
+      "delta_multiplier": {
+        "min": 0.1,
+        "max": 0.2
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/convert_data_format.py b/convert_data_format.py
index 9fa1d0b..8c86674 100644
--- a/convert_data_format.py
+++ b/convert_data_format.py
@@ -57,8 +57,8 @@ def compute_avg_demand(demand: dict, Nn: int, Nf: int) -> Tuple[float, float]:
     # compute standard deviation
     demand_std[f] = 0.0
     for n in range(Nn):
-      demand_avg[f] += (demand[(n+1, f+1)] - demand_avg[f])**2
-    demand_avg[f] = np.sqrt(demand_avg[f] / (Nn - 1))
+      demand_std[f] += (demand[(n+1, f+1)] - demand_avg[f])**2
+    demand_std[f] = np.sqrt(demand_std[f] / max(1, Nn - 1))
   return demand_avg, demand_std
 
 
diff --git a/decentralized_auction.py b/decentralized_auction.py
index 2fd6502..685d5f7 100644
--- a/decentralized_auction.py
+++ b/decentralized_auction.py
@@ -196,10 +196,15 @@ def evaluate_bids(
     p: np.array, 
     capacity: np.array, 
     u0: np.array, 
-    auction_options: dict
+    auction_options: dict,
+    current_y: np.array = None,
   ) -> np.array:
   Nn = data[None]["Nn"][None]
   Nf = data[None]["Nf"][None]
+  if current_y is None:
+    current_y = np.zeros((Nn,Nn,Nf))
+  sending = current_y.sum(axis=1) > 1e-10
+  receiving = current_y.sum(axis=0) > 1e-10
   # loop over agents and functions
   potential_sellers, functions_to_share = np.nonzero(blackboard)
   y = np.zeros((Nn,Nn,Nf))
@@ -211,15 +216,23 @@ def evaluate_bids(
     remaining_capacity = blackboard[j,f]
     next_bid_idx = 0
     min_b = bids_for_j["b"].max()
+    accepted_any = False
     # loop over bids until there is remaining capacity
     while next_bid_idx < len(bids_for_j) and remaining_capacity > 0:
-      q = min(remaining_capacity, bids_for_j.iloc[next_bid_idx]["d"])
-      y[int(bids_for_j.iloc[next_bid_idx]["i"]),j,f] += q
-      remaining_capacity -= q
-      min_b = min(min_b, bids_for_j.iloc[next_bid_idx]["b"])
+      bid = bids_for_j.iloc[next_bid_idx]
+      i = int(bid["i"])
       next_bid_idx += 1
+      if receiving[i,f] or sending[j,f]:
+        continue
+      q = min(remaining_capacity, bid["d"])
+      y[i,j,f] += q
+      remaining_capacity -= q
+      min_b = min(min_b, bid["b"])
+      sending[i,f] = True
+      receiving[j,f] = True
+      accepted_any = True
     # compute utilization and update prices
-    if next_bid_idx > 0:
+    if accepted_any:
       u = (ell[j,f] + y[:,j,f].sum()) / capacity[j,f]
       p[j,f] = min_b + auction_options["eta"] * (u - u0[j,f])
     else:
@@ -411,7 +424,8 @@ def run(
       if len(bids) > 0:
         s = datetime.now()
         auction_y, p = evaluate_bids(
-          bids, blackboard, data, ell, p, capacity, u0, auction_options
+          bids, blackboard, data, ell, p, capacity, u0, auction_options,
+          current_y=y,
         )
         e = datetime.now()
         if verbose > 1:
diff --git a/decentralized_bestresponse.py b/decentralized_bestresponse.py
new file mode 100644
index 0000000..32c02f7
--- /dev/null
+++ b/decentralized_bestresponse.py
@@ -0,0 +1,523 @@
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import (
+  LSP,
+  LSP_capped,
+  LSP_capped_fixedr,
+  LSP_fixedr,
+  LSPr,
+  LSPr_fixedr,
+)
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def best_response_sweep(
+    omega: np.array,
+    residual_capacity: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    br_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    *,
+    order: str,
+    response: str,
+    rng: np.random.Generator = None,
+    reopt_fn=None,
+    current_y: np.array = None,
+    tolerance: float = 1e-6,
+  ) -> Tuple[np.array, pd.DataFrame, int, float, float]:
+  """Sequential (Gauss-Seidel) best-response sweep.
+
+  Nodes act in `order` ("fixed" = ascending index, "random" = rng permutation);
+  Each node releases its current buyer row, computes a new response greedily by
+  descending score, and immediately commits it to the shared ledger. Later
+  nodes therefore observe earlier coordinate updates. For response=="reopt",
+  the target omega row is first recomputed through reopt_fn.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  ledger = np.array(residual_capacity, dtype=float)
+  omega = np.array(omega, dtype=float)
+  if current_y is None:
+    current_y = np.zeros((Nn, Nn, Nf))
+  else:
+    current_y = np.array(current_y, dtype=float)
+  # live view of committed forwarding: updated as each mover commits, so the
+  # no_ping_pong guard below sees earlier movers' sends within this sweep
+  # (matches decentralized_potentialgame's inductive argument).
+  live_y = np.array(current_y, dtype=float)
+  y_increment = np.zeros((Nn, Nn, Nf))
+  memory_bids = {"i": [], "j": [], "f": []}
+  reopt_runtime = 0.0
+  placed_total = 0.0
+  active = set()
+  if order == "random":
+    if rng is None:
+      raise ValueError("rng is required when order='random'")
+    node_order = [int(i) for i in rng.permutation(Nn)]
+  elif order == "fixed":
+    node_order = list(range(Nn))
+  else:
+    raise ValueError("order must be one of: fixed, random")
+  if response not in {"greedy", "reopt"}:
+    raise ValueError("response must be one of: greedy, reopt")
+  for i in node_order:
+    neighbours = set(int(j) for j in np.nonzero(neighborhood[i, :])[0])
+    previous_row = current_y[i, :, :]
+    if not np.any(omega[i, :] > 0) and not np.any(previous_row > 0):
+      continue
+    active.add(i)
+    ledger += previous_row
+    # no_ping_pong: a node already sending f (residual demand or forwarded
+    # load, i's own released row excluded) must not host f; and the mover must
+    # not offload any f it already hosts inbound.
+    sender = live_y.sum(axis=1)
+    sender[i, :] = 0.0
+    forbidden = (omega > tolerance) | (sender > tolerance)
+    inbound_i = live_y[:, i, :].sum(axis=0)
+    new_row = np.zeros((Nn, Nf))
+    if response == "reopt" and reopt_fn is not None and np.any(omega[i, :] > 0):
+      omega_ub_row = np.array(
+        [sum(ledger[j, f] for j in neighbours) for f in range(Nf)]
+      )
+      capped_row, rt = reopt_fn(i, omega_ub_row)
+      reopt_runtime += rt
+      omega[i, :] = capped_row
+    for f in range(Nf):
+      if omega[i, f] <= 0:
+        continue
+      if inbound_i[f] > tolerance:
+        continue
+      memory_requirement = data[None]["memory_requirement"][f + 1]
+      potential_memory = {
+        j for j in neighbours
+        if rho[j] >= memory_requirement and not forbidden[j, f]
+      }
+      potential_capacity = {
+        j for j in neighbours if ledger[j, f] >= 1 and not forbidden[j, f]
+      }
+      score = {}
+      for j in potential_capacity:
+        s = (
+          data[None]["beta"][(i + 1, j + 1, f + 1)]
+          - br_options["latency_weight"] * latency[i, j]
+          - br_options["fairness_weight"] * fairness[i, f]
+        )
+        if s > - data[None]["gamma"][(i + 1, f + 1)]:
+          score[j] = s
+      placed = 0.0
+      for j in sorted(score, key=lambda k: (-score[k], k)):
+        if placed >= omega[i, f]:
+          break
+        q = min(ledger[j, f], omega[i, f] - placed)
+        if q <= 0:
+          continue
+        new_row[j, f] += q
+        ledger[j, f] -= q
+        placed += q
+      placed_total += placed
+      if placed < omega[i, f] or force_memory_bids:
+        for j in sorted(score, key=lambda k: (-score[k], k)):
+          if j in potential_memory:
+            memory_bids["i"].append(i)
+            memory_bids["j"].append(j)
+            memory_bids["f"].append(f)
+      if placed < omega[i, f] or force_memory_bids:
+        for j in sorted(potential_memory - potential_capacity):
+          memory_bids["i"].append(i)
+          memory_bids["j"].append(j)
+          memory_bids["f"].append(f)
+    y_increment[i, :, :] = new_row - previous_row
+    live_y[i, :, :] = new_row
+  return (
+    y_increment, pd.DataFrame(memory_bids), len(active),
+    placed_total, reopt_runtime,
+  )
+
+
+def reoptimize_node(
+    node: int,
+    omega_ub_row: np.array,
+    sp_data: dict,
+    solver_name: str,
+    general_solver_options: dict,
+    parallelism: int,
+    use_fixed_r: bool,
+  ) -> Tuple[np.array, float]:
+  """Capped local best response for one node.
+
+  Deep-copies sp_data, sets the per-function offloading cap omega_ub to the
+  accessible neighbour residual capacity, and re-solves ONLY ``node`` with
+  LSP_capped (or LSP_capped_fixedr when fixed replicas are active). Returns the
+  node's re-optimized omega row and the solve runtime. Only this omega row is
+  consumed by the caller; the capped solve's x/z/r are diagnostic.
+  """
+  Nf = sp_data[None]["Nf"][None]
+  node_data = deepcopy(sp_data)
+  node_data[None]["omega_ub"] = {
+    (f + 1): float(omega_ub_row[f]) for f in range(Nf)
+  }
+  model = LSP_capped_fixedr() if use_fixed_r else LSP_capped()
+  result = solve_subproblem(
+    node_data, [node], model, solver_name, general_solver_options, parallelism
+  )
+  sp_omega = result[4]
+  runtime = result[10]["tot"]
+  return np.array(sp_omega[node, :], dtype=float), float(runtime)
+
+
+def compute_sweep_runtime(
+    elapsed: float, reopt_runtime: float, n_active: int
+  ) -> float:
+  bookkeeping_runtime = max(0.0, elapsed - reopt_runtime)
+  amortized_bookkeeping = (
+    bookkeeping_runtime / n_active if n_active else bookkeeping_runtime
+  )
+  return reopt_runtime + amortized_bookkeeping
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MABR",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  parser.add_argument(
+    "--variant", choices=["s", "r", "o"], default="s",
+    help="FaaS-MABR variant: s (sequential), r (randomized), o (re-optimization)",
+  )
+  return parser.parse_known_args()[0]
+
+
+def _run(
+    config: dict,
+    parallelism: int,
+    *,
+    order: str,
+    response: str,
+    method_name: str,
+    options_key: str,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  br_options = dict(solver_options[options_key])
+  br_options.setdefault("latency_weight", 0.0)
+  br_options.setdefault("fairness_weight", 0.0)
+  rng = np.random.default_rng(seed)
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  patience = config["patience"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight="network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    spr = LSPr() if opt_solution is None else LSPr_fixedr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = -np.inf
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    n_accepted_queue = deque(maxlen=patience)
+    while not stop_searching:
+      s = datetime.now()
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      coordination_rho = (
+        sp_rho if opt_solution is None else np.zeros_like(sp_rho)
+      )
+      total_runtime += (datetime.now() - s).total_seconds()
+      reopt_fn = None
+      if response == "reopt":
+        def reopt_fn(node, omega_ub_row):
+          return reoptimize_node(
+            node, omega_ub_row, sp_data, solver_name,
+            general_solver_options, parallelism,
+            use_fixed_r=(opt_solution is not None),
+          )
+      s = datetime.now()
+      sweep_y, memory_bids, n_active, _, reopt_runtime = best_response_sweep(
+        sp_omega, residual_capacity, sp_data, neighborhood, coordination_rho,
+        br_options, latency, fairness,
+        force_memory_bids=(
+          (coordination_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+        order=order, response=response, rng=rng, reopt_fn=reopt_fn,
+        current_y=y, tolerance=tolerance,
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += compute_sweep_runtime(rt, reopt_runtime, n_active)
+      allocation_changed = (np.abs(sweep_y) > tolerance).any()
+      rmp_omega = y.sum(axis=1)
+      additional_replicas = np.zeros((Nn, Nf))
+      if allocation_changed:
+        y += sweep_y
+        y[np.abs(y) < tolerance] = 0.0
+        rmp_omega = y.sum(axis=1)
+        fairness += (rmp_omega > tolerance)
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      mabr_no_progress = (
+        not allocation_changed and not (additional_replicas > tolerance).any()
+      )
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, None, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching and mabr_no_progress:
+        stop_searching = True
+        why_stop_searching = "no best-response progress"
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=[method_name]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+def run_br_s(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed", response="greedy",
+              method_name="FaaS-MABR-S", options_key="br_s",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_br_r(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="random", response="greedy",
+              method_name="FaaS-MABR-R", options_key="br_r",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_br_o(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed", response="reopt",
+              method_name="FaaS-MABR-O", options_key="br_o",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  runner = {"s": run_br_s, "r": run_br_r, "o": run_br_o}[args.variant]
+  runner(config, args.parallelism, disable_plotting=args.disable_plotting)
diff --git a/decentralized_diffusion.py b/decentralized_diffusion.py
new file mode 100644
index 0000000..600ba12
--- /dev/null
+++ b/decentralized_diffusion.py
@@ -0,0 +1,521 @@
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  VAR_TYPE,
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility, ping_pong_forbidden_hosts
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSPr, LSPr_fixedr
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def define_assignments(
+    omega: np.array,
+    blackboard: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    diffusion_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    current_y: np.array = None,
+    tolerance: float = 1e-6,
+  ) -> Tuple[pd.DataFrame, pd.DataFrame, int]:
+  """Price-free counterpart of run_faasmadea.define_bids.
+
+  Greedy-by-utility assignment of residual load to neighbours with spare
+  capacity. No bid price is computed (no epsilon/delta); the per-pair score is
+  stored in the ``utility`` column, on which evaluate_assignments later sorts.
+  """
+  if current_y is None:
+    current_y = np.zeros((omega.shape[0], omega.shape[0], omega.shape[1]))
+  # no_ping_pong: a node that is a sender of f (residual demand or already
+  # forwarded) must not be picked as a host for f. Covers both the capacity and
+  # the memory seller path, since both derive from ``potential_sellers``.
+  forbidden = ping_pong_forbidden_hosts(omega, current_y, tolerance)
+  potential_buyers, functions_to_share = np.nonzero(omega)
+  bids = {"i": [], "j": [], "f": [], "d": [], "utility": []}
+  memory_bids = {"i": [], "j": [], "f": []}
+  for i, f in zip(potential_buyers, functions_to_share):
+    potential_sellers = set(np.nonzero(neighborhood[i, :])[0])
+    potential_sellers -= {int(j) for j in np.nonzero(forbidden[:, f])[0]}
+    potential_capacity_sellers = potential_sellers.intersection(
+      set(np.where(blackboard[:, f] >= 1)[0])
+    )
+    memory_requirement = data[None]["memory_requirement"][f + 1]
+    potential_memory_sellers = {
+      int(j) for j in potential_sellers if rho[int(j)] >= memory_requirement
+    }
+    utility = []
+    candidate_sellers = []
+    for j in potential_capacity_sellers:
+      ut = (
+        data[None]["beta"][(i + 1, j + 1, f + 1)]
+        - diffusion_options["latency_weight"] * latency[i, j]
+        - diffusion_options["fairness_weight"] * fairness[i, f]
+      )
+      if ut > - data[None]["gamma"][(i + 1, f + 1)]:
+        utility.append(ut)
+        candidate_sellers.append(j)
+    assigned = 0
+    if len(utility) > 0:
+      sellers_order = sorted(
+        range(len(candidate_sellers)),
+        key=lambda idx: (-utility[idx], candidate_sellers[idx]),
+      )
+      idx = 0
+      while idx < len(sellers_order) and assigned < omega[i, f]:
+        j = candidate_sellers[sellers_order[idx]]
+        if diffusion_options.get("unit_bids", False):
+          d = 1
+          while (d < int(min(blackboard[j, f], omega[i, f])) + 1) and (
+              assigned < omega[i, f]
+            ):
+            bids["i"].append(i)
+            bids["f"].append(f)
+            bids["j"].append(j)
+            bids["d"].append(1)
+            bids["utility"].append(utility[sellers_order[idx]])
+            assigned += 1
+            d += 1
+        else:
+          d = VAR_TYPE(min(blackboard[j, f], (omega[i, f] - assigned)))
+          bids["i"].append(i)
+          bids["f"].append(f)
+          bids["j"].append(j)
+          bids["d"].append(d)
+          bids["utility"].append(utility[sellers_order[idx]])
+          assigned += d
+        idx += 1
+      if assigned < omega[i, f] or force_memory_bids:
+        for idx in sellers_order:
+          j = candidate_sellers[idx]
+          if j in potential_memory_sellers:
+            memory_bids["i"].append(i)
+            memory_bids["j"].append(j)
+            memory_bids["f"].append(f)
+    if assigned < omega[i, f] or force_memory_bids:
+      for j in potential_memory_sellers - potential_capacity_sellers:
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(j)
+        memory_bids["f"].append(f)
+  return pd.DataFrame(bids), pd.DataFrame(memory_bids), len(potential_buyers)
+
+
+def evaluate_assignments(
+    bids: pd.DataFrame,
+    residual_capacity: np.array,
+    data: dict,
+    ell: np.array,
+    r: np.array,
+    initial_rho: np.array,
+    tentatively_start_replicas: bool,
+    last_y: np.array = None,
+    diffusion_options: dict = None,
+    latency: np.array = None,
+    fairness: np.array = None,
+  ) -> Tuple[np.array, np.array, int]:
+  """Price-free counterpart of run_faasmadea.evaluate_bids.
+
+  Pure greedy capacity fill: sellers serve buyers by descending ``utility``
+  (tie-break on buyer index ``i`` for reproducibility). No min_b tracking and no
+  price update. When the seller is full and ``last_y`` plus score inputs are
+  provided, a higher-score request may replace a lower-score incumbent, matching
+  the auction's reassignment role without using prices.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  if last_y is None:
+    last_y = np.zeros((Nn, Nn, Nf))
+  if diffusion_options is None:
+    diffusion_options = {"latency_weight": 0.0, "fairness_weight": 0.0}
+  if latency is None:
+    latency = np.zeros((Nn, Nn))
+  if fairness is None:
+    fairness = np.zeros((Nn, Nf))
+  seller_pairs = {
+    (int(j), int(f)) for j, f in zip(*np.nonzero(residual_capacity > 0))
+  }
+  for row in bids[["j", "f"]].itertuples(index=False):
+    j, f = int(row.j), int(row.f)
+    if last_y[:, j, f].sum() > 0:
+      seller_pairs.add((j, f))
+  if tentatively_start_replicas:
+    for j in np.nonzero(initial_rho)[0]:
+      for f in range(Nf):
+        seller_pairs.add((int(j), f))
+  y = np.zeros((Nn, Nn, Nf))
+  additional_replicas = np.zeros((Nn, Nf))
+  rho = deepcopy(initial_rho)
+  for j, f in sorted(seller_pairs):
+    bids_for_j = bids[(bids["j"] == j) & (bids["f"] == f)].sort_values(
+      by=["utility", "i"], ascending=[False, True]
+    ).reset_index(drop=True)
+    bid_remaining = bids_for_j["d"].to_numpy(dtype=float, copy=True)
+    remaining_capacity = float(residual_capacity[j, f])
+    next_bid_idx = 0
+    while next_bid_idx < len(bids_for_j) and remaining_capacity > 0:
+      q = min(remaining_capacity, bid_remaining[next_bid_idx])
+      y[int(bids_for_j.iloc[next_bid_idx]["i"]), j, f] += q
+      remaining_capacity -= q
+      bid_remaining[next_bid_idx] -= q
+      if bid_remaining[next_bid_idx] <= 1e-12:
+        next_bid_idx += 1
+
+    if tentatively_start_replicas and next_bid_idx < len(bids_for_j):
+      memory_requirement = data[None]["memory_requirement"][f + 1]
+      max_a = int(rho[j] // memory_requirement)
+      if max_a > 0:
+        demand = data[None]["demand"][(j + 1, f + 1)]
+        max_utilization = data[None]["max_utilization"][f + 1]
+        max_capacity = (r[j, f] + max_a) * max_utilization / demand
+        replica_capacity = max(0.0, max_capacity - ell[j, f] - y[:, j, f].sum())
+        while next_bid_idx < len(bids_for_j) and replica_capacity > 1e-12:
+          q = min(replica_capacity, bid_remaining[next_bid_idx])
+          i = int(bids_for_j.iloc[next_bid_idx]["i"])
+          y[i, j, f] += q
+          bid_remaining[next_bid_idx] -= q
+          replica_capacity -= q
+          if bid_remaining[next_bid_idx] <= 1e-12:
+            next_bid_idx += 1
+        hosted_load = ell[j, f] + y[:, j, f].sum()
+        required_r = int(np.ceil((demand * hosted_load / max_utilization) - 1e-12))
+        a = min(max_a, max(0, required_r - int(r[j, f])))
+        additional_replicas[j, f] = a
+        rho[j] -= a * memory_requirement
+
+    incumbent_remaining = last_y[:, j, f].copy()
+    while next_bid_idx < len(bids_for_j):
+      i = int(bids_for_j.iloc[next_bid_idx]["i"])
+      candidate_score = float(bids_for_j.iloc[next_bid_idx]["utility"])
+      while bid_remaining[next_bid_idx] > 1e-12:
+        replaceable = []
+        for incumbent in np.nonzero(incumbent_remaining > 1e-12)[0]:
+          incumbent = int(incumbent)
+          if incumbent == i:
+            continue
+          incumbent_score = (
+            data[None]["beta"][(incumbent + 1, j + 1, f + 1)]
+            - diffusion_options["latency_weight"] * latency[incumbent, j]
+            - diffusion_options["fairness_weight"] * fairness[incumbent, f]
+          )
+          if candidate_score > incumbent_score:
+            replaceable.append((incumbent_score, -incumbent, incumbent))
+        if not replaceable:
+          break
+        _, _, incumbent = min(replaceable)
+        q = min(bid_remaining[next_bid_idx], incumbent_remaining[incumbent])
+        y[incumbent, j, f] -= q
+        y[i, j, f] += q
+        incumbent_remaining[incumbent] -= q
+        bid_remaining[next_bid_idx] -= q
+      next_bid_idx += 1
+  return y, additional_replicas, len(seller_pairs)
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MADiG",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  return parser.parse_known_args()[0]
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  diffusion_options = dict(solver_options["diffusion"])
+  diffusion_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  patience = config["patience"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight="network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    spr = LSPr() if opt_solution is None else LSPr_fixedr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = -np.inf
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    n_accepted_queue = deque(maxlen=patience)
+    while not stop_searching:
+      s = datetime.now()
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      coordination_rho = (
+        sp_rho if opt_solution is None else np.zeros_like(sp_rho)
+      )
+      total_runtime += (datetime.now() - s).total_seconds()
+      s = datetime.now()
+      bids, memory_bids, n_auctions = define_assignments(
+        omega, blackboard, sp_data, neighborhood, coordination_rho,
+        diffusion_options, latency, fairness,
+        force_memory_bids=(
+          (coordination_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+        current_y=y, tolerance=tolerance,
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_auctions) if n_auctions else rt
+      rmp_omega = y.sum(axis=1)
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        s = datetime.now()
+        diffusion_y, additional_replicas, n_sellers = evaluate_assignments(
+          bids, residual_capacity, sp_data, ell, sp_r, coordination_rho,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+          last_y=y,
+          diffusion_options=diffusion_options,
+          latency=latency,
+          fairness=fairness,
+        )
+        rt = (datetime.now() - s).total_seconds()
+        total_runtime += (rt / n_sellers) if n_sellers else rt
+        y += diffusion_y
+        y[np.abs(y) < tolerance] = 0.0
+        rmp_omega = y.sum(axis=1)
+        fairness += (rmp_omega > tolerance)
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, bids, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MADiG"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(config, args.parallelism, disable_plotting=args.disable_plotting)
diff --git a/decentralized_dual.py b/decentralized_dual.py
new file mode 100644
index 0000000..9f0f7a7
--- /dev/null
+++ b/decentralized_dual.py
@@ -0,0 +1,563 @@
+from copy import deepcopy
+from datetime import datetime
+from typing import Tuple
+import argparse
+import json
+import os
+import sys
+
+from networkx import adjacency_matrix
+import numpy as np
+import pandas as pd
+
+from decentralized_diffusion import evaluate_assignments
+from models.sp import LSP, LSP_fixedr, LSPr, LSPr_fixedr
+from postprocessing import load_solution
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility, ping_pong_forbidden_hosts
+from utils.common import load_configuration
+from utils.faasmacro import compute_centralized_objective
+
+
+def pair_scores(
+  data: dict,
+  neighborhood: np.array,
+  latency: np.array,
+  fairness: np.array,
+  dual_options: dict,
+) -> Tuple[np.array, np.array]:
+  """Return Cloud-relative advantages and their eligibility mask.
+
+  Only neighboring pairs with strictly positive advantage are eligible; all
+  other entries are ``-inf``.
+  """
+  values = data[None]
+  nn = values["Nn"][None]
+  nf = values["Nf"][None]
+  scores = np.full((nn, nn, nf), -np.inf)
+  eligible = np.zeros((nn, nn, nf), dtype=bool)
+
+  for i in range(nn):
+    for j in np.flatnonzero(neighborhood[i]):
+      j = int(j)
+      for f in range(nf):
+        score = (
+          values["beta"][(i + 1, j + 1, f + 1)]
+          - dual_options["latency_weight"] * latency[i, j]
+          - dual_options["fairness_weight"] * fairness[i, f]
+          + values["gamma"][(i + 1, f + 1)]
+        )
+        if score > 0.0:
+          scores[i, j, f] = score
+          eligible[i, j, f] = True
+
+  return scores, eligible
+
+
+def buyer_price_response(
+  omega: np.array,
+  capacity: np.array,
+  lam: np.array,
+  s: np.array,
+  elig: np.array,
+) -> Tuple[pd.DataFrame, np.array, float]:
+  """Return uncapped best-seller demand and capacity-capped waterfill bids.
+
+  Demand and the buyer dual term use the best strictly positive price-adjusted
+  advantage with lower seller indices breaking ties; bids rank positive sellers
+  sparsely while exposing the Cloud-relative utility.
+  """
+  nn, nf = omega.shape
+  demand = np.zeros((nn, nf))
+  dual_term = 0.0
+  rows = []
+
+  for i, f in zip(*np.nonzero(omega > 0)):
+    ranked = sorted(
+      (
+        (j, s[i, j, f] - lam[j, f])
+        for j in np.flatnonzero(elig[i, :, f])
+        if s[i, j, f] - lam[j, f] > 0.0
+      ),
+      key=lambda item: (-item[1], item[0]),
+    )
+    if not ranked:
+      continue
+
+    best = ranked[0][0]
+    demand[best, f] += omega[i, f]
+    dual_term += omega[i, f] * ranked[0][1]
+
+    remaining = omega[i, f]
+    for j, _ in ranked:
+      quantity = min(remaining, capacity[j, f])
+      if quantity > 0:
+        rows.append({"i": i, "j": j, "f": f, "d": quantity, "utility": s[i, j, f]})
+        remaining -= quantity
+      if remaining <= 0:
+        break
+
+  bids = pd.DataFrame(rows, columns=["i", "j", "f", "d", "utility"])
+  return bids, demand, dual_term
+
+
+def dual_coordination_round(
+  omega: np.array,
+  residual_capacity: np.array,
+  data: dict,
+  neighborhood: np.array,
+  rho: np.array,
+  dual_options: dict,
+  latency: np.array,
+  fairness: np.array,
+  current_y: np.array = None,
+  tolerance: float = 1e-6,
+  ) -> Tuple[np.array, pd.DataFrame, dict, int]:
+  """Projected dual subgradient loop with primal recovery and certificate."""
+  max_inner_iterations = dual_options["max_inner_iterations"]
+  if isinstance(max_inner_iterations, bool) or not isinstance(
+    max_inner_iterations, (int, np.integer)
+  ):
+    raise ValueError("max_inner_iterations must be a positive integer")
+  numeric_options = {
+    "alpha0": dual_options["alpha0"],
+    "theta": dual_options["theta"],
+    "gap_tolerance": dual_options["gap_tolerance"],
+    "latency_weight": dual_options["latency_weight"],
+    "fairness_weight": dual_options["fairness_weight"],
+  }
+  for name, value in numeric_options.items():
+    if not np.isfinite(value):
+      raise ValueError(f"{name} must be finite")
+  if dual_options["step_rule"] == "sqrt" and dual_options["alpha0"] <= 0.0:
+    raise ValueError("alpha0 must be positive")
+  if dual_options["step_rule"] == "polyak" and dual_options["theta"] <= 0.0:
+    raise ValueError("theta must be positive")
+  if dual_options["gap_tolerance"] < 0.0:
+    raise ValueError("gap_tolerance must be nonnegative")
+  if max_inner_iterations < 1:
+    raise ValueError("max_inner_iterations must be at least 1")
+  if dual_options["step_rule"] not in {"sqrt", "polyak"}:
+    raise ValueError("step_rule must be 'sqrt' or 'polyak'")
+  nn = data[None]["Nn"][None]
+  nf = data[None]["Nf"][None]
+  scores, eligible = pair_scores(
+    data, neighborhood, latency, fairness, dual_options
+  )
+  capacity = np.array(residual_capacity, dtype=float)
+  # no_ping_pong: a node already sending f (residual demand or forwarded load)
+  # must not host f. Drop it from the eligible seller set and zero its sellable
+  # capacity so no primal bid can place load there.
+  if current_y is None:
+    current_y = np.zeros((nn, nn, nf))
+  forbidden = ping_pong_forbidden_hosts(omega, current_y, tolerance)
+  eligible = eligible & ~forbidden[None, :, :]
+  capacity[forbidden] = 0.0
+  lam = np.zeros((nn, nf))
+  score_values = np.where(eligible, scores, 0.0)
+  best_lb, best_ub = 0.0, np.inf
+  best_lam = lam.copy()
+  best_y = np.zeros((nn, nn, nf))
+  ell = np.zeros((nn, nf))
+  r = np.zeros((nn, nf))
+  lb_history = []
+  n_active = int((omega > 0).any(axis=1).sum())
+  gap = 0.0
+  k = 0
+
+  for k in range(1, max_inner_iterations + 1):
+    bids, demand, buyer_term = buyer_price_response(
+      omega, capacity, lam, scores, eligible
+    )
+    ub = float((lam * capacity).sum() + buyer_term)
+    if ub < best_ub:
+      best_ub = ub
+      best_lam = lam.copy()
+    if len(bids) > 0:
+      candidate_y, _, _ = evaluate_assignments(
+        bids, residual_capacity, data, ell, r, rho,
+        tentatively_start_replicas=False, last_y=None,
+        diffusion_options=dual_options, latency=latency, fairness=fairness,
+      )
+      candidate_lb = float((score_values * candidate_y).sum())
+      if candidate_lb > best_lb:
+        best_lb = candidate_lb
+        best_y = candidate_y.copy()
+    lb_history.append(best_lb)
+    gap = (best_ub - best_lb) / max(1.0, abs(best_ub))
+    if gap <= dual_options["gap_tolerance"]:
+      break
+    if len(bids) == 0 and k == 1:
+      # at k == 1 prices are zero, so the bid-eligible seller set is maximal:
+      # no bids now (every positively-advantaged seller lacks capacity, or no
+      # pair is eligible at all) means no bids at any later iteration either,
+      # and the LP optimum is exactly 0, so the zero incumbent is certified
+      # optimal
+      best_ub = 0.0
+      gap = 0.0
+      break
+    if len(bids) == 0 and demand.sum() <= 0:
+      break
+    subgradient = demand - capacity
+    if dual_options["step_rule"] == "polyak":
+      denominator = float((subgradient * subgradient).sum())
+      alpha = (
+        0.0 if denominator <= 0.0
+        else dual_options["theta"] * max(0.0, best_ub - best_lb) / denominator
+      )
+    else:
+      alpha = dual_options["alpha0"] / np.sqrt(k)
+    lam = np.maximum(0.0, lam + alpha * subgradient)
+
+  memory_bids = {"i": [], "j": [], "f": []}
+  placed = best_y.sum(axis=1)
+  for i, f in zip(*np.nonzero(omega > 0)):
+    i, f = int(i), int(f)
+    if placed[i, f] + 1e-12 < omega[i, f]:
+      memory_requirement = data[None]["memory_requirement"][f + 1]
+      for j in np.nonzero(neighborhood[i, :])[0]:
+        if rho[int(j)] >= memory_requirement and not forbidden[int(j), f]:
+          memory_bids["i"].append(i)
+          memory_bids["j"].append(int(j))
+          memory_bids["f"].append(f)
+  memory_bids = pd.DataFrame(memory_bids)
+
+  gap_info = {
+    "LB": best_lb, "UB": best_ub, "gap": gap,
+    "inner_iterations": k, "lam": lam, "best_lam": best_lam,
+    "lb_history": lb_history,
+  }
+  return best_y, memory_bids, gap_info, n_active
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MALD",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  return parser.parse_known_args()[0]
+
+
+def _capacity_state(
+    sp_x: np.array, y: np.array, sp_r: np.array, sp_data: dict
+  ) -> Tuple[np.array, np.array, np.array, np.array]:
+  capacity, residual_capacity, ell = compute_residual_capacity(
+    sp_x, y, sp_r, sp_data
+  )
+  blackboard = np.maximum(0.0, capacity - sp_x)
+  return capacity, residual_capacity, ell, blackboard
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  dual_options = dict(solver_options.get("dual", {}))
+  dual_options.setdefault("alpha0", 1.0)
+  dual_options.setdefault("step_rule", "sqrt")
+  dual_options.setdefault("theta", 1.0)
+  dual_options.setdefault("max_inner_iterations", 50)
+  dual_options.setdefault("gap_tolerance", 0.01)
+  dual_options.setdefault("latency_weight", 0.0)
+  dual_options.setdefault("fairness_weight", 0.0)
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight="network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  certificate_rows = []
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    spr = LSPr() if opt_solution is None else LSPr_fixedr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = -np.inf
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    while not stop_searching:
+      s = datetime.now()
+      capacity, residual_capacity, ell, blackboard = _capacity_state(
+        sp_x, y, sp_r, sp_data
+      )
+      coordination_rho = (
+        sp_rho if opt_solution is None else np.zeros_like(sp_rho)
+      )
+      total_runtime += (datetime.now() - s).total_seconds()
+      s = datetime.now()
+      y_inc, memory_bids, gap_info, n_active = dual_coordination_round(
+        omega, residual_capacity, sp_data, neighborhood, coordination_rho,
+        dual_options, latency, fairness,
+        current_y=y, tolerance=tolerance,
+      )
+      additional_replicas = np.zeros((Nn, Nf))
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_active) if n_active else rt
+      rmp_omega = y.sum(axis=1)
+      allocation_changed = (np.abs(y_inc) > tolerance).any()
+      if allocation_changed:
+        y += y_inc
+        y[np.abs(y) < tolerance] = 0.0
+        rmp_omega = y.sum(axis=1)
+        fairness += (rmp_omega > tolerance)
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(
+            f"LSPr infeasible from fixed y assignments: {bad_nodes}"
+          )
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+      if len(memory_bids) > 0:
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        if (additional_replicas > tolerance).any():
+          capacity, residual_capacity, ell, blackboard = _capacity_state(
+            sp_x, y, sp_r, sp_data
+          )
+        total_runtime += (datetime.now() - s).total_seconds()
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, None, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching and not allocation_changed and not (
+          additional_replicas > tolerance
+        ).any():
+        stop_searching = True
+        why_stop_searching = "no dual progress"
+      certificate_rows.append(
+        {
+          "timestep": t,
+          "outer_iteration": it,
+          "LB": gap_info["LB"],
+          "UB": gap_info["UB"],
+          "gap": gap_info["gap"],
+          "inner_iterations": gap_info["inner_iterations"],
+          "stop_reason": why_stop_searching if stop_searching else "",
+        }
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; fixed-C gap: {gap_info['gap']:.6f}; "
+          f"fixed-C LB: {gap_info['LB']:.6f}; "
+          f"fixed-C UB: {gap_info['UB']:.6f}; "
+          f"inner: {gap_info['inner_iterations']}; "
+          f"best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MALD"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame(
+    certificate_rows,
+    columns=[
+      "timestep",
+      "outer_iteration",
+      "LB",
+      "UB",
+      "gap",
+      "inner_iterations",
+      "stop_reason",
+    ],
+  ).to_csv(
+    os.path.join(solution_folder, "coordination_certificate.csv"),
+    index=False,
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(config, args.parallelism, disable_plotting=args.disable_plotting)
diff --git a/decentralized_gcaa.py b/decentralized_gcaa.py
new file mode 100644
index 0000000..d3f72ca
--- /dev/null
+++ b/decentralized_gcaa.py
@@ -0,0 +1,337 @@
+import numpy as np
+import pandas as pd
+
+from run_centralized_model import (
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  define_bids,
+  neigh_dict_to_matrix,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSPr
+
+from networkx import adjacency_matrix
+from datetime import datetime
+from copy import deepcopy
+import argparse
+import json
+import sys
+import os
+
+
+def resolve_gcaa_round(
+    bids: pd.DataFrame,
+    residual_capacity: np.array,
+    current_y: np.array = None,
+  ) -> np.array:
+  """One GCAA consensus round (Braquet & Bakolas, 2021 - Algorithms 1+3):
+  each buyer agent (i, f) proposes only its highest-utility task (j, f);
+  for each contested task, the single highest-utility proposal wins and
+  consumes one unit of residual_capacity[j, f]. Losers are absent from
+  the returned allocation and simply re-propose next round via a fresh
+  call to define_bids (their omega is left untouched by this function)."""
+  Nn, Nf = residual_capacity.shape
+  y_round = np.zeros((Nn, Nn, Nf))
+  if len(bids) == 0:
+    return y_round
+  if current_y is None:
+    current_y = y_round
+  sending = current_y.sum(axis=1) > 1e-10
+  receiving = current_y.sum(axis=0) > 1e-10
+  best_per_agent = bids.loc[bids.groupby(["i", "f"])["utility"].idxmax()]
+  for (j, f), group in best_per_agent.groupby(["j", "f"]):
+    j, f = int(j), int(f)
+    if sending[j, f]:
+      continue
+    for _, winner in group.sort_values("utility", ascending=False).iterrows():
+      i = int(winner["i"])
+      if receiving[i, f] or residual_capacity[j, f] < winner["d"]:
+        continue
+      y_round[i, j, f] += winner["d"]
+      sending[i, f] = True
+      receiving[j, f] = True
+      break
+  return y_round
+
+
+def parse_arguments() -> argparse.Namespace:
+  """
+  Parse input arguments
+  """
+  parser: argparse.ArgumentParser = argparse.ArgumentParser(
+    description = "Run FaaS-MAGCAA",
+    formatter_class = argparse.ArgumentDefaultsHelpFormatter
+  )
+  parser.add_argument(
+    "-c", "--config",
+    help = "Configuration file",
+    type = str,
+    default = "manual_config.json"
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help = "Number of parallel processes to start (-1: auto, 0: sequential)",
+    type = int,
+    default = -1
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help = "True to disable automatic plot generation for each experiment",
+    default = False,
+    action = "store_true"
+  )
+  args: argparse.Namespace = parser.parse_known_args()[0]
+  return args
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False
+  ):
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  gcaa_options = solver_options["gcaa"]
+  if gcaa_options.get("unit_bids") is not True:
+    raise ValueError("solver_options.gcaa.unit_bids must be true")
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  # generate solution folder
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok = True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent = 2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight = "network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  # GCAA bids are pure utility: price stays at zero forever (no
+  # evaluate_bids-style price adaptation)
+  no_price = np.zeros((Nn, Nf))
+  # zero replica capacity disables define_bids' memory-bid path: GCAA
+  # has no replica-bidding, a buyer with no convenient seller just gets
+  # the null assignment (utility 0) for this round
+  no_replica_sellers = np.zeros((Nn,))
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file = log_stream, flush = True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    sp = LSP()
+    spr = LSPr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    if verbose > 1:
+      print(
+        f"    sp: DONE ({tc['tot']}; obj = {obj['tot']}; "
+        f"runtime = {sp_runtime['tot']})",
+        file = log_stream, flush = True
+      )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = -np.inf
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    while not stop_searching:
+      if verbose > 0:
+        print(f"    it = {it}", file = log_stream, flush = True)
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      bids, memory_bids, n_auctions = define_bids(
+        omega, blackboard, no_price, sp_data, neighborhood,
+        no_replica_sellers, gcaa_options, latency, fairness,
+        force_memory_bids = False
+      )
+      if verbose > 2:
+        print(bids, file = log_stream, flush = True)
+      rmp_omega = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        auction_y = resolve_gcaa_round(bids, residual_capacity, y)
+        y += auction_y
+        for n in range(Nn):
+          for f in range(Nf):
+            rmp_omega[n,f] = y[n,:,f].sum()
+            if rmp_omega[n,f] > 0:
+              fairness[n,f] += 1
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(
+            f"LSPr infeasible from fixed y assignments: {bad_nodes}"
+          )
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        for i in range(Nn):
+          for f in range(Nf):
+            omega[i,f] = sp_omega[i,f] - rmp_omega[i,f]
+            if abs(omega[i,f]) < tolerance:
+              omega[i,f] = 0.0
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if best_centralized_solution is None or cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega, None,
+        bids, memory_bids, tolerance, total_runtime, time_limit
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    ee = datetime.now()
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(ee-ss).total_seconds()})",
+        file = log_stream, flush = True
+      )
+    runtime_list.append(total_runtime)
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns = ["FaaS-MAGCAA"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index = False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index = False
+  )
+  if verbose > 0:
+    print(
+      f"All solutions saved in: {solution_folder}",
+      file = log_stream, flush = True
+    )
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(
+    config, args.parallelism, log_on_file = False,
+    disable_plotting = args.disable_plotting
+  )
diff --git a/decentralized_potentialgame.py b/decentralized_potentialgame.py
new file mode 100644
index 0000000..1c39c2f
--- /dev/null
+++ b/decentralized_potentialgame.py
@@ -0,0 +1,551 @@
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSP_pg, LSP_pg_fixedr
+
+from datetime import datetime
+from copy import deepcopy
+from typing import Callable, Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def compute_z(x: np.array, y: np.array, sp_data: dict) -> np.array:
+  """Cloud-forwarded load derived from flow conservation (same convention as
+  combine_solutions): z = load - x - outbound."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  z = np.zeros((Nn, Nf))
+  for n in range(Nn):
+    for f in range(Nf):
+      load = sp_data[None]["incoming_load"][(n + 1, f + 1)]
+      z[n, f] = max(0.0, load - x[n, f] - y[n, :, f].sum())
+  return z
+
+
+def compute_node_utility(
+    i: int, x: np.array, y: np.array, z: np.array, sp_data: dict
+  ) -> float:
+  """Node i's share of the centralized objective. Summing over all nodes
+  yields exactly compute_centralized_objective (the exact potential)."""
+  xm = np.zeros_like(x)
+  ym = np.zeros_like(y)
+  zm = np.zeros_like(z)
+  xm[i, :] = x[i, :]
+  ym[i, :, :] = y[i, :, :]
+  zm[i, :] = z[i, :]
+  return compute_centralized_objective(sp_data, xm, ym, zm)
+
+
+def split_omega(
+    i: int,
+    omega_row: np.array,
+    ledger: np.array,
+    neighbours: set,
+    sp_data: dict,
+  ) -> np.array:
+  """Fractional-knapsack split of node i's proposed offload across eligible
+  sellers by descending beta (exact best response for the linear utility).
+  Mutates ledger in place; unplaced residual is left to the Cloud (z)."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  new_row = np.zeros((Nn, Nf))
+  for f in range(Nf):
+    if omega_row[f] <= 0:
+      continue
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    score = {}
+    for j in neighbours:
+      b = sp_data[None]["beta"][(i + 1, j + 1, f + 1)]
+      if b > -gamma_if and ledger[j, f] > 0:
+        score[j] = b
+    placed = 0.0
+    for j in sorted(score, key=lambda k: (-score[k], k)):
+      if placed >= omega_row[f]:
+        break
+      q = min(ledger[j, f], omega_row[f] - placed)
+      if q <= 0:
+        continue
+      new_row[j, f] += q
+      ledger[j, f] -= q
+      placed += q
+  return new_row
+
+
+def propose_node_move(
+    node: int,
+    omega_ub_row: np.array,
+    y: np.array,
+    sp_data: dict,
+    model,
+    solver_name: str,
+    general_solver_options: dict,
+    parallelism: int,
+  ) -> Tuple[np.array, np.array, np.array, float]:
+  """MILP proposal for one node: re-solve the local problem with committed
+  inbound flows (y_bar) and the accessible-capacity cap (omega_ub).
+
+  The proposal prices aggregate offloading with delta (as P2 does); the
+  caller's epsilon-acceptance on the true beta-aware utility is what
+  guarantees potential monotonicity, not proposal optimality."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  node_data = deepcopy(sp_data)
+  node_data[None]["omega_ub"] = {
+    (f + 1): float(omega_ub_row[f]) for f in range(Nf)
+  }
+  node_data[None]["y_bar"] = {
+    (m + 1, n + 1, f + 1): float(max(y[m, n, f], 0.0))
+    for m in range(Nn) for n in range(Nn) for f in range(Nf)
+  }
+  result = solve_subproblem(
+    node_data, [node], model, solver_name, general_solver_options, parallelism
+  )
+  x_row = np.array(result[1][node, :], dtype=float)
+  omega_row = np.array(result[4][node, :], dtype=float)
+  r_row = np.array(result[5][node, :], dtype=float)
+  runtime = float(result[10]["tot"])
+  return x_row, r_row, omega_row, runtime
+
+
+def compute_rho(r: np.array, sp_data: dict) -> np.array:
+  """Memory slack per node for the CURRENT committed replicas. Must be
+  recomputed whenever r changes (accepted moves re-decide r via the MILP),
+  or the memory market would allocate replicas against stale slack."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  rho = np.array([
+    sp_data[None]["memory_capacity"][j + 1] - sum(
+      r[j, f] * sp_data[None]["memory_requirement"][f + 1] for f in range(Nf)
+    )
+    for j in range(Nn)
+  ], dtype=float)
+  assert (rho > -1e-6).all(), f"memory budget violated: rho={rho}"
+  return np.maximum(rho, 0.0)
+
+
+def node_move(
+    i: int,
+    x: np.array,
+    y: np.array,
+    r: np.array,
+    sp_data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    epsilon: float,
+    propose_fn: Callable,
+    tolerance: float,
+  ) -> Tuple[bool, float, dict, float]:
+  """One better-response move. Rules that keep Phi an exact potential:
+  the mover keeps serving committed inbound flows (enforced by LSP_pg via
+  y_bar) and only claims advertised residual capacity of its neighbours.
+  The move is committed iff the TRUE utility (per-pair beta) improves by
+  more than epsilon; x, y, r are mutated in place only on acceptance.
+  Moves also respect the FRALB no-ping-pong constraint (see inline note)."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  memory_bids = {"i": [], "j": [], "f": []}
+  neighbours = set(int(j) for j in np.nonzero(neighborhood[i, :])[0])
+  z = compute_z(x, y, sp_data)
+  u_old = compute_node_utility(i, x, y, z, sp_data)
+  # residual capacity visible to i, with its own row released
+  y_trial = np.array(y, dtype=float)
+  y_trial[i, :, :] = 0.0
+  _, ledger, _ = compute_residual_capacity(x, y_trial, r, sp_data)
+  # FRALB no-ping-pong (validate_centralized_solution): a node must not both
+  # send and receive the same function. Inductively (y starts at 0):
+  # a neighbour currently offloading f is not a valid seller for f, and the
+  # mover must not offload any f it holds inbound commitments for. Both rules
+  # only shrink the move class, so the exact-potential argument is unaffected.
+  outbound = y_trial.sum(axis=1)
+  ledger[outbound > tolerance] = 0.0
+  inbound_row = y_trial[:, i, :].sum(axis=0)
+  omega_ub_row = np.zeros(Nf)
+  for f in range(Nf):
+    if inbound_row[f] > tolerance:
+      continue
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    omega_ub_row[f] = sum(
+      ledger[j, f] for j in neighbours
+      if sp_data[None]["beta"][(i + 1, j + 1, f + 1)] > -gamma_if
+    )
+  x_row, r_row, omega_row, runtime = propose_fn(i, omega_ub_row)
+  omega_row = np.minimum(np.array(omega_row, dtype=float), omega_ub_row)
+  new_row = split_omega(i, omega_row, ledger, neighbours, sp_data)
+  # candidate state (copies: commit only on acceptance)
+  x_new = np.array(x, dtype=float)
+  y_new = y_trial
+  x_new[i, :] = x_row
+  y_new[i, :, :] = new_row
+  z_new = compute_z(x_new, y_new, sp_data)
+  u_new = compute_node_utility(i, x_new, y_new, z_new, sp_data)
+  delta_u = u_new - u_old
+  accepted = delta_u > epsilon
+  if accepted:
+    x[i, :] = x_row
+    y[i, :, :] = new_row
+    r[i, :] = r_row
+  # unplaced appetite signals a capacity shortage: bid on neighbour memory.
+  # The proposal's omega is capped by the current ledger, so scarcity must
+  # also be read from the Cloud-forwarded residue z (load the node would
+  # rather offload than reject, since delta > 0 > -gamma): without the
+  # z-signal, a saturated neighbourhood never grows and coordination stalls
+  # at the initial residual capacity.
+  placed = new_row.sum(axis=0)
+  for f in range(Nf):
+    if inbound_row[f] > tolerance:
+      continue  # no-ping-pong: this node can never offload f
+    unmet = max(omega_row[f] - placed[f], z_new[i, f])
+    if unmet <= tolerance:
+      continue
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    memory_requirement = sp_data[None]["memory_requirement"][f + 1]
+    for j in sorted(neighbours):
+      if (
+          rho[j] >= memory_requirement
+          and sp_data[None]["beta"][(i + 1, j + 1, f + 1)] > -gamma_if
+        ):
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(j)
+        memory_bids["f"].append(f)
+  return accepted, float(delta_u), memory_bids, runtime
+
+
+def potential_game_sweep(
+    x: np.array,
+    y: np.array,
+    r: np.array,
+    sp_data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    epsilon: float,
+    tolerance: float,
+    order: str,
+    rng: np.random.Generator,
+    propose_fn: Callable,
+  ) -> Tuple[int, float, pd.DataFrame, float]:
+  """Gauss-Seidel sweep of better-response moves. Every accepted move raises
+  the exact potential Phi by more than epsilon, so sweeps terminate."""
+  Nn = sp_data[None]["Nn"][None]
+  if order == "random":
+    node_order = [int(i) for i in rng.permutation(Nn)]
+  elif order == "fixed":
+    node_order = list(range(Nn))
+  else:
+    raise ValueError("order must be one of: fixed, random")
+  n_accepted = 0
+  delta_phi = 0.0
+  proposal_runtime = 0.0
+  all_bids = {"i": [], "j": [], "f": []}
+  for i in node_order:
+    accepted, delta_u, bids, runtime = node_move(
+      i, x, y, r, sp_data, neighborhood, rho, epsilon, propose_fn, tolerance
+    )
+    proposal_runtime += runtime
+    if accepted:
+      n_accepted += 1
+      delta_phi += delta_u
+    for k in all_bids:
+      all_bids[k].extend(bids[k])
+  return n_accepted, delta_phi, pd.DataFrame(all_bids), proposal_runtime
+
+
+def check_pg_stopping(
+    it: int,
+    max_iterations: int,
+    n_accepted: int,
+    n_new_replicas: int,
+    total_runtime: float,
+    time_limit: float,
+  ) -> Tuple[bool, str]:
+  if it >= max_iterations - 1:
+    return True, "max iterations reached"
+  if total_runtime >= time_limit:
+    return True, f"reached time limit: {total_runtime} >= {time_limit}"
+  if n_accepted == 0 and n_new_replicas == 0:
+    return True, "epsilon-Nash equilibrium certified"
+  return False, None
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MAPG",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  parser.add_argument(
+    "--variant", choices=["s", "r"], default="s",
+    help="FaaS-MAPG variant: s (fixed order), r (randomized order)",
+  )
+  return parser.parse_known_args()[0]
+
+
+def _run(
+    config: dict,
+    parallelism: int,
+    *,
+    order: str,
+    method_name: str,
+    options_key: str,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  pg_options = dict(solver_options.get(options_key, {}))
+  epsilon = pg_options.get("epsilon", 1e-6)
+  rng = np.random.default_rng(seed)
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"phi_final": []}
+  tc_dict = {"pg": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    pg_model = LSP_pg() if opt_solution is None else LSP_pg_fixedr()
+    (
+      sp_data, sp_x, _, _, _, sp_r, sp_rho, _, _, _, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    x = np.array(sp_x, dtype=float)
+    r = np.array(sp_r, dtype=float)
+    rho = np.array(
+      sp_rho if opt_solution is None else np.zeros_like(sp_rho), dtype=float
+    )
+    y = np.zeros((Nn, Nn, Nf))
+
+    def propose_fn(node, omega_ub_row):
+      return propose_node_move(
+        node, omega_ub_row, y, sp_data, pg_model,
+        solver_name, general_solver_options, parallelism,
+      )
+
+    it = 0
+    stop_searching = False
+    phi_prev = compute_centralized_objective(
+      sp_data, x, y, compute_z(x, y, sp_data)
+    )
+    while not stop_searching:
+      if opt_solution is None:
+        rho = compute_rho(r, sp_data)
+      s = datetime.now()
+      n_accepted, delta_phi, memory_bids, proposal_runtime = (
+        potential_game_sweep(
+          x, y, r, sp_data, neighborhood, rho, epsilon, tolerance,
+          order, rng, propose_fn,
+        )
+      )
+      elapsed = (datetime.now() - s).total_seconds()
+      bookkeeping = max(0.0, elapsed - proposal_runtime)
+      total_runtime += proposal_runtime + (
+        bookkeeping / n_accepted if n_accepted else bookkeeping
+      )
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(memory_bids) > 0 and opt_solution is None:
+        s = datetime.now()
+        # accepted moves in the sweep re-decide r and consume memory slack:
+        # recompute rho before the market or it would allocate stale slack
+        rho = compute_rho(r, sp_data)
+        if (rho > 0).any():
+          additional_replicas, rho = start_additional_replicas(
+            memory_bids, r, sp_data, rho
+          )
+          r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      phi = compute_centralized_objective(
+        sp_data, x, y, compute_z(x, y, sp_data)
+      )
+      assert phi >= phi_prev - 1e-9, (
+        f"potential decreased: {phi_prev} -> {phi}"
+      )
+      phi_prev = phi
+      stop_searching, why_stop_searching = check_pg_stopping(
+        it, max_iterations, n_accepted,
+        int(additional_replicas.sum()), total_runtime, time_limit,
+      )
+      if not stop_searching:
+        it += 1
+    csol = combine_solutions(
+      Nn, Nf, sp_data, loadt, x, r, rho,
+      None, y, None, None, None, None
+    )
+    feas = check_feasibility(
+      csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+      csol["sp"]["r"], csol["sp"]["U"], sp_data
+    )
+    assert feas[0], feas[1]
+    sp_complete_solution, _, objf = decode_solutions(
+      sp_data, csol, sp_complete_solution, None
+    )
+    spc_complete_solution, _, _ = decode_solutions(
+      sp_data, csol, spc_complete_solution, None
+    )
+    obj_dict["phi_final"].append(objf)
+    tc_dict["pg"].append(
+      f"{why_stop_searching} (it: {it}; obj. deviation: {None}; best it: {it}; total runtime: {total_runtime})"
+    )
+    if t % checkpoint_interval == 0 or t == max_steps - 1:
+      save_checkpoint(
+        sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+      )
+      save_checkpoint(
+        spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+      )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = (
+    join_complete_solution(spc_complete_solution)
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["phi_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["phi_final"], columns=[method_name]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["pg"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(
+      f"All solutions saved in: {solution_folder}",
+      file=log_stream, flush=True
+    )
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+def run_pg_s(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed",
+              method_name="FaaS-MAPG-S", options_key="pg_s",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_pg_r(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="random",
+              method_name="FaaS-MAPG-R", options_key="pg_r",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  runner = {"s": run_pg_s, "r": run_pg_r}[args.variant]
+  runner(config, args.parallelism, disable_plotting=args.disable_plotting)
diff --git a/decentralized_powerd.py b/decentralized_powerd.py
new file mode 100644
index 0000000..4c97da4
--- /dev/null
+++ b/decentralized_powerd.py
@@ -0,0 +1,437 @@
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  VAR_TYPE,
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from decentralized_diffusion import evaluate_assignments
+from utils.centralized import check_feasibility, ping_pong_forbidden_hosts
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSPr, LSPr_fixedr
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def sample_assignments(
+    omega: np.array,
+    blackboard: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    powerd_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    rng: np.random.Generator,
+    current_y: np.array = None,
+    tolerance: float = 1e-6,
+  ) -> Tuple[pd.DataFrame, pd.DataFrame, int]:
+  """Power-of-d-choices counterpart of decentralized_diffusion.define_assignments.
+
+  For each overloaded (i, f), instead of scanning the whole candidate
+  neighbourhood greedily (FaaS-MADiG), repeatedly probe a random sample of ``d``
+  candidate sellers (uniform, without replacement) and pick the best by
+  ``criterion``: "score" -> max s_{ij}^f = beta - w_lat*L - w_fair*phi;
+  "capacity" -> max advertised residual capacity. Ties break on the lower node
+  id for reproducibility. The score is always stored in the ``utility`` column,
+  on which the reused evaluate_assignments later sorts the seller side.
+  """
+  try:
+    d = int(powerd_options["d"])
+  except (TypeError, ValueError) as exc:
+    raise ValueError("powerd d must be an integer >= 1") from exc
+  if d < 1:
+    raise ValueError("powerd d must be >= 1")
+  criterion = powerd_options.get("criterion", "score")
+  if criterion not in {"score", "capacity"}:
+    raise ValueError("powerd criterion must be one of: score, capacity")
+  unit_bids = powerd_options.get("unit_bids", False)
+  if current_y is None:
+    current_y = np.zeros((omega.shape[0], omega.shape[0], omega.shape[1]))
+  # no_ping_pong: exclude sender nodes of f from being hosts of f (covers both
+  # the capacity and memory seller path, both derived from potential_sellers).
+  forbidden = ping_pong_forbidden_hosts(omega, current_y, tolerance)
+  potential_buyers, functions_to_share = np.nonzero(omega)
+  bids = {"i": [], "j": [], "f": [], "d": [], "utility": []}
+  memory_bids = {"i": [], "j": [], "f": []}
+  for i, f in zip(potential_buyers, functions_to_share):
+    i = int(i)
+    f = int(f)
+    potential_sellers = set(np.nonzero(neighborhood[i, :])[0])
+    potential_sellers -= {int(j) for j in np.nonzero(forbidden[:, f])[0]}
+    potential_capacity_sellers = potential_sellers.intersection(
+      set(np.where(blackboard[:, f] >= 1)[0])
+    )
+    memory_requirement = data[None]["memory_requirement"][f + 1]
+    potential_memory_sellers = {
+      int(j) for j in potential_sellers if rho[int(j)] >= memory_requirement
+    }
+    score = {}
+    candidates = []
+    for j in potential_capacity_sellers:
+      j = int(j)
+      s = (
+        data[None]["beta"][(i + 1, j + 1, f + 1)]
+        - powerd_options["latency_weight"] * latency[i, j]
+        - powerd_options["fairness_weight"] * fairness[i, f]
+      )
+      if s > - data[None]["gamma"][(i + 1, f + 1)]:
+        score[j] = s
+        candidates.append(j)
+    candidates.sort()
+    # buyer-local view of advertised capacity, decremented as we bid, so we
+    # never request more from a seller than the buyer has observed locally
+    remaining = {j: blackboard[j, f] for j in candidates}
+    assigned = 0
+    while assigned < omega[i, f] and len(candidates) > 0:
+      sample_size = min(d, len(candidates))
+      sample = rng.choice(candidates, size=sample_size, replace=False)
+      if criterion == "capacity":
+        j_star = int(max(sample, key=lambda k: (remaining[int(k)], -int(k))))
+      else:
+        j_star = int(max(sample, key=lambda k: (score[int(k)], -int(k))))
+      if unit_bids:
+        q = 1
+      else:
+        q = VAR_TYPE(min(remaining[j_star], omega[i, f] - assigned))
+      if q <= 0:
+        # VAR_TYPE truncates to int: q hits 0 when either j_star is nearly full
+        # (drop it and try others) or the residual demand is below one integer
+        # unit (nothing more can be offloaded) -- without this the loop spins
+        # forever appending zero-quantity bids.
+        if remaining[j_star] < 1:
+          candidates.remove(j_star)
+          continue
+        break
+      bids["i"].append(i)
+      bids["f"].append(f)
+      bids["j"].append(j_star)
+      bids["d"].append(q)
+      bids["utility"].append(score[j_star])
+      assigned += q
+      remaining[j_star] -= q
+      if remaining[j_star] < 1:
+        candidates.remove(j_star)
+    if assigned < omega[i, f] or force_memory_bids:
+      for j in sorted(score, key=lambda k: (-score[k], k)):
+        if j in potential_memory_sellers:
+          memory_bids["i"].append(i)
+          memory_bids["j"].append(int(j))
+          memory_bids["f"].append(f)
+    if assigned < omega[i, f] or force_memory_bids:
+      for j in potential_memory_sellers - potential_capacity_sellers:
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(int(j))
+        memory_bids["f"].append(f)
+  return pd.DataFrame(bids), pd.DataFrame(memory_bids), len(potential_buyers)
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MAPoD",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  return parser.parse_known_args()[0]
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  powerd_options = dict(solver_options["powerd"])
+  powerd_options.setdefault("d", 2)
+  powerd_options.setdefault("criterion", "score")
+  powerd_options.setdefault("latency_weight", 0.0)
+  powerd_options.setdefault("fairness_weight", 0.0)
+  powerd_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+  rng = np.random.default_rng(seed)
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  patience = config["patience"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight="network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    spr = LSPr() if opt_solution is None else LSPr_fixedr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = -np.inf
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    n_accepted_queue = deque(maxlen=patience)
+    while not stop_searching:
+      s = datetime.now()
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      coordination_rho = (
+        sp_rho if opt_solution is None else np.zeros_like(sp_rho)
+      )
+      total_runtime += (datetime.now() - s).total_seconds()
+      s = datetime.now()
+      bids, memory_bids, n_auctions = sample_assignments(
+        omega, blackboard, sp_data, neighborhood, coordination_rho,
+        powerd_options, latency, fairness,
+        force_memory_bids=(
+          (coordination_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+        rng=rng,
+        current_y=y, tolerance=tolerance,
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_auctions) if n_auctions else rt
+      rmp_omega = y.sum(axis=1)
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        s = datetime.now()
+        diffusion_y, additional_replicas, n_sellers = evaluate_assignments(
+          bids, residual_capacity, sp_data, ell, sp_r, coordination_rho,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+          last_y=y,
+          diffusion_options=powerd_options,
+          latency=latency,
+          fairness=fairness,
+        )
+        rt = (datetime.now() - s).total_seconds()
+        total_runtime += (rt / n_sellers) if n_sellers else rt
+        y += diffusion_y
+        y[np.abs(y) < tolerance] = 0.0
+        rmp_omega = y.sum(axis=1)
+        fairness += (rmp_omega > tolerance)
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, bids, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MAPoD"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(config, args.parallelism, disable_plotting=args.disable_plotting)
diff --git a/docs/hierarchical_model_experiment_plan.md b/docs/hierarchical_model_experiment_plan.md
new file mode 100644
index 0000000..d2f0b99
--- /dev/null
+++ b/docs/hierarchical_model_experiment_plan.md
@@ -0,0 +1,497 @@
+# Experimental Plan for the Hierarchical DFaaS Optimization Model
+
+## 1. Study objective
+
+This study will evaluate the proposed hierarchical auction model against the
+centralized optimizer and the distributed optimization methods implemented in
+DFaaSOptimizer. The evaluation is organized by research question rather than by
+a single omnibus benchmark. Each experiment family isolates the factors needed
+to answer one question while keeping all other factors controlled. This design
+supports a full journal article with confirmatory comparisons, scalability
+analysis, robustness tests, and mechanism-oriented ablations.
+
+The central claim to test is that hierarchical coordination offers a favorable
+compromise between solution quality and computational scalability. The study
+must therefore demonstrate not only that the hierarchical model performs well,
+but also when hierarchy helps, which components produce the gain, and what costs
+are incurred in runtime, communication, latency, or fairness.
+
+## 2. Compared methods
+
+The following methods form the comparison set available in the repository.
+
+| Label | Repository method | Role in the study |
+|---|---|---|
+| Centralized | `centralized` | Exact or bounded reference for small and medium instances |
+| FaaS-MACrO | `faas-macro` | Primary decomposition-based comparator |
+| FaaS-MACrO-v0 | `faas-macro-v0` | Non-accelerated MACrO reference |
+| FaaS-MADeA | `faas-madea` | Distributed auction comparator |
+| Hierarchical MADeA | `hierarchical-madea` | Proposed method: production MADeA at level one plus higher-level coordination |
+| Hierarchical legacy | `hierarchical` | Historical softmax one-hop implementation, retained for diagnostic comparison only |
+| FaaS-MADiG | `faas-diffuse` | Diffusion-based comparator |
+| FaaS-MAPoD | `faas-powd` | Power-diffusion comparator |
+| FaaS-MABR-S | `faas-br-s` | Sequential best-response comparator |
+| FaaS-MABR-R | `faas-br-r` | Randomized best-response comparator |
+| FaaS-MABR-O | `faas-br-o` | Re-optimization best-response comparator |
+
+All methods will be run on the same generated instance for a given experimental
+cell and seed. The centralized method will be omitted from large cells where it
+cannot provide a useful solution or bound within the predefined time limit; the
+omission will be reported explicitly rather than interpreted as a hierarchical
+win.
+
+## 3. Research questions and hypotheses
+
+### RQ1 — Solution quality
+
+Does the hierarchical model achieve better social welfare and lower rejection
+than distributed alternatives on instances for which all methods can run?
+
+**H1.** The hierarchical model will reduce the welfare gap to the centralized
+reference relative to the distributed baselines, with the largest improvement
+on sparse graphs where local coordination alone has limited reach.
+
+### RQ2 — Quality–runtime trade-off
+
+How close does the hierarchical model come to the centralized solution, and
+what runtime and convergence cost does it pay?
+
+**H2.** The hierarchical model will retain most of the centralized welfare while
+requiring substantially less wall-clock time as network size increases.
+
+### RQ3 — Scalability
+
+How do runtime, iteration count, completion probability, and solution quality
+scale with the number of nodes and functions?
+
+**H3.** Hierarchical coordination will scale more favorably than centralized and
+global decomposition methods, while degrading more slowly in solution quality
+than purely local methods.
+
+### RQ4 — Network structure
+
+Under which topology, density, and connectivity conditions does hierarchical
+coordination provide a measurable advantage when topology families are compared
+at a common mean degree?
+
+**H4.** The advantage will be strongest in sparse, high-diameter topologies and
+will shrink as graph density makes direct coordination sufficient. This effect
+will remain detectable after controlling for mean degree and edge-latency
+distribution.
+
+### RQ5 — Robustness to operating conditions
+
+Is the hierarchical advantage preserved under load pressure, scarce memory,
+and heterogeneous nodes and functions?
+
+**H5.** Hierarchy will provide the largest reduction in rejected requests under
+resource scarcity and heterogeneous capacity, where coordination across local
+neighborhoods is most valuable.
+
+### RQ6 — Mechanism and parameter ablations
+
+Which hierarchy depths and pricing parameters are responsible for performance,
+and is the full hierarchy necessary?
+
+**H6.** Depth one will behave as a flat local auction, moderate depths will
+improve welfare, and excessive depth will yield diminishing returns and higher
+runtime. Congestion-aware price updates will outperform zero or fixed updates.
+
+### RQ7 — Latency and fairness trade-offs
+
+How does the hierarchical model trade social welfare against network latency
+and allocation fairness when these terms are activated?
+
+**H7.** Small positive latency and fairness weights will improve their respective
+outcomes with limited welfare loss, whereas large weights will expose a clear
+Pareto trade-off.
+
+### RQ8 — Spatial scaling and distance-dependent latency
+
+How does coupling network latency to Euclidean edge length affect performance as
+the number of nodes grows at constant spatial density?
+
+**H8.** Distance-dependent latency will favor allocations that use short local
+paths. Hierarchical coordination will retain its quality advantage while
+reducing latency-weighted traffic relative to methods that do not exploit the
+spatial structure.
+
+## 4. Common experimental protocol
+
+### 4.1 Experimental unit and pairing
+
+The experimental unit is one algorithm run on one generated DFaaS instance.
+The instance is identified by the complete factor tuple and an instance seed.
+All applicable methods receive the same topology, workload trace, resource
+capacities, costs, and seed. Confirmatory cells use 30 independent instance
+seeds. Pilot and tuning seeds must be disjoint from confirmatory seeds.
+
+The seed lists will be frozen before confirmatory execution. If an algorithm
+uses internal randomness beyond instance generation, its random seed will also
+be recorded. Repeated runs on the same instance will only be introduced if a
+pilot shows nondeterministic output.
+
+### 4.2 Default scenario
+
+Unless an experiment family states otherwise, the default scenario uses 50
+nodes, 4 functions, a connected Euclidean planar graph with target mean degree
+3, sinusoidal load, heterogeneous function demand, heterogeneous objective
+weights, hierarchy depth 3, and the auction parameters `eta = [0.5, 0.3, 0.15]`,
+`epsilon = 0.01`, and `zeta = 0.1`. Memory and utilization ranges will be
+calibrated in the pilot so that the base scenario produces neither zero
+rejection nor universal overload. The calibrated values will then be frozen for
+all confirmatory runs.
+
+### 4.3 Execution controls
+
+Every run will use the same solver version, solver options, Python environment,
+and code revision. Gurobi will use deterministic settings where applicable and
+a fixed thread count per job. Jobs will run on homogeneous VM types. The remote
+manifest will record host assignment and duration so host effects can be
+checked. Concurrent jobs must not oversubscribe physical cores or solver
+licenses.
+
+The default time limit is 600 seconds for confirmatory runs. A shorter limit may
+be used only after the pilot demonstrates that it does not censor relevant
+methods. Timeouts, infeasible terminations, missing outputs, and validation
+failures are outcomes and must remain in the analysis dataset.
+
+### 4.4 Tuning policy
+
+Hyperparameter tuning will use only dedicated pilot seeds. Each comparator may
+use the parameterization recommended by its implementation, but the search
+budget must be comparable across methods. The selected configuration and search
+space will be reported. Confirmatory results must not be used to retune any
+method.
+
+### 4.5 Spatial graph and latency protocol
+
+Euclidean planar instances will sample node coordinates at constant spatial
+density. For an instance with `Nn` nodes and density `rho`, coordinates will be
+sampled in a square with area `Nn / rho`, so the side length grows as
+`sqrt(Nn / rho)`. This convention prevents larger instances from becoming
+artificially crowded and keeps the characteristic distance between nearby nodes
+approximately stable as network size increases.
+
+The planar candidate graph will be the Delaunay triangulation of the sampled
+coordinates. A connected Euclidean backbone will be retained, and additional
+Delaunay edges will be sampled until the edge budget
+`m = round(Nn * mean_degree / 2)` is reached. This construction guarantees a
+straight-line planar embedding, connectedness, and the requested mean degree up
+to the unavoidable integer rounding. The supported target range is bounded
+below by the connected-graph requirement and above by the planar limit; the
+confirmatory study uses target mean degrees 3 and 5.
+
+Every Euclidean edge will store its geometric length separately from its network
+latency. Under the distance-dependent mode, latency will be generated as a
+fixed access delay plus a calibrated distance coefficient times edge length and
+a bounded random jitter term. Bandwidth remains a separate edge attribute. For
+multi-hop communication, end-to-end latency will be the weighted shortest-path
+sum rather than the adjacency-matrix value of a non-edge.
+
+Topology-only comparisons will use a common latency regime across topology
+families, because assigning distance-dependent latency only to the planar family
+would confound topology with edge cost. The spatial experiment instead compares
+distance-dependent latencies with a paired permutation control on the same
+Euclidean graph. The control preserves the multiset of edge latencies while
+breaking their association with edge length, thereby isolating the effect of
+spatially structured latency.
+
+## 5. Outcome measures
+
+### 5.1 Primary outcome
+
+The primary outcome is normalized social welfare. On cells where the
+centralized solver proves optimality, the main quality measure is the relative
+optimality gap
+
+\[
+g = \frac{W_{\mathrm{centralized}} - W_{\mathrm{method}}}
+         {\max(|W_{\mathrm{centralized}}|, \varepsilon)}.
+\]
+
+If the centralized run ends with a nonzero solver gap, comparisons will use its
+incumbent and bound separately. Such runs will not be described as comparisons
+against the exact optimum.
+
+### 5.2 Secondary outcomes
+
+Secondary outcomes are total rejected requests, rejection rate, locally
+processed requests, offloaded requests, wall-clock runtime, algorithm-reported
+runtime, iteration count, termination condition, completion rate, replica count,
+memory utilization, and CPU utilization. Network cost will be computed by
+weighting forwarded traffic by end-to-end shortest-path latency. Fairness will
+be measured with Jain's index over per-node served-load ratios. The analysis
+will also record the maximum and 95th-percentile node-level rejection rate to
+expose tail behavior.
+
+### 5.3 Required instrumentation
+
+Objective, rejection, runtime, termination, offloading, replica, and utilization
+outputs already exist in the current result format. Before RQ7, the analysis
+pipeline must add deterministic derivations for latency-weighted traffic and
+Jain fairness. Before making communication-efficiency claims, the hierarchical
+runner must record counts of bids, accepted allocations, hierarchy-level
+messages, and transferred tokens. Communication overhead is excluded from the
+primary claims until that instrumentation is validated. Before RQ8, generated
+instances must also persist node coordinates, edge lengths, direct-edge
+latencies, and the all-pairs shortest-path latency matrix used by the methods.
+
+## 6. Experiment families
+
+### E0 — Pilot, feasibility, and calibration
+
+This non-confirmatory experiment validates the full remote pipeline and selects
+resource ranges that avoid trivial workloads. It uses 10 pilot seeds, node counts
+10, 20, and 50, two functions, and the centralized, hierarchical, FaaS-MACrO,
+and FaaS-MADeA methods. The pilot checks output completeness, central feasibility,
+runtime distributions, timeout frequency, deterministic replay, and whether the
+base scenario produces meaningful offloading and rejection. It also calibrates
+the spatial density, fixed access delay, distance-to-latency coefficient, and
+jitter range before these values are frozen for confirmatory experiments.
+
+No E0 result will appear as confirmatory evidence. Its outputs may be reported
+as implementation validation in supplementary material.
+
+### E1 — Controlled quality comparison for RQ1 and RQ2
+
+| Factor | Values |
+|---|---|
+| Nodes | 10, 20, 30 |
+| Functions | 2, 4 |
+| Topology | Connected Euclidean planar, target mean degree 3 |
+| Load | Medium sinusoidal |
+| Methods | All ten methods |
+| Seeds | 30 confirmatory seeds |
+
+E1 contains 1,800 runs. It is the primary comparison because all methods,
+including the centralized reference, are expected to remain usable. The main
+analysis compares paired welfare gaps and rejection rates. Runtime is analyzed
+jointly with quality to determine whether improvements are obtained at an
+acceptable computational cost.
+
+### E2 — Scalability for RQ3
+
+| Factor | Values |
+|---|---|
+| Nodes | 10, 20, 50, 100, 200 |
+| Functions | 2, 4, 8 |
+| Topology | Random regular, degree 3 |
+| Methods | All non-centralized methods; centralized only for 10 and 20 nodes |
+| Seeds | 30 confirmatory seeds |
+
+E2 contains 4,050 non-centralized runs and 180 centralized runs. Primary outcomes
+are wall-clock runtime, completion probability, and welfare normalized by the
+best feasible result available for the same instance. Scaling curves will be
+reported against both node count and the approximate problem size `Nn × Nf`.
+Timeouts will not be discarded.
+
+### E3 — Density-controlled topology and connectivity for RQ4
+
+| Factor | Values |
+|---|---|
+| Nodes and functions | 50 nodes, 4 functions |
+| Euclidean planar topology | Delaunay-derived connected graph, target mean degree 3 or 5 |
+| Regular topology | Random regular degree 3 or 5 |
+| Random topology | Connected Erdős–Rényi `G(n,m)`, target mean degree 3 or 5 |
+| Methods | Hierarchical, FaaS-MACrO, FaaS-MADeA, FaaS-MADiG, FaaS-MAPoD, best MABR variant from E1 |
+| Seeds | 30 confirmatory seeds |
+
+E3 contains 1,080 runs. All topology families use the same edge budget, or its
+closest feasible equivalent, at each target mean degree. Disconnected random
+graphs will be regenerated using the same deterministic seed sequence, because
+connectivity must not be confounded with topology family. Direct-edge latency
+distributions will be matched across families and will not depend on Euclidean
+length in E3. The analysis will relate method performance to realized mean
+degree, diameter, clustering coefficient, and average shortest-path length, not
+only to the generator parameters.
+
+### E4 — Resource and workload robustness for RQ5
+
+E4 varies one operating condition at a time around the frozen default scenario.
+The seven unique conditions are baseline, low load, high load, scarce memory,
+ample memory, homogeneous nodes, and strongly heterogeneous nodes. It uses 50
+nodes, 4 functions, the default Euclidean planar topology, 30 seeds, and the same
+six representative methods used in E3, for 1,260 runs.
+
+Load levels will be calibrated by offered load relative to aggregate nominal
+capacity rather than by arbitrary request counts. Memory conditions will be
+defined by the fraction of function replicas that can be placed. Heterogeneity
+will be controlled through predeclared capacity and demand distributions. The
+primary robustness result is the method-by-condition interaction for welfare and
+rejection rate.
+
+### E5 — Dynamic workload behavior for RQ5
+
+| Factor | Values |
+|---|---|
+| Trace | Sinusoidal, clipped sinusoidal, fixed-sum min/max |
+| Timesteps | 100 |
+| Nodes and functions | 50 nodes, 4 functions |
+| Methods | Same six representative methods as E3 |
+| Seeds | 30 confirmatory seeds |
+
+E5 contains 540 runs, each evaluated across 100 timesteps. Analysis will report
+time-averaged outcomes, worst-window rejection, adaptation lag after load changes,
+and temporal variance. Timesteps are repeated observations within an instance
+and will not be treated as independent samples.
+
+### E6 — Hierarchical ablation and sensitivity for RQ6
+
+E6 evaluates the proposed method only. The base configuration is compared with
+hierarchy depths 1, 2, 4, and 5; zero congestion update (`eta = 0`); fixed updates
+`eta = 0.1` and `eta = 0.5`; and alternative `epsilon` values `0.001` and `0.1`.
+Together with the base configuration, this gives 10 variants. Variants are run
+at 20 and 50 nodes on Euclidean planar graphs with target mean degree 3 and on
+random-regular degree-3 graphs using 30 seeds, for 1,200 runs.
+
+Depth one is the operational flat-auction ablation. The analysis will estimate
+the marginal benefit of each additional hierarchy level and identify the
+smallest depth whose welfare is practically equivalent to the best depth. A
+parameter setting will not replace the base confirmatory configuration unless
+the decision rule was specified before E1–E5 are inspected.
+
+### E7 — Latency and fairness trade-offs for RQ7
+
+E7 uses the supported `(latency_weight, fairness_weight)` pairs `(0,0)`,
+`(0.25,0)`, `(1,0)`, `(0,0.25)`, `(0,1)`, `(0.25,0.25)`, and `(1,1)`. The
+hierarchical model and the three strongest compatible distributed comparators
+identified in E1 are tested on Euclidean planar and random-regular graphs with
+target mean degree 3, 50 nodes, 4 functions, and 30 seeds. E7 uses the common
+topology-only latency regime so that the weight sweep is not confounded with a
+change in the latency generator. This produces 1,680 runs.
+
+Results will be presented as Pareto fronts over welfare, latency-weighted
+traffic, and fairness. A weighted objective value alone is insufficient because
+it hides the magnitude of each constituent outcome.
+
+### E8 — Spatial scaling and latency coupling for RQ8
+
+E8 uses Euclidean planar graphs with target mean degree 3 at 20, 50, and 100
+nodes. Spatial density, function count, workload intensity per node, and all
+non-network parameters remain constant. Each generated topology is evaluated
+under two paired latency assignments: distance-dependent latency and a
+permutation of the same edge-latency values across the same edges. The
+hierarchical method and the three strongest latency-compatible distributed
+comparators identified in E1 use the predeclared latency weight 0.25 and are run
+on 30 confirmatory seeds, producing 720 runs.
+
+The primary contrast is the method-by-latency-assignment interaction for
+normalized welfare, rejection, and latency-weighted traffic. Scaling trends are
+estimated against node count while realized node density, edge-length
+distribution, mean degree, graph diameter, and shortest-path latency are
+reported as manipulation checks. Because the topology and latency multiset are
+paired within each seed, differences can be attributed to the spatial coupling
+between physical edge length and network latency rather than to graph density or
+overall latency magnitude.
+
+## 7. Statistical analysis plan
+
+All main comparisons are paired by instance seed. For each primary contrast,
+the analysis will report the paired median difference, paired bootstrap 95%
+confidence interval, and a paired effect size. Method rankings will be secondary
+to effect estimates.
+
+For factorial experiment families, a mixed-effects model will include method,
+the manipulated factor, and their interaction as fixed effects, with instance
+seed as a random intercept. Runtime will be log-transformed when residual
+diagnostics support that model. Rejection proportions will use a model suitable
+for bounded outcomes or a bootstrap analysis if model assumptions are not met.
+
+Pairwise post-hoc comparisons will use Holm correction within each research
+question. The study will use a two-sided family-wise significance level of 0.05,
+but scientific conclusions will prioritize confidence intervals and practical
+effect sizes. A practical-equivalence margin of 1% normalized welfare will be
+used when claiming that two methods have comparable solution quality.
+
+Timeout and failure rates will be analyzed explicitly. Runtime summaries will
+include completion-conditioned runtime and restricted mean runtime under the
+common time limit. Assigning the time limit as if it were an observed runtime
+will be used only for clearly labeled sensitivity analysis.
+
+## 8. Planned tables and figures
+
+The main article should contain a study-design diagram mapping each RQ to its
+experiment family, a paired quality–runtime plot for E1, scalability curves for
+E2, topology interaction plots for E3, robustness effect plots for E4–E5, an
+ablation plot for E6, a Pareto plot for E7, and a spatial scaling interaction
+plot for E8. Tables should report experimental factors, completion rates, effect
+estimates with confidence intervals, and the final hyperparameters. Full
+per-cell summaries and termination conditions belong in supplementary material.
+
+No plot will aggregate across incompatible instance sizes without normalization
+or stratification. Error bars will represent confidence intervals across
+independent instances, not variability across timesteps treated as independent.
+
+## 9. Reproducibility and data management
+
+Each batch definition must be immutable and serialized before execution. All
+problem instances will then be materialized once under the structured
+`remote_experiments/instances/<suite>/` store before any algorithm is run. A
+materialized instance includes the base optimization data, load limits, complete
+temporal request traces, and the exact graph with node coordinates, edge
+lengths, and latencies where applicable. Algorithms compared on the same cell
+must reference the same instance identifier rather than regenerate inputs.
+
+Each instance records a generation seed and SHA-256 checksums for all payload
+files. Checksum validation is performed before dispatch and again when the
+runner loads the transferred data. Stochastic algorithm seeds remain experiment
+parameters and are not part of the instance payload. Every result will be linked
+to the Git commit, configuration file, batch file, instance identifier, suite
+manifest, method, algorithm seed, VM host, solver version, Python environment,
+start time, termination condition, and output directory. The existing
+`remote_experiments` workflow will be used for submission and resume.
+
+Raw outputs remain read-only after collection. Postprocessing creates a tidy
+dataset with one row per method–instance–timestep observation and a separate
+instance table containing topology and workload descriptors. Analysis scripts
+will consume only these versioned tables. Euclidean instances will additionally
+record the spatial density, bounding area, node coordinates, edge lengths,
+latency-generation mode, direct-edge latency summary, and shortest-path latency
+summary. Exclusions and reruns require a reason code; failed runs must never be
+silently replaced.
+
+The confirmatory seed list, hypotheses, primary outcomes, practical-equivalence
+margin, timeout policy, and statistical contrasts will be frozen in a protocol
+file before confirmatory execution. Pilot, tuning, and confirmatory artifacts
+will be stored separately.
+
+## 10. Execution order and decision gates
+
+Execution proceeds in the order E0, E1, E2, E3, E4–E5, E6, E7, and E8. E0 must
+show complete artifacts and centrally feasible outputs before E1 starts. E1
+selects the representative MABR method and the three compatible comparators used
+in later families. E2 determines whether the 200-node cells are feasible within
+the compute budget. E3–E5 establish external validity, E6 and E7 explain the
+mechanism and trade-offs, and E8 tests whether the conclusions survive a
+physically grounded spatial latency model.
+
+If more than 10% of runs in a confirmatory cell fail for infrastructure reasons,
+the entire cell will be rerun after the infrastructure issue is fixed. Algorithmic
+timeouts and infeasibility are retained as results. Any protocol change after E1
+begins must be versioned and described as exploratory.
+
+The planned confirmatory workload is approximately 12,510 runs. After E0, the
+observed runtime distribution will be used to estimate VM-hours and schedule the
+families, but not to remove scientifically necessary cells. If resources are
+insufficient, E7 becomes supplementary first, followed by reducing E8 to 20 and
+100 nodes while preserving its paired design. The primary E1–E3 comparisons and
+E6 ablation remain mandatory for the central claim.
+
+## 11. Criteria for supporting the paper's claim
+
+The evidence will support the proposed model if the hierarchical method shows a
+practically meaningful paired welfare or rejection improvement over the strongest
+distributed comparator in E1, maintains a favorable quality–runtime trade-off in
+E2, and does not lose that advantage across most topology and robustness
+conditions in E3–E5. E6 must show that genuine multi-level coordination, rather
+than an incidental parameter choice, explains the improvement. Claims about
+communication efficiency, latency, or fairness require the corresponding
+instrumentation and E7 evidence.
+
+Failure to outperform every baseline in every cell will not invalidate the
+study. Evidence for spatial robustness additionally requires a favorable or
+neutral method-by-latency-assignment interaction in E8; E7 alone cannot support
+claims about physically grounded latency. The paper must report the conditions
+where hierarchy is neutral or inferior, because identifying its operating
+envelope is part of the scientific contribution.
diff --git a/docs/plans/2026-07-02-hierarchical-madea-design.md b/docs/plans/2026-07-02-hierarchical-madea-design.md
new file mode 100644
index 0000000..faeeeb3
--- /dev/null
+++ b/docs/plans/2026-07-02-hierarchical-madea-design.md
@@ -0,0 +1,55 @@
+# Hierarchical MADeA Design
+
+## Objective
+
+Add a new hierarchical algorithm whose level-one behavior is the production
+FaaS-MADeA auction in `run_faasmadea.py`. The existing `hierarchical` method is
+retained unchanged as a legacy implementation. The new method is exposed as
+`hierarchical-madea` and writes the result label `HierarchicalMADeA`.
+
+The implementation may import existing functions but must not modify the
+FaaS-MADeA functions or the existing hierarchical runner. This preserves both
+baselines and makes the scientific comparison explicit.
+
+## Architecture
+
+Create `hierarchical_auction/madea_runner.py`. Its initialization, temporal
+loop, persistence, and centralized solution construction follow the current
+hierarchical runner. Its level-one iteration follows `run_faasmadea.run`:
+
+1. compute residual capacity;
+2. call MADeA `define_bids`, including stagnation-driven memory bids;
+3. call MADeA `evaluate_bids`, including replacement and tentative replicas;
+4. update cumulative offloading, replicas, fairness, and residual demand;
+5. validate fixed offloading and solve LSPr.
+
+After level one, recompute residual capacity from the updated state and call
+`HierarchicalAuctionEngine.run_higher_levels`. Accepted higher-level allocations
+are mapped into the same cumulative `y` matrix. If they change `y`, validate it
+and solve LSPr again. Termination uses MADeA's stopping function with keyword
+arguments and treats accepted hierarchical allocations as progress.
+
+No imported MADeA or legacy hierarchical function is edited. Small new helpers
+in the new runner may normalize the level-one `eta`, compute offloaded demand,
+and preserve the loop when higher levels make progress.
+
+## Integration
+
+Register `hierarchical-madea` in `run.py`, remote job construction, and result
+metadata. The module command is:
+
+```bash
+python -m hierarchical_auction.madea_runner -c config.json -j 0
+```
+
+Paper suite defaults use `hierarchical-madea` as the proposed model. Explicit
+requests for the legacy `hierarchical` algorithm continue to work. The smoke
+suite contains both so wiring regressions remain visible.
+
+## Validation
+
+Tests verify that the new runner imports the production MADeA helpers, passes
+the correct signatures and options, invokes higher levels only after level one,
+is accepted by local and remote dispatch, and is selected by paper defaults.
+A Gurobi-backed planar smoke test verifies complete artifacts and centralized
+feasibility. The full test suite protects all existing algorithms.
diff --git a/docs/plans/2026-07-02-hierarchical-madea.md b/docs/plans/2026-07-02-hierarchical-madea.md
new file mode 100644
index 0000000..bf033cd
--- /dev/null
+++ b/docs/plans/2026-07-02-hierarchical-madea.md
@@ -0,0 +1,65 @@
+# Hierarchical MADeA Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add a separately runnable hierarchical method that extends the production FaaS-MADeA level-one auction without modifying existing algorithm functions.
+
+**Architecture:** A new runner reuses public MADeA helpers for level one and invokes the existing hierarchy engine for residual demand. Existing `hierarchical` remains unchanged; dispatch and paper suites use the explicit `hierarchical-madea` identifier.
+
+**Tech Stack:** Python 3.10, NumPy, pandas, existing Pyomo/Gurobi runners, pytest, GitNexus.
+
+---
+
+### Task 1: New runner contract
+
+**Files:**
+- Create: `hierarchical_auction/madea_runner.py`
+- Create: `tests/test_hierarchical_madea_runner.py`
+
+1. Write failing tests for option normalization, MADeA helper provenance, offloaded-demand calculation, hierarchical progress, and CLI parsing.
+2. Run the focused tests and confirm the module is absent.
+3. Implement the helpers and CLI shell with imports from `run_faasmadea`.
+4. Run the focused tests.
+
+### Task 2: MADeA level one plus higher levels
+
+**Files:**
+- Modify: `hierarchical_auction/madea_runner.py`
+- Modify: `tests/test_hierarchical_madea_runner.py`
+- Modify: `tests/test_e2e_gurobi_planar.py`
+
+1. Write failing wiring tests that constrain calls to MADeA `define_bids`, `evaluate_bids`, fixed-y validation, LSPr, hierarchy engine, and stopping criteria.
+2. Implement the minimal combined iteration and persistence loop.
+3. Run focused wiring and Gurobi planar tests.
+
+### Task 3: Local and remote registration
+
+**Files:**
+- Modify: `run.py`
+- Modify: `remote_experiments/jobs.py`
+- Modify: `tests/test_hierarchical_madea_runner.py`
+- Modify: `tests/test_remote_experiments_jobs.py`
+
+1. Write failing parser, dispatch, command, and result-label tests.
+2. Register `hierarchical-madea` without altering legacy `hierarchical` behavior.
+3. Run focused tests.
+
+### Task 4: Paper suite migration
+
+**Files:**
+- Modify: `remote_experiments/definitions/paper.py`
+- Modify: `remote_experiments/definitions/smoke.py`
+- Modify: `tests/test_paper_experiment_suites.py`
+- Modify: `tests/test_remote_experiments_smoke_suite.py`
+
+1. Write failing tests that paper defaults select `hierarchical-madea` and smoke exposes both variants.
+2. Update method sets and algorithm-to-option mappings.
+3. Run paper, smoke, materialization, and job tests.
+
+### Task 5: Verification
+
+1. Run focused hierarchical and remote-experiment tests.
+2. Run Ruff on all changed Python files.
+3. Run the complete test suite.
+4. Run `git diff --check`.
+5. Run GitNexus change detection and review every affected flow.
diff --git a/docs/plans/2026-07-02-materialized-paper-instances-design.md b/docs/plans/2026-07-02-materialized-paper-instances-design.md
new file mode 100644
index 0000000..6b35e08
--- /dev/null
+++ b/docs/plans/2026-07-02-materialized-paper-instances-design.md
@@ -0,0 +1,84 @@
+# Materialized Paper Instances Design
+
+## Goal and constraints
+
+The paper experiments must generate each problem instance once and execute every
+algorithm against exactly the same immutable input. An instance includes the
+base optimization data, graph topology and edge attributes, load limits, and the
+complete temporal request trace. Algorithm settings, including stochastic
+algorithm seeds, remain in the experiment configuration and are not stored as
+instance data. Generated instance payloads are local artifacts under
+`remote_experiments/instances/`; they are not committed by default.
+
+An instance still needs a generation seed because random topology, capacities,
+weights, and traces must be reproducible. This value is recorded explicitly as
+`generation_seed` in metadata and is distinct in meaning from the runtime
+algorithm seed. The current paper matrices may use the same integer for both;
+the storage and execution paths nevertheless keep the two roles separate.
+
+## Architecture and layout
+
+The existing `Experiment` schema remains unchanged. A canonical generation
+specification is derived from the fields that affect the materialized input:
+`limits`, time horizon, trace timing, and generation seed. A short SHA-256 digest
+of that canonical JSON becomes the stable instance identifier. Consequently,
+all algorithms in the same experimental cell resolve to the same instance,
+without duplicating data or adding another registry abstraction.
+
+Each suite is written as:
+
+```text
+remote_experiments/instances/<suite>/
+  README.md
+  manifest.json
+  data/<instance-id>/
+    base_instance_data.json
+    load_limits.json
+    input_requests_traces.json
+    graph.json
+    metadata.json
+```
+
+`graph.json` uses NetworkX node-link JSON so Euclidean coordinates, edge
+lengths, and network latencies survive materialization. `metadata.json` records
+the schema version, instance identifier, suite, generation specification, and a
+SHA-256 checksum for every payload file. The suite manifest maps experiments to
+instances and summarizes the materialized set. The generated README describes
+the format and counts for that suite.
+
+## Data flow and validation
+
+The CLI gains a `materialize` command that loads an existing batch, derives and
+deduplicates its instance specifications, generates each missing instance, and
+writes the suite documentation and manifest. Existing valid instances are
+reused. Missing files, malformed metadata, or checksum mismatches are hard
+errors; there is no automatic repair, database, or content-addressed object
+store.
+
+At execution time, `remote_experiments run` resolves each experiment's instance
+from the same canonical specification. The job receives the five instance
+files plus its algorithm configuration. Only the job's copy of the
+configuration is changed: `limits` points to the transferred `instance/`
+directory and selects the materialized loading mode. The original batch remains
+unchanged.
+
+All algorithm runners already call the shared `run_centralized_model.init_problem`.
+That function therefore receives one additive branch: materialized mode verifies
+checksums, loads the three optimization/load JSON files and exact graph, copies
+the inputs into the solution folder for provenance, and returns the same tuple
+as the existing generator path. Random and legacy `load_existing` behavior stay
+unchanged.
+
+## Error handling and tests
+
+Materialization rejects inconsistent data for an existing identifier and never
+silently overwrites corrupt artifacts. Job creation fails before dispatch when
+an instance is absent or invalid. Remote loading validates again, protecting
+against transfer corruption. Error messages identify the instance, file, and
+expected versus actual checksum.
+
+Tests cover deterministic deduplication across algorithms, complete file
+creation, temporal trace inclusion, checksum rejection, exact graph round-trip,
+job input transfer, CLI parsing, and the materialized branch of `init_problem`.
+The existing generator path and all remote-experiment tests remain regression
+coverage. No solver is required for the focused tests.
diff --git a/docs/plans/2026-07-02-materialized-paper-instances.md b/docs/plans/2026-07-02-materialized-paper-instances.md
new file mode 100644
index 0000000..eadbb0c
--- /dev/null
+++ b/docs/plans/2026-07-02-materialized-paper-instances.md
@@ -0,0 +1,77 @@
+# Materialized Paper Instances Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Materialize complete paper instances once, verify them with SHA-256 checksums, and make every remote runner consume the exact stored inputs.
+
+**Architecture:** Add one small instance module that derives a canonical generation specification, writes/loads the five-file instance format, and materializes a batch with deduplication. Extend the existing CLI and job mapping, then add an additive materialized branch to the shared `init_problem` function so all algorithms benefit without runner-specific changes.
+
+**Tech Stack:** Python 3.10 standard library (`hashlib`, `json`, `pathlib`), NumPy, NetworkX, existing generators, pytest, ray-dispatcher input specifications.
+
+---
+
+### Task 1: Instance format, identity, and checksums
+
+**Files:**
+- Create: `remote_experiments/instances.py`
+- Create: `tests/test_remote_experiments_instances.py`
+
+1. Write failing tests for canonical identity shared across algorithms, different identity when generation inputs differ, complete materialization, graph/load round-trip, and checksum failure.
+2. Run `uv run pytest -q tests/test_remote_experiments_instances.py` and confirm failure because the module is absent.
+3. Implement the minimal generation-spec, SHA-256, materialize, validate, and load functions using existing generators and JSON helpers.
+4. Run the focused tests and confirm they pass.
+
+### Task 2: Batch materialization CLI
+
+**Files:**
+- Modify: `remote_experiments/cli.py`
+- Modify: `tests/test_remote_experiments_cli.py`
+
+1. Write failing tests for `materialize <batch> [-o root]` parsing and suite output creation.
+2. Run the focused tests and confirm the missing-command failure.
+3. Add `cmd_materialize` and the parser entry; default output is `remote_experiments/instances`.
+4. Run the CLI and instance tests.
+
+### Task 3: Transfer materialized inputs to remote jobs
+
+**Files:**
+- Modify: `remote_experiments/jobs.py`
+- Modify: `remote_experiments/cli.py`
+- Modify: `tests/test_remote_experiments_jobs.py`
+- Modify: `tests/test_remote_experiments_cli.py`
+
+1. Write failing tests requiring the job configuration to select materialized mode and requiring all five files as job inputs.
+2. Run the focused tests and confirm the old config-only behavior fails.
+3. Extend `experiment_to_job` with an instance root, validate the instance, copy the configuration before changing `limits`, and pass the root from `cmd_run` through a new `--instances` option.
+4. Run the focused tests.
+
+### Task 4: Shared runner loading path
+
+**Files:**
+- Modify: `run_centralized_model.py`
+- Modify: `tests/test_run_helpers.py`
+
+1. Write a failing test that materializes a small instance, calls `init_problem` in materialized mode, and compares base data, temporal traces, agents, and graph edge attributes.
+2. Run the test and confirm failure because materialized mode is unsupported.
+3. Add the materialized branch at the start of `init_problem`; validate/load and copy provenance files to the solution directory. Leave the existing generation branch unchanged.
+4. Run the focused test plus existing runner-helper tests.
+
+### Task 5: Documentation and data hygiene
+
+**Files:**
+- Modify: `remote_experiments/README.md`
+- Modify: `docs/hierarchical_model_experiment_plan.md`
+- Modify: `.gitignore`
+
+1. Document define → materialize → run, the distinction between generation and algorithm seeds, temporal loads as instance data, checksums, layout, and ZIP archival.
+2. Ignore `remote_experiments/instances/*/data/` while retaining the generated suite README and manifest as optional reviewable artifacts.
+3. Do not generate or commit the full paper datasets during implementation.
+
+### Task 6: Verification
+
+1. Run `uv run pytest -q tests/test_remote_experiments_instances.py tests/test_remote_experiments_jobs.py tests/test_remote_experiments_cli.py tests/test_run_helpers.py`.
+2. Run the complete test suite with `MPLCONFIGDIR=/tmp/matplotlib uv run pytest -q`.
+3. Run Ruff on all changed Python files.
+4. Run `git diff --check`.
+5. Run GitNexus change detection (or the CLI graph diff equivalent available in this environment) and verify only the expected generation, job dispatch, CLI, and shared initialization flows are affected.
+6. Leave all changes uncommitted.
diff --git a/docs/plans/2026-07-04-plasma-design.md b/docs/plans/2026-07-04-plasma-design.md
new file mode 100644
index 0000000..8ddd36c
--- /dev/null
+++ b/docs/plans/2026-07-04-plasma-design.md
@@ -0,0 +1,254 @@
+# PLASMA Design (repo-aligned)
+
+**Supersedes:** `/Users/micheleciavotta/Downloads/PLASMA_SPEC.md` (standalone draft).
+**Status:** design specification, ready for implementation.
+**Relation to existing work:** PLASMA is a new fully-decentralized method for the
+same FRALB/DiFRALB problem solved by `run_centralized_model.py` (LMM),
+`run_faasmacro.py` (FaaS-MACrO) and `run_faasmadea.py` (FaaS-MADeA), evaluated
+side by side with them exactly like `decentralized_gcaa.py`,
+`decentralized_bestresponse.py`, `decentralized_diffusion.py`,
+`decentralized_dual.py`, `decentralized_potentialgame.py`,
+`decentralized_powerd.py` and `hierarchical_auction/` already are.
+
+The algorithmic content (Physarum routing Layer A, discrete Simulated
+Bifurcation Layer B, Hamiltonian, protocol, acceptance criteria) is unchanged
+from the original spec, §§2–5 and §9–10 there. This document fixes the
+conflicts identified against this repo's conventions and rules:
+
+1. Python version pin.
+2. New dependencies where the repo already has an equivalent tool.
+3. Package/CLI/test layout inconsistent with existing conventions.
+4. The asynchronous variant (PLASMA-A) is **removed entirely**. PLASMA ships
+   only the synchronous, round-barrier execution described as PLASMA-S in the
+   original spec's §4.4. There is a single execution mode; `execution.mode`
+   as a config axis does not exist.
+
+## 1. Constraints resolved
+
+### 1.1 Python version
+
+`pyproject.toml` pins `requires-python = ">=3.10,<3.11"`. That file is not to
+be modified for this feature. PLASMA targets **Python 3.10**: no
+`match` on complex patterns beyond what 3.10 supports, no 3.11-only stdlib
+(`tomllib`, `ExceptionGroup`). Use `from __future__ import annotations` where
+helpful. Drop the original spec's "Python 3.11+" line.
+
+### 1.2 Reuse existing tools, do not modify them; new functions are fine
+
+Per the pattern already used by `hierarchical_auction/madea_runner.py` ("the
+implementation may import existing functions but must not modify the
+FaaS-MADeA functions or the existing hierarchical runner"), PLASMA:
+
+- **Must not edit** any existing file (`models/*`, `run_centralized_model.py`,
+  `run_faasmacro.py`, `run_faasmadea.py`, `heuristic_coordinator.py`,
+  `generators/*`, `postprocessing.py`, `logs_postprocessing.py`,
+  `compare_results.py`, `run.py` internals other than the additive
+  registration described in §3).
+- **May freely import and call** existing functions/classes from those
+  modules.
+- **May add new functions/modules** wherever the existing surface doesn't
+  cover what PLASMA needs (the SB integrator, the Hamiltonian, the heartbeat
+  protocol, the routing dynamics have no existing analogue and are written
+  from scratch as originally specified).
+
+Concretely, replace the three new-dependency baselines from the original
+spec with thin wrappers over what already exists:
+
+| Original spec (`plasma/baselines/*`) | New dependency | Replacement (reuse, no new dependency) |
+|---|---|---|
+| `milp.py` via PuLP/CBC | `pulp` | New module `plasma/baselines/milp_baseline.py` that imports `init_problem` from `run_centralized_model.py`, `update_data` from `generators/generate_data.py`, `get_current_load` from `utils/centralized.py`, and the Pyomo model in `models/sp.py`/`models/model.py`, re-solved every `K` s on observed rates. Same Gurobi/GLPK solver path as every other baseline in the repo. |
+| `greedy.py` | — | New module `plasma/baselines/greedy_baseline.py` that instantiates `heuristic_coordinator.GreedyCoordinator` (already implements a local, non-coordinated greedy allocator) instead of writing a new greedy solver. |
+| `sim/traffic.py`, `sim/scenarios.py` | — | Reuse `generators/generate_data.py`, `generators/load_generator.py`, `generators/generate_load.py` for integer arrival traces (existing `clipped`/`sinusoidal` trace types) and for topology generation (`generate_neighborhood` already supports ER via `p`, G(n,m) via `m`, k-regular via `k`, and Euclidean planar — same `neighborhood` config as every other method). Barabási–Albert is **not** supported and is not added: milestones use G(n,m) or k-regular instead. Anything genuinely missing (pure Poisson traces, MMPP bursts) is written as new generator functions in `plasma/sim/` — never by editing `generators/*`. |
+| `sim/network.py` via `simpy` | `simpy` | New module `plasma/sim/clock.py`: a `heapq`-based discrete-event scheduler (stdlib `heapq` + `dataclasses`) driving a single shared round barrier (period `W`; SB pass every `k_sb` rounds) and delivering heartbeat/data-plane messages with configurable latency/loss. `simpy`'s extra features (resources, processes-as-generators, per-node independent clocks) are not needed — there is one global clock. |
+| `cli.py` via Typer | `typer` | No new CLI framework. PLASMA is invoked the same way as every other method: through `run.py --methods ...` (see §3) plus, for direct debugging, a small `argparse` entry point in `plasma/cli.py`, matching `run_centralized_model.py`/`run_faasmacro.py`. |
+
+Net new third-party dependency: **none**. Everything PLASMA needs (numpy,
+networkx, pandas, pyyaml) is already in `pyproject.toml`.
+
+### 1.3 Package layout and tests
+
+Keep `plasma/` as its own subpackage — `hierarchical_auction/` already
+establishes that a self-contained algorithm package is an accepted shape in
+this repo, so this is not a new convention, just a second instance of one.
+Layout, trimmed to what §1.2 didn't already reuse:
+
+```
+plasma/
+  core/
+    types.py          # NodeId, FnId, frozen dataclasses for config & messages
+    node.py            # PlasmaNode: owns Layer A + Layer B state; step(dt) API
+    routing.py          # Layer A: sampling, gates, conductance updates
+    sbm.py              # Layer B: encoding, local Hamiltonian, dSB integrator, hysteresis, repair
+    protocol.py         # heartbeat encode/decode, staleness handling
+  sim/
+    clock.py            # heapq-based discrete-event scheduler, single shared round barrier (period = W)
+  baselines/
+    milp_baseline.py     # wraps run_centralized_model.init_problem + models/sp.py
+    greedy_baseline.py    # wraps heuristic_coordinator.GreedyCoordinator
+    madea_iface.py        # adapter so run_faasmadea can be plugged in for comparison
+  eval/
+    regret.py            # dynamic/static oracle regret, adaptation lag (genuinely new metrics)
+  cli.py                 # argparse entry point for standalone debugging runs
+```
+
+Drop the original spec's `sim/traffic.py`, `sim/scenarios.py`, `sim/network.py`
+and `eval/metrics.py`/`eval/plots.py` as separate modules: traces/topologies
+come from `generators/`, headline metrics/plots come from
+`postprocessing.py`/`logs_postprocessing.py`/`compare_results.py` (extended,
+not forked — see §3). `eval/regret.py` holds only the metrics that don't
+exist anywhere in the repo yet (cumulative regret vs. dynamic/static oracle,
+adaptation lag).
+
+Tests move out of the package and into the existing flat `tests/` directory,
+one file per concern, matching the `test_<module>_<aspect>.py` convention
+used everywhere else (`test_gcaa_helpers.py`, `test_gcaa_e2e.py`,
+`test_gcaa_wiring.py`, ...):
+
+```
+tests/test_plasma_routing.py       # Layer A: gates, conductance updates, LP convergence
+tests/test_plasma_sbm.py           # Layer B: dSB vs brute force, hysteresis, RAM repair
+tests/test_plasma_protocol.py      # heartbeat, staleness, locality invariant
+tests/test_plasma_clock.py         # round barrier scheduling, phase-locked-commit scenario
+tests/test_plasma_baselines.py     # milp_baseline/greedy_baseline wiring, madea_iface
+tests/test_plasma_e2e.py           # full pipeline vs MILP on a small graph
+```
+
+## 2. Only the synchronous variant exists
+
+The original spec's §4.4 described two execution modes, PLASMA-A (async,
+independent jittered per-node clocks, no barrier) and PLASMA-S (sync, shared
+round barrier, period `W`). **PLASMA-A is dropped entirely.** Every other
+decentralized method already in this repo (FaaS-MACrO, FaaS-MADeA, GCAA,
+best-response, diffusion, dual, potential-game, power-d, hierarchical) runs
+on synchronized rounds, so the sync formulation is the one directly
+comparable to all of them on the repo's own terms; the async variant added
+implementation surface (independent clocks, re-jittered ticks, phase-lock as
+an "accidental" pathology) without a comparable baseline to evaluate it
+against.
+
+Consequences for the rest of this design:
+
+- `plasma/sim/clock.py` implements **only** the shared round barrier (period
+  `W`; SB pass every `k_sb` rounds, default 10). There is no per-node clock,
+  no tick jitter, no `execution.mode` config key.
+- The "Jacobi-oscillation countermeasure" (randomized commit with probability
+  `p_commit`, default 0.5) from §4.4 is mandatory, not mode-gated — under a
+  shared barrier, simultaneous neighbor commits are always the norm, so this
+  is simply how Layer B commits, unconditionally. Hysteresis (§4.3 of the
+  original spec) stays exactly as specified.
+- `test_phase_locked_commit` becomes: with `p_commit = 1` (deliberately
+  disabling the randomized-commit countermeasure) the adversarial scenario
+  must exhibit replica thrashing; with default `p_commit = 0.5` plus
+  hysteresis, the same scenario must settle within 20 slow ticks. There is no
+  "jitter off" variant to test since there is no jitter.
+- Every acceptance criterion in the test plan (§8 of the original spec:
+  `test_dead_neighbor`, `test_oscillation_hysteresis`,
+  `test_phase_locked_commit`, LP-convergence, dSB-vs-brute-force) is evaluated
+  once, under the single execution model.
+- Every cross-method comparison in M5/M6 (§4 below) reports a single PLASMA
+  row/curve against MILP/greedy/FaaS-MADeA, at matched message budget (tune
+  `W` vs. each baseline's own round period, per §6.1 of the original spec).
+
+## 3. Integration with `run.py` and `compare_results.py`
+
+Following the `hierarchical-madea` precedent (`run.py` line 37:
+`"hierarchical-madea": ("LSPc", "HierarchicalMADeA")`), register one new
+method, additively, in `run.py`'s dispatch tables (method list, result-label
+mapping, folder bookkeeping) — the same touch points already extended for
+`hierarchical-madea`, none of the existing entries changed:
+
+```python
+"plasma": ("LSPc", "Plasma"),
+```
+
+(The first element of a `METHOD_RESULT_MODELS` entry is the result-model key
+consumed by `load_models_results` at `run.py:317` — `"LSPc"` for every
+decentralized method — not a config class name. PLASMA writes LSPc-format
+result logs so it plugs into the existing loaders unchanged.)
+
+"Additively" means the same ~7 touch points `hierarchical-madea` needed, all
+new lines next to existing ones, none changed: the runner import (cf. line 7),
+the `--methods` choices list (line ~79), the `METHOD_RESULT_MODELS` table,
+the solution-folder bookkeeping dict (line ~901), the resume/skip logic
+(line ~970), the per-experiment run flag (line ~1030), and the invocation +
+folder registration (lines ~1143–1150).
+
+Invocation mirrors every other method:
+
+```bash
+python run.py -c config_files/plasma_comparison.json \
+  --methods centralized faas-macro plasma \
+  --n_experiments 3 --loop_over Nn
+```
+
+`compare_results.py` needs no changes: it already compares an arbitrary
+`--models` list by result label, so `Plasma` slots in next to
+`LoadManagementModel`/`FaaS-MACrO`/`HierarchicalMADeA`.
+
+`postprocessing.py`/`logs_postprocessing.py` gain new parsing functions only
+for what doesn't exist (regret vs. oracle, adaptation lag, msgs/node/s) —
+added as new functions in `plasma/eval/regret.py` plus, if genuinely needed,
+new (not modified) functions alongside the existing `parse_*_log_file`
+functions in `logs_postprocessing.py`.
+
+## 4. Milestones (repo-aligned)
+
+1. **M1 — Skeleton + scheduler.** `plasma/core/types.py`, `plasma/sim/clock.py`
+   (shared round barrier only), empty `PlasmaNode` that rejects everything.
+   Metrics pipeline (reusing `postprocessing.py`) works end-to-end on a
+   3-node line generated via `generators/generate_data.py`.
+2. **M2 — Layer A alone**, replicas fixed by config, on the round barrier. LP
+   convergence criteria on a 10-node ER graph (`neighborhood: {"p": ...}`)
+   from existing topology generation, stationary traffic from
+   `load_generator.py`'s existing `clipped` trace type (a pure-Poisson trace,
+   if needed for the paper, is a new function in `plasma/sim/`, per §1.2).
+3. **M3 — Baselines wired.** `milp_baseline.py` over `models/sp.py`,
+   `greedy_baseline.py` over `HeuristicCoordinator`/`GreedyCoordinator`,
+   `madea_iface.py` adapter. Gap metric vs LP relaxation.
+4. **M4 — Layer B alone**, synthetic `benefit` fields, dSB vs brute force
+   (≤12 spins/node).
+5. **M5 — Coupling + hysteresis.** Oscillation test, plus the mandatory
+   randomized-commit countermeasure (`p_commit`) test from §2. Full pipeline
+   vs MILP on a 20-node G(n,m) graph (`neighborhood: {"m": ...}`; BA is not
+   supported by `generate_neighborhood` and is not added): target gap ≤ 10%
+   stationary.
+6. **M6 — Non-stationarity + failures.** MMPP-style bursts (via existing
+   trace types or a small new generator if needed), node kill/revive,
+   adaptation-lag metric, comparison table PLASMA / greedy / stale-MILP /
+   FaaS-MADeA.
+7. **M7 — Rare-function mode + parameter sweeps.** Reuse `run.py`'s existing
+   `loop_over`/sweep machinery instead of a new sweep runner.
+
+## 5. LaTeX note
+
+The repo documents each method as a `faas-<name>-note/` LaTeX package
+(`faas-magcaa-note/`, `faas-mald-note/`, `faas-mapg-note/`,
+`faas-mapod-note/`, `faas-bestresponse-note/`, `faas-madig-note/`), each with
+a `main.tex` wrapper (`\input{faas-<name>}`) plus a `faas-<name>.tex` body and
+`references.bib`. Create `faas-plasma-note/` the same way:
+
+```
+faas-plasma-note/
+  main.tex          # \input{faas-plasma}
+  faas-plasma.tex    # body: problem statement, Layer A/B dynamics, Hamiltonian,
+                      #        round-barrier formulation, acceptance criteria,
+                      #        privacy comparison vs FaaS-MADeA's bid exchange
+  references.bib
+```
+
+Populate incrementally starting at M3 (once there's a baseline gap number to
+report) and keep it current through M7, replacing the original spec's
+`NOTES.md` (§10) — this repo's convention for paper-facing notes is the LaTeX
+package, not a markdown scratch file.
+
+## 6. What is unchanged from the original spec
+
+Sections 2–5 (problem model, Layer A dynamics, Layer B Hamiltonian/dSB,
+communication protocol), the open-parameter list (§9 there, minus
+`tick_jitter` which no longer applies), and the test plan's algorithmic
+content (§8 there: locality invariant, capacity gate, RAM repair,
+dSB-vs-brute-force, LP convergence, dead-neighbor decay, oscillation
+hysteresis, message budget, phase-locked commit) all carry over verbatim —
+only their file locations move per §1.3 above, and every test now runs under
+the single round-barrier execution model per §2 (no async variant to test
+against).
diff --git a/docs/plans/2026-07-04-plasma-findings-fixes.md b/docs/plans/2026-07-04-plasma-findings-fixes.md
new file mode 100644
index 0000000..cc46c8a
--- /dev/null
+++ b/docs/plans/2026-07-04-plasma-findings-fixes.md
@@ -0,0 +1,290 @@
+# PLASMA Review-Findings Fix Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Resolve the 8 code-review findings on the PLASMA implementation (branch `feat/uv-migration-and-extended-tests`).
+
+**Architecture:** No new modules. Four behavioral fixes (config tracking, W-scaling, spare flooring, zero-load objective guard), one input validation, two deletions. Finding 4 (missing Tasks 11–14) is NOT re-planned here: it is executed from the existing `docs/plans/2026-07-04-plasma-implementation.md`, which already specifies those tasks in full.
+
+**Tech Stack:** unchanged — Python 3.10, numpy, pandas; `uv run pytest`.
+
+## Global Constraints
+
+- Same as the implementation plan: 2-space indent, no new deps, never edit existing non-plasma files (`run.py` already carries its additive registration — do not touch it further).
+- There are pre-existing UNCOMMITTED changes (`run.py` registration, `plasma/runner.py` termination-condition format, `tests/test_plasma_e2e.py` wiring tests) that belong to the implementation plan's Task 10. Task 1 below commits them together with the force-added config — do not lose them.
+- Run `gitnexus_detect_changes()` before each commit (project CLAUDE.md rule).
+- Commit messages end with `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`.
+
+---
+
+### Task 1: Track the gitignored config + commit pending Task-10 work (finding 1)
+
+`.gitignore:2` has `config_files/*`; every other config there was force-added. Without `-f` the new config never ships and `test_plasma_comparison_config_exists_and_has_section` fails on a clean clone.
+
+- [ ] **Step 1: Verify current state**
+
+Run: `git check-ignore config_files/plasma_comparison.json && git status --short`
+Expected: the file is ignored; `run.py`, `plasma/runner.py`, `tests/test_plasma_e2e.py` are modified.
+
+- [ ] **Step 2: Run the wiring tests**
+
+Run: `uv run pytest tests/test_plasma_e2e.py tests/test_gcaa_wiring.py -q`
+Expected: all PASS.
+
+- [ ] **Step 3: Commit (force-adding the config)**
+
+```bash
+git add -f config_files/plasma_comparison.json
+git add run.py plasma/runner.py tests/test_plasma_e2e.py
+git commit -m "register plasma method in run.py dispatch"
+```
+
+---
+
+### Task 2: Validate PlasmaOptions (finding 6)
+
+**Files:**
+- Modify: `plasma/core/types.py` (add `__post_init__` to `PlasmaOptions`)
+- Test: `tests/test_plasma_protocol.py` (types tests live here)
+
+**Interfaces:** unchanged; invalid options now raise `ValueError` at construction instead of a `KeyError` deep inside `PlasmaEngine.run_rounds`.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_protocol.py`)
+
+```python
+def test_options_reject_nonpositive_rounds_per_step():
+  with pytest.raises(ValueError, match="rounds_per_step"):
+    PlasmaOptions(rounds_per_step=0)
+
+
+def test_options_reject_nonpositive_w():
+  with pytest.raises(ValueError, match="W"):
+    PlasmaOptions(W=0.0)
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -v -k options_reject`
+Expected: 2 FAIL (no exception raised)
+
+- [ ] **Step 3: Implement** — add to `PlasmaOptions` in `plasma/core/types.py`, after the field list:
+
+```python
+  def __post_init__(self) -> None:
+    if self.rounds_per_step < 1:
+      raise ValueError(f"rounds_per_step must be >= 1, got {self.rounds_per_step}")
+    if self.W <= 0.0:
+      raise ValueError(f"W must be > 0, got {self.W}")
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -q`
+Expected: all PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/types.py tests/test_plasma_protocol.py
+git commit -m "validate plasma options at construction"
+```
+
+---
+
+### Task 3: Make the runner correct for W != 1 (finding 2)
+
+**Files:**
+- Modify: `plasma/runner.py:103-109`
+- Test: `tests/test_plasma_e2e.py`
+
+A round lasts `W` seconds, so a window must receive `loadt * W` arrivals; today it receives `loadt`, while capacity gates scale with `W` — with `W = 2` utilization can reach `max_utilization * 2` and the `assert feasible` at `plasma/runner.py:123` fires. Feasibility/objective must then be checked against per-window counts, i.e. `incoming_load = arrivals` (already the case — the fix is only the arrival scaling).
+
+- [ ] **Step 1: Write the failing test** (append to `tests/test_plasma_e2e.py`)
+
+```python
+def test_runner_supports_w_not_one(tmp_path):
+  config = _config(tmp_path)
+  config["solver_options"]["plasma"]["W"] = 2.0
+  folder = run_plasma(config, parallelism=0)  # must not trip check_feasibility
+  obj = pd.read_csv(os.path.join(folder, "obj.csv"))["Plasma"]
+  assert np.isfinite(obj).all()
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_plasma_e2e.py::test_runner_supports_w_not_one -v`
+Expected: FAIL — either `AssertionError: max utilization ...` from the runner's feasibility assert, or (if traffic happens to stay low) investigate: the fix below must make the test pass for the right reason. If it passes before the fix, raise the config's load (`"max": {"min": 60, "max": 80}`) until the assert fires.
+
+- [ ] **Step 3: Implement** — in `plasma/runner.py`, scale arrivals by `W`:
+
+```python
+    arrivals = np.array([
+      [int(round(loadt[(n + 1, f + 1)] * opts.W)) for f in range(Nf)]
+      for n in range(Nn)
+    ])
+```
+
+(No other change: `incoming_load` is already set to `arrivals`, so conservation, utilization, and the objective are all per-window and consistent. `plasma_messages.csv` already divides by `rounds_per_step * W`.)
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_e2e.py -q`
+Expected: all PASS (W=1 tests unchanged: scaling by 1.0 is identity)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/runner.py tests/test_plasma_e2e.py
+git commit -m "scale plasma arrivals by round period W"
+```
+
+---
+
+### Task 4: Advertise floored spare in heartbeats (finding 3)
+
+**Files:**
+- Modify: `plasma/core/node.py:138-140` (`end_window`)
+- Test: `tests/test_plasma_routing.py`
+
+`_capacity_units` floors admission, but `end_window` advertises the continuous remainder: with `r*u_max*W = 2.085` and 2 admissions, `spare = 0.085 > 0` keeps neighbor gates fully open toward a node that will NACK everything.
+
+- [ ] **Step 1: Write the failing test** (append to `tests/test_plasma_routing.py`)
+
+```python
+def test_spare_advertises_floored_capacity():
+  node = _node(r=(1,), u_max=(2.085,))  # capacity_units = 2
+  node.begin_window()
+  assert node.admit_forward(0)
+  assert node.admit_forward(0)
+  assert not node.admit_forward(0)  # floored capacity exhausted
+  node.end_window()
+  hb = node.make_heartbeat()
+  assert hb.spare[0] == 0.0  # not 0.085: nothing more is admittable
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_plasma_routing.py::test_spare_advertises_floored_capacity -v`
+Expected: FAIL with `assert 0.08... == 0.0`
+
+- [ ] **Step 3: Implement** — in `end_window`, replace the `_spare_last` assignment:
+
+```python
+    self._spare_last = np.maximum(
+      0.0,
+      np.array([self._capacity_units(f) for f in range(self.Nf)])
+      - self._admitted,
+    )
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_routing.py tests/test_plasma_clock.py -q`
+Expected: all PASS (the engine scenario tests must stay green — same seeds)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/node.py tests/test_plasma_routing.py
+git commit -m "advertise floored spare capacity in heartbeats"
+```
+
+---
+
+### Task 5: Guard the objective against zero-load pairs (finding 5)
+
+**Files:**
+- Modify: `plasma/runner.py` (new module-level helper + one call-site change)
+- Test: `tests/test_plasma_e2e.py`
+
+`compute_centralized_objective` divides every term by `incoming_load[(n,f)]`; a trace value < 0.5 rounds to 0 and yields inf/nan in `obj.csv`. A zero-load pair has `x = y = z = 0`, so its correct contribution is 0 — dividing by 1 instead of 0 produces exactly that. Only the objective call gets the guarded load; `check_feasibility` keeps the true zeros (0 == 0 conservation must still hold).
+
+- [ ] **Step 1: Write the failing test** (append to `tests/test_plasma_e2e.py`)
+
+```python
+from plasma.runner import objective_load
+
+
+def test_objective_load_floors_zero_pairs_only():
+  load = {(1, 1): 0, (1, 2): 7}
+  assert objective_load(load) == {(1, 1): 1, (1, 2): 7}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_plasma_e2e.py::test_objective_load_floors_zero_pairs_only -v`
+Expected: FAIL with `ImportError: cannot import name 'objective_load'`
+
+- [ ] **Step 3: Implement** — in `plasma/runner.py`:
+
+```python
+def objective_load(incoming_load: dict) -> dict:
+  # a zero-load (n, f) contributes x = y = z = 0 to the objective; floor the
+  # divisor to 1 so its contribution is exactly 0 instead of 0/0 = nan
+  return {k: max(int(v), 1) for k, v in incoming_load.items()}
+```
+
+and change the objective call (runner loop) to:
+
+```python
+    obj_data = update_data(
+      data, {"incoming_load": objective_load(data[None]["incoming_load"])}
+    )
+    obj_list.append(
+      compute_centralized_objective(obj_data, res.x, res.y, res.z)
+    )
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_e2e.py -q`
+Expected: all PASS (with strictly positive loads `objective_load` is the identity, so existing obj.csv values are unchanged — the determinism test confirms it)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/runner.py tests/test_plasma_e2e.py
+git commit -m "guard plasma objective against zero-load pairs"
+```
+
+---
+
+### Task 6: Deletions — stale comment and dead accessor (findings 7, 8)
+
+**Files:**
+- Modify: `plasma/core/node.py:65` (delete the comment line `# Layer B state initialized in sb_setup (Task 7)`)
+- Modify: `plasma/core/protocol.py:53-58` (delete the unused `HeartbeatCache.alpha` method; the `alpha` WIRE field stays — it is the spec's message format and feeds the paper's privacy comparison; whether to drop it from the wire is a LaTeX-note-time decision, out of scope here)
+
+- [ ] **Step 1: Delete both**
+
+No new tests — deletions of dead code; the existing suite is the check.
+
+- [ ] **Step 2: Verify nothing referenced them**
+
+Run: `grep -rn "sb_setup\|cache.alpha\|\.alpha(" plasma/ tests/test_plasma_*.py`
+Expected: no matches (heartbeat `.alpha` FIELD accesses like `hb.alpha` are fine and expected).
+
+- [ ] **Step 3: Run the full plasma suite**
+
+Run: `uv run pytest tests/test_plasma_routing.py tests/test_plasma_sbm.py tests/test_plasma_protocol.py tests/test_plasma_clock.py tests/test_plasma_e2e.py -q`
+Expected: all PASS
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add plasma/core/node.py plasma/core/protocol.py
+git commit -m "drop dead heartbeat alpha accessor and stale comment"
+```
+
+---
+
+### Task 7: Full regression + scope closure (finding 4)
+
+- [ ] **Step 1: Full suite**
+
+Run: `uv run pytest tests/ -q`
+Expected: 541+ passed, 0 failed.
+
+- [ ] **Step 2: Finding 4 — remaining implementation scope**
+
+Execute Tasks 11–14 of `docs/plans/2026-07-04-plasma-implementation.md` exactly as written there (baselines, `eval/regret.py`, `tests/test_plasma_baselines.py`, LP-convergence + MILP-gap acceptance tests, `faas-plasma-note/`). They are fully specified in that plan — no re-planning needed. If the user prefers to defer them, tick this box with a note in the implementation plan marking M3+ as deferred.
diff --git a/docs/plans/2026-07-04-plasma-implementation.md b/docs/plans/2026-07-04-plasma-implementation.md
new file mode 100644
index 0000000..65e3be2
--- /dev/null
+++ b/docs/plans/2026-07-04-plasma-implementation.md
@@ -0,0 +1,2595 @@
+# PLASMA Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Implement PLASMA — Physarum routing (Layer A) + discrete Simulated Bifurcation replica allocation (Layer B), synchronous round-barrier only — as a new `plasma/` subpackage evaluated side by side with the existing methods via `run.py`.
+
+**Architecture:** A self-contained `plasma/` package (precedent: `hierarchical_auction/`). Pure-function algorithm modules (`routing`, `sbm`, `protocol`) composed by a `PlasmaNode`, driven by a heapq round-barrier engine. A runner mirrors `decentralized_gcaa.run`'s contract (`run(config, parallelism, log_on_file, disable_plotting) -> solution_folder`) and writes LSPc-format results via the existing `decode_solution`/`save_solution` helpers so `compare_results.py` and postprocessing work unchanged.
+
+**Tech Stack:** Python 3.10, numpy, networkx, pandas, scipy (all already in `pyproject.toml`). Tests: pytest via `uv run pytest`. Zero new third-party dependencies.
+
+**Spec sources:** `docs/plans/2026-07-04-plasma-design.md` (authoritative for repo integration) and `/Users/micheleciavotta/Downloads/PLASMA_SPEC.md` §§2–5, 8, 9 (authoritative for algorithm content; §4.4 async mode is DROPPED).
+
+## Global Constraints
+
+- Python pinned `>=3.10,<3.11` — no 3.11+ stdlib (`tomllib`, `ExceptionGroup`), no new deps, do not touch `pyproject.toml`.
+- **Never modify existing files** except `run.py` (additive registration only, Task 10) and `config_files/` (new file only). No edits to `models/*`, `run_centralized_model.py`, `run_faasmacro.py`, `run_faasmadea.py`, `heuristic_coordinator.py`, `generators/*`, `postprocessing.py`, `logs_postprocessing.py`, `compare_results.py`.
+- Repo code style: **2-space indentation**, double quotes, `snake_case`, type hints (repo passes mypy with lax codes).
+- Synchronous execution ONLY: single shared round barrier, period `W`. No per-node clocks, no tick jitter, no `execution.mode` key. Randomized commit (`p_commit`, default 0.5) is unconditional.
+- Locality invariant: a node reads only its own state and heartbeats/ACKs from direct neighbors. Heartbeat carries ONLY `spare`, `alpha`, `pull` (+ node id, seq). No `lambda`, RAM, replica counts, or topology cross an edge.
+- Determinism: every stochastic component takes an explicit `numpy.random.Generator`.
+- All spin couplings are node-local: assert and raise if any Hamiltonian term would couple spins of different nodes (structural: the Hamiltonian is a per-node closure over per-node arrays only).
+- Tests live flat in `tests/`, exactly six files: `test_plasma_routing.py`, `test_plasma_sbm.py`, `test_plasma_protocol.py`, `test_plasma_clock.py`, `test_plasma_baselines.py`, `test_plasma_e2e.py`.
+- Per project CLAUDE.md: before editing `run.py` run `gitnexus_impact({target: "parse_arguments", direction: "upstream"})`; run `gitnexus_detect_changes()` before every commit. New `plasma/*` files have no upstream callers, so impact analysis applies only to the `run.py` task.
+- Run tests with `uv run pytest <file> -v`. Commit after every task; end commit messages with `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`.
+
+## Repo interfaces you will reuse (read-only — verified signatures)
+
+```python
+# run_centralized_model.py
+init_problem(limits, trace_type, max_steps, seed, solution_folder)
+#   -> (base_instance_data, input_requests_traces, agents, graph)
+init_complete_solution() -> dict of empty DataFrames
+decode_solution(x, y, z, r, xi, rho, U, complete_solution) -> dict   # numpy in, accumulates one timestep
+join_complete_solution(cs) -> (solution_df, offloaded_df, detailed_fwd_df)
+save_solution(solution, offloaded, cs, detailed_fwd, model_name, folder)  # model_name = "LSPc"
+save_checkpoint(cs, folder, t)
+solve_instance(M, data, solver_name, solver_options)
+#   -> (x, y, z, r, xi, omega, rho, U, obj, runtime, tc)
+
+# utils/centralized.py
+get_current_load(input_requests_traces, agents, t) -> {(n, f): load}      # 1-indexed keys
+check_feasibility(x, omega, z, r, cpu_utilization, data) -> (bool, str)
+
+# generators/generate_data.py
+update_data(data, fixed_values) -> dict                                    # deepcopy + set data[None][k]
+
+# utils/faasmacro.py
+compute_centralized_objective(sp_data, x, y, z) -> float                   # per-load-normalized
+
+# utils/common.py
+load_configuration(path) -> dict
+
+# models/model.py
+LoadManagementModel  # centralized MILP, for solve_instance
+
+# heuristic_coordinator.py
+GreedyCoordinator().solve(instance, solver_options) -> dict
+#   instance needs data[None] keys: Nn, Nf, neighborhood, omega_bar, x_bar, r_bar,
+#   beta, gamma, demand, max_utilization, memory_requirement, incoming_load
+#   plus instance["sp_rho"] (residual RAM per node, np.array (Nn,))
+```
+
+`base_instance_data[None]` keys (1-indexed dict keys): `Nn`, `Nf`, `neighborhood[(n1,n2)]∈{0,1}`, `alpha[(n,f)]`, `beta[(n1,n2,f)]`, `gamma[(n,f)]`, `delta[(n,f)]`, `demand[(n,f)]`, `max_utilization[f]`, `memory_capacity[n]`, `memory_requirement[f]`. Graph edges carry `network_latency`.
+
+**Problem mapping (locked in):** per-replica capacity `u_max[i][f] = max_utilization[f] / demand[(i,f)]` req/s. Layer-A rewards: LOCAL → `alpha[(i,f)]`, forward to j → `beta[(i,j,f)]` (the sender's own objective coefficient — local constant, already latency-aware; this instantiates the spec's `alpha_remote − c` in repo terms), REJ → small floor. Layer-B benefit: `benefit[f] = alpha[f] * (demand_hat[f] + pull_in[f])`.
+
+---
+
+### Task 1: Types and options — `plasma/core/types.py`
+
+**Files:**
+- Create: `plasma/__init__.py`, `plasma/core/__init__.py`, `plasma/core/types.py`
+- Test: `tests/test_plasma_protocol.py` (types + protocol share this file)
+
+**Interfaces:**
+- Produces: `LOCAL = 0`, `REJ = 1` (column indices in the conductance matrix; neighbor k occupies column `2 + k`), `PlasmaOptions` frozen dataclass with `from_config(config: dict) -> PlasmaOptions`, `Heartbeat` frozen dataclass `(node: int, seq: int, spare: tuple, alpha: tuple, pull: tuple)`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_protocol.py
+import dataclasses
+
+import pytest
+
+from plasma.core.types import LOCAL, REJ, Heartbeat, PlasmaOptions
+
+
+def test_target_columns():
+  assert LOCAL == 0
+  assert REJ == 1
+
+
+def test_options_defaults():
+  opts = PlasmaOptions()
+  assert opts.W == 1.0
+  assert opts.k_sb == 10
+  assert opts.mu == 0.1
+  assert opts.p_commit == 0.5
+  assert opts.n_hyst == 2
+  assert opts.staleness_rounds == 3
+  assert opts.rare_function_mode == "sampled"
+
+
+def test_options_from_config_overrides():
+  config = {"solver_options": {"plasma": {"mu": 0.2, "k_sb": 5}}}
+  opts = PlasmaOptions.from_config(config)
+  assert opts.mu == 0.2
+  assert opts.k_sb == 5
+  assert opts.W == 1.0
+
+
+def test_options_frozen():
+  with pytest.raises(dataclasses.FrozenInstanceError):
+    PlasmaOptions().mu = 0.5
+
+
+def test_options_rejects_execution_mode():
+  config = {"solver_options": {"plasma": {"execution_mode": "async"}}}
+  with pytest.raises(TypeError):
+    PlasmaOptions.from_config(config)
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'plasma'`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/__init__.py  (empty file)
+# plasma/core/__init__.py  (empty file)
+
+# plasma/core/types.py
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+
+# conductance-matrix column layout: D has shape (Nf, 2 + deg)
+LOCAL = 0
+REJ = 1
+
+
+@dataclass(frozen=True)
+class PlasmaOptions:
+  # Layer A (round period W is the time unit: 1 round = W seconds)
+  W: float = 1.0
+  rounds_per_step: int = 20
+  mu: float = 0.1
+  kappa: float = 1.0
+  D_init: float = 1.0
+  D_min: float = 1e-3
+  D_max: float = 1e3
+  eps_explore: float = 0.01
+  rej_floor: float = 0.01
+  ewma: float = 0.3
+  lambda_split_threshold: float = 5.0
+  rare_function_mode: str = "sampled"  # "sampled" | "unsplittable"
+  r_init: str = "spread"  # "spread" | "zero"
+  # Layer B (k_sb = 0 disables SB entirely: replicas stay fixed)
+  k_sb: int = 10
+  n_sb_steps: int = 300
+  sb_dt: float = 0.05
+  sb_delta: float = 1.0
+  sb_c0: float = 0.2
+  a_final: float = 1.0
+  A: Optional[float] = None  # None -> auto: 2 * max_f(benefit_f / ram_req_f)
+  B: float = 1.0
+  C: float = 0.1
+  switch_cost: float = 1.0
+  z_delta: float = 2.0
+  eps_commit: float = 0.05
+  n_hyst: int = 2
+  p_commit: float = 0.5
+  # protocol
+  hb_latency_rounds: int = 1
+  hb_loss: float = 0.0
+  staleness_rounds: int = 3
+
+  @classmethod
+  def from_config(cls, config: dict) -> "PlasmaOptions":
+    return cls(**config.get("solver_options", {}).get("plasma", {}))
+
+
+@dataclass(frozen=True)
+class Heartbeat:
+  # the ENTIRE control-plane message: nothing else may cross an edge
+  node: int
+  seq: int
+  spare: Tuple[float, ...]  # per function, max(0, r*u_max - admitted)
+  alpha: Tuple[float, ...]  # per function
+  pull: Tuple[float, ...]   # per function, offload pressure last window
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -v`
+Expected: 5 PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/ tests/test_plasma_protocol.py
+git commit -m "add plasma core types and options"
+```
+
+---
+
+### Task 2: Round-barrier scheduler — `plasma/sim/clock.py`
+
+**Files:**
+- Create: `plasma/sim/__init__.py`, `plasma/sim/clock.py`
+- Test: `tests/test_plasma_clock.py`
+
+**Interfaces:**
+- Produces: `RoundClock` with `schedule(round_: int, fn: Callable[[], None])`, `run(n_rounds: int, on_round: Callable[[int], None])`, attribute `round: int` (next round to execute). Events due at round r are delivered BEFORE `on_round(r)`; ties delivered FIFO.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_clock.py
+from plasma.sim.clock import RoundClock
+
+
+def test_events_delivered_before_round_callback():
+  clock = RoundClock()
+  trace = []
+  clock.schedule(1, lambda: trace.append("hb@1"))
+  clock.run(2, on_round=lambda r: trace.append(f"round{r}"))
+  assert trace == ["round0", "hb@1", "round1"]
+
+
+def test_fifo_tie_break():
+  clock = RoundClock()
+  trace = []
+  clock.schedule(0, lambda: trace.append("a"))
+  clock.schedule(0, lambda: trace.append("b"))
+  clock.run(1, on_round=lambda r: None)
+  assert trace == ["a", "b"]
+
+
+def test_round_counter_persists_across_runs():
+  clock = RoundClock()
+  seen = []
+  clock.run(3, on_round=seen.append)
+  clock.run(2, on_round=seen.append)
+  assert seen == [0, 1, 2, 3, 4]
+
+
+def test_past_due_events_flush():
+  clock = RoundClock()
+  trace = []
+  clock.run(2, on_round=lambda r: None)
+  clock.schedule(0, lambda: trace.append("late"))
+  clock.run(1, on_round=lambda r: trace.append(f"round{r}"))
+  assert trace == ["late", "round2"]
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_clock.py -v`
+Expected: FAIL with `ModuleNotFoundError`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/sim/__init__.py  (empty file)
+
+# plasma/sim/clock.py
+from __future__ import annotations
+
+import heapq
+from typing import Callable, List, Tuple
+
+
+class RoundClock:
+  """Single shared round barrier (period = W). The only clock in PLASMA:
+  there is no per-node clock and no tick jitter (sync-only design)."""
+
+  def __init__(self) -> None:
+    self._queue: List[Tuple[int, int, Callable[[], None]]] = []
+    self._seq = 0
+    self.round = 0
+
+  def schedule(self, round_: int, fn: Callable[[], None]) -> None:
+    heapq.heappush(self._queue, (round_, self._seq, fn))
+    self._seq += 1
+
+  def run(self, n_rounds: int, on_round: Callable[[int], None]) -> None:
+    for r in range(self.round, self.round + n_rounds):
+      while self._queue and self._queue[0][0] <= r:
+        heapq.heappop(self._queue)[2]()
+      on_round(r)
+    self.round += n_rounds
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_clock.py -v`
+Expected: 4 PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/sim tests/test_plasma_clock.py
+git commit -m "add plasma round-barrier scheduler"
+```
+
+---
+
+### Task 3: Layer A pure functions — `plasma/core/routing.py`
+
+**Files:**
+- Create: `plasma/core/routing.py`
+- Test: `tests/test_plasma_routing.py`
+
+**Interfaces:**
+- Consumes: `LOCAL`, `REJ` from `plasma.core.types`.
+- Produces:
+  - `target_weights(D_f: np.ndarray, local_open: bool, nbr_spare: np.ndarray, eps_explore: float) -> np.ndarray` — shape `(2+deg,)`; column LOCAL zeroed when gate closed, neighbor columns scaled by 1.0 when `nbr_spare > 0` else `eps_explore`.
+  - `choose_target(rng, weights: np.ndarray, unsplittable: bool) -> int` — categorical sample, or argmax when `unsplittable`.
+  - `update_conductance(D: np.ndarray, phi: np.ndarray, rewards: np.ndarray, opts) -> np.ndarray` — `(1-mu)*D + mu*(phi**kappa)*rewards`, clipped to `[D_min, D_max]`; shapes all `(Nf, 2+deg)`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_routing.py
+import numpy as np
+import pytest
+
+from plasma.core.types import LOCAL, REJ, PlasmaOptions
+from plasma.core.routing import choose_target, target_weights, update_conductance
+
+
+def test_local_gate_closes_local_column():
+  D_f = np.array([10.0, 0.1, 5.0])  # LOCAL, REJ, one neighbor
+  w = target_weights(D_f, local_open=False, nbr_spare=np.array([1.0]),
+                     eps_explore=0.01)
+  assert w[LOCAL] == 0.0
+  assert w[2] == 5.0
+
+
+def test_neighbor_without_spare_gets_exploration_floor():
+  D_f = np.array([1.0, 0.1, 4.0])
+  w = target_weights(D_f, local_open=True, nbr_spare=np.array([0.0]),
+                     eps_explore=0.01)
+  assert w[2] == pytest.approx(4.0 * 0.01)
+
+
+def test_choose_target_unsplittable_is_argmax():
+  rng = np.random.default_rng(0)
+  w = np.array([1.0, 0.5, 7.0])
+  assert choose_target(rng, w, unsplittable=True) == 2
+
+
+def test_choose_target_sampled_follows_weights():
+  rng = np.random.default_rng(0)
+  w = np.array([0.0, 0.0, 1.0])
+  assert choose_target(rng, w, unsplittable=False) == 2
+
+
+def test_conductance_reinforces_accepted_traffic():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 1.0)
+  phi = np.array([[10.0, 0.0, 0.0]])
+  rewards = np.array([[2.0, 0.0, 0.0]])
+  D2 = update_conductance(D, phi, rewards, opts)
+  assert D2[0, LOCAL] == pytest.approx(0.9 * 1.0 + 0.1 * 10.0 * 2.0)
+
+
+def test_dead_neighbor_conductance_decays_to_floor():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 100.0)
+  phi = np.zeros((1, 3))
+  rewards = np.zeros((1, 3))
+  for _ in range(200):
+    D = update_conductance(D, phi, rewards, opts)
+  # pure evaporation: (1-mu)^200 * 100 << D_min -> clipped at floor
+  assert D[0, 2] == pytest.approx(opts.D_min)
+
+
+def test_conductance_clipped_above():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 1.0)
+  phi = np.full((1, 3), 1e9)
+  rewards = np.full((1, 3), 1e9)
+  D2 = update_conductance(D, phi, rewards, opts)
+  assert (D2 <= opts.D_max).all()
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_routing.py -v`
+Expected: FAIL with `ModuleNotFoundError` (no `plasma.core.routing`)
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/core/routing.py
+from __future__ import annotations
+
+import numpy as np
+
+from plasma.core.types import LOCAL, REJ, PlasmaOptions
+
+
+def target_weights(
+    D_f: np.ndarray, local_open: bool, nbr_spare: np.ndarray,
+    eps_explore: float
+  ) -> np.ndarray:
+  w = D_f.copy()
+  if not local_open:
+    w[LOCAL] = 0.0
+  gates = np.where(nbr_spare > 0.0, 1.0, eps_explore)
+  w[2:] = w[2:] * gates
+  return w
+
+
+def choose_target(
+    rng: np.random.Generator, weights: np.ndarray, unsplittable: bool
+  ) -> int:
+  if unsplittable:
+    return int(np.argmax(weights))
+  total = weights.sum()
+  if total <= 0.0:
+    return REJ
+  return int(rng.choice(len(weights), p=weights / total))
+
+
+def update_conductance(
+    D: np.ndarray, phi: np.ndarray, rewards: np.ndarray, opts: PlasmaOptions
+  ) -> np.ndarray:
+  reinforced = (1.0 - opts.mu) * D + opts.mu * (phi ** opts.kappa) * rewards
+  return np.clip(reinforced, opts.D_min, opts.D_max)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_routing.py -v`
+Expected: 7 PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/routing.py tests/test_plasma_routing.py
+git commit -m "add plasma layer A routing primitives"
+```
+
+---
+
+### Task 4: Heartbeat protocol — `plasma/core/protocol.py`
+
+**Files:**
+- Create: `plasma/core/protocol.py`
+- Test: `tests/test_plasma_protocol.py` (append)
+
+**Interfaces:**
+- Consumes: `Heartbeat` from `plasma.core.types`.
+- Produces:
+  - `encode_heartbeat(hb: Heartbeat) -> dict` / `decode_heartbeat(msg: dict) -> Heartbeat` (raises `ValueError` on unknown fields — the privacy whitelist).
+  - `HeartbeatCache` with `store(hb: Heartbeat, round_: int)`, `spare(nbr: int, now_round: int, staleness_rounds: int, Nf: int) -> np.ndarray`, `alpha(nbr, now_round, staleness_rounds, Nf) -> np.ndarray`, `pull_in(now_round, staleness_rounds, Nf) -> np.ndarray` (sum of fresh neighbors' pull).
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_protocol.py`)
+
+```python
+import numpy as np
+
+from plasma.core.protocol import HeartbeatCache, decode_heartbeat, encode_heartbeat
+
+
+def _hb(node=3, seq=7):
+  return Heartbeat(node=node, seq=seq, spare=(1.0, 0.0), alpha=(2.0, 2.5),
+                   pull=(0.0, 4.0))
+
+
+def test_heartbeat_roundtrip():
+  hb = _hb()
+  assert decode_heartbeat(encode_heartbeat(hb)) == hb
+
+
+def test_heartbeat_field_whitelist():
+  msg = encode_heartbeat(_hb())
+  assert set(msg) == {"node", "seq", "spare", "alpha", "pull"}
+  msg["ram_capacity"] = 64  # privacy violation: must be rejected
+  with pytest.raises(ValueError):
+    decode_heartbeat(msg)
+
+
+def test_stale_neighbor_treated_as_zero_spare():
+  cache = HeartbeatCache()
+  cache.store(_hb(node=3), round_=10)
+  fresh = cache.spare(3, now_round=12, staleness_rounds=3, Nf=2)
+  stale = cache.spare(3, now_round=14, staleness_rounds=3, Nf=2)
+  assert fresh.tolist() == [1.0, 0.0]
+  assert stale.tolist() == [0.0, 0.0]
+
+
+def test_unknown_neighbor_is_zero_spare():
+  cache = HeartbeatCache()
+  assert cache.spare(9, now_round=0, staleness_rounds=3, Nf=2).tolist() == [0.0, 0.0]
+
+
+def test_pull_in_sums_fresh_neighbors_only():
+  cache = HeartbeatCache()
+  cache.store(_hb(node=1), round_=10)   # pull (0, 4)
+  cache.store(_hb(node=2), round_=1)    # stale at now=12
+  pull = cache.pull_in(now_round=12, staleness_rounds=3, Nf=2)
+  assert pull.tolist() == [0.0, 4.0]
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -v`
+Expected: new tests FAIL with `ModuleNotFoundError` (no `plasma.core.protocol`); Task 1 tests still PASS
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/core/protocol.py
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+import numpy as np
+
+from plasma.core.types import Heartbeat
+
+_FIELDS = {"node", "seq", "spare", "alpha", "pull"}
+
+
+def encode_heartbeat(hb: Heartbeat) -> dict:
+  return {
+    "node": hb.node, "seq": hb.seq, "spare": list(hb.spare),
+    "alpha": list(hb.alpha), "pull": list(hb.pull),
+  }
+
+
+def decode_heartbeat(msg: dict) -> Heartbeat:
+  extra = set(msg) - _FIELDS
+  if extra:
+    raise ValueError(f"heartbeat carries non-whitelisted fields: {sorted(extra)}")
+  return Heartbeat(
+    node=int(msg["node"]), seq=int(msg["seq"]), spare=tuple(msg["spare"]),
+    alpha=tuple(msg["alpha"]), pull=tuple(msg["pull"]),
+  )
+
+
+class HeartbeatCache:
+  """Per-node view of neighbors. Staleness rule: older than
+  staleness_rounds -> spare = 0 for all f (gates close, conductance decays;
+  no failure detector, no membership protocol)."""
+
+  def __init__(self) -> None:
+    self._last: Dict[int, Tuple[int, Heartbeat]] = {}
+
+  def store(self, hb: Heartbeat, round_: int) -> None:
+    self._last[hb.node] = (round_, hb)
+
+  def _fresh(self, nbr: int, now_round: int, staleness_rounds: int):
+    entry = self._last.get(nbr)
+    if entry is None or now_round - entry[0] > staleness_rounds:
+      return None
+    return entry[1]
+
+  def spare(
+      self, nbr: int, now_round: int, staleness_rounds: int, Nf: int
+    ) -> np.ndarray:
+    hb = self._fresh(nbr, now_round, staleness_rounds)
+    return np.array(hb.spare) if hb else np.zeros(Nf)
+
+  def alpha(
+      self, nbr: int, now_round: int, staleness_rounds: int, Nf: int
+    ) -> np.ndarray:
+    hb = self._fresh(nbr, now_round, staleness_rounds)
+    return np.array(hb.alpha) if hb else np.zeros(Nf)
+
+  def pull_in(
+      self, now_round: int, staleness_rounds: int, Nf: int
+    ) -> np.ndarray:
+    total = np.zeros(Nf)
+    for nbr in self._last:
+      hb = self._fresh(nbr, now_round, staleness_rounds)
+      if hb:
+        total += np.array(hb.pull)
+    return total
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_protocol.py -v`
+Expected: all PASS (10 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/protocol.py tests/test_plasma_protocol.py
+git commit -m "add plasma heartbeat protocol and staleness cache"
+```
+
+---
+
+### Task 5: Layer B — `plasma/core/sbm.py`
+
+**Files:**
+- Create: `plasma/core/sbm.py`
+- Test: `tests/test_plasma_sbm.py`
+
+**Interfaces:**
+- Produces:
+  - `r_max_per_fn(ram_cap: float, ram_req: np.ndarray) -> np.ndarray[int]`, `bits_per_fn(r_max: np.ndarray) -> np.ndarray[int]` (`ceil(log2(r_max+1))`, 0 bits when r_max == 0).
+  - `decode_spins(s: np.ndarray, bits: np.ndarray, r_max: np.ndarray) -> np.ndarray[int]` — binary decode, clipped to `r_max`.
+  - `HamiltonianContext` frozen dataclass `(benefit, ram_req, ram_cap, demand_hat, margin, u_max, r_prev, A, B, C, switch_cost)` — all per-node arrays `(Nf,)` + scalars. Node-local by construction (the locality invariant).
+  - `hamiltonian(r: np.ndarray, ctx: HamiltonianContext) -> float`.
+  - `dsb_minimize(H, n_spins: int, opts: PlasmaOptions, rng) -> np.ndarray` — spins in {-1,+1}; `H: Callable[[np.ndarray], float]` over spins.
+  - `brute_force(H, n_spins: int) -> np.ndarray` — exact ground state (test oracle, ≤ 12 spins).
+  - `repair(r, benefit, ram_req, ram_cap) -> np.ndarray` — drop lowest-benefit replicas until RAM-feasible.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_sbm.py
+import numpy as np
+import pytest
+
+from plasma.core.types import PlasmaOptions
+from plasma.core.sbm import (
+  HamiltonianContext, bits_per_fn, brute_force, decode_spins, dsb_minimize,
+  hamiltonian, r_max_per_fn, repair,
+)
+
+
+def test_encoding_roundtrip():
+  r_max = np.array([5, 0, 1])
+  bits = bits_per_fn(r_max)
+  assert bits.tolist() == [3, 0, 1]
+  # spins for r = (5, -, 1): 5 = 101b -> bits (1,0,1) -> spins (+1,-1,+1)
+  s = np.array([1, -1, 1, 1])
+  assert decode_spins(s, bits, r_max).tolist() == [5, 0, 1]
+
+
+def test_decode_clips_to_r_max():
+  r_max = np.array([5])           # 3 bits encode up to 7
+  s = np.array([1, 1, 1])         # decodes to 7
+  assert decode_spins(s, bits_per_fn(r_max), r_max).tolist() == [5]
+
+
+def _ctx(**over):
+  base = dict(
+    benefit=np.array([3.0, 1.0]), ram_req=np.array([2.0, 2.0]), ram_cap=8.0,
+    demand_hat=np.array([4.0, 1.0]), margin=np.array([1.0, 0.5]),
+    u_max=np.array([5.0, 5.0]), r_prev=np.array([1, 0]),
+    A=10.0, B=1.0, C=0.1, switch_cost=1.0,
+  )
+  base.update(over)
+  return HamiltonianContext(**base)
+
+
+def test_hamiltonian_penalizes_ram_violation():
+  ctx = _ctx()
+  ok = hamiltonian(np.array([2, 2]), ctx)       # RAM = 8 <= 8
+  bad = hamiltonian(np.array([3, 2]), ctx)      # RAM = 10 > 8
+  assert bad > ok
+
+
+def test_hamiltonian_churn_term():
+  ctx = _ctx(B=0.0, A=0.0, benefit=np.zeros(2))
+  h_stay = hamiltonian(np.array([1, 0]), ctx)
+  h_move = hamiltonian(np.array([3, 2]), ctx)
+  assert h_move == pytest.approx(h_stay + 0.1 * 1.0 * (2 + 2))
+
+
+def test_repair_restores_feasibility_dropping_lowest_benefit():
+  r = np.array([3, 3])  # RAM = 12 > 8
+  fixed = repair(r, benefit=np.array([3.0, 1.0]), ram_req=np.array([2.0, 2.0]),
+                 ram_cap=8.0)
+  assert (fixed * np.array([2.0, 2.0])).sum() <= 8.0
+  assert fixed[0] >= fixed[1]  # low-benefit f=1 dropped first
+
+
+def test_dsb_matches_brute_force_on_random_hamiltonians():
+  opts = PlasmaOptions(n_sb_steps=400)
+  hits = 0
+  trials = 200
+  for trial in range(trials):
+    rng = np.random.default_rng(trial)
+    n = 8
+    J = rng.normal(size=(n, n)); J = (J + J.T) / 2; np.fill_diagonal(J, 0.0)
+    h = rng.normal(size=n)
+
+    def H(s, J=J, h=h):
+      return float(-0.5 * s @ J @ s - h @ s)
+
+    s_star = brute_force(H, n)
+    s_dsb = dsb_minimize(H, n, opts, rng)
+    if H(s_dsb) <= H(s_star) + 1e-9:
+      hits += 1
+  assert hits >= 0.95 * trials
+
+
+def test_brute_force_exact_on_tiny_instance():
+  def H(s):
+    return float(-(s[0] * s[1]) - s[0])  # ground state (+1, +1)
+  assert brute_force(H, 2).tolist() == [1, 1]
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_sbm.py -v`
+Expected: FAIL with `ModuleNotFoundError`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/core/sbm.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import product
+from typing import Callable
+
+import numpy as np
+
+from plasma.core.types import PlasmaOptions
+
+
+def r_max_per_fn(ram_cap: float, ram_req: np.ndarray) -> np.ndarray:
+  return np.floor(ram_cap / ram_req).astype(int)
+
+
+def bits_per_fn(r_max: np.ndarray) -> np.ndarray:
+  return np.where(r_max > 0, np.ceil(np.log2(r_max + 1)), 0).astype(int)
+
+
+def decode_spins(
+    s: np.ndarray, bits: np.ndarray, r_max: np.ndarray
+  ) -> np.ndarray:
+  r = np.zeros(len(bits), dtype=int)
+  k = 0
+  for f, nb in enumerate(bits):
+    for b in range(nb):
+      r[f] += (2 ** b) * (1 + int(s[k])) // 2
+      k += 1
+  return np.minimum(r, r_max)
+
+
+@dataclass(frozen=True)
+class HamiltonianContext:
+  # every array is per-node-local: no term may reference another node's
+  # spins (decentralization holds by construction)
+  benefit: np.ndarray
+  ram_req: np.ndarray
+  ram_cap: float
+  demand_hat: np.ndarray
+  margin: np.ndarray
+  u_max: np.ndarray
+  r_prev: np.ndarray
+  A: float
+  B: float
+  C: float
+  switch_cost: float
+
+
+def hamiltonian(r: np.ndarray, ctx: HamiltonianContext) -> float:
+  field = -(ctx.benefit * r).sum()
+  ram_over = max(0.0, float((ctx.ram_req * r).sum() - ctx.ram_cap))
+  cap_short = np.maximum(0.0, ctx.demand_hat + ctx.margin - r * ctx.u_max)
+  churn = ctx.switch_cost * np.abs(r - ctx.r_prev).sum()
+  return float(
+    field + ctx.A * ram_over ** 2 + ctx.B * (cap_short ** 2).sum()
+    + ctx.C * churn
+  )
+
+
+def _local_field(H: Callable, s: np.ndarray, k: int) -> float:
+  sp = s.copy(); sp[k] = 1
+  sm = s.copy(); sm[k] = -1
+  return (H(sp) - H(sm)) / 2.0
+
+
+def dsb_minimize(
+    H: Callable[[np.ndarray], float], n_spins: int, opts: PlasmaOptions,
+    rng: np.random.Generator
+  ) -> np.ndarray:
+  # discrete SB: couplings act on sign(q) (dSB variant)
+  # ponytail: local fields via 2 H-evals per spin per step; fine for
+  # <=12 spins/node, switch to analytic gradients if n_spins grows
+  q = rng.uniform(-0.1, 0.1, n_spins)
+  p = np.zeros(n_spins)
+  for step in range(opts.n_sb_steps):
+    a = opts.a_final * step / max(1, opts.n_sb_steps)
+    s = np.where(q >= 0, 1, -1)
+    h = np.array([_local_field(H, s, k) for k in range(n_spins)])
+    p += opts.sb_dt * (-(opts.sb_delta - a) * q - opts.sb_c0 * h)
+    q += opts.sb_dt * opts.sb_delta * p
+    hit = np.abs(q) > 1.0
+    q[hit] = np.sign(q[hit])
+    p[hit] = 0.0
+  return np.where(q >= 0, 1, -1).astype(int)
+
+
+def brute_force(H: Callable[[np.ndarray], float], n_spins: int) -> np.ndarray:
+  best_s, best_h = None, np.inf
+  for combo in product((-1, 1), repeat=n_spins):
+    s = np.array(combo)
+    val = H(s)
+    if val < best_h:
+      best_s, best_h = s, val
+  return best_s
+
+
+def repair(
+    r: np.ndarray, benefit: np.ndarray, ram_req: np.ndarray, ram_cap: float
+  ) -> np.ndarray:
+  fixed = r.copy()
+  while (ram_req * fixed).sum() > ram_cap:
+    candidates = np.where(fixed > 0)[0]
+    f = candidates[np.argmin(benefit[candidates])]
+    fixed[f] -= 1
+  return fixed
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_sbm.py -v`
+Expected: 7 PASS. The brute-force comparison test takes ~1–2 minutes; if `dsb_minimize` misses the 95% bar, tune `sb_c0` (try 0.3–0.7) and `n_sb_steps` (up to 1000) — the spec fixes the acceptance bar, not the parameters.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/sbm.py tests/test_plasma_sbm.py
+git commit -m "add plasma layer B dSB solver with hamiltonian and repair"
+```
+
+---
+
+### Task 6: PlasmaNode, Layer A behavior — `plasma/core/node.py`
+
+**Files:**
+- Create: `plasma/core/node.py`
+- Test: `tests/test_plasma_routing.py` (append node-level Layer A tests)
+
+**Interfaces:**
+- Consumes: everything from Tasks 1, 3, 4, 5.
+- Produces:
+
+```python
+@dataclass(frozen=True)
+class NodeParams:
+  node_id: int              # 0-based
+  nbrs: tuple               # 0-based neighbor ids; column 2+k <-> nbrs[k]
+  alpha: np.ndarray         # (Nf,)
+  gamma: np.ndarray         # (Nf,)
+  beta: np.ndarray          # (deg, Nf) reward for forwarding to nbrs[k]
+  u_max: np.ndarray         # (Nf,) req/s per replica
+  ram_cap: float
+  ram_req: np.ndarray       # (Nf,)
+
+class PlasmaNode:
+  def __init__(self, params: NodeParams, opts: PlasmaOptions, rng): ...
+  r: np.ndarray                                   # (Nf,) int, current replicas
+  alive: bool
+  def begin_window(self) -> None
+  def route_request(self, f: int, round_: int) -> int      # returns column
+  def admit_forward(self, f: int) -> bool                  # incoming data plane
+  def record_forward_result(self, f: int, col: int, accepted: bool) -> None
+  def end_window(self) -> WindowCounts
+  def make_heartbeat(self) -> Heartbeat
+  def on_heartbeat(self, hb: Heartbeat, round_: int) -> None
+  def sb_pass(self) -> None                                # Task 7
+
+@dataclass
+class WindowCounts:
+  x: np.ndarray        # (Nf,) locally processed externals
+  z: np.ndarray        # (Nf,) rejected (incl. NACKed forwards)
+  y: np.ndarray        # (deg, Nf) ACKed forwards per neighbor
+  xi: np.ndarray       # (Nf,) forwards accepted FROM others (received)
+```
+
+Semantics locked in:
+- `route_request` computes weights via `target_weights` with `local_open = admitted_total[f] < r[f]*u_max[f]*W` and `nbr_spare[k] = cache.spare(nbrs[k], round_, staleness_rounds, Nf)[f]`; unsplittable iff `rare_function_mode == "unsplittable"` and `lam_hat[f] < lambda_split_threshold` (`lam_hat` = EWMA of external arrivals). LOCAL increments `x` and `admitted_total[f]`; REJ increments `z`.
+- `admit_forward` returns True and increments `admitted_total[f]` and `xi[f]` iff alive and `admitted_total[f] < r[f]*u_max[f]*W`; TTL=1: a forwarded request is never re-forwarded (receiver only processes or the ORIGIN records the rejection).
+- `record_forward_result(f, col, accepted)`: accepted → `y[col-2, f] += 1` and `phi[f, col] += 1`; NACK → `z[f] += 1`. Every forward ATTEMPT (accepted or not) increments `pull_out[f]` (offload pressure), as do local rejections.
+- `end_window`: `phi[f, LOCAL] = x[f]`; rewards matrix: `rewards[:, LOCAL] = alpha`, `rewards[:, REJ] = rej_floor`, `rewards[:, 2+k] = beta[k]`; then `update_conductance`; update `demand_hat = (1-ewma)*demand_hat + ewma*(x + accepted forwards... )` — locked: `demand_hat` tracks ACCEPTED local demand: `(1-ewma)*demand_hat + ewma*(x + xi)`; reset window counters after returning them.
+- `make_heartbeat`: `spare[f] = max(0, r[f]*u_max[f]*W - admitted_total_last_window[f])`, `alpha` = params.alpha, `pull` = last window's `pull_out`.
+- A dead node (`alive = False`) routes nothing, admits nothing, sends no heartbeats.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_routing.py`)
+
+```python
+from plasma.core.node import NodeParams, PlasmaNode
+
+
+def _node(r=(2,), u_max=(5.0,), nbrs=(1,), opts=None):
+  Nf = len(u_max)
+  params = NodeParams(
+    node_id=0, nbrs=tuple(nbrs), alpha=np.full(Nf, 2.0),
+    gamma=np.full(Nf, 0.1), beta=np.full((len(nbrs), Nf), 1.5),
+    u_max=np.array(u_max), ram_cap=100.0, ram_req=np.full(Nf, 2.0),
+  )
+  node = PlasmaNode(params, opts or PlasmaOptions(), np.random.default_rng(0))
+  node.r = np.array(r, dtype=int)
+  return node
+
+
+def test_capacity_gate_never_admits_beyond_r_umax():
+  node = _node(r=(2,), u_max=(5.0,))  # capacity 10 req/window
+  node.begin_window()
+  local = sum(node.route_request(0, round_=0) == LOCAL for _ in range(100))
+  counts = node.end_window()
+  assert local <= 10
+  assert counts.x[0] == local
+
+
+def test_incoming_forwards_share_the_same_capacity():
+  node = _node(r=(1,), u_max=(3.0,))
+  node.begin_window()
+  admitted = sum(node.admit_forward(0) for _ in range(10))
+  assert admitted == 3
+  assert node.route_request(0, round_=0) != LOCAL  # capacity exhausted
+
+
+def test_nack_counts_as_origin_rejection_and_pull():
+  node = _node()
+  node.begin_window()
+  node.record_forward_result(0, col=2, accepted=False)
+  node.record_forward_result(0, col=2, accepted=True)
+  counts = node.end_window()
+  assert counts.z[0] == 1
+  assert counts.y[0, 0] == 1
+  hb = node.make_heartbeat()
+  assert hb.pull[0] == 2  # both attempts are offload pressure
+
+
+def test_zero_replicas_rejects_or_forwards_everything():
+  node = _node(r=(0,))
+  node.begin_window()
+  for _ in range(20):
+    assert node.route_request(0, round_=0) != LOCAL
+
+
+def test_dead_node_admits_nothing():
+  node = _node()
+  node.alive = False
+  assert node.admit_forward(0) is False
+
+
+def test_end_window_reinforces_local_conductance():
+  node = _node(r=(4,), u_max=(100.0,))
+  node.begin_window()
+  for _ in range(50):
+    node.route_request(0, round_=0)
+  d_before = node.D[0, LOCAL]
+  node.end_window()
+  assert node.D[0, LOCAL] > d_before  # phi*alpha > evaporation at D_init
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_routing.py -v`
+Expected: new tests FAIL (`No module named 'plasma.core.node'`); earlier tests PASS
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/core/node.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from plasma.core.protocol import HeartbeatCache
+from plasma.core.routing import choose_target, target_weights, update_conductance
+from plasma.core.types import LOCAL, REJ, Heartbeat, PlasmaOptions
+
+
+@dataclass(frozen=True)
+class NodeParams:
+  node_id: int
+  nbrs: tuple
+  alpha: np.ndarray
+  gamma: np.ndarray
+  beta: np.ndarray
+  u_max: np.ndarray
+  ram_cap: float
+  ram_req: np.ndarray
+
+
+@dataclass
+class WindowCounts:
+  x: np.ndarray
+  z: np.ndarray
+  y: np.ndarray
+  xi: np.ndarray
+
+
+class PlasmaNode:
+  def __init__(
+      self, params: NodeParams, opts: PlasmaOptions, rng: np.random.Generator
+    ) -> None:
+    self.params = params
+    self.opts = opts
+    self.rng = rng
+    Nf = len(params.alpha)
+    deg = len(params.nbrs)
+    self.Nf = Nf
+    self.deg = deg
+    self.alive = True
+    self.r = np.zeros(Nf, dtype=int)
+    self.D = np.full((Nf, 2 + deg), opts.D_init)
+    self.cache = HeartbeatCache()
+    self.demand_hat = np.zeros(Nf)
+    self.lam_hat = np.zeros(Nf)
+    self._seq = 0
+    self._spare_last = np.zeros(Nf)
+    self._pull_last = np.zeros(Nf)
+    # rewards are constant: local alpha, REJ floor, per-neighbor beta
+    self._rewards = np.empty((Nf, 2 + deg))
+    self._rewards[:, LOCAL] = params.alpha
+    self._rewards[:, REJ] = opts.rej_floor
+    for k in range(deg):
+      self._rewards[:, 2 + k] = params.beta[k]
+    self.begin_window()
+    # Layer B state initialized in sb_setup (Task 7)
+
+  # ---------------- Layer A: data plane ----------------
+
+  def begin_window(self) -> None:
+    Nf, deg = self.Nf, self.deg
+    self._x = np.zeros(Nf)
+    self._z = np.zeros(Nf)
+    self._y = np.zeros((deg, Nf))
+    self._xi = np.zeros(Nf)
+    self._phi = np.zeros((Nf, 2 + deg))
+    self._pull = np.zeros(Nf)
+    self._admitted = np.zeros(Nf)
+    self._arrivals = np.zeros(Nf)
+
+  def _capacity(self, f: int) -> float:
+    return float(self.r[f]) * self.params.u_max[f] * self.opts.W
+
+  def route_request(self, f: int, round_: int) -> int:
+    self._arrivals[f] += 1
+    local_open = self._admitted[f] < self._capacity(f)
+    nbr_spare = np.array([
+      self.cache.spare(
+        j, round_, self.opts.staleness_rounds, self.Nf
+      )[f] for j in self.params.nbrs
+    ])
+    weights = target_weights(
+      self.D[f], local_open, nbr_spare, self.opts.eps_explore
+    )
+    unsplittable = (
+      self.opts.rare_function_mode == "unsplittable"
+      and self.lam_hat[f] < self.opts.lambda_split_threshold
+    )
+    col = choose_target(self.rng, weights, unsplittable)
+    if col == LOCAL:
+      self._x[f] += 1
+      self._admitted[f] += 1
+      self._phi[f, LOCAL] += 1
+    elif col == REJ:
+      self._z[f] += 1
+      self._pull[f] += 1
+    return col
+
+  def admit_forward(self, f: int) -> bool:
+    if not self.alive or self._admitted[f] >= self._capacity(f):
+      return False
+    self._admitted[f] += 1
+    self._xi[f] += 1
+    return True
+
+  def record_forward_result(self, f: int, col: int, accepted: bool) -> None:
+    self._pull[f] += 1
+    if accepted:
+      self._y[col - 2, f] += 1
+      self._phi[f, col] += 1
+    else:
+      self._z[f] += 1
+
+  # ---------------- Layer A: control plane ----------------
+
+  def end_window(self) -> WindowCounts:
+    counts = WindowCounts(x=self._x, z=self._z, y=self._y, xi=self._xi)
+    self.D = update_conductance(self.D, self._phi, self._rewards, self.opts)
+    ew = self.opts.ewma
+    self.demand_hat = (1 - ew) * self.demand_hat + ew * (self._x + self._xi)
+    self.lam_hat = (1 - ew) * self.lam_hat + ew * self._arrivals
+    self._spare_last = np.maximum(
+      0.0, self.r * self.params.u_max * self.opts.W - self._admitted
+    )
+    self._pull_last = self._pull
+    self.begin_window()
+    return counts
+
+  def make_heartbeat(self) -> Heartbeat:
+    self._seq += 1
+    return Heartbeat(
+      node=self.params.node_id, seq=self._seq,
+      spare=tuple(self._spare_last), alpha=tuple(self.params.alpha),
+      pull=tuple(self._pull_last),
+    )
+
+  def on_heartbeat(self, hb: Heartbeat, round_: int) -> None:
+    if self.alive:
+      self.cache.store(hb, round_)
+```
+
+Note: `sb_pass` is intentionally absent — Task 7 adds it. If a linter complains about the trailing comment, keep the comment; the class is extended in place by Task 7.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_routing.py tests/test_plasma_protocol.py -v`
+Expected: all PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/node.py tests/test_plasma_routing.py
+git commit -m "add PlasmaNode layer A window behavior"
+```
+
+---
+
+### Task 7: PlasmaNode, Layer B integration (sb_pass, hysteresis, randomized commit)
+
+**Files:**
+- Modify: `plasma/core/node.py` (add methods to `PlasmaNode`)
+- Test: `tests/test_plasma_sbm.py` (append)
+
+**Interfaces:**
+- Produces (methods on `PlasmaNode`):
+  - `init_replicas() -> None` — `r_init == "spread"`: round-robin add one replica per function while RAM allows; `"zero"`: all zeros.
+  - `sb_pass(round_: int) -> bool` — builds the local `HamiltonianContext`, runs `dsb_minimize`, decodes + `repair`s, applies hysteresis (`n_hyst` consecutive improving proposals of the SAME r_new, improvement margin `eps_commit * |H(r_prev)|`) then commits with probability `p_commit`. Returns True iff committed. Setting `p_commit = 1` disables the randomized-commit countermeasure (used by the phase-locked test).
+
+Locked-in details: `benefit = alpha * (demand_hat + pull_in)` with `pull_in` from the cache at `round_`; `margin = z_delta * sqrt(demand_hat)`; `A` auto-rule when `opts.A is None`: `A = 2 * max(benefit / ram_req)` (with floor 1.0); RAM feasibility re-checked exactly on commit via `repair`.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_sbm.py`)
+
+```python
+from plasma.core.node import NodeParams, PlasmaNode
+
+
+def _sb_node(p_commit=1.0, n_hyst=1, k_sb=1, ram_cap=8.0):
+  params = NodeParams(
+    node_id=0, nbrs=(), alpha=np.array([3.0, 1.0]),
+    gamma=np.array([0.1, 0.1]), beta=np.zeros((0, 2)),
+    u_max=np.array([5.0, 5.0]), ram_cap=ram_cap, ram_req=np.array([2.0, 2.0]),
+  )
+  opts = PlasmaOptions(p_commit=p_commit, n_hyst=n_hyst, k_sb=k_sb,
+                       n_sb_steps=200)
+  return PlasmaNode(params, opts, np.random.default_rng(1))
+
+
+def test_init_replicas_spread_fills_ram_round_robin():
+  node = _sb_node()
+  node.init_replicas()
+  assert (node.r * node.params.ram_req).sum() <= node.params.ram_cap
+  assert node.r.sum() == 4  # 8 RAM / 2 per replica
+
+
+def test_sb_pass_grows_replicas_under_demand():
+  node = _sb_node(n_hyst=1)
+  node.r = np.zeros(2, dtype=int)
+  node.demand_hat = np.array([8.0, 0.0])
+  committed = node.sb_pass(round_=0)
+  assert committed
+  assert node.r[0] >= 1
+  assert (node.r * node.params.ram_req).sum() <= node.params.ram_cap
+
+
+def test_hysteresis_requires_consecutive_confirmations():
+  node = _sb_node(n_hyst=2)
+  node.r = np.zeros(2, dtype=int)
+  node.demand_hat = np.array([8.0, 0.0])
+  assert node.sb_pass(round_=0) is False  # first proposal only counts
+  assert node.sb_pass(round_=1) is True   # second consecutive -> commit
+
+
+def test_p_commit_zero_never_commits():
+  node = _sb_node(p_commit=0.0, n_hyst=1)
+  node.demand_hat = np.array([8.0, 0.0])
+  for k in range(5):
+    assert node.sb_pass(round_=k) is False
+  assert node.r.sum() == 0
+
+
+def test_committed_r_is_always_ram_feasible():
+  node = _sb_node(n_hyst=1, ram_cap=4.0)
+  node.demand_hat = np.array([50.0, 50.0])  # wants far more than RAM allows
+  node.sb_pass(round_=0)
+  assert (node.r * node.params.ram_req).sum() <= 4.0
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_sbm.py -v`
+Expected: new tests FAIL with `AttributeError: 'PlasmaNode' object has no attribute 'init_replicas'`
+
+- [ ] **Step 3: Write the implementation** (append methods to `PlasmaNode` in `plasma/core/node.py`; add imports)
+
+```python
+# add to imports in plasma/core/node.py
+from plasma.core.sbm import (
+  HamiltonianContext, bits_per_fn, decode_spins, dsb_minimize, hamiltonian,
+  r_max_per_fn, repair,
+)
+
+# add inside class PlasmaNode:
+
+  # ---------------- Layer B ----------------
+
+  def init_replicas(self) -> None:
+    if self.opts.r_init == "zero":
+      return
+    used = 0.0
+    while True:
+      progress = False
+      for f in range(self.Nf):
+        if used + self.params.ram_req[f] <= self.params.ram_cap:
+          self.r[f] += 1
+          used += self.params.ram_req[f]
+          progress = True
+      if not progress:
+        return
+
+  def _hamiltonian_ctx(self, round_: int) -> HamiltonianContext:
+    pull_in = self.cache.pull_in(round_, self.opts.staleness_rounds, self.Nf)
+    benefit = self.params.alpha * (self.demand_hat + pull_in)
+    A = self.opts.A
+    if A is None:
+      A = max(1.0, 2.0 * float((benefit / self.params.ram_req).max()))
+    return HamiltonianContext(
+      benefit=benefit, ram_req=self.params.ram_req,
+      ram_cap=self.params.ram_cap, demand_hat=self.demand_hat,
+      margin=self.opts.z_delta * np.sqrt(self.demand_hat),
+      u_max=self.params.u_max * self.opts.W, r_prev=self.r.copy(),
+      A=A, B=self.opts.B, C=self.opts.C, switch_cost=self.opts.switch_cost,
+    )
+
+  def sb_pass(self, round_: int) -> bool:
+    if not self.alive:
+      return False
+    ctx = self._hamiltonian_ctx(round_)
+    r_max = r_max_per_fn(self.params.ram_cap, self.params.ram_req)
+    bits = bits_per_fn(r_max)
+    n_spins = int(bits.sum())
+    if n_spins == 0:
+      return False
+
+    def H(s: np.ndarray) -> float:
+      return hamiltonian(decode_spins(s, bits, r_max), ctx)
+
+    s = dsb_minimize(H, n_spins, self.opts, self.rng)
+    r_new = repair(
+      decode_spins(s, bits, r_max), ctx.benefit, self.params.ram_req,
+      self.params.ram_cap,
+    )
+    h_prev = hamiltonian(self.r, ctx)
+    h_new = hamiltonian(r_new, ctx)
+    improving = h_new < h_prev - self.opts.eps_commit * abs(h_prev)
+    if not improving or (self._pending is not None
+                         and not np.array_equal(r_new, self._pending)):
+      self._pending, self._streak = None, 0
+      return False
+    self._pending = r_new
+    self._streak += 1
+    if self._streak < self.opts.n_hyst:
+      return False
+    self._pending, self._streak = None, 0
+    # randomized commit: the mandatory Jacobi-oscillation countermeasure
+    # under the shared barrier (p_commit = 1 disables it, deliberately)
+    if self.rng.random() >= self.opts.p_commit:
+      return False
+    self.r = r_new
+    return True
+```
+
+Also add to `__init__` (before `self.begin_window()`):
+
+```python
+    self._pending = None
+    self._streak = 0
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_sbm.py tests/test_plasma_routing.py -v`
+Expected: all PASS (tune `n_sb_steps`/`sb_c0` in the test fixture only if `test_sb_pass_grows_replicas_under_demand` flakes; keep seeds fixed)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/core/node.py tests/test_plasma_sbm.py
+git commit -m "add PlasmaNode layer B pass with hysteresis and randomized commit"
+```
+
+---
+
+### Task 8: Engine — `plasma/engine.py`
+
+**Files:**
+- Create: `plasma/engine.py`
+- Test: `tests/test_plasma_clock.py` (append) and `tests/test_plasma_protocol.py` (message budget)
+
+**Interfaces:**
+- Consumes: `PlasmaNode`, `RoundClock`, `encode_heartbeat`/`decode_heartbeat`, `PlasmaOptions`.
+- Produces:
+
+```python
+class PlasmaEngine:
+  def __init__(self, nodes: list, opts: PlasmaOptions, rng): ...
+  clock: RoundClock
+  msg_count: int          # heartbeats sent + forwards attempted (data plane)
+  hb_count: int           # heartbeats sent only
+  def set_alive(self, i: int, alive: bool) -> None
+  def run_rounds(self, n_rounds: int, arrivals: np.ndarray) -> StepResult
+  # arrivals: (Nn, Nf) integer external arrivals per round (constant here)
+
+@dataclass
+class StepResult:      # aggregates of the LAST round's window (rates, W=1s)
+  x: np.ndarray        # (Nn, Nf)
+  z: np.ndarray        # (Nn, Nf)
+  y: np.ndarray        # (Nn, Nn, Nf)  ACKed forwards, sender-major
+  xi: np.ndarray       # (Nn, Nn, Nf)  xi[n2, n1, f] = y[n1, n2, f]
+  r: np.ndarray        # (Nn, Nf)
+```
+
+Per-round order (the round barrier): (1) clock delivers due heartbeats to their targets, (2) every alive node routes its external arrivals — forwards resolved synchronously: `ok = nodes[j].admit_forward(f)`, then `record_forward_result`; dead-node arrivals are dropped (not routed, not counted), (3) `end_window()` on every alive node, heartbeats scheduled for `round + hb_latency_rounds` per neighbor, each independently lost with probability `hb_loss`, (4) if `k_sb > 0` and `(round+1) % k_sb == 0`: `sb_pass(round)` on every alive node. Heartbeats cross the "wire" as dicts (`encode_heartbeat` → `decode_heartbeat`) so the whitelist is enforced on every message.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_clock.py`)
+
+```python
+import numpy as np
+
+from plasma.core.node import NodeParams, PlasmaNode
+from plasma.core.types import PlasmaOptions
+from plasma.engine import PlasmaEngine
+
+
+def _line_engine(Nn=2, Nf=1, opts=None, seed=0, u_max=5.0, ram_cap=8.0):
+  opts = opts or PlasmaOptions(k_sb=0)
+  rng = np.random.default_rng(seed)
+  nodes = []
+  for i in range(Nn):
+    nbrs = tuple(j for j in (i - 1, i + 1) if 0 <= j < Nn)
+    params = NodeParams(
+      node_id=i, nbrs=nbrs, alpha=np.full(Nf, 2.0), gamma=np.full(Nf, 0.1),
+      beta=np.full((len(nbrs), Nf), 1.5), u_max=np.full(Nf, u_max),
+      ram_cap=ram_cap, ram_req=np.full(Nf, 2.0),
+    )
+    node = PlasmaNode(params, opts, np.random.default_rng(seed + i))
+    node.init_replicas()
+    nodes.append(node)
+  return PlasmaEngine(nodes, opts, rng), nodes
+
+
+def test_traffic_conservation_every_round():
+  engine, _ = _line_engine()
+  arrivals = np.array([[8], [8]])
+  res = engine.run_rounds(5, arrivals)
+  total = res.x + res.z + res.y.sum(axis=1)
+  np.testing.assert_allclose(total, arrivals.astype(float))
+
+
+def test_xi_transposes_y():
+  engine, _ = _line_engine()
+  res = engine.run_rounds(5, np.array([[20], [0]]))
+  np.testing.assert_allclose(res.xi[1, 0, :], res.y[0, 1, :])
+
+
+def test_dead_node_traffic_redistributes():
+  # 3-node line, kill the middle node: node 0 must stop forwarding to it
+  opts = PlasmaOptions(k_sb=0)
+  engine, nodes = _line_engine(Nn=3, opts=opts)
+  engine.run_rounds(5, np.array([[20], [0], [0]]))
+  engine.set_alive(1, False)
+  res = engine.run_rounds(10 * opts.staleness_rounds, np.array([[20], [0], [0]]))
+  assert res.y[0, 1, 0] == 0.0  # nothing ACKed by a dead node
+  # conductance toward the dead neighbor decayed to the floor
+  col = 2 + nodes[0].params.nbrs.index(1)
+  assert nodes[0].D[0, col] <= opts.D_min * 1.01
+
+
+def test_phase_locked_commit_thrash_vs_randomized():
+  # adversarial: 2-node line, shared demand pulse, SB every round
+  def run(p_commit):
+    opts = PlasmaOptions(k_sb=1, n_hyst=1, p_commit=p_commit, n_sb_steps=150)
+    engine, nodes = _line_engine(Nn=2, opts=opts, seed=3, ram_cap=4.0)
+    flips = 0
+    prev = [n.r.copy() for n in nodes]
+    for _ in range(20):
+      engine.run_rounds(1, np.array([[12], [12]]))
+      for k, n in enumerate(nodes):
+        if not np.array_equal(prev[k], n.r):
+          flips += 1
+        prev[k] = n.r.copy()
+    return flips
+
+  thrash = run(p_commit=1.0)
+  calm = run(p_commit=0.5)
+  assert calm <= thrash
+
+
+def test_settles_within_20_slow_ticks_with_default_p_commit():
+  opts = PlasmaOptions(k_sb=1, n_hyst=2, p_commit=0.5, n_sb_steps=150)
+  engine, nodes = _line_engine(Nn=2, opts=opts, seed=3, ram_cap=4.0)
+  last_change = 0
+  prev = [n.r.copy() for n in nodes]
+  for tick in range(1, 21):
+    engine.run_rounds(1, np.array([[12], [12]]))
+    for k, n in enumerate(nodes):
+      if not np.array_equal(prev[k], n.r):
+        last_change = tick
+        prev[k] = n.r.copy()
+  assert last_change < 20
+```
+
+And append to `tests/test_plasma_protocol.py`:
+
+```python
+from plasma.engine import PlasmaEngine  # noqa: F401 (import checks packaging)
+
+
+def test_message_budget_heartbeats_bounded_by_degree():
+  from plasma.core.node import NodeParams, PlasmaNode
+  from plasma.core.types import PlasmaOptions
+  opts = PlasmaOptions(k_sb=0, hb_loss=0.0)
+  rng = np.random.default_rng(0)
+  params0 = NodeParams(node_id=0, nbrs=(1,), alpha=np.ones(1),
+                       gamma=np.ones(1), beta=np.ones((1, 1)),
+                       u_max=np.ones(1), ram_cap=4.0, ram_req=np.ones(1))
+  params1 = NodeParams(node_id=1, nbrs=(0,), alpha=np.ones(1),
+                       gamma=np.ones(1), beta=np.ones((1, 1)),
+                       u_max=np.ones(1), ram_cap=4.0, ram_req=np.ones(1))
+  nodes = [PlasmaNode(params0, opts, np.random.default_rng(1)),
+           PlasmaNode(params1, opts, np.random.default_rng(2))]
+  engine = PlasmaEngine(nodes, opts, rng)
+  engine.run_rounds(10, np.zeros((2, 1), dtype=int))
+  # exactly deg(i) heartbeats per node per round, no hidden channels
+  assert engine.hb_count == 10 * 2 * 1
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_clock.py tests/test_plasma_protocol.py -v`
+Expected: new tests FAIL with `ModuleNotFoundError: No module named 'plasma.engine'`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/engine.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+
+from plasma.core.node import PlasmaNode
+from plasma.core.protocol import decode_heartbeat, encode_heartbeat
+from plasma.core.types import LOCAL, REJ, PlasmaOptions
+from plasma.sim.clock import RoundClock
+
+
+@dataclass
+class StepResult:
+  x: np.ndarray
+  z: np.ndarray
+  y: np.ndarray
+  xi: np.ndarray
+  r: np.ndarray
+
+
+class PlasmaEngine:
+  def __init__(
+      self, nodes: List[PlasmaNode], opts: PlasmaOptions,
+      rng: np.random.Generator
+    ) -> None:
+    self.nodes = nodes
+    self.opts = opts
+    self.rng = rng
+    self.clock = RoundClock()
+    self.msg_count = 0
+    self.hb_count = 0
+
+  def set_alive(self, i: int, alive: bool) -> None:
+    self.nodes[i].alive = alive
+
+  def _route_all(self, round_: int, arrivals: np.ndarray) -> None:
+    for i, node in enumerate(self.nodes):
+      if not node.alive:
+        continue
+      for f in range(node.Nf):
+        for _ in range(int(arrivals[i, f])):
+          col = node.route_request(f, round_)
+          if col >= 2:
+            j = node.params.nbrs[col - 2]
+            self.msg_count += 1
+            accepted = self.nodes[j].admit_forward(f)
+            node.record_forward_result(f, col, accepted)
+
+  def _send_heartbeats(self, round_: int) -> None:
+    for node in self.nodes:
+      if not node.alive:
+        continue
+      hb = node.make_heartbeat()
+      wire = encode_heartbeat(hb)
+      for j in node.params.nbrs:
+        self.hb_count += 1
+        self.msg_count += 1
+        if self.rng.random() < self.opts.hb_loss:
+          continue
+        target = self.nodes[j]
+        self.clock.schedule(
+          round_ + self.opts.hb_latency_rounds,
+          lambda t=target, w=wire, r=round_ + self.opts.hb_latency_rounds:
+            t.on_heartbeat(decode_heartbeat(w), r),
+        )
+
+  def run_rounds(self, n_rounds: int, arrivals: np.ndarray) -> StepResult:
+    Nn = len(self.nodes)
+    Nf = self.nodes[0].Nf
+    last = {}
+
+    def on_round(round_: int) -> None:
+      self._route_all(round_, arrivals)
+      x = np.zeros((Nn, Nf))
+      z = np.zeros((Nn, Nf))
+      y = np.zeros((Nn, Nn, Nf))
+      for i, node in enumerate(self.nodes):
+        if not node.alive:
+          continue
+        counts = node.end_window()
+        x[i] = counts.x
+        z[i] = counts.z
+        for k, j in enumerate(node.params.nbrs):
+          y[i, j, :] = counts.y[k]
+      last["x"], last["z"], last["y"] = x, z, y
+      self._send_heartbeats(round_)
+      if self.opts.k_sb > 0 and (round_ + 1) % self.opts.k_sb == 0:
+        for node in self.nodes:
+          node.sb_pass(round_)
+
+    self.clock.run(n_rounds, on_round)
+    xi = np.transpose(last["y"], (1, 0, 2))
+    r = np.array([node.r for node in self.nodes])
+    return StepResult(x=last["x"], z=last["z"], y=last["y"], xi=xi, r=r)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_clock.py tests/test_plasma_protocol.py -v`
+Expected: all PASS. The two commit-behavior tests are statistical: keep the fixed seeds; if a seed is unlucky, change the SEED in the test, never the assertion.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/engine.py tests/test_plasma_clock.py tests/test_plasma_protocol.py
+git commit -m "add plasma engine with round barrier, forwarding and heartbeats"
+```
+
+---
+
+### Task 9: Runner and CLI — `plasma/runner.py`, `plasma/cli.py`
+
+**Files:**
+- Create: `plasma/runner.py`, `plasma/cli.py`
+- Test: `tests/test_plasma_e2e.py`
+
+**Interfaces:**
+- Consumes: `init_problem`, `get_current_load`, `update_data`, `init_complete_solution`, `decode_solution`, `join_complete_solution`, `save_solution`, `save_checkpoint`, `check_feasibility`, `compute_centralized_objective`, `load_configuration` (see "Repo interfaces" table above), plus `PlasmaEngine`.
+- Produces: `plasma.runner.run(config: dict, parallelism: int, log_on_file: bool = False, disable_plotting: bool = False) -> str` — same contract as `decentralized_gcaa.run`. Writes into a fresh timestamped folder: `config.json`, `LSPc_solution.csv`, `LSPc_offloaded.csv`, `LSPc_utilization.csv`, `LSPc_replicas.csv`, `LSPc_detailed_fwd_solution.csv`, `LSPc_residual_capacity.csv`, `obj.csv` (column `Plasma`), `runtime.csv`, `termination_condition.csv`, `plasma_messages.csv` (columns `t`, `msgs_per_node_s`, `hb_per_node_s`).
+
+Runner flow (mirrors `decentralized_gcaa.run` lines 106–328, minus the Pyomo solves):
+1. Read config: `base_solution_folder`, `seed`, `limits`, `trace_type` (from `limits["load"]`, default `"fixed_sum"`), `verbose`, `max_steps`, `min_run_time`, `max_run_time`, `run_time_step`, `checkpoint_interval`; `opts = PlasmaOptions.from_config(config)`.
+2. Create timestamped folder, dump config, optionally open `out.log`.
+3. `init_problem(limits, trace_type, max_steps, seed, solution_folder)`.
+4. Build `NodeParams` per node from `base_instance_data[None]` (0-based conversion; `beta[k] = beta[(i+1, nbrs[k]+1, f+1)]`; `u_max[f] = max_utilization[f+1] / demand[(i+1, f+1)]`), build `PlasmaNode`s (per-node rng: `np.random.default_rng(seed * 1000 + i)`), `init_replicas()`, build `PlasmaEngine` (engine rng: `np.random.default_rng(seed)`).
+5. For each `t` in `range(min_run_time, ub, run_time_step)` (ub logic identical to gcaa): `loadt = get_current_load(...)`; `data = update_data(base_instance_data, {"incoming_load": loadt})`; `arrivals[i, f] = round(loadt[(i+1, f+1)])`; `res = engine.run_rounds(opts.rounds_per_step, arrivals)`.
+6. Per step: scale the last-window counts back to the true load so `check_feasibility`'s traffic-conservation holds exactly against `loadt` (arrivals are already the integer load; assert `x + y.sum(axis=1) + z == arrivals` and pass through). Compute `U[n, f] = demand[(n+1, f+1)] * (x + xi.sum(axis=1))[n, f] / r[n, f]` where `r > 0` else 0; `rho[n] = ram_cap[n] - sum_f r[n, f] * ram_req[f]`. Call `check_feasibility(x, y.sum(axis=1), z, r, U, data)` and raise on failure. Accumulate `decode_solution(x, y, z, r, xi, rho, U, cs)`; append `compute_centralized_objective(data, x, y, z)` to `obj_list`; append wall-clock to `runtime_list`; append messages row; `save_checkpoint(cs, os.path.join(folder, "LSPc"), t)` on `checkpoint_interval`.
+7. After the loop: `join_complete_solution`, `save_solution(..., "LSPc", folder)`, write `obj.csv` (`pd.DataFrame(obj_list, columns=["Plasma"])`), `termination_condition.csv` (one row per step: `f"rounds: {opts.rounds_per_step}"`), `runtime.csv`, `plasma_messages.csv`. Return folder.
+
+`plasma/cli.py`: argparse entry mirroring `decentralized_gcaa.parse_arguments` (flags `-c/--config`, `-j/--parallelism`, `--disable_plotting`) with `if __name__ == "__main__": run(load_configuration(args.config), args.parallelism, disable_plotting=args.disable_plotting)`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_e2e.py
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from plasma.runner import run as run_plasma
+
+
+def _config(tmp_path, Nn=3, max_steps=3):
+  return {
+    "base_solution_folder": str(tmp_path),
+    "verbose": 0,
+    "seed": 42,
+    "max_steps": max_steps,
+    "min_run_time": 0,
+    "max_run_time": max_steps - 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "solver_name": "none",
+    "solver_options": {
+      "plasma": {"rounds_per_step": 5, "k_sb": 2, "n_sb_steps": 100,
+                 "n_hyst": 1}
+    },
+    "limits": {
+      "Nn": {"values": [Nn]},
+      "Nf": {"min": 2, "max": 2},
+      "neighborhood": {"m": Nn - 1},   # a line/tree on 3 nodes
+      "demand": {"values": [1.0, 1.2]},
+      "memory_capacity": {"min": 12, "max": 12},
+      "memory_requirement": {"values": [2, 3]},
+      "max_utilization": {"min": 0.65, "max": 0.75},
+      "load": {"trace_type": "sinusoidal",
+               "min": {"min": 5, "max": 10},
+               "max": {"min": 20, "max": 30}},
+      "weights": {"alpha": {"min": 1.0, "max": 1.5},
+                  "beta_multiplier": {"min": 1.5, "max": 2.5},
+                  "gamma": {"min": 0.05, "max": 0.15},
+                  "delta_multiplier": {"min": 0.1, "max": 0.2}},
+    },
+  }
+
+
+def test_runner_produces_lspc_artifacts(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  for name in ("LSPc_solution.csv", "LSPc_offloaded.csv",
+               "LSPc_utilization.csv", "LSPc_replicas.csv",
+               "LSPc_detailed_fwd_solution.csv",
+               "LSPc_residual_capacity.csv", "obj.csv", "runtime.csv",
+               "termination_condition.csv", "plasma_messages.csv",
+               "config.json"):
+    assert os.path.exists(os.path.join(folder, name)), name
+
+
+def test_runner_objective_column_is_plasma(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  obj = pd.read_csv(os.path.join(folder, "obj.csv"))
+  assert list(obj.columns) == ["Plasma"]
+  assert len(obj) == 3
+
+
+def test_runner_is_deterministic_given_seed(tmp_path):
+  f1 = run_plasma(_config(tmp_path / "a"), parallelism=0)
+  f2 = run_plasma(_config(tmp_path / "b"), parallelism=0)
+  o1 = pd.read_csv(os.path.join(f1, "obj.csv"))
+  o2 = pd.read_csv(os.path.join(f2, "obj.csv"))
+  pd.testing.assert_frame_equal(o1, o2)
+
+
+def test_runner_messages_bounded(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  msgs = pd.read_csv(os.path.join(folder, "plasma_messages.csv"))
+  assert (msgs["hb_per_node_s"] <= 2.0 + 1e-9).all()  # deg <= 2 on a tree of 3
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_e2e.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'plasma.runner'`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/runner.py
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+
+from run_centralized_model import (
+  init_complete_solution, init_problem, decode_solution,
+  join_complete_solution, save_checkpoint, save_solution,
+)
+from generators.generate_data import update_data
+from utils.centralized import check_feasibility, get_current_load
+from utils.faasmacro import compute_centralized_objective
+
+from plasma.core.node import NodeParams, PlasmaNode
+from plasma.core.types import PlasmaOptions
+from plasma.engine import PlasmaEngine
+
+
+def build_nodes(base_instance_data: dict, opts: PlasmaOptions, seed: int):
+  d = base_instance_data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  nodes = []
+  for i in range(Nn):
+    nbrs = tuple(
+      j for j in range(Nn) if j != i and d["neighborhood"][(i + 1, j + 1)]
+    )
+    alpha = np.array([d["alpha"][(i + 1, f + 1)] for f in range(Nf)])
+    gamma = np.array([d["gamma"][(i + 1, f + 1)] for f in range(Nf)])
+    beta = np.array([
+      [d["beta"][(i + 1, j + 1, f + 1)] for f in range(Nf)] for j in nbrs
+    ]).reshape(len(nbrs), Nf)
+    u_max = np.array([
+      d["max_utilization"][f + 1] / d["demand"][(i + 1, f + 1)]
+      for f in range(Nf)
+    ])
+    params = NodeParams(
+      node_id=i, nbrs=nbrs, alpha=alpha, gamma=gamma, beta=beta,
+      u_max=u_max, ram_cap=float(d["memory_capacity"][i + 1]),
+      ram_req=np.array([d["memory_requirement"][f + 1] for f in range(Nf)]),
+    )
+    node = PlasmaNode(params, opts, np.random.default_rng(seed * 1000 + i))
+    node.init_replicas()
+    nodes.append(node)
+  return nodes
+
+
+def run(
+    config: dict, parallelism: int, log_on_file: bool = False,
+    disable_plotting: bool = False
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = limits["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  opts = PlasmaOptions.from_config(config)
+  now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  d = base_instance_data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  nodes = build_nodes(base_instance_data, opts, seed)
+  engine = PlasmaEngine(nodes, opts, np.random.default_rng(seed))
+  ram_cap = np.array([d["memory_capacity"][n + 1] for n in range(Nn)])
+  ram_req = np.array([d["memory_requirement"][f + 1] for f in range(Nf)])
+  demand = np.array([
+    [d["demand"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  cs = init_complete_solution()
+  obj_list = []
+  runtime_list = []
+  msg_rows = []
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    arrivals = np.array([
+      [int(round(loadt[(n + 1, f + 1)])) for f in range(Nf)]
+      for n in range(Nn)
+    ])
+    data = update_data(data, {"incoming_load": {
+      (n + 1, f + 1): arrivals[n, f] for n in range(Nn) for f in range(Nf)
+    }})
+    msgs_before, hb_before = engine.msg_count, engine.hb_count
+    started = datetime.now()
+    res = engine.run_rounds(opts.rounds_per_step, arrivals)
+    elapsed = (datetime.now() - started).total_seconds()
+    omega = res.y.sum(axis=1)
+    with np.errstate(divide="ignore", invalid="ignore"):
+      U = np.where(
+        res.r > 0,
+        demand * (res.x + res.xi.sum(axis=1)) / np.maximum(res.r, 1),
+        0.0,
+      )
+    rho = ram_cap - (res.r * ram_req[None, :]).sum(axis=1)
+    feasible, why = check_feasibility(res.x, omega, res.z, res.r, U, data)
+    assert feasible, why
+    cs = decode_solution(res.x, res.y, res.z, res.r, res.xi, rho, U, cs)
+    obj_list.append(compute_centralized_objective(data, res.x, res.y, res.z))
+    runtime_list.append(elapsed)
+    seconds = opts.rounds_per_step * opts.W
+    msg_rows.append({
+      "t": t,
+      "msgs_per_node_s": (engine.msg_count - msgs_before) / (Nn * seconds),
+      "hb_per_node_s": (engine.hb_count - hb_before) / (Nn * seconds),
+    })
+    if t % checkpoint_interval == 0 or t == max_steps - 1:
+      save_checkpoint(cs, os.path.join(solution_folder, "LSPc"), t)
+  solution, offloaded, detailed_fwd = join_complete_solution(cs)
+  save_solution(solution, offloaded, cs, detailed_fwd, "LSPc", solution_folder)
+  pd.DataFrame(obj_list, columns=["Plasma"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(
+    [f"rounds: {opts.rounds_per_step}"] * len(obj_list)
+  ).to_csv(os.path.join(solution_folder, "termination_condition.csv"))
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  pd.DataFrame(msg_rows).to_csv(
+    os.path.join(solution_folder, "plasma_messages.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream,
+          flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+```
+
+```python
+# plasma/cli.py
+from __future__ import annotations
+
+import argparse
+
+from utils.common import load_configuration
+
+from plasma.runner import run
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run PLASMA standalone (debugging entry point)",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument("-c", "--config", type=str, default="manual_config.json")
+  parser.add_argument("-j", "--parallelism", type=int, default=0)
+  parser.add_argument("--disable_plotting", default=False,
+                      action="store_true")
+  return parser.parse_known_args()[0]
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  run(
+    load_configuration(args.config), args.parallelism,
+    disable_plotting=args.disable_plotting,
+  )
+```
+
+Implementation notes:
+- `check_feasibility` requires exact traffic conservation against `data[None]["incoming_load"]`; that's why the runner overwrites `incoming_load` with the rounded integer `arrivals` before the check and objective (traces may be floats).
+- If a node dies mid-run (not exercised by the runner yet — engine API only), its dropped arrivals would break conservation; the runner never kills nodes, scenario tests drive the engine directly.
+- `parallelism` is accepted for signature compatibility and unused (single-process simulation) — keep the parameter, document with a comment.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_e2e.py -v`
+Expected: 4 PASS (each e2e test runs ~seconds)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/runner.py plasma/cli.py tests/test_plasma_e2e.py
+git commit -m "add plasma runner writing LSPc results and argparse cli"
+```
+
+---
+
+### Task 10: `run.py` registration + comparison config
+
+**Files:**
+- Modify: `run.py` (7 additive touch points, no existing line changed)
+- Create: `config_files/plasma_comparison.json`
+- Test: `tests/test_plasma_e2e.py` (append wiring tests)
+
+**IMPORTANT (project rule):** before editing, run `gitnexus_impact({target: "parse_arguments", direction: "upstream"})` and `gitnexus_impact({target: "results_postprocessing", direction: "upstream"})`; report blast radius. After editing, `gitnexus_detect_changes()` must show only `run.py` + new files.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_e2e.py`)
+
+```python
+import run as run_module
+
+
+def test_methods_choice_accepts_plasma(monkeypatch):
+  argv = ["run.py", "-c", "config_files/plasma_comparison.json",
+          "--methods", "plasma"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run_module.parse_arguments()
+  assert "plasma" in args.methods
+
+
+def test_run_module_exposes_plasma_runner():
+  assert callable(run_module.run_plasma)
+
+
+def test_method_result_models_has_plasma_entry():
+  assert run_module.METHOD_RESULT_MODELS["plasma"] == ("LSPc", "Plasma")
+
+
+def test_plasma_comparison_config_exists_and_has_section():
+  config = json.loads(
+    Path("config_files/plasma_comparison.json").read_text()
+  )
+  assert "plasma" in config["solver_options"]
+
+
+def test_set_solution_folder_tolerates_missing_plasma_key():
+  solution_folders = {"experiments_list": []}
+  run_module.set_solution_folder(solution_folders, "plasma", 0, "/x")
+  assert solution_folders["plasma"][0] == "/x"
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_e2e.py -v`
+Expected: new tests FAIL (`AttributeError: module 'run' has no attribute 'run_plasma'`, missing choice, missing config file)
+
+- [ ] **Step 3: Edit `run.py` — 7 additive touch points**
+
+1. Imports (after line 12 `from decentralized_gcaa import run as run_gcaa`):
+```python
+from plasma.runner import run as run_plasma
+```
+2. `METHOD_RESULT_MODELS` (after the `"faas-gcaa"` entry, ~line 45):
+```python
+  "plasma": ("LSPc", "Plasma"),
+```
+3. `--methods` choices list (after `"faas-gcaaa"`... exactly after `"faas-gcaa",`, before `"generate_only"`):
+```python
+      "plasma",
+```
+4. `solution_folders` initial dict (~line 901, add key):
+```python
+    "plasma": [],
+```
+5. Run-flag init (next to `run_g = False`, ~line 934):
+```python
+    run_pl = False # -- plasma (Plasma)
+```
+6. Skip/resume logic (after the `faas-gcaa` block, ~line 1024) and the `except ValueError` fallback (after `run_g = ...`) and the big `if run_c or ...` condition — add `run_pl` to all three:
+```python
+      if (not generate_only and "plasma" in methods) and ((
+          len(solution_folders.get("plasma", [])) <= experiment_idx
+        ) or (
+          solution_folders["plasma"][experiment_idx] is None
+        )):
+        run_pl = True
+```
+```python
+      run_pl = "plasma" in methods
+```
+and extend the condition: `... or run_g or run_pl or generate_only:`
+7. Invocation (after the `if run_g:` block, ~line 1228):
+```python
+      # -- solve PLASMA (Physarum + simulated bifurcation)
+      if run_pl:
+        pl_folder = run_plasma(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "plasma", experiment_idx, pl_folder
+        )
+```
+
+Create `config_files/plasma_comparison.json` — copy of `config_files/eval_smoke.json` with: `"base_solution_folder": "solutions/plasma_comparison"`, and this block added inside `"solver_options"`:
+```json
+    "plasma": {
+      "rounds_per_step": 20,
+      "k_sb": 10,
+      "mu": 0.1,
+      "n_sb_steps": 300,
+      "p_commit": 0.5,
+      "n_hyst": 2
+    }
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_e2e.py tests/test_gcaa_wiring.py -v`
+Expected: all PASS (gcaa wiring must stay green — proves the edit was additive)
+
+- [ ] **Step 5: Smoke the real pipeline**
+
+Run: `uv run python run.py -c config_files/plasma_comparison.json --methods plasma --n_experiments 1 2>&1 | tail -5`
+Expected: completes without traceback; a `solutions/plasma_comparison/...` folder with LSPc files exists. Delete the produced `solutions/plasma_comparison/` folder afterwards (scratch output).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add run.py config_files/plasma_comparison.json tests/test_plasma_e2e.py
+git commit -m "register plasma method in run.py dispatch"
+```
+
+---
+
+### Task 11: Baselines — `plasma/baselines/`
+
+**Files:**
+- Create: `plasma/baselines/__init__.py`, `plasma/baselines/milp_baseline.py`, `plasma/baselines/greedy_baseline.py`, `plasma/baselines/madea_iface.py`
+- Test: `tests/test_plasma_baselines.py`
+
+**Interfaces:**
+- Produces:
+  - `milp_baseline.solve_snapshot(data, solver_name, solver_options) -> (x, y, z, r, obj)` — one MILP solve on the current `incoming_load` via `solve_instance(LoadManagementModel(), ...)`.
+  - `milp_baseline.routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency) -> (obj, x, y, z)` — LP-optimal routing with FIXED replicas via `scipy.optimize.linprog` (Layer-A reference; per-load-normalized objective like `compute_centralized_objective`). Shapes: `lam, x, z: (Nn, Nf)`, `y: (Nn, Nn, Nf)`, `r, u_max: (Nn, Nf)`, `alpha, gamma: (Nn, Nf)`, `beta: (Nn, Nn, Nf)`, `adjacency: (Nn, Nn)` 0/1.
+  - `milp_baseline.stale_objectives(base_instance_data, traces, agents, t_range, solver_name, solver_options, resolve_every) -> list[float]` — re-solve every `resolve_every` steps on the load observed at the re-solve instant, hold the allocation in between, score each step's held solution on the TRUE load via `compute_centralized_objective` (rejections absorb the mismatch: `z = load - x - y_sent`, clipped at 0, and `x` scaled down if load dropped below the held `x + y`).
+  - `greedy_baseline.solve(data, solver_options) -> (x, y, z, r)` — non-coordinated greedy: per node fill RAM greedily by `alpha * load` order, `x = min(load, r * u_max)` (with `u_max = max_utilization/demand`), `omega_bar = load - x`; then delegate cross-node distribution to `heuristic_coordinator.GreedyCoordinator().solve(instance, solver_options)` and convert its `y, z, r` output; anything GreedyCoordinator leaves unassigned is rejection.
+  - `madea_iface.run_madea = run_faasmadea.run` (re-export with a docstring; the comparison plug per design §1.2).
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_plasma_baselines.py
+import numpy as np
+import pytest
+
+from plasma.baselines.milp_baseline import routing_lp
+from plasma.baselines import madea_iface
+
+
+def test_routing_lp_prefers_local_when_capacity_allows():
+  lam = np.array([[10.0]])
+  r = np.array([[5]])
+  u_max = np.array([[4.0]])
+  alpha = np.array([[2.0]])
+  beta = np.zeros((1, 1, 1))
+  gamma = np.array([[1.0]])
+  adjacency = np.zeros((1, 1))
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert x[0, 0] == pytest.approx(10.0)
+  assert z[0, 0] == pytest.approx(0.0)
+  assert obj == pytest.approx(2.0)  # alpha * x / lam
+
+
+def test_routing_lp_offloads_overflow_to_neighbor():
+  lam = np.array([[10.0], [0.0]])
+  r = np.array([[1], [5]])
+  u_max = np.array([[4.0], [4.0]])
+  alpha = np.full((2, 1), 2.0)
+  beta = np.zeros((2, 2, 1)); beta[0, 1, 0] = 1.5
+  gamma = np.full((2, 1), 5.0)
+  adjacency = np.array([[0, 1], [1, 0]])
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert x[0, 0] == pytest.approx(4.0)
+  assert y[0, 1, 0] == pytest.approx(6.0)
+  assert z[0, 0] == pytest.approx(0.0)
+
+
+def test_routing_lp_respects_receiver_capacity():
+  lam = np.array([[10.0], [0.0]])
+  r = np.array([[0], [1]])
+  u_max = np.array([[4.0], [4.0]])
+  alpha = np.full((2, 1), 2.0)
+  beta = np.zeros((2, 2, 1)); beta[0, 1, 0] = 1.5
+  gamma = np.full((2, 1), 0.1)
+  adjacency = np.array([[0, 1], [1, 0]])
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert y[0, 1, 0] == pytest.approx(4.0)
+  assert z[0, 0] == pytest.approx(6.0)
+
+
+def test_madea_iface_reexports_runner():
+  import run_faasmadea
+  assert madea_iface.run_madea is run_faasmadea.run
+
+
+def test_greedy_baseline_conserves_traffic():
+  from plasma.baselines.greedy_baseline import solve
+  data = _tiny_instance()
+  x, y, z, r = solve(data, {})
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  for n in range(Nn):
+    for f in range(Nf):
+      load = data[None]["incoming_load"][(n + 1, f + 1)]
+      assert x[n, f] + y[n, :, f].sum() + z[n, f] == pytest.approx(load)
+
+
+def _tiny_instance():
+  Nn, Nf = 2, 1
+  return {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "neighborhood": {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+    "alpha": {(1, 1): 2.0, (2, 1): 2.0},
+    "beta": {(1, 1, 1): 0.0, (1, 2, 1): 1.5, (2, 1, 1): 1.5, (2, 2, 1): 0.0},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.7},
+    "memory_capacity": {1: 4, 2: 4},
+    "memory_requirement": {1: 2},
+    "incoming_load": {(1, 1): 10, (2, 1): 1},
+  }}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_baselines.py -v`
+Expected: FAIL with `ModuleNotFoundError`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/baselines/__init__.py  (empty file)
+
+# plasma/baselines/madea_iface.py
+"""Adapter so FaaS-MADeA plugs into PLASMA comparisons (design doc S1.2)."""
+from run_faasmadea import run as run_madea  # noqa: F401
+```
+
+```python
+# plasma/baselines/milp_baseline.py
+from __future__ import annotations
+
+from typing import List, Tuple
+
+import numpy as np
+from scipy.optimize import linprog
+
+from generators.generate_data import update_data
+from models.model import LoadManagementModel
+from run_centralized_model import solve_instance
+from utils.centralized import get_current_load
+from utils.faasmacro import compute_centralized_objective
+
+
+def solve_snapshot(data: dict, solver_name: str, solver_options: dict):
+  x, y, z, r, xi, omega, rho, U, obj, runtime, tc = solve_instance(
+    LoadManagementModel(), data, solver_name, solver_options
+  )
+  return x, y, z, r, obj
+
+
+def routing_lp(
+    lam: np.ndarray, r: np.ndarray, u_max: np.ndarray, alpha: np.ndarray,
+    beta: np.ndarray, gamma: np.ndarray, adjacency: np.ndarray
+  ) -> Tuple[float, np.ndarray, np.ndarray, np.ndarray]:
+  """LP-optimal routing with fixed replicas: the Layer-A reference optimum.
+  Variables per (n, f): x, z; per edge (n1, n2, f): y. Objective matches
+  compute_centralized_objective (per-load-normalized)."""
+  Nn, Nf = lam.shape
+  # variable order: x (Nn*Nf), z (Nn*Nf), y (Nn*Nn*Nf)
+  nx = Nn * Nf
+  ny = Nn * Nn * Nf
+  def ix(n, f): return n * Nf + f
+  def iz(n, f): return nx + n * Nf + f
+  def iy(n1, n2, f): return 2 * nx + (n1 * Nn + n2) * Nf + f
+  c = np.zeros(2 * nx + ny)
+  for n in range(Nn):
+    for f in range(Nf):
+      scale = max(lam[n, f], 1e-12)
+      c[ix(n, f)] = -alpha[n, f] / scale
+      c[iz(n, f)] = gamma[n, f] / scale
+      for m in range(Nn):
+        c[iy(n, m, f)] = -beta[n, m, f] / scale
+  A_eq, b_eq = [], []
+  for n in range(Nn):
+    for f in range(Nf):
+      row = np.zeros(2 * nx + ny)
+      row[ix(n, f)] = 1.0
+      row[iz(n, f)] = 1.0
+      for m in range(Nn):
+        row[iy(n, m, f)] = 1.0
+      A_eq.append(row)
+      b_eq.append(lam[n, f])
+  A_ub, b_ub = [], []
+  for n in range(Nn):
+    for f in range(Nf):
+      row = np.zeros(2 * nx + ny)
+      row[ix(n, f)] = 1.0
+      for m in range(Nn):
+        row[iy(m, n, f)] = 1.0
+      A_ub.append(row)
+      b_ub.append(r[n, f] * u_max[n, f])
+  bounds = [(0, None)] * (2 * nx) + [
+    (0, None if adjacency[n1, n2] else 0)
+    for n1 in range(Nn) for n2 in range(Nn) for _ in range(Nf)
+  ]
+  res = linprog(c, A_ub=np.array(A_ub), b_ub=np.array(b_ub),
+                A_eq=np.array(A_eq), b_eq=np.array(b_eq), bounds=bounds,
+                method="highs")
+  assert res.success, res.message
+  sol = res.x
+  x = sol[:nx].reshape(Nn, Nf)
+  z = sol[nx:2 * nx].reshape(Nn, Nf)
+  y = sol[2 * nx:].reshape(Nn, Nn, Nf)
+  return float(-res.fun), x, y, z
+
+
+def stale_objectives(
+    base_instance_data: dict, traces: dict, agents, t_range,
+    solver_name: str, solver_options: dict, resolve_every: int
+  ) -> List[float]:
+  """Centralized MILP re-solved every resolve_every steps on then-current
+  load, held in between, scored on the true load (staleness is the point)."""
+  held = None
+  objs = []
+  for k, t in enumerate(t_range):
+    loadt = get_current_load(traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    if held is None or k % resolve_every == 0:
+      x, y, z, r, _ = solve_snapshot(data, solver_name, solver_options)
+      held = (x, y)
+    x, y = held
+    lam = np.array([
+      [loadt[(n + 1, f + 1)] for f in range(x.shape[1])]
+      for n in range(x.shape[0])
+    ])
+    handled = x + y.sum(axis=1)
+    over = np.maximum(0.0, handled - lam)
+    x_eff = np.maximum(0.0, x - over)  # shed overflow from local first
+    z_eff = np.maximum(0.0, lam - x_eff - y.sum(axis=1))
+    objs.append(compute_centralized_objective(data, x_eff, y, z_eff))
+  return objs
+```
+
+```python
+# plasma/baselines/greedy_baseline.py
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Tuple
+
+import numpy as np
+
+from heuristic_coordinator import GreedyCoordinator
+
+
+def solve(data: dict, solver_options: dict) -> Tuple[np.ndarray, ...]:
+  """Local, non-coordinated greedy lower baseline: each node fills its own
+  RAM by alpha*load order and serves what it can; leftover offloading is
+  distributed by the existing GreedyCoordinator."""
+  d = data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  ram_cap = np.array([float(d["memory_capacity"][n + 1]) for n in range(Nn)])
+  ram_req = np.array([float(d["memory_requirement"][f + 1]) for f in range(Nf)])
+  lam = np.array([
+    [d["incoming_load"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  u_max = np.array([
+    [d["max_utilization"][f + 1] / d["demand"][(n + 1, f + 1)]
+     for f in range(Nf)] for n in range(Nn)
+  ])
+  alpha = np.array([
+    [d["alpha"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  r = np.zeros((Nn, Nf), dtype=int)
+  for n in range(Nn):
+    budget = ram_cap[n]
+    for f in sorted(range(Nf), key=lambda f: -alpha[n, f] * lam[n, f]):
+      while lam[n, f] > r[n, f] * u_max[n, f] and budget >= ram_req[f]:
+        r[n, f] += 1
+        budget -= ram_req[f]
+  x = np.minimum(lam, r * u_max)
+  omega = lam - x
+  instance = deepcopy(data)
+  instance[None]["omega_bar"] = {
+    (n + 1, f + 1): float(omega[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance[None]["x_bar"] = {
+    (n + 1, f + 1): float(x[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance[None]["r_bar"] = {
+    (n + 1, f + 1): int(r[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance["sp_rho"] = ram_cap - (r * ram_req[None, :]).sum(axis=1)
+  result = GreedyCoordinator().solve(instance, solver_options)
+  y = np.array(result["y"], dtype=float).reshape(Nn, Nn, Nf)
+  r_extra = np.array(result["r"], dtype=float).reshape(Nn, Nf)
+  z = omega - y.sum(axis=1)
+  return x, y, np.maximum(z, 0.0), r + r_extra.astype(int)
+```
+
+Note: inspect `GreedyCoordinator.solve`'s return dict once during implementation (`heuristic_coordinator.py:127` onward) — if the keys differ from `{"y", "z", "r"}` adapt the conversion, keep the `solve(data, solver_options) -> (x, y, z, r)` contract fixed.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_baselines.py -v`
+Expected: 6 PASS (`solve_snapshot`/`stale_objectives` need a Pyomo solver — they are exercised in Task 13 behind a solver-availability skip, not here)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/baselines tests/test_plasma_baselines.py
+git commit -m "add plasma baselines: milp snapshot, routing lp, greedy, madea iface"
+```
+
+---
+
+### Task 12: Evaluation metrics — `plasma/eval/regret.py`
+
+**Files:**
+- Create: `plasma/eval/__init__.py`, `plasma/eval/regret.py`
+- Test: `tests/test_plasma_baselines.py` (append — metrics consume baseline outputs)
+
+**Interfaces:**
+- Produces:
+  - `cumulative_regret(method_obj: np.ndarray, oracle_obj: np.ndarray) -> np.ndarray` — elementwise `cumsum(oracle - method)`.
+  - `adaptation_lag(times: np.ndarray, method_obj: np.ndarray, oracle_obj: np.ndarray, change_points: list, threshold: float = 0.1) -> list` — for each change point, seconds until `method >= (1 - threshold) * oracle` again (`np.nan` if never).
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_baselines.py`)
+
+```python
+from plasma.eval.regret import adaptation_lag, cumulative_regret
+
+
+def test_cumulative_regret():
+  method = np.array([1.0, 1.0, 2.0])
+  oracle = np.array([2.0, 2.0, 2.0])
+  assert cumulative_regret(method, oracle).tolist() == [1.0, 2.0, 2.0]
+
+
+def test_adaptation_lag_measures_recovery():
+  times = np.arange(6, dtype=float)
+  oracle = np.full(6, 10.0)
+  method = np.array([10.0, 10.0, 2.0, 5.0, 9.5, 9.8])  # change point at t=2
+  lag = adaptation_lag(times, method, oracle, change_points=[2.0])
+  assert lag == [2.0]  # recovered at t=4 (9.5 >= 9.0)
+
+
+def test_adaptation_lag_nan_when_never_recovering():
+  times = np.arange(3, dtype=float)
+  lag = adaptation_lag(times, np.zeros(3), np.full(3, 10.0),
+                       change_points=[0.0])
+  assert np.isnan(lag[0])
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_plasma_baselines.py -v`
+Expected: new tests FAIL with `ModuleNotFoundError`
+
+- [ ] **Step 3: Write the implementation**
+
+```python
+# plasma/eval/__init__.py  (empty file)
+
+# plasma/eval/regret.py
+from __future__ import annotations
+
+from typing import List
+
+import numpy as np
+
+
+def cumulative_regret(
+    method_obj: np.ndarray, oracle_obj: np.ndarray
+  ) -> np.ndarray:
+  return np.cumsum(np.asarray(oracle_obj) - np.asarray(method_obj))
+
+
+def adaptation_lag(
+    times: np.ndarray, method_obj: np.ndarray, oracle_obj: np.ndarray,
+    change_points: List[float], threshold: float = 0.1
+  ) -> List[float]:
+  times = np.asarray(times)
+  method_obj = np.asarray(method_obj)
+  oracle_obj = np.asarray(oracle_obj)
+  lags: List[float] = []
+  for cp in change_points:
+    after = times >= cp
+    recovered = after & (method_obj >= (1.0 - threshold) * oracle_obj)
+    idx = np.flatnonzero(recovered)
+    lags.append(float(times[idx[0]] - cp) if len(idx) else float("nan"))
+  return lags
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_plasma_baselines.py -v`
+Expected: all PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plasma/eval tests/test_plasma_baselines.py
+git commit -m "add plasma regret and adaptation-lag metrics"
+```
+
+---
+
+### Task 13: Acceptance tests — LP convergence, dead neighbor at scale, MILP gap
+
+These are the spec's remaining non-negotiable acceptance criteria, run against the finished stack. They are slower (~1–3 min total); mark each with `@pytest.mark.slow` only if the repo's pytest config defines that marker — otherwise leave unmarked (check `pyproject.toml`/`pytest.ini` first; currently no marker config exists, so leave unmarked).
+
+**Files:**
+- Test: `tests/test_plasma_routing.py` (LP convergence), `tests/test_plasma_e2e.py` (MILP gap, solver-gated)
+
+- [ ] **Step 1: Write the LP-convergence test** (append to `tests/test_plasma_routing.py`)
+
+```python
+from plasma.baselines.milp_baseline import routing_lp
+from plasma.engine import PlasmaEngine
+
+
+def test_physarum_converges_to_lp_routing_fractions():
+  # 2-node line, fixed replicas, stationary integer traffic (lambda = 40):
+  # node 0 undersized -> LP says: serve 20 locally, forward 20.
+  opts = PlasmaOptions(k_sb=0, hb_latency_rounds=1)
+  rng = np.random.default_rng(7)
+  make = lambda i, nbrs: PlasmaNode(
+    NodeParams(
+      node_id=i, nbrs=nbrs, alpha=np.array([2.0]), gamma=np.array([0.1]),
+      beta=np.full((len(nbrs), 1), 1.5), u_max=np.array([10.0]),
+      ram_cap=100.0, ram_req=np.array([2.0]),
+    ), opts, np.random.default_rng(10 + i))
+  n0, n1 = make(0, (1,)), make(1, (0,))
+  n0.r = np.array([2])   # capacity 20
+  n1.r = np.array([4])   # capacity 40
+  engine = PlasmaEngine([n0, n1], opts, rng)
+  arrivals = np.array([[40], [0]])
+  engine.run_rounds(150, arrivals)         # burn-in
+  x_acc = np.zeros(1); y_acc = 0.0
+  for _ in range(50):                      # measure 50 windows
+    res = engine.run_rounds(1, arrivals)
+    x_acc += res.x[0]; y_acc += res.y[0, 1, 0]
+  lp_obj, lp_x, lp_y, lp_z = routing_lp(
+    lam=np.array([[40.0], [0.0]]), r=np.array([[2], [4]]),
+    u_max=np.full((2, 1), 10.0), alpha=np.full((2, 1), 2.0),
+    beta=np.array([[[0.0], [1.5]], [[1.5], [0.0]]]),
+    gamma=np.full((2, 1), 0.1), adjacency=np.array([[0, 1], [1, 0]]),
+  )
+  assert abs(x_acc[0] / 50 - lp_x[0, 0]) / 40.0 <= 0.05   # +-5% band
+  assert abs(y_acc / 50 - lp_y[0, 1, 0]) / 40.0 <= 0.05
+```
+
+- [ ] **Step 2: Write the solver-gated MILP-gap e2e test** (append to `tests/test_plasma_e2e.py`)
+
+```python
+def _solver_available(name="gurobi"):
+  try:
+    from pyomo.environ import SolverFactory
+    return SolverFactory(name).available(exception_flag=False)
+  except Exception:
+    return False
+
+
+@pytest.mark.skipif(not _solver_available(), reason="no MILP solver")
+def test_plasma_gap_vs_milp_on_small_graph(tmp_path):
+  from generators.generate_data import update_data
+  from plasma.baselines.milp_baseline import solve_snapshot
+  from run_centralized_model import init_problem
+  from utils.centralized import get_current_load
+  config = _config(tmp_path, Nn=3, max_steps=6)
+  config["solver_options"]["plasma"]["rounds_per_step"] = 30
+  folder = run_plasma(config, parallelism=0)
+  plasma_obj = pd.read_csv(os.path.join(folder, "obj.csv"))["Plasma"]
+  # dynamic oracle on the same instance/traces (re-generated: same seed)
+  base, traces, agents, _ = init_problem(
+    config["limits"], "sinusoidal", config["max_steps"], config["seed"],
+    str(tmp_path / "oracle"),
+  )
+  oracle = []
+  for t in range(0, config["max_steps"] - 1):
+    loadt = get_current_load(traces, agents, t)
+    loadt = {k: int(round(v)) for k, v in loadt.items()}
+    data = update_data(base, {"incoming_load": loadt})
+    oracle.append(solve_snapshot(data, "gurobi", {"OutputFlag": 0})[4])
+  # late-horizon gap (after Layer A/B settle): within 35% of the oracle
+  # (M5's 10% target applies to the tuned 20-node run, not this smoke)
+  late_p = plasma_obj.iloc[-2:].mean()
+  late_o = np.mean(oracle[-2:])
+  assert late_p >= late_o - abs(late_o) * 0.35
+```
+
+- [ ] **Step 3: Run the new tests**
+
+Run: `uv run pytest tests/test_plasma_routing.py tests/test_plasma_e2e.py -v`
+Expected: all PASS (gap test SKIPPED when no Gurobi). If the LP-convergence band fails, increase burn-in rounds (to ~300) before touching algorithm defaults; if it still fails, debug Layer A — the ±5% band is the spec's acceptance bar, do not widen it.
+
+- [ ] **Step 4: Full suite + repo regression**
+
+Run: `uv run pytest tests/ -x -q`
+Expected: everything green, pre-existing tests untouched.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/test_plasma_routing.py tests/test_plasma_e2e.py
+git commit -m "add plasma acceptance tests: lp convergence and milp gap"
+```
+
+---
+
+### Task 14: LaTeX note skeleton — `faas-plasma-note/`
+
+**Files:**
+- Create: `faas-plasma-note/main.tex`, `faas-plasma-note/faas-plasma.tex`, `faas-plasma-note/references.bib`
+
+Match the existing convention exactly (compare with `faas-magcaa-note/main.tex` before writing; adjust preamble to be byte-similar).
+
+- [ ] **Step 1: Inspect the convention**
+
+Run: `head -30 faas-magcaa-note/main.tex && head -40 faas-magcaa-note/faas-magcaa.tex`
+Copy the documentclass/preamble structure verbatim, replacing the name.
+
+- [ ] **Step 2: Write the three files**
+
+`main.tex`:
+```latex
+% Same preamble as faas-magcaa-note/main.tex, then:
+\input{faas-plasma}
+```
+
+`faas-plasma.tex` — section skeleton with real content stubs to be populated from M3 results onward:
+```latex
+\section{PLASMA: Physarum Routing with Simulated-Bifurcation Allocation}
+
+\subsection{Problem statement}
+% FRALB/DiFRALB instance as in the other notes; neighbor-only communication.
+
+\subsection{Layer A: Physarum conductance routing}
+% Per-request categorical routing on gated conductances; window update
+% D <- (1-mu) D + mu g(phi) reward; capacity and spare-capacity gates.
+
+\subsection{Layer B: discrete simulated bifurcation for replicas}
+% Binary spin encoding, node-local Hamiltonian (field + RAM penalty +
+% capacity chance-constraint + churn), dSB integrator, hysteresis,
+% randomized commit (p_commit) under the shared round barrier.
+
+\subsection{Round-barrier formulation}
+% Single synchronous execution mode; SB pass every k_sb rounds.
+
+\subsection{Acceptance criteria and results}
+% LP-convergence band, dSB vs brute force, gap vs MILP (populate from M3).
+
+\subsection{Privacy comparison vs FaaS-MADeA}
+% Heartbeat carries only spare/alpha/pull: strictly less disclosure than
+% MADeA's bid exchange.
+```
+
+`references.bib` — seed with the two published lines of work named in the spec:
+```bibtex
+@article{bonifaci2012physarum,
+  author  = {Bonifaci, Vincenzo and Mehlhorn, Kurt and Varma, Girish},
+  title   = {Physarum can compute shortest paths},
+  journal = {Journal of Theoretical Biology},
+  volume  = {309},
+  pages   = {121--133},
+  year    = {2012}
+}
+
+@article{goto2021high,
+  author  = {Goto, Hayato and Endo, Kotaro and Suzuki, Masaru and others},
+  title   = {High-performance combinatorial optimization based on classical mechanics},
+  journal = {Science Advances},
+  volume  = {7},
+  number  = {6},
+  year    = {2021}
+}
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add faas-plasma-note/
+git commit -m "scaffold faas-plasma-note LaTeX package"
+```
+
+---
+
+## Milestone map (design §4 → tasks)
+
+| Milestone | Tasks | Notes |
+|---|---|---|
+| M1 skeleton + scheduler | 1, 2, 6 (partial), 9 | 3-node line e2e in Task 9 |
+| M2 Layer A alone | 3, 4, 6, 8, 13 (LP convergence) | `k_sb = 0` = fixed replicas |
+| M3 baselines | 11 | milp/greedy/madea_iface + routing LP |
+| M4 Layer B alone | 5 | dSB vs brute force |
+| M5 coupling + hysteresis | 7, 8 (phase-locked tests), 13 (gap) | 10% gap target is a tuning goal on 20-node G(n,m), tracked in the note, not a CI assert |
+| M6 non-stationarity + failures | 8 (`set_alive`), 11 (`stale_objectives`), 12 | comparison tables are experiment work via `run.py --methods centralized plasma faas-madea`, not new code |
+| M7 rare-function mode + sweeps | 3, 6 (`rare_function_mode`) | sweeps reuse `run.py --loop_over`; nothing new to build |
+
+Deliberately not built (YAGNI, per design doc): MMPP burst generator (existing `clipped`/`sinusoidal` traces cover M1–M5; add a small generator in `plasma/sim/` only when M6 experiments demand it), plotting modules (`postprocessing.py` covers it), a sweep runner (`--loop_over` exists), pure-Poisson traces (same rule).
+
+## Self-review checklist (done during planning)
+
+- Spec coverage: all §8 non-negotiable tests mapped — locality invariant (Task 4 whitelist + Task 5 node-local ctx), capacity gate (Task 6), RAM repair (Tasks 5, 7), dSB-vs-brute-force (Task 5), Physarum-LP (Task 13), dead neighbor (Tasks 3, 8), oscillation/hysteresis (Task 7), message budget (Task 8), phase-locked commit (Task 8). Async variant: intentionally absent everywhere, `execution_mode` rejected by construction (Task 1 test).
+- Types consistent across tasks: `PlasmaOptions`, `Heartbeat`, `NodeParams`, `WindowCounts`, `StepResult`, `HamiltonianContext` defined once each, consumed by name.
+- No placeholders: every code step is complete; the one deliberate deferral (GreedyCoordinator return-dict keys) is an explicit verify-then-adapt instruction with a fixed contract.
diff --git a/docs/plans/2026-07-05-plasma-m5-m7.md b/docs/plans/2026-07-05-plasma-m5-m7.md
new file mode 100644
index 0000000..2a84f8f
--- /dev/null
+++ b/docs/plans/2026-07-05-plasma-m5-m7.md
@@ -0,0 +1,185 @@
+# PLASMA M5–M7 Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Close the remaining milestones of the PLASMA design: M5 (stationary gap benchmark on a 20-node G(n,m) graph, target ≤10%), M6 (non-stationarity + node failures with regret/adaptation-lag comparison vs greedy and stale-MILP), M7 (rare-function ablation + a reusable parameter-sweep driver).
+
+**Architecture:** One mechanism change (provisioning demand target based on arrivals, not accepted traffic), then experiment drivers under `plasma/eval/` that reuse the existing engine, baselines, and metrics. No runner/CSV format changes; `run.py` untouched.
+
+**Tech Stack:** unchanged. Tests via `uv run pytest`.
+
+## Global Constraints
+
+- 2-space indent, double quotes, no new deps, Python 3.10; only `plasma/*`, `tests/test_plasma_*.py`, and new `config_files/*.json` may change.
+- Determinism: explicit `numpy.random.Generator` everywhere.
+- Experiment tasks REPORT results against the milestone bars; missing a bar is a reported outcome, not a task failure. Never widen an acceptance band to make a bar.
+- Commit per task; end commit messages with `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`.
+
+---
+
+### Task 1: Provision for arrivals, not accepted traffic (M5 mechanism fix)
+
+**Files:**
+- Modify: `plasma/core/node.py`
+- Test: `tests/test_plasma_sbm.py`
+
+**Rationale (measured):** `demand_target = demand_hat + pull_in` where `demand_hat` is the EWMA of ACCEPTED traffic (`x + xi`). A node rejecting its own arrivals for lack of replicas never sees that demand, so it under-provisions (1049 replicas vs oracle's 1192; 6–9% steady rejections). The node already tracks `lam_hat` (EWMA of external arrivals, served or not).
+
+**Change:** in `_hamiltonian_ctx`, use `lam_hat` as the own-demand component:
+
+```python
+    demand_target = self.lam_hat + pull_in
+```
+
+and pass `demand_hat=self.lam_hat` into the `HamiltonianContext` (the ctx field feeds the capacity chance-constraint; margin stays `z_delta * sqrt(...)` of the same quantity — compute both from `demand_target`'s own-demand base consistently: `margin=self.opts.z_delta * np.sqrt(self.lam_hat)`). Then DELETE the now-unused `self.demand_hat` state and its EWMA update in `end_window` (grep first: if anything else reads `demand_hat`, report instead of deleting).
+
+Do NOT add `xi` to the target: `pull_in` already carries the neighbors' full overflow (of which `xi` is the realized share) — adding both would double-count.
+
+- [ ] **Step 1: Write the failing test** (append to `tests/test_plasma_sbm.py`)
+
+```python
+def test_rejected_own_demand_still_drives_provisioning():
+  # a node with r=0 rejects everything; its provisioning target must still
+  # see the full arrival rate (lam_hat), not the accepted traffic (zero)
+  node = _sb_node(n_hyst=1)
+  node.r = np.zeros(2, dtype=int)
+  node.begin_window()
+  node.route_window(np.array([12, 0]), round_=0)
+  node.end_window()  # everything was rejected or forwarded; nothing accepted
+  committed = node.sb_pass(round_=0)
+  assert committed
+  assert node.r[0] >= 1  # grows replicas from rejected demand
+```
+
+(Existing tests that set `node.demand_hat = ...` directly must be converted to set `node.lam_hat = ...` — same values, same assertions.)
+
+- [ ] **Step 2: Run** — the new test FAILS on current code (accepted-demand target is zero → no growth). Convert the `demand_hat`-setting tests, run `uv run pytest tests/test_plasma_sbm.py -q` to see only the new test failing.
+
+- [ ] **Step 3: Implement** as specified above.
+
+- [ ] **Step 4: Run** — `uv run pytest tests/test_plasma_sbm.py tests/test_plasma_routing.py tests/test_plasma_clock.py tests/test_plasma_e2e.py -q` — all green.
+
+- [ ] **Step 5: Commit** — `git commit -m "provision replicas for arrivals, not accepted traffic"`
+
+- [ ] **Step 6 (controller measures):** re-run the real-instance long horizon and compare rejections/gap vs the previous run before proceeding.
+
+---
+
+### Task 2: M5 benchmark — 20-node G(n,m) stationary gap
+
+**Files:**
+- Create: `config_files/plasma_m5_benchmark.json` (`git add -f` — the folder is gitignored)
+
+Config: derive from `config_files/eval_smoke.json` limits with these overrides — `"base_solution_folder": "solutions/plasma_m5"`, `"seed": 4242`, `"max_steps": 40`, `"min_run_time": 0`, `"max_run_time": 39`, `Nn` values `[20]`, `Nf` min/max 3, `"neighborhood": {"m": 40}`, `"load": {"trace_type": "clipped", "min": {"min": 20, "max": 30}, "max": {"min": 60, "max": 90}}`, `memory_capacity` min/max 24, `memory_requirement` values `[2, 3, 2]`, plus `"plasma": {"rounds_per_step": 20, "k_sb": 10, "mu": 0.3, "p_commit": 0.5, "n_hyst": 2}` in `solver_options`.
+
+- [ ] **Step 1:** Create the config; smoke it: `uv run python run.py -c config_files/plasma_m5_benchmark.json --methods centralized plasma --n_experiments 1 -j 2` (runs in minutes: 40 steps × 0.3 s + 40 Gurobi solves).
+- [ ] **Step 2:** Compute per-step and last-10 gap vs the centralized oracle, rejection %, mix, replicas ratio, msgs/node/s (same analysis as the fromexisting trials).
+- [ ] **Step 3:** Report against the M5 bar (≤10% stationary gap). If missed: run the `plasma/eval/sweep.py` driver (Task 4) over `mu × z_delta × eps_commit` on this config and report the best point too. The bar verdict (met/missed + best number) goes in the ledger and the final report.
+- [ ] **Step 4:** Commit the config — `git commit -m "add M5 20-node stationary benchmark config"`
+
+---
+
+### Task 3: M6 — failure/non-stationarity scenario driver
+
+**Files:**
+- Create: `plasma/eval/scenario.py`
+- Test: `tests/test_plasma_baselines.py` (append one smoke test)
+
+**Interfaces:**
+
+```python
+def run_scenario(
+    config: dict,
+    kill: tuple | None = None,       # (node_idx, t_kill, t_revive)
+    solver_name: str = "gurobi",
+    solver_options: dict | None = None,
+    resolve_every: int = 5,           # stale-MILP re-solve period
+  ) -> pd.DataFrame:
+  """Drive PlasmaEngine directly over the config's horizon (sinusoidal traces
+  give the non-stationarity), applying set_alive at the kill/revive steps.
+  Per step, also score: dynamic oracle (solve_snapshot on true load),
+  stale-MILP (stale_objectives logic), greedy baseline (greedy_baseline.solve
+  on true load). Returns a DataFrame with columns:
+  t, plasma, oracle, stale_milp, greedy, plasma_msgs_per_node_s.
+  Dead-node arrivals are dropped for EVERY method alike (oracle included:
+  zero out that node's load) so the comparison stays apples-to-apples."""
+```
+
+plus a `__main__` that takes `-c config -o out.csv [--kill n,t0,t1]`, writes the CSV, and prints `cumulative_regret` and `adaptation_lag` (change points = kill and revive times) for each method vs the oracle.
+
+Implementation notes (binding):
+- Build nodes/engine exactly as `plasma.runner.build_nodes` does (import and reuse it — do not duplicate).
+- Reuse `init_problem`, `get_current_load`, `update_data`, `objective_load`, `compute_centralized_objective`; plasma's per-step objective is computed from the engine's `StepResult` exactly as the runner does.
+- The plasma side must NOT call `check_feasibility` when a node is dead (dropped arrivals break conservation by design); everything else identical to the runner loop.
+- Greedy is re-solved every step on the true load (it is the no-coordination lower baseline); stale-MILP re-solves every `resolve_every` steps and is scored with `shed_overflow`.
+- MADeA comparison is NOT implemented here — it runs through `run.py --methods faas-madea` on the same materialized instance when needed (document this in the module docstring).
+
+- [ ] **Step 1: Smoke test** (append to `tests/test_plasma_baselines.py`; gate on solver availability like the gap test):
+
+```python
+@pytest.mark.skipif(not _solver_available(), reason="no MILP solver")
+def test_scenario_driver_produces_comparison(tmp_path):
+  from plasma.eval.scenario import run_scenario
+  config = _scenario_config(tmp_path)   # small: 3 nodes, 6 steps, seed 7
+  df = run_scenario(config, kill=(1, 2, 4), solver_name="gurobi",
+                    solver_options={"OutputFlag": 0})
+  assert list(df.columns) == ["t", "plasma", "oracle", "stale_milp",
+                              "greedy", "plasma_msgs_per_node_s"]
+  assert len(df) == 6
+  assert (df["oracle"] >= df["plasma"] - 1e-6).all()  # oracle upper-bounds
+```
+
+with `_scenario_config` building the same shape as `tests/test_plasma_e2e.py::_config` (copy it, 3 nodes, `max_steps=6`, `max_run_time=5`).
+
+- [ ] **Step 2:** FAIL first, implement, PASS; full baselines file green.
+- [ ] **Step 3:** Commit — `git commit -m "add M6 failure scenario driver with oracle and baselines"`
+
+---
+
+### Task 4: M7 — sweep driver + rare-function ablation
+
+**Files:**
+- Create: `plasma/eval/sweep.py`
+- Create: `config_files/plasma_m7_rare.json` (`git add -f`)
+- Test: `tests/test_plasma_baselines.py` (append)
+
+**Sweep driver** (promotes the session's scratch script):
+
+```python
+def sweep(config: dict, grid: dict, lmm_obj: "np.ndarray | None" = None) -> pd.DataFrame:
+  """grid: {option_name: [values]} over solver_options['plasma'] keys.
+  Runs plasma.runner.run for every combination (itertools.product),
+  returns a DataFrame with one row per combo: the option values,
+  mean objective, last-10-mean objective, and (if lmm_obj given)
+  full/last-10 gap %. Deterministic: same config seed for every combo."""
+```
+
+plus `__main__`: `-c config --grid '{"mu": [0.1, 0.3]}' [--lmm obj.csv]`.
+
+**Rare-function ablation config** `plasma_m7_rare.json`: same shape as the M5 config but `Nn` values `[10]`, `"load": {"trace_type": "clipped", "min": {"min": 1, "max": 2}, "max": {"min": 4, "max": 8}}` (low-rate: under the default `lambda_split_threshold = 5`), `max_steps` 30, `base_solution_folder` `solutions/plasma_m7`.
+
+- [ ] **Step 1: Test** (append to `tests/test_plasma_baselines.py`):
+
+```python
+def test_sweep_driver_runs_grid(tmp_path):
+  from plasma.eval.sweep import sweep
+  config = _scenario_config(tmp_path)
+  df = sweep(config, {"mu": [0.1, 0.3]})
+  assert len(df) == 2
+  assert set(df["mu"]) == {0.1, 0.3}
+  assert df["obj_mean"].notna().all()
+```
+
+- [ ] **Step 2:** FAIL, implement, PASS.
+- [ ] **Step 3 (controller measures):** ablation — run the rare config twice via the sweep driver with `{"rare_function_mode": ["sampled", "unsplittable"]}` plus centralized once for the oracle; report objective/rejections for both modes.
+- [ ] **Step 4:** Commit — `git commit -m "add plasma sweep driver and M7 rare-function config"`
+
+---
+
+### Task 5 (controller): measurements, ledger, report
+
+- [ ] Task 1 aftermath: long-horizon re-measure on the fromexisting instance (v6) vs v5.
+- [ ] M5: benchmark run + gap verdict (sweep pass if the bar is missed).
+- [ ] M6: scenario run on the fromexisting instance (or the M5 instance) with a mid-horizon kill/revive; table: time-averaged objective, cumulative regret, adaptation lag (kill + revive), msgs/node/s for plasma/greedy/stale-MILP.
+- [ ] M7: ablation numbers (sampled vs unsplittable at low rate).
+- [ ] Full regression suite; ledger updated with all verdicts; final report to the user with the milestone bars met/missed stated plainly.
diff --git a/docs/plans/2026-07-05-plasma-quality-perf.md b/docs/plans/2026-07-05-plasma-quality-perf.md
new file mode 100644
index 0000000..52ce86b
--- /dev/null
+++ b/docs/plans/2026-07-05-plasma-quality-perf.md
@@ -0,0 +1,346 @@
+# PLASMA Quality & Performance Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Close the quality gap found in the instance trials (64% objective gap vs LMM, 25% rejections, 45 s/step) with three targeted changes: local-first admission, exact per-node DP for Layer B (dSB kept as ablation), and window-vectorized overflow routing. Then re-measure on the same instance.
+
+**Architecture:** All changes stay inside `plasma/`; no new dependencies; the runner/engine/heartbeat contracts are unchanged except the node data-plane API (Task 3). Evidence base: `solutions/fromexisting_plasma*` trials — replicas already match the oracle, the gap is routing mix (40% local vs LMM's 75%) plus pure-Python per-request routing cost.
+
+**Tech Stack:** unchanged (numpy, pytest via `uv run pytest`).
+
+## Global Constraints
+
+- 2-space indent, double quotes, no new deps, Python 3.10.
+- Only `plasma/*` and `tests/test_plasma_*.py` may change (no runner CSV format changes, no `run.py` changes).
+- Determinism: explicit `numpy.random.Generator` everywhere; same seed → same outputs.
+- Locality invariant untouched: nodes still read only own state + neighbor heartbeats/ACKs.
+- Existing test semantics: tests may be ADAPTED where the plan says so, never weakened (assertions must still prove the property).
+- Commit per task; end commit messages with `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`.
+
+---
+
+### Task 1: Local-first admission — Physarum only on overflow
+
+**Files:**
+- Modify: `plasma/core/node.py` (`route_request`)
+- Test: `tests/test_plasma_routing.py`
+
+**Rationale (from trials):** sampling LOCAL against neighbors/REJ makes nodes forward/reject traffic they could serve locally (40% local vs LMM's 75%); the reference model semantics (every other method in this repo) is: serve locally up to capacity (`x`), coordinate only the overflow (`omega`).
+
+**Interfaces:** `route_request(f, round_) -> int` keeps its signature and column convention. New semantics: while local capacity remains, return `LOCAL` deterministically; once exhausted, sample ONLY over `[REJ] + neighbors` (LOCAL weight forced to 0). `unsplittable` mode applies to the overflow choice. Conductance updates unchanged (`phi[f, LOCAL]` still counts local admissions).
+
+- [ ] **Step 1: Write the failing test** (append to `tests/test_plasma_routing.py`)
+
+```python
+def test_local_first_admission_fills_local_capacity_before_any_forward():
+  # capacity 10: the FIRST 10 requests must all go LOCAL, deterministically
+  node = _node(r=(2,), u_max=(5.0,))
+  node.begin_window()
+  cols = [node.route_request(0, round_=0) for _ in range(15)]
+  assert cols[:10] == [LOCAL] * 10
+  assert LOCAL not in cols[10:]
+```
+
+- [ ] **Step 2: Run it** — `uv run pytest tests/test_plasma_routing.py::test_local_first_admission_fills_local_capacity_before_any_forward -v` — expected FAIL (sampling sends some early requests elsewhere).
+
+- [ ] **Step 3: Implement** — in `route_request`, replace the weight/choice block:
+
+```python
+  def route_request(self, f: int, round_: int) -> int:
+    self._arrivals[f] += 1
+    if self._admitted[f] < self._capacity_units(f):
+      # local-first: serve own load up to capacity (reference-model x),
+      # Physarum coordinates only the overflow
+      self._x[f] += 1
+      self._admitted[f] += 1
+      self._phi[f, LOCAL] += 1
+      return LOCAL
+    nbr_spare = np.array([
+      self.cache.spare(
+        j, round_, self.opts.staleness_rounds, self.Nf
+      )[f] for j in self.params.nbrs
+    ])
+    weights = target_weights(
+      self.D[f], False, nbr_spare, self.opts.eps_explore
+    )
+    unsplittable = (
+      self.opts.rare_function_mode == "unsplittable"
+      and self.lam_hat[f] < self.opts.lambda_split_threshold
+    )
+    col = choose_target(self.rng, weights, unsplittable)
+    if col == LOCAL:  # weight is 0; only reachable if every weight is 0
+      col = REJ
+    if col == REJ:
+      self._z[f] += 1
+      self._pull[f] += 1
+    return col
+```
+
+Note: `choose_target` returns REJ when the total weight is ≤ 0, and with `local_open=False` the LOCAL weight is 0 — the `col == LOCAL` guard covers the argmax path of unsplittable mode (argmax could pick a zero-weight column only if all are zero).
+
+- [ ] **Step 4: Run the routing + clock + e2e suites** — `uv run pytest tests/test_plasma_routing.py tests/test_plasma_clock.py tests/test_plasma_e2e.py -q` — all green. The LP-convergence acceptance test must still pass (local-first gives x = capacity = LP optimum exactly). Seeded engine tests may shift values but their assertions are structural; if a seeded assertion fails, inspect whether the property genuinely still holds under the new (better) routing and adjust the SEED only, never the asserted property.
+
+- [ ] **Step 5: Commit** — `git commit -m "route local-first, physarum on overflow only"`
+
+---
+
+### Task 2: Exact per-node DP for Layer B (`sbm_method: exact|dsb`)
+
+**Files:**
+- Modify: `plasma/core/types.py` (new option + validation), `plasma/core/sbm.py` (DP), `plasma/core/node.py` (`sb_pass` dispatch)
+- Test: `tests/test_plasma_sbm.py`, `tests/test_plasma_protocol.py` (option validation)
+
+**Rationale:** the per-node Hamiltonian is separable per function with one RAM knapsack constraint — a multi-choice knapsack, exactly solvable by DP in microseconds. dSB (30–40 s/step) stays as ablation (`sbm_method: "dsb"`).
+
+**Interfaces:**
+- `PlasmaOptions.sbm_method: str = "exact"`, validated in `__post_init__` (`ValueError` unless in `{"exact", "dsb"}`).
+- `sbm.exact_minimize(ctx: HamiltonianContext, r_max: np.ndarray) -> np.ndarray` — returns the exact argmin of the Hamiltonian under the HARD RAM constraint (the soft `A` penalty is irrelevant on the feasible set; no repair needed). Requires integer `ram_req`/`ram_cap` (repo-wide the case); raises `ValueError` telling the user to use `sbm_method: "dsb"` otherwise.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plasma_sbm.py`; option test to `tests/test_plasma_protocol.py`)
+
+```python
+# test_plasma_sbm.py
+from plasma.core.sbm import exact_minimize
+
+
+def test_exact_matches_brute_force_ground_state():
+  rng = np.random.default_rng(0)
+  for trial in range(50):
+    Nf = 3
+    ram_req = rng.integers(1, 4, Nf).astype(float)
+    ram_cap = float(rng.integers(4, 13))
+    r_max = np.floor(ram_cap / ram_req).astype(int)
+    ctx = HamiltonianContext(
+      benefit=rng.uniform(0, 5, Nf), ram_req=ram_req, ram_cap=ram_cap,
+      demand_hat=rng.uniform(0, 10, Nf), margin=rng.uniform(0, 2, Nf),
+      u_max=rng.uniform(1, 6, Nf), r_prev=rng.integers(0, 3, Nf),
+      A=10.0, B=1.0, C=0.1, switch_cost=1.0,
+    )
+    r_star = exact_minimize(ctx, r_max)
+    assert (ctx.ram_req * r_star).sum() <= ctx.ram_cap + 1e-9
+    # brute force over all feasible r
+    from itertools import product as iproduct
+    best = min(
+      (hamiltonian(np.array(rr), ctx)
+       for rr in iproduct(*[range(m + 1) for m in r_max])
+       if (ctx.ram_req * np.array(rr)).sum() <= ctx.ram_cap + 1e-9)
+    )
+    assert hamiltonian(r_star, ctx) <= best + 1e-9
+
+
+def test_exact_rejects_fractional_ram():
+  ctx = _ctx(ram_req=np.array([1.5, 2.0]))
+  with pytest.raises(ValueError, match="dsb"):
+    exact_minimize(ctx, np.array([5, 4]))
+
+
+def test_sb_pass_exact_is_deterministic():
+  a = _sb_node(n_hyst=1)
+  b = _sb_node(n_hyst=1)
+  for node in (a, b):
+    node.demand_hat = np.array([8.0, 3.0])
+    node.sb_pass(round_=0)
+  assert np.array_equal(a.r, b.r)
+```
+
+```python
+# test_plasma_protocol.py
+def test_options_reject_unknown_sbm_method():
+  with pytest.raises(ValueError, match="sbm_method"):
+    PlasmaOptions(sbm_method="quantum")
+```
+
+- [ ] **Step 2: Run them** — expected FAIL (`ImportError: exact_minimize`, no validation).
+
+- [ ] **Step 3: Implement**
+
+`plasma/core/types.py` — add field `sbm_method: str = "exact"` in the Layer B block and in `__post_init__`:
+
+```python
+    if self.sbm_method not in ("exact", "dsb"):
+      raise ValueError(f"sbm_method must be 'exact' or 'dsb', got {self.sbm_method!r}")
+```
+
+`plasma/core/sbm.py`:
+
+```python
+def _level_values(ctx: HamiltonianContext, f: int, r_max_f: int) -> np.ndarray:
+  # per-function contribution of r_f = 0..r_max_f (Hamiltonian minus RAM term,
+  # which the DP enforces as a hard budget)
+  levels = np.arange(r_max_f + 1)
+  cap_short = np.maximum(
+    0.0, ctx.demand_hat[f] + ctx.margin[f] - levels * ctx.u_max[f]
+  )
+  return (
+    -ctx.benefit[f] * levels
+    + ctx.B * cap_short ** 2
+    + ctx.C * ctx.switch_cost * np.abs(levels - ctx.r_prev[f])
+  )
+
+
+def exact_minimize(ctx: HamiltonianContext, r_max: np.ndarray) -> np.ndarray:
+  # multi-choice knapsack DP over the integer RAM budget: exact argmin of the
+  # Hamiltonian under the hard RAM constraint (per-node problem is separable
+  # per function; RAM is the only coupling)
+  ram_req = np.rint(ctx.ram_req).astype(int)
+  budget = int(np.floor(ctx.ram_cap + 1e-9))
+  if not np.allclose(ctx.ram_req, ram_req, atol=1e-9) or (ram_req <= 0).any():
+    raise ValueError(
+      "exact_minimize requires positive integer ram_req; use sbm_method 'dsb'"
+    )
+  Nf = len(r_max)
+  INF = np.inf
+  best = np.full(budget + 1, 0.0)  # value of best partial assignment
+  choice = np.zeros((Nf, budget + 1), dtype=int)
+  for f in range(Nf):
+    values = _level_values(ctx, f, int(r_max[f]))
+    new_best = np.full(budget + 1, INF)
+    for b in range(budget + 1):
+      k_hi = min(int(r_max[f]), b // ram_req[f])
+      for k in range(k_hi + 1):
+        cand = best[b - k * ram_req[f]] + values[k]
+        if cand < new_best[b]:
+          new_best[b] = cand
+          choice[f, b] = k
+    best = new_best
+  # backtrack from the best final budget
+  b = int(np.argmin(best))
+  r = np.zeros(Nf, dtype=int)
+  for f in range(Nf - 1, -1, -1):
+    r[f] = choice[f, b]
+    b -= r[f] * ram_req[f]
+  return r
+```
+
+`plasma/core/node.py` — in `sb_pass`, replace the dSB block:
+
+```python
+    if self.opts.sbm_method == "exact":
+      r_new = exact_minimize(ctx, r_max)
+    else:
+      bits = bits_per_fn(r_max)
+      n_spins = int(bits.sum())
+      if n_spins == 0:
+        return False
+
+      def H(s: np.ndarray) -> float:
+        return hamiltonian(decode_spins(s, bits, r_max), ctx)
+
+      s = dsb_minimize(H, n_spins, self.opts, self.rng)
+      r_new = repair(
+        decode_spins(s, bits, r_max), ctx.benefit, self.params.ram_req,
+        self.params.ram_cap,
+      )
+```
+
+(import `exact_minimize` alongside the existing sbm imports; keep everything after — hysteresis, `p_commit` — identical.)
+
+- [ ] **Step 4: Run** — `uv run pytest tests/test_plasma_sbm.py tests/test_plasma_protocol.py tests/test_plasma_e2e.py -q` — all green. Existing `_sb_node` tests now run the exact path (deterministic, still RAM-feasible). dSB tests still call `dsb_minimize` directly and stay green.
+
+- [ ] **Step 5: Commit** — `git commit -m "solve layer B exactly via knapsack DP, keep dSB as ablation"`
+
+---
+
+### Task 3: Window-vectorized overflow routing
+
+**Files:**
+- Modify: `plasma/core/node.py` (window API), `plasma/engine.py` (`_route_all`)
+- Test: `tests/test_plasma_routing.py`, `tests/test_plasma_clock.py` (adapt data-plane tests)
+
+**Rationale:** the hot loop is per-request Python (`cache.spare` array per request × neighbor): 45→697 s/step in the trials. Weights are CONSTANT within a window (heartbeat cache only changes between rounds; local gate is now deterministic), so sequential sampling ≡ one multinomial draw per (node, f).
+
+**Interfaces (replaces the per-request data plane):**
+- `PlasmaNode.route_window(arrivals: np.ndarray, round_: int) -> np.ndarray` — arrivals shape `(Nf,)`; admits local-first internally (fills `x`, `phi[:, LOCAL]`, `admitted`), samples the overflow once per function (multinomial over `[REJ]+nbrs`, or argmax for unsplittable), records REJ into `z`/`pull`, and returns desired forward counts, shape `(Nf, deg)`.
+- `PlasmaNode.accept_forwards(f: int, n: int) -> int` — bulk admission: returns `k = min(n, remaining_units)`, adds to `admitted`/`xi`.
+- `PlasmaNode.record_forward_results(f: int, k: int, attempted: int, accepted: int)` — `y[k, f] += accepted`, `phi[f, 2+k] += accepted`, `z[f] += attempted - accepted`, `pull[f] += attempted`.
+- `route_request`/`admit_forward`/`record_forward_result` are DELETED (engine is the only caller; tests migrate to the window API).
+
+Engine `_route_all` becomes:
+
+```python
+  def _route_all(self, round_: int, arrivals: np.ndarray) -> None:
+    for i, node in enumerate(self.nodes):
+      if not node.alive:
+        continue
+      desired = node.route_window(arrivals[i], round_)
+      for k, j in enumerate(node.params.nbrs):
+        for f in range(node.Nf):
+          n = int(desired[f, k])
+          if n == 0:
+            continue
+          self.msg_count += n
+          accepted = self.nodes[j].accept_forwards(f, n)
+          node.record_forward_results(f, k, n, accepted)
+```
+
+`route_window` core (per function `f` with `overflow > 0`):
+
+```python
+    nbr_spare = self._nbr_spare(round_)  # (deg, Nf), ONE cache read per window
+    weights = target_weights(self.D[f], False, nbr_spare[:, f], self.opts.eps_explore)
+    weights[LOCAL] = 0.0
+    if unsplittable:
+      counts = np.zeros(len(weights), dtype=int)
+      counts[int(np.argmax(weights))] = overflow
+    else:
+      total = weights.sum()
+      if total <= 0.0:
+        counts = np.zeros(len(weights), dtype=int)
+        counts[REJ] = overflow
+      else:
+        counts = self.rng.multinomial(overflow, weights / total)
+    counts[REJ] += counts[LOCAL]  # zero-weight LOCAL can only be hit by argmax ties
+    self._z[f] += counts[REJ]
+    self._pull[f] += overflow
+    desired[f, :] = counts[2:]
+```
+
+with `_nbr_spare(round_)` building the `(deg, Nf)` spare matrix once per window via `cache.spare`.
+
+**Distributional note (binding):** multinomial over fixed weights is exactly the law of the per-request categorical sequence, so the acceptance tests (LP convergence band) must still pass — that is the regression witness for this task.
+
+- [ ] **Step 1: Write the new-API tests first** (adapt in place in `tests/test_plasma_routing.py`): rewrite `test_capacity_gate_never_admits_beyond_r_umax`, `test_incoming_forwards_share_the_same_capacity`, `test_nack_counts_as_origin_rejection_and_pull`, `test_zero_replicas_rejects_or_forwards_everything`, `test_dead_node_admits_nothing`, `test_end_window_reinforces_local_conductance`, `test_local_first_admission_...`, `test_spare_advertises_floored_capacity` to the window API, preserving each asserted property. Example conversions:
+
+```python
+def test_capacity_gate_never_admits_beyond_r_umax():
+  node = _node(r=(2,), u_max=(5.0,))
+  node.begin_window()
+  desired = node.route_window(np.array([100]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 10                       # local-first fills capacity
+  assert counts.z[0] + desired[0].sum() == 90    # overflow rejected or forwarded
+
+
+def test_incoming_forwards_share_the_same_capacity():
+  node = _node(r=(1,), u_max=(3.0,))
+  node.begin_window()
+  assert node.accept_forwards(0, 10) == 3
+  desired = node.route_window(np.array([5]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 0                        # capacity consumed by forwards
+
+
+def test_nack_counts_as_origin_rejection_and_pull():
+  node = _node()
+  node.begin_window()
+  node.record_forward_results(0, k=0, attempted=2, accepted=1)
+  counts = node.end_window()
+  assert counts.z[0] == 1 and counts.y[0, 0] == 1
+  assert node.make_heartbeat().pull[0] == 2
+```
+
+- [ ] **Step 2: Run** — new/adapted tests FAIL (`route_window` missing).
+
+- [ ] **Step 3: Implement** node + engine as specified. Delete the per-request methods.
+
+- [ ] **Step 4: Run everything** — `uv run pytest tests/test_plasma_routing.py tests/test_plasma_clock.py tests/test_plasma_protocol.py tests/test_plasma_sbm.py tests/test_plasma_e2e.py -q` — all green, INCLUDING the LP-convergence band (distributional equivalence witness). Then timing check: `uv run python -m pytest tests/test_plasma_e2e.py::test_runner_produces_lspc_artifacts -q --durations=1` — the e2e should be visibly faster than before.
+
+- [ ] **Step 5: Commit** — `git commit -m "vectorize window routing with bulk forward resolution"`
+
+---
+
+### Task 4: Re-measure on the instance (controller-run)
+
+- [ ] Re-run: `uv run python run.py -c config_files/config_fromexisting_plasma.json --methods plasma --n_experiments 1 -j 2` (centralized results already exist in `solutions/fromexisting_plasma/`; the runner appends a new plasma folder).
+- [ ] Compare vs LMM and vs the pre-fix trials: objective gap per step, rejection %, local/fwd mix, runtime/step. Success bar: rejections ≤ 10%, mean gap ≤ 25%, runtime ≤ 2 s/step. Report the table either way — if the bar is missed, report the residual bottleneck (this is measurement, not tuning; M5 sweeps remain future work).
+- [ ] Full regression: `uv run pytest tests/ -q`.
diff --git a/docs/plans/2026-07-06-tight-load-management-model.md b/docs/plans/2026-07-06-tight-load-management-model.md
new file mode 100644
index 0000000..1500c5a
--- /dev/null
+++ b/docs/plans/2026-07-06-tight-load-management-model.md
@@ -0,0 +1,75 @@
+# TightLoadManagementModel: centralized model reformulation and solver findings
+
+## Context
+
+Investigation into speeding up the centralized `LoadManagementModel`
+(`models/model.py`). Benders decomposition was considered and rejected;
+benchmarking found the real bottleneck elsewhere.
+
+## Key finding: MIPGap, not the model
+
+Benchmarks (Gurobi 12.0.3, Apple M3 Pro, random instances with the
+`eval_full.json` parameters, Nf=2, sinusoidal load traces):
+
+| Nn  | MIPGap 1e-5 (configs today) | MIPGap 1e-2 | speedup |
+|-----|-----------------------------|-------------|---------|
+| 20  | 0.16 s/step                 | 0.035 s/step| ~5x     |
+| 50  | 45.8 s/step, 1 of 3 steps hit TimeLimit=120 and returned **no solution** | 0.17 s/step | ~270x |
+| 100 | 83.5 s/step                 | 0.65 s/step | ~130x   |
+
+Objective degradation at gap 1e-2 was 0.07–0.2% on the same instances.
+The tight gap is also less robust: the step that timed out at 1e-5 solved
+in 0.2 s at 1e-2.
+
+**Recommendation: set `"MIPGap": 1e-2` (or `1e-3`) in
+`config_files/*.json` and `test_instances/config.json`.** Pyomo instance
+build time is negligible (0.08 s at Nn=50, 0.3 s at Nn=100), so a
+persistent solver interface is not needed. At these sizes (Nn <= 100
+solving sub-second with a sane gap), Benders or Lagrangian decomposition
+would add per-iteration overhead for nothing; revisit only well beyond
+Nn ~ 500.
+
+## TightLoadManagementModel
+
+New class in `models/model.py`, subclassing `LoadManagementModel` (the
+original is untouched). Two changes:
+
+1. **Tighter big-M in `no_ping_pong2`**: the bound
+   `sum_m incoming_load[m,f]` is restricted to actual neighbors
+   (`incoming_load[m,f] * neighborhood[m,n]`). Tighter LP relaxation,
+   same feasible set, since `offload_only_to_neighbors` already forces
+   `y[m,n,f] = 0` for non-neighbors.
+2. **`utilization_equilibrium2` dropped**, replaced by a `-r_penalty *
+   sum(r)` term in the objective (mutable Param, default 1e-4). The
+   original constraint only pins `r` to its minimal value; the epsilon
+   penalty achieves the same without |N|*|F| constraints coupling `r` to
+   the flow variables. `r_penalty` must stay well below the smallest
+   marginal gain of serving one request (~beta/incoming_load); at the
+   default it never trades replicas against served traffic.
+
+Selection: `"model_variant": "tight"` in the run config
+(`run_centralized_model.py`); default behavior is unchanged.
+
+## Measured effect
+
+Same Nn=50 instance, 3 timesteps:
+
+| model    | gap 1e-5    | gap 1e-2     |
+|----------|-------------|--------------|
+| original | 46.5 s/step | 0.160 s/step |
+| tight    | 47.2 s/step | 0.132 s/step |
+
+The reformulation is equivalence-verified and ~18% faster at a
+reasonable gap, but it does **not** fix the 1e-5 pathology — that time
+goes into proving the bound, not into branching that tighter big-Ms
+help. The MIPGap change is the fix; the tight model is a bonus on top.
+
+## Verification
+
+`tests/test_tight_model.py`: on 2 random seeds, checks that the tight
+model's objective (net of the epsilon penalty) matches the original
+within 1e-4 relative tolerance and that total replicas stay minimal.
+
+Note for future stress testing: the Nn=50 / seed=42 / step t=1 instance
+makes both models hit TimeLimit=120 at gap 1e-5 — a good hard case to
+keep around.
diff --git a/docs/superpowers/plans/2026-05-19-hierarchical-auction-fixes.md b/docs/superpowers/plans/2026-05-19-hierarchical-auction-fixes.md
new file mode 100644
index 0000000..92ab32c
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-19-hierarchical-auction-fixes.md
@@ -0,0 +1,638 @@
+# Hierarchical Auction — Post-Review Fixes
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:subagent-driven-development` (recommended) or `superpowers:executing-plans` to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Fix the six correctness and quality issues identified during code review of the `hierarchical_auction/` package, and add the three missing test scenarios.
+
+**Architecture:** All changes are surgical — no file structure changes, no new modules. Task 4 is pure cleanup (no new tests needed). Tasks 1-3 follow TDD: failing test first, then fix.
+
+**Tech Stack:** Python 3.10, NumPy, pytest, ruff, mypy, networkx, scipy (for `.toarray()`).
+
+---
+
+## Issues Addressed
+
+| # | Severity | Summary |
+|---|----------|---------|
+| 1 | Critical | Structure price caching uses zero as sentinel → stale/repeated computation |
+| 2 | Critical | Latency hardcoded to zeros in runner → `latency_weight` is inert in production |
+| 3 | Important | `check_global_feasibility()` never called → Invariant 3 has no runtime guard |
+| 4 | Important | `omega = result.omega` on runner:252 is overwritten unconditionally → dead assignment |
+| 5 | Minor | `bid_price` field on `Structure` is never written → dead state |
+| 6 | Important | `__init__.py` exports only types, not `HierarchicalAuctionEngine` / `LevelResult` |
+| T1 | Coverage | No test for engine early termination when no allocations produced at a level |
+| T2 | Coverage | No test for multi-level cascade with demand propagation through levels |
+| T3 | Coverage | No test that calls `check_global_feasibility()` as an invariant assertion |
+
+---
+
+## File Map
+
+Modify only:
+- `hierarchical_auction/engine.py` — Tasks 1, 3
+- `hierarchical_auction/runner.py` — Tasks 2, 4
+- `hierarchical_auction/structure.py` — Task 5 (remove `bid_price`)
+- `hierarchical_auction/__init__.py` — Task 6
+- `tests/test_hierarchical_engine.py` — Tasks 1, T1, T2
+- `tests/test_hierarchical_runner.py` — Task 2
+- `tests/test_hierarchical_token_manager.py` — Tasks 3, T3
+
+---
+
+## Task 1: Fix Structure Price Caching Bug
+
+**Files:**
+- Modify: `hierarchical_auction/engine.py:241-250`
+- Modify: `tests/test_hierarchical_engine.py`
+
+The guard `if np.allclose(buyer_s.structure_price, 0.0)` uses the initial all-zeros value as a "not yet computed" sentinel. In a zero-price network (node_prices all zero, eta=0), the legitimate price is also zero — the guard fires on every function iteration and recomputes unnecessarily. More importantly, the code placement (inside the `for f` loop) is misleading: `compute_structure_price` returns an array over *all* functions at once, so it must be called once per structure, not once per (structure, function) with a fragile zero-sentinel.
+
+**Fix:** Move the call outside the function loop, compute unconditionally.
+
+- [ ] **Step 1: Write failing test for two-function zero-price network**
+
+Add to `tests/test_hierarchical_engine.py`:
+
+```python
+def test_price_computed_correctly_in_zero_price_two_function_network():
+    """Regression: caching guard must not skip recomputation in zero-price network.
+
+    With eta=0, structure_price = avg(node_prices) = 0.  The effective bid equals
+    epsilon > 0, so allocation should still happen even when all prices are zero.
+    """
+    neighborhood = np.array([
+        [0, 1, 0],
+        [1, 0, 1],
+        [0, 1, 0],
+    ], dtype=float)
+    engine = HierarchicalAuctionEngine(
+        neighborhood=neighborhood,
+        num_functions=2,
+        service_quantum=np.array([1.0, 1.0]),
+        max_depth=2,
+        auction_options={
+            "epsilon": 0.01,
+            "eta": [0.0, 0.0],
+            "latency_weight": 0.0,
+            "fairness_weight": 0.0,
+        },
+    )
+
+    result = engine.run_higher_levels(
+        y=np.zeros((3, 3, 2)),
+        omega=np.array([[3.0, 2.0], [0.0, 0.0], [0.0, 0.0]]),
+        residual_capacity=np.array([[0.0, 0.0], [0.0, 0.0], [5.0, 5.0]]),
+        node_prices=np.zeros((3, 2)),
+        latency=np.zeros((3, 3)),
+        fairness=np.zeros((3, 2)),
+    )
+
+    # With zero prices and eta=0, bid = max(0 + 0.01, 0) = 0.01 > 0
+    # Both functions should be allocated from node 0 to node 2
+    assert result.y[0, 2, 0] == 3.0
+    assert result.y[0, 2, 1] == 2.0
+    assert result.omega[0, 0] == 0.0
+    assert result.omega[0, 1] == 0.0
+```
+
+- [ ] **Step 2: Run test to verify it fails (or passes — note the result)**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py::test_price_computed_correctly_in_zero_price_two_function_network -v`
+
+Note: if this passes, the bug is latent (logic is correct but code is fragile). Proceed to the fix regardless — the test locks in correct behavior.
+
+- [ ] **Step 3: Move compute_structure_price outside the function loop**
+
+In `hierarchical_auction/engine.py`, the `_generate_level_requests` method. Find the loop starting at line ~241:
+
+```python
+    for root, buyer_s in buyer_structures.items():
+      for f in range(self._num_functions):
+        if not buyer_s.is_buyer(f):
+          continue
+
+        # Compute structure price once per (structure, function)
+        if np.allclose(buyer_s.structure_price, 0.0):
+          buyer_s.structure_price = compute_structure_price(
+            buyer_s, node_prices, token_manager.tokens, eta=eta,
+          )
+
+        # Find seller nodes in adjacent structures
+```
+
+Replace with:
+
+```python
+    for root, buyer_s in buyer_structures.items():
+      buyer_s.structure_price = compute_structure_price(
+        buyer_s, node_prices, token_manager.tokens, eta=eta,
+      )
+      for f in range(self._num_functions):
+        if not buyer_s.is_buyer(f):
+          continue
+
+        # Find seller nodes in adjacent structures
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py -v`
+
+Expected: all engine tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/engine.py tests/test_hierarchical_engine.py
+git commit -m "fix: compute structure price unconditionally per structure, not per function"
+```
+
+---
+
+## Task 2: Wire Real Latency from Graph in Runner
+
+**Files:**
+- Modify: `hierarchical_auction/runner.py`
+- Modify: `tests/test_hierarchical_runner.py`
+
+Both `define_bids` and `engine.run_higher_levels` receive `latency=np.zeros((Nn, Nn))`. The `latency_weight` config option is therefore inert in production: `latency_weight * 0 = 0` always. The fix follows the exact pattern used in `decentralized_auction.py` (line 311) and `run_faasmadea.py` (line 280).
+
+The networkx `adjacency_matrix` function returns a scipy sparse matrix; use `.toarray()` to get a dense numpy array compatible with the `engine.py` type annotation `latency: np.ndarray`.
+
+- [ ] **Step 1: Write failing test for latency extraction helper**
+
+Add to `tests/test_hierarchical_runner.py`:
+
+```python
+def test_extract_graph_latency_returns_numpy_array_with_edge_weights():
+    import networkx as nx
+    from hierarchical_auction.runner import _extract_latency
+
+    g = nx.path_graph(3)
+    nx.set_edge_attributes(
+        g, {(0, 1): 5.0, (1, 2): 3.0}, "network_latency"
+    )
+    lat = _extract_latency(g)
+
+    assert isinstance(lat, np.ndarray)
+    assert lat.shape == (3, 3)
+    assert lat[0, 1] == 5.0
+    assert lat[1, 0] == 5.0   # undirected
+    assert lat[1, 2] == 3.0
+    assert lat[0, 0] == 0.0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py::test_extract_graph_latency_returns_numpy_array_with_edge_weights -v`
+
+Expected: FAIL with `ImportError: cannot import name '_extract_latency'`.
+
+- [ ] **Step 3: Add `_extract_latency` helper and wire it into `run()`**
+
+In `hierarchical_auction/runner.py`:
+
+**3a.** Add the import at the top of the file (after the existing imports):
+
+```python
+from networkx import adjacency_matrix as nx_adjacency_matrix
+```
+
+**3b.** Add the helper function after `compute_offloaded_demand` (around line 91):
+
+```python
+def _extract_latency(graph: Any) -> np.ndarray:
+    return nx_adjacency_matrix(graph, weight="network_latency").toarray()
+```
+
+**3c.** In `run()`, after `init_problem` sets up `graph` (around line 137), add latency extraction **before** the time loop:
+
+Find the block:
+```python
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn,
+  )
+```
+
+Replace with:
+```python
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn,
+  )
+  latency = _extract_latency(graph)
+```
+
+**3d.** In the level-1 `define_bids` call (around line 193), replace:
+```python
+        latency=np.zeros((Nn, Nn)),
+```
+with:
+```python
+        latency=latency,
+```
+
+**3e.** In the `engine.run_higher_levels` call (around line 248), replace:
+```python
+        latency=np.zeros((Nn, Nn)),
+```
+with:
+```python
+        latency=latency,
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py -v`
+
+Expected: all runner tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/runner.py tests/test_hierarchical_runner.py
+git commit -m "fix: extract real latency from graph; latency_weight now effective in production"
+```
+
+---
+
+## Task 3: Enforce Global Feasibility Invariant
+
+**Files:**
+- Modify: `hierarchical_auction/engine.py`
+- Modify: `tests/test_hierarchical_token_manager.py`
+
+`check_global_feasibility()` exists and is correct (`token_manager.py:119-122`) but is never called. This leaves Invariant 3 (`sum_accepted_to_node[k,f] <= initial_tokens[k,f]`) without any runtime guard. An assertion after the level loop in `run_higher_levels` catches token accounting bugs immediately.
+
+- [ ] **Step 1: Write failing test for check_global_feasibility**
+
+Add to `tests/test_hierarchical_token_manager.py`:
+
+```python
+def test_check_global_feasibility_detects_over_committed_state():
+    manager = CapacityTokenManager(np.array([[3.0]]), np.array([1.0]))
+    # Manually corrupt the token state to simulate over-commitment
+    manager._current_tokens[0, 0] = -1  # type: ignore[attr-defined]
+    assert manager.check_global_feasibility() is False
+
+
+def test_check_global_feasibility_passes_after_valid_commits():
+    manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+    manager.request(make_request(1, 6, 10.0))
+    accepted = manager.resolve_node_function(0, 0)
+    manager.commit(accepted)
+    assert manager.check_global_feasibility() is True
+```
+
+- [ ] **Step 2: Run tests to verify**
+
+Run: `uv run pytest tests/test_hierarchical_token_manager.py -v`
+
+Note: these should already PASS (the method works). If they fail, the method has a bug — fix it before continuing.
+
+- [ ] **Step 3: Add assertion to engine after level loop**
+
+In `hierarchical_auction/engine.py`, at the end of `run_higher_levels` just before the `return` statement (around line 170):
+
+Find:
+```python
+    return LevelResult(
+      y=current_y,
+      omega=current_omega,
+      accepted_allocations=all_accepted,
+    )
+```
+
+Replace with:
+```python
+    assert token_manager.check_global_feasibility(), (
+      "Invariant 3 violated: committed tokens exceed initial tokens for some (k,f)"
+    )
+    return LevelResult(
+      y=current_y,
+      omega=current_omega,
+      accepted_allocations=all_accepted,
+    )
+```
+
+- [ ] **Step 4: Verify all engine tests still pass**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py tests/test_hierarchical_token_manager.py -v`
+
+Expected: all PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/engine.py tests/test_hierarchical_token_manager.py
+git commit -m "fix: assert global feasibility invariant after each run_higher_levels call"
+```
+
+---
+
+## Task 4: Remove Dead Code and Fix Exports
+
+**Files:**
+- Modify: `hierarchical_auction/runner.py`
+- Modify: `hierarchical_auction/structure.py`
+- Modify: `hierarchical_auction/__init__.py`
+
+Three small cleanup changes with no behavior impact. No new tests required.
+
+**4a — Remove redundant `omega` assignment (runner.py:252)**
+
+In `run()`, after `engine.run_higher_levels` returns, the line `omega = result.omega` is immediately overwritten by `omega[i, f] = sp_omega[i, f] - rmp_omega[i, f]` inside the `if result.accepted_allocations:` block. The `result.omega` assignment is dead.
+
+Find block (around line 250):
+```python
+      y = result.y
+      omega = result.omega
+      rmp_omega = compute_offloaded_demand(y)
+```
+
+Replace with:
+```python
+      y = result.y
+      rmp_omega = compute_offloaded_demand(y)
+```
+
+**4b — Remove `bid_price` dead field from `Structure`**
+
+`bid_price` is declared in `structure.py` but never assigned anywhere in the engine, runner, or tests.
+
+In `hierarchical_auction/structure.py`, remove the two lines:
+```python
+  bid_price: np.ndarray = field(init=False)
+```
+and (inside `__post_init__`):
+```python
+    self.bid_price = np.zeros(self.num_functions, dtype=float)
+```
+
+**4c — Export `HierarchicalAuctionEngine` and `LevelResult` from `__init__.py`**
+
+Replace the content of `hierarchical_auction/__init__.py` with:
+
+```python
+from hierarchical_auction.engine import HierarchicalAuctionEngine, LevelResult
+from hierarchical_auction.types import AcceptedAllocation, TokenRequest
+
+__all__ = [
+  "AcceptedAllocation",
+  "HierarchicalAuctionEngine",
+  "LevelResult",
+  "TokenRequest",
+]
+```
+
+**4d — Document `zeta` in `build_auction_options`**
+
+`zeta` is intentionally forwarded: `evaluate_bids` (level-1 price dampening) consumes it via `level1_options`. Add one comment so future readers understand.
+
+In `hierarchical_auction/runner.py`, in `build_auction_options`:
+```python
+def build_auction_options(config: dict) -> dict:
+  solver_options = config.get("solver_options", {})
+  auction = solver_options.get("auction", {})
+  return {
+    "epsilon": auction.get("epsilon", 0.01),
+    "eta": auction.get("eta", [0.5, 0.3, 0.1]),
+    "zeta": auction.get("zeta", 0.1),   # consumed by evaluate_bids (level-1 price dampening)
+    "latency_weight": auction.get("latency_weight", 0.0),
+    "fairness_weight": auction.get("fairness_weight", 0.0),
+  }
+```
+
+- [ ] **Step 1: Apply all four sub-changes above**
+
+- [ ] **Step 2: Run full hierarchical test suite**
+
+Run: `uv run pytest tests/test_hierarchical_types.py tests/test_hierarchical_structure_graph.py tests/test_hierarchical_token_manager.py tests/test_hierarchical_pricing.py tests/test_hierarchical_flow_mapper.py tests/test_hierarchical_engine.py tests/test_hierarchical_runner.py -v`
+
+Expected: all PASS.
+
+- [ ] **Step 3: Update smoke test in test_coverage_expansion.py**
+
+Find in `tests/test_coverage_expansion.py`:
+```python
+def test_hierarchical_auction_public_imports():
+  import hierarchical_auction as ha
+
+  assert ha.AcceptedAllocation is not None
+  assert ha.TokenRequest is not None
+```
+
+Replace with:
+```python
+def test_hierarchical_auction_public_imports():
+  import hierarchical_auction as ha
+
+  assert ha.AcceptedAllocation is not None
+  assert ha.TokenRequest is not None
+  assert ha.HierarchicalAuctionEngine is not None
+  assert ha.LevelResult is not None
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add hierarchical_auction/runner.py hierarchical_auction/structure.py hierarchical_auction/__init__.py tests/test_coverage_expansion.py
+git commit -m "refactor: remove dead omega assignment and bid_price field; expand public exports"
+```
+
+---
+
+## Task 5: Add Missing Engine Tests
+
+**Files:**
+- Modify: `tests/test_hierarchical_engine.py`
+
+Two test scenarios required by the plan's coverage checklist:
+1. Engine stops early when no level produces allocations (the `break` at engine.py:158 is untested).
+2. Multi-level cascade: demand is only satisfiable at level 3, verifying `current_omega` propagates correctly through `apply_allocations` → `_aggregate_residual_demand`.
+
+- [ ] **Step 1: Write the two failing tests**
+
+Add to `tests/test_hierarchical_engine.py`:
+
+```python
+def test_engine_stops_early_when_no_capacity_available():
+    """No seller has capacity → accepted_allocations is empty and engine does not loop forever."""
+    neighborhood = np.array([
+        [0, 1, 0],
+        [1, 0, 1],
+        [0, 1, 0],
+    ], dtype=float)
+    engine = HierarchicalAuctionEngine(
+        neighborhood=neighborhood,
+        num_functions=1,
+        service_quantum=np.array([1.0]),
+        max_depth=5,
+        auction_options={
+            "epsilon": 0.01,
+            "eta": [0.5, 0.3, 0.2, 0.1, 0.05],
+            "latency_weight": 0.0,
+            "fairness_weight": 0.0,
+        },
+    )
+
+    result = engine.run_higher_levels(
+        y=np.zeros((3, 3, 1)),
+        omega=np.array([[3.0], [0.0], [0.0]]),
+        residual_capacity=np.zeros((3, 1)),   # no capacity anywhere
+        node_prices=np.zeros((3, 1)),
+        latency=np.zeros((3, 3)),
+        fairness=np.zeros((3, 1)),
+    )
+
+    assert result.accepted_allocations == []
+    assert result.omega[0, 0] == 3.0          # demand unchanged
+    assert result.y[0, :, 0].sum() == 0.0
+
+
+def test_engine_level3_cascade_satisfies_demand_beyond_direct_neighbors():
+    """Demand at node 0 is satisfied by node 4 reachable only at level 3.
+
+    Topology: linear chain 0-1-2-3-4
+    - omega[0,f] = 2.0; all other nodes have no demand
+    - residual_capacity[4,f] = 5.0; all other nodes have no capacity
+    At level 2, S_0^(2) merges with S_1^(1) → covers {0,1,2}.  Node 4 is
+    still not reachable.  At level 3 (if aggregation reaches it), node 4
+    becomes accessible.  The engine must complete without error and must not
+    over-allocate.
+    """
+    n = 5
+    neighborhood = np.zeros((n, n), dtype=float)
+    for i in range(n - 1):
+        neighborhood[i, i + 1] = 1.0
+        neighborhood[i + 1, i] = 1.0
+
+    engine = HierarchicalAuctionEngine(
+        neighborhood=neighborhood,
+        num_functions=1,
+        service_quantum=np.array([1.0]),
+        max_depth=4,
+        auction_options={
+            "epsilon": 0.01,
+            "eta": [0.5, 0.4, 0.3, 0.2],
+            "latency_weight": 0.0,
+            "fairness_weight": 0.0,
+        },
+    )
+
+    result = engine.run_higher_levels(
+        y=np.zeros((n, n, 1)),
+        omega=np.array([[2.0], [0.0], [0.0], [0.0], [0.0]]),
+        residual_capacity=np.array([[0.0], [0.0], [0.0], [0.0], [5.0]]),
+        node_prices=np.zeros((n, 1)),
+        latency=np.zeros((n, n)),
+        fairness=np.zeros((n, 1)),
+    )
+
+    # Whether or not level 3 reaches node 4 depends on aggregation depth;
+    # what must hold unconditionally:
+    assert result.omega[0, 0] >= 0.0             # demand is non-negative
+    assert result.y.sum() == pytest.approx(2.0 - result.omega[0, 0])  # flow = allocated
+    assert result.y[0, 0, 0] == 0.0              # no self-allocation
+    # If any allocation happened, committed tokens must not exceed initial
+    # (the engine assertion already checks this, but re-test explicitly)
+    total_allocated = result.y[0, :, 0].sum()
+    assert total_allocated <= 2.0
+```
+
+At the top of the test file, ensure `pytest` is imported:
+
+```python
+import pytest
+```
+
+(Add this if not already present.)
+
+- [ ] **Step 2: Run the new tests to verify they pass**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py -v`
+
+Expected: all PASS. The cascade test verifies the engine terminates cleanly; the empty-capacity test verifies early exit.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/test_hierarchical_engine.py
+git commit -m "test: add engine early-termination and multi-level cascade tests"
+```
+
+---
+
+## Task 6: Quality Gates
+
+**Files:** none (read-only verification)
+
+- [ ] **Step 1: Run full hierarchical test suite**
+
+```bash
+uv run pytest tests/test_hierarchical_types.py \
+  tests/test_hierarchical_structure_graph.py \
+  tests/test_hierarchical_token_manager.py \
+  tests/test_hierarchical_pricing.py \
+  tests/test_hierarchical_flow_mapper.py \
+  tests/test_hierarchical_engine.py \
+  tests/test_hierarchical_runner.py \
+  tests/test_coverage_expansion.py \
+  -v
+```
+
+Expected: all PASS.
+
+- [ ] **Step 2: Run full test suite with coverage**
+
+```bash
+uv run pytest --cov --cov-report=term-missing -q
+```
+
+Expected: PASS, total coverage ≥ 50%.
+
+- [ ] **Step 3: Run linting and type checking**
+
+```bash
+uv run ruff check .
+uv run mypy
+```
+
+Expected: both pass with zero errors. If `mypy` reports `_extract_latency` return type, add the annotation:
+
+```python
+def _extract_latency(graph: Any) -> np.ndarray:
+```
+
+(`Any` is already used in the runner's type annotations; `np.ndarray` is the correct return type.)
+
+- [ ] **Step 4: Run GitNexus change detection**
+
+```bash
+gitnexus detect_changes
+```
+
+Expected: no HIGH or CRITICAL risk without explicit review.
+
+- [ ] **Step 5: Final summary commit (if any loose files remain)**
+
+```bash
+git status
+```
+
+If any modified files were missed by earlier task commits, add them now.
+
+---
+
+## Self-Review Checklist
+
+- [x] All 8 non-negotiable invariants addressed: Invariant 3 now has runtime enforcement.
+- [x] Structure price caching replaced with unconditional computation per structure.
+- [x] Real latency extracted from graph; `latency_weight` is now effective in production.
+- [x] `omega = result.omega` dead assignment removed.
+- [x] `bid_price` dead field removed from `Structure`.
+- [x] `__init__.py` exports `HierarchicalAuctionEngine` and `LevelResult`.
+- [x] `zeta` documented (consumed by level-1 `evaluate_bids`).
+- [x] Early termination path tested explicitly.
+- [x] Multi-level cascade tested for correctness and no over-allocation.
+- [x] `check_global_feasibility` tested both pass and fail paths.
+- [x] No new files created; no existing behavior changed beyond the identified fixes.
diff --git a/docs/superpowers/plans/2026-05-19-hierarchical-auction.md b/docs/superpowers/plans/2026-05-19-hierarchical-auction.md
new file mode 100644
index 0000000..237c364
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-19-hierarchical-auction.md
@@ -0,0 +1,774 @@
+# Hierarchical Auction Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:subagent-driven-development` (recommended) or `superpowers:executing-plans` to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Implement the hierarchical multi-structure auction from `Decentralized_FaaS_coordination.pdf` Sections 4.5-4.7 so accepted higher-level reservations become concrete node-to-node FaaS offloading flows and remain compatible with the existing experiment pipeline.
+
+**Architecture:** Build a new `hierarchical_auction/` package around explicit allocation records. Structures coordinate demand, but capacity remains node-owned; every accepted token must map to a concrete `(buyer_node, seller_node, function, quantity)` allocation and update the normal `y[i,j,f]` matrix. Keep the first implementation runnable through a standalone runner, then integrate with `run.py` only after output files match the existing `faas-madea` conventions.
+
+**Tech Stack:** Python 3.10, NumPy, Pandas, existing Pyomo runners and utilities, pytest, ruff, mypy.
+
+---
+
+## Non-Negotiable Invariants
+
+These invariants come directly from the PDF and must be tested before the runner is considered correct:
+
+1. Structures never own capacity. Node `k` owns tokens `T[k,f] = floor(C[k,f] / delta[f])`.
+2. Multiple structures may request the same `(k,f)` capacity. Conflict resolution happens after all requests are collected.
+3. Accepted reservations must satisfy `sum_accepted_to_node[k,f] <= initial_tokens[k,f]` across all levels.
+4. Every accepted reservation must map to one or more concrete flows `y[buyer_node, seller_node, f]`.
+5. Residual demand after a level is computed from concrete allocations, not from abstract structure counters.
+6. Higher levels query adjacent structures and candidate seller nodes inside those adjacent structures.
+7. Structure price is only an indicative congestion signal; it must not imply ownership of aggregate tokens.
+8. The runner must emit the same artifact shape expected by existing postprocessing: solution CSVs, `obj.csv`, `termination_condition.csv`, and checkpoints when configured.
+
+---
+
+## File Structure
+
+Create:
+
+- `hierarchical_auction/__init__.py`: public exports.
+- `hierarchical_auction/types.py`: dataclasses for token requests and accepted allocations.
+- `hierarchical_auction/structure.py`: `Structure` dataclass and demand helpers.
+- `hierarchical_auction/structure_graph.py`: level-1 structures, adjacency, recursive aggregation.
+- `hierarchical_auction/token_manager.py`: request collection, conflict resolution, cumulative token commits.
+- `hierarchical_auction/pricing.py`: structure prices, structure bids, effective seller-side bid values.
+- `hierarchical_auction/flow_mapper.py`: convert accepted tokens into concrete `y` updates.
+- `hierarchical_auction/engine.py`: level-by-level orchestration around existing one-hop auction state.
+- `hierarchical_auction/runner.py`: standalone `run(config, ...)` entry point.
+
+Create tests:
+
+- `tests/test_hierarchical_types.py`
+- `tests/test_hierarchical_structure_graph.py`
+- `tests/test_hierarchical_token_manager.py`
+- `tests/test_hierarchical_pricing.py`
+- `tests/test_hierarchical_flow_mapper.py`
+- `tests/test_hierarchical_engine.py`
+- `tests/test_hierarchical_runner.py`
+
+Modify only after the standalone runner is verified:
+
+- `run.py`: add `hierarchical` to method choices and experiment bookkeeping.
+- `tests/test_coverage_expansion.py`: add import smoke coverage for the new package.
+
+---
+
+## Task 1: Allocation Types
+
+**Files:**
+- Create: `hierarchical_auction/types.py`
+- Create: `hierarchical_auction/__init__.py`
+- Create: `tests/test_hierarchical_types.py`
+
+- [ ] **Step 1: Write failing tests for request and allocation records**
+
+```python
+import pytest
+
+from hierarchical_auction.types import AcceptedAllocation, TokenRequest
+
+
+def test_token_request_rejects_negative_quantity():
+  with pytest.raises(ValueError, match="tokens must be positive"):
+    TokenRequest(
+      level=2,
+      buyer_structure=0,
+      buyer_node=0,
+      seller_node=1,
+      function=0,
+      tokens=0,
+      bid_value=1.0,
+      quantity=0.0,
+    )
+
+
+def test_accepted_allocation_records_concrete_flow():
+  allocation = AcceptedAllocation(
+    level=2,
+    buyer_structure=0,
+    buyer_node=0,
+    seller_node=3,
+    function=1,
+    tokens=4,
+    quantity=4.0,
+    bid_value=2.5,
+  )
+  assert allocation.buyer_node == 0
+  assert allocation.seller_node == 3
+  assert allocation.function == 1
+  assert allocation.quantity == 4.0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_types.py -q`
+
+Expected: FAIL with `ModuleNotFoundError: No module named 'hierarchical_auction'`.
+
+- [ ] **Step 3: Implement minimal dataclasses**
+
+```python
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TokenRequest:
+  level: int
+  buyer_structure: int
+  buyer_node: int
+  seller_node: int
+  function: int
+  tokens: int
+  bid_value: float
+  quantity: float
+
+  def __post_init__(self) -> None:
+    if self.tokens <= 0:
+      raise ValueError("tokens must be positive")
+    if self.quantity <= 0:
+      raise ValueError("quantity must be positive")
+
+
+@dataclass(frozen=True)
+class AcceptedAllocation:
+  level: int
+  buyer_structure: int
+  buyer_node: int
+  seller_node: int
+  function: int
+  tokens: int
+  quantity: float
+  bid_value: float
+```
+
+`hierarchical_auction/__init__.py`:
+
+```python
+from hierarchical_auction.types import AcceptedAllocation, TokenRequest
+
+__all__ = [
+  "AcceptedAllocation",
+  "TokenRequest",
+]
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_types.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/__init__.py hierarchical_auction/types.py tests/test_hierarchical_types.py
+git commit -m "feat: add hierarchical auction allocation types"
+```
+
+---
+
+## Task 2: Structures and Structure Graph
+
+**Files:**
+- Create: `hierarchical_auction/structure.py`
+- Create: `hierarchical_auction/structure_graph.py`
+- Create: `tests/test_hierarchical_structure_graph.py`
+
+- [ ] **Step 1: Write failing graph tests**
+
+```python
+import numpy as np
+
+from hierarchical_auction.structure_graph import StructureGraph
+
+
+def chain_graph(size: int) -> np.ndarray:
+  graph = np.zeros((size, size), dtype=float)
+  for i in range(size - 1):
+    graph[i, i + 1] = 1.0
+    graph[i + 1, i] = 1.0
+  return graph
+
+
+def test_level1_structure_is_one_hop_neighborhood():
+  sg = StructureGraph(chain_graph(4))
+  structures = sg.build_level1(num_functions=2)
+  assert structures[0].member_nodes == {0, 1}
+  assert structures[1].member_nodes == {0, 1, 2}
+  assert structures[2].member_nodes == {1, 2, 3}
+  assert structures[3].member_nodes == {2, 3}
+
+
+def test_adjacency_uses_physical_edge_between_members():
+  sg = StructureGraph(chain_graph(4))
+  structures = sg.build_level1(num_functions=1)
+  assert sg.are_adjacent(structures[0], structures[2]) is True
+  assert sg.are_adjacent(structures[0], structures[3]) is False
+
+
+def test_aggregation_rebuilds_adjacency_for_new_level():
+  sg = StructureGraph(chain_graph(5))
+  level1 = sg.build_level1(num_functions=1)
+  level2 = sg.aggregate_to_next_level(level1, num_functions=1)
+  assert all(s.level == 2 for s in level2.values())
+  assert level1[0].member_nodes.issubset(level2[0].member_nodes)
+  assert all(root not in s.adjacent_structures for root, s in level2.items())
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_structure_graph.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement `Structure` and `StructureGraph`**
+
+Implementation rules:
+
+- `Structure.residual_demand`, `structure_price`, `indicative_tokens`, and `bid_price` are NumPy arrays of shape `(num_functions,)`.
+- `build_level1()` must call `build_adjacency()`.
+- `aggregate_to_next_level()` must merge the root structure with its adjacent previous-level structures, then call `build_adjacency()` on the new level. Do not inherit stale adjacency sets.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_structure_graph.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/structure.py hierarchical_auction/structure_graph.py tests/test_hierarchical_structure_graph.py
+git commit -m "feat: add hierarchical structure graph"
+```
+
+---
+
+## Task 3: Token Manager With Deferred Conflict Resolution
+
+**Files:**
+- Create: `hierarchical_auction/token_manager.py`
+- Create: `tests/test_hierarchical_token_manager.py`
+
+- [ ] **Step 1: Write failing token tests**
+
+```python
+import numpy as np
+
+from hierarchical_auction.token_manager import CapacityTokenManager
+from hierarchical_auction.types import TokenRequest
+
+
+def make_request(root: int, tokens: int, bid: float) -> TokenRequest:
+  return TokenRequest(
+    level=2,
+    buyer_structure=root,
+    buyer_node=root,
+    seller_node=0,
+    function=0,
+    tokens=tokens,
+    bid_value=bid,
+    quantity=float(tokens),
+  )
+
+
+def test_collects_oversubscribed_requests_before_resolution():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 6, 10.0))
+  manager.request(make_request(2, 8, 5.0))
+  assert len(manager.pending_requests(0, 0)) == 2
+  assert manager.available_tokens(0, 0) == 10
+
+
+def test_resolve_conflicts_does_not_exceed_node_tokens():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 6, 10.0))
+  manager.request(make_request(2, 8, 5.0))
+  accepted = manager.resolve_node_function(0, 0)
+  assert sum(a.tokens for a in accepted) == 10
+  assert accepted[0].buyer_structure == 1
+  assert accepted[0].tokens == 6
+  assert accepted[1].tokens == 4
+
+
+def test_commit_is_cumulative_across_rounds():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 4, 1.0))
+  accepted = manager.resolve_node_function(0, 0)
+  manager.commit(accepted)
+  assert manager.available_tokens(0, 0) == 6
+
+  manager.request(make_request(2, 5, 1.0))
+  accepted = manager.resolve_node_function(0, 0)
+  manager.commit(accepted)
+  assert manager.available_tokens(0, 0) == 1
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_token_manager.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement token manager**
+
+Implementation rules:
+
+- `request()` appends to pending requests and does not reduce availability.
+- `resolve_node_function(k, f)` sorts by descending effective `bid_value` and accepts full or partial token quantities until capacity is exhausted.
+- `commit(allocations)` subtracts from current tokens, not from initial tokens.
+- `check_global_feasibility()` validates committed allocations against initial tokens.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_token_manager.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/token_manager.py tests/test_hierarchical_token_manager.py
+git commit -m "feat: add cumulative hierarchical token manager"
+```
+
+---
+
+## Task 4: Pricing and Effective Bid Values
+
+**Files:**
+- Create: `hierarchical_auction/pricing.py`
+- Create: `tests/test_hierarchical_pricing.py`
+
+- [ ] **Step 1: Write failing pricing tests**
+
+```python
+import numpy as np
+import pytest
+
+from hierarchical_auction.pricing import (
+  compute_effective_bid,
+  compute_structure_price,
+  generate_structure_bid,
+)
+from hierarchical_auction.structure import Structure
+
+
+def test_structure_price_matches_pdf_equation_27():
+  structure = Structure(level=2, root_node=0, member_nodes={0, 1}, num_functions=1)
+  structure.residual_demand[:] = [6.0]
+  node_prices = np.array([[0.2], [0.4]])
+  node_tokens = np.array([[4], [2]])
+  price = compute_structure_price(structure, node_prices, node_tokens, eta=0.5)
+  assert price[0] == pytest.approx(0.3 + 0.5 * (6.0 / (6.0 + 6.0 + 1e-6)))
+
+
+def test_bid_to_node_is_at_least_node_price():
+  structure_price = 0.1
+  node_price = 0.5
+  assert generate_structure_bid(structure_price, node_price, epsilon=0.01) == 0.5
+
+
+def test_effective_bid_penalizes_latency_and_fairness():
+  effective = compute_effective_bid(
+    bid=2.0,
+    node_price=0.5,
+    latency=3.0,
+    fairness=4.0,
+    latency_weight=0.1,
+    fairness_weight=0.2,
+  )
+  assert effective == pytest.approx(2.0 - 0.5 - 0.3 - 0.8)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_pricing.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement pricing helpers**
+
+Implementation rules:
+
+- `compute_structure_price()` implements PDF Eq.27.
+- `generate_structure_bid(structure_price, node_price, epsilon)` implements Eq.28 plus Eq.22 with `max(structure_price + epsilon, node_price)`.
+- `compute_effective_bid()` implements PDF Eq.19.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_pricing.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/pricing.py tests/test_hierarchical_pricing.py
+git commit -m "feat: add hierarchical structure pricing"
+```
+
+---
+
+## Task 5: Flow Mapping
+
+**Files:**
+- Create: `hierarchical_auction/flow_mapper.py`
+- Create: `tests/test_hierarchical_flow_mapper.py`
+
+- [ ] **Step 1: Write failing flow mapping tests**
+
+```python
+import numpy as np
+
+from hierarchical_auction.flow_mapper import apply_allocations
+from hierarchical_auction.types import AcceptedAllocation
+
+
+def test_apply_allocations_updates_y_and_residual_demand():
+  y = np.zeros((3, 3, 1))
+  omega = np.array([[5.0], [0.0], [0.0]])
+  allocations = [
+    AcceptedAllocation(
+      level=2,
+      buyer_structure=0,
+      buyer_node=0,
+      seller_node=2,
+      function=0,
+      tokens=3,
+      quantity=3.0,
+      bid_value=1.0,
+    )
+  ]
+  new_y, new_omega = apply_allocations(y, omega, allocations)
+  assert new_y[0, 2, 0] == 3.0
+  assert new_omega[0, 0] == 2.0
+
+
+def test_apply_allocations_clips_to_remaining_demand():
+  y = np.zeros((2, 2, 1))
+  omega = np.array([[2.0], [0.0]])
+  allocations = [
+    AcceptedAllocation(2, 0, 0, 1, 0, 5, 5.0, 1.0)
+  ]
+  new_y, new_omega = apply_allocations(y, omega, allocations)
+  assert new_y[0, 1, 0] == 2.0
+  assert new_omega[0, 0] == 0.0
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_flow_mapper.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement `apply_allocations()`**
+
+Implementation rules:
+
+- Copy input arrays.
+- For each allocation, add `min(quantity, residual demand)` to `y[buyer_node, seller_node, function]`.
+- Subtract the same quantity from `omega[buyer_node, function]`.
+- Never create negative residual demand.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_flow_mapper.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/flow_mapper.py tests/test_hierarchical_flow_mapper.py
+git commit -m "feat: map hierarchical tokens to flows"
+```
+
+---
+
+## Task 6: Hierarchical Engine
+
+**Files:**
+- Create: `hierarchical_auction/engine.py`
+- Create: `tests/test_hierarchical_engine.py`
+
+- [ ] **Step 1: Write failing engine tests**
+
+```python
+import numpy as np
+
+from hierarchical_auction.engine import HierarchicalAuctionEngine
+
+
+def test_level2_allocates_from_adjacent_structure_seller_node():
+  neighborhood = np.array([
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0],
+  ], dtype=float)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+  y = np.zeros((3, 3, 1))
+  omega = np.array([[3.0], [0.0], [0.0]])
+  residual_capacity = np.array([[0.0], [0.0], [5.0]])
+  node_prices = np.zeros((3, 1))
+  latency = np.zeros((3, 3))
+  fairness = np.zeros((3, 1))
+
+  result = engine.run_higher_levels(
+    y=y,
+    omega=omega,
+    residual_capacity=residual_capacity,
+    node_prices=node_prices,
+    latency=latency,
+    fairness=fairness,
+  )
+
+  assert result.y[0, 2, 0] == 3.0
+  assert result.omega[0, 0] == 0.0
+  assert result.accepted_allocations
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement engine around completed helpers**
+
+Implementation rules:
+
+- Build level 1 structures from the physical graph.
+- At each higher level, aggregate structures, compute residual demand, compute indicative tokens, and generate token requests only for seller nodes in adjacent structures.
+- For each buyer structure, distribute demand to concrete buyer nodes that still have residual `omega`.
+- For each candidate seller node, compute bid with Eq.28/Eq.22 and effective bid with Eq.19.
+- Collect all requests, resolve per `(seller_node, function)`, commit accepted allocations, then call `apply_allocations()`.
+- Stop when no structure has residual demand, no accepted allocations are produced at a level, or `max_depth` is reached.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_engine.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add hierarchical_auction/engine.py tests/test_hierarchical_engine.py
+git commit -m "feat: add hierarchical auction engine"
+```
+
+---
+
+## Task 7: Standalone Runner
+
+**Files:**
+- Create: `hierarchical_auction/runner.py`
+- Create: `tests/test_hierarchical_runner.py`
+
+- [ ] **Step 1: Write failing runner tests**
+
+```python
+from hierarchical_auction.runner import build_auction_options
+
+
+def test_build_auction_options_accepts_scalar_or_list_eta():
+  config = {
+    "solver_options": {
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3],
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      }
+    }
+  }
+  opts = build_auction_options(config)
+  assert opts["eta"] == [0.5, 0.3]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py -q`
+
+Expected: FAIL with import errors.
+
+- [ ] **Step 3: Implement standalone runner**
+
+Implementation rules:
+
+- Reuse `decentralized_auction.run()` structure for initialization, logging, time loop, checkpointing, and saving.
+- Reuse existing one-hop auction functions for level 1.
+- Invoke `HierarchicalAuctionEngine.run_higher_levels()` after level-1 allocation and before convergence checks.
+- Do not pass `None` into `combine_solutions()` where arrays are required; create zero arrays of the correct shape when a component is absent.
+- Save outputs with the `LSPc` prefix so existing postprocessing can parse them.
+
+- [ ] **Step 4: Run runner helper tests**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Run a minimal smoke command**
+
+Use a config where list-valued parameters match dimensions. For `Nn=3`, `memory_capacity.values` must contain three values.
+
+Run: `uv run python -m hierarchical_auction.runner -c config_files/manual_config.json -j 0 --disable_plotting`
+
+Expected: command starts, creates a solution folder, and does not fail during initialization.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add hierarchical_auction/runner.py tests/test_hierarchical_runner.py
+git commit -m "feat: add hierarchical auction runner"
+```
+
+---
+
+## Task 8: `run.py` Integration
+
+**Files:**
+- Modify: `run.py`
+- Create or modify: `tests/test_hierarchical_runner.py`
+
+- [ ] **Step 1: Write failing integration test for method registration**
+
+```python
+from run import parse_arguments
+
+
+def test_run_py_accepts_hierarchical_method(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv",
+    ["run.py", "-c", "config_files/config.json", "--methods", "hierarchical"],
+  )
+  args = parse_arguments()
+  assert args.methods == ["hierarchical"]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py::test_run_py_accepts_hierarchical_method -q`
+
+Expected: FAIL because `hierarchical` is not in argparse choices.
+
+- [ ] **Step 3: Modify `run.py`**
+
+Implementation rules:
+
+- Import `run` from `hierarchical_auction.runner` as `run_hierarchical`.
+- Add `"hierarchical"` to `--methods` choices.
+- Add `"hierarchical": []` to `solution_folders`.
+- Add run flag detection and execution analogous to `faas-madea`.
+- Update result labels in postprocessing dispatch only after verifying output files match existing expectations.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_hierarchical_runner.py::test_run_py_accepts_hierarchical_method -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add run.py tests/test_hierarchical_runner.py
+git commit -m "feat: register hierarchical auction method"
+```
+
+---
+
+## Task 9: Verification and Quality Gates
+
+**Files:**
+- Modify: `tests/test_coverage_expansion.py`
+
+- [ ] **Step 1: Add import smoke test**
+
+```python
+def test_hierarchical_auction_public_imports():
+  import hierarchical_auction as ha
+
+  assert ha.AcceptedAllocation is not None
+  assert ha.TokenRequest is not None
+```
+
+- [ ] **Step 2: Run focused tests**
+
+Run:
+
+```bash
+uv run pytest tests/test_hierarchical_types.py tests/test_hierarchical_structure_graph.py tests/test_hierarchical_token_manager.py tests/test_hierarchical_pricing.py tests/test_hierarchical_flow_mapper.py tests/test_hierarchical_engine.py tests/test_hierarchical_runner.py -q
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Run full test suite with coverage**
+
+Run:
+
+```bash
+uv run pytest --cov --cov-report=term-missing -q
+```
+
+Expected: PASS and total coverage remains at least 50%.
+
+- [ ] **Step 4: Run quality gates**
+
+Run:
+
+```bash
+uv run ruff check .
+uv run mypy
+```
+
+Expected: both pass.
+
+- [ ] **Step 5: Run GitNexus change detection before commit**
+
+Run:
+
+```bash
+gitnexus detect_changes
+```
+
+Expected: no HIGH or CRITICAL risk without explicit review.
+
+- [ ] **Step 6: Final commit**
+
+```bash
+git add hierarchical_auction tests run.py
+git commit -m "feat: add hierarchical multi-structure auction"
+```
+
+---
+
+## Self-Review Checklist
+
+- [x] The plan no longer treats accepted tokens as sufficient by themselves.
+- [x] Every accepted reservation must become concrete `y[buyer,seller,function]`.
+- [x] Token conflict resolution allows oversubscribed pending requests before clearing.
+- [x] Token commits are cumulative.
+- [x] Higher levels query adjacent structures and candidate seller nodes inside those structures.
+- [x] Effective bid logic includes node price, latency, and fairness penalties.
+- [x] Runner integration is separated from the first standalone runner.
+- [x] Existing files are modified only when required for actual `run.py` support.
+- [x] Smoke config warning covers dimension-sensitive fields such as `memory_capacity.values`.
+- [x] Verification includes pytest coverage, ruff, mypy, and GitNexus.
diff --git a/docs/superpowers/plans/2026-05-20-planar-benchmark-csv-html.md b/docs/superpowers/plans/2026-05-20-planar-benchmark-csv-html.md
new file mode 100644
index 0000000..8d85b2e
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-20-planar-benchmark-csv-html.md
@@ -0,0 +1,361 @@
+# Planar Benchmark CSV+HTML Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:subagent-driven-development` (recommended) or `superpowers:executing-plans` to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a standalone benchmark script that runs centralized, distributed, and hierarchical models on planar degree-3 graphs for 20, 40, and 50 nodes across 5 seeds, then writes raw CSV results plus an HTML report with mean and standard deviation for objective and runtime.
+
+**Architecture:** Keep the benchmark isolated from the existing runners. The new script will build one config per `(Nn, seed)`, invoke the three existing run functions directly, collect `objective`, `wallclock_s`, and `termination` into a flat results table, then aggregate by `Nn` and model for a summary CSV and HTML report. No runner internals change; the script only composes existing entry points and the already-fixed planar degree-3 graph generation path.
+
+**Tech Stack:** Python 3.10, pandas, numpy, networkx, existing `run_centralized_model.run`, `run_faasmacro.run`, `hierarchical_auction.runner.run`, pytest, ruff, mypy, standard-library HTML generation.
+
+---
+
+## File Structure
+
+Create:
+
+- `benchmark_planar_3reg.py`: CLI entry point, per-run execution, result extraction, CSV/HTML writing.
+- `tests/test_benchmark_planar_3reg.py`: unit tests for config building, aggregation, HTML rendering, and the orchestration helper.
+
+Do not modify the existing runners unless a test exposes a real bug in shared code. The benchmark should call the already-present run functions and use their generated artifacts.
+
+---
+
+## Task 1: Define the Benchmark Data Model and Summary Helpers
+
+**Files:**
+- Create: `benchmark_planar_3reg.py`
+- Create: `tests/test_benchmark_planar_3reg.py`
+
+- [ ] **Step 1: Write failing tests for summary aggregation and HTML rendering**
+
+Add tests that exercise pure helpers only, using synthetic data:
+
+```python
+import pandas as pd
+
+from benchmark_planar_3reg import aggregate_results, render_html_report
+
+
+def test_aggregate_results_computes_mean_and_std():
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+    {"Nn": 20, "seed": 1, "model": "centralized", "objective": 14.0, "wallclock_s": 3.0},
+    {"Nn": 20, "seed": 0, "model": "hierarchical", "objective": 8.0, "wallclock_s": 2.0},
+    {"Nn": 20, "seed": 1, "model": "hierarchical", "objective": 12.0, "wallclock_s": 4.0},
+  ])
+
+  summary = aggregate_results(raw)
+  row = summary[(summary["Nn"] == 20) & (summary["model"] == "centralized")].iloc[0]
+
+  assert row["objective_mean"] == 12.0
+  assert row["objective_std"] == pytest.approx(2.8284271247)
+  assert row["wallclock_mean_s"] == 2.0
+  assert row["wallclock_std_s"] == pytest.approx(1.4142135623)
+  assert row["runs"] == 2
+
+
+def test_render_html_report_contains_summary_and_raw_tables(tmp_path):
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+  ])
+  summary = pd.DataFrame([
+    {"Nn": 20, "model": "centralized", "objective_mean": 10.0, "objective_std": 0.0,
+     "wallclock_mean_s": 1.0, "wallclock_std_s": 0.0, "runs": 1},
+  ])
+
+  html_path = tmp_path / "report.html"
+  render_html_report(summary, raw, html_path, meta={"sizes": [20, 40, 50], "seeds": [0, 1, 2, 3, 4]})
+
+  text = html_path.read_text()
+  assert "<html" in text.lower()
+  assert "Summary" in text
+  assert "Raw Results" in text
+  assert "centralized" in text
+```
+
+- [ ] **Step 2: Run the tests to verify they fail for missing helpers**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py -q`
+
+Expected: fail because `benchmark_planar_3reg.py` does not exist yet.
+
+- [ ] **Step 3: Implement the pure helpers**
+
+In `benchmark_planar_3reg.py`, add:
+
+```python
+def aggregate_results(raw: pd.DataFrame) -> pd.DataFrame:
+  grouped = raw.groupby(["Nn", "model"], as_index=False).agg(
+    objective_mean=("objective", "mean"),
+    objective_std=("objective", lambda s: s.std(ddof=1)),
+    wallclock_mean_s=("wallclock_s", "mean"),
+    wallclock_std_s=("wallclock_s", lambda s: s.std(ddof=1)),
+    runs=("seed", "count"),
+  )
+  return grouped.sort_values(["Nn", "model"]).reset_index(drop=True)
+
+
+def render_html_report(
+  summary: pd.DataFrame,
+  raw: pd.DataFrame,
+  html_path: Path,
+  meta: dict[str, object],
+) -> None:
+  # Write one HTML file with:
+  # - title and benchmark metadata
+  # - summary table
+  # - raw results table
+  # - minimal inline CSS for readability
+```
+
+Use `pandas.DataFrame.to_html(index=False)` and keep the HTML generation dependency-free.
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add benchmark_planar_3reg.py tests/test_benchmark_planar_3reg.py
+git commit -m "feat: add planar benchmark summary helpers"
+```
+
+---
+
+## Task 2: Build the Benchmark Orchestrator
+
+**Files:**
+- Modify: `benchmark_planar_3reg.py`
+- Modify: `tests/test_benchmark_planar_3reg.py`
+
+The script should run the same benchmark for `Nn = 20, 40, 50` and five seeds by default. Use a fixed two-function workload so the comparison remains meaningful across graph sizes. The three model runners should be executed sequentially for each `(Nn, seed)` pair, with `parallelism=0` and `disable_plotting=True` for reproducibility.
+
+- [ ] **Step 1: Write failing tests for config building and orchestration**
+
+Add tests that monkeypatch the three runner functions and the metric reader so no solver is needed:
+
+```python
+from pathlib import Path
+
+import pandas as pd
+
+from benchmark_planar_3reg import build_base_config, run_benchmark
+
+
+def test_build_base_config_uses_requested_sizes_and_seed(tmp_path):
+  config = build_base_config(tmp_path, nn=20, seed=3)
+  assert config["limits"]["Nn"]["min"] == 20
+  assert config["limits"]["Nn"]["max"] == 20
+  assert config["seed"] == 3
+  assert config["solver_name"] == "gurobi"
+  assert config["limits"]["neighborhood"] == {"type": "planar", "degree": 3}
+
+
+def test_run_benchmark_collects_three_models(monkeypatch, tmp_path):
+  def fake_run(_config, **_kwargs):
+    folder = tmp_path / "fake"
+    folder.mkdir(exist_ok=True)
+    pd.DataFrame({"LoadManagementModel": [11.0]}).to_csv(folder / "obj.csv", index=False)
+    pd.DataFrame({"runtime": [1.0]}).to_csv(folder / "runtime.csv", index=False)
+    pd.DataFrame({"0": ["optimal"]}).to_csv(folder / "termination_condition.csv", index=False)
+    return str(folder)
+
+  monkeypatch.setattr("benchmark_planar_3reg.run_centralized", fake_run)
+  monkeypatch.setattr("benchmark_planar_3reg.run_distributed", fake_run)
+  monkeypatch.setattr("benchmark_planar_3reg.run_hierarchical", fake_run)
+
+  raw = run_benchmark(output_root=tmp_path, sizes=[20], seeds=[0], solver_name="gurobi")
+  assert set(raw["model"]) == {"centralized", "distributed", "hierarchical"}
+  assert len(raw) == 3
+```
+
+- [ ] **Step 2: Run the tests to verify they fail against the empty script**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py -q`
+
+Expected: fail because `build_base_config` and `run_benchmark` are not implemented yet.
+
+- [ ] **Step 3: Implement the orchestrator**
+
+In `benchmark_planar_3reg.py`, add:
+
+```python
+def build_base_config(output_root: Path, nn: int, seed: int) -> dict:
+  return {
+    "base_solution_folder": str(output_root / f"n{nn}" / f"seed{seed}"),
+    "seed": seed,
+    "limits": {
+      "Nn": {"min": nn, "max": nn},
+      "Nf": {"min": 2, "max": 2},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.5},
+        "beta_multiplier": {"min": 1.5, "max": 2.5},
+        "gamma": {"min": 0.05, "max": 0.15},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0, 1.2]},
+      "memory_capacity": {"values": [12] * nn},
+      "memory_requirement": {"values": [2, 3]},
+      "max_utilization": {"min": 0.65, "max": 0.75},
+      "load": {"trace_type": "fixed_sum", "values": [2.0, 3.0]},
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3, 0.15],
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "sw_patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "max_hierarchy_depth": 3,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def run_benchmark(
+  output_root: Path,
+  sizes: list[int],
+  seeds: list[int],
+  solver_name: str = "gurobi",
+) -> pd.DataFrame:
+  # For each (nn, seed):
+  # 1. Build config
+  # 2. Call centralized / distributed / hierarchical runners
+  # 3. Measure wallclock with time.perf_counter()
+  # 4. Read objective from the run folder
+  # 5. Append one row per model to a raw results DataFrame
+```
+
+Use explicit runner aliases at the top of the file:
+
+```python
+from run_centralized_model import run as run_centralized
+from run_faasmacro import run as run_distributed
+from hierarchical_auction.runner import run as run_hierarchical
+```
+
+Store per-run outputs under `solutions/planar_benchmark/<timestamp>/n{nn}/seed{seed}/{model}/` and write `raw_results.csv` after all runs complete.
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add benchmark_planar_3reg.py tests/test_benchmark_planar_3reg.py
+git commit -m "feat: orchestrate planar benchmark runs"
+```
+
+---
+
+## Task 3: Write the CSV and HTML Report Artifacts
+
+**Files:**
+- Modify: `benchmark_planar_3reg.py`
+- Modify: `tests/test_benchmark_planar_3reg.py`
+
+The final report should be easy to read and easy to reuse. Write:
+
+- `raw_results.csv`: one row per `(Nn, seed, model)`
+- `summary.csv`: grouped by `(Nn, model)` with mean and standard deviation
+- `summary.html`: a single HTML document containing metadata, the summary table, and the raw table
+
+- [ ] **Step 1: Write failing tests for artifact writing**
+
+Add a test that creates a small raw results frame, calls the report writer, and asserts the files exist and contain the expected headings:
+
+```python
+def test_report_writer_creates_csv_and_html(tmp_path):
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+    {"Nn": 20, "seed": 1, "model": "centralized", "objective": 14.0, "wallclock_s": 3.0},
+  ])
+  summary = aggregate_results(raw)
+
+  write_report(raw, summary, tmp_path, meta={"sizes": [20], "seeds": [0, 1]})
+
+  assert (tmp_path / "raw_results.csv").exists()
+  assert (tmp_path / "summary.csv").exists()
+  html = (tmp_path / "summary.html").read_text()
+  assert "Planar Benchmark" in html
+  assert "Objective mean" in html
+  assert "Wallclock mean" in html
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py::test_report_writer_creates_csv_and_html -v`
+
+Expected: FAIL before the implementation exists.
+
+- [ ] **Step 3: Implement the report writer**
+
+In `benchmark_planar_3reg.py`, add:
+
+```python
+def write_report(
+  raw: pd.DataFrame,
+  summary: pd.DataFrame,
+  output_root: Path,
+  meta: dict[str, object],
+) -> None:
+  raw.to_csv(output_root / "raw_results.csv", index=False)
+  summary.to_csv(output_root / "summary.csv", index=False)
+  render_html_report(summary, raw, output_root / "summary.html", meta)
+```
+
+The HTML should use a compact inline stylesheet, a top metadata block, then the summary table, then the raw table. Keep the model order stable as `centralized`, `distributed`, `hierarchical`.
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_benchmark_planar_3reg.py -q`
+
+Expected: PASS.
+
+- [ ] **Step 5: Manual benchmark smoke**
+
+Run:
+
+```bash
+uv run python benchmark_planar_3reg.py \
+  --sizes 20 40 50 \
+  --seeds 0 1 2 3 4 \
+  --solver-name gurobi \
+  --output-root solutions/planar_benchmark
+```
+
+Expected:
+- one benchmark folder with `raw_results.csv`, `summary.csv`, and `summary.html`
+- 45 raw rows total
+- summary rows for each `(Nn, model)` pair
+- no Pyomo objective replacement warnings
+
+---
+
+## Self-Review Checklist
+
+- The script is standalone and does not disturb the existing run pipeline.
+- The benchmark uses the requested node sizes and exactly 5 seeds by default.
+- The report exposes both mean and standard deviation for objective and runtime.
+- The HTML report is generated without adding new dependencies.
+- The benchmark remains reproducible and can be extended later to more sizes/seeds.
diff --git a/docs/superpowers/plans/2026-06-25-faas-madig-distributed-heuristic.md b/docs/superpowers/plans/2026-06-25-faas-madig-distributed-heuristic.md
new file mode 100644
index 0000000..270aad2
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-25-faas-madig-distributed-heuristic.md
@@ -0,0 +1,1073 @@
+# FaaS-MADiG Distributed-Heuristic Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add FaaS-MADiG, a distributed greedy-diffusion heuristic that ablates the price/bidding signal of the production FaaS-MADeA auction, as a fourth comparable method.
+
+**Architecture:** A new standalone runner `decentralized_diffusion.py` mirrors `run_faasmadea.py`. It reuses the local MILP planning (`LSP`/`LSPr`) and every shared helper unchanged (imported from `run_faasmadea`), and replaces only the two market functions with price-free equivalents: `define_assignments` (greedy by utility, no bid price) and `evaluate_assignments` (greedy capacity fill by utility, no price update, score-based replacement of lower-utility incumbents). Wiring into `run.py` and `compare_results.py` is purely additive.
+
+**Tech Stack:** Python 3.10, NumPy, pandas, Pyomo (Gurobi/GLPK), pytest. 2-space indentation throughout (project style).
+
+## Global Constraints
+
+- **DO NOT modify functions that support other methods.** Files `run_faasmadea.py`, `run_faasmacro.py`, `run_centralized_model.py`, `models/`, `utils/`, `hierarchical_auction/`, `postprocessing.py`, `logs_postprocessing.py` are **read-only**. Reuse their functions by `import`.
+- **New behavior → new function.** Where FaaS-MADiG needs slightly different behavior than the auction, write a NEW function in `decentralized_diffusion.py` (`define_assignments`, `evaluate_assignments`, `run`). Never edit `define_bids`/`evaluate_bids`/`run` in `run_faasmadea.py`.
+- **`run.py` and `compare_results.py` changes must be ADDITIVE only** — new `--methods` choice, new dispatch block, new dict key, new ternary branch. Existing methods' code paths must remain byte-for-byte unchanged. The wiring test (Task 4/5) doubles as a regression guard for the existing methods' labels.
+- **Reuse, don't duplicate.** Import `compute_residual_capacity`, `check_stopping_criteria`, `neigh_dict_to_matrix`, `start_additional_replicas`, `ensure_memory_sellers`, `check_ls_pr_feasibility_from_fixed_y`, `VAR_TYPE` from `run_faasmadea`.
+- **Ablation rule:** no prices anywhere — no `epsilon`/`eta`/`zeta`/`u0`/`p`, no `min_b` tracking, no price update. Keep the price-free `tentatively_start_replicas` branch and use current utility scores, not prices, for any `last_y` replacement.
+- **Method name:** `FaaS-MADiG`. CLI key: `faas-diffuse`. `obj.csv` column: `FaaS-MADiG`. Artifact family (`mkey`): `LSPc`.
+- **Out of scope (v1):** `--fix_r` / `opt_solution` support in the new runner (use plain `LSP()`), and Options B/C from the spec.
+- Spec: `docs/superpowers/specs/2026-06-25-faas-madig-distributed-heuristic-design.md`.
+
+---
+
+## File Structure
+
+- **Create `decentralized_diffusion.py`** (top level) — `parse_arguments`, `define_assignments`, `evaluate_assignments`, `run`, `__main__`.
+- **Create `tests/test_diffusion_helpers.py`** — unit tests for the two helpers (no solver).
+- **Create `tests/test_diffusion_e2e.py`** — solver-gated end-to-end smoke test.
+- **Create `tests/test_diffusion_wiring.py`** — `run.py` CLI/wiring tests (no solver).
+- **Modify `run.py`** — additive wiring (import, choices, `solution_folders`, `run_d`, dispatch, `mkey`/`mname`, colors).
+- **Modify `config_files/planar_comparison.json`** — add `solver_options.diffusion`.
+- **Modify `compare_results.py`** — add `FaaS-MADiG` to the box/violin `colors` dict.
+
+---
+
+## Task 1: `define_assignments` (price-free buyer side)
+
+**Files:**
+- Create: `decentralized_diffusion.py`
+- Test: `tests/test_diffusion_helpers.py`
+
+**Interfaces:**
+- Consumes: `run_faasmadea.VAR_TYPE` (int/float scalar type).
+- Produces:
+  `define_assignments(omega, blackboard, data, neighborhood, rho, diffusion_options, latency, fairness, force_memory_bids) -> (pd.DataFrame, pd.DataFrame, int)`.
+  The first DataFrame has columns `["i","j","f","d","utility"]` (no `b`); the second has `["i","j","f"]`; the int is the number of potential buyers.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_diffusion_helpers.py`:
+
+```python
+import numpy as np
+import pandas as pd
+import pytest
+
+from decentralized_diffusion import define_assignments, evaluate_assignments
+
+
+def _base_data(Nn=3, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _ring_neighborhood(Nn=3):
+  neighborhood = np.zeros((Nn, Nn))
+  for n in range(Nn):
+    neighborhood[n, (n + 1) % Nn] = 1
+    neighborhood[n, (n - 1) % Nn] = 1
+  return neighborhood
+
+
+def test_define_assignments_greedy_by_utility_no_price_column():
+  data = _base_data(Nn=3, Nf=1)
+  # buyer 0 prefers seller 1 (beta 2.0) over seller 2 (beta 1.0)
+  data[None]["beta"][(1, 2, 1)] = 2.0
+  data[None]["beta"][(1, 3, 1)] = 1.0
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  rho = np.zeros((3,))
+  options = {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False}
+  latency = np.zeros((3, 3))
+  fairness = np.zeros((3, 1))
+
+  bids, memory_bids, n_buyers = define_assignments(
+    omega, blackboard, data, _ring_neighborhood(3), rho,
+    options, latency, fairness, force_memory_bids=False,
+  )
+
+  assert n_buyers == 1
+  assert "b" not in bids.columns
+  assert list(bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+  assert bids.iloc[0]["d"] == 2.0
+  assert bids.iloc[0]["utility"] == 2.0
+  assert len(memory_bids) == 0
+
+
+def test_define_assignments_requests_replicas_when_no_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((2, 1))           # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0       # neighbor 1 has spare memory
+  options = {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False}
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  bids, memory_bids, _ = define_assignments(
+    omega, blackboard, data, neighborhood, rho,
+    options, np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+  )
+
+  assert len(bids) == 0
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_diffusion_helpers.py::test_define_assignments_greedy_by_utility_no_price_column -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'decentralized_diffusion'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Create `decentralized_diffusion.py` with the imports and `define_assignments`:
+
+```python
+from run_centralized_model import (
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  VAR_TYPE,
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  ensure_memory_sellers,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSPr
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def define_assignments(
+    omega: np.array,
+    blackboard: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    diffusion_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+  ) -> Tuple[pd.DataFrame, pd.DataFrame, int]:
+  """Price-free counterpart of run_faasmadea.define_bids.
+
+  Greedy-by-utility assignment of residual load to neighbours with spare
+  capacity. No bid price is computed (no epsilon/delta); the per-pair score is
+  stored in the ``utility`` column, on which evaluate_assignments later sorts.
+  """
+  potential_buyers, functions_to_share = np.nonzero(omega)
+  bids = {"i": [], "j": [], "f": [], "d": [], "utility": []}
+  memory_bids = {"i": [], "j": [], "f": []}
+  for i, f in zip(potential_buyers, functions_to_share):
+    potential_sellers = set(np.nonzero(neighborhood[i, :])[0])
+    potential_capacity_sellers = potential_sellers.intersection(
+      set(np.where(blackboard[:, f] >= 1)[0])
+    )
+    potential_memory_sellers = potential_sellers.intersection(
+      set(np.nonzero(rho)[0])
+    )
+    utility = []
+    candidate_sellers = []
+    for j in potential_capacity_sellers:
+      ut = (
+        data[None]["beta"][(i + 1, j + 1, f + 1)]
+        - diffusion_options["latency_weight"] * latency[i, j]
+        - diffusion_options["fairness_weight"] * fairness[i, f]
+      )
+      if ut > - data[None]["gamma"][(i + 1, f + 1)]:
+        utility.append(ut)
+        candidate_sellers.append(j)
+    assigned = 0
+    if len(utility) > 0:
+      utility = np.array(utility)
+      sellers_order = np.argsort(utility)[::-1]
+      idx = 0
+      while idx < len(sellers_order) and assigned < omega[i, f]:
+        j = candidate_sellers[sellers_order[idx]]
+        if diffusion_options.get("unit_bids", False):
+          d = 1
+          while (d < int(min(blackboard[j, f], omega[i, f])) + 1) and (
+              assigned < omega[i, f]
+            ):
+            bids["i"].append(i)
+            bids["f"].append(f)
+            bids["j"].append(j)
+            bids["d"].append(1)
+            bids["utility"].append(utility[sellers_order[idx]])
+            assigned += 1
+            d += 1
+        else:
+          d = VAR_TYPE(min(blackboard[j, f], (omega[i, f] - assigned)))
+          bids["i"].append(i)
+          bids["f"].append(f)
+          bids["j"].append(j)
+          bids["d"].append(d)
+          bids["utility"].append(utility[sellers_order[idx]])
+          assigned += d
+        idx += 1
+      if assigned < omega[i, f]:
+        for idx in sellers_order:
+          j = candidate_sellers[idx]
+          if j in potential_memory_sellers:
+            memory_bids["i"].append(i)
+            memory_bids["j"].append(j)
+            memory_bids["f"].append(f)
+    if assigned < omega[i, f] or force_memory_bids:
+      for j in potential_memory_sellers - potential_capacity_sellers:
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(j)
+        memory_bids["f"].append(f)
+  return pd.DataFrame(bids), pd.DataFrame(memory_bids), len(potential_buyers)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_diffusion_helpers.py -k define_assignments -v`
+Expected: 2 passed.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_diffusion.py tests/test_diffusion_helpers.py
+git commit -m "feat(madig): add price-free define_assignments helper"
+```
+
+---
+
+## Task 2: `evaluate_assignments` (price-free seller side)
+
+**Files:**
+- Modify: `decentralized_diffusion.py`
+- Test: `tests/test_diffusion_helpers.py`
+
+**Interfaces:**
+- Consumes: `run_faasmadea.ensure_memory_sellers`; the `bids` DataFrame from Task 1.
+- Produces:
+  `evaluate_assignments(bids, residual_capacity, data, ell, r, initial_rho, tentatively_start_replicas) -> (np.array, np.array, int)`
+  returning `(y, additional_replicas, n_sellers)` — **no price array**.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/test_diffusion_helpers.py`:
+
+```python
+def test_evaluate_assignments_respects_capacity_and_tiebreaks_by_buyer():
+  data = _base_data(Nn=3, Nf=1)
+  # two buyers tie on utility for seller 1; capacity only fits one fully
+  bids = pd.DataFrame({
+    "i": [2, 0],
+    "j": [1, 1],
+    "f": [0, 0],
+    "d": [2.0, 2.0],
+    "utility": [5.0, 5.0],
+  })
+  residual_capacity = np.zeros((3, 1)); residual_capacity[1, 0] = 3.0
+  ell = np.zeros((3, 1))
+  r = np.zeros((3, 1))
+  rho = np.zeros((3,))
+
+  y, additional_replicas, n_sellers = evaluate_assignments(
+    bids, residual_capacity, data, ell, r, rho,
+    tentatively_start_replicas=False,
+  )
+
+  assert y[:, 1, 0].sum() == 3.0            # never exceeds capacity
+  assert y[0, 1, 0] == 2.0                  # lower buyer index served first
+  assert y[2, 1, 0] == 1.0
+  assert (additional_replicas == 0).all()
+  assert n_sellers == 1
+
+
+def test_evaluate_assignments_is_deterministic_and_returns_no_price():
+  data = _base_data(Nn=3, Nf=1)
+  bids = pd.DataFrame({
+    "i": [2, 0], "j": [1, 1], "f": [0, 0],
+    "d": [2.0, 2.0], "utility": [5.0, 5.0],
+  })
+  residual_capacity = np.zeros((3, 1)); residual_capacity[1, 0] = 3.0
+  args = (bids, residual_capacity, data, np.zeros((3, 1)),
+          np.zeros((3, 1)), np.zeros((3,)))
+
+  first = evaluate_assignments(*args, tentatively_start_replicas=False)
+  second = evaluate_assignments(*args, tentatively_start_replicas=False)
+
+  assert len(first) == 3                    # (y, additional_replicas, n_sellers)
+  assert np.array_equal(first[0], second[0])
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_diffusion_helpers.py -k evaluate_assignments -v`
+Expected: FAIL — `ImportError: cannot import name 'evaluate_assignments'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add to `decentralized_diffusion.py` (after `define_assignments`):
+
+```python
+def evaluate_assignments(
+    bids: pd.DataFrame,
+    residual_capacity: np.array,
+    data: dict,
+    ell: np.array,
+    r: np.array,
+    initial_rho: np.array,
+    tentatively_start_replicas: bool,
+  ) -> Tuple[np.array, np.array, int]:
+  """Price-free counterpart of run_faasmadea.evaluate_bids.
+
+  Pure greedy capacity fill: sellers serve buyers by descending ``utility``
+  (tie-break on buyer index ``i`` for reproducibility). No min_b tracking, no
+  price update; score-based `last_y` replacement may re-award lower-utility
+  incumbent load. The price-free
+  tentatively_start_replicas branch is kept for parity with the baseline.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  potential_sellers, functions_to_share = np.nonzero(residual_capacity)
+  if tentatively_start_replicas:
+    potential_sellers, functions_to_share = ensure_memory_sellers(
+      potential_sellers, functions_to_share, np.nonzero(initial_rho)[0], Nf
+    )
+  y = np.zeros((Nn, Nn, Nf))
+  additional_replicas = np.zeros((Nn, Nf))
+  rho = deepcopy(initial_rho)
+  for j, f in zip(potential_sellers, functions_to_share):
+    j = int(j)
+    f = int(f)
+    bids_for_j = bids[(bids["j"] == j) & (bids["f"] == f)].sort_values(
+      by=["utility", "i"], ascending=[False, True]
+    )
+    remaining_capacity = int(residual_capacity[j, f])
+    next_bid_idx = 0
+    while next_bid_idx < len(bids_for_j) and remaining_capacity > 0:
+      q = min(remaining_capacity, bids_for_j.iloc[next_bid_idx]["d"])
+      y[int(bids_for_j.iloc[next_bid_idx]["i"]), j, f] += q
+      remaining_capacity -= q
+      next_bid_idx += 1
+    # price-free tentative replica start (decides on utilization, not price)
+    if (
+        remaining_capacity == 0
+        and (next_bid_idx > 0 or len(bids_for_j) > 0)
+        and tentatively_start_replicas
+      ):
+      max_a = int(rho[j] / data[None]["memory_requirement"][f + 1])
+      if max_a > 0:
+        a = 1
+        while next_bid_idx < len(bids_for_j) and a <= max_a:
+          q = bids_for_j.iloc[next_bid_idx]["d"]
+          u = data[None]["demand"][(j + 1, f + 1)] * (
+            ell[j, f] + y[:, j, f].sum() + q
+          ) / (r[j, f] + a)
+          if u <= data[None]["max_utilization"][f + 1]:
+            y[int(bids_for_j.iloc[next_bid_idx]["i"]), j, f] += q
+            next_bid_idx += 1
+            additional_replicas[j, f] = a
+            rho[j] -= (a * data[None]["memory_requirement"][f + 1])
+          else:
+            a += 1
+  return y, additional_replicas, len(potential_sellers)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_diffusion_helpers.py -v`
+Expected: 4 passed.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_diffusion.py tests/test_diffusion_helpers.py
+git commit -m "feat(madig): add price-free evaluate_assignments helper"
+```
+
+---
+
+## Task 3: `run()` runner + `parse_arguments` + e2e smoke
+
+**Files:**
+- Modify: `decentralized_diffusion.py`
+- Test: `tests/test_diffusion_e2e.py`
+
+**Interfaces:**
+- Consumes: `define_assignments`, `evaluate_assignments` (Tasks 1–2) and the reused `run_faasmadea`/`run_faasmacro`/`run_centralized_model` helpers.
+- Produces: `run(config, parallelism, log_on_file=False, disable_plotting=False) -> str` (solution folder path). Saves `LSP*`/`LSPc*` solutions, `obj.csv` (column `FaaS-MADiG`), `termination_condition.csv`, and `runtime.csv` (column `tot`).
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_diffusion_e2e.py`:
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_diffusion import run as run_diffusion
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _diffusion_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "diffusion": {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_diffusion_runner_produces_expected_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_diffusion(
+    _diffusion_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert "FaaS-MADiG" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MADiG"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_diffusion_e2e.py -v`
+Expected: FAIL — `ImportError: cannot import name 'run'` (or `AttributeError`), or skip if Gurobi missing.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Add `parse_arguments` and `run` to `decentralized_diffusion.py`:
+
+```python
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MADiG",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  return parser.parse_known_args()[0]
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ):
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  diffusion_options = solver_options["diffusion"]
+  diffusion_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  patience = config["patience"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight="network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    sp = LSP()
+    spr = LSPr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = 0.0
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    n_accepted_queue = deque(maxlen=patience)
+    while not stop_searching:
+      s = datetime.now()
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      total_runtime += (datetime.now() - s).total_seconds()
+      s = datetime.now()
+      bids, memory_bids, n_auctions = define_assignments(
+        omega, blackboard, sp_data, neighborhood, sp_rho,
+        diffusion_options, latency, fairness,
+        force_memory_bids=(
+          (sp_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_auctions) if n_auctions else rt
+      rmp_omega = np.zeros((Nn, Nf))
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        s = datetime.now()
+        diffusion_y, additional_replicas, n_sellers = evaluate_assignments(
+          bids, residual_capacity, sp_data, ell, sp_r, sp_rho,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+        )
+        rt = (datetime.now() - s).total_seconds()
+        total_runtime += (rt / n_sellers) if n_sellers else rt
+        y += diffusion_y
+        for n in range(Nn):
+          for f in range(Nf):
+            rmp_omega[n, f] = y[n, :, f].sum()
+            if rmp_omega[n, f] > 0:
+              fairness[n, f] += 1
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        for i in range(Nn):
+          for f in range(Nf):
+            omega[i, f] = sp_omega[i, f] - rmp_omega[i, f]
+            if abs(omega[i, f]) < tolerance:
+              omega[i, f] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, bids, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MADiG"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(config, args.parallelism, disable_plotting=args.disable_plotting)
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_diffusion_e2e.py -v`
+Expected: PASS (or SKIP if Gurobi unavailable). Also run `uv run python decentralized_diffusion.py --help` → prints the FaaS-MADiG usage.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_diffusion.py tests/test_diffusion_e2e.py
+git commit -m "feat(madig): add price-free run() runner with runtime.csv"
+```
+
+---
+
+## Task 4: Wire `faas-diffuse` into `run.py` (additive)
+
+**Files:**
+- Modify: `run.py` (additive edits only)
+- Test: `tests/test_diffusion_wiring.py`
+
+**Interfaces:**
+- Consumes: `decentralized_diffusion.run`.
+- Produces: `run.py` accepts `--methods faas-diffuse`, dispatches to `run_diffusion`, and maps it to `mkey="LSPc"`, `mname="FaaS-MADiG"`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_diffusion_wiring.py`:
+
+```python
+import run
+
+
+def test_methods_choice_accepts_faas_diffuse(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-diffuse"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-diffuse" in args.methods
+
+
+def test_run_module_exposes_diffusion_runner():
+  assert hasattr(run, "run_diffusion")
+  assert callable(run.run_diffusion)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_diffusion_wiring.py -v`
+Expected: FAIL — `faas-diffuse` not in choices (argparse SystemExit) and `run` has no `run_diffusion`.
+
+- [ ] **Step 3: Make the additive edits**
+
+In `run.py`, add the import after line 6 (`from hierarchical_auction.runner import run as run_hierarchical`):
+
+```python
+from decentralized_diffusion import run as run_diffusion
+```
+
+Add `"faas-diffuse"` to the `--methods` choices list (after `"hierarchical",` near line 54):
+
+```python
+      "hierarchical",
+      "faas-diffuse",
+      "generate_only"
+```
+
+Extend `method_colors` (line 259-265) with a sixth color so all methods are distinct:
+
+```python
+    method_colors = [
+      mcolors.TABLEAU_COLORS["tab:blue"],
+      mcolors.TABLEAU_COLORS["tab:orange"],
+      mcolors.TABLEAU_COLORS["tab:red"],
+      mcolors.TABLEAU_COLORS["tab:green"],
+      mcolors.TABLEAU_COLORS["tab:pink"],
+      mcolors.TABLEAU_COLORS["tab:purple"]
+    ]
+```
+
+Extend the `mname` ternary (line 280-286) — add the `faas-diffuse` branch (additive; existing methods unchanged):
+
+```python
+        mname = "LoadManagementModel" if method == "centralized" else (
+          "FaaS-MACrO" if method == "faas-macro" else (
+            "FaaS-MACrO(v0)" if method == "faas-macro-v0" else (
+              "FaaS-MADeA" if method == "faas-madea" else (
+                "FaaS-MADiG" if method == "faas-diffuse" else "HierarchicalAuction"
+              )
+            )
+          )
+        )
+```
+
+(`mkey` at line 277-279 already resolves to `"LSPc"` for any non-centralized, non-`faas-macro*` method, so `faas-diffuse` correctly maps to `LSPc` with no change.)
+
+Add `"faas-diffuse": []` to the `solution_folders` init (line 863-870):
+
+```python
+  solution_folders = {
+    "experiments_list": [],
+    "centralized": [],
+    "faas-macro": [],
+    "faas-macro-v0": [],
+    "faas-madea": [],
+    "hierarchical": [],
+    "faas-diffuse": []
+  }
+```
+
+Add the `run_d` flag init after line 888 (`run_h = False # -- hierarchical`):
+
+```python
+    run_h = False # -- hierarchical
+    run_d = False # -- faas-diffuse (FaaS-MADiG)
+```
+
+Add the resume check after the hierarchical block (after line 923):
+
+```python
+      if (not generate_only and "hierarchical" in methods) and ((
+          len(solution_folders["hierarchical"]) <= experiment_idx
+        ) or (
+          solution_folders["hierarchical"][experiment_idx] is None
+        )):
+        run_h = True
+      if (not generate_only and "faas-diffuse" in methods) and ((
+          len(solution_folders.get("faas-diffuse", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-diffuse"][experiment_idx] is None
+        )):
+        run_d = True
+```
+
+Add to the `except ValueError` simple-check block (after line 929 `run_h = "hierarchical" in methods`):
+
+```python
+      run_h = "hierarchical" in methods
+      run_d = "faas-diffuse" in methods
+```
+
+Extend the run-guard condition (line 931):
+
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_d or generate_only:
+```
+
+Add the dispatch block after the hierarchical dispatch (after line 1031, before `# -- save info`):
+
+```python
+        set_solution_folder(
+          solution_folders, "hierarchical", experiment_idx, h_folder
+        )
+      # -- solve diffusion (FaaS-MADiG)
+      if run_d:
+        d_folder = run_diffusion(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-diffuse", experiment_idx, d_folder
+        )
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_diffusion_wiring.py -v`
+Expected: 2 passed.
+Then a regression check that other methods' wiring is intact:
+Run: `uv run pytest tests/test_parse_args_extended.py tests/test_run_helpers.py -v`
+Expected: all previously-passing tests still pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add run.py tests/test_diffusion_wiring.py
+git commit -m "feat(madig): wire faas-diffuse method into run.py orchestrator"
+```
+
+---
+
+## Task 5: Config + `compare_results.py` palette (additive)
+
+**Files:**
+- Modify: `config_files/planar_comparison.json`
+- Modify: `compare_results.py` (additive — one dict key)
+- Test: `tests/test_diffusion_wiring.py`
+
+**Interfaces:**
+- Consumes: nothing new.
+- Produces: a `solver_options.diffusion` block in the planar config; a `FaaS-MADiG` entry in the `compare_results.py` box/violin `colors` dict.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/test_diffusion_wiring.py`:
+
+```python
+import json
+from pathlib import Path
+
+
+def test_planar_config_has_diffusion_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  diffusion = config["solver_options"]["diffusion"]
+  assert "latency_weight" in diffusion
+  assert "fairness_weight" in diffusion
+
+
+def test_compare_results_palette_includes_madig():
+  import inspect
+
+  import compare_results
+
+  source = inspect.getsource(compare_results)
+  assert '"FaaS-MADiG"' in source
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_diffusion_wiring.py -k "diffusion_section or palette" -v`
+Expected: FAIL — no `diffusion` key in config; no `FaaS-MADiG` in `compare_results.py`.
+
+- [ ] **Step 3: Make the additive edits**
+
+In `config_files/planar_comparison.json`, add the `diffusion` block inside `solver_options` (after the `auction` block, line 15-21):
+
+```json
+    "auction": {
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3, 0.15],
+      "zeta": 0.1,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    }
+```
+
+In `compare_results.py`, add the `FaaS-MADiG` key to the `colors` dict (line 667-672):
+
+```python
+  colors = {
+    "LoadManagementModel": mcolors.CSS4_COLORS["lightgreen"],
+    "FaaS-MACrO": mcolors.CSS4_COLORS["lightpink"],
+    "FaaS-MACrO(v0)": mcolors.CSS4_COLORS["lightcoral"],
+    "FaaS-MADeA": mcolors.CSS4_COLORS["lightskyblue"],
+    "FaaS-MADiG": mcolors.CSS4_COLORS["plum"]
+  }
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_diffusion_wiring.py -v`
+Expected: 4 passed.
+Then validate the config parses and is still a valid planar config:
+Run: `uv run python -c "import json; json.load(open('config_files/planar_comparison.json'))"`
+Expected: no error.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add config_files/planar_comparison.json compare_results.py tests/test_diffusion_wiring.py
+git commit -m "feat(madig): add diffusion config block and compare_results palette"
+```
+
+---
+
+## Final verification (after all tasks)
+
+- [ ] Run the full unit suite: `uv run pytest tests/test_diffusion_helpers.py tests/test_diffusion_wiring.py -v` → all pass.
+- [ ] Run the e2e (needs Gurobi): `uv run pytest tests/test_diffusion_e2e.py -v` → pass or skip.
+- [ ] Run the existing suite to confirm no regressions: `uv run pytest -q`.
+- [ ] Optional manual four-way run (needs SageMath + Gurobi):
+  ```
+  uv run python run.py -c config_files/planar_comparison.json \
+    --methods centralized faas-macro faas-madea hierarchical faas-diffuse \
+    --n_experiments 1 --loop_over Nn
+  ```
+  Confirm `solutions/planar_comparison/` contains a FaaS-MADiG folder with `obj.csv` (column `FaaS-MADiG`) and `runtime.csv`.
+
+## Self-review notes
+
+- **Spec coverage:** §3.1 → Task 1; §3.2 → Task 2; §4 module + §6 artifacts (obj.csv column, runtime.csv, runtime accounting + `n_auctions` guard) → Task 3; §5 wiring + labels → Task 4; §4 config + §6 compare_results palette → Task 5; §7 tests → Tasks 1–5.
+- **Caveat compliance:** no shared/algorithmic function is edited; new behavior is isolated in `decentralized_diffusion.py`; `run.py`/`compare_results.py` edits are additive; reused helpers are imported from `run_faasmadea`.
+- **Type consistency:** `define_assignments` returns `(DataFrame[i,j,f,d,utility], DataFrame[i,j,f], int)`; `evaluate_assignments` consumes that first DataFrame and returns `(y, additional_replicas, int)`; `run()` consumes both. `mkey="LSPc"`, `mname="FaaS-MADiG"`, obj column `FaaS-MADiG`, runtime column `tot` are consistent across Tasks 3–5.
diff --git a/docs/superpowers/plans/2026-06-26-faas-mabr-best-response.md b/docs/superpowers/plans/2026-06-26-faas-mabr-best-response.md
new file mode 100644
index 0000000..6a21531
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-26-faas-mabr-best-response.md
@@ -0,0 +1,1595 @@
+# FaaS-MABR Distributed Best-Response (Gauss-Seidel) Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add three solver-light Gauss-Seidel distributed heuristics — FaaS-MABR-S (sequential greedy, fixed order), FaaS-MABR-R (sequential greedy, randomized order), FaaS-MABR-O (capped local best response) — as the sequential counterpart to FaaS-MADiG/MAPoD's simultaneous coordination.
+
+**Architecture:** One new module `decentralized_bestresponse.py` holds a shared `best_response_sweep` (sequential placement on a shared, in-place-decremented residual ledger), a solver-backed `reoptimize_node` (per-node `LSP_capped` solve for the `-O` variant), a parameterized internal `_run` (the per-runner control-period loop, copied from `decentralized_diffusion.run` with the coordinate step swapped for one sweep), and three thin entry points `run_br_s/r/o`. Two additive model classes `LSP_capped`/`LSP_capped_fixedr` add an `omega` upper bound. All `run.py`/`compare_results.py`/planar-config changes are additive.
+
+**Tech Stack:** Python 3.10, NumPy, pandas, Pyomo (Gurobi/GLPK). 2-space indentation. Run/test via `uv run` / `uv run pytest`. LaTeX via `latexmk`.
+
+## Global Constraints
+
+- **2-space indentation** throughout (match existing files).
+- **Do NOT modify** functions/classes that support other methods: `run_faasmadea.py`, `run_faasmacro.py`, `run_centralized_model.py`, existing classes in `models/sp.py`, `utils/`, `hierarchical_auction/`, `decentralized_diffusion.py`, `decentralized_powerd.py`. Reuse by import; new behaviour → new function/class.
+- **`run.py` / `compare_results.py` / `planar_comparison.json` changes are ADDITIVE only** — existing methods' code paths stay byte-for-byte unchanged.
+- **Method names** `FaaS-MABR-S` / `FaaS-MABR-R` / `FaaS-MABR-O`; CLI keys `faas-br-s` / `faas-br-r` / `faas-br-o`; `obj.csv` column = the method name; artifact key `LSPc`; runner symbols `run_br_s` / `run_br_r` / `run_br_o`.
+- **Coordination = one sequential sweep over a shared ledger** (true residual capacity `compute_residual_capacity`, decremented in place). Admission uses score `s_{ij}^f = beta − latency_weight·L − fairness_weight·phi` and threshold `s > −gamma_i^f`; placement is descending score, tie-break lower `j`. No seller-clearing phase, no reuse of `evaluate_assignments`/`define_assignments`.
+- **`-O` reopt:** per node, cap `omega` at accessible neighbour residual capacity and re-solve via `solve_subproblem([node], LSP_capped()/LSP_capped_fixedr())`; only `omega[node,:]` is committed; final `x/z/r/rho` come from the subsequent `LSPr` solve. The 4th combination (randomized-order reopt) is out of scope.
+- **`-R` stochasticity:** node order permutation from `np.random.default_rng(config["seed"])` (created once); variance via `--n_experiments`. `_run` copies its options block with `dict(...)` so the input config is never mutated.
+- **Stopping:** reuse `check_stopping_criteria` (passing `bids=None`) plus an explicit MABR guard: stop with `"no best-response progress"` when a sweep places no load and emits no memory bids.
+- **Replica expansion** is sweep-level via `start_additional_replicas`, at parity with FaaS-MADiG's two-block memory-bid emission.
+
+---
+
+### Task 1: `LSP_capped` / `LSP_capped_fixedr` model classes
+
+**Files:**
+- Modify: `models/sp.py` (append two classes)
+- Test: `tests/test_lsp_capped.py`
+
+**Interfaces:**
+- Consumes: existing `LSP`, `LSP_fixedr` (in `models/sp.py`).
+- Produces: `LSP_capped()` (subclass of `LSP`) and `LSP_capped_fixedr()` (subclass of `LSP_fixedr`), each with a `Param omega_ub` (indexed by the function set `F`, default `1e9`) and a `Constraint cap_offloading` enforcing `omega[f] <= omega_ub[f]`. Data key: `data[None]["omega_ub"] = {f+1: value}`.
+
+- [ ] **Step 1: Write the failing structural test**
+
+Create `tests/test_lsp_capped.py`:
+
+```python
+from models.sp import LSP, LSP_fixedr, LSP_capped, LSP_capped_fixedr
+
+
+def test_lsp_capped_subclasses_lsp_and_adds_cap():
+  m = LSP_capped()
+  assert isinstance(m, LSP)
+  assert m.model.component("omega_ub") is not None
+  assert m.model.component("cap_offloading") is not None
+
+
+def test_lsp_capped_fixedr_subclasses_fixedr_and_adds_cap():
+  m = LSP_capped_fixedr()
+  assert isinstance(m, LSP_fixedr)
+  assert m.model.component("omega_ub") is not None
+  assert m.model.component("cap_offloading") is not None
+  assert m.model.component("fix_r") is not None
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_lsp_capped.py -v`
+Expected: FAIL — `ImportError: cannot import name 'LSP_capped' from 'models.sp'`.
+
+- [ ] **Step 3: Append the two classes to `models/sp.py`**
+
+Append at the end of `models/sp.py`:
+
+```python
+##############################################################################
+# OFFLOADING CAP (for FaaS-MABR-O capped local best response)
+##############################################################################
+
+class LSP_capped(LSP):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_capped"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+
+
+class LSP_capped_fixedr(LSP_fixedr):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_capped_fixedr"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `uv run pytest tests/test_lsp_capped.py -v`
+Expected: PASS (2 passed).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add models/sp.py tests/test_lsp_capped.py
+git commit -m "feat: add LSP_capped / LSP_capped_fixedr offloading-cap models"
+```
+
+---
+
+### Task 2: `best_response_sweep` (sequential greedy core)
+
+**Files:**
+- Create: `decentralized_bestresponse.py`
+- Test: `tests/test_bestresponse_helpers.py`
+
+**Interfaces:**
+- Consumes: `data[None]["beta"][(i+1,j+1,f+1)]`, `data[None]["gamma"][(i+1,f+1)]` (same layout as `decentralized_diffusion.define_assignments`).
+- Produces: `best_response_sweep(omega, residual_capacity, data, neighborhood, rho, br_options, latency, fairness, force_memory_bids, *, order, response, rng=None, reopt_fn=None) -> (y_increment: np.ndarray(Nn,Nn,Nf), memory_bids: pd.DataFrame[i,j,f], n_active: int, placed_total: float, reopt_runtime: float)`. When `response=="reopt"`, `reopt_fn(node:int, omega_ub_row:np.ndarray(Nf)) -> (capped_omega_row:np.ndarray(Nf), runtime:float)` is called per node before placement.
+
+- [ ] **Step 1: Create the module header + the failing test file**
+
+Create `decentralized_bestresponse.py` with the full header (everything `_run` will need in Task 4) followed by nothing else yet:
+
+```python
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSPr, LSP_capped, LSP_capped_fixedr
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+```
+
+Then create `tests/test_bestresponse_helpers.py`:
+
+```python
+import numpy as np
+import pandas as pd
+
+from decentralized_bestresponse import best_response_sweep
+
+
+def _base_data(Nn=4, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _full_neighborhood(Nn=4):
+  return np.ones((Nn, Nn)) - np.eye(Nn)
+
+
+def _opts():
+  return {"latency_weight": 0.0, "fairness_weight": 0.0}
+
+
+def test_sweep_ledger_is_order_dependent():
+  # buyers 0 and 1 both want 2 from the only capacity seller 2 (cap 2);
+  # in a fixed sequential sweep, node 0 (first) takes it all, node 1 gets none.
+  data = _base_data(Nn=3, Nf=1)
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0; omega[1, 0] = 2.0
+  residual = np.zeros((3, 1)); residual[2, 0] = 2.0
+  neighborhood = np.zeros((3, 3))
+  neighborhood[0, 2] = 1; neighborhood[1, 2] = 1
+  rho = np.zeros((3,))
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, rho, _opts(),
+    np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert y[0, 2, 0] == 2.0      # first node claimed the shared capacity
+  assert y[1, 2, 0] == 0.0      # later node saw the decremented ledger
+  assert placed == 2.0
+  assert rt == 0.0
+
+
+def test_sweep_fixed_order_is_deterministic():
+  data = _base_data()
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  omega = np.zeros((4, 1)); omega[0, 0] = 3.0
+  residual = np.zeros((4, 1)); residual[1, 0] = 2; residual[2, 0] = 2
+  args = (omega, residual, data, _full_neighborhood(), np.zeros((4,)),
+          _opts(), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  y1, *_ = best_response_sweep(*args, force_memory_bids=False,
+                               order="fixed", response="greedy")
+  y2, *_ = best_response_sweep(*args, force_memory_bids=False,
+                               order="fixed", response="greedy")
+  assert np.array_equal(y1, y2)
+
+
+def test_sweep_random_order_reproducible_with_same_seed():
+  data = _base_data()
+  for j in [1, 2, 3]:
+    data[None]["beta"][(1, j + 1, 1)] = float(j)
+  omega = np.zeros((4, 1)); omega[0, 0] = 2.0
+  residual = np.zeros((4, 1)); residual[1, 0] = 1; residual[2, 0] = 1; residual[3, 0] = 1
+  args = (omega, residual, data, _full_neighborhood(), np.zeros((4,)),
+          _opts(), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  y1, *_ = best_response_sweep(*args, force_memory_bids=False, order="random",
+                               response="greedy", rng=np.random.default_rng(7))
+  y2, *_ = best_response_sweep(*args, force_memory_bids=False, order="random",
+                               response="greedy", rng=np.random.default_rng(7))
+  assert np.array_equal(y1, y2)
+
+
+def test_sweep_threshold_excludes_unconvenient_seller():
+  data = _base_data(Nn=2, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = -1.0   # score -1.0 <= -0.05 => excluded
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 5
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, np.zeros((2,)), _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert placed == 0.0
+  assert len(mem) == 0
+
+
+def test_sweep_emits_memory_bids_when_no_capacity():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  residual = np.zeros((2, 1))                 # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0           # neighbour 1 has spare memory
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, rho, _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert placed == 0.0
+  assert list(mem[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_sweep_reopt_branch_caps_omega_via_reopt_fn():
+  # response="reopt" calls reopt_fn before placement; a fake fn halves omega.
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 4.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 10
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+  calls = {}
+
+  def fake_reopt(node, omega_ub_row):
+    calls["node"] = node
+    calls["ub"] = list(omega_ub_row)
+    return np.array([2.0]), 0.5     # capped to 2.0, 0.5s runtime
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, np.zeros((2,)), _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="reopt", reopt_fn=fake_reopt)
+
+  assert calls["node"] == 0
+  assert calls["ub"] == [10.0]      # accessible neighbour capacity
+  assert placed == 2.0              # placed the capped amount, not 4.0
+  assert rt == 0.5
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `uv run pytest tests/test_bestresponse_helpers.py -v`
+Expected: FAIL — `ImportError: cannot import name 'best_response_sweep'`.
+
+- [ ] **Step 3: Implement `best_response_sweep`**
+
+Append to `decentralized_bestresponse.py`:
+
+```python
+def best_response_sweep(
+    omega: np.array,
+    residual_capacity: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    br_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    *,
+    order: str,
+    response: str,
+    rng: np.random.Generator = None,
+    reopt_fn=None,
+  ) -> Tuple[np.array, pd.DataFrame, int, float, float]:
+  """Sequential (Gauss-Seidel) best-response sweep.
+
+  Nodes act in `order` ("fixed" = ascending index, "random" = rng permutation);
+  each places its residual demand greedily by descending score onto the shared
+  `ledger` (a copy of residual_capacity), decremented in place so later nodes
+  see what earlier nodes took. For response=="reopt", each node first caps its
+  omega row at the accessible neighbour capacity via reopt_fn before placing.
+  Replica-expansion memory bids use the FaaS-MADiG two-block emission.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  ledger = np.array(residual_capacity, dtype=float)
+  omega = np.array(omega, dtype=float)  # working copy; never mutate the caller's
+  y_increment = np.zeros((Nn, Nn, Nf))
+  memory_bids = {"i": [], "j": [], "f": []}
+  reopt_runtime = 0.0
+  active = set()
+  memory_seller_nodes = set(int(j) for j in np.nonzero(rho)[0])
+  if order == "random":
+    node_order = [int(i) for i in rng.permutation(Nn)]
+  else:
+    node_order = list(range(Nn))
+  for i in node_order:
+    neighbours = set(int(j) for j in np.nonzero(neighborhood[i, :])[0])
+    if response == "reopt" and reopt_fn is not None:
+      omega_ub_row = np.array(
+        [sum(ledger[j, f] for j in neighbours) for f in range(Nf)]
+      )
+      capped_row, rt = reopt_fn(i, omega_ub_row)
+      reopt_runtime += rt
+      omega[i, :] = capped_row
+    potential_memory = neighbours & memory_seller_nodes
+    for f in range(Nf):
+      if omega[i, f] <= 0:
+        continue
+      score = {}
+      candidates = []
+      for j in neighbours:
+        if ledger[j, f] >= 1:
+          s = (
+            data[None]["beta"][(i + 1, j + 1, f + 1)]
+            - br_options["latency_weight"] * latency[i, j]
+            - br_options["fairness_weight"] * fairness[i, f]
+          )
+          if s > - data[None]["gamma"][(i + 1, f + 1)]:
+            score[j] = s
+            candidates.append(j)
+      placed = 0.0
+      for j in sorted(candidates, key=lambda k: (-score[k], k)):
+        if placed >= omega[i, f]:
+          break
+        q = min(ledger[j, f], omega[i, f] - placed)
+        if q <= 0:
+          continue
+        y_increment[i, j, f] += q
+        ledger[j, f] -= q
+        placed += q
+        active.add(i)
+      potential_capacity = set(
+        j for j in neighbours if residual_capacity[j, f] >= 1
+      )
+      if placed < omega[i, f]:
+        for j in sorted(score, key=lambda k: (-score[k], k)):
+          if j in potential_memory:
+            memory_bids["i"].append(i)
+            memory_bids["j"].append(j)
+            memory_bids["f"].append(f)
+      if placed < omega[i, f] or force_memory_bids:
+        for j in sorted(potential_memory - potential_capacity):
+          memory_bids["i"].append(i)
+          memory_bids["j"].append(j)
+          memory_bids["f"].append(f)
+  placed_total = float(y_increment.sum())
+  return (
+    y_increment, pd.DataFrame(memory_bids), len(active),
+    placed_total, reopt_runtime,
+  )
+```
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_bestresponse_helpers.py -v`
+Expected: PASS (6 passed).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_bestresponse.py tests/test_bestresponse_helpers.py
+git commit -m "feat: add sequential best-response sweep (FaaS-MABR core)"
+```
+
+---
+
+### Task 3: `reoptimize_node` (capped per-node solve)
+
+**Files:**
+- Modify: `decentralized_bestresponse.py` (append `reoptimize_node`)
+- Test: `tests/test_bestresponse_reopt.py`
+
+**Interfaces:**
+- Consumes: `solve_subproblem` (imported), `LSP_capped`/`LSP_capped_fixedr` (Task 1).
+- Produces: `reoptimize_node(node, omega_ub_row, sp_data, solver_name, general_solver_options, parallelism, use_fixed_r) -> (omega_row: np.ndarray(Nf), runtime: float)`. Deep-copies `sp_data`, sets `omega_ub`, solves only `node`, returns its re-optimized `omega` row and the solve runtime. This is the `reopt_fn` the `-O` runner passes to `best_response_sweep`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_bestresponse_reopt.py`:
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pyomo.environ as pyo
+import pytest
+
+from run_centralized_model import init_problem, update_data, get_current_load
+from decentralized_bestresponse import reoptimize_node
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _tiny_instance(tmp_path: Path):
+  limits = {
+    "Nn": {"min": 3, "max": 3},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"type": "planar", "degree": 2},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 1.5, "max": 2.0},
+      "gamma": {"min": 0.05, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.2},
+    },
+    "demand": {"values": [1.0]},
+    "memory_capacity": {"values": [12, 12, 12]},
+    "memory_requirement": {"values": [2]},
+    "max_utilization": {"min": 0.7, "max": 0.7},
+    "load": {"trace_type": "clipped",
+             "min": {"min": 2.0, "max": 2.0},
+             "max": {"min": 3.0, "max": 3.0}},
+  }
+  base, traces, agents, graph = init_problem(
+    limits, "clipped", 4, 21, str(tmp_path))
+  loadt = get_current_load(traces, agents, 1)
+  data = update_data(base, {"incoming_load": loadt})
+  return data
+
+
+def test_reoptimize_node_respects_cap_and_reduces_offload(tmp_path):
+  _require_gurobi()
+  data = _tiny_instance(tmp_path)
+  Nf = data[None]["Nf"][None]
+
+  loose = np.full(Nf, 1e9)
+  tight = np.zeros(Nf)        # no neighbour capacity at all
+
+  omega_loose, rt1 = reoptimize_node(
+    0, loose, data, "gurobi", {"OutputFlag": 0}, 0, use_fixed_r=False)
+  omega_tight, rt2 = reoptimize_node(
+    0, tight, data, "gurobi", {"OutputFlag": 0}, 0, use_fixed_r=False)
+
+  assert (omega_tight <= tight + 1e-6).all()    # cap respected (omega ~ 0)
+  assert omega_tight.sum() <= omega_loose.sum() + 1e-6  # capping cannot raise offload
+  assert rt1 >= 0 and rt2 >= 0
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_bestresponse_reopt.py -v`
+Expected: FAIL — `ImportError: cannot import name 'reoptimize_node'`.
+
+- [ ] **Step 3: Implement `reoptimize_node`**
+
+Append to `decentralized_bestresponse.py`:
+
+```python
+def reoptimize_node(
+    node: int,
+    omega_ub_row: np.array,
+    sp_data: dict,
+    solver_name: str,
+    general_solver_options: dict,
+    parallelism: int,
+    use_fixed_r: bool,
+  ) -> Tuple[np.array, float]:
+  """Capped local best response for one node.
+
+  Deep-copies sp_data, sets the per-function offloading cap omega_ub to the
+  accessible neighbour residual capacity, and re-solves ONLY ``node`` with
+  LSP_capped (or LSP_capped_fixedr when fixed replicas are active). Returns the
+  node's re-optimized omega row and the solve runtime. Only this omega row is
+  consumed by the caller; the capped solve's x/z/r are diagnostic.
+  """
+  Nf = sp_data[None]["Nf"][None]
+  node_data = deepcopy(sp_data)
+  node_data[None]["omega_ub"] = {
+    (f + 1): float(omega_ub_row[f]) for f in range(Nf)
+  }
+  model = LSP_capped_fixedr() if use_fixed_r else LSP_capped()
+  result = solve_subproblem(
+    node_data, [node], model, solver_name, general_solver_options, parallelism
+  )
+  sp_omega = result[4]
+  runtime = result[10]["tot"]
+  return np.array(sp_omega[node, :], dtype=float), float(runtime)
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `uv run pytest tests/test_bestresponse_reopt.py -v`
+Expected: PASS if Gurobi is available, else SKIP.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_bestresponse.py tests/test_bestresponse_reopt.py
+git commit -m "feat: add reoptimize_node capped per-node solve (FaaS-MABR-O)"
+```
+
+---
+
+### Task 4: `_run` + entry points `run_br_s/r/o`
+
+**Files:**
+- Modify: `decentralized_bestresponse.py` (append `parse_arguments`, `_run`, `run_br_s/r/o`, `__main__`)
+- Test: `tests/test_bestresponse_run.py`
+
+**Interfaces:**
+- Consumes: `best_response_sweep` (Task 2), `reoptimize_node` (Task 3), all imported helpers.
+- Produces: `_run(config, parallelism, *, order, response, method_name, options_key, log_on_file=False, disable_plotting=False) -> str`; `run_br_s/run_br_r/run_br_o(config, parallelism, log_on_file=False, disable_plotting=False) -> str`. Each writes `obj.csv` (column = its method name), `runtime.csv`, `termination_condition.csv`, `LSP_solution.csv`, `LSPc_solution.csv`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_bestresponse_run.py`:
+
+```python
+import numpy as np
+import networkx as nx
+
+import decentralized_bestresponse as mabr
+
+
+def test_run_br_o_uses_fixed_replicas_and_does_not_mutate_options(tmp_path, monkeypatch):
+  seen = {}
+  base_data = {None: {"Nn": {None: 1}, "Nf": {None: 1}, "neighborhood": {(1, 1): 0}}}
+
+  monkeypatch.setattr(mabr, "init_problem",
+    lambda *a, **k: (base_data, {}, [], nx.empty_graph(1)))
+  monkeypatch.setattr(mabr, "load_solution",
+    lambda folder, model: ("s", "rep", "fwd", None, None), raising=False)
+  monkeypatch.setattr(mabr, "encode_solution",
+    lambda Nn, Nf, s, d, r, t: (None, None, None, np.array([[3]]), None), raising=False)
+  monkeypatch.setattr(mabr, "LSP", lambda: "LSP")
+  monkeypatch.setattr(mabr, "LSP_fixedr", lambda: "LSP_fixedr", raising=False)
+
+  def _solve_subproblem(sp_data, agents, sp, *a):
+    seen["sp"] = sp
+    seen["r_bar"] = dict(sp_data[None].get("r_bar", {}))
+    return (sp_data, np.zeros((1, 1)), None, None, np.zeros((1, 1)),
+            np.ones((1, 1)), np.zeros((1,)), np.zeros((1, 1)),
+            {"tot": 0.0}, {"tot": "ok"}, {"tot": 0.0})
+
+  monkeypatch.setattr(mabr, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(mabr, "get_current_load", lambda *a: {})
+  monkeypatch.setattr(mabr, "update_data", lambda data, u: data)
+  monkeypatch.setattr(mabr, "compute_residual_capacity",
+    lambda *a: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))))
+  monkeypatch.setattr(mabr, "best_response_sweep",
+    lambda *a, **k: (np.zeros((1, 1, 1)),
+                     __import__("pandas").DataFrame({"i": [], "j": [], "f": []}),
+                     0, 0.0, 0.0))
+  monkeypatch.setattr(mabr, "combine_solutions",
+    lambda *a: {"sp": {"x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)),
+                       "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1))}})
+  monkeypatch.setattr(mabr, "compute_centralized_objective", lambda *a: 1.0)
+  monkeypatch.setattr(mabr, "check_feasibility", lambda *a: (True, "ok"))
+  monkeypatch.setattr(mabr, "decode_solutions",
+    lambda sp_data, sol, comp, arg: (comp, None, 1.0))
+  monkeypatch.setattr(mabr, "join_complete_solution", lambda comp: ({}, {}, {}))
+  monkeypatch.setattr(mabr, "save_checkpoint", lambda *a: None)
+  monkeypatch.setattr(mabr, "save_solution", lambda *a: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {"general": {"TimeLimit": 10},
+                       "br_o": {}},
+    "max_iterations": 1, "patience": 1, "max_steps": 1,
+    "min_run_time": 0, "max_run_time": 0, "run_time_step": 1,
+    "checkpoint_interval": 1, "verbose": 0,
+    "opt_solution_folder": "centralized-folder",
+  }
+
+  mabr.run_br_o(config, parallelism=0, disable_plotting=True)
+
+  assert seen["sp"] == "LSP_fixedr"
+  assert seen["r_bar"] == {(1, 1): 3}
+  assert "latency_weight" not in config["solver_options"]["br_o"]
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_bestresponse_run.py -v`
+Expected: FAIL — `AttributeError: module 'decentralized_bestresponse' has no attribute 'run_br_o'`.
+
+- [ ] **Step 3: Append `parse_arguments`, `_run`, entry points, `__main__`**
+
+First copy `parse_arguments` (lines 234–253), `run` (lines 256–500), and `__main__` (lines 503–506) **verbatim** from `decentralized_diffusion.py` into the end of `decentralized_bestresponse.py`. Then apply exactly these edits:
+
+**Edit 3a** — in `parse_arguments`, change the description and add a `--variant` argument (insert the new argument just before `return parser.parse_known_args()[0]`):
+
+```python
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MABR",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+```
+```python
+  parser.add_argument(
+    "--variant", choices=["s", "r", "o"], default="s",
+    help="FaaS-MABR variant: s (sequential), r (randomized), o (re-optimization)",
+  )
+  return parser.parse_known_args()[0]
+```
+
+**Edit 3b** — rename `def run(` to `def _run(` and replace its signature with:
+
+```python
+def _run(
+    config: dict,
+    parallelism: int,
+    *,
+    order: str,
+    response: str,
+    method_name: str,
+    options_key: str,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+```
+
+**Edit 3c** — replace the diffusion options block:
+
+```python
+  diffusion_options = dict(solver_options["diffusion"])
+  diffusion_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+```
+with the MABR options block + RNG:
+
+```python
+  br_options = dict(solver_options[options_key])
+  br_options.setdefault("latency_weight", 0.0)
+  br_options.setdefault("fairness_weight", 0.0)
+  rng = np.random.default_rng(seed)
+```
+
+**Edit 3d** — replace the whole coordinate block (from `s = datetime.now()` immediately above `bids, memory_bids, n_auctions = define_assignments(` down to the end of the `start_additional_replicas` block, i.e. `decentralized_diffusion.py` lines 357–410):
+
+```python
+      s = datetime.now()
+      bids, memory_bids, n_auctions = define_assignments(
+        omega, blackboard, sp_data, neighborhood, sp_rho,
+        diffusion_options, latency, fairness,
+        force_memory_bids=(
+          (sp_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_auctions) if n_auctions else rt
+      rmp_omega = np.zeros((Nn, Nf))
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        s = datetime.now()
+        diffusion_y, additional_replicas, n_sellers = evaluate_assignments(
+          bids, residual_capacity, sp_data, ell, sp_r, sp_rho,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+          last_y=y,
+          diffusion_options=diffusion_options,
+          latency=latency,
+          fairness=fairness,
+        )
+        rt = (datetime.now() - s).total_seconds()
+        total_runtime += (rt / n_sellers) if n_sellers else rt
+        y += diffusion_y
+        for n in range(Nn):
+          for f in range(Nf):
+            rmp_omega[n, f] = y[n, :, f].sum()
+            if rmp_omega[n, f] > 0:
+              fairness[n, f] += 1
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        for i in range(Nn):
+          for f in range(Nf):
+            omega[i, f] = sp_omega[i, f] - rmp_omega[i, f]
+            if abs(omega[i, f]) < tolerance:
+              omega[i, f] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+```
+
+with the MABR sweep block:
+
+```python
+      reopt_fn = None
+      if response == "reopt":
+        def reopt_fn(node, omega_ub_row):
+          return reoptimize_node(
+            node, omega_ub_row, sp_data, solver_name,
+            general_solver_options, parallelism,
+            use_fixed_r=(opt_solution is not None),
+          )
+      s = datetime.now()
+      sweep_y, memory_bids, n_active, placed_total, reopt_runtime = best_response_sweep(
+        omega, residual_capacity, sp_data, neighborhood, sp_rho,
+        br_options, latency, fairness,
+        force_memory_bids=(
+          (sp_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+        order=order, response=response, rng=rng, reopt_fn=reopt_fn,
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_active) if n_active else rt
+      total_runtime += reopt_runtime
+      rmp_omega = np.zeros((Nn, Nf))
+      additional_replicas = np.zeros((Nn, Nf))
+      if placed_total > 0:
+        y += sweep_y
+        for n in range(Nn):
+          for f in range(Nf):
+            rmp_omega[n, f] = y[n, :, f].sum()
+            if rmp_omega[n, f] > 0:
+              fairness[n, f] += 1
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        for i in range(Nn):
+          for f in range(Nf):
+            omega[i, f] = sp_omega[i, f] - rmp_omega[i, f]
+            if abs(omega[i, f]) < tolerance:
+              omega[i, f] = 0.0
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      mabr_no_progress = (placed_total == 0 and len(memory_bids) == 0)
+```
+
+**Edit 3e** — replace the `check_stopping_criteria` call (pass `None` for `bids`) and add the MABR guard. Change:
+
+```python
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, bids, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+```
+to:
+```python
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        additional_replicas, None, memory_bids,
+        tolerance, total_runtime, time_limit
+      )
+      if not stop_searching and mabr_no_progress:
+        stop_searching = True
+        why_stop_searching = "no best-response progress"
+```
+
+**Edit 3f** — change the `obj.csv` column header to the method name:
+
+```python
+  pd.DataFrame(obj_dict["LSPr_final"], columns=[method_name]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+```
+
+**Edit 3g** — append the three entry points and replace the `__main__` block:
+
+```python
+def run_br_s(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed", response="greedy",
+              method_name="FaaS-MABR-S", options_key="br_s",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_br_r(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="random", response="greedy",
+              method_name="FaaS-MABR-R", options_key="br_r",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_br_o(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed", response="reopt",
+              method_name="FaaS-MABR-O", options_key="br_o",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  runner = {"s": run_br_s, "r": run_br_r, "o": run_br_o}[args.variant]
+  runner(config, args.parallelism, disable_plotting=args.disable_plotting)
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `uv run pytest tests/test_bestresponse_run.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Confirm earlier tests still pass and the module imports cleanly**
+
+Run: `uv run pytest tests/test_bestresponse_helpers.py tests/test_bestresponse_run.py -v && uv run python -c "import decentralized_bestresponse as m; print('ok', callable(m.run_br_s), callable(m.run_br_r), callable(m.run_br_o))"`
+Expected: tests PASS; prints `ok True True True`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add decentralized_bestresponse.py tests/test_bestresponse_run.py
+git commit -m "feat: add FaaS-MABR _run loop and run_br_s/r/o entry points"
+```
+
+---
+
+### Task 5: Additive wiring (run.py, compare_results.py, planar config)
+
+**Files:**
+- Modify: `run.py`
+- Modify: `compare_results.py`
+- Modify: `config_files/planar_comparison.json`
+- Test: `tests/test_bestresponse_wiring.py`
+
+**Interfaces:**
+- Consumes: `decentralized_bestresponse.run_br_s/r/o` (Task 4).
+- Produces: `run.run_br_s/r/o` symbols; `faas-br-s/-r/-o` accepted in `--methods`; `FaaS-MABR-S/-R/-O` in `compare_results` default set and palettes; `solver_options.{br_s,br_r,br_o}` in the planar config.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_bestresponse_wiring.py`:
+
+```python
+import json
+from pathlib import Path
+
+import run
+
+
+def test_methods_choice_accepts_faas_br(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-br-s", "faas-br-r", "faas-br-o"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert {"faas-br-s", "faas-br-r", "faas-br-o"}.issubset(set(args.methods))
+
+
+def test_run_module_exposes_br_runners():
+  for name in ("run_br_s", "run_br_r", "run_br_o"):
+    assert callable(getattr(run, name))
+
+
+def test_planar_config_has_br_blocks():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  so = config["solver_options"]
+  assert "br_s" in so and "br_r" in so and "br_o" in so
+
+
+def test_compare_results_palette_includes_mabr():
+  import inspect
+  import compare_results
+  src = inspect.getsource(compare_results)
+  assert '"FaaS-MABR-S"' in src and '"FaaS-MABR-R"' in src and '"FaaS-MABR-O"' in src
+
+
+def test_compare_results_defaults_include_mabr(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  import compare_results
+  args = compare_results.parse_arguments()
+  assert {"FaaS-MABR-S", "FaaS-MABR-R", "FaaS-MABR-O"}.issubset(set(args.models))
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `uv run pytest tests/test_bestresponse_wiring.py -v`
+Expected: FAIL — `faas-br-s` not in argparse choices / `run` has no `run_br_s` / config has no `br_s` / palette missing.
+
+- [ ] **Step 3a: `run.py` import** — after `from decentralized_powerd import run as run_powerd`:
+
+```python
+from decentralized_bestresponse import (
+  run_br_s as run_br_s,
+  run_br_r as run_br_r,
+  run_br_o as run_br_o,
+)
+```
+
+- [ ] **Step 3b: `run.py` `--methods` choices** — add the three keys after `"faas-powd",`:
+
+```python
+      "faas-powd",
+      "faas-br-s",
+      "faas-br-r",
+      "faas-br-o",
+      "generate_only"
+```
+
+- [ ] **Step 3c: `run.py` `solution_folders` template** — add three keys (note the comma after `"faas-powd": []`):
+
+```python
+    "faas-diffuse": [],
+    "faas-powd": [],
+    "faas-br-s": [],
+    "faas-br-r": [],
+    "faas-br-o": []
+  }
+```
+
+- [ ] **Step 3d: `run.py` flag init** — after the `run_p = False` line:
+
+```python
+    run_brs = False # -- faas-br-s (FaaS-MABR-S)
+    run_brr = False # -- faas-br-r (FaaS-MABR-R)
+    run_bro = False # -- faas-br-o (FaaS-MABR-O)
+```
+
+- [ ] **Step 3e: `run.py` resume-time checks** — after the `faas-powd` resume block (ending `run_p = True`):
+
+```python
+      if (not generate_only and "faas-br-s" in methods) and ((
+          len(solution_folders.get("faas-br-s", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-s"][experiment_idx] is None
+        )):
+        run_brs = True
+      if (not generate_only and "faas-br-r" in methods) and ((
+          len(solution_folders.get("faas-br-r", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-r"][experiment_idx] is None
+        )):
+        run_brr = True
+      if (not generate_only and "faas-br-o" in methods) and ((
+          len(solution_folders.get("faas-br-o", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-o"][experiment_idx] is None
+        )):
+        run_bro = True
+```
+
+- [ ] **Step 3f: `run.py` `except ValueError` branch** — after `run_p = "faas-powd" in methods`:
+
+```python
+      run_brs = "faas-br-s" in methods
+      run_brr = "faas-br-r" in methods
+      run_bro = "faas-br-o" in methods
+```
+
+- [ ] **Step 3g: `run.py` run-guard** — change:
+
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_d or run_p or generate_only:
+```
+to:
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_d or run_p or run_brs or run_brr or run_bro or generate_only:
+```
+
+- [ ] **Step 3h: `run.py` dispatch blocks** — after the `faas-powd` dispatch block (ending its `set_solution_folder(..., "faas-powd", ...)`):
+
+```python
+      # -- solve best-response sequential (FaaS-MABR-S)
+      if run_brs:
+        brs_folder = run_br_s(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-s", experiment_idx, brs_folder
+        )
+      # -- solve best-response randomized (FaaS-MABR-R)
+      if run_brr:
+        brr_folder = run_br_r(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-r", experiment_idx, brr_folder
+        )
+      # -- solve best-response re-optimization (FaaS-MABR-O)
+      if run_bro:
+        bro_folder = run_br_o(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-o", experiment_idx, bro_folder
+        )
+```
+
+- [ ] **Step 3i: `run.py` `mname` ternary** — replace the innermost branch:
+
+```python
+                "FaaS-MADiG" if method == "faas-diffuse" else (
+                  "FaaS-MAPoD" if method == "faas-powd" else "HierarchicalAuction"
+                )
+```
+with:
+```python
+                "FaaS-MADiG" if method == "faas-diffuse" else (
+                  "FaaS-MAPoD" if method == "faas-powd" else (
+                    "FaaS-MABR-S" if method == "faas-br-s" else (
+                      "FaaS-MABR-R" if method == "faas-br-r" else (
+                        "FaaS-MABR-O" if method == "faas-br-o" else "HierarchicalAuction"
+                      )
+                    )
+                  )
+                )
+```
+(`mkey` needs no change: none of `faas-br-*` start with `faas-macro`, so they resolve to `"LSPc"`.)
+
+- [ ] **Step 3j: `run.py` `method_colors`** — extend the list (add a comma after `tab:brown` and three new entries):
+
+```python
+      mcolors.TABLEAU_COLORS["tab:brown"],
+      mcolors.TABLEAU_COLORS["tab:olive"],
+      mcolors.TABLEAU_COLORS["tab:cyan"],
+      mcolors.TABLEAU_COLORS["tab:gray"]
+    ]
+```
+
+- [ ] **Step 3k: `compare_results.py` default model set** — change line ~55:
+
+```python
+    default = ["LoadManagementModel", "FaaS-MACrO", "FaaS-MADeA", "FaaS-MADiG", "FaaS-MAPoD"]
+```
+to:
+```python
+    default = ["LoadManagementModel", "FaaS-MACrO", "FaaS-MADeA", "FaaS-MADiG", "FaaS-MAPoD", "FaaS-MABR-S", "FaaS-MABR-R", "FaaS-MABR-O"]
+```
+
+- [ ] **Step 3l: `compare_results.py` both palettes** — in `plot_by_key` and `violinplot_by_key`, add three entries after the `"FaaS-MAPoD"` line (add a comma after it):
+
+```python
+    "FaaS-MAPoD": mcolors.CSS4_COLORS["khaki"],
+    "FaaS-MABR-S": mcolors.CSS4_COLORS["mediumaquamarine"],
+    "FaaS-MABR-R": mcolors.CSS4_COLORS["sandybrown"],
+    "FaaS-MABR-O": mcolors.CSS4_COLORS["mediumpurple"]
+```
+
+- [ ] **Step 3m: `config_files/planar_comparison.json`** — after the `powerd` block, add a comma and the three blocks:
+
+```json
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+    "br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 }
+```
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_bestresponse_wiring.py -v`
+Expected: PASS (5 passed).
+
+- [ ] **Step 5: Verify JSON + imports + no regression of existing wiring**
+
+Run: `uv run python -c "import json; json.load(open('config_files/planar_comparison.json')); import run, compare_results; print('imports ok')"`
+Expected: prints `imports ok`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add run.py compare_results.py config_files/planar_comparison.json tests/test_bestresponse_wiring.py
+git commit -m "feat: wire FaaS-MABR-S/R/O into run.py, compare_results, planar config"
+```
+
+---
+
+### Task 6: End-to-end smoke + reproducibility (Gurobi-gated)
+
+**Files:**
+- Test: `tests/test_bestresponse_e2e.py`
+
+**Interfaces:**
+- Consumes: `decentralized_bestresponse.run_br_s/r/o` (Task 4).
+- Produces: none (test-only verification gate).
+
+- [ ] **Step 1: Write the e2e test**
+
+Create `tests/test_bestresponse_e2e.py`:
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_bestresponse import run_br_s, run_br_r, run_br_o
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {"trace_type": "clipped",
+               "min": {"min": 2.0, "max": 2.0},
+               "max": {"min": 3.0, "max": 3.0}},
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "br_s": {"latency_weight": 0.0, "fairness_weight": 0.0},
+      "br_r": {"latency_weight": 0.0, "fairness_weight": 0.0},
+      "br_o": {"latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 2, "patience": 1, "max_steps": 8,
+    "min_run_time": 1, "max_run_time": 1, "run_time_step": 1,
+    "checkpoint_interval": 1, "tolerance": 1e-6, "verbose": 0,
+  }
+
+
+def _assert_artifacts(folder, column):
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert column in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj[column], errors="coerce")).all()
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns and (runtime["tot"] >= 0).all()
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_br_s_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_s(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-S")
+
+
+def test_br_r_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_r(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-R")
+
+
+def test_br_o_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_o(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-O")
+
+
+def test_br_s_reproducible(tmp_path):
+  _require_gurobi()
+  fa = run_br_s(_e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True)
+  fb = run_br_s(_e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True)
+  oa = pd.read_csv(Path(fa, "obj.csv"))["FaaS-MABR-S"].to_numpy()
+  ob = pd.read_csv(Path(fb, "obj.csv"))["FaaS-MABR-S"].to_numpy()
+  assert oa.shape == ob.shape and oa.shape[0] >= 1
+  assert np.allclose(oa, ob)
+```
+
+- [ ] **Step 2: Run the e2e test**
+
+Run: `uv run pytest tests/test_bestresponse_e2e.py -v`
+Expected: PASS if Gurobi available, else SKIP.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/test_bestresponse_e2e.py
+git commit -m "test: add FaaS-MABR e2e smoke + reproducibility (Gurobi-gated)"
+```
+
+---
+
+### Task 7: LaTeX note `faas-bestresponse-note/`
+
+**Files:**
+- Create: `faas-bestresponse-note/faas-mabr.tex`
+- Create: `faas-bestresponse-note/main.tex`
+- Create: `faas-bestresponse-note/references.bib`
+- Create: `faas-bestresponse-note/README.md`
+- Create: `faas-bestresponse-note/.gitignore`
+
+**Interfaces:**
+- Consumes: the committed `faas-mapod-note/` files as templates (notation recap, preview wrapper, gitignore).
+- Produces: a standalone, compilable LaTeX note for the FaaS-MABR family.
+
+- [ ] **Step 1: Scaffold from the sibling note**
+
+```bash
+mkdir -p faas-bestresponse-note
+cp faas-mapod-note/.gitignore faas-bestresponse-note/.gitignore
+```
+
+- [ ] **Step 2: Create `faas-bestresponse-note/references.bib`**
+
+```bibtex
+% References for the FaaS-MABR positioning subsection (shared, verified set
+% plus the Gauss-Seidel anchor).
+
+@book{bertsekastsitsiklis1989,
+  author    = {Dimitri P. Bertsekas and John N. Tsitsiklis},
+  title     = {Parallel and Distributed Computation: Numerical Methods},
+  publisher = {Prentice-Hall},
+  year      = {1989},
+  address   = {Englewood Cliffs, NJ}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@article{cybenko1989,
+  author  = {George Cybenko},
+  title   = {Dynamic load balancing for distributed memory multiprocessors},
+  journal = {Journal of Parallel and Distributed Computing},
+  volume  = {7},
+  number  = {2},
+  pages   = {279--301},
+  year    = {1989},
+  doi     = {10.1016/0743-7315(89)90021-X}
+}
+```
+
+- [ ] **Step 3: Create `faas-bestresponse-note/main.tex`**
+
+```latex
+% Standalone preview wrapper for the FaaS-MABR note.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\begin{document}
+\input{faas-mabr}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
+```
+
+- [ ] **Step 4: Create the notation recap block**
+
+Copy the self-contained "Notation and capacity model" subsection from `faas-mapod-note/faas-mapod.tex` (the block between `% BEGIN self-contained notation recap` and `% END self-contained notation recap`) into a scratch buffer, changing only: relabel `sec:mapod-notation` → `sec:mabr-notation` and `tab:mapod-notation` → `tab:mabr-notation`; in the table's "Parameters and weights" group, replace the two FaaS-MAPoD rows (`Sample size` and `Selection criterion`) with one row:
+```
+Offloading cap & $\omega^{\mathrm{ub}}_i$ & per-function cap on $\omega_i$ in the capped local best response (FaaS-MABR-O).\\
+```
+
+- [ ] **Step 5: Create `faas-bestresponse-note/faas-mabr.tex`**
+
+```latex
+% =====================================================================
+% FaaS-MABR: distributed best-response (Gauss-Seidel) heuristics.
+% Meant to be \input{} (or pasted) into the paper. Assumes the paper's
+% notation (N, F, C_i^f, rho_i, omega_i^f, beta_{ij}^f, gamma_i^f, ...).
+% Cross-references are plain text; convert to \ref{} in the host paper.
+% =====================================================================
+
+\section{FaaS-MABR: sequential best-response (Gauss-Seidel) variants}
+\label{sec:mabr}
+
+\textsc{FaaS-MABR} (Multi-Agent Best-Response) is the \emph{sequential}
+counterpart of the \emph{simultaneous} coordination used by \textsc{FaaS-MADiG}
+and \textsc{FaaS-MAPoD}. The auction and its price-free diffusion ablations
+compute every overloaded node's request against a single snapshot of advertised
+capacity and then resolve the resulting cross-node conflicts (a Jacobi-style
+round followed by seller-side clearing). \textsc{FaaS-MABR} instead visits nodes
+in an order and lets each node claim capacity on a \emph{shared residual-capacity
+ledger that is decremented in place}, so a node responds to what earlier nodes
+have already taken. This is the Gauss-Seidel analogue of the same coordination
+problem, and because updates are sequential there are no cross-node conflicts and
+\emph{no seller-clearing phase}. Everything else is inherited from
+\textsc{FaaS-MADiG}: the local problem~(P2) that fixes $x_i^f$, $r_i^f$, and the
+residual demand $\omega_i^f$; the price-free score~$s_{ij}^f$ and the convenience
+threshold $\gamma_i^f$; the price-free replica expansion of Algorithm~4; and the
+restricted re-solve after each round.
+
+% PASTE HERE the notation recap subsection prepared in Step 4
+% (\subsection{Notation and capacity model} with table tab:mabr-notation,
+%  including the omega^ub row).
+
+\subsection{Sequential best-response sweep}
+\label{sec:mabr-sweep}
+
+At iteration $h$ the coordination is a single \emph{sweep} over the nodes. Let
+$\tilde C_j^f$ be the shared ledger, initialized to the true residual capacity
+$C_j^f(h)$ and decremented in place during the sweep. Visiting the nodes in the
+order $\sigma$ (a fixed index order or a per-sweep random permutation), each node
+$i$, for every $f$ with $\omega_i^f(h)>0$, admits the candidate sellers
+\begin{equation}
+  A_i^f(h)=\{\,j\in N_i : \tilde C_j^f \ge 1 \ \text{and}\ s_{ij}^f(h)>-\gamma_i^f\,\},
+  \qquad
+  s_{ij}^f(h)=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f(h),
+  \label{eq:mabr-score}
+\end{equation}
+and claims their capacity greedily in descending score order (tie-break: lower
+node id), decrementing $\tilde C_{j}^f$ as it claims, until $\omega_i^f(h)$ is met
+or $A_i^f(h)$ is exhausted. The immediate decrement is what distinguishes
+Gauss-Seidel from the Jacobi snapshot of \textsc{FaaS-MADiG}: in a fixed-order
+sweep a node that acts earlier can consume capacity that a later node would
+otherwise have seen. Unplaced demand triggers the same price-free
+replica-expansion requests to neighbours with memory slack $\rho_j(h)>0$ as in
+\textsc{FaaS-MADiG} (the two-block emission), collected over the whole sweep and
+served by Algorithm~4 afterwards. The inter-sweep restricted re-solve makes the
+overall scheme a Gauss-Seidel relaxation: each sweep best-responds to the state
+left by the previous sweep's re-solve, and the loop stops at a fixed point (a
+sweep that places no new load and emits no expansion requests).
+
+\subsection{The three variants}
+\label{sec:mabr-variants}
+
+\textsc{FaaS-MABR} spans two axes.
+
+\paragraph{Node order.} \textsc{FaaS-MABR-S} sweeps in a fixed ascending node
+order (deterministic, reproducible). \textsc{FaaS-MABR-R} draws a fresh random
+node permutation each sweep from a per-run generator seeded once; statistical
+variance is obtained by repeating experiments, as for \textsc{FaaS-MAPoD}.
+
+\paragraph{Response type.} \textsc{FaaS-MABR-S}/\textsc{-R} use a \emph{sequential
+greedy} response: the node places its residual demand on the ledger as above.
+These are Gauss-Seidel greedy responses, not optimal best responses.
+\textsc{FaaS-MABR-O} uses a \emph{capped local best response}: before placing,
+node $i$ re-solves its local subproblem with the horizontal offloading capped at
+the capacity its neighbours currently still advertise,
+\begin{equation}
+  \omega_i^f \le \omega^{\mathrm{ub}}_{i,f}, \qquad
+  \omega^{\mathrm{ub}}_{i,f}=\sum_{j\in N_i}\tilde C_j^f ,
+  \label{eq:mabr-cap}
+\end{equation}
+so it can reduce its horizontal demand and leave the rest to local execution or
+Cloud forwarding in the subsequent restricted solve. Only the re-optimized
+$\omega_i$ is committed to the sweep before placement; the capped probe's
+$x/z/r$ are diagnostic, and the final feasible state is produced by the
+restricted re-solve with fixed $y$. (The fourth combination, randomized-order
+re-optimization, is not used.)
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MABR} --- one sequential best-response sweep}
+\label{alg:mabr-sweep}
+\begin{algorithmic}[1]
+\Require ledger $\tilde C\gets C(h)$, residual demand $\omega(h)$, order $\sigma$, response $\in\{\text{greedy},\text{reopt}\}$
+\For{each node $i$ in order $\sigma$}
+  \If{response $=$ reopt}
+    \State $\omega^{\mathrm{ub}}_{i,f}\gets\sum_{j\in N_i}\tilde C_j^f$;\quad re-solve node $i$'s capped local problem; commit only $\omega_i$
+  \EndIf
+  \For{each $f$ with $\omega_i^f(h)>0$}
+    \State $A_i^f(h)\gets\{\,j\in N_i:\tilde C_j^f\ge1,\ s_{ij}^f(h)>-\gamma_i^f\,\}$
+    \State place $\omega_i^f(h)$ greedily by descending $s_{ij}^f(h)$ (tie-break lower id), decrementing $\tilde C_j^f$ in place
+    \If{demand remains} emit price-free replica-expansion requests to neighbours with $\rho_j(h)>0$ \EndIf
+  \EndFor
+\EndFor
+\State after the sweep: start additional replicas (Alg.~4); re-solve the restricted problem with fixed $y$
+\end{algorithmic}
+\end{algorithm}
+
+\subsection{What is kept and what changes}
+\label{sec:mabr-ablation}
+
+\noindent\textbf{Kept} (identical to \textsc{FaaS-MADiG}): the local
+problem~(P2); the advertised residual capacity and memory slack
+(Eqs.~(12)--(13)); the price-free score~\eqref{eq:mabr-score} and convenience
+threshold $\gamma_i^f$; the fairness penalty $\phi_i^f$; the price-free replica
+expansion of Algorithm~4; and the restricted re-solve.
+
+\noindent\textbf{Changed}: simultaneous (Jacobi) coordination becomes sequential
+(Gauss-Seidel) with an in-place-decremented ledger; the seller-clearing phase is
+removed (sequential updates produce no conflicts); and \textsc{FaaS-MABR-O} adds
+the anticipatory capped local re-optimization of Eq.~\eqref{eq:mabr-cap}.
+
+\subsection{Positioning with respect to the literature}
+\label{sec:mabr-related}
+
+We state plainly that \textsc{FaaS-MABR} instantiates a classical
+distributed-optimization pattern and is not claimed as novel. The sequential,
+in-place-update sweep is the \emph{Gauss-Seidel} relaxation, and the simultaneous
+snapshot of \textsc{FaaS-MADiG}/\textsc{FaaS-MAPoD} is its \emph{Jacobi}
+counterpart; both are textbook iterative schemes for distributed fixed-point
+computation~\citep{bertsekastsitsiklis1989}. \textsc{FaaS-MABR-S}/\textsc{-R} are
+sequential greedy responses (better-response, not exact best-response) dynamics,
+while \textsc{FaaS-MABR-O} computes a per-node capped best response. The
+underlying push of excess load to less-loaded neighbours remains the diffusion
+paradigm of Cybenko~\citep{cybenko1989}, and the relation to the auction is the
+familiar one between Gauss-Seidel relaxation and Bertsekas-style coordinate
+methods~\citep{bertsekas1988}. The value of the family is therefore the
+\emph{sequential-vs-simultaneous} contrast with \textsc{FaaS-MADiG} and the
+re-optimization ablation of \textsc{FaaS-MABR-O}, not a new heuristic.
+```
+
+(After pasting, replace the Step-4 comment line with the actual notation recap subsection.)
+
+- [ ] **Step 6: Create `faas-bestresponse-note/README.md`**
+
+```markdown
+# FaaS-MABR note
+
+A paper-ready LaTeX section explaining the **FaaS-MABR** family — three
+sequential (Gauss-Seidel) best-response heuristics (S: fixed-order greedy, R:
+randomized-order greedy, O: capped local best response) — in the notation of
+`Decentralized_FaaS_coordination.pdf`.
+
+## Files
+- `faas-mabr.tex` — the `\section{}` to `\input{}` (or paste) into the paper.
+  Remove the self-contained "Notation and capacity model" subsection on
+  insertion.
+- `main.tex` — standalone preview wrapper.
+- `references.bib` — cited works (Bertsekas & Tsitsiklis 1989 Gauss-Seidel
+  anchor; Cybenko diffusion; Bertsekas auction).
+- `.gitignore` — LaTeX build artifacts.
+
+## Build a preview
+```bash
+cd faas-bestresponse-note
+latexmk -pdf main.tex
+```
+
+## Insert into the paper
+1. `\input{faas-mabr}` (or paste the section).
+2. Delete the "Notation and capacity model" subsection.
+3. Convert plain-text cross-references to the host paper's `\ref{}` labels.
+4. Merge `references.bib` into the paper's bibliography.
+```
+
+- [ ] **Step 7: Compile the preview to verify it builds**
+
+Run:
+```bash
+cd faas-bestresponse-note && latexmk -pdf -interaction=nonstopmode main.tex
+```
+Expected: `main.pdf` is produced; no LaTeX errors (undefined-citation warnings on the first pass are fine — `latexmk` reruns BibTeX). Then clean: `latexmk -c main.tex`.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add faas-bestresponse-note/faas-mabr.tex faas-bestresponse-note/main.tex \
+        faas-bestresponse-note/references.bib faas-bestresponse-note/README.md \
+        faas-bestresponse-note/.gitignore
+git commit -m "docs: add FaaS-MABR LaTeX note (Gauss-Seidel positioning)"
+```
+
+---
+
+## Self-Review
+
+**1. Spec coverage:**
+- Part I §3 architecture (module, shared sweep, three entry points, reuse, no `evaluate_assignments`) → Tasks 2, 4. ✅
+- §3.1 `best_response_sweep` (ledger, order, greedy, threshold, memory parity, reopt plumbing, return tuple incl. `placed_total`/`reopt_runtime`) → Task 2. ✅
+- §3.2 reopt context (single-node `solve_subproblem([i])`, only `omega[i,:]` committed) → Task 3. ✅
+- §4 `LSP_capped`/`LSP_capped_fixedr` additive classes → Task 1. ✅
+- §3 fixed-point guard ("no best-response progress") + sweep-level replica expansion + `check_stopping_criteria` with `bids=None` → Task 4 (Edits 3d, 3e). ✅
+- §5 config blocks + no-mutation copy → Tasks 4, 5. ✅
+- §6 additive wiring ×3 (run.py, compare_results both palettes + default set, planar) → Task 5. ✅
+- §8 testing (sweep unit incl. order-dependence + stopping signal; `LSP_capped` structural + behavioral via reopt; wiring; e2e ×3 + reproducibility + `-O` fix_r) → Tasks 1,2,3,5,6. ✅
+- §2 names/CLI/columns `FaaS-MABR-S/-R/-O`, `faas-br-s/-r/-o`, `LSPc` → Tasks 4,5. ✅
+- Part II LaTeX note → Task 7. ✅
+- Out of scope (randomized-order reopt; other methods untouched) → respected. ✅
+
+**2. Placeholder scan:** No "TBD"/"TODO"/"handle edge cases". The notation-recap block is copied verbatim from a committed sibling file with one explicitly listed row change (Task 7 Steps 4–5) — concrete, not a placeholder.
+
+**3. Type consistency:** `best_response_sweep(...) -> (y_increment, memory_bids, n_active, placed_total, reopt_runtime)` is produced in Task 2 and unpacked identically in Task 4 (Edit 3d). `reopt_fn(node, omega_ub_row) -> (capped_row, runtime)` is the contract in both Task 2 (consumer) and Task 3 (`reoptimize_node`, the producer the `-O` runner wraps). `LSP_capped`/`LSP_capped_fixedr` (Task 1) are imported and used in Task 3. CLI keys `faas-br-{s,r,o}`, method names `FaaS-MABR-{S,R,O}`, runner symbols `run_br_{s,r,o}`, `mkey="LSPc"`, and `obj.csv` columns are consistent across Tasks 4–6.
+
+## Execution Handoff
+
+Plan complete and saved to `docs/superpowers/plans/2026-06-26-faas-mabr-best-response.md`. Two execution options:
+
+**1. Subagent-Driven (recommended)** — fresh subagent per task, review between tasks, fast iteration.
+
+**2. Inline Execution** — execute tasks in this session with checkpoints.
+
+Which approach?
diff --git a/docs/superpowers/plans/2026-06-26-faas-mapod-power-of-d.md b/docs/superpowers/plans/2026-06-26-faas-mapod-power-of-d.md
new file mode 100644
index 0000000..4857799
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-26-faas-mapod-power-of-d.md
@@ -0,0 +1,1271 @@
+# FaaS-MAPoD Power-of-d Heuristic Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add **FaaS-MAPoD**, a randomized power-of-d-choices distributed heuristic that probes only `d` randomly sampled neighbours per offloading step, as a sixth comparable method alongside LMM, FaaS-MACrO, FaaS-MADeA, HierarchicalAuction, and FaaS-MADiG.
+
+**Architecture:** A new standalone runner `decentralized_powerd.py` mirrors `decentralized_diffusion.py` (the FaaS-MADiG runner). It **reuses** `evaluate_assignments` from `decentralized_diffusion` and every helper from `run_faasmadea` **unchanged by import**. It replaces only the buyer side: a new `sample_assignments` function implements iterated power-of-d sampling with a config-selectable `criterion` (`score`|`capacity`). The sampling RNG is seeded once per run from `config["seed"]`; variance is captured by the existing `--n_experiments` aggregation. All wiring into `run.py`, `compare_results.py`, and `config_files/planar_comparison.json` is **additive only**.
+
+**Tech Stack:** Python 3.10, NumPy, pandas, Pyomo (Gurobi/GLPK). 2-space indentation. Run via `uv run`. Tests via `uv run pytest`. LaTeX via `latexmk` (Task 5).
+
+## Global Constraints
+
+- **2-space indentation** throughout (match the existing files).
+- **Do NOT modify** functions that support other methods: `run_faasmadea.py`, `run_faasmacro.py`, `run_centralized_model.py`, `models/`, `utils/`, `hierarchical_auction/`, and the existing `define_assignments`/`evaluate_assignments`/`run` in `decentralized_diffusion.py`. Reuse by import. New behaviour → new function in the new file.
+- **`run.py` / `compare_results.py` / `planar_comparison.json` changes are ADDITIVE only** — existing methods' code paths must stay byte-for-byte unchanged.
+- **Method name** `FaaS-MAPoD`; CLI key `faas-powd`; `obj.csv` column header `FaaS-MAPoD`; artifact family key `LSPc`.
+- **`evaluate_assignments` is reused unchanged** by import from `decentralized_diffusion`; the seller clearing stays score-ordered even when `criterion="capacity"`.
+- **Config block:** `solver_options.powerd = {"d":2, "criterion":"score", "latency_weight":0.0, "fairness_weight":0.0, "unit_bids":false}`. `unit_bids` falls back to `solver_options["auction"]["unit_bids"]` when absent. `run()` copies the options dict (`dict(...)`) before applying defaults so the input config is never mutated.
+- **Reproducibility:** the sampling RNG is `np.random.default_rng(config["seed"])`, created **once** before the time loop. Determinism is verified against two independent generators with the same seed (not two calls on one advanced generator).
+- **Out of scope (v1):** Option C (distributed best-response); a fully capacity-ordered seller clearing; per-instance K-seed averaging.
+
+---
+
+### Task 1: `sample_assignments` (randomized power-of-d buyer side)
+
+**Files:**
+- Create: `decentralized_powerd.py`
+- Test: `tests/test_powerd_helpers.py`
+
+**Interfaces:**
+- Consumes: `VAR_TYPE` from `run_faasmadea`; `data[None]["beta"][(i+1,j+1,f+1)]`, `data[None]["gamma"][(i+1,f+1)]` (same dict layout used by `decentralized_diffusion.define_assignments`).
+- Produces: `sample_assignments(omega, blackboard, data, neighborhood, rho, powerd_options, latency, fairness, force_memory_bids, rng) -> (pd.DataFrame[i,j,f,d,utility], pd.DataFrame[i,j,f], int)`. The `utility` column always holds the score `s_{ij}^f` (regardless of `criterion`) so the reused `evaluate_assignments` can sort sellers by `(utility, i)`.
+
+- [ ] **Step 1: Write the new module header + the failing test file**
+
+Create `decentralized_powerd.py` with the full import header (everything `run()` will need in Task 2, plus the reused `evaluate_assignments`):
+
+```python
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  VAR_TYPE,
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  ensure_memory_sellers,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from decentralized_diffusion import evaluate_assignments
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSPr
+
+from networkx import adjacency_matrix
+from collections import deque
+from datetime import datetime
+from copy import deepcopy
+from typing import Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+```
+
+Then create `tests/test_powerd_helpers.py`:
+
+```python
+import numpy as np
+import pandas as pd
+
+from decentralized_powerd import sample_assignments
+from decentralized_diffusion import define_assignments
+
+
+def _base_data(Nn=4, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _full_neighborhood(Nn=4):
+  neighborhood = np.ones((Nn, Nn)) - np.eye(Nn)
+  return neighborhood
+
+
+def _opts(d=2, criterion="score", unit_bids=False):
+  return {
+    "d": d, "criterion": criterion, "unit_bids": unit_bids,
+    "latency_weight": 0.0, "fairness_weight": 0.0,
+  }
+
+
+def test_sample_assignments_is_deterministic_given_seed():
+  data = _base_data()
+  # distinct betas so the random sampling has something to choose between
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  data[None]["beta"][(1, 4, 1)] = 1.5
+  omega = np.zeros((4, 1)); omega[0, 0] = 6.0
+  blackboard = np.zeros((4, 1)); blackboard[1, 0] = 2; blackboard[2, 0] = 2; blackboard[3, 0] = 2
+  rho = np.zeros((4,))
+  args = (omega, blackboard, data, _full_neighborhood(), rho,
+          _opts(d=2), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  bids1, _, _ = sample_assignments(*args, force_memory_bids=False,
+                                   rng=np.random.default_rng(123))
+  bids2, _, _ = sample_assignments(*args, force_memory_bids=False,
+                                   rng=np.random.default_rng(123))
+
+  pd.testing.assert_frame_equal(bids1, bids2)
+
+
+def test_sample_assignments_degenerates_to_madig_when_d_covers_candidates():
+  # d >= |candidates|, criterion="score", unique scores => same as FaaS-MADiG
+  data = _base_data()
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  data[None]["beta"][(1, 4, 1)] = 1.0
+  omega = np.zeros((4, 1)); omega[0, 0] = 4.0
+  blackboard = np.zeros((4, 1)); blackboard[1, 0] = 2; blackboard[2, 0] = 2; blackboard[3, 0] = 2
+  rho = np.zeros((4,))
+  common = (omega, blackboard, data, _full_neighborhood(), rho)
+  geo = (np.zeros((4, 4)), np.zeros((4, 1)))
+
+  sampled, _, _ = sample_assignments(
+    *common, _opts(d=99, criterion="score"), *geo,
+    force_memory_bids=False, rng=np.random.default_rng(0))
+  greedy, _, _ = define_assignments(
+    *common, _opts(d=99, criterion="score"), *geo, force_memory_bids=False)
+
+  pd.testing.assert_frame_equal(
+    sampled.reset_index(drop=True), greedy.reset_index(drop=True))
+
+
+def test_sample_assignments_capacity_criterion_prefers_largest_capacity():
+  # score ranks seller 1 best, but seller 2 advertises far more capacity;
+  # with d covering both, criterion="capacity" must pick seller 2 first.
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 9.0   # seller 1: best score, small capacity
+  data[None]["beta"][(1, 3, 1)] = 1.0   # seller 2: worse score, big capacity
+  omega = np.zeros((3, 1)); omega[0, 0] = 3.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 1; blackboard[2, 0] = 10
+  rho = np.zeros((3,))
+
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, _full_neighborhood(3), rho,
+    _opts(d=99, criterion="capacity"), np.zeros((3, 3)), np.zeros((3, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  first = bids.iloc[0]
+  assert first["j"] == 2           # largest-capacity seller picked first
+  assert first["d"] == 3.0
+
+
+def test_sample_assignments_threshold_excludes_unconvenient_seller():
+  data = _base_data(Nn=2, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 0.0
+  data[None]["gamma"][(1, 1)] = 0.05    # score 0.0 > -0.05 holds; flip sign below
+  data[None]["beta"][(1, 2, 1)] = -1.0  # score -1.0 <= -0.05 => excluded
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 5
+  rho = np.zeros((2,))
+
+  bids, memory_bids, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 0
+  assert len(memory_bids) == 0
+
+
+def test_sample_assignments_requests_replicas_when_no_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((2, 1))           # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0       # neighbour 1 has spare memory
+
+  bids, memory_bids, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 0
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_sample_assignments_unit_bids_emits_one_unit_per_request():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 3.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 3
+  rho = np.zeros((2,))
+
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2, unit_bids=True), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 3
+  assert (bids["d"] == 1).all()
+  assert (bids["j"] == 1).all()
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `uv run pytest tests/test_powerd_helpers.py -v`
+Expected: FAIL — `ImportError: cannot import name 'sample_assignments' from 'decentralized_powerd'` (the function does not exist yet).
+
+- [ ] **Step 3: Implement `sample_assignments`**
+
+Append this function to `decentralized_powerd.py` (after the import header):
+
+```python
+def sample_assignments(
+    omega: np.array,
+    blackboard: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    powerd_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    rng: np.random.Generator,
+  ) -> Tuple[pd.DataFrame, pd.DataFrame, int]:
+  """Power-of-d-choices counterpart of decentralized_diffusion.define_assignments.
+
+  For each overloaded (i, f), instead of scanning the whole candidate
+  neighbourhood greedily (FaaS-MADiG), repeatedly probe a random sample of ``d``
+  candidate sellers (uniform, without replacement) and pick the best by
+  ``criterion``: "score" -> max s_{ij}^f = beta - w_lat*L - w_fair*phi;
+  "capacity" -> max advertised residual capacity. Ties break on the lower node
+  id for reproducibility. The score is always stored in the ``utility`` column,
+  on which the reused evaluate_assignments later sorts the seller side.
+  """
+  d = int(powerd_options["d"])
+  criterion = powerd_options.get("criterion", "score")
+  unit_bids = powerd_options.get("unit_bids", False)
+  potential_buyers, functions_to_share = np.nonzero(omega)
+  bids = {"i": [], "j": [], "f": [], "d": [], "utility": []}
+  memory_bids = {"i": [], "j": [], "f": []}
+  for i, f in zip(potential_buyers, functions_to_share):
+    i = int(i)
+    f = int(f)
+    potential_sellers = set(np.nonzero(neighborhood[i, :])[0])
+    potential_capacity_sellers = potential_sellers.intersection(
+      set(np.where(blackboard[:, f] >= 1)[0])
+    )
+    potential_memory_sellers = potential_sellers.intersection(
+      set(np.nonzero(rho)[0])
+    )
+    score = {}
+    candidates = []
+    for j in potential_capacity_sellers:
+      j = int(j)
+      s = (
+        data[None]["beta"][(i + 1, j + 1, f + 1)]
+        - powerd_options["latency_weight"] * latency[i, j]
+        - powerd_options["fairness_weight"] * fairness[i, f]
+      )
+      if s > - data[None]["gamma"][(i + 1, f + 1)]:
+        score[j] = s
+        candidates.append(j)
+    # buyer-local view of advertised capacity, decremented as we bid, so we
+    # never request more from a seller than the buyer has observed locally
+    remaining = {j: int(blackboard[j, f]) for j in candidates}
+    assigned = 0
+    while assigned < omega[i, f] and len(candidates) > 0:
+      sample_size = min(d, len(candidates))
+      sample = rng.choice(candidates, size=sample_size, replace=False)
+      if criterion == "capacity":
+        j_star = int(max(sample, key=lambda j: (remaining[int(j)], -int(j))))
+      else:
+        j_star = int(max(sample, key=lambda j: (score[int(j)], -int(j))))
+      if unit_bids:
+        q = 1
+      else:
+        q = VAR_TYPE(min(remaining[j_star], omega[i, f] - assigned))
+      bids["i"].append(i)
+      bids["f"].append(f)
+      bids["j"].append(j_star)
+      bids["d"].append(q)
+      bids["utility"].append(score[j_star])
+      assigned += q
+      remaining[j_star] -= q
+      if remaining[j_star] < 1:
+        candidates.remove(j_star)
+    if assigned < omega[i, f] or force_memory_bids:
+      for j in potential_memory_sellers - potential_capacity_sellers:
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(int(j))
+        memory_bids["f"].append(f)
+  return pd.DataFrame(bids), pd.DataFrame(memory_bids), len(potential_buyers)
+```
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_powerd_helpers.py -v`
+Expected: PASS (6 passed).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_powerd.py tests/test_powerd_helpers.py
+git commit -m "feat: add sample_assignments power-of-d buyer rule (FaaS-MAPoD)"
+```
+
+---
+
+### Task 2: `run()` for FaaS-MAPoD
+
+**Files:**
+- Modify: `decentralized_powerd.py` (append `parse_arguments`, `run`, `__main__`)
+- Test: `tests/test_powerd_wiring.py`
+
+**Interfaces:**
+- Consumes: `sample_assignments` (Task 1, same file); `evaluate_assignments` (imported from `decentralized_diffusion`); all `run_faasmadea`/`run_faasmacro`/`run_centralized_model` helpers (imported in Task 1's header).
+- Produces: `run(config, parallelism, log_on_file=False, disable_plotting=False) -> str`. Writes `obj.csv` (column `FaaS-MAPoD`), `runtime.csv` (column `tot`), `termination_condition.csv`, `LSP_solution.csv`, `LSPc_solution.csv` into a timestamped folder under `config["base_solution_folder"]`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_powerd_wiring.py`:
+
+```python
+import json
+from pathlib import Path
+
+import numpy as np
+import networkx as nx
+
+import decentralized_powerd
+
+
+def test_powerd_run_uses_fixed_replicas_without_mutating_options(tmp_path, monkeypatch):
+  seen = {}
+  base_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0},
+    }
+  }
+
+  monkeypatch.setattr(
+    decentralized_powerd, "init_problem",
+    lambda *args, **kwargs: (base_data, {}, [], nx.empty_graph(1)),
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "load_solution",
+    lambda folder, model: ("opt_solution", "opt_replicas", "opt_detailed", None, None),
+    raising=False,
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "encode_solution",
+    lambda Nn, Nf, solution, detailed, replicas, t: (None, None, None, np.array([[3]]), None),
+    raising=False,
+  )
+  monkeypatch.setattr(decentralized_powerd, "LSP", lambda: "LSP")
+  monkeypatch.setattr(decentralized_powerd, "LSP_fixedr", lambda: "LSP_fixedr", raising=False)
+
+  def _solve_subproblem(sp_data, agents, sp, *args):
+    seen["sp"] = sp
+    seen["r_bar"] = dict(sp_data[None].get("r_bar", {}))
+    return (
+      sp_data, np.zeros((1, 1)), None, None, np.zeros((1, 1)),
+      np.ones((1, 1)), np.zeros((1,)), np.zeros((1, 1)),
+      {"tot": 0.0}, {"tot": "ok"}, {"tot": 0.0},
+    )
+
+  monkeypatch.setattr(decentralized_powerd, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(decentralized_powerd, "get_current_load", lambda *args: {})
+  monkeypatch.setattr(decentralized_powerd, "update_data", lambda data, update: data)
+  monkeypatch.setattr(
+    decentralized_powerd, "compute_residual_capacity",
+    lambda *args: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))),
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "sample_assignments",
+    lambda *args, **kwargs: (
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": [], "d": [], "utility": []}),
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": []}),
+      0,
+    ),
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "combine_solutions",
+    lambda *args: {"sp": {"x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)), "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1))}},
+  )
+  monkeypatch.setattr(decentralized_powerd, "compute_centralized_objective", lambda *args: 1.0)
+  monkeypatch.setattr(decentralized_powerd, "check_feasibility", lambda *args: (True, "ok"))
+  monkeypatch.setattr(
+    decentralized_powerd, "decode_solutions",
+    lambda sp_data, solution, complete, arg: (complete, None, 1.0),
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "join_complete_solution",
+    lambda complete: ({}, {}, {}),
+  )
+  monkeypatch.setattr(decentralized_powerd, "save_checkpoint", lambda *args: None)
+  monkeypatch.setattr(decentralized_powerd, "save_solution", lambda *args: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {
+      "general": {"TimeLimit": 10},
+      "auction": {"unit_bids": True},
+      "powerd": {"latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 1,
+    "patience": 1,
+    "max_steps": 1,
+    "min_run_time": 0,
+    "max_run_time": 0,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "verbose": 0,
+    "opt_solution_folder": "centralized-folder",
+  }
+
+  decentralized_powerd.run(config, parallelism=0, disable_plotting=True)
+
+  assert seen["sp"] == "LSP_fixedr"
+  assert seen["r_bar"] == {(1, 1): 3}
+  # run() applied its defaults to a COPY, not the input config
+  assert "d" not in config["solver_options"]["powerd"]
+  assert "unit_bids" not in config["solver_options"]["powerd"]
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_powerd_wiring.py::test_powerd_run_uses_fixed_replicas_without_mutating_options -v`
+Expected: FAIL — `AttributeError: module 'decentralized_powerd' has no attribute 'run'`.
+
+- [ ] **Step 3: Append `parse_arguments`, `run`, and `__main__`**
+
+Copy `parse_arguments` (lines 234–253), `run` (lines 256–500), and the `__main__` block (lines 503–506) **verbatim** from `decentralized_diffusion.py` into the end of `decentralized_powerd.py`, then apply exactly these five edits (and no others):
+
+**Edit 3a** — in `parse_arguments`, change the description string:
+
+```python
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MAPoD",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+```
+
+**Edit 3b** — in `run`, replace the diffusion-options block:
+
+```python
+  diffusion_options = dict(solver_options["diffusion"])
+  diffusion_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+```
+
+with the power-of-d options block plus the RNG:
+
+```python
+  powerd_options = dict(solver_options["powerd"])
+  powerd_options.setdefault("d", 2)
+  powerd_options.setdefault("criterion", "score")
+  powerd_options.setdefault("latency_weight", 0.0)
+  powerd_options.setdefault("fairness_weight", 0.0)
+  powerd_options.setdefault(
+    "unit_bids", solver_options.get("auction", {}).get("unit_bids", False)
+  )
+  rng = np.random.default_rng(seed)
+```
+
+**Edit 3c** — in the iteration loop, replace the `define_assignments(...)` call:
+
+```python
+      bids, memory_bids, n_auctions = define_assignments(
+        omega, blackboard, sp_data, neighborhood, sp_rho,
+        diffusion_options, latency, fairness,
+        force_memory_bids=(
+          (sp_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+      )
+```
+
+with the `sample_assignments(...)` call (note the trailing `rng=rng`):
+
+```python
+      bids, memory_bids, n_auctions = sample_assignments(
+        omega, blackboard, sp_data, neighborhood, sp_rho,
+        powerd_options, latency, fairness,
+        force_memory_bids=(
+          (sp_rho > 0).any()
+          and len(n_accepted_queue) >= n_accepted_queue.maxlen
+          and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+        ),
+        rng=rng,
+      )
+```
+
+**Edit 3d** — in the `evaluate_assignments(...)` call, pass `powerd_options` instead of `diffusion_options`:
+
+```python
+        diffusion_y, additional_replicas, n_sellers = evaluate_assignments(
+          bids, residual_capacity, sp_data, ell, sp_r, sp_rho,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+          last_y=y,
+          diffusion_options=powerd_options,
+          latency=latency,
+          fairness=fairness,
+        )
+```
+
+**Edit 3e** — change the `obj.csv` column header from `FaaS-MADiG` to `FaaS-MAPoD`:
+
+```python
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MAPoD"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `uv run pytest tests/test_powerd_wiring.py::test_powerd_run_uses_fixed_replicas_without_mutating_options -v`
+Expected: PASS.
+
+- [ ] **Step 5: Confirm the helper tests still pass and the module imports cleanly**
+
+Run: `uv run pytest tests/test_powerd_helpers.py -v && uv run python -c "import decentralized_powerd; print('ok', callable(decentralized_powerd.run))"`
+Expected: helper tests PASS; prints `ok True`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add decentralized_powerd.py tests/test_powerd_wiring.py
+git commit -m "feat: add FaaS-MAPoD run() reusing diffusion seller clearing"
+```
+
+---
+
+### Task 3: Additive wiring (run.py, compare_results.py, planar config)
+
+**Files:**
+- Modify: `run.py`
+- Modify: `compare_results.py`
+- Modify: `config_files/planar_comparison.json`
+- Test: `tests/test_powerd_wiring.py` (append tests)
+
+**Interfaces:**
+- Consumes: `decentralized_powerd.run` (Task 2).
+- Produces: `run.run_powerd` symbol; `faas-powd` accepted in `--methods`; `FaaS-MAPoD` in `compare_results` default model set and palettes; `solver_options.powerd` block in the planar config.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `tests/test_powerd_wiring.py`:
+
+```python
+import run
+
+
+def test_methods_choice_accepts_faas_powd(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-powd"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-powd" in args.methods
+
+
+def test_run_module_exposes_powerd_runner():
+  assert hasattr(run, "run_powerd")
+  assert callable(run.run_powerd)
+
+
+def test_planar_config_has_powerd_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  powerd = config["solver_options"]["powerd"]
+  assert powerd["d"] == 2
+  assert powerd["criterion"] == "score"
+
+
+def test_compare_results_palette_includes_mapod():
+  import inspect
+  import compare_results
+  source = inspect.getsource(compare_results)
+  assert '"FaaS-MAPoD"' in source
+
+
+def test_compare_results_defaults_include_mapod(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  import compare_results
+  args = compare_results.parse_arguments()
+  assert "FaaS-MAPoD" in args.models
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `uv run pytest tests/test_powerd_wiring.py -k "powd or mapod or powerd" -v`
+Expected: FAIL — `faas-powd` not in argparse choices / `run` has no `run_powerd` / config has no `powerd` section / palette missing.
+
+- [ ] **Step 3a: Add the import in `run.py`**
+
+After `run.py:7` (`from decentralized_diffusion import run as run_diffusion`):
+
+```python
+from decentralized_powerd import run as run_powerd
+```
+
+- [ ] **Step 3b: Add `faas-powd` to the `--methods` choices**
+
+In `run.py` `parse_arguments`, add `"faas-powd",` after `"faas-diffuse",`:
+
+```python
+    choices = [
+      "centralized", 
+      "faas-macro-v0", 
+      "faas-macro", 
+      "faas-madea",
+      "hierarchical",
+      "faas-diffuse",
+      "faas-powd",
+      "generate_only"
+    ],
+```
+
+- [ ] **Step 3c: Add the `faas-powd` key to the `solution_folders` template**
+
+In `run.py` (the `solution_folders = {...}` initializer), add the new key (note the added comma after the diffuse entry):
+
+```python
+  solution_folders = {
+    "experiments_list": [],
+    "centralized": [],
+    "faas-macro": [],
+    "faas-macro-v0": [],
+    "faas-madea": [],
+    "hierarchical": [],
+    "faas-diffuse": [],
+    "faas-powd": []
+  }
+```
+
+- [ ] **Step 3d: Add the `run_p` flag initialization**
+
+After the `run_d = False # -- faas-diffuse (FaaS-MADiG)` line:
+
+```python
+    run_p = False # -- faas-powd (FaaS-MAPoD)
+```
+
+- [ ] **Step 3e: Add the resume-time check for `faas-powd`**
+
+After the `faas-diffuse` resume block (the one ending `run_d = True`), add:
+
+```python
+      if (not generate_only and "faas-powd" in methods) and ((
+          len(solution_folders.get("faas-powd", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-powd"][experiment_idx] is None
+        )):
+        run_p = True
+```
+
+- [ ] **Step 3f: Add `run_p` to the `except ValueError` branch**
+
+After `run_d = "faas-diffuse" in methods`:
+
+```python
+      run_p = "faas-powd" in methods
+```
+
+- [ ] **Step 3g: Add `run_p` to the run-guard**
+
+Change the guard line:
+
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_d or generate_only:
+```
+
+to:
+
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_d or run_p or generate_only:
+```
+
+- [ ] **Step 3h: Add the dispatch block**
+
+After the `faas-diffuse` dispatch block (the one calling `run_diffusion` and `set_solution_folder(..., "faas-diffuse", ...)`), add:
+
+```python
+      # -- solve power-of-d (FaaS-MAPoD)
+      if run_p:
+        p_folder = run_powerd(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-powd", experiment_idx, p_folder
+        )
+```
+
+- [ ] **Step 3i: Extend the `mname` ternary**
+
+In `run.py` `results_postprocessing`, replace the innermost `mname` branch:
+
+```python
+                "FaaS-MADiG" if method == "faas-diffuse" else "HierarchicalAuction"
+```
+
+with:
+
+```python
+                "FaaS-MADiG" if method == "faas-diffuse" else (
+                  "FaaS-MAPoD" if method == "faas-powd" else "HierarchicalAuction"
+                )
+```
+
+(The `mkey` ternary needs no change: `faas-powd` does not start with `faas-macro`, so it resolves to `"LSPc"`.)
+
+- [ ] **Step 3j: Add a 7th method color**
+
+In `run.py` `results_postprocessing`, extend `method_colors` (add a comma after `tab:purple` and a new entry):
+
+```python
+    method_colors = [
+      mcolors.TABLEAU_COLORS["tab:blue"],
+      mcolors.TABLEAU_COLORS["tab:orange"],
+      mcolors.TABLEAU_COLORS["tab:red"],
+      mcolors.TABLEAU_COLORS["tab:green"],
+      mcolors.TABLEAU_COLORS["tab:pink"],
+      mcolors.TABLEAU_COLORS["tab:purple"],
+      mcolors.TABLEAU_COLORS["tab:brown"]
+    ]
+```
+
+- [ ] **Step 3k: Add `FaaS-MAPoD` to the `compare_results.py` default model set**
+
+Change `compare_results.py:55`:
+
+```python
+    default = ["LoadManagementModel", "FaaS-MACrO", "FaaS-MADeA", "FaaS-MADiG"]
+```
+
+to:
+
+```python
+    default = ["LoadManagementModel", "FaaS-MACrO", "FaaS-MADeA", "FaaS-MADiG", "FaaS-MAPoD"]
+```
+
+- [ ] **Step 3l: Add `FaaS-MAPoD` to both palettes in `compare_results.py`**
+
+In `plot_by_key` (the dict near line 668) add the entry after the `FaaS-MADiG` line (add a comma after it):
+
+```python
+    "FaaS-MADiG": mcolors.CSS4_COLORS["plum"],
+    "FaaS-MAPoD": mcolors.CSS4_COLORS["khaki"]
+```
+
+Apply the **identical** addition to the second palette in `violinplot_by_key` (the dict near line 829).
+
+- [ ] **Step 3m: Add the `powerd` block to `config_files/planar_comparison.json`**
+
+In `solver_options`, after the `diffusion` block, add a comma and the `powerd` block:
+
+```json
+    "diffusion": {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "powerd": {
+      "d": 2,
+      "criterion": "score",
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    }
+```
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `uv run pytest tests/test_powerd_wiring.py -v`
+Expected: PASS (all wiring tests + the Task 2 run mock test).
+
+- [ ] **Step 5: Verify no existing method wiring regressed**
+
+Run: `uv run python -c "import json; json.load(open('config_files/planar_comparison.json')); import run, compare_results; print('imports ok')"`
+Expected: prints `imports ok` (valid JSON, both modules import).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add run.py compare_results.py config_files/planar_comparison.json tests/test_powerd_wiring.py
+git commit -m "feat: wire FaaS-MAPoD into run.py, compare_results, planar config"
+```
+
+---
+
+### Task 4: End-to-end smoke + reproducibility (Gurobi-gated)
+
+**Files:**
+- Test: `tests/test_powerd_e2e.py`
+
+**Interfaces:**
+- Consumes: `decentralized_powerd.run` (Task 2).
+- Produces: none (test-only verification gate).
+
+- [ ] **Step 1: Write the e2e test**
+
+Create `tests/test_powerd_e2e.py`:
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_powerd import run as run_powerd
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _powerd_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "powerd": {"d": 2, "criterion": "score",
+                 "latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_powerd_runner_produces_expected_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_powerd(
+    _powerd_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert "FaaS-MAPoD" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MAPoD"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_powerd_runner_is_reproducible_for_same_seed(tmp_path):
+  _require_gurobi()
+  folder_a = run_powerd(
+    _powerd_e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  folder_b = run_powerd(
+    _powerd_e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+
+  obj_a = pd.read_csv(Path(folder_a, "obj.csv"))["FaaS-MAPoD"].to_numpy()
+  obj_b = pd.read_csv(Path(folder_b, "obj.csv"))["FaaS-MAPoD"].to_numpy()
+
+  assert obj_a.shape == obj_b.shape
+  assert np.allclose(obj_a, obj_b)
+```
+
+- [ ] **Step 2: Run the e2e test**
+
+Run: `uv run pytest tests/test_powerd_e2e.py -v`
+Expected: PASS if Gurobi is available; otherwise both tests SKIP with "Gurobi solver is not available".
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/test_powerd_e2e.py
+git commit -m "test: add FaaS-MAPoD e2e smoke and reproducibility (Gurobi-gated)"
+```
+
+---
+
+### Task 5: LaTeX note `faas-mapod-note/`
+
+**Files:**
+- Create: `faas-mapod-note/faas-mapod.tex`
+- Create: `faas-mapod-note/main.tex`
+- Create: `faas-mapod-note/references.bib`
+- Create: `faas-mapod-note/README.md`
+- Create: `faas-mapod-note/.gitignore`
+
+**Interfaces:**
+- Consumes: the committed `faas-madig-note/` files as templates (notation recap, preview wrapper, bibliography, gitignore).
+- Produces: a standalone, compilable LaTeX note for FaaS-MAPoD.
+
+- [ ] **Step 1: Scaffold by copying the shared sibling files**
+
+```bash
+mkdir -p faas-mapod-note
+cp faas-madig-note/references.bib faas-mapod-note/references.bib
+cp faas-madig-note/.gitignore faas-mapod-note/.gitignore
+```
+
+(The reference set is the already-verified shared set; reuse it as-is. `nezami2021` and `bertsekas1988` stay available even though the note leans on Mitzenmacher as the basis.)
+
+- [ ] **Step 2: Create `faas-mapod-note/main.tex` (preview wrapper)**
+
+```latex
+% Standalone preview wrapper for the FaaS-MAPoD note.
+% The deliverable section lives in faas-mapod.tex and is meant to be
+% \input{} (or pasted) into the host paper; this wrapper only renders it
+% on its own for review.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\begin{document}
+\input{faas-mapod}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
+```
+
+- [ ] **Step 3: Create the notation recap block**
+
+Copy the self-contained notation recap subsection from `faas-madig-note/faas-madig.tex` (the block delimited by `% BEGIN self-contained notation recap` … `% END self-contained notation recap`, i.e. the `\subsection{Notation and capacity model}` with its table) into a scratch buffer; it will be pasted into `faas-mapod.tex` in Step 4 with these two changes:
+- relabel `sec:madig-notation` → `sec:mapod-notation` and `tab:madig-notation` → `tab:mapod-notation`;
+- add two rows to the table's "Parameters and weights" group:
+  - `Sample size & $d$ & number of neighbours probed per offloading step (power-of-$d$).\\`
+  - `Selection criterion & --- & \texttt{score} (max $s_{ij}^f$) or \texttt{capacity} (max $C_j^f$).\\`
+
+- [ ] **Step 4: Create `faas-mapod-note/faas-mapod.tex`**
+
+```latex
+% =====================================================================
+% FaaS-MAPoD: randomized power-of-d-choices variant of FaaS-MADiG.
+% This file is meant to be \input{} (or pasted) into the paper.
+% It assumes the paper's notation (N, F, C_i^f, rho_i, omega_i^f,
+% beta_{ij}^f, gamma_i^f, ...) is already defined.
+% Cross-references are written as plain text "Eq.~(7)", "Alg.~4", etc.;
+% convert them to \ref{} once the labels of the host paper are known.
+% =====================================================================
+
+\section{FaaS-MAPoD: a randomized power-of-$d$-choices variant}
+\label{sec:mapod}
+
+\textsc{FaaS-MAPoD} (Multi-Agent Power-of-$d$) is the randomized,
+\emph{partial-visibility} sibling of \textsc{FaaS-MADiG}. It keeps every
+price-free ingredient of \textsc{FaaS-MADiG}---the local problem~(P2), the
+one-hop blackboard advertising residual execution capacity
+$C_i^f(h)=\max\{0,\mathrm{Cap}_i^f(h)-x_i^f(h)\}$~(Eq.~(12)) and memory slack
+$\rho_i(h)$~(Eq.~(13)), the convenience threshold $\gamma_i^f$, the fairness
+penalty $\phi_i^f$, the price-free replica expansion of Algorithm~4, and the
+restricted re-solve after each round. It changes \emph{only} how an overloaded
+buyer chooses where to offload: instead of scanning its entire one-hop
+candidate set $A_i^f(h)$ (as \textsc{FaaS-MADiG} does), it probes a random
+sample of just $d$ candidates per offloading step and serves the best of that
+sample---the classical \emph{power-of-$d$-choices} rule. Its purpose is to
+isolate the value of full neighbourhood visibility: \emph{how much does scanning
+the whole neighbourhood (FaaS-MADiG) buy over probing a random sample of $d$?}
+
+% PASTE HERE the notation recap subsection prepared in Step 3
+% (\subsection{Notation and capacity model} with table tab:mapod-notation,
+%  including the two added rows for d and the selection criterion).
+
+\subsection{Power-of-$d$ coordination}
+\label{sec:mapod-coordination}
+
+At iteration $h$, an overloaded buyer $i$ (with $\omega_i^f(h)>0$) admits the
+same candidate sellers as \textsc{FaaS-MADiG}: those advertising residual
+capacity $C_j^f(h)\ge 1$ and passing the convenience threshold,
+\begin{equation}
+  A_i^f(h)=\{\,j\in N_i : C_j^f(h)\ge 1 \ \text{and}\ s_{ij}^f(h)>-\gamma_i^f\,\},
+  \qquad
+  s_{ij}^f(h)=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f(h),
+  \label{eq:mapod-score}
+\end{equation}
+where $s_{ij}^f(h)$ is exactly the \textsc{FaaS-MADiG} score (the
+\textsc{FaaS-MADeA} utility with the price term removed). The difference is the
+\emph{visibility}: rather than ranking all of $A_i^f(h)$, the buyer repeatedly
+draws a uniform random sample $S\subseteq A_i^f(h)$ of size $\min(d,|A_i^f(h)|)$,
+\emph{without replacement}, and selects from $S$ the seller
+\begin{equation}
+  j^\star=
+  \begin{cases}
+    \arg\max_{j\in S}\ s_{ij}^f(h), & \text{criterion}=\texttt{score},\\[2pt]
+    \arg\max_{j\in S}\ C_j^f(h),     & \text{criterion}=\texttt{capacity},
+  \end{cases}
+  \label{eq:mapod-criterion}
+\end{equation}
+with ties broken by the lower node id for reproducibility. The \texttt{score}
+criterion ablates only the buyer's \emph{visibility} relative to
+\textsc{FaaS-MADiG}; the \texttt{capacity} criterion is the textbook
+shortest-queue (largest-spare-capacity) power-of-$d$ rule. In the default
+\emph{batched} form the buyer claims $\min(C_{j^\star}^f(h),\ \omega_i^f(h)-o)$
+from $j^\star$, removes it from the pool, and repeats until its demand is met or
+the candidate set is empty; in the \emph{per-unit} form (\texttt{unit\_bids})
+each unit of $\omega_i^f(h)$ draws a fresh sample of $d$, recovering the classic
+per-arrival power-of-$d$-choices. Any residual demand triggers the same
+price-free replica-expansion requests to neighbours with memory slack
+$\rho_j(h)>0$ as in \textsc{FaaS-MADiG}.
+
+When $d\ge|A_i^f(h)|$ the sample is the whole candidate set, and (for
+distinct scores) the \texttt{score} criterion reduces exactly to
+\textsc{FaaS-MADiG}'s greedy buyer rule---so \textsc{FaaS-MAPoD} interpolates
+between full-visibility greedy diffusion ($d=|A_i^f(h)|$) and blind random
+placement ($d=1$).
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MAPoD} --- buyer power-of-$d$ sampling (replaces the FaaS-MADiG buyer rule)}
+\label{alg:mapod-buyer}
+\begin{algorithmic}[1]
+\Require residual demand $\omega_i^f(h)$, blackboard residuals $C_j^f(h)$ and memory slacks $\rho_j(h)$, sample size $d$, criterion, RNG
+\For{each function $f$ with $\omega_i^f(h)>0$}
+  \State $A_i^f(h)\gets\{\,j\in N_i: C_j^f(h)\ge 1 \text{ and } s_{ij}^f(h)>-\gamma_i^f\,\}$
+  \State $o\gets 0$;\quad maintain a local view $\tilde C_j\gets C_j^f(h)$ for $j\in A_i^f(h)$
+  \While{$o<\omega_i^f(h)$ \textbf{and} $A_i^f(h)\ne\emptyset$}
+     \State draw a uniform sample $S\subseteq A_i^f(h)$, $|S|=\min(d,|A_i^f(h)|)$, without replacement
+     \State $j^\star\gets\arg\max_{j\in S} s_{ij}^f(h)$ \textbf{if} criterion${}=\texttt{score}$ \textbf{else} $\arg\max_{j\in S}\tilde C_j$ \Comment{tie-break: lower id}
+     \State $q\gets 1$ \textbf{if} \texttt{unit\_bids} \textbf{else} $\min(\tilde C_{j^\star},\,\omega_i^f(h)-o)$
+     \State emit assignment request $(i\!\to\! j^\star,f,q)$ with score $s_{ij^\star}^f(h)$;\quad $o\gets o+q$;\quad $\tilde C_{j^\star}\gets\tilde C_{j^\star}-q$
+     \If{$\tilde C_{j^\star}<1$} remove $j^\star$ from $A_i^f(h)$ \EndIf
+  \EndWhile
+  \If{$o<\omega_i^f(h)$}
+     \For{$j\in N_i$ with $\rho_j(h)>0$ and $j$ not already a capacity seller}
+        \State emit \emph{price-free} replica-expansion request $(i\!\to\! j,f)$
+     \EndFor
+  \EndIf
+\EndFor
+\end{algorithmic}
+\end{algorithm}
+
+The seller side is \emph{unchanged}: requests received by $j$ are cleared by
+\textsc{FaaS-MADiG}'s greedy fill (the \texttt{evaluate\_assignments} routine of
+Section~\ref{sec:madig-greedy}), which serves buyers in descending-score order
+up to the true residual capacity $C_j^f(h)$, tentatively starts replicas under
+the utilization test $\kappa_j^f\le 1$, and re-awards incumbent load only to a
+higher-score buyer. Consequently cross-buyer conflicts---when several buyers
+sample the same seller---are resolved identically to \textsc{FaaS-MADiG}; only
+the buyer's \emph{probe} is randomized.
+
+\subsection{What is removed and what is kept}
+\label{sec:mapod-ablation}
+
+\noindent\textbf{Removed} (relative to \textsc{FaaS-MADeA}): the entire price
+machinery, exactly as in \textsc{FaaS-MADiG}. \textbf{Removed} (relative to
+\textsc{FaaS-MADiG}): \emph{full neighbourhood visibility}---the buyer now sees
+only a random size-$d$ sample per step rather than the whole candidate set.
+
+\noindent\textbf{Kept} (identical to \textsc{FaaS-MADiG}): the local
+problem~(P2); the advertising of $C_i^f(h)$ and $\rho_i(h)$ (Eqs.~(12)--(13));
+the score~\eqref{eq:mapod-score} and the convenience threshold $\gamma_i^f$; the
+fairness penalty $\phi_i^f$; the price-free replica expansion of Algorithm~4;
+the score-ordered seller clearing and reassignment; and the restricted
+re-solve after each coordination round.
+
+\subsection{Rationale and properties}
+\label{sec:mapod-rationale}
+
+\paragraph{Visibility ablation.} Because \textsc{FaaS-MAPoD} shares its score,
+threshold, seller clearing, and provisioning with \textsc{FaaS-MADiG}, the
+\emph{only} behavioural difference is how many neighbours the buyer inspects per
+step. Any performance gap is therefore attributable to partial visibility
+alone, placing \textsc{FaaS-MAPoD} at the random/partial-visibility end of the
+\emph{market $\to$ greedy $\to$ random} spectrum
+(\textsc{FaaS-MADeA} $\to$ \textsc{FaaS-MADiG} $\to$ \textsc{FaaS-MAPoD}).
+
+\paragraph{Reproducibility.} The sampling generator is seeded once per run from
+the experiment seed, so a run is fully reproducible; statistical variance across
+the random draws is obtained by repeating experiments (the campaign's
+$n_{\text{experiments}}$ replicates, each with its own seed and instance) rather
+than by in-run averaging.
+
+\paragraph{Communication.} Each offloading step inspects at most $d$ neighbours,
+so \textsc{FaaS-MAPoD} has the smallest probe footprint of the three methods:
+it reads $O(d)$ blackboard entries per step instead of the full one-hop
+neighbourhood, while exchanging no prices.
+
+\subsection{Positioning with respect to the literature}
+\label{sec:mapod-related}
+
+We state plainly that the buyer rule of \textsc{FaaS-MAPoD} \emph{is} the
+power-of-$d$-choices load-balancing rule of
+Mitzenmacher~\citep{mitzenmacher2001}, applied to one-hop FRALB offloading; it
+is, by design, \emph{less} novel than \textsc{FaaS-MADiG} and is included as a
+controlled baseline, not as a new algorithm.
+
+\paragraph{Basis.} Probing $d$ uniformly random candidates and dispatching to
+the best is exactly the power-of-$d$-choices paradigm
+of~\citep{mitzenmacher2001}; with the \texttt{capacity} criterion and $d=2$ it
+is the canonical ``power of two choices'' (shortest of two sampled queues). The
+underlying push of excess load to less-loaded neighbours is the diffusion
+paradigm of Cybenko~\citep{cybenko1989} and the sender-initiated strategies
+catalogued by Willebeek-LeMair and Reeves~\citep{willebeek1993}; greedy,
+locality-driven offloading in FaaS/edge dispatchers~\citep{leechoi2021} is a
+full-visibility relative. \textsc{FaaS-MAPoD} and \textsc{FaaS-MADiG} are
+siblings: \textsc{FaaS-MADiG} is the $d\!=\!|A_i^f(h)|$ (full-visibility) limit
+of \textsc{FaaS-MAPoD}, and \textsc{FaaS-MADiG} is itself the price-frozen limit
+of the \textsc{FaaS-MADeA} auction~\citep{bertsekas1988}.
+
+\paragraph{Differences.} Two elements separate \textsc{FaaS-MAPoD} from the
+textbook power-of-$d$ rule. \emph{(i) Objective-aligned selection.} With the
+\texttt{score} criterion the buyer ranks the sample by the model's economic
+weights ($\beta_{ij}^f$, $\gamma_i^f$, latency $L_{ij}$, fairness $\phi_i^f$)
+rather than by raw queue length, and every round is re-validated by the local
+problem~(P2) and the restricted re-solve. \emph{(ii) Joint balancing and
+provisioning.} Beyond migrating load over a fixed graph, \textsc{FaaS-MAPoD}
+triggers memory-slack-based replica expansion (Algorithm~4), inherited from the
+\textsc{FaaS-MADeA}/\textsc{FaaS-MADiG} framework.
+
+\paragraph{Takeaway.} As an isolated coordination rule, \textsc{FaaS-MAPoD}
+instantiates power-of-$d$-choices balancing and is not claimed as novel; its
+value is as a partial-visibility ablation that attributes any gap with respect
+to \textsc{FaaS-MADiG} to full neighbourhood visibility, and as the random
+endpoint of the market$\to$greedy$\to$random spectrum.
+```
+
+(After pasting, replace the Step-3 comment line with the actual notation recap subsection.)
+
+- [ ] **Step 5: Create `faas-mapod-note/README.md`**
+
+```markdown
+# FaaS-MAPoD note
+
+A paper-ready LaTeX section explaining **FaaS-MAPoD**, the randomized
+power-of-d-choices sibling of FaaS-MADiG, in the notation of
+`Decentralized_FaaS_coordination.pdf`.
+
+## Files
+- `faas-mapod.tex` — the `\section{}` to `\input{}` (or paste) into the paper.
+  Remove the self-contained "Notation and capacity model" subsection on
+  insertion (the host paper already defines that notation and those equations).
+- `main.tex` — standalone preview wrapper (compile this to review the note).
+- `references.bib` — cited works (shared, already-verified set; Mitzenmacher is
+  the direct basis).
+- `.gitignore` — LaTeX build artifacts.
+
+## Build a preview
+```bash
+cd faas-mapod-note
+latexmk -pdf main.tex
+```
+
+## Insert into the paper
+1. `\input{faas-mapod}` (or paste the section).
+2. Delete the "Notation and capacity model" subsection.
+3. Convert the plain-text cross-references ("Eq.~(7)", "Alg.~4",
+   "Section~\ref{sec:madig-greedy}") to the host paper's `\ref{}` labels.
+4. Merge `references.bib` into the paper's bibliography (or re-key the
+   `\citep{}` commands).
+```
+
+- [ ] **Step 6: Compile the preview to verify it builds**
+
+Run:
+```bash
+cd faas-mapod-note && latexmk -pdf -interaction=nonstopmode main.tex
+```
+Expected: `main.pdf` is produced; no LaTeX errors (undefined-citation warnings on first pass are fine — `latexmk` reruns BibTeX). Then clean intermediates: `latexmk -c main.tex`.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add faas-mapod-note/faas-mapod.tex faas-mapod-note/main.tex \
+        faas-mapod-note/references.bib faas-mapod-note/README.md \
+        faas-mapod-note/.gitignore
+git commit -m "docs: add FaaS-MAPoD LaTeX note (power-of-d positioning)"
+```
+
+---
+
+## Self-Review
+
+**1. Spec coverage:**
+- Part I §3.1 `sample_assignments` (criteria, batched/per-unit, threshold, memory fallback, remaining_blackboard, tie-break, degeneracy) → Task 1. ✅
+- Part I §3.2 `run()` (RNG once, powerd options w/ defaults + no mutation, sample swap, evaluate reuse, fix_r/LSP_fixedr, obj column) → Task 2. ✅
+- Part I §5 additive `run.py` wiring (import, choices, solution_folders, run_p flag/resume/except/guard, dispatch, mname, color) → Task 3. ✅
+- Part I §4 config block + §6 compare_results palette/defaults + planar config → Task 3. ✅
+- Part I §7 testing (unit, wiring, e2e + reproducibility) → Tasks 1, 2, 3, 4. ✅
+- Part II §9–§12 LaTeX note → Task 5. ✅
+- Out-of-scope items (Option C, capacity-ordered clearing, K-seed averaging) → not implemented, as required. ✅
+
+**2. Placeholder scan:** No "TBD"/"TODO"/"handle edge cases". The only deferred content is the notation-recap block, which is copied verbatim from a committed file with two explicitly listed row additions (Task 5 Steps 3–4) — concrete, not a placeholder.
+
+**3. Type consistency:** `sample_assignments(... , rng)` returns `(DataFrame[i,j,f,d,utility], DataFrame[i,j,f], int)`, matching the `bids, memory_bids, n_auctions` unpack in `run()` (Task 2 Edit 3c) and the `evaluate_assignments` consumer. `powerd_options` keys (`d`, `criterion`, `unit_bids`, `latency_weight`, `fairness_weight`) are produced in Task 2 Edit 3b and consumed by `sample_assignments` (Task 1). CLI key `faas-powd`, method name `FaaS-MAPoD`, mkey `LSPc`, obj column `FaaS-MAPoD`, runner symbol `run_powerd` are consistent across Tasks 2–4.
+
+## Execution Handoff
+
+Plan complete and saved to `docs/superpowers/plans/2026-06-26-faas-mapod-power-of-d.md`. Two execution options:
+
+**1. Subagent-Driven (recommended)** — fresh subagent per task, review between tasks, fast iteration.
+
+**2. Inline Execution** — execute tasks in this session with checkpoints.
+
+Which approach?
diff --git a/docs/superpowers/plans/2026-06-30-centralized-feasibility-contract.md b/docs/superpowers/plans/2026-06-30-centralized-feasibility-contract.md
new file mode 100644
index 0000000..a0e65b0
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-30-centralized-feasibility-contract.md
@@ -0,0 +1,470 @@
+# Centralized Feasibility Contract Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make every heuristic generate and report only solutions feasible for `LoadManagementModel`, with fail-fast diagnostics as a final safety check.
+
+**Architecture:** Add a complete array-level validator beside the existing lightweight feasibility helper, preserving that high-risk helper's signature. Invoke the validator once in `combine_solutions`, the shared assembly point used by all command-line heuristic runners. Prevent the hierarchical engine from requesting non-neighbor or ping-pong allocations so validation is an invariant check rather than normal control flow.
+
+**Tech Stack:** Python 3.10, NumPy, pytest, Pyomo/Gurobi for the final comparison.
+
+---
+
+### Task 1: Canonical centralized-feasibility validator
+
+**Files:**
+- Modify: `utils/centralized.py`
+- Create: `tests/test_centralized_feasibility.py`
+
+- [ ] **Step 1: Re-run impact analysis immediately before editing**
+
+Run GitNexus impact for the existing `check_feasibility` symbol and record that its current signature remains unchanged. The known result is CRITICAL: 44 dependents and 9 affected execution flows. This task adds a new sibling function rather than changing those callers.
+
+- [ ] **Step 2: Write failing validator tests**
+
+Create a compact two-node, one-function fixture and tests for a valid solution plus every constraint family:
+
+```python
+import numpy as np
+import pytest
+
+from utils.centralized import validate_centralized_solution
+
+
+def _data():
+  return {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 2.0, (2, 1): 2.0},
+    "neighborhood": {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+    "demand": {(1, 1): 0.4, (2, 1): 0.4},
+    "max_utilization": {1: 0.8},
+    "memory_requirement": {1: 1},
+    "memory_capacity": {1: 4, 2: 4},
+  }}
+
+
+def _solution():
+  return (
+    np.array([[2.0], [2.0]]),
+    np.zeros((2, 2, 1)),
+    np.zeros((2, 1)),
+    np.ones((2, 1)),
+  )
+
+
+def test_validate_centralized_solution_accepts_valid_arrays():
+  x, y, z, r = _solution()
+  validate_centralized_solution(x, y, z, r, _data())
+
+
+def test_validate_centralized_solution_rejects_non_neighbor():
+  x, y, z, r = _solution()
+  y[0, 0, 0] = 1.0
+  x[0, 0] = 1.0
+  with pytest.raises(ValueError, match="offload_only_to_neighbors"):
+    validate_centralized_solution(x, y, z, r, _data())
+
+
+def test_validate_centralized_solution_rejects_ping_pong():
+  x, y, z, r = _solution()
+  x[:, 0] = 1.0
+  y[0, 1, 0] = y[1, 0, 0] = 1.0
+  with pytest.raises(ValueError, match="no_ping_pong"):
+    validate_centralized_solution(x, y, z, r, _data())
+
+
+@pytest.mark.parametrize(
+  ("field", "value", "message"),
+  [
+    ("x", 1.0, "no_traffic_loss"),
+    ("r", 0.0, "utilization_equilibrium"),
+    ("r", 3.0, "utilization_equilibrium2"),
+  ],
+)
+def test_validate_centralized_solution_rejects_balance_and_utilization(
+  field, value, message,
+):
+  x, y, z, r = _solution()
+  {"x": x, "r": r}[field][0, 0] = value
+  with pytest.raises(ValueError, match=message):
+    validate_centralized_solution(x, y, z, r, _data())
+
+
+def test_validate_centralized_solution_rejects_memory_excess():
+  x, y, z, r = _solution()
+  data = _data()
+  data[None]["memory_capacity"][1] = 0
+  with pytest.raises(ValueError, match="residual_capacity"):
+    validate_centralized_solution(x, y, z, r, data)
+```
+
+- [ ] **Step 3: Run tests and verify RED**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_centralized_feasibility.py -q
+```
+
+Expected: collection fails because `validate_centralized_solution` does not exist.
+
+- [ ] **Step 4: Implement the minimal validator**
+
+Add `validate_centralized_solution(x, y, z, r, data, tolerance=1e-6) -> None` to `utils/centralized.py`. It must:
+
+```python
+def validate_centralized_solution(x, y, z, r, data, tolerance=1e-6):
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  if x.shape != (Nn, Nf) or y.shape != (Nn, Nn, Nf):
+    raise ValueError("solution_shape: incompatible x/y dimensions")
+  if z.shape != (Nn, Nf) or r.shape != (Nn, Nf):
+    raise ValueError("solution_shape: incompatible z/r dimensions")
+  for name, values in (("x", x), ("y", y), ("z", z), ("r", r)):
+    bad = np.argwhere(values < -tolerance)
+    if len(bad):
+      raise ValueError(f"nonnegative_{name}: {tuple(bad[0])}")
+  bad = np.argwhere(np.abs(r - np.rint(r)) > tolerance)
+  if len(bad):
+    raise ValueError(f"integer_replicas: {tuple(bad[0])}")
+
+  neighborhood = np.zeros((Nn, Nn))
+  for (n, m), adjacent in data[None]["neighborhood"].items():
+    neighborhood[n - 1, m - 1] = adjacent
+  bad = np.argwhere((y > tolerance) & (neighborhood[:, :, None] == 0))
+  if len(bad):
+    raise ValueError(f"offload_only_to_neighbors: {tuple(bad[0])}")
+
+  outgoing = y.sum(axis=1)
+  incoming = y.sum(axis=0)
+  bad = np.argwhere((outgoing > tolerance) & (incoming > tolerance))
+  if len(bad):
+    raise ValueError(f"no_ping_pong: {tuple(bad[0])}")
+
+  for n in range(Nn):
+    used_memory = 0.0
+    for f in range(Nf):
+      load = data[None]["incoming_load"][(n + 1, f + 1)]
+      if abs(x[n, f] + outgoing[n, f] + z[n, f] - load) > tolerance:
+        raise ValueError(f"no_traffic_loss: {(n, f)}")
+      processed = x[n, f] + incoming[n, f]
+      demand = data[None]["demand"][(n + 1, f + 1)]
+      max_utilization = data[None]["max_utilization"][f + 1]
+      utilization = demand * processed
+      if utilization - r[n, f] * max_utilization > tolerance:
+        raise ValueError(f"utilization_equilibrium: {(n, f)}")
+      if (r[n, f] - 1) * max_utilization - utilization > tolerance:
+        raise ValueError(f"utilization_equilibrium2: {(n, f)}")
+      used_memory += r[n, f] * data[None]["memory_requirement"][f + 1]
+    if used_memory - data[None]["memory_capacity"][n + 1] > tolerance:
+      raise ValueError(f"residual_capacity: {n}")
+```
+
+Do not modify `check_feasibility`; existing callers remain compatible.
+
+- [ ] **Step 5: Run focused tests and verify GREEN**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_centralized_feasibility.py tests/test_utilities.py -q
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 6: Commit the validator**
+
+```bash
+git add utils/centralized.py tests/test_centralized_feasibility.py
+git commit -m "add centralized feasibility validator"
+```
+
+Before committing, run `gitnexus_detect_changes({scope: "staged"})` and verify only the new validator and its tests are reported.
+
+### Task 2: Enforce the contract at the shared solution boundary
+
+**Files:**
+- Modify: `run_faasmacro.py:273-317`
+- Modify: `tests/test_faas_helpers_extended.py`
+
+- [ ] **Step 1: Re-run impact analysis immediately before editing**
+
+Run `gitnexus_impact` upstream for `combine_solutions`. The known result is CRITICAL: 8 direct callers, 49 impacted symbols, and 8 execution flows. This broad reach is intentional because these callers are the command-line heuristic algorithms that require the common safety boundary. Reconfirm all d=1 callers before proceeding.
+
+- [ ] **Step 2: Write a failing boundary test**
+
+Extend the existing combine-solution tests with a valid two-node data fixture and a non-neighbor flow:
+
+```python
+def _two_node_data(neighborhood):
+  data = {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 1.0, (2, 1): 1.0},
+    "neighborhood": {
+      (1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0,
+    },
+    "demand": {(1, 1): 0.4, (2, 1): 0.4},
+    "max_utilization": {1: 0.8},
+    "memory_requirement": {1: 1},
+    "memory_capacity": {1: 2, 2: 2},
+    "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+    "beta": {
+      (1, 1, 1): 0.9, (1, 2, 1): 0.9,
+      (2, 1, 1): 0.9, (2, 2, 1): 0.9,
+    },
+    "gamma": {(1, 1): 0.8, (2, 1): 0.8},
+  }}
+  data[None]["neighborhood"].update(neighborhood)
+  return data
+
+
+def test_combine_solutions_rejects_centralized_infeasibility():
+  data = _two_node_data(neighborhood={(1, 2): 0, (2, 1): 0})
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 1.0
+  with pytest.raises(ValueError, match="offload_only_to_neighbors"):
+    combine_solutions(
+      2, 1, data, {(1, 1): 1.0, (2, 1): 1.0},
+      np.zeros((2, 1)), np.ones((2, 1)), np.zeros(2),
+      None, y, None, None, None, None,
+    )
+```
+
+Keep the fixture local to `tests/test_faas_helpers_extended.py` and include all parameters required by `compute_utilization` and the validator.
+
+- [ ] **Step 3: Run the boundary test and verify RED**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_faas_helpers_extended.py::test_combine_solutions_rejects_centralized_infeasibility -q
+```
+
+Expected: FAIL because `combine_solutions` currently returns the invalid solution.
+
+- [ ] **Step 4: Validate before returning the shared solution**
+
+Import `validate_centralized_solution` in `run_faasmacro.py`, assign the current return literal to `solution`, validate its `sp` arrays, then return it:
+
+```python
+solution = {
+  "sp": {
+    "x": sp_x, "y": rmp_y, "z": sp_z, "r": spr_r,
+    "xi": sp_xi, "rho": sp_rho, "U": spr_U,
+  },
+  "rmp": {
+    "x": rmp_x, "y": rmp_y, "z": rmp_z, "r": rmp_r,
+    "xi": rmp_xi, "rho": rmp_rho, "U": spr_U,
+  },
+}
+validate_centralized_solution(
+  solution["sp"]["x"], solution["sp"]["y"],
+  solution["sp"]["z"], solution["sp"]["r"], sp_data,
+)
+return solution
+```
+
+Do not add checks to each runner; all eight direct algorithm callers already pass through this boundary.
+
+- [ ] **Step 5: Run shared-helper and runner unit tests**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_faas_helpers_extended.py tests/test_algorithm_helpers.py tests/test_bestresponse_run.py tests/test_diffusion_wiring.py tests/test_powerd_wiring.py tests/test_hierarchical_runner.py -q
+```
+
+Expected: all tests pass, or mocked fixtures must be completed only with data required by the real centralized contract. Do not weaken validation for mocks.
+
+- [ ] **Step 6: Commit the shared safety boundary**
+
+```bash
+git add run_faasmacro.py tests/test_faas_helpers_extended.py
+git commit -m "enforce centralized feasibility for heuristic solutions"
+```
+
+Before committing, run `gitnexus_detect_changes({scope: "staged"})` and verify the eight known algorithm flows are the only production flows affected.
+
+### Task 3: Prevent invalid hierarchical allocations by construction
+
+**Files:**
+- Modify: `hierarchical_auction/engine.py:80-315`
+- Modify: `tests/test_hierarchical_engine.py`
+
+- [ ] **Step 1: Re-run impact analysis immediately before editing**
+
+Run `gitnexus_impact` upstream for `_generate_level_requests`. The known risk is LOW: one direct caller (`run_higher_levels`) and two affected execution flows. Report this blast radius before editing.
+
+- [ ] **Step 2: Change the non-neighbor expectation into a failing prevention test**
+
+Replace `test_level2_allocates_from_adjacent_structure_seller_node` with:
+
+```python
+def _engine(neighborhood):
+  return HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.ones(1),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01, "eta": [0.5, 0.3],
+      "latency_weight": 0.0, "fairness_weight": 0.0,
+    },
+  )
+
+
+def test_higher_level_never_allocates_to_non_neighbor_node():
+  neighborhood = np.array([
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0],
+  ], dtype=float)
+  engine = _engine(neighborhood)
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 1)),
+    omega=np.array([[3.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0], [5.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+  assert result.y[0, 2, 0] == 0.0
+  assert result.omega[0, 0] == 3.0
+```
+
+Also change the service-quantum test topology to a complete three-node graph so it still tests token conversion using an admissible direct edge.
+
+- [ ] **Step 3: Add a failing ping-pong prevention test**
+
+```python
+def test_higher_level_never_makes_receiver_send_same_function():
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  y = np.zeros((3, 3, 1))
+  y[1, 0, 0] = 1.0
+  result = _engine(neighborhood).run_higher_levels(
+    y=y,
+    omega=np.array([[2.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0], [2.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+  assert result.y[0, 2, 0] == 0.0
+```
+
+- [ ] **Step 4: Run both tests and verify RED**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_hierarchical_engine.py::test_higher_level_never_allocates_to_non_neighbor_node tests/test_hierarchical_engine.py::test_higher_level_never_makes_receiver_send_same_function -q
+```
+
+Expected: both tests fail because remote and ping-pong requests are currently generated.
+
+- [ ] **Step 5: Add direct-edge and no-ping-pong request guards**
+
+Pass `current_y` into `_generate_level_requests`. At the start of that method derive provisional roles:
+
+```python
+sending = current_y.sum(axis=1) > 1e-10
+receiving = current_y.sum(axis=0) > 1e-10
+```
+
+Before creating a candidate, require:
+
+```python
+if self._neighborhood[buyer_node, seller_node] <= 0:
+  continue
+if receiving[buyer_node, f] or sending[seller_node, f]:
+  continue
+```
+
+After registering a request, reserve the roles conservatively for the remainder of that auction level:
+
+```python
+sending[buyer_node, f] = True
+receiving[seller_node, f] = True
+```
+
+This may exclude a later request if an earlier request loses conflict resolution, but it cannot create an invalid solution and requires no rollback protocol.
+
+- [ ] **Step 6: Run hierarchical tests and verify GREEN**
+
+Run:
+
+```bash
+.venv/bin/pytest tests/test_hierarchical_engine.py tests/test_hierarchical_flow_mapper.py tests/test_hierarchical_runner.py -q
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 7: Commit hierarchical prevention**
+
+```bash
+git add hierarchical_auction/engine.py tests/test_hierarchical_engine.py
+git commit -m "keep hierarchical allocations centrally feasible"
+```
+
+Before committing, run `gitnexus_detect_changes({scope: "staged"})` and verify only hierarchical request generation and its two known flows are affected.
+
+### Task 4: Prove the centralized upper bound and run regression checks
+
+**Files:**
+- Modify: `tests/test_e2e_gurobi_planar.py:89-143`
+
+- [ ] **Step 1: Add the objective-bound assertion**
+
+After running the centralized and hierarchical methods, load both `obj.csv` files and assert the bound with solver tolerance:
+
+```python
+centralized_obj = pd.read_csv(Path(centralized_folder, "obj.csv"))["LoadManagementModel"]
+hierarchical_obj = pd.read_csv(Path(hierarchical_folder, "obj.csv"))["HierarchicalAuction"]
+assert (hierarchical_obj <= centralized_obj + 1e-6).all()
+```
+
+- [ ] **Step 2: Run the focused Gurobi end-to-end test**
+
+Run:
+
+```bash
+MPLCONFIGDIR=/tmp/matplotlib .venv/bin/pytest tests/test_e2e_gurobi_planar.py -q
+```
+
+Expected: PASS, including the new upper-bound assertion.
+
+- [ ] **Step 3: Run the complete test suite**
+
+Run:
+
+```bash
+MPLCONFIGDIR=/tmp/matplotlib .venv/bin/pytest -q
+```
+
+Expected: all tests pass with no unexpected warnings or errors.
+
+- [ ] **Step 4: Verify change scope and commit the regression assertion**
+
+Run:
+
+```bash
+git add tests/test_e2e_gurobi_planar.py
+```
+
+Then run `gitnexus_detect_changes({scope: "staged"})`, confirm the affected scope matches the centralized/distributed/hierarchical planar flow, and commit:
+
+```bash
+git commit -m "test centralized objective upper bound"
+```
+
+- [ ] **Step 5: Refresh GitNexus after all commits**
+
+Because `.gitnexus/meta.json` reports zero embeddings, run:
+
+```bash
+npx gitnexus analyze
+```
+
+Then read `gitnexus://repo/DFaaSOptimizer/context` and confirm the index is current.
diff --git a/docs/superpowers/plans/2026-06-30-remote-experiments-implementation.md b/docs/superpowers/plans/2026-06-30-remote-experiments-implementation.md
new file mode 100644
index 0000000..43a8a34
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-30-remote-experiments-implementation.md
@@ -0,0 +1,1695 @@
+# Remote Experiments Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build `remote_experiments/`, a two-phase (define / run) tool that dispatches DFaaSOptimizer algorithm-comparison experiments to Gurobi-equipped VMs via `ray-dispatcher`, with a pluggable experiment-suite registry and a `rich` TUI showing live per-experiment and per-VM progress, supporting stop/resume across process restarts.
+
+**Architecture:** `definitions/` builds `Experiment` lists from a registry of pluggable suite functions; `batch.py` serializes them to a static JSON file; `jobs.py` maps each `Experiment` to a `ray_dispatcher.Job`; `runner.py` drives `Dispatcher.submit/status/cancel/running_hosts` in a poll loop, persisting state via `manifest.py`; `tui.py` renders that state with `rich`; `cli.py` wires it all behind `define`/`run` subcommands.
+
+**Tech Stack:** Python 3.10 (`uv`), `ray-dispatcher` (local sibling checkout, path dependency), `rich`, `pytest` — no new test framework.
+
+## Global Constraints
+
+- Indentation: 2 spaces (`pyproject.toml` `[tool.ruff] indent-width = 2`) — this repo's style, distinct from `ray-dispatcher`'s 4-space.
+- Line length: 100.
+- Python: `>=3.10,<3.11`; this machine's interpreter is `3.10.19`, `uv` is `0.11.25`.
+- New tests go in `tests/` (flat, matches existing convention — no `tests/remote_experiments/` subdirectory).
+- Prerequisite: `ray-dispatcher`'s `Dispatcher.running_hosts()` must exist — implemented by
+  `~/Downloads/ray-dispatcher`'s `docs/superpowers/plans/2026-06-30-ray-dispatcher-phase-9-live-host-visibility.md`.
+  **Run that plan first if it hasn't been executed yet** — Task 9 of this plan fails without it.
+- Reference design: [docs/superpowers/specs/2026-06-30-remote-experiments-design.md](../specs/2026-06-30-remote-experiments-design.md).
+- `Dispatcher` has no public `resolve()` — never call it. Job duration is computed locally
+  (wall-clock from submit to terminal status), not read from `JobResult`.
+
+---
+
+### Task 1: Add `ray-dispatcher` and `rich` dependencies
+
+**Files:**
+- Modify: `pyproject.toml`
+
+**Interfaces:**
+- Produces: `import ray_dispatcher`, `import rich` available in the project's `uv` environment.
+
+- [ ] **Step 1: Add the dependencies**
+
+In `pyproject.toml`, add to the `dependencies` list (after `"pyyaml>=6.0.2",`):
+
+```toml
+  "pyyaml>=6.0.2",
+  "ray-dispatcher",
+  "rich>=13,<15",
+```
+
+Add a new section after `[tool.uv]`:
+
+```toml
+[tool.uv]
+package = false
+
+[tool.uv.sources]
+ray-dispatcher = { path = "../ray-dispatcher", editable = true }
+```
+
+- [ ] **Step 2: Sync and verify**
+
+Run: `cd /Users/micheleciavotta/Downloads/DFaaSOptimizer && uv sync`
+Expected: resolves and installs `ray-dispatcher` (editable, from `../ray-dispatcher`), `ray`, `fabric`, `rich`, and their transitive deps without conflicts.
+
+Run: `uv run python -c "import ray_dispatcher, rich; print(ray_dispatcher.__version__)"`
+Expected: prints `0.1.0`, no import errors.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add pyproject.toml uv.lock
+git commit -m "build: add ray-dispatcher and rich for remote_experiments"
+```
+
+---
+
+### Task 2: Expose `faas-macro-v0` via a CLI flag
+
+**Files:**
+- Modify: `run_faasmacro.py` (the `parse_arguments` function and the `__main__` block, lines ~50-78 and ~1142-1155)
+- Test: `tests/test_run_faasmacro_v0_flag.py`
+
+**Interfaces:**
+- Produces: `run_faasmacro.py --v0` sets `args.v0 = True`, passed through to `run(..., v0=True)`. `run()` already accepts `v0: bool = False` (line 625) — only the CLI wiring is missing.
+
+**Why:** `remote_experiments` dispatches algorithms as subprocess CLI calls (`uv run run_faasmacro.py -c config.json ...`). `run.py`'s in-process orchestrator currently reaches `v0=True` by calling `run_iterations(..., v0=True)` directly in Python — there is no CLI path to it. `SCRIPT_BY_ALGORITHM` (Task 6) needs one for the `faas-macro-v0` algorithm.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_run_faasmacro_v0_flag.py
+import run_faasmacro
+
+
+def test_parse_arguments_default_v0_is_false(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["run_faasmacro.py"])
+  args = run_faasmacro.parse_arguments()
+  assert args.v0 is False
+
+
+def test_parse_arguments_accepts_v0_flag(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["run_faasmacro.py", "--v0"])
+  args = run_faasmacro.parse_arguments()
+  assert args.v0 is True
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_run_faasmacro_v0_flag.py -v`
+Expected: FAIL — `AttributeError: 'Namespace' object has no attribute 'v0'`
+
+- [ ] **Step 3: Implement**
+
+In `run_faasmacro.py`, inside `parse_arguments()`, add after the `--disable_plotting` argument:
+
+```python
+  parser.add_argument(
+    "--v0",
+    help = "Use the v0 (non-accelerated) FaaS-MACrO iteration variant",
+    default = False,
+    action = "store_true"
+  )
+```
+
+In the `if __name__ == "__main__":` block, change:
+
+```python
+  run(
+    config, 
+    parallelism, 
+    log_on_file = False, 
+    disable_plotting = disable_plotting
+  )
+```
+
+to:
+
+```python
+  run(
+    config, 
+    parallelism, 
+    log_on_file = False, 
+    disable_plotting = disable_plotting,
+    v0 = args.v0
+  )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_run_faasmacro_v0_flag.py -v`
+Expected: PASS (2 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add run_faasmacro.py tests/test_run_faasmacro_v0_flag.py
+git commit -m "feat: expose faas-macro v0 variant via --v0 CLI flag"
+```
+
+---
+
+### Task 3: `remote_experiments` package + `Experiment`/`Batch`
+
+**Files:**
+- Create: `remote_experiments/__init__.py`
+- Create: `remote_experiments/batch.py`
+- Test: `tests/test_remote_experiments_batch.py`
+
+**Interfaces:**
+- Produces:
+  - `Experiment(id, suite, algorithm, seed, graph_params, load_params, config)` — frozen dataclass, `.to_dict()`/`.from_dict()`
+  - `Batch(suite, experiments)` — frozen dataclass, `.to_dict()`/`.from_dict()`/`.save(path)`/`.load(path)` (classmethod)
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_batch.py
+import json
+
+from remote_experiments.batch import Batch, Experiment
+
+
+def _experiment(id="e1", seed=1):
+  return Experiment(
+    id=id, suite="smoke", algorithm="centralized", seed=seed,
+    graph_params={"Nn": 10}, load_params={"trace_type": "sinusoidal"},
+    config={"seed": seed, "base_solution_folder": f"solutions/{id}"},
+  )
+
+
+def test_experiment_round_trips_through_dict():
+  e = _experiment()
+  assert Experiment.from_dict(e.to_dict()) == e
+
+
+def test_batch_save_and_load_round_trips(tmp_path):
+  batch = Batch(suite="smoke", experiments=(_experiment("e1", 1), _experiment("e2", 2)))
+  path = tmp_path / "batch.json"
+  batch.save(path)
+  loaded = Batch.load(path)
+  assert loaded == batch
+
+
+def test_batch_save_writes_readable_json(tmp_path):
+  batch = Batch(suite="smoke", experiments=(_experiment(),))
+  path = tmp_path / "batch.json"
+  batch.save(path)
+  raw = json.loads(path.read_text())
+  assert raw["suite"] == "smoke"
+  assert raw["experiments"][0]["id"] == "e1"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_batch.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/__init__.py
+"""Define-then-run batches of DFaaSOptimizer experiments on remote Gurobi VMs via ray-dispatcher."""
+```
+
+```python
+# remote_experiments/batch.py
+"""Experiment and Batch value objects: build once, serialize, run later."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Experiment:
+  id: str
+  suite: str
+  algorithm: str
+  seed: int
+  graph_params: dict
+  load_params: dict
+  config: dict
+
+  def to_dict(self) -> dict:
+    return asdict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict) -> Experiment:
+    return cls(**data)
+
+
+@dataclass(frozen=True)
+class Batch:
+  suite: str
+  experiments: tuple[Experiment, ...]
+
+  def to_dict(self) -> dict:
+    return {"suite": self.suite, "experiments": [e.to_dict() for e in self.experiments]}
+
+  @classmethod
+  def from_dict(cls, data: dict) -> Batch:
+    return cls(
+      suite=data["suite"],
+      experiments=tuple(Experiment.from_dict(e) for e in data["experiments"]),
+    )
+
+  def save(self, path: str | Path) -> None:
+    Path(path).write_text(json.dumps(self.to_dict(), indent=2))
+
+  @classmethod
+  def load(cls, path: str | Path) -> Batch:
+    return cls.from_dict(json.loads(Path(path).read_text()))
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_batch.py -v`
+Expected: PASS (3 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/__init__.py remote_experiments/batch.py tests/test_remote_experiments_batch.py
+git commit -m "feat: add Experiment/Batch value objects for remote_experiments"
+```
+
+---
+
+### Task 4: Suite registry
+
+**Files:**
+- Create: `remote_experiments/definitions/__init__.py`
+- Test: `tests/test_remote_experiments_registry.py`
+
+**Interfaces:**
+- Consumes: `Experiment` (Task 3)
+- Produces: `register_suite(name)` (decorator), `get_suite(name) -> Callable[..., list[Experiment]]`, `list_suites() -> list[str]`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_registry.py
+import pytest
+
+from remote_experiments.definitions import get_suite, list_suites, register_suite
+
+
+def test_get_suite_unknown_raises_key_error():
+  with pytest.raises(KeyError):
+    get_suite("does-not-exist")
+
+
+def test_register_suite_makes_it_listable():
+  @register_suite("__test_registry_suite__")
+  def build():
+    return []
+
+  assert "__test_registry_suite__" in list_suites()
+  assert get_suite("__test_registry_suite__") is build
+
+
+def test_register_suite_rejects_duplicate_name():
+  @register_suite("__test_dup__")
+  def build_a():
+    return []
+
+  with pytest.raises(ValueError):
+    @register_suite("__test_dup__")
+    def build_b():
+      return []
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_registry.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.definitions'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/definitions/__init__.py
+"""Registry of pluggable experiment suites: @register_suite("name") -> builder fn."""
+
+from collections.abc import Callable
+
+from ..batch import Experiment
+
+_REGISTRY: dict[str, Callable[..., list[Experiment]]] = {}
+
+
+def register_suite(name: str):
+  def decorator(fn: Callable[..., list[Experiment]]) -> Callable[..., list[Experiment]]:
+    if name in _REGISTRY:
+      raise ValueError(f"suite already registered: {name}")
+    _REGISTRY[name] = fn
+    return fn
+  return decorator
+
+
+def get_suite(name: str) -> Callable[..., list[Experiment]]:
+  if name not in _REGISTRY:
+    raise KeyError(f"unknown suite: {name!r}; available: {sorted(_REGISTRY)}")
+  return _REGISTRY[name]
+
+
+def list_suites() -> list[str]:
+  return sorted(_REGISTRY)
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_registry.py -v`
+Expected: PASS (3 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/definitions/__init__.py tests/test_remote_experiments_registry.py
+git commit -m "feat: add experiment suite registry"
+```
+
+---
+
+### Task 5: `smoke` suite (concrete pluggable example)
+
+**Files:**
+- Create: `remote_experiments/definitions/smoke.py`
+- Modify: `remote_experiments/definitions/__init__.py` (add the registration-side-effect import)
+- Test: `tests/test_remote_experiments_smoke_suite.py`
+
+**Interfaces:**
+- Consumes: `register_suite` (Task 4), `Experiment` (Task 3), `config_files/eval_smoke.json` (existing file)
+- Produces: `ALGORITHMS` (tuple of 10 algorithm names), `build(seeds=(42, 43), algorithms=ALGORITHMS) -> list[Experiment]`, registered under the name `"smoke"`.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_smoke_suite.py
+from remote_experiments.definitions import get_suite
+from remote_experiments.definitions.smoke import ALGORITHMS, build
+
+
+def test_smoke_suite_is_registered():
+  assert get_suite("smoke") is build
+
+
+def test_build_produces_one_experiment_per_seed_and_algorithm():
+  experiments = build(seeds=(1, 2), algorithms=("centralized", "faas-macro"))
+  assert len(experiments) == 4
+
+
+def test_build_produces_unique_ids():
+  experiments = build(seeds=(1, 2), algorithms=("centralized", "faas-macro"))
+  ids = [e.id for e in experiments]
+  assert len(ids) == len(set(ids))
+
+
+def test_build_sets_seed_in_config_and_base_solution_folder():
+  experiments = build(seeds=(7,), algorithms=("centralized",))
+  e = experiments[0]
+  assert e.config["seed"] == 7
+  assert e.config["base_solution_folder"] == f"solutions/{e.id}"
+
+
+def test_build_default_covers_all_ten_algorithms():
+  experiments = build()
+  assert {e.algorithm for e in experiments} == set(ALGORITHMS)
+  assert len(ALGORITHMS) == 10
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_smoke_suite.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.definitions.smoke'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/definitions/smoke.py
+"""Example pluggable suite: every algorithm across a couple of seeds, from eval_smoke.json."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+from ..batch import Experiment
+from . import register_suite
+
+_BASE_CONFIG_PATH = Path(__file__).resolve().parents[2] / "config_files" / "eval_smoke.json"
+
+ALGORITHMS = (
+  "centralized", "faas-macro", "faas-macro-v0", "faas-madea", "hierarchical",
+  "faas-diffuse", "faas-powd", "faas-br-s", "faas-br-r", "faas-br-o",
+)
+
+
+@register_suite("smoke")
+def build(
+    seeds: tuple[int, ...] = (42, 43),
+    algorithms: tuple[str, ...] = ALGORITHMS,
+  ) -> list[Experiment]:
+  base_config = json.loads(_BASE_CONFIG_PATH.read_text())
+  limits = base_config["limits"]
+  graph_params = {k: v for k, v in limits.items() if k != "load"}
+  load_params = limits["load"]
+  experiments = []
+  for seed in seeds:
+    for algorithm in algorithms:
+      config = copy.deepcopy(base_config)
+      config["seed"] = seed
+      experiment_id = f"smoke-{algorithm}-seed{seed}"
+      config["base_solution_folder"] = f"solutions/{experiment_id}"
+      experiments.append(Experiment(
+        id=experiment_id, suite="smoke", algorithm=algorithm, seed=seed,
+        graph_params=graph_params, load_params=load_params, config=config,
+      ))
+  return experiments
+```
+
+Add the import so the registration side effect runs whenever the registry is imported, at the bottom of `remote_experiments/definitions/__init__.py`:
+
+```python
+from . import smoke  # imported for its @register_suite("smoke") side effect
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_smoke_suite.py tests/test_remote_experiments_registry.py -v`
+Expected: PASS (8 tests total)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/definitions/smoke.py remote_experiments/definitions/__init__.py tests/test_remote_experiments_smoke_suite.py
+git commit -m "feat: add smoke suite covering all 10 algorithms"
+```
+
+---
+
+### Task 6: Experiment → Job mapping
+
+**Files:**
+- Create: `remote_experiments/jobs.py`
+- Test: `tests/test_remote_experiments_jobs.py`
+
+**Interfaces:**
+- Consumes: `Experiment` (Task 3), `ray_dispatcher.{Job, InputSpec, OutputSpec}`
+- Produces: `SCRIPT_BY_ALGORITHM: dict[str, tuple[str, tuple[str, ...]]]`, `experiment_to_job(experiment, config_dir) -> Job`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_jobs.py
+import json
+
+import pytest
+
+from remote_experiments.batch import Experiment
+from remote_experiments.jobs import SCRIPT_BY_ALGORITHM, experiment_to_job
+
+
+def _experiment(algorithm="centralized"):
+  return Experiment(
+    id="e1", suite="smoke", algorithm=algorithm, seed=1,
+    graph_params={}, load_params={}, config={"seed": 1, "base_solution_folder": "solutions/e1"},
+  )
+
+
+def test_all_ten_algorithms_are_mapped():
+  expected = {
+    "centralized", "faas-macro", "faas-macro-v0", "faas-madea", "hierarchical",
+    "faas-diffuse", "faas-powd", "faas-br-s", "faas-br-r", "faas-br-o",
+  }
+  assert set(SCRIPT_BY_ALGORITHM) == expected
+
+
+def test_experiment_to_job_builds_expected_command_for_variant_algorithm(tmp_path):
+  job = experiment_to_job(_experiment("faas-br-r"), tmp_path)
+  assert job.command == (
+    "uv", "run", "decentralized_bestresponse.py", "-c", "config.json",
+    "--disable_plotting", "--variant", "r",
+  )
+
+
+def test_experiment_to_job_builds_expected_command_for_plain_algorithm(tmp_path):
+  job = experiment_to_job(_experiment("centralized"), tmp_path)
+  assert job.command == (
+    "uv", "run", "run_centralized_model.py", "-c", "config.json", "--disable_plotting",
+  )
+
+
+def test_experiment_to_job_writes_config_file(tmp_path):
+  job = experiment_to_job(_experiment(), tmp_path)
+  config_path = tmp_path / "e1.json"
+  assert config_path.exists()
+  assert json.loads(config_path.read_text())["seed"] == 1
+  assert job.inputs[0].destination == "config.json"
+
+
+def test_experiment_to_job_output_matches_experiment_id(tmp_path):
+  job = experiment_to_job(_experiment(), tmp_path)
+  assert job.outputs[0].source == "solutions/e1"
+  assert job.outputs[0].destination == "e1"
+
+
+def test_experiment_to_job_unknown_algorithm_raises(tmp_path):
+  with pytest.raises(KeyError):
+    experiment_to_job(_experiment("nope"), tmp_path)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_jobs.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.jobs'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/jobs.py
+"""Maps an Experiment to a ray_dispatcher.Job that runs it on a VM."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ray_dispatcher import InputSpec, Job, OutputSpec
+
+from .batch import Experiment
+
+SCRIPT_BY_ALGORITHM: dict[str, tuple[str, tuple[str, ...]]] = {
+  "centralized":   ("run_centralized_model.py", ()),
+  "faas-macro":    ("run_faasmacro.py", ()),
+  "faas-macro-v0": ("run_faasmacro.py", ("--v0",)),
+  "faas-madea":    ("run_faasmadea.py", ()),
+  "hierarchical":  ("hierarchical_auction/runner.py", ()),
+  "faas-diffuse":  ("decentralized_diffusion.py", ()),
+  "faas-powd":     ("decentralized_powerd.py", ()),
+  "faas-br-s":     ("decentralized_bestresponse.py", ("--variant", "s")),
+  "faas-br-r":     ("decentralized_bestresponse.py", ("--variant", "r")),
+  "faas-br-o":     ("decentralized_bestresponse.py", ("--variant", "o")),
+}
+
+
+def experiment_to_job(experiment: Experiment, config_dir: Path) -> Job:
+  if experiment.algorithm not in SCRIPT_BY_ALGORITHM:
+    raise KeyError(f"unknown algorithm: {experiment.algorithm!r}")
+  script, extra_args = SCRIPT_BY_ALGORITHM[experiment.algorithm]
+  config_dir.mkdir(parents=True, exist_ok=True)
+  config_path = config_dir / f"{experiment.id}.json"
+  config_path.write_text(json.dumps(experiment.config, indent=2))
+  return Job(
+    id=experiment.id,
+    command=("uv", "run", script, "-c", "config.json", "--disable_plotting", *extra_args),
+    inputs=(InputSpec(source=str(config_path), destination="config.json"),),
+    outputs=(OutputSpec(source=f"solutions/{experiment.id}", destination=experiment.id, required=True),),
+  )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_jobs.py -v`
+Expected: PASS (6 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/jobs.py tests/test_remote_experiments_jobs.py
+git commit -m "feat: map Experiment to ray_dispatcher.Job"
+```
+
+---
+
+### Task 7: Manifest (persisted per-experiment status)
+
+**Files:**
+- Create: `remote_experiments/manifest.py`
+- Test: `tests/test_remote_experiments_manifest.py`
+
+**Interfaces:**
+- Produces: `Manifest(path)` with `.status(id) -> str`, `.host(id) -> str | None`, `.duration(id) -> float | None`, `.record(id, **fields)`, `.pending_ids(ids) -> list[str]`; module constants `NEVER_RUN = "never_run"`, `SUCCEEDED = "succeeded"`.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_manifest.py
+from remote_experiments.manifest import Manifest
+
+
+def test_unknown_experiment_status_is_never_run(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  assert manifest.status("e1") == "never_run"
+
+
+def test_record_updates_status_and_persists(tmp_path):
+  path = tmp_path / "m.json"
+  manifest = Manifest(path)
+  manifest.record("e1", status="running", host="vm1")
+  assert manifest.status("e1") == "running"
+  assert manifest.host("e1") == "vm1"
+  assert path.exists()
+
+
+def test_record_partial_update_preserves_other_fields(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  manifest.record("e1", status="succeeded", duration_s=12.5)
+  assert manifest.host("e1") == "vm1"
+  assert manifest.duration("e1") == 12.5
+
+
+def test_manifest_reloads_from_disk(tmp_path):
+  path = tmp_path / "m.json"
+  Manifest(path).record("e1", status="succeeded")
+  reloaded = Manifest(path)
+  assert reloaded.status("e1") == "succeeded"
+
+
+def test_pending_ids_excludes_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded")
+  manifest.record("e2", status="failed")
+  assert manifest.pending_ids(["e1", "e2", "e3"]) == ["e2", "e3"]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_manifest.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.manifest'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/manifest.py
+"""Per-experiment status persisted to disk, for cross-process stop/resume."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+NEVER_RUN = "never_run"
+SUCCEEDED = "succeeded"
+
+
+@dataclass
+class ManifestEntry:
+  status: str = NEVER_RUN
+  host: str | None = None
+  duration_s: float | None = None
+
+
+class Manifest:
+  def __init__(self, path: str | Path) -> None:
+    self._path = Path(path)
+    self._entries: dict[str, ManifestEntry] = {}
+    if self._path.exists():
+      raw = json.loads(self._path.read_text())
+      self._entries = {k: ManifestEntry(**v) for k, v in raw.items()}
+
+  def status(self, experiment_id: str) -> str:
+    entry = self._entries.get(experiment_id)
+    return entry.status if entry else NEVER_RUN
+
+  def host(self, experiment_id: str) -> str | None:
+    entry = self._entries.get(experiment_id)
+    return entry.host if entry else None
+
+  def duration(self, experiment_id: str) -> float | None:
+    entry = self._entries.get(experiment_id)
+    return entry.duration_s if entry else None
+
+  def record(self, experiment_id: str, **fields) -> None:
+    current = self._entries.get(experiment_id, ManifestEntry())
+    updated = ManifestEntry(**{**asdict(current), **fields})
+    self._entries[experiment_id] = updated
+    self._save()
+
+  def pending_ids(self, experiment_ids: list[str]) -> list[str]:
+    return [eid for eid in experiment_ids if self.status(eid) != SUCCEEDED]
+
+  def _save(self) -> None:
+    self._path.parent.mkdir(parents=True, exist_ok=True)
+    self._path.write_text(
+      json.dumps({k: asdict(v) for k, v in self._entries.items()}, indent=2)
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_manifest.py -v`
+Expected: PASS (5 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/manifest.py tests/test_remote_experiments_manifest.py
+git commit -m "feat: add Manifest for persisted per-experiment status"
+```
+
+---
+
+### Task 8: Selection parsing and resume defaults
+
+**Files:**
+- Create: `remote_experiments/selection.py`
+- Test: `tests/test_remote_experiments_selection.py`
+
+**Interfaces:**
+- Consumes: `Manifest`, `SUCCEEDED` (Task 7)
+- Produces: `parse_selection(text, n) -> list[int]`, `default_selection(experiment_ids, manifest) -> list[int]`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_selection.py
+import pytest
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.selection import default_selection, parse_selection
+
+
+def test_parse_selection_all_returns_every_index():
+  assert parse_selection("all", 5) == [0, 1, 2, 3, 4]
+
+
+def test_parse_selection_empty_returns_every_index():
+  assert parse_selection("", 5) == [0, 1, 2, 3, 4]
+
+
+def test_parse_selection_comma_list():
+  assert parse_selection("0,2,4", 5) == [0, 2, 4]
+
+
+def test_parse_selection_range():
+  assert parse_selection("1-3", 5) == [1, 2, 3]
+
+
+def test_parse_selection_mixed():
+  assert parse_selection("0, 2-3", 5) == [0, 2, 3]
+
+
+def test_parse_selection_out_of_range_raises():
+  with pytest.raises(ValueError):
+    parse_selection("9", 5)
+
+
+def test_default_selection_skips_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded")
+  assert default_selection(["e1", "e2", "e3"], manifest) == [1, 2]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_selection.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.selection'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/selection.py
+"""Parse free-text experiment selection ("1,2,5-7" / "all") and compute resume defaults."""
+
+from __future__ import annotations
+
+from .manifest import Manifest, SUCCEEDED
+
+
+def parse_selection(text: str, n: int) -> list[int]:
+  text = text.strip()
+  if text == "" or text.lower() == "all":
+    return list(range(n))
+  indices: set[int] = set()
+  for part in text.split(","):
+    part = part.strip()
+    if not part:
+      continue
+    if "-" in part:
+      start_s, end_s = part.split("-", 1)
+      indices.update(range(int(start_s), int(end_s) + 1))
+    else:
+      indices.add(int(part))
+  for i in indices:
+    if not (0 <= i < n):
+      raise ValueError(f"selection index out of range: {i} (valid: 0..{n - 1})")
+  return sorted(indices)
+
+
+def default_selection(experiment_ids: list[str], manifest: Manifest) -> list[int]:
+  return [i for i, eid in enumerate(experiment_ids) if manifest.status(eid) != SUCCEEDED]
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_selection.py -v`
+Expected: PASS (7 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/selection.py tests/test_remote_experiments_selection.py
+git commit -m "feat: add selection parsing and resume defaults"
+```
+
+---
+
+### Task 9: Batch/VM stats and ETA heuristic
+
+**Files:**
+- Create: `remote_experiments/stats.py`
+- Test: `tests/test_remote_experiments_stats.py`
+
+**Interfaces:**
+- Consumes: `Manifest`, `SUCCEEDED` (Task 7); `ray_dispatcher.Inventory`
+- Produces: `HostStats(host, slots_total, slots_busy, jobs_completed, current_jobs)`, `BatchStats(total, succeeded, failed, running, pending, elapsed_s, throughput_per_min, eta_s, hosts)`, `estimate_eta(avg_duration_s, remaining, total_slots) -> float`, `summarize(experiment_ids, manifest, inventory, running_hosts, elapsed_s) -> BatchStats`
+
+**Requires:** `Dispatcher.running_hosts()` from the ray-dispatcher phase-9 plan (see Global Constraints).
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_stats.py
+import pytest
+from ray_dispatcher import Inventory, RemoteHost
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.stats import estimate_eta, summarize
+
+
+def test_estimate_eta_zero_remaining_is_zero():
+  assert estimate_eta(avg_duration_s=10.0, remaining=0, total_slots=2) == 0.0
+
+
+def test_estimate_eta_divides_by_total_slots():
+  assert estimate_eta(avg_duration_s=10.0, remaining=4, total_slots=2) == 20.0
+
+
+def test_estimate_eta_rejects_zero_slots():
+  with pytest.raises(ValueError):
+    estimate_eta(avg_duration_s=10.0, remaining=1, total_slots=0)
+
+
+def _inventory():
+  return Inventory((
+    RemoteHost("vm1", user="ubuntu", slots=2),
+    RemoteHost("vm2", user="ubuntu", slots=1),
+  ))
+
+
+def test_summarize_counts_by_status(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", host="vm1", duration_s=10.0)
+  manifest.record("e2", status="running", host="vm1")
+  manifest.record("e3", status="never_run")
+  stats = summarize(["e1", "e2", "e3"], manifest, _inventory(), {"e2": "vm1"}, elapsed_s=60.0)
+  assert stats.total == 3
+  assert stats.succeeded == 1
+  assert stats.running == 1
+  assert stats.pending == 1
+  assert stats.failed == 0
+
+
+def test_summarize_eta_uses_succeeded_average_duration(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", host="vm1", duration_s=10.0)
+  manifest.record("e2", status="running", host="vm1")
+  stats = summarize(["e1", "e2"], manifest, _inventory(), {"e2": "vm1"}, elapsed_s=60.0)
+  assert stats.eta_s == 10.0 / 3  # avg_duration=10, remaining=1, total_slots=3
+
+
+def test_summarize_eta_none_without_any_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  stats = summarize(["e1"], manifest, _inventory(), {"e1": "vm1"}, elapsed_s=60.0)
+  assert stats.eta_s is None
+
+
+def test_summarize_attributes_current_jobs_per_host(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running")
+  manifest.record("e2", status="running")
+  stats = summarize(
+    ["e1", "e2"], manifest, _inventory(), {"e1": "vm1", "e2": "vm2"}, elapsed_s=10.0
+  )
+  vm1 = next(h for h in stats.hosts if h.host == "vm1")
+  vm2 = next(h for h in stats.hosts if h.host == "vm2")
+  assert vm1.current_jobs == ("e1",)
+  assert vm1.slots_busy == 1
+  assert vm2.current_jobs == ("e2",)
+
+
+def test_summarize_throughput_per_minute(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", duration_s=5.0)
+  stats = summarize(["e1"], manifest, _inventory(), {}, elapsed_s=30.0)
+  assert stats.throughput_per_min == 2.0  # 1 succeeded in 30s -> 2/min
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_stats.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.stats'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/stats.py
+"""Pure computation of batch/VM progress stats for the TUI — no rendering here."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ray_dispatcher import Inventory
+
+from .manifest import Manifest, SUCCEEDED
+
+_RUNNING = "running"
+_NEVER_RUN = "never_run"
+_PENDING = "pending"
+
+
+@dataclass(frozen=True)
+class HostStats:
+  host: str
+  slots_total: int
+  slots_busy: int
+  jobs_completed: int
+  current_jobs: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class BatchStats:
+  total: int
+  succeeded: int
+  failed: int
+  running: int
+  pending: int
+  elapsed_s: float
+  throughput_per_min: float
+  eta_s: float | None
+  hosts: tuple[HostStats, ...]
+
+
+def estimate_eta(avg_duration_s: float, remaining: int, total_slots: int) -> float:
+  if total_slots <= 0:
+    raise ValueError("total_slots must be > 0")
+  if remaining <= 0:
+    return 0.0
+  return avg_duration_s * remaining / total_slots
+
+
+def summarize(
+    experiment_ids: list[str],
+    manifest: Manifest,
+    inventory: Inventory,
+    running_hosts: dict[str, str],
+    elapsed_s: float,
+  ) -> BatchStats:
+  statuses = {eid: manifest.status(eid) for eid in experiment_ids}
+  succeeded = sum(1 for s in statuses.values() if s == SUCCEEDED)
+  running = sum(1 for s in statuses.values() if s == _RUNNING)
+  pending = sum(1 for s in statuses.values() if s in (_NEVER_RUN, _PENDING))
+  failed = len(statuses) - succeeded - running - pending
+
+  durations = [
+    manifest.duration(eid) for eid in experiment_ids
+    if statuses[eid] == SUCCEEDED and manifest.duration(eid) is not None
+  ]
+  avg_duration = sum(durations) / len(durations) if durations else 0.0
+  total_slots = sum(h.slots for h in inventory.hosts)
+  remaining = running + pending
+  eta_s = estimate_eta(avg_duration, remaining, total_slots) if durations else None
+  throughput_per_min = (succeeded / elapsed_s * 60) if elapsed_s > 0 else 0.0
+
+  host_stats = []
+  for h in inventory.hosts:
+    current_jobs = tuple(
+      eid for eid, host in running_hosts.items() if host == h.host and eid in statuses
+    )
+    completed = sum(
+      1 for eid in experiment_ids
+      if statuses[eid] == SUCCEEDED and manifest.host(eid) == h.host
+    )
+    host_stats.append(HostStats(
+      host=h.host, slots_total=h.slots, slots_busy=len(current_jobs),
+      jobs_completed=completed, current_jobs=current_jobs,
+    ))
+
+  return BatchStats(
+    total=len(statuses), succeeded=succeeded, failed=failed, running=running,
+    pending=pending, elapsed_s=elapsed_s, throughput_per_min=throughput_per_min,
+    eta_s=eta_s, hosts=tuple(host_stats),
+  )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_stats.py -v`
+Expected: PASS (9 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/stats.py tests/test_remote_experiments_stats.py
+git commit -m "feat: add batch/VM progress stats and ETA heuristic"
+```
+
+---
+
+### Task 10: Poll loop (submit, status, stop/resume)
+
+**Files:**
+- Create: `remote_experiments/runner.py`
+- Test: `tests/test_remote_experiments_runner.py`
+
+**Interfaces:**
+- Consumes: `Manifest` (Task 7), `ray_dispatcher.{Job, JobHandle, JobStatus}`
+- Produces: `run_batch(dispatcher, jobs, manifest, on_tick, *, poll_interval_s=1.0, sleep=time.sleep, now=time.monotonic) -> bool`. `dispatcher` is duck-typed: `.submit(jobs) -> list[JobHandle]`, `.status(handle) -> JobStatus`, `.cancel(handle) -> None`, `.running_hosts() -> dict[str, str]`. `on_tick: Callable[[dict[str, str]], None]` is called once per poll iteration with the current `running_hosts()` snapshot.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_runner.py
+from ray_dispatcher import Job, JobHandle, JobStatus
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.runner import run_batch
+
+
+class FakeDispatcher:
+  def __init__(self, status_sequences, hosts=None):
+    self._sequences = {k: list(v) for k, v in status_sequences.items()}
+    self._hosts = hosts or {}
+    self.cancelled: list[str] = []
+
+  def submit(self, jobs):
+    return [JobHandle(batch_id="b1", job_id=j.id, token=j.id) for j in jobs]
+
+  def status(self, handle):
+    seq = self._sequences[handle.job_id]
+    return seq.pop(0) if len(seq) > 1 else seq[0]
+
+  def cancel(self, handle):
+    self.cancelled.append(handle.job_id)
+
+  def running_hosts(self):
+    return dict(self._hosts)
+
+
+def _jobs(*ids):
+  return [Job(id=i, command=("echo",)) for i in ids]
+
+
+def test_run_batch_records_succeeded_status_and_host(tmp_path):
+  dispatcher = FakeDispatcher(
+    {"e1": [JobStatus.RUNNING, JobStatus.SUCCEEDED]}, hosts={"e1": "vm1"}
+  )
+  manifest = Manifest(tmp_path / "m.json")
+  ticks = []
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=ticks.append, sleep=lambda s: None
+  )
+  assert completed is True
+  assert manifest.status("e1") == "succeeded"
+  assert manifest.host("e1") == "vm1"
+  assert len(ticks) >= 1
+
+
+def test_run_batch_records_duration_from_submit_to_terminal(tmp_path):
+  times = iter([100.0, 105.0])
+  dispatcher = FakeDispatcher({"e1": [JobStatus.SUCCEEDED]}, hosts={})
+  manifest = Manifest(tmp_path / "m.json")
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None,
+    sleep=lambda s: None, now=lambda: next(times),
+  )
+  assert completed is True
+  assert manifest.duration("e1") == 5.0
+
+
+def test_run_batch_stops_and_cancels_on_keyboard_interrupt(tmp_path):
+  dispatcher = FakeDispatcher({"e1": [JobStatus.RUNNING] * 5}, hosts={"e1": "vm1"})
+  manifest = Manifest(tmp_path / "m.json")
+
+  def _raising_sleep(_seconds):
+    raise KeyboardInterrupt
+
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None, sleep=_raising_sleep
+  )
+  assert completed is False
+  assert "e1" in dispatcher.cancelled
+  assert manifest.status("e1") == "cancelled"
+
+
+def test_run_batch_preserves_host_after_lease_released_before_terminal_is_observed(tmp_path):
+  hosts_per_tick = [{"e1": "vm1"}, {}]
+
+  class _Dispatcher(FakeDispatcher):
+    def running_hosts(self):
+      return hosts_per_tick.pop(0) if hosts_per_tick else {}
+
+  dispatcher = _Dispatcher({"e1": [JobStatus.RUNNING, JobStatus.SUCCEEDED]})
+  manifest = Manifest(tmp_path / "m.json")
+  run_batch(dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None, sleep=lambda s: None)
+  assert manifest.host("e1") == "vm1"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_runner.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.runner'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/runner.py
+"""Submit/poll loop driving a batch through ray_dispatcher, with stop-on-interrupt."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Sequence
+
+from ray_dispatcher import Job, JobHandle, JobStatus
+
+from .manifest import Manifest
+
+_TERMINAL = frozenset({
+  JobStatus.SUCCEEDED, JobStatus.FAILED, JobStatus.CANCELLED, JobStatus.TIMED_OUT,
+})
+
+
+def run_batch(
+    dispatcher,
+    jobs: Sequence[Job],
+    manifest: Manifest,
+    on_tick: Callable[[dict[str, str]], None],
+    *,
+    poll_interval_s: float = 1.0,
+    sleep: Callable[[float], None] = time.sleep,
+    now: Callable[[], float] = time.monotonic,
+  ) -> bool:
+  """Submit jobs, poll until all terminal or interrupted.
+
+  Returns True if the batch ran to completion, False if stopped (Ctrl-C):
+  in-flight jobs are cancelled and the manifest reflects their last known
+  state, so a later run_batch() call on the same experiment ids resumes
+  from there.
+  """
+  handles: list[JobHandle] = dispatcher.submit(jobs)
+  started_at = {h.job_id: now() for h in handles}
+  last_known_host: dict[str, str] = {}
+  for handle in handles:
+    manifest.record(handle.job_id, status="pending")
+
+  remaining = list(handles)
+  try:
+    while remaining:
+      running_hosts = dispatcher.running_hosts()
+      last_known_host.update(running_hosts)
+      next_remaining = []
+      for handle in remaining:
+        status = dispatcher.status(handle)
+        host = last_known_host.get(handle.job_id)
+        if status in _TERMINAL:
+          duration = now() - started_at[handle.job_id]
+          manifest.record(handle.job_id, status=status.value, host=host, duration_s=duration)
+        else:
+          manifest.record(handle.job_id, status=status.value, host=host)
+          next_remaining.append(handle)
+      remaining = next_remaining
+      on_tick(running_hosts)
+      if remaining:
+        sleep(poll_interval_s)
+    return True
+  except KeyboardInterrupt:
+    for handle in remaining:
+      dispatcher.cancel(handle)
+      manifest.record(handle.job_id, status=JobStatus.CANCELLED.value)
+    return False
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_runner.py -v`
+Expected: PASS (4 tests)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/runner.py tests/test_remote_experiments_runner.py
+git commit -m "feat: add submit/poll loop with stop-on-interrupt"
+```
+
+---
+
+### Task 11: TUI rendering
+
+**Files:**
+- Create: `remote_experiments/tui.py`
+- Test: `tests/test_remote_experiments_tui.py`
+
+**Interfaces:**
+- Consumes: `Batch` (Task 3), `Manifest` (Task 7), `BatchStats`/`summarize` (Task 9), `ray_dispatcher.Inventory`
+- Produces: `render(batch, manifest, stats) -> rich.layout.Layout`; `live_view(batch, manifest, inventory, *, start_time) -> contextmanager yielding Callable[[dict[str, str]], None]`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_tui.py
+from rich.console import Console
+from ray_dispatcher import Inventory, RemoteHost
+
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.manifest import Manifest
+from remote_experiments.stats import summarize
+from remote_experiments.tui import render
+
+
+def _batch():
+  return Batch(suite="smoke", experiments=(
+    Experiment(id="e1", suite="smoke", algorithm="centralized", seed=1,
+               graph_params={}, load_params={}, config={}),
+  ))
+
+
+def test_render_includes_experiment_status_and_host(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  inventory = Inventory((RemoteHost("vm1", user="ubuntu", slots=1),))
+  stats = summarize(["e1"], manifest, inventory, {"e1": "vm1"}, elapsed_s=10.0)
+  layout = render(_batch(), manifest, stats)
+
+  console = Console(record=True, width=120)
+  console.print(layout)
+  output = console.export_text()
+  assert "e1" in output
+  assert "running" in output
+  assert "vm1" in output
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_tui.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.tui'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/tui.py
+"""rich-based live progress view: renders BatchStats/Manifest, no business logic."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+
+from ray_dispatcher import Inventory
+
+from .batch import Batch
+from .manifest import Manifest
+from .stats import BatchStats, summarize
+
+
+def render(batch: Batch, manifest: Manifest, stats: BatchStats) -> Layout:
+  summary = Table.grid(padding=(0, 2))
+  summary.add_row(
+    f"total: {stats.total}", f"succeeded: {stats.succeeded}", f"failed: {stats.failed}",
+    f"running: {stats.running}", f"pending: {stats.pending}",
+    f"throughput: {stats.throughput_per_min:.1f}/min",
+    f"eta: {_format_seconds(stats.eta_s)}",
+  )
+
+  vm_table = Table(title="VMs")
+  vm_table.add_column("host")
+  vm_table.add_column("slots")
+  vm_table.add_column("current jobs")
+  vm_table.add_column("completed")
+  for h in stats.hosts:
+    vm_table.add_row(
+      h.host, f"{h.slots_busy}/{h.slots_total}", ", ".join(h.current_jobs) or "-",
+      str(h.jobs_completed),
+    )
+
+  exp_table = Table(title="Experiments")
+  exp_table.add_column("id")
+  exp_table.add_column("algorithm")
+  exp_table.add_column("seed")
+  exp_table.add_column("status")
+  exp_table.add_column("host")
+  for e in batch.experiments:
+    exp_table.add_row(
+      e.id, e.algorithm, str(e.seed), manifest.status(e.id), manifest.host(e.id) or "-",
+    )
+
+  layout = Layout()
+  layout.split_column(
+    Layout(Panel(summary, title="Batch"), size=3),
+    Layout(vm_table, size=len(stats.hosts) + 4),
+    Layout(exp_table),
+  )
+  return layout
+
+
+def _format_seconds(seconds: float | None) -> str:
+  if seconds is None:
+    return "-"
+  minutes, secs = divmod(int(seconds), 60)
+  return f"{minutes}m{secs:02d}s"
+
+
+@contextmanager
+def live_view(
+    batch: Batch, manifest: Manifest, inventory: Inventory, *, start_time: float,
+  ) -> Iterator[Callable[[dict[str, str]], None]]:
+  console = Console()
+  experiment_ids = [e.id for e in batch.experiments]
+  with Live(console=console, refresh_per_second=4) as live:
+    def on_tick(running_hosts: dict[str, str]) -> None:
+      elapsed = time.monotonic() - start_time
+      stats = summarize(experiment_ids, manifest, inventory, running_hosts, elapsed)
+      live.update(render(batch, manifest, stats))
+    yield on_tick
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_tui.py -v`
+Expected: PASS (1 test)
+
+`live_view` itself (the `Live`-driven context manager) is not unit tested here — it needs a real/interactive console session. Task 12's manual verification step covers it end-to-end.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/tui.py tests/test_remote_experiments_tui.py
+git commit -m "feat: add rich TUI rendering for batch/VM/experiment progress"
+```
+
+---
+
+### Task 12: CLI (`define` / `run`)
+
+**Files:**
+- Create: `remote_experiments/cli.py`
+- Create: `remote_experiments/__main__.py`
+- Test: `tests/test_remote_experiments_cli.py`
+
+**Interfaces:**
+- Consumes: everything from Tasks 3-11
+- Produces: `build_parser() -> argparse.ArgumentParser`, `cmd_define(args)`, `cmd_run(args)`, `main(argv=None)`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_remote_experiments_cli.py
+import json
+
+import pytest
+
+from remote_experiments.batch import Batch
+from remote_experiments.cli import build_parser, cmd_define
+
+
+def test_define_accepts_registered_suite_name():
+  parser = build_parser()
+  args = parser.parse_args(["define", "smoke", "-o", "/tmp/x.json"])
+  assert args.suite == "smoke"
+
+
+def test_define_rejects_unregistered_suite_name():
+  parser = build_parser()
+  with pytest.raises(SystemExit):
+    parser.parse_args(["define", "does-not-exist", "-o", "/tmp/x.json"])
+
+
+def test_cmd_define_writes_batch_file(tmp_path):
+  out_path = tmp_path / "out" / "batch.json"
+  args = build_parser().parse_args(["define", "smoke", "-o", str(out_path)])
+  cmd_define(args)
+  loaded = Batch.load(out_path)
+  assert loaded.suite == "smoke"
+  assert len(loaded.experiments) == 20  # smoke suite default: 2 seeds x 10 algorithms
+
+
+def test_cmd_define_output_is_valid_json(tmp_path):
+  out_path = tmp_path / "batch.json"
+  cmd_define(build_parser().parse_args(["define", "smoke", "-o", str(out_path)]))
+  raw = json.loads(out_path.read_text())
+  assert raw["suite"] == "smoke"
+
+
+def test_run_subcommand_parses_required_arguments():
+  parser = build_parser()
+  args = parser.parse_args(["run", "batches/foo.json", "--inventory", "inv.yaml"])
+  assert args.batch_file == "batches/foo.json"
+  assert args.inventory == "inv.yaml"
+  assert args.results_dir == "./results"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_cli.py -v`
+Expected: FAIL — `ModuleNotFoundError: No module named 'remote_experiments.cli'`
+
+- [ ] **Step 3: Implement**
+
+```python
+# remote_experiments/cli.py
+"""CLI entry point: `define` builds a batch file from a suite, `run` executes/resumes it."""
+
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+
+from ray_dispatcher import Dispatcher, Inventory, Project, SecretFile
+
+from . import definitions  # imports register all suites as a side effect
+from .batch import Batch
+from .definitions import get_suite, list_suites
+from .jobs import experiment_to_job
+from .manifest import Manifest
+from .runner import run_batch
+from .selection import default_selection, parse_selection
+from .tui import live_view
+
+
+def cmd_define(args: argparse.Namespace) -> None:
+  build = get_suite(args.suite)
+  experiments = build()
+  batch = Batch(suite=args.suite, experiments=tuple(experiments))
+  out_path = Path(args.output)
+  out_path.parent.mkdir(parents=True, exist_ok=True)
+  batch.save(out_path)
+  print(f"wrote {len(experiments)} experiments to {out_path}")
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+  batch = Batch.load(args.batch_file)
+  manifest_path = Path(args.batch_file).with_suffix(".manifest.json")
+  manifest = Manifest(manifest_path)
+  experiment_ids = [e.id for e in batch.experiments]
+
+  default_idx = default_selection(experiment_ids, manifest)
+  print(f"{len(batch.experiments)} experiments in batch, {len(default_idx)} pending")
+  for i, e in enumerate(batch.experiments):
+    print(f"  [{i}] {e.id} ({manifest.status(e.id)})")
+  raw = input(f"Select to run [default: {len(default_idx)} pending] (indices/ranges/'all'): ")
+  selected_idx = parse_selection(raw, len(batch.experiments)) if raw.strip() else default_idx
+  selected = [batch.experiments[i] for i in selected_idx]
+  if not selected:
+    print("nothing selected, exiting")
+    return
+
+  inventory = Inventory.from_yaml(args.inventory)
+  secrets = ()
+  if args.gurobi_license:
+    secrets = (
+      SecretFile(source=args.gurobi_license, remote_name="gurobi.lic", env_var="GRB_LICENSE_FILE"),
+    )
+  project = Project(
+    path=str(Path(args.project_path).resolve()),
+    project_id="dfaas-optimizer",
+    python=args.python_version,
+    uv_version=args.uv_version,
+    secrets=secrets,
+    exclude=(".venv/", ".git/", "solutions/", "results/", "batches/"),
+  )
+  config_dir = manifest_path.parent / f"{manifest_path.stem}-configs"
+  jobs = [experiment_to_job(e, config_dir) for e in selected]
+
+  with Dispatcher(inventory, project, results_dir=args.results_dir) as dispatcher:
+    start = time.monotonic()
+    with live_view(batch, manifest, inventory, start_time=start) as on_tick:
+      completed = run_batch(dispatcher, jobs, manifest, on_tick)
+  print("batch complete" if completed else "stopped — rerun the same command to resume")
+
+
+def build_parser() -> argparse.ArgumentParser:
+  parser = argparse.ArgumentParser(prog="remote_experiments")
+  sub = parser.add_subparsers(dest="command", required=True)
+
+  define_p = sub.add_parser("define", help="Build a batch file from a registered suite")
+  define_p.add_argument("suite", choices=list_suites())
+  define_p.add_argument("-o", "--output", required=True)
+  define_p.set_defaults(func=cmd_define)
+
+  run_p = sub.add_parser("run", help="Run (or resume) a batch file through the TUI")
+  run_p.add_argument("batch_file")
+  run_p.add_argument("--inventory", required=True)
+  run_p.add_argument("--project-path", default=".")
+  run_p.add_argument("--results-dir", default="./results")
+  run_p.add_argument("--gurobi-license", default=None)
+  run_p.add_argument("--python-version", default="3.10.19")
+  run_p.add_argument("--uv-version", default="0.11.25")
+  run_p.set_defaults(func=cmd_run)
+
+  return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+  parser = build_parser()
+  args = parser.parse_args(argv)
+  args.func(args)
+```
+
+```python
+# remote_experiments/__main__.py
+from .cli import main
+
+if __name__ == "__main__":
+  main()
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_cli.py -v`
+Expected: PASS (5 tests)
+
+- [ ] **Step 5: Manual verification of `cmd_run`/`main`**
+
+`cmd_run` needs a real `Inventory` (SSH-reachable VMs) and is not covered by an automated test. Verify the wiring manually:
+
+Run: `uv run -m remote_experiments --help`
+Expected: prints usage with `define` and `run` subcommands, no traceback.
+
+Run: `uv run -m remote_experiments define smoke -o /tmp/smoke-batch.json && cat /tmp/smoke-batch.json | python3 -m json.tool | head -20`
+Expected: a real batch file with 20 experiments, valid JSON.
+
+Run: `uv run -m remote_experiments run --help`
+Expected: prints `run` subcommand usage (`--inventory` required, etc.), no traceback — confirms the module imports cleanly (pulls in `tui.py`/`runner.py`/`ray_dispatcher` without error) even though no VMs are configured to actually execute against.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add remote_experiments/cli.py remote_experiments/__main__.py tests/test_remote_experiments_cli.py
+git commit -m "feat: add define/run CLI for remote_experiments"
+```
+
+---
+
+### Task 13: Inventory example, README, full-suite verification
+
+**Files:**
+- Create: `remote_experiments/inventory.yaml.example`
+- Create: `remote_experiments/README.md`
+- No test (documentation + verification only)
+
+**Interfaces:** None — closing task.
+
+- [ ] **Step 1: Add an example inventory file**
+
+```yaml
+# remote_experiments/inventory.yaml.example
+hosts:
+  - host: 10.0.0.10
+    user: ubuntu
+    slots: 2
+    identity_file: ~/.ssh/id_ed25519
+  - host: 10.0.0.11
+    user: ubuntu
+    slots: 2
+    identity_file: ~/.ssh/id_ed25519
+```
+
+- [ ] **Step 2: Write the README**
+
+```markdown
+# remote_experiments/README.md
+# remote_experiments
+
+Define batches of DFaaSOptimizer experiments, then run them on Gurobi-equipped
+VMs via `ray-dispatcher` with a live TUI.
+
+## Define a batch
+
+\`\`\`
+uv run -m remote_experiments define smoke -o batches/smoke.json
+\`\`\`
+
+Builds every `Experiment` for the named suite (a registered function under
+`remote_experiments/definitions/`) and writes them to a static JSON file.
+
+## Run (or resume) a batch
+
+\`\`\`
+cp remote_experiments/inventory.yaml.example my-inventory.yaml  # edit hosts
+uv run -m remote_experiments run batches/smoke.json --inventory my-inventory.yaml \
+  --gurobi-license ~/gurobi.lic
+\`\`\`
+
+Shows which experiments are pending (everything not yet `succeeded`,
+tracked in `batches/smoke.manifest.json`), prompts for a selection
+(indices, ranges, or `all` — default is every pending one), then submits
+and shows a live progress view.
+
+Ctrl-C cancels in-flight jobs and stops cleanly. Re-running the same `run`
+command resumes — it defaults to selecting only what isn't `succeeded` yet.
+
+## Adding a suite
+
+Add a file to `remote_experiments/definitions/` with a function decorated
+`@register_suite("name")` returning a `list[Experiment]` (see `smoke.py`).
+```
+
+- [ ] **Step 3: Run the full test suite**
+
+Run: `uv run pytest tests/ -v -k remote_experiments`
+Expected: PASS, all `remote_experiments`-related tests green (batch, registry, smoke suite, jobs, manifest, selection, stats, runner, tui, cli — Tasks 3-12).
+
+Run: `uv run pytest tests/ -v` (full suite, including pre-existing tests)
+Expected: PASS — no regressions in the rest of the repo (including `tests/test_run_faasmacro_v0_flag.py` from Task 2).
+
+- [ ] **Step 4: Run ruff**
+
+Run: `uv run ruff check remote_experiments tests/test_remote_experiments_*.py run_faasmacro.py`
+Expected: no errors (this repo's ruff `select = ["E9", "F"]` with `F401/F541/F841` ignored — mostly a syntax-error check).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/inventory.yaml.example remote_experiments/README.md
+git commit -m "docs: add remote_experiments usage README and example inventory"
+```
diff --git a/docs/superpowers/plans/2026-07-01-euclidean-planar-generators.md b/docs/superpowers/plans/2026-07-01-euclidean-planar-generators.md
new file mode 100644
index 0000000..c5f2318
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-01-euclidean-planar-generators.md
@@ -0,0 +1,218 @@
+# Euclidean Planar Experiment Generators Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace the deterministic circular-ladder topology with reproducible Euclidean planar graphs that have constant spatial density and a target mean degree, add distance-derived edge latency, and align the paper experiment suites with the revised protocol.
+
+**Architecture:** `generate_neighborhood` remains the single topology entry point. Euclidean planar graphs are sampled from random coordinates, use Delaunay edges as the planar candidate set, retain a Euclidean minimum spanning tree for connectivity, and add candidate edges up to the requested edge budget. `add_network_latency` remains the single edge-attribute entry point and supports constant, random, Euclidean, and Euclidean-permuted latency without changing non-spatial generators.
+
+**Tech Stack:** Python 3.10, NumPy, SciPy `spatial.Delaunay`, NetworkX, pytest.
+
+---
+
+### Task 1: Specify Euclidean planar topology behavior
+
+**Files:**
+- Modify: `tests/test_generate_data_extended.py`
+- Modify: `generators/generate_data.py:184-230`
+
+- [ ] **Step 1: Replace the circular-ladder test with failing geometric tests**
+
+```python
+def test_generate_euclidean_planar_neighborhood_with_target_mean_degree():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 3, "density": 0.5,
+    }
+  }
+  matrix, graph = generate_neighborhood(20, limits, _rng(7))
+  positions = nx.get_node_attributes(graph, "pos")
+
+  assert matrix.shape == (20, 20)
+  assert nx.is_connected(graph)
+  assert nx.check_planarity(graph)[0]
+  assert graph.number_of_edges() == round(20 * 3 / 2)
+  assert len(positions) == 20
+  assert all(0 <= x <= np.sqrt(20 / 0.5) for x, _ in positions.values())
+  assert all(0 <= y <= np.sqrt(20 / 0.5) for _, y in positions.values())
+  assert all(data["edge_length"] > 0 for _, _, data in graph.edges(data=True))
+
+
+def test_euclidean_planar_neighborhood_changes_with_seed():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 3, "density": 1.0,
+    }
+  }
+  _, first = generate_neighborhood(20, limits, _rng(1))
+  _, second = generate_neighborhood(20, limits, _rng(2))
+  assert nx.get_node_attributes(first, "pos") != nx.get_node_attributes(second, "pos")
+
+
+def test_euclidean_planar_neighborhood_rejects_infeasible_edge_budget():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 1, "density": 1.0,
+    }
+  }
+  with pytest.raises(ValueError, match="connected Euclidean planar"):
+    generate_neighborhood(20, limits, _rng(1))
+```
+
+- [ ] **Step 2: Run the tests and verify they fail**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k euclidean_planar`
+
+Expected: failures because the current implementation returns a circular ladder and does not store coordinates or edge lengths.
+
+- [ ] **Step 3: Implement the minimal Delaunay-backed generator**
+
+Import `Delaunay` from `scipy.spatial`. Add a private `_generate_euclidean_planar` helper that validates positive density, samples coordinates in a square of side `sqrt(Nn / density)`, converts Delaunay simplices to candidate edges, assigns Euclidean `edge_length`, computes the minimum spanning tree, shuffles the remaining candidate edges with the supplied NumPy generator, and adds edges until `round(Nn * mean_degree / 2)` edges exist. Accept `type = "euclidean_planar"` as the canonical configuration and map the legacy planar keys `degree` or `k` to `mean_degree`.
+
+- [ ] **Step 4: Run the focused tests**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k 'euclidean_planar or neighborhood_with_k_regular or probability_neighborhood'`
+
+Expected: all selected tests pass.
+
+### Task 2: Generate connected fixed-edge random graphs
+
+**Files:**
+- Modify: `tests/test_generate_data_extended.py`
+- Modify: `generators/generate_data.py:184-230`
+
+- [ ] **Step 1: Write failing tests for exact edge count and connected regular graphs**
+
+```python
+def test_fixed_edge_neighborhood_is_connected_and_exact():
+  limits = {"neighborhood": {"m": 30}}
+  _, graph = generate_neighborhood(20, limits, _rng(3))
+  assert nx.is_connected(graph)
+  assert graph.number_of_edges() == 30
+
+
+def test_regular_neighborhood_is_connected():
+  limits = {"neighborhood": {"k": 3}}
+  _, graph = generate_neighborhood(20, limits, _rng(3))
+  assert nx.is_connected(graph)
+```
+
+- [ ] **Step 2: Run the tests and verify the fixed-edge test fails**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k 'fixed_edge or regular_neighborhood_is_connected'`
+
+Expected: the `m` configuration fails because no graph is created.
+
+- [ ] **Step 3: Add bounded connected rejection sampling**
+
+Generate `G(n,m)` and random-regular candidates with integer seeds drawn from the supplied NumPy generator. Retry at most 1,000 times and raise a descriptive `ValueError` when no connected graph is obtained. Keep the existing connected `G(n,p)` behavior.
+
+- [ ] **Step 4: Run the focused tests**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k 'neighborhood'`
+
+Expected: all neighborhood tests pass.
+
+### Task 3: Derive latency from Euclidean edge length
+
+**Files:**
+- Modify: `tests/test_generate_data_extended.py`
+- Modify: `generators/generate_data.py:14-28`
+
+- [ ] **Step 1: Write failing latency tests**
+
+```python
+def test_add_network_latency_from_euclidean_length():
+  graph = nx.Graph()
+  graph.add_edge(0, 1, edge_length=2.5)
+  limits = {"weights": {"edge_network_latency": {
+    "mode": "euclidean", "base": 1.0, "distance_factor": 2.0,
+    "jitter": {"min": 0.0, "max": 0.0},
+  }}}
+  result = add_network_latency(graph, limits, _rng(1))
+  assert result.edges[0, 1]["network_latency"] == 6.0
+
+
+def test_permuted_euclidean_latency_preserves_values():
+  graph = nx.path_graph(4)
+  for index, edge in enumerate(graph.edges(), start=1):
+    graph.edges[edge]["edge_length"] = float(index)
+  base = {"base": 0.0, "distance_factor": 1.0,
+          "jitter": {"min": 0.0, "max": 0.0}}
+  direct = add_network_latency(graph.copy(), {"weights": {
+    "edge_network_latency": {**base, "mode": "euclidean"}}}, _rng(4))
+  permuted = add_network_latency(graph.copy(), {"weights": {
+    "edge_network_latency": {**base, "mode": "euclidean_permuted"}}}, _rng(4))
+  assert sorted(nx.get_edge_attributes(direct, "network_latency").values()) == sorted(
+    nx.get_edge_attributes(permuted, "network_latency").values()
+  )
+```
+
+- [ ] **Step 2: Run the tests and verify they fail**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k 'euclidean_latency'`
+
+Expected: failure because the current function expects random `min` and `max` bounds.
+
+- [ ] **Step 3: Extend the shared latency function**
+
+For Euclidean modes, require `edge_length` and compute `base + distance_factor * edge_length + jitter`. Permute the completed latency vector only for `euclidean_permuted`. Preserve constant latency when no configuration is present and the existing bounded-random mode for configurations without a `mode` key. Assign bandwidth only when `edge_bandwidth` is configured.
+
+- [ ] **Step 4: Run latency and weight tests**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py -k 'latency or weights'`
+
+Expected: all selected tests pass.
+
+### Task 4: Align the paper experiment suites
+
+**Files:**
+- Modify: `remote_experiments/definitions/paper.py`
+- Modify: `tests/test_paper_experiment_suites.py`
+
+- [ ] **Step 1: Write failing suite tests**
+
+Update E3 to expect six topology cells: Euclidean planar, random regular, and connected `G(n,m)`, each at target mean degree 3 or 5. Add E8 registration and assert its default count is 720, its node counts are `{20, 50, 100}`, and its latency modes are `{"euclidean", "euclidean_permuted"}`.
+
+- [ ] **Step 2: Run the suite tests and verify failure**
+
+Run: `uv run pytest -q tests/test_paper_experiment_suites.py`
+
+Expected: E3 count/topology assertions fail and E8 is missing.
+
+- [ ] **Step 3: Replace planar configurations and add E8**
+
+Use `{"type": "euclidean_planar", "mean_degree": 3, "density": 1.0}` for the default planar topology. In E3, use mean degrees 3 and 5 and compute `m = round(50 * mean_degree / 2)` for `G(n,m)`. Add `paper-e8-spatial-latency` for 20, 50, and 100 nodes, the two Euclidean latency modes, four trade-off-compatible algorithms, and 30 seeds.
+
+- [ ] **Step 4: Run suite tests**
+
+Run: `uv run pytest -q tests/test_paper_experiment_suites.py`
+
+Expected: all tests pass and E3/E8 counts are 1,080 and 720.
+
+### Task 5: Verify the complete change
+
+**Files:**
+- Modify: `docs/hierarchical_model_experiment_plan.md` only if configuration names need synchronization
+
+- [ ] **Step 1: Run focused and regression tests**
+
+Run: `uv run pytest -q tests/test_generate_data_extended.py tests/test_paper_experiment_suites.py tests/test_e2e_gurobi_planar.py`
+
+Expected: all available tests pass; Gurobi-dependent tests may skip when no license is available.
+
+- [ ] **Step 2: Run static checks**
+
+Run: `uv run ruff check generators/generate_data.py remote_experiments/definitions/paper.py tests/test_generate_data_extended.py tests/test_paper_experiment_suites.py`
+
+Expected: `All checks passed!`
+
+- [ ] **Step 3: Generate one real paper instance per topology family**
+
+Run: `uv run pytest -q tests/test_paper_experiment_suites.py::test_generated_config_builds_a_real_instance`
+
+Expected: pass with a connected graph and the configured node count.
+
+- [ ] **Step 4: Review affected execution flows**
+
+Run GitNexus change detection over all uncommitted changes and confirm that only instance generation, paper suite definition, tests, and experiment documentation are affected.
diff --git a/docs/superpowers/plans/2026-07-01-paper-experiment-generators.md b/docs/superpowers/plans/2026-07-01-paper-experiment-generators.md
new file mode 100644
index 0000000..f3bf81c
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-01-paper-experiment-generators.md
@@ -0,0 +1,350 @@
+# Paper Experiment Generators Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Generate all paper experiment matrices as registered `remote_experiments` suites compatible with the existing `Batch` and job workflow.
+
+**Architecture:** Add one `paper.py` suite module with small configuration helpers and eight explicit builders, preserving one batch per experiment family. Add a bounded connected-graph retry for probability-based topologies because E3 requires connected instances.
+
+**Tech Stack:** Python 3.10, pytest, NetworkX, existing `remote_experiments` registry and batch dataclasses.
+
+---
+
+## File map
+
+- Create `remote_experiments/definitions/paper.py`: constants, configuration helpers, and E0–E7 suite builders.
+- Modify `remote_experiments/definitions/__init__.py`: import `paper` for registration.
+- Modify `generators/generate_data.py`: bounded deterministic resampling for connected probability graphs.
+- Create `tests/test_paper_experiment_suites.py`: suite counts, factors, IDs, and batch compatibility.
+- Modify `tests/test_generate_data_extended.py`: connected probability-topology regression tests.
+- Modify `remote_experiments/README.md`: list commands for defining the paper batches.
+
+### Task 1: Connected probability topologies
+
+**Files:**
+- Modify: `tests/test_generate_data_extended.py`
+- Modify: `generators/generate_data.py:185-223`
+
+- [ ] **Step 1: Add failing connectivity tests**
+
+```python
+def test_probability_neighborhood_is_connected():
+  limits = {"neighborhood": {"p": 1.0}}
+  matrix, graph = generate_neighborhood(4, limits, np.random.default_rng(1))
+  assert nx.is_connected(graph)
+  assert matrix.shape == (4, 4)
+
+
+def test_probability_neighborhood_rejects_impossible_connectivity():
+  limits = {"neighborhood": {"p": 0.0}}
+  with pytest.raises(ValueError, match="connected random neighborhood"):
+    generate_neighborhood(4, limits, np.random.default_rng(1))
+```
+
+- [ ] **Step 2: Run RED**
+
+Run: `.venv/bin/pytest -q tests/test_generate_data_extended.py -k probability_neighborhood`
+
+Expected: the impossible-connectivity test fails because the current generator returns a disconnected graph.
+
+- [ ] **Step 3: Run impact analysis**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream generate_neighborhood`
+
+Expected: inspect all direct generation flows and stop for user confirmation only if risk is HIGH or CRITICAL.
+
+- [ ] **Step 4: Implement bounded resampling**
+
+Replace the `p` branch with a 1,000-attempt loop that rebuilds the symmetric
+adjacency matrix using the existing RNG and exits when `nx.is_connected(graph)`.
+After the loop, raise:
+
+```python
+raise ValueError("could not generate a connected random neighborhood in 1000 attempts")
+```
+
+- [ ] **Step 5: Run GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_generate_data_extended.py -k probability_neighborhood`
+
+Expected: both tests pass.
+
+### Task 2: Common paper-suite helpers and E0/E1
+
+**Files:**
+- Create: `tests/test_paper_experiment_suites.py`
+- Create: `remote_experiments/definitions/paper.py`
+
+- [ ] **Step 1: Add failing registration and E0/E1 tests**
+
+```python
+from remote_experiments.definitions import get_suite, list_suites
+from remote_experiments.definitions.paper import build_e0, build_e1
+
+
+def test_paper_suites_are_registered():
+  expected = {
+    "paper-e0-pilot", "paper-e1-quality-runtime", "paper-e2-scalability",
+    "paper-e3-topology", "paper-e4-robustness", "paper-e5-dynamics",
+    "paper-e6-ablation", "paper-e7-tradeoffs",
+  }
+  assert expected <= set(list_suites())
+
+
+def test_e0_default_count():
+  assert len(build_e0()) == 120
+
+
+def test_e1_default_count_and_unique_ids():
+  experiments = build_e1()
+  assert len(experiments) == 1800
+  assert len({e.id for e in experiments}) == 1800
+```
+
+- [ ] **Step 2: Run RED**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'registered or e0 or e1'`
+
+Expected: collection fails because `paper.py` does not exist.
+
+- [ ] **Step 3: Run impact analysis**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream register_suite`
+
+Expected: registry consumers and CLI are reported.
+
+- [ ] **Step 4: Implement constants and helpers**
+
+Create `paper.py` with fixed `PILOT_SEEDS = tuple(range(1, 11))`,
+`CONFIRMATORY_SEEDS = tuple(range(1001, 1031))`, method sets, and these helpers:
+
+```python
+def _base_config() -> dict:
+  return json.loads(_BASE_CONFIG_PATH.read_text())
+
+
+def _set_dimensions(config: dict, nodes: int, functions: int) -> None:
+  limits = config["limits"]
+  limits["Nn"] = {"values": [nodes]}
+  limits["Nf"] = {"min": functions, "max": functions}
+  limits["demand"]["values"] = [1.0, 1.2] * ((functions + 1) // 2)
+  limits["demand"]["values"] = limits["demand"]["values"][:functions]
+  limits["memory_requirement"]["values"] = [2, 3] * ((functions + 1) // 2)
+  limits["memory_requirement"]["values"] = limits["memory_requirement"]["values"][:functions]
+
+
+def _experiment(suite: str, cell: str, algorithm: str, seed: int, config: dict) -> Experiment:
+  experiment_id = f"{suite}-{cell}-{algorithm}-s{seed}"
+  config["seed"] = seed
+  config["base_solution_folder"] = f"solutions/{experiment_id}"
+  limits = config["limits"]
+  return Experiment(
+    id=experiment_id, suite=suite, algorithm=algorithm, seed=seed,
+    graph_params={k: copy.deepcopy(v) for k, v in limits.items() if k != "load"},
+    load_params=copy.deepcopy(limits["load"]), config=config,
+  )
+```
+
+Implement `build_e0` and `build_e1` as explicit products over their documented
+factors, copying the base config for every run.
+
+- [ ] **Step 5: Run GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'registered or e0 or e1'`
+
+Expected: selected tests pass.
+
+### Task 3: E2 scalability and E3 topology
+
+**Files:**
+- Modify: `tests/test_paper_experiment_suites.py`
+- Modify: `remote_experiments/definitions/paper.py`
+
+- [ ] **Step 1: Add failing E2/E3 tests**
+
+```python
+def test_e2_count_and_centralized_size_limit():
+  experiments = build_e2()
+  assert len(experiments) == 4230
+  centralized_sizes = {
+    e.config["limits"]["Nn"]["values"][0]
+    for e in experiments if e.algorithm == "centralized"
+  }
+  assert centralized_sizes == {10, 20}
+
+
+def test_e3_count_and_topology_cells():
+  experiments = build_e3()
+  assert len(experiments) == 1260
+  cells = {e.id.split("-hierarchical-")[0] for e in experiments if e.algorithm == "hierarchical"}
+  assert len(cells) == 7 * 30
+```
+
+- [ ] **Step 2: Run RED**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e2 or e3'`
+
+Expected: imports or assertions fail because E2/E3 builders are absent.
+
+- [ ] **Step 3: Run impact analysis**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream _experiment`
+
+Expected: only paper builders and tests depend directly on the helper.
+
+- [ ] **Step 4: Implement E2/E3**
+
+Implement the exact factors from the design. E2 emits the nine non-centralized
+methods for all `(nodes, functions, seed)` cells and emits centralized only when
+`nodes <= 20`. E3 emits seven topology dictionaries: planar `k=3`, regular
+`k=3/5/7`, and probability `p=0.1/0.2/0.3`.
+
+- [ ] **Step 5: Run GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e2 or e3'`
+
+Expected: selected tests pass.
+
+### Task 4: E4 robustness and E5 dynamics
+
+**Files:**
+- Modify: `tests/test_paper_experiment_suites.py`
+- Modify: `remote_experiments/definitions/paper.py`
+
+- [ ] **Step 1: Add failing E4/E5 tests**
+
+```python
+def test_e4_count_and_conditions():
+  experiments = build_e4(seeds=(1001,))
+  assert len(experiments) == 7 * 6
+  assert {e.id.split("-hierarchical-")[0].split("e4-")[-1] for e in experiments if e.algorithm == "hierarchical"} == {
+    "baseline", "load-low", "load-high", "memory-scarce", "memory-ample",
+    "nodes-homogeneous", "nodes-heterogeneous",
+  }
+
+
+def test_e5_count_trace_coverage_and_steps():
+  experiments = build_e5(seeds=(1001,))
+  assert len(experiments) == 3 * 6
+  assert {e.config["limits"]["load"]["trace_type"] for e in experiments} == {
+    "sinusoidal", "clipped", "fixed_sum_minmax",
+  }
+  assert {e.config["max_steps"] for e in experiments} == {100}
+```
+
+- [ ] **Step 2: Run RED**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e4 or e5'`
+
+Expected: builders are missing.
+
+- [ ] **Step 3: Implement E4/E5**
+
+Use seven named mutators for E4 and three trace names for E5. Static conditions
+use 50 nodes, four functions, and planar `k=3`. E5 sets `max_steps=100`,
+`min_run_time=0`, `max_run_time=100`, and `run_time_step=1`.
+
+- [ ] **Step 4: Run GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e4 or e5'`
+
+Expected: selected tests pass.
+
+### Task 5: E6 ablations and E7 trade-offs
+
+**Files:**
+- Modify: `tests/test_paper_experiment_suites.py`
+- Modify: `remote_experiments/definitions/paper.py`
+
+- [ ] **Step 1: Add failing E6/E7 tests**
+
+```python
+def test_e6_default_count_and_hierarchical_only():
+  experiments = build_e6()
+  assert len(experiments) == 1200
+  assert {e.algorithm for e in experiments} == {"hierarchical"}
+
+
+def test_e7_default_count_and_weight_pairs():
+  experiments = build_e7()
+  assert len(experiments) == 1680
+  assert {
+    (e.config["solver_options"]["auction"]["latency_weight"],
+     e.config["solver_options"]["auction"]["fairness_weight"])
+    for e in experiments
+  } == {(0, 0), (0.25, 0), (1, 0), (0, 0.25), (0, 1), (0.25, 0.25), (1, 1)}
+```
+
+- [ ] **Step 2: Run RED**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e6 or e7'`
+
+Expected: builders are missing.
+
+- [ ] **Step 3: Implement E6/E7**
+
+E6 applies ten named config mutations to the hierarchical method and crosses
+them with two sizes, two topologies, and 30 seeds. E7 crosses seven weight pairs,
+two topologies, four fixed methods, and 30 seeds.
+
+- [ ] **Step 4: Run GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py -k 'e6 or e7'`
+
+Expected: selected tests pass.
+
+### Task 6: Registration, serialization, docs, and full verification
+
+**Files:**
+- Modify: `remote_experiments/definitions/__init__.py`
+- Modify: `remote_experiments/README.md`
+- Modify: `tests/test_paper_experiment_suites.py`
+
+- [ ] **Step 1: Add the reduced batch round-trip test**
+
+```python
+def test_paper_experiments_round_trip_as_batch(tmp_path):
+  experiments = build_e1(seeds=(1001,), algorithms=("hierarchical",))
+  path = tmp_path / "batch.json"
+  expected = Batch(suite="paper-e1-quality-runtime", experiments=tuple(experiments))
+  expected.save(path)
+  assert Batch.load(path) == expected
+  assert all(e.config["base_solution_folder"] == f"solutions/{e.id}" for e in experiments)
+```
+
+- [ ] **Step 2: Import paper suites and document commands**
+
+Add `from . import paper` beside the smoke import. Add eight `uv run -m
+remote_experiments define ...` examples to the README, one output batch per suite.
+
+- [ ] **Step 3: Run focused tests**
+
+Run: `.venv/bin/pytest -q tests/test_paper_experiment_suites.py tests/test_generate_data_extended.py`
+
+Expected: all selected tests pass.
+
+- [ ] **Step 4: Verify actual CLI generation**
+
+Run: `uv run -m remote_experiments define paper-e0-pilot -o /tmp/paper-e0.json`
+
+Run: `.venv/bin/python -c 'from remote_experiments.batch import Batch; assert len(Batch.load("/tmp/paper-e0.json").experiments) == 120'`
+
+Expected: both commands exit 0.
+
+- [ ] **Step 5: Run the complete regression suite**
+
+Run: `MPLCONFIGDIR=/tmp/matplotlib .venv/bin/pytest -q tests/test_remote_experiments_*.py tests/test_generate_data_extended.py tests/test_paper_experiment_suites.py`
+
+Expected: all tests pass.
+
+- [ ] **Step 6: Run GitNexus scope verification**
+
+Run `gitnexus_detect_changes(scope="all")`. Confirm changed symbols are limited
+to neighborhood generation, suite registration/builders, tests, and README.
+
+- [ ] **Step 7: Check diff hygiene**
+
+Run: `git diff --check && git status --short`
+
+Expected: no whitespace errors; preserve the untracked
+`test_instances/2026-06-30_13-54-13.841040/` directory.
diff --git a/docs/superpowers/plans/2026-07-01-remote-experiments-fixes.md b/docs/superpowers/plans/2026-07-01-remote-experiments-fixes.md
new file mode 100644
index 0000000..d7d3f31
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-01-remote-experiments-fixes.md
@@ -0,0 +1,268 @@
+# Remote Experiments Reliability Fixes Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make remote experiment provisioning portable, generated commands executable, and terminal metrics/messages accurate.
+
+**Architecture:** Keep the current batch/manifest/runner/TUI boundaries. Change only dependency resolution, job argv construction, final CLI reporting, and session-relative throughput; each behavior gets one focused regression test before implementation.
+
+**Tech Stack:** Python 3.10, pytest, uv, ray-dispatcher, Rich.
+
+---
+
+## File map
+
+- Modify `pyproject.toml` and `uv.lock`: resolve `ray-dispatcher` from a pinned Git revision.
+- Modify `remote_experiments/jobs.py`: construct Python commands, including module execution for hierarchical.
+- Modify `remote_experiments/cli.py`: report terminal failures accurately.
+- Modify `remote_experiments/stats.py` and `remote_experiments/tui.py`: compute throughput relative to session start.
+- Modify focused `tests/test_remote_experiments_*.py` files; add one dependency-source test.
+- Modify `remote_experiments/README.md`: remove the obsolete sibling-checkout prerequisite.
+
+### Task 1: Portable ray-dispatcher dependency
+
+**Files:**
+- Create: `tests/test_remote_experiments_dependencies.py`
+- Modify: `pyproject.toml:38-39`
+- Modify: `uv.lock`
+- Modify: `remote_experiments/README.md:6-15`
+
+- [ ] **Step 1: Write the failing source-portability test**
+
+```python
+import tomllib
+from pathlib import Path
+
+
+def test_ray_dispatcher_source_is_remote_resolvable():
+  config = tomllib.loads(Path("pyproject.toml").read_text())
+  source = config["tool"]["uv"]["sources"]["ray-dispatcher"]
+  assert source == {
+    "git": "https://github.com/miciav/ray-dispatcher.git",
+    "rev": "30e91c81959eab30908675102e639a8953945049",
+  }
+```
+
+- [ ] **Step 2: Run the test and verify RED**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_dependencies.py`
+
+Expected: FAIL because the current source is `{"path": "../ray-dispatcher", "editable": true}`.
+
+- [ ] **Step 3: Run GitNexus impact checks before editing configuration consumers**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream cmd_run`
+
+Expected: review direct CLI/test dependants; warn before proceeding only if risk is HIGH or CRITICAL.
+
+- [ ] **Step 4: Replace the source and refresh the lock**
+
+Set:
+
+```toml
+[tool.uv.sources]
+ray-dispatcher = { git = "https://github.com/miciav/ray-dispatcher.git", rev = "30e91c81959eab30908675102e639a8953945049" }
+```
+
+Run: `uv lock`
+
+Update the README prerequisites to require SSH access, Gurobi, and network access for provisioning, without requiring a sibling checkout.
+
+- [ ] **Step 5: Verify GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_dependencies.py`
+
+Expected: `1 passed`.
+
+### Task 2: Executable job commands
+
+**Files:**
+- Modify: `tests/test_remote_experiments_jobs.py`
+- Modify: `remote_experiments/jobs.py:12-38`
+
+- [ ] **Step 1: Change command expectations to the required behavior**
+
+```python
+def test_experiment_to_job_builds_expected_command_for_plain_algorithm(tmp_path):
+  job = experiment_to_job(_experiment("centralized"), tmp_path)
+  assert job.command == (
+    "python", "run_centralized_model.py", "-c", "config.json", "--disable_plotting",
+  )
+
+
+def test_experiment_to_job_runs_hierarchical_as_module(tmp_path):
+  job = experiment_to_job(_experiment("hierarchical"), tmp_path)
+  assert job.command == (
+    "python", "-m", "hierarchical_auction.runner", "-c", "config.json",
+    "--disable_plotting",
+  )
+```
+
+Also update the variant expectation to start with `("python", "decentralized_bestresponse.py", ...)`.
+
+- [ ] **Step 2: Run the focused tests and verify RED**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_jobs.py`
+
+Expected: three command assertions fail because commands currently start with `uv run` and hierarchical is a file path.
+
+- [ ] **Step 3: Run GitNexus impact analysis**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream experiment_to_job`
+
+Expected: direct callers are `cmd_run` and job tests; report risk before editing.
+
+- [ ] **Step 4: Implement the minimal command mapping**
+
+Store each algorithm's executable tail rather than only a script:
+
+```python
+COMMAND_BY_ALGORITHM = {
+  "centralized": ("run_centralized_model.py",),
+  "hierarchical": ("-m", "hierarchical_auction.runner"),
+  # existing scripts and variant arguments follow the same tuple format
+}
+```
+
+Build the job command as:
+
+```python
+command = COMMAND_BY_ALGORITHM[experiment.algorithm]
+Job(command=("python", *command, "-c", "config.json", "--disable_plotting"), ...)
+```
+
+Keep the existing public constant name if changing it would add unnecessary churn.
+
+- [ ] **Step 5: Verify GREEN and the real entry point**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_jobs.py`
+
+Run: `MPLCONFIGDIR=/tmp/matplotlib .venv/bin/python -m hierarchical_auction.runner --help`
+
+Expected: all job tests pass and module help exits 0.
+
+### Task 3: Accurate terminal message
+
+**Files:**
+- Modify: `tests/test_remote_experiments_cli.py`
+- Modify: `remote_experiments/cli.py:65-69`
+
+- [ ] **Step 1: Add a failed-dispatcher CLI test**
+
+Create a fake derived from `_FakeDispatcher` whose status sequence ends in `JobStatus.FAILED`, run `cmd_run`, capture stdout with `capsys`, and assert:
+
+```python
+assert "batch finished with 1 unsuccessful experiment" in capsys.readouterr().out
+assert "batch complete" not in capsys.readouterr().out
+```
+
+Read captured output once and store it in a variable before both assertions.
+
+- [ ] **Step 2: Run the test and verify RED**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_cli.py::test_cmd_run_reports_terminal_failures`
+
+Expected: FAIL because the CLI prints `batch complete`.
+
+- [ ] **Step 3: Run GitNexus impact analysis**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream cmd_run`
+
+Expected: CLI tests are direct dependants; report risk before editing.
+
+- [ ] **Step 4: Implement selected-experiment reporting**
+
+After `run_batch`, retain the interrupted message when `completed` is false. Otherwise count selected experiments whose manifest status is not `SUCCEEDED`; print `batch complete` only when the count is zero, else print `batch finished with N unsuccessful experiment(s)`.
+
+- [ ] **Step 5: Verify GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_cli.py`
+
+Expected: all CLI tests pass.
+
+### Task 4: Session-relative throughput
+
+**Files:**
+- Modify: `tests/test_remote_experiments_stats.py`
+- Modify: `remote_experiments/stats.py:46-67`
+- Modify: `remote_experiments/tui.py:65-76`
+
+- [ ] **Step 1: Add the resumed-session regression test**
+
+```python
+def test_summarize_throughput_excludes_successes_from_before_session(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("old", status="succeeded", duration_s=5.0)
+  manifest.record("new", status="succeeded", duration_s=5.0)
+  stats = summarize(
+    ["old", "new"], manifest, _inventory(), {}, elapsed_s=30.0,
+    succeeded_at_start=1,
+  )
+  assert stats.throughput_per_min == 2.0
+```
+
+- [ ] **Step 2: Run the test and verify RED**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_stats.py::test_summarize_throughput_excludes_successes_from_before_session`
+
+Expected: FAIL because `summarize` does not accept `succeeded_at_start`.
+
+- [ ] **Step 3: Run GitNexus impact analysis for both edited symbols**
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream summarize`
+
+Run: `npx gitnexus impact -r DFaaSOptimizer --direction upstream live_view`
+
+Expected: TUI and tests are direct dependants; report risk before editing.
+
+- [ ] **Step 4: Implement baseline subtraction**
+
+Add keyword parameter `succeeded_at_start: int = 0` to `summarize` and compute:
+
+```python
+session_succeeded = max(succeeded - succeeded_at_start, 0)
+throughput_per_min = session_succeeded / elapsed_s * 60 if elapsed_s > 0 else 0.0
+```
+
+In `live_view`, calculate the initial number of succeeded experiment IDs once before opening `Live`, then pass it to every `summarize` call.
+
+- [ ] **Step 5: Verify GREEN**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_stats.py tests/test_remote_experiments_tui.py`
+
+Expected: all stats and TUI tests pass.
+
+### Task 5: Full verification and scope audit
+
+**Files:**
+- Verify all files changed above.
+
+- [ ] **Step 1: Run the complete focused suite**
+
+Run: `.venv/bin/pytest -q tests/test_remote_experiments_*.py`
+
+Expected: all tests pass.
+
+- [ ] **Step 2: Verify dependency lock and command entry point**
+
+Run: `uv lock --check`
+
+Run: `MPLCONFIGDIR=/tmp/matplotlib .venv/bin/python -m hierarchical_auction.runner --help`
+
+Expected: both commands exit 0.
+
+- [ ] **Step 3: Check diff quality**
+
+Run: `git diff --check`
+
+Expected: no output and exit 0.
+
+- [ ] **Step 4: Run GitNexus change detection**
+
+Run: `npx gitnexus cypher -r DFaaSOptimizer "MATCH (n) WHERE n.filePath STARTS WITH 'remote_experiments/' RETURN n.filePath, n.name LIMIT 5"`
+
+Run the available GitNexus change-detection tool for the working tree; if the CLI lacks `detect-changes`, use the configured MCP tool. Confirm only dependency provisioning, job construction, CLI reporting, stats/TUI, docs, and tests are affected.
+
+- [ ] **Step 5: Report completion without committing implementation unless requested**
+
+Summarize changed behavior and exact verification results. Preserve the user's untracked `test_instances/2026-06-30_13-54-13.841040/` directory.
diff --git a/docs/superpowers/plans/2026-07-02-faas-mald-dual-coordination.md b/docs/superpowers/plans/2026-07-02-faas-mald-dual-coordination.md
new file mode 100644
index 0000000..67b33d1
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-02-faas-mald-dual-coordination.md
@@ -0,0 +1,828 @@
+# FaaS-MALD Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add FaaS-MALD, a Lagrangian-dual decentralized coordinator with a per-timestep duality-gap certificate, as a new standalone module plus tests and a LaTeX technical note.
+
+**Architecture:** One new module `decentralized_dual.py` mirrors `decentralized_diffusion.py`'s runner skeleton; the only new logic is a projected dual-subgradient inner loop (`pair_scores`, `buyer_price_response`, `dual_coordination_round`) whose primal recovery reuses `decentralized_diffusion.evaluate_assignments`. Spec: `docs/superpowers/specs/2026-07-02-faas-mald-dual-coordination-design.md`.
+
+**Tech Stack:** Python 3.10, numpy, pandas, networkx, Pyomo+Gurobi (via reused helpers), scipy (tests only), pytest, LaTeX (latexmk).
+
+## Global Constraints
+
+- **NEVER modify any existing file.** Only create: `decentralized_dual.py`, `tests/test_dual_helpers.py`, `tests/test_dual_e2e.py`, `faas-mald-note/*`.
+- **Model policy:** every task is executed by a subagent with **`model: gpt-5.4` at most**; `model: gpt-5.4-mini` is allowed for simpler tasks. Each task below states its model.
+- Code style: 2-space indentation, same import layout and docstring style as `decentralized_diffusion.py` / `decentralized_powerd.py`.
+- Run tests with `uv run pytest <file> -v` from the repo root.
+- Commits: one per task, message style matching repo history (short imperative subject).
+
+## File Structure
+
+- `decentralized_dual.py` — new coordinator: pure helpers (`pair_scores`, `buyer_price_response`, `dual_coordination_round`) + `run()` + CLI.
+- `tests/test_dual_helpers.py` — unit tests for the pure helpers, incl. LP certificate check vs `scipy.optimize.linprog`.
+- `tests/test_dual_e2e.py` — wiring + end-to-end test (skips without Gurobi), mirrors `tests/test_powerd_e2e.py`.
+- `faas-mald-note/` — LaTeX technical note (`faas-mald.tex`, `main.tex`, `references.bib`, `README.md`, `.gitignore`).
+
+---
+
+### Task 1: Pure buyer-side helpers (`pair_scores`, `buyer_price_response`)
+
+**Model:** gpt-5.4
+
+**Files:**
+- Create: `decentralized_dual.py` (helpers only in this task)
+- Test: `tests/test_dual_helpers.py`
+
+**Interfaces:**
+- Consumes: nothing from earlier tasks; only numpy/pandas and the standard `data[None]` dict format (`Nn`, `Nf`, `beta[(i+1,j+1,f+1)]`, `gamma[(i+1,f+1)]`).
+- Produces:
+  - `pair_scores(data: dict, neighborhood: np.array, latency, fairness: np.array, dual_options: dict) -> Tuple[np.array, np.array]` returning `(s, elig)` with shapes `(Nn,Nn,Nf)`; `s[i,j,f]` is the unpriced score, `elig` a bool mask (neighbor and `s > -gamma`); `s` is `-inf` where ineligible.
+  - `buyer_price_response(omega: np.array, capacity: np.array, lam: np.array, s: np.array, elig: np.array) -> Tuple[pd.DataFrame, np.array, float]` returning `(bids, demand, buyer_dual_term)`; `bids` has columns `i, j, f, d, utility` (utility = unpriced score, for `evaluate_assignments`); `demand` is the uncapped argmax response `(Nn,Nf)` indexed by seller; `buyer_dual_term = Σ_{i,f} ω_{if}·max(0, max_j (s_{ijf} − λ_{jf}))`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_dual_helpers.py`:
+
+```python
+import numpy as np
+import pandas as pd
+
+from decentralized_dual import buyer_price_response, pair_scores
+
+
+def make_data(Nn=3, Nf=1, beta=None, gamma=0.05):
+  data = {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "beta": {}, "gamma": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "demand": {(j + 1, f + 1): 1.0 for j in range(Nn) for f in range(Nf)},
+    "max_utilization": {f + 1: 0.7 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = gamma
+      for j in range(Nn):
+        b = 1.0 if beta is None else beta[i][j][f]
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = b
+  return data
+
+
+def full_neighborhood(Nn):
+  return np.ones((Nn, Nn)) - np.eye(Nn)
+
+
+DUAL_OPTIONS = {"latency_weight": 0.0, "fairness_weight": 0.0}
+
+
+def test_pair_scores_masks_non_neighbors_and_dominated_pairs():
+  Nn, Nf = 3, 1
+  beta = [[[1.0]] * Nn for _ in range(Nn)]
+  beta[0][2][0] = -1.0  # worse than rejecting (gamma=0.05): ineligible
+  data = make_data(Nn, Nf, beta=beta)
+  neighborhood = full_neighborhood(Nn)
+  neighborhood[0, 1] = 0  # not a neighbor
+  s, elig = pair_scores(
+    data, neighborhood, np.zeros((Nn, Nn)), np.zeros((Nn, Nf)), DUAL_OPTIONS
+  )
+  assert not elig[0, 1, 0] and not elig[0, 2, 0] and not elig[0, 0, 0]
+  assert elig[1, 0, 0] and s[1, 0, 0] == 1.0
+  assert s[0, 1, 0] == -np.inf
+
+
+def test_buyer_response_zero_prices_picks_best_score_seller():
+  Nn, Nf = 3, 1
+  beta = [[[1.0]] * Nn for _ in range(Nn)]
+  beta[0][1][0] = 2.0  # node 0 prefers node 1
+  data = make_data(Nn, Nf, beta=beta)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 5.0
+  capacity = np.full((Nn, Nf), 3.0)
+  bids, demand, dual_term = buyer_price_response(
+    omega, capacity, np.zeros((Nn, Nf)), s, elig
+  )
+  # uncapped argmax response: all 5 units demanded from node 1
+  assert demand[1, 0] == 5.0 and demand[2, 0] == 0.0
+  assert dual_term == 5.0 * 2.0
+  # capped bids waterfill: 3 to node 1, 2 to node 2
+  first = bids.iloc[0]
+  assert (first.j, first.d) == (1, 3.0)
+  assert bids["d"].sum() == 5.0
+
+
+def test_buyer_response_price_shifts_demand():
+  Nn, Nf = 3, 1
+  beta = [[[1.0]] * Nn for _ in range(Nn)]
+  beta[0][1][0] = 2.0
+  data = make_data(Nn, Nf, beta=beta)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 5.0
+  lam = np.zeros((Nn, Nf)); lam[1, 0] = 1.5  # price out node 1 (2-1.5 < 1)
+  bids, demand, dual_term = buyer_price_response(
+    omega, np.full((Nn, Nf), 10.0), lam, s, elig
+  )
+  assert demand[2, 0] == 5.0 and demand[1, 0] == 0.0
+  assert dual_term == 5.0 * 1.0
+
+
+def test_buyer_response_all_priced_out_yields_empty():
+  Nn, Nf = 2, 1
+  data = make_data(Nn, Nf)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 4.0
+  lam = np.full((Nn, Nf), 10.0)
+  bids, demand, dual_term = buyer_price_response(
+    omega, np.full((Nn, Nf), 10.0), lam, s, elig
+  )
+  assert len(bids) == 0 and demand.sum() == 0.0 and dual_term == 0.0
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_dual_helpers.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'decentralized_dual'` (or ImportError).
+
+- [ ] **Step 3: Implement the helpers**
+
+Create `decentralized_dual.py`:
+
+```python
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+
+
+def pair_scores(
+    data: dict,
+    neighborhood: np.array,
+    latency: np.array,
+    fairness: np.array,
+    dual_options: dict,
+  ) -> Tuple[np.array, np.array]:
+  """Unpriced pair scores and eligibility for the coordination LP.
+
+  s[i,j,f] = beta_{ijf} - w_lat * L_{ij} - w_fair * phi_{if}, defined only for
+  neighbors j of i with s > -gamma_{if} (offloading beats rejection), the same
+  score and filter used by define_assignments/best_response_sweep. Ineligible
+  entries hold -inf.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  s = np.full((Nn, Nn, Nf), -np.inf)
+  elig = np.zeros((Nn, Nn, Nf), dtype=bool)
+  for i in range(Nn):
+    for j in np.nonzero(neighborhood[i, :])[0]:
+      j = int(j)
+      for f in range(Nf):
+        val = (
+          data[None]["beta"][(i + 1, j + 1, f + 1)]
+          - dual_options["latency_weight"] * latency[i, j]
+          - dual_options["fairness_weight"] * fairness[i, f]
+        )
+        if val > -data[None]["gamma"][(i + 1, f + 1)]:
+          s[i, j, f] = val
+          elig[i, j, f] = True
+  return s, elig
+
+
+def buyer_price_response(
+    omega: np.array,
+    capacity: np.array,
+    lam: np.array,
+    s: np.array,
+    elig: np.array,
+  ) -> Tuple[pd.DataFrame, np.array, float]:
+  """One synchronous buyer step at seller prices ``lam``.
+
+  Subgradient side: each buyer places its whole residual demand omega[i,f] on
+  the argmax seller by price-adjusted score (if positive), giving the demand
+  matrix D used in the projected subgradient g = D - C, and the buyer part of
+  the dual value sum_{i,f} omega * max(0, max_j (s - lam)).
+
+  Primal-recovery side: bids waterfill the ranked positive-adjusted-score
+  sellers, capping each request at the advertised capacity; ``utility`` holds
+  the unpriced score, on which evaluate_assignments later sorts.
+  """
+  Nn, Nf = omega.shape
+  demand = np.zeros((Nn, Nf))
+  dual_term = 0.0
+  bids = {"i": [], "j": [], "f": [], "d": [], "utility": []}
+  for i, f in zip(*np.nonzero(omega > 0)):
+    i, f = int(i), int(f)
+    sellers = np.nonzero(elig[i, :, f])[0]
+    if len(sellers) == 0:
+      continue
+    adj = s[i, sellers, f] - lam[sellers, f]
+    order = np.lexsort((sellers, -adj))
+    best = float(adj[order[0]])
+    if best > 0:
+      j_star = int(sellers[order[0]])
+      demand[j_star, f] += omega[i, f]
+      dual_term += float(omega[i, f]) * best
+    left = float(omega[i, f])
+    for idx in order:
+      if left <= 0 or adj[idx] <= 0:
+        break
+      j = int(sellers[idx])
+      q = min(left, float(capacity[j, f]))
+      if q <= 0:
+        continue
+      bids["i"].append(i)
+      bids["j"].append(j)
+      bids["f"].append(f)
+      bids["d"].append(q)
+      bids["utility"].append(float(s[i, j, f]))
+      left -= q
+  return pd.DataFrame(bids), demand, dual_term
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_dual_helpers.py -v`
+Expected: 4 PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_dual.py tests/test_dual_helpers.py
+git commit -m "add FaaS-MALD buyer-side dual helpers"
+```
+
+---
+
+### Task 2: Dual subgradient loop with certificate (`dual_coordination_round`)
+
+**Model:** gpt-5.4
+
+**Files:**
+- Modify: `decentralized_dual.py` (append; created in Task 1 — this is our new file, allowed)
+- Test: `tests/test_dual_helpers.py` (append)
+
+**Interfaces:**
+- Consumes: `pair_scores`, `buyer_price_response` (Task 1); `decentralized_diffusion.evaluate_assignments(bids, residual_capacity, data, ell, r, initial_rho, tentatively_start_replicas, last_y=None, diffusion_options=None, latency=None, fairness=None) -> (y, additional_replicas, n_sellers)` (existing, reused as-is).
+- Produces: `dual_coordination_round(omega, residual_capacity, data, neighborhood, rho, dual_options, latency, fairness, force_memory_bids, ell, r) -> Tuple[np.array, np.array, pd.DataFrame, dict, int]` returning `(y_increment, additional_replicas, memory_bids, gap_info, n_active)`. `gap_info` keys: `"LB"`, `"UB"`, `"gap"`, `"inner_iterations"`, `"lam"` (final prices), `"lb_history"` (list). `dual_options` keys (all consumed here): `alpha0`, `step_rule` ("sqrt"|"polyak"), `theta`, `max_inner_iterations`, `gap_tolerance`, `latency_weight`, `fairness_weight`.
+
+The certificate loop always calls `evaluate_assignments` with `last_y=None` and `tentatively_start_replicas=False`, so LB and UB bound the same LP (fresh assignment of `omega` to `residual_capacity`); the incumbent-replacement path of `evaluate_assignments` is deliberately unused. After the loop, one final call on the best bids uses `tentatively_start_replicas=(len(memory_bids) == 0)`, mirroring FaaS-MADiG.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `tests/test_dual_helpers.py`:
+
+```python
+from scipy.optimize import linprog
+
+from decentralized_dual import dual_coordination_round
+
+
+def coordination_lp_optimum(omega, capacity, s, elig):
+  """Brute-force the coordination LP with scipy (test oracle)."""
+  Nn, Nf = omega.shape
+  pairs = [(i, j, f) for i in range(Nn) for j in range(Nn) for f in range(Nf)
+           if elig[i, j, f]]
+  if not pairs:
+    return 0.0
+  c = [-s[i, j, f] for (i, j, f) in pairs]
+  A, b = [], []
+  for i in range(Nn):
+    for f in range(Nf):
+      A.append([1.0 if (p[0], p[2]) == (i, f) else 0.0 for p in pairs])
+      b.append(float(omega[i, f]))
+  for j in range(Nn):
+    for f in range(Nf):
+      A.append([1.0 if (p[1], p[2]) == (j, f) else 0.0 for p in pairs])
+      b.append(float(capacity[j, f]))
+  res = linprog(c, A_ub=A, b_ub=b, bounds=[(0, None)] * len(pairs))
+  assert res.success
+  return -res.fun
+
+
+def dual_round_setup(Nn=4, Nf=2, seed=7):
+  rng = np.random.default_rng(seed)
+  beta = [[[float(rng.uniform(0.5, 2.0)) for _ in range(Nf)]
+           for _ in range(Nn)] for _ in range(Nn)]
+  data = make_data(Nn, Nf, beta=beta)
+  neighborhood = full_neighborhood(Nn)
+  omega = rng.uniform(0.0, 4.0, size=(Nn, Nf))
+  capacity = rng.uniform(0.0, 3.0, size=(Nn, Nf))
+  return data, neighborhood, omega, capacity
+
+
+DUAL_ROUND_OPTIONS = {
+  "alpha0": 0.5, "step_rule": "sqrt", "theta": 1.0,
+  "max_inner_iterations": 300, "gap_tolerance": 0.01,
+  "latency_weight": 0.0, "fairness_weight": 0.0,
+}
+
+
+def run_round(data, neighborhood, omega, capacity, options=None):
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  return dual_coordination_round(
+    omega, capacity, data, neighborhood,
+    rho=np.zeros(Nn), dual_options=options or DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)), fairness=np.zeros((Nn, Nf)),
+    force_memory_bids=False, ell=np.zeros((Nn, Nf)),
+    r=np.zeros((Nn, Nf)),
+  )
+
+
+def test_certificate_brackets_lp_optimum_and_gap_closes():
+  data, neighborhood, omega, capacity = dual_round_setup()
+  y_inc, _, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  s, elig = pair_scores(
+    data, neighborhood, np.zeros_like(neighborhood),
+    np.zeros(omega.shape), DUAL_ROUND_OPTIONS,
+  )
+  opt = coordination_lp_optimum(omega, capacity, s, elig)
+  assert gap_info["UB"] >= opt - 1e-6
+  assert gap_info["LB"] <= opt + 1e-6
+  assert gap_info["gap"] <= 0.05
+  # weak duality: reported LB is the value of the returned feasible y
+  val = float((np.where(elig, s, 0.0) * y_inc).sum())
+  assert abs(val - gap_info["LB"]) <= 1e-6
+
+
+def test_best_lb_is_monotone_nondecreasing():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=11)
+  _, _, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  hist = gap_info["lb_history"]
+  assert all(b >= a - 1e-12 for a, b in zip(hist, hist[1:]))
+
+
+def test_recovered_increment_is_feasible():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=3)
+  y_inc, _, _, _, _ = run_round(data, neighborhood, omega, capacity)
+  assert (y_inc >= -1e-9).all()
+  assert (y_inc.sum(axis=1) <= omega + 1e-6).all()
+  assert (y_inc.sum(axis=0) <= capacity + 1e-6).all()
+
+
+def test_price_rises_on_oversubscribed_seller():
+  Nn, Nf = 3, 1
+  beta = [[[1.0]] * Nn for _ in range(Nn)]
+  beta[0][2][0] = 5.0
+  beta[1][2][0] = 5.0  # both buyers want node 2
+  data = make_data(Nn, Nf, beta=beta)
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 4.0; omega[1, 0] = 4.0
+  capacity = np.zeros((Nn, Nf)); capacity[2, 0] = 2.0; capacity[0, 0] = 6.0
+  capacity[1, 0] = 6.0
+  _, _, _, gap_info, _ = run_round(data, full_neighborhood(Nn), omega, capacity)
+  assert gap_info["lam"][2, 0] > 0.0
+
+
+def test_no_demand_returns_zero_gap_and_empty_outputs():
+  data, neighborhood, _, capacity = dual_round_setup()
+  omega = np.zeros((4, 2))
+  y_inc, add_r, memory_bids, gap_info, n_active = run_round(
+    data, neighborhood, omega, capacity
+  )
+  assert y_inc.sum() == 0.0 and add_r.sum() == 0.0
+  assert len(memory_bids) == 0 and n_active == 0
+  assert gap_info["LB"] == 0.0 and gap_info["UB"] == 0.0
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_dual_helpers.py -v -k "certificate or monotone or recovered or oversubscribed or no_demand"`
+Expected: FAIL with `ImportError: cannot import name 'dual_coordination_round'`.
+
+- [ ] **Step 3: Implement `dual_coordination_round`**
+
+Append to `decentralized_dual.py` (add `from decentralized_diffusion import evaluate_assignments` to the imports):
+
+```python
+def dual_coordination_round(
+    omega: np.array,
+    residual_capacity: np.array,
+    data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    dual_options: dict,
+    latency: np.array,
+    fairness: np.array,
+    force_memory_bids: bool,
+    ell: np.array,
+    r: np.array,
+  ) -> Tuple[np.array, np.array, pd.DataFrame, dict, int]:
+  """Projected dual subgradient loop with primal recovery and gap certificate.
+
+  Relaxes the seller capacity constraints of the coordination LP with prices
+  lam >= 0. Each inner iteration: closed-form buyer responses at current
+  prices (buyer_price_response), dual value L(lam) = lam.C + buyer terms as a
+  valid upper bound (weak duality), feasible primal via the reused
+  evaluate_assignments (lower bound; last_y=None and no tentative replicas so
+  LB and UB bound the same LP), then lam <- max(0, lam + alpha_k (D - C)).
+  Stops on relative gap <= gap_tolerance or max_inner_iterations. A final
+  evaluate_assignments call on the best bids may tentatively start replicas
+  (mirroring FaaS-MADiG) when no memory bids were generated.
+  """
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  s, elig = pair_scores(data, neighborhood, latency, fairness, dual_options)
+  C = np.array(residual_capacity, dtype=float)
+  lam = np.zeros((Nn, Nf))
+  s_val = np.where(elig, s, 0.0)
+  best_lb, best_ub = 0.0, np.inf
+  best_bids = pd.DataFrame({"i": [], "j": [], "f": [], "d": [], "utility": []})
+  lb_history = []
+  n_active = int((omega > 0).any(axis=1).sum())
+  gap = 0.0
+  k = 0
+  max_inner = int(dual_options["max_inner_iterations"])
+  for k in range(1, max_inner + 1):
+    bids, demand, dual_term = buyer_price_response(omega, C, lam, s, elig)
+    best_ub = min(best_ub, float((lam * C).sum() + dual_term))
+    if len(bids) > 0:
+      y_try, _, _ = evaluate_assignments(
+        bids, residual_capacity, data, ell, r, rho,
+        tentatively_start_replicas=False, last_y=None,
+        diffusion_options=dual_options, latency=latency, fairness=fairness,
+      )
+      lb = float((s_val * y_try).sum())
+      if lb > best_lb:
+        best_lb, best_bids = lb, bids
+    lb_history.append(best_lb)
+    gap = (best_ub - best_lb) / max(1.0, abs(best_ub))
+    if gap <= dual_options["gap_tolerance"]:
+      break
+    if demand.sum() <= 0 and len(bids) == 0:
+      break
+    g = demand - C
+    if dual_options["step_rule"] == "polyak":
+      denom = float((g * g).sum())
+      alpha = (
+        0.0 if denom <= 0.0
+        else dual_options["theta"] * max(0.0, best_ub - best_lb) / denom
+      )
+    else:
+      alpha = dual_options["alpha0"] / np.sqrt(k)
+    lam = np.maximum(0.0, lam + alpha * g)
+  memory_bids = {"i": [], "j": [], "f": []}
+  placed = (
+    np.zeros((Nn, Nf)) if len(best_bids) == 0
+    else evaluate_assignments(
+      best_bids, residual_capacity, data, ell, r, rho,
+      tentatively_start_replicas=False, last_y=None,
+      diffusion_options=dual_options, latency=latency, fairness=fairness,
+    )[0].sum(axis=1)
+  )
+  for i, f in zip(*np.nonzero(omega > 0)):
+    i, f = int(i), int(f)
+    if placed[i, f] < omega[i, f] or force_memory_bids:
+      memory_requirement = data[None]["memory_requirement"][f + 1]
+      for j in np.nonzero(neighborhood[i, :])[0]:
+        if rho[int(j)] >= memory_requirement:
+          memory_bids["i"].append(i)
+          memory_bids["j"].append(int(j))
+          memory_bids["f"].append(f)
+  memory_bids = pd.DataFrame(memory_bids)
+  y_increment = np.zeros((Nn, Nn, Nf))
+  additional_replicas = np.zeros((Nn, Nf))
+  if len(best_bids) > 0:
+    y_increment, additional_replicas, _ = evaluate_assignments(
+      best_bids, residual_capacity, data, ell, r, rho,
+      tentatively_start_replicas=(len(memory_bids) == 0), last_y=None,
+      diffusion_options=dual_options, latency=latency, fairness=fairness,
+    )
+  gap_info = {
+    "LB": best_lb, "UB": best_ub, "gap": gap,
+    "inner_iterations": k, "lam": lam, "lb_history": lb_history,
+  }
+  if not np.isfinite(gap_info["UB"]):
+    gap_info["UB"] = 0.0
+    gap_info["gap"] = 0.0
+  return y_increment, additional_replicas, memory_bids, gap_info, n_active
+```
+
+Note for the implementer: `best_ub` stays `inf` only if the loop never runs (`max_inner_iterations == 0`); with no demand the first iteration yields `dual_term == 0` and `lam == 0`, so `UB == 0`. Keep the final normalization exactly as written so `test_no_demand_returns_zero_gap_and_empty_outputs` passes.
+
+- [ ] **Step 4: Run all helper tests**
+
+Run: `uv run pytest tests/test_dual_helpers.py -v`
+Expected: 9 PASS (4 from Task 1 + 5 new).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_dual.py tests/test_dual_helpers.py
+git commit -m "add FaaS-MALD dual subgradient round with gap certificate"
+```
+
+---
+
+### Task 3: Runner, CLI, and end-to-end tests
+
+**Model:** gpt-5.4
+
+**Files:**
+- Modify: `decentralized_dual.py` (append `parse_arguments`, `run`, `__main__`)
+- Test: `tests/test_dual_e2e.py`
+
+**Interfaces:**
+- Consumes: `dual_coordination_round` (Task 2); the same reused helpers `decentralized_diffusion.py` imports (`run_centralized_model`, `run_faasmacro`, `run_faasmadea`, `utils.*`, `models.sp`, `postprocessing.load_solution`).
+- Produces: `run(config: dict, parallelism: int, log_on_file: bool = False, disable_plotting: bool = False) -> str` (returns the solution folder), CLI `uv run decentralized_dual.py -c <config> [-j N] [--disable_plotting]`. Output column/method name: `FaaS-MALD`. Options key: `solver_options["dual"]` with defaults `{"alpha0": 1.0, "step_rule": "sqrt", "theta": 1.0, "max_inner_iterations": 50, "gap_tolerance": 0.01, "latency_weight": 0.0, "fairness_weight": 0.0}` applied via `setdefault`, so existing configs run unchanged.
+
+**Implementation instruction (read first):** open `decentralized_diffusion.py` and copy its `run()`, `parse_arguments()`, and `__main__` block verbatim into `decentralized_dual.py`, then apply ONLY the deltas below. Do not restructure. The imports to add at the top of `decentralized_dual.py` are exactly the ones `decentralized_diffusion.py` uses (minus `VAR_TYPE`), plus `from decentralized_diffusion import evaluate_assignments` already added in Task 2.
+
+Deltas versus `decentralized_diffusion.run`:
+
+1. Argparse description: `"Run FaaS-MALD"`.
+2. Options block replaces the `diffusion_options` block:
+
+```python
+  dual_options = dict(solver_options.get("dual", {}))
+  dual_options.setdefault("alpha0", 1.0)
+  dual_options.setdefault("step_rule", "sqrt")
+  dual_options.setdefault("theta", 1.0)
+  dual_options.setdefault("max_inner_iterations", 50)
+  dual_options.setdefault("gap_tolerance", 0.01)
+  dual_options.setdefault("latency_weight", 0.0)
+  dual_options.setdefault("fairness_weight", 0.0)
+```
+
+3. The `define_assignments` + `evaluate_assignments` block inside the inner `while not stop_searching` loop (diffusion lines building `bids`/`memory_bids` and then `diffusion_y`) is replaced by:
+
+```python
+      s = datetime.now()
+      y_inc, additional_replicas, memory_bids, gap_info, n_active = (
+        dual_coordination_round(
+          omega, residual_capacity, sp_data, neighborhood, coordination_rho,
+          dual_options, latency, fairness,
+          force_memory_bids=(
+            (coordination_rho > 0).any()
+            and len(n_accepted_queue) >= n_accepted_queue.maxlen
+            and all(x == n_accepted_queue[0] for x in n_accepted_queue)
+          ),
+          ell=ell, r=sp_r,
+        )
+      )
+      rt = (datetime.now() - s).total_seconds()
+      total_runtime += (rt / n_active) if n_active else rt
+      rmp_omega = y.sum(axis=1)
+      allocation_changed = (np.abs(y_inc) > tolerance).any()
+      if allocation_changed:
+        y += y_inc
+        y[np.abs(y) < tolerance] = 0.0
+        rmp_omega = y.sum(axis=1)
+        fairness += (rmp_omega > tolerance)
+        n_accepted_queue.append(rmp_omega.sum())
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(
+            f"LSPr infeasible from fixed y assignments: {bad_nodes}"
+          )
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+```
+
+   (`additional_replicas` initialization to zeros is no longer needed — the round returns it.)
+4. `check_stopping_criteria` receives `None` in place of `bids` (as `decentralized_bestresponse.py` does), and after it add the same no-progress guard pattern:
+
+```python
+      if not stop_searching and not allocation_changed and not (
+          additional_replicas > tolerance
+        ).any():
+        stop_searching = True
+        why_stop_searching = "no dual progress"
+```
+
+5. Termination string gains the certificate (this is the spec's logging requirement):
+
+```python
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; gap: {gap_info['gap']:.6f}; "
+          f"LB: {gap_info['LB']:.6f}; UB: {gap_info['UB']:.6f}; "
+          f"inner: {gap_info['inner_iterations']}; "
+          f"best it: {best_it_so_far}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+```
+
+6. Output column: `pd.DataFrame(obj_dict["LSPr_final"], columns=["FaaS-MALD"])`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_dual_e2e.py` (mirror of `tests/test_powerd_e2e.py`; the config is identical except the options key):
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_dual import run as run_dual
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _dual_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "dual": {"alpha0": 1.0, "step_rule": "sqrt",
+               "max_inner_iterations": 30, "gap_tolerance": 0.01,
+               "latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_dual_runner_produces_expected_artifacts_with_gap(tmp_path):
+  _require_gurobi()
+  folder = run_dual(
+    _dual_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert len(obj) >= 1
+  assert "FaaS-MALD" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MALD"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert tc.iloc[:, -1].astype(str).str.contains("gap:").all()
+
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_dual_runner_is_reproducible_for_same_seed(tmp_path):
+  _require_gurobi()
+  folder_a = run_dual(
+    _dual_e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  folder_b = run_dual(
+    _dual_e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+
+  obj_a = pd.read_csv(Path(folder_a, "obj.csv"))["FaaS-MALD"].to_numpy()
+  obj_b = pd.read_csv(Path(folder_b, "obj.csv"))["FaaS-MALD"].to_numpy()
+
+  assert obj_a.shape[0] >= 1
+  assert obj_a.shape == obj_b.shape
+  assert np.allclose(obj_a, obj_b)
+
+
+def test_dual_defaults_applied_without_dual_options_key(tmp_path):
+  _require_gurobi()
+  config = _dual_e2e_config(tmp_path)
+  del config["solver_options"]["dual"]
+  folder = run_dual(config, parallelism=0, disable_plotting=True)
+  assert Path(folder, "obj.csv").exists()
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_dual_e2e.py -v`
+Expected: FAIL with `ImportError: cannot import name 'run'` (or SKIP if Gurobi missing — in that case verify the import error by `uv run python -c "from decentralized_dual import run"`).
+
+- [ ] **Step 3: Implement `run`, `parse_arguments`, `__main__`**
+
+Copy from `decentralized_diffusion.py` and apply deltas 1–6 above. The `__main__` block:
+
+```python
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(config, args.parallelism, disable_plotting=args.disable_plotting)
+```
+
+- [ ] **Step 4: Run the full new test suite**
+
+Run: `uv run pytest tests/test_dual_helpers.py tests/test_dual_e2e.py -v`
+Expected: all PASS (e2e SKIP only if Gurobi unavailable). Also run the sibling suites to prove nothing existing changed: `uv run pytest tests/test_diffusion_helpers.py tests/test_powerd_helpers.py -v` — all PASS, and `git status` shows only the two new files.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_dual.py tests/test_dual_e2e.py
+git commit -m "add FaaS-MALD runner and e2e tests"
+```
+
+---
+
+### Task 4: LaTeX technical note (`faas-mald-note/`)
+
+**Model:** gpt-5.4 (the `.gitignore` and compile check are gpt-5.4-mini-grade, but the note's math must match the shipped code, so keep one gpt-5.4 task)
+
+**Files:**
+- Create: `faas-mald-note/faas-mald.tex`, `faas-mald-note/main.tex`, `faas-mald-note/references.bib`, `faas-mald-note/README.md`, `faas-mald-note/.gitignore`
+
+**Interfaces:**
+- Consumes: the shipped `decentralized_dual.py` (Tasks 1–3) — the pseudocode and stated properties MUST match it; `faas-madig-note/` as the structural template (read `faas-madig-note/README.md`, `faas-madig-note/main.tex`, and `faas-madig-note/faas-madig.tex` first and follow their conventions exactly, including the fenced notation recap).
+- Produces: a compilable standalone note (`latexmk -pdf main.tex` in `faas-mald-note/`).
+
+- [ ] **Step 1: Read the template note**
+
+Read `faas-madig-note/README.md`, `faas-madig-note/main.tex`, `faas-madig-note/faas-madig.tex`, and `faas-madig-note/.gitignore`. Copy `main.tex` and `.gitignore` adapting only the input filename (`faas-mald`).
+
+- [ ] **Step 2: Write `faas-mald.tex`**
+
+A `\section{FaaS-MALD: Lagrangian-dual coordination with an optimality certificate}` in the notation and style of `Decentralized_FaaS_coordination.pdf`, mirroring faas-madig.tex's structure, with these mandatory subsections and content:
+
+1. *Self-contained notation recap* — fenced by `% BEGIN self-contained notation recap` / `% END ...` comments, reproducing the same table rows and capacity equations the MADiG note reproduces.
+2. *The coordination problem* — the transportation LP exactly as in the spec:
+
+```latex
+\begin{align}
+\max_{y \ge 0}\;& \sum_{i,f}\sum_{j \in N(i)} s_{ij}^{f}\, y_{ij}^{f} \\
+\text{s.t. }& \textstyle\sum_{j} y_{ij}^{f} \le \omega_i^f, \qquad
+             \textstyle\sum_{i} y_{ij}^{f} \le C_j^f,
+\end{align}
+```
+
+with $s_{ij}^f = \beta_{ij}^f - w_{\mathrm{lat}} L_{ij} - w_{\mathrm{fair}}\varphi_i^f$ and the eligibility filter $s_{ij}^f > -\gamma_i^f$.
+3. *Lagrangian relaxation and algorithm* — the dual function
+
+```latex
+\mathcal{L}(\lambda) = \sum_{j,f} \lambda_j^f C_j^f
+  + \sum_{i,f} \omega_i^f \max\Bigl(0, \max_{j \in N(i)} \bigl(s_{ij}^f - \lambda_j^f\bigr)\Bigr),
+```
+
+the closed-form buyer response, the projected subgradient update $\lambda \leftarrow [\lambda + \alpha_k (D - C)]^+$ with $\alpha_k = \alpha_0/\sqrt{k}$ (and the Polyak option), and primal recovery by greedy capacity fill of the price-ranked bids (cite that it reuses the MADiG evaluation mechanism). Include an `algorithm`/`algorithmic` float whose steps match `dual_coordination_round` one-to-one.
+4. *Properties* — (i) weak duality: every reported $(\mathrm{LB}, \mathrm{UB})$ pair is a valid per-timestep suboptimality certificate regardless of early stopping; (ii) with $\alpha_k = \alpha_0/\sqrt{k}$ the dual iterates converge to the dual optimum and, the LP having zero duality gap, $\mathrm{UB} \to$ LP optimum; (iii) per-iteration complexity $O(\sum_i |N(i)| \cdot |F|)$ buyer-side, $O(|N|\cdot|F|)$ seller-side, message complexity $O(|E|\cdot|F|)$, 1-hop only.
+5. *Positioning with respect to the literature* — dual decomposition and subgradient methods (Bertsekas; Nedić & Ozdaglar 2009 on primal recovery/averaging), auction algorithms (Bertsekas ε-auction, as the MADEA baseline), price-based offloading in edge computing. Every claim carries a `\citep{}` backed by `references.bib`.
+
+- [ ] **Step 3: Write `references.bib` and `README.md`**
+
+`references.bib`: real, verifiable entries for at least — Bertsekas *Nonlinear Programming* (or *Parallel and Distributed Computation*, Bertsekas & Tsitsiklis 1989); Nedić & Ozdaglar 2009 "Approximate primal solutions and rate analysis for dual subgradient methods" (SIAM J. Optim. 19(4)); Bertsekas 1988 auction algorithm (Annals of OR); at least one recent price-/market-based edge offloading survey or paper already cited by the sibling notes' `references.bib` (reuse entries from `faas-madig-note/references.bib` where applicable). `README.md`: same structure as `faas-madig-note/README.md`, adapted (deliverable file name, algorithm one-liner, compile instructions).
+
+- [ ] **Step 4: Compile check**
+
+Run: `cd faas-mald-note && latexmk -pdf main.tex && latexmk -c`
+Expected: `main.pdf` produced with no errors. If `latexmk` is not installed, run `command -v pdflatex` and use `pdflatex main.tex` twice + `bibtex main` if available; if no TeX toolchain exists on the machine, state that explicitly in the task report instead of claiming the note compiles.
+
+- [ ] **Step 5: Cross-check note vs code**
+
+Re-read `dual_coordination_round` and confirm the algorithm float matches it step-by-step (buyer response → UB update → primal recovery → LB update → gap test → subgradient step). Fix any mismatch in the note (never in the code).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add faas-mald-note/
+git commit -m "add FaaS-MALD technical note"
+```
+
+---
+
+## Self-Review (done at plan-writing time)
+
+- Spec coverage: coordination LP + dual loop (Tasks 1–2), certificate logging and runner/CLI/config defaults (Task 3), testing section (Tasks 1–3 tests), LaTeX note (Task 4), execution policy (Global Constraints + per-task Model lines), non-goals respected (no existing file modified, no remote_experiments integration). Benchmark comparison is explicitly out of scope in the spec.
+- No placeholders: every code step carries complete code; Task 3 defines its deltas against a file the implementer is instructed to copy verbatim first.
+- Type consistency: `dual_coordination_round` signature identical in Task 2 (definition), Task 2 tests (`run_round`), and Task 3 (call site); `gap_info` keys used in Task 3's termination string all produced in Task 2.
diff --git a/docs/superpowers/plans/2026-07-02-faas-mald-findings-remediation.md b/docs/superpowers/plans/2026-07-02-faas-mald-findings-remediation.md
new file mode 100644
index 0000000..ba7493d
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-02-faas-mald-findings-remediation.md
@@ -0,0 +1,835 @@
+# FaaS-MALD Findings Remediation Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make FaaS-MALD Cloud-consistent, prevent premature stopping after replica creation, expose auditable fixed-capacity certificates, and remove MALD-only dead paths and dense-graph overhead.
+
+**Architecture:** Keep the public runner and CLI unchanged. Inside MALD, optimize Cloud-relative advantage `beta - latency - fairness + gamma`, retain the primal assignment and price vector that produced the certificate, use outer memory bids as the sole replica mechanism, and record one certificate row per outer coordination iteration. Existing coordinators and shared helpers remain untouched.
+
+**Tech Stack:** Python 3.10, numpy, pandas, scipy, Pyomo/Gurobi for optional E2E tests, pytest, LaTeX/latexmk.
+
+---
+
+## Global Constraints
+
+- Modify only `decentralized_dual.py`, `tests/test_dual_helpers.py`, `tests/test_dual_e2e.py`, `faas-mald-note/faas-mald.tex`, and `faas-mald-note/README.md`.
+- Do not modify MADiG, MABR, MAPoD, MADEA, shared solver helpers, configs, or method registries.
+- Preserve unrelated dirty-worktree changes and stage only files named by each task.
+- Before editing each existing MALD symbol, run `gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests <symbol>` and report the blast radius. Current expected risk is MEDIUM for `buyer_price_response` and LOW for `dual_coordination_round`.
+- Before every commit, run the available GitNexus change-scope check. If the local CLI does not expose `detect_changes`, record that limitation and verify staged scope with `git diff --cached --name-only` and `git diff --cached --check`.
+- Follow 2-space indentation and existing repository import conventions.
+- Use TDD: write the failing test, observe the intended failure, implement the minimum fix, rerun the focused and neighboring suites.
+- Use `uv run pytest ...` from the repository root.
+- One logical commit per task with a short imperative subject.
+
+## File Responsibilities
+
+- `decentralized_dual.py`: Cloud-relative pair advantages, dual response/round, capacity-state refresh, runner, certificate CSV.
+- `tests/test_dual_helpers.py`: pure mathematical, validation, sparse traversal, retained-primal, and price-identity tests.
+- `tests/test_dual_e2e.py`: runner artifacts, replica lifecycle helper, reproducibility, defaults.
+- `faas-mald-note/faas-mald.tex`: equations, algorithm, certificate scope, complexity.
+- `faas-mald-note/README.md`: concise fixed-capacity certificate description and artifact list.
+
+---
+
+### Task 1: Cloud-relative advantage, option validation, and bound-producing prices
+
+**Files:**
+- Modify: `decentralized_dual.py:pair_scores`
+- Modify: `decentralized_dual.py:buyer_price_response`
+- Modify: `decentralized_dual.py:dual_coordination_round`
+- Test: `tests/test_dual_helpers.py`
+
+- [ ] **Step 1: Run impact analysis**
+
+Run:
+
+```bash
+gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests pair_scores
+gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests buyer_price_response
+gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests dual_coordination_round
+```
+
+Expected: only the MALD round, MALD runner, and MALD tests are affected; warn before editing if risk is HIGH or CRITICAL.
+
+- [ ] **Step 2: Add failing Cloud-relative regression tests**
+
+Append to `tests/test_dual_helpers.py`:
+
+```python
+def test_negative_node_score_better_than_cloud_is_selected():
+  data = make_data(Nn=2, Nf=1, gamma=0.10)
+  data[None]["beta"][(1, 2, 1)] = -0.05
+  neighborhood = full_neighborhood(2)
+  advantage, eligible = pair_scores(
+    data, neighborhood, np.zeros((2, 2)), np.zeros((2, 1)), DUAL_OPTIONS
+  )
+  bids, demand, buyer_term = buyer_price_response(
+    np.array([[1.0], [0.0]]), np.ones((2, 1)), np.zeros((2, 1)),
+    advantage, eligible,
+  )
+  assert eligible[0, 1, 0]
+  assert advantage[0, 1, 0] == pytest.approx(0.05)
+  assert bids.to_dict("records") == [
+    {"i": 0, "j": 1, "f": 0, "d": 1.0, "utility": 0.05}
+  ]
+  assert demand[1, 0] == 1.0
+  assert buyer_term == pytest.approx(0.05)
+
+
+def test_cloud_relative_filter_rejects_node_worse_than_cloud():
+  data = make_data(Nn=2, Nf=1, gamma=0.10)
+  data[None]["beta"][(1, 2, 1)] = -0.11
+  advantage, eligible = pair_scores(
+    data, full_neighborhood(2), np.zeros((2, 2)), np.zeros((2, 1)),
+    DUAL_OPTIONS,
+  )
+  assert not eligible[0, 1, 0]
+  assert advantage[0, 1, 0] == -np.inf
+```
+
+Add `import pytest` at the top of the test file.
+
+- [ ] **Step 3: Run the new tests to verify RED**
+
+Run:
+
+```bash
+uv run pytest \
+  tests/test_dual_helpers.py::test_negative_node_score_better_than_cloud_is_selected \
+  tests/test_dual_helpers.py::test_cloud_relative_filter_rejects_node_worse_than_cloud \
+  -v
+```
+
+Expected: the first test fails because the current score is `-0.05` and no bid is emitted.
+
+- [ ] **Step 4: Implement Cloud-relative pair advantage with sparse traversal**
+
+Replace `pair_scores` with:
+
+```python
+def pair_scores(
+  data: dict,
+  neighborhood: np.array,
+  latency: np.array,
+  fairness: np.array,
+  dual_options: dict,
+) -> Tuple[np.array, np.array]:
+  """Return Cloud-relative pair advantages and their eligibility mask."""
+  values = data[None]
+  nn = values["Nn"][None]
+  nf = values["Nf"][None]
+  advantages = np.full((nn, nn, nf), -np.inf)
+  eligible = np.zeros((nn, nn, nf), dtype=bool)
+  for i in range(nn):
+    for j in np.flatnonzero(neighborhood[i]):
+      j = int(j)
+      for f in range(nf):
+        advantage = (
+          values["beta"][(i + 1, j + 1, f + 1)]
+          - dual_options["latency_weight"] * latency[i, j]
+          - dual_options["fairness_weight"] * fairness[i, f]
+          + values["gamma"][(i + 1, f + 1)]
+        )
+        if advantage > 0:
+          advantages[i, j, f] = advantage
+          eligible[i, j, f] = True
+  return advantages, eligible
+```
+
+The returned quantity is now an advantage over Cloud, not the raw horizontal score. Keep the function name to avoid an unnecessary public rename.
+
+- [ ] **Step 5: Make buyer traversal sparse and deterministic**
+
+Inside `buyer_price_response`, replace dense adjusted-score construction with:
+
+```python
+    sellers = np.flatnonzero(elig[i, :, f])
+    if not len(sellers):
+      continue
+    adjusted = s[i, sellers, f] - lam[sellers, f]
+    positive = adjusted > 0
+    sellers = sellers[positive]
+    adjusted = adjusted[positive]
+    if not len(sellers):
+      continue
+    order = np.lexsort((sellers, -adjusted))
+    sellers = sellers[order]
+    adjusted = adjusted[order]
+    best = int(sellers[0])
+    demand[best, f] += omega[i, f]
+    dual_term += omega[i, f] * adjusted[0]
+
+    remaining = float(omega[i, f])
+    for j in sellers:
+      j = int(j)
+      quantity = min(remaining, float(capacity[j, f]))
+      if quantity > 0:
+        rows.append(
+          {"i": int(i), "j": j, "f": int(f), "d": quantity,
+           "utility": float(s[i, j, f])}
+        )
+        remaining -= quantity
+      if remaining <= 0:
+        break
+```
+
+Update the docstring to say that `s` contains Cloud-relative advantages.
+
+- [ ] **Step 6: Add failing option-validation and best-price tests**
+
+Append:
+
+```python
+@pytest.mark.parametrize(
+  ("overrides", "message"),
+  [
+    ({"alpha0": 0.0}, "alpha0"),
+    ({"alpha0": np.nan}, "alpha0"),
+    ({"theta": 0.0, "step_rule": "polyak"}, "theta"),
+    ({"theta": np.inf, "step_rule": "polyak"}, "theta"),
+    ({"gap_tolerance": -1.0}, "gap_tolerance"),
+    ({"gap_tolerance": np.nan}, "gap_tolerance"),
+    ({"latency_weight": np.inf}, "latency_weight"),
+    ({"fairness_weight": np.nan}, "fairness_weight"),
+  ],
+)
+def test_invalid_dual_numeric_options_are_rejected(overrides, message):
+  data, neighborhood, omega, capacity = dual_round_setup()
+  options = {**DUAL_ROUND_OPTIONS, **overrides}
+  with pytest.raises(ValueError, match=message):
+    run_round(data, neighborhood, omega, capacity, options)
+
+
+def test_best_lambda_reproduces_reported_upper_bound():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=19)
+  _, _, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  scores, eligible = pair_scores(
+    data, neighborhood, np.zeros_like(neighborhood), np.zeros_like(omega),
+    DUAL_ROUND_OPTIONS,
+  )
+  _, _, buyer_term = buyer_price_response(
+    omega, capacity, gap_info["best_lam"], scores, eligible
+  )
+  reproduced = float((gap_info["best_lam"] * capacity).sum() + buyer_term)
+  assert reproduced == pytest.approx(gap_info["UB"])
+```
+
+Task 2 later updates this unpacking when it simplifies the round return contract.
+
+- [ ] **Step 7: Run validation/price tests to verify RED**
+
+Run:
+
+```bash
+uv run pytest tests/test_dual_helpers.py \
+  -k "invalid_dual_numeric_options or best_lambda" -v
+```
+
+Expected: missing validation cases fail and `best_lam` raises `KeyError`.
+
+- [ ] **Step 8: Implement validation and retain the UB-producing lambda**
+
+At the start of `dual_coordination_round`, validate:
+
+```python
+  max_inner = dual_options["max_inner_iterations"]
+  if isinstance(max_inner, bool) or not isinstance(max_inner, (int, np.integer)):
+    raise ValueError("max_inner_iterations must be an integer")
+  if max_inner < 1:
+    raise ValueError("max_inner_iterations must be at least 1")
+  step_rule = dual_options["step_rule"]
+  if step_rule not in {"sqrt", "polyak"}:
+    raise ValueError("step_rule must be 'sqrt' or 'polyak'")
+  if not np.isfinite(dual_options["gap_tolerance"]) or (
+      dual_options["gap_tolerance"] < 0
+    ):
+    raise ValueError("gap_tolerance must be finite and non-negative")
+  for name in ("latency_weight", "fairness_weight"):
+    if not np.isfinite(dual_options[name]):
+      raise ValueError(f"{name} must be finite")
+  step_name = "alpha0" if step_rule == "sqrt" else "theta"
+  if not np.isfinite(dual_options[step_name]) or dual_options[step_name] <= 0:
+    raise ValueError(f"{step_name} must be finite and positive")
+```
+
+Initialize `best_lam = lam.copy()`. Replace direct UB minimization with:
+
+```python
+    current_ub = float((lam * capacity).sum() + buyer_term)
+    if current_ub < best_ub:
+      best_ub = current_ub
+      best_lam = lam.copy()
+```
+
+Expose both vectors explicitly:
+
+```python
+  gap_info = {
+    "LB": best_lb,
+    "UB": best_ub,
+    "gap": gap,
+    "inner_iterations": k,
+    "best_lam": best_lam,
+    "final_lam": lam,
+    "lb_history": lb_history,
+  }
+```
+
+- [ ] **Step 9: Update existing helper expectations and run Task 1 suite**
+
+Update the existing exact expectations:
+
+```python
+# test_pair_scores_masks_non_neighbors_and_dominated_pairs
+assert eligible[1, 0, 0] and scores[1, 0, 0] == pytest.approx(1.05)
+
+# test_buyer_response_zero_prices_picks_best_score_seller
+assert dual_term == pytest.approx(5.0 * 2.05)
+
+# test_buyer_response_price_shifts_demand
+assert dual_term == pytest.approx(5.0 * 1.05)
+```
+
+The tie-order assertion remains `[1, 2]`. The LP oracle needs no structural
+change because it already consumes the array returned by `pair_scores`; after
+this task that array contains Cloud-relative advantages.
+
+Run:
+
+```bash
+uv run pytest tests/test_dual_helpers.py -v
+```
+
+Expected: all helper tests pass.
+
+- [ ] **Step 10: Commit Task 1**
+
+Run the required scope checks, then:
+
+```bash
+git add decentralized_dual.py tests/test_dual_helpers.py
+git commit -m "align FaaS-MALD rewards with Cloud rejection"
+```
+
+---
+
+### Task 2: Retain the best primal assignment and remove dead round paths
+
+**Files:**
+- Modify: `decentralized_dual.py:dual_coordination_round`
+- Modify: `tests/test_dual_helpers.py`
+
+- [ ] **Step 1: Run impact analysis**
+
+```bash
+gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests dual_coordination_round
+```
+
+- [ ] **Step 2: Add a failing retained-assignment test**
+
+Use `monkeypatch` to count evaluator calls:
+
+```python
+def test_round_returns_retained_best_y_without_post_loop_reevaluation(monkeypatch):
+  data, neighborhood, omega, capacity = dual_round_setup(seed=23)
+  calls = 0
+  original = decentralized_dual.evaluate_assignments
+
+  def counted(*args, **kwargs):
+    nonlocal calls
+    calls += 1
+    return original(*args, **kwargs)
+
+  monkeypatch.setattr(decentralized_dual, "evaluate_assignments", counted)
+  options = {**DUAL_ROUND_OPTIONS, "max_inner_iterations": 7,
+             "gap_tolerance": 0.0}
+  y_inc, _, _, gap_info, _ = run_round(
+    data, neighborhood, omega, capacity, options
+  )
+  assert calls == gap_info["inner_iterations"]
+  assert y_inc.sum() >= 0
+```
+
+Add `import decentralized_dual` to the test file.
+
+- [ ] **Step 3: Verify RED**
+
+```bash
+uv run pytest \
+  tests/test_dual_helpers.py::test_round_returns_retained_best_y_without_post_loop_reevaluation \
+  -v
+```
+
+Expected: evaluator calls exceed `gap_info["inner_iterations"]` because the current round re-evaluates the best bids after the loop.
+
+- [ ] **Step 4: Simplify the round state and return contract**
+
+Change the signature to remove `force_memory_bids`, `ell`, and `r`:
+
+```python
+def dual_coordination_round(
+  omega: np.array,
+  residual_capacity: np.array,
+  data: dict,
+  neighborhood: np.array,
+  rho: np.array,
+  dual_options: dict,
+  latency: np.array,
+  fairness: np.array,
+) -> Tuple[np.array, pd.DataFrame, dict, int]:
+```
+
+Initialize:
+
+```python
+  best_y = np.zeros((nn, nn, nf))
+```
+
+When LB improves:
+
+```python
+      if candidate_lb > best_lb:
+        best_lb = candidate_lb
+        best_y = candidate_y.copy()
+```
+
+Delete `best_bids`, the post-loop evaluator calls, tentative replica handling, and `additional_replicas`. Build memory bids from `best_y`:
+
+```python
+  memory_rows = []
+  placed = best_y.sum(axis=1)
+  for i, f in zip(*np.nonzero(omega > 0)):
+    i, f = int(i), int(f)
+    if placed[i, f] + 1e-12 >= omega[i, f]:
+      continue
+    memory_requirement = data[None]["memory_requirement"][f + 1]
+    for j in np.flatnonzero(neighborhood[i]):
+      j = int(j)
+      if rho[j] >= memory_requirement:
+        memory_rows.append({"i": i, "j": j, "f": f})
+  memory_bids = pd.DataFrame(memory_rows, columns=["i", "j", "f"])
+  return best_y, memory_bids, gap_info, n_active
+```
+
+- [ ] **Step 5: Update helper calls and tests**
+
+Update `run_round`:
+
+```python
+  return dual_coordination_round(
+    omega, capacity, data, neighborhood,
+    rho=np.zeros(Nn), dual_options=options or DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)), fairness=np.zeros((Nn, Nf)),
+  )
+```
+
+Update all unpacking from five values to four:
+
+```python
+y_inc, memory_bids, gap_info, n_active = run_round(...)
+```
+
+Update the retained-assignment test introduced in Step 2 to:
+
+```python
+  y_inc, _, gap_info, _ = run_round(
+    data, neighborhood, omega, capacity, options
+  )
+```
+
+Update the Task 1 best-price test to:
+
+```python
+  _, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+```
+
+Replace the old forced-memory test with:
+
+```python
+def test_memory_bids_are_emitted_only_for_unplaced_demand():
+  Nn, Nf = 2, 1
+  data = make_data(Nn, Nf)
+  neighborhood = full_neighborhood(Nn)
+  rho = np.array([0.0, 2.0])
+  common = dict(
+    data=data, neighborhood=neighborhood, rho=rho,
+    dual_options=DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)), fairness=np.zeros((Nn, Nf)),
+  )
+  full = dual_coordination_round(
+    omega=np.array([[1.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [1.0]]), **common,
+  )[1]
+  short = dual_coordination_round(
+    omega=np.array([[2.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [1.0]]), **common,
+  )[1]
+  assert full.empty
+  assert short.to_dict("records") == [{"i": 0, "j": 1, "f": 0}]
+```
+
+- [ ] **Step 6: Run helper and sibling tests**
+
+```bash
+uv run pytest tests/test_dual_helpers.py tests/test_diffusion_helpers.py -v
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 7: Commit Task 2**
+
+```bash
+git add decentralized_dual.py tests/test_dual_helpers.py
+git commit -m "simplify FaaS-MALD dual recovery"
+```
+
+---
+
+### Task 3: Repair replica lifecycle and write per-round certificates
+
+**Files:**
+- Modify: `decentralized_dual.py:run`
+- Modify: `tests/test_dual_e2e.py`
+
+- [ ] **Step 1: Run impact analysis**
+
+```bash
+gitnexus context -r DFaaSOptimizer -f decentralized_dual.py run
+gitnexus impact -r DFaaSOptimizer -d upstream --depth 3 --include-tests \
+  Function:decentralized_dual.py:run
+```
+
+- [ ] **Step 2: Add a pure capacity-state helper and failing lifecycle test**
+
+Add the test first:
+
+```python
+from decentralized_dual import _capacity_state
+
+
+def test_capacity_state_reflects_newly_started_replicas():
+  data = {None: {
+    "Nn": {None: 1}, "Nf": {None: 1},
+    "max_utilization": {1: 0.8}, "demand": {(1, 1): 1.0},
+  }}
+  x = np.zeros((1, 1))
+  y = np.zeros((1, 1, 1))
+  before = _capacity_state(x, y, np.zeros((1, 1)), data)
+  after = _capacity_state(x, y, np.ones((1, 1)), data)
+  assert before[3][0, 0] == 0.0
+  assert after[3][0, 0] == pytest.approx(0.8)
+```
+
+- [ ] **Step 3: Verify RED**
+
+```bash
+uv run pytest \
+  tests/test_dual_e2e.py::test_capacity_state_reflects_newly_started_replicas \
+  -v
+```
+
+Expected: import fails because `_capacity_state` does not exist.
+
+- [ ] **Step 4: Implement and use `_capacity_state`**
+
+Add before `run`:
+
+```python
+def _capacity_state(
+  sp_x: np.array,
+  y: np.array,
+  sp_r: np.array,
+  sp_data: dict,
+) -> Tuple[np.array, np.array, np.array, np.array]:
+  capacity, residual_capacity, ell = compute_residual_capacity(
+    sp_x, y, sp_r, sp_data
+  )
+  blackboard = np.maximum(0.0, capacity - sp_x)
+  return capacity, residual_capacity, ell, blackboard
+```
+
+Use it at the top of each outer coordination iteration. After `sp_r += additional_replicas`, call it again when any increment exceeds tolerance:
+
+```python
+      if len(memory_bids) > 0:
+        s = datetime.now()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho
+        )
+        sp_r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+        if (additional_replicas > tolerance).any():
+          capacity, residual_capacity, ell, blackboard = _capacity_state(
+            sp_x, y, sp_r, sp_data
+          )
+```
+
+- [ ] **Step 5: Adapt the round call and remove dead runner state**
+
+Remove `deque` import, `n_accepted_queue`, and the forced-memory expression. Call:
+
+```python
+      y_inc, memory_bids, gap_info, n_active = dual_coordination_round(
+        omega, residual_capacity, sp_data, neighborhood, coordination_rho,
+        dual_options, latency, fairness,
+      )
+      additional_replicas = np.zeros((Nn, Nf))
+```
+
+Keep the no-progress guard after memory-bid processing so a positive replica increment keeps the loop alive.
+
+- [ ] **Step 6: Add certificate-row collection**
+
+Initialize before the timestep loop:
+
+```python
+  certificate_rows = []
+```
+
+After shared stopping criteria and the no-progress guard determine the reason, append:
+
+```python
+      certificate_rows.append({
+        "timestep": t,
+        "outer_iteration": it,
+        "LB": gap_info["LB"],
+        "UB": gap_info["UB"],
+        "gap": gap_info["gap"],
+        "inner_iterations": gap_info["inner_iterations"],
+        "stop_reason": why_stop_searching if stop_searching else "",
+      })
+```
+
+At output time:
+
+```python
+  pd.DataFrame(
+    certificate_rows,
+    columns=[
+      "timestep", "outer_iteration", "LB", "UB", "gap",
+      "inner_iterations", "stop_reason",
+    ],
+  ).to_csv(
+    os.path.join(solution_folder, "coordination_certificate.csv"), index=False
+  )
+```
+
+Change termination wording to `fixed-C gap`, `fixed-C LB`, and `fixed-C UB`.
+
+- [ ] **Step 7: Extend E2E artifact assertions**
+
+In `test_dual_runner_produces_expected_artifacts_with_gap`, add:
+
+```python
+  certificate = pd.read_csv(Path(folder, "coordination_certificate.csv"))
+  assert list(certificate.columns) == [
+    "timestep", "outer_iteration", "LB", "UB", "gap",
+    "inner_iterations", "stop_reason",
+  ]
+  assert len(certificate) >= 1
+  assert (certificate["UB"] + 1e-8 >= certificate["LB"]).all()
+  assert (certificate["gap"] >= -1e-8).all()
+  assert tc.iloc[:, -1].astype(str).str.contains("fixed-C gap:").all()
+```
+
+Extend reproducibility to compare stable certificate columns excluding runtime and free-form stop text:
+
+```python
+  cert_columns = ["timestep", "outer_iteration", "LB", "UB", "gap",
+                  "inner_iterations"]
+  cert_a = pd.read_csv(Path(folder_a, "coordination_certificate.csv"))
+  cert_b = pd.read_csv(Path(folder_b, "coordination_certificate.csv"))
+  pd.testing.assert_frame_equal(cert_a[cert_columns], cert_b[cert_columns])
+```
+
+- [ ] **Step 8: Run runner and sibling suites**
+
+```bash
+uv run pytest \
+  tests/test_dual_helpers.py tests/test_dual_e2e.py \
+  tests/test_diffusion_helpers.py tests/test_powerd_helpers.py \
+  -v
+uv run python decentralized_dual.py --help
+```
+
+Expected: all tests pass; Gurobi E2E skips only when Gurobi is unavailable; CLI exits zero.
+
+- [ ] **Step 9: Commit Task 3**
+
+```bash
+git add decentralized_dual.py tests/test_dual_e2e.py
+git commit -m "repair FaaS-MALD replica lifecycle and certificates"
+```
+
+---
+
+### Task 4: Align the technical note and README
+
+**Files:**
+- Modify: `faas-mald-note/faas-mald.tex`
+- Modify: `faas-mald-note/README.md`
+
+- [ ] **Step 1: Update the mathematical formulation**
+
+Define:
+
+```latex
+a_{ij}^f = s_{ij}^f + \gamma_i^f
+  = \beta_{ij}^f - w_{\mathrm{lat}}L_{ij}
+    - w_{\mathrm{fair}}\phi_i^f + \gamma_i^f .
+```
+
+State that Cloud is the zero incremental baseline and eligibility is
+`a_{ij}^f > 0`, equivalent to `s_{ij}^f > -\gamma_i^f`.
+
+Replace the LP objective and dual buyer term with `a`:
+
+```latex
+\max_{y\geq0}\ \sum_{i,j,f} a_{ij}^f y_{ij}^f
+```
+
+```latex
+g(\lambda)=\sum_{j,f}\lambda_j^fC_j^f+
+\sum_{i,f}\omega_i^f\max\!\left\{0,
+\max_j(a_{ij}^f-\lambda_j^f)\right\}.
+```
+
+- [ ] **Step 2: Update algorithm and certificate artifacts**
+
+The pseudocode must show:
+
+- validation of numeric options;
+- sparse neighbor/eligible traversal;
+- `best_y`, `best_lam`, and `final_lam`;
+- no tentative replicas;
+- no forced-memory branch;
+- return `(best_y, memory_bids, gap_info, n_active)`;
+- outer memory bids as the only replica mechanism;
+- capacity refresh before stopping;
+- `coordination_certificate.csv` as one row per outer iteration.
+
+Retain the warning that the certificate covers only the fixed-capacity inner LP.
+
+- [ ] **Step 3: Update complexity and README wording**
+
+State score evaluation as `O(|E| |F|)` and buyer ranking as
+`O(sum_{i,f} |A_i^f| log |A_i^f|)`. Do not claim that the practical gap-based
+`polyak` option has classical Polyak convergence guarantees.
+
+Change the README introduction to:
+
+```markdown
+A focused, paper-ready LaTeX section describing FaaS-MALD and its
+fixed-residual-capacity transportation-LP certificate.
+```
+
+Add `coordination_certificate.csv` to the listed runtime artifacts.
+
+- [ ] **Step 4: Compile and visually verify**
+
+Run:
+
+```bash
+cd faas-mald-note
+latexmk -C main.tex
+latexmk -pdf main.tex
+pdftoppm -png main.pdf /tmp/faas-mald-remediation
+```
+
+Check `main.log` for undefined references, undefined citations, duplicate destinations, and overfull boxes. Inspect every rendered PNG for clipping, overlap, malformed equations, and unreadable algorithm lines. Run `latexmk -c main.tex` after inspection.
+
+Expected: PDF compiles; no undefined references/citations or overfull boxes; visual inspection passes.
+
+- [ ] **Step 5: Cross-check note against code**
+
+Read `pair_scores`, `buyer_price_response`, `dual_coordination_round`, and the MALD runner loop line-by-line. Confirm that reward, thresholds, state, return values, replica lifecycle, certificate fields, and complexity match the note. Fix the note, never the validated code, for documentation-only discrepancies.
+
+- [ ] **Step 6: Commit Task 4**
+
+```bash
+git add faas-mald-note/faas-mald.tex faas-mald-note/README.md
+git commit -m "align FaaS-MALD note with remediated algorithm"
+```
+
+---
+
+### Task 5: Final scope and regression verification
+
+**Files:**
+- Verify only; no planned source modifications.
+
+- [ ] **Step 1: Verify changed scope with GitNexus and Git**
+
+Run the available GitNexus change detector. Then run:
+
+```bash
+git diff --check
+git diff --name-only b4d1848..HEAD
+```
+
+Expected changed implementation paths:
+
+```text
+decentralized_dual.py
+tests/test_dual_helpers.py
+tests/test_dual_e2e.py
+faas-mald-note/faas-mald.tex
+faas-mald-note/README.md
+```
+
+No unrelated user changes may be staged or committed.
+
+- [ ] **Step 2: Run MALD and sibling verification**
+
+```bash
+uv run pytest \
+  tests/test_dual_helpers.py tests/test_dual_e2e.py \
+  tests/test_diffusion_helpers.py tests/test_diffusion_e2e.py \
+  tests/test_powerd_helpers.py tests/test_powerd_e2e.py \
+  -v
+```
+
+Expected: all available tests pass; solver-dependent tests skip only when their solver is unavailable.
+
+- [ ] **Step 3: Run the complete repository suite**
+
+```bash
+uv run pytest -v
+```
+
+Expected: zero failures. Record exact passed/skipped counts and warnings.
+
+- [ ] **Step 4: Final mathematical audit**
+
+Confirm with the SciPy oracle tests that:
+
+```text
+LB <= LP optimum <= UB
+```
+
+Confirm the oracle objective, buyer response, primal LB, dual UB, and LaTeX note all use the same Cloud-relative advantage `s + gamma`.
+
+- [ ] **Step 5: Final code review**
+
+Request one independent final review of commits created by Tasks 1-4. The reviewer must check:
+
+- Cloud decision parity with sibling algorithms;
+- stale-blackboard regression;
+- certificate/price identity;
+- absence of tentative/forced-memory dead paths;
+- sparse traversal;
+- runner/CLI compatibility;
+- note/code agreement.
+
+Resolve every Critical or Important finding and rerun affected tests before completion.
+
+---
+
+## Self-Review
+
+- Spec coverage: every requirement in `docs/superpowers/specs/2026-07-02-faas-mald-findings-remediation-design.md` maps to Tasks 1-4; Task 5 verifies the combined result.
+- Scope: no existing coordinator or shared helper is modified; common-runner extraction remains out of scope.
+- Type consistency: the final round return is consistently `(np.array, pd.DataFrame, dict, int)` in implementation, runner, tests, and note.
+- Certificate consistency: advantage, LB, UB, oracle, `best_lam`, CSV, and note use the same fixed-capacity LP.
+- Placeholder scan: no deferred steps or unspecified error handling remain.
diff --git a/docs/superpowers/plans/2026-07-02-faas-mapg.md b/docs/superpowers/plans/2026-07-02-faas-mapg.md
new file mode 100644
index 0000000..cbbbe56
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-02-faas-mapg.md
@@ -0,0 +1,1275 @@
+# FaaS-MAPG Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Implement FaaS-MAPG, a potential-game decentralized algorithm for DiFRALB with ε-Nash termination certificate and monotone social welfare.
+
+**Architecture:** New module `decentralized_potentialgame.py` mirroring `decentralized_bestresponse.py`'s outer structure; node moves are better-responses (MILP proposal via new Pyomo model `LSP_pg` + exact β-aware split + ε-acceptance on true utility). Potential Φ = `compute_centralized_objective`. Seller capacity grows only through the reused MADeA memory market.
+
+**Tech Stack:** Python 3.10, numpy, pandas, Pyomo (+ gurobi in tests, with skip guard), pytest.
+
+## Global Constraints
+
+- **NEVER modify any existing function, method, or class.** Only add new ones. `models/sp.py` may only gain new classes appended at the end; `run.py` may only gain additive lines (imports, dict entries, argparse choice items, one dispatch block per variant).
+- Follow repo style: 2-space indentation, same import grouping as `decentralized_bestresponse.py`.
+- Spec: `docs/superpowers/specs/2026-07-02-faas-mapg-design.md`.
+- Model assignment for subagents: Tasks 1–5 and 7 → **sonnet**; Task 6 → **haiku**.
+- All tests live under `tests/`, run with `uv run pytest`. Solver-dependent tests use the `_require_gurobi()` skip guard pattern from `tests/test_bestresponse_e2e.py`.
+- Utility/potential convention: `z` is always derived as `z[i,f] = load[i,f] − x[i,f] − Σ_j y[i,j,f]` (same convention as `combine_solutions`).
+
+---
+
+### Task 1: Pyomo models `LSP_pg` and `LSP_pg_fixedr` [sonnet]
+
+**Files:**
+- Modify: `models/sp.py` (append two classes at end of file — do not touch existing classes)
+- Test: `tests/test_potentialgame_model.py` (new)
+
+**Interfaces:**
+- Produces: `models.sp.LSP_pg` and `models.sp.LSP_pg_fixedr`, both instantiable with no args, usable through `run_faasmacro.solve_subproblem(node_data, [node], model, solver_name, opts, parallelism)`. New data keys consumed: `data[None]["y_bar"][(m, i, f)]` (committed inbound, 1-based, default 0.0) and `data[None]["omega_ub"][f]` (per-function offload cap, 1-based, default 1e9). `LSP_pg_fixedr` additionally consumes `data[None]["r_bar"][(i, f)]`.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_potentialgame_model.py
+import pyomo.environ as pyo
+import pytest
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _tiny_pg_data():
+  # 2 nodes, 1 function. Node 1 is the mover; node 2 exists only as index.
+  # demand=1.0, U_max=0.8 -> each replica serves 0.8 req/s.
+  return {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "whoami": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 4.0},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+    "delta": {(1, 1): 0.2, (2, 1): 0.2},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "pi": {1: 0.0},
+    # node 2 has committed 2.4 req/s of inbound traffic onto node 1
+    "y_bar": {(2, 1, 1): 2.4},
+    "omega_ub": {1: 1.0},
+  }}
+
+
+def test_lsp_pg_respects_inbound_commitments_and_cap():
+  _require_gurobi()
+  from models.sp import LSP_pg
+  model = LSP_pg()
+  instance = model.generate_instance(_tiny_pg_data())
+  sol = model.solve(instance, {"OutputFlag": 0}, "gurobi")
+  assert sol["solution_exists"]
+  r = sol["r"][0]
+  x = sol["x"][0]
+  omega = sol["omega"][0]
+  # replicas must cover local load PLUS the 2.4 committed inbound
+  assert 1.0 * (x + 2.4) <= r * 0.8 + 1e-6
+  # offloading capped by omega_ub
+  assert omega <= 1.0 + 1e-6
+  # flow conservation: x + omega + z == load
+  z = sol["z"][0]
+  assert abs(x + omega + z - 4.0) <= 1e-6
+
+
+def test_lsp_pg_fixedr_pins_replicas():
+  _require_gurobi()
+  from models.sp import LSP_pg_fixedr
+  data = _tiny_pg_data()
+  data[None]["r_bar"] = {(1, 1): 6, (2, 1): 0}
+  model = LSP_pg_fixedr()
+  instance = model.generate_instance(data)
+  sol = model.solve(instance, {"OutputFlag": 0}, "gurobi")
+  assert sol["solution_exists"]
+  assert abs(sol["r"][0] - 6) <= 1e-6
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_potentialgame_model.py -v`
+Expected: FAIL (or ERROR) with `ImportError: cannot import name 'LSP_pg'`
+
+- [ ] **Step 3: Append the two classes to `models/sp.py`**
+
+```python
+##############################################################################
+# POTENTIAL GAME (FaaS-MAPG node proposal model)
+##############################################################################
+
+class LSP_pg(LSP):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_pg"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # committed inbound offloading (other players' strategies, fixed)
+    self.model.y_bar = pyo.Param(
+      self.model.N, self.model.N, self.model.F,
+      within = PYO_PARAM_TYPE, default = 0.0
+    )
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    # replicas must also cover committed inbound flows (LSPr-style)
+    self.model.del_component(self.model.utilization_equilibrium)
+    self.model.del_component(self.model.utilization_equilibrium2)
+    self.model.utilization_equilibrium = pyo.Constraint(
+      self.model.F, rule = self.utilization_equilibrium_pg
+    )
+    self.model.utilization_equilibrium2 = pyo.Constraint(
+      self.model.F, rule = self.utilization_equilibrium2_pg
+    )
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def utilization_equilibrium_pg(model, f):
+    return (
+      model.demand[model.whoami,f] * (
+        model.x[f] + sum(model.y_bar[m,model.whoami,f] for m in model.N)
+      ) <= model.r[f] * model.max_utilization[f]
+    )
+
+  @staticmethod
+  def utilization_equilibrium2_pg(model, f):
+    return (
+      model.demand[model.whoami,f] * (
+        model.x[f] + sum(model.y_bar[m,model.whoami,f] for m in model.N)
+      ) >= (model.r[f] - 1) * model.max_utilization[f]
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+
+
+class LSP_pg_fixedr(LSP_pg):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_pg_fixedr"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # number of assigned replicas
+    self.model.r_bar = pyo.Param(
+      self.model.N, self.model.F,
+      within = pyo.NonNegativeIntegers, default = 0
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.fix_r = pyo.Constraint(
+      self.model.F, rule = self.fix_r
+    )
+    # with r pinned the replica lower bound may conflict with commitments
+    # (same reasoning as LSP_fixedr)
+    self.model.del_component(self.model.utilization_equilibrium2)
+
+  @staticmethod
+  def fix_r(model, f):
+    return model.r[f] == model.r_bar[model.whoami,f]
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_potentialgame_model.py -v`
+Expected: 2 PASS (or 2 SKIP if gurobi missing — in that case verify import works: `uv run python -c "from models.sp import LSP_pg, LSP_pg_fixedr; LSP_pg(); LSP_pg_fixedr()"`)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add models/sp.py tests/test_potentialgame_model.py
+git commit -m "add LSP_pg models for FaaS-MAPG node proposals"
+```
+
+---
+
+### Task 2: Utility and split helpers [sonnet]
+
+**Files:**
+- Create: `decentralized_potentialgame.py`
+- Test: `tests/test_potentialgame_helpers.py` (new)
+
+**Interfaces:**
+- Consumes: `utils.faasmacro.compute_centralized_objective(sp_data, x, y, z) -> float`
+- Produces (in `decentralized_potentialgame.py`):
+  - `compute_z(x: np.array (Nn,Nf), y: np.array (Nn,Nn,Nf), sp_data) -> np.array (Nn,Nf)`
+  - `compute_node_utility(i: int, x, y, z, sp_data) -> float`
+  - `split_omega(i: int, omega_row: np.array (Nf,), ledger: np.array (Nn,Nf), neighbours: set[int], sp_data) -> np.array (Nn,Nf)` — **mutates `ledger` in place**, returns node i's new outbound row. Eligibility: `j ∈ neighbours`, `beta[(i+1,j+1,f+1)] > -gamma[(i+1,f+1)]`, `ledger[j,f] > 0`. Fill descending β, ties ascending j.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_potentialgame_helpers.py
+import numpy as np
+
+from decentralized_potentialgame import (
+  compute_node_utility,
+  compute_z,
+  split_omega,
+)
+from utils.faasmacro import compute_centralized_objective
+
+
+def _data_3n_1f():
+  # 3 nodes, 1 function; node 0 offloads, nodes 1-2 are sellers
+  return {None: {
+    "Nn": {None: 3},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 4.0, (3, 1): 4.0},
+    "demand": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100, 3: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "delta": {(i, 1): 0.2 for i in (1, 2, 3)},
+    "gamma": {(i, 1): 0.1 for i in (1, 2, 3)},
+    "beta": {
+      (1, 2, 1): 2.0, (1, 3, 1): 1.5,
+      (2, 1, 1): 1.0, (2, 3, 1): 1.0,
+      (3, 1, 1): 1.0, (3, 2, 1): 1.0,
+    },
+  }}
+
+
+def test_split_omega_prefers_higher_beta_and_respects_ledger():
+  data = _data_3n_1f()
+  ledger = np.array([[0.0], [1.5], [10.0]])
+  row = split_omega(0, np.array([4.0]), ledger, {1, 2}, data)
+  # 1.5 to node 1 (beta 2.0, capped by ledger), remaining 2.5 to node 2
+  assert np.isclose(row[1, 0], 1.5)
+  assert np.isclose(row[2, 0], 2.5)
+  # ledger consumed in place
+  assert np.isclose(ledger[1, 0], 0.0)
+  assert np.isclose(ledger[2, 0], 7.5)
+
+
+def test_split_omega_skips_inconvenient_sellers():
+  data = _data_3n_1f()
+  data[None]["beta"][(1, 2, 1)] = -0.2  # below -gamma = -0.1: worse than Cloud
+  ledger = np.array([[0.0], [10.0], [10.0]])
+  row = split_omega(0, np.array([4.0]), ledger, {1, 2}, data)
+  assert np.isclose(row[1, 0], 0.0)
+  assert np.isclose(row[2, 0], 4.0)
+
+
+def test_node_utilities_sum_to_potential():
+  data = _data_3n_1f()
+  x = np.array([[2.0], [4.0], [4.0]])
+  y = np.zeros((3, 3, 1))
+  y[0, 1, 0] = 1.0
+  z = compute_z(x, y, data)
+  assert np.isclose(z[0, 0], 1.0)  # 4 - 2 - 1
+  phi = compute_centralized_objective(data, x, y, z)
+  total = sum(compute_node_utility(i, x, y, z, data) for i in range(3))
+  assert np.isclose(total, phi)
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_potentialgame_helpers.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'decentralized_potentialgame'`
+
+- [ ] **Step 3: Create `decentralized_potentialgame.py` with the helpers**
+
+```python
+from run_centralized_model import (
+  encode_solution,
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from postprocessing import load_solution
+from run_faasmacro import (
+  combine_solutions,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  compute_residual_capacity,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSP_fixedr, LSP_pg, LSP_pg_fixedr
+
+from datetime import datetime
+from copy import deepcopy
+from typing import Callable, Tuple
+import pandas as pd
+import numpy as np
+import argparse
+import json
+import sys
+import os
+
+
+def compute_z(x: np.array, y: np.array, sp_data: dict) -> np.array:
+  """Cloud-forwarded load derived from flow conservation (same convention as
+  combine_solutions): z = load - x - outbound."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  z = np.zeros((Nn, Nf))
+  for n in range(Nn):
+    for f in range(Nf):
+      load = sp_data[None]["incoming_load"][(n + 1, f + 1)]
+      z[n, f] = max(0.0, load - x[n, f] - y[n, :, f].sum())
+  return z
+
+
+def compute_node_utility(
+    i: int, x: np.array, y: np.array, z: np.array, sp_data: dict
+  ) -> float:
+  """Node i's share of the centralized objective. Summing over all nodes
+  yields exactly compute_centralized_objective (the exact potential)."""
+  xm = np.zeros_like(x)
+  ym = np.zeros_like(y)
+  zm = np.zeros_like(z)
+  xm[i, :] = x[i, :]
+  ym[i, :, :] = y[i, :, :]
+  zm[i, :] = z[i, :]
+  return compute_centralized_objective(sp_data, xm, ym, zm)
+
+
+def split_omega(
+    i: int,
+    omega_row: np.array,
+    ledger: np.array,
+    neighbours: set,
+    sp_data: dict,
+  ) -> np.array:
+  """Fractional-knapsack split of node i's proposed offload across eligible
+  sellers by descending beta (exact best response for the linear utility).
+  Mutates ledger in place; unplaced residual is left to the Cloud (z)."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  new_row = np.zeros((Nn, Nf))
+  for f in range(Nf):
+    if omega_row[f] <= 0:
+      continue
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    score = {}
+    for j in neighbours:
+      b = sp_data[None]["beta"][(i + 1, j + 1, f + 1)]
+      if b > -gamma_if and ledger[j, f] > 0:
+        score[j] = b
+    placed = 0.0
+    for j in sorted(score, key=lambda k: (-score[k], k)):
+      if placed >= omega_row[f]:
+        break
+      q = min(ledger[j, f], omega_row[f] - placed)
+      if q <= 0:
+        continue
+      new_row[j, f] += q
+      ledger[j, f] -= q
+      placed += q
+  return new_row
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_potentialgame_helpers.py -v`
+Expected: 3 PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_potentialgame.py tests/test_potentialgame_helpers.py
+git commit -m "add FaaS-MAPG utility and split helpers"
+```
+
+---
+
+### Task 3: `node_move`, `potential_game_sweep`, proposal and stopping [sonnet]
+
+**Files:**
+- Modify: `decentralized_potentialgame.py` (append functions)
+- Test: `tests/test_potentialgame_sweep.py` (new)
+
+**Interfaces:**
+- Consumes: Task 2 helpers; `run_faasmadea.compute_residual_capacity(x, y, r, data) -> (cap, residual, ell)`; `run_faasmacro.solve_subproblem`; `models.sp.LSP_pg` (data keys `y_bar`, `omega_ub` from Task 1).
+- Produces:
+  - `propose_node_move(node, omega_ub_row, y, sp_data, model, solver_name, general_solver_options, parallelism) -> (x_row, r_row, omega_row, runtime)` (rows are `np.array (Nf,)`)
+  - `node_move(i, x, y, r, sp_data, neighborhood, rho, epsilon, propose_fn, tolerance) -> (accepted: bool, delta_u: float, memory_bids: dict, runtime: float)` — mutates `x`, `y`, `r` in place iff accepted. `propose_fn(i, omega_ub_row) -> (x_row, r_row, omega_row, runtime)`. `memory_bids` is `{"i": [...], "j": [...], "f": [...]}` (0-based).
+  - `potential_game_sweep(x, y, r, sp_data, neighborhood, rho, epsilon, tolerance, order, rng, propose_fn) -> (n_accepted: int, delta_phi: float, memory_bids: pd.DataFrame, proposal_runtime: float)`
+  - `check_pg_stopping(it, max_iterations, n_accepted, n_new_replicas, total_runtime, time_limit) -> (bool, str)` — reasons: `"epsilon-Nash equilibrium certified"`, `"max iterations reached"`, `"reached time limit: ..."`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+# tests/test_potentialgame_sweep.py
+import numpy as np
+import pytest
+
+from decentralized_potentialgame import (
+  check_pg_stopping,
+  compute_z,
+  node_move,
+  potential_game_sweep,
+)
+from run_faasmadea import compute_residual_capacity
+from utils.faasmacro import compute_centralized_objective
+
+
+def _data_2n_1f():
+  # node 0: load 4, initially served locally (r=5 -> cap 4.0)
+  # node 1: load 0-ish, big idle capacity (r=10 -> cap 8.0)
+  # beta(0->1)=2.0 > alpha=1.0: offloading everything is the improving move
+  return {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 0.001},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+    "delta": {(1, 1): 0.2, (2, 1): 0.2},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "beta": {(1, 2, 1): 2.0, (2, 1, 1): 0.5},
+    "neighborhood": {(1, 2): 1, (2, 1): 1},
+  }}
+
+
+def _state():
+  x = np.array([[4.0], [0.001]])
+  y = np.zeros((2, 2, 1))
+  r = np.array([[5.0], [10.0]])
+  return x, y, r
+
+
+def _offload_all_proposal(i, omega_ub_row):
+  # node 0 proposes moving everything out; node 1 proposes staying put
+  if i == 0:
+    return (
+      np.array([0.0]), np.array([0.0]),
+      np.minimum(np.array([4.0]), omega_ub_row), 0.0,
+    )
+  return np.array([0.001]), np.array([10.0]), np.array([0.0]), 0.0
+
+
+def test_node_move_accepts_improving_move_and_updates_state():
+  data = _data_2n_1f()
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  rho = np.zeros(2)
+  accepted, delta_u, bids, _ = node_move(
+    0, x, y, r, data, neighborhood, rho, 1e-6, _offload_all_proposal, 1e-9
+  )
+  assert accepted
+  assert delta_u > 0
+  # 4.0 offloaded to node 1 (residual cap 8.0 - 0.001)
+  assert np.isclose(y[0, 1, 0], 4.0)
+  assert np.isclose(x[0, 0], 0.0)
+
+
+def test_node_move_rejects_non_improving_move():
+  data = _data_2n_1f()
+  data[None]["beta"][(1, 2, 1)] = 0.5  # now worse than serving locally
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  accepted, _, _, _ = node_move(
+    0, x, y, r, data, neighborhood, np.zeros(2), 1e-6,
+    _offload_all_proposal, 1e-9,
+  )
+  assert not accepted
+  # state untouched
+  assert np.isclose(x[0, 0], 4.0)
+  assert np.isclose(y.sum(), 0.0)
+
+
+def test_sweep_raises_potential_then_certifies_equilibrium():
+  data = _data_2n_1f()
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  rng = np.random.default_rng(0)
+  phi0 = compute_centralized_objective(data, x, y, compute_z(x, y, data))
+  n_acc, delta_phi, bids, _ = potential_game_sweep(
+    x, y, r, data, neighborhood, np.zeros(2), 1e-6, 1e-9,
+    "fixed", rng, _offload_all_proposal,
+  )
+  phi1 = compute_centralized_objective(data, x, y, compute_z(x, y, data))
+  assert n_acc == 1
+  assert delta_phi > 0
+  assert np.isclose(phi1 - phi0, delta_phi)
+  # second sweep: same proposal is no longer an improvement -> equilibrium
+  n_acc2, delta_phi2, _, _ = potential_game_sweep(
+    x, y, r, data, neighborhood, np.zeros(2), 1e-6, 1e-9,
+    "fixed", rng, _offload_all_proposal,
+  )
+  assert n_acc2 == 0
+  assert np.isclose(delta_phi2, 0.0)
+  stop, why = check_pg_stopping(1, 100, n_acc2, 0, 0.0, np.inf)
+  assert stop and why == "epsilon-Nash equilibrium certified"
+  # ledger conservation: residual capacity consistent with committed flows
+  _, residual, ell = compute_residual_capacity(x, y, r, data)
+  assert np.isclose(ell[1, 0], 4.001)
+
+
+def test_check_pg_stopping_guards():
+  stop, why = check_pg_stopping(99, 100, 5, 0, 0.0, np.inf)
+  assert stop and why == "max iterations reached"
+  stop, why = check_pg_stopping(0, 100, 5, 0, 100.0, 50.0)
+  assert stop and "time limit" in why
+  stop, why = check_pg_stopping(0, 100, 5, 0, 0.0, np.inf)
+  assert not stop
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_potentialgame_sweep.py -v`
+Expected: FAIL with `ImportError: cannot import name 'node_move'`
+
+- [ ] **Step 3: Append the functions to `decentralized_potentialgame.py`**
+
+```python
+def propose_node_move(
+    node: int,
+    omega_ub_row: np.array,
+    y: np.array,
+    sp_data: dict,
+    model,
+    solver_name: str,
+    general_solver_options: dict,
+    parallelism: int,
+  ) -> Tuple[np.array, np.array, np.array, float]:
+  """MILP proposal for one node: re-solve the local problem with committed
+  inbound flows (y_bar) and the accessible-capacity cap (omega_ub).
+
+  The proposal prices aggregate offloading with delta (as P2 does); the
+  caller's epsilon-acceptance on the true beta-aware utility is what
+  guarantees potential monotonicity, not proposal optimality."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  node_data = deepcopy(sp_data)
+  node_data[None]["omega_ub"] = {
+    (f + 1): float(omega_ub_row[f]) for f in range(Nf)
+  }
+  node_data[None]["y_bar"] = {
+    (m + 1, n + 1, f + 1): float(max(y[m, n, f], 0.0))
+    for m in range(Nn) for n in range(Nn) for f in range(Nf)
+  }
+  result = solve_subproblem(
+    node_data, [node], model, solver_name, general_solver_options, parallelism
+  )
+  x_row = np.array(result[1][node, :], dtype=float)
+  omega_row = np.array(result[4][node, :], dtype=float)
+  r_row = np.array(result[5][node, :], dtype=float)
+  runtime = float(result[10]["tot"])
+  return x_row, r_row, omega_row, runtime
+
+
+def node_move(
+    i: int,
+    x: np.array,
+    y: np.array,
+    r: np.array,
+    sp_data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    epsilon: float,
+    propose_fn: Callable,
+    tolerance: float,
+  ) -> Tuple[bool, float, dict, float]:
+  """One better-response move. Rules that keep Phi an exact potential:
+  the mover keeps serving committed inbound flows (enforced by LSP_pg via
+  y_bar) and only claims advertised residual capacity of its neighbours.
+  The move is committed iff the TRUE utility (per-pair beta) improves by
+  more than epsilon; x, y, r are mutated in place only on acceptance."""
+  Nn = sp_data[None]["Nn"][None]
+  Nf = sp_data[None]["Nf"][None]
+  memory_bids = {"i": [], "j": [], "f": []}
+  neighbours = set(int(j) for j in np.nonzero(neighborhood[i, :])[0])
+  z = compute_z(x, y, sp_data)
+  u_old = compute_node_utility(i, x, y, z, sp_data)
+  # residual capacity visible to i, with its own row released
+  y_trial = np.array(y, dtype=float)
+  y_trial[i, :, :] = 0.0
+  _, ledger, _ = compute_residual_capacity(x, y_trial, r, sp_data)
+  omega_ub_row = np.zeros(Nf)
+  for f in range(Nf):
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    omega_ub_row[f] = sum(
+      ledger[j, f] for j in neighbours
+      if sp_data[None]["beta"][(i + 1, j + 1, f + 1)] > -gamma_if
+    )
+  x_row, r_row, omega_row, runtime = propose_fn(i, omega_ub_row)
+  new_row = split_omega(i, omega_row, ledger, neighbours, sp_data)
+  # candidate state (copies: commit only on acceptance)
+  x_new = np.array(x, dtype=float)
+  y_new = y_trial
+  x_new[i, :] = x_row
+  y_new[i, :, :] = new_row
+  z_new = compute_z(x_new, y_new, sp_data)
+  u_new = compute_node_utility(i, x_new, y_new, z_new, sp_data)
+  delta_u = u_new - u_old
+  accepted = delta_u > epsilon
+  if accepted:
+    x[i, :] = x_row
+    y[i, :, :] = new_row
+    r[i, :] = r_row
+  # unplaced appetite signals a capacity shortage: bid on neighbour memory
+  placed = new_row.sum(axis=0)
+  for f in range(Nf):
+    if omega_row[f] - placed[f] <= tolerance:
+      continue
+    gamma_if = sp_data[None]["gamma"][(i + 1, f + 1)]
+    memory_requirement = sp_data[None]["memory_requirement"][f + 1]
+    for j in sorted(neighbours):
+      if (
+          rho[j] >= memory_requirement
+          and sp_data[None]["beta"][(i + 1, j + 1, f + 1)] > -gamma_if
+        ):
+        memory_bids["i"].append(i)
+        memory_bids["j"].append(j)
+        memory_bids["f"].append(f)
+  return accepted, float(delta_u), memory_bids, runtime
+
+
+def potential_game_sweep(
+    x: np.array,
+    y: np.array,
+    r: np.array,
+    sp_data: dict,
+    neighborhood: np.array,
+    rho: np.array,
+    epsilon: float,
+    tolerance: float,
+    order: str,
+    rng: np.random.Generator,
+    propose_fn: Callable,
+  ) -> Tuple[int, float, pd.DataFrame, float]:
+  """Gauss-Seidel sweep of better-response moves. Every accepted move raises
+  the exact potential Phi by more than epsilon, so sweeps terminate."""
+  Nn = sp_data[None]["Nn"][None]
+  if order == "random":
+    node_order = [int(i) for i in rng.permutation(Nn)]
+  elif order == "fixed":
+    node_order = list(range(Nn))
+  else:
+    raise ValueError("order must be one of: fixed, random")
+  n_accepted = 0
+  delta_phi = 0.0
+  proposal_runtime = 0.0
+  all_bids = {"i": [], "j": [], "f": []}
+  for i in node_order:
+    accepted, delta_u, bids, runtime = node_move(
+      i, x, y, r, sp_data, neighborhood, rho, epsilon, propose_fn, tolerance
+    )
+    proposal_runtime += runtime
+    if accepted:
+      n_accepted += 1
+      delta_phi += delta_u
+    for k in all_bids:
+      all_bids[k].extend(bids[k])
+  return n_accepted, delta_phi, pd.DataFrame(all_bids), proposal_runtime
+
+
+def check_pg_stopping(
+    it: int,
+    max_iterations: int,
+    n_accepted: int,
+    n_new_replicas: int,
+    total_runtime: float,
+    time_limit: float,
+  ) -> Tuple[bool, str]:
+  if it >= max_iterations - 1:
+    return True, "max iterations reached"
+  if total_runtime >= time_limit:
+    return True, f"reached time limit: {total_runtime} >= {time_limit}"
+  if n_accepted == 0 and n_new_replicas == 0:
+    return True, "epsilon-Nash equilibrium certified"
+  return False, None
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_potentialgame_sweep.py tests/test_potentialgame_helpers.py -v`
+Expected: all PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_potentialgame.py tests/test_potentialgame_sweep.py
+git commit -m "add FaaS-MAPG better-response move and sweep"
+```
+
+---
+
+### Task 4: Outer loop `_run`, runners, CLI [sonnet]
+
+**Files:**
+- Modify: `decentralized_potentialgame.py` (append `parse_arguments`, `_run`, `run_pg_s`, `run_pg_r`, `__main__` block)
+
+**Interfaces:**
+- Consumes: everything from Tasks 1–3; reused functions already imported in Task 2 (`init_problem`, `get_current_load`, `update_data`, `solve_subproblem`, `combine_solutions`, `decode_solutions`, `check_feasibility`, `start_additional_replicas`, `save_checkpoint`, `save_solution`, `join_complete_solution`, `plot_history`, `encode_solution`, `load_solution`, `neigh_dict_to_matrix`).
+- Produces: `run_pg_s(config, parallelism, log_on_file=False, disable_plotting=False) -> str` and `run_pg_r(...) -> str` (return the solution folder path). Config keys consumed: standard MABR-style keys plus `solver_options.pg_s` / `solver_options.pg_r` dicts with `epsilon` (default 1e-6). Artifacts written: `config.json`, `obj.csv` (column = method name), `runtime.csv`, `termination_condition.csv`, `LSP*/LSPc*` checkpoints and solutions — same layout as MABR so `run.py` postprocessing works unchanged.
+
+- [ ] **Step 1: Append the outer loop to `decentralized_potentialgame.py`**
+
+```python
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run FaaS-MAPG",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", help="Configuration file", type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int, default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="True to disable automatic plot generation for each experiment",
+    default=False, action="store_true",
+  )
+  parser.add_argument(
+    "--variant", choices=["s", "r"], default="s",
+    help="FaaS-MAPG variant: s (fixed order), r (randomized order)",
+  )
+  return parser.parse_known_args()[0]
+
+
+def _run(
+    config: dict,
+    parallelism: int,
+    *,
+    order: str,
+    method_name: str,
+    options_key: str,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  pg_options = dict(solver_options.get(options_key, {}))
+  epsilon = pg_options.get("epsilon", 1e-6)
+  rng = np.random.default_rng(seed)
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  opt_solution, opt_replicas, opt_detailed_fwd = None, None, None
+  if "opt_solution_folder" in config:
+    opt_solution, opt_replicas, opt_detailed_fwd, _, _ = load_solution(
+      config["opt_solution_folder"], "LoadManagementModel"
+    )
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"phi_final": []}
+  tc_dict = {"pg": []}
+  runtime_list = []
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    if opt_solution is not None:
+      _, _, _, opt_r, _ = encode_solution(
+        Nn, Nf, opt_solution, opt_detailed_fwd, opt_replicas, t
+      )
+      sp_data[None]["r_bar"] = {}
+      for n in range(Nn):
+        for f in range(Nf):
+          sp_data[None]["r_bar"][(n + 1, f + 1)] = int(opt_r[n, f])
+    sp = LSP() if opt_solution is None else LSP_fixedr()
+    pg_model = LSP_pg() if opt_solution is None else LSP_pg_fixedr()
+    (
+      sp_data, sp_x, _, _, _, sp_r, sp_rho, _, _, _, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    total_runtime += sp_runtime["tot"]
+    x = np.array(sp_x, dtype=float)
+    r = np.array(sp_r, dtype=float)
+    rho = np.array(
+      sp_rho if opt_solution is None else np.zeros_like(sp_rho), dtype=float
+    )
+    y = np.zeros((Nn, Nn, Nf))
+
+    def propose_fn(node, omega_ub_row):
+      return propose_node_move(
+        node, omega_ub_row, y, sp_data, pg_model,
+        solver_name, general_solver_options, parallelism,
+      )
+
+    it = 0
+    stop_searching = False
+    phi_prev = compute_centralized_objective(
+      sp_data, x, y, compute_z(x, y, sp_data)
+    )
+    while not stop_searching:
+      s = datetime.now()
+      n_accepted, delta_phi, memory_bids, proposal_runtime = (
+        potential_game_sweep(
+          x, y, r, sp_data, neighborhood, rho, epsilon, tolerance,
+          order, rng, propose_fn,
+        )
+      )
+      elapsed = (datetime.now() - s).total_seconds()
+      bookkeeping = max(0.0, elapsed - proposal_runtime)
+      total_runtime += proposal_runtime + (
+        bookkeeping / n_accepted if n_accepted else bookkeeping
+      )
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(memory_bids) > 0 and (rho > 0).any():
+        s = datetime.now()
+        additional_replicas, rho = start_additional_replicas(
+          memory_bids, r, sp_data, rho
+        )
+        r += additional_replicas
+        total_runtime += (datetime.now() - s).total_seconds()
+      phi = compute_centralized_objective(
+        sp_data, x, y, compute_z(x, y, sp_data)
+      )
+      assert phi >= phi_prev - 1e-9, (
+        f"potential decreased: {phi_prev} -> {phi}"
+      )
+      phi_prev = phi
+      stop_searching, why_stop_searching = check_pg_stopping(
+        it, max_iterations, n_accepted,
+        int(additional_replicas.sum()), total_runtime, time_limit,
+      )
+      if not stop_searching:
+        it += 1
+    csol = combine_solutions(
+      Nn, Nf, sp_data, loadt, x, r, rho,
+      None, y, None, None, None, None
+    )
+    feas = check_feasibility(
+      csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+      csol["sp"]["r"], csol["sp"]["U"], sp_data
+    )
+    assert feas[0], feas[1]
+    sp_complete_solution, _, objf = decode_solutions(
+      sp_data, csol, sp_complete_solution, None
+    )
+    spc_complete_solution, _, _ = decode_solutions(
+      sp_data, csol, spc_complete_solution, None
+    )
+    obj_dict["phi_final"].append(objf)
+    tc_dict["pg"].append(
+      f"{why_stop_searching} "
+      f"(it: {it}; phi: {phi}; total runtime: {total_runtime})"
+    )
+    if t % checkpoint_interval == 0 or t == max_steps - 1:
+      save_checkpoint(
+        sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+      )
+      save_checkpoint(
+        spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+      )
+    runtime_list.append(total_runtime)
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(datetime.now() - ss).total_seconds()})",
+        file=log_stream, flush=True
+      )
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = (
+    join_complete_solution(spc_complete_solution)
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["phi_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["phi_final"], columns=[method_name]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  pd.DataFrame(tc_dict["pg"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  if verbose > 0:
+    print(
+      f"All solutions saved in: {solution_folder}",
+      file=log_stream, flush=True
+    )
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+def run_pg_s(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="fixed",
+              method_name="FaaS-MAPG-S", options_key="pg_s",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+def run_pg_r(config, parallelism, log_on_file=False, disable_plotting=False):
+  return _run(config, parallelism, order="random",
+              method_name="FaaS-MAPG-R", options_key="pg_r",
+              log_on_file=log_on_file, disable_plotting=disable_plotting)
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  runner = {"s": run_pg_s, "r": run_pg_r}[args.variant]
+  runner(config, args.parallelism, disable_plotting=args.disable_plotting)
+```
+
+Implementation notes for this task:
+- `combine_solutions` derives `z = load − x − Σ_j y` and tightens `r` to the served load; neither changes Φ, so the monotonicity assert stays valid.
+- In fixed-replica mode (`opt_solution_folder` in config) `rho` is zeroed so the memory market is disabled, mirroring MABR.
+- The `while` loop's `phi`/`why_stop_searching` variables are referenced after the loop; they are always bound because the loop body executes at least once (`max_iterations ≥ 1`).
+
+- [ ] **Step 2: Sanity-run the module import and CLI help**
+
+Run: `uv run python -c "import decentralized_potentialgame as m; assert callable(m.run_pg_s) and callable(m.run_pg_r)"`
+Expected: no output, exit 0
+
+Run: `uv run python decentralized_potentialgame.py --help`
+Expected: usage text with `--variant {s,r}`
+
+- [ ] **Step 3: Re-run all potential-game tests**
+
+Run: `uv run pytest tests/test_potentialgame_helpers.py tests/test_potentialgame_sweep.py tests/test_potentialgame_model.py -v`
+Expected: all PASS (model tests may SKIP without gurobi)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add decentralized_potentialgame.py
+git commit -m "add FaaS-MAPG outer loop, runners and CLI"
+```
+
+---
+
+### Task 5: End-to-end test [sonnet]
+
+**Files:**
+- Test: `tests/test_potentialgame_e2e.py` (new)
+
+**Interfaces:**
+- Consumes: `run_pg_s`, `run_pg_r` from Task 4.
+
+- [ ] **Step 1: Write the e2e test**
+
+```python
+# tests/test_potentialgame_e2e.py
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_potentialgame import run_pg_s, run_pg_r
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "pg_s": {"epsilon": 1e-6},
+      "pg_r": {"epsilon": 1e-6},
+    },
+    "max_iterations": 3,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def _assert_artifacts(folder, column):
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert column in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj[column], errors="coerce")).all()
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert len(tc) >= 1
+
+
+def test_run_pg_s_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_pg_s(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  _assert_artifacts(folder, "FaaS-MAPG-S")
+
+
+def test_run_pg_r_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_pg_r(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  _assert_artifacts(folder, "FaaS-MAPG-R")
+```
+
+- [ ] **Step 2: Run the e2e tests**
+
+Run: `uv run pytest tests/test_potentialgame_e2e.py -v`
+Expected: 2 PASS (or 2 SKIP without gurobi). Note the in-loop `assert phi >= phi_prev - 1e-9` inside `_run` means a pass also certifies welfare monotonicity end-to-end.
+
+- [ ] **Step 3: Run the full test suite to check for regressions**
+
+Run: `uv run pytest tests/ -x -q`
+Expected: no failures (pre-existing skips allowed)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add tests/test_potentialgame_e2e.py
+git commit -m "add FaaS-MAPG end-to-end test"
+```
+
+---
+
+### Task 6: Registration in `run.py` and config files [haiku]
+
+**Files:**
+- Modify: `run.py` (additive lines only)
+- Modify: `config_files/eval_smoke.json`, `config_files/eval_tuned_smoke.json`, `config_files/planar_comparison.json`, `config_files/eval_full.json` (add two keys each)
+
+**Interfaces:**
+- Consumes: `run_pg_s`, `run_pg_r` from `decentralized_potentialgame`.
+
+- [ ] **Step 1: Add the import in `run.py`**
+
+After the line `from decentralized_bestresponse import run_br_s, run_br_r, run_br_o` add:
+
+```python
+from decentralized_potentialgame import run_pg_s, run_pg_r
+```
+
+- [ ] **Step 2: Add entries to `METHOD_RESULT_MODELS`** (after the `"faas-br-o"` entry):
+
+```python
+  "faas-pg-s": ("LSPc", "FaaS-MAPG-S"),
+  "faas-pg-r": ("LSPc", "FaaS-MAPG-R"),
+```
+
+- [ ] **Step 3: Add `"faas-pg-s", "faas-pg-r",`** to the `--methods` argparse `choices` list (before `"generate_only"`).
+
+- [ ] **Step 4: Add run flags.** Next to the `run_bro = False` initialization (line ~923) add:
+
+```python
+    run_pgs = False # -- faas-pg-s (FaaS-MAPG-S)
+    run_pgr = False # -- faas-pg-r (FaaS-MAPG-R)
+```
+
+In the postprocessing_list branch (where `run_bro = True` is set around line 994), add matching branches:
+
+```python
+      elif "FaaS-MAPG-S" in method:
+        run_pgs = True
+      elif "FaaS-MAPG-R" in method:
+        run_pgr = True
+```
+
+(match the exact `if/elif` style of the surrounding block at lines ~970–994). Next to `run_bro = "faas-br-o" in methods` (line ~1006) add:
+
+```python
+      run_pgs = "faas-pg-s" in methods
+      run_pgr = "faas-pg-r" in methods
+```
+
+- [ ] **Step 5: Add dispatch blocks** after the `if run_bro:` block (line ~1161), same shape:
+
+```python
+      # -- solve potential game sequential (FaaS-MAPG-S)
+      if run_pgs:
+        pgs_folder = run_pg_s(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-pg-s", experiment_idx, pgs_folder
+        )
+      # -- solve potential game randomized (FaaS-MAPG-R)
+      if run_pgr:
+        pgr_folder = run_pg_r(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-pg-r", experiment_idx, pgr_folder
+        )
+```
+
+- [ ] **Step 6: Add config keys.** In each of the four config files, inside `"solver_options"` next to the `"br_s"` entry, add:
+
+```json
+    "pg_s": { "epsilon": 1e-6 },
+    "pg_r": { "epsilon": 1e-6 },
+```
+
+(keep valid JSON — mind trailing commas; in `eval_full.json` match the multi-line style of its `br_s` entry).
+
+- [ ] **Step 7: Verify**
+
+Run: `uv run python -c "import run"` — expected: no error.
+Run: `uv run python -c "import json; [json.load(open(f'config_files/{n}')) for n in ('eval_smoke.json','eval_tuned_smoke.json','planar_comparison.json','eval_full.json')]"` — expected: no error.
+Run: `uv run python run.py --help | grep faas-pg` — expected: shows the two new choices.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add run.py config_files/eval_smoke.json config_files/eval_tuned_smoke.json config_files/planar_comparison.json config_files/eval_full.json
+git commit -m "register FaaS-MAPG variants in run.py and configs"
+```
+
+---
+
+### Task 7: LaTeX note `faas-mapg-note/` [sonnet]
+
+**Files:**
+- Create: `faas-mapg-note/faas-mapg.tex`, `faas-mapg-note/main.tex`, `faas-mapg-note/references.bib`, `faas-mapg-note/README.md`
+
+**Interfaces:**
+- Consumes: the implemented algorithm in `decentralized_potentialgame.py` (the note must describe exactly what the code does) and the structure/notation of `faas-bestresponse-note/faas-mabr.tex` and `faas-mald-note/faas-mald.tex` (read both before writing).
+
+- [ ] **Step 1: Write `faas-mapg.tex`** following the existing notes' conventions (section meant to be `\input{}` into the host paper; self-contained notation recap subsection marked for removal; same Eqs. (1),(2),(12),(13) recap; notation table). Required content:
+
+1. **Section intro**: FaaS-MAPG positioning — better-response dynamics of an exact potential game; contrasts: MADeA/MALD coordinate through prices, MABR is a greedy heuristic without monotonicity; MAPG gives a certified ε-Nash equilibrium and monotone welfare.
+2. **Notation recap subsection** (copy the pattern from `faas-mabr.tex`, adjust label prefixes to `mapg-`).
+3. **Game formulation subsection**: players, strategy `(r_i, x_i, z_i, y_{i\cdot})`, utility
+   $u_i = \sum_f (\alpha_i^f x_i^f + \sum_j \beta_{ij}^f y_{ij}^f - \gamma_i^f z_i^f)/\lambda_i^f$,
+   unilateral-move rules (inbound commitments kept, only advertised residual capacity claimable).
+4. **Exact potential proposition with proof**: under the move rules, a unilateral move by $i$ changes no other node's utility terms, hence $\Phi=\sum_i u_i$ (the FRALB welfare) satisfies $\Phi(s_i', s_{-i})-\Phi(s_i, s_{-i}) = u_i(s_i', s_{-i})-u_i(s_i, s_{-i})$: an exact potential game.
+5. **Algorithm subsection**: pseudocode (algorithm/algpseudocode environments, as in the MABR note) of the sweep — proposal MILP (P2 with committed inbound and capacity cap), β-descending fractional-knapsack split (exact best response of the routing sub-strategy), ε-acceptance on the true utility.
+6. **Termination theorem with proof**: each accepted move raises Φ by more than ε; Φ is bounded above (finite welfare); replica expansions never decrease Φ and are bounded by total memory; hence finitely many accepted moves and a final sweep with zero accepted moves, whose terminal state is an ε-Nash equilibrium *with respect to the implemented move class* (MILP proposal + greedy split). State this restriction honestly.
+7. **Memory market subsection**: selfish sellers have no incentive to open replicas (β rewards the buyer); the reused MADeA memory market is a Φ-invariant, memory-bounded expansion step.
+8. **Positioning subsection**: vs FaaS-MABR (same Gauss-Seidel skeleton, but MAPG replaces score-greedy commit-always with utility-based ε-acceptance → monotone Φ, certificate), vs FaaS-MALD (per-inner-LP Lagrangian certificate vs game-theoretic equilibrium certificate on the joint replica+routing strategy), vs auction literature (cite the standard potential game references).
+
+- [ ] **Step 2: Write `main.tex`** (copy `faas-bestresponse-note/main.tex`, change `\input{faas-mabr}` to `\input{faas-mapg}`).
+
+- [ ] **Step 3: Write `references.bib`** with at least: Monderer & Shapley 1996 (Potential Games, GEB), Rosenthal 1973 (congestion games), and the entries already cited by the positioning subsection (copy relevant entries from `faas-bestresponse-note/references.bib` / `faas-mald-note/references.bib` as needed).
+
+- [ ] **Step 4: Write `README.md`** (mirror `faas-bestresponse-note/README.md`: what the note is, how to build the standalone preview).
+
+- [ ] **Step 5: Compile check**
+
+Run: `cd faas-mapg-note && pdflatex -interaction=nonstopmode main.tex && bibtex main && pdflatex -interaction=nonstopmode main.tex && pdflatex -interaction=nonstopmode main.tex`
+Expected: `main.pdf` produced, no LaTeX errors (warnings OK). If `pdflatex` is unavailable, verify structure by diffing the preamble against `faas-bestresponse-note/main.tex` and report the skip.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add faas-mapg-note/
+git commit -m "add FaaS-MAPG technical note"
+```
+
+---
+
+## Final verification (run after all tasks)
+
+1. `uv run pytest tests/ -q` — full suite green (gurobi tests may skip).
+2. `uv run python run.py --help | grep faas-pg` — variants registered.
+3. Smoke comparison (if gurobi available):
+   `uv run python run.py -c config_files/eval_smoke.json --methods centralized faas-br-s faas-pg-s --n_experiments 1` — completes; FaaS-MAPG-S objective ≥ FaaS-MABR-S is *expected but not required* (report either way).
+4. Every `termination_condition.csv` row from MAPG runs names one of the three stop reasons.
diff --git a/docs/superpowers/plans/2026-07-03-faas-magcaa-note.md b/docs/superpowers/plans/2026-07-03-faas-magcaa-note.md
new file mode 100644
index 0000000..fa5c18b
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-03-faas-magcaa-note.md
@@ -0,0 +1,166 @@
+# FaaS-MAGCAA Technical Note Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Produce an English, paper-ready and standalone-compilable LaTeX technical note that documents the implemented FaaS-MAGCAA algorithm precisely.
+
+**Architecture:** Add a self-contained `faas-magcaa-note/` directory matching `faas-mapg-note`. The main section will separate the original GCAA result from the FRALB adaptation, derive only properties supported by the implementation, and include pseudocode that matches `decentralized_gcaa.py` after the no-ping-pong fix.
+
+**Tech Stack:** LaTeX, BibTeX, `latexmk`, `algorithm`, `algpseudocode`, `amsmath`, `amssymb`, `amsthm`, `booktabs`, `natbib`.
+
+---
+
+### Task 1: Verified bibliography and note scaffold
+
+**Files:**
+- Create: `faas-magcaa-note/references.bib`
+- Create: `faas-magcaa-note/main.tex`
+- Create: `faas-magcaa-note/.gitignore`
+
+- [ ] **Step 1: Add the primary GCAA reference**
+
+Add a BibTeX entry with the verified metadata: Martin Braquet and Efstathios Bakolas, “Greedy Decentralized Auction-based Task Allocation for Multi-Agent Systems,” `IFAC-PapersOnLine`, volume 54, issue 20, pages 675--680, 2021, DOI `10.1016/j.ifacol.2021.11.249`.
+
+- [ ] **Step 2: Add only positioning references actually cited**
+
+Reuse the verified Bertsekas auction references already present in `faas-mapg-note/references.bib`. Do not add uncited or secondary sources.
+
+- [ ] **Step 3: Create the standalone wrapper**
+
+Create `main.tex` with `article`, UTF-8 input, `amsmath`, `amssymb`, `amsthm`, `booktabs`, `algorithm`, `algpseudocode`, numerical `natbib`, `geometry`, the theorem environments used by the note, `\input{faas-magcaa}`, and the local bibliography.
+
+- [ ] **Step 4: Ignore LaTeX build products**
+
+Create `.gitignore` covering `*.aux`, `*.bbl`, `*.blg`, `*.fdb_latexmk`, `*.fls`, `*.log`, `*.out`, and `main.pdf`.
+
+- [ ] **Step 5: Commit the scaffold**
+
+```bash
+git add faas-magcaa-note/main.tex faas-magcaa-note/references.bib faas-magcaa-note/.gitignore
+git commit -m "scaffold FaaS-MAGCAA technical note"
+```
+
+### Task 2: Paper-ready algorithm section
+
+**Files:**
+- Create: `faas-magcaa-note/faas-magcaa.tex`
+
+- [ ] **Step 1: Write the introduction and positioning**
+
+Explain that FaaS-MAGCAA adapts the GCAA selection-and-consensus mechanism of Braquet and Bakolas to FRALB as an experimental baseline. State explicitly that it has no adaptive prices and no replica market, unlike FaaS-MADeA, and does not claim the equilibrium certificates of FaaS-MALD or FaaS-MAPG.
+
+- [ ] **Step 2: Write the removable notation recap**
+
+Define nodes `\mathcal N`, functions `\mathcal F`, residual buyer load `\omega_i^f`, routing `y_{ij}^f`, seller residual capacity `C_j^f`, neighbourhood `N_i`, utility `u_{ij}^f`, and the sending/receiving predicates. Include the capacity equation
+
+```latex
+C_j^f(h)=\max\!\left\{0,\frac{r_j^f(h)U_{\max}^f}{D_j^f}-x_j^f(h)-\sum_i y_{ij}^f(h)\right\}.
+```
+
+and the implemented utility
+
+```latex
+u_{ij}^f(h)=\beta_{ij}^f-w_L\ell_{ij}-w_F q_i^f(h),
+```
+
+noting that repository configurations set `w_L=w_F=0`, so bids reduce to `\beta_{ij}^f`.
+
+- [ ] **Step 3: Describe the GCAA-to-FRALB mapping**
+
+State that each active buyer--function pair `(i,f)` is a GCAA agent and each feasible seller--function pair `(j,f)` is a task. Unit bids are mandatory. A null assignment occurs when no convenient, capacity-feasible, no-ping-pong-safe seller exists.
+
+- [ ] **Step 4: Formalize proposal and consensus**
+
+Define the best proposal as the maximum-utility candidate after capacity and neighbourhood filtering. For every contested `(j,f)`, select at most one valid winner, test `C_j^f\ge1`, and update the within-round sending/receiving state immediately. Explain that a lower-ranked contender may win only when a higher-ranked proposal is invalid under no-ping-pong or capacity constraints.
+
+- [ ] **Step 5: Add implementation-faithful pseudocode**
+
+Provide one algorithm covering initial local solves, zero price vector, disabled replica sellers, repeated `define_bids`, `resolve_gcaa_round`, restricted social-welfare re-optimization, residual-load update, and the existing stopping guards. The pseudocode must show both checks `R_i^f=0` for a buyer and `S_j^f=0` for a seller, with state updates immediately after acceptance.
+
+- [ ] **Step 6: State and prove only supported properties**
+
+Add propositions for: one winner per contested seller--function task per round; no capacity over-allocation from unit acceptance; and inductive preservation of no ping-pong from `y=0`. Do not claim global optimality, strategy-proofness, an equilibrium certificate, or transfer of the original paper's at-most-`n` bound.
+
+- [ ] **Step 7: Document stopping and practical limits**
+
+Describe residual-demand exhaustion, residual-capacity exhaustion, lack of admissible bids, maximum iterations, and time limit. State that an execution reaching `max iterations reached` remains feasible but does not carry a convergence certificate.
+
+- [ ] **Step 8: Commit the main section**
+
+```bash
+git add faas-magcaa-note/faas-magcaa.tex
+git commit -m "document FaaS-MAGCAA algorithm"
+```
+
+### Task 3: README and semantic cross-check
+
+**Files:**
+- Create: `faas-magcaa-note/README.md`
+- Verify: `decentralized_gcaa.py`
+- Verify: `run_faasmadea.py`
+- Verify: `run_faasmacro.py`
+
+- [ ] **Step 1: Write README integration instructions**
+
+Describe every file, the `latexmk -pdf main.tex` preview command, insertion through `\input{faas-magcaa}`, required packages, bibliography merging, and removal of the self-contained notation recap when embedded in the host paper.
+
+- [ ] **Step 2: Cross-check every implementation claim**
+
+Verify the note against the actual code for: mandatory `unit_bids`; zero price; zero replica-seller vector; highest utility per `(i,f)`; at most one winner per `(j,f)`; residual-capacity comparison against `d`; `current_y` no-ping-pong guards; restricted re-optimization; and saved `LSP`/`LSPc`, objective, runtime, and termination artifacts.
+
+- [ ] **Step 3: Scan for unsupported language**
+
+Reject or qualify every occurrence of “optimal,” “converges,” “guarantees,” “equilibrium,” “strategy-proof,” and the original GCAA round bound unless the surrounding sentence explicitly scopes it to the cited original paper rather than FaaS-MAGCAA.
+
+- [ ] **Step 4: Commit README and corrections**
+
+```bash
+git add faas-magcaa-note/README.md faas-magcaa-note/faas-magcaa.tex
+git commit -m "complete FaaS-MAGCAA note guidance"
+```
+
+### Task 4: Compile and verify the deliverable
+
+**Files:**
+- Verify: `faas-magcaa-note/main.tex`
+- Verify: `faas-magcaa-note/faas-magcaa.tex`
+- Verify: `faas-magcaa-note/references.bib`
+
+- [ ] **Step 1: Compile twice through latexmk**
+
+Run:
+
+```bash
+cd faas-magcaa-note
+latexmk -pdf -interaction=nonstopmode -halt-on-error main.tex
+```
+
+Expected: exit code 0 and `main.pdf` generated.
+
+- [ ] **Step 2: Check warnings**
+
+Run:
+
+```bash
+rg -n "Undefined|Citation.*undefined|Reference.*undefined|LaTeX Error|Overfull" main.log
+```
+
+Expected: no undefined citations/references, LaTeX errors, or material overfull boxes. Fix prose or tables if any are reported and rebuild.
+
+- [ ] **Step 3: Perform final source checks**
+
+Run:
+
+```bash
+rg -n "TODO|TBD|PLACEHOLDER|\\?\\?\\?" README.md faas-magcaa.tex main.tex references.bib
+git diff --check
+```
+
+Expected: no placeholders and no whitespace errors.
+
+- [ ] **Step 4: Commit compilation fixes**
+
+```bash
+git add faas-magcaa-note
+git commit -m "verify FaaS-MAGCAA LaTeX note"
+```
diff --git a/docs/superpowers/plans/2026-07-03-faas-magcaa.md b/docs/superpowers/plans/2026-07-03-faas-magcaa.md
new file mode 100644
index 0000000..4779eb0
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-03-faas-magcaa.md
@@ -0,0 +1,1045 @@
+# FaaS-MAGCAA Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add FaaS-MAGCAA, a decentralized load-allocation algorithm adapted
+from the Greedy Coalition Auction Algorithm (Braquet & Bakolas, 2021), as a
+new experimental baseline alongside the existing FaaS-MA* family in this
+repo.
+
+**Architecture:** One new module, `decentralized_gcaa.py`, following the
+exact per-timestep / inner-negotiation-loop shape every sibling
+`decentralized_*.py` file already uses. It reuses `run_faasmadea.py`'s
+`define_bids` unmodified (pinning its price vector at zero and its replica
+vector at zero neutralizes the price-adaptation and replica-bidding paths
+for free) and `check_stopping_criteria` unmodified. The only new logic is
+a single consensus function, `resolve_gcaa_round`, implementing the
+paper's single-winner-per-contested-task-per-round rule (Algorithms 1+3).
+`run.py` gets a new registration entry following the exact pattern already
+used for `faas-pg-s`/`faas-pg-r`.
+
+**Tech Stack:** Python, NumPy, pandas, Pyomo/Gurobi (existing repo stack;
+no new dependencies).
+
+## Global Constraints
+
+- No price adaptation: GCAA bids are pure utility (spec decision, see
+  `docs/superpowers/specs/2026-07-03-faas-magcaa-design.md`).
+- No replica-bidding / dynamic replica creation (spec decision — faithful
+  to the paper's fixed task set with null assignment).
+- Single winner per contested task per round; losers retry next round
+  (spec decision — faithful to Algorithm 3, not a MADeA-style
+  fill-capacity-in-one-round).
+- `gcaa.unit_bids` must be `true` in config (the per-round consensus
+  assumes each bid row is exactly one discrete unit of load).
+- Follow existing repo conventions: each `decentralized_*.py` file owns a
+  complete, self-contained `run()` (not a shared parameterized one); 2-space
+  indentation (matches existing `.py` and `.json` files in this repo).
+
+---
+
+## Task 1: GCAA consensus function (`resolve_gcaa_round`)
+
+**Files:**
+- Create: `decentralized_gcaa.py` (this task adds only the consensus
+  function and its imports; Task 2 extends the same file)
+- Test: `tests/test_gcaa_helpers.py`
+
+**Interfaces:**
+- Produces: `resolve_gcaa_round(bids: pd.DataFrame, residual_capacity: np.array) -> np.array`
+  — `bids` has columns `["i", "j", "f", "d", "b", "utility"]` (the exact
+  shape `run_faasmadea.define_bids` returns). `residual_capacity` is a
+  `(Nn, Nf)` array. Returns a `(Nn, Nn, Nf)` allocation delta for one
+  round, where `y_round[i, j, f]` is the load agent `i` sends to seller
+  `j` for function `f` this round.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_gcaa_helpers.py`:
+
+```python
+import numpy as np
+import pandas as pd
+
+from decentralized_gcaa import resolve_gcaa_round
+
+
+def _bids(rows):
+  return pd.DataFrame(rows, columns=["i", "j", "f", "d", "b", "utility"])
+
+
+def test_empty_bids_returns_zero_allocation():
+  residual_capacity = np.ones((2, 1))
+  y_round = resolve_gcaa_round(_bids([]), residual_capacity)
+  assert y_round.shape == (2, 2, 1)
+  assert (y_round == 0).all()
+
+
+def test_single_winner_per_contested_task():
+  # agents 0 and 1 both target seller 1 / function 0; agent 1 has the
+  # higher utility and must be the sole winner this round
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+    {"i": 1, "j": 1, "f": 0, "d": 1, "b": 0.7, "utility": 2.0},
+  ])
+  residual_capacity = np.array([[0.0], [5.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round[1, 1, 0] == 1.0
+  assert y_round[0, 1, 0] == 0.0
+  assert y_round.sum() == 1.0
+
+
+def test_agent_proposes_only_its_best_task():
+  # agent 0 has bid rows for two different sellers; only the
+  # higher-utility one (seller 2) should be proposed this round
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.1, "utility": 0.5},
+    {"i": 0, "j": 2, "f": 0, "d": 1, "b": 0.9, "utility": 3.0},
+  ])
+  residual_capacity = np.array([[5.0], [5.0], [5.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round[0, 2, 0] == 1.0
+  assert y_round[0, 1, 0] == 0.0
+
+
+def test_seller_with_no_residual_capacity_is_skipped():
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+  ])
+  residual_capacity = np.array([[5.0], [0.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round.sum() == 0.0
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_gcaa_helpers.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'decentralized_gcaa'`
+
+- [ ] **Step 3: Implement `resolve_gcaa_round`**
+
+Create `decentralized_gcaa.py`:
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def resolve_gcaa_round(
+    bids: pd.DataFrame, residual_capacity: np.array
+  ) -> np.array:
+  """One GCAA consensus round (Braquet & Bakolas, 2021 - Algorithms 1+3):
+  each buyer agent (i, f) proposes only its highest-utility task (j, f);
+  for each contested task, the single highest-utility proposal wins and
+  consumes one unit of residual_capacity[j, f]. Losers are absent from
+  the returned allocation and simply re-propose next round via a fresh
+  call to define_bids (their omega is left untouched by this function)."""
+  Nn, Nf = residual_capacity.shape
+  y_round = np.zeros((Nn, Nn, Nf))
+  if len(bids) == 0:
+    return y_round
+  best_per_agent = bids.loc[bids.groupby(["i", "f"])["utility"].idxmax()]
+  for (j, f), group in best_per_agent.groupby(["j", "f"]):
+    j, f = int(j), int(f)
+    if residual_capacity[j, f] <= 0:
+      continue
+    winner = group.loc[group["utility"].idxmax()]
+    y_round[int(winner["i"]), j, f] += winner["d"]
+  return y_round
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_gcaa_helpers.py -v`
+Expected: 4 passed
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_gcaa.py tests/test_gcaa_helpers.py
+git commit -m "$(cat <<'EOF'
+Add GCAA consensus function (resolve_gcaa_round)
+
+Implements the single-winner-per-contested-task-per-round rule from
+Braquet & Bakolas (2021) Algorithms 1+3, as the core new logic for the
+FaaS-MAGCAA baseline.
+EOF
+)"
+```
+
+---
+
+## Task 2: GCAA `run()` orchestration and CLI entrypoint
+
+**Files:**
+- Modify: `decentralized_gcaa.py` (append to the file created in Task 1)
+
+**Interfaces:**
+- Consumes: `resolve_gcaa_round(bids, residual_capacity) -> np.array` (Task 1)
+- Consumes (reused unmodified, all pre-existing in this repo):
+  - `run_faasmadea.define_bids(omega, blackboard, p, data, neighborhood, rho, auction_options, latency, fairness, force_memory_bids) -> Tuple[pd.DataFrame, pd.DataFrame, int]`
+  - `run_faasmadea.check_stopping_criteria(it, max_iterations, blackboard, omega, rmp_omega, a, bids, memory_bids, tolerance, total_runtime, time_limit) -> Tuple[bool, str]`
+  - `run_faasmadea.compute_residual_capacity(x, y, r, data) -> Tuple[np.array, np.array, np.array]` (returns `capacity, residual_capacity, ell`)
+  - `run_faasmadea.neigh_dict_to_matrix(neighborhood_dict, Nn) -> np.array`
+  - `run_faasmadea.check_ls_pr_feasibility_from_fixed_y(sp_data, y, tol=1e-9) -> list`
+  - `run_faasmacro.solve_subproblem(sp_data, agents, sp, solver_name, general_solver_options, parallelism) -> 11-tuple` (`sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime`)
+  - `run_faasmacro.compute_social_welfare(spr, sp_data, agents, solver_name, general_solver_options, y, rmp_omega, parallelism) -> Tuple[tuple, float, str, float]` (solution unpacks as `sp_x, _, _, _, sp_r, sp_rho`)
+  - `run_faasmacro.combine_solutions(Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho, None, y, None, None, None, None) -> dict` (has `["sp"]["x"|"y"|"z"|"r"|"U"]`)
+  - `run_faasmacro.decode_solutions(sp_data, solution, complete, None) -> Tuple[dict, Any, float]`
+  - `utils.faasmacro.compute_centralized_objective(sp_data, x, y, z) -> float`
+  - `utils.centralized.check_feasibility(x, y_sum, z, r, U, sp_data) -> Tuple[bool, str]`
+  - `run_centralized_model.init_problem(limits, trace_type, max_steps, seed, solution_folder) -> Tuple[dict, dict, list, Graph]`
+  - `run_centralized_model.get_current_load(input_requests_traces, agents, t) -> dict`
+  - `run_centralized_model.update_data(base_instance_data, {"incoming_load": loadt}) -> dict`
+  - `run_centralized_model.init_complete_solution() -> dict`
+  - `run_centralized_model.join_complete_solution(complete) -> Tuple[dict, dict, dict]`
+  - `run_centralized_model.save_checkpoint(complete_solution, path_prefix, t)`
+  - `run_centralized_model.save_solution(solution, offloaded, complete_solution, detailed_fwd, name, folder)`
+  - `run_centralized_model.plot_history(...)`
+  - `utils.common.load_configuration(path) -> dict`
+  - `models.sp.LSP()`, `models.sp.LSPr()`
+- Produces: `run(config: dict, parallelism: int, log_on_file: bool = False, disable_plotting: bool = False) -> str` (returns solution folder path)
+- Produces: `parse_arguments() -> argparse.Namespace`
+
+- [ ] **Step 1: Add imports to the top of `decentralized_gcaa.py`**
+
+Prepend to `decentralized_gcaa.py` (above the `resolve_gcaa_round`
+function added in Task 1):
+
+```python
+from run_centralized_model import (
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+  update_data,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  define_bids,
+  neigh_dict_to_matrix,
+)
+from utils.centralized import check_feasibility
+from utils.faasmacro import compute_centralized_objective
+from utils.common import load_configuration
+from models.sp import LSP, LSPr
+
+from networkx import adjacency_matrix
+from datetime import datetime
+from copy import deepcopy
+import argparse
+import json
+import sys
+import os
+```
+
+(the `numpy as np` / `pandas as pd` imports already exist from Task 1;
+do not duplicate them)
+
+- [ ] **Step 2: Append `parse_arguments` and `run` to `decentralized_gcaa.py`**
+
+```python
+def parse_arguments() -> argparse.Namespace:
+  """
+  Parse input arguments
+  """
+  parser: argparse.ArgumentParser = argparse.ArgumentParser(
+    description = "Run FaaS-MAGCAA",
+    formatter_class = argparse.ArgumentDefaultsHelpFormatter
+  )
+  parser.add_argument(
+    "-c", "--config",
+    help = "Configuration file",
+    type = str,
+    default = "manual_config.json"
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help = "Number of parallel processes to start (-1: auto, 0: sequential)",
+    type = int,
+    default = -1
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help = "True to disable automatic plot generation for each experiment",
+    default = False,
+    action = "store_true"
+  )
+  args: argparse.Namespace = parser.parse_known_args()[0]
+  return args
+
+
+def run(
+    config: dict,
+    parallelism: int,
+    log_on_file: bool = False,
+    disable_plotting: bool = False
+  ):
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config["solver_options"]
+  general_solver_options = solver_options.get("general", {})
+  gcaa_options = solver_options["gcaa"]
+  time_limit = general_solver_options.get("TimeLimit", np.inf)
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  # generate solution folder
+  now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S.%f')
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok = True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent = 2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn
+  )
+  latency = adjacency_matrix(graph, weight = "network_latency")
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  sp_complete_solution = init_complete_solution()
+  spc_complete_solution = init_complete_solution()
+  obj_dict = {"LSPr_final": []}
+  tc_dict = {"LSPr": []}
+  runtime_list = []
+  # GCAA bids are pure utility: price stays at zero forever (no
+  # evaluate_bids-style price adaptation)
+  no_price = np.zeros((Nn, Nf))
+  # zero replica capacity disables define_bids' memory-bid path: GCAA
+  # has no replica-bidding, a buyer with no convenient seller just gets
+  # the null assignment (utility 0) for this round
+  no_replica_sellers = np.zeros((Nn,))
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file = log_stream, flush = True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    total_runtime = 0
+    ss = datetime.now()
+    sp_data = deepcopy(data)
+    sp = LSP()
+    spr = LSPr()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism
+    )
+    if verbose > 1:
+      print(
+        f"    sp: DONE ({tc['tot']}; obj = {obj['tot']}; "
+        f"runtime = {sp_runtime['tot']})",
+        file = log_stream, flush = True
+      )
+    total_runtime += sp_runtime["tot"]
+    it = 0
+    stop_searching = False
+    best_solution_so_far = None
+    best_centralized_solution = None
+    best_cost_so_far = np.inf
+    spr_obj = np.inf
+    best_centralized_cost = 0.0
+    best_it_so_far = -1
+    best_centralized_it = -1
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    while not stop_searching:
+      if verbose > 0:
+        print(f"    it = {it}", file = log_stream, flush = True)
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      bids, memory_bids, n_auctions = define_bids(
+        omega, blackboard, no_price, sp_data, neighborhood,
+        no_replica_sellers, gcaa_options, latency, fairness,
+        force_memory_bids = False
+      )
+      if verbose > 2:
+        print(bids, file = log_stream, flush = True)
+      rmp_omega = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        auction_y = resolve_gcaa_round(bids, residual_capacity)
+        y += auction_y
+        for n in range(Nn):
+          for f in range(Nf):
+            rmp_omega[n,f] = y[n,:,f].sum()
+            if rmp_omega[n,f] > 0:
+              fairness[n,f] += 1
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(
+            f"LSPr infeasible from fixed y assignments: {bad_nodes}"
+          )
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism
+        )
+        total_runtime += spr_runtime
+        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        for i in range(Nn):
+          for f in range(Nf):
+            omega[i,f] = sp_omega[i,f] - rmp_omega[i,f]
+            if abs(omega[i,f]) < tolerance:
+              omega[i,f] = 0.0
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt, sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"]
+      )
+      feas = check_feasibility(
+        csol["sp"]["x"], csol["sp"]["y"].sum(axis=1), csol["sp"]["z"],
+        csol["sp"]["r"], csol["sp"]["U"], sp_data
+      )
+      assert feas[0], feas[1]
+      if spr_obj < best_cost_so_far or it == 0:
+        best_cost_so_far = spr_obj
+        best_solution_so_far = deepcopy(csol)
+        best_it_so_far = it
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = deepcopy(csol)
+        best_centralized_it = it
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega, None,
+        bids, memory_bids, tolerance, total_runtime, time_limit
+      )
+      if not stop_searching:
+        it += 1
+      else:
+        sp_complete_solution, _, objf = decode_solutions(
+          sp_data, best_solution_so_far, sp_complete_solution, None
+        )
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data, best_centralized_solution, spc_complete_solution, None
+        )
+        obj_dict["LSPr_final"].append(objf)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} "
+          f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
+          f"total runtime: {total_runtime})"
+        )
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            sp_complete_solution, os.path.join(solution_folder, "LSP"), t
+          )
+          save_checkpoint(
+            spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+    ee = datetime.now()
+    if verbose > 0:
+      print(
+        f"    TOTAL RUNTIME [s] = {total_runtime} "
+        f"(wallclock: {(ee-ss).total_seconds()})",
+        file = log_stream, flush = True
+      )
+    runtime_list.append(total_runtime)
+  sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
+    sp_complete_solution
+  )
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution
+  )
+  if not disable_plotting and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, min_run_time, max_run_time, run_time_step,
+      sp_solution, sp_complete_solution["utilization"],
+      sp_complete_solution["replicas"], sp_offloaded,
+      obj_dict["LSPr_final"], os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    sp_solution, sp_offloaded, sp_complete_solution,
+    sp_detailed_fwd_solution, "LSP", solution_folder
+  )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns = ["FaaS-MAGCAA"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index = False
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv")
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index = False
+  )
+  if verbose > 0:
+    print(
+      f"All solutions saved in: {solution_folder}",
+      file = log_stream, flush = True
+    )
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(
+    config, args.parallelism, log_on_file = False,
+    disable_plotting = args.disable_plotting
+  )
+```
+
+- [ ] **Step 3: Verify the module imports cleanly**
+
+Run: `python -c "import decentralized_gcaa"`
+Expected: no output, exit code 0 (catches typos/import errors before the
+behavioral wiring test in Task 3 exercises the full `run()` path)
+
+- [ ] **Step 4: Re-run Task 1's tests to confirm nothing broke**
+
+Run: `pytest tests/test_gcaa_helpers.py -v`
+Expected: 4 passed
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add decentralized_gcaa.py
+git commit -m "$(cat <<'EOF'
+Add FaaS-MAGCAA run() orchestration
+
+Per-timestep loop matches run_faasmadea.py's shape exactly, reusing
+define_bids/check_stopping_criteria/compute_residual_capacity
+unmodified; only evaluate_bids is replaced, by resolve_gcaa_round.
+Behavioral verification (wiring smoke test, e2e test) follows in the
+next two tasks.
+EOF
+)"
+```
+
+---
+
+## Task 3: Register FaaS-MAGCAA in `run.py`
+
+**Files:**
+- Modify: `run.py:11` (imports), `run.py:30-44` (`METHOD_RESULT_MODELS`),
+  `run.py:71-87` (`--methods` choices), `run.py:921-934` (flag
+  declarations), `run.py:~1013-1018` (try-block read-back),
+  `run.py:~1020-1029` (except-block fallback + combined condition),
+  `run.py:~1199-1207` (dispatch block)
+- Test: `tests/test_gcaa_wiring.py`
+
+**Interfaces:**
+- Consumes: `decentralized_gcaa.run` (Task 2), `decentralized_gcaa.resolve_gcaa_round`/module attributes for monkeypatching
+- Produces: `run.run_gcaa` (module-level name usable by other code/tests), `run.METHOD_RESULT_MODELS["faas-gcaa"] == ("LSPc", "FaaS-MAGCAA")`, `"faas-gcaa"` accepted by `run.parse_arguments()`'s `--methods`
+
+- [ ] **Step 1: Write the failing wiring tests**
+
+Create `tests/test_gcaa_wiring.py`:
+
+```python
+import json
+from pathlib import Path
+
+import numpy as np
+import networkx as nx
+import pandas as pd
+
+import decentralized_gcaa
+import run
+
+
+def test_methods_choice_accepts_faas_gcaa(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-gcaa"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-gcaa" in args.methods
+
+
+def test_run_module_exposes_gcaa_runner():
+  assert hasattr(run, "run_gcaa")
+  assert callable(run.run_gcaa)
+
+
+def test_method_result_models_has_gcaa_entry():
+  assert run.METHOD_RESULT_MODELS["faas-gcaa"] == ("LSPc", "FaaS-MAGCAA")
+
+
+def test_planar_config_has_gcaa_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  gcaa = config["solver_options"]["gcaa"]
+  assert gcaa["unit_bids"] is True
+  assert "latency_weight" in gcaa
+  assert "fairness_weight" in gcaa
+
+
+def test_set_solution_folder_tolerates_missing_method_key():
+  solution_folders = {"experiments_list": []}
+  run.set_solution_folder(solution_folders, "faas-gcaa", 0, "/some/folder")
+  assert solution_folders["faas-gcaa"][0] == "/some/folder"
+
+
+def test_gcaa_run_stops_when_no_bids_available(tmp_path, monkeypatch):
+  base_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0},
+    }
+  }
+  monkeypatch.setattr(
+    decentralized_gcaa, "init_problem",
+    lambda *args, **kwargs: (base_data, {}, [], nx.empty_graph(1)),
+  )
+  monkeypatch.setattr(decentralized_gcaa, "get_current_load", lambda *args: {})
+  monkeypatch.setattr(decentralized_gcaa, "update_data", lambda data, update: data)
+  monkeypatch.setattr(decentralized_gcaa, "LSP", lambda: "LSP")
+  monkeypatch.setattr(decentralized_gcaa, "LSPr", lambda: "LSPr")
+
+  def _solve_subproblem(sp_data, agents, sp, *args):
+    return (
+      sp_data,
+      np.zeros((1, 1)),
+      None,
+      None,
+      np.zeros((1, 1)),   # sp_omega: no residual load -> no bids
+      np.ones((1, 1)),
+      np.array([0.0]),
+      np.zeros((1, 1)),
+      {"tot": 0.0},
+      {"tot": "ok"},
+      {"tot": 0.0},
+    )
+
+  monkeypatch.setattr(decentralized_gcaa, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(
+    decentralized_gcaa, "compute_residual_capacity",
+    lambda *args: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))),
+  )
+  monkeypatch.setattr(
+    decentralized_gcaa, "define_bids",
+    lambda *args, **kwargs: (
+      pd.DataFrame({"i": [], "j": [], "f": [], "d": [], "b": [], "utility": []}),
+      pd.DataFrame({"i": [], "j": [], "f": []}),
+      1,
+    ),
+  )
+  monkeypatch.setattr(
+    decentralized_gcaa, "combine_solutions",
+    lambda *args: {"sp": {
+      "x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)),
+      "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1)),
+    }},
+  )
+  monkeypatch.setattr(decentralized_gcaa, "compute_centralized_objective", lambda *args: -1.0)
+  monkeypatch.setattr(decentralized_gcaa, "check_feasibility", lambda *args: (True, "ok"))
+
+  decoded = []
+
+  def _decode(sp_data, solution, complete, arg):
+    decoded.append(solution)
+    return complete, None, 1.0
+
+  monkeypatch.setattr(decentralized_gcaa, "decode_solutions", _decode)
+  monkeypatch.setattr(
+    decentralized_gcaa, "join_complete_solution", lambda complete: ({}, {}, {})
+  )
+  monkeypatch.setattr(decentralized_gcaa, "save_checkpoint", lambda *args: None)
+  monkeypatch.setattr(decentralized_gcaa, "save_solution", lambda *args: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {
+      "general": {"TimeLimit": 10},
+      "gcaa": {
+        "unit_bids": True, "epsilon": 0.01,
+        "latency_weight": 0.0, "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 5,
+    "max_steps": 1,
+    "min_run_time": 0,
+    "max_run_time": 0,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "verbose": 0,
+  }
+
+  decentralized_gcaa.run(config, parallelism=0, disable_plotting=True)
+
+  assert len(decoded) == 2
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_gcaa_wiring.py -v`
+Expected: FAIL — `ModuleNotFoundError` / `AttributeError: module 'run' has
+no attribute 'run_gcaa'` / `KeyError: 'faas-gcaa'`
+
+- [ ] **Step 3: Add the import**
+
+In `run.py`, modify line 11 (the line reading
+`from decentralized_potentialgame import run_pg_s, run_pg_r`):
+
+```python
+from decentralized_potentialgame import run_pg_s, run_pg_r
+from decentralized_gcaa import run as run_gcaa
+```
+
+- [ ] **Step 4: Register in `METHOD_RESULT_MODELS`**
+
+In `run.py`, modify the `METHOD_RESULT_MODELS` dict (currently ends with
+`"faas-pg-r": ("LSPc", "FaaS-MAPG-R"),` followed by the closing `}`):
+
+```python
+  "faas-pg-r": ("LSPc", "FaaS-MAPG-R"),
+  "faas-gcaa": ("LSPc", "FaaS-MAGCAA"),
+}
+```
+
+- [ ] **Step 5: Add to `--methods` CLI choices**
+
+In `run.py`, modify the `choices` list in `parse_arguments`:
+
+```python
+      "faas-pg-s",
+      "faas-pg-r",
+      "faas-gcaa",
+      "generate_only"
+    ],
+```
+
+- [ ] **Step 6: Add the per-experiment flag declaration**
+
+In `run.py`, modify the flag block inside the experiments loop (currently
+ends with `run_pgr = False # -- faas-pg-r (FaaS-MAPG-R)` followed by
+`experiment_idx = None`):
+
+```python
+    run_pgr = False # -- faas-pg-r (FaaS-MAPG-R)
+    run_g = False # -- faas-gcaa (FaaS-MAGCAA)
+    experiment_idx = None
+```
+
+- [ ] **Step 7: Add the try-block read-back check**
+
+In `run.py`, modify the `try:` block, immediately after the existing
+`faas-pg-r` check (which ends with `run_pgr = True`) and before
+`except ValueError:`:
+
+```python
+      if (not generate_only and "faas-pg-r" in methods) and ((
+          len(solution_folders.get("faas-pg-r", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-pg-r"][experiment_idx] is None
+        )):
+        run_pgr = True
+      if (not generate_only and "faas-gcaa" in methods) and ((
+          len(solution_folders.get("faas-gcaa", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-gcaa"][experiment_idx] is None
+        )):
+        run_g = True
+    except ValueError:
+```
+
+- [ ] **Step 8: Add the except-block fallback and combined condition**
+
+In `run.py`, modify the `except ValueError:` block (currently ends with
+`run_pgr = "faas-pg-r" in methods` followed by the `# if the experiment
+is still to run...` comment):
+
+```python
+      run_pgr = "faas-pg-r" in methods
+      run_g = "faas-gcaa" in methods
+    # if the experiment is still to run...
+```
+
+Then modify the combined condition line immediately after:
+
+```python
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_hm or run_d or run_p or run_brs or run_brr or run_bro or run_pgs or run_pgr or run_g or generate_only:
+```
+
+- [ ] **Step 9: Add the dispatch block**
+
+In `run.py`, modify the dispatch section, immediately after the existing
+`run_pgr` dispatch block (which ends with the `set_solution_folder(...,
+"faas-pg-r", ...)` call) and before the `# -- save info` comment:
+
+```python
+      # -- solve potential game randomized (FaaS-MAPG-R)
+      if run_pgr:
+        pgr_folder = run_pg_r(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-pg-r", experiment_idx, pgr_folder
+        )
+      # -- solve greedy coalition auction (FaaS-MAGCAA)
+      if run_g:
+        g_folder = run_gcaa(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-gcaa", experiment_idx, g_folder
+        )
+      # -- save info
+```
+
+- [ ] **Step 10: Add the `gcaa` section to `config_files/planar_comparison.json`**
+
+(Needed now because `test_planar_config_has_gcaa_section` reads this
+file; the remaining config files are updated in Task 4.)
+
+Modify `config_files/planar_comparison.json`:
+
+```json
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+```
+
+- [ ] **Step 11: Run tests to verify they pass**
+
+Run: `pytest tests/test_gcaa_wiring.py -v`
+Expected: 6 passed
+
+- [ ] **Step 12: Run the full existing test suite to check for regressions**
+
+Run: `pytest tests/ -x -q`
+Expected: all tests pass (or skip, for Gurobi-dependent tests if Gurobi
+is unavailable in this environment) — no new failures introduced by the
+`run.py` edits
+
+- [ ] **Step 13: Commit**
+
+```bash
+git add run.py config_files/planar_comparison.json tests/test_gcaa_wiring.py
+git commit -m "$(cat <<'EOF'
+Register FaaS-MAGCAA in run.py
+
+Wires up --methods faas-gcaa, METHOD_RESULT_MODELS, and the
+per-experiment run/skip/dispatch flags, following the exact pattern
+already used for faas-pg-s/faas-pg-r.
+EOF
+)"
+```
+
+---
+
+## Task 4: Config files and end-to-end test
+
+**Files:**
+- Modify: `config_files/eval_full.json`, `config_files/eval_smoke.json`,
+  `config_files/eval_tuned_smoke.json`
+- Test: `tests/test_gcaa_e2e.py`
+
+**Interfaces:**
+- Consumes: `decentralized_gcaa.run` (Task 2)
+
+- [ ] **Step 1: Add the `gcaa` section to the remaining config files**
+
+Modify `config_files/eval_full.json` and `config_files/eval_smoke.json`
+(both share the same auction-block tail):
+
+```json
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+```
+
+Modify `config_files/eval_tuned_smoke.json` (its auction block ends with
+an explicit `"unit_bids": false` line):
+
+```json
+      "fairness_weight": 0.0,
+      "unit_bids": false
+    },
+    "gcaa": {
+      "unit_bids": true,
+      "epsilon": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0
+    },
+    "diffusion": {
+```
+
+- [ ] **Step 2: Verify all four config files still parse as valid JSON**
+
+Run:
+```bash
+python3 -c "
+import json
+for f in ['config_files/planar_comparison.json', 'config_files/eval_full.json', 'config_files/eval_smoke.json', 'config_files/eval_tuned_smoke.json']:
+    c = json.load(open(f))
+    assert c['solver_options']['gcaa']['unit_bids'] is True, f
+    print(f, 'OK')
+"
+```
+Expected: all four files print `OK`, no exceptions
+
+- [ ] **Step 3: Write the failing end-to-end test**
+
+Create `tests/test_gcaa_e2e.py`:
+
+```python
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+from parse import parse
+
+from decentralized_gcaa import run as run_gcaa
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "gcaa": {
+        "unit_bids": True, "epsilon": 0.01,
+        "latency_weight": 0.0, "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 50,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_run_gcaa_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_gcaa(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert "FaaS-MAGCAA" in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MAGCAA"], errors="coerce")).all()
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert len(tc) >= 1
+  for s in tc["0"]:
+    assert parse(
+      "{} (it: {}; obj. deviation: {}; best it: {}; total runtime: {})", s
+    ) is not None
+```
+
+- [ ] **Step 4: Run the test**
+
+Run: `pytest tests/test_gcaa_e2e.py -v`
+Expected: PASS if Gurobi is available, otherwise SKIPPED with reason
+"Gurobi solver is not available" (do not treat a skip as a failure — it
+mirrors the exact same skip behavior as `test_potentialgame_e2e.py`)
+
+- [ ] **Step 5: If Gurobi is available and the test fails, diagnose before
+  changing the consensus logic**
+
+The most likely failure mode is `max_iterations reached` before all load
+is assigned, given the single-winner-per-round rule needs one round per
+finalized unit in the worst case. If this happens, raise
+`max_iterations` in `_e2e_config` (not the production defaults) — this
+is a test-tuning concern, not a correctness bug, unless `obj.csv` /
+`runtime.csv` / `termination_condition.csv` are malformed.
+
+- [ ] **Step 6: Run the full test suite one more time**
+
+Run: `pytest tests/ -q`
+Expected: all tests pass or skip (Gurobi-dependent), zero failures
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add config_files/eval_full.json config_files/eval_smoke.json \
+  config_files/eval_tuned_smoke.json tests/test_gcaa_e2e.py
+git commit -m "$(cat <<'EOF'
+Add FaaS-MAGCAA config sections and end-to-end test
+
+Completes the FaaS-MAGCAA baseline: all four existing config files now
+carry a gcaa solver_options section, and an end-to-end test (skipped
+without Gurobi) exercises the full run() against a 10-node planar
+instance.
+EOF
+)"
+```
diff --git a/docs/superpowers/plans/2026-07-06-two-phase-campaign.md b/docs/superpowers/plans/2026-07-06-two-phase-campaign.md
new file mode 100644
index 0000000..a6788ef
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-06-two-phase-campaign.md
@@ -0,0 +1,970 @@
+# Two-Phase Auto-Chained Campaign — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace the 12,630-run `paper.py` campaign with a screen-then-confirm design (~1,900 runs) launched by one `campaign` command: a cheap screening suite ranks candidate algorithms by relative-to-best objective, the top 4 are auto-selected as survivors, then the confirmatory suites run only on survivors + the two anchors.
+
+**Architecture:** Three resumable stages behind `remote_experiments campaign run`: (1) run `paper-a-screening`; (2) parse its results and write `batches/survivors.json`; (3) `define`+`materialize`+`run` each confirmatory suite non-interactively, with the suite builders reading survivors from that file. New modules `results_reader.py`, `survivors.py`, `campaign.py`; edits to `definitions/paper.py` and `cli.py`.
+
+**Tech Stack:** Python 3.10, `uv`, `pytest`, `pandas` (already used by `compare_results.py`), `ray_dispatcher`.
+
+## Global Constraints
+
+- Two-space indentation, `from __future__ import annotations`, module docstring first line — match every file in `remote_experiments/`.
+- Optimization is **maximize** (`models/rmp.py:119`): higher objective is better; screening ranks by `reldef = (obj_best − obj)/obj_best·100`, smaller is better.
+- Anchors always in the confirmatory set and never promotable: `("centralized", "hierarchical-madea")`.
+- Confirmatory seed count: **5**. Screening seed count: **5**.
+- Weight-tunable algorithms (eligible for e7/e8): `{"hierarchical-madea": "auction", "faas-madea": "auction", "faas-diffuse": "diffusion", "faas-powd": "powerd"}` — any other survivor is excluded from e7/e8 only.
+- Tests live in `tests/test_*.py`, flat, run with `uv run pytest`.
+- Do **not** modify `build_e0` / `paper-e0-pilot`; it is superseded by screening but left intact.
+
+---
+
+### Task 1: `--yes` flag makes `run` non-interactive
+
+**Files:**
+- Modify: `remote_experiments/cli.py:38-53` (`cmd_run`), `remote_experiments/cli.py:110-119` (`run` parser)
+- Test: `tests/test_remote_experiments_cli.py`
+
+**Interfaces:**
+- Produces: `run` subcommand accepts `--yes`; when set, `cmd_run` selects all pending (no `input()`).
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `tests/test_remote_experiments_cli.py` (reuse the `_FakeDispatcher` pattern already in that file; do not add an `input` monkeypatch — its absence is the point):
+
+```python
+def test_cmd_run_yes_skips_prompt(tmp_path, monkeypatch):
+  batch = _write_smoke_batch(tmp_path)  # same helper the other run tests use
+  monkeypatch.setattr("remote_experiments.cli.Dispatcher", _FakeDispatcher)
+  monkeypatch.setattr(
+    "builtins.input",
+    lambda prompt: (_ for _ in ()).throw(AssertionError("prompt must not be called")),
+  )
+  args = build_parser().parse_args([
+    "run", str(batch), "--inventory", str(_write_inventory(tmp_path)), "--yes",
+  ])
+  cmd_run(args)  # must not raise
+```
+
+If `_write_smoke_batch` / `_write_inventory` helpers do not already exist in the test file, lift the inline setup from `test_cmd_run_wires_dispatcher_into_manifest` into small local helpers first.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_cli.py::test_cmd_run_yes_skips_prompt -v`
+Expected: FAIL — `--yes` is an unrecognized argument (SystemExit from argparse).
+
+- [ ] **Step 3: Implement**
+
+In `build_parser`, under the `run_p` block:
+
+```python
+  run_p.add_argument("--yes", action="store_true", help="Run all pending without prompting")
+```
+
+In `cmd_run`, replace the prompt block:
+
+```python
+  default_idx = default_selection(experiment_ids, manifest)
+  print(f"{len(batch.experiments)} experiments in batch, {len(default_idx)} pending")
+  for i, e in enumerate(batch.experiments):
+    print(f"  [{i}] {e.id} ({manifest.status(e.id)})")
+  if args.yes:
+    selected_idx = default_idx
+  else:
+    raw = input(f"Select to run [default: {len(default_idx)} pending] (indices/ranges/'all'): ")
+    selected_idx = parse_selection(raw, len(batch.experiments)) if raw.strip() else default_idx
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_cli.py -v`
+Expected: PASS (all cli tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/cli.py tests/test_remote_experiments_cli.py
+git commit -m "feat(remote): --yes runs all pending non-interactively"
+```
+
+---
+
+### Task 2: Survivors plumbing and shared constants in `paper.py`
+
+**Files:**
+- Modify: `remote_experiments/definitions/paper.py` (top-of-module constants + helpers)
+- Test: `tests/test_paper_experiment_suites.py`
+
+**Interfaces:**
+- Produces: `ANCHORS: tuple[str, ...]`, `DEFAULT_SURVIVORS: tuple[str, ...]`, `WEIGHT_TUNABLE: dict[str, str]`, `SURVIVORS_PATH: Path`, `_survivors() -> tuple[str, ...]`, `_final_algorithms() -> tuple[str, ...]`, `_tunable(algos) -> tuple[str, ...]`. `CONFIRMATORY_SEEDS = tuple(range(1001, 1006))`.
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `tests/test_paper_experiment_suites.py`:
+
+```python
+import json
+from remote_experiments.definitions import paper as paper_mod
+
+
+def test_survivors_fallback_when_file_absent(tmp_path, monkeypatch):
+  monkeypatch.setattr(paper_mod, "SURVIVORS_PATH", tmp_path / "missing.json")
+  assert paper_mod._survivors() == paper_mod.DEFAULT_SURVIVORS
+  assert paper_mod._final_algorithms() == paper_mod.ANCHORS + paper_mod.DEFAULT_SURVIVORS
+
+
+def test_survivors_read_from_file(tmp_path, monkeypatch):
+  path = tmp_path / "survivors.json"
+  path.write_text(json.dumps({"survivors": ["faas-gcaa", "faas-pg-s", "faas-powd", "faas-diffuse"]}))
+  monkeypatch.setattr(paper_mod, "SURVIVORS_PATH", path)
+  assert paper_mod._survivors() == ("faas-gcaa", "faas-pg-s", "faas-powd", "faas-diffuse")
+
+
+def test_confirmatory_seeds_are_five():
+  assert len(paper_mod.CONFIRMATORY_SEEDS) == 5
+
+
+def test_tunable_filters_non_weight_algorithms():
+  assert paper_mod._tunable(("hierarchical-madea", "faas-powd", "faas-br-o")) == (
+    "hierarchical-madea", "faas-powd",
+  )
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py::test_survivors_fallback_when_file_absent -v`
+Expected: FAIL — `paper` has no attribute `SURVIVORS_PATH`.
+
+- [ ] **Step 3: Implement**
+
+In `remote_experiments/definitions/paper.py`, replace the `CONFIRMATORY_SEEDS`/`ALL_ALGORITHMS`/`REPRESENTATIVE_ALGORITHMS`/`TRADEOFF_ALGORITHMS` block near the top with:
+
+```python
+PILOT_SEEDS = tuple(range(1, 11))
+CONFIRMATORY_SEEDS = tuple(range(1001, 1006))
+
+ALL_ALGORITHMS = (
+  "centralized", "faas-macro", "faas-macro-v0", "faas-madea", "hierarchical-madea",
+  "faas-diffuse", "faas-powd", "faas-br-s", "faas-br-r", "faas-br-o",
+)
+ANCHORS = ("centralized", "hierarchical-madea")
+DEFAULT_SURVIVORS = ("faas-madea", "faas-diffuse", "faas-powd", "faas-br-o")
+WEIGHT_TUNABLE = {
+  "hierarchical-madea": "auction", "faas-madea": "auction",
+  "faas-diffuse": "diffusion", "faas-powd": "powerd",
+}
+SURVIVORS_PATH = Path(__file__).resolve().parents[2] / "batches" / "survivors.json"
+
+SCREENING_CANDIDATES = (
+  "faas-macro", "faas-macro-v0", "faas-madea", "faas-diffuse", "faas-powd",
+  "faas-br-s", "faas-br-r", "faas-br-o", "faas-pg-s", "faas-pg-r", "faas-gcaa", "plasma",
+)
+
+
+def _survivors() -> tuple[str, ...]:
+  if SURVIVORS_PATH.exists():
+    return tuple(json.loads(SURVIVORS_PATH.read_text())["survivors"])
+  return DEFAULT_SURVIVORS
+
+
+def _final_algorithms() -> tuple[str, ...]:
+  return ANCHORS + _survivors()
+
+
+def _tunable(algorithms: tuple[str, ...]) -> tuple[str, ...]:
+  return tuple(a for a in algorithms if a in WEIGHT_TUNABLE)
+```
+
+Keep the existing `NON_CENTRALIZED_ALGORITHMS = tuple(a for a in ALL_ALGORITHMS if a != "centralized")` line. `json` and `Path` are already imported at the top of the file.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py -k "survivors or seeds or tunable" -v`
+Expected: PASS (4 new tests). Existing count tests still fail — fixed in Task 4.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/definitions/paper.py tests/test_paper_experiment_suites.py
+git commit -m "feat(paper): survivors plumbing, anchors, tunable filter, 5 seeds"
+```
+
+---
+
+### Task 3: `paper-a-screening` suite
+
+**Files:**
+- Modify: `remote_experiments/definitions/paper.py` (new `build_screening`)
+- Test: `tests/test_paper_experiment_suites.py`
+
+**Interfaces:**
+- Consumes: `SCREENING_CANDIDATES`, `_new_config`, `_euclidean_planar`, `_experiment` (all in `paper.py`).
+- Produces: `build_screening(seeds=..., ) -> list[Experiment]` registered as `paper-a-screening`.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+from remote_experiments.definitions.paper import build_screening
+
+def test_screening_count_algorithms_and_no_centralized():
+  experiments = build_screening()
+  assert len(experiments) == 260                      # 13 algos x {50,100}x{2,4} x 5 seeds
+  algos = {e.algorithm for e in experiments}
+  assert "centralized" not in algos
+  assert "hierarchical-madea" in algos                # reference for obj_best
+  assert algos == set(paper_mod.SCREENING_CANDIDATES) | {"hierarchical-madea"}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {50, 100}
+  assert len({e.id for e in experiments}) == 260
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py::test_screening_count_algorithms_and_no_centralized -v`
+Expected: FAIL — cannot import `build_screening`.
+
+- [ ] **Step 3: Implement**
+
+Add to `paper.py` (after `build_e0`):
+
+```python
+@register_suite("paper-a-screening")
+def build_screening(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = SCREENING_CANDIDATES + ("hierarchical-madea",),
+  ) -> list[Experiment]:
+  suite = "paper-a-screening"
+  return [
+    _experiment(
+      suite, f"n{nodes}-f{functions}-planar3", algorithm, seed,
+      _new_config(nodes, functions, _euclidean_planar()),
+    )
+    for nodes in (50, 100)
+    for functions in (2, 4)
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+```
+
+Add `"paper-a-screening"` to the expected set in `test_paper_suites_are_registered`.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py -k "screening or registered" -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/definitions/paper.py tests/test_paper_experiment_suites.py
+git commit -m "feat(paper): paper-a-screening suite (260 runs, relative-to-best)"
+```
+
+---
+
+### Task 4: Rewire confirmatory suites e1–e8 to survivors
+
+**Files:**
+- Modify: `remote_experiments/definitions/paper.py` (`build_e1`..`build_e8`)
+- Test: `tests/test_paper_experiment_suites.py`
+
+**Interfaces:**
+- Consumes: `_final_algorithms`, `_survivors`, `_tunable`, `ANCHORS`, `CONFIRMATORY_SEEDS`.
+
+- [ ] **Step 1: Update the count tests to the new expected values**
+
+Replace the existing count assertions in `tests/test_paper_experiment_suites.py`:
+
+```python
+def test_e1_default_count_and_unique_ids():
+  experiments = build_e1()
+  assert len(experiments) == 180                    # 3 nodes x 2 funcs x 6 algos x 5 seeds
+  assert len({e.id for e in experiments}) == 180
+  assert set(e.algorithm for e in experiments) == set(paper_mod._final_algorithms())
+
+def test_e2_count_and_centralized_size_limit():
+  experiments = build_e2()
+  assert len(experiments) == 480
+  centralized_sizes = {
+    e.config["limits"]["Nn"]["min"]
+    for e in experiments if e.algorithm == "centralized"
+  }
+  assert centralized_sizes == {10, 20}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {10, 20, 50, 100, 200, 500}
+
+def test_e3_count_and_topology_coverage():
+  assert len(build_e3()) == 180
+
+def test_e4_count_and_conditions():
+  experiments = build_e4()
+  assert len(experiments) == 7 * 6 * 5
+
+def test_e5_count_trace_coverage_and_steps():
+  experiments = build_e5()
+  assert len(experiments) == 3 * 6 * 5
+  assert {e.config["max_steps"] for e in experiments} == {100}
+
+def test_e6_default_count_and_hierarchical_only():
+  experiments = build_e6()
+  assert len(experiments) == 100                    # 10 variants x 1 node x 2 topo x 5
+  assert {e.algorithm for e in experiments} == {"hierarchical-madea"}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {50}
+
+def test_e7_default_count_and_weight_pairs():
+  experiments = build_e7()
+  assert len(experiments) == 7 * 2 * 4 * 5          # 4 = tunable subset of FINAL
+  assert {e.algorithm for e in experiments} == {
+    "hierarchical-madea", "faas-madea", "faas-diffuse", "faas-powd",
+  }
+
+def test_e8_default_count_and_spatial_latency_coverage():
+  experiments = paper.build_e8()
+  assert len(experiments) == 3 * 2 * 4 * 5
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {20, 50, 100}
+```
+
+Delete `test_e1_expands_function_vectors_and_output_folder`'s dependence on `algorithms=("hierarchical",)`? No — leave it; `build_e1` keeps its `algorithms` keyword. Keep `test_generated_config_builds_a_real_instance` and `test_paper_experiments_round_trip_as_batch` (they pass explicit `algorithms=`).
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py -k "e1 or e2 or e3 or e4 or e5 or e6 or e7 or e8" -v`
+Expected: FAIL with old counts (1800/4230/…).
+
+- [ ] **Step 3: Implement**
+
+In `paper.py`, change the builder signatures/defaults:
+
+`build_e1`: default `algorithms: tuple[str, ...] = ()` and, at call, `algorithms = algorithms or _final_algorithms()`. Concretely:
+
+```python
+@register_suite("paper-e1-quality-runtime")
+def build_e1(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e1-quality-runtime"
+  algorithms = algorithms or _final_algorithms()
+  return [
+    _experiment(
+      suite, f"n{nodes}-f{functions}-planar3", algorithm, seed,
+      _new_config(nodes, functions, _euclidean_planar()),
+    )
+    for nodes in (10, 20, 30)
+    for functions in (2, 4)
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+```
+
+`build_e2`: add 500 to the node loop and switch the non-centralized set to survivors + `hierarchical-madea`:
+
+```python
+@register_suite("paper-e2-scalability")
+def build_e2(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+  ) -> list[Experiment]:
+  suite = "paper-e2-scalability"
+  scalable = ("hierarchical-madea",) + _survivors()
+  experiments = []
+  for nodes in (10, 20, 50, 100, 200, 500):
+    algorithms = scalable + (("centralized",) if nodes <= 20 else ())
+    for functions in (2, 4, 8):
+      for algorithm in algorithms:
+        for seed in seeds:
+          experiments.append(_experiment(
+            suite, f"n{nodes}-f{functions}-reg3", algorithm, seed,
+            _new_config(nodes, functions, {"k": 3}),
+          ))
+  return experiments
+```
+
+`build_e3`, `build_e4`, `build_e5`: change their `algorithms` default from `REPRESENTATIVE_ALGORITHMS` to `()` and add `algorithms = algorithms or _final_algorithms()` as the first line of the body (same pattern as e1).
+
+`build_e6`: change the node loop from `for nodes in (20, 50):` to `for nodes in (50,):`. No other change.
+
+`build_e7`: default `algorithms: tuple[str, ...] = ()`; first body line `algorithms = algorithms or _tunable(_final_algorithms())`. The existing `section = {...}[algorithm]` map must be replaced with `section = WEIGHT_TUNABLE[algorithm]` (guaranteed present because `_tunable` filtered).
+
+`build_e8`: same treatment as e7 — default `()`, `algorithms = algorithms or _tunable(_final_algorithms())`, and `section = WEIGHT_TUNABLE[algorithm]`.
+
+Delete the now-unused `REPRESENTATIVE_ALGORITHMS` and `TRADEOFF_ALGORITHMS` constants if nothing else references them (grep first).
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_paper_experiment_suites.py -v`
+Expected: PASS (all).
+
+- [ ] **Step 5: Verify total campaign size**
+
+Run:
+```bash
+uv run python -c "
+from remote_experiments.definitions import paper as p
+suites=['build_screening','build_e1','build_e2','build_e3','build_e4','build_e5','build_e6','build_e7','build_e8']
+tot=sum(len(getattr(p,s)()) for s in suites)
+print('total', tot)
+assert tot == 1900, tot
+"
+```
+Expected: `total 1900`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add remote_experiments/definitions/paper.py tests/test_paper_experiment_suites.py
+git commit -m "feat(paper): confirmatory suites on survivors+anchors, e2 n=500, e6 n=50"
+```
+
+---
+
+### Task 5: `results_reader.py` — per-run objective/runtime/failure
+
+**Files:**
+- Create: `remote_experiments/results_reader.py`
+- Test: `tests/test_remote_experiments_results_reader.py`
+
+**Interfaces:**
+- Produces:
+  - `read_run_objective(run_dir: Path) -> float | None` — mean of the single data column of the first `obj.csv` found under `run_dir`; `None` if no `obj.csv` or it is empty.
+  - `read_run_runtime(run_dir: Path) -> float | None` — mean of the single data column of the first `runtime.csv`; `None` if absent.
+  - `run_failed(run_dir: Path) -> bool` — `read_run_objective(run_dir) is None`.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+from pathlib import Path
+from remote_experiments.results_reader import (
+  read_run_objective, read_run_runtime, run_failed,
+)
+
+
+def _make_run(tmp_path: Path, obj_rows, runtime_rows=None) -> Path:
+  run = tmp_path / "exp-id" / "2026-07-06_00-00-00.000000"
+  run.mkdir(parents=True)
+  if obj_rows is not None:
+    (run / "obj.csv").write_text("Model\n" + "\n".join(str(v) for v in obj_rows) + "\n")
+  if runtime_rows is not None:
+    (run / "runtime.csv").write_text("tot\n" + "\n".join(str(v) for v in runtime_rows) + "\n")
+  return tmp_path / "exp-id"
+
+
+def test_read_objective_is_column_mean(tmp_path):
+  run = _make_run(tmp_path, [10.0, 20.0, 30.0])
+  assert read_run_objective(run) == 20.0
+
+
+def test_read_runtime_is_column_mean(tmp_path):
+  run = _make_run(tmp_path, [1.0], runtime_rows=[0.2, 0.4])
+  assert read_run_runtime(run) == 0.3
+
+
+def test_missing_obj_is_failure(tmp_path):
+  run = _make_run(tmp_path, None)
+  assert read_run_objective(run) is None
+  assert run_failed(run) is True
+
+
+def test_present_obj_is_not_failure(tmp_path):
+  run = _make_run(tmp_path, [5.0])
+  assert run_failed(run) is False
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_results_reader.py -v`
+Expected: FAIL — module does not exist.
+
+- [ ] **Step 3: Implement**
+
+Create `remote_experiments/results_reader.py`:
+
+```python
+"""Read a single experiment's objective/runtime from its output CSVs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+
+
+def _first_column_mean(run_dir: Path, filename: str) -> float | None:
+  matches = sorted(Path(run_dir).rglob(filename))
+  if not matches:
+    return None
+  frame = pd.read_csv(matches[0])
+  if frame.empty or frame.shape[1] == 0:
+    return None
+  return float(frame.iloc[:, 0].mean())
+
+
+def read_run_objective(run_dir: Path) -> float | None:
+  return _first_column_mean(run_dir, "obj.csv")
+
+
+def read_run_runtime(run_dir: Path) -> float | None:
+  return _first_column_mean(run_dir, "runtime.csv")
+
+
+def run_failed(run_dir: Path) -> bool:
+  return read_run_objective(run_dir) is None
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_results_reader.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/results_reader.py tests/test_remote_experiments_results_reader.py
+git commit -m "feat(remote): results_reader for per-run objective/runtime"
+```
+
+---
+
+### Task 6: `survivors.py` — relative-to-best selection
+
+**Files:**
+- Create: `remote_experiments/survivors.py`
+- Test: `tests/test_remote_experiments_survivors.py`
+
+**Interfaces:**
+- Consumes: `Batch`/`Experiment` (`batch.py`), `read_run_objective`/`read_run_runtime`/`run_failed` (`results_reader.py`).
+- Produces: `select_survivors(batch: Batch, results_dir: Path, *, anchors: tuple[str, ...] = ("centralized", "hierarchical-madea"), n: int = 4, min_valid_fraction: float = 0.8) -> list[str]`. Raises `SurvivorSelectionError` when the guard trips.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+import pytest
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.survivors import select_survivors, SurvivorSelectionError
+
+
+def _exp(algo, nodes, seed):
+  return Experiment(
+    id=f"paper-a-screening-n{nodes}-f2-planar3-{algo}-s{seed}",
+    suite="paper-a-screening", algorithm=algo, seed=seed,
+    graph_params={"Nn": {"min": nodes, "max": nodes}, "Nf": {"min": 2, "max": 2}},
+    load_params={}, config={},
+  )
+
+
+def _write_result(results_dir, exp, obj, runtime=0.1):
+  run = results_dir / exp.id / "2026-07-06_00-00-00.000000"
+  run.mkdir(parents=True)
+  if obj is not None:
+    (run / "obj.csv").write_text(f"Model\n{obj}\n")
+  (run / "runtime.csv").write_text(f"tot\n{runtime}\n")
+
+
+def test_selects_lowest_relative_deficit(tmp_path):
+  # per instance obj_best is the max; rank candidates by mean deficit to it
+  objs = {  # algo -> obj on the single instance (n50, seed1)
+    "hierarchical-madea": 100.0,  # anchor, best, but not promotable
+    "faas-madea": 99.0, "faas-diffuse": 98.0, "faas-powd": 97.0,
+    "faas-br-o": 96.0, "faas-gcaa": 50.0,
+  }
+  exps = [_exp(a, 50, 1) for a in objs]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  for e in exps:
+    _write_result(tmp_path, e, objs[e.algorithm])
+  survivors = select_survivors(batch, tmp_path, n=4)
+  assert survivors == ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+  assert "hierarchical-madea" not in survivors
+
+
+def test_runtime_breaks_ties(tmp_path):
+  exps = [_exp("faas-madea", 50, 1), _exp("faas-powd", 50, 1),
+          _exp("hierarchical-madea", 50, 1)]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  _write_result(tmp_path, exps[0], 90.0, runtime=0.5)
+  _write_result(tmp_path, exps[1], 90.0, runtime=0.1)   # same obj, faster
+  _write_result(tmp_path, exps[2], 100.0, runtime=0.9)
+  assert select_survivors(batch, tmp_path, n=1) == ["faas-powd"]
+
+
+def test_guard_trips_on_too_many_failures(tmp_path):
+  exps = [_exp("faas-madea", 50, 1), _exp("faas-powd", 50, 1)]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  _write_result(tmp_path, exps[0], 90.0)
+  _write_result(tmp_path, exps[1], None)   # failed
+  with pytest.raises(SurvivorSelectionError):
+    select_survivors(batch, tmp_path, n=1, min_valid_fraction=0.8)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_survivors.py -v`
+Expected: FAIL — module does not exist.
+
+- [ ] **Step 3: Implement**
+
+Create `remote_experiments/survivors.py`:
+
+```python
+"""Select survivor algorithms from screening results by relative-to-best objective."""
+
+from __future__ import annotations
+
+import statistics
+from pathlib import Path
+
+from .batch import Batch
+from .results_reader import read_run_objective, read_run_runtime
+
+
+class SurvivorSelectionError(RuntimeError):
+  """Raised when screening results are too degenerate to promote survivors."""
+
+
+def _instance_key(experiment) -> tuple[int, int, int]:
+  limits = experiment.graph_params
+  return (limits["Nn"]["min"], limits["Nf"]["min"], experiment.seed)
+
+
+def select_survivors(
+    batch: Batch,
+    results_dir: Path,
+    *,
+    anchors: tuple[str, ...] = ("centralized", "hierarchical-madea"),
+    n: int = 4,
+    min_valid_fraction: float = 0.8,
+  ) -> list[str]:
+  results_dir = Path(results_dir)
+  obj_by_algo: dict[str, dict[tuple, float]] = {}
+  runtime_by_algo: dict[str, list[float]] = {}
+  valid = 0
+  for e in batch.experiments:
+    objective = read_run_objective(results_dir / e.id)
+    if objective is None:
+      continue
+    valid += 1
+    obj_by_algo.setdefault(e.algorithm, {})[_instance_key(e)] = objective
+    runtime = read_run_runtime(results_dir / e.id)
+    if runtime is not None:
+      runtime_by_algo.setdefault(e.algorithm, []).append(runtime)
+
+  if valid < min_valid_fraction * len(batch.experiments):
+    raise SurvivorSelectionError(
+      f"only {valid}/{len(batch.experiments)} screening runs valid "
+      f"(< {min_valid_fraction:.0%}); refusing to promote"
+    )
+
+  # obj_best per instance across every algorithm that ran it
+  best: dict[tuple, float] = {}
+  for per_instance in obj_by_algo.values():
+    for key, value in per_instance.items():
+      best[key] = max(value, best.get(key, float("-inf")))
+
+  candidates = [a for a in obj_by_algo if a not in anchors]
+  scored = []
+  for algo in candidates:
+    deficits = [
+      (best[key] - obj) / best[key] * 100.0
+      for key, obj in obj_by_algo[algo].items()
+    ]
+    reldef = statistics.fmean(deficits)
+    runtime = statistics.median(runtime_by_algo.get(algo, [float("inf")]))
+    scored.append((reldef, runtime, algo))
+
+  if len(scored) < n:
+    raise SurvivorSelectionError(
+      f"only {len(scored)} candidate algorithms produced valid runs; need {n}"
+    )
+  scored.sort(key=lambda t: (t[0], t[1]))
+  return [algo for _, _, algo in scored[:n]]
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `uv run pytest tests/test_remote_experiments_survivors.py -v`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add remote_experiments/survivors.py tests/test_remote_experiments_survivors.py
+git commit -m "feat(remote): relative-to-best survivor selection with guard"
+```
+
+---
+
+### Task 7: `campaign.py` orchestrator + `campaign` subcommand
+
+**Files:**
+- Create: `remote_experiments/campaign.py`
+- Modify: `remote_experiments/cli.py` (extract `execute_batch`, add `campaign` subcommand)
+- Test: `tests/test_remote_experiments_campaign.py`
+
+**Interfaces:**
+- Consumes: `get_suite`, `Batch`, `materialize_batch`, `Manifest`, `select_survivors`, and a batch-execution callable.
+- Produces:
+  - `execute_batch(batch_path, args) -> None` in `cli.py` — the Dispatcher/Project/run_batch wiring currently inside `cmd_run`, callable non-interactively (`select all pending`).
+  - `run_campaign(args) -> None` in `campaign.py` — drives stages via `campaign-state.json`.
+  - `CONFIRMATORY_SUITES: tuple[str, ...]`, `SCREENING_SUITE = "paper-a-screening"`, `write_survivors(path, survivors)`.
+
+- [ ] **Step 1: Write the failing test (stage sequencing with fakes)**
+
+```python
+import json
+from pathlib import Path
+import remote_experiments.campaign as campaign
+
+
+def test_campaign_runs_screening_then_selects_then_confirms(tmp_path, monkeypatch):
+  calls = []
+
+  def fake_run_suite(suite, args, state):
+    calls.append(suite)
+
+  def fake_select(batch, results_dir, **kw):
+    return ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+
+  monkeypatch.setattr(campaign, "_run_suite", fake_run_suite)
+  monkeypatch.setattr(campaign, "select_survivors", fake_select)
+  monkeypatch.setattr(campaign, "SURVIVORS_PATH", tmp_path / "survivors.json")
+  monkeypatch.setattr(campaign, "STATE_PATH", tmp_path / "campaign-state.json")
+
+  args = _fake_args(tmp_path)   # namespace with inventory/results-dir/etc.
+  campaign.run_campaign(args)
+
+  assert calls[0] == "paper-a-screening"
+  assert calls[1:] == list(campaign.CONFIRMATORY_SUITES)
+  survivors = json.loads((tmp_path / "survivors.json").read_text())["survivors"]
+  assert survivors == ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+
+
+def test_campaign_resumes_from_state(tmp_path, monkeypatch):
+  calls = []
+  monkeypatch.setattr(campaign, "_run_suite", lambda s, a, st: calls.append(s))
+  monkeypatch.setattr(campaign, "select_survivors", lambda *a, **k: ["x", "y", "z", "w"])
+  monkeypatch.setattr(campaign, "SURVIVORS_PATH", tmp_path / "survivors.json")
+  state = tmp_path / "campaign-state.json"
+  monkeypatch.setattr(campaign, "STATE_PATH", state)
+  (tmp_path / "survivors.json").write_text(json.dumps({"survivors": ["x", "y", "z", "w"]}))
+  state.write_text(json.dumps({"stage": "confirm", "done_suites": ["paper-e1-quality-runtime"]}))
+
+  campaign.run_campaign(_fake_args(tmp_path))
+  assert "paper-a-screening" not in calls
+  assert "paper-e1-quality-runtime" not in calls
+  assert calls[0] == "paper-e2-scalability"
+```
+
+Add a `_fake_args(tmp_path)` helper returning an `argparse.Namespace` with the fields `execute_batch`/`_run_suite` read (inventory, results_dir, instances, gurobi_license, project_path, python_version, uv_version).
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `uv run pytest tests/test_remote_experiments_campaign.py -v`
+Expected: FAIL — module does not exist.
+
+- [ ] **Step 3: Extract `execute_batch` in `cli.py`**
+
+Move the body of `cmd_run` after selection (the `Inventory.from_yaml(...)` through the completion print) into:
+
+```python
+def execute_batch(batch, manifest, manifest_path, selected, args) -> bool:
+  inventory = Inventory.from_yaml(args.inventory)
+  secrets = ()
+  if args.gurobi_license:
+    secrets = (
+      SecretFile(source=args.gurobi_license, remote_name="gurobi.lic", env_var="GRB_LICENSE_FILE"),
+    )
+  project = Project(
+    path=str(Path(args.project_path).resolve()),
+    project_id="dfaas-optimizer",
+    python=args.python_version,
+    uv_version=args.uv_version,
+    secrets=secrets,
+    exclude=(
+      ".venv/", ".git/", "solutions/", "results/", "batches/",
+      "remote_experiments/instances/",
+    ),
+  )
+  config_dir = manifest_path.parent / f"{manifest_path.stem}-configs"
+  jobs = [experiment_to_job(e, config_dir, Path(args.instances)) for e in selected]
+  with Dispatcher(inventory, project, results_dir=args.results_dir) as dispatcher:
+    start = time.monotonic()
+    with live_view(batch, manifest, inventory, start_time=start) as on_tick:
+      return run_batch(dispatcher, jobs, manifest, on_tick)
+```
+
+`cmd_run` keeps its selection logic (incl. `--yes` from Task 1) and calls `execute_batch(...)`, then prints the completion/failure summary as before.
+
+- [ ] **Step 4: Implement `campaign.py`**
+
+```python
+"""Orchestrate the two-phase campaign: screening -> select survivors -> confirm."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .batch import Batch
+from .definitions import get_suite
+from .definitions.paper import SURVIVORS_PATH
+from .instances import materialize_batch
+from .manifest import Manifest
+from .selection import default_selection
+from .survivors import select_survivors
+
+SCREENING_SUITE = "paper-a-screening"
+CONFIRMATORY_SUITES = (
+  "paper-e1-quality-runtime", "paper-e2-scalability", "paper-e3-topology",
+  "paper-e4-robustness", "paper-e5-dynamics", "paper-e6-ablation",
+  "paper-e7-tradeoffs", "paper-e8-spatial-latency",
+)
+STATE_PATH = Path("batches") / "campaign-state.json"
+
+
+def _load_state() -> dict:
+  if STATE_PATH.exists():
+    return json.loads(STATE_PATH.read_text())
+  return {"stage": "screening", "done_suites": []}
+
+
+def _save_state(state: dict) -> None:
+  STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+  STATE_PATH.write_text(json.dumps(state, indent=2))
+
+
+def write_survivors(path: Path, survivors: list[str]) -> None:
+  Path(path).parent.mkdir(parents=True, exist_ok=True)
+  Path(path).write_text(json.dumps({"survivors": survivors}, indent=2))
+
+
+def _batch_path(suite: str) -> Path:
+  return Path("batches") / f"{suite}.json"
+
+
+def _define_and_materialize(suite: str, instances_root: str) -> Batch:
+  batch = Batch(suite=suite, experiments=tuple(get_suite(suite)()))
+  path = _batch_path(suite)
+  batch.save(path)
+  materialize_batch(batch, instances_root)
+  return batch
+
+
+def _run_suite(suite: str, args, state: dict) -> None:
+  # imported lazily to avoid a cli<->campaign import cycle
+  from .cli import execute_batch
+  batch = _define_and_materialize(suite, args.instances)
+  manifest_path = _batch_path(suite).with_suffix(".manifest.json")
+  manifest = Manifest(manifest_path)
+  selected_idx = default_selection([e.id for e in batch.experiments], manifest)
+  selected = [batch.experiments[i] for i in selected_idx]
+  if selected:
+    execute_batch(batch, manifest, manifest_path, selected, args)
+
+
+def run_campaign(args) -> None:
+  state = _load_state()
+
+  if state["stage"] == "screening":
+    _run_suite(SCREENING_SUITE, args, state)
+    state["stage"] = "select"
+    _save_state(state)
+
+  if state["stage"] == "select":
+    batch = Batch.load(_batch_path(SCREENING_SUITE))
+    survivors = select_survivors(batch, Path(args.results_dir))
+    write_survivors(SURVIVORS_PATH, survivors)
+    print(f"survivors: {survivors}")
+    state["stage"] = "confirm"
+    _save_state(state)
+
+  if state["stage"] == "confirm":
+    for suite in CONFIRMATORY_SUITES:
+      if suite in state["done_suites"]:
+        continue
+      _run_suite(suite, args, state)
+      state["done_suites"].append(suite)
+      _save_state(state)
+  print("campaign complete")
+```
+
+- [ ] **Step 5: Wire the `campaign` subcommand in `cli.py`**
+
+```python
+def cmd_campaign(args: argparse.Namespace) -> None:
+  from .campaign import run_campaign
+  run_campaign(args)
+```
+
+In `build_parser`, add (share the same optional args as `run`):
+
+```python
+  campaign_p = sub.add_parser("campaign", help="Run the full two-phase campaign (screen->select->confirm)")
+  campaign_p.add_argument("--inventory", required=True)
+  campaign_p.add_argument("--project-path", default=".")
+  campaign_p.add_argument("--results-dir", default="./results")
+  campaign_p.add_argument("--instances", default="remote_experiments/instances")
+  campaign_p.add_argument("--gurobi-license", default=None)
+  campaign_p.add_argument("--python-version", default="3.10.19")
+  campaign_p.add_argument("--uv-version", default="0.11.25")
+  campaign_p.set_defaults(func=cmd_campaign)
+```
+
+- [ ] **Step 6: Run tests to verify they pass**
+
+Run: `uv run pytest tests/test_remote_experiments_campaign.py tests/test_remote_experiments_cli.py -v`
+Expected: PASS (campaign sequencing + resume, and cli still green after the `execute_batch` extraction).
+
+- [ ] **Step 7: Full suite regression**
+
+Run: `uv run pytest tests/ -k "remote or paper or campaign or survivors or results_reader" -q`
+Expected: PASS.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add remote_experiments/campaign.py remote_experiments/cli.py tests/test_remote_experiments_campaign.py
+git commit -m "feat(remote): campaign orchestrator with resumable screen/select/confirm"
+```
+
+---
+
+### Task 8: Docs — README campaign flow
+
+**Files:**
+- Modify: `remote_experiments/README.md` (replace the "Paper experiment batches" section)
+
+- [ ] **Step 1: Replace the manual per-suite loop instructions**
+
+Under "Paper experiment batches", document the one-command flow:
+
+```markdown
+## Run the two-phase paper campaign
+
+One command runs screening, auto-selects the 4 survivor algorithms, then runs
+the confirmatory suites on survivors + anchors (centralized, hierarchical-madea):
+
+    uv run -m remote_experiments campaign --inventory my-inventory.yaml \
+      --gurobi-license ~/gurobi.lic
+
+Progress is checkpointed in `batches/campaign-state.json` and each suite has its
+own `batches/<suite>.manifest.json`, so re-running `campaign` resumes where it
+stopped. Survivors are written to `batches/survivors.json`; delete it (and reset
+the state file to `{"stage":"screening","done_suites":[]}`) to re-screen.
+
+To inspect a single suite without the orchestrator, the old
+`define`/`materialize`/`run` commands still work (add `--yes` to `run` to skip
+the prompt).
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add remote_experiments/README.md
+git commit -m "docs(remote): document one-command two-phase campaign"
+```
+
+---
+
+## Self-Review notes
+
+- **Spec coverage:** screening suite (T3), relative-to-best metric incl. anchor-as-reference and non-promotable (T6), 5 seeds (T2), e2 n=500 / e6 n=50 (T4), tunable e7/e8 subset (T2+T4), `--yes` (T1), survivors.json injection (T2), orchestrator + campaign-state resume + guard (T6+T7), fallback when survivors.json absent (T2), README (T8). Total-count check (1900) in T4.
+- **Not automated (by design):** none — full auto-chain per approved spec. The only stop is the guard raising `SurvivorSelectionError`.
+- **Type consistency:** `select_survivors(batch, results_dir, *, anchors, n, min_valid_fraction)` used identically in T6 and T7; `execute_batch(batch, manifest, manifest_path, selected, args)` defined in T7 Step 3 and called in `cmd_run` and `_run_suite`; `SURVIVORS_PATH` is the single source in `paper.py`, imported by `campaign.py`.
+- **Statistical note (spec):** 5-seed thinness is a reporting caveat, not code; `CONFIRMATORY_SEEDS` is one editable tuple (T2) — no task needed.
diff --git a/docs/superpowers/specs/2026-06-25-distributed-heuristic-alternatives.md b/docs/superpowers/specs/2026-06-25-distributed-heuristic-alternatives.md
new file mode 100644
index 0000000..f4afef0
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-25-distributed-heuristic-alternatives.md
@@ -0,0 +1,66 @@
+# Distributed coordination heuristics — alternatives considered
+
+**Date:** 2026-06-25
+**Status:** Reference / future work
+
+This note records the distributed-coordination heuristics considered as
+alternatives to the auction-based methods (FaaS-MADeA, HierarchicalAuction) for
+the DiFRALB problem. The chosen method, **FaaS-MADiG** (greedy proportional
+diffusion), is specified in
+`2026-06-25-faas-madig-distributed-heuristic-design.md`. The two options below
+were deliberately deferred.
+
+All options share the same frame as the auctions: each node solves the local
+`LSP`/`LSPr` MILP to fix replicas `r`, local load `x`, and residual load
+`omega`; only the inter-node coordination (the replacement for `define_bids` +
+`evaluate_bids` + price update) differs.
+
+## Option B — Power-of-d-choices (randomized, lightweight)
+
+**Mechanism.** For each function `f`, every overloaded node samples `d` random
+neighbors (e.g. `d = 2`), queries their residual capacity `blackboard[j,f]`, and
+forwards its residual load to the best of the sampled neighbors (most residual
+capacity, or highest `score`). No global preference ranking; minimal
+communication and state.
+
+**Pros.**
+- Models realistic stateless gossip / randomized load balancing.
+- Very low computational and communication cost; trivially distributed.
+
+**Cons.**
+- Stochastic → requires averaging over multiple seeds for fair reporting.
+- Typically sub-optimal; weakly tied to the objective weights `beta`.
+- Harder to compare head-to-head with the deterministic auctions.
+
+**When to revisit.** If we want to position FaaS-MADiG on a spectrum
+*market → greedy → random*, B is the natural lightweight endpoint and a cheap
+add-on once `define_assignments`/`evaluate_assignments` exist.
+
+## Option C — Distributed best-response (Gauss-Seidel relaxation)
+
+**Mechanism.** Treat neighbor residual capacity as a shared resource. In each
+round, nodes (in a fixed order) claim capacity by computing their best response
+to the current claims — i.e. re-optimize their local marginal cost given what
+neighbors have taken — iterating toward a fixed point / equilibrium.
+
+**Pros.**
+- More "intelligent"; tends toward an equilibrium allocation.
+- Can yield higher-quality solutions than plain greedy.
+
+**Cons.**
+- Heavier per iteration (repeated local re-optimization).
+- Conceptually close to the auction and to the FaaS-MACrO decomposition →
+  weak contrast; risks blurring the comparison the study aims to make.
+
+**When to revisit.** If FaaS-MADiG proves too myopic and we need a stronger
+solver-light competitor that still avoids an explicit market.
+
+## Decision rationale (why A / FaaS-MADiG was chosen)
+
+- **Cleanest ablation:** identical information and local plan as the auctions,
+  differing *only* by removing the price signal → directly answers whether the
+  market mechanism is worth its cost.
+- **Maximal code reuse / lowest risk:** reuses `compute_residual_capacity`,
+  `start_additional_replicas`, the restricted-problem re-solve, fairness, the
+  objective, and all stopping criteria unchanged.
+- **Deterministic / reproducible:** no seed averaging required.
diff --git a/docs/superpowers/specs/2026-06-25-faas-madig-distributed-heuristic-design.md b/docs/superpowers/specs/2026-06-25-faas-madig-distributed-heuristic-design.md
new file mode 100644
index 0000000..6fa0cd9
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-25-faas-madig-distributed-heuristic-design.md
@@ -0,0 +1,316 @@
+# FaaS-MADiG — Distributed greedy-diffusion heuristic
+
+**Date:** 2026-06-25
+**Status:** Approved (brainstorming) — pending spec review
+**Author:** brainstormed with Claude Code
+
+## 1. Goal
+
+Add a new **distributed coordination heuristic**, named **FaaS-MADiG**
+(*Multi-Agent Distributed Greedy*), to be compared against the two existing
+auction-based methods for the DiFRALB problem (distributed Function Replica
+Allocation and Load Balancing in the Edge-Cloud continuum):
+
+- **FaaS-MADeA** — flat decentralized auction (`run_faasmadea.py`). The
+  older `decentralized_auction.py` module remains useful as historical/helper
+  context, but it is not the production baseline dispatched by `run.py`.
+- **HierarchicalAuction** — hierarchical multi-structure auction
+  (`hierarchical_auction/`).
+
+FaaS-MADiG is an **apples-to-apples ablation of the market mechanism**: it
+keeps everything the production flat auction does except the price/bidding
+signal, replacing seller selection with the same greedy ordering evaluated on a
+price-free score. This isolates the scientific question: *does the auction's
+price signal actually improve the solution over a plain greedy diffusion that
+uses the same information?*
+
+## 2. Scope decisions (settled during brainstorming)
+
+- **Local planning is reused unchanged.** Each node still solves the local MILP
+  subproblem `LSP`/`LSPr` (via `solve_subproblem` / `compute_social_welfare`),
+  which fixes replicas `r[n,f]`, locally served load `x[n,f]`, and produces the
+  residual load `omega[i,f]` to offload. Only the inter-node coordination is
+  replaced.
+- **New standalone file**, `decentralized_diffusion.py`, mirroring the current
+  production FaaS-MADeA runner `run_faasmadea.py`. This follows the established
+  codebase pattern (each method has its own runner reusing shared helpers), but
+  avoids implementing the ablation against the older `decentralized_auction.py`
+  behavior.
+- **Method name:** `FaaS-MADiG`; CLI method key: `faas-diffuse`.
+- **Alternatives (power-of-d-choices, distributed best-response) are recorded**
+  for future work in
+  `docs/superpowers/specs/2026-06-25-distributed-heuristic-alternatives.md`.
+
+## 3. The precise ablation (what changes vs. the auction)
+
+The production auction iteration loop (`run_faasmadea.run`) does, per iteration:
+
+1. `compute_residual_capacity(sp_x, y, sp_r, sp_data)` → `capacity`,
+   `residual_capacity`, `ell`; then `blackboard = max(0, capacity - sp_x)`.
+2. `define_bids(...)` → `bids`, `memory_bids`
+3. if bids: `evaluate_bids(...)` → `auction_y`, **updated prices `p`**;
+   then `y += auction_y`; recompute `rmp_omega`; bump `fairness`;
+   `compute_social_welfare(spr, ...)` (restricted problem) → updated
+   `sp_x, sp_r, sp_rho`; update `omega = sp_omega - rmp_omega`.
+   else: `start_additional_replicas(...)` → add replicas.
+4. `combine_solutions` + `compute_centralized_objective`; track best.
+5. `check_stopping_criteria`; save on stop.
+
+FaaS-MADiG keeps **steps 1, 4, 5 and the non-bid branch of step 3 identical**.
+It replaces only the two market functions in steps 2–3:
+
+### 3.1 `define_bids` → `define_assignments`
+
+Start from `run_faasmadea.define_bids`, not the older
+`decentralized_auction.define_bids`. Keep its production behavior, with only
+the price/bid signal removed:
+
+- The buyer utility loses the price term:
+  `score(i,j,f) = beta[i,j,f] − latency_weight·latency[i,j] − fairness_weight·fairness[i,f]`
+  (the auction had an extra `− p[j,f]`). Candidate sellers are still neighbors
+  with residual computing capacity `blackboard[j,f] >= 1`, kept using the same
+  convenience threshold as FaaS-MADeA:
+  `score > -data[None]["gamma"][(i+1,f+1)]`.
+- Candidate sellers are sorted by descending `score`, matching the current
+  greedy allocation structure of `run_faasmadea.define_bids`. The older
+  softmax-proportional split in `decentralized_auction.py` is **not** used for
+  this ablation because it would change both pricing and allocation behavior.
+- Demand quantity `d` is computed exactly as in `run_faasmadea.define_bids`:
+  if `solver_options["diffusion"]["unit_bids"]` is enabled, keep the same
+  unit-request behavior; otherwise use
+  `d = min(blackboard[j,f], omega[i,f] - assigned)`.
+- The bid price `b` is **not computed** (no `epsilon`, no `delta`). **Reuse the
+  existing `utility` column** that `define_bids` already produces (it stores the
+  per-pair score) instead of adding a new `score` column — this minimizes churn,
+  and `evaluate_assignments` will sort on `utility`. The `b` column is dropped;
+  no downstream logic may interpret any column as a price.
+- The partial-assignment and memory-request branches are unchanged:
+  when assigned load is smaller than `omega[i,f]`, populate `memory_bids`
+  exactly as `run_faasmadea.define_bids` does, including `force_memory_bids`.
+
+### 3.2 `evaluate_bids` → `evaluate_assignments`
+
+Sellers fill their residual capacity with a **pure greedy fill** — the
+production capacity loop kept verbatim, every price-dependent piece removed:
+
+- Candidate requests for seller `(j,f)` are sorted by **`utility` descending**
+  (the auction sorted by bid price `b` descending). Pandas' stable sort would
+  otherwise break ties by insertion order, so use an **explicit secondary key**
+  on the buyer index for reproducibility:
+  `sort_values(by=["utility", "i"], ascending=[False, True])`. The buyer that
+  values seller `j` most for function `f` is served first.
+- The capacity-filling loop (`q = min(remaining_capacity, d)`, accumulate into
+  `y`, decrement `remaining_capacity`) tracks the unserved remainder of every
+  request, including batched requests, and preserves continuous-valued capacity.
+  It still respects
+  `residual_capacity[j,f]` (the array passed in this slot by the runner, see §3
+  step 1 — `define_assignments` uses `blackboard`, the seller fill uses
+  `residual_capacity`).
+- **Keep `tentatively_start_replicas`** (the `initial_rho`/`r` tentative-replica
+  branch): it is already **price-free** — it decides on utilization
+  (`u <= max_utilization`), not on price — so it stays for parity with the
+  baseline and feeds `additional_replicas`.
+- **Drop the price machinery entirely** — this is the ablation:
+  - no `min_b` tracking;
+  - no final price update (`p[j,f] = min_b + eta·(u - u0)` and the
+    `p[j,f] *= (1 - zeta)` decay) — `eta`, `zeta`, `u0` are not used;
+  - **previous-assignment replacement is kept, but price-free.** Seller/function
+    pairs targeted by a request remain eligible even with zero residual capacity
+    when they have incumbent load that can be re-awarded. The production
+    swap is gated by `b_arr[next_bid_idx] > p[j,f]`; with prices removed
+    (`p ≡ 0`) that test is not meaningful. FaaS-MADiG instead compares the
+    candidate buyer's current `utility` with the incumbent buyer's current
+    price-free score and replaces lower-score incumbent load when the seller
+    saturates. Only incumbent load from `last_y` is replaceable; requests accepted
+    in the current score-ordered clearing retain their ordering.
+- `evaluate_assignments` returns `y`, `additional_replicas`, and `n_auctions`
+  (`len(potential_sellers)`); **never a price array** (the production
+  `evaluate_bids` returns `p` in slot 2 — that slot is dropped here).
+
+Net effect: the only behavioral difference between FaaS-MADeA and FaaS-MADiG is
+the absence of the price signal (cross-iteration congestion feedback +
+seller-side price arbitration). Note the buyer-side greedy-by-utility ordering
+already exists in production `define_bids`; what the auction adds on top — and
+what this ablation removes — is precisely the price coordination. Replica
+scaling (`start_additional_replicas`, tentative replicas), the
+restricted-problem re-solve, the fairness mechanism, the objective, and all
+stopping criteria are kept aligned with `run_faasmadea.py`.
+
+When `--fix_r` supplies an optimal replica plan, both the initial local solve and
+the restricted re-solve use their fixed-r variants, and coordination receives no
+memory slack. Replica expansion is therefore disabled for the whole run.
+
+## 4. New module: `decentralized_diffusion.py`
+
+```
+decentralized_diffusion.py
+├── parse_arguments()              # same CLI as run_faasmadea (-c, -j, --disable_plotting)
+├── define_assignments(...)        # NEW — see §3.1
+├── evaluate_assignments(...)      # NEW — see §3.2
+└── run(config, parallelism,       # copy of run_faasmadea.run with
+        log_on_file=False,         #   steps 2–3 swapped and price logic removed
+        disable_plotting=False)
+```
+
+Imported **unchanged** from `run_faasmadea` where possible:
+`compute_residual_capacity`, `neigh_dict_to_matrix`, `start_additional_replicas`,
+`check_stopping_criteria`, `check_ls_pr_feasibility_from_fixed_y`, and any
+small helper already used by the production runner.
+
+Imported (as the auction does) from `run_centralized_model`, `run_faasmacro`,
+`utils.*`, `models.sp`: `init_problem`, `get_current_load`, `update_data`,
+`init_complete_solution`, `join_complete_solution`, `save_checkpoint`,
+`save_solution`, `plot_history`, `solve_subproblem`, `compute_social_welfare`,
+`combine_solutions`, `compute_centralized_objective`, `decode_solutions`,
+`LSP`, `LSPr`.
+
+The `run()` signature matches `run_faasmadea.run` /
+`hierarchical_auction.runner.run`: `(config, parallelism, log_on_file=False,
+disable_plotting=False)`.
+
+### Config: `solver_options["diffusion"]`
+
+The auction reads `solver_options["auction"]` with keys including `epsilon`,
+`eta`, `zeta`, `latency_weight`, `fairness_weight`, and possibly `unit_bids`.
+FaaS-MADiG reads `solver_options["diffusion"]`:
+
+```json
+"diffusion": {
+  "latency_weight": 0.0,
+  "fairness_weight": 0.0,
+  "unit_bids": false
+}
+```
+
+`epsilon`, `eta`, `zeta`, `u0` are dropped (price-only parameters). If
+`unit_bids` is omitted, default it to the auction config's value when present,
+otherwise `false`, so benchmark configs can keep both methods aligned.
+
+## 5. Wiring into `run.py`
+
+- Add import: `from decentralized_diffusion import run as run_diffusion`.
+- Add `"faas-diffuse"` to the `--methods` choices list.
+- Add `"faas-diffuse": []` to the `solution_folders` structure and preserve it
+  when loading existing `experiments.json` files that may not yet contain the
+  key.
+- Derive a `run_d` boolean from `--methods` alongside `run_a`/`run_h`, including
+  the same resume/skip checks used for `faas-madea` and `hierarchical`.
+- Add a dispatch block mirroring the auction one:
+  ```python
+  if run_d:
+      d_folder = run_diffusion(
+          config, sp_parallelism,
+          log_on_file=log_on_file, disable_plotting=disable_plotting,
+      )
+      set_solution_folder(solution_folders, "faas-diffuse", experiment_idx, d_folder)
+  ```
+- Extend the `mkey`/`mname` mapping (around `run.py:277-290`):
+  `mkey = "LSPc"` (same artifact family as the auctions), and
+  `mname = "FaaS-MADiG"` for `method == "faas-diffuse"`.
+- Add a color entry in `method_colors` so plots distinguish all four methods.
+- Extend the old-instance reuse preference list if needed so experiments
+  generated by FaaS-MADiG can also be reused as a source of load traces.
+
+## 6. Output artifacts & comparison compatibility
+
+Because `run()` is a copy of the auction loop, FaaS-MADiG produces the **same
+artifacts** automatically:
+
+- `LSP` / `LSPc` solution folders + checkpoints (`save_checkpoint`, `save_solution`).
+- `obj_dict["LSPr_final"]` and a termination string in the auction's format:
+  `"{why_stopping} (it: ...; obj. deviation: None; best it: ...; best centralized it: ...; total runtime: ...)"`.
+  `run.py` already parses both the "obj. deviation" and the hierarchical formats
+  (`run.py:158-166`), so no parser change is needed.
+- `obj.csv` must use column name `FaaS-MADiG` so `run.py` and
+  `compare_results.py` can keep method-specific columns distinct.
+- **Runtime accounting (fairness of comparison).** `run_faasmadea.run` does not
+  measure wall-clock: it accumulates a *per-agent average* via
+  `total_runtime += rt / n_auctions` for the `define`/`evaluate` phases (plus
+  `spr_runtime` for the restricted-problem solves), modelling distributed
+  execution across agents. FaaS-MADiG **must keep the identical accounting** so
+  the runtime comparison stays apples-to-apples. Add a guard for
+  `n_auctions == 0` (latent divide-by-zero in the baseline) so empty-bid
+  iterations don't raise.
+- **Persist `runtime.csv` explicitly.** `run_faasmadea.py` does *not* save
+  `runtime.csv` (only `obj.csv` + the termination CSV), forcing `run.py` to
+  reconstruct runtime from logs. Recent commits (`a6646b8`, `84a2f1d`) added
+  explicit `runtime.csv` saving to the faasmacro and hierarchical runners
+  *"to avoid fragile log parsing"* — FaaS-MADiG follows that newer, robust
+  direction and **saves `runtime.csv`** rather than relying on log parsing.
+
+`compare_results.py` needs small compatibility updates before it can ingest
+FaaS-MADiG robustly:
+
+- add `FaaS-MADiG` to color/palette dictionaries used by box and violin plots;
+- optionally extend the default `--models` list when FaaS-MADiG should be part
+  of standard comparisons;
+- verify all deviation helpers handle any model whose name starts with `FaaS-`.
+
+### Three/four-way benchmark config
+
+Extend `config_files/planar_comparison.json` to add the `"diffusion"` section
+under `solver_options` so the existing planar campaign can run all methods:
+
+```
+python run.py -c config_files/planar_comparison.json \
+  --methods centralized faas-macro faas-madea hierarchical faas-diffuse \
+  --n_experiments 3 --loop_over Nn
+```
+
+## 7. Testing
+
+Follow the existing `tests/` patterns (e.g. `test_run_faasmacro_helpers.py`,
+`test_hierarchical_*`):
+
+- **Unit — `define_assignments`:**
+  - score uses `beta − latency_weight·latency − fairness_weight·fairness`, no price term;
+  - convenience filtering matches `run_faasmadea.define_bids`
+    (`score > -data[None]["gamma"][(i+1,f+1)]`);
+  - assignments follow descending score order and respect the production
+    `unit_bids`/non-unit quantity behavior;
+  - no-capacity and partial-assignment cases populate `memory_bids` identically
+    to `run_faasmadea.define_bids`, including `force_memory_bids`.
+- **Unit — `evaluate_assignments`:**
+  - total assigned to seller `(j,f)` never exceeds `residual_capacity[j,f]`;
+  - fractional capacity is not truncated and a partially served batched request
+    retains its unserved remainder;
+  - higher-`utility` buyers are served first; tie-break is the explicit
+    secondary sort on buyer index `i` (assert a constructed tie resolves to the
+    lower `i`, not insertion order);
+  - returns `y`, `additional_replicas`, `n_auctions` and **no price array**;
+    running twice on the same input yields identical `y` (determinism);
+  - `tentatively_start_replicas` branch still produces `additional_replicas`
+    from `initial_rho`/`r` on the utilization condition;
+  - score-based replacement: on an input where a seller saturates and a new
+    buyer has higher utility than a previous incumbent in `last_y`, assert the
+    returned `y` delta removes incumbent load and assigns it to the higher-score
+    buyer, including when the seller starts with zero residual capacity.
+- **Unit — wiring/postprocessing:**
+  - `run.parse_arguments` accepts `faas-diffuse`;
+  - `run.results_postprocessing` maps `faas-diffuse` to `LSPc` /
+    `FaaS-MADiG`;
+  - `compare_results.py` plotting helpers accept `FaaS-MADiG` without palette
+    errors.
+- **Smoke / e2e:** a tiny instance (small `Nn`, `Nf`, few steps, short
+  `TimeLimit`) run end-to-end via `decentralized_diffusion.run`, asserting the
+  expected output files exist — including `obj.csv` (column `FaaS-MADiG`), the
+  termination CSV, and a well-formed `runtime.csv`. Gate on solver availability
+  like the other e2e tests.
+
+## 8. Out of scope (recorded for future work)
+
+- Power-of-d-choices randomized baseline (Option B).
+- Distributed best-response / Gauss-Seidel relaxation (Option C).
+
+See `2026-06-25-distributed-heuristic-alternatives.md`.
+
+## 9. Open questions / assumptions
+
+- **Convergence without prices.** Greedy diffusion lacks the price signal that
+  damps oscillation. The score-based `last_y` replacement keeps MADiG closer to
+  MADeA, but can re-award already served load when a better local score appears.
+  `check_stopping_criteria` (no capacity / all assigned / max iterations / time
+  limit) bounds iterations. If empirical oscillation appears, add a guard such
+  as stopping when `y` is unchanged between iterations or when objective no
+  longer improves — noted as a contingency, not built up front (YAGNI).
+- **Method name** `FaaS-MADiG` is final unless changed during spec review.
diff --git a/docs/superpowers/specs/2026-06-26-faas-mabr-best-response-design.md b/docs/superpowers/specs/2026-06-26-faas-mabr-best-response-design.md
new file mode 100644
index 0000000..1581bdc
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-26-faas-mabr-best-response-design.md
@@ -0,0 +1,338 @@
+# FaaS-MABR — Distributed best-response (Gauss-Seidel) heuristics (+ LaTeX note)
+
+**Date:** 2026-06-26
+**Status:** Reviewed — ready for implementation
+**Author:** brainstormed with Claude Code
+
+This spec covers, in two parts:
+- **Part I** — three distributed sequential-response methods (Option C from
+  `2026-06-25-distributed-heuristic-alternatives.md`) and their implementation.
+- **Part II** — a paper-ready LaTeX note for the FaaS-MABR family, mirroring
+  `faas-madig-note/` and `faas-mapod-note/`.
+
+---
+
+# Part I — Algorithms: FaaS-MABR-S / -R / -O
+
+## 1. Goal
+
+Add the **FaaS-MABR** family (*Multi-Agent Best-Response*), two solver-light
+sequential-greedy heuristics plus one solver-backed capped local best response
+for DiFRALB/DeFRALB, comparable head-to-head with LMM, FaaS-MACrO, FaaS-MADeA,
+HierarchicalAuction, FaaS-MADiG, and FaaS-MAPoD.
+Where FaaS-MADeA (auction), FaaS-MADiG (greedy diffusion), and FaaS-MAPoD
+(power-of-d) all compute every buyer's request **simultaneously** against a
+snapshot and then resolve conflicts (a Jacobi-style round + seller clearing),
+the FaaS-MABR family replaces that with a **sequential** sweep: nodes act in an
+order, each claims capacity on a **shared residual-capacity ledger** that is
+decremented immediately, so a node responds to what earlier nodes have already
+taken. This is the Gauss-Seidel analogue of the same coordination problem. The
+research question: *does sequential immediate-update coordination beat
+simultaneous diffusion (snapshot), and is anticipatory local re-optimization
+worth its cost?*
+
+## 2. The three methods (two orthogonal axes)
+
+The family spans two axes — **node order** and **response type**:
+
+| Method | CLI key | obj.csv col | order | response |
+|--------|---------|-------------|-------|----------|
+| **FaaS-MABR-S** | `faas-br-s` | `FaaS-MABR-S` | fixed (ascending node index) | sequential greedy |
+| **FaaS-MABR-R** | `faas-br-r` | `FaaS-MABR-R` | randomized per sweep (seeded) | sequential greedy |
+| **FaaS-MABR-O** | `faas-br-o` | `FaaS-MABR-O` | fixed (ascending node index) | capped local best response |
+
+- **sequential greedy response (`-S`, `-R`):** the node places its residual demand
+  `omega_i^f` greedily, in descending score order, onto the current ledger (same score
+  `s_{ij}^f = beta_{ij}^f − w_lat·L_{ij} − w_fair·phi_i^f` and convenience
+  threshold `s > −gamma_i^f` as FaaS-MADiG). These variants are Gauss-Seidel
+  greedy responses, not optimal best responses.
+- **capped local best response (`-O`):** before placing, the node re-solves its
+  local subproblem with `omega` **capped** at the capacity its neighbours
+  currently still advertise, so it can reduce horizontal demand and leave the
+  rest to local execution / Cloud in the subsequent restricted solve. It then
+  places the capped `omega` greedily on the ledger.
+- **fixed vs randomized order:** `-S`/`-O` sweep nodes in ascending index
+  (deterministic, reproducible); `-R` draws a fresh node permutation each sweep
+  from a per-run RNG (seeded from `config["seed"]`; variance via
+  `--n_experiments`, exactly as FaaS-MAPoD).
+
+(The fourth combination, randomized-order re-optimization, is intentionally
+**not** exposed — YAGNI; it can be added later if needed.)
+
+## 3. Architecture
+
+One new module `decentralized_bestresponse.py`, **DRY internally, three methods
+at the user level**:
+
+- a shared sweep function `best_response_sweep(...)` parameterized by `order`
+  and `response`;
+- three thin public entry points `run_br_s`, `run_br_r`, `run_br_o`, each reading
+  its own `solver_options` block and writing its own `obj.csv` column;
+- a single internal `_run(config, parallelism, *, order, response, method_name,
+  rng_seed, ...)` that holds the control-period loop (the three entry points are
+  one-liners delegating to it).
+
+**Reused unchanged by import** (from `run_faasmadea` / `run_faasmacro` /
+`run_centralized_model` / `decentralized_diffusion`): `compute_residual_capacity`,
+`check_stopping_criteria`, `neigh_dict_to_matrix`, `start_additional_replicas`,
+`check_ls_pr_feasibility_from_fixed_y`, `VAR_TYPE`, `combine_solutions`,
+`compute_social_welfare`, `decode_solutions`, `solve_subproblem`,
+`init_problem`/`update_data`/`get_current_load`/`save_solution`/…, `LSP`,
+`LSPr`, `LSP_fixedr`.
+
+**New additive model classes** (in `models/sp.py`): `LSP_capped` and
+`LSP_capped_fixedr`. The fixed-r variant is required so `--fix_r` remains
+available for all three MABR methods, including `-O`.
+
+**Not reused:** `evaluate_assignments` / `define_assignments` (the sequential
+sweep has no separate seller-clearing phase — sequential updates produce no
+cross-buyer conflicts to resolve).
+
+**Control-period loop reuse.** The `_run` loop is the same per-runner loop as
+`decentralized_diffusion.run` (`for t: LSP → while not stop_searching: coordinate
+→ re-solve LSPr → update omega → check stop → save`). Only the **coordinate**
+step changes: one call to `best_response_sweep` (one sequential sweep) replaces
+the `define_assignments`+`evaluate_assignments` pair. Each visited buyer releases
+its current assignment row before computing and immediately committing a
+replacement row. The inter-sweep `LSPr`
+re-solve is what makes this the Gauss-Seidel analogue (each sweep responds to
+the state left by the previous sweep's re-solve). `_run` adds one explicit
+MABR-specific fixed-point guard: if a sweep changes no assignment and starts no
+replica, stop with `"no best-response progress"`. The existing
+`check_stopping_criteria` is still used for no capacity, all load assigned,
+`max_iterations`, unavailable sellers, and time limit.
+
+### 3.1 `best_response_sweep`
+
+```
+best_response_sweep(omega, residual_ledger, data, neighborhood, rho,
+                    br_options, latency, fairness, force_memory_bids,
+                    *, order, response, rng=None, current_y=None,
+                    reopt_ctx=None) -> (y_increment, memory_bids, n_active,
+                                        placed_total, reopt_runtime)
+```
+- `residual_ledger`: a **mutable copy** of the current true residual capacity
+  (from `compute_residual_capacity`), `shape (Nn, Nf)`, decremented in place as
+  nodes claim — this is the shared ledger that gives Gauss-Seidel its
+  immediate-update behaviour.
+- `current_y` is the assignment tensor at sweep entry. Before node `i` responds,
+  `current_y[i,:,:]` is released back to the ledger.
+- Returns `y_increment` `(Nn, Nn, Nf)` as the coordinate delta
+  `new_y[i,:,:] - current_y[i,:,:]`, `memory_bids`
+  DataFrame `[i,j,f]` (price-free replica-expansion requests, identical to
+  FaaS-MADiG), `n_active` (number of nodes that acted this sweep, for runtime
+  amortization), `placed_total` equal to the gross load in the newly constructed
+  rows, and `reopt_runtime`, the
+  full, non-amortized time spent in per-node `LSP_capped` solves.
+
+**Sweep body.** Determine node visiting order: `range(Nn)` if `order=="fixed"`,
+else `rng.permutation(Nn)`. For each node `i` in that order with a positive
+offloading target or an existing assignment row:
+1. Release `current_y[i,:,:]` into the shared ledger and initialize an empty new
+   row for buyer `i`.
+2. (**FaaS-MABR-O only**) re-optimize: cap `omega[i,f]` at the accessible
+   neighbour capacity `sum_{j in N_i} residual_ledger[j,f]` and re-solve node
+   `i`'s local subproblem via `reopt_ctx` (§3.2). Only the re-optimized
+   `omega_i` row is committed to the sweep state before placement; `x`, `z`,
+   `r`, and `rho` from the capped probe are **not** committed directly to the
+   global solution. The final feasible `x/z/r/rho` state is still produced by
+   the subsequent restricted `LSPr` solve with fixed `y`. `-S`/`-R` skip this
+   step.
+3. Admit candidates `j in N_i` with `residual_ledger[j,f] >= 1` and
+   `s_{ij}^f > −gamma_i^f`; sort by descending `s_{ij}^f` (tie-break lower `j`).
+4. Place greedily into the new row: for each candidate `j` in order,
+   `q = min(residual_ledger[j,f], omega[i,f] − placed)`;
+   `new_y[i,j,f] += q`; **`residual_ledger[j,f] −= q`**
+   (immediate decrement → later nodes see less); `placed += q`; stop when
+   `omega[i,f]` met or candidates exhausted.
+5. If `placed < omega[i,f]` (or `force_memory_bids`), emit price-free
+   replica-expansion `memory_bids` to neighbours with enough memory for one
+   replica, `rho_j >= memory_requirement[f]` (both
+   still-serving capacity sellers and memory-only neighbours), **at parity with
+   FaaS-MADiG** (the two-block emission), then return `new_y-current_y`.
+
+**Replica-expansion timing.** Memory bids are collected for the whole sweep and
+`start_additional_replicas` is called **after** the sweep, before assembling the
+candidate solution. Replica expansion is therefore sweep-level, not per-node;
+this preserves parity with FaaS-MADiG/MAPoD and avoids making memory expansion
+another order-dependent side effect.
+
+### 3.2 Re-optimization context (FaaS-MABR-O)
+
+`reopt_ctx` bundles what a single-node re-solve needs (`sp_data`, solver
+name/options, parallelism, and whether fixed replicas are active). For node `i`,
+the sweep prepares a deep copy of `sp_data`, sets
+`omega_ub[f] = sum_{j in N_i} residual_ledger[j,f]`, and calls the existing
+`solve_subproblem` path with `agents=[i]` and either `LSP_capped()` or
+`LSP_capped_fixedr()`. If `--fix_r` is active, the same `r_bar` map already used
+by MADiG/MAPoD must be present in the copied data. The returned arrays are read
+only at row `i`; `omega[i, :]` is replaced by the capped solve's `sp_omega[i, :]`
+for the current sweep. The capped solve's `x/z/r/rho/U` values are diagnostic
+only and are not committed to the global state; after the sweep, `compute_social_welfare`
+with fixed `y` remains the single source of truth for the candidate solution.
+When `--fix_r` is active this final restricted solve uses `LSPr_fixedr`, and
+coordination receives zero memory slack so no replica expansion can alter the
+centralized replica plan.
+
+## 4. Model additions: `LSP_capped` and `LSP_capped_fixedr` (additive, `models/sp.py`)
+
+Add new classes **only**; do not modify existing classes:
+
+```python
+class LSP_capped(LSP):
+  # adds an upper bound on horizontal offloading per function
+  #   omega[f] <= omega_ub[f]
+  # where omega_ub is a Param fed from accessible neighbour residual capacity.
+class LSP_capped_fixedr(LSP_fixedr):
+  # same omega cap, plus inherited r[f] == r_bar[whoami, f]
+```
+
+Both classes declare `omega_ub` as a `Param` indexed by function and add one
+constraint `omega[f] <= omega_ub[f]`. Everything else (objective, traffic-loss,
+utilization, residual-capacity constraints) is inherited unchanged. Only
+FaaS-MABR-O instantiates these models; FaaS-MADiG/MAPoD/MADeA/MACrO and
+FaaS-MABR-S/-R are untouched.
+
+## 5. Config: `solver_options.{br_s, br_r, br_o}`
+
+Three blocks (one per method), all sharing the latency/fairness weights:
+```json
+"br_s": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+"br_r": { "latency_weight": 0.0, "fairness_weight": 0.0 },
+"br_o": { "latency_weight": 0.0, "fairness_weight": 0.0 }
+```
+`-R` additionally uses `config["seed"]` for its per-sweep permutation RNG
+(`np.random.default_rng(seed)`, created once). `_run` copies its options block
+with `dict(...)` before applying defaults, so the input config is never mutated
+(as in FaaS-MAPoD).
+
+## 6. Wiring (`run.py`, `compare_results.py`, planar config — additive only)
+
+Same additive pattern as FaaS-MADiG/MAPoD, ×3: import `run_br_s`/`run_br_r`/
+`run_br_o`; add `faas-br-s`/`faas-br-r`/`faas-br-o` to `--methods` choices and to
+the `solution_folders` template; three `run_*` flags (init + resume-check +
+`except ValueError`); extend the run-guard; three dispatch blocks; extend the
+`mname` ternary (`FaaS-MABR-S/-R/-O`, all resolving `mkey = "LSPc"`); add three
+`method_colors`; add the three names to `compare_results` default model set and
+both palettes; add the three blocks to `config_files/planar_comparison.json`.
+Existing methods' code paths stay byte-for-byte unchanged.
+
+## 7. Output, evaluation, comparison
+
+Artifacts identical to FaaS-MADiG/MAPoD (so `compare_results.py` ingests them
+unchanged except palette/default-set keys). `-R` variance surfaces across
+`--n_experiments` (each experiment: own seed → own instance and own sweep order).
+Extend the planar campaign:
+```
+python run.py -c config_files/planar_comparison.json \
+  --methods centralized faas-madea hierarchical faas-diffuse faas-powd \
+            faas-br-s faas-br-r faas-br-o \
+  --n_experiments 3 --loop_over Nn
+```
+
+## 8. Testing
+
+- **Unit — `best_response_sweep` (greedy, no solver):**
+  - sequential ledger: a constructed instance where node 0 (acting first) claims
+    a shared seller's capacity, leaving node 1 (later) strictly less than a
+    simultaneous round would — i.e. the ledger decrement is observable and
+    order-dependent;
+  - `order="fixed"` determinism (two calls → identical `y_increment`);
+  - `order="random"` reproducibility with two independent `default_rng(seed)`;
+  - admission threshold `> −gamma` filters candidates; descending-score order +
+    lower-`j` tie-break;
+  - no-capacity → `memory_bids` (parity two-block emission, asserted against the
+    FaaS-MADiG memory-bid shape).
+- **Unit — `best_response_sweep` stopping signal:** a sweep with
+  `placed_total == 0` and empty `memory_bids` triggers the MABR-specific
+  `"no best-response progress"` guard in `_run`; a sweep with memory bids does
+  not stop before replica expansion is attempted.
+- **Unit — `LSP_capped` / `LSP_capped_fixedr`:** with a tight `omega_ub`, the
+  solved `omega[f]` respects the cap and the freed demand moves to `x`/`z`
+  (constructed small model); without a cap (or a loose one) it matches plain
+  `LSP`; with `r_bar`, `LSP_capped_fixedr` respects both `omega_ub` and fixed
+  replicas.
+- **Unit — reopt step:** on a constructed node whose neighbours are nearly full,
+  FaaS-MABR-O caps `omega` before placement versus FaaS-MABR-S on the same
+  instance; assert that only `omega[i, :]` is committed from the capped probe and
+  the final `x/z/r/rho` candidate comes from the subsequent `LSPr` solve.
+- **Unit — wiring:** the three CLI keys accepted; `run` exposes `run_br_s/r/o`;
+  planar config has the three blocks; `compare_results` default set + palette
+  include the three names; `--fix_r` help mentions FaaS-MABR and `run_br_o` uses
+  `LSP_capped_fixedr` when `opt_solution_folder` is present.
+- **Smoke/e2e (Gurobi-gated):** one tiny run per method asserting `obj.csv`
+  (correct column), `runtime.csv`, `termination_condition.csv`, `LSPc_solution.csv`;
+  `-S`/`-O` reproducible (same seed → identical `obj.csv`); `-O` also runs under
+  `--fix_r` on a tiny centralized solution.
+
+## 9. Out of scope (v1)
+
+- Randomized-order re-optimization (the 4th axis combination).
+- Any change to FaaS-MADeA/MACrO/MADiG/MAPoD/hierarchical code paths.
+
+---
+
+# Part II — LaTeX note: `faas-bestresponse-note/`
+
+Mirrors `faas-madig-note/` / `faas-mapod-note/` in structure and conventions.
+
+## 10. Folder structure
+```
+faas-bestresponse-note/
+├── faas-mabr.tex     % the \section to \input/paste into the paper
+├── main.tex          % standalone preview wrapper (article + natbib)
+├── references.bib    % cited works
+├── README.md
+└── .gitignore
+```
+
+## 11. Content of `faas-mabr.tex`
+
+In the paper's notation; no abstract/intro; self-contained removable notation
+recap (reused from the sibling notes). Sections:
+1. **Hook:** FaaS-MABR is the *sequential* (Gauss-Seidel-style) counterpart of
+   the *simultaneous* (Jacobi-style) coordination of FaaS-MADiG/MAPoD; nodes act
+   on a shared ledger updated in place.
+2. **Notation recap** (reused, removable).
+3. **Sequential response sweep** — the shared ledger, the visiting order,
+   the greedy claim with immediate decrement; Eqs. for the score and admission
+   (same as FaaS-MADiG). State the Jacobi↔Gauss-Seidel relation explicitly.
+4. **The three variants** — fixed vs randomized order; sequential greedy vs
+   capped local best response (the `omega`-capped local re-solve, with the
+   `LSP_capped` and fixed-r constraints written out).
+5. **Pseudocode** — one Algorithm for the sweep (parameterized by order/response).
+6. **What is kept / changed** vs FaaS-MADiG (kept: local plan, score, threshold,
+   replica expansion, restricted re-solve; changed: simultaneous→sequential, no
+   seller-clearing phase, optional anticipatory re-optimization).
+7. **Positioning (honest):** Gauss-Seidel-style sequential response dynamics —
+   a classical distributed-optimization pattern, not novel; S/R are sequential
+   greedy responses, while O is the local capped best-response variant. The
+   value is the *sequential-vs-simultaneous* contrast and the re-optimization
+   ablation.
+   Cite **Bertsekas & Tsitsiklis, *Parallel and Distributed Computation: Numerical
+   Methods* (1989)** (Gauss-Seidel / Jacobi relaxation), the diffusion/auction
+   siblings (Cybenko, FaaS-MADeA), and best-response/better-response dynamics.
+
+## 12. Build & insertion
+`latexmk -pdf main.tex` for a preview; `\input{faas-mabr}` into the paper,
+removing the notation recap and converting cross-refs. Cited PDFs verified +
+downloaded into `faas-bestresponse-note/cited_papers/` (same audit workflow as
+the sibling notes; reuse the shared verified set where it overlaps).
+
+---
+
+# Open questions / assumptions
+
+- Names `FaaS-MABR-S/-R/-O` and CLI `faas-br-s/-r/-o` are final unless changed in
+  review.
+- Re-optimization solves up to one `LSP_capped`/`LSP_capped_fixedr` per active
+  node per sweep. Greedy sweep bookkeeping is amortized per active node as in
+  the siblings; each capped MILP solve is charged in full through
+  `reopt_runtime`. The solve time is subtracted from the measured sweep wall
+  time before bookkeeping is amortized, avoiding double counting.
+- The shared ledger is the **true** residual capacity (`compute_residual_capacity`)
+  decremented in place, not the advertised blackboard; admission still uses the
+  score/threshold.
+- Stopping reuses `check_stopping_criteria` for inherited guards, plus an
+  explicit MABR guard for sweeps with no assignment delta and no replicas
+  actually started.
diff --git a/docs/superpowers/specs/2026-06-26-faas-mapod-power-of-d-design.md b/docs/superpowers/specs/2026-06-26-faas-mapod-power-of-d-design.md
new file mode 100644
index 0000000..5183104
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-26-faas-mapod-power-of-d-design.md
@@ -0,0 +1,290 @@
+# FaaS-MAPoD — Power-of-d-choices distributed heuristic (+ LaTeX note)
+
+**Date:** 2026-06-26
+**Status:** Reviewed — ready for implementation
+**Author:** brainstormed with Claude Code
+
+This spec covers, in two parts:
+- **Part I** — the FaaS-MAPoD algorithm (Option B from
+  `2026-06-25-distributed-heuristic-alternatives.md`) and its implementation.
+- **Part II** — a paper-ready LaTeX note for FaaS-MAPoD, mirroring
+  `faas-madig-note/`.
+
+---
+
+# Part I — Algorithm: FaaS-MAPoD
+
+## 1. Goal
+
+Add **FaaS-MAPoD** (*Multi-Agent Power-of-d*), a randomized, partial-visibility
+distributed heuristic for DiFRALB/DeFRALB, as a sixth comparable method
+alongside LMM, FaaS-MACrO, FaaS-MADeA, HierarchicalAuction, and FaaS-MADiG.
+FaaS-MAPoD is the **"random / partial-visibility" endpoint** of the
+*market → greedy → random* spectrum: like FaaS-MADiG it uses no prices, but
+instead of scanning the full one-hop neighbourhood it probes only `d` randomly
+sampled neighbours per offloading step (power-of-d-choices). It isolates the
+research question: *how much does full neighbourhood visibility (FaaS-MADiG)
+buy over probing a random sample of `d`?*
+
+## 2. Scope decisions (settled during brainstorming)
+
+- **Local planning reused unchanged.** Same as FaaS-MADiG: each node solves the
+  local MILP `LSP`/`LSPr` (or `LSP_fixedr`/`LSPr_fixedr` when `--fix_r` provides an
+  `opt_solution_folder`), fixing `r`, `x`, residual `omega`; only the buyer-side
+  request generation differs.
+- **Two selection criteria, config-selectable** (`criterion ∈ {"score","capacity"}`):
+  - `score` — pick the sampled neighbour with the highest
+    `s_{ij}^f = beta[i,j,f] − w_lat·L_{ij} − w_fair·phi_i^f` (identical to
+    FaaS-MADiG's score, but evaluated only on the `d`-sample → ablates
+    *visibility*).
+  - `capacity` — pick the sampled neighbour with the largest advertised residual
+    capacity `C_j^f`. This is a buyer-side capacity-sampling variant inspired by
+    shortest-queue power-of-d, not a fully capacity-ordered clearing rule:
+    cross-buyer seller conflicts remain resolved by FaaS-MADiG's score-ordered
+    seller rule.
+- **Stochasticity handled by the existing pipeline.** The sampling RNG is seeded
+  once per run from `config["seed"]`, so each run is reproducible. Variance is
+  captured by the existing `--n_experiments` aggregation in `run.py` /
+  `compare_results.py` (box/violin) — **no new repetition/averaging machinery**.
+- **New standalone file** `decentralized_powerd.py`, mirroring
+  `decentralized_diffusion.py` (established per-method-runner pattern; the
+  new-file-over-shared-loop choice was already adjudicated for FaaS-MADiG).
+- **Method name** `FaaS-MAPoD`; CLI key `faas-powd`; `obj.csv` column
+  `FaaS-MAPoD`; artifact family `mkey = LSPc`. (Name adjustable in spec review.)
+
+## 3. What changes vs. FaaS-MADiG (and what is reused)
+
+FaaS-MAPoD reuses **everything** of FaaS-MADiG except the buyer-side request
+generation:
+
+- **Reused unchanged by import from `decentralized_diffusion`:**
+  `evaluate_assignments` (seller-side greedy clearing — resolves cross-buyer
+  conflicts deterministically by `(utility, i)`). Because the seller clearing
+  is reused verbatim, conflict resolution is identical to FaaS-MADiG.
+- **Reused unchanged by import from `run_faasmadea`:**
+  `compute_residual_capacity`, `check_stopping_criteria`, `neigh_dict_to_matrix`,
+  `start_additional_replicas`, `ensure_memory_sellers`,
+  `check_ls_pr_feasibility_from_fixed_y`, `VAR_TYPE`.
+- **Reused unchanged from the current FaaS-MADiG runner path:**
+  `load_solution`, `encode_solution`, `LSP`, `LSP_fixedr`, `LSPr`, and
+  `LSPr_fixedr`, so
+  `--fix_r` / `opt_solution_folder` behaves exactly as in FaaS-MADiG.
+- **New function** `sample_assignments(...)` replaces
+  `define_assignments`. **New `run(...)`** is a copy of
+  `decentralized_diffusion.run` with `define_assignments` → `sample_assignments`
+  and an RNG created once from the seed.
+
+### 3.1 `sample_assignments` (randomized buyer side)
+
+```
+sample_assignments(omega, blackboard, data, neighborhood, rho,
+                   powerd_options, latency, fairness, force_memory_bids,
+                   rng) -> (pd.DataFrame, pd.DataFrame, int)
+```
+Returns the same shapes as `define_assignments`: a bids DataFrame with columns
+`["i","j","f","d","utility"]`, a memory-bids DataFrame `["i","j","f"]`, and the
+number of potential buyers. (The `utility` column is **always** populated with
+the score `s_{ij}^f`, regardless of `criterion`, so the reused
+`evaluate_assignments` can sort sellers by `(utility, i)`.)
+
+For each `(i,f)` with `omega_i^f > 0`:
+1. Candidate sellers = one-hop neighbours with `blackboard[j,f] ≥ 1` **and**
+   `s_{ij}^f > −gamma_i^f` (same convenience threshold as FaaS-MADiG/MADeA).
+2. **Power-of-d loop** (let `criterion = powerd_options["criterion"]`,
+   `d = powerd_options["d"]`). For each `(i,f)`, maintain a local
+   `remaining_blackboard[j]` copy initialized from `blackboard[j,f]`; this avoids
+   emitting more bids to a seller than the buyer has observed locally.
+   - **Batched (default, `unit_bids=false`):** while `assigned < omega_i^f` and
+     candidates remain: draw a sample `S` of `min(d, |candidates|)` candidates
+     **uniformly at random without replacement** via `rng`; pick `j*` =
+     `argmax_{j∈S} (s_{ij}^f, -j)` (if `criterion="score"`) or
+     `argmax_{j∈S} (remaining_blackboard[j], -j)` (if
+     `criterion="capacity"`); let
+     `q=min(remaining_blackboard[j*], omega_i^f−assigned)`; emit a bid
+     `(i, j*, f, d=q, utility=s_{i,j*}^f)`; decrement
+     `remaining_blackboard[j*]` by `q`; remove `j*` from candidates;
+     `assigned += q`.
+   - **Per-unit (`unit_bids=true`, classic power-of-d):** repeat for each unit of
+     `omega_i^f`: draw a fresh sample of `min(d, |candidates|)`, pick `j*` by the
+     same criterion and tie-break, emit a unit bid `(i, j*, f, d=1, utility=s)`;
+     decrement `remaining_blackboard[j*]`; remove `j*` from the candidate pool
+     only when its advertised capacity is locally exhausted.
+3. If `assigned < omega_i^f` (or `force_memory_bids`), emit **price-free
+   replica-expansion bids** to neighbours with `rho_j > 0` — both same-node
+   capacity sellers that ran out of capacity and memory-only neighbours,
+   identical to FaaS-MADiG (two emission blocks). This keeps the difference
+   from FaaS-MADiG to buyer visibility alone.
+
+Degeneracy check: when `d ≥ |candidates|`, the sample is the whole candidate set
+and `criterion="score"` reduces to FaaS-MADiG's greedy buyer rule for all
+instances without exact score ties. With exact ties, MAPoD must remain
+deterministic via the explicit lower-node-id tie-break; tests should avoid
+claiming byte-for-byte equality with FaaS-MADiG unless the constructed scores
+are unique.
+
+### 3.2 `run(...)`
+
+Copy of `decentralized_diffusion.run` with two changes:
+- create the RNG once: `rng = np.random.default_rng(config["seed"])` (before the
+  time loop), and pass it to `sample_assignments`;
+- read `powerd_options = solver_options["powerd"]` (with
+  `unit_bids` defaulting from `solver_options["auction"]["unit_bids"]` when
+  present, `d` to `2`, `criterion` to `"score"`). Copy the options with
+  `dict(...)` before applying defaults so the input config is not mutated.
+Everything else (residual-capacity computation, the reused
+`evaluate_assignments`, fairness update, restricted re-solve, `combine_solutions`
++ objective, stopping criteria, `obj.csv`/`runtime.csv`/`termination_condition.csv`
+saving, and `opt_solution_folder` / `LSP_fixedr` support) is identical to
+FaaS-MADiG. `obj.csv` column = `FaaS-MAPoD`. Runtime accounting
+(`rt/n_auctions` + `spr_runtime`, with the zero-guard) is kept for a fair
+comparison. Signature: `run(config, parallelism, log_on_file=False,
+disable_plotting=False) -> str`.
+
+## 4. Config: `solver_options["powerd"]`
+
+```json
+"powerd": {
+  "d": 2,
+  "criterion": "score",
+  "latency_weight": 0.0,
+  "fairness_weight": 0.0,
+  "unit_bids": false
+}
+```
+`criterion ∈ {"score","capacity"}`. The convenience filter and the seller-side
+clearing always use the score populated in the `utility` column. When
+`criterion="capacity"`, the weights do not affect the buyer-side ranking among
+the sampled candidates, but they still affect candidate admissibility through
+the convenience threshold and seller-side conflict resolution through
+`evaluate_assignments`.
+
+## 5. Wiring into `run.py` (additive only)
+
+Same additive pattern as FaaS-MADiG: import
+`from decentralized_powerd import run as run_powerd`; add `"faas-powd"` to
+`--methods` choices and to `solution_folders`; add a `run_p` flag (init +
+resume-check + `except ValueError` branch); extend the run-guard `if`; add a
+dispatch block; extend the `mname` ternary with
+`"FaaS-MAPoD" if method == "faas-powd"` (`mkey` already resolves to `LSPc`); add
+a 7th `method_colors` entry. Existing methods' code paths stay byte-for-byte
+unchanged.
+
+## 6. Output, evaluation, comparison
+
+Artifacts identical to FaaS-MADiG. Extend `compare_results.py` by adding
+`FaaS-MAPoD` to the default model set and palette. Stochasticity surfaces
+across `--n_experiments` (each experiment uses its own seed → its own instance
+and its own sampling draw). Extend `config_files/planar_comparison.json` with
+the `powerd` block so the planar campaign can run the full spectrum:
+```
+python run.py -c config_files/planar_comparison.json \
+  --methods centralized faas-macro faas-madea hierarchical faas-diffuse faas-powd \
+  --n_experiments 3 --loop_over Nn
+```
+
+## 7. Testing
+
+- **Unit — `sample_assignments`** (no solver): determinism with two independent
+  `np.random.default_rng(seed)` instances (not two calls on the same advanced
+  RNG state); the sample size never exceeds `d`; `criterion="score"` vs
+  `"capacity"` pick different sellers on a constructed instance where capacity
+  and score disagree; capacity is consumed from the buyer-local
+  `remaining_blackboard`; convenience threshold `> −gamma` filters candidates;
+  no-capacity case emits `memory_bids`; **degeneracy**: with
+  `d ≥ |candidates|`, `criterion="score"`, and unique scores, output equals
+  FaaS-MADiG's `define_assignments` on the same input.
+- **Reuse** the existing `evaluate_assignments` unit tests (no new seller-side
+  tests needed; it is imported unchanged).
+- **Unit — wiring:** `run.parse_arguments` accepts `faas-powd`; `run` exposes
+  `run_powerd`; `compare_results` default model set and palette include
+  `FaaS-MAPoD`; `decentralized_powerd.run` uses `LSP_fixedr` when
+  `opt_solution_folder` is present and does not mutate `solver_options["powerd"]`.
+- **Smoke / e2e** (Gurobi-gated): tiny instance via `decentralized_powerd.run`,
+  asserting `obj.csv` (col `FaaS-MAPoD`), `runtime.csv`, `termination_condition.csv`,
+  `LSPc_solution.csv` exist; assert reproducibility (same config seed → identical
+  `obj.csv`).
+
+## 8. Out of scope (v1)
+
+- Option C (distributed best-response) — see the alternatives note.
+- Fully capacity-ordered seller clearing for `criterion="capacity"`; v1 keeps
+  score-ordered FaaS-MADiG seller clearing for apples-to-apples reuse.
+- Per-instance K-seed averaging (the `--n_experiments` aggregation is used
+  instead).
+
+---
+
+# Part II — LaTeX note: `faas-mapod-note/`
+
+Mirrors `faas-madig-note/` exactly in structure and conventions.
+
+## 9. Folder structure
+```
+faas-mapod-note/
+├── faas-mapod.tex   % the \section to \input/paste into the paper
+├── main.tex         % standalone preview wrapper (article + natbib bibliography)
+├── references.bib   % cited works (subset shared with the MADiG note + Mitzenmacher)
+├── README.md        % compile + insertion instructions
+└── .gitignore       % LaTeX build artifacts (*.aux, *.bbl, main.pdf, …)
+```
+
+## 10. Content of `faas-mapod.tex` (concentrated on algorithm + rationale)
+
+In the paper's notation; no abstract/intro; self-contained, removable notation
+recap (same block as the MADiG note, reused so the note reads on its own).
+
+1. **Hook (1–2 sentences):** FaaS-MAPoD is the randomized, partial-visibility
+   sibling of FaaS-MADiG — same price-free score and local plan, but each
+   offloading step probes only `d` randomly sampled neighbours.
+2. **Notation and capacity model** — the same removable recap as the MADiG note
+   (Eqs. 1,2,12,13 + Table 2/3 subset), so the note is self-contained.
+3. **Power-of-d coordination** — define the sampling step and the two criteria
+   (`score` Eq. mirroring the MADiG score; `capacity` buyer-side largest-spare-
+   capacity sampling); state the batched vs per-unit forms; note the degeneracy
+   `d ≥ |A_i^f|` ⇒ FaaS-MADiG for unique scores. Reuse FaaS-MADiG's seller-side
+   greedy clearing (cite the sibling note/section).
+4. **Two pseudocodes** (algorithmicx, paper style): *buyer power-of-d sampling*
+   and a one-line note that the seller clearing is FaaS-MADiG's
+   `evaluate_assignments`.
+5. **What is removed / kept** vs FaaS-MADeA and vs FaaS-MADiG (removed: prices
+   AND full-neighbourhood visibility; kept: local plan, residual/memory
+   advertising, convenience threshold, fairness, replica expansion).
+6. **Rationale and positioning** — honest: FaaS-MAPoD is essentially the
+   **power-of-d-choices** rule of Mitzenmacher applied to FRALB offloading; it is
+   *even less novel* than FaaS-MADiG and is used as the random/partial-visibility
+   endpoint of the spectrum. Reproducibility via per-experiment seeding; variance
+   via `--n_experiments`; communication footprint smaller still (only `d` probes
+   per step).
+
+## 11. Positioning / references (`references.bib`)
+
+Reuse the verified entries from `faas-madig-note/references.bib`:
+`mitzenmacher2001` (the **direct** ancestor — promote from "contrast" to "basis"),
+`cybenko1989`, `willebeek1993`, `leechoi2021`, plus `bertsekas1988` if the
+auction relation is mentioned. Cite FaaS-MADeA and FaaS-MADiG as sibling methods.
+The positioning subsection states plainly that the buyer rule **is**
+power-of-d-choices; novelty is not claimed; value is comparative (the random
+endpoint and a partial-visibility ablation of FaaS-MADiG).
+
+> Reuse the citation-verification workflow already applied to the MADiG note:
+> the cited works are the same verified set (existence + metadata checked via
+> CrossRef; PDFs in `faas-madig-note/cited_papers/`), so no re-verification is
+> needed for the shared references.
+
+## 12. Build & insertion
+`latexmk -pdf main.tex` for a preview; insert by `\input{faas-mapod}` into the
+paper, converting plain-text cross-refs to `\ref{}` and merging the (shared)
+`.bib` entries. Remove the notation-recap block on insertion.
+
+---
+
+# Open questions / assumptions
+
+- **Method name** `FaaS-MAPoD` / CLI `faas-powd` are final unless changed in
+  review.
+- **Default `d = 2`** (classic power-of-two-choices); configurable.
+- **Seller clearing stays score-ordered** even when `criterion="capacity"`
+  (so `evaluate_assignments` is reused unchanged). This is no longer an open
+  implementation ambiguity: v1 deliberately randomizes only the
+  probe/selection step, while cross-buyer conflict resolution remains the
+  deterministic score order of FaaS-MADiG.
diff --git a/docs/superpowers/specs/2026-06-30-centralized-feasibility-contract-design.md b/docs/superpowers/specs/2026-06-30-centralized-feasibility-contract-design.md
new file mode 100644
index 0000000..c2ecadf
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-30-centralized-feasibility-contract-design.md
@@ -0,0 +1,46 @@
+# Centralized Feasibility Contract
+
+## Goal
+
+Every non-centralized algorithm must generate solutions that are feasible for
+`LoadManagementModel`. The centralized optimum is therefore a valid upper bound
+for every reported objective value.
+
+Invalid solutions must fail immediately with a diagnostic naming the violated
+constraint. This check is a safety and observability mechanism, not a repair or
+projection step.
+
+## Design
+
+Add one canonical array-level validator for the constraints shared with
+`LoadManagementModel`. It will check traffic conservation, direct-neighbor
+offloading, no ping-pong, utilization bounds, and memory capacity using the same
+tolerances as the solver-facing code.
+
+All algorithms must invoke this validator before accepting a candidate as their
+best centralized solution and before persisting it. Existing algorithm-specific
+checks may delegate to the canonical validator instead of duplicating rules.
+Validation failure raises an exception containing the constraint name and
+indices involved.
+
+The hierarchical auction must also prevent invalid moves by construction.
+Higher-level requests may select a seller only when the concrete buyer and
+seller nodes are direct neighbors. A request is excluded when it would make a
+node both send and receive traffic for the same function. The final validator
+remains active to catch regressions in this or any other algorithm.
+
+## Non-goals
+
+- Do not alter or clamp objective values.
+- Do not project invalid solutions into the feasible region.
+- Do not broaden the centralized model to support multi-hop offloading.
+- Do not refactor unrelated auction or solver logic.
+
+## Verification
+
+Tests will first demonstrate the current failures: hierarchical allocation to a
+non-neighbor, ping-pong creation, and acceptance of an invalid candidate. After
+the change, focused unit tests must show that invalid moves are not generated
+and that the validator reports each relevant constraint. Existing algorithm
+tests and a small Gurobi comparison must confirm that every reported heuristic
+objective is at most the centralized optimum within numerical tolerance.
diff --git a/docs/superpowers/specs/2026-06-30-remote-experiments-design.md b/docs/superpowers/specs/2026-06-30-remote-experiments-design.md
new file mode 100644
index 0000000..ec95f4b
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-30-remote-experiments-design.md
@@ -0,0 +1,201 @@
+# Remote Experiments — Design
+
+## Purpose
+
+Run batches of DFaaSOptimizer algorithm comparisons on remote, SSH-accessible
+VMs with Gurobi installed, dispatched via the `ray-dispatcher` library. The
+work splits into two static phases: **define** a batch of experiments to a
+file, then **run** that file through a TUI that tracks per-experiment and
+per-VM progress and supports stopping/resuming across process restarts.
+
+## Scope
+
+New package `remote_experiments/` inside `DFaaSOptimizer` (not a separate
+repo). It reuses the existing entrypoint scripts
+(`run_centralized_model.py`, `run_faasmacro.py`, `run_faasmadea.py`,
+`decentralized_diffusion.py`, `decentralized_powerd.py`,
+`decentralized_bestresponse.py`, `hierarchical_auction/runner.py`) and the
+algorithm set already enumerated in `run.py`'s `METHOD_RESULT_MODELS`:
+`centralized, faas-macro, faas-macro-v0, faas-madea, hierarchical,
+faas-diffuse, faas-powd, faas-br-s, faas-br-r, faas-br-o`.
+
+Dispatch, SSH transport, provisioning, retries, and local download of
+partial results are all handled by `ray-dispatcher`
+(`miciav/ray-dispatcher`, local checkout at `~/Downloads/ray-dispatcher`)
+and are out of scope here — this project only produces `Job` objects for it
+and polls `Dispatcher.status()`/`Dispatcher.running_hosts()`.
+
+**Dependency:** the live per-VM panel (below) needs to know which host a
+`RUNNING` job is on. The public `Dispatcher` API at the time this spec was
+written only exposed that after a job finished (via `JobResult.host`).
+`ray-dispatcher` was extended first — see its own
+`docs/superpowers/specs/2026-06-30-live-host-visibility-design.md` and
+`docs/superpowers/plans/2026-06-30-ray-dispatcher-phase-9-live-host-visibility.md`
+— to add `Dispatcher.running_hosts() -> dict[str, str]` (job_id → host, for
+every job currently holding a lease). This plan assumes that method exists.
+`Dispatcher` has no public `resolve()`; job duration is tracked locally
+(wall-clock from submit to terminal status), not read from `JobResult`.
+
+## Package layout
+
+```
+remote_experiments/
+├── definitions/
+│   ├── __init__.py        # registry: @register_suite("name") -> builder fn
+│   ├── planar_comparison.py
+│   └── eval_full.py        # one file per pluggable suite
+├── batch.py                 # Experiment, Batch dataclasses + JSON (de)serialization
+├── jobs.py                  # Experiment -> ray_dispatcher.Job
+├── manifest.py               # persisted per-experiment status, for stop/resume
+├── cli.py                    # `define` and `run` subcommands
+└── tui.py                    # experiment selection + live progress view (rich)
+```
+
+## Data model
+
+```python
+@dataclass(frozen=True)
+class Experiment:
+    id: str                  # stable, e.g. "planar_comparison-faas-macro-seed7"
+    suite: str
+    algorithm: str           # key into SCRIPT_BY_ALGORITHM
+    seed: int
+    graph_params: dict       # Nn, Nf, neighborhood, etc.
+    load_params: dict
+    config: dict              # full config JSON to ship to the VM
+
+@dataclass(frozen=True)
+class Batch:
+    suite: str
+    experiments: tuple[Experiment, ...]
+```
+
+`Batch` serializes to a single JSON file. There is no database — the file
+*is* the batch.
+
+## Suite registry (pluggability)
+
+Each file under `remote_experiments/definitions/` registers a builder:
+
+```python
+@register_suite("planar_comparison")
+def build(seeds: list[int]) -> list[Experiment]:
+    ...
+```
+
+The builder returns the cartesian product of graph config × load config ×
+seeds × algorithms for that suite, with stable experiment ids (so resume can
+match experiments across runs). Adding a suite means adding a file to
+`definitions/` — no external registration mechanism (no entry_points).
+
+## Two-phase workflow
+
+1. **Define** (static, run once per batch):
+   ```
+   uv run -m remote_experiments define planar_comparison -o batches/foo.json
+   ```
+   Looks up the suite in the registry, builds the `Experiment` list, writes
+   `batches/foo.json`. This file is the static entity referenced by
+   `run`.
+
+2. **Run** (TUI):
+   ```
+   uv run -m remote_experiments run batches/foo.json
+   ```
+   - Loads `batches/foo.json` and the associated manifest
+     `batches/foo.manifest.json` (created on first run).
+   - Shows experiments with their current status (✓ succeeded / pending /
+     failed / cancelled) and prompts for which to launch — default
+     selection is everything not `SUCCEEDED` (this default *is* the resume
+     mechanism, no separate `resume` command).
+   - Selection input is plain text (indices / ranges / `all` via
+     `rich.prompt`), not a graphical checkbox widget — avoids adding a new
+     dependency (`textual`, `questionary`).
+   - Submits selected experiments via `Dispatcher.submit()` under a fresh
+     `batch_id` (uuid4), then switches to the live progress view.
+
+## Job mapping
+
+For each selected `Experiment`, `jobs.py` writes `experiment.config` to a
+local temp file and builds:
+
+```python
+Job(
+    id=experiment.id,
+    command=("uv", "run", SCRIPT_BY_ALGORITHM[experiment.algorithm], "-c", "config.json"),
+    inputs=(InputSpec(source=local_config_path, destination="config.json"),),
+    outputs=(OutputSpec(source=f"solutions/{experiment.id}", destination=experiment.id),),
+)
+```
+
+`SCRIPT_BY_ALGORITHM` mirrors `METHOD_RESULT_MODELS` from `run.py`. The
+`Project` passed to `Dispatcher` points at the `DFaaSOptimizer` repo root
+(so the VM has `models/`, `generators/`, the `decentralized_*.py` scripts,
+etc. available) and carries the Gurobi license as a secret:
+
+```python
+Project(
+    path=".",
+    project_id="dfaas-optimizer",
+    python="3.10.x",
+    uv_version="...",
+    secrets=(SecretFile(source="~/gurobi.lic", remote_name="gurobi.lic", env_var="GRB_LICENSE_FILE"),),
+)
+```
+
+## Manifest and stop/resume
+
+`manifest.py` persists, per `experiment_id`:
+`{status, host, started_at, finished_at, duration_s, attempt}`, written on
+every status transition observed during polling — so it survives a hard
+kill, not just Ctrl-C.
+
+- **Stop**: Ctrl-C in the TUI is caught; all non-terminal handles get
+  `dispatcher.cancel(handle)`. The manifest reflects whatever state each
+  job reached (`CANCELLED`/`RUNNING`/`PENDING` — any non-`SUCCEEDED` value
+  is enough for the resume logic).
+- **Resume**: re-running `run batches/foo.json` reads the manifest, offers
+  every non-`SUCCEEDED` experiment as the default selection, and submits
+  them under a new `batch_id`. `ray-dispatcher` itself has no batch-resume
+  concept (`Dispatcher.submit` raises `BatchExistsError` if the batch
+  directory already exists) — resume is implemented entirely in this
+  project's manifest, keyed by the stable `experiment.id` rather than by
+  `batch_id`.
+
+## TUI content
+
+`rich.Live`, refreshed roughly once per second by polling
+`dispatcher.status(handle)` for every outstanding handle:
+
+- **Batch summary panel**: total / succeeded / failed / running / pending
+  counts, throughput (completed jobs per minute), elapsed time, and an
+  **ETA** computed as
+  `average_duration_of_completed_jobs * remaining_jobs / total_slots` —
+  a simple heuristic, not a predictive model.
+- **VM panel**: one row per `RemoteHost` from the `Inventory`, showing
+  slots busy/total, the job(s) currently running there, and jobs completed
+  on that host so far. Slot totals are static configuration
+  (`inventory.hosts`); which jobs are currently running where comes from
+  `Dispatcher.running_hosts()`, polled once per tick alongside `status()`.
+- **Experiments table**: id, algorithm, seed, status, assigned host,
+  duration/elapsed.
+
+## Testing
+
+No framework beyond `pytest` (already a dev dependency). One test per
+non-trivial behavior:
+- a sample suite builder produces the expected number of combinations with
+  unique experiment ids
+- `Batch` JSON round-trip
+- `Experiment -> Job` mapping produces the expected command/config/io specs
+- ETA heuristic computes correctly against fabricated completed/pending
+  counts and durations
+
+## Out of scope
+
+- SSH transport, provisioning, retries, partial-result download: owned by
+  `ray-dispatcher`.
+- Interactive in-TUI stop/resume controls (textual-style keybindings) —
+  stop/resume is a cross-process workflow (Ctrl-C, then re-run `run`).
+- External/third-party suite plugins (entry_points) — suites live only
+  inside `remote_experiments/definitions/`.
diff --git a/docs/superpowers/specs/2026-07-01-paper-experiment-generators-design.md b/docs/superpowers/specs/2026-07-01-paper-experiment-generators-design.md
new file mode 100644
index 0000000..a22bc2a
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-01-paper-experiment-generators-design.md
@@ -0,0 +1,124 @@
+# Paper Experiment Generators Design
+
+## Goal
+
+Add registered `remote_experiments` suites that generate the complete experiment
+matrices defined in `docs/hierarchical_model_experiment_plan.md`. The generated
+`Experiment` objects must serialize through the existing `Batch` format and run
+without manual config editing.
+
+## Suite boundaries
+
+One module, `remote_experiments/definitions/paper.py`, registers nine suites:
+
+| Suite | Scientific scope | Default size |
+|---|---|---:|
+| `paper-e0-pilot` | Pipeline calibration | 120 |
+| `paper-e1-quality-runtime` | RQ1 and RQ2; shared runs avoid duplication | 1,800 |
+| `paper-e2-scalability` | RQ3 | 4,230 |
+| `paper-e3-topology` | RQ4 | 1,080 |
+| `paper-e4-robustness` | RQ5, static conditions | 1,260 |
+| `paper-e5-dynamics` | RQ5, temporal conditions | 540 |
+| `paper-e6-ablation` | RQ6 | 1,200 |
+| `paper-e7-tradeoffs` | RQ7 | 1,680 |
+| `paper-e8-spatial-latency` | RQ8 | 720 |
+
+The confirmatory suites total 12,510 runs. E0 uses 10 pilot seeds. E1–E8 use
+the fixed confirmatory seeds 1001 through 1030. Builders accept optional `seeds`
+and, where useful, optional `algorithms` so tests can exercise small matrices;
+the registry and CLI call them without arguments and therefore generate the full
+sets.
+
+## Method sets
+
+E1 uses all ten repository methods. E2 uses all nine non-centralized methods at
+all sizes and adds centralized runs for 10 and 20 nodes. E3–E5 use the fixed,
+predeclared representative set `hierarchical`, `faas-macro`, `faas-madea`,
+`faas-diffuse`, `faas-powd`, and `faas-br-o`. E7 uses `hierarchical`,
+`faas-madea`, `faas-diffuse`, and `faas-powd`, the four methods whose runners
+consume latency and fairness weights. E8 uses the same four methods with a
+predeclared latency weight of 0.25. Fixing these sets before results exist avoids
+post-hoc comparator selection.
+
+## Configuration construction
+
+All suites start from `config_files/eval_full.json`. Small helper functions copy
+the base config, assign one exact factor cell, and build one `Experiment` per
+method and seed. Every config has singleton node and function limits, an exact
+topology definition, a fixed workload definition, and a unique
+`base_solution_folder` equal to `solutions/<experiment-id>`.
+
+Function-dependent arrays are expanded deterministically when `Nf` is 4 or 8:
+demand cycles over `(1.0, 1.2)` and memory requirement cycles over `(2, 3)`.
+This prevents the current two-function base vectors from producing invalid
+larger-function configurations.
+
+Experiment IDs contain the suite, factor labels, method, and seed. IDs use only
+letters, digits, underscores, periods, and hyphens accepted by
+`ray_dispatcher.Job`, and must be globally unique within each suite.
+
+## Experiment-specific factors
+
+E0 varies nodes `(10, 20, 50)` with two functions, four methods, and a connected
+Euclidean planar graph with target mean degree 3. E1 uses nodes `(10, 20, 30)`,
+functions `(2, 4)`, and the same spatial topology. E2 uses nodes
+`(10, 20, 50, 100, 200)`, functions `(2, 4, 8)`, and random-regular degree 3.
+
+E3 uses 50 nodes, four functions, and six density-controlled topology cells:
+Euclidean planar, random regular, and connected Erdős–Rényi `G(n,m)`, each at
+target mean degree 3 or 5.
+E4 uses the seven predefined conditions baseline, low/high load, scarce/ample
+memory, homogeneous nodes, and strongly heterogeneous nodes. E5 uses the three
+supported traces `sinusoidal`, `clipped`, and `fixed_sum_minmax`, with 100 time
+steps.
+
+E6 creates ten hierarchical variants: the base, hierarchy depth `(1, 2, 4, 5)`,
+`eta` values `(0, 0.1, 0.5)`, and `epsilon` values `(0.001, 0.1)`. These are
+crossed with node count `(20, 50)` and planar/random-regular degree-3 topology.
+E7 uses seven `(latency_weight, fairness_weight)` pairs crossed with planar and
+random-regular degree-3 topology.
+
+E8 uses Euclidean planar graphs with target mean degree 3 at 20, 50, and 100
+nodes. It pairs distance-dependent and latency-permuted assignments on the same
+topology for the four latency-compatible methods.
+
+## Connected random topology requirement
+
+Probability-based, fixed-edge, and random-regular generators can return
+disconnected graphs. The generator resamples each random family with the same
+seeded RNG until connected, with a fixed maximum of 1,000 attempts. Exhaustion
+raises a descriptive `ValueError`. Euclidean planar graphs are connected by
+construction through their minimum-spanning-tree backbone.
+
+## Registration and CLI behavior
+
+`remote_experiments/definitions/__init__.py` imports `paper` for registration.
+No CLI changes are needed. A full batch is created with, for example:
+
+```bash
+uv run -m remote_experiments define paper-e1-quality-runtime \
+  -o batches/paper-e1-quality-runtime.json
+```
+
+Each suite produces a separate batch and manifest, allowing execution, resume,
+and postprocessing by research question.
+
+## Validation
+
+Focused tests verify registration of all nine names, exact default counts,
+unique IDs, output-folder consistency, dimension-vector expansion, E2's
+centralized-size restriction, E3 topology coverage, E4 condition coverage, E5
+trace coverage, E6 variant coverage, E7 weight-pair coverage, and E8 spatial
+latency coverage. A reduced-seed batch is serialized and loaded to prove
+compatibility with `Batch`.
+
+The topology tests will prove that probability-based generation returns a
+connected graph and raises after bounded failure. Full `remote_experiments` and
+generator tests must pass before completion.
+
+## Non-goals
+
+This work does not run the experiments, implement analysis metrics, add dynamic
+CLI arguments, tune parameters, or change result formats. Calibration values are
+centralized as module constants so a later pilot can change them without altering
+the suite structure.
diff --git a/docs/superpowers/specs/2026-07-01-remote-experiments-fixes-design.md b/docs/superpowers/specs/2026-07-01-remote-experiments-fixes-design.md
new file mode 100644
index 0000000..5f1bffa
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-01-remote-experiments-fixes-design.md
@@ -0,0 +1,47 @@
+# Remote Experiments Reliability Fixes
+
+## Goal
+
+Make `remote_experiments` provisionable and truthful in normal and resumed runs,
+without expanding its architecture.
+
+## Design
+
+Replace the local `ray-dispatcher` source override with its Git repository pinned
+in `uv.lock`. This makes the same dependency resolvable locally and on remote
+hosts, where the sibling checkout does not exist.
+
+Build jobs with the Python interpreter already exposed by `ray-dispatcher`'s
+provisioned virtual environment. Top-level algorithms run their script directly;
+the hierarchical runner uses `python -m hierarchical_auction.runner` so its
+`types.py` cannot shadow the standard-library `types` module. No second `uv sync`
+is needed inside a job.
+
+Keep `run_batch`'s boolean contract: `True` means polling reached terminal state,
+and `False` means interruption. After a terminal run, the CLI inspects the
+selected experiments in the manifest and reports either success or the number of
+non-successful experiments.
+
+Capture the number of already-succeeded experiments when the live view starts.
+Throughput is `(current successes - initial successes) / current-session elapsed
+time`; persisted durations and ETA behavior remain unchanged.
+
+## Error Handling
+
+Dependency resolution continues to fail during provisioning with the existing
+`ProvisioningError`. Job command failures remain represented by the dispatcher's
+terminal statuses. The CLI must not label a terminal batch successful when any
+selected experiment is not `succeeded`.
+
+## Tests
+
+- Assert generated commands use `python`, and hierarchical uses module mode.
+- Assert a terminal batch containing a failure is not announced as successful.
+- Assert resumed-session throughput excludes successes present at startup.
+- Run all `remote_experiments` tests and verify the hierarchical module entry
+  point directly.
+
+## Non-goals
+
+No dispatcher API changes, vendoring, submodules, new retry behavior, manifest
+format changes, or TUI redesign.
diff --git a/docs/superpowers/specs/2026-07-02-faas-mald-dual-coordination-design.md b/docs/superpowers/specs/2026-07-02-faas-mald-dual-coordination-design.md
new file mode 100644
index 0000000..00b120c
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-02-faas-mald-dual-coordination-design.md
@@ -0,0 +1,212 @@
+# FaaS-MALD — Multi-Agent Lagrangian Dual coordination (design)
+
+Date: 2026-07-02
+Status: draft, awaiting user review
+
+## Context
+
+DFaaSOptimizer solves DiFRALB with a family of decentralized coordinators that
+share one skeleton (per-timestep local LSP solves, an inner coordination loop
+that fills a shared residual-capacity ledger with offloading assignments
+`y[i,j,f]`, replica top-ups via memory bids, `compute_social_welfare` re-solve,
+`check_stopping_criteria`, standard solution saving):
+
+- FaaS-MADEA — Bertsekas-style ε-increment auction (prices as bids)
+- FaaS-MADiG — price-free greedy diffusion
+- FaaS-MABR (S/R/O) — Gauss-Seidel best-response sweeps
+- FaaS-MAPoD — power-of-d-choices sampling
+
+None of them can say how far the coordination outcome is from the optimum of
+the per-timestep coordination problem without running the centralized LMM.
+
+## Goal
+
+A new coordinator, **FaaS-MALD**, that is (a) scientifically grounded —
+projected dual subgradient with known convergence guarantees, (b) original in
+this suite — continuous marginal-value prices plus a per-timestep
+**duality-gap certificate**, and (c) empirically competitive — the buyer step
+is closed-form (no MILP), so inner iterations are cheap.
+
+Constraint: existing code is reused, never modified. FaaS-MALD is one new
+module `decentralized_dual.py` (plus its test), mirroring how
+`decentralized_powerd.py` was added.
+
+## The coordination problem and the algorithm
+
+After the local LSP solves at time t, coordination reduces to the
+transportation LP (same score and filter the other coordinators use):
+
+```
+max  Σ_{i,f} Σ_{j∈N(i)} s_{ijf} · y_{ijf}
+s.t. Σ_j y_{ijf} ≤ ω_{if}          (buyer demand, local to i)
+     Σ_i y_{ijf} ≤ C_{jf}          (seller capacity, coupling)
+     y ≥ 0,   only pairs with s_{ijf} > −γ_{if}
+```
+
+with `s_{ijf} = β_{ijf} − w_lat·L_{ij} − w_fair·φ_{if}` (φ is the fairness
+counter, as in MADiG/MABR).
+
+Relax the coupling constraints with multipliers λ_{jf} ≥ 0 (the "shadow price"
+of seller capacity):
+
+```
+L(λ) = Σ_{jf} λ_{jf} C_{jf} + Σ_{i,f} ω_{if} · max(0, max_{j∈N(i)} (s_{ijf} − λ_{jf}))
+```
+
+**Inner loop** (k = 0, 1, …, per outer coordination iteration):
+
+1. **Buyer response (closed form).** Each buyer i, for each f with ω_{if}>0,
+   ranks accessible sellers by price-adjusted score `s̃ = s_{ijf} − λ_{jf}` and
+   requests its demand greedily from positive-`s̃` sellers, capping each request
+   at the advertised capacity C_{jf} (so requests stay realistic and the
+   waterfilling produces useful bids). The uncapped argmax response is what
+   defines the subgradient; the capped ranked list doubles as the bid list for
+   primal recovery.
+2. **Seller price update (projected subgradient).** Each seller aggregates the
+   demand D_{jf} directed at it and updates
+   `λ_{jf} ← max(0, λ_{jf} + α_k (D_{jf} − C_{jf}))`.
+   Step rule: `α_k = α0/√(k+1)` (default, guaranteed convergence of the dual
+   to the LP dual optimum — Nedić & Ozdaglar 2009 / Bertsekas), or Polyak
+   `α_k = θ (L(λ_k) − best_LB) / ‖g_k‖²` as an option.
+3. **Primal recovery (reuse).** The ranked, price-ordered bids are fed to the
+   existing `decentralized_diffusion.evaluate_assignments` against the true
+   residual capacity, yielding a feasible y. Keep the best feasible y found
+   across inner iterations (LB); L(λ_k) gives a monotone-tracked dual UB.
+4. **Stop** when `(UB − LB)/max(1,|UB|) ≤ gap_tolerance`, or after
+   `max_inner_iterations`, or when demand prices out (no positive s̃ anywhere).
+
+**Certificate.** Per outer iteration the run logs `best_LB`, `best_UB`, and
+the relative gap in the termination-condition CSV — a bound on suboptimality
+of the coordination step that no other method in the suite provides.
+
+**Outer loop, replicas, and everything else** are identical in structure to
+`decentralized_diffusion.run`: commit the best y increment, re-run
+`compute_social_welfare` (LSPr) to re-optimize local variables given y, use
+memory bids + `start_additional_replicas` for replica top-ups when unmet
+demand persists, stop via the shared `check_stopping_criteria` plus a
+"no dual progress" guard, track best decentralized and best centralized
+solutions, save with `save_solution`/`save_checkpoint`.
+
+Distribution model: one inner iteration costs one 1-hop price broadcast per
+seller and one 1-hop demand message per buyer — O(K·|E|·Nf) messages, no
+global state beyond the ledger already assumed by every other coordinator.
+Runtime is amortized per active node, matching `compute_sweep_runtime`-style
+accounting used by the siblings.
+
+## Approaches considered
+
+1. **Lagrangian dual subgradient with greedy primal recovery (chosen).**
+   Closed-form buyer step, tiny per-iteration cost, dual certificate,
+   textbook convergence theory, maximal reuse of `evaluate_assignments`.
+2. **Consensus-ADMM on y.** Stronger (O(1/k)) convergence and no step-size
+   tuning, but needs per-node QP solves and variable duplication — much more
+   new code, no certificate advantage over the dual bound. Rejected.
+3. **Lyapunov drift-plus-penalty.** Provable stability for time-varying load,
+   but changes the per-timestep framing (queues carried across t) and would
+   not be comparable to the existing per-timestep suite. Rejected.
+
+## Architecture and reuse map
+
+New file `decentralized_dual.py` (structure mirrors
+`decentralized_diffusion.py`):
+
+| Piece | Source |
+|---|---|
+| timestep loop, IO, checkpoints, plots | `run_centralized_model` helpers (init_problem, get_current_load, update_data, save_*) |
+| local solves LSP/LSPr, social welfare | `run_faasmacro.solve_subproblem`, `compute_social_welfare`, `combine_solutions`, `decode_solutions` |
+| ledger, stopping, replicas | `run_faasmadea.compute_residual_capacity`, `check_stopping_criteria`, `start_additional_replicas`, `neigh_dict_to_matrix`, `check_ls_pr_feasibility_from_fixed_y` |
+| feasible allocation from priced bids | `decentralized_diffusion.evaluate_assignments` |
+| feasibility / objective checks | `utils.centralized.check_feasibility`, `utils.faasmacro.compute_centralized_objective` |
+| **new**: `dual_coordination_round(...)` — inner subgradient loop returning (best_y_increment, memory_bids, gap_info, n_active) | `decentralized_dual.py` |
+
+New functions are pure on arrays (like `best_response_sweep`) for testability.
+
+## Configuration
+
+Options under `solver_options["dual"]`, all read with defaults so existing
+config files run unchanged:
+
+```json
+"dual": {
+  "alpha0": 1.0,
+  "step_rule": "sqrt",          // "sqrt" | "polyak"
+  "max_inner_iterations": 50,
+  "gap_tolerance": 0.01,
+  "latency_weight": 0.0,
+  "fairness_weight": 0.0
+}
+```
+
+CLI: `uv run decentralized_dual.py -c <config> [-j N] [--disable_plotting]`,
+same flags as the siblings. Method name in outputs: `FaaS-MALD`.
+
+## Outputs
+
+Same artifacts as MADiG (LSP/LSPc solutions, obj.csv, runtime.csv,
+termination_condition.csv) with the gap certificate embedded in the
+termination-condition string: `gap: <rel_gap> (LB: …, UB: …)`.
+
+## Testing
+
+`tests/test_decentralized_dual.py`:
+
+- unit: on a hand-built 3-node/2-function instance, the inner loop's dual
+  values are valid UBs (≥ LP optimum computed by brute force), best-LB is
+  monotone non-decreasing, recovered y is feasible, and the gap closes below
+  1% within the iteration budget;
+- price behavior: an oversubscribed seller's λ rises until demand shifts to
+  the cheaper neighbor;
+- e2e smoke: full `run()` on the small manual-config-style instance produces
+  feasible solutions (`check_feasibility` already asserts inside the loop) and
+  the standard output files.
+
+Benchmark (follow-up, not in scope here): add FaaS-MALD to the comparison
+experiments against MADiG/MABR/MADEA on the paper instances.
+
+## LaTeX technical note (deliverable)
+
+A `faas-mald-note/` directory following the exact pattern of
+`faas-madig-note/`:
+
+- `faas-mald.tex` — the deliverable: a self-contained `\section` in the
+  notation and style of `Decentralized_FaaS_coordination.pdf`, with a
+  fenced `BEGIN/END self-contained notation recap` subsection (relevant
+  rows of the paper's Tables 2–3 and capacity equations), the coordination
+  LP and its Lagrangian relaxation, the algorithm (buyer response, projected
+  subgradient price update, primal recovery, gap certificate), the
+  convergence and weak-duality statements, complexity/message analysis, and
+  a *Positioning with respect to the literature* subsection (dual
+  decomposition / subgradient methods, auction baseline, price-based
+  offloading).
+- `references.bib` — entries cited by the positioning subsection.
+- `main.tex` — minimal standalone wrapper to compile a preview PDF
+  (`latexmk -pdf main.tex`).
+- `README.md` — same structure as the sibling notes' READMEs.
+
+The note is written after the implementation is validated, so the pseudocode
+and the stated properties match the shipped code.
+
+## Implementation execution policy
+
+All implementation tasks from the plan (code, tests, LaTeX note) MUST be
+executed with **Sonnet 5 as the most powerful model allowed** (subagents
+launched with `model: sonnet`); **Haiku** (`model: haiku`) may be used for
+simpler tasks. The plan document must carry this constraint explicitly on
+each task.
+
+## Non-goals
+
+- No modification of any existing module, model, or config file.
+- No integration into `remote_experiments/definitions/paper.py` (would
+  require editing existing code); standalone entrypoint only.
+- No asynchronous/message-passing runtime — same synchronous simulation model
+  as the rest of the suite.
+
+## Theoretical properties (to state in the note)
+
+- With α_k = α0/√(k+1), λ_k converges to the dual optimum of the coordination
+  LP; since the LP has zero duality gap, UB → LP optimum.
+- Every reported gap is a valid per-timestep suboptimality certificate for the
+  coordination step (weak duality), regardless of when the loop is stopped.
+- Per-iteration complexity: O(Σ_i |N(i)|·Nf) buyer-side, O(Nn·Nf) seller-side;
+  message complexity O(|E|·Nf) per iteration, 1-hop only.
diff --git a/docs/superpowers/specs/2026-07-02-faas-mald-findings-remediation-design.md b/docs/superpowers/specs/2026-07-02-faas-mald-findings-remediation-design.md
new file mode 100644
index 0000000..7f4bb74
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-02-faas-mald-findings-remediation-design.md
@@ -0,0 +1,203 @@
+# FaaS-MALD Findings Remediation Design
+
+**Date:** 2026-07-02
+
+**Status:** approved design, pending implementation plan
+
+## Goal
+
+Correct the semantic and lifecycle defects found in the first FaaS-MALD
+implementation, then remove MALD-specific dead paths and dense-graph overhead
+without refactoring the existing coordinators.
+
+## Scope
+
+The work modifies only the MALD module, its tests, and its technical note:
+
+- `decentralized_dual.py`
+- `tests/test_dual_helpers.py`
+- `tests/test_dual_e2e.py`
+- `faas-mald-note/faas-mald.tex`
+- `faas-mald-note/README.md`
+
+Existing coordinators and shared helpers remain unchanged. Extracting a common
+runner from MADiG, MABR, MAPoD, and MALD is explicitly out of scope.
+
+## Phase 1: Correctness
+
+### Cloud-relative coordination reward
+
+The existing coordinators prefer horizontal offloading whenever its score is
+better than Cloud rejection:
+
+```text
+s_ijf > -gamma_if
+```
+
+MALD currently applies that eligibility filter but later requires the raw
+price-adjusted score to be positive. It therefore rejects negative horizontal
+scores even when they are better than Cloud rejection.
+
+MALD will optimize the incremental advantage over Cloud:
+
+```text
+a_ijf = s_ijf + gamma_if
+```
+
+The Cloud is the zero baseline. A pair participates when `a_ijf > 0`, which is
+algebraically equivalent to `s_ijf > -gamma_if`. Seller prices are subtracted
+from `a`, not from the raw score. The primal LB and dual UB use the same
+Cloud-relative reward, so the certificate remains internally consistent.
+
+The bid `utility` used by `evaluate_assignments` must also be the
+Cloud-relative reward. This preserves the same buyer ordering as raw `s` for a
+fixed `(i, f)` because `gamma_if` is constant across that buyer's sellers.
+
+### Replica lifecycle and stopping
+
+The runner currently computes `blackboard`, may create replicas through
+`start_additional_replicas`, and then passes the old blackboard to
+`check_stopping_criteria`. A globally empty old blackboard causes an immediate
+`no capacity left` stop even when replicas have just created new capacity.
+
+After any positive replica increment, MALD will recompute capacity, residual
+capacity, effective load, and blackboard before evaluating stopping criteria.
+The next outer iteration can then use the newly available capacity.
+
+### Certificate identity and observability
+
+`best_ub` can be obtained at an earlier price vector than the final `lam`.
+Whenever `best_ub` improves, the round will retain a copy as `best_lam`.
+`gap_info` will expose `best_lam`; it may optionally expose `final_lam` for
+diagnostics, but a generic `lam` field must not ambiguously refer to one while
+the bound refers to the other.
+
+The certificate applies only to one fixed-residual-capacity inner
+transportation LP. It does not certify the outer MALD solution, replica
+decisions, or the LSPr re-optimization. The runner will write
+`coordination_certificate.csv` with one row per outer coordination iteration:
+
+- `timestep`
+- `outer_iteration`
+- `LB`
+- `UB`
+- `gap`
+- `inner_iterations`
+- `stop_reason`
+
+`termination_condition.csv` remains the final per-timestep summary and labels
+the reported gap as the final inner fixed-capacity LP gap.
+
+### Configuration validation
+
+Before starting the round, MALD validates:
+
+- `max_inner_iterations` is an integer greater than or equal to one;
+- `step_rule` is `sqrt` or `polyak`;
+- `alpha0` is finite and strictly positive for `sqrt`;
+- `theta` is finite and strictly positive for `polyak`;
+- `gap_tolerance` is finite and non-negative;
+- latency and fairness weights are finite.
+
+Invalid settings raise `ValueError` with the option name in the message.
+
+## Phase 2: Simplification and Sparse-Graph Performance
+
+### Sparse neighbor traversal
+
+`pair_scores` will iterate only over nonzero neighbors instead of all node
+pairs. `buyer_price_response` will rank only eligible seller indices rather
+than constructing a dense length-`Nn` adjusted-score vector for every active
+buyer/function pair.
+
+The resulting score and response work is proportional to eligible graph edges
+plus ranking cost, rather than unconditionally `O(Nn^2 * Nf)`.
+
+### Retain the best primal assignment
+
+When a candidate improves the LB, the round will retain both `best_y` and
+`best_bids`. Post-loop placed-demand calculation and the returned increment use
+`best_y` directly. This removes duplicate calls to `evaluate_assignments` and
+makes the identity between returned assignment and reported LB structural.
+
+### Remove unreachable replica paths
+
+MALD will have one replica-start mechanism: memory bids handled by the outer
+runner. `dual_coordination_round` will no longer request tentative replica
+starts or return `additional_replicas`. Its internal return becomes:
+
+```text
+(y_increment, memory_bids, gap_info, n_active)
+```
+
+If recovered demand is short, memory bids are produced for neighbors with
+sufficient memory. The outer runner converts those bids into replica increments
+and recomputes capacity before stopping.
+
+### Remove unreachable forced-memory state
+
+MALD increments are non-negative and its accepted-load total increases whenever
+allocation changes. The copied equal-history stagnation condition cannot
+normally become true. MALD will remove `force_memory_bids`, its accepted-load
+deque, and the corresponding parameter from `dual_coordination_round`.
+
+This change is MALD-only. Other coordinators keep their existing reassignment
+and forced-memory behavior.
+
+## Error Handling and Compatibility
+
+The public `run(config, parallelism, log_on_file=False,
+disable_plotting=False)` API and CLI remain unchanged. Existing configuration
+files without a `solver_options.dual` section continue to use defaults.
+
+The internal `dual_coordination_round` signature changes only in MALD and its
+tests. No compatibility shim is required because GitNexus reports only the MALD
+runner and MALD tests as callers.
+
+## Testing Strategy
+
+Development follows TDD. New regression coverage includes:
+
+1. A negative horizontal score that is still better than Cloud is selected.
+2. Cloud-relative LB/UB bracket a SciPy LP oracle built with `s + gamma`.
+3. `best_lam` reproduces the retained UB.
+4. Invalid numeric dual options raise clear `ValueError` exceptions.
+5. New replicas created from an initially empty blackboard prevent premature
+   stopping and are usable in the following iteration.
+6. The round returns stored `best_y` without repeated evaluator calls.
+7. Sparse graphs evaluate only neighbor pairs.
+8. `coordination_certificate.csv` contains one row per outer iteration with the
+   fixed-capacity scope fields.
+9. Existing helper, E2E, sibling, and full repository suites remain green.
+
+The E2E test continues to run with Gurobi when available. Pure runner lifecycle
+logic introduced by this remediation must also have a focused test that does
+not silently disappear when Gurobi is unavailable.
+
+## Documentation
+
+The LaTeX note and README will be updated to:
+
+- formulate the LP with Cloud-relative advantage `a = s + gamma`;
+- use the same quantity in buyer response, LB, and UB;
+- describe `best_lam` and the per-outer-iteration certificate CSV;
+- state explicitly that the certificate covers a fixed-capacity inner LP;
+- remove tentative-replica and forced-memory pseudocode;
+- state sparse traversal and ranking complexity matching the shipped code;
+- distinguish the practical gap-based `polyak` rule from classical Polyak
+  convergence theory.
+
+The standalone LaTeX preview must compile without undefined references,
+undefined citations, or overfull boxes, and all rendered pages must pass visual
+inspection.
+
+## Acceptance Criteria
+
+- MALD makes the same node-versus-Cloud decision as the sibling coordinators.
+- Replicas created from memory bids can affect the next outer iteration.
+- Every certificate row identifies exactly one fixed-capacity inner LP.
+- The price vector associated with the best UB is reported unambiguously.
+- No MALD-only tentative-replica or forced-memory dead path remains.
+- Sparse graphs are processed through neighbor/eligible indices.
+- Public runner and CLI interfaces remain compatible.
+- All MALD, sibling, and repository tests pass.
diff --git a/docs/superpowers/specs/2026-07-02-faas-mapg-design.md b/docs/superpowers/specs/2026-07-02-faas-mapg-design.md
new file mode 100644
index 0000000..c806123
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-02-faas-mapg-design.md
@@ -0,0 +1,127 @@
+# FaaS-MAPG — Potential-game coordination for DiFRALB
+
+Design spec, 2026-07-02. Approved by Michele in brainstorming session.
+
+## Goal
+
+A new decentralized algorithm, **FaaS-MAPG** (Multi-Agent Potential Game),
+for the DiFRALB problem: joint replica allocation and horizontal offloading
+formulated as an **exact potential game**, with better-response dynamics that
+provably terminate at an ε-Nash equilibrium while the social welfare
+(centralized objective) increases monotonically.
+
+Hard constraint: **no modification to any existing function** of other
+algorithms. Reuse is allowed and encouraged; only new functions, methods,
+classes, and files may be added.
+
+## Game formulation
+
+- **Players**: the nodes `i ∈ N`.
+- **Strategy of node i**: the tuple `(r_i, x_i, z_i, y_i··)` — replicas,
+  locally served load, Cloud-forwarded load, per-neighbour routing.
+- **Utility**: node *i*'s own terms of the centralized objective
+  (`utils.faasmacro.compute_centralized_objective`):
+
+  ```
+  u_i = Σ_f [ α_if·x_if + Σ_j β_ijf·y_ijf − γ_if·z_if ] / λ_if
+  ```
+
+  No latency/fairness terms: the potential coincides exactly with the
+  centralized objective, enabling direct comparison with LMM/MABR/MADeA.
+- **Unilateral-move rules**:
+  1. node *i* must keep serving committed inbound flows `y_·i·`
+     (LSPr-style utilization constraints);
+  2. node *i* may only claim advertised residual capacity of its
+     neighbours (shared ledger, decremented in place, Gauss-Seidel).
+
+  Under these rules a move by *i* leaves every other node's utility terms
+  untouched, hence **Φ = Σ_i u_i = centralized objective is an exact
+  potential**.
+- **Acceptance (better-response)**: a proposed move is committed iff it
+  improves *i*'s true utility (evaluated after the β-aware split) by more
+  than `ε`. Every accepted move raises Φ by ≥ ε; Φ is bounded above ⇒
+  finitely many accepted moves ⇒ termination at an ε-Nash equilibrium.
+  Welfare monotonicity is asserted at runtime.
+
+## Node move (proposal + exact evaluation)
+
+1. Release own row `y_i··` back to the ledger (same bookkeeping as
+   `best_response_sweep` in `decentralized_bestresponse.py`).
+2. Solve a local MILP with the **new model `LSP_pg`** (see below) via the
+   reused `run_faasmacro.solve_subproblem`: decision `(r_i, x_i, z_i, ω_i)`
+   with inbound commitments `y_bar` in the utilization constraints and
+   per-function cap `omega_ub_f = Σ_{j ∈ eligible} ledger[j,f]`.
+   Eligible sellers: neighbours with `β_ijf > −γ_if` (Cloud-relative
+   advantage) and positive ledger.
+3. Split `ω_if` across eligible neighbours by descending `β_ijf`
+   (ties: ascending j), capped by ledger — a fractional knapsack, exact for
+   the linear utility. Unplaced residual goes to `z_if`.
+4. Compute the true `u_i(new)` with per-pair β. Accept iff
+   `u_i(new) − u_i(old) > ε`; on acceptance commit the new row to the
+   ledger and update `x_i, r_i, z_i`; otherwise restore the previous row.
+
+## Seller replica expansion (memory market)
+
+A selfish seller never opens replicas for others (β rewards the buyer).
+Reuse the existing MADeA mechanism verbatim: unplaced demand emits
+`memory_bids`; `run_faasmadea.start_additional_replicas` (reused, not
+modified) converts seller memory slack into capacity. Opening replicas does
+not change Φ (no r-term in the objective) and is bounded by finite memory,
+so monotonicity and finite termination are preserved.
+
+## Dynamics and stopping
+
+- Gauss-Seidel sweeps. Variants: **MAPG-S** (fixed ascending order) and
+  **MAPG-R** (per-sweep random permutation, seeded rng) — mirrors MABR-S/R.
+- Stop when a full sweep produces zero accepted moves and zero replica
+  additions ⇒ certified ε-Nash. Standard guards (max_iterations,
+  time_limit) as in MABR.
+- Per control period `t`: initial local solve P2 (`LSP` via
+  `solve_subproblem`, reused) → sweeps until stop →
+  `compute_social_welfare`, `combine_solutions`,
+  `compute_centralized_objective`, `check_feasibility`,
+  `decode_solutions`, `save_solution` — all reused, matching MABR's outer
+  loop structure.
+
+## Files and integration
+
+| File | Change |
+|------|--------|
+| `decentralized_potentialgame.py` | NEW: `potential_game_sweep()`, `node_move()`, `compute_node_utility()`, `_run()` mirroring MABR, runners `run_pg_s` / `run_pg_r`, CLI `--variant {s,r}` |
+| `models/sp.py` | ADD class `LSP_pg` (LSP + inbound `y_bar` param in utilization constraints + `omega_ub` cap) and `LSP_pg_fixedr` (for the fixed-optimal-replicas comparison mode, mirroring the others). No existing class touched. |
+| `run.py` | ADD imports + map entries `faas-pg-s` / `faas-pg-r` → ("LSPc", "FaaS-MAPG-S"/"-R"). Additive lines only. |
+| `config_files/*.json` (smoke/eval) | ADD `solver_options.pg_s` / `pg_r` with `epsilon` (default 1e-6) |
+| `tests/test_potentialgame_*.py` | NEW: unit (knapsack split, ε-acceptance, `LSP_pg` constraints), property (welfare monotone non-decreasing across iterations; feasibility at every commit), e2e smoke vs centralized on a small instance |
+| `faas-mapg-note/` | NEW: LaTeX note (`faas-mapg.tex` + `main.tex` wrapper + `references.bib` + `README.md`) following the `faas-bestresponse-note` pattern: game formulation, exact-potential proof, better-response algorithm, ε-Nash termination proof, positioning vs MABR/MADeA/MALD |
+
+## `LSP_pg` model detail
+
+Extends `LSP` (Pyomo): adds param `y_bar[(m,i,f)]` (committed inbound) and
+`omega_ub[f]`. Constraints:
+
+- flow: `x_f + ω_f + z_f == λ_if` (inherited `no_traffic_loss`)
+- utilization: `D_if·(x_f + Σ_m y_bar[m,i,f]) ≤ r_f·U_max` (and the
+  matching `≥ (r_f − 1)·U_max` lower bound, LSPr-style)
+- memory budget (inherited), `ω_f ≤ omega_ub_f`
+
+Objective: inherited LSP objective (α·x + δ·ω − γ·z, normalized). δ is a
+proxy for β in the proposal; correctness comes from the exact acceptance
+test in step 4, not from the proposal being optimal.
+
+## Implementation delegation
+
+- **Sonnet** (hard): `LSP_pg`/`LSP_pg_fixedr` models; `node_move` +
+  `potential_game_sweep` + acceptance logic; monotonicity/e2e tests;
+  **the LaTeX note** (formal proofs — quality critical).
+- **Haiku** (easy): `run.py` registration, config keys, CLI/argparse and
+  `_run` boilerplate mirroring MABR, README/docstring touch-ups.
+
+## Correctness invariants (enforced in code/tests)
+
+1. Φ (centralized objective on the combined solution) non-decreasing
+   across accepted moves within a control period.
+2. `check_feasibility` passes after every sweep commit.
+3. Ledger conservation: `ledger[j,f] + Σ_i y[i,j,f] == C_j^f` after every
+   move.
+4. Termination: every run ends with a recorded reason
+   (ε-Nash / max_iterations / time_limit).
diff --git a/docs/superpowers/specs/2026-07-03-faas-magcaa-design.md b/docs/superpowers/specs/2026-07-03-faas-magcaa-design.md
new file mode 100644
index 0000000..7fadba7
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-03-faas-magcaa-design.md
@@ -0,0 +1,208 @@
+# FaaS-MAGCAA: Greedy Coalition Auction Algorithm adapted to FRALB
+
+## Context
+
+The repo implements several decentralized algorithms for the FRALB (Function
+Replica Allocation and Load Balancing) problem, all following the same
+per-timestep pattern: solve a local MILP subproblem per node
+(`solve_subproblem`), then run an inner iterative negotiation loop between
+nodes until convergence, then combine and save the solution
+(`combine_solutions` / `decode_solutions`). Existing decentralized methods:
+FaaS-MADeA (`run_faasmadea.py` / `decentralized_auction.py`, price-based
+double auction), FaaS-MADiG (diffusion), FaaS-MAPoD (power-of-d),
+FaaS-MABR (best response), FaaS-MAPG (potential game).
+
+This spec adds **FaaS-MAGCAA**, an adaptation of the Greedy Coalition
+Auction Algorithm (Braquet & Bakolas, 2021, IFAC) as an additional
+decentralized baseline for experimental comparison against the existing
+family. Goal: pure experimental comparison, not a theoretical contribution
+— so the implementation should stay close to the original algorithm's
+mechanics rather than being tuned for best performance.
+
+## Non-goals
+
+- No dynamic price adjustment (unlike MADeA's `p[j,f]` update) — GCAA bids
+  are pure utility, faithful to the paper.
+- No replica-bidding / dynamic replica creation (MADeA's `memory_bids` /
+  `start_additional_replicas`) — the original GCAA algorithm has a fixed
+  task set and a null assignment (∅, utility 0) for agents with no
+  convenient task; FRALB's "no capacity anywhere" case maps directly to
+  that null assignment, so no new mechanism is needed.
+- No change to the outer per-timestep loop, MILP subproblem, or solution
+  encoding/saving — those are reused unmodified.
+
+## Conceptual mapping (GCAA paper -> FRALB)
+
+| GCAA (paper)                        | FaaS-MAGCAA (this repo)                                   |
+|--------------------------------------|-------------------------------------------------------------|
+| Agent *i*                            | (buyer node *i*, function *f*) pair with residual load `omega[i,f] > 0` |
+| Task *T_j*                           | (seller node *j*, function *f*) pair with residual capacity `blackboard[j,f] > 0` |
+| Bid / utility `U_i`                  | `beta[i,j,f] - latency_weight * latency[i,j] - fairness_weight * fairness[i,f]` (no price term) |
+| Null assignment `a_i = ∅`            | No seller with positive utility available -> agent does not bid this round, its load stays unassigned/local |
+| Coalition (multiple agents on same task) | Multiple buyer (i,f) agents contest the same seller (j,f) across successive rounds; capacity is filled incrementally, one winner per round |
+| Convergence bound (≤ n steps, n = #agents) | ≤ number of (buyer, function) agent-task pairs at that timestep |
+
+## Algorithm
+
+Per timestep `t` (inside the existing `for t in range(min_run_time, ub,
+run_time_step)` loop, after `solve_subproblem` produces the initial `sp_x`,
+`sp_r`, `sp_omega` as today):
+
+```
+y = 0                          # allocated load (buyer -> seller)
+while exists an agent (i,f) with residual omega[i,f] > 0 and at least one
+      seller with positive utility for it:
+  # 1. SelectBestTask
+  for each agent (i,f) with omega[i,f] > 0:
+    candidates = sellers j in neighborhood[i] with blackboard[j,f] > 0
+    bid[i,f] = max utility over candidates (skip if no candidate: null task)
+    proposal[i,f] = argmax seller j
+
+  # 2. Consensus (single winner per task per round, faithful to Algorithm 3)
+  for each contested task (j,f) [i.e. proposal[i,f] == j for >=1 agent]:
+    winner = argmax_i bid[i,f] among agents proposing j for f
+    q = min(omega[winner,f], blackboard[j,f])
+    y[winner,j,f] += q
+    omega[winner,f] -= q
+    blackboard[j,f] -= q
+    # losers: proposal reset to "none this round", they retry next round
+```
+
+Stopping condition (mirrors `check_stopping_criteria` from
+`run_faasmadea.py`, simplified — no price/memory-bid branches):
+- no agent has residual `omega[i,f] > tolerance`, OR
+- no seller has residual `blackboard[j,f] > tolerance`, OR
+- every agent with residual omega has no positive-utility seller left
+  (all remaining proposals are null), OR
+- max iterations / time limit reached (same knobs as MADeA:
+  `max_iterations`, `time_limit`).
+
+After the inner loop converges, the outer flow is unchanged: solve the
+"restricted problem" / recompute `sp_x`, `sp_r`, `sp_rho` from `y` (reuse
+`compute_social_welfare` as MADeA does), combine solutions, compute
+centralized objective, track best-so-far, checkpoint/save — all via the
+existing `run_faasmacro.py` / `run_centralized_model.py` helpers.
+
+## Components
+
+**Correction after re-reading the codebase** (the version below supersedes
+the first draft): the canonical, actively-maintained MADeA implementation
+is `run_faasmadea.py` (imported by `run.py` as `run_auction`), not the
+older `decentralized_auction.py` (dead code, unreferenced by `run.py`,
+lacks the `unit_bids` mode). `run_faasmadea.py`'s `define_bids` already
+has a `unit_bids: true` mode that generates one bid row per integer unit
+of load, each carrying both a ranking price `b` (VCG-style, includes
+`epsilon`/`delta`) *and* the raw `utility` value in a separate column.
+Since GCAA's bid is pure utility with no price adaptation, calling
+`define_bids` with `p` pinned at an all-zero array that is **never
+updated** (no `evaluate_bids` price-update step) makes its `ut`
+computation exactly `beta - latency_weight*latency - fairness_weight*fairness`
+— precisely the GCAA bid formula, with no fork needed. Passing
+`rho = np.zeros(Nn)` (instead of the real `sp_rho`) makes
+`potential_memory_sellers` always empty, so `memory_bids` stays empty and
+the replica-bidding path is inert without needing to strip any code.
+`check_stopping_criteria` in `run_faasmadea.py` is already fully
+parameterized (all its branches degrade gracefully when `memory_bids` is
+always empty and `a`/`additional_replicas` is always zero), so it is
+reused unmodified too.
+
+This means only the **consensus/winner-selection step** is new code —
+everything else is direct reuse. New file: `decentralized_gcaa.py`.
+
+- `resolve_gcaa_round(bids: pd.DataFrame, blackboard: np.array) -> Tuple[np.array, np.array]`
+  — implements Algorithm 1 + Algorithm 3 from the paper in one pass:
+  first keeps only the highest-`utility` row per agent `(i, f)` (one
+  proposal per agent per round, i.e. `SelectBestTask`), then, per
+  contested task `(j, f)`, picks the single highest-`utility` row as
+  winner and transfers its `d` (always `1` under `unit_bids`) from
+  `blackboard[j,f]`. Returns `(y_round, blackboard)` where `y_round` is
+  the `(Nn, Nn, Nf)` allocation delta for this round. Losers are simply
+  absent from `y_round`; they reappear in `bids` next round via the
+  outer loop's call to `define_bids` (their `omega` is unchanged). New
+  code, ~20-25 lines.
+- `run(config, parallelism, log_on_file=False, disable_plotting=False)` —
+  copy of `run_faasmadea.py`'s `run()` outer per-timestep loop and inner
+  `while not stop_searching` loop, with the price/`evaluate_bids` block
+  replaced by a call to `resolve_gcaa_round`, `p` never updated (stays
+  zero), and no replica-bidding branch (dead under `rho=zeros`, so
+  omitted rather than left as inert code — YAGNI). Everything else
+  (subproblem solve, restricted-problem solve, best-solution tracking,
+  checkpointing, saving) is an unmodified copy of the existing loop
+  shape, per repo convention (each `decentralized_*.py` file owns a full
+  `run()`, not a shared parameterized one).
+
+Reused unmodified (imported, not reimplemented):
+- `run_faasmadea.define_bids`, `check_stopping_criteria`,
+  `compute_residual_capacity`, `neigh_dict_to_matrix`
+- `run_faasmacro.solve_subproblem`, `combine_solutions`, `decode_solutions`,
+  `compute_social_welfare`
+- `utils.faasmacro.compute_centralized_objective`
+- `utils.centralized.check_feasibility`
+- `run_centralized_model.init_problem`, `get_current_load`,
+  `init_complete_solution`, `join_complete_solution`, `save_checkpoint`,
+  `save_solution`, `plot_history`, `update_data`
+- `models.sp.LSP`, `LSPr`
+
+## Config
+
+New `solver_options.gcaa` block (mirrors `solver_options.auction` but only
+the keys `define_bids` actually reads — no `eta`/`zeta`, those are
+`evaluate_bids`-only and GCAA never calls it):
+```json
+"gcaa": {
+  "unit_bids": true,
+  "epsilon": 0.01,
+  "latency_weight": 0.0,
+  "fairness_weight": 0.0
+}
+```
+
+## Integration
+
+`run.py`:
+- `METHOD_RESULT_MODELS["faas-gcaa"] = ("LSPc", "FaaS-MAGCAA")`
+- add `"faas-gcaa"` to the `--methods` CLI choices list
+- import `from decentralized_gcaa import run as run_gcaa`
+- add a dispatch block mirroring the existing `if run_a: ... run_auction(...)`
+  block, gated by a new `run_gcaa_flag`/similar boolean derived from
+  `"faas-gcaa" in methods` (following the exact naming/branching pattern
+  already used for `run_a`, `run_diffuse`, etc. in `run.py`)
+
+## Testing
+
+**Correction:** the repo does have a real pytest suite
+(`tests/test_potentialgame_*.py`, `tests/test_diffusion_*.py`, etc.), one
+per algorithm, following a consistent three-layer pattern that
+`decentralized_gcaa.py` will follow:
+
+1. **Helper unit tests** (`tests/test_gcaa_helpers.py`, mirrors
+   `test_potentialgame_helpers.py`) — pure-function tests of
+   `resolve_gcaa_round` against small synthetic `bids` DataFrames and
+   `blackboard` arrays: single winner picked per contested task, losers
+   absent from `y_round`, ties broken deterministically, empty `bids`
+   returns an all-zero `y_round`.
+2. **Wiring tests** (`tests/test_gcaa_wiring.py`, mirrors
+   `test_diffusion_wiring.py`) — `--methods faas-gcaa` accepted by
+   `run.parse_arguments()`, `run.run_gcaa` exists and is callable,
+   `run.set_solution_folder` tolerates a missing `"faas-gcaa"` key, and a
+   fully monkeypatched `run()` smoke test (all I/O and solver calls
+   stubbed) verifying the orchestration wiring without solving any MILP.
+3. **End-to-end test** (`tests/test_gcaa_e2e.py`, mirrors
+   `test_potentialgame_e2e.py`) — skipped if Gurobi is unavailable, runs
+   `decentralized_gcaa.run()` on a small planar instance (same shape as
+   `_e2e_config` in `test_potentialgame_e2e.py`) and asserts `obj.csv`,
+   `runtime.csv`, `termination_condition.csv` are produced and well-formed.
+
+## Open questions / risks
+
+- The paper's ≤ n round bound assumes exactly one task finalized per
+  round system-wide (single global consensus). Here, multiple **different**
+  (j,f) tasks can each finalize a winner in the same round (independent
+  seller queues), so the practical round count is likely lower than
+  `Nn * Nf`, not higher — worth confirming empirically rather than
+  re-deriving the bound formally, since this is a comparison baseline, not
+  a proof.
+- Fairness weighting (`fairness[i,f]`) accumulates only within a single
+  timestep's inner loop today (matches MADeA's existing behavior) — no
+  change proposed here, flagged only so it isn't mistaken for a bug during
+  review.
diff --git a/docs/superpowers/specs/2026-07-03-faas-magcaa-note-design.md b/docs/superpowers/specs/2026-07-03-faas-magcaa-note-design.md
new file mode 100644
index 0000000..dcb8ef6
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-03-faas-magcaa-note-design.md
@@ -0,0 +1,59 @@
+# FaaS-MAGCAA Technical Note Design
+
+## Goal
+
+Create an English, paper-ready LaTeX technical note for FaaS-MAGCAA that
+matches the structure and standalone usability of `faas-mapg-note`. The note
+must describe the implemented algorithm exactly, distinguish inherited GCAA
+ideas from FRALB-specific adaptations, and avoid unsupported convergence or
+optimality claims.
+
+## Deliverables
+
+Create `faas-magcaa-note/` containing:
+
+- `faas-magcaa.tex`: the section intended for `\input{}` into the paper;
+- `main.tex`: a minimal standalone preview wrapper;
+- `references.bib`: verified primary references;
+- `README.md`: build and integration instructions;
+- `.gitignore`: LaTeX build artifacts.
+
+## Content
+
+The main section will introduce FaaS-MAGCAA and position it against FaaS-MADeA,
+FaaS-MALD, FaaS-MABR, and FaaS-MAPG. A removable notation recap will define
+FRALB load, residual demand, seller capacity, utility, routing, and the
+no-ping-pong constraint. The method description will then map GCAA agents and
+tasks to buyer--function and seller--function pairs, formalize pure-utility
+bids, and present the single-winner consensus rule.
+
+The pseudocode will match `decentralized_gcaa.py`: unit bids, zero price
+adaptation, no replica bidding, one preferred seller per buyer--function pair,
+one accepted winner per seller--function pair per round, residual-capacity
+checks, and dynamic sending/receiving guards that preserve no-ping-pong both
+across previous allocations and within a round. It will also describe the
+re-optimization and artifact-generation path reused from the existing runners.
+
+The properties section will state only defensible results: per-round capacity
+feasibility, single-winner consensus, and inductive preservation of the
+no-ping-pong invariant. It will explicitly state that the original GCAA round
+bound does not automatically transfer to this FRALB adaptation, whose practical
+guards are maximum iterations and wall-clock time. The observed possibility of
+termination by the maximum-iteration guard will not be presented as a
+convergence certificate.
+
+## References and Verification
+
+Bibliographic metadata and algorithm claims will be checked against the primary
+Braquet--Bakolas publication and other primary sources used for positioning.
+The implementation-facing statements will be checked against
+`decentralized_gcaa.py`, `run_faasmadea.py`, `run_faasmacro.py`, and the GCAA
+tests. The standalone document must compile with `latexmk -pdf main.tex`; the
+log must contain no undefined references or citations.
+
+## Scope
+
+No production code, configuration, or other algorithm note will be modified.
+No experimental performance claims or generated plots will be added because
+the request is for an algorithmic technical note and the repository does not
+yet contain a controlled MAGCAA comparison dataset.
diff --git a/docs/superpowers/specs/2026-07-06-campaign-two-phase-design.md b/docs/superpowers/specs/2026-07-06-campaign-two-phase-design.md
new file mode 100644
index 0000000..62afa88
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-06-campaign-two-phase-design.md
@@ -0,0 +1,138 @@
+# Two-phase auto-chained experimental campaign
+
+**Date:** 2026-07-06
+**Status:** Design approved, pending spec review
+**Scope:** `remote_experiments/` — new `campaign` orchestrator, screening suite, survivor-driven confirmatory suites.
+
+## Problem
+
+The `paper.py` campaign is **12,630 experiments** across 9 suites, run on **3 VMs × 2 slots = 6 workers**. The confirmatory suites use 30 seeds and the quality/scalability suites run all 10–13 algorithms (e1: all algos; e2: up to n=200), producing the slowest, most numerous cells. On 6 workers this is weeks of wall-clock. There is no cross-suite orchestration: `define`/`materialize`/`run` are separate per-suite commands and `run` blocks on an interactive `input()` prompt (`cli.py:48`).
+
+## Goal
+
+Cut the campaign to the minimum runs that still answer the research questions, and launch it with a **single command**. Achieve this with a **screen-then-confirm** design: cheaply rank all candidate algorithms by objective deficit relative to the best method on each instance (at mid-scale, where centralized no longer scales), promote the best 4, then run the confirmatory suites only on those 4 plus the two anchors.
+
+Locked decisions (from brainstorming):
+- Screening metric: **relative-to-best objective** on a mid-scale grid, runtime as tie-break. Centralized is *not* run in screening (it does not scale past n≈20 within the 120s Gurobi limit, so it cannot provide an optimal baseline at screening sizes).
+- Promote **top 4** decentralized algorithms.
+- Anchors always present: `centralized`, `hierarchical-madea`.
+- Confirmatory seeds: **5** (parametrized, so cells can be topped up later).
+- Ablation (e6): **n=50 only**.
+- Scalability (e2): **add n=500**.
+- Automation level: **full auto-chain**, including automatic survivor selection.
+
+## Screening metric: relative-to-best (settled)
+
+The model maximizes (`models/rmp.py:119`, `models/model.py` — `sense = pyo.maximize`), so higher objective is better. Centralized would be the true upper bound but does not scale to screening sizes (excluded past n≤20 in `build_e2`, `TimeLimit=120s`), so screening ranks by **relative deficit to the best algorithm on each instance**. For each instance `i = (cell, seed)`, let `obj_best(i) = max_a obj_a(i)` over the algorithms present:
+
+```
+reldef(a) = mean over i of  (obj_best(i) − obj_a(i)) / obj_best(i) · 100    (≥ 0; smaller = better)
+```
+
+`hierarchical-madea` participates in screening so `obj_best` is anchored to the strongest known method even when candidates are weak; it is excluded from the promotion pool (it is an anchor and always advances). The computation reuses the deviation logic in `compare_results.py:279` (`(baseline − obj)/obj·100`, joined on shared keys), with `obj_best` per instance as the reference instead of a fixed baseline column.
+
+## Architecture
+
+Three-stage pipeline behind one command, each stage independently resumable.
+
+```
+campaign run
+  │
+  ├─ Stage 1  SCREENING   define+materialize+run  paper-a-screening   (260 runs)
+  │
+  ├─ Stage 2  SELECT      postprocess → relative-to-best deficit per algo
+  │                       → rank → batches/survivors.json (top 4)
+  │                       guard: abort if too many runs failed / no objective
+  │
+  └─ Stage 3  CONFIRM     for suite in e1..e8:
+                            define(survivors) + materialize + run     (~1640 runs)
+```
+
+**Resumability.** Per-batch manifests (`*.manifest.json`) already give run-level resume. A new `batches/campaign-state.json` records the last completed stage and, within Stage 3, the last completed suite. Re-running `campaign run` continues from there. Ctrl-C uses the existing dispatcher clean-stop.
+
+### New component: `remote_experiments/campaign.py`
+
+- `run_campaign(inventory, gurobi_license, ...)` — drives the three stages, reading/writing `campaign-state.json`.
+- Stage helpers reuse existing functions: `get_suite`, `materialize_batch`, `run_batch`, `Manifest`. No new run machinery.
+- Selection helper `select_survivors(screening_results_dir) -> list[str]`:
+  1. Postprocess each screening run (existing `postprocessing.py` pipeline) to obtain `obj.csv`, `runtime.csv`, `termination_condition.csv`.
+  2. Drop runs that failed / produced no valid objective (via `termination_condition.csv` and a missing/NaN obj check). Note: decentralized methods do not report `optimal`; only failed/no-objective runs are dropped, not converged-but-suboptimal ones.
+  3. Per instance `(cell, seed)`, compute `obj_best` across all algorithms present (including `hierarchical-madea`), then each candidate's `reldef` = mean over instances of `(obj_best − obj_a)/obj_best·100` (reuse `compare_results` deviation logic).
+  4. Rank ascending by mean `reldef`; break ties by median runtime.
+  5. Return the top 4 **candidate** algorithms (anchors excluded from promotion).
+- Guard: if fewer than `MIN_VALID_FRACTION` (default 0.8) of screening runs are valid, or fewer than 4 candidates produce any valid run, abort Stage 2 with a clear message instead of promoting.
+
+### CLI change: `cli.py`
+
+- Add `campaign` subcommand → `remote_experiments/campaign.py:run_campaign`, taking the same `--inventory`, `--gurobi-license`, `--instances`, `--results-dir`, project args as `run`.
+- Add `--yes` (alias `--select all`) to **`run`** so it skips the `input()` prompt. `campaign` invokes the run stage non-interactively via the same code path. Interactive behavior unchanged when the flag is absent.
+
+### Survivor injection: `definitions/paper.py`
+
+- `ANCHORS = ("centralized", "hierarchical-madea")`.
+- `DEFAULT_SURVIVORS` = current `("faas-madea", "faas-diffuse", "faas-powd", "faas-br-o")` (fallback for standalone `define` / tests).
+- `_survivors()` reads `batches/survivors.json` (`{"survivors": [...]}`) if present, else `DEFAULT_SURVIVORS`.
+- `FINAL = ANCHORS + _survivors()` (6 algorithms).
+- Confirmatory builders use `FINAL` (or the survivors-only / centralized-gated variants) instead of hardcoded `ALL/REPRESENTATIVE/TRADEOFF` tuples.
+- Because Stage 2 writes `survivors.json` before Stage 3 calls `define`, the builders pick up the real survivors at define time.
+
+## Suites
+
+### New: `paper-a-screening`
+Algorithms: `hierarchical-madea` (reference for `obj_best`, not promotable) + 12 candidates (`faas-macro`, `faas-macro-v0`, `faas-madea`, `faas-diffuse`, `faas-powd`, `faas-br-s`, `faas-br-r`, `faas-br-o`, `faas-pg-s`, `faas-pg-r`, `faas-gcaa`, `plasma`) = 13. **No `centralized`** (does not scale to these sizes).
+Grid: nodes ∈ {50, 100}, functions ∈ {2, 4}, planar-3, 5 seeds.
+**13 × 4 × 5 = 260 runs.** Promotion pool = the 12 candidates (anchors auto-advance regardless of their deficit).
+
+### Confirmatory suites (5 seeds, algorithm set = `FINAL` unless noted)
+
+| Suite | Grid | Algorithms | Runs |
+|---|---|---|---:|
+| e1-quality-runtime | nodes{10,20,30} × func{2,4} × planar3 | FINAL (6) | 180 |
+| e2-scalability | nodes{10,20,50,100,200,**500**} × func{2,4,8} × reg3 | survivors+hier (5); +centralized for n≤20 (6) | 480 |
+| e3-topology | 6 topologies × n50 f4 | FINAL (6) | 180 |
+| e4-robustness | 7 conditions × n50 f4 planar3 | FINAL (6) | 210 |
+| e5-dynamics | 3 traces × n50 f4 (100 steps) | FINAL (6) | 90 |
+| e6-ablation | 10 variants × **n{50}** × 2 topologies | hierarchical-madea only | 100 |
+| e7-tradeoffs | 7 weights × 2 topologies | weight-tunable subset of FINAL (≤4) | ≤280 |
+| e8-spatial-latency | nodes{20,50,100} × 2 modes | weight-tunable subset of FINAL (≤4) | ≤120 |
+
+**Weight-tunable subset (e7/e8):** only algorithms with a per-section weight (`latency_weight`/`fairness_weight`) can vary it. Section map: `hierarchical-madea`→auction, `faas-madea`→auction, `faas-diffuse`→diffusion, `faas-powd`→powerd. Survivors outside this map are excluded from e7/e8 only (they remain in e1–e5). If none of the 4 survivors is tunable, e7/e8 fall back to `hierarchical-madea` alone (a warning is logged).
+
+**Total: 260 (screening) + ~1640 (confirmatory) ≈ 1,900 runs** vs 12,630 (**≈6.6× fewer**, and the slowest cells removed by construction). Screening runs are at n∈{50,100} so each is heavier than a small-grid run, but 260 runs are still negligible against the confirmatory total.
+
+## Data flow
+
+```
+screening solutions/<id>/  ──postprocess──▶  obj.csv, runtime.csv, termination_condition.csv
+        │
+        ▼  obj_best per (cell,seed); reldef per algo; drop failed/no-obj runs
+   rank + tie-break ──▶ batches/survivors.json {"survivors":[a1,a2,a3,a4]}
+        │
+        ▼  read by paper.py _survivors()
+   confirmatory define(FINAL) ──▶ materialize ──▶ run
+```
+
+## Error handling
+
+- **Screening degenerate** → Stage 2 aborts before promoting; user re-runs screening or overrides `survivors.json` by hand.
+- **Individual run failure** → tracked in the suite manifest as not-`SUCCEEDED`; `campaign run` re-selects only pending on resume (existing behavior).
+- **Ctrl-C** → dispatcher stops in-flight jobs cleanly; `campaign-state.json` preserves stage progress.
+- **`survivors.json` missing at Stage 3 define** (e.g., manual run out of order) → builder falls back to `DEFAULT_SURVIVORS` and logs a warning; no crash.
+
+## Statistical note (non-blocking)
+
+5 seeds is thin for confidence intervals. `CONFIRMATORY_SEEDS` stays a single-source constant so a specific noisy cell can be topped up to 15/30 by editing one tuple and re-running (`materialize`/`run` reuse existing instances and resume). Report with non-parametric summaries / CIs given n=5.
+
+## Testing
+
+- `test_select_survivors`: synthetic screening results (known objs, `obj_best` per instance) → asserts the 4 lowest-`reldef` candidates are chosen and runtime breaks ties; asserts failed/no-objective runs are dropped and the guard trips below the valid-fraction threshold; asserts `hierarchical-madea` is never promoted even if it has the best objective.
+- `test_paper_suites_counts`: each confirmatory suite defines the exact run count in the table above given a fixed `survivors.json`; screening = 260.
+- `test_survivors_fallback`: `define` with no `survivors.json` uses `DEFAULT_SURVIVORS` and stays runnable.
+- `test_run_yes_flag`: `run --yes` skips the prompt and selects all pending (no stdin).
+- `test_e7e8_tunable_filter`: a non-tunable survivor is excluded from e7/e8 but present in e1.
+
+## Out of scope
+
+- No changes to the algorithms themselves or their runners.
+- No new plotting; analysis reuses `compare_results.py`.
+- No automatic top-up of seeds (manual one-tuple edit is enough).
diff --git a/faas-bestresponse-note/.gitignore b/faas-bestresponse-note/.gitignore
new file mode 100644
index 0000000..ab6921a
--- /dev/null
+++ b/faas-bestresponse-note/.gitignore
@@ -0,0 +1,10 @@
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+*.synctex.gz
+*.toc
+*.bbl
+*.blg
+main.pdf
diff --git a/faas-bestresponse-note/README.md b/faas-bestresponse-note/README.md
new file mode 100644
index 0000000..66ed01a
--- /dev/null
+++ b/faas-bestresponse-note/README.md
@@ -0,0 +1,27 @@
+# FaaS-MABR note
+
+A paper-ready LaTeX section explaining the **FaaS-MABR** family --- three
+sequential (Gauss-Seidel) best-response heuristics (S: fixed-order greedy, R:
+randomized-order greedy, O: capped local best response) --- in the notation of
+`Decentralized_FaaS_coordination.pdf`.
+
+## Files
+- `faas-mabr.tex` --- the `\section{}` to `\input{}` (or paste) into the paper.
+  Remove the self-contained "Notation and capacity model" subsection on
+  insertion.
+- `main.tex` --- standalone preview wrapper.
+- `references.bib` --- cited works (Bertsekas & Tsitsiklis 1989 Gauss-Seidel
+  anchor; Cybenko diffusion; Bertsekas auction).
+- `.gitignore` --- LaTeX build artifacts.
+
+## Build a preview
+```bash
+cd faas-bestresponse-note
+latexmk -pdf main.tex
+```
+
+## Insert into the paper
+1. `\input{faas-mabr}` (or paste the section).
+2. Delete the "Notation and capacity model" subsection.
+3. Convert plain-text cross-references to the host paper's `\ref{}` labels.
+4. Merge `references.bib` into the paper's bibliography.
diff --git a/faas-bestresponse-note/faas-mabr.tex b/faas-bestresponse-note/faas-mabr.tex
new file mode 100644
index 0000000..61728f0
--- /dev/null
+++ b/faas-bestresponse-note/faas-mabr.tex
@@ -0,0 +1,209 @@
+% =====================================================================
+% FaaS-MABR: distributed best-response (Gauss-Seidel) heuristics.
+% Meant to be \input{} (or pasted) into the paper. Assumes the paper's
+% notation (N, F, C_i^f, rho_i, omega_i^f, beta_{ij}^f, gamma_i^f, ...).
+% Cross-references are plain text; convert to \ref{} in the host paper.
+% =====================================================================
+
+\section{FaaS-MABR: sequential best-response (Gauss-Seidel) variants}
+\label{sec:mabr}
+
+\textsc{FaaS-MABR} (Multi-Agent Best-Response) is the \emph{sequential}
+counterpart of the \emph{simultaneous} coordination used by \textsc{FaaS-MADiG}
+and \textsc{FaaS-MAPoD}. The auction and its price-free diffusion ablations
+compute every overloaded node's request against a single snapshot of advertised
+capacity and then resolve the resulting cross-node conflicts (a Jacobi-style
+round followed by seller-side clearing). \textsc{FaaS-MABR} instead visits nodes
+in an order and lets each node claim capacity on a \emph{shared residual-capacity
+ledger that is decremented in place}, so a node responds to what earlier nodes
+have already taken. This is the Gauss-Seidel analogue of the same coordination
+problem, and because updates are sequential there are no cross-node conflicts and
+\emph{no seller-clearing phase}. Everything else is inherited from
+\textsc{FaaS-MADiG}: the local problem~(P2) that fixes $x_i^f$, $r_i^f$, and the
+residual demand $\omega_i^f$; the price-free score~$s_{ij}^f$ and the convenience
+threshold $\gamma_i^f$; the price-free replica expansion of Algorithm~4; and the
+restricted re-solve after each round.
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% Reproduces the relevant rows of the paper's Table 2 (FRALB) and Table 3
+% (auction) plus Eqs. (1),(2),(12),(13), so the note is readable on its own.
+% REMOVE this whole subsection when inserting into the paper, where the
+% notation and these equations are already defined.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:mabr-notation}
+
+Each control period $t$ runs auction iterations $h=0,1,\dots,H_{\max}$ in
+parallel. Before coordination, every node $i$ solves a local problem~(P2)
+that, for each function $f\in\mathcal{F}_i$, splits the incoming workload
+$\lambda_i^f$ into locally processed load $x_i^f$, horizontally offloaded
+demand $\omega_i^f$, and Cloud-forwarded load $z_i^f$, and fixes the number of
+replicas $r_i^f$. Replicas obey the memory budget and provide capacity
+\begin{equation}
+  \sum_{f\in\mathcal{F}_i} r_i^f\,\mathrm{RAM}^f \le \mathrm{RAM}_i,
+  \qquad
+  \mathrm{Cap}_i^f = \frac{r_i^f\,U^f_{\max}}{D_i^f}\ \text{[req/s]} ,
+  \tag{1,2}
+\end{equation}
+from which each node advertises, on a neighbour-accessible blackboard, its
+residual execution capacity and its memory slack:
+\begin{equation}
+  C_i^f(h) = \max\!\big\{0,\ \mathrm{Cap}_i^f(h) - x_i^f(h)\big\},
+  \qquad
+  \rho_i(h) = \mathrm{RAM}_i - \sum_{f\in\mathcal{F}_i} r_i^f(h)\,\mathrm{RAM}^f \ge 0 .
+  \tag{12,13}
+\end{equation}
+Table~\ref{tab:mabr-notation} collects the symbols used below.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in this section (subset of the paper's Tables~2--3).}
+\label{tab:mabr-notation}
+\small
+\begin{tabular}{@{}l l p{0.62\linewidth}@{}}
+\toprule
+\multicolumn{3}{@{}l}{\textit{Sets}}\\
+Nodes / neighbours & $\mathcal{N}$, $N_i$ & computing nodes; one-hop neighbours of $i$.\\
+Functions & $\mathcal{F}_i$ & functions deployable on $i$; $\mathcal{F}=\bigcup_i \mathcal{F}_i$.\\
+Candidate sellers & $A_i^f(h)$ & neighbours of $i$ with positive score for $f$, $A_i^f(h)\subseteq N_i$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Parameters and weights}}\\
+Input workload & $\lambda_i^f$ & incoming request rate for $f$ at $i$ [req/s].\\
+Memory cap / demand & $\mathrm{RAM}_i$, $\mathrm{RAM}^f$ & node memory; per-replica memory of $f$ [MB].\\
+Service demand & $D_i^f$ & average execution time of $f$ at $i$ [s].\\
+Max utilization & $U^f_{\max}$ & stability threshold, $U^f_{\max}\in[0,1)$.\\
+Local / offload / Cloud profit & $\alpha_i^f$, $\beta_{ij}^f$, $\gamma_i^f$ & profit of local exec.; profit of offloading $i\!\to\! j$; Cloud-offloading penalty (per req/s).\\
+Communication latency & $L_{ij}$ & horizontal-offloading latency between $i$ and $j$.\\
+Weights & $w_{\mathrm{lat}}$, $w_{\mathrm{fair}}$ & importance of latency and of fairness.\\
+Max iterations & $H_{\max}$ & auction iterations per control period.\\
+Price params \emph{(MADeA only)} & $\varepsilon$, $\zeta$ & min.\ bid increment; idle-seller price discount $\zeta\in(0,1)$.\\
+Offloading cap & $\omega^{\mathrm{ub}}_i$ & per-function cap on $\omega_i$ in the capped local best response (FaaS-MABR-O).\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Variables and state at iteration $h$}}\\
+Replicas & $r_i^f$ & number of $f$ replicas on $i$, $r_i^f\in\mathbb{N}_0$.\\
+Local / forwarded / Cloud load & $x_i^f$, $y_{ij}^f$, $z_i^f$ & locally served; forwarded $i\!\to\! j$; Cloud-offloaded [req/s].\\
+Offloaded demand & $\omega_i^f$ & horizontal demand still to place [req/s].\\
+Effective load & $\ell_i^f$ & load to be served at $i$ for $f$ [req/s].\\
+Capacity / residual / slack & $\mathrm{Cap}_i^f$, $C_i^f$, $\rho_i$ & exec.\ capacity (Eq.~2); residual exec.\ capacity (Eq.~12); memory slack (Eq.~13).\\
+Congestion ratio & $\kappa_i^f$ & utilization ratio for $f$ on $i$, $\kappa_i^f\in[0,1]$.\\
+Fairness term & $\phi_i^f$ & penalty on nodes that offload excessively.\\
+Execution price \emph{(MADeA only)} & $p_i^f$ & shadow cost of residual capacity; \textbf{removed} in \textsc{FaaS-MADiG}.\\
+Coordination score & $s_{ij}^f$ & price-free preference of buyer $i$ for seller $j$ (Eq.~\eqref{eq:mabr-score}).\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{Sequential best-response sweep}
+\label{sec:mabr-sweep}
+
+At iteration $h$ the coordination is a single \emph{sweep} over the nodes. Let
+$\tilde C_j^f$ be the shared ledger, initialized to the true residual capacity
+$C_j^f(h)$ and updated in place during the sweep. Before node $i$ responds, its
+current assignment row $y_{i\cdot}^f(h)$ is released back to the ledger. Visiting the nodes in the
+order $\sigma$ (a fixed index order or a per-sweep random permutation), each node
+$i$, for every $f$ with target $\omega_i^f(h)>0$, admits the candidate sellers
+\begin{equation}
+  A_i^f(h)=\{\,j\in N_i : \tilde C_j^f \ge 1 \ \text{and}\ s_{ij}^f(h)>-\gamma_i^f\,\},
+  \qquad
+  s_{ij}^f(h)=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f(h),
+  \label{eq:mabr-score}
+\end{equation}
+and constructs a replacement row greedily in descending score order (tie-break: lower
+node id), decrementing $\tilde C_{j}^f$ as it claims, until $\omega_i^f(h)$ is met
+or $A_i^f(h)$ is exhausted. The immediate decrement is what distinguishes
+Gauss-Seidel from the Jacobi snapshot of \textsc{FaaS-MADiG}: in a fixed-order
+sweep a node that acts earlier can consume capacity that a later node would
+otherwise have seen. Unplaced demand triggers the same price-free
+replica-expansion requests to neighbours with memory slack $\rho_j(h)>0$ as in
+\textsc{FaaS-MADiG} (the two-block emission), collected over the whole sweep and
+served by Algorithm~4 afterwards. The inter-sweep restricted re-solve makes the
+overall scheme a Gauss-Seidel relaxation: each sweep best-responds to the state
+left by the previous sweep's re-solve, and the loop stops at a fixed point (a
+sweep whose coordinate deltas are zero and that starts no replicas).
+
+\subsection{The three variants}
+\label{sec:mabr-variants}
+
+\textsc{FaaS-MABR} spans two axes.
+
+\paragraph{Node order.} \textsc{FaaS-MABR-S} sweeps in a fixed ascending node
+order (deterministic, reproducible). \textsc{FaaS-MABR-R} draws a fresh random
+node permutation each sweep from a per-run generator seeded once; statistical
+variance is obtained by repeating experiments, as for \textsc{FaaS-MAPoD}.
+
+\paragraph{Response type.} \textsc{FaaS-MABR-S}/\textsc{-R} use a \emph{sequential
+greedy} response: the node replaces its complete buyer row on the ledger as above.
+These are Gauss-Seidel greedy responses, not optimal best responses.
+\textsc{FaaS-MABR-O} uses a \emph{capped local best response}: before placing,
+node $i$ re-solves its local subproblem with the horizontal offloading capped at
+the capacity its neighbours currently still advertise,
+\begin{equation}
+  \omega_i^f \le \omega^{\mathrm{ub}}_{i,f}, \qquad
+  \omega^{\mathrm{ub}}_{i,f}=\sum_{j\in N_i}\tilde C_j^f ,
+  \label{eq:mabr-cap}
+\end{equation}
+so it can reduce its horizontal demand and leave the rest to local execution or
+Cloud forwarding in the subsequent restricted solve. Only the re-optimized
+$\omega_i$ is committed to the sweep before placement; the capped probe's
+$x/z/r$ are diagnostic, and the final feasible state is produced by the
+restricted re-solve with fixed $y$. (The fourth combination, randomized-order
+re-optimization, is not used.)
+
+When the experiment fixes the centralized replica plan, both the capped probe
+and the restricted re-solve enforce that plan and the coordination phase receives
+zero memory slack; replica expansion is therefore disabled throughout the run.
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MABR} --- one sequential best-response sweep}
+\label{alg:mabr-sweep}
+\begin{algorithmic}[1]
+\Require ledger $\tilde C\gets C(h)$, current assignment $y(h)$, offloading target $\omega(h)$, order $\sigma$, response $\in\{\text{greedy},\text{reopt}\}$
+\For{each node $i$ in order $\sigma$}
+  \State $\tilde C_j^f\gets\tilde C_j^f+y_{ij}^f(h)$ for all $j,f$; initialize replacement row $y'_{i\cdot}\gets0$
+  \If{response $=$ reopt}
+    \State $\omega^{\mathrm{ub}}_{i,f}\gets\sum_{j\in N_i}\tilde C_j^f$;\quad re-solve node $i$'s capped local problem; commit only $\omega_i$
+  \EndIf
+  \For{each $f$ with $\omega_i^f(h)>0$}
+    \State $A_i^f(h)\gets\{\,j\in N_i:\tilde C_j^f\ge1,\ s_{ij}^f(h)>-\gamma_i^f\,\}$
+    \State place $\omega_i^f(h)$ into $y'_{i\cdot}$ greedily by descending $s_{ij}^f(h)$ (tie-break lower id), decrementing $\tilde C_j^f$ in place
+    \If{demand remains or expansion is forced} emit requests to neighbours with $\rho_j(h)\ge\mathrm{RAM}^f$ \EndIf
+  \EndFor
+  \State commit coordinate delta $\Delta y_{i\cdot}\gets y'_{i\cdot}-y_{i\cdot}(h)$
+\EndFor
+\State after the sweep: start additional replicas (Alg.~4); re-solve the restricted problem with fixed $y$
+\end{algorithmic}
+\end{algorithm}
+
+\subsection{What is kept and what changes}
+\label{sec:mabr-ablation}
+
+\noindent\textbf{Kept} (identical to \textsc{FaaS-MADiG}): the local
+problem~(P2); the advertised residual capacity and memory slack
+(Eqs.~(12)--(13)); the price-free score~\eqref{eq:mabr-score} and convenience
+threshold $\gamma_i^f$; the fairness penalty $\phi_i^f$; the price-free replica
+expansion of Algorithm~4; and the restricted re-solve.
+
+\noindent\textbf{Changed}: simultaneous (Jacobi) coordination becomes sequential
+(Gauss-Seidel) with an in-place-decremented ledger; the seller-clearing phase is
+removed (sequential updates produce no conflicts); and \textsc{FaaS-MABR-O} adds
+the anticipatory capped local re-optimization of Eq.~\eqref{eq:mabr-cap}.
+
+\subsection{Positioning with respect to the literature}
+\label{sec:mabr-related}
+
+We state plainly that \textsc{FaaS-MABR} instantiates a classical
+distributed-optimization pattern and is not claimed as novel. The sequential,
+in-place-update sweep is the \emph{Gauss-Seidel} relaxation, and the simultaneous
+snapshot of \textsc{FaaS-MADiG}/\textsc{FaaS-MAPoD} is its \emph{Jacobi}
+counterpart; both are textbook iterative schemes for distributed fixed-point
+computation~\citep{bertsekastsitsiklis1989}. \textsc{FaaS-MABR-S}/\textsc{-R} are
+sequential greedy responses (better-response, not exact best-response) dynamics,
+while \textsc{FaaS-MABR-O} computes a per-node capped best response. The
+underlying push of excess load to less-loaded neighbours remains the diffusion
+paradigm of Cybenko~\citep{cybenko1989}, and the relation to the auction is the
+familiar one between Gauss-Seidel relaxation and Bertsekas-style coordinate
+methods~\citep{bertsekas1988}. The value of the family is therefore the
+\emph{sequential-vs-simultaneous} contrast with \textsc{FaaS-MADiG} and the
+re-optimization ablation of \textsc{FaaS-MABR-O}, not a new heuristic.
diff --git a/faas-bestresponse-note/main.tex b/faas-bestresponse-note/main.tex
new file mode 100644
index 0000000..edc14a3
--- /dev/null
+++ b/faas-bestresponse-note/main.tex
@@ -0,0 +1,15 @@
+% Standalone preview wrapper for the FaaS-MABR note.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\begin{document}
+\input{faas-mabr}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-bestresponse-note/references.bib b/faas-bestresponse-note/references.bib
new file mode 100644
index 0000000..e156e36
--- /dev/null
+++ b/faas-bestresponse-note/references.bib
@@ -0,0 +1,32 @@
+% References for the FaaS-MABR positioning subsection (shared, verified set
+% plus the Gauss-Seidel anchor).
+
+@book{bertsekastsitsiklis1989,
+  author    = {Dimitri P. Bertsekas and John N. Tsitsiklis},
+  title     = {Parallel and Distributed Computation: Numerical Methods},
+  publisher = {Prentice-Hall},
+  year      = {1989},
+  address   = {Englewood Cliffs, NJ}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@article{cybenko1989,
+  author  = {George Cybenko},
+  title   = {Dynamic load balancing for distributed memory multiprocessors},
+  journal = {Journal of Parallel and Distributed Computing},
+  volume  = {7},
+  number  = {2},
+  pages   = {279--301},
+  year    = {1989},
+  doi     = {10.1016/0743-7315(89)90021-X}
+}
diff --git a/faas-madig-note/.gitignore b/faas-madig-note/.gitignore
new file mode 100644
index 0000000..ab6921a
--- /dev/null
+++ b/faas-madig-note/.gitignore
@@ -0,0 +1,10 @@
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+*.synctex.gz
+*.toc
+*.bbl
+*.blg
+main.pdf
diff --git a/faas-madig-note/README.md b/faas-madig-note/README.md
new file mode 100644
index 0000000..2b239f9
--- /dev/null
+++ b/faas-madig-note/README.md
@@ -0,0 +1,44 @@
+# FaaS-MADiG technical note
+
+A focused, paper-ready LaTeX section describing **FaaS-MADiG** — the price-free
+greedy-diffusion ablation of the **FaaS-MADeA** decentralized auction — in the
+notation and style of `Decentralized_FaaS_coordination.pdf`.
+
+## Files
+
+- `faas-madig.tex` — **the deliverable**: a `\section` to be inserted into the
+  paper. Concentrated on the algorithm and its rationale (no abstract/intro).
+  It is **self-contained**: the `Notation and capacity model` subsection
+  reproduces the relevant rows of the paper's Tables 2–3 and Eqs. (1),(2),(12),
+  (13), so the note can be read without the original paper. That subsection is
+  fenced by `BEGIN/END self-contained notation recap` comments — **delete it
+  when inserting into the paper**, where the notation is already defined.
+- `references.bib` — bibliography for the *Positioning with respect to the
+  literature* subsection (diffusion LB, greedy edge/FaaS offloading, auction
+  baseline). Merge these entries into the paper's `.bib` (or re-key the
+  `\citep{}` commands) when inserting.
+- `main.tex` — a minimal standalone wrapper used only to compile a preview PDF.
+- `.gitignore` — ignores LaTeX build artifacts.
+
+## Compile the preview
+
+```bash
+cd faas-madig-note
+latexmk -pdf main.tex      # produces main.pdf
+latexmk -c                 # clean aux files (keep main.pdf)
+```
+
+## Insert into the paper
+
+1. Copy `faas-madig.tex` next to the paper sources and add `\input{faas-madig}`
+   at the desired position (after the FaaS-MADeA solution-approach section), or
+   paste its body directly.
+2. Replace the plain-text cross-references (`Eq.~(7)`, `Eq.~(12)`, `Eq.~(13)`,
+   `Alg.~2`, `Alg.~3`, `Alg.~4`, `(P2)`) with `\ref{}`/`\eqref{}` to the host
+   paper's labels.
+3. Align the latency/fairness symbols of Eq.~`\eqref{eq:madig-score}`
+   (`\ell_{ij}`, `\Phi_i^f`, `w_lat`, `w_fair`) with whatever the paper uses in
+   its Eq.~(7); the note derives the score as "Eq.~(7) without the `-p_j^f`
+   term", so only the symbol names need matching.
+4. Required packages (already in the paper for the auction algorithms):
+   `amsmath`, `amssymb`, `algorithm`, `algpseudocode`.
diff --git a/faas-madig-note/cited_papers/AUDIT.md b/faas-madig-note/cited_papers/AUDIT.md
new file mode 100644
index 0000000..07e91fc
--- /dev/null
+++ b/faas-madig-note/cited_papers/AUDIT.md
@@ -0,0 +1,70 @@
+# Literature-Comparison Audit — `\subsection{Positioning with respect to the literature}`
+
+Audited file: `faas-madig-note/faas-madig.tex` (subsection `sec:madig-related`).
+Ground-truth algorithm: `decentralized_diffusion.py` (`define_assignments`, `evaluate_assignments`).
+Evidence: downloaded PDFs (`bertsekas1988`, `mitzenmacher2001`, `jiang2018`, `nezami2021`) read directly via `mutool`; paywalled works (`cybenko1989`, `willebeek1993`, `leechoi2021`) assessed from abstracts + verification reports.
+Date: 2026-06-26.
+
+## Verdict table
+
+| Citation | Note's claim (short) | Verdict | Evidence | Recommended fix |
+|---|---|---|---|---|
+| `cybenko1989` | "Diffusion paradigm: an overloaded node sends excess load to its less-loaded neighbours." | **Correct** | Cybenko studies diffusion schemes for dynamic load balancing on message-passing networks; nodes iteratively redistribute excess load to less-loaded neighbours (abstract; verification-classics §1). Accurate, textbook characterization. | None. (Optional: Cybenko's diffusion is *iterative to equilibrium*, not single-round; the note attributes "single-round" to Willebeek, not Cybenko, so no conflict.) |
+| `willebeek1993` | "Sender-initiated, single-round diffusion is one of the dynamic strategies catalogued." | **Correct** (minor wording) | Paper compares five DLB strategies including **sender-initiated diffusion (SID)** and receiver-initiated diffusion (RID) (abstract; verification-classics §2). The "catalogues sender-initiated diffusion" claim is solid. | "single-round" is imprecise: SID is an iterative near-neighbour scheme, not single-round. Either drop "single-round" or attribute the single-round simplification to FaaS-MADiG itself ("the sender-initiated form we use, run as a single coordination round, is a simplification of the SID strategy catalogued by..."). |
+| `nezami2021` | Underlies "serve locally first, then greedily offload residual to one-hop neighbours" / decentralized service placement & LB for IoT. | **Overstated / partly misattributed** | EPOS Fog's core mechanism is **I-EPOS collective learning** (agents generate candidate *plans*, then cooperatively/iteratively select one maximizing edge utilization) — not greedy residual offloading. The greedy step is only intra-plan generation, and it "**randomly chooses** the required number of available neighbouring nodes as candidate hosts" (nezami.txt L1283–1287), i.e. it does *not* scan the full one-hop set. It is decentralized edge-to-cloud LB for IoT (true), but the "greedy one-hop residual offload" control structure is not its mechanism. | Soften: cite as an example of *decentralized multi-agent edge LB* (true) but do not imply its mechanism is greedy one-hop residual offloading. Move out of the "serve-locally-then-greedily-offload" list, or qualify "uses a greedy candidate-host heuristic within a collective-learning framework." Note also it contradicts the later "full-neighbourhood deterministic scan" contrast (Nezami samples randomly). |
+| `jiang2018` | Underlies "serve locally first, then greedily offload residual to one-hop neighbours" / greedy energy–delay–cost offloading in imbalanced edge–cloud. | **Wrong / misattributed** | System model is **mobile users (MUs) offloading tasks to *shared* edge-cloud servers (ECSs) through wireless access points (APs)** (jiang.txt L398–414); "all these computing-intensive tasks **must be offloaded**" (L412). It is a user→AP→ECS bipartite assignment solved by centralized greedy (CGA/MGA), a many-to-one **matching game** (ADMA), and a fairness greedy (FGA). There is **no** local-execution-first step and **no** peer-to-peer one-hop neighbour diffusion. | Remove `jiang2018` from the "serve-locally-first / one-hop neighbour offloading" claim. If kept at all, cite narrowly as "greedy heuristics for energy–delay–cost task offloading," without implying one-hop peer diffusion or serve-local-first. |
+| `leechoi2021` | "Greedy load balancing tailored to FaaS platforms." | **Correct** | GRAF is a greedy LB algorithm specifically for FaaS, maximizing locality/cache-hit ratio while preserving load balance (verification-modern §3). The note's loose phrasing "greedy load balancing tailored to FaaS platforms" is accurate. | None required. (Caveat for honesty: it is a *dispatcher-level, cache-locality* greedy scheduler, not one-hop peer offloading; the note's wording is general enough to remain correct, but do not lean on it as evidence of the one-hop-diffusion structure.) |
+| `bertsekas1988` | "Fixing all prices to zero in a Bertsekas-style auction reduces the bidding-and-clearing mechanism to a greedy (deferred-acceptance) assignment." | **Overstated** | See dedicated section below. The reduction is *directionally* defensible (greedy is a degenerate/single-round special case) but the phrasing conflates "prices = 0", "ε = 0", and "single round," and "deferred-acceptance" is the wrong term. | Reword — see below. |
+| `mitzenmacher2001` | "Power-of-d-choices probes a random sample of d candidates," contrasted with FaaS-MADiG's deterministic full one-hop scan. | **Correct** | Supermarket model: each arrival samples d ≥ 2 servers **uniformly at random** and joins the shortest queue (abstract; verification-classics §3). "Probes a random sample of d candidates" is exact, and the determinism/full-set contrast with FaaS-MADiG is fair. | None. |
+
+## Bertsekas "auction → greedy" reduction — detailed audit
+
+**Note's sentence:** "fixing all prices to zero in a Bertsekas-style auction reduces the bidding-and-clearing mechanism to a greedy (deferred-acceptance) assignment."
+
+**What Bertsekas's auction actually does (paper §2, eqs. 5–8):**
+- Each unassigned person `i` computes object values `v_ij = a_ij − p_j` (eq. 5), picks best `j* = argmax_j (a_ij − p_j)`, and **bids** `b_ij* = p_j* + v_ij* − w_ij* + ε` where `w_ij*` is the second-best value (eq. 7).
+- Each object goes to the highest bidder and **raises its price** (eq. 8).
+- The algorithm is **iterative**: it runs multiple bidding/assignment rounds, **prices rise monotonically**, and **objects are re-awarded** across rounds (a person can lose an object it briefly held).
+- The whole construction is driven by **ε-complementary slackness (ε-CS)** (eq. 4), and the theory needs **ε > 0** strictly; with ε = 0 the bid increment vanishes and the convergence/termination argument no longer applies.
+
+**Why the note's phrasing is imprecise / overstated:**
+1. **It is not "prices = 0" that yields greedy; it is "no price *update*" + a single round.** Setting `p_j ≡ 0` only makes the score equal `a_ij` (the raw utility). The auction would still iterate and re-award objects — that is *not* greedy. What actually reduces the mechanism to greedy is **freezing prices (no eq.-8 update) and disallowing re-assignment of already-served load**, i.e. running essentially one pass with each buyer grabbing its best available residual capacity. The code confirms this: `evaluate_assignments` has "no min_b tracking, no price update, no last_y replacement swap" — it is the *removal of the price-update/reassignment*, not zeroing a price level, that produces the greedy rule.
+2. **"deferred-acceptance" is the wrong term.** Deferred acceptance (Gale–Shapley) is precisely characterized by *tentative* holds that can be *bumped* by later, more-preferred proposers — i.e. re-assignment. FaaS-MADiG explicitly **removes** reassignment ("no reassignment of previously served load," Alg. seller line 17; code: no `last_y` swap). So the resulting rule is **immediate-acceptance / first-come greedy**, the *opposite* of deferred acceptance. (Ironically, the *full* auction, with its price-driven re-awarding, is the more DA-like object.)
+3. **ε is silently dropped.** "Fixing all prices to zero" ignores that the auction is parameterized by ε > 0 (the minimum bid increment / ε-CS slack). A faithful statement should mention that *both* the price feedback *and* the ε bidding increment are removed.
+
+**Verdict:** Overstated. The underlying intuition — *greedy assignment is the degenerate, price-frozen, single-round special case of the auction* — is sound and is even stated in the verification report ("Setting all prices to zero and running a single bidding round reduces the auction to a greedy assignment"). But the published sentence (a) mislocates the reduction in "prices = 0," (b) uses "deferred-acceptance," which is technically false for a rule that forbids reassignment, and (c) omits the single-round / no-price-update condition that actually does the work.
+
+**Recommended phrasing:**
+
+> "FaaS-MADiG is the price-frozen special case of a Bertsekas-style auction~\citep{bertsekas1988}: when the cross-iteration price update (and the associated $\varepsilon$ bid increment and $\varepsilon$-complementary-slackness mechanism) is removed, the bidding-and-clearing cycle collapses to a single-pass greedy assignment in which each buyer claims its best available residual capacity and no previously served load is re-awarded. In this sense FaaS-MADiG *is* FaaS-MADeA with the market layer removed."
+
+(If a matching-theory label is wanted, the correct one is **immediate-acceptance / serial-dictatorship-style greedy**, *not* deferred acceptance — so it is safer to drop the parenthetical term entirely.)
+
+## FaaS-MADiG self-description vs `decentralized_diffusion.py`
+
+The note's "Differences" and algorithm prose were checked line-by-line against the code. All three differentiators are **supported**:
+
+| Note's claim | Code evidence | Status |
+|---|---|---|
+| (i) Determinism over the **full** one-hop neighbourhood; deterministic tie-break on buyer index. | `define_assignments` builds `candidate_sellers` from **all** capacity-bearing neighbours (`potential_capacity_sellers`, L65–82), sorts by descending `utility` via `np.argsort(...)[::-1]` (L86). `evaluate_assignments` sorts bids `by=["utility","i"], ascending=[False,True]` (L155–157) — deterministic buyer-index tie-break. No random sampling anywhere. | **Supported.** Genuinely contrasts with Mitzenmacher's random-d and with Nezami's *random* candidate selection. |
+| (ii) Joint balancing + provisioning via memory-slack replica expansion (not on a fixed graph). | Buyer emits `memory_bids` to neighbours with `rho>0` (L111–122); seller's `tentatively_start_replicas` branch starts replicas gated by the **utilization test** `u <= max_utilization` with **no price** (L166–186); `start_additional_replicas` invoked in `run` (L344). | **Supported.** Matches "price-free replica expansion (Alg. 4)" and "coupling LB with provisioning." |
+| (iii) Objective-aligned score (β, γ, latency, fairness), re-validated by P2 / restricted re-solve. | Score `ut = beta − latency_weight·latency − fairness_weight·fairness`, thresholded by `> −gamma` (L75–80) — exactly Eq. (score) and Eq. (threshold). Each round re-solves the restricted problem via `compute_social_welfare` (`run`, L331–336) and recomputes `omega` (L337–341). | **Supported.** Score matches the note's Eq.~\eqref{eq:madig-score} *including the sign* of the price term (the note's `s = u + p` with `p` removed equals `beta − w_lat·L − w_fair·φ`). |
+
+Additional consistency checks on the "Removed/Kept" lists and Algorithms 2–3:
+- **No price update / no bid-price tracking / no reassignment** — confirmed: `evaluate_assignments` docstring and body have "no min_b tracking, no price update, no last_y replacement swap." **Correct.**
+- **Buyer greedy fill until `omega` met or neighbourhood saturated** — `while idx < ... and assigned < omega[i,f]` (L88). **Correct.**
+- **`unit_bids` option** ("unit bids if enabled") — present (L90–101). **Correct.**
+- **Seller fills to residual capacity in descending-(utility, i) order** — L155–164. **Correct.**
+- One **wording nuance** (not in the Positioning subsection, but flagged for accuracy): the seller-side replica branch in code requires `remaining_capacity == 0` **and** existing bids, then iterates `a` upward until the utilization test passes (L166–186); the note's prose ("tentatively starts replicas ... gated by `κ ≤ 1`") is faithful.
+
+No claim in the self-description is contradicted by the code.
+
+## Final verdict
+
+The comparison is **mostly sound but not publishable as written**. Two sentences need editing and one needs softening:
+
+1. **Bertsekas sentence (lines 248–252)** — *must* be reworded. Drop "fixing all prices to zero" as the trigger (it is the price-*update*/reassignment removal plus single-round, not the price *level*), and **remove "deferred-acceptance"** (technically false for a no-reassignment rule). Use the recommended phrasing above.
+2. **`jiang2018` (line 246)** — *must* be removed from, or detached from, the "serve locally first, then greedily offload residual to one-hop neighbours" claim: its model is users→shared-ECS offloading, not peer one-hop diffusion. Misattribution.
+3. **`nezami2021` (line 245)** — *should* be softened: its mechanism is I-EPOS collective learning with *randomly* sampled candidate hosts, so it neither exemplifies greedy one-hop residual offloading nor the deterministic full-neighbourhood scan FaaS-MADiG claims to differ by.
+
+Correct as written: **Cybenko, Mitzenmacher, Lee & Choi** (and **Willebeek-LeMair & Reeves** modulo dropping "single-round"). The FaaS-MADiG self-description faithfully matches `decentralized_diffusion.py`.
diff --git a/faas-madig-note/cited_papers/bertsekas1988.pdf b/faas-madig-note/cited_papers/bertsekas1988.pdf
new file mode 100644
index 0000000..651fa36
Binary files /dev/null and b/faas-madig-note/cited_papers/bertsekas1988.pdf differ
diff --git a/faas-madig-note/cited_papers/jiang2018.pdf b/faas-madig-note/cited_papers/jiang2018.pdf
new file mode 100644
index 0000000..a6e89f5
Binary files /dev/null and b/faas-madig-note/cited_papers/jiang2018.pdf differ
diff --git a/faas-madig-note/cited_papers/mitzenmacher2001.pdf b/faas-madig-note/cited_papers/mitzenmacher2001.pdf
new file mode 100644
index 0000000..cc1b42b
Binary files /dev/null and b/faas-madig-note/cited_papers/mitzenmacher2001.pdf differ
diff --git a/faas-madig-note/cited_papers/nezami2021.pdf b/faas-madig-note/cited_papers/nezami2021.pdf
new file mode 100644
index 0000000..c3eebe0
Binary files /dev/null and b/faas-madig-note/cited_papers/nezami2021.pdf differ
diff --git a/faas-madig-note/cited_papers/verification-classics.md b/faas-madig-note/cited_papers/verification-classics.md
new file mode 100644
index 0000000..40c4deb
--- /dev/null
+++ b/faas-madig-note/cited_papers/verification-classics.md
@@ -0,0 +1,149 @@
+# Verification Report -- Classic References
+
+Generated: 2026-06-26
+
+---
+
+## 1. `cybenko1989` -- Cybenko, "Dynamic load balancing for distributed memory multiprocessors"
+
+### Existence
+
+**Yes.** Confirmed via CrossRef (DOI resolves) and Semantic Scholar.
+
+### Metadata verification
+
+| Field | BibTeX value | Authoritative value (CrossRef) | Status |
+|-------|-------------|-------------------------------|--------|
+| Author | George Cybenko | George Cybenko | OK |
+| Title | Dynamic load balancing for distributed memory multiprocessors | Dynamic load balancing for distributed memory multiprocessors | OK |
+| Journal | Journal of Parallel and Distributed Computing | Journal of Parallel and Distributed Computing | OK |
+| Volume | 7 | 7 | OK |
+| Number | 2 | 2 | OK |
+| Pages | 279--301 | 279-301 | OK |
+| Year | 1989 | 1989 (published October 1989) | OK |
+| DOI | 10.1016/0743-7315(89)90021-X | 10.1016/0743-7315(89)90021-x | OK |
+
+All fields match.
+
+### Download status
+
+**Paywalled.** Semantic Scholar listed an open-access PDF at `http://www.dartmouth.edu/~gvc/Cybenko_JPDP.pdf` (GREEN status), but the URL returns HTTP 404 as of 2026-06-26. No alternative open-access copy was found. The canonical publisher URL is:
+
+- DOI: <https://doi.org/10.1016/0743-7315(89)90021-X>
+- ScienceDirect: <https://www.sciencedirect.com/science/article/abs/pii/074373158990021X>
+
+### Core claim
+
+Cybenko studies diffusion schemes for dynamic load balancing on message-passing multiprocessor networks, proving convergence conditions and convergence rates for arbitrary topologies via the eigenstructure of the iteration matrices; he also proposes and analyzes a "dimension exchange" method for hypercube networks and shows it is superior to the diffusion approach. Yes, the paper is about diffusion-based load balancing where overloaded nodes iteratively redistribute excess load to less-loaded neighbours.
+
+Source: abstract reproduced in multiple citing works and confirmed via web search; DOI <https://doi.org/10.1016/0743-7315(89)90021-X>.
+
+---
+
+## 2. `willebeek1993` -- Willebeek-LeMair & Reeves, "Strategies for dynamic load balancing on highly parallel computers"
+
+### Existence
+
+**Yes.** Confirmed via CrossRef (DOI resolves) and Semantic Scholar.
+
+### Metadata verification
+
+| Field | BibTeX value | Authoritative value (CrossRef) | Status |
+|-------|-------------|-------------------------------|--------|
+| Author | Marc H. Willebeek-LeMair and Anthony P. Reeves | M.H. Willebeek-LeMair and A.P. Reeves | OK |
+| Title | Strategies for dynamic load balancing on highly parallel computers | Strategies for dynamic load balancing on highly parallel computers | OK |
+| Journal | IEEE Transactions on Parallel and Distributed Systems | IEEE Transactions on Parallel and Distributed Systems | OK |
+| Volume | 4 | 4 | OK |
+| Number | 9 | 9 | OK |
+| Pages | 979--993 | 979-993 | OK |
+| Year | 1993 | 1993 | OK |
+| DOI | 10.1109/71.243526 | 10.1109/71.243526 | OK |
+
+All fields match.
+
+### Download status
+
+**Paywalled.** Semantic Scholar reports CLOSED access. No open-access author copy, institutional repository version, or preprint was found. The canonical publisher URL is:
+
+- DOI: <https://doi.org/10.1109/71.243526>
+- IEEE Xplore: <https://ieeexplore.ieee.org/document/243526/>
+
+### Core claim
+
+The paper presents and experimentally compares five dynamic load balancing (DLB) strategies on a hypercube multicomputer (Intel iPSC/2): sender-initiated diffusion (SID), receiver-initiated diffusion (RID), hierarchical balancing method (HBM), gradient model (GM), and dimension exchange method (DEM). These strategies illustrate the tradeoff between knowledge (accuracy of each balancing decision) and overhead (communication/processing cost). Yes, it catalogs sender-initiated and receiver-initiated diffusion strategies among others.
+
+Source: abstract and descriptions confirmed across multiple citing works; DOI <https://doi.org/10.1109/71.243526>.
+
+---
+
+## 3. `mitzenmacher2001` -- Mitzenmacher, "The power of two choices in randomized load balancing"
+
+### Existence
+
+**Yes.** Confirmed via CrossRef (DOI resolves) and Semantic Scholar.
+
+### Metadata verification
+
+| Field | BibTeX value | Authoritative value (CrossRef) | Status |
+|-------|-------------|-------------------------------|--------|
+| Author | Michael Mitzenmacher | M. Mitzenmacher | OK |
+| Title | The power of two choices in randomized load balancing | The power of two choices in randomized load balancing | OK |
+| Journal | IEEE Transactions on Parallel and Distributed Systems | IEEE Transactions on Parallel and Distributed Systems | OK |
+| Volume | 12 | 12 | OK |
+| Number | 10 | 10 | OK |
+| Pages | 1094--1104 | 1094-1104 | OK |
+| Year | 2001 | 2001 | OK |
+| DOI | 10.1109/71.963420 | 10.1109/71.963420 | OK |
+
+All fields match.
+
+### Download status
+
+**Downloaded.** Author copy from Harvard EECS.
+
+- Local path: `faas-madig-note/cited_papers/mitzenmacher2001.pdf`
+- Source URL: <https://www.eecs.harvard.edu/~michaelm/postscripts/tpds2001.pdf>
+- Verified: PDF document, version 1.3, 11 pages, 242 KB
+
+### Core claim
+
+Mitzenmacher analyzes the "supermarket model" where each arriving customer samples d >= 2 servers uniformly at random and joins the shortest queue. He proves that having d = 2 choices yields an exponential improvement in expected customer time over d = 1 (random placement), while d = 3 is only a constant factor better than d = 2. Yes, this is the randomized power-of-d-choices result.
+
+Source: author copy abstract; <https://www.eecs.harvard.edu/~michaelm/postscripts/tpds2001.pdf>.
+
+---
+
+## 4. `bertsekas1988` -- Bertsekas, "The auction algorithm: A distributed relaxation method for the assignment problem"
+
+### Existence
+
+**Yes.** Confirmed via CrossRef (DOI resolves) and Semantic Scholar.
+
+### Metadata verification
+
+| Field | BibTeX value | Authoritative value (CrossRef) | Status |
+|-------|-------------|-------------------------------|--------|
+| Author | Dimitri P. Bertsekas | D. P. Bertsekas | OK |
+| Title | The auction algorithm: A distributed relaxation method for the assignment problem | The auction algorithm: A distributed relaxation method for the assignment problem | OK |
+| Journal | Annals of Operations Research | Annals of Operations Research | OK |
+| Volume | 14 | 14 | OK |
+| Number | 1 | 1 | OK |
+| Pages | 105--123 | 105-123 | OK |
+| Year | 1988 | 1988 (published December 1988) | OK |
+| DOI | 10.1007/BF02186476 | 10.1007/bf02186476 | OK |
+
+All fields match.
+
+### Download status
+
+**Downloaded.** Author copy from Bertsekas's MIT page.
+
+- Local path: `faas-madig-note/cited_papers/bertsekas1988.pdf`
+- Source URL: <https://www.mit.edu/~dimitrib/TheAuctionAP.pdf>
+- Verified: PDF document, version 1.2, 3.3 MB
+
+### Core claim
+
+Bertsekas proposes a massively parallelizable auction algorithm for the classical assignment problem: unassigned "persons" bid simultaneously for "objects," raising object prices; objects are then awarded to the highest bidder. The algorithm can also be interpreted as a Jacobi-like relaxation method for solving a dual problem. Setting all prices to zero and running a single bidding round reduces the auction to a greedy assignment (each person grabs its best available object), so greedy assignment is a degenerate special case of the auction mechanism.
+
+Source: abstract and description confirmed via ASU/Springer listing and MIT-hosted PDF; DOI <https://doi.org/10.1007/BF02186476>.
diff --git a/faas-madig-note/cited_papers/verification-modern.md b/faas-madig-note/cited_papers/verification-modern.md
new file mode 100644
index 0000000..e03dcf0
--- /dev/null
+++ b/faas-madig-note/cited_papers/verification-modern.md
@@ -0,0 +1,94 @@
+# Verification Report: Modern Cited Works
+
+Generated: 2026-06-26
+
+---
+
+## 1. `nezami2021` — Nezami et al., IEEE Access 2021
+
+### Existence
+**Confirmed.** Published in IEEE Access, indexed on IEEE Xplore as document 9418552. arXiv preprint 2005.00270 is the same paper (same authors, title, content).
+
+### Metadata Verification
+
+| Field | BibTeX value | Authoritative source | Status |
+|-------|-------------|---------------------|--------|
+| author | Zeinab Nezami, Kamran Zamanifar, Karim Djemame, Evangelos Pournaras | IEEE Xplore / arXiv | OK |
+| title | Decentralized Edge-to-Cloud Load Balancing: Service Placement for the Internet of Things | IEEE Xplore: identical; arXiv uses "Load-balancing" (hyphenated) | OK (matches IEEE published version) |
+| journal | IEEE Access | IEEE Xplore | OK |
+| volume | 9 | IEEE Xplore | OK |
+| year | 2021 | IEEE Xplore | OK |
+| pages | (omitted) | 64983--65000 per IEEE Xplore | OK (acceptable omission, noted in task) |
+| doi | 10.1109/ACCESS.2021.3074962 | IEEE Xplore | OK |
+
+### Download Status
+**Downloaded.** Local path: `faas-madig-note/cited_papers/nezami2021.pdf`
+Source: arXiv (https://arxiv.org/pdf/2005.00270). Verified: PDF document, 4.5 MB.
+
+### Core Claim
+The paper proposes EPOS Fog, a decentralized multi-agent system for IoT service placement across the edge-to-cloud continuum. Agents locally generate possible assignments of requests to resources and then cooperatively select an assignment that maximizes edge utilization while minimizing service execution cost — this is collective learning-based optimization, not greedy/diffusion-style one-hop neighbour offloading. The approach reduces service execution delay up to 25% and improves load-balance up to 90% vs. First Fit and cloud-only baselines.
+
+Source: https://arxiv.org/abs/2005.00270
+
+---
+
+## 2. `jiang2018` — Jiang et al., arXiv 2018
+
+### Existence
+**Confirmed.** Available on arXiv as preprint 1805.02006 (submitted 2018-05-05). Not published in a peer-reviewed journal as of this check.
+
+### Metadata Verification
+
+| Field | BibTeX value | Authoritative source | Status |
+|-------|-------------|---------------------|--------|
+| author | Weiheng Jiang, Yi Gong, Yang Cao, Xiaogang Wu, Qian Xiao | arXiv | OK |
+| title | Energy-delay-cost Tradeoff for Task Offloading in Imbalanced Edge Cloud Based Computing | arXiv | OK |
+| journal | arXiv preprint arXiv:1805.02006 | arXiv | OK |
+| year | 2018 | arXiv | OK |
+
+### Download Status
+**Downloaded.** Local path: `faas-madig-note/cited_papers/jiang2018.pdf`
+Source: arXiv (https://arxiv.org/pdf/1805.02006). Verified: PDF document, 537 KB, 36 pages.
+
+### Core Claim
+The paper addresses task offloading in an edge cloud architecture where mobile users offload tasks to shared edge cloud servers (ECS) through wireless access points. It introduces an "ECS access-cost" metric incorporating transmission delay, energy consumption, and resource usage costs, then solves NP-hard optimization problems (minimizing aggregate cost for efficiency, or minimizing maximum individual cost for fairness) via centralized and distributed heuristic algorithms. This is a centralized/hierarchical offloading model (users to shared ECS), not a peer-to-peer diffusion/gossip-style one-hop neighbour offloading scheme.
+
+Source: https://arxiv.org/abs/1805.02006
+
+---
+
+## 3. `leechoi2021` — Lee & Choi, ICCBDC 2021
+
+### Existence
+**Confirmed.** Published in Proceedings of the 2021 5th International Conference on Cloud and Big Data Computing (ICCBDC), indexed in ACM Digital Library with DOI 10.1145/3481646.3481657. Also indexed on dblp.
+
+### Metadata Verification
+
+| Field | BibTeX value | Authoritative source | Status |
+|-------|-------------|---------------------|--------|
+| author | Youngsoo Lee, Sunghee Choi | ACM DL / dblp | OK |
+| title | A Greedy Load Balancing Algorithm for {FaaS} Platforms | ACM DL: "A Greedy Load Balancing Algorithm for FaaS Platforms" | OK |
+| booktitle | Proc.\ 2021 5th International Conference on Cloud and Big Data Computing (ICCBDC) | ACM DL: "Proceedings of the 2021 5th International Conference on Cloud and Big Data Computing" | OK (abbreviated form acceptable) |
+| year | 2021 | ACM DL / dblp | OK |
+| pages | (omitted) | 63--69 per dblp | MISMATCH — pages not present in BibTeX (consider adding `pages = {63--69}`) |
+| doi | 10.1145/3481646.3481657 | ACM DL | OK |
+
+### Download Status
+**Paywalled.** The ACM Digital Library requires a subscription. The author's preprint was hosted at `https://get.prev.kr/papers/preprint/faas_lb.pdf` but the domain does not currently resolve (DNS failure). No other open-access copy was found.
+
+DOI URL: https://doi.org/10.1145/3481646.3481657
+
+### Core Claim
+The paper proposes GRAF (GReedy Algorithm for FaaS platforms), a load balancing algorithm specifically designed for FaaS platforms that maximizes locality (cache-hit ratio) while preserving load balance. The algorithm uses a tabular data structure to greedily route function invocations to workers that already have warm containers/cached state, reducing cold starts. This is indeed a greedy, locality/cache-driven LB specifically for FaaS — it is not diffusion-style one-hop neighbour offloading but rather a dispatcher-level scheduling algorithm that optimizes for container reuse.
+
+Source: https://dl.acm.org/doi/10.1145/3481646.3481657 (search result summary), https://prev.github.io/about/
+
+---
+
+## Summary
+
+| Paper | Exists | Metadata | Download |
+|-------|--------|----------|----------|
+| `nezami2021` | Yes | All fields OK (pages omitted, acceptable) | Downloaded (`nezami2021.pdf`, 4.5 MB) |
+| `jiang2018` | Yes | All fields OK | Downloaded (`jiang2018.pdf`, 537 KB) |
+| `leechoi2021` | Yes | Pages missing (should be 63--69) | Paywalled; preprint host unreachable |
diff --git a/faas-madig-note/faas-madig.tex b/faas-madig-note/faas-madig.tex
new file mode 100644
index 0000000..9d0e7a7
--- /dev/null
+++ b/faas-madig-note/faas-madig.tex
@@ -0,0 +1,324 @@
+% =====================================================================
+% FaaS-MADiG: price-free greedy-diffusion variant of FaaS-MADeA.
+% This file is meant to be \input{} (or pasted) into the paper.
+% It assumes the paper's notation (N, F, C_i^f, rho_i, omega_i^f,
+% beta_{ij}^f, gamma_i^f, p_i^f, ...) is already defined.
+% Cross-references are written as plain text "Eq.~(7)", "Alg.~4", etc.;
+% convert them to \ref{} once the labels of the host paper are known.
+% =====================================================================
+
+\section{FaaS-MADiG: a price-free greedy-diffusion variant}
+\label{sec:madig}
+
+\textsc{FaaS-MADiG} (Multi-Agent Distributed Greedy) is a \emph{price-free}
+ablation of the \textsc{FaaS-MADeA} auction. It leaves the decentralized
+per-iteration loop unchanged: at each control period $t$ every node $i$ still
+solves its local problem~(P2) to fix the replicas $r_i^f$, the locally executed
+load $x_i^f$, and the residual demand $\omega_i^f(h)$ to offload; it still
+advertises on the neighbour-accessible blackboard its residual execution
+capacity $C_i^f(h)=\max\{0,\mathrm{Cap}_i^f(h)-x_i^f(h)\}$~(Eq.~(12)) and its
+memory slack $\rho_i(h)$~(Eq.~(13)); and it still re-solves the restricted
+problem after coordination. \textsc{FaaS-MADiG} replaces \emph{only} the market
+layer---bidding, pricing, and the price update of Eqs.~(7)--(8) and
+Algorithms~2--3---with a deterministic greedy diffusion that consumes the same
+one-hop residual-capacity announcements. Its purpose is to isolate the
+contribution of the price signal: \emph{does congestion pricing improve the
+allocation over a plain greedy rule that uses exactly the same local
+information?}
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% Reproduces the relevant rows of the paper's Table 2 (FRALB) and Table 3
+% (auction) plus Eqs. (1),(2),(12),(13), so the note is readable on its own.
+% REMOVE this whole subsection when inserting into the paper, where the
+% notation and these equations are already defined.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:madig-notation}
+
+Each control period $t$ runs auction iterations $h=0,1,\dots,H_{\max}$ in
+parallel. Before coordination, every node $i$ solves a local problem~(P2)
+that, for each function $f\in\mathcal{F}_i$, splits the incoming workload
+$\lambda_i^f$ into locally processed load $x_i^f$, horizontally offloaded
+demand $\omega_i^f$, and Cloud-forwarded load $z_i^f$, and fixes the number of
+replicas $r_i^f$. Replicas obey the memory budget and provide capacity
+\begin{equation}
+  \sum_{f\in\mathcal{F}_i} r_i^f\,\mathrm{RAM}^f \le \mathrm{RAM}_i,
+  \qquad
+  \mathrm{Cap}_i^f = \frac{r_i^f\,U^f_{\max}}{D_i^f}\ \text{[req/s]} ,
+  \tag{1,2}
+\end{equation}
+from which each node advertises, on a neighbour-accessible blackboard, its
+residual execution capacity and its memory slack:
+\begin{equation}
+  C_i^f(h) = \max\!\big\{0,\ \mathrm{Cap}_i^f(h) - x_i^f(h)\big\},
+  \qquad
+  \rho_i(h) = \mathrm{RAM}_i - \sum_{f\in\mathcal{F}_i} r_i^f(h)\,\mathrm{RAM}^f \ge 0 .
+  \tag{12,13}
+\end{equation}
+Table~\ref{tab:madig-notation} collects the symbols used below.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in this section (subset of the paper's Tables~2--3).}
+\label{tab:madig-notation}
+\small
+\begin{tabular}{@{}l l p{0.62\linewidth}@{}}
+\toprule
+\multicolumn{3}{@{}l}{\textit{Sets}}\\
+Nodes / neighbours & $\mathcal{N}$, $N_i$ & computing nodes; one-hop neighbours of $i$.\\
+Functions & $\mathcal{F}_i$ & functions deployable on $i$; $\mathcal{F}=\bigcup_i \mathcal{F}_i$.\\
+Candidate sellers & $A_i^f(h)$ & neighbours of $i$ with positive score for $f$, $A_i^f(h)\subseteq N_i$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Parameters and weights}}\\
+Input workload & $\lambda_i^f$ & incoming request rate for $f$ at $i$ [req/s].\\
+Memory cap / demand & $\mathrm{RAM}_i$, $\mathrm{RAM}^f$ & node memory; per-replica memory of $f$ [MB].\\
+Service demand & $D_i^f$ & average execution time of $f$ at $i$ [s].\\
+Max utilization & $U^f_{\max}$ & stability threshold, $U^f_{\max}\in[0,1)$.\\
+Local / offload / Cloud profit & $\alpha_i^f$, $\beta_{ij}^f$, $\gamma_i^f$ & profit of local exec.; profit of offloading $i\!\to\! j$; Cloud-offloading penalty (per req/s).\\
+Communication latency & $L_{ij}$ & horizontal-offloading latency between $i$ and $j$.\\
+Weights & $w_{\mathrm{lat}}$, $w_{\mathrm{fair}}$ & importance of latency and of fairness.\\
+Max iterations & $H_{\max}$ & auction iterations per control period.\\
+Price params \emph{(MADeA only)} & $\varepsilon$, $\zeta$ & min.\ bid increment; idle-seller price discount $\zeta\in(0,1)$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Variables and state at iteration $h$}}\\
+Replicas & $r_i^f$ & number of $f$ replicas on $i$, $r_i^f\in\mathbb{N}_0$.\\
+Local / forwarded / Cloud load & $x_i^f$, $y_{ij}^f$, $z_i^f$ & locally served; forwarded $i\!\to\! j$; Cloud-offloaded [req/s].\\
+Offloaded demand & $\omega_i^f$ & horizontal demand still to place [req/s].\\
+Effective load & $\ell_i^f$ & load to be served at $i$ for $f$ [req/s].\\
+Capacity / residual / slack & $\mathrm{Cap}_i^f$, $C_i^f$, $\rho_i$ & exec.\ capacity (Eq.~2); residual exec.\ capacity (Eq.~12); memory slack (Eq.~13).\\
+Congestion ratio & $\kappa_i^f$ & utilization ratio for $f$ on $i$, $\kappa_i^f\in[0,1]$.\\
+Fairness term & $\phi_i^f$ & penalty on nodes that offload excessively.\\
+Execution price \emph{(MADeA only)} & $p_i^f$ & shadow cost of residual capacity; \textbf{removed} in \textsc{FaaS-MADiG}.\\
+Coordination score & $s_{ij}^f$ & price-free preference of buyer $i$ for seller $j$ (Eq.~\eqref{eq:madig-score}).\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{Price-free coordination score}
+\label{sec:madig-score}
+
+At iteration $h$, an overloaded buyer $i$ (with $\omega_i^f(h)>0$) ranks each
+neighbour $j$ advertising residual capacity $C_j^f(h)\ge 1$ by the
+\emph{same} localized utility of Eq.~(7) with the execution price removed:
+\begin{equation}
+  s_{ij}^f(h)\;=\;u_{ij}^f(h)+p_j^f(h)
+  \;=\;\beta_{ij}^f\;-\;w_{\mathrm{lat}}\,L_{ij}\;-\;w_{\mathrm{fair}}\,\phi_i^f(h),
+  \label{eq:madig-score}
+\end{equation}
+and retains the same convenience threshold used by \textsc{FaaS-MADeA},
+\begin{equation}
+  j\in A_i^f(h)\iff s_{ij}^f(h)>-\,\gamma_i^f,
+  \label{eq:madig-threshold}
+\end{equation}
+where $\beta_{ij}^f$ is the reward of serving $i$'s load for $f$ at $j$,
+$L_{ij}$ the one-hop network latency, $\phi_i^f(h)$ the fairness penalty, and
+$\gamma_i^f$ the vertical (Cloud) offloading cost that sets the
+break-even point against Cloud forwarding. Dropping the $-p_j^f(h)$ term
+removes the only quantity the auction feeds back \emph{across} iterations;
+every other component of the buyer's preference, and the seller it prefers, are
+left untouched.
+
+\subsection{Greedy diffusion}
+\label{sec:madig-greedy}
+
+Algorithm~\ref{alg:madig-loop} summarizes the full control-period loop. Inside
+each diffusion iteration, two deterministic rules replace the auction's
+bid/clear cycle. On the buyer side (Algorithm~\ref{alg:madig-buyer}), node $i$
+sorts its candidate sellers by descending score~\eqref{eq:madig-score}, breaking
+ties by lower seller id, and greedily claims advertised
+blackboard capacity until its demand $\omega_i^f(h)$ is met or the
+neighbourhood is saturated; any
+shortfall triggers \emph{price-free} replica-expansion requests to neighbours
+with memory slack $\rho_j(h)>0$, exactly as in \textsc{FaaS-MADeA}. On the
+seller side (Algorithm~\ref{alg:madig-seller}), node $j$ serves incoming
+requests in descending-score order---ties broken by the buyer index $i$ for
+reproducibility---up to its true residual capacity $C_j^f(h)$. If capacity is
+exhausted while expansion requests remain and memory permits, the seller
+\emph{tentatively} starts replicas through the unchanged mechanism of
+Algorithm~4, which is gated by the utilization test $\kappa_j^f\le 1$ (i.e.
+$u\le U^f_{\max}$) and therefore needs no price.
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MADiG} --- control-period diffusion loop}
+\label{alg:madig-loop}
+\begin{algorithmic}[1]
+\Require workload at period $t$, neighbourhoods $N_i$, maximum iterations $H_{\max}$
+\For{each control period $t$}
+  \State each node solves its local problem (P2), obtaining $x_i^f$, $r_i^f$, $\rho_i$, and residual demand $\omega_i^f$
+  \State initialize assignment tensor $y\gets 0$, fairness counters, best solution trackers, and stopping state
+  \For{$h=0,\ldots,H_{\max}-1$}
+    \State compute advertised blackboard capacity $\bar C_i^f(h)=\max\{0,\mathrm{Cap}_i^f(h)-x_i^f(h)\}$
+    \State compute true residual capacity $C_i^f(h)=\max\{0,\mathrm{Cap}_i^f(h)-\ell_i^f(h)\}$
+    \State buyers generate assignment and replica-expansion requests using Algorithm~\ref{alg:madig-buyer}
+    \If{assignment requests exist}
+      \State sellers greedily accept requests, tentatively start replicas, and apply score-based replacement using Algorithm~\ref{alg:madig-seller}
+      \State update $y$, placed demand, and fairness counters
+      \State re-solve the restricted local problem with fixed $y$ to update $x$, $r$, and $\rho$
+      \State update residual demand $\omega_i^f$
+    \Else
+      \If{replica-expansion requests exist}
+        \State start additional replicas using the same feasibility rule as \textsc{FaaS-MADeA}
+      \EndIf
+    \EndIf
+    \State assemble the decentralized solution and update the best observed objective value
+    \If{the stopping criterion is met}
+      \State \textbf{break}
+    \EndIf
+  \EndFor
+  \State save the best solution, objective value, termination condition, and runtime
+\EndFor
+\end{algorithmic}
+\end{algorithm}
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MADiG} --- buyer greedy assignment (replaces Alg.~2)}
+\label{alg:madig-buyer}
+\begin{algorithmic}[1]
+\Require residual demand $\omega_i^f(h)$, neighbour blackboard residuals $\bar C_j^f(h)$ and
+         memory slacks $\rho_j(h)$ on the blackboard
+\For{each function $f$ with $\omega_i^f(h)>0$}
+  \State $A_i^f(h)\gets\{\,j\in N_i: \bar C_j^f(h)\ge 1 \text{ and } s_{ij}^f(h)>-\gamma_i^f\,\}$
+  \State sort $A_i^f(h)$ by $(\textbf{descending }s_{ij}^f(h),\ \textbf{ascending }j)$
+  \State $o\gets 0$ \Comment{load already placed}
+  \For{$j\in A_i^f(h)$ \textbf{while} $o<\omega_i^f(h)$}
+     \State $d\gets\min\!\big(\bar C_j^f(h),\,\omega_i^f(h)-o\big)$ \Comment{unit bids if enabled}
+     \State emit assignment request $(i\!\to\! j,f,d)$;\quad $o\gets o+d$
+  \EndFor
+  \If{$o<\omega_i^f(h)$ or replica expansion is forced} \Comment{shortfall or stagnation}
+     \For{$j\in N_i$ with $\rho_j(h)\ge \mathrm{RAM}^f$}
+        \State emit \emph{price-free} replica-expansion request $(i\!\to\! j,f)$
+     \EndFor
+  \EndIf
+\EndFor
+\end{algorithmic}
+\end{algorithm}
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MADiG} --- seller greedy fill (replaces Alg.~3)}
+\label{alg:madig-seller}
+\begin{algorithmic}[1]
+\Require requests received by $j$, residual capacity $C_j^f(h)$, memory slack $\rho_j(h)$
+\For{each function $f$ with $C_j^f(h)>0$, incumbent load, \textbf{or} pending expansion requests}
+  \State sort received requests by $\big(\text{descending } s_{ij}^f(h),\ \text{ascending } i\big)$
+  \State $c\gets C_j^f(h)$
+  \While{requests remain \textbf{and} $c>0$}
+     \State $q\gets\min(c,\,d_{\text{remaining}})$;\quad $y_{ij}^f\mathrel{+}= q$;\quad $c\gets c-q$;\quad $d_{\text{remaining}}\gets d_{\text{remaining}}-q$
+  \EndWhile
+  \If{$c=0$ \textbf{and} expansion requests remain \textbf{and} $\rho_j(h)>0$}
+     \State tentatively start replicas as in Alg.~4 \Comment{utilization test $\kappa_j^f\le1$; no price}
+  \EndIf
+  \If{$c=0$ \textbf{and} requests remain}
+     \State re-award incumbent load only from buyers with lower current score
+  \EndIf
+\EndFor
+\State \textbf{no} price update and \textbf{no} bid-price tracking
+\end{algorithmic}
+\end{algorithm}
+
+\subsection{What is removed and what is kept}
+\label{sec:madig-ablation}
+
+\noindent\textbf{Removed} (the price machinery of Eqs.~(7)--(8) and
+Algorithms~2--3): the price term $-p_j^f(h)$ in the utility; the per-unit
+bidding price $b_{ij}^f$ and minimum increment $\varepsilon$; the
+congestion-based price update of Eq.~(8) and the idle-seller discount $\zeta$;
+and the price-gated reassignment test for load already granted to another
+buyer. The reassignment role itself is retained in price-free form: a saturated
+seller may re-award incumbent load only when the new request has a higher
+current score.
+
+\noindent\textbf{Kept} (identical to \textsc{FaaS-MADeA}): the local
+problem~(P2); the advertising of residual execution capacity $C_i^f(h)$ and
+memory slack $\rho_i(h)$ (Eqs.~(12)--(13)); the convenience threshold
+$\gamma_i^f$ and the fairness penalty $\phi_i^f$; the price-free replica
+expansion of Algorithm~4; and the restricted-problem re-solve after each
+coordination round.
+
+\subsection{Rationale and properties}
+\label{sec:madig-rationale}
+
+\paragraph{Clean ablation.} Because the buyer already ranks sellers greedily by
+utility in \textsc{FaaS-MADeA}, the \emph{only} behavioural difference of
+\textsc{FaaS-MADiG} is the absence of the price signal---the cross-iteration
+congestion feedback and the seller-side price arbitration. Any performance gap
+between the two is therefore attributable to that signal alone, which makes
+\textsc{FaaS-MADiG} a controlled baseline rather than an unrelated heuristic.
+
+\paragraph{Determinism and termination.} With prices removed, the score
+\eqref{eq:madig-score} is constant within a control period $t$, and the
+tie-break on the buyer index makes the seller fill deterministic. Residual
+capacity is consumed during the initial fill, while score-based reassignment
+preserves the seller's accepted-load total but may move load from a lower-score
+incumbent to a higher-score buyer. The stopping criteria of
+\textsc{FaaS-MADeA} carry over unchanged (no residual capacity, all load
+assigned, $H_{\max}$ reached, or no convenient seller). If score-based
+reassignment induces empirical oscillation, the implementation can add the same
+kind of finite-horizon or no-change stopping guard already used by the runner.
+
+\paragraph{Fair runtime comparison.} Heuristic time is amortized per agent
+(the per-iteration cost is divided by the number of participating
+buyers/sellers, as in \textsc{FaaS-MADeA}), and only the MILP solves are charged
+in full. Wall-clock differences between the two methods thus reflect the cost of
+the coordination mechanism, not of the implementation.
+
+\paragraph{Communication.} \textsc{FaaS-MADiG} uses the same one-hop blackboard
+as \textsc{FaaS-MADeA} (advertising $C_i^f(h)$ and $\rho_i(h)$), but exchanges
+\emph{no} prices and runs \emph{no} price-update round, so its per-iteration
+message footprint is strictly smaller.
+
+\subsection{Positioning with respect to the literature}
+\label{sec:madig-related}
+
+We make explicit that \textsc{FaaS-MADiG} is, by design, an instance of a
+well-established family of distributed load-balancing rules, used here as a
+\emph{controlled} baseline rather than as a novel algorithm. Stating its lineage
+clarifies that the contribution it supports is methodological---isolating the
+effect of congestion pricing---and not a new heuristic.
+
+\paragraph{Similarities.} The buyer-side push of residual demand to one-hop
+neighbours ranked by a local gradient is exactly the \emph{diffusion} paradigm of
+Cybenko~\citep{cybenko1989}, in which an overloaded node iteratively sends excess
+load to its less-loaded neighbours; the sender-initiated form we use is a
+single-round simplification of the sender-initiated diffusion (SID) strategy
+catalogued by Willebeek-LeMair and Reeves~\citep{willebeek1993}. Greedy and
+heuristic offloading is likewise common in Edge/FaaS load management---for
+instance greedy, locality-driven load balancing inside FaaS
+dispatchers~\citep{leechoi2021} and decentralized multi-agent edge load
+balancing~\citep{nezami2021}---although those works differ in mechanism
+(dispatcher-level cache-locality scheduling, and collective-learning plan
+selection with randomly sampled candidate hosts, respectively) rather than
+instantiating the same one-hop residual-offload rule. Finally, the relation to
+\textsc{FaaS-MADeA} is precise: \textsc{FaaS-MADiG} is the \emph{price-frozen}
+special case of a Bertsekas-style auction~\citep{bertsekas1988}. Removing the
+cross-iteration price update---together with the $\varepsilon$ bid increment and
+the $\varepsilon$-complementary-slackness mechanism it serves---collapses the
+bidding-and-clearing cycle of
+Algorithms~\ref{alg:madig-buyer}--\ref{alg:madig-seller} to a greedy,
+price-free fill in which each buyer claims its best available residual capacity
+and a saturated seller may re-award incumbent load only to a higher-score buyer.
+In this sense \textsc{FaaS-MADiG} \emph{is} \textsc{FaaS-MADeA} with the market
+layer removed.
+
+\paragraph{Differences.} Three elements separate \textsc{FaaS-MADiG} from the
+textbook rules above. \emph{(i) Determinism over the full neighbourhood.} Unlike
+randomized power-of-$d$-choices balancing~\citep{mitzenmacher2001}, which probes
+a random sample of $d$ candidates, \textsc{FaaS-MADiG} scans the entire one-hop
+candidate set $A_i^f(h)$ and breaks ties deterministically, yielding reproducible
+runs without seed averaging. \emph{(ii) Joint balancing and provisioning.}
+Classical diffusion migrates load over a \emph{fixed} resource graph;
+\textsc{FaaS-MADiG} additionally triggers memory-slack-based replica expansion
+(Algorithm~4), coupling load balancing with capacity provisioning---a feature
+inherited from the \textsc{FaaS-MADeA} framework rather than from diffusion.
+\emph{(iii) Objective-aligned, optimization-coupled ranking.} The score
+\eqref{eq:madig-score} ranks neighbours by the model's economic weights
+($\beta_{ij}^f$, $\gamma_i^f$, latency $L_{ij}$, fairness $\phi_i^f$) rather than
+by raw queue length, and every offloading round is re-validated by the local
+problem~(P2) and the restricted re-solve, so the diffusion is steered by the
+social-welfare objective instead of by local load alone.
+
+\paragraph{Takeaway.} As an isolated coordination rule, \textsc{FaaS-MADiG}
+instantiates the diffusion / greedy one-hop-offloading paradigm and is not
+claimed as novel; its value is as a price-free ablation that attributes any
+performance gap with respect to \textsc{FaaS-MADeA} to congestion pricing alone.
diff --git a/faas-madig-note/main.tex b/faas-madig-note/main.tex
new file mode 100644
index 0000000..d9fe54a
--- /dev/null
+++ b/faas-madig-note/main.tex
@@ -0,0 +1,20 @@
+% Standalone preview wrapper for faas-madig.tex.
+% This file exists ONLY to compile a self-contained PDF of the section.
+% When inserting into the paper, do NOT use this wrapper: just
+%   \input{faas-madig}
+% (or paste its content) into the paper, which already defines the notation.
+\documentclass[11pt]{article}
+\usepackage[margin=1in]{geometry}
+\usepackage{amsmath,amssymb}
+\usepackage{algorithm}
+\usepackage[noend]{algpseudocode}
+\usepackage{booktabs}
+\usepackage[numbers]{natbib}
+\usepackage[hidelinks]{hyperref}
+
+\begin{document}
+\input{faas-madig}
+
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-madig-note/references.bib b/faas-madig-note/references.bib
new file mode 100644
index 0000000..eea4bf3
--- /dev/null
+++ b/faas-madig-note/references.bib
@@ -0,0 +1,66 @@
+% References for the FaaS-MADiG positioning subsection.
+% When inserting into the paper, merge these entries into the paper's .bib
+% (or re-key the \citep{} commands to the paper's existing keys).
+
+@article{cybenko1989,
+  author  = {George Cybenko},
+  title   = {Dynamic load balancing for distributed memory multiprocessors},
+  journal = {Journal of Parallel and Distributed Computing},
+  volume  = {7},
+  number  = {2},
+  pages   = {279--301},
+  year    = {1989},
+  doi     = {10.1016/0743-7315(89)90021-X}
+}
+
+@article{willebeek1993,
+  author  = {Marc H. Willebeek-LeMair and Anthony P. Reeves},
+  title   = {Strategies for dynamic load balancing on highly parallel computers},
+  journal = {IEEE Transactions on Parallel and Distributed Systems},
+  volume  = {4},
+  number  = {9},
+  pages   = {979--993},
+  year    = {1993},
+  doi     = {10.1109/71.243526}
+}
+
+@article{mitzenmacher2001,
+  author  = {Michael Mitzenmacher},
+  title   = {The power of two choices in randomized load balancing},
+  journal = {IEEE Transactions on Parallel and Distributed Systems},
+  volume  = {12},
+  number  = {10},
+  pages   = {1094--1104},
+  year    = {2001},
+  doi     = {10.1109/71.963420}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@article{nezami2021,
+  author  = {Zeinab Nezami and Kamran Zamanifar and Karim Djemame and Evangelos Pournaras},
+  title   = {Decentralized Edge-to-Cloud Load Balancing: Service Placement for the Internet of Things},
+  journal = {IEEE Access},
+  volume  = {9},
+  pages   = {64983--65000},
+  year    = {2021},
+  doi     = {10.1109/ACCESS.2021.3074962}
+}
+
+@inproceedings{leechoi2021,
+  author    = {Youngsoo Lee and Sunghee Choi},
+  title     = {A Greedy Load Balancing Algorithm for {FaaS} Platforms},
+  booktitle = {Proc.\ 2021 5th International Conference on Cloud and Big Data Computing (ICCBDC)},
+  pages     = {63--69},
+  year      = {2021},
+  doi       = {10.1145/3481646.3481657}
+}
diff --git a/faas-magcaa-note/.gitignore b/faas-magcaa-note/.gitignore
new file mode 100644
index 0000000..61cc0a3
--- /dev/null
+++ b/faas-magcaa-note/.gitignore
@@ -0,0 +1,8 @@
+*.aux
+*.bbl
+*.blg
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+main.pdf
diff --git a/faas-magcaa-note/README.md b/faas-magcaa-note/README.md
new file mode 100644
index 0000000..b35dacf
--- /dev/null
+++ b/faas-magcaa-note/README.md
@@ -0,0 +1,52 @@
+# FaaS-MAGCAA technical note
+
+This directory contains a paper-ready technical note for the FaaS-MAGCAA
+baseline, aligned with the implementation in `decentralized_gcaa.py`.
+
+## Contents
+
+- `faas-magcaa.tex`: the section to include in a paper. It contains a removable
+  notation recap, the implementation mapping, pseudocode, invariants, stopping
+  conditions, and positioning relative to GCAA and the other baselines.
+- `main.tex`: a minimal standalone wrapper for compiling and reviewing the note.
+- `references.bib`: the bibliography entries used by the standalone wrapper.
+- `.gitignore`: excludes LaTeX build products, including the generated PDF.
+
+## Build
+
+```bash
+cd faas-magcaa-note && latexmk -pdf main.tex
+```
+
+Optionally remove generated files with `latexmk -C main.tex`.
+
+## Integrate into the paper
+
+1. Copy the directory or place `faas-magcaa.tex` on the paper's TeX input path,
+   then add `\input{faas-magcaa}` at the intended location.
+2. Remove the fenced “self-contained notation recap” block when the paper
+   already defines the FRALB notation and capacity model.
+3. Replace section/equation/algorithm labels and plain cross-references where
+   needed to match the host paper's naming and numbering conventions.
+4. Merge the required entries from `references.bib` into the paper bibliography.
+5. Ensure the host preamble loads `amsmath`, `amssymb`, `amsthm`, `booktabs`,
+   `algorithm`, `algpseudocode`, and `natbib`, and defines the `proposition`
+   theorem environment. The standalone wrapper also loads `inputenc` and
+   `geometry`, but the included section does not require them specifically.
+
+## Runtime artifacts
+
+For each prefix `LSP` and `LSPc`, the implementation writes
+`<prefix>_solution.csv`, `<prefix>_offloaded.csv`,
+`<prefix>_utilization.csv`, `<prefix>_replicas.csv`,
+`<prefix>_detailed_fwd_solution.csv`, and
+`<prefix>_residual_capacity.csv`. It also writes `obj.csv`,
+`termination_condition.csv`, `runtime.csv`, and `config.json`. The file
+`out.log` is written only when `log_on_file=True`.
+
+When `t % checkpoint_interval == 0` or `t == max_steps - 1`, component CSVs
+are checkpointed under `LSP/<t>/` and `LSPc/<t>/`; no checkpoint directory is
+written for other periods. The MAGCAA history plot `sp.png` is written when
+plotting is enabled and both `Nf <= 10` and `Nn <= 10`. The shared
+`init_problem` setup also creates instance artifacts, including
+`graph/graph.png` and, for planar graphs, the `graph/PLANAR` marker.
diff --git a/faas-magcaa-note/faas-magcaa.tex b/faas-magcaa-note/faas-magcaa.tex
new file mode 100644
index 0000000..582bf55
--- /dev/null
+++ b/faas-magcaa-note/faas-magcaa.tex
@@ -0,0 +1,402 @@
+% =====================================================================
+% FaaS-MAGCAA: greedy coalition-auction allocation for FRALB.
+% Meant to be \input{} (or pasted) into the paper. The notation recap
+% below is removable when the host paper has already defined FRALB.
+% =====================================================================
+
+\section{FaaS-MAGCAA: greedy coalition auction allocation}
+\label{sec:magcaa}
+
+\textsc{FaaS-MAGCAA} adapts the task-selection and winner-consensus
+mechanism of the Greedy Coalition Auction Algorithm (GCAA) of
+\citet{braquetbakolas2021} to Function Replica Allocation and Load Balancing
+(FRALB). It is included as an experimental decentralized baseline rather
+than as a new auction-theoretic mechanism. At every control period, local
+problems first determine the load that each node would like to offload and
+the replicas already available. Repeated auction rounds then match unit
+loads to neighbouring execution capacity by greedy utility ranking.
+
+This baseline deliberately omits two mechanisms used by other methods in
+the paper. First, its price array is fixed at zero: there is no adaptive
+price update as in \textsc{FaaS-MADeA}. Second, its replica-seller array is
+fixed at zero: there is no memory or replica market, and unmatched load
+receives the null allocation. Consequently, the method provides neither the
+price or dual certificate associated with \textsc{FaaS-MALD} nor the
+equilibrium certificate associated with \textsc{FaaS-MAPG}. Its role is to
+isolate the empirical behaviour of a greedy GCAA-style selection and
+consensus rule inside the common FRALB execution pipeline.
+Classical price-based auction algorithms and distributed numerical methods
+provide broader background for such coordination
+\citep{bertsekas1988,bertsekas1989}; FaaS-MAGCAA's fixed zero price means that
+it does not inherit their price-adjustment results or guarantees.
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% This subsection restates only the FRALB notation needed by FaaS-MAGCAA.
+% REMOVE this whole fenced block when inserting the section into a paper
+% that has already introduced these symbols and the capacity model.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:magcaa-notation}
+
+Let $\mathcal N$ be the set of compute nodes, $\mathcal F$ the function set,
+and $N_i\subseteq\mathcal N$ the one-hop neighbourhood of node $i$. At a
+control period, node $i$ receives workload $\lambda_i^f$ for function $f$.
+Its local solve partitions this workload into locally executed load $x_i^f$,
+load $\omega_i^f$ offered to the coordination mechanism, and rejected or
+Cloud-forwarded load $z_i^f$. The coordination variable $y_{ij}^f$ is the
+amount originating at $i$ and executed by neighbour $j$. Node $j$ runs
+$r_j^f$ replicas, each governed by maximum utilization $U_{\max}^f$ and by
+the per-request service demand $D_j^f$ used by the implementation.
+
+Before auction round $h$, the implementation computes execution capacity
+and residual capacity as
+\begin{equation}
+  \operatorname{Cap}_j^f(h)=
+    \frac{r_j^f(h)U_{\max}^f}{D_j^f},
+  \qquad
+  C_j^f(h)=\max\!\left\{0,
+    \frac{r_j^f(h)U_{\max}^f}{D_j^f}
+    -x_j^f(h)-\sum_{i\in\mathcal N}y_{ij}^f(h)
+  \right\}.
+  \label{eq:magcaa-residual-capacity}
+\end{equation}
+Thus $C_j^f$ is measured in load units, not replicas. The bid generator is
+given the looser blackboard quantity
+$B_j^f=\max\{0,\operatorname{Cap}_j^f-x_j^f\}$, whereas final acceptance
+uses $C_j^f$, which also subtracts inbound assignments accumulated in $y$.
+
+For a buyer $i$, seller $j$, and function $f$, the inherited helper computes
+$\beta_{ij}^f-p_j^f-w_L\ell_{ij}-w_Fq_i^f(h)$. FaaS-MAGCAA fixes
+$p_j^f=0$, so its specialized baseline utility is
+\begin{equation}
+  u_{ij}^f(h)=\beta_{ij}^f-w_L\ell_{ij}-w_Fq_i^f(h),
+  \label{eq:magcaa-utility}
+\end{equation}
+where $\beta_{ij}^f$ is the FRALB offloading benefit, $\ell_{ij}$ is network
+latency, and $q_i^f$ is a within-period fairness counter. The configurations
+used for this baseline set $w_L=w_F=0$, so
+$u_{ij}^f=\beta_{ij}^f$. The symbol $\ell_{ij}$ in
+Eq.~\eqref{eq:magcaa-utility} denotes latency and is distinct from the
+served-load quantity $x_j^f+\sum_i y_{ij}^f$ computed internally by the
+capacity helper.
+
+The no-ping-pong state for function $f$ is represented by
+\begin{equation}
+  S_i^f(y)=\mathbf 1\!\left\{\sum_j y_{ij}^f>0\right\},
+  \qquad
+  R_i^f(y)=\mathbf 1\!\left\{\sum_k y_{ki}^f>0\right\},
+  \label{eq:magcaa-send-receive}
+\end{equation}
+where $S_i^f$ and $R_i^f$ mean, respectively, that $i$ is sending or
+receiving function-$f$ load. Feasibility requires that they are not both
+true for the same node and function.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in the FaaS-MAGCAA section.}
+\label{tab:magcaa-notation}
+\small
+\begin{tabular}{@{}l l p{0.59\linewidth}@{}}
+\toprule
+Nodes, functions & $\mathcal N,\mathcal F$ & compute nodes and deployable functions.\\
+Neighbourhood & $N_i$ & sellers visible to buyer node $i$.\\
+Input workload & $\lambda_i^f$ & function-$f$ load arriving at node $i$.\\
+Local load & $x_i^f$ & load executed at its origin node $i$.\\
+Auction load & $\omega_i^f$ & residual load of active buyer--function pair $(i,f)$.\\
+Routed load & $y_{ij}^f$ & load sent from buyer $i$ to seller $j$.\\
+Cloud/rejected load & $z_i^f$ & load not executed locally or by a neighbour.\\
+Replicas & $r_i^f$ & number of function-$f$ replicas at node $i$.\\
+Residual capacity & $C_j^f$ & seller capacity after local $x_j^f$ and inbound $\sum_i y_{ij}^f$.\\
+Benefit, latency & $\beta_{ij}^f,\ell_{ij}$ & offloading benefit and network-latency input.\\
+Fairness state & $q_i^f$ & number of prior inner rounds in the period in which $(i,f)$ has an allocation.\\
+Utility & $u_{ij}^f$ & consensus ranking value in Eq.~\eqref{eq:magcaa-utility}.\\
+Sending, receiving & $S_i^f,R_i^f$ & predicates in Eq.~\eqref{eq:magcaa-send-receive}.\\
+Iteration limits & $H_{\max},T_{\max}$ & maximum auction rounds and accumulated solver-time limit.\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{From GCAA tasks to FRALB unit allocations}
+\label{sec:magcaa-mapping}
+
+In the original GCAA, an agent selects at most one task during an auction
+iteration, agents proposing the same task are compared by utility, and the
+winner is finalized. Several agents may ultimately form a coalition on the
+same task over successive iterations; the null task remains available when
+no task yields an acceptable assignment \citep{braquetbakolas2021}. In the
+FRALB adaptation, every active buyer--function pair $(i,f)$ with
+$\omega_i^f>0$ plays the role of one GCAA agent. A neighbouring
+seller--function pair $(j,f)$ with advertised capacity plays the role of a
+task. The translation is deliberately unit based: the runner rejects any
+configuration in which \texttt{unit\_bids} is not true, and every bid row
+therefore has demand $d=1$.
+
+This mapping changes the meaning of coalition formation. A seller--function
+task accepts at most one buyer in one FaaS-MAGCAA round, but its capacity may
+be filled by buyers accepted in later rounds. The accumulated tensor $y$
+therefore records the analogue of a coalition across rounds. Conversely, a
+buyer--function pair is not permanently finalized after its first accepted
+unit: if residual load remains, it can bid again in a later round. If no row
+survives neighbourhood, convenience, capacity, and no-ping-pong checks, the
+pair receives no allocation in that round. This is the FRALB counterpart of
+GCAA's null assignment, without creating a replica to manufacture a task.
+
+\paragraph{Utility and bid columns.}
+The inherited bid generator produces both a utility column
+$u_{ij}^f$ and a ranking-price column
+\begin{equation}
+  b_{ij}^f=p_j^f+\epsilon+\delta_{ij}^f,
+  \label{eq:magcaa-b-column}
+\end{equation}
+where $\delta_{ij}^f$ is the gap to the next seller in the generator's
+utility ordering. FaaS-MAGCAA fixes $p_j^f=0$ and does not call the adaptive
+price-update routine. More importantly, its proposal and consensus code
+ranks the \texttt{utility} column, not $b_{ij}^f$. Hence $\epsilon$ and
+$\delta_{ij}^f$ may change the unused $b$ column but cannot change the
+winner ranking; under the baseline configurations, that ranking is simply
+descending $\beta_{ij}^f$.
+
+\subsection{Proposal and consensus round}
+\label{sec:magcaa-consensus}
+
+Let $\mathcal B(h)$ denote the rows emitted by the bid generator in round
+$h$. Because unit mode expands available quantities, $\mathcal B(h)$ can
+contain repeated unit rows and rows for several sellers for the same
+buyer--function pair. The proposal stage keeps exactly the row selected by
+the data-frame operation
+\begin{equation}
+  \widehat b_i^f(h)\in
+  \underset{b\in\mathcal B(h):\,(b.i,b.f)=(i,f)}{\operatorname{arg\,max}}
+  b.\textit{utility}.
+  \label{eq:magcaa-proposal}
+\end{equation}
+The implementation uses \texttt{groupby(...).idxmax()}, including its
+data-frame semantics when equal maxima occur; no stronger universal
+tie-breaking rule is part of the algorithmic contract.
+
+The selected proposals are grouped by seller--function pair $(j,f)$. If
+$S_j^f(y)=1$, the entire group is skipped because that seller already sends
+the same function. Otherwise its contenders are visited in descending
+utility. A contender $(i,f)$ is skipped if $R_i^f(y)=1$ or if
+$C_j^f(h)<d$. The first contender passing both tests is accepted,
+$y_{ij}^f$ is increased by $d=1$, and the round-local states are updated to
+$S_i^f=1$ and $R_j^f=1$ before the next group is examined. The group then
+terminates. A lower-ranked contender can therefore win when a higher-ranked
+one is invalid under the receiving or capacity test; the code does not
+blindly discard the whole task after rejecting its first row.
+
+The state used to initialize these predicates is the cumulative
+\texttt{current\_y} from all previous rounds. The immediate round-local
+updates additionally prevent an allocation accepted earlier in the same
+round from participating in a later ping-pong chain. Once all task groups
+have been visited, the round increment is added to cumulative $y$.
+
+\subsection{Implemented procedure}
+\label{sec:magcaa-procedure}
+
+Algorithm~\ref{alg:magcaa} states the complete per-period procedure. It
+separates the greedy auction operation from the common FRALB machinery that
+re-solves local models, validates feasibility, evaluates candidate welfare,
+tracks two best candidates, checkpoints, and saves artifacts.
+
+\begin{algorithm}[H]
+\caption{\textsc{FaaS-MAGCAA} at one control period}
+\label{alg:magcaa}
+\begin{algorithmic}[1]
+\Require period data, neighbourhoods, $H_{\max}$, $T_{\max}$, tolerance $\tau$
+\State solve one local \textsc{LSP} for each node; obtain $x$, $r$, $\rho$, $U$, and initial components $\omega_i^{f,0}$
+\State $y\gets0$; $\boldsymbol\omega\gets(\omega_i^{f,0})_{i,f}$; $q\gets0$; $p\gets0$; replica-seller vector $\widehat\rho\gets0$
+\State require \texttt{unit\_bids}${}={}$true; set round $h\gets0$
+\Repeat
+  \State compute $\operatorname{Cap}$, $C$, and served load from $(x,y,r)$ by Eq.~\eqref{eq:magcaa-residual-capacity}
+  \State $B\gets\max\{0,\operatorname{Cap}-x\}$
+  \State $(\mathcal B,\mathcal B_{\rm mem},n_a)\gets\textsc{DefineBids}(\omega,B,p,\widehat\rho,q)$
+  \Comment{$\mathcal B_{\rm mem}=\emptyset$ because $\widehat\rho=0$}
+  \State $\widehat\omega\gets0$
+  \If{$\mathcal B\ne\emptyset$}
+    \State $\Delta y\gets0$; initialize $S,R$ from cumulative $y$
+    \State keep one maximum-utility row per active $(i,f)$ as in Eq.~\eqref{eq:magcaa-proposal}
+    \For{each resulting seller--function group $(j,f)$}
+      \If{$S_j^f=0$}
+        \For{each contender $(i,f,d)$ in descending utility}
+          \If{$R_i^f=0$ and $C_j^f\ge d$}
+            \State $\Delta y_{ij}^f\gets\Delta y_{ij}^f+d$; $S_i^f\gets1$; $R_j^f\gets1$
+            \State \textbf{break}
+          \EndIf
+        \EndFor
+      \EndIf
+    \EndFor
+    \State $y\gets y+\Delta y$; $\widehat\omega_i^f\gets\sum_j y_{ij}^f$
+    \State increment $q_i^f$ for each $(i,f)$ with $\widehat\omega_i^f>0$
+    \State run the pre-solve fixed-$y$ \textsc{LSPr} memory-feasibility check; abort with a runtime error if it fails
+    \State solve fixed-$y$ \textsc{LSPr} models via \textsc{ComputeSocialWelfare}; update $x,r,\rho$
+    \State $\omega_i^f\gets\omega_i^{f,0}-\widehat\omega_i^f$; set values within $\tau$ of zero to zero
+  \EndIf
+  \State combine $(x,y,r,\rho)$, tighten replicas to realized served load, and assert centralized feasibility
+  \State update the best restricted-objective candidate and the best centralized-objective candidate
+  \State $(\mathrm{stop},\mathrm{reason})\gets\textsc{CheckStoppingCriteria}(h,H_{\max},B,\omega,\widehat\omega,0,\mathcal B,\mathcal B_{\rm mem},\tau,\mathrm{runtime},T_{\max})$
+  \If{not $\mathrm{stop}$} \State $h\gets h+1$ \EndIf
+\Until{$\mathrm{stop}$}
+\State decode the two tracked candidates and record the period objective and termination reason
+\State checkpoint \textsc{LSP}/\textsc{LSPc} only if $t\bmod I_{\rm checkpoint}=0$ or $t=\texttt{max\_steps}-1$
+\end{algorithmic}
+\end{algorithm}
+
+The zero in the stopping call is the default all-zero additional-replica
+allocation created when the argument is passed as \texttt{None}; the
+restricted allocation $\widehat\omega$ is cumulative, not merely the most
+recent round increment. The variable $n_a$ is returned by the inherited bid
+generator but is not used by this runner. Likewise, the local solution's
+$\rho$ is retained for solution construction, while the separate all-zero
+$\widehat\rho$ disables memory bids.
+
+The runner always writes \texttt{config.json}. It writes \texttt{out.log}
+only when \texttt{log\_on\_file=True}. The MAGCAA history plot
+\texttt{sp.png} is written when plotting is enabled and both $N_f\le10$ and
+$N_n\le10$. The shared instance setup also creates artifacts including
+\texttt{graph/graph.png} and, for planar graphs, the \texttt{graph/PLANAR}
+marker. After all control periods, the runner joins the complete period
+solutions and writes the final \textsc{LSP} and \textsc{LSPc} outputs. For
+each prefix \texttt{LSP} and \texttt{LSPc}, these
+are:
+\begin{itemize}
+  \item \texttt{<prefix>\_solution.csv};
+  \item \texttt{<prefix>\_offloaded.csv};
+  \item \texttt{<prefix>\_utilization.csv};
+  \item \texttt{<prefix>\_replicas.csv};
+  \item \texttt{<prefix>\_detailed\_fwd\_solution.csv}; and
+  \item \texttt{<prefix>\_residual\_capacity.csv}.
+\end{itemize}
+The runner also writes
+\texttt{obj.csv}, \texttt{termination\_condition.csv}, and
+\texttt{runtime.csv}. When the checkpoint predicate in
+Algorithm~\ref{alg:magcaa} holds, the component CSVs are written beneath
+\texttt{LSP/<t>/} and \texttt{LSPc/<t>/}; those checkpoint directories are
+not written for other periods.
+
+\subsection{Round invariants}
+\label{sec:magcaa-properties}
+
+\begin{proposition}[At most one winner per task and round]
+\label{prop:magcaa-one-winner}
+For every round $h$ and seller--function pair $(j,f)$,
+$\sum_i\Delta y_{ij}^f(h)$ contains at most one accepted unit.
+\end{proposition}
+\begin{proof}
+All selected proposals for $(j,f)$ are processed in one data-frame group.
+After the first valid contender is accepted, the inner contender loop
+terminates. If no contender is valid, the group contributes zero. Because
+the outer grouping visits $(j,f)$ only once, no second unit can be accepted
+for that task during the same round.
+\end{proof}
+
+\begin{proposition}[Capacity at acceptance]
+\label{prop:magcaa-capacity}
+Every unit accepted for $(j,f)$ is no larger than the residual capacity
+$C_j^f(h)$ computed at the start of that round.
+\end{proposition}
+\begin{proof}
+The acceptance branch is entered only if $C_j^f(h)\ge d$, and mandatory
+unit mode gives $d=1$. By Proposition~\ref{prop:magcaa-one-winner}, no other
+unit for $(j,f)$ is accepted in that round, so the start-of-round residual
+need not be decremented again within the group traversal. Before the next
+round, $C_j^f$ is recomputed from the cumulative $y$ and the latest
+restricted re-optimization. Thus each accepted unit respects the residual
+capacity available at the time of its check, including load accumulated in
+earlier rounds.
+\end{proof}
+
+\begin{proposition}[Inductive no-ping-pong preservation]
+\label{prop:magcaa-no-ping-pong}
+Starting from $y=0$, every cumulative allocation produced by
+Algorithm~\ref{alg:magcaa} satisfies
+$S_i^f(y)R_i^f(y)=0$ for every $(i,f)$.
+\end{proposition}
+\begin{proof}
+The property is true at initialization. Assume it holds for cumulative $y$
+at the beginning of a round. A proposed edge $i\to j$ is accepted only if
+$R_i^f=0$ and $S_j^f=0$, so it cannot make an existing receiver send or an
+existing sender receive. Immediately after acceptance, the algorithm sets
+$S_i^f=1$ and $R_j^f=1$. Subsequent groups in the same round therefore
+cannot use $i$ as a seller or $j$ as a buyer. Each accepted edge preserves
+the invariant both relative to prior rounds and relative to earlier edges
+in the current round. Induction over accepted edges and then over rounds
+proves the claim.
+\end{proof}
+
+These propositions are local feasibility statements. They do not establish
+global optimality, truthfulness, a market equilibrium, or a dual bound. In
+particular, Proposition~\ref{prop:magcaa-capacity} concerns the residual at
+each acceptance; overall FRALB feasibility is additionally checked by the
+fixed-$y$ memory pre-check, the restricted local solves, and the centralized
+feasibility assertion shown in Algorithm~\ref{alg:magcaa}.
+
+\subsection{Stopping conditions and practical limits}
+\label{sec:magcaa-stopping}
+
+The runner reuses \texttt{check\_stopping\_criteria} from
+\textsc{FaaS-MADeA} with its arguments specialized as shown in
+Algorithm~\ref{alg:magcaa}. Its tests are ordered. It first stops when
+$h\ge H_{\max}-1$. It next stops if all blackboard capacities $B$ are at
+most $\tau$, or if all residual buyer loads $\omega$ are at most $\tau$.
+The default all-zero additional-replica allocation then makes the inherited
+``load cannot be assigned'' branch apply whenever cumulative
+$\widehat\omega$ is also all zero. If that branch does not apply, the code
+stops when both ordinary and memory bid tables are empty. Finally, it tests
+whether accumulated solver runtime has reached $T_{\max}$. The later
+``feasible solution found'' branch of the shared helper is inactive because
+this call does not pass its optional \texttt{sp\_omega} and \texttt{sp\_y}
+arguments.
+
+The stopping helper is called only after bid resolution, any fixed-$y$
+restricted re-solve, and candidate evaluation. Consequently, every entered
+control period executes round $h=0$. For positive $H_{\max}$, the maximum
+iteration guard bounds the number of completed rounds; it does not prevent
+entry into the current round.
+
+These guards cover exhaustion of offered load, exhaustion of advertised
+capacity, absence of bidders, an initially unassignable allocation, the
+iteration cap, and the time cap. They do not make every stalled state an
+algorithmic fixed point: after some allocation has accumulated,
+$\widehat\omega$ is nonzero, and bid rows rejected only by the stricter
+residual-capacity or no-ping-pong checks may persist until another guard
+fires. Reaching ``max iterations reached'' or the time limit therefore
+returns a feasibility-checked candidate but is not a convergence
+certificate.
+
+The original GCAA proves completion within at most the number of agents
+because each iteration finalizes an additional agent under that paper's
+task-allocation protocol \citep{braquetbakolas2021}. That result does not
+transfer automatically here. A FaaS-MAGCAA buyer--function pair may demand
+several units, may bid again after an accepted unit, and competes under
+capacity, re-optimization, eligibility, and no-ping-pong constraints.
+Moreover, several distinct seller--function tasks can accept concurrently
+in one round. Accordingly, this implementation relies on the practical
+guards above and claims no inherited finite bound in terms of the number of
+nodes or buyer--function pairs.
+
+\subsection{Relation to GCAA and the other coordination baselines}
+\label{sec:magcaa-positioning}
+
+FaaS-MAGCAA retains the two recognizable operations of GCAA: an active agent
+selects one currently best task, and contenders for a common task are
+resolved greedily by utility. It does not reproduce the paper's distributed
+bid-vector exchange or its permanent finalized-agent vector. Instead, the
+shared runner materializes bid rows centrally for an experimental baseline,
+resolves one winner per seller--function task and round, and carries the
+accepted flow tensor across rounds. The original paper permits multiple
+agents to form a task coalition through repeated finalizations; the FRALB
+counterpart accumulates unit winners against execution capacity through
+repeated fixed-$y$ re-optimization.
+
+This construction also explains its narrower interpretation relative to
+the paper's other baselines. Unlike \textsc{FaaS-MADeA}, it never updates
+prices and never solicits replica memory. Unlike \textsc{FaaS-MALD}, it does
+not optimize or certify a Lagrangian bound. Unlike \textsc{FaaS-MAPG}, its
+stopping reasons do not certify a Nash equilibrium. FaaS-MAGCAA should
+therefore be read as an implementation-faithful greedy allocation heuristic
+whose empirical results can be compared under the same FRALB local-solve,
+feasibility, evaluation, and persistence pipeline, not as a transfer of the
+original GCAA theorem or as an alternative optimality certificate.
diff --git a/faas-magcaa-note/main.tex b/faas-magcaa-note/main.tex
new file mode 100644
index 0000000..cd09a67
--- /dev/null
+++ b/faas-magcaa-note/main.tex
@@ -0,0 +1,19 @@
+% Standalone preview wrapper for the FaaS-MAGCAA note.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\newtheorem{proposition}{Proposition}
+\newtheorem{theorem}{Theorem}
+
+\begin{document}
+\input{faas-magcaa}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-magcaa-note/references.bib b/faas-magcaa-note/references.bib
new file mode 100644
index 0000000..b7ca481
--- /dev/null
+++ b/faas-magcaa-note/references.bib
@@ -0,0 +1,31 @@
+% References for the FaaS-MAGCAA positioning subsection.
+
+@article{braquetbakolas2021,
+  author  = {Martin Braquet and Efstathios Bakolas},
+  title   = {Greedy Decentralized Auction-based Task Allocation for Multi-Agent Systems},
+  journal = {IFAC-PapersOnLine},
+  volume  = {54},
+  number  = {20},
+  pages   = {675--680},
+  year    = {2021},
+  doi     = {10.1016/j.ifacol.2021.11.249}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@book{bertsekas1989,
+  author    = {Dimitri P. Bertsekas and John N. Tsitsiklis},
+  title     = {Parallel and Distributed Computation: Numerical Methods},
+  publisher = {Prentice-Hall},
+  address   = {Englewood Cliffs, NJ},
+  year      = {1989}
+}
diff --git a/faas-mald-note/.gitignore b/faas-mald-note/.gitignore
new file mode 100644
index 0000000..ab6921a
--- /dev/null
+++ b/faas-mald-note/.gitignore
@@ -0,0 +1,10 @@
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+*.synctex.gz
+*.toc
+*.bbl
+*.blg
+main.pdf
diff --git a/faas-mald-note/README.md b/faas-mald-note/README.md
new file mode 100644
index 0000000..a44b530
--- /dev/null
+++ b/faas-mald-note/README.md
@@ -0,0 +1,39 @@
+# FaaS-MALD technical note
+
+A focused, paper-ready LaTeX section describing FaaS-MALD and its fixed-residual-capacity transportation-LP certificate.
+
+## Files
+
+- `faas-mald.tex` — **the deliverable**: a self-contained `\section` covering
+  the transportation LP, dual decomposition, primal recovery, certificate,
+  properties, and literature positioning. Delete the fenced notation recap
+  when inserting it into a paper that already defines the notation.
+- `references.bib` — bibliography for the literature-positioning subsection.
+- `main.tex` — minimal standalone preview wrapper.
+- `.gitignore` — ignores LaTeX build artifacts and the preview PDF.
+
+## Runtime artifacts
+
+- `obj.csv` — objective trace written by the runner.
+- `termination_condition.csv` — outer-loop stopping summaries.
+- `coordination_certificate.csv` — one row per outer iteration with the fixed-capacity inner-LP certificate columns `timestep`, `outer_iteration`, `LB`, `UB`, `gap`, `inner_iterations`, and `stop_reason`.
+- `runtime.csv` — runtime totals per timestep.
+
+## Compile the preview
+
+```bash
+cd faas-mald-note
+latexmk -pdf main.tex      # produces main.pdf
+latexmk -c                 # clean aux files (keep main.pdf)
+```
+
+## Insert into the paper
+
+Copy `faas-mald.tex` next to the paper sources and add `\input{faas-mald}` at
+the desired position. Merge `references.bib` into the paper bibliography and
+replace standalone equation and algorithm references with the host paper's
+labels. The inserted section requires `amsmath`, `amssymb`, `algorithm`,
+`algpseudocode`, `booktabs`, and `natbib`. The standalone `main.tex` wrapper
+additionally loads `geometry` for preview margins and `hyperref` for PDF links;
+those two packages are wrapper conveniences rather than host-section
+requirements.
diff --git a/faas-mald-note/faas-mald.tex b/faas-mald-note/faas-mald.tex
new file mode 100644
index 0000000..6eed9bc
--- /dev/null
+++ b/faas-mald-note/faas-mald.tex
@@ -0,0 +1,228 @@
+% FaaS-MALD section: input this file into the host paper.
+\section{FaaS-MALD: fixed-capacity LP coordination and certificate}
+\label{sec:mald}
+
+\textsc{FaaS-MALD} coordinates one-hop horizontal offloading by solving a
+capacity-constrained transportation problem through seller prices. Unlike an
+auction heuristic, each inner solve at fixed residual capacity maintains a
+feasible transportation-LP incumbent and a Lagrangian upper bound. The resulting
+certificate applies only to that inner LP, not to the end-to-end outer execution
+whose capacities can subsequently change.
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% Reproduces the relevant rows of the paper's Table 2 (FRALB) and Table 3
+% (auction) plus Eqs. (1),(2),(12),(13), so the note is readable on its own.
+% REMOVE this whole subsection when inserting into the paper, where the
+% notation and these equations are already defined.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:mald-notation}
+
+Each control period $t$ runs coordination iterations $h=0,1,\dots,H_{\max}$ in
+parallel. Before coordination, every node $i$ solves a local problem~(P2)
+that, for each function $f\in\mathcal{F}_i$, splits the incoming workload
+$\lambda_i^f$ into locally processed load $x_i^f$, horizontally offloaded
+demand $\omega_i^f$, and Cloud-forwarded load $z_i^f$, and fixes the number of
+replicas $r_i^f$. Replicas obey the memory budget and provide capacity
+\begin{equation*}
+  \sum_{f\in\mathcal{F}_i} r_i^f\,\mathrm{RAM}^f \le \mathrm{RAM}_i,
+  \qquad
+  \mathrm{Cap}_i^f = \frac{r_i^f\,U^f_{\max}}{D_i^f}\ \text{[req/s]} ,
+  \tag*{(1,2)}
+\end{equation*}
+from which each node advertises, on a neighbour-accessible blackboard, its
+residual execution capacity and its memory slack:
+\begin{equation*}
+  C_i^f(h) = \max\!\big\{0,\ \mathrm{Cap}_i^f(h) - x_i^f(h)\big\},
+  \qquad
+  \rho_i(h) = \mathrm{RAM}_i - \sum_{f\in\mathcal{F}_i} r_i^f(h)\,\mathrm{RAM}^f \ge 0 .
+  \tag*{(12,13)}
+\end{equation*}
+Table~\ref{tab:mald-notation} collects the symbols used below.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in this section (subset of the paper's Tables~2--3).}
+\label{tab:mald-notation}
+\footnotesize
+\setlength{\tabcolsep}{3pt}
+\begin{tabular}{@{}p{0.23\linewidth} p{0.18\linewidth} p{0.54\linewidth}@{}}
+\toprule
+\multicolumn{3}{@{}l}{\textit{Sets}}\\
+Nodes / neighbours & $\mathcal{N}$, $N_i$ & computing nodes; one-hop neighbours of $i$.\\
+Functions & $\mathcal{F}_i$ & functions deployable on $i$; $\mathcal{F}=\bigcup_i\mathcal{F}_i$.\\
+Candidate sellers & $A_i^f(h)$ & neighbours with positive Cloud-relative advantage $a_{ij}^f>0$, equivalently $s_{ij}^f>-\gamma_i^f$; $A_i^f(h)\subseteq N_i$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Parameters and weights}}\\
+Input workload & $\lambda_i^f$ & incoming request rate for $f$ at $i$ [req/s].\\
+Memory cap / demand & $\mathrm{RAM}_i$, $\mathrm{RAM}^f$ & node memory; per-replica memory of $f$ [MB].\\
+Service demand & $D_i^f$ & average execution time of $f$ at $i$ [s].\\
+Max utilization & $U^f_{\max}$ & stability threshold, $U^f_{\max}\in[0,1)$.\\
+Local / offload / Cloud profit & $\alpha_i^f$, $\beta_{ij}^f$, $\gamma_i^f$ & profit of local exec.; profit of offloading $i\!\to\! j$; Cloud-offloading penalty (per req/s).\\
+Communication latency & $L_{ij}$ & horizontal-offloading latency between $i$ and $j$.\\
+Weights & $w_{\mathrm{lat}}$, $w_{\mathrm{fair}}$ & importance of latency and fairness.\\
+Max iterations & $H_{\max}$ & coordination iterations per control period.\\
+Price params \emph{(MADeA only)} & $\varepsilon$, $\zeta$ & min.\ bid increment; idle-seller price discount $\zeta\in(0,1)$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Variables and state at iteration $h$}}\\
+Replicas & $r_i^f$ & number of $f$ replicas on $i$, $r_i^f\in\mathbb{N}_0$.\\
+Local / forwarded / Cloud load & $x_i^f$, $y_{ij}^f$, $z_i^f$ & locally served; forwarded $i\!\to\! j$; Cloud-offloaded [req/s].\\
+Offloaded demand & $\omega_i^f$ & horizontal demand still to place [req/s].\\
+Effective load & $\ell_i^f$ & load to be served at $i$ for $f$ [req/s].\\
+Capacity / residual / slack & $\mathrm{Cap}_i^f$, $C_i^f$, $\rho_i$ & exec.\ capacity (Eq.~2); residual exec.\ capacity (Eq.~12); memory slack (Eq.~13).\\
+Congestion ratio & $\kappa_i^f$ & utilization ratio for $f$ on $i$, $\kappa_i^f\in[0,1]$.\\
+Fairness term & $\phi_i^f$ & penalty on nodes that offload excessively.\\
+Execution price \emph{(MADeA only)} & $p_i^f$ & shadow cost of residual capacity; replaced by multiplier $\lambda_i^f$ in \textsc{FaaS-MALD}.\\
+Coordination score / advantage & $s_{ij}^f$, $a_{ij}^f$ & price-free score $s_{ij}^f=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f$ and Cloud-relative advantage $a_{ij}^f=s_{ij}^f+\gamma_i^f$.\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{Coordination transportation LP}
+For fixed residual demands and capacities, define the price-free score
+\(
+  s_{ij}^f=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f
+\)
+and the Cloud-relative advantage
+\(
+  a_{ij}^f=s_{ij}^f+\gamma_i^f
+  =\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f+\gamma_i^f
+\).
+The Cloud is the zero incremental baseline, so an offloading pair is eligible
+exactly when $j\in N_i$ and $a_{ij}^f>0$, equivalently when $s_{ij}^f>-\gamma_i^f$.
+With pairs outside that candidate set omitted, the fixed-capacity
+coordination LP is
+\begin{align}
+ \max_{y\geq0}\quad&\sum_{i,j,f}a_{ij}^fy_{ij}^f,\\
+ \text{s.t.}\quad&\sum_jy_{ij}^f\leq\omega_i^f &&\forall i,f,\\
+ &\sum_iy_{ij}^f\leq C_j^f &&\forall j,f.
+\end{align}
+Its demand constraints are inequalities and its outside option has value zero.
+Consequently a nonpositive candidate edge is never needed by an optimum; at a
+dual iterate the implemented buyer response is stricter still and participates
+only when $a_{ij}^f-\lambda_j^f>0$.
+
+\subsection{Lagrangian relaxation and coordination algorithm}
+Relaxing seller capacities with multipliers $\lambda_j^f\geq0$ gives the exact
+dual function
+\begin{equation}
+ g(\lambda)=\sum_{j,f}\lambda_j^fC_j^f+
+ \sum_{i,f}\omega_i^f\max\!\left\{0,\max_{j\in A_i^f}
+ (a_{ij}^f-\lambda_j^f)\right\}.
+\end{equation}
+Each buyer therefore sends all uncapped demand to its strictly positive
+price-adjusted best seller, breaking ties by seller index. This uncapped
+response supplies demand $D_j^f$ and the dual bound; capacity-capped bids rank
+all positive sellers and feed the same greedy, score-ranked capacity fill used
+to evaluate \textsc{FaaS-MADiG}. Prices follow
+$\lambda_j^f\leftarrow[\lambda_j^f+\alpha_k(D_j^f-C_j^f)]^+$.
+The implementation supports $\alpha_k=\alpha_0/\sqrt{k}$ and a gap-based choice
+$\alpha_k=\theta[UB-LB]^+/\|D-C\|_2^2$, taking zero when the denominator is
+zero. It rejects fewer than one inner iteration and any step rule other than
+\texttt{sqrt} or \texttt{polyak}. The latter label is implementation
+terminology: because it substitutes the incumbent $UB-LB$ gap for a known
+optimal value, it is a practical Polyak-like heuristic rather than the
+classical Polyak step.
+
+\begin{algorithm}[H]
+\caption{One \textsc{FaaS-MALD} dual coordination round}
+\label{alg:mald}
+\begin{algorithmic}[1]
+\Require $\omega,C$, data, neighbourhood, $\rho$, options, latency, fairness
+\State validate options, raising \texttt{ValueError} unless: $K$ is a positive
+  integer; $\texttt{step\_rule}\in\{\texttt{sqrt},\texttt{polyak}\}$; the numeric
+  options $\{\alpha_0,\theta,\texttt{gap\_tolerance},w_{\mathrm{lat}},w_{\mathrm{fair}}\}$
+  are finite; $\alpha_0>0$ (\texttt{sqrt}) or $\theta>0$ (\texttt{polyak});
+  and $\texttt{gap\_tolerance}\ge 0$
+\State compute Cloud-relative advantages $a$ and eligibility mask $A$; copy $C$; set
+  $\lambda\gets0$, $\textit{best\_lam}\gets\lambda$, and $a^{0}_{ij}{}^f\gets a_{ij}^f$ on eligible edges, $0$ otherwise
+\State $\textit{best\_y}\gets0$, $LB\gets0$, $UB\gets+\infty$,
+  $\mathrm{lb\_history}\gets[,]$, gap $\gets0$, $k\gets0$
+\State $n_{\mathrm{active}}\gets|\{i:\exists f,\omega_i^f>0\}|$
+\For{$k=1,\ldots,K$}
+  \State initialize an empty bid table and seller-demand matrix $D$
+  \For{each active buyer-function pair $(i,f)$ with $\omega_i^f>0$}
+    \State traverse only eligible neighbours $j\in A_i^f$ and keep those with $a_{ij}^f-\lambda_j^f>0$
+    \State sort the surviving sellers by descending $a_{ij}^f-\lambda_j^f$, breaking ties by seller index
+    \State add $\omega_i^f$ to the uncapped demand of the best seller and accumulate the buyer dual term
+    \State greedily fill capacity-capped bids along the same ranking until $\omega_i^f$ is exhausted or sellers run out
+  \EndFor
+  \State $UB\gets\min\{UB,g(\lambda)\}$
+  \If{$g(\lambda)$ improved the incumbent upper bound}
+    \State $\textit{best\_lam}\gets\lambda$
+  \EndIf
+  \If{bids are nonempty}
+    \State evaluate bids with tentative replica starts disabled to recover feasible $y$
+    \State compute candidate $LB=\sum_{i,j,f}a^{0}_{ij}{}^fy_{ij}^f$;
+      if it improves $LB$, retain its value and set $\textit{best\_y}\gets y$
+  \EndIf
+  \State append incumbent $LB$ to $\mathrm{lb\_history}$ and set
+    gap $\gets(UB-LB)/\max\{1,|UB|\}$
+  \If{$(UB-LB)/\max\{1,|UB|\}$ is within tolerance} \State \textbf{break} \EndIf
+  \If{$\sum_{j,f}D_j^f\leq0$ and bids are empty} \State \textbf{break} \EndIf
+  \State set subgradient $q\gets D-C$; select the configured square-root or
+    Polyak step $\alpha_k$; update $\lambda\gets[\lambda+\alpha_kq]^+$
+\EndFor
+\State $\textit{final\_lam}\gets\lambda$ and $\mathrm{placed}\gets\sum_j \textit{best\_y}_{ij}^f$
+\State initialize an empty memory-bid table
+\For{every $(i,f)$ with $\omega_i^f>0$}
+  \If{$\mathrm{placed}_i^f<\omega_i^f$}
+    \State emit a bid to every neighbour $j$ whose $\rho_j$ meets $f$'s memory requirement
+  \EndIf
+\EndFor
+\State $\mathrm{gap\_info}\gets\{LB,UB,\mathrm{gap},
+  \mathrm{inner\_iterations}:k,\textit{final\_lam},\textit{best\_lam},\mathrm{lb\_history}\}$
+\State \Return $(\textit{best\_y},\mathrm{memory\_bids},\mathrm{gap\_info},n_{\mathrm{active}})$
+\end{algorithmic}
+\end{algorithm}
+
+\subsection{Fixed-capacity certificate, convergence, and cost}
+For one inner transportation LP with $\omega$, $C$, scores, and eligibility
+held fixed, weak duality makes every dual value an upper bound, while the
+non-tentative greedy recovery is feasible for that same $C$ and supplies a
+lower bound. Its stored $LB/UB$ pair therefore remains a valid certificate for
+the retained feasible incumbent of that inner LP after a gap stop, an
+empty-response stop, or the iteration limit. It is not a certificate for the
+complete accepted end-to-end run, the outer loop as capacities change, or the
+final operational assignment. In the shipped runner, outer memory bids are the
+only replica mechanism: the inner routine returns $\textit{best\_y}$ plus a
+memory-bid table, and the outer loop may then start additional replicas and
+refresh capacity before the next stopping check. The file
+\texttt{coordination\_certificate.csv} records one row per outer iteration with
+\texttt{timestep}, \texttt{outer\_iteration}, \texttt{LB}, \texttt{UB},
+\texttt{gap}, \texttt{inner\_iterations}, and \texttt{stop\_reason}; those rows
+certify only the fixed-capacity inner LP solved during that outer iteration.
+
+For diminishing subgradient steps satisfying the standard hypotheses,
+including the required summability conditions and bounded subgradients,
+classical results apply to the fixed LP dual; LP strong duality makes its primal
+and dual optimal values coincide. Primal recovery or averaging is still needed
+for convergent feasible primal solutions \citep{nedic2009,bertsekas1989}. This
+qualified statement applies to suitable diminishing sequences, not
+automatically to both implemented rules. In particular, the implemented
+``polyak'' rule uses $\theta(UB-LB)/\lVert D-C\rVert_2^2$ with incumbent bounds,
+not the classical formula with a known optimum, and has no unconditional
+convergence guarantee here.
+
+Per inner iteration, evaluating scores and eligibility over the neighbour graph
+costs $O(|E||\mathcal F|)$. Ranking eligible neighbours in the buyer response
+costs $O(\sum_{i,f}|A_i^f|\log|A_i^f|)$. If $b_j^f$ is
+the number of bids incident on seller $j$ for function $f$, the shipped
+evaluator filters bids by seller and function and sorts each nonempty incident
+set, giving a transparent bound of
+$O(\sum_{j,f}(|B|+b_j^f\log b_j^f))$ for its repeated filtering and sorting,
+where $|B|$ is the round's total bid count. Messages occupy
+$O(|E||\mathcal F|)$ scalars, and all exchanges are one hop.
+
+\subsection{Positioning with respect to the literature}
+The multiplier exchange is classical dual decomposition with projected
+subgradient prices, and the qualified convergence and primal-recovery caveats
+follow distributed optimization theory \citep{bertsekas1989,nedic2009}.
+This differs from the $\varepsilon$-auction lineage underlying
+\textsc{FaaS-MADeA}, where prices arise from competitive bids for assignment
+objects \citep{bertsekas1988}. It also belongs to the broader family of
+decentralized, price- or market-mediated edge offloading schemes, while retaining
+the one-hop service-placement setting studied for edge-to-cloud load balancing
+\citep{nezami2021}.
diff --git a/faas-mald-note/main.tex b/faas-mald-note/main.tex
new file mode 100644
index 0000000..2efee8f
--- /dev/null
+++ b/faas-mald-note/main.tex
@@ -0,0 +1,20 @@
+% Standalone preview wrapper for faas-mald.tex.
+% This file exists ONLY to compile a self-contained PDF of the section.
+% When inserting into the paper, do NOT use this wrapper: just
+%   \input{faas-mald}
+% (or paste its content) into the paper, which already defines the notation.
+\documentclass[11pt]{article}
+\usepackage[margin=1in]{geometry}
+\usepackage{amsmath,amssymb}
+\usepackage{algorithm}
+\usepackage[noend]{algpseudocode}
+\usepackage{booktabs}
+\usepackage[numbers]{natbib}
+\usepackage[hidelinks]{hyperref}
+
+\begin{document}
+\input{faas-mald}
+
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-mald-note/references.bib b/faas-mald-note/references.bib
new file mode 100644
index 0000000..ff2d74f
--- /dev/null
+++ b/faas-mald-note/references.bib
@@ -0,0 +1,41 @@
+% References for the FaaS-MALD positioning subsection.
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@article{nedic2009,
+  author  = {Angelia Nedi\'c and Asuman Ozdaglar},
+  title   = {Approximate Primal Solutions and Rate Analysis for Dual Subgradient Methods},
+  journal = {SIAM Journal on Optimization},
+  volume  = {19},
+  number  = {4},
+  pages   = {1757--1780},
+  year    = {2009},
+  doi     = {10.1137/070708856}
+}
+
+@book{bertsekas1989,
+  author    = {Dimitri P. Bertsekas and John N. Tsitsiklis},
+  title     = {Parallel and Distributed Computation: Numerical Methods},
+  publisher = {Prentice-Hall},
+  address   = {Englewood Cliffs, NJ},
+  year      = {1989}
+}
+
+@article{nezami2021,
+  author  = {Zeinab Nezami and Kamran Zamanifar and Karim Djemame and Evangelos Pournaras},
+  title   = {Decentralized Edge-to-Cloud Load Balancing: Service Placement for the Internet of Things},
+  journal = {IEEE Access},
+  volume  = {9},
+  pages   = {64983--65000},
+  year    = {2021},
+  doi     = {10.1109/ACCESS.2021.3074962}
+}
diff --git a/faas-mapg-note/.gitignore b/faas-mapg-note/.gitignore
new file mode 100644
index 0000000..ab6921a
--- /dev/null
+++ b/faas-mapg-note/.gitignore
@@ -0,0 +1,10 @@
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+*.synctex.gz
+*.toc
+*.bbl
+*.blg
+main.pdf
diff --git a/faas-mapg-note/README.md b/faas-mapg-note/README.md
new file mode 100644
index 0000000..78e83b9
--- /dev/null
+++ b/faas-mapg-note/README.md
@@ -0,0 +1,39 @@
+# FaaS-MAPG technical note
+
+A paper-ready LaTeX section describing **FaaS-MAPG** (Multi-Agent Potential
+Game) --- the sequential better-response coordination scheme in
+`decentralized_potentialgame.py` --- as an exact potential game with a
+certified $\varepsilon$-Nash equilibrium stopping condition, in the notation
+of `Decentralized_FaaS_coordination.pdf`.
+
+## Files
+- `faas-mapg.tex` --- the `\section{}` to `\input{}` (or paste) into the
+  paper. Covers the game formulation, the exact-potential proposition, the
+  proposal-MILP + greedy-split + $\varepsilon$-acceptance move rule, the
+  finite-termination / equilibrium-certificate theorem (explicitly scoped to
+  the implemented move class), the reused memory market, the S/R variants,
+  the three stopping reasons, and positioning against FaaS-MABR, FaaS-MALD,
+  and the potential-game literature. Remove the self-contained "Notation and
+  capacity model" subsection on insertion.
+- `main.tex` --- standalone preview wrapper.
+- `references.bib` --- cited works: Monderer & Shapley 1996 (potential
+  games), Rosenthal 1973 (congestion games), plus the auction/dual-
+  decomposition references shared with the FaaS-MADeA/FaaS-MALD notes.
+- `.gitignore` --- LaTeX build artifacts.
+
+## Build a preview
+```bash
+cd faas-mapg-note
+latexmk -pdf main.tex
+```
+
+## Insert into the paper
+1. `\input{faas-mapg}` (or paste the section).
+2. Delete the "Notation and capacity model" subsection.
+3. Convert plain-text cross-references to the host paper's `\ref{}` labels.
+4. Merge `references.bib` into the paper's bibliography.
+5. The section requires `amsmath`, `amssymb`, `amsthm` (for the
+   `proposition`/`theorem`/`proof` environments), `booktabs`, `algorithm`,
+   `algpseudocode`, and `natbib`; define the `proposition`/`theorem`
+   environments with `\newtheorem` if the host paper does not already have
+   them (or rename to match the paper's own theorem environments).
diff --git a/faas-mapg-note/faas-mapg.tex b/faas-mapg-note/faas-mapg.tex
new file mode 100644
index 0000000..d4eca87
--- /dev/null
+++ b/faas-mapg-note/faas-mapg.tex
@@ -0,0 +1,428 @@
+% =====================================================================
+% FaaS-MAPG: sequential better-response dynamics of an exact potential
+% game, with an epsilon-Nash certificate.
+% Meant to be \input{} (or pasted) into the paper. Assumes the paper's
+% notation (N, F, C_i^f, rho_i, omega_i^f, beta_{ij}^f, gamma_i^f, ...).
+% Cross-references are plain text; convert to \ref{} in the host paper.
+% =====================================================================
+
+\section{FaaS-MAPG: multi-agent potential-game better response}
+\label{sec:mapg}
+
+\textsc{FaaS-MAPG} (Multi-Agent Potential Game) revisits the same
+Gauss-Seidel sweep skeleton as \textsc{FaaS-MABR}, but replaces the
+score-greedy, commit-always response with a response rule chosen so that the
+sum of node utilities is an \emph{exact potential function}: every accepted
+unilateral move raises the sum by exactly the mover's utility gain. This is
+qualitatively different from the two other coordination families in this
+paper. \textsc{FaaS-MADeA} and \textsc{FaaS-MALD} coordinate through prices
+(an $\varepsilon$-auction and a Lagrangian dual, respectively) and their
+certificates bound a fixed-capacity inner problem, not the joint outer game.
+\textsc{FaaS-MABR} is a greedy heuristic: nothing prevents a sweep from
+lowering the objective, and it offers no equilibrium notion. \textsc{FaaS-MAPG}
+instead accepts a move only when it strictly improves the mover's own utility
+by more than a tolerance $\varepsilon>0$, which (Proposition~\ref{prop:mapg-potential})
+makes the welfare function $\Phi=\sum_i u_i$ increase by exactly the same
+amount, is monotonically non-decreasing, and yields a finite-time certificate
+(Theorem~\ref{thm:mapg-termination}) that the terminal state is an
+$\varepsilon$-Nash equilibrium with respect to the implemented move class.
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% Reproduces the relevant rows of the paper's Table 2 (FRALB) and Table 3
+% (auction) plus Eqs. (1),(2),(12),(13), so the note is readable on its own.
+% REMOVE this whole subsection when inserting into the paper, where the
+% notation and these equations are already defined.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:mapg-notation}
+
+Each control period $t$ runs coordination iterations (\emph{sweeps})
+$h=0,1,\dots,H_{\max}$. Before coordination, every node $i$ solves a local
+problem~(P2) that, for each function $f\in\mathcal{F}_i$, splits the incoming
+workload $\lambda_i^f$ into locally processed load $x_i^f$, horizontally
+offloaded demand $\omega_i^f$, and Cloud-forwarded load $z_i^f$, and fixes the
+number of replicas $r_i^f$. Replicas obey the memory budget and provide
+capacity
+\begin{equation}
+  \sum_{f\in\mathcal{F}_i} r_i^f\,\mathrm{RAM}^f \le \mathrm{RAM}_i,
+  \qquad
+  \mathrm{Cap}_i^f = \frac{r_i^f\,U^f_{\max}}{D_i^f}\ \text{[req/s]} ,
+  \tag{1,2}
+\end{equation}
+from which each node advertises, on a neighbour-accessible blackboard, its
+residual execution capacity and its memory slack:
+\begin{equation}
+  C_i^f(h) = \max\!\big\{0,\ \mathrm{Cap}_i^f(h) - x_i^f(h)\big\},
+  \qquad
+  \rho_i(h) = \mathrm{RAM}_i - \sum_{f\in\mathcal{F}_i} r_i^f(h)\,\mathrm{RAM}^f \ge 0 .
+  \tag{12,13}
+\end{equation}
+Table~\ref{tab:mapg-notation} collects the symbols used below.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in this section (subset of the paper's Tables~2--3).}
+\label{tab:mapg-notation}
+\small
+\begin{tabular}{@{}l l p{0.6\linewidth}@{}}
+\toprule
+\multicolumn{3}{@{}l}{\textit{Sets and players}}\\
+Nodes / neighbours & $\mathcal{N}$, $N_i$ & computing nodes, treated as players; one-hop neighbours of $i$.\\
+Functions & $\mathcal{F}_i$ & functions deployable on $i$; $\mathcal{F}=\bigcup_i \mathcal{F}_i$.\\
+Move order & $\sigma$ & the sweep's visiting order over $\mathcal{N}$ (fixed or a per-sweep random permutation).\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Parameters and weights}}\\
+Input workload & $\lambda_i^f$ & incoming request rate for $f$ at $i$ [req/s]; also the utility normalizer.\\
+Memory cap / demand & $\mathrm{RAM}_i$, $\mathrm{RAM}^f$ & node memory; per-replica memory of $f$ [MB].\\
+Service demand & $D_i^f$ & average execution time of $f$ at $i$ [s].\\
+Max utilization & $U^f_{\max}$ & stability threshold, $U^f_{\max}\in[0,1)$.\\
+Local / offload / Cloud profit & $\alpha_i^f$, $\beta_{ij}^f$, $\gamma_i^f$ & profit of local exec.; profit of offloading $i\!\to\! j$; Cloud-offloading penalty (per req/s).\\
+Acceptance tolerance & $\varepsilon>0$ & minimum utility gain required to commit a move.\\
+Max iterations / time limit & $H_{\max}$, $T_{\max}$ & sweep and wall-clock stop guards.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Strategy and state at sweep $h$}}\\
+Node strategy & $s_i=(r_i,x_i,\omega_i,y_{i\cdot})$ & replicas, local load, offloading target, and outbound routing row.\\
+Replicas & $r_i^f$ & number of $f$ replicas on $i$, $r_i^f\in\mathbb{N}_0$.\\
+Local / forwarded / Cloud load & $x_i^f$, $y_{ij}^f$, $z_i^f$ & locally served; forwarded $i\!\to\! j$; Cloud-offloaded [req/s].\\
+Committed inbound & $\bar y_{mi}^f$ & the current $y_{mi}^f$ of every node $m\ne i$, frozen while $i$ moves.\\
+Accessible capacity cap & $\omega_i^{\mathrm{ub},f}$ & the residual capacity $i$ may claim from its neighbours in this move.\\
+Capacity / residual / slack & $\mathrm{Cap}_i^f$, $C_i^f$, $\rho_i$ & exec.\ capacity (Eq.~2); residual exec.\ capacity (Eq.~12); memory slack (Eq.~13).\\
+Node utility & $u_i$ & node $i$'s share of the centralized FRALB objective (Eq.~\eqref{eq:mapg-utility}).\\
+Potential / welfare & $\Phi$ & $\Phi=\sum_i u_i$, the centralized objective; the exact potential (Prop.~\ref{prop:mapg-potential}).\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{Game formulation}
+\label{sec:mapg-game}
+
+Players are the nodes $\mathcal{N}$. Node $i$'s strategy is
+$s_i=(r_i,x_i,\omega_i,y_{i\cdot})$: its replica counts, locally served load,
+offloading target, and the row $y_{i\cdot}^f=(y_{ij}^f)_{j\in N_i}$ of load it
+routes to neighbours (Cloud-forwarded load $z_i^f$ is not a free coordinate;
+it is the flow-conservation residual $z_i^f=\max\{0,\ell_i^f-x_i^f-\sum_j y_{ij}^f\}$
+of $i$'s own served load $\ell_i^f$). Node $i$'s utility is its share of the
+centralized FRALB objective, i.e. the terms of the objective that depend on
+$i$'s own coordinates:
+\begin{equation}
+  u_i(s) = \sum_{f\in\mathcal{F}_i}
+    \frac{\alpha_i^f x_i^f + \sum_{j\in N_i}\beta_{ij}^f y_{ij}^f - \gamma_i^f z_i^f}
+         {\lambda_i^f}.
+  \label{eq:mapg-utility}
+\end{equation}
+Summing $u_i$ over all nodes recovers exactly the centralized objective
+$\Phi(s)=\sum_i u_i(s)$: each $(\alpha,\beta,\gamma)$-weighted term is counted
+once, against the node that owns the corresponding row of $x$, $y$, or $z$.
+
+\paragraph{Unilateral-move rules.} A move by node $i$ changes only $i$'s
+strategy $s_i$; every other node's strategy $s_{-i}$, including its outbound
+row $y_{m\cdot}$ for $m\ne i$, is held fixed. Two rules make this well
+defined and keep $\Phi$ an exact potential:
+\begin{enumerate}
+\item \textbf{Inbound commitments are kept.} Load already routed to $i$ by
+  other nodes, $\bar y_{mi}^f$ for $m\ne i$, must still be served by $i$ after
+  the move; $i$'s local problem enforces $D_i^f\big(x_i^f+\sum_m \bar y_{mi}^f\big)\le r_i^f U_{\max}^f$
+  (utilization constraints \texttt{utilization\_equilibrium\_pg} /
+  \texttt{\_2\_pg} of \texttt{LSP\_pg} in \texttt{models/sp.py}), so a move
+  can never strand another node's already-placed load.
+\item \textbf{Only advertised residual capacity is claimable, and $i$'s own
+  row is released first.} Before computing $i$'s move, $i$'s current outbound
+  row $y_{i\cdot}$ is zeroed out of the residual-capacity ledger (so $i$ does
+  not compete with the capacity it is about to give up), and $i$ is capped to
+  the resulting residual capacity of eligible neighbours,
+  $\omega_i^{\mathrm{ub},f}=\sum_{j\in N_i:\ \beta_{ij}^f>-\gamma_i^f}\tilde C_j^f$,
+  enforced by the \texttt{cap\_offloading} constraint $\omega_i^f\le\omega_i^{\mathrm{ub},f}$.
+\item \textbf{No ping-pong (FRALB feasibility).} FRALB forbids a node from
+  simultaneously sending and receiving the same function. Accordingly, a
+  neighbour $j$ currently offloading $f$ (i.e., $\sum_k y_{jk}^f>0$) is
+  excluded from the seller set for $f$, and the mover sets
+  $\omega_i^{\mathrm{ub},f}=0$ for every $f$ it holds inbound commitments
+  for ($\sum_m \bar y_{mi}^f>0$). Since $y=0$ initially, these two rules
+  inductively keep every intermediate state ping-pong-free. Both only
+  shrink the feasible move set, so the exact-potential argument below is
+  unaffected.
+\end{enumerate}
+Because $i$'s move only ever reallocates $i$'s own row $y_{i\cdot}$ within
+capacity every other node has already advertised as unused, and every other
+node's coordinates $s_{-i}$ (including $\bar y_{mi}$, which $i$ must
+continue to serve) are literally unchanged by the move, no other node's
+utility term changes: $u_m(s_i',s_{-i})=u_m(s_i,s_{-i})$ for all $m\ne i$.
+
+\subsection{Exact potential}
+\label{sec:mapg-potential}
+
+\begin{proposition}[FaaS-MAPG is an exact potential game]
+\label{prop:mapg-potential}
+Under the unilateral-move rules of \S\ref{sec:mapg-game}, the welfare function
+$\Phi(s)=\sum_{k\in\mathcal{N}} u_k(s)$ is an exact potential for the game:
+for every node $i$, every strategy profile $s$, and every unilateral
+deviation $s_i'$,
+\[
+  \Phi(s_i',s_{-i}) - \Phi(s_i,s_{-i}) = u_i(s_i',s_{-i}) - u_i(s_i,s_{-i}).
+\]
+\end{proposition}
+\begin{proof}
+Write $\Phi(s_i,s_{-i})=u_i(s_i,s_{-i})+\sum_{m\ne i}u_m(s_i,s_{-i})$ and
+likewise for $\Phi(s_i',s_{-i})$. Subtracting,
+\[
+  \Phi(s_i',s_{-i})-\Phi(s_i,s_{-i})
+  = \big[u_i(s_i',s_{-i})-u_i(s_i,s_{-i})\big]
+  + \sum_{m\ne i}\big[u_m(s_i',s_{-i})-u_m(s_i,s_{-i})\big].
+\]
+Each $u_m$, $m\ne i$, is a function of $m$'s own coordinates
+$(x_m,y_{m\cdot},z_m)$ only (Eq.~\eqref{eq:mapg-utility}). A unilateral move
+by $i$ leaves $s_{-i}$ untouched by construction, and rule~1 guarantees that
+$m$'s served load $\bar y_{mi}^f$ from $i$'s row, hence $m$'s own $x_m$,
+$y_{m\cdot}$, $z_m$, do not have to and do not change to remain feasible
+(the move only reduces or reallocates what $i$ sends, which $m$ does not
+own). Consequently $u_m(s_i',s_{-i})=u_m(s_i,s_{-i})$ for every $m\ne i$, the
+sum of differences vanishes, and
+$\Phi(s_i',s_{-i})-\Phi(s_i,s_{-i})=u_i(s_i',s_{-i})-u_i(s_i,s_{-i})$.
+\end{proof}
+
+This is the FaaS instance of the standard construction of an exact potential
+game from an additively separable global objective in which each player's
+payoff is exactly its own contribution to that objective
+\citep{monderershapley1996}; the resulting $\Phi$ coincides with the FRALB
+welfare, and the game is, structurally, a congestion-style game over shared
+capacity resources in the sense of \citet{rosenthal1973}, restricted here to
+the implemented move class rather than unrestricted resource choice.
+
+\subsection{Move rule: proposal MILP, exact split, and $\varepsilon$-acceptance}
+\label{sec:mapg-move}
+
+A single node move (function \texttt{node\_move} in
+\texttt{decentralized\_potentialgame.py}) has three stages.
+
+\paragraph{1. Proposal MILP.} Node $i$ re-solves its local problem
+(\texttt{LSP\_pg}, or \texttt{LSP\_pg\_fixedr} when replicas are pinned to a
+reference plan) with committed inbound flows $\bar y_{mi}^f$ fixed as a
+parameter and the offloading target capped at $\omega_i^{\mathrm{ub},f}$
+(\S\ref{sec:mapg-game}). This MILP is \emph{P2 with committed inbound and a
+capacity cap}: it prices the aggregate offload $\omega_i^f$ using the same
+weighted objective as~(P2), i.e.\ it treats every unit of $\omega_i^f$ as
+interchangeable rather than pricing each destination pair $\beta_{ij}^f$
+individually. Its output is a proposed $x_i$, $r_i$, and offload amount
+$\omega_i$; it does \emph{not} decide the destination split.
+
+\paragraph{2. Fractional-knapsack split by descending $\beta$.} The proposed
+$\omega_i^f$ is placed into a routing row by \texttt{split\_omega}: eligible
+neighbours $j$ (those with $\beta_{ij}^f>-\gamma_i^f$ and unused ledger
+capacity) are ranked by descending true pair-specific profit $\beta_{ij}^f$,
+ties broken by ascending node index $j$, and filled greedily up to each
+neighbour's remaining ledger capacity until $\omega_i^f$ is exhausted or
+sellers run out; any residual is left to the Cloud ($z_i^f$). Because the
+per-unit payoff $\beta_{ij}^f$ is fixed and the feasible region is a simple
+capacity knapsack (a matroid / linear-program vertex problem), this greedy
+split is the exact utility-maximizing response to the proposed aggregate
+$\omega_i^f$: no other split of the same total achieves a strictly higher
+$\sum_j\beta_{ij}^fy_{ij}^f$ term of $u_i$.
+
+\paragraph{3. $\varepsilon$-acceptance on the true
+utility.} Only after the split is constructed is the candidate utility $u_i$
+recomputed (\texttt{compute\_node\_utility}, using the true per-pair
+$\beta_{ij}^f$, unlike the proposal MILP's aggregate pricing) and compared to
+the utility of $i$'s current strategy. The move is committed to $(x,y,r)$
+iff $\Delta u_i = u_i^{\mathrm{new}}-u_i^{\mathrm{old}} > \varepsilon$;
+otherwise $i$'s strategy is left unchanged for this sweep. This is why the
+proposal MILP's aggregate pricing does not compromise Proposition~\ref{prop:mapg-potential}:
+acceptance is gated on the true, exactly-decomposed $u_i$, not on the
+proposal's own objective value.
+
+\begin{algorithm}[H]
+\caption{\textsc{FaaS-MAPG} --- one better-response sweep}
+\label{alg:mapg-sweep}
+\begin{algorithmic}[1]
+\Require state $(x,y,r)$, ledger seed $C(h)$, order $\sigma$, tolerance $\varepsilon$
+\State $n_{\mathrm{accepted}}\gets 0$, $\Delta\Phi\gets 0$, memory bids $\gets\emptyset$
+\For{each node $i$ in order $\sigma$}
+  \State $u_i^{\mathrm{old}}\gets u_i(x,y,z(x,y))$
+  \State release $i$'s own row: $y_{i\cdot}\gets0$ in a working copy; rebuild ledger $\tilde C$ from that copy
+  \State $\omega_i^{\mathrm{ub},f}\gets\sum_{j\in N_i:\beta_{ij}^f>-\gamma_i^f}\tilde C_j^f$ for all $f$
+  \State solve proposal MILP (\texttt{LSP\_pg}) with $\bar y_{\cdot i}$ fixed and cap $\omega_i^{\mathrm{ub}}$; obtain $x_i',r_i',\omega_i'$
+  \State $y_{i\cdot}'\gets\textsc{SplitOmega}(\omega_i',\tilde C)$: descending $\beta_{ij}^f$, ties by ascending $j$
+  \State $u_i^{\mathrm{new}}\gets u_i(x',y',z(x',y'))$ with $x_i\gets x_i',\,y_{i\cdot}\gets y_{i\cdot}'$
+  \If{$u_i^{\mathrm{new}}-u_i^{\mathrm{old}}>\varepsilon$}
+    \State commit $x_i\gets x_i'$, $y_{i\cdot}\gets y_{i\cdot}'$, $r_i\gets r_i'$;\quad $n_{\mathrm{accepted}}{+}{+}$;\quad $\Delta\Phi\mathrel{+}=u_i^{\mathrm{new}}-u_i^{\mathrm{old}}$
+  \EndIf
+  \State for every $f$ with $\max\{\omega_i'^f-\sum_j y_{ij}'^f,\ z_i'^f\}>\text{tol}$ and no inbound commitment, emit memory bids to neighbours $j$ with $\rho_j\ge\mathrm{RAM}^f$ and $\beta_{ij}^f>-\gamma_i^f$
+\EndFor
+\State \Return $n_{\mathrm{accepted}}$, $\Delta\Phi$, memory bids
+\end{algorithmic}
+\end{algorithm}
+
+The outer loop (\texttt{potential\_game\_sweep} inside the per-timestep loop
+of \texttt{decentralized\_potentialgame.py}) repeats the sweep, starts
+replicas from any collected memory bids (\S\ref{sec:mapg-memory}), and checks
+the stopping condition (\texttt{check\_pg\_stopping}) after each sweep.
+
+\subsection{Finite termination and $\varepsilon$-Nash certificate}
+\label{sec:mapg-termination}
+
+\begin{theorem}[Finite termination at an $\varepsilon$-Nash equilibrium]
+\label{thm:mapg-termination}
+Let $\Phi_0$ be the potential of the initial state and let
+$\Phi_{\max}<\infty$ be any finite upper bound on $\Phi$ over the run's
+feasible region (finite since $x,y,z,r$ are bounded by finite loads,
+capacities, and memory). Under the move rules of \S\ref{sec:mapg-game} and
+the acceptance rule of \S\ref{sec:mapg-move}:
+\begin{enumerate}
+\item the number of \emph{accepted} moves over the whole run is at most
+  $(\Phi_{\max}-\Phi_0)/\varepsilon$;
+\item the number of replica-expansion events (\S\ref{sec:mapg-memory}) is
+  finite, bounded by $\sum_i\lfloor \mathrm{RAM}_i/\min_f\mathrm{RAM}^f\rfloor$
+  total replicas system-wide;
+\item hence, absent the max-iterations or time-limit guards, the algorithm
+  terminates after finitely many sweeps at a sweep with zero accepted moves
+  and zero new replicas, and the terminal state $s^\star$ is an
+  $\varepsilon$-Nash equilibrium with respect to the implemented move class:
+  for every node $i$, the move that \emph{stage 1--2 of \S\ref{sec:mapg-move}
+  would propose} from $s^\star$ satisfies $u_i(s_i',s_{-i}^\star)-u_i(s^\star)\le\varepsilon$.
+\end{enumerate}
+\end{theorem}
+\begin{proof}
+(1) By Proposition~\ref{prop:mapg-potential}, an accepted move by $i$
+satisfies $\Phi(s')-\Phi(s)=u_i(s')-u_i(s)>\varepsilon$, so $\Phi$ strictly
+increases by more than $\varepsilon$ at every accepted move and is
+non-decreasing at every rejected move (rejected moves leave the state, hence
+$\Phi$, unchanged). Since $\Phi$ starts at $\Phi_0$ and is bounded above by
+$\Phi_{\max}$, at most $(\Phi_{\max}-\Phi_0)/\varepsilon$ accepted moves can
+occur before $\Phi$ would have to exceed $\Phi_{\max}$; the count is hence
+finite and bounded by that quantity.
+(2) Each replica-expansion event (\texttt{start\_additional\_replicas},
+reused unchanged from \textsc{FaaS-MADeA}) consumes strictly positive memory
+slack $\rho_j$ at some node $j$ and never removes a replica, so the total
+number of replicas placed system-wide is monotonically non-decreasing and
+bounded above by the total memory divided by the smallest per-function
+memory footprint; expansion events are therefore finite in number. Because
+$\Phi$ is the centralized objective and replicas only ever relax capacity
+constraints for subsequent moves (they do not change $x,y,z$ of the sweep
+that placed them), an expansion event does not decrease $\Phi$.
+(3) Both accepted moves and replica expansions are finite in number and each
+sweep with neither is a fixed point of \texttt{check\_pg\_stopping}
+(condition \texttt{n\_accepted == 0 and n\_new\_replicas == 0}), so, absent
+the two runtime guards, some finite sweep reaches this fixed point (each
+non-fixed-point sweep strictly advances one of the two finite counters). At
+that terminal state $s^\star$, sweep~\S\ref{sec:mapg-move} was run for every
+node and rejected the proposed move, i.e.\ $u_i(s_i',s_{-i}^\star)-u_i(s^\star)\le\varepsilon$
+for the specific $s_i'$ that stages 1--2 constructed from $s^\star$ for every
+$i$; this is the definition of an $\varepsilon$-Nash equilibrium restricted
+to deviations reachable by that move class.
+\end{proof}
+
+\paragraph{Scope of the certificate.} The certificate in part~3 is honest
+about what it does \emph{not} claim: it is not an $\varepsilon$-Nash
+equilibrium of the unrestricted game (arbitrary $s_i'$), only with respect to
+the specific move class implemented --- the MILP proposal of stage~1 (which
+prices aggregate offloading, not per-pair $\beta$) composed with the greedy
+split of stage~2. A node might in principle find a strategy outside this
+move class (e.g. a split that is not the descending-$\beta$ knapsack applied
+to the MILP's own $\omega_i$, or a jointly different $(x_i,\omega_i)$ pair
+that the aggregate-priced MILP does not surface) with a strictly larger
+utility gain. The greedy split (stage~2) is exact given the proposed
+$\omega_i$, so the residual freedom is entirely in whether the proposal MILP
+explores the same $(x_i,\omega_i)$ vertex a per-pair-$\beta$-aware
+formulation would; this is the same aggregation gap discussed for the
+\textsc{FaaS-MADiG}/\textsc{FaaS-MABR} local problem~(P2) elsewhere in the
+paper. In practice, when the max-iterations or time-limit guard fires first,
+\texttt{check\_pg\_stopping} reports that reason instead and the run carries
+no equilibrium certificate for that timestep.
+
+\subsection{Memory market}
+\label{sec:mapg-memory}
+
+Unplaced appetite after the fractional-knapsack split triggers the same
+memory-bid mechanism as \textsc{FaaS-MADeA}. Because the proposal MILP is
+capped at the currently advertised residual capacity, unmet demand is read
+from \emph{both} scarcity signals: the unplaced split residue
+$\omega_i'^f-\sum_j y_{ij}'^f$ and the Cloud-forwarded residue $z_i^f$ of the
+candidate state (load the node would rather offload than reject, since
+$\delta_i^f>0>-\gamma_i^f$) — without the $z$-signal a saturated
+neighbourhood would never grow and coordination would stall at the initial
+residual capacity. For every such $f$ (excluding functions held as inbound
+commitments, which the mover can never offload), node $i$ bids to every
+neighbour $j$ with unused memory slack $\rho_j\ge\mathrm{RAM}^f$ and
+$\beta_{ij}^f>-\gamma_i^f$; \texttt{start\_additional\_replicas} allocates new
+replicas at bid-receiving sellers proportionally to demand fraction, subject
+to $\rho_j$. Two properties transfer unchanged from \textsc{FaaS-MADeA} and
+matter for Theorem~\ref{thm:mapg-termination}: (i) the market is
+\emph{memory-bounded} — replicas are only ever added within $\rho_j\ge0$, so
+the process cannot run indefinitely; and (ii) the market is
+\emph{$\Phi$-invariant} in the sense of never decreasing $\Phi$ — a seller
+who opens a new replica does so purely to relax a capacity constraint seen by
+some other node's future proposal MILP, and the transaction has no direct
+$\beta$-weighted utility term for the seller itself, so a selfish seller has
+no incentive to open a replica on its own account and no disincentive
+against doing so when bid (the reward, if any, accrues to the buyer's
+$\beta_{ij}^f y_{ij}^f$ term in a later sweep, not to the seller's utility
+directly). The mechanism is therefore reused as an exogenous capacity-relief
+step layered on top of the potential-game dynamics, not itself a move subject
+to $\varepsilon$-acceptance.
+
+\subsection{The two variants}
+\label{sec:mapg-variants}
+
+\textsc{FaaS-MAPG-S} sweeps nodes in a fixed ascending order (deterministic,
+reproducible). \textsc{FaaS-MAPG-R} draws a fresh random node permutation
+each sweep from a per-run generator seeded once. Both variants share the same
+move rule, acceptance test, and termination guarantee: the order only affects
+\emph{which} sequence of moves is realized and hence the specific
+$\varepsilon$-Nash equilibrium reached (potential games can have multiple
+equilibria), not whether termination and the certificate hold.
+
+\subsection{Stopping conditions}
+\label{sec:mapg-stopping}
+
+\texttt{check\_pg\_stopping} reports exactly one of three reasons per
+timestep, checked in order: (i) \texttt{"max iterations reached"} if the
+sweep count reaches the configured cap; (ii) \texttt{"reached time limit"} if
+accumulated wall-clock/solver runtime exceeds the configured limit; (iii)
+\texttt{"epsilon-Nash equilibrium certified"} if a sweep accepts zero moves
+and starts zero new replicas — the fixed point of
+Theorem~\ref{thm:mapg-termination}. Only reason (iii) carries the equilibrium
+certificate of \S\ref{sec:mapg-termination}; (i) and (ii) are runtime guards
+that may fire before the certificate is reached, in which case the run's
+terminal state carries no such guarantee.
+
+\subsection{Positioning with respect to the literature and the paper's other coordination families}
+\label{sec:mapg-related}
+
+\textsc{FaaS-MAPG} shares the Gauss-Seidel sequential-sweep skeleton with
+\textsc{FaaS-MABR}: both visit nodes in order $\sigma$, re-solve a capped
+local MILP, and place offload greedily by descending $\beta_{ij}^f$. The
+difference is entirely in the acceptance rule: \textsc{FaaS-MABR} commits the
+proposed move unconditionally (score-greedy, commit-always), which offers no
+monotonicity guarantee on the objective; \textsc{FaaS-MAPG} gates commitment
+on a strict, true-utility improvement, which (Proposition~\ref{prop:mapg-potential},
+Theorem~\ref{thm:mapg-termination}) makes $\Phi$ monotone non-decreasing and
+yields a finite-time, certified stopping condition that \textsc{FaaS-MABR}
+does not have.
+
+Against \textsc{FaaS-MALD}, the certificates answer different questions.
+\textsc{FaaS-MALD}'s $LB$/$UB$ pair (see the companion \texttt{faas-mald-note},
+\S\S~``Coordination transportation LP''--``Positioning with respect to the
+literature'') certifies optimality of one fixed-capacity inner
+transportation LP, re-derived every outer iteration as capacities change; it
+says nothing about the joint replica-and-routing strategy across the outer
+loop. \textsc{FaaS-MAPG}'s certificate is a game-theoretic equilibrium
+statement on exactly that joint strategy $(r_i,x_i,\omega_i,y_{i\cdot})_i$,
+persisting across sweeps rather than being re-certified per inner solve, at
+the cost of being restricted to the implemented move class rather than to
+all deviations.
+
+The exact-potential-game construction is standard once payoffs are chosen as
+each player's contribution to a shared, additively separable objective
+\citep{monderershapley1996}, and the underlying resource-sharing structure
+(nodes competing for shared, capacitated neighbour capacity) is the setting
+of congestion games \citep{rosenthal1973}, of which potential games are a
+generalization admitting best/better-response convergence and the
+finite-improvement property exploited by Theorem~\ref{thm:mapg-termination}.
+The auction-based literature underlying \textsc{FaaS-MADeA}
+\citep{bertsekas1988} and the dual-decomposition literature underlying
+\textsc{FaaS-MALD} \citep{bertsekas1989,nedic2009} both target a different
+certificate (price-based optimality of an inner allocation problem) rather
+than a Nash-equilibrium notion on the full decentralized game; \textsc{FaaS-MAPG}
+is, to our knowledge, the only family in this paper whose stopping condition
+is an explicit game-theoretic equilibrium certificate.
diff --git a/faas-mapg-note/main.tex b/faas-mapg-note/main.tex
new file mode 100644
index 0000000..632086e
--- /dev/null
+++ b/faas-mapg-note/main.tex
@@ -0,0 +1,19 @@
+% Standalone preview wrapper for the FaaS-MAPG note.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\newtheorem{proposition}{Proposition}
+\newtheorem{theorem}{Theorem}
+
+\begin{document}
+\input{faas-mapg}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-mapg-note/references.bib b/faas-mapg-note/references.bib
new file mode 100644
index 0000000..d4ac75a
--- /dev/null
+++ b/faas-mapg-note/references.bib
@@ -0,0 +1,53 @@
+% References for the FaaS-MAPG positioning subsection.
+
+@article{monderershapley1996,
+  author  = {Dov Monderer and Lloyd S. Shapley},
+  title   = {Potential Games},
+  journal = {Games and Economic Behavior},
+  volume  = {14},
+  number  = {1},
+  pages   = {124--143},
+  year    = {1996},
+  doi     = {10.1006/game.1996.0044}
+}
+
+@article{rosenthal1973,
+  author  = {Robert W. Rosenthal},
+  title   = {A Class of Games Possessing Pure-Strategy Nash Equilibria},
+  journal = {International Journal of Game Theory},
+  volume  = {2},
+  number  = {1},
+  pages   = {65--67},
+  year    = {1973},
+  doi     = {10.1007/BF01737559}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@book{bertsekas1989,
+  author    = {Dimitri P. Bertsekas and John N. Tsitsiklis},
+  title     = {Parallel and Distributed Computation: Numerical Methods},
+  publisher = {Prentice-Hall},
+  address   = {Englewood Cliffs, NJ},
+  year      = {1989}
+}
+
+@article{nedic2009,
+  author  = {Angelia Nedi\'c and Asuman Ozdaglar},
+  title   = {Approximate Primal Solutions and Rate Analysis for Dual Subgradient Methods},
+  journal = {SIAM Journal on Optimization},
+  volume  = {19},
+  number  = {4},
+  pages   = {1757--1780},
+  year    = {2009},
+  doi     = {10.1137/070708856}
+}
diff --git a/faas-mapod-note/.gitignore b/faas-mapod-note/.gitignore
new file mode 100644
index 0000000..ab6921a
--- /dev/null
+++ b/faas-mapod-note/.gitignore
@@ -0,0 +1,10 @@
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.out
+*.synctex.gz
+*.toc
+*.bbl
+*.blg
+main.pdf
diff --git a/faas-mapod-note/README.md b/faas-mapod-note/README.md
new file mode 100644
index 0000000..754dbab
--- /dev/null
+++ b/faas-mapod-note/README.md
@@ -0,0 +1,28 @@
+# FaaS-MAPoD note
+
+A paper-ready LaTeX section explaining **FaaS-MAPoD**, the randomized
+power-of-d-choices sibling of FaaS-MADiG, in the notation of
+`Decentralized_FaaS_coordination.pdf`.
+
+## Files
+- `faas-mapod.tex` — the `\section{}` to `\input{}` (or paste) into the paper.
+  Remove the self-contained "Notation and capacity model" subsection on
+  insertion (the host paper already defines that notation and those equations).
+- `main.tex` — standalone preview wrapper (compile this to review the note).
+- `references.bib` — cited works (shared, already-verified set; Mitzenmacher is
+  the direct basis).
+- `.gitignore` — LaTeX build artifacts.
+
+## Build a preview
+```bash
+cd faas-mapod-note
+latexmk -pdf main.tex
+```
+
+## Insert into the paper
+1. `\input{faas-mapod}` (or paste the section).
+2. Delete the "Notation and capacity model" subsection.
+3. Convert the plain-text cross-references ("Eq.~(7)", "Alg.~4",
+   "Section~\ref{sec:madig-greedy}") to the host paper's `\ref{}` labels.
+4. Merge `references.bib` into the paper's bibliography (or re-key the
+   `\citep{}` commands).
diff --git a/faas-mapod-note/cited_papers/AUDIT.md b/faas-mapod-note/cited_papers/AUDIT.md
new file mode 100644
index 0000000..9996d61
--- /dev/null
+++ b/faas-mapod-note/cited_papers/AUDIT.md
@@ -0,0 +1,47 @@
+# Citation Existence & Metadata Audit — FaaS-MAPoD note
+
+Audited file: `faas-mapod-note/faas-mapod.tex` (citations) and `faas-mapod-note/references.bib` (metadata).
+Scope: exactly the 5 works cited in `faas-mapod.tex` via `\citep{...}` — `bertsekas1988`, `cybenko1989`, `leechoi2021`, `mitzenmacher2001`, `willebeek1993`.
+(Note: `references.bib` also contains `nezami2021`, but it is NOT cited in `faas-mapod.tex`, so it is out of scope for this audit.)
+Method: re-confirmed every DOI against CrossRef (`https://api.crossref.org/works/<DOI>`) on this run; reused the prior FaaS-MADiG audit (`faas-madig-note/cited_papers/`) as baseline. PDFs copied/verified locally.
+Date: 2026-06-26.
+
+## Summary table
+
+| Key | Exists | Metadata correct | Fix needed | PDF status |
+|---|---|---|---|---|
+| `bertsekas1988` | Yes | Yes | None | Downloaded (reused) — `bertsekas1988.pdf`, 3.3 MB |
+| `cybenko1989` | Yes | Yes | None | Downloaded (user-provided) & content-verified — `cybenko1989.pdf` |
+| `leechoi2021` | Yes | Yes | None | Downloaded (user-provided) & content-verified — `leechoi2021.pdf` |
+| `mitzenmacher2001` | Yes | Yes | None | Downloaded (reused) — `mitzenmacher2001.pdf`, 242 KB |
+| `willebeek1993` | Yes | Yes | None | Downloaded (user-provided) & content-verified — `willebeek1993.pdf` |
+
+**Verdict: all 5 works exist; all metadata fields in `references.bib` are correct. No `references.bib` corrections are required.**
+
+## Per-work confirmation
+
+### `bertsekas1988` — Bertsekas, "The auction algorithm: A distributed relaxation method for the assignment problem"
+CrossRef (DOI `10.1007/BF02186476`) returns author D. P. Bertsekas, title verbatim, journal *Annals of Operations Research*, volume 14, issue 1, pages 105–123, year 1988. Every field in the `.bib` entry (lines 38–47) matches exactly. PDF is the author copy from MIT (`https://www.mit.edu/~dimitrib/TheAuctionAP.pdf`), copied here from the prior MADiG audit; md5 verified identical to the source copy. **`.bib` entry is correct as written.**
+
+### `cybenko1989` — Cybenko, "Dynamic load balancing for distributed memory multiprocessors"
+CrossRef (DOI `10.1016/0743-7315(89)90021-X`) returns author George Cybenko, title verbatim, journal *Journal of Parallel and Distributed Computing*, volume 7, issue 2, pages 279–301, year 1989. Every field in the `.bib` entry (lines 5–14) matches exactly (CrossRef lowercases the DOI suffix to `...90021-x`; this is case-insensitive and not an error). No legitimate open-access PDF exists: the Dartmouth author URL from the prior audit (`http://www.dartmouth.edu/~gvc/Cybenko_JPDP.pdf`) still returns HTTP 404; only paywalled ScienceDirect and non-publisher mirrors (ResearchGate/Academia) were found. **`.bib` entry is correct as written.** PDF subsequently provided by the user and content-verified: page 1 reads "JOURNAL OF PARALLEL AND DISTRIBUTED COMPUTING 7, 279-301 (1989) / Dynamic Load Balancing for Distributed Memory Multiprocessors / GEORGE CYBENKO, Tufts University" — matches title, author, venue, volume, pages, year.
+
+### `leechoi2021` — Lee & Choi, "A Greedy Load Balancing Algorithm for FaaS Platforms"
+CrossRef (DOI `10.1145/3481646.3481657`) returns authors Youngsoo Lee and Sunghee Choi, title verbatim, container *2021 5th International Conference on Cloud and Big Data Computing (ICCBDC)*, pages 63–69, year 2021. The `.bib` entry (lines 59–66) matches, **and notably it already includes `pages = {63--69}`** — the missing-pages issue flagged for this key in the prior MADiG audit is already fixed in this note's `.bib`. No legitimate open-access PDF exists: the author's old preprint host `get.prev.kr` no longer resolves (DNS failure), and the author's current page (`https://prev.github.io/about/`) links only to the paywalled ACM DL and a code repo (`github.com/Prev/HotFunctions`), not a PDF. ACM `doi/fullHtml` returns HTTP 403. **`.bib` entry is correct as written.** PDF subsequently provided by the user and content-verified: page 1 reads "A Greedy Load Balancing Algorithm for FaaS Platforms / Youngsoo Lee … Sunghee Choi … KAIST" — matches title and both authors.
+
+### `mitzenmacher2001` — Mitzenmacher, "The power of two choices in randomized load balancing"
+CrossRef (DOI `10.1109/71.963420`) returns author M. Mitzenmacher, title verbatim, journal *IEEE Transactions on Parallel and Distributed Systems*, volume 12, issue 10, pages 1094–1104, year 2001. Every field in the `.bib` entry (lines 27–36) matches exactly. PDF is the author copy from Harvard EECS (`https://www.eecs.harvard.edu/~michaelm/postscripts/tpds2001.pdf`), copied here from the prior MADiG audit; md5 verified identical to the source copy. **`.bib` entry is correct as written.**
+
+### `willebeek1993` — Willebeek-LeMair & Reeves, "Strategies for dynamic load balancing on highly parallel computers"
+CrossRef (DOI `10.1109/71.243526`) returns authors M.H. Willebeek-LeMair and A.P. Reeves (the `.bib` spells out first names "Marc H." / "Anthony P." — consistent, not an error), title verbatim, journal *IEEE Transactions on Parallel and Distributed Systems*, volume 4, issue 9, pages 979–993, year 1993. Every field in the `.bib` entry (lines 16–25) matches exactly. No legitimate open-access PDF exists: only paywalled IEEE Xplore and non-publisher mirrors (ResearchGate/Academia) were found; no author copy, institutional repository, or preprint. **`.bib` entry is correct as written.** PDF subsequently provided by the user and content-verified: page 1 reads "IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS, VOL. 4, NO. 9, SEPTEMBER 1993, 979 / Strategies for Dynamic Load Balancing on Highly Parallel Computers / Marc H. Willebeek-LeMair … Anthony P. Reeves" — matches title, both authors, venue, volume, issue, page, year.
+
+## `references.bib` corrections needed
+
+**None.** All five in-scope entries (`bertsekas1988`, `cybenko1989`, `leechoi2021`, `mitzenmacher2001`, `willebeek1993`) are metadata-correct against CrossRef. In particular, `leechoi2021` already carries `pages = {63--69}`, so the pages gap noted in the prior MADiG audit does not apply here.
+
+## Download tally
+
+- Reused (copied from `faas-madig-note/cited_papers/`, md5-verified identical): `bertsekas1988.pdf`, `mitzenmacher2001.pdf` — 2 PDFs.
+- User-provided (the agents found no legal open-access copy; the user supplied them via institutional/subscription access, no paywall bypassed by the agents): `cybenko1989.pdf`, `willebeek1993.pdf`, `leechoi2021.pdf` — 3 PDFs, each content-verified against its first page (title/authors/venue match the `.bib`).
+
+**Tally: all 5 cited works now have a content-verified PDF in `cited_papers/` (2 reused + 3 user-provided).**
diff --git a/faas-mapod-note/cited_papers/bertsekas1988.pdf b/faas-mapod-note/cited_papers/bertsekas1988.pdf
new file mode 100644
index 0000000..651fa36
Binary files /dev/null and b/faas-mapod-note/cited_papers/bertsekas1988.pdf differ
diff --git a/faas-mapod-note/cited_papers/cybenko1989.pdf b/faas-mapod-note/cited_papers/cybenko1989.pdf
new file mode 100644
index 0000000..591ce8f
Binary files /dev/null and b/faas-mapod-note/cited_papers/cybenko1989.pdf differ
diff --git a/faas-mapod-note/cited_papers/leechoi2021.pdf b/faas-mapod-note/cited_papers/leechoi2021.pdf
new file mode 100644
index 0000000..9ae68e8
Binary files /dev/null and b/faas-mapod-note/cited_papers/leechoi2021.pdf differ
diff --git a/faas-mapod-note/cited_papers/mitzenmacher2001.pdf b/faas-mapod-note/cited_papers/mitzenmacher2001.pdf
new file mode 100644
index 0000000..cc1b42b
Binary files /dev/null and b/faas-mapod-note/cited_papers/mitzenmacher2001.pdf differ
diff --git a/faas-mapod-note/cited_papers/willebeek1993.pdf b/faas-mapod-note/cited_papers/willebeek1993.pdf
new file mode 100644
index 0000000..fb64e57
Binary files /dev/null and b/faas-mapod-note/cited_papers/willebeek1993.pdf differ
diff --git a/faas-mapod-note/faas-mapod.tex b/faas-mapod-note/faas-mapod.tex
new file mode 100644
index 0000000..44664c4
--- /dev/null
+++ b/faas-mapod-note/faas-mapod.tex
@@ -0,0 +1,265 @@
+% =====================================================================
+% FaaS-MAPoD: randomized power-of-d-choices variant of FaaS-MADiG.
+% This file is meant to be \input{} (or pasted) into the paper.
+% It assumes the paper's notation (N, F, C_i^f, rho_i, omega_i^f,
+% beta_{ij}^f, gamma_i^f, ...) is already defined.
+% Cross-references are written as plain text "Eq.~(7)", "Alg.~4", etc.;
+% convert them to \ref{} once the labels of the host paper are known.
+% =====================================================================
+
+\section{FaaS-MAPoD: a randomized power-of-$d$-choices variant}
+\label{sec:mapod}
+
+\textsc{FaaS-MAPoD} (Multi-Agent Power-of-$d$) is the randomized,
+\emph{partial-visibility} sibling of \textsc{FaaS-MADiG}. It keeps every
+price-free ingredient of \textsc{FaaS-MADiG}---the local problem~(P2), the
+one-hop blackboard advertising residual execution capacity
+$C_i^f(h)=\max\{0,\mathrm{Cap}_i^f(h)-x_i^f(h)\}$~(Eq.~(12)) and memory slack
+$\rho_i(h)$~(Eq.~(13)), the convenience threshold $\gamma_i^f$, the fairness
+penalty $\phi_i^f$, the price-free replica expansion of Algorithm~4, and the
+restricted re-solve after each round. It changes \emph{only} how an overloaded
+buyer chooses where to offload: instead of scanning its entire one-hop
+candidate set $A_i^f(h)$ (as \textsc{FaaS-MADiG} does), it probes a random
+sample of just $d$ candidates per offloading step and serves the best of that
+sample---the classical \emph{power-of-$d$-choices} rule. Its purpose is to
+isolate the value of full neighbourhood visibility: \emph{how much does scanning
+the whole neighbourhood (FaaS-MADiG) buy over probing a random sample of $d$?}
+
+% =====================================================================
+% BEGIN self-contained notation recap.
+% Reproduces the relevant rows of the paper's Table 2 (FRALB) and Table 3
+% (auction) plus Eqs. (1),(2),(12),(13), so the note is readable on its own.
+% REMOVE this whole subsection when inserting into the paper, where the
+% notation and these equations are already defined.
+% =====================================================================
+\subsection{Notation and capacity model}
+\label{sec:mapod-notation}
+
+Each control period $t$ runs auction iterations $h=0,1,\dots,H_{\max}$ in
+parallel. Before coordination, every node $i$ solves a local problem~(P2)
+that, for each function $f\in\mathcal{F}_i$, splits the incoming workload
+$\lambda_i^f$ into locally processed load $x_i^f$, horizontally offloaded
+demand $\omega_i^f$, and Cloud-forwarded load $z_i^f$, and fixes the number of
+replicas $r_i^f$. Replicas obey the memory budget and provide capacity
+\begin{equation}
+  \sum_{f\in\mathcal{F}_i} r_i^f\,\mathrm{RAM}^f \le \mathrm{RAM}_i,
+  \qquad
+  \mathrm{Cap}_i^f = \frac{r_i^f\,U^f_{\max}}{D_i^f}\ \text{[req/s]} ,
+  \tag{1,2}
+\end{equation}
+from which each node advertises, on a neighbour-accessible blackboard, its
+residual execution capacity and its memory slack:
+\begin{equation}
+  C_i^f(h) = \max\!\big\{0,\ \mathrm{Cap}_i^f(h) - x_i^f(h)\big\},
+  \qquad
+  \rho_i(h) = \mathrm{RAM}_i - \sum_{f\in\mathcal{F}_i} r_i^f(h)\,\mathrm{RAM}^f \ge 0 .
+  \tag{12,13}
+\end{equation}
+Table~\ref{tab:mapod-notation} collects the symbols used below.
+
+\begin{table}[t]
+\centering
+\caption{Notation used in this section (subset of the paper's Tables~2--3).}
+\label{tab:mapod-notation}
+\small
+\begin{tabular}{@{}l l p{0.62\linewidth}@{}}
+\toprule
+\multicolumn{3}{@{}l}{\textit{Sets}}\\
+Nodes / neighbours & $\mathcal{N}$, $N_i$ & computing nodes; one-hop neighbours of $i$.\\
+Functions & $\mathcal{F}_i$ & functions deployable on $i$; $\mathcal{F}=\bigcup_i \mathcal{F}_i$.\\
+Candidate sellers & $A_i^f(h)$ & neighbours of $i$ with positive score for $f$, $A_i^f(h)\subseteq N_i$.\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Parameters and weights}}\\
+Input workload & $\lambda_i^f$ & incoming request rate for $f$ at $i$ [req/s].\\
+Memory cap / demand & $\mathrm{RAM}_i$, $\mathrm{RAM}^f$ & node memory; per-replica memory of $f$ [MB].\\
+Service demand & $D_i^f$ & average execution time of $f$ at $i$ [s].\\
+Max utilization & $U^f_{\max}$ & stability threshold, $U^f_{\max}\in[0,1)$.\\
+Local / offload / Cloud profit & $\alpha_i^f$, $\beta_{ij}^f$, $\gamma_i^f$ & profit of local exec.; profit of offloading $i\!\to\! j$; Cloud-offloading penalty (per req/s).\\
+Communication latency & $L_{ij}$ & horizontal-offloading latency between $i$ and $j$.\\
+Weights & $w_{\mathrm{lat}}$, $w_{\mathrm{fair}}$ & importance of latency and of fairness.\\
+Max iterations & $H_{\max}$ & auction iterations per control period.\\
+Price params \emph{(MADeA only)} & $\varepsilon$, $\zeta$ & min.\ bid increment; idle-seller price discount $\zeta\in(0,1)$.\\
+Sample size & $d$ & number of neighbours probed per offloading step (power-of-$d$).\\
+Selection criterion & --- & \texttt{score} (max $s_{ij}^f$) or \texttt{capacity} (max $C_j^f$).\\
+\midrule
+\multicolumn{3}{@{}l}{\textit{Variables and state at iteration $h$}}\\
+Replicas & $r_i^f$ & number of $f$ replicas on $i$, $r_i^f\in\mathbb{N}_0$.\\
+Local / forwarded / Cloud load & $x_i^f$, $y_{ij}^f$, $z_i^f$ & locally served; forwarded $i\!\to\! j$; Cloud-offloaded [req/s].\\
+Offloaded demand & $\omega_i^f$ & horizontal demand still to place [req/s].\\
+Effective load & $\ell_i^f$ & load to be served at $i$ for $f$ [req/s].\\
+Capacity / residual / slack & $\mathrm{Cap}_i^f$, $C_i^f$, $\rho_i$ & exec.\ capacity (Eq.~2); residual exec.\ capacity (Eq.~12); memory slack (Eq.~13).\\
+Congestion ratio & $\kappa_i^f$ & utilization ratio for $f$ on $i$, $\kappa_i^f\in[0,1]$.\\
+Fairness term & $\phi_i^f$ & penalty on nodes that offload excessively.\\
+Execution price \emph{(MADeA only)} & $p_i^f$ & shadow cost of residual capacity; \textbf{removed} in \textsc{FaaS-MADiG}.\\
+Coordination score & $s_{ij}^f$ & price-free preference of buyer $i$ for seller $j$ (Eq.~\eqref{eq:mapod-score}).\\
+\bottomrule
+\end{tabular}
+\end{table}
+% ===================== END self-contained notation recap =====================
+
+\subsection{Power-of-$d$ coordination}
+\label{sec:mapod-coordination}
+
+At iteration $h$, an overloaded buyer $i$ (with $\omega_i^f(h)>0$) admits the
+same candidate sellers as \textsc{FaaS-MADiG}: those advertising residual
+capacity $C_j^f(h)\ge 1$ and passing the convenience threshold,
+\begin{equation}
+  A_i^f(h)=\{\,j\in N_i : C_j^f(h)\ge 1 \ \text{and}\ s_{ij}^f(h)>-\gamma_i^f\,\},
+  \qquad
+  s_{ij}^f(h)=\beta_{ij}^f-w_{\mathrm{lat}}L_{ij}-w_{\mathrm{fair}}\phi_i^f(h),
+  \label{eq:mapod-score}
+\end{equation}
+where $s_{ij}^f(h)$ is exactly the \textsc{FaaS-MADiG} score (the
+\textsc{FaaS-MADeA} utility with the price term removed). The difference is the
+\emph{visibility}: rather than ranking all of $A_i^f(h)$, the buyer repeatedly
+draws a uniform random sample $S\subseteq A_i^f(h)$ of size $\min(d,|A_i^f(h)|)$,
+\emph{without replacement}, and selects from $S$ the seller
+\begin{equation}
+  j^\star=
+  \begin{cases}
+    \arg\max_{j\in S}\ s_{ij}^f(h), & \text{criterion}=\texttt{score},\\[2pt]
+    \arg\max_{j\in S}\ C_j^f(h),     & \text{criterion}=\texttt{capacity},
+  \end{cases}
+  \label{eq:mapod-criterion}
+\end{equation}
+with ties broken by the lower node id for reproducibility. The \texttt{score}
+criterion ablates only the buyer's \emph{visibility} relative to
+\textsc{FaaS-MADiG}; the \texttt{capacity} criterion is a buyer-side
+spare-capacity sampling variant inspired by the textbook shortest-queue
+power-of-$d$ rule. It is not a fully capacity-ordered clearing rule: admissible
+sellers still pass the score threshold, and seller-side conflicts are still
+resolved by \textsc{FaaS-MADiG}'s score-ordered clearing. In the default
+\emph{batched} form the buyer claims $\min(C_{j^\star}^f(h),\ \omega_i^f(h)-o)$
+from $j^\star$, removes it from the pool, and repeats until its demand is met or
+the candidate set is empty; in the \emph{per-unit} form (\texttt{unit\_bids})
+each unit of $\omega_i^f(h)$ draws a fresh sample of $d$, recovering the classic
+per-arrival power-of-$d$-choices. Any residual demand triggers the same
+price-free replica-expansion requests to neighbours with memory slack
+$\rho_j(h)>0$ as in \textsc{FaaS-MADiG}.
+
+When $d\ge|A_i^f(h)|$ the sample is the whole candidate set, and (for
+distinct scores) the \texttt{score} criterion reduces exactly to
+\textsc{FaaS-MADiG}'s greedy buyer rule---so \textsc{FaaS-MAPoD} interpolates
+between full-visibility greedy diffusion ($d=|A_i^f(h)|$) and blind random
+placement ($d=1$).
+
+\begin{algorithm}
+\caption{\textsc{FaaS-MAPoD} --- buyer power-of-$d$ sampling (replaces the FaaS-MADiG buyer rule)}
+\label{alg:mapod-buyer}
+\begin{algorithmic}[1]
+\Require residual demand $\omega_i^f(h)$, blackboard residuals $C_j^f(h)$ and memory slacks $\rho_j(h)$, sample size $d$, criterion, RNG
+\For{each function $f$ with $\omega_i^f(h)>0$}
+  \State $A_i^f(h)\gets\{\,j\in N_i: C_j^f(h)\ge 1 \text{ and } s_{ij}^f(h)>-\gamma_i^f\,\}$
+  \State $o\gets 0$;\quad maintain a local view $\tilde C_j\gets C_j^f(h)$ for $j\in A_i^f(h)$
+  \While{$o<\omega_i^f(h)$ \textbf{and} $A_i^f(h)\ne\emptyset$}
+     \State draw a uniform sample $S\subseteq A_i^f(h)$, $|S|=\min(d,|A_i^f(h)|)$, without replacement
+     \State $j^\star\gets\arg\max_{j\in S} s_{ij}^f(h)$ \textbf{if} criterion${}=\texttt{score}$ \textbf{else} $\arg\max_{j\in S}\tilde C_j$ \Comment{tie-break: lower id}
+     \State $q\gets 1$ \textbf{if} \texttt{unit\_bids} \textbf{else} $\min(\tilde C_{j^\star},\,\omega_i^f(h)-o)$
+     \State emit assignment request $(i\!\to\! j^\star,f,q)$ with score $s_{ij^\star}^f(h)$;\quad $o\gets o+q$;\quad $\tilde C_{j^\star}\gets\tilde C_{j^\star}-q$
+     \If{$\tilde C_{j^\star}<1$} remove $j^\star$ from $A_i^f(h)$ \EndIf
+  \EndWhile
+  \If{$o<\omega_i^f(h)$}
+     \For{$j\in N_i$ with $\rho_j(h)>0$} \Comment{both still-serving and memory-only neighbours, as in FaaS-MADiG}
+        \State emit \emph{price-free} replica-expansion request $(i\!\to\! j,f)$
+     \EndFor
+  \EndIf
+\EndFor
+\end{algorithmic}
+\end{algorithm}
+
+The seller side is \emph{unchanged}: requests received by $j$ are cleared by
+\textsc{FaaS-MADiG}'s greedy fill (the \texttt{evaluate\_assignments} routine of
+Section~\ref{sec:madig-greedy}), which serves buyers in descending-score order
+up to the true residual capacity $C_j^f(h)$, tentatively starts replicas under
+the utilization test $\kappa_j^f\le 1$, and re-awards incumbent load only to a
+higher-score buyer. Consequently cross-buyer conflicts---when several buyers
+sample the same seller---are resolved identically to \textsc{FaaS-MADiG}; only
+the buyer's \emph{probe} is randomized.
+
+\subsection{What is removed and what is kept}
+\label{sec:mapod-ablation}
+
+\noindent\textbf{Removed} (relative to \textsc{FaaS-MADeA}): the entire price
+machinery, exactly as in \textsc{FaaS-MADiG}. \textbf{Removed} (relative to
+\textsc{FaaS-MADiG}): \emph{full neighbourhood visibility}---the buyer now sees
+only a random size-$d$ sample per step rather than the whole candidate set.
+
+\noindent\textbf{Kept} (identical to \textsc{FaaS-MADiG}): the local
+problem~(P2); the advertising of $C_i^f(h)$ and $\rho_i(h)$ (Eqs.~(12)--(13));
+the score~\eqref{eq:mapod-score} and the convenience threshold $\gamma_i^f$; the
+fairness penalty $\phi_i^f$; the price-free replica expansion of Algorithm~4;
+the score-ordered seller clearing and reassignment; and the restricted
+re-solve after each coordination round.
+
+\subsection{Rationale and properties}
+\label{sec:mapod-rationale}
+
+\paragraph{Visibility ablation.} Because \textsc{FaaS-MAPoD} shares its score,
+threshold, seller clearing, and provisioning with \textsc{FaaS-MADiG}, the
+\emph{only} behavioural difference is how many neighbours the buyer inspects per
+step. Any performance gap is therefore attributable to partial visibility
+alone, placing \textsc{FaaS-MAPoD} at the random/partial-visibility end of the
+\emph{market $\to$ greedy $\to$ random} spectrum
+(\textsc{FaaS-MADeA} $\to$ \textsc{FaaS-MADiG} $\to$ \textsc{FaaS-MAPoD}).
+
+\paragraph{Reproducibility.} The sampling generator is seeded once per run from
+the experiment seed, so a run is fully reproducible; statistical variance across
+the random draws is obtained by repeating experiments (the campaign's
+$n_{\text{experiments}}$ replicates, each with its own seed and instance) rather
+than by in-run averaging.
+
+\paragraph{Communication.} Each offloading step inspects at most $d$ neighbours,
+so \textsc{FaaS-MAPoD} has the smallest probe footprint of the three methods:
+it reads $O(d)$ blackboard entries per step instead of the full one-hop
+neighbourhood, while exchanging no prices.
+
+\subsection{Positioning with respect to the literature}
+\label{sec:mapod-related}
+
+We state plainly that the buyer rule of \textsc{FaaS-MAPoD} adopts the
+power-of-$d$-choices \emph{sampling mechanism} of
+Mitzenmacher~\citep{mitzenmacher2001}, applied to one-hop FRALB offloading:
+it probes $d$ uniformly random candidates per step instead of scanning the
+whole neighbourhood. Under the \texttt{capacity} criterion it uses the
+largest-spare-capacity choice on the buyer's sampled set, but keeps the model's
+score threshold and \textsc{FaaS-MADiG}'s score-ordered seller clearing; under
+the default \texttt{score} criterion it keeps the random-$d$ sampling but
+selects by the model's economic score rather than by load (see
+Differences~(i) below). It is, by design, \emph{less} novel than
+\textsc{FaaS-MADiG} and is included as a controlled baseline, not as a new
+algorithm.
+
+\paragraph{Basis.} Probing $d$ uniformly random candidates without replacement
+and dispatching to the best of the sample is the power-of-$d$-choices
+\emph{sampling} paradigm of~\citep{mitzenmacher2001}. Under the \texttt{capacity}
+criterion the buyer routes to the largest-spare-capacity seller of the $d$
+samples---a spare-capacity analogue of Mitzenmacher's shortest-queue rule---but
+the overall method is still filtered by the convenience threshold and cleared by
+the score-ordered \textsc{FaaS-MADiG} seller rule. With $d=2$, only the buyer
+probe is the canonical ``power of two choices''. Under the default
+\texttt{score} criterion the same random-$d$ sampling is kept, but selection
+maximizes the economic score rather than load (Differences~(i)). The
+underlying push of excess load to less-loaded neighbours is the diffusion
+paradigm of Cybenko~\citep{cybenko1989} and the sender-initiated strategies
+catalogued by Willebeek-LeMair and Reeves~\citep{willebeek1993}; greedy,
+locality-driven offloading in FaaS/edge dispatchers~\citep{leechoi2021} is a
+full-visibility relative. \textsc{FaaS-MAPoD} and \textsc{FaaS-MADiG} are
+siblings: \textsc{FaaS-MADiG} is the $d\!=\!|A_i^f(h)|$ (full-visibility) limit
+of \textsc{FaaS-MAPoD}, and \textsc{FaaS-MADiG} is itself the price-frozen limit
+of the \textsc{FaaS-MADeA} auction~\citep{bertsekas1988}.
+
+\paragraph{Differences.} Two elements separate \textsc{FaaS-MAPoD} from the
+textbook power-of-$d$ rule. \emph{(i) Objective-aligned selection.} With the
+\texttt{score} criterion the buyer ranks the sample by the model's economic
+weights ($\beta_{ij}^f$, $\gamma_i^f$, latency $L_{ij}$, fairness $\phi_i^f$)
+rather than by raw queue length, and every round is re-validated by the local
+problem~(P2) and the restricted re-solve. \emph{(ii) Joint balancing and
+provisioning.} Beyond migrating load over a fixed graph, \textsc{FaaS-MAPoD}
+triggers memory-slack-based replica expansion (Algorithm~4), inherited from the
+\textsc{FaaS-MADeA}/\textsc{FaaS-MADiG} framework.
+
+\paragraph{Takeaway.} As an isolated coordination rule, \textsc{FaaS-MAPoD}
+instantiates power-of-$d$-choices balancing and is not claimed as novel; its
+value is as a partial-visibility ablation that attributes any gap with respect
+to \textsc{FaaS-MADiG} to full neighbourhood visibility, and as the random
+endpoint of the market$\to$greedy$\to$random spectrum.
diff --git a/faas-mapod-note/main.tex b/faas-mapod-note/main.tex
new file mode 100644
index 0000000..13713f5
--- /dev/null
+++ b/faas-mapod-note/main.tex
@@ -0,0 +1,18 @@
+% Standalone preview wrapper for the FaaS-MAPoD note.
+% The deliverable section lives in faas-mapod.tex and is meant to be
+% \input{} (or pasted) into the host paper; this wrapper only renders it
+% on its own for review.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\begin{document}
+\input{faas-mapod}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-mapod-note/references.bib b/faas-mapod-note/references.bib
new file mode 100644
index 0000000..b269f6e
--- /dev/null
+++ b/faas-mapod-note/references.bib
@@ -0,0 +1,66 @@
+% References for the FaaS-MAPoD positioning subsection (shared with the FaaS-MADiG note).
+% When inserting into the paper, merge these entries into the paper's .bib
+% (or re-key the \citep{} commands to the paper's existing keys).
+
+@article{cybenko1989,
+  author  = {George Cybenko},
+  title   = {Dynamic load balancing for distributed memory multiprocessors},
+  journal = {Journal of Parallel and Distributed Computing},
+  volume  = {7},
+  number  = {2},
+  pages   = {279--301},
+  year    = {1989},
+  doi     = {10.1016/0743-7315(89)90021-X}
+}
+
+@article{willebeek1993,
+  author  = {Marc H. Willebeek-LeMair and Anthony P. Reeves},
+  title   = {Strategies for dynamic load balancing on highly parallel computers},
+  journal = {IEEE Transactions on Parallel and Distributed Systems},
+  volume  = {4},
+  number  = {9},
+  pages   = {979--993},
+  year    = {1993},
+  doi     = {10.1109/71.243526}
+}
+
+@article{mitzenmacher2001,
+  author  = {Michael Mitzenmacher},
+  title   = {The power of two choices in randomized load balancing},
+  journal = {IEEE Transactions on Parallel and Distributed Systems},
+  volume  = {12},
+  number  = {10},
+  pages   = {1094--1104},
+  year    = {2001},
+  doi     = {10.1109/71.963420}
+}
+
+@article{bertsekas1988,
+  author  = {Dimitri P. Bertsekas},
+  title   = {The auction algorithm: A distributed relaxation method for the assignment problem},
+  journal = {Annals of Operations Research},
+  volume  = {14},
+  number  = {1},
+  pages   = {105--123},
+  year    = {1988},
+  doi     = {10.1007/BF02186476}
+}
+
+@article{nezami2021,
+  author  = {Zeinab Nezami and Kamran Zamanifar and Karim Djemame and Evangelos Pournaras},
+  title   = {Decentralized Edge-to-Cloud Load Balancing: Service Placement for the Internet of Things},
+  journal = {IEEE Access},
+  volume  = {9},
+  pages   = {64983--65000},
+  year    = {2021},
+  doi     = {10.1109/ACCESS.2021.3074962}
+}
+
+@inproceedings{leechoi2021,
+  author    = {Youngsoo Lee and Sunghee Choi},
+  title     = {A Greedy Load Balancing Algorithm for {FaaS} Platforms},
+  booktitle = {Proc.\ 2021 5th International Conference on Cloud and Big Data Computing (ICCBDC)},
+  pages     = {63--69},
+  year      = {2021},
+  doi       = {10.1145/3481646.3481657}
+}
diff --git a/faas-plasma-note/faas-plasma.tex b/faas-plasma-note/faas-plasma.tex
new file mode 100644
index 0000000..b7c0c94
--- /dev/null
+++ b/faas-plasma-note/faas-plasma.tex
@@ -0,0 +1,164 @@
+% =====================================================================
+% FaaS-PLASMA: Physarum Routing with Simulated-Bifurcation Allocation.
+% Meant to be \input{} (or pasted) into the paper.
+% =====================================================================
+
+\section{PLASMA: Physarum Routing with Simulated-Bifurcation Allocation}
+\label{sec:plasma}
+
+\subsection{Problem statement}
+PLASMA addresses decentralized function-replica allocation and request
+routing on an undirected neighborhood graph $G=(V,E)$.  Node $i$ observes
+only its arrivals $\lambda_{if}$, local resource state, and heartbeats from
+$j\in\mathcal{N}_i$.  For function $f$, a local completion yields utility
+$\alpha_{if}$, forwarding from $i$ to $j$ yields $\beta_{ijf}$, and rejection
+incurs penalty $\gamma_{if}$.  The local replica vector $r_i$ must satisfy
+$\sum_f m_f r_{if}\leq M_i$, while $r_{if}u_{if}^{\max}W$ is the request
+capacity in a routing window of duration $W$.  PLASMA separates the problem
+into a fast routing layer and a slower replica-allocation layer.  Both layers
+are node-local; no coordinator or global state is introduced.
+
+\subsection{Layer A: conductance routing}
+For each $(i,f)$, node $i$ maintains a conductance vector $D_{ifc}$ over the
+local, rejection, and neighbor channels.  This state is inspired by Physarum
+transport dynamics \citep{bonifaci2012physarum}, but its reinforcement signal
+is the realized application utility rather than physical tube flow.  If
+$\phi_{ifc}(t)$ requests succeed on channel $c$ during window $t$, the update
+is
+\begin{equation}
+ D_{ifc}(t+1)=\operatorname{clip}_{[D_{\min},D_{\max}]}
+ \left((1-\mu)D_{ifc}(t)+\mu\phi_{ifc}(t)^{\kappa}q_{ifc}\right),
+ \label{eq:plasma-conductance}
+\end{equation}
+where $q_{ifc}$ is $\alpha_{if}$ locally, a small rejection floor on the
+rejection channel, and $\beta_{ijf}$ on neighbor $j$'s channel.  Routing
+probabilities are normalized gated conductances.  The local gate closes when
+local capacity is exhausted; a neighbor advertising no spare capacity keeps
+only an $\epsilon$ exploration weight.  A stale neighbor advertises zero
+spare capacity, so its conductance decays without a separate failure detector.
+
+The implemented policy also performs reward-aware admission before sampling:
+when $\beta_{ijf}>\alpha_{if}$ and $j$ advertises spare capacity, requests are
+offered to the highest-reward eligible neighbors first.  Remaining overflow is
+sampled from the conductance distribution.  A negative acknowledgement is
+retried locally when capacity remains and is rejected otherwise.  This retry
+is important: it turns outdated spare-capacity advertisements into a local
+loss rather than a conservation error.  Low-rate functions may optionally use
+an unsplittable argmax route, although the default remains categorical
+sampling.
+
+\subsection{Layer B: discrete allocation}
+Each node estimates arrivals by an exponentially weighted mean
+$\widehat{\lambda}_{if}$ and sums the offload pressure advertised by its
+neighbors, $p_{if}^{\mathrm{in}}$.  The provisioning target is therefore
+$d_{if}=\widehat{\lambda}_{if}+p_{if}^{\mathrm{in}}$.  For a candidate local
+replica vector $r_i$, the current Hamiltonian is
+\begin{align}
+ H_i(r_i)={}&-\sum_f \alpha_{if}
+ \min\{r_{if}u_{if}^{\max}W,d_{if}\}
+ +A\left[\sum_fm_fr_{if}-M_i\right]_+^2 \notag\\
+ &+B\sum_f\left[\widehat{\lambda}_{if}
+ +z_\delta\sqrt{\widehat{\lambda}_{if}}
+ -r_{if}u_{if}^{\max}W\right]_+^2
+ +C c_{\mathrm{sw}}\lVert r_i-r_i^{\mathrm{prev}}\rVert_1 .
+ \label{eq:plasma-hamiltonian}
+\end{align}
+The first term is a concave served-demand field: extra replicas cease to earn
+utility after meeting estimated demand.  This measured Hamiltonian v2
+supersedes the linear field in the original design specification, Section
+4.2, because the linear field rewarded idle capacity and ignored per-replica
+throughput.  The remaining terms penalize RAM overflow, capacity shortfall
+with a configurable safety margin, and churn.
+
+Replica levels are binary encoded as spins and can be minimized with discrete
+simulated bifurcation (dSB) \citep{goto2021high}.  The dSB implementation runs
+multiple oscillator trajectories and retains the lowest-energy state.  The
+operational default uses an exact multiple-choice knapsack dynamic program
+for positive integer RAM costs; this is an exact solver for the same node-local
+Hamiltonian and avoids stochastic variance in evaluation.  dSB remains the
+scalable alternative when the exact solver's assumptions or state space cease
+to be appropriate.  Every proposal is repaired to RAM feasibility, must
+improve the Hamiltonian by at least $\epsilon_{\mathrm{commit}}$, persist for
+$n_{\mathrm{hyst}}$ consecutive slow ticks, and pass an independent commit
+coin with probability $p_{\mathrm{commit}}$.
+
+\subsection{Round barrier and protocol}
+PLASMA has one synchronous execution mode.  A shared barrier advances windows
+of duration $W$; routing runs every window and Layer B runs every $k_{\mathrm{SB}}$
+windows.  Heartbeat deliveries scheduled for a round are applied before that
+round's routing callback.  Randomized commits are therefore mandatory rather
+than an asynchronous-mode option: with $p_{\mathrm{commit}}=1$, adjacent nodes
+may update simultaneously in a Jacobi-like oscillation, whereas hysteresis and
+the default $p_{\mathrm{commit}}=0.5$ break phase locking.
+
+The complete control-plane heartbeat is
+$\langle i,\mathrm{seq},\mathrm{spare}_{if},\alpha_{if},p_{if}\rangle_f$.
+Messages carry no arrival trace, replica vector, conductance, spin state, or
+global topology.  Sequence numbers reject stale replacements; after a fixed
+staleness horizon, cached spare capacity and pull pressure are treated as
+zero.  Data-plane forwards and their acknowledgements are counted separately
+from heartbeats in the reported message rate.
+
+\subsection{Acceptance criteria and measured results}
+The implementation passed traffic conservation, RAM feasibility, heartbeat
+locality, dead-neighbor decay, phase-lock mitigation, runner integration, and
+baseline-wiring checks.  On the stationary two-node acceptance instance,
+conductance routing converged within a 1.35\% band of the LP routing split.
+dSB found the brute-force ground state in at least 95\% of 200 random
+eight-spin Hamiltonians.  GCD scaling of the exact dynamic program preserved
+the optimum while reducing its measured cost by $73\times$; the corresponding
+end-to-end step runtime fell from 44.9~s to 0.30~s in the quality experiment.
+The complete regression suite contained 570 passing tests at the recorded
+checkpoint.
+
+The M5 target of at most 10\% stationary gap to the centralized MILP was not
+met.  On the real-instance long horizon, the steady gap fell from 30.1\% to
+22.7\% after provisioning from arrivals rather than accepted traffic.  On the
+20-node, $\beta$-dominant benchmark, reward-aware admission raised forwarding
+from 12\% to 25\% and reduced the gap from 35.3\% to 32.2\%, but rejection rose
+from 15\% to 20\%.  The residual mechanism is over-subscription of attractive
+high-$\beta$ receivers.  Static fair-share rationing by advertised spare
+capacity divided by degree regressed the gap to 35.2\% by throttling preferred
+forwards, and was reverted; NACK followed by local retry performed better.
+
+\begin{table}[t]
+\centering
+\caption{Recorded M6 failure experiment with node 3 unavailable during
+$t\in[80,90)$.  Lower gap is better.}
+\label{tab:plasma-m6}
+\begin{tabular}{lcc}
+\toprule
+Method & Mean gap (\%) & Observation \\
+\midrule
+PLASMA & 28.8 & $+2$ points during failure, then recovery \\
+Stale MILP & 10.1 & Sawtooth between re-solves \\
+Greedy & 5.6 & Recomputed from instantaneous global loads \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+The M6 comparison is deliberately qualified: both baselines read the true
+instantaneous global load, while PLASMA is neighbor-only.  PLASMA's adaptation
+lag is undefined in this run because its pre-failure gap already exceeds the
+10\% recovery threshold.  In the M7 low-rate ablation, sampled routing
+obtained a 36.6\% gap and unsplittable routing 37.9\%; hence the unsplittable
+mode provided no benefit on that instance.
+
+\subsection{Privacy comparison and limitations}
+FaaS-MADeA exchanges bids that directly expose utility-bearing allocation
+intent.  PLASMA exposes only per-function spare capacity, local reward
+$\alpha$, and aggregate pull pressure to immediate neighbors.  This is a
+strictly smaller operational view than bid exchange, although it is not a
+formal privacy guarantee: repeated heartbeats can still reveal load and
+capacity trends.
+
+The next M5 mechanism is adaptive claim sizing.  Rather than reinstating the
+failed static fair share, a sender should size preferred-forward claims from
+its conductance share or from the receiver-specific NACK rate.  This directly
+targets receiver over-subscription while retaining reward-aware admission.
+The remaining non-blocking implementation debt is limited to documenting the
+$W$/floor convention in the routing LP helper, guarding adaptation lag against
+a negative oracle, and reducing the runtime and random-stream sensitivity of
+the dSB quality test.  The reported numbers are single recorded benchmark
+outcomes, not confidence intervals; multi-seed evaluation is required before
+making population-level performance claims.
diff --git a/faas-plasma-note/main.tex b/faas-plasma-note/main.tex
new file mode 100644
index 0000000..1b760b5
--- /dev/null
+++ b/faas-plasma-note/main.tex
@@ -0,0 +1,19 @@
+% Standalone preview wrapper for the FaaS-PLASMA note.
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage{booktabs}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
+\usepackage[numbers,square]{natbib}
+\usepackage[margin=1in]{geometry}
+
+\newtheorem{proposition}{Proposition}
+\newtheorem{theorem}{Theorem}
+
+\begin{document}
+\input{faas-plasma}
+\bibliographystyle{plainnat}
+\bibliography{references}
+\end{document}
diff --git a/faas-plasma-note/references.bib b/faas-plasma-note/references.bib
new file mode 100644
index 0000000..1f589f7
--- /dev/null
+++ b/faas-plasma-note/references.bib
@@ -0,0 +1,19 @@
+% References for the FaaS-PLASMA note.
+
+@article{bonifaci2012physarum,
+  author  = {Bonifaci, Vincenzo and Mehlhorn, Kurt and Varma, Girish},
+  title   = {Physarum can compute shortest paths},
+  journal = {Journal of Theoretical Biology},
+  volume  = {309},
+  pages   = {121--133},
+  year    = {2012}
+}
+
+@article{goto2021high,
+  author  = {Goto, Hayato and Endo, Kotaro and Suzuki, Masaru and others},
+  title   = {High-performance combinatorial optimization based on classical mechanics},
+  journal = {Science Advances},
+  volume  = {7},
+  number  = {6},
+  year    = {2021}
+}
diff --git a/generate_data.py b/generate_data.py
new file mode 100644
index 0000000..0ac1543
--- /dev/null
+++ b/generate_data.py
@@ -0,0 +1 @@
+from generators.generate_data import *  # noqa: F403
diff --git a/generators/generate_data.py b/generators/generate_data.py
index c6faf57..b2d514f 100644
--- a/generators/generate_data.py
+++ b/generators/generate_data.py
@@ -2,30 +2,46 @@
 from utils.common import load_base_instance
 
 from copy import deepcopy
+from itertools import combinations
 from typing import Tuple
 import networkx as nx
 import numpy as np
-
-try:
-  import sage.all as sage
-except ImportError:
-  pass
+from scipy.spatial import Delaunay
 
 
 def add_network_latency(
     graph: nx.Graph, limits: dict, rng: np.random.Generator
   ) -> nx.Graph:
-  if "weights" in limits and "edge_network_latency" in limits["weights"]:
-    for (u, v) in graph.edges():
-      graph.edges[u,v]["network_latency"] = generate_random_float(
-        rng, limits["weights"]["edge_network_latency"]
-      )
-      graph.edges[u,v]["edge_bandwidth"] = generate_random_int(
-        rng, limits["weights"]["edge_bandwidth"]
+  weights = limits.get("weights", {})
+  latency_limits = weights.get("edge_network_latency")
+  edges = list(graph.edges())
+  if latency_limits and latency_limits.get("mode") in {
+      "euclidean", "euclidean_permuted"
+    }:
+    jitter_limits = latency_limits.get("jitter", {"min": 0.0, "max": 0.0})
+    latencies = [
+      latency_limits.get("base", 0.0)
+      + latency_limits.get("distance_factor", 1.0)
+      * graph.edges[edge]["edge_length"]
+      + generate_random_float(rng, jitter_limits)
+      for edge in edges
+    ]
+    if latency_limits["mode"] == "euclidean_permuted":
+      latencies = rng.permutation(latencies)
+    for edge, latency in zip(edges, latencies):
+      graph.edges[edge]["network_latency"] = float(latency)
+  elif latency_limits:
+    for edge in edges:
+      graph.edges[edge]["network_latency"] = generate_random_float(
+        rng, latency_limits
       )
   else:
-    for (u, v) in graph.edges():
-      graph.edges[u,v]["network_latency"] = 1.0
+    nx.set_edge_attributes(graph, 1.0, "network_latency")
+  if "edge_bandwidth" in weights:
+    for edge in edges:
+      graph.edges[edge]["edge_bandwidth"] = generate_random_int(
+        rng, weights["edge_bandwidth"]
+      )
   return graph
 
 
@@ -187,27 +203,82 @@ def generate_neighborhood(
   ) -> Tuple[np.array, nx.Graph]:
   neighborhood = np.zeros((Nn, Nn))
   graph = None
-  if "p" in limits["neighborhood"]:
-    for n1 in range(Nn):
-      for n2 in range(n1+1,Nn):
-        neighborhood[n1,n2] = rng.binomial(1, limits["neighborhood"]["p"])
-        neighborhood[n2,n1] = neighborhood[n1,n2]
-    graph = nx.from_numpy_array(neighborhood)
-  elif "k" in limits["neighborhood"]:
-    if limits["neighborhood"].get("shape", "") == "planar":
-      g = sage.graphs.RandomTriangulation(
-        n = Nn, 
-        k = limits["neighborhood"]["k"],
-        seed = int(rng.integers(low = 0, high = 4850 * 4850 * 4850))
+  neighborhood_limits = limits["neighborhood"]
+  if (
+      neighborhood_limits.get("type") in {"planar", "euclidean_planar"}
+      or neighborhood_limits.get("shape") == "planar"
+    ):
+    mean_degree = neighborhood_limits.get(
+      "mean_degree",
+      neighborhood_limits.get("degree", neighborhood_limits.get("k")),
+    )
+    density = neighborhood_limits.get("density", 1.0)
+    if Nn < 3 or density <= 0 or mean_degree is None:
+      raise ValueError("connected Euclidean planar neighborhood requires Nn >= 3, "
+                       "positive density, and mean_degree")
+    side = np.sqrt(Nn / density)
+    points = rng.uniform(0, side, size=(Nn, 2))
+    candidate = nx.Graph()
+    candidate.add_nodes_from(
+      (node, {"pos": tuple(point)}) for node, point in enumerate(points)
+    )
+    for simplex in Delaunay(points).simplices:
+      candidate.add_edges_from(combinations(map(int, simplex), 2))
+    for u, v in candidate.edges():
+      candidate.edges[u, v]["edge_length"] = float(
+        np.linalg.norm(points[u] - points[v])
+      )
+    target_edges = round(Nn * mean_degree / 2)
+    if not Nn - 1 <= target_edges <= candidate.number_of_edges():
+      raise ValueError(
+        "connected Euclidean planar neighborhood has an infeasible edge budget"
+      )
+    graph = nx.minimum_spanning_tree(candidate, weight="edge_length")
+    remaining = list(set(candidate.edges()) - set(graph.edges()))
+    for index in rng.permutation(len(remaining))[:target_edges - (Nn - 1)]:
+      u, v = remaining[index]
+      graph.add_edge(u, v, **candidate.edges[u, v])
+    neighborhood = nx.to_numpy_array(graph, dtype=int)
+  elif "p" in limits["neighborhood"]:
+    for _ in range(1000):
+      neighborhood = np.zeros((Nn, Nn))
+      for n1 in range(Nn):
+        for n2 in range(n1+1,Nn):
+          neighborhood[n1,n2] = rng.binomial(1, limits["neighborhood"]["p"])
+          neighborhood[n2,n1] = neighborhood[n1,n2]
+      graph = nx.from_numpy_array(neighborhood)
+      if nx.is_connected(graph):
+        break
+    else:
+      raise ValueError(
+        "could not generate a connected random neighborhood in 1000 attempts"
+      )
+  elif "m" in limits["neighborhood"]:
+    for _ in range(1000):
+      graph = nx.gnm_random_graph(
+        Nn,
+        limits["neighborhood"]["m"],
+        seed=int(rng.integers(low=0, high=4850 * 4850 * 4850)),
       )
-      graph = nx.Graph()
-      graph.add_nodes_from(g.vertices())
-      graph.add_edges_from(g.edges(labels=False))
+      if nx.is_connected(graph):
+        break
     else:
+      raise ValueError(
+        "could not generate a connected fixed-edge neighborhood in 1000 attempts"
+      )
+    neighborhood = nx.adjacency_matrix(graph).toarray()
+  elif "k" in limits["neighborhood"]:
+    for _ in range(1000):
       graph = nx.random_regular_graph(
-        d = limits["neighborhood"]["k"],
-        n = Nn,
-        seed = int(rng.integers(low = 0, high = 4850 * 4850 * 4850))
+        d=limits["neighborhood"]["k"],
+        n=Nn,
+        seed=int(rng.integers(low=0, high=4850 * 4850 * 4850)),
+      )
+      if nx.is_connected(graph):
+        break
+    else:
+      raise ValueError(
+        "could not generate a connected regular neighborhood in 1000 attempts"
       )
     neighborhood = nx.adjacency_matrix(graph).toarray()
   # -- add network latency (if available)
@@ -328,27 +399,39 @@ def generate_weights(
             beta[n1,n2,f] = -1
           beta[n2,n1,f] = beta[n1,n2,f]
           max_price = max(max_price, beta[n2,n1,f])
-    gamma[Nn - 1,f] = generate_random_float(
-      rng, limits["weights"]["cloud_network_latency"]
-    ) + (
-      data_size[f] / cloud_bandwidth
-    )
+    for f in range(Nf):
+      gamma[Nn - 1,f] = generate_random_float(
+        rng, limits["weights"]["cloud_network_latency"]
+      ) + (
+        data_size[f] / cloud_bandwidth
+      )
     min_g = gamma.min()
     max_g = gamma.max()
+    gamma_range = max_g - min_g
+    price_range = max_price - min_price
     # -- normalize
-    alpha = [1 - ((a - min_price) / (max_price - min_price)) for a in alpha]
+    alpha = [
+      0.0 if price_range == 0 else 1 - ((a - min_price) / price_range)
+      for a in alpha
+    ]
     for n1 in range(Nn - 1):
       for f in range(Nf):
-        gamma[n1,f] = (gamma[n1,f] - min_g) / (max_g - min_g)
+        gamma[n1,f] = (
+          0.0 if gamma_range == 0 else (gamma[n1,f] - min_g) / gamma_range
+        )
         for n2 in range(n1 + 1, Nn):
           if beta[n1,n2,f] > 0:
-            beta[n1,n2,f] = 1 - (
-              (beta[n1,n2,f] - min_price) / (max_price - min_price)
+            beta[n1,n2,f] = (
+              0.0 if price_range == 0
+              else 1 - ((beta[n1,n2,f] - min_price) / price_range)
             )
           else:
             beta[n1,n2,f] = 0
           beta[n2,n1,f] = beta[n1,n2,f]
-    gamma[Nn - 1,f] = (gamma[Nn - 1,f] - min_g) / (max_g - min_g)
+    for f in range(Nf):
+      gamma[Nn - 1,f] = (
+        0.0 if gamma_range == 0 else (gamma[Nn - 1,f] - min_g) / gamma_range
+      )
     delta = beta.mean(axis = 1)
   return alpha, beta, gamma, delta
 
diff --git a/generators/load_generator.py b/generators/load_generator.py
index 9630001..ae32996 100644
--- a/generators/load_generator.py
+++ b/generators/load_generator.py
@@ -123,7 +123,8 @@ def generate_traces(
         if trace_type == "clipped":
           # Clip the excess values respecting the minimum and maximum values
           # for the input requests observation.
-          np.clip(requests, minr, maxr, out = requests)
+          clipped = np.clip(requests.astype(float), minr, maxr)
+          requests = clipped.astype(np.int32) if only_integer_values else clipped
         elif trace_type == "sinusoidal":
           # Rescale
           in_min = requests.min()
@@ -139,14 +140,14 @@ def generate_traces(
         input_requests[agent] = requests
     elif trace_type.startswith("fixed_sum"):
       total_workload = 0.0
+      values = list(limits.values())
+      numeric_values = [v["max"] if isinstance(v, dict) else v for v in values]
       if trace_type == "fixed_sum":
-        total_workload = sum(list(limits.values()))/len(list(limits.values()))
+        total_workload = sum(numeric_values) / len(numeric_values)
       else:
-        total_workload = min(list(limits.values())) if trace_type.endswith(
+        total_workload = min(numeric_values) if trace_type.endswith(
           "min"
-        ) else max(list(limits.values()))
-      if isinstance(total_workload, dict):
-        total_workload = total_workload["max"]
+        ) else max(numeric_values)
       input_requests = self._impose_system_workload(
         total_workload, input_requests
       )
@@ -190,4 +191,3 @@ def plot_input_load(
       plt.close()
     else:
       plt.show()
-
diff --git a/heuristic_coordinator.py b/heuristic_coordinator.py
index 29fcd49..a3708d5 100644
--- a/heuristic_coordinator.py
+++ b/heuristic_coordinator.py
@@ -26,8 +26,9 @@ def _check_feasibility(
     total_r = np.zeros(r.shape)
     for (n,f), load in instance[None]["incoming_load"].items():
       x = instance[None]["x_bar"][(n,f)]
+      previous_z = instance[None]["z_bar"][(n,f)]
       # no traffic loss
-      managed_load = x + z[n-1,f-1] + y[n-1,:,f-1].sum()
+      managed_load = x + z[n-1,f-1] + y[n-1,:,f-1].sum() + previous_z
       if abs(managed_load - load) > 1e-3:
         return False, f"no traffic loss: {abs(managed_load - load)} > 1e-3"
       # total number of function replicas
diff --git a/hierarchical_auction/__init__.py b/hierarchical_auction/__init__.py
new file mode 100644
index 0000000..19a6fc4
--- /dev/null
+++ b/hierarchical_auction/__init__.py
@@ -0,0 +1,9 @@
+from hierarchical_auction.engine import HierarchicalAuctionEngine, LevelResult
+from hierarchical_auction.types import AcceptedAllocation, TokenRequest
+
+__all__ = [
+  "AcceptedAllocation",
+  "HierarchicalAuctionEngine",
+  "LevelResult",
+  "TokenRequest",
+]
diff --git a/hierarchical_auction/engine.py b/hierarchical_auction/engine.py
new file mode 100644
index 0000000..3e36dfa
--- /dev/null
+++ b/hierarchical_auction/engine.py
@@ -0,0 +1,344 @@
+"""HierarchicalAuctionEngine: level-by-level orchestration.
+
+Runs higher-level (ℓ ≥ 2) structure-based auctions around the existing
+one-hop auction state.  Builds structures, propagates residual demand,
+generates token requests for seller nodes in adjacent structures,
+resolves conflicts, and maps accepted tokens to concrete y flows.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import cast
+
+import numpy as np
+
+from hierarchical_auction.flow_mapper import apply_allocations
+from hierarchical_auction.pricing import (
+  compute_effective_bid,
+  compute_structure_price,
+  generate_structure_bid,
+)
+from hierarchical_auction.structure import Structure
+from hierarchical_auction.structure_graph import StructureGraph
+from hierarchical_auction.token_manager import CapacityTokenManager
+from hierarchical_auction.types import (
+  AcceptedAllocation,
+  AuctionOptions,
+  FloatArray,
+  TokenRequest,
+)
+
+
+@dataclass
+class LevelResult:
+  """Output of a single run through higher levels."""
+  y: FloatArray
+  omega: FloatArray
+  accepted_allocations: list[AcceptedAllocation] = field(default_factory=list)
+
+
+class HierarchicalAuctionEngine:
+
+  def __init__(
+    self,
+    neighborhood: FloatArray,
+    num_functions: int,
+    service_quantum: FloatArray,
+    max_depth: int = 3,
+    auction_options: AuctionOptions | None = None,
+  ) -> None:
+    self._neighborhood = neighborhood
+    self._num_nodes = neighborhood.shape[0]
+    self._num_functions = num_functions
+    self._service_quantum = np.broadcast_to(
+      np.asarray(service_quantum, dtype=float),
+      (num_functions,),
+    )
+    self.max_depth = max_depth
+    self._options = dict(auction_options or {})
+
+    self._structure_graph = StructureGraph(
+      neighborhood, max_depth=max_depth
+    )
+
+  # ------------------------------------------------------------------
+  # Public entry point
+  # ------------------------------------------------------------------
+
+  def run_higher_levels(
+    self,
+    y: FloatArray,
+    omega: FloatArray,
+    residual_capacity: FloatArray,
+    node_prices: FloatArray,
+    latency: FloatArray,
+    fairness: FloatArray,
+  ) -> LevelResult:
+    """Execute higher-level (ℓ ≥ 2) auctions.
+
+    Parameters
+    ----------
+    y : np.ndarray, shape (Nn, Nn, Nf)
+      Current horizontal offloading matrix (after level 1).
+    omega : np.ndarray, shape (Nn, Nf)
+      Residual demand after level 1.
+    residual_capacity : np.ndarray, shape (Nn, Nf)
+      Current residual capacity C_k^f.
+    node_prices : np.ndarray, shape (Nn, Nf)
+      Current per-node execution prices p_k^f.
+    latency : np.ndarray, shape (Nn, Nn)
+      Communication latency matrix L_{i,j}.
+    fairness : np.ndarray, shape (Nn, Nf)
+      Fairness penalty matrix Φ_k^f.
+
+    Returns
+    -------
+    LevelResult
+      Updated y, omega, and list of accepted allocations.
+    """
+    current_y = y.copy()
+    current_omega = omega.copy()
+    all_accepted: list[AcceptedAllocation] = []
+
+    token_manager = CapacityTokenManager(
+      residual_capacity, self._service_quantum
+    )
+
+    level_structures = self._structure_graph.build_level1(
+      num_functions=self._num_functions
+    )
+    self._aggregate_residual_demand(level_structures, current_omega)
+
+    current_level = 2
+    while current_level <= self.max_depth:
+      if not self._has_residual_demand(level_structures):
+        break
+
+      next_structures = self._structure_graph.aggregate_to_next_level(
+        level_structures, num_functions=self._num_functions,
+      )
+      if not next_structures:
+        break
+
+      self._aggregate_residual_demand(next_structures, current_omega)
+      self._populate_indicative_tokens(next_structures, token_manager)
+
+      eta = self._get_eta(current_level)
+      lat_w = self._options.get("latency_weight", 0.0)
+      fair_w = self._options.get("fairness_weight", 0.0)
+      eps = self._options.get("epsilon", 1e-4)
+
+      requests = self._generate_level_requests(
+        buyer_structures=next_structures,
+        all_structures=next_structures,
+        current_y=current_y,
+        node_prices=node_prices,
+        token_manager=token_manager,
+        latency=latency,
+        fairness=fairness,
+        omega=current_omega,
+        eta=eta,
+        epsilon=eps,
+        latency_weight=lat_w,
+        fairness_weight=fair_w,
+        level=current_level,
+      )
+
+      level_accepted: list[AcceptedAllocation] = []
+      for k in range(self._num_nodes):
+        for f in range(self._num_functions):
+          accepted = token_manager.resolve_node_function(k, f)
+          if accepted:
+            token_manager.commit(accepted)
+            level_accepted.extend(accepted)
+
+      if not level_accepted:
+        break
+
+      all_accepted.extend(level_accepted)
+      current_y, current_omega = apply_allocations(
+        current_y, current_omega, level_accepted,
+      )
+      level_structures = next_structures
+      current_level += 1
+
+    assert token_manager.check_global_feasibility(), (
+      "Invariant 3 violated: committed tokens exceed initial tokens for some (k,f)"
+    )
+    return LevelResult(
+      y=current_y,
+      omega=current_omega,
+      accepted_allocations=all_accepted,
+    )
+
+  # ------------------------------------------------------------------
+  # Internal helpers
+  # ------------------------------------------------------------------
+
+  def _aggregate_residual_demand(
+    self,
+    structures: dict[int, Structure],
+    omega: FloatArray,
+  ) -> None:
+    """Ω_{S_i^(ℓ)}^f = Σ_{k∈S_i^(ℓ)} ω_k^{f,res}  (Eq.24)."""
+    for s in structures.values():
+      members = sorted(s.member_nodes)
+      s.residual_demand = omega[members, :].sum(axis=0)
+
+  def _populate_indicative_tokens(
+    self,
+    structures: dict[int, Structure],
+    token_manager: CapacityTokenManager,
+  ) -> None:
+    """T_{S_i^(ℓ)}^f = Σ_{k∈S} T_k^f (indicative only)."""
+    for s in structures.values():
+      members = sorted(s.member_nodes)
+      s.indicative_tokens = token_manager.tokens[members, :].sum(axis=0)
+
+  def _has_residual_demand(
+    self,
+    structures: dict[int, Structure],
+    tolerance: float = 1e-10,
+  ) -> bool:
+    return any(
+      s.has_any_residual_demand(tolerance=tolerance)
+      for s in structures.values()
+    )
+
+  def _get_eta(self, level: int) -> float:
+    eta_raw = self._options.get("eta", 0.5)
+    if isinstance(eta_raw, (int, float)):
+      return float(eta_raw)
+    eta_list = list(cast(Sequence[float], eta_raw))
+    idx = min(level - 1, len(eta_list) - 1)
+    return float(eta_list[idx])
+
+  def _generate_level_requests(
+    self,
+    buyer_structures: dict[int, Structure],
+    all_structures: dict[int, Structure],
+    current_y: FloatArray,
+    node_prices: FloatArray,
+    token_manager: CapacityTokenManager,
+    latency: FloatArray,
+    fairness: FloatArray,
+    omega: FloatArray,
+    eta: float,
+    epsilon: float,
+    latency_weight: float,
+    fairness_weight: float,
+    level: int,
+  ) -> list[TokenRequest]:
+    """Generate token requests for all buyer structures at a given level.
+
+    For each buyer structure with residual demand, find seller nodes in
+    adjacent structures, compute bid and effective bid, create requests.
+    """
+    requests: list[TokenRequest] = []
+    sending = current_y.sum(axis=1) > 1e-10
+    receiving = current_y.sum(axis=0) > 1e-10
+
+    for root, buyer_s in buyer_structures.items():
+      buyer_s.structure_price = compute_structure_price(
+        buyer_s, node_prices, token_manager.tokens, eta=eta,
+      )
+      for f in range(self._num_functions):
+        if not buyer_s.is_buyer(f):
+          continue
+
+        seller_nodes = self._collect_seller_nodes(
+          buyer_s, all_structures, token_manager, f,
+        )
+        if not seller_nodes:
+          continue
+
+        demand_remaining = buyer_s.residual_demand[f]
+        buyer_nodes = sorted(
+          n for n in buyer_s.member_nodes
+          if omega[n, f] > 1e-10
+        )
+
+        for buyer_node in buyer_nodes:
+          if demand_remaining <= 1e-10:
+            break
+
+          want = min(omega[buyer_node, f], demand_remaining)
+          candidates: list[tuple[float, int, int]] = []
+          for seller_node in seller_nodes:
+            if seller_node == buyer_node:
+              continue
+            if self._neighborhood[buyer_node, seller_node] <= 0:
+              continue
+            if receiving[buyer_node, f] or sending[seller_node, f]:
+              continue
+            available = token_manager.available_tokens(seller_node, f)
+            if available <= 0:
+              continue
+
+            structure_bid = generate_structure_bid(
+              buyer_s.structure_price[f],
+              node_prices[seller_node, f],
+              epsilon=epsilon,
+            )
+            effective = compute_effective_bid(
+              bid=structure_bid,
+              node_price=node_prices[seller_node, f],
+              latency=latency[buyer_node, seller_node],
+              fairness=fairness[buyer_node, f],
+              latency_weight=latency_weight,
+              fairness_weight=fairness_weight,
+            )
+            if effective <= 0.0:
+              continue
+            candidates.append((effective, seller_node, available))
+
+          candidates.sort(reverse=True)
+
+          for effective, seller_node, available in candidates:
+            if want <= 1e-10:
+              break
+
+            quantum = self._service_quantum[f]
+            tokens = min(available, int(np.ceil(want / quantum)))
+            if tokens <= 0:
+              continue
+            quantity = min(want, tokens * quantum)
+
+            req = TokenRequest(
+              level=level,
+              buyer_structure=root,
+              buyer_node=buyer_node,
+              seller_node=seller_node,
+              function=f,
+              tokens=tokens,
+              bid_value=effective,
+              quantity=float(quantity),
+            )
+            requests.append(req)
+            token_manager.request(req)
+            sending[buyer_node, f] = True
+            receiving[seller_node, f] = True
+            want -= quantity
+            demand_remaining -= quantity
+
+    return requests
+
+  def _collect_seller_nodes(
+    self,
+    buyer_s: Structure,
+    all_structures: dict[int, Structure],
+    token_manager: CapacityTokenManager,
+    function: int,
+  ) -> list[int]:
+    """Collect seller nodes from structures adjacent to buyer_s."""
+    seller_nodes: set[int] = set()
+    for adj_root in buyer_s.adjacent_structures:
+      adj_s = all_structures.get(adj_root)
+      if adj_s is None:
+        continue
+      for node in adj_s.member_nodes:
+        if token_manager.available_tokens(node, function) > 0:
+          seller_nodes.add(node)
+    return sorted(seller_nodes)
diff --git a/hierarchical_auction/flow_mapper.py b/hierarchical_auction/flow_mapper.py
new file mode 100644
index 0000000..26462e6
--- /dev/null
+++ b/hierarchical_auction/flow_mapper.py
@@ -0,0 +1,50 @@
+"""Flow mapper: convert accepted token allocations into concrete y updates.
+
+Every accepted allocation must become a concrete (buyer_node, seller_node,
+function, quantity) update to the y[i,j,f] matrix.  This function is pure:
+it copies inputs and returns new arrays.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+
+from hierarchical_auction.types import AcceptedAllocation, FloatArray
+
+
+def apply_allocations(
+  y: FloatArray,
+  omega: FloatArray,
+  allocations: Sequence[AcceptedAllocation],
+) -> tuple[FloatArray, FloatArray]:
+  """Apply accepted allocations to y and residual demand.
+
+  Parameters
+  ----------
+  y : np.ndarray, shape (Nn, Nn, Nf)
+    Current horizontal offloading matrix.
+  omega : np.ndarray, shape (Nn, Nf)
+    Current residual demand per node and function.
+  allocations : list[AcceptedAllocation]
+    Accepted allocations to apply.
+
+  Returns
+  -------
+  tuple[np.ndarray, np.ndarray]
+    (new_y, new_omega) — copies; inputs are never mutated.
+  """
+  new_y = y.copy()
+  new_omega = omega.copy()
+
+  for a in allocations:
+    quantity = min(a.quantity, new_omega[a.buyer_node, a.function])
+    if quantity <= 0:
+      continue
+    new_y[a.buyer_node, a.seller_node, a.function] += quantity
+    new_omega[a.buyer_node, a.function] = max(
+      0.0, new_omega[a.buyer_node, a.function] - quantity
+    )
+
+  return new_y, new_omega
diff --git a/hierarchical_auction/madea_runner.py b/hierarchical_auction/madea_runner.py
new file mode 100644
index 0000000..7db175a
--- /dev/null
+++ b/hierarchical_auction/madea_runner.py
@@ -0,0 +1,432 @@
+"""Hierarchical auction with the production FaaS-MADeA auction at level one."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from collections import deque
+from copy import deepcopy
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from networkx import adjacency_matrix
+
+from hierarchical_auction.engine import HierarchicalAuctionEngine
+from models.sp import LSP, LSPr, LSPr_x
+from run_centralized_model import (
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  save_checkpoint,
+  save_solution,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_centralized_objective,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+
+from run_faasmadea import (
+  check_ls_pr_feasibility_from_fixed_y,
+  check_stopping_criteria,
+  compute_residual_capacity,
+  define_bids,
+  evaluate_bids,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from utils.common import load_configuration
+
+
+def build_auction_options(config: dict[str, Any]) -> dict[str, Any]:
+  options = deepcopy(config.get("solver_options", {}).get("auction", {}))
+  options.setdefault("epsilon", 0.01)
+  options.setdefault("eta", [0.5, 0.3, 0.1])
+  options.setdefault("zeta", 0.1)
+  options.setdefault("latency_weight", 0.0)
+  options.setdefault("fairness_weight", 0.0)
+  options.setdefault("unit_bids", False)
+  return options
+
+
+def level1_options(options: dict[str, Any]) -> dict[str, Any]:
+  result = deepcopy(options)
+  if isinstance(result["eta"], list):
+    result["eta"] = result["eta"][0]
+  return result
+
+
+def compute_offloaded_demand(y: np.ndarray) -> np.ndarray:
+  return y.sum(axis=1)
+
+
+def bids_for_stopping(
+    bids: pd.DataFrame, hierarchical_allocations_count: int,
+  ) -> pd.DataFrame:
+  if len(bids) > 0 or hierarchical_allocations_count <= 0:
+    return bids
+  return pd.DataFrame({"hierarchical_progress": [hierarchical_allocations_count]})
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description = "Hierarchical auction extending production FaaS-MADeA",
+    formatter_class = argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config", default="config_files/manual_config.json"
+  )
+  parser.add_argument(
+    "-j", "--parallelism", type=int, default=-1
+  )
+  parser.add_argument(
+    "--disable_plotting", action="store_true"
+  )
+  return parser.parse_known_args()[0]
+
+
+def run(
+    config: dict[str, Any],
+    parallelism: int = -1,
+    log_on_file: bool = False,
+    disable_plotting: bool = False,
+  ) -> str:
+  del disable_plotting
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = limits["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  solver_name = config["solver_name"]
+  solver_options = config.get("solver_options", {})
+  general_solver_options = solver_options.get("general", {})
+  auction_options = build_auction_options(config)
+  first_level_options = level1_options(auction_options)
+  time_limit = general_solver_options.get("TimeLimit", float("inf"))
+  tolerance = config.get("tolerance", 1e-6)
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  max_hierarchy_depth = config.get("max_hierarchy_depth", 3)
+  patience = config.get("patience", 1)
+
+  now = pd.Timestamp.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as stream:
+    stream.write(json.dumps(config, indent=2))
+  log_stream = open(os.path.join(solution_folder, "out.log"), "w") \
+    if log_on_file else sys.stdout
+
+  base_data, traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder,
+  )
+  Nn = base_data[None]["Nn"][None]
+  Nf = base_data[None]["Nf"][None]
+  neighborhood = neigh_dict_to_matrix(base_data[None]["neighborhood"], Nn)
+  latency = adjacency_matrix(graph, weight="network_latency").toarray()
+  ub = max_run_time + run_time_step if max_run_time == min_run_time else max_run_time
+
+  complete_solution = init_complete_solution()
+  objectives = []
+  termination_conditions = []
+  runtimes = []
+
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    started_at = time.monotonic()
+    total_runtime = 0
+    loadt = get_current_load(traces, agents, t)
+    sp_data = deepcopy(base_data)
+    sp_data[None]["incoming_load"] = loadt
+    sp = LSP()
+    spr = LSPr_x()
+    (
+      sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, _, obj, tc, sp_runtime
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism,
+    )
+    if verbose > 1:
+      print(
+        f"    sp: DONE ({tc['tot']}; obj = {obj['tot']}; "
+        f"x = {sp_x.tolist()}; runtime = {sp_runtime['tot']})", 
+        file = log_stream, 
+        flush = True
+      )
+    total_runtime += sp_runtime['tot']
+    u0 = np.ones((Nn, Nf)) * 0.8
+    p = np.zeros((Nn, Nf))
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    fairness = np.zeros((Nn, Nf))
+    accepted_queue = deque(maxlen=patience)
+    best_solution = None
+    best_cost = -np.inf
+    best_it = -1
+    it = 0
+    stop = False
+    engine = HierarchicalAuctionEngine(
+      neighborhood=neighborhood,
+      num_functions=Nf,
+      service_quantum=np.ones(Nf),
+      max_depth=max_hierarchy_depth,
+      auction_options=auction_options,
+    )
+
+    while not stop:
+      if verbose > 0:
+        print(f"    it = {it}", file=log_stream, flush=True)
+      s = time.monotonic()
+      capacity, residual_capacity, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data,
+      )
+      blackboard = np.maximum(0.0, capacity - sp_x)
+      stalled = (
+        len(accepted_queue) >= accepted_queue.maxlen
+        and all(value == accepted_queue[0] for value in accepted_queue)
+      )
+      e = time.monotonic()
+      total_runtime += (e - s)
+      if verbose > 1:
+        print(
+          f"        compute_residual_capacity: DONE ",
+          f"({capacity.tolist()}; blackboard = {blackboard.tolist()}; "
+          f"ell = {ell.tolist()}; stalled = {stalled}; "
+          f"runtime = {(e - s)})", 
+          file = log_stream, 
+          flush = True
+        )
+      s = time.monotonic()
+      bids, memory_bids, n_auctions = define_bids(
+        omega, blackboard, p, sp_data, neighborhood, sp_rho,
+        first_level_options, latency, fairness,
+        force_memory_bids=(sp_rho > 0).any() and stalled,
+      )
+      e = time.monotonic()
+      rt = (e - s)
+      total_runtime += rt/max(n_auctions, 1)
+      if verbose > 1:
+        print(
+          f"        define_bids: DONE; runtime = {rt/max(n_auctions, 1)}; "
+          f"n_auctions = {n_auctions}; tot runtime = {rt})", 
+          file = log_stream, 
+          flush = True
+        )
+        if verbose > 2:
+          print(bids, file = log_stream, flush = True)
+      additional_replicas = np.zeros((Nn, Nf))
+      if len(bids) > 0:
+        s = time.monotonic()
+        auction_y, p, additional_replicas, n_auctions = evaluate_bids(
+          bids, residual_capacity, sp_data, y, ell, p, capacity, u0,
+          first_level_options, sp_rho, sp_r,
+          tentatively_start_replicas=(len(memory_bids) == 0),
+        )
+        e = time.monotonic()
+        rt = (e - s)
+        total_runtime += rt/max(n_auctions, 1)
+        if verbose > 1:
+          print(
+           f"        evaluate_bids: DONE; runtime = {rt/max(n_auctions, 1)}; "
+           f"n_auctions = {n_auctions}; tot runtime = {rt})", 
+           file = log_stream, 
+           flush = True
+          )
+        y += auction_y
+        rmp_omega = compute_offloaded_demand(y)
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism, sp_x
+        )
+        total_runtime += spr_runtime
+        if verbose > 1:
+          print(
+            f"        solve 'restricted problem': DONE ({spr_tc}; "
+            f"obj: {spr_obj}; runtime = {spr_runtime})", 
+            file = log_stream, 
+            flush = True
+          )
+        _, _, _, _, sp_r, sp_rho = spr_sol
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+        if verbose > 1:
+          print(
+            f"        solution updated: DONE (auct_y = {auction_y.tolist()}; "
+            f"omega = {omega.tolist()}; x = {sp_x.tolist()}; "
+            f"r = {sp_r.tolist()}; rho = {sp_rho.tolist()}; ", 
+            f"y = {y.tolist()})", 
+            file = log_stream, 
+            flush = True
+          )
+
+      if len(memory_bids) > 0 and not (additional_replicas > 0).any():
+        s = time.monotonic()
+        additional_replicas, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho,
+        )
+        sp_r += additional_replicas
+        e = time.monotonic()
+        total_runtime += (e - s)
+        if verbose > 1:
+          print(
+            f"        additional replicas started: DONE "
+            f"(a = {additional_replicas.tolist()}; "
+            f"rho = {sp_rho.tolist()}; runtime = {(e - s)})", 
+            file = log_stream, 
+            flush = True
+          )
+      s = time.monotonic()
+      _, residual_capacity, _ = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data,
+      )
+      result = engine.run_higher_levels(
+        y=y,
+        omega=omega,
+        residual_capacity=residual_capacity,
+        node_prices=p,
+        latency=latency,
+        fairness=fairness,
+      )
+      y = result.y
+      rmp_omega = compute_offloaded_demand(y)
+      e = time.monotonic()
+      total_runtime += (e - s)
+      if verbose > 1:
+        print(
+          f"        higher-level auction: DONE (y = {y.tolist()}; "
+          f"rmp_omega = {rmp_omega.tolist()}; runtime = {(e - s)})", 
+          file = log_stream, 
+          flush = True
+        )
+      if result.accepted_allocations:
+        bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
+        if bad_nodes:
+          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+        spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism, sp_x
+        )
+        total_runtime += spr_runtime
+        _, _, _, _, sp_r, sp_rho = spr_sol
+        if verbose > 1:
+          print(
+            f"        solve 'restricted problem': DONE ({spr_tc}; "
+            f"obj: {spr_obj}; runtime = {spr_runtime})", 
+            file = log_stream, 
+            flush = True
+          )
+      omega = sp_omega - rmp_omega
+      omega[np.abs(omega) < tolerance] = 0.0
+      fairness += (rmp_omega > 0).astype(fairness.dtype)
+      accepted_queue.append(float(rmp_omega.sum()))
+
+      _, final_residual, _ = compute_residual_capacity(sp_x, y, sp_r, sp_data)
+      combined = combine_solutions(
+        Nn, Nf, sp_data, loadt,
+        sp_x, sp_r, sp_rho,
+        None, y, None, None, None, None,
+      )
+      cost = compute_centralized_objective(
+        sp_data, combined["sp"]["x"], combined["sp"]["y"], combined["sp"]["z"],
+      )
+      if cost > best_cost:
+        best_cost = cost
+        best_solution = deepcopy(combined)
+        best_it = it
+
+      elapsed = time.monotonic() - started_at
+      s = time.monotonic()
+      stop, reason = check_stopping_criteria(
+        it=it,
+        max_iterations=max_iterations,
+        blackboard=final_residual,
+        omega=omega,
+        rmp_omega=rmp_omega,
+        a=additional_replicas,
+        bids=bids_for_stopping(bids, len(result.accepted_allocations)),
+        memory_bids=memory_bids,
+        tolerance=tolerance,
+        total_runtime=total_runtime,
+        time_limit=time_limit,
+      )
+      e = time.monotonic()
+      if verbose > 1:
+        print(
+          f"        check_stopping_criteria: DONE "
+          f"(runtime = {(e - s)}; "
+          f"total runtime = {total_runtime}; "
+          f"wallclock: {elapsed}) "
+          f"--> stop? {stop} ({reason})", 
+          file = log_stream, 
+          flush = True
+        )
+      if stop:
+        complete_solution, _, objective = decode_solutions(
+          sp_data, best_solution, complete_solution, None,
+        )
+        objectives.append(objective)
+        termination_conditions.append(
+          f"{reason} (it: {it}; obj. deviation: None; best it: {best_it}; "
+          f"best centralized it: {best_it}; total runtime: {total_runtime})"
+        )
+        runtimes.append(total_runtime)
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            complete_solution, os.path.join(solution_folder, "LSPc"), t
+          )
+        if verbose > 0:
+          print(
+            f"    TOTAL RUNTIME [s] = {total_runtime} "
+            f"(wallclock: {elapsed})",
+            file = log_stream, 
+            flush = True
+          )
+      else:
+        it += 1
+
+  solution, offloaded, detailed = join_complete_solution(complete_solution)
+  save_solution(
+    solution, offloaded, complete_solution, detailed, "LSPc", solution_folder,
+  )
+  pd.DataFrame({"HierarchicalMADeA": objectives}).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False,
+  )
+  pd.DataFrame(termination_conditions).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv"),
+  )
+  pd.DataFrame({"tot": runtimes}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False,
+  )
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config_file = args.config
+  parallelism = args.parallelism
+  disable_plotting = args.disable_plotting
+  # load configuration file
+  config = load_configuration(config_file)
+  # run
+  run(
+    config,
+    parallelism = parallelism, 
+    log_on_file = False, 
+    disable_plotting=disable_plotting,
+  )
diff --git a/hierarchical_auction/pricing.py b/hierarchical_auction/pricing.py
new file mode 100644
index 0000000..942f796
--- /dev/null
+++ b/hierarchical_auction/pricing.py
@@ -0,0 +1,65 @@
+"""Structure-level pricing functions.
+
+Eq.27: p_{S_i^(ℓ)}^f = p̄ + η_ℓ · Ω^f / (Ω^f + T^f + ε)
+Eq.28: b_{S_i^(ℓ)}^f = p_{S_i^(ℓ)}^f + ε
+Eq.22: b_{S→k}^f ≥ p_k^f (enforced via max)
+Eq.19: b̃ = b - p_k^f - w_lat·L - w_fair·Φ
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from hierarchical_auction.structure import Structure
+from hierarchical_auction.types import FloatArray
+
+
+def compute_structure_price(
+  structure: Structure,
+  node_prices: FloatArray,
+  node_tokens: FloatArray,
+  eta: float,
+  epsilon: float = 1e-6,
+) -> FloatArray:
+  """Compute structure-level execution price (Eq.27).
+
+  p̄ = (1/|S|) · Σ_{k∈S} p_k^f
+  congestion = Ω^f / (Ω^f + T^f + ε)
+  return p̄ + η · congestion, clipped to [0, ∞).
+  """
+  members = sorted(structure.member_nodes)
+  if not members:
+    return np.zeros(structure.num_functions, dtype=float)
+
+  avg_price = node_prices[members, :].mean(axis=0)
+  omega = structure.residual_demand
+  tokens_sum = node_tokens[members, :].sum(axis=0)
+  congestion = omega / (omega + tokens_sum + epsilon)
+  return np.maximum(avg_price + eta * congestion, 0.0)
+
+
+def generate_structure_bid(
+  structure_price: float,
+  node_price: float,
+  epsilon: float = 1e-4,
+) -> float:
+  """Generate bid from structure to a specific seller node.
+
+  Eq.28 + Eq.22: bid = max(p_S + ε, p_k).
+  """
+  return max(structure_price + epsilon, node_price)
+
+
+def compute_effective_bid(
+  bid: float,
+  node_price: float,
+  latency: float,
+  fairness: float,
+  latency_weight: float,
+  fairness_weight: float,
+) -> float:
+  """Compute effective bid value for seller-side sorting (Eq.19).
+
+  b̃ = bid - p_k - w_lat·L - w_fair·Φ
+  """
+  return bid - node_price - latency_weight * latency - fairness_weight * fairness
diff --git a/hierarchical_auction/runner.py b/hierarchical_auction/runner.py
new file mode 100644
index 0000000..4cdf40c
--- /dev/null
+++ b/hierarchical_auction/runner.py
@@ -0,0 +1,371 @@
+"""Standalone runner for the hierarchical multi-structure auction.
+
+Follows the same lifecycle as decentralized_auction.run():
+init -> time loop -> iteration loop -> save.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections.abc import Mapping
+from copy import deepcopy
+from datetime import datetime
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from networkx import adjacency_matrix as nx_adjacency_matrix
+
+from decentralized_auction import (
+  check_stopping_criteria,
+  compute_residual_capacity,
+  define_bids,
+  evaluate_bids,
+  neigh_dict_to_matrix,
+  start_additional_replicas,
+)
+from hierarchical_auction.engine import HierarchicalAuctionEngine
+from hierarchical_auction.types import FloatArray
+from models.sp import LSP, LSPr, LSPr_x
+from run_centralized_model import (
+  get_current_load,
+  init_complete_solution,
+  init_problem,
+  join_complete_solution,
+  plot_history,
+  save_checkpoint,
+  save_solution,
+)
+from run_faasmacro import (
+  combine_solutions,
+  compute_centralized_objective,
+  compute_social_welfare,
+  decode_solutions,
+  solve_subproblem,
+)
+from utils.common import load_configuration
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run Hierarchical Multi-Structure Auction",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument(
+    "-c", "--config",
+    help="Configuration file",
+    type=str,
+    default="config_files/manual_config.json",
+  )
+  parser.add_argument(
+    "-j", "--parallelism",
+    help="Number of parallel processes (-1: auto, 0: sequential)",
+    type=int,
+    default=-1,
+  )
+  parser.add_argument(
+    "--disable_plotting",
+    help="Disable automatic plot generation",
+    default=False,
+    action="store_true",
+  )
+  return parser.parse_known_args()[0]
+
+
+def build_auction_options(config: Mapping[str, Any]) -> dict[str, object]:
+  solver_options = config.get("solver_options", {})
+  auction = solver_options.get("auction", {})
+  return {
+    "epsilon": auction.get("epsilon", 0.01),
+    "eta": auction.get("eta", [0.5, 0.3, 0.1]),
+    "zeta": auction.get("zeta", 0.1),
+    "latency_weight": auction.get("latency_weight", 0.0),
+    "fairness_weight": auction.get("fairness_weight", 0.0),
+  }
+
+
+def compute_offloaded_demand(y: FloatArray) -> FloatArray:
+  """Return total offloaded demand per buyer node/function."""
+  return y.sum(axis=1)
+
+
+def bids_for_stopping(
+  bids: pd.DataFrame,
+  hierarchical_allocations_count: int,
+) -> pd.DataFrame:
+  """Avoid treating a productive hierarchical round as no-progress."""
+  if len(bids) > 0 or hierarchical_allocations_count <= 0:
+    return bids
+  return pd.DataFrame({"hierarchical_progress": [hierarchical_allocations_count]})
+
+
+def _extract_latency(graph: Any) -> FloatArray:
+  return nx_adjacency_matrix(graph, weight="network_latency").toarray()
+
+
+def run(
+  config: dict[str, Any],
+  parallelism: int = -1,
+  log_on_file: bool = False,
+  disable_plotting: bool = False,
+) -> str:
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = config["limits"]["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+
+  solver_name = config["solver_name"]
+  solver_options = config.get("solver_options", {})
+  general_solver_options = solver_options.get("general", {})
+  auction_options = build_auction_options(config)
+  time_limit = general_solver_options.get("TimeLimit", float("inf"))
+  tolerance = config.get("tolerance", 1e-6)
+
+  max_iterations = config["max_iterations"]
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  max_hierarchy_depth = config.get("max_hierarchy_depth", 3)
+
+  now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder,
+  )
+  Nn = base_instance_data[None]["Nn"][None]
+  Nf = base_instance_data[None]["Nf"][None]
+
+  neighborhood = neigh_dict_to_matrix(
+    base_instance_data[None]["neighborhood"], Nn,
+  )
+  latency = _extract_latency(graph)
+
+  ub = (max_run_time + run_time_step) if max_run_time == min_run_time else max_run_time
+  spc_complete_solution = init_complete_solution()
+  obj_dict: dict[str, list[Any]] = {"LSPr_final": []}
+  tc_dict: dict[str, list[Any]] = {"LSPr": []}
+  runtime_list: list[float] = []
+
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+
+    loadt = get_current_load(input_requests_traces, agents, t)
+    data = deepcopy(base_instance_data)
+    data[None]["incoming_load"] = loadt
+
+    u0 = np.ones((Nn, Nf)) * 0.9
+    p = np.zeros((Nn, Nf))
+    fairness = np.zeros((Nn, Nf))
+
+    sp_data = deepcopy(data)
+    sp = LSP()
+    spr = LSPr_x()
+    (
+      sp_data, sp_x, _, _sp_z, sp_omega, sp_r, sp_rho, _sp_u,
+      _obj, _tc, sp_runtime,
+    ) = solve_subproblem(
+      sp_data, agents, sp, solver_name, general_solver_options, parallelism,
+    )
+    total_runtime = sp_runtime["tot"] if isinstance(sp_runtime, dict) else 0.0
+
+    it = 0
+    stop_searching = False
+    y = np.zeros((Nn, Nn, Nf))
+    omega = deepcopy(sp_omega)
+    rmp_omega = np.zeros((Nn, Nf))
+    best_centralized_solution: dict | None = None
+    best_centralized_cost = -np.inf
+    best_centralized_it = -1
+    engine = HierarchicalAuctionEngine(
+      neighborhood=neighborhood,
+      num_functions=Nf,
+      service_quantum=np.ones(Nf),
+      max_depth=max_hierarchy_depth,
+      auction_options=auction_options,
+    )
+
+    while not stop_searching:
+      if verbose > 0:
+        print(f"    it = {it}", file=log_stream, flush=True)
+
+      capacity, blackboard, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data,
+      )
+
+      level1_options = dict(auction_options)
+      if isinstance(level1_options.get("eta"), list):
+        level1_options["eta"] = level1_options["eta"][0]
+
+      bids, memory_bids = define_bids(
+        omega, blackboard, p, sp_data, neighborhood, sp_rho,
+        level1_options,
+        latency=latency,
+        fairness=fairness,
+        delta=np.zeros((Nn, Nn)),
+      )
+
+      if len(bids) > 0:
+        auction_y, p = evaluate_bids(
+          bids, blackboard, sp_data, ell, p, capacity, u0,
+          level1_options, current_y=y,
+        )
+        y += auction_y
+
+        rmp_omega = compute_offloaded_demand(y)
+        fairness += (rmp_omega > 0).astype(fairness.dtype)
+
+        spr_sol, _spr_obj, _spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism, sp_x
+        )
+        total_runtime += spr_runtime if isinstance(spr_runtime, (int, float)) else 0.0
+
+        # sp_x = spr_sol[0]
+        sp_r = spr_sol[4]
+        sp_rho = spr_sol[5]
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+      else:
+        a, sp_rho = start_additional_replicas(
+          memory_bids, sp_r, sp_data, sp_rho,
+        )
+        sp_r += a
+
+      capacity, blackboard, ell = compute_residual_capacity(
+        sp_x, y, sp_r, sp_data,
+      )
+
+      result = engine.run_higher_levels(
+        y=y,
+        omega=omega,
+        residual_capacity=blackboard,
+        node_prices=p,
+        latency=latency,
+        fairness=fairness,
+      )
+      y = result.y
+      rmp_omega = compute_offloaded_demand(y)
+
+      if result.accepted_allocations:
+        spr_sol, _spr_obj, _spr_tc, spr_runtime = compute_social_welfare(
+          spr, sp_data, agents, solver_name, general_solver_options,
+          y, rmp_omega, parallelism, sp_x
+        )
+        total_runtime += (
+          spr_runtime if isinstance(spr_runtime, (int, float)) else 0.0
+        )
+
+        # sp_x = spr_sol[0]
+        sp_r = spr_sol[4]
+        sp_rho = spr_sol[5]
+        omega = sp_omega - rmp_omega
+        omega[np.abs(omega) < tolerance] = 0.0
+
+      stopping_bids = bids_for_stopping(
+        bids, len(result.accepted_allocations),
+      )
+      stop_searching, why_stop_searching = check_stopping_criteria(
+        it, max_iterations, blackboard, omega, rmp_omega,
+        stopping_bids, memory_bids, tolerance, total_runtime, time_limit,
+      )
+
+      csol = combine_solutions(
+        Nn, Nf, sp_data, loadt,
+        sp_x, sp_r, sp_rho,
+        np.zeros((Nn, Nf)), y, np.zeros((Nn, Nf)),
+        np.zeros((Nn, Nf)), np.zeros((Nn, Nn, Nf)),
+        np.zeros((Nn,)),
+      )
+      cobj = compute_centralized_objective(
+        sp_data, csol["sp"]["x"], csol["sp"]["y"], csol["sp"]["z"],
+      )
+
+      if cobj > best_centralized_cost:
+        best_centralized_cost = cobj
+        best_centralized_solution = csol
+        best_centralized_it = it
+
+      if not stop_searching:
+        it += 1
+      else:
+        spc_complete_solution, _, _ = decode_solutions(
+          sp_data,
+          best_centralized_solution if best_centralized_solution is not None else csol,
+          spc_complete_solution, None,
+        )
+        obj_dict["LSPr_final"].append(best_centralized_cost)
+        tc_dict["LSPr"].append(
+          f"{why_stop_searching} (it: {it}; "
+          f"best centralized it: {best_centralized_it}; "
+          f"total runtime: {total_runtime})"
+        )
+        runtime_list.append(total_runtime)
+        if t % checkpoint_interval == 0 or t == max_steps - 1:
+          save_checkpoint(
+            spc_complete_solution,
+            os.path.join(solution_folder, "LSPc"), t,
+          )
+
+  spc_solution, spc_offloaded, spc_detailed_fwd_solution = join_complete_solution(
+    spc_complete_solution,
+  )
+  if not disable_plotting:# and Nf <= 10 and Nn <= 10:
+    plot_history(
+      input_requests_traces, 
+      min_run_time,
+      max_run_time,
+      run_time_step,
+      spc_solution, 
+      spc_complete_solution["utilization"], 
+      spc_complete_solution["replicas"], 
+      spc_offloaded,
+      # obj_dict["LSP"][max_iterations-1],
+      obj_dict["LSPr_final"],
+      os.path.join(solution_folder, "sp.png")
+    )
+  save_solution(
+    spc_solution, spc_offloaded, spc_complete_solution,
+    spc_detailed_fwd_solution, "LSPc", solution_folder,
+  )
+  pd.DataFrame(obj_dict["LSPr_final"], columns=["HierarchicalAuction"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False,
+  )
+  pd.DataFrame(tc_dict["LSPr"]).to_csv(
+    os.path.join(solution_folder, "termination_condition.csv"),
+  )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False,
+  )
+
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream, flush=True)
+  if log_on_file and log_stream is not sys.stdout:
+    log_stream.close()
+
+  return solution_folder
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  config = load_configuration(args.config)
+  run(
+    config,
+    parallelism=args.parallelism,
+    log_on_file=False,
+    disable_plotting=args.disable_plotting,
+  )
diff --git a/hierarchical_auction/structure.py b/hierarchical_auction/structure.py
new file mode 100644
index 0000000..ae8ae35
--- /dev/null
+++ b/hierarchical_auction/structure.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from hierarchical_auction.types import FloatArray
+
+
+@dataclass
+class Structure:
+  """Coordination domain at a given hierarchy level.
+
+  S_i^(ℓ) — Eq.23: structures aggregate adjacent structures from
+  the previous level.  Structures do NOT own capacity; they only
+  coordinate access to node-owned tokens.
+  """
+
+  level: int
+  root_node: int
+  member_nodes: set[int]
+  adjacent_structures: set[int]
+  num_functions: int
+
+  residual_demand: FloatArray = field(init=False)
+  structure_price: FloatArray = field(init=False)
+  indicative_tokens: FloatArray = field(init=False)
+
+  def __post_init__(self) -> None:
+    self.residual_demand = np.zeros(self.num_functions, dtype=float)
+    self.structure_price = np.zeros(self.num_functions, dtype=float)
+    self.indicative_tokens = np.zeros(self.num_functions, dtype=float)
+
+  @property
+  def size(self) -> int:
+    return len(self.member_nodes)
+
+  def is_buyer(self, f: int, tolerance: float = 1e-10) -> bool:
+    return bool(self.residual_demand[f] > tolerance)
+
+  def has_any_residual_demand(self, tolerance: float = 1e-10) -> bool:
+    return bool((self.residual_demand > tolerance).any())
diff --git a/hierarchical_auction/structure_graph.py b/hierarchical_auction/structure_graph.py
new file mode 100644
index 0000000..b1435cd
--- /dev/null
+++ b/hierarchical_auction/structure_graph.py
@@ -0,0 +1,91 @@
+"""StructureGraph: adjacency and recursive aggregation of structures.
+
+S_i^(1) = {i} ∪ N_i                                    (level 1)
+S_i^(ℓ) = ⋃_{j ∈ A_i^(ℓ-1)} S_j^(ℓ-1)                  (ℓ ≥ 2)
+
+Adjacency (Eq.16): (S_i, S_j) ∈ E_S ⇔ ∃ u∈S_i, v∈S_j with (u,v)∈E.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from hierarchical_auction.structure import Structure
+from hierarchical_auction.types import FloatArray
+
+
+class StructureGraph:
+
+  def __init__(
+    self,
+    neighborhood: FloatArray,
+    max_depth: int = 5,
+  ) -> None:
+    self._neighborhood = neighborhood
+    self._num_nodes = neighborhood.shape[0]
+    self.max_depth = max_depth
+
+  def build_level1(self, num_functions: int) -> dict[int, Structure]:
+    structures: dict[int, Structure] = {}
+    for i in range(self._num_nodes):
+      neighbors = set(np.nonzero(self._neighborhood[i])[0])
+      members = {i} | neighbors
+      structures[i] = Structure(
+        level=1,
+        root_node=i,
+        member_nodes=members,
+        adjacent_structures=set(),
+        num_functions=num_functions,
+      )
+    self.build_adjacency(structures)
+    return structures
+
+  def build_adjacency(self, structures: dict[int, Structure]) -> None:
+    roots = sorted(structures.keys())
+    for s in structures.values():
+      s.adjacent_structures.clear()
+    for idx_a, ri in enumerate(roots):
+      si = structures[ri]
+      for rj in roots[idx_a + 1:]:
+        sj = structures[rj]
+        if self.are_adjacent(si, sj):
+          si.adjacent_structures.add(rj)
+          sj.adjacent_structures.add(ri)
+
+  def are_adjacent(self, si: Structure, sj: Structure) -> bool:
+    for u in si.member_nodes:
+      for v in sj.member_nodes:
+        if self._neighborhood[u, v] > 0:
+          return True
+    return False
+
+  def aggregate_to_next_level(
+    self,
+    prev_level: dict[int, Structure],
+    num_functions: int,
+  ) -> dict[int, Structure]:
+    if not prev_level:
+      return {}
+
+    new_level_num = max(s.level for s in prev_level.values()) + 1
+    structures: dict[int, Structure] = {}
+
+    for root, s_prev in prev_level.items():
+      if not s_prev.adjacent_structures:
+        continue
+
+      merged_members: set[int] = set(s_prev.member_nodes)
+      for adj_root in s_prev.adjacent_structures:
+        if adj_root in prev_level:
+          merged_members.update(prev_level[adj_root].member_nodes)
+
+      structures[root] = Structure(
+        level=new_level_num,
+        root_node=root,
+        member_nodes=merged_members,
+        adjacent_structures=set(),
+        num_functions=num_functions,
+      )
+
+    self.build_adjacency(structures)
+    return structures
diff --git a/hierarchical_auction/token_manager.py b/hierarchical_auction/token_manager.py
new file mode 100644
index 0000000..eb479f6
--- /dev/null
+++ b/hierarchical_auction/token_manager.py
@@ -0,0 +1,112 @@
+"""CapacityTokenManager: collect requests, resolve conflicts, commit.
+
+Each node k owns T_k^f = floor(C_k^f / Delta_k^f) indivisible tokens.
+Multiple structures may request the same (k,f); resolution happens
+after all requests are collected for an auction round.
+Commits are cumulative: accepted tokens are permanently subtracted.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+
+from hierarchical_auction.types import AcceptedAllocation, FloatArray, IntArray, TokenRequest
+
+
+class CapacityTokenManager:
+  def __init__(
+    self,
+    residual_capacity: FloatArray,
+    service_quantum: FloatArray,
+  ) -> None:
+    self._num_nodes, self._num_functions = residual_capacity.shape
+    sq = np.broadcast_to(
+      np.asarray(service_quantum, dtype=float),
+      residual_capacity.shape,
+    )
+    if (sq <= 0).any():
+      raise ValueError("service_quantum must be positive")
+    self._service_quantum = sq
+    residual_capacity = np.maximum(residual_capacity, 0.0)
+    self._initial_tokens = np.floor(
+      residual_capacity / np.maximum(sq, 1e-12)
+    ).astype(int)
+    self._current_tokens = self._initial_tokens.copy()
+
+    self._pending: list[list[list[TokenRequest]]] = [
+      [[] for _ in range(self._num_functions)]
+      for _ in range(self._num_nodes)
+    ]
+
+  @property
+  def tokens(self) -> IntArray:
+    return self._current_tokens
+
+  def available_tokens(self, node: int, function: int) -> int:
+    return int(self._current_tokens[node, function])
+
+  def pending_requests(
+    self, node: int, function: int
+  ) -> list[TokenRequest]:
+    return list(self._pending[node][function])
+
+  def request(self, req: TokenRequest) -> None:
+    """Register a token request without reducing availability."""
+    if req.tokens <= 0:
+      raise ValueError("tokens must be positive")
+    self._pending[req.seller_node][req.function].append(req)
+
+  def resolve_node_function(
+    self, node: int, function: int
+  ) -> list[AcceptedAllocation]:
+    """Resolve pending requests for (node, function)."""
+    pending = self._pending[node][function]
+    if not pending:
+      return []
+
+    sorted_reqs = sorted(pending, key=lambda r: r.bid_value, reverse=True)
+    remaining = self._current_tokens[node, function]
+    accepted: list[AcceptedAllocation] = []
+
+    for req in sorted_reqs:
+      take = min(req.tokens, remaining)
+      if take > 0:
+        accepted_quantity = min(
+          req.quantity,
+          take * self._service_quantum[node, function],
+        )
+        accepted.append(AcceptedAllocation(
+          level=req.level,
+          buyer_structure=req.buyer_structure,
+          buyer_node=req.buyer_node,
+          seller_node=req.seller_node,
+          function=req.function,
+          tokens=take,
+          quantity=float(accepted_quantity),
+          bid_value=req.bid_value,
+        ))
+        remaining -= take
+      if remaining <= 0:
+        break
+
+    return accepted
+
+  def commit(self, allocations: Sequence[AcceptedAllocation]) -> None:
+    """Permanently subtract accepted token counts from current tokens."""
+    committed: dict[tuple[int, int], int] = {}
+    for a in allocations:
+      key = (a.seller_node, a.function)
+      committed[key] = committed.get(key, 0) + a.tokens
+
+    for (node, function), total in committed.items():
+      self._current_tokens[node, function] = max(
+        0, self._current_tokens[node, function] - total
+      )
+      self._pending[node][function].clear()
+
+  def check_global_feasibility(self) -> bool:
+    """Verify Eq.26: committed <= initial tokens for every (k,f)."""
+    committed = self._initial_tokens - self._current_tokens
+    return bool((committed >= 0).all() and (committed <= self._initial_tokens).all())
diff --git a/hierarchical_auction/types.py b/hierarchical_auction/types.py
new file mode 100644
index 0000000..5a9df60
--- /dev/null
+++ b/hierarchical_auction/types.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+FloatArray: TypeAlias = NDArray[np.float64]
+IntArray: TypeAlias = NDArray[np.int_]
+AuctionOptions: TypeAlias = Mapping[str, object]
+
+
+@dataclass(frozen=True)
+class TokenRequest:
+  level: int
+  buyer_structure: int
+  buyer_node: int
+  seller_node: int
+  function: int
+  tokens: int
+  bid_value: float
+  quantity: float
+
+  def __post_init__(self) -> None:
+    if self.tokens <= 0:
+      raise ValueError("tokens must be positive")
+    if self.quantity <= 0:
+      raise ValueError("quantity must be positive")
+
+
+@dataclass(frozen=True)
+class AcceptedAllocation:
+  level: int
+  buyer_structure: int
+  buyer_node: int
+  seller_node: int
+  function: int
+  tokens: int
+  quantity: float
+  bid_value: float
diff --git a/load_generator.py b/load_generator.py
new file mode 100644
index 0000000..582d3c1
--- /dev/null
+++ b/load_generator.py
@@ -0,0 +1 @@
+from generators.load_generator import *  # noqa: F403
diff --git a/logs_postprocessing.py b/logs_postprocessing.py
index 33a6747..f0575d0 100644
--- a/logs_postprocessing.py
+++ b/logs_postprocessing.py
@@ -17,7 +17,7 @@ def get_faasmacro_runtime(
       runtime_cols = []
       for col in t_data.columns:
         if col.endswith("runtime"):
-          if "MACrO" in method or (not col.startswith("sp")):
+          if method == "" or "MACrO" in method or (not col.startswith("sp")):
             runtime_cols.append(col)
       time_data = t_data.loc[:,runtime_cols].copy(
         deep = True
@@ -293,6 +293,8 @@ def parse_faasmacro_log_file(
             df["wallclock_time"] += [float(wct)] * n_iterations
             t_row_idx += 1
             n_iterations = 0
+        else:
+          t_row_idx += 1
       # add number of nodes
       df["Nn"] = [Nn] * len(df["exp"])
       # merge and move to the next time step
@@ -384,12 +386,12 @@ def parse_faasmadea_log_file(
             # load sp info
             if "sp: DONE" in lines[it_row_idx]:
               sp_runtime = None
-              if "runtime" in lines[t_row_idx]:
+              if "runtime" in lines[it_row_idx]:
                 _, _, sp_runtime = parse.parse(
                   "        sp: DONE  ({}; obj = {}; runtime = {})\n", 
-                  lines[t_row_idx]
+                  lines[it_row_idx]
                 )
-              df["sp_runtime"].append(float(runtime) if sp_runtime else None)
+              df["sp_runtime"].append(float(sp_runtime) if sp_runtime else None)
             elif "define_bids" in lines[it_row_idx]:
               runtime = None
               if "runtime" in lines[it_row_idx]:
@@ -403,10 +405,18 @@ def parse_faasmadea_log_file(
             elif "evaluate_bids" in lines[it_row_idx]:
               runtime = None
               if "runtime" in lines[it_row_idx]:
-                _, runtime = parse.parse(
+                parsed_eval = parse.parse(
                   "        evaluate_bids: DONE; obj = {}; runtime = {})\n",
                   lines[it_row_idx]
                 )
+                if parsed_eval is None:
+                  parsed_eval = parse.parse(
+                    "        evaluate_bids: DONE; runtime = {})\n",
+                    lines[it_row_idx]
+                  )
+                  runtime = parsed_eval[0] if parsed_eval else None
+                else:
+                  _, runtime = parsed_eval
               df["evaluate_bids_runtime"].append(
                 float(runtime) if runtime else None
               )
@@ -471,6 +481,8 @@ def parse_faasmadea_log_file(
             df["wallclock_time"] += [float(wct)] * n_iterations
             t_row_idx += 1
             n_iterations = 0
+        else:
+          t_row_idx += 1
       # add number of nodes
       df["Nn"] = [Nn] * len(df["exp"])
       # correct potential issues in array lengths
@@ -488,6 +500,8 @@ def parse_faasmadea_log_file(
             lines[t_row_idx].startswith("All solutions saved")
         ):
         row_idx += 1
+    else:
+      row_idx += 1
   best_solution_df["social_welfare"] = pd.concat(
     [
       best_sol_df.get("social_welfare", pd.DataFrame()), 
@@ -541,11 +555,13 @@ def parse_faasmadea0_log_file(
       # load sp info
       sp_runtime = None
       if "sp" in lines[t_row_idx] and "runtime" in lines[t_row_idx]:
-        _, _, sp_runtime = parse.parse(
-          "    sp: DONE ({}; obj = {}; runtime = {})\n", 
+        parsed_sp = parse.parse(
+          "    sp: DONE{}({}; obj = {}; runtime = {})\n", 
           lines[t_row_idx]
         )
-      t_row_idx += 1
+        if parsed_sp is not None:
+          _, _, _, sp_runtime = parsed_sp
+          t_row_idx += 1
       # loop over iterations
       df = {
         "exp": [],
@@ -652,7 +668,7 @@ def parse_faasmadea0_log_file(
               best_solution_df["centralized"]["Nn"].append(Nn)
             it_row_idx += 1
           # save iteration info
-          df["sp_runtime"].append(float(runtime) if sp_runtime else None)
+          df["sp_runtime"].append(float(sp_runtime) if sp_runtime else None)
           df["iteration"].append(it)
           df["time"].append(t)
           df["exp"].append(exp)
@@ -675,6 +691,8 @@ def parse_faasmadea0_log_file(
             df["wallclock_time"] += [float(wct)] * n_iterations
             t_row_idx += 1
             n_iterations = 0
+        else:
+          t_row_idx += 1
       # add number of nodes
       df["Nn"] = [Nn] * len(df["exp"])
       # correct potential issues in array lengths
@@ -693,6 +711,8 @@ def parse_faasmadea0_log_file(
             lines[t_row_idx].startswith("All solutions saved")
         ):
         row_idx += 1
+    else:
+      row_idx += 1
   best_solution_df["social_welfare"] = pd.concat(
     [
       best_sol_df.get("social_welfare", pd.DataFrame()), 
diff --git a/models/__init__.py b/models/__init__.py
new file mode 100644
index 0000000..2accd06
--- /dev/null
+++ b/models/__init__.py
@@ -0,0 +1 @@
+"""Optimization model definitions."""
diff --git a/models/auction_models.py b/models/auction_models.py
index 93162aa..b47077a 100644
--- a/models/auction_models.py
+++ b/models/auction_models.py
@@ -65,9 +65,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.maximize_utility, sense = pyo.maximize
-    )
+    self.set_objective(rule = self.maximize_utility, sense = pyo.maximize)
   
   @staticmethod
   def no_traffic_loss(model, f):
@@ -163,9 +161,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.maximize_processing, sense = pyo.maximize
-    )
+    self.set_objective(rule = self.maximize_processing, sense = pyo.maximize)
   
   @staticmethod
   def no_traffic_loss(model, n, f):
diff --git a/models/model.py b/models/model.py
index 9fde6dc..9c27334 100644
--- a/models/model.py
+++ b/models/model.py
@@ -12,6 +12,15 @@
 PYO_PARAM_TYPE = pyo.NonNegativeReals
 
 
+_SOLVER_CACHE: dict = {}
+
+
+def _solver_option_name(solver_name: str, option_name: str) -> str:
+  if solver_name in {"glpk", "glpsol"} and option_name == "TimeLimit":
+    return "tmlim"
+  return option_name
+
+
 class BaseAbstractModel():
   def __init__(self):
     self.model = pyo.AbstractModel()
@@ -23,6 +32,11 @@ def _provide_initial_solution(self, instance, initial_solution):
   
   def generate_instance(self, data: dict):
     return self.model.create_instance(data)
+
+  def set_objective(self, rule, sense = pyo.minimize) -> None:
+    if hasattr(self.model, "OBJ"):
+      self.model.del_component(self.model.OBJ)
+    self.model.OBJ = pyo.Objective(rule = rule, sense = sense)
   
   def solve(
       self, 
@@ -31,10 +45,15 @@ def solve(
       solver_name: str = "glpk",
       initial_solution: dict = None
     ):
-    # initialize solver and set options
-    solver = pyo.SolverFactory(solver_name)
+    # initialize solver and set options (cached per process: SolverFactory
+    # re-creates the Gurobi environment/license handshake on every call,
+    # which dominated runtime for the small per-node subproblems)
+    solver = _SOLVER_CACHE.get(solver_name)
+    if solver is None:
+      solver = pyo.SolverFactory(solver_name)
+      _SOLVER_CACHE[solver_name] = solver
     for k, v in solver_options.items():
-      solver.options[k] = v
+      solver.options[_solver_option_name(solver_name, k)] = v
     # provide initial solution (if any)
     warmstart = False
     if initial_solution is not None:
@@ -42,7 +61,13 @@ def solve(
       warmstart = True
     # solve
     s = datetime.now()
-    results = solver.solve(instance, warmstart = warmstart)
+    solve_kwargs = {"warmstart": True} if warmstart else {}
+    try:
+      results = solver.solve(instance, **solve_kwargs)
+    except ValueError as exc:
+      if not warmstart or "warmstart" not in str(exc):
+        raise
+      results = solver.solve(instance)
     e = datetime.now()
     # check solver status
     get_solution_ok = results.solver.status == SolverStatus.ok
@@ -226,9 +251,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.maximize_processing, sense = pyo.maximize
-    )
+    self.set_objective(rule = self.maximize_processing, sense = pyo.maximize)
   
   @staticmethod
   def utilization_equilibrium(model, n, f):
@@ -382,3 +405,45 @@ def maximize_processing(model):
         ) / model.incoming_load[n,f] for f in model.F
       ) for n in model.N
     )
+
+
+class TightLoadManagementModel(LoadManagementModel):
+  """
+  Same problem as LoadManagementModel, reformulated for solve speed:
+  - no_ping_pong2 big-M restricted to neighbors (tighter LP relaxation);
+  - utilization_equilibrium2 replaced by a tiny -r_penalty * sum(r) term in
+    the objective, which keeps r minimal without |N|*|F| extra constraints.
+  Same variables, so solution extraction is unchanged.
+  """
+  def __init__(self):
+    super().__init__()
+    self.name = "TightLoadManagementModel"
+    # ponytail: r_penalty must stay << min marginal gain of serving one
+    # request (~beta/incoming_load); raise only if r inflates in solutions
+    self.model.r_penalty = pyo.Param(
+      within = pyo.NonNegativeReals, default = 1e-4, mutable = True
+    )
+    self.model.del_component(self.model.utilization_equilibrium2)
+    self.model.del_component(self.model.no_ping_pong2)
+    self.model.no_ping_pong2 = pyo.Constraint(
+      self.model.N, self.model.F, rule = self.no_ping_pong2_tight
+    )
+    self.set_objective(
+      rule = self.maximize_processing_penalized, sense = pyo.maximize
+    )
+  
+  @staticmethod
+  def no_ping_pong2_tight(model, n, f):
+    return sum(
+      model.y[m,n,f] for m in model.N
+    ) <= sum(
+      model.incoming_load[m,f] * model.neighborhood[m,n] for m in model.N
+    ) * model.i_receives_f[n,f]
+  
+  @staticmethod
+  def maximize_processing_penalized(model):
+    return LoadManagementModel.maximize_processing(model) - (
+      model.r_penalty * sum(
+        model.r[n,f] for n in model.N for f in model.F
+      )
+    )
diff --git a/models/rmp.py b/models/rmp.py
index 45068e9..48384da 100644
--- a/models/rmp.py
+++ b/models/rmp.py
@@ -116,9 +116,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.maximize_processing, sense = pyo.maximize
-    )
+    self.set_objective(rule = self.maximize_processing, sense = pyo.maximize)
   
   def _provide_initial_solution(self, instance, initial_solution):
     Nn = instance.Nn.value
@@ -242,9 +240,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.maximize_processing, sense = pyo.maximize
-    )
+    self.set_objective(rule = self.maximize_processing, sense = pyo.maximize)
   
   @staticmethod
   def no_traffic_loss(model, n, f):
diff --git a/models/sp.py b/models/sp.py
index 3f2ad14..154ae01 100644
--- a/models/sp.py
+++ b/models/sp.py
@@ -1,4 +1,4 @@
-from models.model import BaseLoadManagementModel, PYO_VAR_TYPE
+from models.model import BaseLoadManagementModel, PYO_VAR_TYPE, PYO_PARAM_TYPE
 
 import pyomo.environ as pyo
 
@@ -74,9 +74,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.minimize_processing_cost_v0
-    )
+    self.set_objective(rule = self.minimize_processing_cost_v0)
   
   @staticmethod
   def no_traffic_loss_v0(model, f):
@@ -141,16 +139,21 @@ def __init__(self):
     ###########################################################################
     # Constraints
     ###########################################################################
+    # The inherited LSP_v0 balance (x + omega == load) is an equality with no
+    # room for the cloud-rejection variable z: combined with the z-aware
+    # balance below it would force z == 0 (silently disabling cloud rejection
+    # and the gamma*z objective term, and making LSP_capped infeasible whenever
+    # the offload cap is below the overflow). Drop it; no_traffic_loss is the
+    # real flow-conservation constraint once z exists.
+    self.model.del_component(self.model.no_traffic_loss_v0)
     self.model.no_traffic_loss = pyo.Constraint(
       self.model.F, rule = self.no_traffic_loss
     )
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.minimize_processing_cost
-    )
-  
+    self.set_objective(rule = self.minimize_processing_cost)
+
   @staticmethod
   def no_traffic_loss(model, f):
     return (
@@ -181,12 +184,12 @@ def __init__(self):
     ###########################################################################
     # assigned offloading
     self.model.omega_bar = pyo.Param(
-      self.model.N, self.model.F, 
-      within = PYO_VAR_TYPE
+      self.model.N, self.model.F,
+      within = PYO_PARAM_TYPE
     )
     self.model.y_bar = pyo.Param(
-      self.model.N, self.model.N, self.model.F, 
-      within = PYO_VAR_TYPE
+      self.model.N, self.model.N, self.model.F,
+      within = PYO_PARAM_TYPE
     )
     ###########################################################################
     # Constraints
@@ -206,9 +209,7 @@ def __init__(self):
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.minimize_processing_cost_v0
-    )
+    self.set_objective(rule = self.minimize_processing_cost_v0)
   
   @staticmethod
   def no_traffic_loss_v0(model, f):
@@ -271,15 +272,71 @@ def __init__(self):
     ###########################################################################
     # Constraints
     ###########################################################################
+    self.model.del_component(self.model.no_traffic_loss_v0)
     self.model.no_traffic_loss = pyo.Constraint(
       self.model.F, rule = self.no_traffic_loss
     )
     ###########################################################################
     # Objective function
     ###########################################################################
-    self.model.OBJ = pyo.Objective(
-      rule = self.minimize_processing_cost
+    self.set_objective(rule = self.minimize_processing_cost)
+  
+  @staticmethod
+  def no_traffic_loss(model, f):
+    return (
+      model.x[f] + model.omega_bar[model.whoami,f] + model.z[f]
+    ) <= model.incoming_load[model.whoami,f]
+  
+  @staticmethod
+  def minimize_processing_cost(model):
+    return - (
+      sum(
+        (
+          model.alpha[model.whoami,f] * model.x[f] + 
+          model.delta[model.whoami,f] * model.omega_bar[model.whoami,f] -
+          model.gamma[model.whoami,f] * model.z[f]
+        ) / model.incoming_load[model.whoami,f] for f in model.F
+      )
+    )
+
+
+class LSPr_x(LSPr_v0):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSPr_x"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    self.model.x_bar = pyo.Param(
+      self.model.N, self.model.F,
+      within = PYO_PARAM_TYPE
+    )
+    # objective function weights
+    self.model.gamma = pyo.Param(
+      self.model.N, self.model.F, within = pyo.NonNegativeReals, default = 0.1
+    )
+    ###########################################################################
+    # Problem variables
+    ###########################################################################
+    # number of rejected requests
+    self.model.z = pyo.Var(
+      self.model.F, 
+      domain = PYO_VAR_TYPE
     )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.del_component(self.model.no_traffic_loss_v0)
+    self.model.no_traffic_loss = pyo.Constraint(
+      self.model.F, rule = self.no_traffic_loss
+    )
+    self.model.temp_fix_x = pyo.Constraint(
+      self.model.F, rule = self.temp_fix_x
+    )
+    ###########################################################################
+    # Objective function
+    ###########################################################################
+    self.set_objective(rule = self.minimize_processing_cost)
   
   @staticmethod
   def no_traffic_loss(model, f):
@@ -287,6 +344,12 @@ def no_traffic_loss(model, f):
       model.x[f] + model.omega_bar[model.whoami,f] + model.z[f]
     ) <= model.incoming_load[model.whoami,f]
   
+  @staticmethod
+  def temp_fix_x(model, f):
+    return (
+      model.x[f] == model.x_bar[model.whoami,f]
+    )
+  
   @staticmethod
   def minimize_processing_cost(model):
     return - (
@@ -361,7 +424,7 @@ def __init__(self):
     ###########################################################################
     # assigned offloading
     self.model.r_bar = pyo.Param(
-      self.model.N, self.model.F, 
+      self.model.N, self.model.F,
       within = pyo.NonNegativeIntegers
     )
     ###########################################################################
@@ -370,7 +433,141 @@ def __init__(self):
     self.model.fix_r = pyo.Constraint(
       self.model.F, rule = self.fix_r
     )
-  
+
+  @staticmethod
+  def fix_r(model, f):
+    return model.r[f] == model.r_bar[model.whoami,f]
+
+
+##############################################################################
+# OFFLOADING CAP (for FaaS-MABR-O capped local best response)
+##############################################################################
+
+class LSP_capped(LSP):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_capped"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+
+
+class LSP_capped_fixedr(LSP_fixedr):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_capped_fixedr"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+
+
+##############################################################################
+# POTENTIAL GAME (FaaS-MAPG node proposal model)
+##############################################################################
+
+class LSP_pg(LSP):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_pg"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # committed inbound offloading (other players' strategies, fixed)
+    self.model.y_bar = pyo.Param(
+      self.model.N, self.model.N, self.model.F,
+      within = PYO_PARAM_TYPE, default = 0.0
+    )
+    # per-function upper bound on horizontal offloading
+    self.model.omega_ub = pyo.Param(
+      self.model.F, within = pyo.NonNegativeReals, default = 1e9
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    # replicas must also cover committed inbound flows (LSPr-style)
+    self.model.del_component(self.model.utilization_equilibrium)
+    self.model.del_component(self.model.utilization_equilibrium2)
+    self.model.utilization_equilibrium = pyo.Constraint(
+      self.model.F, rule = self.utilization_equilibrium_pg
+    )
+    self.model.utilization_equilibrium2 = pyo.Constraint(
+      self.model.F, rule = self.utilization_equilibrium2_pg
+    )
+    self.model.cap_offloading = pyo.Constraint(
+      self.model.F, rule = self.cap_offloading
+    )
+
+  @staticmethod
+  def utilization_equilibrium_pg(model, f):
+    return (
+      model.demand[model.whoami,f] * (
+        model.x[f] + sum(model.y_bar[m,model.whoami,f] for m in model.N)
+      ) <= model.r[f] * model.max_utilization[f]
+    )
+
+  @staticmethod
+  def utilization_equilibrium2_pg(model, f):
+    return (
+      model.demand[model.whoami,f] * (
+        model.x[f] + sum(model.y_bar[m,model.whoami,f] for m in model.N)
+      ) >= (model.r[f] - 1) * model.max_utilization[f]
+    )
+
+  @staticmethod
+  def cap_offloading(model, f):
+    return model.omega[f] <= model.omega_ub[f]
+
+
+class LSP_pg_fixedr(LSP_pg):
+  def __init__(self):
+    super().__init__()
+    self.name = "LSP_pg_fixedr"
+    ###########################################################################
+    # Problem parameters
+    ###########################################################################
+    # number of assigned replicas
+    self.model.r_bar = pyo.Param(
+      self.model.N, self.model.F,
+      within = pyo.NonNegativeIntegers, default = 0
+    )
+    ###########################################################################
+    # Constraints
+    ###########################################################################
+    self.model.fix_r = pyo.Constraint(
+      self.model.F, rule = self.fix_r
+    )
+    # with r pinned the replica lower bound may conflict with commitments
+    # (same reasoning as LSP_fixedr)
+    self.model.del_component(self.model.utilization_equilibrium2)
+
   @staticmethod
   def fix_r(model, f):
     return model.r[f] == model.r_bar[model.whoami,f]
diff --git a/plasma/__init__.py b/plasma/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/plasma/baselines/__init__.py b/plasma/baselines/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/plasma/baselines/greedy_baseline.py b/plasma/baselines/greedy_baseline.py
new file mode 100644
index 0000000..150a229
--- /dev/null
+++ b/plasma/baselines/greedy_baseline.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Tuple
+
+import numpy as np
+
+from heuristic_coordinator import GreedyCoordinator
+
+
+def solve(data: dict, solver_options: dict) -> Tuple[np.ndarray, ...]:
+  """Local, non-coordinated greedy lower baseline: each node fills its own
+  RAM by alpha*load order and serves what it can; leftover offloading is
+  distributed by the existing GreedyCoordinator."""
+  d = data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  ram_cap = np.array([float(d["memory_capacity"][n + 1]) for n in range(Nn)])
+  ram_req = np.array([float(d["memory_requirement"][f + 1]) for f in range(Nf)])
+  lam = np.array([
+    [d["incoming_load"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  u_max = np.array([
+    [d["max_utilization"][f + 1] / d["demand"][(n + 1, f + 1)]
+     for f in range(Nf)] for n in range(Nn)
+  ])
+  alpha = np.array([
+    [d["alpha"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  r = np.zeros((Nn, Nf), dtype=int)
+  for n in range(Nn):
+    budget = ram_cap[n]
+    for f in sorted(range(Nf), key=lambda f: -alpha[n, f] * lam[n, f]):
+      while lam[n, f] > r[n, f] * u_max[n, f] and budget >= ram_req[f]:
+        r[n, f] += 1
+        budget -= ram_req[f]
+  x = np.minimum(lam, r * u_max)
+  omega = lam - x
+  instance = deepcopy(data)
+  instance[None]["omega_bar"] = {
+    (n + 1, f + 1): float(omega[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance[None]["x_bar"] = {
+    (n + 1, f + 1): float(x[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance[None]["r_bar"] = {
+    (n + 1, f + 1): int(r[n, f]) for n in range(Nn) for f in range(Nf)
+  }
+  instance["sp_rho"] = ram_cap - (r * ram_req[None, :]).sum(axis=1)
+  result = GreedyCoordinator().solve(instance, solver_options)
+  y = np.array(result["y"], dtype=float).reshape(Nn, Nn, Nf)
+  r_extra = np.array(result["r"], dtype=float).reshape(Nn, Nf)
+  z = omega - y.sum(axis=1)
+  return x, y, np.maximum(z, 0.0), r + r_extra.astype(int)
diff --git a/plasma/baselines/madea_iface.py b/plasma/baselines/madea_iface.py
new file mode 100644
index 0000000..8714232
--- /dev/null
+++ b/plasma/baselines/madea_iface.py
@@ -0,0 +1,2 @@
+"""Adapter so FaaS-MADeA plugs into PLASMA comparisons (design doc S1.2)."""
+from run_faasmadea import run as run_madea  # noqa: F401
diff --git a/plasma/baselines/milp_baseline.py b/plasma/baselines/milp_baseline.py
new file mode 100644
index 0000000..1fd55db
--- /dev/null
+++ b/plasma/baselines/milp_baseline.py
@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from typing import List, Tuple
+
+import numpy as np
+from scipy.optimize import linprog
+
+from generators.generate_data import update_data
+from models.model import LoadManagementModel
+from plasma.runner import objective_load
+from run_centralized_model import solve_instance
+from utils.centralized import get_current_load
+from utils.faasmacro import compute_centralized_objective
+
+
+def solve_snapshot(data: dict, solver_name: str, solver_options: dict):
+  x, y, z, r, xi, omega, rho, U, obj, runtime, tc = solve_instance(
+    LoadManagementModel(), data, solver_name, solver_options
+  )
+  return x, y, z, r, obj
+
+
+def routing_lp(
+    lam: np.ndarray, r: np.ndarray, u_max: np.ndarray, alpha: np.ndarray,
+    beta: np.ndarray, gamma: np.ndarray, adjacency: np.ndarray
+  ) -> Tuple[float, np.ndarray, np.ndarray, np.ndarray]:
+  """LP-optimal routing with fixed replicas: the Layer-A reference optimum.
+  Variables per (n, f): x, z; per edge (n1, n2, f): y. Objective matches
+  compute_centralized_objective (per-load-normalized)."""
+  Nn, Nf = lam.shape
+  # variable order: x (Nn*Nf), z (Nn*Nf), y (Nn*Nn*Nf)
+  nx = Nn * Nf
+  ny = Nn * Nn * Nf
+  def ix(n, f): return n * Nf + f
+  def iz(n, f): return nx + n * Nf + f
+  def iy(n1, n2, f): return 2 * nx + (n1 * Nn + n2) * Nf + f
+  c = np.zeros(2 * nx + ny)
+  for n in range(Nn):
+    for f in range(Nf):
+      scale = max(lam[n, f], 1e-12)
+      c[ix(n, f)] = -alpha[n, f] / scale
+      c[iz(n, f)] = gamma[n, f] / scale
+      for m in range(Nn):
+        c[iy(n, m, f)] = -beta[n, m, f] / scale
+  A_eq, b_eq = [], []
+  for n in range(Nn):
+    for f in range(Nf):
+      row = np.zeros(2 * nx + ny)
+      row[ix(n, f)] = 1.0
+      row[iz(n, f)] = 1.0
+      for m in range(Nn):
+        row[iy(n, m, f)] = 1.0
+      A_eq.append(row)
+      b_eq.append(lam[n, f])
+  A_ub, b_ub = [], []
+  for n in range(Nn):
+    for f in range(Nf):
+      row = np.zeros(2 * nx + ny)
+      row[ix(n, f)] = 1.0
+      for m in range(Nn):
+        row[iy(m, n, f)] = 1.0
+      A_ub.append(row)
+      b_ub.append(r[n, f] * u_max[n, f])
+  bounds = [(0, None)] * (2 * nx) + [
+    (0, None if adjacency[n1, n2] else 0)
+    for n1 in range(Nn) for n2 in range(Nn) for _ in range(Nf)
+  ]
+  res = linprog(c, A_ub=np.array(A_ub), b_ub=np.array(b_ub),
+                A_eq=np.array(A_eq), b_eq=np.array(b_eq), bounds=bounds,
+                method="highs")
+  assert res.success, res.message
+  sol = res.x
+  x = sol[:nx].reshape(Nn, Nf)
+  z = sol[nx:2 * nx].reshape(Nn, Nf)
+  y = sol[2 * nx:].reshape(Nn, Nn, Nf)
+  return float(-res.fun), x, y, z
+
+
+def shed_overflow(
+    x: np.ndarray, y: np.ndarray, lam: np.ndarray
+  ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+  """Shed true-load overflow from a held (x, y) plan against true load lam.
+  Overflow is shed from local (x) first; any remainder is shed from the
+  outgoing y row for that (n, f), scaled proportionally, so no phantom
+  (never-arrived) traffic is credited by the objective. Returns
+  (x_eff, y_eff, z_eff) with x_eff + y_eff.sum(axis=1) + z_eff == lam."""
+  y_row_sum = y.sum(axis=1)  # per (n, f) outgoing total
+  handled = x + y_row_sum
+  over = np.maximum(0.0, handled - lam)
+  x_eff = np.maximum(0.0, x - over)
+  over2 = over - (x - x_eff)  # overflow left after shedding x
+  safe_row_sum = np.where(y_row_sum > 0, y_row_sum, 1.0)
+  scale = np.where(y_row_sum > 0, 1.0 - over2 / safe_row_sum, 1.0)
+  y_eff = y * scale[:, None, :]
+  z_eff = np.maximum(0.0, lam - x_eff - y_eff.sum(axis=1))
+  return x_eff, y_eff, z_eff
+
+
+def stale_objectives(
+    base_instance_data: dict, traces: dict, agents, t_range,
+    solver_name: str, solver_options: dict, resolve_every: int
+  ) -> List[float]:
+  """Centralized MILP re-solved every resolve_every steps on then-current
+  load, held in between, scored on the true load (staleness is the point)."""
+  if resolve_every < 1:
+    raise ValueError("resolve_every must be >= 1")
+  held = None
+  objs = []
+  for k, t in enumerate(t_range):
+    loadt = get_current_load(traces, agents, t)
+    data = update_data(base_instance_data, {"incoming_load": loadt})
+    if held is None or k % resolve_every == 0:
+      x, y, z, r, _ = solve_snapshot(data, solver_name, solver_options)
+      held = (x, y)
+    x, y = held
+    lam = np.array([
+      [loadt[(n + 1, f + 1)] for f in range(x.shape[1])]
+      for n in range(x.shape[0])
+    ])
+    x_eff, y_eff, z_eff = shed_overflow(x, y, lam)
+    score_data = update_data(
+      data, {"incoming_load": objective_load(loadt)}
+    )
+    objs.append(
+      compute_centralized_objective(score_data, x_eff, y_eff, z_eff)
+    )
+  return objs
diff --git a/plasma/cli.py b/plasma/cli.py
new file mode 100644
index 0000000..baefadc
--- /dev/null
+++ b/plasma/cli.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import argparse
+
+from utils.common import load_configuration
+
+from plasma.runner import run
+
+
+def parse_arguments() -> argparse.Namespace:
+  parser = argparse.ArgumentParser(
+    description="Run PLASMA standalone (debugging entry point)",
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+  )
+  parser.add_argument("-c", "--config", type=str, default="manual_config.json")
+  parser.add_argument("-j", "--parallelism", type=int, default=0)
+  parser.add_argument("--disable_plotting", default=False,
+                      action="store_true")
+  return parser.parse_known_args()[0]
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  run(
+    load_configuration(args.config), args.parallelism,
+    disable_plotting=args.disable_plotting,
+  )
diff --git a/plasma/core/__init__.py b/plasma/core/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/plasma/core/node.py b/plasma/core/node.py
new file mode 100644
index 0000000..9eb5ad8
--- /dev/null
+++ b/plasma/core/node.py
@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from plasma.core.protocol import HeartbeatCache
+from plasma.core.routing import target_weights, update_conductance
+from plasma.core.sbm import (
+  HamiltonianContext, bits_per_fn, decode_spins, dsb_minimize, exact_minimize,
+  hamiltonian, r_max_per_fn, repair,
+)
+from plasma.core.types import LOCAL, REJ, Heartbeat, PlasmaOptions
+
+
+@dataclass(frozen=True)
+class NodeParams:
+  node_id: int
+  nbrs: tuple
+  alpha: np.ndarray
+  gamma: np.ndarray
+  beta: np.ndarray
+  u_max: np.ndarray
+  ram_cap: float
+  ram_req: np.ndarray
+
+
+@dataclass
+class WindowCounts:
+  x: np.ndarray
+  z: np.ndarray
+  y: np.ndarray
+  xi: np.ndarray
+
+
+class PlasmaNode:
+  def __init__(
+      self, params: NodeParams, opts: PlasmaOptions, rng: np.random.Generator
+    ) -> None:
+    self.params = params
+    self.opts = opts
+    self.rng = rng
+    Nf = len(params.alpha)
+    deg = len(params.nbrs)
+    self.Nf = Nf
+    self.deg = deg
+    self.alive = True
+    self.r = np.zeros(Nf, dtype=int)
+    self.D = np.full((Nf, 2 + deg), opts.D_init)
+    self.cache = HeartbeatCache()
+    self.lam_hat = np.zeros(Nf)
+    self._seq = 0
+    self._spare_last = np.zeros(Nf)
+    self._pull_last = np.zeros(Nf)
+    self._recv_from_last = np.zeros((deg, Nf))
+    # rewards are constant: local alpha, REJ floor, per-neighbor beta
+    self._rewards = np.empty((Nf, 2 + deg))
+    self._rewards[:, LOCAL] = params.alpha
+    self._rewards[:, REJ] = opts.rej_floor
+    for k in range(deg):
+      self._rewards[:, 2 + k] = params.beta[k]
+    self._pending = None
+    self._streak = 0
+    self.begin_window()
+
+  # ---------------- Layer A: data plane ----------------
+
+  def begin_window(self) -> None:
+    Nf, deg = self.Nf, self.deg
+    self._x = np.zeros(Nf)
+    self._z = np.zeros(Nf)
+    self._y = np.zeros((deg, Nf))
+    self._xi = np.zeros(Nf)
+    self._phi = np.zeros((Nf, 2 + deg))
+    self._pull = np.zeros(Nf)
+    self._admitted = np.zeros(Nf)
+    self._arrivals = np.zeros(Nf)
+    self._recv_from = np.zeros((deg, Nf))
+
+  def _capacity(self, f: int) -> float:
+    return float(self.r[f]) * self.params.u_max[f] * self.opts.W
+
+  def _capacity_units(self, f: int) -> int:
+    # admission is per-request (integer): floor the continuous capacity so
+    # a window never admits more than r*u_max*W actually allows -- using
+    # the raw fractional value as the gate threshold lets one extra unit
+    # through whenever capacity has a fractional part (e.g. 2.085 admits 3)
+    return int(self._capacity(f) + 1e-9)
+
+  def _nbr_spare(self, round_: int) -> np.ndarray:
+    # (deg, Nf) spare matrix, ONE cache read per neighbor per window
+    if self.deg == 0:
+      # ponytail: np.array([]) on an empty list degenerates to 1-D; a
+      # node with no neighbors still needs a (0, Nf) matrix for [:, f]
+      return np.zeros((0, self.Nf))
+    return np.array([
+      self.cache.spare(j, round_, self.opts.staleness_rounds, self.Nf)
+      for j in self.params.nbrs
+    ])
+
+  def route_window(self, arrivals: np.ndarray, round_: int) -> np.ndarray:
+    self._arrivals += arrivals
+    Nf, deg = self.Nf, self.deg
+    desired = np.zeros((Nf, deg), dtype=int)
+    nbr_spare = self._nbr_spare(round_)
+    for f in range(Nf):
+      n = int(arrivals[f])
+      if n == 0:
+        continue
+      preferred = 0
+      remaining = n
+      if deg:
+        candidates = [
+          k for k in range(deg)
+          if nbr_spare[k, f] > 0 and self._recv_from_last[k, f] == 0
+          and self.params.beta[k, f] > self.params.alpha[f]
+        ]
+        candidates.sort(key=lambda k: self.params.beta[k, f], reverse=True)
+        for k in candidates:
+          if remaining <= 0:
+            break
+          take = min(remaining, int(nbr_spare[k, f]))
+          if take <= 0:
+            continue
+          desired[f, k] += take
+          remaining -= take
+          preferred += take
+      n = remaining
+      cap = self._capacity_units(f)
+      local = max(0, min(n, cap - int(self._admitted[f])))
+      if local:
+        self._x[f] += local
+        self._admitted[f] += local
+        self._phi[f, LOCAL] += local
+      overflow = n - local
+      self._pull[f] += preferred
+      if overflow == 0:
+        continue
+      weights = target_weights(
+        self.D[f], False, nbr_spare[:, f], self.opts.eps_explore
+      )
+      weights[LOCAL] = 0.0
+      unsplittable = (
+        self.opts.rare_function_mode == "unsplittable"
+        and self.lam_hat[f] < self.opts.lambda_split_threshold
+      )
+      if unsplittable:
+        counts = np.zeros(len(weights), dtype=int)
+        counts[int(np.argmax(weights))] = overflow
+      else:
+        total = weights.sum()
+        if total <= 0.0:
+          counts = np.zeros(len(weights), dtype=int)
+          counts[REJ] = overflow
+        else:
+          counts = self.rng.multinomial(overflow, weights / total)
+      counts[REJ] += counts[LOCAL]  # zero-weight LOCAL can only be hit by argmax ties
+      self._z[f] += counts[REJ]
+      self._pull[f] += overflow
+      desired[f, :] += counts[2:]
+    return desired
+
+  def accept_forwards(self, f: int, n: int, sender: int) -> int:
+    if not self.alive:
+      return 0
+    remaining = self._capacity_units(f) - int(self._admitted[f])
+    k = max(0, min(n, remaining))
+    self._admitted[f] += k
+    self._xi[f] += k
+    if k:
+      idx = self.params.nbrs.index(sender)
+      self._recv_from[idx, f] += k
+    return k
+
+  def record_forward_results(
+      self, f: int, k: int, attempted: int, accepted: int
+    ) -> None:
+    # pull is fully accounted at routing time (route_window adds the whole
+    # overflow); adding attempted here would double-count forwarded requests
+    self._y[k, f] += accepted
+    self._phi[f, 2 + k] += accepted
+    nacked = attempted - accepted
+    local_units = self._capacity_units(f)
+    retry = int(min(nacked, max(0, local_units - self._admitted[f])))
+    self._x[f] += retry
+    self._admitted[f] += retry
+    self._phi[f, LOCAL] += retry
+    self._z[f] += nacked - retry
+
+  # ---------------- Layer A: control plane ----------------
+
+  def end_window(self) -> WindowCounts:
+    counts = WindowCounts(x=self._x, z=self._z, y=self._y, xi=self._xi)
+    self.D = update_conductance(self.D, self._phi, self._rewards, self.opts)
+    ew = self.opts.ewma
+    self.lam_hat = (1 - ew) * self.lam_hat + ew * self._arrivals
+    self._spare_last = np.maximum(
+      0.0,
+      np.array([self._capacity_units(f) for f in range(self.Nf)])
+      - self._admitted,
+    )
+    self._pull_last = self._pull
+    self._recv_from_last = self._recv_from
+    self.begin_window()
+    return counts
+
+  def make_heartbeat(self) -> Heartbeat:
+    self._seq += 1
+    return Heartbeat(
+      node=self.params.node_id, seq=self._seq,
+      spare=tuple(self._spare_last), alpha=tuple(self.params.alpha),
+      pull=tuple(self._pull_last),
+    )
+
+  def on_heartbeat(self, hb: Heartbeat, round_: int) -> None:
+    if self.alive:
+      self.cache.store(hb, round_)
+
+  # ---------------- Layer B ----------------
+
+  def init_replicas(self) -> None:
+    if self.opts.r_init == "zero":
+      return
+    used = 0.0
+    while True:
+      progress = False
+      for f in range(self.Nf):
+        if used + self.params.ram_req[f] <= self.params.ram_cap:
+          self.r[f] += 1
+          used += self.params.ram_req[f]
+          progress = True
+      if not progress:
+        return
+
+  def _hamiltonian_ctx(self, round_: int) -> HamiltonianContext:
+    pull_in = self.cache.pull_in(round_, self.opts.staleness_rounds, self.Nf)
+    demand_target = self.lam_hat + pull_in
+    benefit = self.params.alpha * demand_target
+    A = self.opts.A
+    if A is None:
+      A = max(1.0, 2.0 * float((benefit / self.params.ram_req).max()))
+    return HamiltonianContext(
+      benefit=benefit, ram_req=self.params.ram_req,
+      ram_cap=self.params.ram_cap, demand_hat=self.lam_hat,
+      margin=self.opts.z_delta * np.sqrt(self.lam_hat),
+      u_max=self.params.u_max * self.opts.W, r_prev=self.r.copy(),
+      A=A, B=self.opts.B, C=self.opts.C, switch_cost=self.opts.switch_cost,
+      alpha=self.params.alpha, demand_target=demand_target,
+    )
+
+  def sb_pass(self, round_: int) -> bool:
+    if not self.alive:
+      return False
+    ctx = self._hamiltonian_ctx(round_)
+    r_max = r_max_per_fn(self.params.ram_cap, self.params.ram_req)
+    if self.opts.sbm_method == "exact":
+      r_new = exact_minimize(ctx, r_max)
+    else:
+      bits = bits_per_fn(r_max)
+      n_spins = int(bits.sum())
+      if n_spins == 0:
+        return False
+
+      def H(s: np.ndarray) -> float:
+        return hamiltonian(decode_spins(s, bits, r_max), ctx)
+
+      s = dsb_minimize(H, n_spins, self.opts, self.rng)
+      r_new = repair(
+        decode_spins(s, bits, r_max), ctx.benefit, self.params.ram_req,
+        self.params.ram_cap,
+      )
+    h_prev = hamiltonian(self.r, ctx)
+    h_new = hamiltonian(r_new, ctx)
+    improving = h_new < h_prev - self.opts.eps_commit * abs(h_prev)
+    if not improving or (self._pending is not None
+                         and not np.array_equal(r_new, self._pending)):
+      self._pending, self._streak = None, 0
+      return False
+    self._pending = r_new
+    self._streak += 1
+    if self._streak < self.opts.n_hyst:
+      return False
+    self._pending, self._streak = None, 0
+    # randomized commit: the mandatory Jacobi-oscillation countermeasure
+    # under the shared barrier (p_commit = 1 disables it, deliberately)
+    if self.rng.random() >= self.opts.p_commit:
+      return False
+    self.r = r_new
+    return True
diff --git a/plasma/core/protocol.py b/plasma/core/protocol.py
new file mode 100644
index 0000000..4fb6625
--- /dev/null
+++ b/plasma/core/protocol.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+import numpy as np
+
+from plasma.core.types import Heartbeat
+
+_FIELDS = {"node", "seq", "spare", "alpha", "pull"}
+
+
+def encode_heartbeat(hb: Heartbeat) -> dict:
+  return {
+    "node": hb.node, "seq": hb.seq, "spare": list(hb.spare),
+    "alpha": list(hb.alpha), "pull": list(hb.pull),
+  }
+
+
+def decode_heartbeat(msg: dict) -> Heartbeat:
+  extra = set(msg) - _FIELDS
+  if extra:
+    raise ValueError(f"heartbeat carries non-whitelisted fields: {sorted(extra)}")
+  return Heartbeat(
+    node=int(msg["node"]), seq=int(msg["seq"]), spare=tuple(msg["spare"]),
+    alpha=tuple(msg["alpha"]), pull=tuple(msg["pull"]),
+  )
+
+
+class HeartbeatCache:
+  """Per-node view of neighbors. Staleness rule: older than
+  staleness_rounds -> spare = 0 for all f (gates close, conductance decays;
+  no failure detector, no membership protocol)."""
+
+  def __init__(self) -> None:
+    self._last: Dict[int, Tuple[int, Heartbeat]] = {}
+
+  def store(self, hb: Heartbeat, round_: int) -> None:
+    self._last[hb.node] = (round_, hb)
+
+  def _fresh(self, nbr: int, now_round: int, staleness_rounds: int):
+    entry = self._last.get(nbr)
+    if entry is None or now_round - entry[0] > staleness_rounds:
+      return None
+    return entry[1]
+
+  def spare(
+      self, nbr: int, now_round: int, staleness_rounds: int, Nf: int
+    ) -> np.ndarray:
+    hb = self._fresh(nbr, now_round, staleness_rounds)
+    return np.array(hb.spare) if hb else np.zeros(Nf)
+
+  def pull_in(
+      self, now_round: int, staleness_rounds: int, Nf: int
+    ) -> np.ndarray:
+    total = np.zeros(Nf)
+    for nbr in self._last:
+      hb = self._fresh(nbr, now_round, staleness_rounds)
+      if hb:
+        total += np.array(hb.pull)
+    return total
diff --git a/plasma/core/routing.py b/plasma/core/routing.py
new file mode 100644
index 0000000..a805862
--- /dev/null
+++ b/plasma/core/routing.py
@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import numpy as np
+
+from plasma.core.types import LOCAL, REJ, PlasmaOptions
+
+
+def target_weights(
+    D_f: np.ndarray, local_open: bool, nbr_spare: np.ndarray,
+    eps_explore: float
+  ) -> np.ndarray:
+  w = D_f.copy()
+  if not local_open:
+    w[LOCAL] = 0.0
+  gates = np.where(nbr_spare > 0.0, 1.0, eps_explore)
+  w[2:] = w[2:] * gates
+  return w
+
+
+def choose_target(
+    rng: np.random.Generator, weights: np.ndarray, unsplittable: bool
+  ) -> int:
+  if unsplittable:
+    return int(np.argmax(weights))
+  total = weights.sum()
+  if total <= 0.0:
+    return REJ
+  return int(rng.choice(len(weights), p=weights / total))
+
+
+def update_conductance(
+    D: np.ndarray, phi: np.ndarray, rewards: np.ndarray, opts: PlasmaOptions
+  ) -> np.ndarray:
+  reinforced = (1.0 - opts.mu) * D + opts.mu * (phi ** opts.kappa) * rewards
+  return np.clip(reinforced, opts.D_min, opts.D_max)
diff --git a/plasma/core/sbm.py b/plasma/core/sbm.py
new file mode 100644
index 0000000..b278716
--- /dev/null
+++ b/plasma/core/sbm.py
@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import product
+from typing import Callable
+
+import numpy as np
+
+from plasma.core.types import PlasmaOptions
+
+
+def r_max_per_fn(ram_cap: float, ram_req: np.ndarray) -> np.ndarray:
+  return np.floor(ram_cap / ram_req).astype(int)
+
+
+def bits_per_fn(r_max: np.ndarray) -> np.ndarray:
+  return np.where(r_max > 0, np.ceil(np.log2(r_max + 1)), 0).astype(int)
+
+
+def decode_spins(
+    s: np.ndarray, bits: np.ndarray, r_max: np.ndarray
+  ) -> np.ndarray:
+  r = np.zeros(len(bits), dtype=int)
+  k = 0
+  for f, nb in enumerate(bits):
+    for b in range(nb):
+      r[f] += (2 ** b) * (1 + int(s[k])) // 2
+      k += 1
+  return np.minimum(r, r_max)
+
+
+@dataclass(frozen=True)
+class HamiltonianContext:
+  # every array is per-node-local: no term may reference another node's
+  # spins (decentralization holds by construction)
+  benefit: np.ndarray
+  ram_req: np.ndarray
+  ram_cap: float
+  demand_hat: np.ndarray
+  margin: np.ndarray
+  u_max: np.ndarray
+  r_prev: np.ndarray
+  A: float
+  B: float
+  C: float
+  switch_cost: float
+  alpha: np.ndarray          # per-request utility per function
+  demand_target: np.ndarray  # demand_hat + pull_in, per-window units
+
+
+def hamiltonian(r: np.ndarray, ctx: HamiltonianContext) -> float:
+  served = np.minimum(r * ctx.u_max, ctx.demand_target)
+  field = -(ctx.alpha * served).sum()
+  ram_over = max(0.0, float((ctx.ram_req * r).sum() - ctx.ram_cap))
+  cap_short = np.maximum(0.0, ctx.demand_hat + ctx.margin - r * ctx.u_max)
+  churn = ctx.switch_cost * np.abs(r - ctx.r_prev).sum()
+  return float(
+    field + ctx.A * ram_over ** 2 + ctx.B * (cap_short ** 2).sum()
+    + ctx.C * churn
+  )
+
+
+def _local_field(H: Callable, s: np.ndarray, k: int) -> float:
+  sp = s.copy(); sp[k] = 1
+  sm = s.copy(); sm[k] = -1
+  return (H(sp) - H(sm)) / 2.0
+
+
+def _dsb_trajectory(
+    H: Callable[[np.ndarray], float], n_spins: int, opts: PlasmaOptions,
+    rng: np.random.Generator
+  ) -> np.ndarray:
+  # discrete SB: couplings act on sign(q) (dSB variant)
+  # ponytail: local fields via 2 H-evals per spin per step; fine for
+  # <=12 spins/node, switch to analytic gradients if n_spins grows
+  q = rng.uniform(-0.1, 0.1, n_spins)
+  p = np.zeros(n_spins)
+  for step in range(opts.n_sb_steps):
+    a = opts.a_final * step / max(1, opts.n_sb_steps)
+    s = np.where(q >= 0, 1, -1)
+    h = np.array([_local_field(H, s, k) for k in range(n_spins)])
+    p += opts.sb_dt * (-(opts.sb_delta - a) * q - opts.sb_c0 * h)
+    q += opts.sb_dt * opts.sb_delta * p
+    hit = np.abs(q) > 1.0
+    q[hit] = np.sign(q[hit])
+    p[hit] = 0.0
+  return np.where(q >= 0, 1, -1).astype(int)
+
+
+def dsb_minimize(
+    H: Callable[[np.ndarray], float], n_spins: int, opts: PlasmaOptions,
+    rng: np.random.Generator
+  ) -> np.ndarray:
+  # multiple independent trajectories, keep the best: standard SB practice
+  # (parallel oscillator replicas), needed because a single trajectory
+  # settles into a local attractor of the bifurcation dynamics
+  best_s, best_h = None, np.inf
+  for _ in range(opts.sb_restarts):
+    s = _dsb_trajectory(H, n_spins, opts, rng)
+    val = H(s)
+    if val < best_h:
+      best_s, best_h = s, val
+  return best_s
+
+
+def brute_force(H: Callable[[np.ndarray], float], n_spins: int) -> np.ndarray:
+  best_s, best_h = None, np.inf
+  for combo in product((-1, 1), repeat=n_spins):
+    s = np.array(combo)
+    val = H(s)
+    if val < best_h:
+      best_s, best_h = s, val
+  return best_s
+
+
+def _level_values(ctx: HamiltonianContext, f: int, r_max_f: int) -> np.ndarray:
+  # per-function contribution of r_f = 0..r_max_f (Hamiltonian minus RAM term,
+  # which the DP enforces as a hard budget)
+  levels = np.arange(r_max_f + 1)
+  cap_short = np.maximum(
+    0.0, ctx.demand_hat[f] + ctx.margin[f] - levels * ctx.u_max[f]
+  )
+  return (
+    -ctx.alpha[f] * np.minimum(levels * ctx.u_max[f], ctx.demand_target[f])
+    + ctx.B * cap_short ** 2
+    + ctx.C * ctx.switch_cost * np.abs(levels - ctx.r_prev[f])
+  )
+
+
+def exact_minimize(ctx: HamiltonianContext, r_max: np.ndarray) -> np.ndarray:
+  # multi-choice knapsack DP over the integer RAM budget: exact argmin of the
+  # Hamiltonian under the hard RAM constraint (per-node problem is separable
+  # per function; RAM is the only coupling)
+  ram_req = np.rint(ctx.ram_req).astype(int)
+  budget = int(np.floor(ctx.ram_cap + 1e-9))
+  if not np.allclose(ctx.ram_req, ram_req, atol=1e-9) or (ram_req <= 0).any():
+    raise ValueError(
+      "exact_minimize requires positive integer ram_req; use sbm_method 'dsb'"
+    )
+  # gcd scaling: states are multiples of gcd(ram_req); exactness preserved
+  scale = int(np.gcd.reduce(ram_req))
+  ram_req = ram_req // scale
+  budget = budget // scale
+  Nf = len(r_max)
+  INF = np.inf
+  best = np.full(budget + 1, 0.0)  # value of best partial assignment
+  choice = np.zeros((Nf, budget + 1), dtype=int)
+  for f in range(Nf):
+    values = _level_values(ctx, f, int(r_max[f]))
+    new_best = np.full(budget + 1, INF)
+    for b in range(budget + 1):
+      k_hi = min(int(r_max[f]), b // ram_req[f])
+      for k in range(k_hi + 1):
+        cand = best[b - k * ram_req[f]] + values[k]
+        if cand < new_best[b]:
+          new_best[b] = cand
+          choice[f, b] = k
+    best = new_best
+  # backtrack from the best final budget
+  b = int(np.argmin(best))
+  r = np.zeros(Nf, dtype=int)
+  for f in range(Nf - 1, -1, -1):
+    r[f] = choice[f, b]
+    b -= r[f] * ram_req[f]
+  return r
+
+
+def repair(
+    r: np.ndarray, benefit: np.ndarray, ram_req: np.ndarray, ram_cap: float
+  ) -> np.ndarray:
+  fixed = r.copy()
+  while (ram_req * fixed).sum() > ram_cap:
+    candidates = np.where(fixed > 0)[0]
+    f = candidates[np.argmin(benefit[candidates])]
+    fixed[f] -= 1
+  return fixed
diff --git a/plasma/core/types.py b/plasma/core/types.py
new file mode 100644
index 0000000..4dc6417
--- /dev/null
+++ b/plasma/core/types.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+# conductance-matrix column layout: D has shape (Nf, 2 + deg)
+LOCAL = 0
+REJ = 1
+
+
+@dataclass(frozen=True)
+class PlasmaOptions:
+  # Layer A (round period W is the time unit: 1 round = W seconds)
+  W: float = 1.0
+  rounds_per_step: int = 20
+  mu: float = 0.1
+  kappa: float = 1.0
+  D_init: float = 1.0
+  D_min: float = 1e-3
+  D_max: float = 1e3
+  eps_explore: float = 0.01
+  rej_floor: float = 0.01
+  ewma: float = 0.3
+  lambda_split_threshold: float = 5.0
+  rare_function_mode: str = "sampled"  # "sampled" | "unsplittable"
+  r_init: str = "spread"  # "spread" | "zero"
+  # Layer B (k_sb = 0 disables SB entirely: replicas stay fixed)
+  k_sb: int = 10
+  n_sb_steps: int = 300
+  sb_dt: float = 0.05
+  sb_delta: float = 1.0
+  sb_c0: float = 0.2
+  sb_restarts: int = 8
+  a_final: float = 1.0
+  A: Optional[float] = None  # None -> auto: 2 * max_f(benefit_f / ram_req_f)
+  B: float = 1.0
+  C: float = 0.1
+  switch_cost: float = 1.0
+  z_delta: float = 2.0
+  eps_commit: float = 0.05
+  n_hyst: int = 2
+  p_commit: float = 0.5
+  sbm_method: str = "exact"  # "exact" | "dsb"
+  # protocol
+  hb_latency_rounds: int = 1
+  hb_loss: float = 0.0
+  staleness_rounds: int = 3
+
+  @classmethod
+  def from_config(cls, config: dict) -> "PlasmaOptions":
+    return cls(**config.get("solver_options", {}).get("plasma", {}))
+
+  def __post_init__(self) -> None:
+    if self.rounds_per_step < 1:
+      raise ValueError(f"rounds_per_step must be >= 1, got {self.rounds_per_step}")
+    if self.W <= 0.0:
+      raise ValueError(f"W must be > 0, got {self.W}")
+    if self.hb_latency_rounds > self.staleness_rounds:
+      raise ValueError(f"hb_latency_rounds ({self.hb_latency_rounds}) must be <= staleness_rounds ({self.staleness_rounds}), otherwise every neighbor is permanently stale")
+    if self.sbm_method not in ("exact", "dsb"):
+      raise ValueError(f"sbm_method must be 'exact' or 'dsb', got {self.sbm_method!r}")
+
+
+@dataclass(frozen=True)
+class Heartbeat:
+  # the ENTIRE control-plane message: nothing else may cross an edge
+  node: int
+  seq: int
+  spare: Tuple[float, ...]  # per function, floored: max(0, capacity_units - admitted)
+  alpha: Tuple[float, ...]  # per function
+  pull: Tuple[float, ...]   # per function, offload pressure last window
diff --git a/plasma/engine.py b/plasma/engine.py
new file mode 100644
index 0000000..80ba55e
--- /dev/null
+++ b/plasma/engine.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+
+from plasma.core.node import PlasmaNode
+from plasma.core.protocol import decode_heartbeat, encode_heartbeat
+from plasma.core.types import PlasmaOptions
+from plasma.sim.clock import RoundClock
+
+
+@dataclass
+class StepResult:
+  x: np.ndarray
+  z: np.ndarray
+  y: np.ndarray
+  xi: np.ndarray
+  r: np.ndarray
+
+
+class PlasmaEngine:
+  def __init__(
+      self, nodes: List[PlasmaNode], opts: PlasmaOptions,
+      rng: np.random.Generator
+    ) -> None:
+    self.nodes = nodes
+    self.opts = opts
+    self.rng = rng
+    self.clock = RoundClock()
+    self.msg_count = 0
+    self.hb_count = 0
+
+  def set_alive(self, i: int, alive: bool) -> None:
+    self.nodes[i].alive = alive
+
+  def _route_all(self, round_: int, arrivals: np.ndarray) -> None:
+    for i, node in enumerate(self.nodes):
+      if not node.alive:
+        continue
+      desired = node.route_window(arrivals[i], round_)
+      for k, j in enumerate(node.params.nbrs):
+        for f in range(node.Nf):
+          n = int(desired[f, k])
+          if n == 0:
+            continue
+          self.msg_count += n
+          accepted = self.nodes[j].accept_forwards(f, n, sender=node.params.node_id)
+          node.record_forward_results(f, k, n, accepted)
+
+  def _send_heartbeats(self, round_: int) -> None:
+    for node in self.nodes:
+      if not node.alive:
+        continue
+      hb = node.make_heartbeat()
+      wire = encode_heartbeat(hb)
+      for j in node.params.nbrs:
+        self.hb_count += 1
+        self.msg_count += 1
+        if self.rng.random() < self.opts.hb_loss:
+          continue
+        target = self.nodes[j]
+        self.clock.schedule(
+          round_ + self.opts.hb_latency_rounds,
+          lambda t=target, w=wire, r=round_ + self.opts.hb_latency_rounds:
+            t.on_heartbeat(decode_heartbeat(w), r),
+        )
+
+  def run_rounds(self, n_rounds: int, arrivals: np.ndarray) -> StepResult:
+    Nn = len(self.nodes)
+    Nf = self.nodes[0].Nf
+    last = {}
+
+    def on_round(round_: int) -> None:
+      self._route_all(round_, arrivals)
+      x = np.zeros((Nn, Nf))
+      z = np.zeros((Nn, Nf))
+      y = np.zeros((Nn, Nn, Nf))
+      for i, node in enumerate(self.nodes):
+        if not node.alive:
+          continue
+        counts = node.end_window()
+        x[i] = counts.x
+        z[i] = counts.z
+        for k, j in enumerate(node.params.nbrs):
+          y[i, j, :] = counts.y[k]
+      # snapshot r as it stood WHILE this window's traffic was admitted,
+      # before any sb_pass below changes it -- utilization is x/xi over the
+      # replicas that actually gated admission, not the post-sb_pass count
+      last["x"], last["z"], last["y"] = x, z, y
+      last["r"] = np.array([node.r for node in self.nodes])
+      self._send_heartbeats(round_)
+      if self.opts.k_sb > 0 and (round_ + 1) % self.opts.k_sb == 0:
+        for node in self.nodes:
+          node.sb_pass(round_)
+
+    self.clock.run(n_rounds, on_round)
+    xi = np.transpose(last["y"], (1, 0, 2))
+    return StepResult(
+      x=last["x"], z=last["z"], y=last["y"], xi=xi, r=last["r"]
+    )
diff --git a/plasma/eval/__init__.py b/plasma/eval/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/plasma/eval/regret.py b/plasma/eval/regret.py
new file mode 100644
index 0000000..b072b4e
--- /dev/null
+++ b/plasma/eval/regret.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import List
+
+import numpy as np
+
+
+def cumulative_regret(
+    method_obj: np.ndarray, oracle_obj: np.ndarray
+  ) -> np.ndarray:
+  return np.cumsum(np.asarray(oracle_obj) - np.asarray(method_obj))
+
+
+def adaptation_lag(
+    times: np.ndarray, method_obj: np.ndarray, oracle_obj: np.ndarray,
+    change_points: List[float], threshold: float = 0.1
+  ) -> List[float]:
+  times = np.asarray(times)
+  method_obj = np.asarray(method_obj)
+  oracle_obj = np.asarray(oracle_obj)
+  lags: List[float] = []
+  for cp in change_points:
+    after = times >= cp
+    recovered = after & (method_obj >= (1.0 - threshold) * oracle_obj)
+    idx = np.flatnonzero(recovered)
+    lags.append(float(times[idx[0]] - cp) if len(idx) else float("nan"))
+  return lags
diff --git a/plasma/eval/scenario.py b/plasma/eval/scenario.py
new file mode 100644
index 0000000..83e95d3
--- /dev/null
+++ b/plasma/eval/scenario.py
@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+"""M6 failure/non-stationarity scenario driver.
+
+Drives PlasmaEngine directly over a config's horizon (the sinusoidal load
+trace supplies the non-stationarity) and applies set_alive at kill/revive
+steps, scoring PLASMA per-step against three baselines on the same true
+load: a dynamic MILP oracle (solve_snapshot every step), a stale MILP
+(re-solved every `resolve_every` steps, held and scored with shed_overflow
+against the true load in between), and the local greedy baseline
+(re-solved every step, no coordination). A dead node's arrivals /
+incoming_load are zeroed for every method alike so the comparison stays
+apples-to-apples.
+
+MADeA is NOT compared here: run it separately via
+`run.py --methods faas-madea` on the same materialized instance and join
+its objective series against this driver's oracle column offline.
+"""
+
+import argparse
+import os
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+
+from generators.generate_data import update_data
+from plasma.baselines.greedy_baseline import solve as greedy_solve
+from plasma.baselines.milp_baseline import shed_overflow, solve_snapshot
+from plasma.core.types import PlasmaOptions
+from plasma.engine import PlasmaEngine
+from plasma.eval.regret import adaptation_lag, cumulative_regret
+from plasma.runner import build_nodes, objective_load
+from run_centralized_model import init_problem
+from utils.centralized import get_current_load
+from utils.common import load_configuration
+from utils.faasmacro import compute_centralized_objective
+
+
+def _zero_dead_row(loadt: dict, Nf: int, dead_node: int | None) -> dict:
+  if dead_node is None:
+    return loadt
+  out = dict(loadt)
+  for f in range(Nf):
+    out[(dead_node + 1, f + 1)] = 0
+  return out
+
+
+def run_scenario(
+    config: dict,
+    kill: tuple | None = None,
+    solver_name: str = "gurobi",
+    solver_options: dict | None = None,
+    resolve_every: int = 5,
+  ) -> pd.DataFrame:
+  solver_options = solver_options or {}
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = limits["load"].get("trace_type", "fixed_sum")
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  opts = PlasmaOptions.from_config(config)
+  base_solution_folder = config["base_solution_folder"]
+  now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  base_instance_data, traces, agents, _ = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  d = base_instance_data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  nodes = build_nodes(base_instance_data, opts, seed)
+  engine = PlasmaEngine(nodes, opts, np.random.default_rng(seed))
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+
+  dead_node, t_kill, t_revive = kill if kill else (None, None, None)
+  held_stale = None
+  rows = []
+  for k, t in enumerate(range(min_run_time, ub, run_time_step)):
+    if dead_node is not None and t == t_kill:
+      engine.set_alive(dead_node, False)
+    if dead_node is not None and t == t_revive:
+      engine.set_alive(dead_node, True)
+    currently_dead = (
+      dead_node if dead_node is not None and t_kill <= t < t_revive else None
+    )
+    raw_loadt = get_current_load(traces, agents, t)
+    raw_loadt = _zero_dead_row(raw_loadt, Nf, currently_dead)
+    # floor zero (dead-node) entries to 1 for the MILP-side methods: the
+    # model's own objective divides by incoming_load internally, so an
+    # unfloored 0 blows up solve_snapshot itself, not just
+    # compute_centralized_objective. Plasma's engine arrivals stay raw
+    # (0 forwarded packets for a dead node), only its scoring is floored.
+    loadt = objective_load(raw_loadt)
+
+    # -- plasma: drive the engine directly, mirroring plasma.runner.run --
+    arrivals = np.array([
+      [int(round(raw_loadt[(n + 1, f + 1)] * opts.W)) for f in range(Nf)]
+      for n in range(Nn)
+    ])
+    msgs_before = engine.msg_count
+    res = engine.run_rounds(opts.rounds_per_step, arrivals)
+    plasma_data = update_data(base_instance_data, {"incoming_load": {
+      (n + 1, f + 1): arrivals[n, f] for n in range(Nn) for f in range(Nf)
+    }})
+    plasma_obj_data = update_data(
+      plasma_data,
+      {"incoming_load": objective_load(plasma_data[None]["incoming_load"])},
+    )
+    plasma_obj = compute_centralized_objective(
+      plasma_obj_data, res.x, res.y, res.z
+    )
+
+    # -- shared true/floored load for the MILP-side methods --
+    milp_data = update_data(base_instance_data, {"incoming_load": loadt})
+    score_data = milp_data  # loadt is already objective_load-floored above
+    lam = np.array([
+      [loadt[(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+    ])
+
+    # -- dynamic oracle: fresh MILP solve every step on the true load --
+    x_o, y_o, z_o, _, _ = solve_snapshot(milp_data, solver_name, solver_options)
+    oracle_obj = compute_centralized_objective(score_data, x_o, y_o, z_o)
+
+    # -- stale MILP: re-solve every resolve_every steps, held in between --
+    if held_stale is None or k % resolve_every == 0:
+      x_s, y_s, _, _, _ = solve_snapshot(milp_data, solver_name, solver_options)
+      held_stale = (x_s, y_s)
+    x_s, y_s = held_stale
+    x_eff, y_eff, z_eff = shed_overflow(x_s, y_s, lam)
+    stale_obj = compute_centralized_objective(score_data, x_eff, y_eff, z_eff)
+
+    # -- greedy: no-coordination lower baseline, re-solved every step --
+    x_g, y_g, z_g, _ = greedy_solve(milp_data, solver_options)
+    greedy_obj = compute_centralized_objective(score_data, x_g, y_g, z_g)
+
+    seconds = opts.rounds_per_step * opts.W
+    rows.append({
+      "t": t,
+      "plasma": plasma_obj,
+      "oracle": oracle_obj,
+      "stale_milp": stale_obj,
+      "greedy": greedy_obj,
+      "plasma_msgs_per_node_s":
+        (engine.msg_count - msgs_before) / (Nn * seconds),
+    })
+  return pd.DataFrame(rows)
+
+
+def _parse_kill(spec: str | None):
+  if not spec:
+    return None
+  n, t0, t1 = spec.split(",")
+  return (int(n), int(t0), int(t1))
+
+
+def main() -> None:
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument("-c", "--config", required=True, help="config json path")
+  parser.add_argument("-o", "--out", required=True, help="output csv path")
+  parser.add_argument("--kill", default=None, help="node,t_kill,t_revive")
+  parser.add_argument("--resolve_every", type=int, default=5)
+  args = parser.parse_args()
+  config = load_configuration(args.config)
+  kill = _parse_kill(args.kill)
+  df = run_scenario(config, kill=kill, resolve_every=args.resolve_every)
+  df.to_csv(args.out, index=False)
+  change_points = [float(kill[1]), float(kill[2])] if kill else []
+  for method in ("plasma", "stale_milp", "greedy"):
+    regret = cumulative_regret(
+      df[method].to_numpy(), df["oracle"].to_numpy()
+    )
+    lag = adaptation_lag(
+      df["t"].to_numpy(), df[method].to_numpy(), df["oracle"].to_numpy(),
+      change_points=change_points,
+    ) if change_points else []
+    print(f"{method}: cumulative_regret={regret[-1]:.4f} "
+          f"adaptation_lag={lag}")
+
+
+if __name__ == "__main__":
+  main()
diff --git a/plasma/eval/sweep.py b/plasma/eval/sweep.py
new file mode 100644
index 0000000..33cb316
--- /dev/null
+++ b/plasma/eval/sweep.py
@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+"""M7 parameter-sweep driver: run plasma.runner.run over a grid of
+solver_options['plasma'] combinations and rank by objective."""
+
+import argparse
+import itertools
+import json
+import os
+
+import numpy as np
+import pandas as pd
+
+from plasma.runner import run as plasma_run
+
+
+def _last10_mean(series: np.ndarray) -> float:
+  return float(series[-10:].mean())
+
+
+def sweep(config: dict, grid: dict, lmm_obj: "np.ndarray | None" = None) -> pd.DataFrame:
+  """grid: {option_name: [values]} over solver_options['plasma'] keys.
+  Runs plasma.runner.run for every combination (itertools.product),
+  returns a DataFrame with one row per combo: the option values,
+  mean objective, last-10-mean objective, and (if lmm_obj given)
+  full/last-10 gap %. Deterministic: same config seed for every combo."""
+  keys = list(grid.keys())
+  rows = []
+  for values in itertools.product(*(grid[k] for k in keys)):
+    combo = dict(zip(keys, values))
+    cfg = json.loads(json.dumps(config))
+    cfg["solver_options"].setdefault("plasma", {}).update(combo)
+    folder = plasma_run(cfg, parallelism=0, log_on_file=True,
+                        disable_plotting=True)
+    obj = pd.read_csv(os.path.join(folder, "obj.csv"))["Plasma"].to_numpy()
+    row = dict(combo)
+    row["obj_mean"] = float(obj.mean())
+    row["obj_last10"] = _last10_mean(obj)
+    if lmm_obj is not None:
+      lmm = np.asarray(lmm_obj)
+      row["gap_full"] = float(
+        ((obj - lmm[: len(obj)]) / lmm[: len(obj)]).mean() * 100
+      )
+      n = min(10, len(obj), len(lmm))
+      row["gap_last10"] = float(
+        ((obj[-n:] - lmm[-n:]) / lmm[-n:]).mean() * 100
+      )
+    rows.append(row)
+  return pd.DataFrame(rows)
+
+
+def main() -> None:
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument("-c", "--config", required=True, help="config json path")
+  parser.add_argument("--grid", required=True, help="JSON grid dict")
+  parser.add_argument("--lmm", default=None, help="obj.csv for LMM/oracle gap")
+  args = parser.parse_args()
+  with open(args.config) as f:
+    config = json.load(f)
+  grid = json.loads(args.grid)
+  lmm_obj = None
+  if args.lmm:
+    lmm_obj = pd.read_csv(args.lmm).iloc[:, 0].to_numpy()
+  df = sweep(config, grid, lmm_obj=lmm_obj)
+  sort_col = "gap_full" if "gap_full" in df.columns else "obj_mean"
+  print(df.sort_values(sort_col).to_string(index=False))
+
+
+if __name__ == "__main__":
+  main()
diff --git a/plasma/runner.py b/plasma/runner.py
new file mode 100644
index 0000000..6d2c842
--- /dev/null
+++ b/plasma/runner.py
@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+
+from run_centralized_model import (
+  init_complete_solution, init_problem, decode_solution,
+  join_complete_solution, save_checkpoint, save_solution,
+)
+from generators.generate_data import update_data
+from utils.centralized import check_feasibility, get_current_load
+from utils.faasmacro import compute_centralized_objective
+
+from plasma.core.node import NodeParams, PlasmaNode
+from plasma.core.types import PlasmaOptions
+from plasma.engine import PlasmaEngine
+
+
+def build_nodes(base_instance_data: dict, opts: PlasmaOptions, seed: int):
+  d = base_instance_data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  nodes = []
+  for i in range(Nn):
+    nbrs = tuple(
+      j for j in range(Nn) if j != i and d["neighborhood"][(i + 1, j + 1)]
+    )
+    alpha = np.array([d["alpha"][(i + 1, f + 1)] for f in range(Nf)])
+    gamma = np.array([d["gamma"][(i + 1, f + 1)] for f in range(Nf)])
+    beta = np.array([
+      [d["beta"][(i + 1, j + 1, f + 1)] for f in range(Nf)] for j in nbrs
+    ]).reshape(len(nbrs), Nf)
+    u_max = np.array([
+      d["max_utilization"][f + 1] / d["demand"][(i + 1, f + 1)]
+      for f in range(Nf)
+    ])
+    params = NodeParams(
+      node_id=i, nbrs=nbrs, alpha=alpha, gamma=gamma, beta=beta,
+      u_max=u_max, ram_cap=float(d["memory_capacity"][i + 1]),
+      ram_req=np.array([d["memory_requirement"][f + 1] for f in range(Nf)]),
+    )
+    node = PlasmaNode(params, opts, np.random.default_rng(seed * 1000 + i))
+    node.init_replicas()
+    nodes.append(node)
+  return nodes
+
+
+def objective_load(incoming_load: dict) -> dict:
+  # a zero-load (n, f) contributes x = y = z = 0 to the objective; floor the
+  # divisor to 1 so its contribution is exactly 0 instead of 0/0 = nan
+  return {k: max(int(v), 1) for k, v in incoming_load.items()}
+
+
+def run(
+    config: dict, parallelism: int, log_on_file: bool = False,
+    disable_plotting: bool = False
+  ) -> str:
+  # parallelism: accepted for signature compatibility with the other method
+  # runners (decentralized_gcaa.run and friends); PLASMA is a single-process
+  # simulation and does not use it.
+  base_solution_folder = config["base_solution_folder"]
+  seed = config["seed"]
+  limits = config["limits"]
+  trace_type = limits["load"].get("trace_type", "fixed_sum")
+  verbose = config.get("verbose", 0)
+  max_steps = config["max_steps"]
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", max_steps)
+  run_time_step = config.get("run_time_step", 1)
+  checkpoint_interval = config["checkpoint_interval"]
+  opts = PlasmaOptions.from_config(config)
+  now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S.%f")
+  solution_folder = f"{base_solution_folder}/{now}"
+  os.makedirs(solution_folder, exist_ok=True)
+  with open(os.path.join(solution_folder, "config.json"), "w") as ostream:
+    ostream.write(json.dumps(config, indent=2))
+  log_stream = sys.stdout
+  if log_on_file:
+    log_stream = open(os.path.join(solution_folder, "out.log"), "w")
+  base_instance_data, input_requests_traces, agents, graph = init_problem(
+    limits, trace_type, max_steps, seed, solution_folder
+  )
+  d = base_instance_data[None]
+  Nn = d["Nn"][None]
+  Nf = d["Nf"][None]
+  nodes = build_nodes(base_instance_data, opts, seed)
+  engine = PlasmaEngine(nodes, opts, np.random.default_rng(seed))
+  ram_cap = np.array([d["memory_capacity"][n + 1] for n in range(Nn)])
+  ram_req = np.array([d["memory_requirement"][f + 1] for f in range(Nf)])
+  demand = np.array([
+    [d["demand"][(n + 1, f + 1)] for f in range(Nf)] for n in range(Nn)
+  ])
+  cs = init_complete_solution()
+  obj_list = []
+  runtime_list = []
+  msg_rows = []
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  for t in range(min_run_time, ub, run_time_step):
+    if verbose > 0:
+      print(f"t = {t}", file=log_stream, flush=True)
+    loadt = get_current_load(input_requests_traces, agents, t)
+    arrivals = np.array([
+      [int(round(loadt[(n + 1, f + 1)] * opts.W)) for f in range(Nf)]
+      for n in range(Nn)
+    ])
+    data = update_data(base_instance_data, {"incoming_load": {
+      (n + 1, f + 1): arrivals[n, f] for n in range(Nn) for f in range(Nf)
+    }})
+    msgs_before, hb_before = engine.msg_count, engine.hb_count
+    started = datetime.now()
+    res = engine.run_rounds(opts.rounds_per_step, arrivals)
+    elapsed = (datetime.now() - started).total_seconds()
+    omega = res.y.sum(axis=1)
+    with np.errstate(divide="ignore", invalid="ignore"):
+      U = np.where(
+        res.r > 0,
+        demand * (res.x + res.xi.sum(axis=1)) / np.maximum(res.r, 1) / opts.W,
+        0.0,
+      )
+    rho = ram_cap - (res.r * ram_req[None, :]).sum(axis=1)
+    feasible, why = check_feasibility(res.x, omega, res.z, res.r, U, data)
+    assert feasible, why
+    cs = decode_solution(res.x, res.y, res.z, res.r, res.xi, rho, U, cs)
+    obj_data = update_data(
+      data, {"incoming_load": objective_load(data[None]["incoming_load"])}
+    )
+    obj_list.append(
+      compute_centralized_objective(obj_data, res.x, res.y, res.z)
+    )
+    runtime_list.append(elapsed)
+    seconds = opts.rounds_per_step * opts.W
+    msg_rows.append({
+      "t": t,
+      "msgs_per_node_s": (engine.msg_count - msgs_before) / (Nn * seconds),
+      "hb_per_node_s": (engine.hb_count - hb_before) / (Nn * seconds),
+    })
+    if t % checkpoint_interval == 0 or t == max_steps - 1:
+      save_checkpoint(cs, os.path.join(solution_folder, "LSPc"), t)
+  solution, offloaded, detailed_fwd = join_complete_solution(cs)
+  save_solution(solution, offloaded, cs, detailed_fwd, "LSPc", solution_folder)
+  pd.DataFrame(obj_list, columns=["Plasma"]).to_csv(
+    os.path.join(solution_folder, "obj.csv"), index=False
+  )
+  # format matches results_postprocessing's shared parser (run.py
+  # load_termination_condition): "{criterion} (it: {iteration}; obj.
+  # deviation: {deviation})" -- PLASMA always runs the full rounds_per_step
+  # budget each step, there is no separate convergence criterion
+  pd.DataFrame(
+    [f"converged (it: {opts.rounds_per_step}; obj. deviation: {None})"]
+    * len(obj_list)
+  ).to_csv(os.path.join(solution_folder, "termination_condition.csv"))
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False
+  )
+  pd.DataFrame(msg_rows).to_csv(
+    os.path.join(solution_folder, "plasma_messages.csv"), index=False
+  )
+  if verbose > 0:
+    print(f"All solutions saved in: {solution_folder}", file=log_stream,
+          flush=True)
+  if log_on_file:
+    log_stream.close()
+  return solution_folder
diff --git a/plasma/sim/__init__.py b/plasma/sim/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/plasma/sim/clock.py b/plasma/sim/clock.py
new file mode 100644
index 0000000..0f9ba45
--- /dev/null
+++ b/plasma/sim/clock.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import heapq
+from typing import Callable, List, Tuple
+
+
+class RoundClock:
+  """Single shared round barrier (period = W). The only clock in PLASMA:
+  there is no per-node clock and no tick jitter (sync-only design)."""
+
+  def __init__(self) -> None:
+    self._queue: List[Tuple[int, int, Callable[[], None]]] = []
+    self._seq = 0
+    self.round = 0
+
+  def schedule(self, round_: int, fn: Callable[[], None]) -> None:
+    heapq.heappush(self._queue, (round_, self._seq, fn))
+    self._seq += 1
+
+  def run(self, n_rounds: int, on_round: Callable[[int], None]) -> None:
+    for r in range(self.round, self.round + n_rounds):
+      while self._queue and self._queue[0][0] <= r:
+        heapq.heappop(self._queue)[2]()
+      on_round(r)
+    self.round += n_rounds
diff --git a/postprocessing.py b/postprocessing.py
index 6a8956d..c663c3b 100644
--- a/postprocessing.py
+++ b/postprocessing.py
@@ -308,7 +308,8 @@ def plot_history(
     nrows = Nn, 
     ncols = 2 * Nf + 3, 
     sharex = True,
-    figsize = ((2 * Nf + 3) * 8, 6 * Nn)
+    figsize = ((2 * Nf + 3) * 8, 6 * Nn),
+    squeeze = False
   )
   for function, traces in input_requests_traces.items():
     for agent, incoming_load in traces.items():
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..53314a3
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,120 @@
+[project]
+name = "dfaasoptimizer"
+version = "0.1.0"
+description = "Optimization models and experiment orchestration for FRALB/DiFRALB in FaaS-enabled edge-cloud continuums."
+readme = "README.md"
+requires-python = ">=3.10,<3.11"
+dependencies = [
+  "contourpy==1.3.2",
+  "cycler==0.12.1",
+  "fonttools==4.59.0",
+  "gurobipy==12.0.3",
+  "kiwisolver==1.4.8",
+  "matplotlib==3.10.3",
+  "networkx==3.4.2",
+  "numpy==2.2.6",
+  "packaging==25.0",
+  "pandas==2.3.1",
+  "parse==1.20.2",
+  "pillow==11.3.0",
+  "ply==3.11",
+  "pyomo==6.9.2",
+  "pyparsing==3.2.3",
+  "python-dateutil==2.9.0.post0",
+  "pyyaml>=6.0.2",
+  "ray-dispatcher",
+  "rich>=13,<15",
+  "pytz==2025.2",
+  "scipy==1.15.3",
+  "six==1.17.0",
+  "tqdm==4.67.1",
+  "tzdata==2025.2",
+  "seaborn>=0.13.2",
+]
+
+[tool.uv]
+package = false
+
+[tool.uv.sources]
+ray-dispatcher = { git = "https://github.com/miciav/ray-dispatcher.git", tag = "v0.1.1" }
+
+[dependency-groups]
+dev = [
+    "mypy>=2.1.0",
+    "pandas-stubs>=2.3.3.260113",
+    "pre-commit>=4.6.0",
+    "pytest>=9.0.3",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.13",
+    "types-pyyaml>=6.0.12.20260518",
+]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+indent-width = 2
+
+[tool.ruff.lint]
+select = [
+  "E9",
+  "F",
+]
+ignore = [
+  "F401",
+  "F541",
+  "F841",
+]
+
+[tool.ruff.format]
+indent-style = "space"
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.10"
+files = [
+  "*.py",
+  "models",
+  "tests",
+]
+check_untyped_defs = true
+disable_error_code = [
+  "arg-type",
+  "assignment",
+  "attr-defined",
+  "call-overload",
+  "has-type",
+  "index",
+  "list-item",
+  "misc",
+  "operator",
+  "override",
+  "return-value",
+  "str-bytes-safe",
+  "union-attr",
+  "valid-type",
+  "var-annotated",
+]
+follow_imports = "skip"
+ignore_missing_imports = true
+implicit_optional = true
+show_error_codes = true
+warn_unused_configs = true
+warn_unused_ignores = true
+
+[tool.coverage.run]
+branch = true
+source = [
+  ".",
+]
+omit = [
+  ".claude/*",
+  ".gitnexus/*",
+  ".pytest_cache/*",
+  ".uv-cache/*",
+  ".venv/*",
+  "tests/*",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
diff --git a/remote_experiments/README.md b/remote_experiments/README.md
new file mode 100644
index 0000000..7292f44
--- /dev/null
+++ b/remote_experiments/README.md
@@ -0,0 +1,89 @@
+# remote_experiments
+
+Define batches, materialize immutable inputs once, then run DFaaSOptimizer
+experiments on Gurobi-equipped VMs via `ray-dispatcher` with a live TUI.
+
+## Prerequisites
+
+- VMs in the inventory need SSH reachability and Gurobi installed with a
+  license (see `--gurobi-license`).
+- VMs need outbound network access while provisioning Python and dependencies.
+- `--project-path` defaults to `.` (this repo's root) — that's what gets
+  rsynced to each VM, excluding `.venv/`, `.git/`, `solutions/`, `results/`,
+  `batches/`, and the materialized instance store.
+
+## Define a batch
+
+```
+uv run -m remote_experiments define smoke -o batches/smoke.json
+```
+
+Builds every `Experiment` for the named suite (a registered function under
+`remote_experiments/definitions/`) and writes them to a static JSON file.
+
+The paper suites use `hierarchical-madea`, which extends the production
+FaaS-MADeA auction with higher-level coordination. The older `hierarchical`
+runner remains available in the smoke suite as a legacy diagnostic method.
+
+## Materialize the instances
+
+```bash
+uv run -m remote_experiments materialize batches/smoke.json
+```
+
+This creates `remote_experiments/instances/<suite>/`. Experiments whose input
+generation specification is identical share one instance directory. Each
+instance contains base optimization data, load limits, the complete temporal
+request traces, the exact graph with edge attributes, and SHA-256 metadata.
+Existing valid instances are reused; missing or modified files are rejected.
+
+The generation seed recorded in instance metadata reproduces topology, weights,
+capacities, and load traces. The experiment's runtime seed remains an algorithm
+configuration. They are separate concepts even when a study initially assigns
+them the same numeric value.
+
+## Run (or resume) a batch
+
+```
+cp remote_experiments/inventory.yaml.example my-inventory.yaml  # edit hosts
+uv run -m remote_experiments run batches/smoke.json --inventory my-inventory.yaml \
+  --gurobi-license ~/gurobi.lic
+```
+
+Shows which experiments are pending (everything not yet `succeeded`,
+tracked in `batches/smoke.manifest.json`), prompts for a selection
+(indices, ranges, or `all` — default is every pending one), then submits
+and shows a live progress view.
+
+Ctrl-C cancels in-flight jobs and stops cleanly. Re-running the same `run`
+command resumes — it defaults to selecting only what isn't `succeeded` yet.
+Every selected job transfers only its own materialized instance. Use
+`--instances <root>` when the store is not under `remote_experiments/instances`.
+
+## Adding a suite
+
+Add a file to `remote_experiments/definitions/` with a function decorated
+`@register_suite("name")` returning a `list[Experiment]` (see `smoke.py`).
+
+## Run the two-phase paper campaign
+
+One command runs screening, auto-selects the 4 survivor algorithms, then runs
+the confirmatory suites on survivors + anchors (centralized, hierarchical-madea):
+
+```bash
+uv run -m remote_experiments campaign --inventory my-inventory.yaml \
+  --gurobi-license ~/gurobi.lic
+```
+
+Progress is checkpointed in `batches/campaign-state.json` and each suite has its
+own `batches/<suite>.manifest.json`, so re-running `campaign` resumes where it
+stopped. Survivors are written to `batches/survivors.json`; delete it (and reset
+the state file to `{"stage":"screening","done_suites":[]}`) to re-screen.
+
+Generated suite directories are ignored by Git. For archival, create a ZIP only
+after materialization and retain its external SHA-256 checksum; ZIP files are
+not used directly by the runners.
+
+To inspect a single suite without the orchestrator, the old
+`define`/`materialize`/`run` commands above still work (add `--yes` to `run`
+to skip the prompt).
diff --git a/remote_experiments/__init__.py b/remote_experiments/__init__.py
new file mode 100644
index 0000000..4e0ca5b
--- /dev/null
+++ b/remote_experiments/__init__.py
@@ -0,0 +1 @@
+"""Define-then-run batches of DFaaSOptimizer experiments on remote Gurobi VMs via ray-dispatcher."""
diff --git a/remote_experiments/__main__.py b/remote_experiments/__main__.py
new file mode 100644
index 0000000..013582e
--- /dev/null
+++ b/remote_experiments/__main__.py
@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+  main()
diff --git a/remote_experiments/batch.py b/remote_experiments/batch.py
new file mode 100644
index 0000000..10d6a50
--- /dev/null
+++ b/remote_experiments/batch.py
@@ -0,0 +1,48 @@
+"""Experiment and Batch value objects: build once, serialize, run later."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Experiment:
+  id: str
+  suite: str
+  algorithm: str
+  seed: int
+  graph_params: dict
+  load_params: dict
+  config: dict
+
+  def to_dict(self) -> dict:
+    return asdict(self)
+
+  @classmethod
+  def from_dict(cls, data: dict) -> Experiment:
+    return cls(**data)
+
+
+@dataclass(frozen=True)
+class Batch:
+  suite: str
+  experiments: tuple[Experiment, ...]
+
+  def to_dict(self) -> dict:
+    return {"suite": self.suite, "experiments": [e.to_dict() for e in self.experiments]}
+
+  @classmethod
+  def from_dict(cls, data: dict) -> Batch:
+    return cls(
+      suite=data["suite"],
+      experiments=tuple(Experiment.from_dict(e) for e in data["experiments"]),
+    )
+
+  def save(self, path: str | Path) -> None:
+    Path(path).write_text(json.dumps(self.to_dict(), indent=2))
+
+  @classmethod
+  def load(cls, path: str | Path) -> Batch:
+    return cls.from_dict(json.loads(Path(path).read_text()))
diff --git a/remote_experiments/campaign.py b/remote_experiments/campaign.py
new file mode 100644
index 0000000..84d6f57
--- /dev/null
+++ b/remote_experiments/campaign.py
@@ -0,0 +1,95 @@
+"""Orchestrate the two-phase campaign: screening -> select survivors -> confirm."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .batch import Batch
+from .definitions import get_suite
+from .definitions.paper import SURVIVORS_PATH
+from .instances import materialize_batch
+from .manifest import Manifest
+from .selection import default_selection
+from .survivors import select_survivors
+
+SCREENING_SUITE = "paper-a-screening"
+CONFIRMATORY_SUITES = (
+  "paper-e1-quality-runtime", "paper-e2-scalability", "paper-e3-topology",
+  "paper-e4-robustness", "paper-e5-dynamics", "paper-e6-ablation",
+  "paper-e7-tradeoffs", "paper-e8-spatial-latency",
+)
+STATE_PATH = Path("batches") / "campaign-state.json"
+
+
+def _load_state() -> dict:
+  if STATE_PATH.exists():
+    return json.loads(STATE_PATH.read_text())
+  return {"stage": "screening", "done_suites": []}
+
+
+def _save_state(state: dict) -> None:
+  STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+  STATE_PATH.write_text(json.dumps(state, indent=2))
+
+
+def write_survivors(path: Path, survivors: list[str]) -> None:
+  Path(path).parent.mkdir(parents=True, exist_ok=True)
+  Path(path).write_text(json.dumps({"survivors": survivors}, indent=2))
+
+
+def _batch_path(suite: str) -> Path:
+  return Path("batches") / f"{suite}.json"
+
+
+def _define_and_materialize(suite: str, instances_root: str) -> Batch:
+  batch = Batch(suite=suite, experiments=tuple(get_suite(suite)()))
+  path = _batch_path(suite)
+  batch.save(path)
+  materialize_batch(batch, instances_root)
+  return batch
+
+
+def _run_suite(suite: str, args, state: dict) -> bool:
+  # imported lazily to avoid a cli<->campaign import cycle
+  from .cli import execute_batch
+  batch = _define_and_materialize(suite, args.instances)
+  manifest_path = _batch_path(suite).with_suffix(".manifest.json")
+  manifest = Manifest(manifest_path)
+  selected_idx = default_selection([e.id for e in batch.experiments], manifest)
+  selected = [batch.experiments[i] for i in selected_idx]
+  if not selected:
+    return True
+  return execute_batch(batch, manifest, manifest_path, selected, args)
+
+
+def run_campaign(args) -> None:
+  state = _load_state()
+
+  if state["stage"] == "screening":
+    if not _run_suite(SCREENING_SUITE, args, state):
+      print("screening interrupted — rerun campaign to resume")
+      return
+    state["stage"] = "select"
+    _save_state(state)
+
+  if state["stage"] == "select":
+    # rebuild the (deterministic) screening batch rather than reading it back
+    # from disk — keeps `select` independent of `_run_suite`'s side effects.
+    batch = Batch(suite=SCREENING_SUITE, experiments=tuple(get_suite(SCREENING_SUITE)()))
+    survivors = select_survivors(batch, Path(args.results_dir) / SCREENING_SUITE)
+    write_survivors(SURVIVORS_PATH, survivors)
+    print(f"survivors: {survivors}")
+    state["stage"] = "confirm"
+    _save_state(state)
+
+  if state["stage"] == "confirm":
+    for suite in CONFIRMATORY_SUITES:
+      if suite in state["done_suites"]:
+        continue
+      if not _run_suite(suite, args, state):
+        print(f"{suite} interrupted — rerun campaign to resume")
+        return
+      state["done_suites"].append(suite)
+      _save_state(state)
+  print("campaign complete")
diff --git a/remote_experiments/cli.py b/remote_experiments/cli.py
new file mode 100644
index 0000000..8559d2f
--- /dev/null
+++ b/remote_experiments/cli.py
@@ -0,0 +1,152 @@
+"""CLI entry point: `define` builds a batch file from a suite, `run` executes/resumes it."""
+
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+
+from ray_dispatcher import Dispatcher, Inventory, Project, SecretFile
+
+from . import definitions  # imports register all suites as a side effect
+from .batch import Batch
+from .definitions import get_suite, list_suites
+from .jobs import experiment_to_job
+from .instances import materialize_batch
+from .manifest import Manifest, SUCCEEDED
+from .runner import run_batch
+from .selection import default_selection, parse_selection
+from .tui import live_view
+
+
+def cmd_define(args: argparse.Namespace) -> None:
+  build = get_suite(args.suite)
+  experiments = build()
+  batch = Batch(suite=args.suite, experiments=tuple(experiments))
+  out_path = Path(args.output)
+  out_path.parent.mkdir(parents=True, exist_ok=True)
+  batch.save(out_path)
+  print(f"wrote {len(experiments)} experiments to {out_path}")
+
+
+def cmd_materialize(args: argparse.Namespace) -> None:
+  batch = Batch.load(args.batch_file)
+  suite_path = materialize_batch(batch, args.output)
+  print(f"materialized {batch.suite} instances in {suite_path}")
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+  batch = Batch.load(args.batch_file)
+  manifest_path = Path(args.batch_file).with_suffix(".manifest.json")
+  manifest = Manifest(manifest_path)
+  experiment_ids = [e.id for e in batch.experiments]
+
+  default_idx = default_selection(experiment_ids, manifest)
+  print(f"{len(batch.experiments)} experiments in batch, {len(default_idx)} pending")
+  for i, e in enumerate(batch.experiments):
+    print(f"  [{i}] {e.id} ({manifest.status(e.id)})")
+  if args.yes:
+    selected_idx = default_idx
+  else:
+    raw = input(f"Select to run [default: {len(default_idx)} pending] (indices/ranges/'all'): ")
+    selected_idx = parse_selection(raw, len(batch.experiments)) if raw.strip() else default_idx
+  selected = [batch.experiments[i] for i in selected_idx]
+  if not selected:
+    print("nothing selected, exiting")
+    return
+
+  completed = execute_batch(batch, manifest, manifest_path, selected, args)
+  if not completed:
+    print("stopped — rerun the same command to resume")
+  else:
+    unsuccessful = sum(manifest.status(e.id) != SUCCEEDED for e in selected)
+    if unsuccessful:
+      label = "experiment" if unsuccessful == 1 else "experiments"
+      print(f"batch finished with {unsuccessful} unsuccessful {label}")
+    else:
+      print("batch complete")
+
+
+def execute_batch(batch, manifest, manifest_path, selected, args) -> bool:
+  inventory = Inventory.from_yaml(args.inventory)
+  secrets = ()
+  if args.gurobi_license:
+    secrets = (
+      SecretFile(source=args.gurobi_license, remote_name="gurobi.lic", env_var="GRB_LICENSE_FILE"),
+    )
+  project = Project(
+    path=str(Path(args.project_path).resolve()),
+    project_id="dfaas-optimizer",
+    python=args.python_version,
+    uv_version=args.uv_version,
+    secrets=secrets,
+    exclude=(
+      ".venv/", ".git/", "solutions/", "results/", "batches/",
+      "remote_experiments/instances/",
+    ),
+  )
+  config_dir = manifest_path.parent / f"{manifest_path.stem}-configs"
+  jobs = [
+    experiment_to_job(e, config_dir, Path(args.instances)) for e in selected
+  ]
+
+  with Dispatcher(inventory, project, results_dir=args.results_dir) as dispatcher:
+    start = time.monotonic()
+    with live_view(batch, manifest, inventory, start_time=start) as on_tick:
+      return run_batch(dispatcher, jobs, manifest, on_tick, batch_id=batch.suite)
+
+
+def cmd_campaign(args: argparse.Namespace) -> None:
+  from .campaign import run_campaign
+  run_campaign(args)
+
+
+def build_parser() -> argparse.ArgumentParser:
+  parser = argparse.ArgumentParser(prog="remote_experiments")
+  sub = parser.add_subparsers(dest="command", required=True)
+
+  define_p = sub.add_parser("define", help="Build a batch file from a registered suite")
+  define_p.add_argument("suite", choices=list_suites())
+  define_p.add_argument("-o", "--output", required=True)
+  define_p.set_defaults(func=cmd_define)
+
+  materialize_p = sub.add_parser(
+    "materialize", help="Generate and checksum every unique instance in a batch",
+  )
+  materialize_p.add_argument("batch_file")
+  materialize_p.add_argument(
+    "-o", "--output", default="remote_experiments/instances",
+  )
+  materialize_p.set_defaults(func=cmd_materialize)
+
+  run_p = sub.add_parser("run", help="Run (or resume) a batch file through the TUI")
+  run_p.add_argument("batch_file")
+  run_p.add_argument("--inventory", required=True)
+  run_p.add_argument("--project-path", default=".")
+  run_p.add_argument("--results-dir", default="./results")
+  run_p.add_argument("--instances", default="remote_experiments/instances")
+  run_p.add_argument("--gurobi-license", default=None)
+  run_p.add_argument("--python-version", default="3.10.19")
+  run_p.add_argument("--uv-version", default="0.11.25")
+  run_p.add_argument("--yes", action="store_true", help="Run all pending without prompting")
+  run_p.set_defaults(func=cmd_run)
+
+  campaign_p = sub.add_parser(
+    "campaign", help="Run the full two-phase campaign (screen->select->confirm)",
+  )
+  campaign_p.add_argument("--inventory", required=True)
+  campaign_p.add_argument("--project-path", default=".")
+  campaign_p.add_argument("--results-dir", default="./results")
+  campaign_p.add_argument("--instances", default="remote_experiments/instances")
+  campaign_p.add_argument("--gurobi-license", default=None)
+  campaign_p.add_argument("--python-version", default="3.10.19")
+  campaign_p.add_argument("--uv-version", default="0.11.25")
+  campaign_p.set_defaults(func=cmd_campaign)
+
+  return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+  parser = build_parser()
+  args = parser.parse_args(argv)
+  args.func(args)
diff --git a/remote_experiments/definitions/__init__.py b/remote_experiments/definitions/__init__.py
new file mode 100644
index 0000000..5fae548
--- /dev/null
+++ b/remote_experiments/definitions/__init__.py
@@ -0,0 +1,29 @@
+"""Registry of pluggable experiment suites: @register_suite("name") -> builder fn."""
+
+from collections.abc import Callable
+
+from ..batch import Experiment
+
+_REGISTRY: dict[str, Callable[..., list[Experiment]]] = {}
+
+
+def register_suite(name: str):
+  def decorator(fn: Callable[..., list[Experiment]]) -> Callable[..., list[Experiment]]:
+    if name in _REGISTRY:
+      raise ValueError(f"suite already registered: {name}")
+    _REGISTRY[name] = fn
+    return fn
+  return decorator
+
+
+def get_suite(name: str) -> Callable[..., list[Experiment]]:
+  if name not in _REGISTRY:
+    raise KeyError(f"unknown suite: {name!r}; available: {sorted(_REGISTRY)}")
+  return _REGISTRY[name]
+
+
+def list_suites() -> list[str]:
+  return sorted(_REGISTRY)
+
+
+from . import paper, smoke  # imported for @register_suite side effects
diff --git a/remote_experiments/definitions/paper.py b/remote_experiments/definitions/paper.py
new file mode 100644
index 0000000..4266446
--- /dev/null
+++ b/remote_experiments/definitions/paper.py
@@ -0,0 +1,352 @@
+"""Full experiment suites for the hierarchical-model journal evaluation."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+from ..batch import Experiment
+from . import register_suite
+
+_BASE_CONFIG_PATH = Path(__file__).resolve().parents[2] / "config_files" / "eval_full.json"
+
+PILOT_SEEDS = tuple(range(1, 11))
+CONFIRMATORY_SEEDS = tuple(range(1001, 1006))
+
+ANCHORS = ("centralized", "hierarchical-madea")
+DEFAULT_SURVIVORS = ("faas-madea", "faas-diffuse", "faas-powd", "faas-br-o")
+WEIGHT_TUNABLE = {
+  "hierarchical-madea": "auction", "faas-madea": "auction",
+  "faas-diffuse": "diffusion", "faas-powd": "powerd",
+}
+SURVIVORS_PATH = Path(__file__).resolve().parents[2] / "batches" / "survivors.json"
+
+SCREENING_CANDIDATES = (
+  "faas-macro", "faas-macro-v0", "faas-madea", "faas-diffuse", "faas-powd",
+  "faas-br-s", "faas-br-r", "faas-br-o", "faas-pg-s", "faas-pg-r", "faas-gcaa", "plasma",
+)
+
+
+def _survivors() -> tuple[str, ...]:
+  if SURVIVORS_PATH.exists():
+    try:
+      return tuple(json.loads(SURVIVORS_PATH.read_text())["survivors"])
+    except (json.JSONDecodeError, KeyError, TypeError):
+      return DEFAULT_SURVIVORS
+  return DEFAULT_SURVIVORS
+
+
+def _final_algorithms() -> tuple[str, ...]:
+  return ANCHORS + _survivors()
+
+
+def _tunable(algorithms: tuple[str, ...]) -> tuple[str, ...]:
+  return tuple(a for a in algorithms if a in WEIGHT_TUNABLE)
+
+
+def _base_config() -> dict:
+  return json.loads(_BASE_CONFIG_PATH.read_text())
+
+
+def _set_dimensions(config: dict, nodes: int, functions: int) -> None:
+  limits = config["limits"]
+  limits["Nn"] = {"min": nodes, "max": nodes}
+  limits["Nf"] = {"min": functions, "max": functions}
+  repeats = (functions + 1) // 2
+  limits["demand"]["values"] = ([1.0, 1.2] * repeats)[:functions]
+  limits["memory_requirement"]["values"] = ([2, 3] * repeats)[:functions]
+
+
+def _new_config(nodes: int, functions: int, topology: dict) -> dict:
+  config = _base_config()
+  _set_dimensions(config, nodes, functions)
+  config["limits"]["neighborhood"] = copy.deepcopy(topology)
+  return config
+
+
+def _euclidean_planar(mean_degree: int = 3) -> dict:
+  return {
+    "type": "euclidean_planar",
+    "mean_degree": mean_degree,
+    "density": 1.0,
+  }
+
+
+def _experiment(
+    suite: str, cell: str, algorithm: str, seed: int, config: dict,
+  ) -> Experiment:
+  experiment_id = f"{suite}-{cell}-{algorithm}-s{seed}"
+  config["instance_seed"] = seed
+  config["seed"] = seed
+  config["base_solution_folder"] = f"solutions/{experiment_id}"
+  limits = config["limits"]
+  return Experiment(
+    id=experiment_id,
+    suite=suite,
+    algorithm=algorithm,
+    seed=seed,
+    graph_params={k: copy.deepcopy(v) for k, v in limits.items() if k != "load"},
+    load_params=copy.deepcopy(limits["load"]),
+    config=config,
+  )
+
+
+@register_suite("paper-e0-pilot")
+def build_e0(
+    seeds: tuple[int, ...] = PILOT_SEEDS,
+    algorithms: tuple[str, ...] = (
+      "centralized", "hierarchical-madea", "faas-macro", "faas-madea",
+    ),
+  ) -> list[Experiment]:
+  suite = "paper-e0-pilot"
+  return [
+    _experiment(
+      suite, f"n{nodes}-f2-planar3", algorithm, seed,
+      _new_config(nodes, 2, _euclidean_planar()),
+    )
+    for nodes in (10, 20, 50)
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+
+
+@register_suite("paper-a-screening")
+def build_screening(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = SCREENING_CANDIDATES + ("hierarchical-madea",),
+  ) -> list[Experiment]:
+  suite = "paper-a-screening"
+  return [
+    _experiment(
+      suite, f"n{nodes}-f{functions}-planar3", algorithm, seed,
+      _new_config(nodes, functions, _euclidean_planar()),
+    )
+    for nodes in (50, 100)
+    for functions in (2, 4)
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+
+
+@register_suite("paper-e1-quality-runtime")
+def build_e1(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e1-quality-runtime"
+  algorithms = algorithms or _final_algorithms()
+  return [
+    _experiment(
+      suite, f"n{nodes}-f{functions}-planar3", algorithm, seed,
+      _new_config(nodes, functions, _euclidean_planar()),
+    )
+    for nodes in (10, 20, 30)
+    for functions in (2, 4)
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+
+
+@register_suite("paper-e2-scalability")
+def build_e2(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+  ) -> list[Experiment]:
+  suite = "paper-e2-scalability"
+  scalable = ("hierarchical-madea",) + _survivors()
+  experiments = []
+  for nodes in (10, 20, 50, 100, 200, 500):
+    algorithms = scalable + (("centralized",) if nodes <= 20 else ())
+    for functions in (2, 4, 8):
+      for algorithm in algorithms:
+        for seed in seeds:
+          experiments.append(_experiment(
+            suite, f"n{nodes}-f{functions}-reg3", algorithm, seed,
+            _new_config(nodes, functions, {"k": 3}),
+          ))
+  return experiments
+
+
+@register_suite("paper-e3-topology")
+def build_e3(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e3-topology"
+  algorithms = algorithms or _final_algorithms()
+  topologies = (
+    ("planar3", _euclidean_planar(3)),
+    ("planar5", _euclidean_planar(5)),
+    ("reg3", {"k": 3}),
+    ("reg5", {"k": 5}),
+    ("er3", {"m": 75}),
+    ("er5", {"m": 125}),
+  )
+  return [
+    _experiment(
+      suite, topology_name, algorithm, seed,
+      _new_config(50, 4, topology),
+    )
+    for topology_name, topology in topologies
+    for algorithm in algorithms
+    for seed in seeds
+  ]
+
+
+def _apply_robustness_condition(config: dict, condition: str) -> None:
+  limits = config["limits"]
+  if condition == "load-low":
+    limits["load"].update({"min": {"min": 2, "max": 5}, "max": {"min": 20, "max": 40}})
+  elif condition == "load-high":
+    limits["load"].update({"min": {"min": 10, "max": 20}, "max": {"min": 100, "max": 150}})
+  elif condition == "memory-scarce":
+    limits["memory_capacity"] = {"min": 8, "max": 8}
+  elif condition == "memory-ample":
+    limits["memory_capacity"] = {"min": 24, "max": 24}
+  elif condition == "nodes-homogeneous":
+    limits["demand"] = {"values": [1.1] * 4}
+    limits["memory_capacity"] = {"min": 12, "max": 12}
+    limits["max_utilization"] = {"min": 0.7, "max": 0.7}
+  elif condition == "nodes-heterogeneous":
+    limits["demand"] = {"type": "heterogeneous", "min": 0.5, "max": 2.0}
+    limits["memory_capacity"] = {"repeated_values": [[0.5, 8], [0.5, 24]]}
+
+
+@register_suite("paper-e4-robustness")
+def build_e4(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e4-robustness"
+  algorithms = algorithms or _final_algorithms()
+  conditions = (
+    "baseline", "load-low", "load-high", "memory-scarce", "memory-ample",
+    "nodes-homogeneous", "nodes-heterogeneous",
+  )
+  experiments = []
+  for condition in conditions:
+    for algorithm in algorithms:
+      for seed in seeds:
+        config = _new_config(50, 4, _euclidean_planar())
+        _apply_robustness_condition(config, condition)
+        experiments.append(_experiment(suite, condition, algorithm, seed, config))
+  return experiments
+
+
+@register_suite("paper-e5-dynamics")
+def build_e5(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e5-dynamics"
+  algorithms = algorithms or _final_algorithms()
+  experiments = []
+  for trace_type in ("sinusoidal", "clipped", "fixed_sum_minmax"):
+    for algorithm in algorithms:
+      for seed in seeds:
+        config = _new_config(50, 4, _euclidean_planar())
+        config.update({
+          "max_steps": 100, "min_run_time": 0,
+          "max_run_time": 100, "run_time_step": 1,
+        })
+        config["limits"]["load"]["trace_type"] = trace_type
+        experiments.append(_experiment(
+          suite, trace_type.replace("_", "-"), algorithm, seed, config,
+        ))
+  return experiments
+
+
+def _apply_ablation(config: dict, variant: str) -> None:
+  auction = config["solver_options"]["auction"]
+  if variant.startswith("depth"):
+    config["max_hierarchy_depth"] = int(variant.removeprefix("depth"))
+  elif variant.startswith("eta"):
+    auction["eta"] = {"eta0": 0.0, "eta01": 0.1, "eta05": 0.5}[variant]
+  elif variant.startswith("eps"):
+    auction["epsilon"] = {"eps0001": 0.001, "eps01": 0.1}[variant]
+
+
+@register_suite("paper-e6-ablation")
+def build_e6(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+  ) -> list[Experiment]:
+  suite = "paper-e6-ablation"
+  variants = (
+    "base", "depth1", "depth2", "depth4", "depth5",
+    "eta0", "eta01", "eta05", "eps0001", "eps01",
+  )
+  topologies = (
+    ("planar3", _euclidean_planar()),
+    ("reg3", {"k": 3}),
+  )
+  experiments = []
+  for variant in variants:
+    for nodes in (50,):
+      for topology_name, topology in topologies:
+        for seed in seeds:
+          config = _new_config(nodes, 4, topology)
+          _apply_ablation(config, variant)
+          experiments.append(_experiment(
+            suite, f"{variant}-n{nodes}-{topology_name}",
+            "hierarchical-madea", seed, config,
+          ))
+  return experiments
+
+
+@register_suite("paper-e7-tradeoffs")
+def build_e7(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e7-tradeoffs"
+  algorithms = algorithms or _tunable(_final_algorithms())
+  weights = (
+    ("l0-f0", 0, 0), ("l025-f0", 0.25, 0), ("l1-f0", 1, 0),
+    ("l0-f025", 0, 0.25), ("l0-f1", 0, 1),
+    ("l025-f025", 0.25, 0.25), ("l1-f1", 1, 1),
+  )
+  topologies = (
+    ("planar3", _euclidean_planar()),
+    ("reg3", {"k": 3}),
+  )
+  experiments = []
+  for weight_name, latency_weight, fairness_weight in weights:
+    for topology_name, topology in topologies:
+      for algorithm in algorithms:
+        for seed in seeds:
+          config = _new_config(50, 4, topology)
+          section = WEIGHT_TUNABLE[algorithm]
+          options = config["solver_options"][section]
+          options["latency_weight"] = latency_weight
+          options["fairness_weight"] = fairness_weight
+          experiments.append(_experiment(
+            suite, f"{weight_name}-{topology_name}", algorithm, seed, config,
+          ))
+  return experiments
+
+
+@register_suite("paper-e8-spatial-latency")
+def build_e8(
+    seeds: tuple[int, ...] = CONFIRMATORY_SEEDS,
+    algorithms: tuple[str, ...] = (),
+  ) -> list[Experiment]:
+  suite = "paper-e8-spatial-latency"
+  algorithms = algorithms or _tunable(_final_algorithms())
+  experiments = []
+  for nodes in (20, 50, 100):
+    for mode in ("euclidean", "euclidean_permuted"):
+      for algorithm in algorithms:
+        for seed in seeds:
+          config = _new_config(nodes, 4, _euclidean_planar())
+          config["limits"]["weights"]["edge_network_latency"] = {
+            "mode": mode,
+            "base": 1.0,
+            "distance_factor": 1.0,
+            "jitter": {"min": 0.0, "max": 0.1},
+          }
+          section = WEIGHT_TUNABLE[algorithm]
+          config["solver_options"][section]["latency_weight"] = 0.25
+          experiments.append(_experiment(
+            suite, f"n{nodes}-{mode.replace('_', '-')}", algorithm, seed, config,
+          ))
+  return experiments
diff --git a/remote_experiments/definitions/smoke.py b/remote_experiments/definitions/smoke.py
new file mode 100644
index 0000000..b7bcf92
--- /dev/null
+++ b/remote_experiments/definitions/smoke.py
@@ -0,0 +1,41 @@
+"""Example pluggable suite: every algorithm across a couple of seeds, from eval_smoke.json."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+from ..batch import Experiment
+from . import register_suite
+
+_BASE_CONFIG_PATH = Path(__file__).resolve().parents[2] / "config_files" / "eval_smoke.json"
+
+ALGORITHMS = (
+  "centralized", "faas-macro", "faas-macro-v0", "faas-madea", "hierarchical",
+  "hierarchical-madea",
+  "faas-diffuse", "faas-powd", "faas-br-s", "faas-br-r", "faas-br-o",
+)
+
+
+@register_suite("smoke")
+def build(
+    seeds: tuple[int, ...] = (42, 43),
+    algorithms: tuple[str, ...] = ALGORITHMS,
+  ) -> list[Experiment]:
+  base_config = json.loads(_BASE_CONFIG_PATH.read_text())
+  limits = base_config["limits"]
+  graph_params = {k: v for k, v in limits.items() if k != "load"}
+  load_params = limits["load"]
+  experiments = []
+  for seed in seeds:
+    for algorithm in algorithms:
+      config = copy.deepcopy(base_config)
+      config["seed"] = seed
+      experiment_id = f"smoke-{algorithm}-seed{seed}"
+      config["base_solution_folder"] = f"solutions/{experiment_id}"
+      experiments.append(Experiment(
+        id=experiment_id, suite="smoke", algorithm=algorithm, seed=seed,
+        graph_params=graph_params, load_params=load_params, config=config,
+      ))
+  return experiments
diff --git a/remote_experiments/instances.py b/remote_experiments/instances.py
new file mode 100644
index 0000000..e541794
--- /dev/null
+++ b/remote_experiments/instances.py
@@ -0,0 +1,162 @@
+"""Materialize complete, checksummed inputs shared by remote experiments."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import networkx as nx
+import numpy as np
+
+from generators.generate_data import generate_data
+from generators.generate_load import generate_load_traces
+from utils.common import (
+  NpEncoder,
+  delete_tuples,
+  load_base_instance,
+  load_requests_traces,
+)
+
+from .batch import Batch, Experiment
+
+PAYLOAD_FILES = (
+  "base_instance_data.json",
+  "load_limits.json",
+  "input_requests_traces.json",
+  "graph.json",
+)
+
+
+def generation_spec(experiment: Experiment) -> dict:
+  config = experiment.config
+  return {
+    "generation_seed": config.get("instance_seed", experiment.seed),
+    "limits": config["limits"],
+    "max_steps": config["max_steps"],
+    "min_run_time": config.get("min_run_time", 0),
+    "max_run_time": config.get("max_run_time", config["max_steps"]),
+    "run_time_step": config.get("run_time_step", 1),
+  }
+
+
+def instance_id(experiment: Experiment) -> str:
+  encoded = json.dumps(
+    generation_spec(experiment), sort_keys=True, separators=(",", ":"),
+  ).encode()
+  return f"instance-{hashlib.sha256(encoded).hexdigest()[:16]}"
+
+
+def _sha256(path: Path) -> str:
+  digest = hashlib.sha256()
+  with path.open("rb") as stream:
+    for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+      digest.update(chunk)
+  return digest.hexdigest()
+
+
+def validate_instance(path: str | Path) -> dict:
+  instance_path = Path(path)
+  metadata_path = instance_path / "metadata.json"
+  if not metadata_path.is_file():
+    raise ValueError(f"missing instance metadata: {metadata_path}")
+  metadata = json.loads(metadata_path.read_text())
+  for filename in PAYLOAD_FILES:
+    payload_path = instance_path / filename
+    if not payload_path.is_file():
+      raise ValueError(f"missing instance file: {payload_path}")
+    expected = metadata.get("files", {}).get(filename)
+    actual = _sha256(payload_path)
+    if expected != actual:
+      raise ValueError(
+        f"checksum mismatch for {filename}: expected {expected}, got {actual}"
+      )
+  return metadata
+
+
+def materialize_instance(experiment: Experiment, path: str | Path) -> Path:
+  instance_path = Path(path)
+  if instance_path.exists():
+    metadata = validate_instance(instance_path)
+    if metadata.get("generation") != generation_spec(experiment):
+      raise ValueError(f"generation specification mismatch for {instance_path}")
+    return instance_path
+
+  instance_path.mkdir(parents=True)
+  spec = generation_spec(experiment)
+  limits = spec["limits"]
+  rng = np.random.default_rng(seed=spec["generation_seed"])
+  base_data, load_limits, graph = generate_data(
+    limits.get("instance_type", "random"), rng=rng, limits=limits,
+  )
+  traces = generate_load_traces(
+    load_limits,
+    spec["max_steps"],
+    spec["generation_seed"],
+    limits["load"].get("trace_type", "fixed_sum"),
+    enable_plotting=False,
+  )
+
+  (instance_path / "base_instance_data.json").write_text(json.dumps(
+    delete_tuples(base_data), indent=2, cls=NpEncoder,
+  ))
+  (instance_path / "load_limits.json").write_text(json.dumps(
+    load_limits, indent=2, cls=NpEncoder,
+  ))
+  (instance_path / "input_requests_traces.json").write_text(json.dumps(
+    traces, indent=2, cls=NpEncoder,
+  ))
+  (instance_path / "graph.json").write_text(json.dumps(
+    nx.node_link_data(graph, edges="edges"), indent=2, cls=NpEncoder,
+  ))
+  metadata = {
+    "schema_version": 1,
+    "instance_id": instance_id(experiment),
+    "suite": experiment.suite,
+    "generation": spec,
+    "files": {
+      filename: _sha256(instance_path / filename) for filename in PAYLOAD_FILES
+    },
+  }
+  (instance_path / "metadata.json").write_text(json.dumps(metadata, indent=2))
+  return instance_path
+
+
+def load_materialized_instance(path: str | Path) -> tuple[dict, dict, object, nx.Graph]:
+  instance_path = Path(path)
+  validate_instance(instance_path)
+  base_data, load_limits = load_base_instance(str(instance_path))
+  traces = load_requests_traces(str(instance_path))[0]
+  graph = nx.node_link_graph(
+    json.loads((instance_path / "graph.json").read_text()), edges="edges",
+  )
+  return base_data, traces, load_limits[0].keys(), graph
+
+
+def materialize_batch(batch: Batch, root: str | Path) -> Path:
+  suite_path = Path(root) / batch.suite
+  data_path = suite_path / "data"
+  data_path.mkdir(parents=True, exist_ok=True)
+  experiment_instances = {}
+  for experiment in batch.experiments:
+    identifier = instance_id(experiment)
+    materialize_instance(experiment, data_path / identifier)
+    experiment_instances[experiment.id] = identifier
+
+  identifiers = sorted(set(experiment_instances.values()))
+  manifest = {
+    "schema_version": 1,
+    "suite": batch.suite,
+    "instances": identifiers,
+    "experiments": experiment_instances,
+  }
+  (suite_path / "manifest.json").write_text(json.dumps(manifest, indent=2))
+  (suite_path / "README.md").write_text(
+    f"# {batch.suite} materialized instances\n\n"
+    f"This suite contains {len(identifiers)} immutable instances used by "
+    f"{len(batch.experiments)} experiments. Each directory under `data/` contains "
+    "the optimization data, load limits, complete temporal request traces, exact "
+    "graph, and SHA-256 metadata. Algorithm seeds and solver options remain in "
+    "the experiment batch.\n"
+  )
+  return suite_path
diff --git a/remote_experiments/instances/README.md b/remote_experiments/instances/README.md
new file mode 100644
index 0000000..56f8fae
--- /dev/null
+++ b/remote_experiments/instances/README.md
@@ -0,0 +1,8 @@
+# Materialized experiment instances
+
+The `materialize` command creates one ignored subdirectory per experiment suite
+here. Each generated suite contains its own README, manifest, and checksummed
+instance payloads. These directories are runtime data and are not committed.
+
+If a frozen dataset must be archived, package the complete suite directory as a
+ZIP and record the ZIP's SHA-256 checksum separately.
diff --git a/remote_experiments/inventory.yaml.example b/remote_experiments/inventory.yaml.example
new file mode 100644
index 0000000..5951d2f
--- /dev/null
+++ b/remote_experiments/inventory.yaml.example
@@ -0,0 +1,9 @@
+hosts:
+  - host: 10.0.0.10
+    user: ubuntu
+    slots: 2
+    identity_file: ~/.ssh/id_ed25519
+  - host: 10.0.0.11
+    user: ubuntu
+    slots: 2
+    identity_file: ~/.ssh/id_ed25519
diff --git a/remote_experiments/jobs.py b/remote_experiments/jobs.py
new file mode 100644
index 0000000..3cb4cd6
--- /dev/null
+++ b/remote_experiments/jobs.py
@@ -0,0 +1,63 @@
+"""Maps an Experiment to a ray_dispatcher.Job that runs it on a VM."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+from ray_dispatcher import InputSpec, Job, OutputSpec
+
+from .batch import Experiment
+from .instances import PAYLOAD_FILES, instance_id, validate_instance
+
+SCRIPT_BY_ALGORITHM: dict[str, tuple[tuple[str, ...], tuple[str, ...]]] = {
+  "centralized":   (("run_centralized_model.py",), ()),
+  "faas-macro":    (("run_faasmacro.py",), ()),
+  "faas-macro-v0": (("run_faasmacro.py",), ("--v0",)),
+  "faas-madea":    (("run_faasmadea.py",), ()),
+  "hierarchical":  (("-m", "hierarchical_auction.runner"), ()),
+  "hierarchical-madea": (("-m", "hierarchical_auction.madea_runner"), ()),
+  "faas-diffuse":  (("decentralized_diffusion.py",), ()),
+  "faas-powd":     (("decentralized_powerd.py",), ()),
+  "faas-br-s":     (("decentralized_bestresponse.py",), ("--variant", "s")),
+  "faas-br-r":     (("decentralized_bestresponse.py",), ("--variant", "r")),
+  "faas-br-o":     (("decentralized_bestresponse.py",), ("--variant", "o")),
+  "faas-pg-s":     (("decentralized_potentialgame.py",), ("--variant", "s")),
+  "faas-pg-r":     (("decentralized_potentialgame.py",), ("--variant", "r")),
+  "faas-gcaa":     (("decentralized_gcaa.py",), ()),
+  "plasma":        (("-m", "plasma.cli"), ()),
+}
+
+
+def experiment_to_job(
+    experiment: Experiment, config_dir: Path, instances_root: Path | None = None,
+  ) -> Job:
+  if experiment.algorithm not in SCRIPT_BY_ALGORITHM:
+    raise KeyError(f"unknown algorithm: {experiment.algorithm!r}")
+  command, extra_args = SCRIPT_BY_ALGORITHM[experiment.algorithm]
+  config_dir.mkdir(parents=True, exist_ok=True)
+  config_path = config_dir / f"{experiment.id}.json"
+  config = copy.deepcopy(experiment.config)
+  inputs = [InputSpec(source=str(config_path), destination="config.json")]
+  if instances_root is not None:
+    instance_path = (
+      Path(instances_root) / experiment.suite / "data" / instance_id(experiment)
+    )
+    validate_instance(instance_path)
+    config["limits"] = {
+      "instance_type": "materialized",
+      "path": "instance",
+      "load": {"trace_type": "load_existing", "path": "instance"},
+    }
+    inputs.extend(
+      InputSpec(source=str(instance_path / filename), destination=f"instance/{filename}")
+      for filename in (*PAYLOAD_FILES, "metadata.json")
+    )
+  config_path.write_text(json.dumps(config, indent=2))
+  return Job(
+    id=experiment.id,
+    command=("python", *command, "-c", "config.json", "--disable_plotting", *extra_args),
+    inputs=tuple(inputs),
+    outputs=(OutputSpec(source=f"solutions/{experiment.id}", destination=experiment.id, required=True),),
+  )
diff --git a/remote_experiments/manifest.py b/remote_experiments/manifest.py
new file mode 100644
index 0000000..6083073
--- /dev/null
+++ b/remote_experiments/manifest.py
@@ -0,0 +1,53 @@
+"""Per-experiment status persisted to disk, for cross-process stop/resume."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+NEVER_RUN = "never_run"
+SUCCEEDED = "succeeded"
+
+
+@dataclass
+class ManifestEntry:
+  status: str = NEVER_RUN
+  host: str | None = None
+  duration_s: float | None = None
+
+
+class Manifest:
+  def __init__(self, path: str | Path) -> None:
+    self._path = Path(path)
+    self._entries: dict[str, ManifestEntry] = {}
+    if self._path.exists():
+      raw = json.loads(self._path.read_text())
+      self._entries = {k: ManifestEntry(**v) for k, v in raw.items()}
+
+  def status(self, experiment_id: str) -> str:
+    entry = self._entries.get(experiment_id)
+    return entry.status if entry else NEVER_RUN
+
+  def host(self, experiment_id: str) -> str | None:
+    entry = self._entries.get(experiment_id)
+    return entry.host if entry else None
+
+  def duration(self, experiment_id: str) -> float | None:
+    entry = self._entries.get(experiment_id)
+    return entry.duration_s if entry else None
+
+  def record(self, experiment_id: str, **fields) -> None:
+    current = self._entries.get(experiment_id, ManifestEntry())
+    updated = ManifestEntry(**{**asdict(current), **fields})
+    self._entries[experiment_id] = updated
+    self._save()
+
+  def pending_ids(self, experiment_ids: list[str]) -> list[str]:
+    return [eid for eid in experiment_ids if self.status(eid) != SUCCEEDED]
+
+  def _save(self) -> None:
+    self._path.parent.mkdir(parents=True, exist_ok=True)
+    self._path.write_text(
+      json.dumps({k: asdict(v) for k, v in self._entries.items()}, indent=2)
+    )
diff --git a/remote_experiments/results_reader.py b/remote_experiments/results_reader.py
new file mode 100644
index 0000000..fd35fc3
--- /dev/null
+++ b/remote_experiments/results_reader.py
@@ -0,0 +1,29 @@
+"""Read a single experiment's objective/runtime from its output CSVs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+
+
+def _first_column_mean(run_dir: Path, filename: str) -> float | None:
+  matches = sorted(Path(run_dir).rglob(filename))
+  if not matches:
+    return None
+  frame = pd.read_csv(matches[0])
+  if frame.empty or frame.shape[1] == 0:
+    return None
+  return float(frame.iloc[:, 0].mean())
+
+
+def read_run_objective(run_dir: Path) -> float | None:
+  return _first_column_mean(run_dir, "obj.csv")
+
+
+def read_run_runtime(run_dir: Path) -> float | None:
+  return _first_column_mean(run_dir, "runtime.csv")
+
+
+def run_failed(run_dir: Path) -> bool:
+  return read_run_objective(run_dir) is None
diff --git a/remote_experiments/runner.py b/remote_experiments/runner.py
new file mode 100644
index 0000000..0e4cc78
--- /dev/null
+++ b/remote_experiments/runner.py
@@ -0,0 +1,65 @@
+"""Submit/poll loop driving a batch through ray_dispatcher, with stop-on-interrupt."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Sequence
+
+from ray_dispatcher import Job, JobHandle, JobStatus
+
+from .manifest import Manifest
+
+_TERMINAL = frozenset({
+  JobStatus.SUCCEEDED, JobStatus.FAILED, JobStatus.CANCELLED, JobStatus.TIMED_OUT,
+})
+
+
+def run_batch(
+    dispatcher,
+    jobs: Sequence[Job],
+    manifest: Manifest,
+    on_tick: Callable[[dict[str, str]], None],
+    *,
+    batch_id: str | None = None,
+    poll_interval_s: float = 1.0,
+    sleep: Callable[[float], None] = time.sleep,
+    now: Callable[[], float] = time.monotonic,
+  ) -> bool:
+  """Submit jobs, poll until all terminal or interrupted.
+
+  Returns True if the batch ran to completion, False if stopped (Ctrl-C):
+  in-flight jobs are cancelled and the manifest reflects their last known
+  state, so a later run_batch() call on the same experiment ids resumes
+  from there.
+  """
+  handles: list[JobHandle] = dispatcher.submit(jobs, batch_id=batch_id)
+  started_at = {h.job_id: now() for h in handles}
+  last_known_host: dict[str, str] = {}
+  for handle in handles:
+    manifest.record(handle.job_id, status="pending")
+
+  remaining = list(handles)
+  try:
+    while remaining:
+      running_hosts = dispatcher.running_hosts()
+      last_known_host.update(running_hosts)
+      next_remaining = []
+      for handle in remaining:
+        status = dispatcher.status(handle)
+        host = last_known_host.get(handle.job_id)
+        if status in _TERMINAL:
+          duration = now() - started_at[handle.job_id]
+          manifest.record(handle.job_id, status=status.value, host=host, duration_s=duration)
+        else:
+          manifest.record(handle.job_id, status=status.value, host=host)
+          next_remaining.append(handle)
+      remaining = next_remaining
+      on_tick(running_hosts)
+      if remaining:
+        sleep(poll_interval_s)
+    return True
+  except KeyboardInterrupt:
+    for handle in remaining:
+      dispatcher.cancel(handle)
+      manifest.record(handle.job_id, status=JobStatus.CANCELLED.value)
+    return False
diff --git a/remote_experiments/selection.py b/remote_experiments/selection.py
new file mode 100644
index 0000000..1a5422a
--- /dev/null
+++ b/remote_experiments/selection.py
@@ -0,0 +1,29 @@
+"""Parse free-text experiment selection ("1,2,5-7" / "all") and compute resume defaults."""
+
+from __future__ import annotations
+
+from .manifest import Manifest, SUCCEEDED
+
+
+def parse_selection(text: str, n: int) -> list[int]:
+  text = text.strip()
+  if text == "" or text.lower() == "all":
+    return list(range(n))
+  indices: set[int] = set()
+  for part in text.split(","):
+    part = part.strip()
+    if not part:
+      continue
+    if "-" in part:
+      start_s, end_s = part.split("-", 1)
+      indices.update(range(int(start_s), int(end_s) + 1))
+    else:
+      indices.add(int(part))
+  for i in indices:
+    if not (0 <= i < n):
+      raise ValueError(f"selection index out of range: {i} (valid: 0..{n - 1})")
+  return sorted(indices)
+
+
+def default_selection(experiment_ids: list[str], manifest: Manifest) -> list[int]:
+  return [i for i, eid in enumerate(experiment_ids) if manifest.status(eid) != SUCCEEDED]
diff --git a/remote_experiments/stats.py b/remote_experiments/stats.py
new file mode 100644
index 0000000..67d1149
--- /dev/null
+++ b/remote_experiments/stats.py
@@ -0,0 +1,89 @@
+"""Pure computation of batch/VM progress stats for the TUI — no rendering here."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ray_dispatcher import Inventory
+
+from .manifest import Manifest, SUCCEEDED
+
+_RUNNING = "running"
+_NEVER_RUN = "never_run"
+_PENDING = "pending"
+
+
+@dataclass(frozen=True)
+class HostStats:
+  host: str
+  slots_total: int
+  slots_busy: int
+  jobs_completed: int
+  current_jobs: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class BatchStats:
+  total: int
+  succeeded: int
+  failed: int
+  running: int
+  pending: int
+  elapsed_s: float
+  throughput_per_min: float
+  eta_s: float | None
+  hosts: tuple[HostStats, ...]
+
+
+def estimate_eta(avg_duration_s: float, remaining: int, total_slots: int) -> float:
+  if total_slots <= 0:
+    raise ValueError("total_slots must be > 0")
+  if remaining <= 0:
+    return 0.0
+  return avg_duration_s * remaining / total_slots
+
+
+def summarize(
+    experiment_ids: list[str],
+    manifest: Manifest,
+    inventory: Inventory,
+    running_hosts: dict[str, str],
+    elapsed_s: float,
+    succeeded_at_start: int = 0,
+  ) -> BatchStats:
+  statuses = {eid: manifest.status(eid) for eid in experiment_ids}
+  succeeded = sum(1 for s in statuses.values() if s == SUCCEEDED)
+  running = sum(1 for s in statuses.values() if s == _RUNNING)
+  pending = sum(1 for s in statuses.values() if s in (_NEVER_RUN, _PENDING))
+  failed = len(statuses) - succeeded - running - pending
+
+  durations = [
+    manifest.duration(eid) for eid in experiment_ids
+    if statuses[eid] == SUCCEEDED and manifest.duration(eid) is not None
+  ]
+  avg_duration = sum(durations) / len(durations) if durations else 0.0
+  total_slots = sum(h.slots for h in inventory.hosts)
+  remaining = running + pending
+  eta_s = estimate_eta(avg_duration, remaining, total_slots) if durations else None
+  session_succeeded = max(succeeded - succeeded_at_start, 0)
+  throughput_per_min = (session_succeeded / elapsed_s * 60) if elapsed_s > 0 else 0.0
+
+  host_stats = []
+  for h in inventory.hosts:
+    current_jobs = tuple(
+      eid for eid, host in running_hosts.items() if host == h.host and eid in statuses
+    )
+    completed = sum(
+      1 for eid in experiment_ids
+      if statuses[eid] == SUCCEEDED and manifest.host(eid) == h.host
+    )
+    host_stats.append(HostStats(
+      host=h.host, slots_total=h.slots, slots_busy=len(current_jobs),
+      jobs_completed=completed, current_jobs=current_jobs,
+    ))
+
+  return BatchStats(
+    total=len(statuses), succeeded=succeeded, failed=failed, running=running,
+    pending=pending, elapsed_s=elapsed_s, throughput_per_min=throughput_per_min,
+    eta_s=eta_s, hosts=tuple(host_stats),
+  )
diff --git a/remote_experiments/survivors.py b/remote_experiments/survivors.py
new file mode 100644
index 0000000..648df5d
--- /dev/null
+++ b/remote_experiments/survivors.py
@@ -0,0 +1,71 @@
+"""Select survivor algorithms from screening results by relative-to-best objective."""
+
+from __future__ import annotations
+
+import statistics
+from pathlib import Path
+
+from .batch import Batch
+from .results_reader import read_run_objective, read_run_runtime
+
+
+class SurvivorSelectionError(RuntimeError):
+  """Raised when screening results are too degenerate to promote survivors."""
+
+
+def _instance_key(experiment) -> tuple[int, int, int]:
+  limits = experiment.graph_params
+  return (limits["Nn"]["min"], limits["Nf"]["min"], experiment.seed)
+
+
+def select_survivors(
+    batch: Batch,
+    results_dir: Path,
+    *,
+    anchors: tuple[str, ...] = ("centralized", "hierarchical-madea"),
+    n: int = 4,
+    min_valid_fraction: float = 0.8,
+  ) -> list[str]:
+  results_dir = Path(results_dir)
+  obj_by_algo: dict[str, dict[tuple, float]] = {}
+  runtime_by_algo: dict[str, list[float]] = {}
+  valid = 0
+  for e in batch.experiments:
+    objective = read_run_objective(results_dir / e.id)
+    if objective is None:
+      continue
+    valid += 1
+    obj_by_algo.setdefault(e.algorithm, {})[_instance_key(e)] = objective
+    runtime = read_run_runtime(results_dir / e.id)
+    if runtime is not None:
+      runtime_by_algo.setdefault(e.algorithm, []).append(runtime)
+
+  if valid < min_valid_fraction * len(batch.experiments):
+    raise SurvivorSelectionError(
+      f"only {valid}/{len(batch.experiments)} screening runs valid "
+      f"(< {min_valid_fraction:.0%}); refusing to promote"
+    )
+
+  # obj_best per instance across every algorithm that ran it
+  best: dict[tuple, float] = {}
+  for per_instance in obj_by_algo.values():
+    for key, value in per_instance.items():
+      best[key] = max(value, best.get(key, float("-inf")))
+
+  candidates = [a for a in obj_by_algo if a not in anchors]
+  scored = []
+  for algo in candidates:
+    deficits = [
+      (best[key] - obj) / best[key] * 100.0
+      for key, obj in obj_by_algo[algo].items()
+    ]
+    reldef = statistics.fmean(deficits)
+    runtime = statistics.median(runtime_by_algo.get(algo, [float("inf")]))
+    scored.append((reldef, runtime, algo))
+
+  if len(scored) < n:
+    raise SurvivorSelectionError(
+      f"only {len(scored)} candidate algorithms produced valid runs; need {n}"
+    )
+  scored.sort(key=lambda t: (t[0], t[1]))
+  return [algo for _, _, algo in scored[:n]]
diff --git a/remote_experiments/tui.py b/remote_experiments/tui.py
new file mode 100644
index 0000000..e9ebcb2
--- /dev/null
+++ b/remote_experiments/tui.py
@@ -0,0 +1,84 @@
+"""rich-based live progress view: renders BatchStats/Manifest, no business logic."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+
+from ray_dispatcher import Inventory
+
+from .batch import Batch
+from .manifest import Manifest, SUCCEEDED
+from .stats import BatchStats, summarize
+
+
+def render(batch: Batch, manifest: Manifest, stats: BatchStats) -> Layout:
+  summary = Table.grid(padding=(0, 2))
+  summary.add_row(
+    f"total: {stats.total}", f"succeeded: {stats.succeeded}", f"failed: {stats.failed}",
+    f"running: {stats.running}", f"pending: {stats.pending}",
+    f"throughput: {stats.throughput_per_min:.1f}/min",
+    f"eta: {_format_seconds(stats.eta_s)}",
+  )
+
+  vm_table = Table(title="VMs")
+  vm_table.add_column("host")
+  vm_table.add_column("slots")
+  vm_table.add_column("current jobs")
+  vm_table.add_column("completed")
+  for h in stats.hosts:
+    vm_table.add_row(
+      h.host, f"{h.slots_busy}/{h.slots_total}", ", ".join(h.current_jobs) or "-",
+      str(h.jobs_completed),
+    )
+
+  exp_table = Table(title="Experiments")
+  exp_table.add_column("id")
+  exp_table.add_column("algorithm")
+  exp_table.add_column("seed")
+  exp_table.add_column("status")
+  exp_table.add_column("host")
+  for e in batch.experiments:
+    exp_table.add_row(
+      e.id, e.algorithm, str(e.seed), manifest.status(e.id), manifest.host(e.id) or "-",
+    )
+
+  layout = Layout()
+  layout.split_column(
+    Layout(Panel(summary, title="Batch"), size=3),
+    Layout(vm_table, size=len(stats.hosts) + 4),
+    Layout(exp_table),
+  )
+  return layout
+
+
+def _format_seconds(seconds: float | None) -> str:
+  if seconds is None:
+    return "-"
+  minutes, secs = divmod(int(seconds), 60)
+  return f"{minutes}m{secs:02d}s"
+
+
+@contextmanager
+def live_view(
+    batch: Batch, manifest: Manifest, inventory: Inventory, *, start_time: float,
+  ) -> Iterator[Callable[[dict[str, str]], None]]:
+  console = Console()
+  experiment_ids = [e.id for e in batch.experiments]
+  succeeded_at_start = sum(manifest.status(eid) == SUCCEEDED for eid in experiment_ids)
+  with Live(console=console, refresh_per_second=4) as live:
+    def on_tick(running_hosts: dict[str, str]) -> None:
+      elapsed = time.monotonic() - start_time
+      stats = summarize(
+        experiment_ids, manifest, inventory, running_hosts, elapsed,
+        succeeded_at_start=succeeded_at_start,
+      )
+      live.update(render(batch, manifest, stats))
+    yield on_tick
diff --git a/rlagents/postprocessing.py b/rlagents/postprocessing.py
index 83fac6f..e1f63b7 100644
--- a/rlagents/postprocessing.py
+++ b/rlagents/postprocessing.py
@@ -322,7 +322,6 @@ def plot_action(
     )
     plt.close()
   else:
-    plt.title(title_key)
     plt.show()
 
 
@@ -366,7 +365,6 @@ def plot_forward(
     )
     plt.close()
   else:
-    plt.title(title_key)
     plt.show()
 
 
diff --git a/run.py b/run.py
index ec3b9a1..03f5494 100644
--- a/run.py
+++ b/run.py
@@ -3,6 +3,14 @@
 from run_centralized_model import run as run_centralized
 from run_faasmacro import run as run_iterations
 from run_faasmadea import run as run_auction
+from hierarchical_auction.runner import run as run_hierarchical
+from hierarchical_auction.madea_runner import run as run_hierarchical_madea
+from decentralized_diffusion import run as run_diffusion
+from decentralized_powerd import run as run_powerd
+from decentralized_bestresponse import run_br_s, run_br_r, run_br_o
+from decentralized_potentialgame import run_pg_s, run_pg_r
+from decentralized_gcaa import run as run_gcaa
+from plasma.runner import run as run_plasma
 from postprocessing import load_models_results
 from utils.common import reconcile_paths
 
@@ -21,6 +29,41 @@
 logging.getLogger('pyomo.core').setLevel(logging.ERROR)
 
 
+METHOD_RESULT_MODELS = {
+  "centralized": ("LoadManagementModel", "LoadManagementModel"),
+  "faas-macro": ("LSP", "FaaS-MACrO"),
+  "faas-macro-v0": ("LSP", "FaaS-MACrO(v0)"),
+  "faas-madea": ("LSPc", "FaaS-MADeA"),
+  "hierarchical": ("LSPc", "HierarchicalAuction"),
+  "hierarchical-madea": ("LSPc", "HierarchicalMADeA"),
+  "faas-diffuse": ("LSPc", "FaaS-MADiG"),
+  "faas-powd": ("LSPc", "FaaS-MAPoD"),
+  "faas-br-s": ("LSPc", "FaaS-MABR-S"),
+  "faas-br-r": ("LSPc", "FaaS-MABR-R"),
+  "faas-br-o": ("LSPc", "FaaS-MABR-O"),
+  "faas-pg-s": ("LSPc", "FaaS-MAPG-S"),
+  "faas-pg-r": ("LSPc", "FaaS-MAPG-R"),
+  "faas-gcaa": ("LSPc", "FaaS-MAGCAA"),
+  "plasma": ("LSPc", "Plasma"),
+}
+
+# The centralized run saves its solution under the model's own name, which
+# depends on config["model_variant"] (see run_centralized_model): "tight" ->
+# TightLoadManagementModel, otherwise LoadManagementModel. Postprocessing keeps
+# the canonical baseline label "LoadManagementModel" (mname) but must locate the
+# on-disk files by the actual saved name, so it probes the folder. This also
+# works when re-postprocessing solution_folders loaded from an earlier run whose
+# variant the current config no longer reflects.
+CENTRALIZED_MODEL_KEYS = ("LoadManagementModel", "TightLoadManagementModel")
+
+
+def resolve_centralized_model_key(folder: str, default: str) -> str:
+  for key in CENTRALIZED_MODEL_KEYS:
+    if os.path.exists(os.path.join(folder, f"{key}_solution.csv")):
+      return key
+  return default
+
+
 def parse_arguments() -> argparse.Namespace:
   """
   Parse input arguments
@@ -49,7 +92,18 @@ def parse_arguments() -> argparse.Namespace:
       "centralized", 
       "faas-macro-v0", 
       "faas-macro", 
-      "faas-madea", 
+      "faas-madea",
+      "hierarchical",
+      "hierarchical-madea",
+      "faas-diffuse",
+      "faas-powd",
+      "faas-br-s",
+      "faas-br-r",
+      "faas-br-o",
+      "faas-pg-s",
+      "faas-pg-r",
+      "faas-gcaa",
+      "plasma",
       "generate_only"
     ],
     required = True
@@ -68,8 +122,9 @@ def parse_arguments() -> argparse.Namespace:
   )
   parser.add_argument(
     "--fix_r",
-    help = "True to fix the number of replicas in FaaS-MACrO and/or "
-           "FaaS-MADeA according to the optimal centralized solution",
+    help = "True to fix the number of replicas in FaaS-MACrO, FaaS-MADeA, "
+           "FaaS-MADiG, FaaS-MAPoD, and FaaS-MABR according to the optimal "
+           "centralized solution",
     default = False,
     action = "store_true"
   )
@@ -110,6 +165,18 @@ def generate_experiments_list(exp_values, seed, n_experiments):
   return [[exp_value, int(s)] for s in seed_list for exp_value in exp_list]
 
 
+def set_solution_folder(
+    solution_folders: dict, method: str, experiment_idx: int, folder: str
+  ):
+  folders = solution_folders.setdefault(method, [])
+  if experiment_idx is None:
+    folders.append(folder)
+  else:
+    while len(folders) <= experiment_idx:
+      folders.append(None)
+    folders[experiment_idx] = folder
+
+
 def load_obj_value(solution_folder: str) -> pd.DataFrame:
   obj = pd.DataFrame()
   if os.path.exists(os.path.join(solution_folder, "obj.csv")):
@@ -142,14 +209,20 @@ def load_termination_condition(
       for s in tc["0"]:
         c, i, d, b, bc, trt = [None] * 6
         if "total runtime" in s:
-          if "centralized" in s:
+          if "centralized" in s and "obj. deviation" in s:
             c, i, d, b, bc, trt = parse(
-              "{} (it: {}; obj. deviation: {}; best it: {}; best centralized it: {}; total runtime: {})", 
+              "{} (it: {}; obj. deviation: {}; best it: {}; best centralized it: {}; total runtime: {})",
+              s
+            )
+          elif "centralized" in s:
+            # hierarchical auction format: no obj. deviation / best it fields
+            c, i, bc, trt = parse(
+              "{} (it: {}; best centralized it: {}; total runtime: {})",
               s
             )
           else:
             c, i, d, b, trt = parse(
-              "{} (it: {}; obj. deviation: {}; best it: {}; total runtime: {})", 
+              "{} (it: {}; obj. deviation: {}; best it: {}; total runtime: {})",
               s
             )
         elif "best it" in s:
@@ -167,7 +240,7 @@ def load_termination_condition(
           c = f"reached time limit ({c2})"
         criterion.append(c)
         iteration.append(int(i))
-        deviation.append(float(d) if d != "None" else d)
+        deviation.append(float(d) if d is not None and d != "None" else d)
         best_it.append(int(b) if b is not None else b)
       tc.drop("0", axis = "columns", inplace = True)
       tc["criterion"] = criterion
@@ -184,7 +257,8 @@ def merge_sol_dict(results_list: list, methods_names: list) -> pd.DataFrame:
     columns = {"tot": f"tot_{methods_names[0]}"}
   )
   for r,m in zip(results_list[1:], methods_names[1:]):
-    res = res.join(r["tot"], rsuffix = f"_{m}")
+    if "tot" in r:
+      res = res.join(r["tot"], rsuffix = f"_{m}")
   res["time"] = "tot"
   for key in results_list[0]:
     if key != "tot":
@@ -193,7 +267,11 @@ def merge_sol_dict(results_list: list, methods_names: list) -> pd.DataFrame:
         columns = {key: f"{key}_{methods_names[0]}"}
       )
       for r,m in zip(results_list[1:], methods_names[1:]):
-        df = df.join(r[key], rsuffix = f"_{m}")
+        # methods may cover different timestep ranges (e.g. a baseline folder
+        # from an earlier run with a different horizon); skip a method that has
+        # no data for this timestep instead of crashing the postprocessing
+        if key in r:
+          df = df.join(r[key], rsuffix = f"_{m}")
       df["time"] = time
       res = pd.concat([res, df])
   return res
@@ -215,6 +293,7 @@ def results_postprocessing(
     loop_over: str,
     methods: list
   ):
+  methods = [m for m in methods if m != "generate_only"]
   # prepare folder to store plots
   plot_folder = os.path.join(base_folder, "postprocessing")
   os.makedirs(plot_folder, exist_ok = True)
@@ -224,11 +303,9 @@ def results_postprocessing(
   all_tc = pd.DataFrame()
   ping_pong_list = []
   # loop over experiments
-  for tokens in zip(
-      solution_folders["experiments_list"], 
-      *[solution_folders[m] for m in methods]
+  for exp_idx, exp_description_tuple in enumerate(
+      solution_folders["experiments_list"]
     ):
-    exp_description_tuple = tokens[0]
     print(f"Postprocessing exp: {exp_description_tuple}")
     # prepare folder to store results
     exp_description = "_".join([str(s) for s in exp_description_tuple])
@@ -243,23 +320,27 @@ def results_postprocessing(
       mcolors.TABLEAU_COLORS["tab:orange"],
       mcolors.TABLEAU_COLORS["tab:red"],
       mcolors.TABLEAU_COLORS["tab:green"],
-      mcolors.TABLEAU_COLORS["tab:pink"]
+      mcolors.TABLEAU_COLORS["tab:pink"],
+      mcolors.TABLEAU_COLORS["tab:purple"],
+      mcolors.TABLEAU_COLORS["tab:brown"],
+      mcolors.TABLEAU_COLORS["tab:olive"],
+      mcolors.TABLEAU_COLORS["tab:cyan"],
+      mcolors.TABLEAU_COLORS["tab:gray"]
     ]
-    for method, method_folder in zip(methods, tokens[1:]):
+    for method in methods:
+      method_folders = solution_folders.get(method, [])
+      method_folder = (
+        method_folders[exp_idx] if exp_idx < len(method_folders) else None
+      )
       if method_folder is not None:
         abs_folders.append(
-          reconcile_paths(base_solution_folder, method_folder)
+          reconcile_paths(base_folder, method_folder)
         )
         # -- load results
         # ---- local_count, fwd_count, rej_count, replicas, ping_pong
-        mkey = "LoadManagementModel" if method == "centralized" else (
-          "LSP" if method.startswith("faas-macro") else "LSPc"
-        )
-        mname = "LoadManagementModel" if method == "centralized" else (
-          "FaaS-MACrO" if method == "faas-macro" else (
-            "FaaS-MACrO(v0)" if method == "faas-macro-v0" else "FaaS-MADeA"
-          )
-        )
+        mkey, mname = METHOD_RESULT_MODELS[method]
+        if method == "centralized":
+          mkey = resolve_centralized_model_key(abs_folders[-1], mkey)
         results.append(load_models_results(abs_folders[-1], [mkey], [mname]))
         # -- check ping-pong problems
         if len(results[-1][-1][mname]) > 0:
@@ -425,6 +506,16 @@ def results_postprocessing(
     for mname, af in zip(found_methods, abs_folders):
       if os.path.exists(os.path.join(af, "runtime.csv")):
         runtimes[mname] = pd.read_csv(os.path.join(af, "runtime.csv"))
+        if (
+            mname == "LoadManagementModel"
+            and mname not in runtimes[mname].columns
+            and runtimes[mname].shape[1] == 1
+          ):
+          # the centralized runtime.csv stores the model name as its single
+          # column, which is "TightLoadManagementModel" under
+          # model_variant="tight"; normalize it to the canonical baseline label
+          # so the runtime comparison below finds it regardless of variant
+          runtimes[mname].columns = [mname]
       else:
         if mname != "LoadManagementModel":
           logs_df, _ = parse_log_file(
@@ -837,11 +928,18 @@ def run(
   experiments_list = generate_experiments_list(exp_values, seed, n_experiments)
   # load list of already-run experiments (if any)
   solution_folders = {
-    "experiments_list": [], 
-    "centralized": [], 
-    "faas-macro": [], 
-    "faas-macro-v0": [], 
-    "faas-madea": []
+    "experiments_list": [],
+    "centralized": [],
+    "faas-macro": [],
+    "faas-macro-v0": [],
+    "faas-madea": [],
+    "hierarchical": [],
+    "hierarchical-madea": [],
+    "faas-diffuse": [],
+    "faas-powd": [],
+    "faas-br-s": [],
+    "faas-br-r": [],
+    "faas-br-o": []
   }
   if os.path.exists(os.path.join(base_solution_folder, "experiments.json")):
     with open(
@@ -860,6 +958,17 @@ def run(
     run_i = False # -- faasmacro
     run_i_v0 = False # -- faasmacro (v0)
     run_a = False # -- faasmadea
+    run_h = False # -- hierarchical
+    run_hm = False # -- hierarchical MADeA
+    run_d = False # -- faas-diffuse (FaaS-MADiG)
+    run_p = False # -- faas-powd (FaaS-MAPoD)
+    run_brs = False # -- faas-br-s (FaaS-MABR-S)
+    run_brr = False # -- faas-br-r (FaaS-MABR-R)
+    run_bro = False # -- faas-br-o (FaaS-MABR-O)
+    run_pgs = False # -- faas-pg-s (FaaS-MAPG-S)
+    run_pgr = False # -- faas-pg-r (FaaS-MAPG-R)
+    run_g = False # -- faas-gcaa (FaaS-MAGCAA)
+    run_pl = False # -- plasma (Plasma)
     experiment_idx = None
     try:
       experiment_idx = solution_folders["experiments_list"].index(
@@ -889,13 +998,90 @@ def run(
           solution_folders["faas-madea"][experiment_idx] is None
         )):
         run_a = True
+      if (not generate_only and "hierarchical" in methods) and ((
+          len(solution_folders["hierarchical"]) <= experiment_idx
+        ) or (
+          solution_folders["hierarchical"][experiment_idx] is None
+        )):
+        run_h = True
+      if (not generate_only and "hierarchical-madea" in methods) and ((
+          len(solution_folders.get("hierarchical-madea", [])) <= experiment_idx
+        ) or (
+          solution_folders["hierarchical-madea"][experiment_idx] is None
+        )):
+        run_hm = True
+      if (not generate_only and "faas-diffuse" in methods) and ((
+          len(solution_folders.get("faas-diffuse", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-diffuse"][experiment_idx] is None
+        )):
+        run_d = True
+      if (not generate_only and "faas-powd" in methods) and ((
+          len(solution_folders.get("faas-powd", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-powd"][experiment_idx] is None
+        )):
+        run_p = True
+      if (not generate_only and "faas-br-s" in methods) and ((
+          len(solution_folders.get("faas-br-s", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-s"][experiment_idx] is None
+        )):
+        run_brs = True
+      if (not generate_only and "faas-br-r" in methods) and ((
+          len(solution_folders.get("faas-br-r", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-r"][experiment_idx] is None
+        )):
+        run_brr = True
+      if (not generate_only and "faas-br-o" in methods) and ((
+          len(solution_folders.get("faas-br-o", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-br-o"][experiment_idx] is None
+        )):
+        run_bro = True
+      if (not generate_only and "faas-pg-s" in methods) and ((
+          len(solution_folders.get("faas-pg-s", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-pg-s"][experiment_idx] is None
+        )):
+        run_pgs = True
+      if (not generate_only and "faas-pg-r" in methods) and ((
+          len(solution_folders.get("faas-pg-r", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-pg-r"][experiment_idx] is None
+        )):
+        run_pgr = True
+      if (not generate_only and "faas-gcaa" in methods) and ((
+          len(solution_folders.get("faas-gcaa", [])) <= experiment_idx
+        ) or (
+          solution_folders["faas-gcaa"][experiment_idx] is None
+        )):
+        run_g = True
+      if (not generate_only and "plasma" in methods) and ((
+          len(solution_folders.get("plasma", [])) <= experiment_idx
+        ) or (
+          solution_folders["plasma"][experiment_idx] is None
+        )):
+        run_pl = True
     except ValueError:
       run_c = "centralized" in methods
       run_i = "faas-macro" in methods
       run_i_v0 = "faas-macro-v0" in methods
       run_a = "faas-madea" in methods
+      run_h = "hierarchical" in methods
+      run_hm = "hierarchical-madea" in methods
+      run_d = "faas-diffuse" in methods
+      run_p = "faas-powd" in methods
+      run_brs = "faas-br-s" in methods
+      run_brr = "faas-br-r" in methods
+      run_bro = "faas-br-o" in methods
+      run_pgs = "faas-pg-s" in methods
+      run_pgr = "faas-pg-r" in methods
+      run_g = "faas-gcaa" in methods
+      run_pl = "plasma" in methods
     # if the experiment is still to run...
-    if run_c or run_i or run_i_v0 or run_a or generate_only:
+    if run_c or run_i or run_i_v0 or run_a or run_h or run_hm or run_d or run_p or run_brs or run_brr or run_bro or run_pgs or run_pgr or run_g or run_pl or generate_only:
       # -- update configuration
       config = deepcopy(base_config)
       if loop_over in config["limits"]:
@@ -907,6 +1093,7 @@ def run(
         config["limits"]["neighborhood"][loop_over] = exp_value
       config["seed"] = seed
       # -- look for old instance path (if required)
+      c_folder = None
       if "experiments_list" in old_instance_paths:
         try:
           old_exp_idx = old_instance_paths["experiments_list"].index(
@@ -917,6 +1104,7 @@ def run(
             old_exp_path = old_instance_paths["centralized"][
               old_exp_idx
             ]
+            c_folder = old_exp_path
           elif "faas-macro" in old_instance_paths:
             old_exp_path = old_instance_paths["faas-macro"][
               old_exp_idx
@@ -935,7 +1123,6 @@ def run(
         except Exception:
           pass
       # -- solve centralized model
-      c_folder = None
       if run_c or generate_only:
         c_folder = run_centralized(
           config, 
@@ -943,9 +1130,11 @@ def run(
           disable_plotting = disable_plotting,
           generate_only = generate_only
         )
-        solution_folders["centralized"].append(c_folder)
+        set_solution_folder(
+          solution_folders, "centralized", experiment_idx, c_folder
+        )
       else:
-        if experiment_idx is not None:
+        if c_folder is None and experiment_idx is not None:
           c_folder = solution_folders["centralized"][experiment_idx]
       # -- solve iterative model (v0)
       if fix_r:
@@ -958,7 +1147,9 @@ def run(
           disable_plotting = disable_plotting,
           v0 = True
         )
-        solution_folders["faas-macro-v0"].append(i_folder_v0)
+        set_solution_folder(
+          solution_folders, "faas-macro-v0", experiment_idx, i_folder_v0
+        )
       # -- solve iterative model
       if run_i:
         i_folder = run_iterations(
@@ -967,16 +1158,127 @@ def run(
           log_on_file = log_on_file, 
           disable_plotting = disable_plotting
         )
-        solution_folders["faas-macro"].append(i_folder)
+        set_solution_folder(
+          solution_folders, "faas-macro", experiment_idx, i_folder
+        )
       # -- solve auction
       if run_a:
         a_folder = run_auction(
-          config, 
+          config,
           sp_parallelism,
-          log_on_file = log_on_file, 
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-madea", experiment_idx, a_folder
+        )
+      # -- solve hierarchical
+      if run_h:
+        h_folder = run_hierarchical(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "hierarchical", experiment_idx, h_folder
+        )
+      # -- solve hierarchical extension of FaaS-MADeA
+      if run_hm:
+        hm_folder = run_hierarchical_madea(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "hierarchical-madea", experiment_idx, hm_folder
+        )
+      # -- solve diffusion (FaaS-MADiG)
+      if run_d:
+        d_folder = run_diffusion(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
           disable_plotting = disable_plotting
         )
-        solution_folders["faas-madea"].append(a_folder)
+        set_solution_folder(
+          solution_folders, "faas-diffuse", experiment_idx, d_folder
+        )
+      # -- solve power-of-d (FaaS-MAPoD)
+      if run_p:
+        p_folder = run_powerd(
+          config,
+          sp_parallelism,
+          log_on_file = log_on_file,
+          disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-powd", experiment_idx, p_folder
+        )
+      # -- solve best-response sequential (FaaS-MABR-S)
+      if run_brs:
+        brs_folder = run_br_s(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-s", experiment_idx, brs_folder
+        )
+      # -- solve best-response randomized (FaaS-MABR-R)
+      if run_brr:
+        brr_folder = run_br_r(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-r", experiment_idx, brr_folder
+        )
+      # -- solve best-response re-optimization (FaaS-MABR-O)
+      if run_bro:
+        bro_folder = run_br_o(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-br-o", experiment_idx, bro_folder
+        )
+      # -- solve potential game sequential (FaaS-MAPG-S)
+      if run_pgs:
+        pgs_folder = run_pg_s(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-pg-s", experiment_idx, pgs_folder
+        )
+      # -- solve potential game randomized (FaaS-MAPG-R)
+      if run_pgr:
+        pgr_folder = run_pg_r(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-pg-r", experiment_idx, pgr_folder
+        )
+      # -- solve greedy coalition auction (FaaS-MAGCAA)
+      if run_g:
+        g_folder = run_gcaa(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "faas-gcaa", experiment_idx, g_folder
+        )
+      # -- solve PLASMA (Physarum + simulated bifurcation)
+      if run_pl:
+        pl_folder = run_plasma(
+          config, sp_parallelism,
+          log_on_file = log_on_file, disable_plotting = disable_plotting
+        )
+        set_solution_folder(
+          solution_folders, "plasma", experiment_idx, pl_folder
+        )
       # -- save info
       if experiment_idx is None:
         solution_folders["experiments_list"].append([exp_value, seed])
diff --git a/run_centralized_model.py b/run_centralized_model.py
index e675372..1f0da2b 100644
--- a/run_centralized_model.py
+++ b/run_centralized_model.py
@@ -7,10 +7,15 @@
 from utils.centralized import get_current_load
 from generators.generate_data import generate_data, update_data
 from generators.generate_load import generate_load_traces
+from remote_experiments.instances import (
+  PAYLOAD_FILES,
+  load_materialized_instance,
+)
 from postprocessing import plot_history
 from models.model import (
   BaseLoadManagementModel, 
   LoadManagementModel, 
+  TightLoadManagementModel,
   PYO_VAR_TYPE
 )
 
@@ -25,6 +30,7 @@
 import numpy as np
 import argparse
 import json
+import shutil
 import sys
 import os
 
@@ -303,6 +309,15 @@ def init_problem(
     seed: int, 
     solution_folder: str
   ) -> Tuple[dict, dict, list, Graph]:
+  if limits.get("instance_type") == "materialized":
+    instance_path = limits["path"]
+    problem = load_materialized_instance(instance_path)
+    for filename in (*PAYLOAD_FILES, "metadata.json"):
+      shutil.copy2(
+        os.path.join(instance_path, filename),
+        os.path.join(solution_folder, filename),
+      )
+    return problem
   # generate base instance data
   rng = np.random.default_rng(seed = seed)
   base_instance_data, load_limits, graph = generate_data(
@@ -525,7 +540,11 @@ def run(
   if log_on_file:
     log_stream = open(os.path.join(solution_folder, "out.log"), "w")
   # initialize models
-  models = [LoadManagementModel()]
+  model_variant = config.get("model_variant", "default")
+  models = [
+    TightLoadManagementModel() if model_variant == "tight"
+    else LoadManagementModel()
+  ]
   # generate base instance data and load traces
   base_instance_data, input_requests_traces, agents, _ = init_problem(
     limits, trace_type, max_steps, seed, solution_folder
diff --git a/run_faasmacro.py b/run_faasmacro.py
index 558169b..180c00b 100644
--- a/run_faasmacro.py
+++ b/run_faasmacro.py
@@ -10,7 +10,7 @@
   save_solution,
   save_checkpoint
 )
-from utils.centralized import check_feasibility
+from utils.centralized import check_feasibility, validate_centralized_solution
 from utils.faasmacro import compute_centralized_objective
 from utils.common import load_configuration
 from generators.generate_data import update_data
@@ -74,6 +74,12 @@ def parse_arguments() -> argparse.Namespace:
     default = False,
     action = "store_true"
   )
+  parser.add_argument(
+    "--v0",
+    help = "Use the v0 FaaS-MACrO iteration variant",
+    default = False,
+    action = "store_true"
+  )
   # Parse the arguments
   args: argparse.Namespace = parser.parse_known_args()[0]
   return args
@@ -219,7 +225,8 @@ def compute_social_welfare(
     solver_options: dict,
     rmp_y: np.array, 
     rmp_omega: np.array,
-    parallelism: int
+    parallelism: int,
+    sp_x: np.array = None
   ) -> Tuple[list, float, list]:
   Nn = data[None]["Nn"][None]
   Nf = data[None]["Nf"][None]
@@ -234,6 +241,10 @@ def compute_social_welfare(
   spr_data[None]["omega_bar"] = {
     (n+1,f+1): max(rmp_omega[n,f], 0) for n in range(Nn) for f in range(Nf)
   }
+  if sp_x is not None:
+    spr_data[None]["x_bar"] = {
+      (n+1,f+1): max(sp_x[n,f], 0) for n in range(Nn) for f in range(Nf)
+    }
   # solve for all agents
   agents_sol = {}
   if parallelism != 0:
@@ -271,16 +282,34 @@ def combine_solutions(
     rmp_x: np.array, rmp_y: np.array, rmp_z: np.array, 
     rmp_r: np.array, rmp_xi: np.array, rmp_rho: np.array
   ):
-  sp_y = rmp_y
+  sp_y = rmp_y.copy()
   # -- compute xi
   sp_xi = np.zeros((Nn,Nn,Nf))
   for n1 in range(Nn):
     for n2 in range(Nn):
       for f in range(Nf):
         sp_xi[n2,n1,f] = sp_y[n1,n2,f]
+  # -- tighten replicas to the centralized replica equilibrium
+  # r = ceil(utilization / max_utilization) for the realized served load
+  # (local processing + received offload). A heuristic may greedily over-acquire
+  # replicas to be able to receive offload that neighbour/no-ping-pong
+  # restrictions then keep from arriving; r does not enter the welfare objective,
+  # so tightening it leaves the objective unchanged while making the solution
+  # centrally feasible (utilization_equilibrium / utilization_equilibrium2).
+  demand = np.array([
+    [sp_data[None]["demand"][(n + 1, f + 1)] for f in range(Nf)]
+    for n in range(Nn)
+  ])
+  max_utilization = np.array([
+    sp_data[None]["max_utilization"][f + 1] for f in range(Nf)
+  ])
+  served = sp_x + sp_y.sum(axis = 0)
+  with np.errstate(divide = "ignore", invalid = "ignore"):
+    spr_r = np.ceil(demand * served / max_utilization - 1e-9).astype(int)
+  spr_r = np.maximum(spr_r, 0)
   # -- compute utilization
   spr_U = compute_utilization(
-    sp_data, 
+    sp_data,
     {"x": sp_x, "xi": sp_xi, "r": spr_r, "obj": None}
   )
   # -- compute rejections
@@ -289,10 +318,10 @@ def combine_solutions(
     sp_z[n-1,f-1] = (
       l - sp_x[n-1,f-1] - sp_y[n-1,:,f-1].sum()
     )
-  return {
+  solution = {
     "sp": {
       "x":    sp_x,
-      "y":    rmp_y,
+      "y":    sp_y,
       "z":    sp_z,
       "r":    spr_r,
       "xi":   sp_xi,
@@ -301,7 +330,7 @@ def combine_solutions(
     },
     "rmp": {
       "x":    rmp_x,
-      "y":    rmp_y,
+      "y":    sp_y,
       "z":    rmp_z,
       "r":    rmp_r,
       "xi":   rmp_xi,
@@ -309,6 +338,11 @@ def combine_solutions(
       "U":    spr_U
     }
   }
+  validate_centralized_solution(
+    solution["sp"]["x"], solution["sp"]["y"], solution["sp"]["z"],
+    solution["sp"]["r"], sp_data,
+  )
+  return solution
 
 
 def decode_solutions(
@@ -687,10 +721,11 @@ def run(
     "LRMP": {it: [] for it in range(max_iterations)}
   }
   tc_dict = {
-    "LSP": {it: [] for it in range(max_iterations)}, 
-    "LSPr": [], 
+    "LSP": {it: [] for it in range(max_iterations)},
+    "LSPr": [],
     "LRMP": {it: [] for it in range(max_iterations)}
   }
+  runtime_list: list[float] = []
   ub = (
     max_run_time + run_time_step
   ) if max_run_time == min_run_time else max_run_time
@@ -909,9 +944,10 @@ def run(
         x_cost += x_cost_n
       odev_queue.append(odev)
       # merge solutions and compute the centralized objective value
+      spr_x, _, _, _, spr_r, spr_rho = spr_sol
       csol = combine_solutions(
         Nn, Nf, sp_data, loadt, 
-        spr_sol[0], spr_sol[2], spr_sol[3],
+        spr_x, spr_r, spr_rho,
         rmp_x, rmp_y, rmp_z, rmp_r, rmp_xi, rmp_rho
       )
       cobj = compute_centralized_objective(
@@ -1036,11 +1072,12 @@ def run(
             spc_complete_solution, os.path.join(solution_folder, "LSPc"), t
           )
     ee = datetime.now()
+    runtime_list.append(total_runtime)
     if verbose > 0:
       print(
         f"    TOTAL RUNTIME [s] = {total_runtime} "
         f"(wallclock: {(ee-ss).total_seconds()})",
-        file = log_stream, 
+        file = log_stream,
         flush = True
       )
   # join
@@ -1122,6 +1159,9 @@ def run(
   pd.DataFrame(tc_dict["LSPr"]).to_csv(
     os.path.join(solution_folder, "termination_condition.csv")
   )
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index=False,
+  )
   if verbose > 0:
     print(
       f"All solutions saved in: {solution_folder}", 
@@ -1143,8 +1183,9 @@ def run(
   config = load_configuration(config_file)
   # run
   run(
-    config, 
-    parallelism, 
-    log_on_file = False, 
-    disable_plotting = disable_plotting
+    config,
+    parallelism,
+    log_on_file = False,
+    disable_plotting = disable_plotting,
+    v0 = args.v0
   )
diff --git a/run_faasmadea.py b/run_faasmadea.py
index f4f8350..3327427 100644
--- a/run_faasmadea.py
+++ b/run_faasmadea.py
@@ -19,7 +19,7 @@
 from utils.centralized import check_feasibility
 from utils.faasmacro import compute_centralized_objective
 from utils.common import load_configuration
-from models.sp import LSP, LSPr, LSP_fixedr
+from models.sp import LSP, LSPr, LSP_fixedr, LSPr_x
 from models.model import PYO_VAR_TYPE
 
 from networkx import adjacency_matrix
@@ -51,7 +51,7 @@ def parse_arguments() -> argparse.Namespace:
     "-c", "--config",
     help = "Configuration file",
     type = str,
-    default = "manual_config.json"
+    default = "config_files/manual_config.json"
   )
   parser.add_argument(
     "-j", "--parallelism",
@@ -111,15 +111,21 @@ def check_stopping_criteria(
     it: int,
     max_iterations: int,
     blackboard: np.array,
-    omega: np.array,
-    rmp_omega: np.array,
-    a: np.array,
-    bids: pd.DataFrame,
-    memory_bids: pd.DataFrame,
-    tolerance: float,
-    total_runtime: float,
-    time_limit: float
+    omega: np.array = None,
+    rmp_omega: np.array = None,
+    a: np.array = None,
+    bids: pd.DataFrame = None,
+    memory_bids: pd.DataFrame = None,
+    tolerance: float = 1e-6,
+    total_runtime: float = 0.0,
+    time_limit: float = float("inf"),
+    sp_omega: np.array = None,
+    sp_y: np.array = None
   ) -> Tuple[bool, str]:
+  if omega is None:
+    omega = sp_omega
+  if a is None:
+    a = np.zeros_like(rmp_omega) if rmp_omega is not None else None
   stop = False
   why_stopping = None
   if it >= max_iterations - 1:
@@ -131,15 +137,27 @@ def check_stopping_criteria(
   elif (omega <= tolerance).all():
     stop = True
     why_stopping = "all load assigned"
-  elif (rmp_omega <= tolerance).all() and (a <= tolerance).all():
+  elif (
+      rmp_omega is not None and a is not None and
+        (rmp_omega <= tolerance).all() and (a <= tolerance).all()
+    ):
     stop = True
     why_stopping = "load cannot be assigned"
-  elif len(bids) == 0 and len(memory_bids) == 0:
+  elif (
+      bids is not None and memory_bids is not None and
+        len(bids) == 0 and len(memory_bids) == 0
+    ):
     stop = True
     why_stopping = "no available or convenient sellers"
   elif total_runtime >= time_limit:
     stop = True
     why_stopping = f"reached time limit: {total_runtime} >= {time_limit}"
+  elif (
+      sp_omega is not None and rmp_omega is not None and sp_y is not None and
+        (np.abs(sp_omega - rmp_omega) <= tolerance).all()
+    ):
+    stop = True
+    why_stopping = "feasible solution found"
   return stop, why_stopping
 
 
@@ -150,7 +168,6 @@ def compute_residual_capacity(
   Nf = data[None]["Nf"][None]
   # loop over nodes and functions
   cap = np.zeros((Nn,Nf))
-  c = np.zeros((Nn,Nf))
   residual_capacity = np.zeros((Nn,Nf))
   ell = np.zeros((Nn,Nf))
   for n in range(Nn):
@@ -161,10 +178,46 @@ def compute_residual_capacity(
       cap[n,f] = r[n,f] * (
         data[None]["max_utilization"][f+1] / data[None]["demand"][(n+1,f+1)]
       )
-      # residual capacity (the blackboard does not consider y)
-      c[n,f] = max(0.0, cap[n,f] - x[n,f])
       residual_capacity[n,f] = max(0.0, cap[n,f] - ell[n,f])
-  return cap, c, residual_capacity, ell
+  return cap, residual_capacity, ell
+
+
+def data_dict_to_matrix(data_dict: dict, Nn: int, Nf: int = 0) -> np.array:
+  data_mat = np.zeros((Nn,Nn))
+  if Nf > 0:
+    data_mat = np.zeros((Nn,Nn,Nf))
+  for n1 in range(Nn):
+    for n2 in range(Nn):
+      if n1 != n2:
+        if Nf == 0:
+          data_mat[n1,n2] = data_dict[(n1+1,n2+1)]
+        else:
+          for f in range(Nf):
+            data_mat[n1,n2,f] = data_dict[(n1+1,n2+1,f+1)]
+  return data_mat
+
+
+def compute_utility(
+    p: np.array, 
+    data: dict,
+    auction_options: dict,
+    latency: np.array,
+    fairness: np.array
+  ) -> np.array:
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  utility = np.zeros((Nn,Nn,Nf))
+  for i in range(Nn):
+    for j in range(Nn):
+      for f in range(Nf):
+        price = p[j,f] if p.ndim == 2 else p[i,j,f]
+        utility[i,j,f] = (
+          data[None]["beta"][(i+1,j+1,f+1)] - 
+          price - 
+          auction_options["latency_weight"] * latency[i,j] - 
+          auction_options["fairness_weight"] * fairness[i,f]
+        )
+  return utility
 
 
 def define_bids(
@@ -282,18 +335,44 @@ def evaluate_bids(
     bids: pd.DataFrame, 
     blackboard: np.array, 
     data: dict, 
-    last_y: np.array,
-    ell: np.array, 
-    p: np.array, 
-    capacity: np.array, 
-    u0: np.array, 
-    auction_options: dict,
-    initial_rho: np.array,
-    r: np.array,
-    tentatively_start_replicas: bool
+    previous_y: np.array = None,
+    ell: np.array = None, 
+    p: np.array = None, 
+    capacity: np.array = None, 
+    u0: np.array = None, 
+    auction_options: dict = None,
+    initial_rho: np.array = None,
+    r: np.array = None,
+    tentatively_start_replicas: bool = False,
+    it: int = 0
   ) -> np.array:
   Nn = data[None]["Nn"][None]
   Nf = data[None]["Nf"][None]
+  last_y = np.zeros((Nn,Nn,Nf)) if previous_y is None else previous_y.copy()
+  if ell is None:
+    ell = np.zeros((Nn,Nf))
+  if p is None:
+    p = np.zeros((Nn,Nf))
+  if capacity is None:
+    capacity = np.ones((Nn,Nf))
+  if u0 is None:
+    u0 = np.zeros((Nn,Nf))
+  if auction_options is None:
+    auction_options = {"eta": 0.0, "zeta": 0.0}
+  if initial_rho is None:
+    initial_rho = np.zeros((Nn,))
+  if r is None:
+    r = np.zeros((Nn,Nf))
+  # eta may be a per-iteration schedule (e.g. [0.5, 0.3, 0.15]); clamp to the
+  # last value once the schedule is exhausted, accept a plain scalar too
+  eta = auction_options["eta"]
+  eta = eta[min(it, len(eta) - 1)] if isinstance(eta, (list, tuple)) else eta
+  # no_ping_pong (validate_centralized_solution): a node must not both send and
+  # receive the same function across the accumulated y. Track realized roles and
+  # refuse any bid that would give a node a second, conflicting role. Mirrors the
+  # guard in decentralized_auction.evaluate_bids.
+  sending = last_y.sum(axis = 1) > 1e-10
+  receiving = last_y.sum(axis = 0) > 1e-10
   # loop over agents and functions
   potential_sellers, functions_to_share = np.nonzero(blackboard)
   if tentatively_start_replicas:
@@ -306,80 +385,126 @@ def evaluate_bids(
   y = np.zeros((Nn,Nn,Nf))
   additional_replicas = np.zeros((Nn,Nf))
   rho = deepcopy(initial_rho)
-  for j,f in zip(potential_sellers,functions_to_share):
+  unique_potential_sellers = np.unique(potential_sellers)
+  for j in unique_potential_sellers:
     # extract bids for the current node
-    bids_for_j = bids[(bids["j"] == j) & (bids["f"] == f)].sort_values(
+    all_bids_for_j = bids[(bids["j"] == j)].sort_values(
       by = "b", ascending = False
     )
-    remaining_capacity = int(blackboard[j,f])
+    remaining_capacities = blackboard[j,:].astype(int).copy()
+    all_min_b = all_bids_for_j.groupby("f")["b"].max()
     next_bid_idx = 0
-    min_b = bids_for_j["b"].max()
     # loop over bids until there is remaining capacity
-    while next_bid_idx < len(bids_for_j) and remaining_capacity > 0:
-      q = min(remaining_capacity, bids_for_j.iloc[next_bid_idx]["d"])
-      y[int(bids_for_j.iloc[next_bid_idx]["i"]),j,f] += q
-      remaining_capacity -= q
-      min_b = min(min_b, bids_for_j.iloc[next_bid_idx]["b"])
+    while next_bid_idx < len(all_bids_for_j) and \
+        (remaining_capacities > 0).any():
+      bid = all_bids_for_j.iloc[next_bid_idx]
+      i = int(bid["i"])
+      f = int(bid["f"])
       next_bid_idx += 1
+      if receiving[i,f] or sending[j,f]:
+        continue
+      if remaining_capacities[f] > 0:
+        q = min(remaining_capacities[f], bid["d"])
+        y[i,j,f] += q
+        remaining_capacities[f] -= q
+        all_min_b[f] = min(all_min_b[f], bid["b"])
+        sending[i,f] = True
+        receiving[j,f] = True
     # if computational capacity is exhausted and there are still bids, 
     # consider starting new replicas
-    if remaining_capacity == 0 and (
-        next_bid_idx > 0 or (next_bid_idx == 0 and len(bids_for_j) > 0)
+    if (remaining_capacities == 0).all() and (
+        (0 < next_bid_idx < len(all_bids_for_j)) or (
+          next_bid_idx == 0 and len(all_bids_for_j) > 0
+        )
       ):
-      max_a = 0
-      if tentatively_start_replicas:
-        max_a = int(rho[j] / data[None]["memory_requirement"][f+1])
-        if max_a > 0:
-          a = 1
-          while next_bid_idx < len(bids_for_j) and a <= max_a:
-            # -- check utilization with one more replica
-            q = bids_for_j.iloc[next_bid_idx]["d"]
-            u = data[None]["demand"][(j+1,f+1)] * (
-              ell[j,f] + y[:,j,f].sum() + q
-            ) / (r[j,f] + a)
-            if u <= data[None]["max_utilization"][f+1]:
-              # -- if possible, accomodate one more bid...
-              y[int(bids_for_j.iloc[next_bid_idx]["i"]),j,f] += q
-              min_b = min(min_b, bids_for_j.iloc[next_bid_idx]["b"])
-              next_bid_idx += 1
-              additional_replicas[j,f] = a 
-              # -- and update the remaining memory capacity
-              rho[j] -= (a * data[None]["memory_requirement"][f+1])
-            else:
-              # -- ...otherwhise, try to increase replicas
-              a += 1
-      if not tentatively_start_replicas or max_a == 0:
+      if tentatively_start_replicas and rho[j] > 0:
+        while next_bid_idx < len(all_bids_for_j) and rho[j] > 0:
+          i = int(all_bids_for_j.iloc[next_bid_idx]["i"])
+          f = int(all_bids_for_j.iloc[next_bid_idx]["f"])
+          max_a = int(rho[j]/data[None]["memory_requirement"][f+1])
+          if max_a > 0 and not (receiving[i,f] or sending[j,f]):
+            a = int(additional_replicas[j,f] + 1)
+            managed = False
+            while a <= max_a and not managed:
+              # -- check utilization with one more replica
+              q = all_bids_for_j.iloc[next_bid_idx]["d"]
+              u = data[None]["demand"][(j+1,f+1)] * (
+                ell[j,f] + y[:,j,f].sum() + q
+              ) / (r[j,f] + a)
+              if u <= data[None]["max_utilization"][f+1]:
+                # -- if possible, accomodate one more bid...
+                y[i,j,f] += q
+                all_min_b[f] = min(
+                  all_min_b[f], all_bids_for_j.iloc[next_bid_idx]["b"]
+                )
+                sending[i,f] = True
+                receiving[j,f] = True
+                managed = True
+                # -- and update the remaining memory capacity
+                if additional_replicas[j,f] < a:
+                  additional_replicas[j,f] = a
+                  rho[j] -= (a * data[None]["memory_requirement"][f+1])
+              else:
+                # -- ...otherwhise, try to increase replicas
+                a += 1
+            next_bid_idx += 1
+          else:
+            next_bid_idx += 1
+      if not tentatively_start_replicas or (
+          tentatively_start_replicas and rho[j] <= 0
+        ):
         # if no additional replicas can start, replace existing assignments
         # -- check who previously won the assignment to j
-        i_arr, d_arr, b_arr = bids_for_j[["i","d","b"]].to_numpy().T
-        previous_buyers = np.nonzero(last_y[:,j,f])[0]
-        pbidx = 0
-        while next_bid_idx < len(i_arr) and pbidx < len(previous_buyers):
-          i = int(i_arr[next_bid_idx])
-          if previous_buyers[pbidx] != i and b_arr[next_bid_idx] > p[j,f]:
-            max_to_remove = last_y[previous_buyers[pbidx],j,f]
-            nbi = next_bid_idx
-            swapped = 0
-            while (
-                nbi < len(i_arr) and 
-                  i_arr[nbi] == i and 
-                    swapped < max_to_remove
+        i_arr, d_arr, b_arr, f_arr = all_bids_for_j[[
+          "i", "d", "b", "f"
+        ]].to_numpy().T
+        while next_bid_idx < len(f_arr):
+          f = int(f_arr[next_bid_idx])
+          previous_buyers = np.nonzero(last_y[:,j,f])[0]
+          pbidx = 0
+          nbi = -1
+          while pbidx < len(previous_buyers) and next_bid_idx < len(i_arr):
+            i = int(i_arr[next_bid_idx])
+            if (
+                previous_buyers[pbidx] != i and b_arr[next_bid_idx] > p[j,f]
+                and not receiving[i,f] and not sending[j,f]
               ):
-              q = d_arr[nbi]
-              y[previous_buyers[pbidx],j,f] -= q
-              y[i,j,f] += q
-              swapped += q
-              min_b = min(min_b, b_arr[nbi])
-              nbi += 1
-            next_bid_idx += (nbi if nbi > 0 else 1)
-          pbidx += 1
+              max_to_remove = last_y[previous_buyers[pbidx],j,f]
+              nbi = next_bid_idx
+              swapped = 0
+              while (
+                  nbi < len(i_arr) and
+                    i_arr[nbi] == i and
+                      f_arr[nbi] == f and
+                        swapped < max_to_remove
+                ):
+                # cap at what the incumbent still holds: removing the full bid
+                # quantity would over-subtract y (negative) and exceed j capacity
+                q = min(d_arr[nbi], max_to_remove - swapped)
+                y[previous_buyers[pbidx],j,f] -= q
+                y[i,j,f] += q
+                swapped += q
+                all_min_b[f] = min(all_min_b[f], b_arr[nbi])
+                nbi += 1
+              if swapped > 0:
+                sending[i,f] = True
+                receiving[j,f] = True
+                last_y[previous_buyers[pbidx],j,f] -= swapped
+                if last_y[previous_buyers[pbidx],j,f] <= 0:
+                  sending[previous_buyers[pbidx],f] = False
+              next_bid_idx += (nbi if nbi > 0 else 1)
+            pbidx += 1
+          if len(previous_buyers) == 0 or (
+              nbi < 0 and pbidx == len(previous_buyers)
+            ):
+            next_bid_idx += 1
     # compute utilization and update prices
-    if len(bids_for_j) > 0:
+    for f,b in all_min_b.items():
       u = (ell[j,f] + y[:,j,f].sum()) / capacity[j,f]
-      p[j,f] = min_b + auction_options["eta"] * (u - u0[j,f])
-    else:
+      p[j,f] = b + eta * (u - u0[j,f])
+    for f in set(functions_to_share) - set(all_min_b.index):
       p[j,f] *= (1 - auction_options["zeta"])
-  return y, p, additional_replicas, len(potential_sellers)
+  return y, p, additional_replicas, len(unique_potential_sellers)
 
 
 def neigh_dict_to_matrix(neighborhood_dict: dict, Nn: int) -> np.array:
@@ -402,18 +527,34 @@ def start_additional_replicas(
   residual_capacity = deepcopy(rho)
   for j, bids_for_j in memory_bids.groupby("j"):
     if rho[j] > 0:
+      seller_capacity = float(rho[j])
       # count the fraction that each function requires
-      fractions = bids_for_j["f"].value_counts(normalize = True)
+      fractions = bids_for_j["f"].value_counts(normalize = True).sort_index()
+      allocated_memory = {}
       # assign new replicas proportionally to this fraction
       for f, frac in fractions.items():
         # -- check memory requirement
         ram_f = data[None]["memory_requirement"][f+1]
         # -- determine the maximum number of replicas that fit in the 
         # assignable fraction of the residual memory capacity
-        a = int((residual_capacity[j] * frac) // ram_f)
+        a = int((seller_capacity * frac) // ram_f)
         # -- update
         residual_capacity[j] -= int(ram_f * a)
         additional_replicas[j,f] = a
+        allocated_memory[f] = ram_f * a
+      while True:
+        candidates = []
+        for f, frac in fractions.items():
+          ram_f = data[None]["memory_requirement"][f+1]
+          deficit = seller_capacity * frac - allocated_memory[f]
+          if ram_f <= residual_capacity[j] and deficit > 0:
+            candidates.append((deficit, frac, -int(f), int(f), ram_f))
+        if not candidates:
+          break
+        _, _, _, f, ram_f = max(candidates)
+        additional_replicas[j, f] += 1
+        allocated_memory[f] += ram_f
+        residual_capacity[j] -= ram_f
   return additional_replicas, residual_capacity
 
 
@@ -479,6 +620,7 @@ def run(
   spc_complete_solution = init_complete_solution()
   obj_dict = {"LSPr_final": []}
   tc_dict = {"LSPr": []}
+  runtime_list = []
   for t in range(min_run_time, ub, run_time_step):
     if verbose > 0:
       print(f"t = {t}", file = log_stream, flush = True)
@@ -500,7 +642,7 @@ def run(
           sp_data[None]["r_bar"][(n+1,f+1)] = int(opt_r[n,f])
     # -- solve subproblem
     sp = LSP() if opt_solution is None else LSP_fixedr()
-    spr = LSPr()
+    spr = LSPr_x()
     s = datetime.now()
     (
       sp_data, sp_x, _, _, sp_omega, sp_r, sp_rho, sp_U, obj, tc, sp_runtime
@@ -516,7 +658,7 @@ def run(
     if verbose > 1:
       print(
         f"    sp: DONE ({tc['tot']}; obj = {obj['tot']}; "
-        f"runtime = {sp_runtime['tot']})", 
+        f"x = {sp_x.tolist()}; runtime = {sp_runtime['tot']})", 
         file = log_stream, 
         flush = True
       )
@@ -543,9 +685,10 @@ def run(
         print(f"    it = {it}", file = log_stream, flush = True)
       # compute residual computational capacity
       s = datetime.now()
-      capacity, blackboard, residual_capacity, ell = compute_residual_capacity(
+      capacity, residual_capacity, ell = compute_residual_capacity(
         sp_x, y, sp_r, sp_data
       )
+      blackboard = np.maximum(0.0, capacity - sp_x)
       e = datetime.now()
       if verbose > 1:
         print(
@@ -578,14 +721,14 @@ def run(
       rt = (e - s).total_seconds()
       if verbose > 1:
         print(
-          f"        define_bids: DONE; runtime = {rt/n_auctions}; "
-          f"n_auctions = {n_auctions}; tot runtime = {rt})", 
-          file = log_stream, 
+          f"        define_bids: DONE; runtime = {rt/max(n_auctions, 1)}; "
+          f"n_auctions = {n_auctions}; tot runtime = {rt})",
+          file = log_stream,
           flush = True
         )
         if verbose > 2:
           print(bids, file = log_stream, flush = True)
-      total_runtime += (rt/n_auctions)
+      total_runtime += (rt/max(n_auctions, 1))
       # sellers accept/reject bids
       rmp_omega = np.zeros((Nn,Nf))
       additional_replicas = np.zeros((Nn,Nf))
@@ -603,18 +746,19 @@ def run(
           auction_options,
           sp_rho,
           sp_r,
-          tentatively_start_replicas = (len(memory_bids) == 0)
+          tentatively_start_replicas = (len(memory_bids) == 0),
+          it = it
         )
         e = datetime.now()
         rt = (e - s).total_seconds()
         if verbose > 1:
           print(
-           f"        evaluate_bids: DONE; runtime = {rt/n_auctions}; "
-           f"n_auctions = {n_auctions}; tot runtime = {rt})", 
-           file = log_stream, 
+           f"        evaluate_bids: DONE; runtime = {rt/max(n_auctions, 1)}; "
+           f"n_auctions = {n_auctions}; tot runtime = {rt})",
+           file = log_stream,
            flush = True
           )
-        total_runtime += (rt/n_auctions)
+        total_runtime += (rt/max(n_auctions, 1))
         # update effective load, number of replicas and fairness matrix
         y += auction_y
         for n in range(Nn):
@@ -626,7 +770,9 @@ def run(
         # -- solve "restricted problem"
         bad_nodes = check_ls_pr_feasibility_from_fixed_y(sp_data, y)
         if bad_nodes:
-          raise RuntimeError(f"LSPr infeasible from fixed y assignments: {bad_nodes}")
+          raise RuntimeError(
+            f"LSPr infeasible from fixed y assignments: {bad_nodes}"
+          )
         spr_sol, spr_obj, spr_tc, spr_runtime = compute_social_welfare(
           spr, 
           sp_data, 
@@ -635,7 +781,8 @@ def run(
           general_solver_options, 
           y, 
           rmp_omega,
-          parallelism
+          parallelism,
+          sp_x
         )
         total_runtime += spr_runtime
         if verbose > 1:
@@ -646,7 +793,7 @@ def run(
             flush = True
           )
         # -- update solution
-        sp_x, _, _, _, sp_r, sp_rho = spr_sol
+        _, _, _, _, sp_r, sp_rho = spr_sol
         for i in range(Nn):
           for f in range(Nf):
             omega[i,f] = sp_omega[i,f] - rmp_omega[i,f]
@@ -655,8 +802,9 @@ def run(
         if verbose > 1:
           print(
             f"        solution updated: DONE (auct_y = {auction_y.tolist()}; "
-            f"omega = {omega.tolist()}; x: {sp_x.tolist()}; "
-            f"r = {sp_r.tolist()}; rho = {sp_rho.tolist()})", 
+            f"omega = {omega.tolist()}; x = {sp_x.tolist()}; "
+            f"r = {sp_r.tolist()}; rho = {sp_rho.tolist()}; ", 
+            f"y = {y.tolist()})", 
             file = log_stream, 
             flush = True
           )
@@ -668,13 +816,14 @@ def run(
         )
         sp_r += additional_replicas
         e = datetime.now()
-        print(
-          f"        additional replicas started: DONE "
-          f"(a = {additional_replicas.tolist()}; "
-          f"rho = {sp_rho.tolist()}; runtime = {(e - s).total_seconds()})", 
-          file = log_stream, 
-          flush = True
-        )
+        if verbose > 1:
+          print(
+            f"        additional replicas started: DONE "
+            f"(a = {additional_replicas.tolist()}; "
+            f"rho = {sp_rho.tolist()}; runtime = {(e - s).total_seconds()})", 
+            file = log_stream, 
+            flush = True
+          )
         total_runtime += (e - s).total_seconds()
       # merge solutions and compute the centralized objective value
       csol = combine_solutions(
@@ -752,13 +901,13 @@ def run(
           sp_complete_solution, 
           None
         )
-        spc_complete_solution, _, _ = decode_solutions(
+        spc_complete_solution, _, objc = decode_solutions(
           sp_data, 
           best_centralized_solution, 
           spc_complete_solution, 
           None
         )
-        obj_dict["LSPr_final"].append(objf)
+        obj_dict["LSPr_final"].append(objc)
         tc_dict["LSPr"].append(
           f"{why_stop_searching} "
           f"(it: {it}; obj. deviation: {None}; best it: {best_it_so_far}; "
@@ -781,6 +930,7 @@ def run(
         file = log_stream, 
         flush = True
       )
+    runtime_list.append(total_runtime)
   # join
   sp_solution, sp_offloaded, sp_detailed_fwd_solution = join_complete_solution(
     sp_complete_solution
@@ -826,6 +976,10 @@ def run(
   pd.DataFrame(tc_dict["LSPr"]).to_csv(
     os.path.join(solution_folder, "termination_condition.csv")
   )
+  # save runtime (avoids fragile log parsing in results_postprocessing)
+  pd.DataFrame({"tot": runtime_list}).to_csv(
+    os.path.join(solution_folder, "runtime.csv"), index = False
+  )
   if verbose > 0:
     print(
       f"All solutions saved in: {solution_folder}", 
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloaded_processing.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloaded_processing.csv
new file mode 100644
index 0000000..fe02caf
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.125,0.06883259911894513,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.32558139534883734,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6950354609929121,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6255506607929533,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7048458149779577,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.558139534883722,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2553191489361737,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7441860465116292,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3920704845814953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6511627906976685,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.7446808510638334,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.125,1.355176211453724,0.0,0.0,0.0,0.0,0.0,0.0,1.9302325581395223,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6595744680851112,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22026431718057893,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9069767441860535,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.460992907801426,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0220264317180465,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.279069767441854,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.574468085106389,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3436123348017475,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3953488372092977,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7446808510638334,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.215859030836981,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloading.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloading.csv
new file mode 100644
index 0000000..74a8008
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/detailed_offloading.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8
+0.32558139534883734,0.48837209302325846,2.558139534883722,0.7441860465116292,0.0,1.9302325581395223,2.9069767441860535,2.279069767441854,0.0,0.6950354609929121,0.0425531914893682,0.2553191489361737,0.0425531914893682,0.0,0.6595744680851112,2.460992907801426,2.574468085106389,0.0,0.6255506607929533,0.7048458149779577,0.4977973568281868,0.3920704845814953,0.0,0.22026431718057893,2.0220264317180465,1.3436123348017475,1.0,0.0,0.0,0.0,0.0,1.6511627906976685,0.0,0.0,0.0,0.3953488372092977,0.0,0.0,0.0,0.0,2.7446808510638334,0.0,0.0,0.0,0.7446808510638334,0.125,0.0,0.0,0.0,0.125,0.0,0.0,0.0,0.215859030836981,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06883259911894513,0.0,0.0,0.0,1.355176211453724,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/local_processing.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/local_processing.csv
new file mode 100644
index 0000000..1dc8bd8
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/local_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+0.0,0.0,28.0,2.0,22.0,54.0,33.0,34.0,160.0,70.0,44.0,101.0,16.0,34.0,173.0,83.0,33.0,112.0,239.0,47.0,170.0,85.0,73.0,183.0,154.0,57.0,85.0,221.0,35.0,132.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloaded_processing.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloaded_processing.csv
new file mode 100644
index 0000000..ad393eb
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+0.0,0.0,0.19383259911894513,0.32558139534883734,0.6950354609929121,0.6255506607929533,0.48837209302325846,0.0425531914893682,0.7048458149779577,2.558139534883722,0.2553191489361737,0.4977973568281868,0.7441860465116292,0.0425531914893682,0.3920704845814953,1.6511627906976685,2.7446808510638334,1.480176211453724,1.9302325581395223,0.6595744680851112,0.22026431718057893,2.9069767441860535,2.460992907801426,2.0220264317180465,2.279069767441854,2.574468085106389,1.3436123348017475,0.3953488372092977,0.7446808510638334,1.215859030836981
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloading.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloading.csv
new file mode 100644
index 0000000..9e3c245
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/offloading.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+11.232558139534877,6.730496453900749,6.806167400880966,2.046511627906966,3.489361702127667,0.465859030836981,0.0,0.0,1.4240088105726691,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/rejections.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/rejections.csv
new file mode 100644
index 0000000..332900c
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/rejections.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+107.76744186046513,49.26950354609925,33.193832599119034,177.95348837209303,2.510638297872333,4.534140969163019,221.0,1.0,1.5759911894273309,0.0,17.0,0.0,240.0,42.0,14.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/replicas.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/replicas.csv
new file mode 100644
index 0000000..b983e3f
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/replicas.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+0.0,0.0,32.0,1.0,8.0,31.0,12.0,10.0,76.0,26.0,13.0,48.0,6.0,10.0,82.0,26.0,9.0,46.0,74.0,12.0,69.0,27.0,19.0,75.0,48.0,15.0,35.0,68.0,9.0,54.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/residual_capacity.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/residual_capacity.csv
new file mode 100644
index 0000000..c147c62
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/residual_capacity.csv
@@ -0,0 +1,2 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9
+0.0,0.0,0.0,256.0,0.0,10752.0,128.0,9984.0,14464.0,12544.0
diff --git a/test_instances/2026-06-30_13-54-13.841040/LSPc/70/utilization.csv b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/utilization.csv
new file mode 100644
index 0000000..9ef5e9c
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/LSPc/70/utilization.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2
+0.0,0.0,0.7945,0.688,0.7755,0.7908387096774194,0.7883333333333334,0.7989999999999999,0.7964912280701755,0.7717948717948718,0.7953846153846154,0.7960763888888889,0.7644444444444445,0.7989999999999999,0.7981910569105691,0.7843956043956044,0.7385714285714285,0.7895652173913045,0.7935907335907336,0.7889285714285714,0.7989648033126295,0.7735449735449735,0.7739097744360902,0.791257142857143,0.7883333333333334,0.7654285714285715,0.7875510204081634,0.7985714285714286,0.7833333333333333,0.7926984126984129
diff --git a/test_instances/2026-06-30_13-54-13.841040/base_instance_data.json b/test_instances/2026-06-30_13-54-13.841040/base_instance_data.json
new file mode 100644
index 0000000..b6f1037
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/base_instance_data.json
@@ -0,0 +1,564 @@
+{
+  "None": {
+    "Nn": {
+      "None": 10
+    },
+    "Nf": {
+      "None": 3
+    },
+    "demand": {
+      "(1, 1)": 0.688,
+      "(1, 2)": 0.564,
+      "(1, 3)": 0.908,
+      "(2, 1)": 0.344,
+      "(2, 2)": 0.282,
+      "(2, 3)": 0.454,
+      "(3, 1)": 0.2866666666666667,
+      "(3, 2)": 0.235,
+      "(3, 3)": 0.37833333333333335,
+      "(4, 1)": 0.2866666666666667,
+      "(4, 2)": 0.235,
+      "(4, 3)": 0.37833333333333335,
+      "(5, 1)": 0.2866666666666667,
+      "(5, 2)": 0.235,
+      "(5, 3)": 0.37833333333333335,
+      "(6, 1)": 0.24571428571428572,
+      "(6, 2)": 0.20142857142857143,
+      "(6, 3)": 0.32428571428571434,
+      "(7, 1)": 0.24571428571428572,
+      "(7, 2)": 0.20142857142857143,
+      "(7, 3)": 0.32428571428571434,
+      "(8, 1)": 0.24571428571428572,
+      "(8, 2)": 0.20142857142857143,
+      "(8, 3)": 0.32428571428571434,
+      "(9, 1)": 0.24571428571428572,
+      "(9, 2)": 0.20142857142857143,
+      "(9, 3)": 0.32428571428571434,
+      "(10, 1)": 0.24571428571428572,
+      "(10, 2)": 0.20142857142857143,
+      "(10, 3)": 0.32428571428571434
+    },
+    "memory_requirement": {
+      "1": 128,
+      "2": 512,
+      "3": 128
+    },
+    "memory_capacity": {
+      "1": 4096,
+      "2": 8192,
+      "3": 16384,
+      "4": 16384,
+      "5": 16384,
+      "6": 24576,
+      "7": 24576,
+      "8": 32768,
+      "9": 32768,
+      "10": 32768
+    },
+    "neighborhood": {
+      "(1, 1)": 0,
+      "(1, 2)": 1,
+      "(1, 3)": 1,
+      "(1, 4)": 1,
+      "(1, 5)": 1,
+      "(1, 6)": 0,
+      "(1, 7)": 1,
+      "(1, 8)": 1,
+      "(1, 9)": 1,
+      "(1, 10)": 0,
+      "(2, 1)": 1,
+      "(2, 2)": 0,
+      "(2, 3)": 1,
+      "(2, 4)": 1,
+      "(2, 5)": 0,
+      "(2, 6)": 1,
+      "(2, 7)": 1,
+      "(2, 8)": 1,
+      "(2, 9)": 1,
+      "(2, 10)": 1,
+      "(3, 1)": 1,
+      "(3, 2)": 1,
+      "(3, 3)": 0,
+      "(3, 4)": 1,
+      "(3, 5)": 1,
+      "(3, 6)": 1,
+      "(3, 7)": 0,
+      "(3, 8)": 0,
+      "(3, 9)": 0,
+      "(3, 10)": 0,
+      "(4, 1)": 1,
+      "(4, 2)": 1,
+      "(4, 3)": 1,
+      "(4, 4)": 0,
+      "(4, 5)": 1,
+      "(4, 6)": 1,
+      "(4, 7)": 1,
+      "(4, 8)": 0,
+      "(4, 9)": 0,
+      "(4, 10)": 0,
+      "(5, 1)": 1,
+      "(5, 2)": 0,
+      "(5, 3)": 1,
+      "(5, 4)": 1,
+      "(5, 5)": 0,
+      "(5, 6)": 0,
+      "(5, 7)": 0,
+      "(5, 8)": 0,
+      "(5, 9)": 0,
+      "(5, 10)": 0,
+      "(6, 1)": 0,
+      "(6, 2)": 1,
+      "(6, 3)": 1,
+      "(6, 4)": 1,
+      "(6, 5)": 0,
+      "(6, 6)": 0,
+      "(6, 7)": 0,
+      "(6, 8)": 0,
+      "(6, 9)": 0,
+      "(6, 10)": 0,
+      "(7, 1)": 1,
+      "(7, 2)": 1,
+      "(7, 3)": 0,
+      "(7, 4)": 1,
+      "(7, 5)": 0,
+      "(7, 6)": 0,
+      "(7, 7)": 0,
+      "(7, 8)": 1,
+      "(7, 9)": 0,
+      "(7, 10)": 1,
+      "(8, 1)": 1,
+      "(8, 2)": 1,
+      "(8, 3)": 0,
+      "(8, 4)": 0,
+      "(8, 5)": 0,
+      "(8, 6)": 0,
+      "(8, 7)": 1,
+      "(8, 8)": 0,
+      "(8, 9)": 1,
+      "(8, 10)": 1,
+      "(9, 1)": 1,
+      "(9, 2)": 1,
+      "(9, 3)": 0,
+      "(9, 4)": 0,
+      "(9, 5)": 0,
+      "(9, 6)": 0,
+      "(9, 7)": 0,
+      "(9, 8)": 1,
+      "(9, 9)": 0,
+      "(9, 10)": 0,
+      "(10, 1)": 0,
+      "(10, 2)": 1,
+      "(10, 3)": 0,
+      "(10, 4)": 0,
+      "(10, 5)": 0,
+      "(10, 6)": 0,
+      "(10, 7)": 1,
+      "(10, 8)": 1,
+      "(10, 9)": 0,
+      "(10, 10)": 0
+    },
+    "max_utilization": {
+      "1": 0.8,
+      "2": 0.8,
+      "3": 0.8
+    },
+    "alpha": {
+      "(1, 1)": 1.0,
+      "(1, 2)": 1.0,
+      "(1, 3)": 1.0,
+      "(2, 1)": 1.0,
+      "(2, 2)": 1.0,
+      "(2, 3)": 1.0,
+      "(3, 1)": 1.0,
+      "(3, 2)": 1.0,
+      "(3, 3)": 1.0,
+      "(4, 1)": 1.0,
+      "(4, 2)": 1.0,
+      "(4, 3)": 1.0,
+      "(5, 1)": 1.0,
+      "(5, 2)": 1.0,
+      "(5, 3)": 1.0,
+      "(6, 1)": 1.0,
+      "(6, 2)": 1.0,
+      "(6, 3)": 1.0,
+      "(7, 1)": 1.0,
+      "(7, 2)": 1.0,
+      "(7, 3)": 1.0,
+      "(8, 1)": 1.0,
+      "(8, 2)": 1.0,
+      "(8, 3)": 1.0,
+      "(9, 1)": 1.0,
+      "(9, 2)": 1.0,
+      "(9, 3)": 1.0,
+      "(10, 1)": 1.0,
+      "(10, 2)": 1.0,
+      "(10, 3)": 1.0
+    },
+    "beta": {
+      "(1, 1, 1)": 0.288,
+      "(1, 1, 2)": 0.702,
+      "(1, 1, 3)": 0.4,
+      "(1, 2, 1)": 0.288,
+      "(1, 2, 2)": 0.702,
+      "(1, 2, 3)": 0.4,
+      "(1, 3, 1)": 0.288,
+      "(1, 3, 2)": 0.702,
+      "(1, 3, 3)": 0.4,
+      "(1, 4, 1)": 0.288,
+      "(1, 4, 2)": 0.702,
+      "(1, 4, 3)": 0.4,
+      "(1, 5, 1)": 0.288,
+      "(1, 5, 2)": 0.702,
+      "(1, 5, 3)": 0.4,
+      "(1, 6, 1)": 0.288,
+      "(1, 6, 2)": 0.702,
+      "(1, 6, 3)": 0.4,
+      "(1, 7, 1)": 0.288,
+      "(1, 7, 2)": 0.702,
+      "(1, 7, 3)": 0.4,
+      "(1, 8, 1)": 0.288,
+      "(1, 8, 2)": 0.702,
+      "(1, 8, 3)": 0.4,
+      "(1, 9, 1)": 0.288,
+      "(1, 9, 2)": 0.702,
+      "(1, 9, 3)": 0.4,
+      "(1, 10, 1)": 0.288,
+      "(1, 10, 2)": 0.702,
+      "(1, 10, 3)": 0.4,
+      "(2, 1, 1)": 0.288,
+      "(2, 1, 2)": 0.702,
+      "(2, 1, 3)": 0.4,
+      "(2, 2, 1)": 0.288,
+      "(2, 2, 2)": 0.702,
+      "(2, 2, 3)": 0.4,
+      "(2, 3, 1)": 0.288,
+      "(2, 3, 2)": 0.702,
+      "(2, 3, 3)": 0.4,
+      "(2, 4, 1)": 0.288,
+      "(2, 4, 2)": 0.702,
+      "(2, 4, 3)": 0.4,
+      "(2, 5, 1)": 0.288,
+      "(2, 5, 2)": 0.702,
+      "(2, 5, 3)": 0.4,
+      "(2, 6, 1)": 0.288,
+      "(2, 6, 2)": 0.702,
+      "(2, 6, 3)": 0.4,
+      "(2, 7, 1)": 0.288,
+      "(2, 7, 2)": 0.702,
+      "(2, 7, 3)": 0.4,
+      "(2, 8, 1)": 0.288,
+      "(2, 8, 2)": 0.702,
+      "(2, 8, 3)": 0.4,
+      "(2, 9, 1)": 0.288,
+      "(2, 9, 2)": 0.702,
+      "(2, 9, 3)": 0.4,
+      "(2, 10, 1)": 0.288,
+      "(2, 10, 2)": 0.702,
+      "(2, 10, 3)": 0.4,
+      "(3, 1, 1)": 0.288,
+      "(3, 1, 2)": 0.702,
+      "(3, 1, 3)": 0.4,
+      "(3, 2, 1)": 0.288,
+      "(3, 2, 2)": 0.702,
+      "(3, 2, 3)": 0.4,
+      "(3, 3, 1)": 0.288,
+      "(3, 3, 2)": 0.702,
+      "(3, 3, 3)": 0.4,
+      "(3, 4, 1)": 0.288,
+      "(3, 4, 2)": 0.702,
+      "(3, 4, 3)": 0.4,
+      "(3, 5, 1)": 0.288,
+      "(3, 5, 2)": 0.702,
+      "(3, 5, 3)": 0.4,
+      "(3, 6, 1)": 0.288,
+      "(3, 6, 2)": 0.702,
+      "(3, 6, 3)": 0.4,
+      "(3, 7, 1)": 0.288,
+      "(3, 7, 2)": 0.702,
+      "(3, 7, 3)": 0.4,
+      "(3, 8, 1)": 0.288,
+      "(3, 8, 2)": 0.702,
+      "(3, 8, 3)": 0.4,
+      "(3, 9, 1)": 0.288,
+      "(3, 9, 2)": 0.702,
+      "(3, 9, 3)": 0.4,
+      "(3, 10, 1)": 0.288,
+      "(3, 10, 2)": 0.702,
+      "(3, 10, 3)": 0.4,
+      "(4, 1, 1)": 0.288,
+      "(4, 1, 2)": 0.702,
+      "(4, 1, 3)": 0.4,
+      "(4, 2, 1)": 0.288,
+      "(4, 2, 2)": 0.702,
+      "(4, 2, 3)": 0.4,
+      "(4, 3, 1)": 0.288,
+      "(4, 3, 2)": 0.702,
+      "(4, 3, 3)": 0.4,
+      "(4, 4, 1)": 0.288,
+      "(4, 4, 2)": 0.702,
+      "(4, 4, 3)": 0.4,
+      "(4, 5, 1)": 0.288,
+      "(4, 5, 2)": 0.702,
+      "(4, 5, 3)": 0.4,
+      "(4, 6, 1)": 0.288,
+      "(4, 6, 2)": 0.702,
+      "(4, 6, 3)": 0.4,
+      "(4, 7, 1)": 0.288,
+      "(4, 7, 2)": 0.702,
+      "(4, 7, 3)": 0.4,
+      "(4, 8, 1)": 0.288,
+      "(4, 8, 2)": 0.702,
+      "(4, 8, 3)": 0.4,
+      "(4, 9, 1)": 0.288,
+      "(4, 9, 2)": 0.702,
+      "(4, 9, 3)": 0.4,
+      "(4, 10, 1)": 0.288,
+      "(4, 10, 2)": 0.702,
+      "(4, 10, 3)": 0.4,
+      "(5, 1, 1)": 0.288,
+      "(5, 1, 2)": 0.702,
+      "(5, 1, 3)": 0.4,
+      "(5, 2, 1)": 0.288,
+      "(5, 2, 2)": 0.702,
+      "(5, 2, 3)": 0.4,
+      "(5, 3, 1)": 0.288,
+      "(5, 3, 2)": 0.702,
+      "(5, 3, 3)": 0.4,
+      "(5, 4, 1)": 0.288,
+      "(5, 4, 2)": 0.702,
+      "(5, 4, 3)": 0.4,
+      "(5, 5, 1)": 0.288,
+      "(5, 5, 2)": 0.702,
+      "(5, 5, 3)": 0.4,
+      "(5, 6, 1)": 0.288,
+      "(5, 6, 2)": 0.702,
+      "(5, 6, 3)": 0.4,
+      "(5, 7, 1)": 0.288,
+      "(5, 7, 2)": 0.702,
+      "(5, 7, 3)": 0.4,
+      "(5, 8, 1)": 0.288,
+      "(5, 8, 2)": 0.702,
+      "(5, 8, 3)": 0.4,
+      "(5, 9, 1)": 0.288,
+      "(5, 9, 2)": 0.702,
+      "(5, 9, 3)": 0.4,
+      "(5, 10, 1)": 0.288,
+      "(5, 10, 2)": 0.702,
+      "(5, 10, 3)": 0.4,
+      "(6, 1, 1)": 0.288,
+      "(6, 1, 2)": 0.702,
+      "(6, 1, 3)": 0.4,
+      "(6, 2, 1)": 0.288,
+      "(6, 2, 2)": 0.702,
+      "(6, 2, 3)": 0.4,
+      "(6, 3, 1)": 0.288,
+      "(6, 3, 2)": 0.702,
+      "(6, 3, 3)": 0.4,
+      "(6, 4, 1)": 0.288,
+      "(6, 4, 2)": 0.702,
+      "(6, 4, 3)": 0.4,
+      "(6, 5, 1)": 0.288,
+      "(6, 5, 2)": 0.702,
+      "(6, 5, 3)": 0.4,
+      "(6, 6, 1)": 0.288,
+      "(6, 6, 2)": 0.702,
+      "(6, 6, 3)": 0.4,
+      "(6, 7, 1)": 0.288,
+      "(6, 7, 2)": 0.702,
+      "(6, 7, 3)": 0.4,
+      "(6, 8, 1)": 0.288,
+      "(6, 8, 2)": 0.702,
+      "(6, 8, 3)": 0.4,
+      "(6, 9, 1)": 0.288,
+      "(6, 9, 2)": 0.702,
+      "(6, 9, 3)": 0.4,
+      "(6, 10, 1)": 0.288,
+      "(6, 10, 2)": 0.702,
+      "(6, 10, 3)": 0.4,
+      "(7, 1, 1)": 0.288,
+      "(7, 1, 2)": 0.702,
+      "(7, 1, 3)": 0.4,
+      "(7, 2, 1)": 0.288,
+      "(7, 2, 2)": 0.702,
+      "(7, 2, 3)": 0.4,
+      "(7, 3, 1)": 0.288,
+      "(7, 3, 2)": 0.702,
+      "(7, 3, 3)": 0.4,
+      "(7, 4, 1)": 0.288,
+      "(7, 4, 2)": 0.702,
+      "(7, 4, 3)": 0.4,
+      "(7, 5, 1)": 0.288,
+      "(7, 5, 2)": 0.702,
+      "(7, 5, 3)": 0.4,
+      "(7, 6, 1)": 0.288,
+      "(7, 6, 2)": 0.702,
+      "(7, 6, 3)": 0.4,
+      "(7, 7, 1)": 0.288,
+      "(7, 7, 2)": 0.702,
+      "(7, 7, 3)": 0.4,
+      "(7, 8, 1)": 0.288,
+      "(7, 8, 2)": 0.702,
+      "(7, 8, 3)": 0.4,
+      "(7, 9, 1)": 0.288,
+      "(7, 9, 2)": 0.702,
+      "(7, 9, 3)": 0.4,
+      "(7, 10, 1)": 0.288,
+      "(7, 10, 2)": 0.702,
+      "(7, 10, 3)": 0.4,
+      "(8, 1, 1)": 0.288,
+      "(8, 1, 2)": 0.702,
+      "(8, 1, 3)": 0.4,
+      "(8, 2, 1)": 0.288,
+      "(8, 2, 2)": 0.702,
+      "(8, 2, 3)": 0.4,
+      "(8, 3, 1)": 0.288,
+      "(8, 3, 2)": 0.702,
+      "(8, 3, 3)": 0.4,
+      "(8, 4, 1)": 0.288,
+      "(8, 4, 2)": 0.702,
+      "(8, 4, 3)": 0.4,
+      "(8, 5, 1)": 0.288,
+      "(8, 5, 2)": 0.702,
+      "(8, 5, 3)": 0.4,
+      "(8, 6, 1)": 0.288,
+      "(8, 6, 2)": 0.702,
+      "(8, 6, 3)": 0.4,
+      "(8, 7, 1)": 0.288,
+      "(8, 7, 2)": 0.702,
+      "(8, 7, 3)": 0.4,
+      "(8, 8, 1)": 0.288,
+      "(8, 8, 2)": 0.702,
+      "(8, 8, 3)": 0.4,
+      "(8, 9, 1)": 0.288,
+      "(8, 9, 2)": 0.702,
+      "(8, 9, 3)": 0.4,
+      "(8, 10, 1)": 0.288,
+      "(8, 10, 2)": 0.702,
+      "(8, 10, 3)": 0.4,
+      "(9, 1, 1)": 0.288,
+      "(9, 1, 2)": 0.702,
+      "(9, 1, 3)": 0.4,
+      "(9, 2, 1)": 0.288,
+      "(9, 2, 2)": 0.702,
+      "(9, 2, 3)": 0.4,
+      "(9, 3, 1)": 0.288,
+      "(9, 3, 2)": 0.702,
+      "(9, 3, 3)": 0.4,
+      "(9, 4, 1)": 0.288,
+      "(9, 4, 2)": 0.702,
+      "(9, 4, 3)": 0.4,
+      "(9, 5, 1)": 0.288,
+      "(9, 5, 2)": 0.702,
+      "(9, 5, 3)": 0.4,
+      "(9, 6, 1)": 0.288,
+      "(9, 6, 2)": 0.702,
+      "(9, 6, 3)": 0.4,
+      "(9, 7, 1)": 0.288,
+      "(9, 7, 2)": 0.702,
+      "(9, 7, 3)": 0.4,
+      "(9, 8, 1)": 0.288,
+      "(9, 8, 2)": 0.702,
+      "(9, 8, 3)": 0.4,
+      "(9, 9, 1)": 0.288,
+      "(9, 9, 2)": 0.702,
+      "(9, 9, 3)": 0.4,
+      "(9, 10, 1)": 0.288,
+      "(9, 10, 2)": 0.702,
+      "(9, 10, 3)": 0.4,
+      "(10, 1, 1)": 0.288,
+      "(10, 1, 2)": 0.702,
+      "(10, 1, 3)": 0.4,
+      "(10, 2, 1)": 0.288,
+      "(10, 2, 2)": 0.702,
+      "(10, 2, 3)": 0.4,
+      "(10, 3, 1)": 0.288,
+      "(10, 3, 2)": 0.702,
+      "(10, 3, 3)": 0.4,
+      "(10, 4, 1)": 0.288,
+      "(10, 4, 2)": 0.702,
+      "(10, 4, 3)": 0.4,
+      "(10, 5, 1)": 0.288,
+      "(10, 5, 2)": 0.702,
+      "(10, 5, 3)": 0.4,
+      "(10, 6, 1)": 0.288,
+      "(10, 6, 2)": 0.702,
+      "(10, 6, 3)": 0.4,
+      "(10, 7, 1)": 0.288,
+      "(10, 7, 2)": 0.702,
+      "(10, 7, 3)": 0.4,
+      "(10, 8, 1)": 0.288,
+      "(10, 8, 2)": 0.702,
+      "(10, 8, 3)": 0.4,
+      "(10, 9, 1)": 0.288,
+      "(10, 9, 2)": 0.702,
+      "(10, 9, 3)": 0.4,
+      "(10, 10, 1)": 0.0,
+      "(10, 10, 2)": 0.0,
+      "(10, 10, 3)": 0.0
+    },
+    "gamma": {
+      "(1, 1)": 1.0,
+      "(1, 2)": 1.0,
+      "(1, 3)": 1.0,
+      "(2, 1)": 1.0,
+      "(2, 2)": 1.0,
+      "(2, 3)": 1.0,
+      "(3, 1)": 1.0,
+      "(3, 2)": 1.0,
+      "(3, 3)": 1.0,
+      "(4, 1)": 1.0,
+      "(4, 2)": 1.0,
+      "(4, 3)": 1.0,
+      "(5, 1)": 1.0,
+      "(5, 2)": 1.0,
+      "(5, 3)": 1.0,
+      "(6, 1)": 1.0,
+      "(6, 2)": 1.0,
+      "(6, 3)": 1.0,
+      "(7, 1)": 1.0,
+      "(7, 2)": 1.0,
+      "(7, 3)": 1.0,
+      "(8, 1)": 1.0,
+      "(8, 2)": 1.0,
+      "(8, 3)": 1.0,
+      "(9, 1)": 1.0,
+      "(9, 2)": 1.0,
+      "(9, 3)": 1.0,
+      "(10, 1)": 1.0,
+      "(10, 2)": 1.0,
+      "(10, 3)": 1.0
+    },
+    "delta": {
+      "(1, 1)": 0.288,
+      "(1, 2)": 0.702,
+      "(1, 3)": 0.4,
+      "(2, 1)": 0.288,
+      "(2, 2)": 0.702,
+      "(2, 3)": 0.4,
+      "(3, 1)": 0.288,
+      "(3, 2)": 0.702,
+      "(3, 3)": 0.4,
+      "(4, 1)": 0.288,
+      "(4, 2)": 0.702,
+      "(4, 3)": 0.4,
+      "(5, 1)": 0.288,
+      "(5, 2)": 0.702,
+      "(5, 3)": 0.4,
+      "(6, 1)": 0.288,
+      "(6, 2)": 0.702,
+      "(6, 3)": 0.4,
+      "(7, 1)": 0.288,
+      "(7, 2)": 0.702,
+      "(7, 3)": 0.4,
+      "(8, 1)": 0.288,
+      "(8, 2)": 0.702,
+      "(8, 3)": 0.4,
+      "(9, 1)": 0.288,
+      "(9, 2)": 0.702,
+      "(9, 3)": 0.4,
+      "(10, 1)": 0.288,
+      "(10, 2)": 0.702,
+      "(10, 3)": 0.4
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_13-54-13.841040/config.json b/test_instances/2026-06-30_13-54-13.841040/config.json
new file mode 100644
index 0000000..0f0ea5f
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/config.json
@@ -0,0 +1,50 @@
+{
+  "base_solution_folder": "solutions/heterogeneousnodes_equalalpha-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchical",
+  "verbose": 2,
+  "seed": 3865,
+  "max_steps": 100,
+  "min_run_time": 70,
+  "max_run_time": 80,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "MIPGap": 1e-05
+    },
+    "auction": {
+      "eta": 0.0,
+      "epsilon": 0.0001,
+      "zeta": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": true
+    },
+    "coordinator": {
+      "sorting_rule": "product"
+    },
+    "update_neighborhood": false,
+    "start_from_last_pi": false,
+    "use_detailed_pi": false
+  },
+  "checkpoint_interval": 10,
+  "max_iterations": 100,
+  "plot_interval": 100,
+  "patience": 10,
+  "sw_patience": 200,
+  "limits": {
+    "instance_type": "load_existing",
+    "Nn": {
+      "min": 10,
+      "max": 10
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "path": "solutions/heterogeneousnodes_equalalpha-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-16_23-07-20.076828",
+    "load": {
+      "trace_type": "load_existing",
+      "path": "solutions/heterogeneousnodes_equalalpha-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-16_23-07-20.076828"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_13-54-13.841040/experiments.json b/test_instances/2026-06-30_13-54-13.841040/experiments.json
new file mode 100644
index 0000000..10cb8f6
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/experiments.json
@@ -0,0 +1,4 @@
+{
+  "experiments_list": [[10, 3865]],
+  "centralized": ["test_instances/2026-06-30_13-54-13.841040"]
+}
diff --git a/test_instances/2026-06-30_13-54-13.841040/graph/PLANAR b/test_instances/2026-06-30_13-54-13.841040/graph/PLANAR
new file mode 100644
index 0000000..e69de29
diff --git a/test_instances/2026-06-30_13-54-13.841040/graph/graph.png b/test_instances/2026-06-30_13-54-13.841040/graph/graph.png
new file mode 100644
index 0000000..608653f
Binary files /dev/null and b/test_instances/2026-06-30_13-54-13.841040/graph/graph.png differ
diff --git a/test_instances/2026-06-30_13-54-13.841040/input_requests_traces.json b/test_instances/2026-06-30_13-54-13.841040/input_requests_traces.json
new file mode 100644
index 0000000..b32d60f
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/input_requests_traces.json
@@ -0,0 +1,3068 @@
+{
+  "0": {
+    "0": [
+      167,
+      173,
+      146,
+      166,
+      164,
+      165,
+      171,
+      165,
+      181,
+      187,
+      185,
+      185,
+      199,
+      196,
+      192,
+      181,
+      183,
+      175,
+      182,
+      171,
+      169,
+      172,
+      169,
+      173,
+      174,
+      182,
+      181,
+      174,
+      192,
+      203,
+      183,
+      195,
+      180,
+      137,
+      148,
+      166,
+      173,
+      178,
+      188,
+      204,
+      216,
+      225,
+      241,
+      251,
+      262,
+      270,
+      276,
+      293,
+      275,
+      290,
+      263,
+      250,
+      230,
+      205,
+      175,
+      161,
+      150,
+      140,
+      139,
+      107,
+      107,
+      107,
+      102,
+      111,
+      119,
+      113,
+      103,
+      102,
+      108,
+      83,
+      119,
+      113,
+      130,
+      126,
+      140,
+      144,
+      159,
+      175,
+      167,
+      180,
+      176,
+      170,
+      166,
+      169,
+      166,
+      182,
+      181,
+      166,
+      173,
+      173,
+      172,
+      183,
+      196,
+      185,
+      209,
+      205,
+      200,
+      225,
+      219,
+      177
+    ],
+    "1": [
+      167,
+      188,
+      199,
+      202,
+      202,
+      178,
+      180,
+      146,
+      131,
+      108,
+      91,
+      71,
+      66,
+      79,
+      71,
+      109,
+      126,
+      139,
+      141,
+      169,
+      164,
+      166,
+      164,
+      152,
+      130,
+      116,
+      85,
+      77,
+      56,
+      84,
+      89,
+      110,
+      147,
+      215,
+      193,
+      183,
+      160,
+      169,
+      153,
+      157,
+      151,
+      144,
+      147,
+      142,
+      144,
+      125,
+      149,
+      131,
+      145,
+      118,
+      125,
+      131,
+      110,
+      124,
+      111,
+      104,
+      97,
+      111,
+      102,
+      96,
+      103,
+      113,
+      102,
+      92,
+      104,
+      100,
+      268,
+      246,
+      223,
+      222,
+      182,
+      168,
+      135,
+      130,
+      114,
+      101,
+      97,
+      88,
+      83,
+      78,
+      80,
+      92,
+      113,
+      120,
+      135,
+      136,
+      144,
+      166,
+      166,
+      190,
+      191,
+      195,
+      200,
+      207,
+      195,
+      187,
+      185,
+      172,
+      167,
+      193
+    ],
+    "2": [
+      156,
+      160,
+      153,
+      151,
+      151,
+      169,
+      158,
+      173,
+      177,
+      180,
+      192,
+      187,
+      196,
+      188,
+      211,
+      178,
+      189,
+      176,
+      176,
+      170,
+      170,
+      167,
+      175,
+      179,
+      166,
+      176,
+      190,
+      181,
+      189,
+      192,
+      189,
+      193,
+      204,
+      147,
+      169,
+      167,
+      191,
+      190,
+      205,
+      210,
+      224,
+      226,
+      236,
+      242,
+      260,
+      275,
+      286,
+      279,
+      275,
+      257,
+      260,
+      241,
+      202,
+      188,
+      167,
+      165,
+      119,
+      126,
+      102,
+      113,
+      92,
+      111,
+      96,
+      129,
+      102,
+      127,
+      209,
+      231,
+      238,
+      251,
+      254,
+      241,
+      229,
+      192,
+      168,
+      119,
+      92,
+      99,
+      90,
+      94,
+      122,
+      160,
+      151,
+      169,
+      198,
+      196,
+      205,
+      191,
+      174,
+      160,
+      134,
+      96,
+      97,
+      78,
+      60,
+      71,
+      86,
+      110,
+      126,
+      196
+    ],
+    "3": [
+      170,
+      152,
+      161,
+      153,
+      143,
+      156,
+      155,
+      159,
+      164,
+      176,
+      167,
+      174,
+      173,
+      187,
+      187,
+      184,
+      186,
+      175,
+      183,
+      171,
+      181,
+      184,
+      170,
+      179,
+      181,
+      191,
+      205,
+      202,
+      217,
+      198,
+      208,
+      230,
+      230,
+      203,
+      203,
+      208,
+      184,
+      195,
+      186,
+      181,
+      168,
+      165,
+      155,
+      156,
+      183,
+      164,
+      182,
+      157,
+      183,
+      171,
+      166,
+      176,
+      138,
+      162,
+      156,
+      129,
+      128,
+      99,
+      129,
+      116,
+      114,
+      96,
+      111,
+      107,
+      109,
+      86,
+      98,
+      93,
+      85,
+      84,
+      70,
+      96,
+      91,
+      108,
+      117,
+      129,
+      135,
+      134,
+      165,
+      170,
+      170,
+      180,
+      202,
+      197,
+      191,
+      186,
+      196,
+      194,
+      211,
+      191,
+      194,
+      195,
+      181,
+      180,
+      186,
+      180,
+      185,
+      163,
+      151,
+      235
+    ],
+    "4": [
+      160,
+      156,
+      158,
+      154,
+      157,
+      154,
+      170,
+      167,
+      177,
+      174,
+      185,
+      189,
+      189,
+      195,
+      191,
+      191,
+      190,
+      196,
+      186,
+      182,
+      185,
+      173,
+      176,
+      172,
+      181,
+      181,
+      182,
+      195,
+      196,
+      197,
+      191,
+      182,
+      199,
+      248,
+      247,
+      224,
+      227,
+      207,
+      200,
+      196,
+      176,
+      174,
+      137,
+      146,
+      130,
+      125,
+      117,
+      107,
+      98,
+      105,
+      128,
+      116,
+      149,
+      179,
+      173,
+      195,
+      234,
+      256,
+      283,
+      292,
+      289,
+      306,
+      316,
+      305,
+      290,
+      267,
+      249,
+      251,
+      255,
+      251,
+      256,
+      247,
+      256,
+      250,
+      261,
+      261,
+      255,
+      253,
+      249,
+      231,
+      222,
+      203,
+      205,
+      172,
+      171,
+      151,
+      136,
+      121,
+      119,
+      94,
+      93,
+      91,
+      89,
+      98,
+      88,
+      85,
+      91,
+      73,
+      62,
+      203
+    ],
+    "5": [
+      160,
+      146,
+      158,
+      158,
+      152,
+      147,
+      152,
+      151,
+      159,
+      161,
+      169,
+      170,
+      169,
+      185,
+      179,
+      187,
+      170,
+      170,
+      173,
+      173,
+      176,
+      176,
+      182,
+      181,
+      179,
+      194,
+      205,
+      206,
+      226,
+      231,
+      246,
+      251,
+      235,
+      159,
+      182,
+      192,
+      201,
+      199,
+      214,
+      225,
+      221,
+      232,
+      255,
+      244,
+      241,
+      257,
+      245,
+      239,
+      222,
+      226,
+      195,
+      185,
+      198,
+      122,
+      128,
+      127,
+      104,
+      95,
+      110,
+      101,
+      118,
+      130,
+      135,
+      142,
+      154,
+      176,
+      105,
+      97,
+      100,
+      74,
+      83,
+      88,
+      81,
+      86,
+      98,
+      119,
+      128,
+      137,
+      142,
+      157,
+      175,
+      168,
+      166,
+      185,
+      180,
+      193,
+      185,
+      191,
+      189,
+      191,
+      200,
+      186,
+      188,
+      189,
+      187,
+      181,
+      183,
+      179,
+      187,
+      165
+    ],
+    "6": [
+      170,
+      151,
+      161,
+      154,
+      165,
+      169,
+      162,
+      170,
+      177,
+      176,
+      171,
+      186,
+      203,
+      193,
+      190,
+      191,
+      189,
+      181,
+      179,
+      178,
+      157,
+      157,
+      159,
+      163,
+      158,
+      157,
+      163,
+      162,
+      142,
+      155,
+      144,
+      144,
+      129,
+      113,
+      99,
+      83,
+      81,
+      83,
+      79,
+      80,
+      91,
+      84,
+      80,
+      96,
+      95,
+      120,
+      115,
+      139,
+      147,
+      176,
+      166,
+      194,
+      189,
+      219,
+      218,
+      242,
+      252,
+      242,
+      248,
+      268,
+      287,
+      266,
+      283,
+      301,
+      306,
+      294,
+      176,
+      183,
+      209,
+      225,
+      239,
+      239,
+      248,
+      270,
+      248,
+      231,
+      217,
+      184,
+      170,
+      150,
+      122,
+      94,
+      76,
+      72,
+      71,
+      82,
+      80,
+      102,
+      106,
+      126,
+      145,
+      175,
+      172,
+      184,
+      192,
+      201,
+      197,
+      201,
+      190,
+      84
+    ],
+    "7": [
+      172,
+      181,
+      164,
+      164,
+      164,
+      173,
+      154,
+      172,
+      173,
+      180,
+      197,
+      200,
+      196,
+      184,
+      192,
+      191,
+      174,
+      189,
+      173,
+      160,
+      153,
+      154,
+      162,
+      148,
+      158,
+      144,
+      132,
+      147,
+      143,
+      140,
+      150,
+      134,
+      132,
+      173,
+      157,
+      146,
+      148,
+      133,
+      101,
+      113,
+      103,
+      110,
+      113,
+      112,
+      114,
+      105,
+      92,
+      113,
+      115,
+      110,
+      107,
+      100,
+      119,
+      112,
+      122,
+      131,
+      137,
+      130,
+      114,
+      144,
+      139,
+      149,
+      150,
+      144,
+      164,
+      182,
+      129,
+      106,
+      103,
+      112,
+      85,
+      86,
+      83,
+      71,
+      86,
+      96,
+      106,
+      106,
+      105,
+      122,
+      117,
+      128,
+      135,
+      140,
+      143,
+      144,
+      160,
+      159,
+      165,
+      172,
+      173,
+      189,
+      179,
+      193,
+      205,
+      213,
+      209,
+      212,
+      215,
+      85
+    ],
+    "8": [
+      177,
+      188,
+      202,
+      198,
+      200,
+      182,
+      194,
+      176,
+      142,
+      132,
+      122,
+      110,
+      79,
+      65,
+      56,
+      62,
+      75,
+      79,
+      98,
+      120,
+      151,
+      155,
+      169,
+      175,
+      185,
+      179,
+      185,
+      182,
+      158,
+      141,
+      113,
+      104,
+      99,
+      122,
+      136,
+      156,
+      179,
+      195,
+      215,
+      214,
+      218,
+      207,
+      205,
+      180,
+      149,
+      135,
+      96,
+      113,
+      96,
+      96,
+      137,
+      163,
+      210,
+      245,
+      278,
+      297,
+      313,
+      318,
+      281,
+      266,
+      230,
+      203,
+      170,
+      134,
+      109,
+      110,
+      134,
+      152,
+      144,
+      157,
+      154,
+      168,
+      180,
+      196,
+      190,
+      209,
+      217,
+      226,
+      238,
+      222,
+      234,
+      222,
+      231,
+      220,
+      205,
+      193,
+      189,
+      195,
+      179,
+      195,
+      189,
+      188,
+      202,
+      205,
+      194,
+      194,
+      188,
+      194,
+      206,
+      229
+    ],
+    "9": [
+      167,
+      168,
+      162,
+      164,
+      165,
+      169,
+      168,
+      185,
+      181,
+      188,
+      184,
+      191,
+      192,
+      192,
+      195,
+      190,
+      183,
+      183,
+      173,
+      168,
+      158,
+      161,
+      138,
+      140,
+      150,
+      143,
+      137,
+      140,
+      145,
+      123,
+      150,
+      122,
+      108,
+      146,
+      130,
+      138,
+      120,
+      115,
+      123,
+      83,
+      96,
+      96,
+      93,
+      95,
+      87,
+      88,
+      107,
+      93,
+      108,
+      114,
+      116,
+      109,
+      119,
+      107,
+      135,
+      112,
+      130,
+      146,
+      156,
+      161,
+      185,
+      184,
+      197,
+      200,
+      207,
+      208,
+      191,
+      203,
+      199,
+      205,
+      221,
+      218,
+      231,
+      235,
+      241,
+      256,
+      257,
+      259,
+      254,
+      259,
+      245,
+      246,
+      218,
+      220,
+      202,
+      201,
+      189,
+      179,
+      182,
+      172,
+      172,
+      165,
+      159,
+      145,
+      148,
+      147,
+      139,
+      135,
+      139,
+      96
+    ]
+  },
+  "1": {
+    "0": [
+      50,
+      58,
+      60,
+      65,
+      62,
+      59,
+      53,
+      46,
+      41,
+      33,
+      25,
+      21,
+      23,
+      21,
+      25,
+      33,
+      38,
+      43,
+      53,
+      51,
+      52,
+      51,
+      45,
+      43,
+      34,
+      32,
+      24,
+      24,
+      23,
+      25,
+      32,
+      41,
+      47,
+      58,
+      64,
+      68,
+      69,
+      68,
+      79,
+      77,
+      80,
+      81,
+      80,
+      78,
+      77,
+      71,
+      63,
+      65,
+      62,
+      50,
+      53,
+      53,
+      43,
+      37,
+      39,
+      33,
+      23,
+      30,
+      27,
+      28,
+      29,
+      32,
+      23,
+      32,
+      36,
+      35,
+      42,
+      48,
+      46,
+      44,
+      56,
+      47,
+      52,
+      54,
+      50,
+      53,
+      53,
+      51,
+      52,
+      49,
+      51,
+      55,
+      54,
+      55,
+      56,
+      57,
+      60,
+      63,
+      67,
+      61,
+      67,
+      64,
+      66,
+      67,
+      67,
+      69,
+      65,
+      67,
+      66,
+      74
+    ],
+    "1": [
+      54,
+      45,
+      50,
+      45,
+      43,
+      49,
+      47,
+      45,
+      50,
+      48,
+      52,
+      52,
+      53,
+      54,
+      54,
+      53,
+      51,
+      54,
+      52,
+      52,
+      54,
+      53,
+      53,
+      55,
+      62,
+      59,
+      61,
+      62,
+      65,
+      67,
+      69,
+      67,
+      74,
+      26,
+      35,
+      29,
+      32,
+      33,
+      35,
+      35,
+      39,
+      45,
+      48,
+      47,
+      55,
+      55,
+      59,
+      61,
+      64,
+      71,
+      68,
+      73,
+      76,
+      75,
+      78,
+      80,
+      80,
+      82,
+      76,
+      76,
+      73,
+      68,
+      68,
+      61,
+      50,
+      49,
+      68,
+      54,
+      48,
+      38,
+      28,
+      28,
+      19,
+      28,
+      29,
+      37,
+      42,
+      47,
+      52,
+      56,
+      58,
+      59,
+      53,
+      57,
+      49,
+      45,
+      35,
+      30,
+      24,
+      25,
+      21,
+      21,
+      26,
+      23,
+      35,
+      42,
+      49,
+      60,
+      63,
+      56
+    ],
+    "2": [
+      54,
+      45,
+      48,
+      49,
+      53,
+      50,
+      52,
+      54,
+      54,
+      56,
+      58,
+      57,
+      59,
+      57,
+      58,
+      58,
+      59,
+      52,
+      53,
+      50,
+      49,
+      47,
+      44,
+      46,
+      44,
+      39,
+      38,
+      40,
+      38,
+      39,
+      37,
+      37,
+      31,
+      60,
+      55,
+      57,
+      52,
+      46,
+      48,
+      45,
+      45,
+      38,
+      36,
+      30,
+      30,
+      28,
+      26,
+      26,
+      26,
+      30,
+      27,
+      26,
+      26,
+      28,
+      24,
+      30,
+      28,
+      30,
+      34,
+      34,
+      29,
+      38,
+      38,
+      35,
+      38,
+      37,
+      34,
+      37,
+      34,
+      39,
+      35,
+      39,
+      42,
+      40,
+      42,
+      41,
+      43,
+      40,
+      47,
+      45,
+      43,
+      43,
+      43,
+      45,
+      49,
+      50,
+      55,
+      56,
+      51,
+      59,
+      63,
+      64,
+      63,
+      68,
+      68,
+      69,
+      67,
+      69,
+      71,
+      30
+    ],
+    "3": [
+      46,
+      51,
+      46,
+      49,
+      49,
+      49,
+      50,
+      51,
+      53,
+      55,
+      56,
+      56,
+      59,
+      58,
+      62,
+      57,
+      54,
+      61,
+      54,
+      51,
+      52,
+      53,
+      52,
+      49,
+      51,
+      51,
+      51,
+      51,
+      53,
+      49,
+      52,
+      49,
+      48,
+      57,
+      62,
+      71,
+      75,
+      82,
+      80,
+      82,
+      79,
+      85,
+      81,
+      76,
+      71,
+      73,
+      62,
+      59,
+      54,
+      49,
+      48,
+      42,
+      39,
+      36,
+      29,
+      28,
+      29,
+      25,
+      26,
+      24,
+      33,
+      29,
+      39,
+      44,
+      40,
+      47,
+      41,
+      49,
+      52,
+      57,
+      61,
+      65,
+      63,
+      60,
+      66,
+      63,
+      64,
+      61,
+      60,
+      57,
+      56,
+      53,
+      53,
+      51,
+      48,
+      44,
+      41,
+      40,
+      33,
+      32,
+      30,
+      27,
+      24,
+      24,
+      23,
+      21,
+      22,
+      23,
+      25,
+      41
+    ],
+    "4": [
+      51,
+      47,
+      43,
+      49,
+      43,
+      43,
+      47,
+      49,
+      48,
+      50,
+      53,
+      52,
+      50,
+      53,
+      51,
+      53,
+      54,
+      53,
+      47,
+      53,
+      51,
+      51,
+      54,
+      56,
+      59,
+      59,
+      59,
+      62,
+      61,
+      66,
+      66,
+      68,
+      72,
+      33,
+      34,
+      24,
+      30,
+      27,
+      31,
+      28,
+      35,
+      38,
+      35,
+      38,
+      40,
+      42,
+      48,
+      45,
+      51,
+      53,
+      59,
+      56,
+      64,
+      71,
+      70,
+      73,
+      77,
+      77,
+      79,
+      77,
+      79,
+      74,
+      74,
+      73,
+      71,
+      71,
+      84,
+      81,
+      84,
+      83,
+      76,
+      84,
+      76,
+      72,
+      72,
+      64,
+      64,
+      57,
+      52,
+      51,
+      51,
+      46,
+      47,
+      41,
+      42,
+      41,
+      37,
+      36,
+      31,
+      32,
+      32,
+      26,
+      34,
+      28,
+      25,
+      22,
+      19,
+      18,
+      22,
+      50
+    ],
+    "5": [
+      48,
+      52,
+      49,
+      43,
+      52,
+      51,
+      53,
+      52,
+      52,
+      55,
+      58,
+      57,
+      61,
+      62,
+      59,
+      60,
+      56,
+      53,
+      51,
+      53,
+      56,
+      51,
+      49,
+      52,
+      52,
+      47,
+      54,
+      53,
+      50,
+      51,
+      52,
+      48,
+      49,
+      60,
+      48,
+      45,
+      34,
+      38,
+      27,
+      26,
+      29,
+      32,
+      44,
+      45,
+      59,
+      58,
+      64,
+      70,
+      71,
+      77,
+      72,
+      75,
+      68,
+      61,
+      57,
+      51,
+      43,
+      35,
+      26,
+      28,
+      22,
+      29,
+      29,
+      32,
+      40,
+      48,
+      47,
+      46,
+      41,
+      31,
+      33,
+      31,
+      28,
+      26,
+      20,
+      23,
+      22,
+      24,
+      21,
+      23,
+      23,
+      29,
+      31,
+      32,
+      36,
+      38,
+      47,
+      47,
+      52,
+      55,
+      57,
+      62,
+      64,
+      66,
+      69,
+      66,
+      70,
+      68,
+      66,
+      37
+    ],
+    "6": [
+      47,
+      51,
+      50,
+      48,
+      46,
+      48,
+      49,
+      47,
+      51,
+      57,
+      54,
+      57,
+      58,
+      56,
+      56,
+      55,
+      54,
+      52,
+      54,
+      53,
+      54,
+      49,
+      55,
+      54,
+      52,
+      57,
+      55,
+      55,
+      59,
+      60,
+      57,
+      58,
+      59,
+      74,
+      70,
+      67,
+      66,
+      63,
+      58,
+      56,
+      54,
+      50,
+      45,
+      44,
+      37,
+      36,
+      38,
+      35,
+      32,
+      30,
+      32,
+      28,
+      28,
+      30,
+      28,
+      29,
+      26,
+      28,
+      31,
+      24,
+      30,
+      26,
+      22,
+      26,
+      29,
+      25,
+      37,
+      46,
+      41,
+      48,
+      49,
+      48,
+      50,
+      45,
+      54,
+      50,
+      48,
+      51,
+      50,
+      51,
+      50,
+      45,
+      54,
+      50,
+      51,
+      58,
+      55,
+      59,
+      64,
+      64,
+      62,
+      67,
+      68,
+      66,
+      65,
+      69,
+      67,
+      68,
+      62,
+      71
+    ],
+    "7": [
+      48,
+      54,
+      51,
+      47,
+      46,
+      49,
+      51,
+      53,
+      55,
+      55,
+      57,
+      61,
+      59,
+      62,
+      59,
+      57,
+      56,
+      55,
+      56,
+      51,
+      47,
+      52,
+      47,
+      43,
+      45,
+      47,
+      49,
+      47,
+      47,
+      46,
+      44,
+      43,
+      40,
+      30,
+      31,
+      28,
+      27,
+      28,
+      28,
+      34,
+      28,
+      30,
+      32,
+      37,
+      36,
+      43,
+      45,
+      47,
+      44,
+      48,
+      53,
+      56,
+      63,
+      66,
+      68,
+      70,
+      79,
+      75,
+      78,
+      77,
+      79,
+      79,
+      75,
+      70,
+      73,
+      69,
+      67,
+      65,
+      71,
+      70,
+      73,
+      67,
+      73,
+      76,
+      66,
+      66,
+      62,
+      65,
+      60,
+      62,
+      56,
+      58,
+      56,
+      59,
+      58,
+      57,
+      58,
+      54,
+      61,
+      55,
+      56,
+      56,
+      52,
+      53,
+      49,
+      48,
+      49,
+      44,
+      40,
+      24
+    ],
+    "8": [
+      50,
+      47,
+      50,
+      50,
+      46,
+      46,
+      45,
+      50,
+      52,
+      54,
+      56,
+      59,
+      57,
+      57,
+      58,
+      59,
+      59,
+      55,
+      56,
+      54,
+      51,
+      52,
+      53,
+      53,
+      52,
+      55,
+      55,
+      55,
+      57,
+      57,
+      54,
+      57,
+      55,
+      84,
+      79,
+      85,
+      85,
+      86,
+      82,
+      80,
+      69,
+      66,
+      62,
+      63,
+      52,
+      45,
+      39,
+      36,
+      32,
+      29,
+      23,
+      24,
+      22,
+      23,
+      28,
+      31,
+      37,
+      42,
+      50,
+      55,
+      57,
+      59,
+      69,
+      73,
+      68,
+      70,
+      53,
+      50,
+      57,
+      55,
+      57,
+      55,
+      57,
+      54,
+      55,
+      54,
+      56,
+      54,
+      55,
+      55,
+      57,
+      57,
+      54,
+      56,
+      56,
+      57,
+      59,
+      61,
+      62,
+      64,
+      63,
+      65,
+      60,
+      64,
+      61,
+      64,
+      61,
+      61,
+      60,
+      55
+    ],
+    "9": [
+      53,
+      53,
+      56,
+      58,
+      62,
+      59,
+      57,
+      55,
+      47,
+      42,
+      35,
+      31,
+      24,
+      21,
+      21,
+      18,
+      22,
+      24,
+      27,
+      35,
+      36,
+      44,
+      51,
+      54,
+      53,
+      57,
+      56,
+      55,
+      50,
+      42,
+      39,
+      34,
+      27,
+      22,
+      26,
+      29,
+      33,
+      32,
+      35,
+      40,
+      44,
+      39,
+      40,
+      44,
+      48,
+      52,
+      60,
+      59,
+      67,
+      67,
+      66,
+      72,
+      74,
+      75,
+      81,
+      80,
+      79,
+      79,
+      77,
+      80,
+      71,
+      70,
+      67,
+      59,
+      57,
+      52,
+      30,
+      28,
+      29,
+      37,
+      35,
+      40,
+      44,
+      46,
+      48,
+      51,
+      49,
+      54,
+      53,
+      54,
+      58,
+      57,
+      57,
+      58,
+      59,
+      56,
+      56,
+      57,
+      59,
+      56,
+      52,
+      52,
+      46,
+      44,
+      41,
+      33,
+      33,
+      25,
+      28,
+      65
+    ]
+  },
+  "2": {
+    "0": [
+      124,
+      123,
+      123,
+      115,
+      115,
+      112,
+      114,
+      119,
+      117,
+      137,
+      135,
+      142,
+      141,
+      141,
+      142,
+      143,
+      143,
+      139,
+      142,
+      139,
+      141,
+      136,
+      139,
+      147,
+      153,
+      156,
+      162,
+      175,
+      162,
+      165,
+      165,
+      144,
+      155,
+      177,
+      183,
+      170,
+      178,
+      189,
+      178,
+      162,
+      174,
+      173,
+      171,
+      163,
+      169,
+      152,
+      159,
+      150,
+      140,
+      148,
+      138,
+      133,
+      130,
+      134,
+      130,
+      119,
+      123,
+      117,
+      109,
+      111,
+      101,
+      106,
+      96,
+      82,
+      104,
+      90,
+      58,
+      68,
+      68,
+      67,
+      68,
+      70,
+      74,
+      73,
+      78,
+      82,
+      87,
+      86,
+      93,
+      96,
+      93,
+      113,
+      123,
+      127,
+      124,
+      126,
+      133,
+      134,
+      137,
+      137,
+      137,
+      156,
+      164,
+      171,
+      171,
+      176,
+      186,
+      208,
+      200,
+      92
+    ],
+    "1": [
+      132,
+      116,
+      116,
+      117,
+      118,
+      115,
+      123,
+      111,
+      129,
+      140,
+      143,
+      137,
+      153,
+      157,
+      148,
+      144,
+      152,
+      136,
+      138,
+      137,
+      132,
+      142,
+      137,
+      151,
+      143,
+      160,
+      160,
+      150,
+      158,
+      154,
+      153,
+      142,
+      138,
+      144,
+      153,
+      148,
+      146,
+      142,
+      138,
+      132,
+      118,
+      121,
+      116,
+      113,
+      99,
+      99,
+      104,
+      96,
+      105,
+      87,
+      91,
+      99,
+      100,
+      61,
+      81,
+      85,
+      72,
+      88,
+      77,
+      85,
+      75,
+      80,
+      98,
+      96,
+      86,
+      89,
+      67,
+      61,
+      56,
+      63,
+      59,
+      72,
+      65,
+      64,
+      65,
+      62,
+      76,
+      82,
+      85,
+      81,
+      90,
+      93,
+      104,
+      102,
+      98,
+      111,
+      104,
+      110,
+      118,
+      114,
+      118,
+      133,
+      142,
+      137,
+      173,
+      167,
+      176,
+      175,
+      183,
+      145
+    ],
+    "2": [
+      124,
+      119,
+      125,
+      124,
+      112,
+      121,
+      121,
+      132,
+      144,
+      144,
+      156,
+      149,
+      163,
+      162,
+      154,
+      152,
+      143,
+      145,
+      143,
+      133,
+      141,
+      132,
+      133,
+      129,
+      130,
+      125,
+      136,
+      120,
+      120,
+      118,
+      110,
+      105,
+      95,
+      92,
+      90,
+      117,
+      118,
+      143,
+      156,
+      166,
+      183,
+      200,
+      213,
+      204,
+      216,
+      223,
+      214,
+      215,
+      213,
+      200,
+      199,
+      185,
+      195,
+      178,
+      165,
+      159,
+      147,
+      148,
+      124,
+      120,
+      103,
+      97,
+      81,
+      89,
+      92,
+      87,
+      183,
+      185,
+      193,
+      167,
+      163,
+      161,
+      157,
+      165,
+      151,
+      143,
+      143,
+      125,
+      130,
+      116,
+      108,
+      102,
+      86,
+      90,
+      65,
+      75,
+      69,
+      67,
+      54,
+      61,
+      71,
+      58,
+      66,
+      83,
+      88,
+      98,
+      93,
+      102,
+      133,
+      60
+    ],
+    "3": [
+      114,
+      118,
+      110,
+      120,
+      115,
+      123,
+      118,
+      126,
+      119,
+      137,
+      139,
+      143,
+      147,
+      146,
+      144,
+      147,
+      142,
+      140,
+      136,
+      139,
+      145,
+      136,
+      144,
+      149,
+      151,
+      155,
+      155,
+      161,
+      175,
+      162,
+      147,
+      153,
+      145,
+      150,
+      141,
+      146,
+      143,
+      142,
+      129,
+      135,
+      122,
+      123,
+      117,
+      109,
+      109,
+      108,
+      104,
+      93,
+      91,
+      98,
+      86,
+      87,
+      77,
+      93,
+      87,
+      80,
+      72,
+      77,
+      88,
+      83,
+      105,
+      83,
+      81,
+      94,
+      112,
+      104,
+      75,
+      72,
+      77,
+      92,
+      101,
+      106,
+      111,
+      136,
+      151,
+      156,
+      169,
+      179,
+      181,
+      198,
+      196,
+      203,
+      194,
+      188,
+      189,
+      175,
+      171,
+      167,
+      168,
+      152,
+      139,
+      136,
+      116,
+      102,
+      102,
+      83,
+      87,
+      86,
+      69,
+      131
+    ],
+    "4": [
+      127,
+      120,
+      112,
+      115,
+      114,
+      116,
+      112,
+      129,
+      133,
+      134,
+      143,
+      155,
+      144,
+      147,
+      142,
+      142,
+      149,
+      145,
+      142,
+      136,
+      139,
+      145,
+      141,
+      143,
+      154,
+      152,
+      156,
+      158,
+      164,
+      156,
+      150,
+      137,
+      140,
+      125,
+      116,
+      123,
+      108,
+      98,
+      91,
+      98,
+      89,
+      90,
+      70,
+      76,
+      68,
+      75,
+      69,
+      73,
+      65,
+      78,
+      73,
+      79,
+      84,
+      76,
+      89,
+      107,
+      101,
+      107,
+      127,
+      119,
+      131,
+      146,
+      164,
+      158,
+      155,
+      168,
+      154,
+      171,
+      166,
+      179,
+      187,
+      180,
+      182,
+      184,
+      184,
+      210,
+      201,
+      196,
+      199,
+      203,
+      203,
+      187,
+      185,
+      183,
+      171,
+      167,
+      164,
+      146,
+      144,
+      137,
+      144,
+      136,
+      120,
+      121,
+      112,
+      110,
+      113,
+      101,
+      103,
+      141
+    ],
+    "5": [
+      129,
+      127,
+      134,
+      140,
+      141,
+      149,
+      150,
+      145,
+      147,
+      140,
+      132,
+      116,
+      100,
+      91,
+      80,
+      67,
+      46,
+      52,
+      51,
+      55,
+      53,
+      58,
+      79,
+      85,
+      111,
+      121,
+      136,
+      149,
+      158,
+      167,
+      166,
+      163,
+      153,
+      61,
+      65,
+      53,
+      58,
+      57,
+      89,
+      79,
+      100,
+      102,
+      109,
+      124,
+      134,
+      152,
+      152,
+      166,
+      187,
+      199,
+      201,
+      213,
+      214,
+      228,
+      228,
+      246,
+      250,
+      235,
+      235,
+      233,
+      243,
+      228,
+      228,
+      217,
+      202,
+      181,
+      157,
+      150,
+      132,
+      122,
+      112,
+      105,
+      102,
+      90,
+      91,
+      75,
+      71,
+      64,
+      69,
+      73,
+      70,
+      70,
+      61,
+      66,
+      73,
+      74,
+      82,
+      84,
+      89,
+      99,
+      113,
+      113,
+      130,
+      148,
+      156,
+      173,
+      177,
+      188,
+      215,
+      147
+    ],
+    "6": [
+      136,
+      138,
+      153,
+      153,
+      150,
+      143,
+      132,
+      122,
+      95,
+      75,
+      55,
+      51,
+      48,
+      56,
+      72,
+      84,
+      100,
+      125,
+      125,
+      133,
+      137,
+      134,
+      120,
+      105,
+      91,
+      78,
+      66,
+      57,
+      49,
+      55,
+      75,
+      97,
+      120,
+      148,
+      153,
+      148,
+      156,
+      141,
+      133,
+      138,
+      141,
+      142,
+      120,
+      116,
+      116,
+      109,
+      107,
+      106,
+      109,
+      98,
+      98,
+      91,
+      101,
+      89,
+      74,
+      78,
+      92,
+      88,
+      90,
+      88,
+      75,
+      78,
+      89,
+      82,
+      86,
+      90,
+      190,
+      179,
+      191,
+      173,
+      170,
+      179,
+      165,
+      167,
+      157,
+      151,
+      142,
+      144,
+      114,
+      117,
+      111,
+      97,
+      105,
+      83,
+      84,
+      72,
+      80,
+      71,
+      69,
+      61,
+      53,
+      53,
+      79,
+      69,
+      84,
+      87,
+      88,
+      85,
+      106,
+      146
+    ],
+    "7": [
+      124,
+      125,
+      125,
+      126,
+      131,
+      126,
+      131,
+      136,
+      150,
+      150,
+      159,
+      161,
+      162,
+      151,
+      151,
+      147,
+      138,
+      119,
+      114,
+      111,
+      90,
+      95,
+      97,
+      87,
+      87,
+      77,
+      82,
+      69,
+      67,
+      62,
+      63,
+      67,
+      55,
+      67,
+      70,
+      59,
+      69,
+      65,
+      75,
+      82,
+      75,
+      80,
+      92,
+      102,
+      105,
+      122,
+      139,
+      163,
+      152,
+      169,
+      183,
+      183,
+      205,
+      223,
+      225,
+      217,
+      230,
+      247,
+      250,
+      238,
+      253,
+      251,
+      259,
+      245,
+      237,
+      226,
+      157,
+      167,
+      179,
+      188,
+      183,
+      177,
+      182,
+      163,
+      152,
+      132,
+      100,
+      101,
+      78,
+      80,
+      76,
+      65,
+      69,
+      77,
+      109,
+      116,
+      133,
+      148,
+      167,
+      186,
+      190,
+      201,
+      192,
+      190,
+      177,
+      173,
+      151,
+      130,
+      97,
+      138
+    ],
+    "8": [
+      127,
+      150,
+      149,
+      141,
+      150,
+      141,
+      140,
+      116,
+      101,
+      75,
+      61,
+      56,
+      54,
+      54,
+      80,
+      82,
+      101,
+      112,
+      130,
+      137,
+      137,
+      145,
+      121,
+      112,
+      83,
+      89,
+      60,
+      51,
+      54,
+      56,
+      70,
+      95,
+      115,
+      133,
+      126,
+      129,
+      122,
+      123,
+      111,
+      108,
+      107,
+      93,
+      105,
+      99,
+      109,
+      87,
+      93,
+      87,
+      76,
+      72,
+      74,
+      87,
+      65,
+      72,
+      77,
+      75,
+      75,
+      75,
+      84,
+      96,
+      91,
+      97,
+      93,
+      116,
+      111,
+      145,
+      136,
+      123,
+      104,
+      98,
+      85,
+      83,
+      73,
+      57,
+      65,
+      76,
+      80,
+      97,
+      108,
+      99,
+      121,
+      147,
+      143,
+      162,
+      170,
+      185,
+      184,
+      197,
+      187,
+      189,
+      180,
+      173,
+      162,
+      156,
+      119,
+      114,
+      108,
+      105,
+      75,
+      143
+    ],
+    "9": [
+      123,
+      123,
+      110,
+      108,
+      112,
+      116,
+      120,
+      121,
+      124,
+      128,
+      135,
+      149,
+      148,
+      155,
+      145,
+      149,
+      143,
+      147,
+      138,
+      138,
+      146,
+      136,
+      149,
+      151,
+      154,
+      147,
+      146,
+      168,
+      152,
+      163,
+      158,
+      155,
+      143,
+      162,
+      161,
+      165,
+      161,
+      159,
+      159,
+      158,
+      150,
+      134,
+      145,
+      155,
+      132,
+      133,
+      117,
+      109,
+      121,
+      109,
+      116,
+      102,
+      89,
+      104,
+      103,
+      93,
+      97,
+      77,
+      74,
+      85,
+      83,
+      92,
+      71,
+      79,
+      74,
+      79,
+      81,
+      83,
+      93,
+      111,
+      132,
+      126,
+      148,
+      161,
+      164,
+      173,
+      190,
+      187,
+      201,
+      197,
+      191,
+      183,
+      191,
+      180,
+      175,
+      158,
+      139,
+      134,
+      126,
+      124,
+      114,
+      100,
+      88,
+      82,
+      78,
+      78,
+      80,
+      79,
+      77,
+      115
+    ]
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_13-54-13.841040/load_limits.json b/test_instances/2026-06-30_13-54-13.841040/load_limits.json
new file mode 100644
index 0000000..95e0d8e
--- /dev/null
+++ b/test_instances/2026-06-30_13-54-13.841040/load_limits.json
@@ -0,0 +1,39 @@
+{
+  "0": {
+    "0": null,
+    "1": null,
+    "2": null,
+    "3": null,
+    "4": null,
+    "5": null,
+    "6": null,
+    "7": null,
+    "8": null,
+    "9": null
+  },
+  "1": {
+    "0": 36.825,
+    "1": 150.3,
+    "2": 362.121,
+    "3": 362.121,
+    "4": 362.121,
+    "5": 634.461,
+    "6": 634.461,
+    "7": 846.281,
+    "8": 846.281,
+    "9": 846.281
+  },
+  "2": {
+    "0": 92.979,
+    "1": 374.918,
+    "2": 901.203,
+    "3": 901.203,
+    "4": 901.203,
+    "5": 1577.855,
+    "6": 1577.855,
+    "7": 2104.14,
+    "8": 2104.14,
+    "9": 2104.14
+  },
+  "load_existing": "solutions/heterogeneousnodes_equalalpha-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-16_23-07-20.076828"
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloaded_processing.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloaded_processing.csv
new file mode 100644
index 0000000..3816979
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11680911680911699,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.33175355450237376,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6363636363636362,0.4688995215311018,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0995260663507107,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9166666666666663,0.0,0.0,0.0,0.0,0.023504273504275863,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18947368421052602,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,4.8544159544159555,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,0.0,0.0,0.0,0.0,31.46445497630333,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.4889952153110038,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2909090909090901,0.27368421052631153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,1.4270655270655275,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3127962085308127,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,2.5047008547008556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.19905213270143918,0.0,0.0,7.0,1.2274881516587612,1.0,0.0,1.388625592417057,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22105263157895008,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.99999999999997,3.0,24.0,18.0,0.0,0.0,0.0,1.1232227488152091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,1.7635327635327638,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,1.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7345971563981095,0.0,0.0,10.0,0.0,0.0,0.0,28.0,9.0,0.7725118483412388,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,6.0,0.0,0.0,3.431578947368422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1452991452991466,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,24.0,0.0,0.0,0.0,0.0,0.0,0.0,56.53554502369667,0.0,10.488151658767734,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7090909090909099,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.717948717948719,4.0,2.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5023696682464518,0.0,0.0,30.0,0.0,0.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5726495726495724,19.649572649572644,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.3093494183541345,26.436018957345972,0.0,13.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.422364672364656,4.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.274881516587687,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloading.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloading.csv
new file mode 100644
index 0000000..1b78adf
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/detailed_offloading.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.0,0.11680911680911699,0.5584045584045585,0.3504273504273563,0.14529914529914834,0.0,0.14529914529914834,1.9166666666666663,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,1.7635327635327638,2.1452991452991466,1.717948717948719,0.5726495726495724,12.422364672364656,0.16587677725118688,0.33175355450237376,0.0,1.1232227488151665,0.3981042654028428,0.0,0.0995260663507107,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.7345971563981095,1.3636363636363635,0.5023696682464518,7.3093494183541345,2.274881516587687,0.0,0.0,0.6363636363636362,0.04210526315789487,0.10526315789473628,0.0,0.16842105263157947,0.10526315789473628,0.0,0.18947368421052602,0.0,0.0,1.0,0.0,0.43157894736842195,1.0803827751196171,1.0803827751196171,1.0803827751196171,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,19.649572649572644,4.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.436018957345972,0.0,0.0,0.0,0.4688995215311018,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,3.4889952153110038,0.0,0.0,0.0,6.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,9.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,24.0,30.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,3.431578947368422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.023504273504275863,0.25883190883190804,0.0,0.09999999999999999,0.09999999999999999,0.25883190883190804,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.8909952606635159,0.3127962085308127,0.19905213270143918,18.99999999999997,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,28.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,18.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.8544159544159555,1.4270655270655275,2.5047008547008556,0.0,1.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2274881516587612,0.0,0.7725118483412388,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.46445497630333,0.0,1.0,0.0,0.0,56.53554502369667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2909090909090901,0.0,0.0,0.0,0.0,0.7090909090909099,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,1.388625592417057,1.1232227488152091,0.0,10.488151658767734,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27368421052631153,0.22105263157895008,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/local_processing.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/local_processing.csv
new file mode 100644
index 0000000..4bbd96f
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/local_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,15.0,0.0,0.0,15.0,0.0,9.0,30.0,0.0,4.0,0.0,9.0,27.0,33.0,4.0,19.0,36.0,10.0,27.0,36.0,4.0,19.0,9.0,16.0,9.0,63.0,10.0,16.0,54.0,8.0,18.0,0.0,18.0,11.0,92.0,7.0,24.0,74.0,21.0,10.0,98.0,20.0,9.0,49.0,16.0,11.0,55.0,9.0,17.0,59.0,8.0,27.0,34.0,13.0,9.0,71.0,8.0,11.0,80.0,20.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloaded_processing.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloaded_processing.csv
new file mode 100644
index 0000000..bbf6c68
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.11680911680911699,0.33175355450237376,0.0,0.5584045584045585,0.0,1.105263157894738,0.3504273504273563,1.1232227488151665,0.04210526315789487,0.14529914529914834,0.3981042654028428,0.10526315789473628,0.3504273504273563,0.3981042654028428,0.04210526315789487,0.14529914529914834,0.0995260663507107,0.16842105263157947,1.9401709401709422,0.6966824644549732,0.10526315789473628,0.25883190883190804,0.5971563981042607,0.08421052631578974,1.1452991452991483,0.0,0.18947368421052602,4.954415954415955,43.355450236966846,6.053588516746405,1.5270655270655276,0.3127962085308127,0.0,2.763532763532764,10.815165876777257,1.22105263157895,0.25883190883190804,65.12322274881518,0.5052631578947384,4.954415954415955,48.50710900473935,9.863157894736844,2.1452991452991466,92.38733304610076,3.789473684210527,20.71794871794872,39.50236966824645,1.0803827751196171,29.222222222222214,47.74536837570011,1.0803827751196171,17.422364672364658,2.274881516587687,1.0803827751196171
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloading.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloading.csv
new file mode 100644
index 0000000..f66ed94
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/offloading.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+23.0,15.0,6.999999999999998,28.0,27.0,12.0,2.0,0.0,2.0,23.0,77.0,0.0,0.0,0.0,3.5157894736842117,1.0,22.0,0.0,1.0,3.0,0.0,1.0,61.0,0.0,0.0,34.0,0.0,9.97706552706553,2.0,0.0,0.0,89.0,1.0,0.0,0.0,0.0,0.0,24.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/rejections.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/rejections.csv
new file mode 100644
index 0000000..c005988
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/rejections.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,1.7763568394002505e-15,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,15.484210526315788,0.0,0.0,0.0,0.0,0.0,19.0,0.0,0.0,1.0,0.0,0.0,0.0,4.02293447293447,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/replicas.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/replicas.csv
new file mode 100644
index 0000000..24b14ad
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/replicas.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,16.0,0.0,0.0,16.0,0.0,4.0,16.0,0.0,2.0,0.0,6.0,10.0,15.0,2.0,7.0,16.0,5.0,10.0,16.0,2.0,7.0,4.0,8.0,4.0,28.0,5.0,6.0,24.0,4.0,7.0,0.0,9.0,5.0,51.0,6.0,8.0,28.0,9.0,4.0,41.0,9.0,3.0,43.0,7.0,5.0,39.0,8.0,6.0,58.0,5.0,15.0,28.0,6.0,12.0,45.0,4.0,9.0,31.0,9.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/residual_capacity.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/residual_capacity.csv
new file mode 100644
index 0000000..bc7a679
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/residual_capacity.csv
@@ -0,0 +1,2 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,768.0,3328.0,1280.0,6656.0,4096.0,4864.0,6400.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc/70/utilization.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/utilization.csv
new file mode 100644
index 0000000..c5b9b7c
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc/70/utilization.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.78975,0.79125,0.0,0.702,0.0,0.7124999999999999,0.78975,0.7736666666666667,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.78975,0.79125,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.658125,0.79125,0.7916666666666666,0.7799999999999999,0.7912500000000001,0.7916666666666666,0.7521428571428571,0.0,0.7916666666666666,0.5515714285714286,0.5437535014005602,0.3958333333333333,0.7521428571428572,0.7966326530612245,0.7916666666666666,0.6267857142857143,0.7204878048780488,0.7539682539682541,0.7521428571428572,0.34348837209302324,0.7755102040816327,0.5515714285714286,0.4250915750915751,0.3816964285714286,0.7103571428571428,0.3066256157635468,0.5428571428571429,0.4512857142857143,0.3660204081632653,0.7351190476190476,0.1880357142857143,0.47558730158730156,0.6785714285714286,0.30642857142857144,0.7778801843317972,0.7539682539682541
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_detailed_fwd_solution.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_detailed_fwd_solution.csv
new file mode 100644
index 0000000..ac963eb
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_detailed_fwd_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_n1_tot,n0_f0_n2_tot,n0_f0_n3_tot,n0_f0_n4_tot,n0_f0_n5_tot,n0_f0_n6_tot,n0_f0_n7_tot,n0_f0_n8_tot,n0_f0_n9_tot,n0_f0_n10_tot,n0_f0_n11_tot,n0_f0_n12_tot,n0_f0_n13_tot,n0_f0_n14_tot,n0_f0_n15_tot,n0_f0_n16_tot,n0_f0_n17_tot,n0_f0_n18_tot,n0_f0_n19_tot,n0_f1_n1_tot,n0_f1_n2_tot,n0_f1_n3_tot,n0_f1_n4_tot,n0_f1_n5_tot,n0_f1_n6_tot,n0_f1_n7_tot,n0_f1_n8_tot,n0_f1_n9_tot,n0_f1_n10_tot,n0_f1_n11_tot,n0_f1_n12_tot,n0_f1_n13_tot,n0_f1_n14_tot,n0_f1_n15_tot,n0_f1_n16_tot,n0_f1_n17_tot,n0_f1_n18_tot,n0_f1_n19_tot,n0_f2_n1_tot,n0_f2_n2_tot,n0_f2_n3_tot,n0_f2_n4_tot,n0_f2_n5_tot,n0_f2_n6_tot,n0_f2_n7_tot,n0_f2_n8_tot,n0_f2_n9_tot,n0_f2_n10_tot,n0_f2_n11_tot,n0_f2_n12_tot,n0_f2_n13_tot,n0_f2_n14_tot,n0_f2_n15_tot,n0_f2_n16_tot,n0_f2_n17_tot,n0_f2_n18_tot,n0_f2_n19_tot,n1_f0_n0_tot,n1_f0_n2_tot,n1_f0_n3_tot,n1_f0_n4_tot,n1_f0_n5_tot,n1_f0_n6_tot,n1_f0_n7_tot,n1_f0_n8_tot,n1_f0_n9_tot,n1_f0_n10_tot,n1_f0_n11_tot,n1_f0_n12_tot,n1_f0_n13_tot,n1_f0_n14_tot,n1_f0_n15_tot,n1_f0_n16_tot,n1_f0_n17_tot,n1_f0_n18_tot,n1_f0_n19_tot,n1_f1_n0_tot,n1_f1_n2_tot,n1_f1_n3_tot,n1_f1_n4_tot,n1_f1_n5_tot,n1_f1_n6_tot,n1_f1_n7_tot,n1_f1_n8_tot,n1_f1_n9_tot,n1_f1_n10_tot,n1_f1_n11_tot,n1_f1_n12_tot,n1_f1_n13_tot,n1_f1_n14_tot,n1_f1_n15_tot,n1_f1_n16_tot,n1_f1_n17_tot,n1_f1_n18_tot,n1_f1_n19_tot,n1_f2_n0_tot,n1_f2_n2_tot,n1_f2_n3_tot,n1_f2_n4_tot,n1_f2_n5_tot,n1_f2_n6_tot,n1_f2_n7_tot,n1_f2_n8_tot,n1_f2_n9_tot,n1_f2_n10_tot,n1_f2_n11_tot,n1_f2_n12_tot,n1_f2_n13_tot,n1_f2_n14_tot,n1_f2_n15_tot,n1_f2_n16_tot,n1_f2_n17_tot,n1_f2_n18_tot,n1_f2_n19_tot,n2_f0_n0_tot,n2_f0_n1_tot,n2_f0_n3_tot,n2_f0_n4_tot,n2_f0_n5_tot,n2_f0_n6_tot,n2_f0_n7_tot,n2_f0_n8_tot,n2_f0_n9_tot,n2_f0_n10_tot,n2_f0_n11_tot,n2_f0_n12_tot,n2_f0_n13_tot,n2_f0_n14_tot,n2_f0_n15_tot,n2_f0_n16_tot,n2_f0_n17_tot,n2_f0_n18_tot,n2_f0_n19_tot,n2_f1_n0_tot,n2_f1_n1_tot,n2_f1_n3_tot,n2_f1_n4_tot,n2_f1_n5_tot,n2_f1_n6_tot,n2_f1_n7_tot,n2_f1_n8_tot,n2_f1_n9_tot,n2_f1_n10_tot,n2_f1_n11_tot,n2_f1_n12_tot,n2_f1_n13_tot,n2_f1_n14_tot,n2_f1_n15_tot,n2_f1_n16_tot,n2_f1_n17_tot,n2_f1_n18_tot,n2_f1_n19_tot,n2_f2_n0_tot,n2_f2_n1_tot,n2_f2_n3_tot,n2_f2_n4_tot,n2_f2_n5_tot,n2_f2_n6_tot,n2_f2_n7_tot,n2_f2_n8_tot,n2_f2_n9_tot,n2_f2_n10_tot,n2_f2_n11_tot,n2_f2_n12_tot,n2_f2_n13_tot,n2_f2_n14_tot,n2_f2_n15_tot,n2_f2_n16_tot,n2_f2_n17_tot,n2_f2_n18_tot,n2_f2_n19_tot,n3_f0_n0_tot,n3_f0_n1_tot,n3_f0_n2_tot,n3_f0_n4_tot,n3_f0_n5_tot,n3_f0_n6_tot,n3_f0_n7_tot,n3_f0_n8_tot,n3_f0_n9_tot,n3_f0_n10_tot,n3_f0_n11_tot,n3_f0_n12_tot,n3_f0_n13_tot,n3_f0_n14_tot,n3_f0_n15_tot,n3_f0_n16_tot,n3_f0_n17_tot,n3_f0_n18_tot,n3_f0_n19_tot,n3_f1_n0_tot,n3_f1_n1_tot,n3_f1_n2_tot,n3_f1_n4_tot,n3_f1_n5_tot,n3_f1_n6_tot,n3_f1_n7_tot,n3_f1_n8_tot,n3_f1_n9_tot,n3_f1_n10_tot,n3_f1_n11_tot,n3_f1_n12_tot,n3_f1_n13_tot,n3_f1_n14_tot,n3_f1_n15_tot,n3_f1_n16_tot,n3_f1_n17_tot,n3_f1_n18_tot,n3_f1_n19_tot,n3_f2_n0_tot,n3_f2_n1_tot,n3_f2_n2_tot,n3_f2_n4_tot,n3_f2_n5_tot,n3_f2_n6_tot,n3_f2_n7_tot,n3_f2_n8_tot,n3_f2_n9_tot,n3_f2_n10_tot,n3_f2_n11_tot,n3_f2_n12_tot,n3_f2_n13_tot,n3_f2_n14_tot,n3_f2_n15_tot,n3_f2_n16_tot,n3_f2_n17_tot,n3_f2_n18_tot,n3_f2_n19_tot,n4_f0_n0_tot,n4_f0_n1_tot,n4_f0_n2_tot,n4_f0_n3_tot,n4_f0_n5_tot,n4_f0_n6_tot,n4_f0_n7_tot,n4_f0_n8_tot,n4_f0_n9_tot,n4_f0_n10_tot,n4_f0_n11_tot,n4_f0_n12_tot,n4_f0_n13_tot,n4_f0_n14_tot,n4_f0_n15_tot,n4_f0_n16_tot,n4_f0_n17_tot,n4_f0_n18_tot,n4_f0_n19_tot,n4_f1_n0_tot,n4_f1_n1_tot,n4_f1_n2_tot,n4_f1_n3_tot,n4_f1_n5_tot,n4_f1_n6_tot,n4_f1_n7_tot,n4_f1_n8_tot,n4_f1_n9_tot,n4_f1_n10_tot,n4_f1_n11_tot,n4_f1_n12_tot,n4_f1_n13_tot,n4_f1_n14_tot,n4_f1_n15_tot,n4_f1_n16_tot,n4_f1_n17_tot,n4_f1_n18_tot,n4_f1_n19_tot,n4_f2_n0_tot,n4_f2_n1_tot,n4_f2_n2_tot,n4_f2_n3_tot,n4_f2_n5_tot,n4_f2_n6_tot,n4_f2_n7_tot,n4_f2_n8_tot,n4_f2_n9_tot,n4_f2_n10_tot,n4_f2_n11_tot,n4_f2_n12_tot,n4_f2_n13_tot,n4_f2_n14_tot,n4_f2_n15_tot,n4_f2_n16_tot,n4_f2_n17_tot,n4_f2_n18_tot,n4_f2_n19_tot,n5_f0_n0_tot,n5_f0_n1_tot,n5_f0_n2_tot,n5_f0_n3_tot,n5_f0_n4_tot,n5_f0_n6_tot,n5_f0_n7_tot,n5_f0_n8_tot,n5_f0_n9_tot,n5_f0_n10_tot,n5_f0_n11_tot,n5_f0_n12_tot,n5_f0_n13_tot,n5_f0_n14_tot,n5_f0_n15_tot,n5_f0_n16_tot,n5_f0_n17_tot,n5_f0_n18_tot,n5_f0_n19_tot,n5_f1_n0_tot,n5_f1_n1_tot,n5_f1_n2_tot,n5_f1_n3_tot,n5_f1_n4_tot,n5_f1_n6_tot,n5_f1_n7_tot,n5_f1_n8_tot,n5_f1_n9_tot,n5_f1_n10_tot,n5_f1_n11_tot,n5_f1_n12_tot,n5_f1_n13_tot,n5_f1_n14_tot,n5_f1_n15_tot,n5_f1_n16_tot,n5_f1_n17_tot,n5_f1_n18_tot,n5_f1_n19_tot,n5_f2_n0_tot,n5_f2_n1_tot,n5_f2_n2_tot,n5_f2_n3_tot,n5_f2_n4_tot,n5_f2_n6_tot,n5_f2_n7_tot,n5_f2_n8_tot,n5_f2_n9_tot,n5_f2_n10_tot,n5_f2_n11_tot,n5_f2_n12_tot,n5_f2_n13_tot,n5_f2_n14_tot,n5_f2_n15_tot,n5_f2_n16_tot,n5_f2_n17_tot,n5_f2_n18_tot,n5_f2_n19_tot,n6_f0_n0_tot,n6_f0_n1_tot,n6_f0_n2_tot,n6_f0_n3_tot,n6_f0_n4_tot,n6_f0_n5_tot,n6_f0_n7_tot,n6_f0_n8_tot,n6_f0_n9_tot,n6_f0_n10_tot,n6_f0_n11_tot,n6_f0_n12_tot,n6_f0_n13_tot,n6_f0_n14_tot,n6_f0_n15_tot,n6_f0_n16_tot,n6_f0_n17_tot,n6_f0_n18_tot,n6_f0_n19_tot,n6_f1_n0_tot,n6_f1_n1_tot,n6_f1_n2_tot,n6_f1_n3_tot,n6_f1_n4_tot,n6_f1_n5_tot,n6_f1_n7_tot,n6_f1_n8_tot,n6_f1_n9_tot,n6_f1_n10_tot,n6_f1_n11_tot,n6_f1_n12_tot,n6_f1_n13_tot,n6_f1_n14_tot,n6_f1_n15_tot,n6_f1_n16_tot,n6_f1_n17_tot,n6_f1_n18_tot,n6_f1_n19_tot,n6_f2_n0_tot,n6_f2_n1_tot,n6_f2_n2_tot,n6_f2_n3_tot,n6_f2_n4_tot,n6_f2_n5_tot,n6_f2_n7_tot,n6_f2_n8_tot,n6_f2_n9_tot,n6_f2_n10_tot,n6_f2_n11_tot,n6_f2_n12_tot,n6_f2_n13_tot,n6_f2_n14_tot,n6_f2_n15_tot,n6_f2_n16_tot,n6_f2_n17_tot,n6_f2_n18_tot,n6_f2_n19_tot,n7_f0_n0_tot,n7_f0_n1_tot,n7_f0_n2_tot,n7_f0_n3_tot,n7_f0_n4_tot,n7_f0_n5_tot,n7_f0_n6_tot,n7_f0_n8_tot,n7_f0_n9_tot,n7_f0_n10_tot,n7_f0_n11_tot,n7_f0_n12_tot,n7_f0_n13_tot,n7_f0_n14_tot,n7_f0_n15_tot,n7_f0_n16_tot,n7_f0_n17_tot,n7_f0_n18_tot,n7_f0_n19_tot,n7_f1_n0_tot,n7_f1_n1_tot,n7_f1_n2_tot,n7_f1_n3_tot,n7_f1_n4_tot,n7_f1_n5_tot,n7_f1_n6_tot,n7_f1_n8_tot,n7_f1_n9_tot,n7_f1_n10_tot,n7_f1_n11_tot,n7_f1_n12_tot,n7_f1_n13_tot,n7_f1_n14_tot,n7_f1_n15_tot,n7_f1_n16_tot,n7_f1_n17_tot,n7_f1_n18_tot,n7_f1_n19_tot,n7_f2_n0_tot,n7_f2_n1_tot,n7_f2_n2_tot,n7_f2_n3_tot,n7_f2_n4_tot,n7_f2_n5_tot,n7_f2_n6_tot,n7_f2_n8_tot,n7_f2_n9_tot,n7_f2_n10_tot,n7_f2_n11_tot,n7_f2_n12_tot,n7_f2_n13_tot,n7_f2_n14_tot,n7_f2_n15_tot,n7_f2_n16_tot,n7_f2_n17_tot,n7_f2_n18_tot,n7_f2_n19_tot,n8_f0_n0_tot,n8_f0_n1_tot,n8_f0_n2_tot,n8_f0_n3_tot,n8_f0_n4_tot,n8_f0_n5_tot,n8_f0_n6_tot,n8_f0_n7_tot,n8_f0_n9_tot,n8_f0_n10_tot,n8_f0_n11_tot,n8_f0_n12_tot,n8_f0_n13_tot,n8_f0_n14_tot,n8_f0_n15_tot,n8_f0_n16_tot,n8_f0_n17_tot,n8_f0_n18_tot,n8_f0_n19_tot,n8_f1_n0_tot,n8_f1_n1_tot,n8_f1_n2_tot,n8_f1_n3_tot,n8_f1_n4_tot,n8_f1_n5_tot,n8_f1_n6_tot,n8_f1_n7_tot,n8_f1_n9_tot,n8_f1_n10_tot,n8_f1_n11_tot,n8_f1_n12_tot,n8_f1_n13_tot,n8_f1_n14_tot,n8_f1_n15_tot,n8_f1_n16_tot,n8_f1_n17_tot,n8_f1_n18_tot,n8_f1_n19_tot,n8_f2_n0_tot,n8_f2_n1_tot,n8_f2_n2_tot,n8_f2_n3_tot,n8_f2_n4_tot,n8_f2_n5_tot,n8_f2_n6_tot,n8_f2_n7_tot,n8_f2_n9_tot,n8_f2_n10_tot,n8_f2_n11_tot,n8_f2_n12_tot,n8_f2_n13_tot,n8_f2_n14_tot,n8_f2_n15_tot,n8_f2_n16_tot,n8_f2_n17_tot,n8_f2_n18_tot,n8_f2_n19_tot,n9_f0_n0_tot,n9_f0_n1_tot,n9_f0_n2_tot,n9_f0_n3_tot,n9_f0_n4_tot,n9_f0_n5_tot,n9_f0_n6_tot,n9_f0_n7_tot,n9_f0_n8_tot,n9_f0_n10_tot,n9_f0_n11_tot,n9_f0_n12_tot,n9_f0_n13_tot,n9_f0_n14_tot,n9_f0_n15_tot,n9_f0_n16_tot,n9_f0_n17_tot,n9_f0_n18_tot,n9_f0_n19_tot,n9_f1_n0_tot,n9_f1_n1_tot,n9_f1_n2_tot,n9_f1_n3_tot,n9_f1_n4_tot,n9_f1_n5_tot,n9_f1_n6_tot,n9_f1_n7_tot,n9_f1_n8_tot,n9_f1_n10_tot,n9_f1_n11_tot,n9_f1_n12_tot,n9_f1_n13_tot,n9_f1_n14_tot,n9_f1_n15_tot,n9_f1_n16_tot,n9_f1_n17_tot,n9_f1_n18_tot,n9_f1_n19_tot,n9_f2_n0_tot,n9_f2_n1_tot,n9_f2_n2_tot,n9_f2_n3_tot,n9_f2_n4_tot,n9_f2_n5_tot,n9_f2_n6_tot,n9_f2_n7_tot,n9_f2_n8_tot,n9_f2_n10_tot,n9_f2_n11_tot,n9_f2_n12_tot,n9_f2_n13_tot,n9_f2_n14_tot,n9_f2_n15_tot,n9_f2_n16_tot,n9_f2_n17_tot,n9_f2_n18_tot,n9_f2_n19_tot,n10_f0_n0_tot,n10_f0_n1_tot,n10_f0_n2_tot,n10_f0_n3_tot,n10_f0_n4_tot,n10_f0_n5_tot,n10_f0_n6_tot,n10_f0_n7_tot,n10_f0_n8_tot,n10_f0_n9_tot,n10_f0_n11_tot,n10_f0_n12_tot,n10_f0_n13_tot,n10_f0_n14_tot,n10_f0_n15_tot,n10_f0_n16_tot,n10_f0_n17_tot,n10_f0_n18_tot,n10_f0_n19_tot,n10_f1_n0_tot,n10_f1_n1_tot,n10_f1_n2_tot,n10_f1_n3_tot,n10_f1_n4_tot,n10_f1_n5_tot,n10_f1_n6_tot,n10_f1_n7_tot,n10_f1_n8_tot,n10_f1_n9_tot,n10_f1_n11_tot,n10_f1_n12_tot,n10_f1_n13_tot,n10_f1_n14_tot,n10_f1_n15_tot,n10_f1_n16_tot,n10_f1_n17_tot,n10_f1_n18_tot,n10_f1_n19_tot,n10_f2_n0_tot,n10_f2_n1_tot,n10_f2_n2_tot,n10_f2_n3_tot,n10_f2_n4_tot,n10_f2_n5_tot,n10_f2_n6_tot,n10_f2_n7_tot,n10_f2_n8_tot,n10_f2_n9_tot,n10_f2_n11_tot,n10_f2_n12_tot,n10_f2_n13_tot,n10_f2_n14_tot,n10_f2_n15_tot,n10_f2_n16_tot,n10_f2_n17_tot,n10_f2_n18_tot,n10_f2_n19_tot,n11_f0_n0_tot,n11_f0_n1_tot,n11_f0_n2_tot,n11_f0_n3_tot,n11_f0_n4_tot,n11_f0_n5_tot,n11_f0_n6_tot,n11_f0_n7_tot,n11_f0_n8_tot,n11_f0_n9_tot,n11_f0_n10_tot,n11_f0_n12_tot,n11_f0_n13_tot,n11_f0_n14_tot,n11_f0_n15_tot,n11_f0_n16_tot,n11_f0_n17_tot,n11_f0_n18_tot,n11_f0_n19_tot,n11_f1_n0_tot,n11_f1_n1_tot,n11_f1_n2_tot,n11_f1_n3_tot,n11_f1_n4_tot,n11_f1_n5_tot,n11_f1_n6_tot,n11_f1_n7_tot,n11_f1_n8_tot,n11_f1_n9_tot,n11_f1_n10_tot,n11_f1_n12_tot,n11_f1_n13_tot,n11_f1_n14_tot,n11_f1_n15_tot,n11_f1_n16_tot,n11_f1_n17_tot,n11_f1_n18_tot,n11_f1_n19_tot,n11_f2_n0_tot,n11_f2_n1_tot,n11_f2_n2_tot,n11_f2_n3_tot,n11_f2_n4_tot,n11_f2_n5_tot,n11_f2_n6_tot,n11_f2_n7_tot,n11_f2_n8_tot,n11_f2_n9_tot,n11_f2_n10_tot,n11_f2_n12_tot,n11_f2_n13_tot,n11_f2_n14_tot,n11_f2_n15_tot,n11_f2_n16_tot,n11_f2_n17_tot,n11_f2_n18_tot,n11_f2_n19_tot,n12_f0_n0_tot,n12_f0_n1_tot,n12_f0_n2_tot,n12_f0_n3_tot,n12_f0_n4_tot,n12_f0_n5_tot,n12_f0_n6_tot,n12_f0_n7_tot,n12_f0_n8_tot,n12_f0_n9_tot,n12_f0_n10_tot,n12_f0_n11_tot,n12_f0_n13_tot,n12_f0_n14_tot,n12_f0_n15_tot,n12_f0_n16_tot,n12_f0_n17_tot,n12_f0_n18_tot,n12_f0_n19_tot,n12_f1_n0_tot,n12_f1_n1_tot,n12_f1_n2_tot,n12_f1_n3_tot,n12_f1_n4_tot,n12_f1_n5_tot,n12_f1_n6_tot,n12_f1_n7_tot,n12_f1_n8_tot,n12_f1_n9_tot,n12_f1_n10_tot,n12_f1_n11_tot,n12_f1_n13_tot,n12_f1_n14_tot,n12_f1_n15_tot,n12_f1_n16_tot,n12_f1_n17_tot,n12_f1_n18_tot,n12_f1_n19_tot,n12_f2_n0_tot,n12_f2_n1_tot,n12_f2_n2_tot,n12_f2_n3_tot,n12_f2_n4_tot,n12_f2_n5_tot,n12_f2_n6_tot,n12_f2_n7_tot,n12_f2_n8_tot,n12_f2_n9_tot,n12_f2_n10_tot,n12_f2_n11_tot,n12_f2_n13_tot,n12_f2_n14_tot,n12_f2_n15_tot,n12_f2_n16_tot,n12_f2_n17_tot,n12_f2_n18_tot,n12_f2_n19_tot,n13_f0_n0_tot,n13_f0_n1_tot,n13_f0_n2_tot,n13_f0_n3_tot,n13_f0_n4_tot,n13_f0_n5_tot,n13_f0_n6_tot,n13_f0_n7_tot,n13_f0_n8_tot,n13_f0_n9_tot,n13_f0_n10_tot,n13_f0_n11_tot,n13_f0_n12_tot,n13_f0_n14_tot,n13_f0_n15_tot,n13_f0_n16_tot,n13_f0_n17_tot,n13_f0_n18_tot,n13_f0_n19_tot,n13_f1_n0_tot,n13_f1_n1_tot,n13_f1_n2_tot,n13_f1_n3_tot,n13_f1_n4_tot,n13_f1_n5_tot,n13_f1_n6_tot,n13_f1_n7_tot,n13_f1_n8_tot,n13_f1_n9_tot,n13_f1_n10_tot,n13_f1_n11_tot,n13_f1_n12_tot,n13_f1_n14_tot,n13_f1_n15_tot,n13_f1_n16_tot,n13_f1_n17_tot,n13_f1_n18_tot,n13_f1_n19_tot,n13_f2_n0_tot,n13_f2_n1_tot,n13_f2_n2_tot,n13_f2_n3_tot,n13_f2_n4_tot,n13_f2_n5_tot,n13_f2_n6_tot,n13_f2_n7_tot,n13_f2_n8_tot,n13_f2_n9_tot,n13_f2_n10_tot,n13_f2_n11_tot,n13_f2_n12_tot,n13_f2_n14_tot,n13_f2_n15_tot,n13_f2_n16_tot,n13_f2_n17_tot,n13_f2_n18_tot,n13_f2_n19_tot,n14_f0_n0_tot,n14_f0_n1_tot,n14_f0_n2_tot,n14_f0_n3_tot,n14_f0_n4_tot,n14_f0_n5_tot,n14_f0_n6_tot,n14_f0_n7_tot,n14_f0_n8_tot,n14_f0_n9_tot,n14_f0_n10_tot,n14_f0_n11_tot,n14_f0_n12_tot,n14_f0_n13_tot,n14_f0_n15_tot,n14_f0_n16_tot,n14_f0_n17_tot,n14_f0_n18_tot,n14_f0_n19_tot,n14_f1_n0_tot,n14_f1_n1_tot,n14_f1_n2_tot,n14_f1_n3_tot,n14_f1_n4_tot,n14_f1_n5_tot,n14_f1_n6_tot,n14_f1_n7_tot,n14_f1_n8_tot,n14_f1_n9_tot,n14_f1_n10_tot,n14_f1_n11_tot,n14_f1_n12_tot,n14_f1_n13_tot,n14_f1_n15_tot,n14_f1_n16_tot,n14_f1_n17_tot,n14_f1_n18_tot,n14_f1_n19_tot,n14_f2_n0_tot,n14_f2_n1_tot,n14_f2_n2_tot,n14_f2_n3_tot,n14_f2_n4_tot,n14_f2_n5_tot,n14_f2_n6_tot,n14_f2_n7_tot,n14_f2_n8_tot,n14_f2_n9_tot,n14_f2_n10_tot,n14_f2_n11_tot,n14_f2_n12_tot,n14_f2_n13_tot,n14_f2_n15_tot,n14_f2_n16_tot,n14_f2_n17_tot,n14_f2_n18_tot,n14_f2_n19_tot,n15_f0_n0_tot,n15_f0_n1_tot,n15_f0_n2_tot,n15_f0_n3_tot,n15_f0_n4_tot,n15_f0_n5_tot,n15_f0_n6_tot,n15_f0_n7_tot,n15_f0_n8_tot,n15_f0_n9_tot,n15_f0_n10_tot,n15_f0_n11_tot,n15_f0_n12_tot,n15_f0_n13_tot,n15_f0_n14_tot,n15_f0_n16_tot,n15_f0_n17_tot,n15_f0_n18_tot,n15_f0_n19_tot,n15_f1_n0_tot,n15_f1_n1_tot,n15_f1_n2_tot,n15_f1_n3_tot,n15_f1_n4_tot,n15_f1_n5_tot,n15_f1_n6_tot,n15_f1_n7_tot,n15_f1_n8_tot,n15_f1_n9_tot,n15_f1_n10_tot,n15_f1_n11_tot,n15_f1_n12_tot,n15_f1_n13_tot,n15_f1_n14_tot,n15_f1_n16_tot,n15_f1_n17_tot,n15_f1_n18_tot,n15_f1_n19_tot,n15_f2_n0_tot,n15_f2_n1_tot,n15_f2_n2_tot,n15_f2_n3_tot,n15_f2_n4_tot,n15_f2_n5_tot,n15_f2_n6_tot,n15_f2_n7_tot,n15_f2_n8_tot,n15_f2_n9_tot,n15_f2_n10_tot,n15_f2_n11_tot,n15_f2_n12_tot,n15_f2_n13_tot,n15_f2_n14_tot,n15_f2_n16_tot,n15_f2_n17_tot,n15_f2_n18_tot,n15_f2_n19_tot,n16_f0_n0_tot,n16_f0_n1_tot,n16_f0_n2_tot,n16_f0_n3_tot,n16_f0_n4_tot,n16_f0_n5_tot,n16_f0_n6_tot,n16_f0_n7_tot,n16_f0_n8_tot,n16_f0_n9_tot,n16_f0_n10_tot,n16_f0_n11_tot,n16_f0_n12_tot,n16_f0_n13_tot,n16_f0_n14_tot,n16_f0_n15_tot,n16_f0_n17_tot,n16_f0_n18_tot,n16_f0_n19_tot,n16_f1_n0_tot,n16_f1_n1_tot,n16_f1_n2_tot,n16_f1_n3_tot,n16_f1_n4_tot,n16_f1_n5_tot,n16_f1_n6_tot,n16_f1_n7_tot,n16_f1_n8_tot,n16_f1_n9_tot,n16_f1_n10_tot,n16_f1_n11_tot,n16_f1_n12_tot,n16_f1_n13_tot,n16_f1_n14_tot,n16_f1_n15_tot,n16_f1_n17_tot,n16_f1_n18_tot,n16_f1_n19_tot,n16_f2_n0_tot,n16_f2_n1_tot,n16_f2_n2_tot,n16_f2_n3_tot,n16_f2_n4_tot,n16_f2_n5_tot,n16_f2_n6_tot,n16_f2_n7_tot,n16_f2_n8_tot,n16_f2_n9_tot,n16_f2_n10_tot,n16_f2_n11_tot,n16_f2_n12_tot,n16_f2_n13_tot,n16_f2_n14_tot,n16_f2_n15_tot,n16_f2_n17_tot,n16_f2_n18_tot,n16_f2_n19_tot,n17_f0_n0_tot,n17_f0_n1_tot,n17_f0_n2_tot,n17_f0_n3_tot,n17_f0_n4_tot,n17_f0_n5_tot,n17_f0_n6_tot,n17_f0_n7_tot,n17_f0_n8_tot,n17_f0_n9_tot,n17_f0_n10_tot,n17_f0_n11_tot,n17_f0_n12_tot,n17_f0_n13_tot,n17_f0_n14_tot,n17_f0_n15_tot,n17_f0_n16_tot,n17_f0_n18_tot,n17_f0_n19_tot,n17_f1_n0_tot,n17_f1_n1_tot,n17_f1_n2_tot,n17_f1_n3_tot,n17_f1_n4_tot,n17_f1_n5_tot,n17_f1_n6_tot,n17_f1_n7_tot,n17_f1_n8_tot,n17_f1_n9_tot,n17_f1_n10_tot,n17_f1_n11_tot,n17_f1_n12_tot,n17_f1_n13_tot,n17_f1_n14_tot,n17_f1_n15_tot,n17_f1_n16_tot,n17_f1_n18_tot,n17_f1_n19_tot,n17_f2_n0_tot,n17_f2_n1_tot,n17_f2_n2_tot,n17_f2_n3_tot,n17_f2_n4_tot,n17_f2_n5_tot,n17_f2_n6_tot,n17_f2_n7_tot,n17_f2_n8_tot,n17_f2_n9_tot,n17_f2_n10_tot,n17_f2_n11_tot,n17_f2_n12_tot,n17_f2_n13_tot,n17_f2_n14_tot,n17_f2_n15_tot,n17_f2_n16_tot,n17_f2_n18_tot,n17_f2_n19_tot,n18_f0_n0_tot,n18_f0_n1_tot,n18_f0_n2_tot,n18_f0_n3_tot,n18_f0_n4_tot,n18_f0_n5_tot,n18_f0_n6_tot,n18_f0_n7_tot,n18_f0_n8_tot,n18_f0_n9_tot,n18_f0_n10_tot,n18_f0_n11_tot,n18_f0_n12_tot,n18_f0_n13_tot,n18_f0_n14_tot,n18_f0_n15_tot,n18_f0_n16_tot,n18_f0_n17_tot,n18_f0_n19_tot,n18_f1_n0_tot,n18_f1_n1_tot,n18_f1_n2_tot,n18_f1_n3_tot,n18_f1_n4_tot,n18_f1_n5_tot,n18_f1_n6_tot,n18_f1_n7_tot,n18_f1_n8_tot,n18_f1_n9_tot,n18_f1_n10_tot,n18_f1_n11_tot,n18_f1_n12_tot,n18_f1_n13_tot,n18_f1_n14_tot,n18_f1_n15_tot,n18_f1_n16_tot,n18_f1_n17_tot,n18_f1_n19_tot,n18_f2_n0_tot,n18_f2_n1_tot,n18_f2_n2_tot,n18_f2_n3_tot,n18_f2_n4_tot,n18_f2_n5_tot,n18_f2_n6_tot,n18_f2_n7_tot,n18_f2_n8_tot,n18_f2_n9_tot,n18_f2_n10_tot,n18_f2_n11_tot,n18_f2_n12_tot,n18_f2_n13_tot,n18_f2_n14_tot,n18_f2_n15_tot,n18_f2_n16_tot,n18_f2_n17_tot,n18_f2_n19_tot,n19_f0_n0_tot,n19_f0_n1_tot,n19_f0_n2_tot,n19_f0_n3_tot,n19_f0_n4_tot,n19_f0_n5_tot,n19_f0_n6_tot,n19_f0_n7_tot,n19_f0_n8_tot,n19_f0_n9_tot,n19_f0_n10_tot,n19_f0_n11_tot,n19_f0_n12_tot,n19_f0_n13_tot,n19_f0_n14_tot,n19_f0_n15_tot,n19_f0_n16_tot,n19_f0_n17_tot,n19_f0_n18_tot,n19_f1_n0_tot,n19_f1_n1_tot,n19_f1_n2_tot,n19_f1_n3_tot,n19_f1_n4_tot,n19_f1_n5_tot,n19_f1_n6_tot,n19_f1_n7_tot,n19_f1_n8_tot,n19_f1_n9_tot,n19_f1_n10_tot,n19_f1_n11_tot,n19_f1_n12_tot,n19_f1_n13_tot,n19_f1_n14_tot,n19_f1_n15_tot,n19_f1_n16_tot,n19_f1_n17_tot,n19_f1_n18_tot,n19_f2_n0_tot,n19_f2_n1_tot,n19_f2_n2_tot,n19_f2_n3_tot,n19_f2_n4_tot,n19_f2_n5_tot,n19_f2_n6_tot,n19_f2_n7_tot,n19_f2_n8_tot,n19_f2_n9_tot,n19_f2_n10_tot,n19_f2_n11_tot,n19_f2_n12_tot,n19_f2_n13_tot,n19_f2_n14_tot,n19_f2_n15_tot,n19_f2_n16_tot,n19_f2_n17_tot,n19_f2_n18_tot,n0_f0_n1_accepted,n0_f0_n2_accepted,n0_f0_n3_accepted,n0_f0_n4_accepted,n0_f0_n5_accepted,n0_f0_n6_accepted,n0_f0_n7_accepted,n0_f0_n8_accepted,n0_f0_n9_accepted,n0_f0_n10_accepted,n0_f0_n11_accepted,n0_f0_n12_accepted,n0_f0_n13_accepted,n0_f0_n14_accepted,n0_f0_n15_accepted,n0_f0_n16_accepted,n0_f0_n17_accepted,n0_f0_n18_accepted,n0_f0_n19_accepted,n0_f1_n1_accepted,n0_f1_n2_accepted,n0_f1_n3_accepted,n0_f1_n4_accepted,n0_f1_n5_accepted,n0_f1_n6_accepted,n0_f1_n7_accepted,n0_f1_n8_accepted,n0_f1_n9_accepted,n0_f1_n10_accepted,n0_f1_n11_accepted,n0_f1_n12_accepted,n0_f1_n13_accepted,n0_f1_n14_accepted,n0_f1_n15_accepted,n0_f1_n16_accepted,n0_f1_n17_accepted,n0_f1_n18_accepted,n0_f1_n19_accepted,n0_f2_n1_accepted,n0_f2_n2_accepted,n0_f2_n3_accepted,n0_f2_n4_accepted,n0_f2_n5_accepted,n0_f2_n6_accepted,n0_f2_n7_accepted,n0_f2_n8_accepted,n0_f2_n9_accepted,n0_f2_n10_accepted,n0_f2_n11_accepted,n0_f2_n12_accepted,n0_f2_n13_accepted,n0_f2_n14_accepted,n0_f2_n15_accepted,n0_f2_n16_accepted,n0_f2_n17_accepted,n0_f2_n18_accepted,n0_f2_n19_accepted,n1_f0_n0_accepted,n1_f0_n2_accepted,n1_f0_n3_accepted,n1_f0_n4_accepted,n1_f0_n5_accepted,n1_f0_n6_accepted,n1_f0_n7_accepted,n1_f0_n8_accepted,n1_f0_n9_accepted,n1_f0_n10_accepted,n1_f0_n11_accepted,n1_f0_n12_accepted,n1_f0_n13_accepted,n1_f0_n14_accepted,n1_f0_n15_accepted,n1_f0_n16_accepted,n1_f0_n17_accepted,n1_f0_n18_accepted,n1_f0_n19_accepted,n1_f1_n0_accepted,n1_f1_n2_accepted,n1_f1_n3_accepted,n1_f1_n4_accepted,n1_f1_n5_accepted,n1_f1_n6_accepted,n1_f1_n7_accepted,n1_f1_n8_accepted,n1_f1_n9_accepted,n1_f1_n10_accepted,n1_f1_n11_accepted,n1_f1_n12_accepted,n1_f1_n13_accepted,n1_f1_n14_accepted,n1_f1_n15_accepted,n1_f1_n16_accepted,n1_f1_n17_accepted,n1_f1_n18_accepted,n1_f1_n19_accepted,n1_f2_n0_accepted,n1_f2_n2_accepted,n1_f2_n3_accepted,n1_f2_n4_accepted,n1_f2_n5_accepted,n1_f2_n6_accepted,n1_f2_n7_accepted,n1_f2_n8_accepted,n1_f2_n9_accepted,n1_f2_n10_accepted,n1_f2_n11_accepted,n1_f2_n12_accepted,n1_f2_n13_accepted,n1_f2_n14_accepted,n1_f2_n15_accepted,n1_f2_n16_accepted,n1_f2_n17_accepted,n1_f2_n18_accepted,n1_f2_n19_accepted,n2_f0_n0_accepted,n2_f0_n1_accepted,n2_f0_n3_accepted,n2_f0_n4_accepted,n2_f0_n5_accepted,n2_f0_n6_accepted,n2_f0_n7_accepted,n2_f0_n8_accepted,n2_f0_n9_accepted,n2_f0_n10_accepted,n2_f0_n11_accepted,n2_f0_n12_accepted,n2_f0_n13_accepted,n2_f0_n14_accepted,n2_f0_n15_accepted,n2_f0_n16_accepted,n2_f0_n17_accepted,n2_f0_n18_accepted,n2_f0_n19_accepted,n2_f1_n0_accepted,n2_f1_n1_accepted,n2_f1_n3_accepted,n2_f1_n4_accepted,n2_f1_n5_accepted,n2_f1_n6_accepted,n2_f1_n7_accepted,n2_f1_n8_accepted,n2_f1_n9_accepted,n2_f1_n10_accepted,n2_f1_n11_accepted,n2_f1_n12_accepted,n2_f1_n13_accepted,n2_f1_n14_accepted,n2_f1_n15_accepted,n2_f1_n16_accepted,n2_f1_n17_accepted,n2_f1_n18_accepted,n2_f1_n19_accepted,n2_f2_n0_accepted,n2_f2_n1_accepted,n2_f2_n3_accepted,n2_f2_n4_accepted,n2_f2_n5_accepted,n2_f2_n6_accepted,n2_f2_n7_accepted,n2_f2_n8_accepted,n2_f2_n9_accepted,n2_f2_n10_accepted,n2_f2_n11_accepted,n2_f2_n12_accepted,n2_f2_n13_accepted,n2_f2_n14_accepted,n2_f2_n15_accepted,n2_f2_n16_accepted,n2_f2_n17_accepted,n2_f2_n18_accepted,n2_f2_n19_accepted,n3_f0_n0_accepted,n3_f0_n1_accepted,n3_f0_n2_accepted,n3_f0_n4_accepted,n3_f0_n5_accepted,n3_f0_n6_accepted,n3_f0_n7_accepted,n3_f0_n8_accepted,n3_f0_n9_accepted,n3_f0_n10_accepted,n3_f0_n11_accepted,n3_f0_n12_accepted,n3_f0_n13_accepted,n3_f0_n14_accepted,n3_f0_n15_accepted,n3_f0_n16_accepted,n3_f0_n17_accepted,n3_f0_n18_accepted,n3_f0_n19_accepted,n3_f1_n0_accepted,n3_f1_n1_accepted,n3_f1_n2_accepted,n3_f1_n4_accepted,n3_f1_n5_accepted,n3_f1_n6_accepted,n3_f1_n7_accepted,n3_f1_n8_accepted,n3_f1_n9_accepted,n3_f1_n10_accepted,n3_f1_n11_accepted,n3_f1_n12_accepted,n3_f1_n13_accepted,n3_f1_n14_accepted,n3_f1_n15_accepted,n3_f1_n16_accepted,n3_f1_n17_accepted,n3_f1_n18_accepted,n3_f1_n19_accepted,n3_f2_n0_accepted,n3_f2_n1_accepted,n3_f2_n2_accepted,n3_f2_n4_accepted,n3_f2_n5_accepted,n3_f2_n6_accepted,n3_f2_n7_accepted,n3_f2_n8_accepted,n3_f2_n9_accepted,n3_f2_n10_accepted,n3_f2_n11_accepted,n3_f2_n12_accepted,n3_f2_n13_accepted,n3_f2_n14_accepted,n3_f2_n15_accepted,n3_f2_n16_accepted,n3_f2_n17_accepted,n3_f2_n18_accepted,n3_f2_n19_accepted,n4_f0_n0_accepted,n4_f0_n1_accepted,n4_f0_n2_accepted,n4_f0_n3_accepted,n4_f0_n5_accepted,n4_f0_n6_accepted,n4_f0_n7_accepted,n4_f0_n8_accepted,n4_f0_n9_accepted,n4_f0_n10_accepted,n4_f0_n11_accepted,n4_f0_n12_accepted,n4_f0_n13_accepted,n4_f0_n14_accepted,n4_f0_n15_accepted,n4_f0_n16_accepted,n4_f0_n17_accepted,n4_f0_n18_accepted,n4_f0_n19_accepted,n4_f1_n0_accepted,n4_f1_n1_accepted,n4_f1_n2_accepted,n4_f1_n3_accepted,n4_f1_n5_accepted,n4_f1_n6_accepted,n4_f1_n7_accepted,n4_f1_n8_accepted,n4_f1_n9_accepted,n4_f1_n10_accepted,n4_f1_n11_accepted,n4_f1_n12_accepted,n4_f1_n13_accepted,n4_f1_n14_accepted,n4_f1_n15_accepted,n4_f1_n16_accepted,n4_f1_n17_accepted,n4_f1_n18_accepted,n4_f1_n19_accepted,n4_f2_n0_accepted,n4_f2_n1_accepted,n4_f2_n2_accepted,n4_f2_n3_accepted,n4_f2_n5_accepted,n4_f2_n6_accepted,n4_f2_n7_accepted,n4_f2_n8_accepted,n4_f2_n9_accepted,n4_f2_n10_accepted,n4_f2_n11_accepted,n4_f2_n12_accepted,n4_f2_n13_accepted,n4_f2_n14_accepted,n4_f2_n15_accepted,n4_f2_n16_accepted,n4_f2_n17_accepted,n4_f2_n18_accepted,n4_f2_n19_accepted,n5_f0_n0_accepted,n5_f0_n1_accepted,n5_f0_n2_accepted,n5_f0_n3_accepted,n5_f0_n4_accepted,n5_f0_n6_accepted,n5_f0_n7_accepted,n5_f0_n8_accepted,n5_f0_n9_accepted,n5_f0_n10_accepted,n5_f0_n11_accepted,n5_f0_n12_accepted,n5_f0_n13_accepted,n5_f0_n14_accepted,n5_f0_n15_accepted,n5_f0_n16_accepted,n5_f0_n17_accepted,n5_f0_n18_accepted,n5_f0_n19_accepted,n5_f1_n0_accepted,n5_f1_n1_accepted,n5_f1_n2_accepted,n5_f1_n3_accepted,n5_f1_n4_accepted,n5_f1_n6_accepted,n5_f1_n7_accepted,n5_f1_n8_accepted,n5_f1_n9_accepted,n5_f1_n10_accepted,n5_f1_n11_accepted,n5_f1_n12_accepted,n5_f1_n13_accepted,n5_f1_n14_accepted,n5_f1_n15_accepted,n5_f1_n16_accepted,n5_f1_n17_accepted,n5_f1_n18_accepted,n5_f1_n19_accepted,n5_f2_n0_accepted,n5_f2_n1_accepted,n5_f2_n2_accepted,n5_f2_n3_accepted,n5_f2_n4_accepted,n5_f2_n6_accepted,n5_f2_n7_accepted,n5_f2_n8_accepted,n5_f2_n9_accepted,n5_f2_n10_accepted,n5_f2_n11_accepted,n5_f2_n12_accepted,n5_f2_n13_accepted,n5_f2_n14_accepted,n5_f2_n15_accepted,n5_f2_n16_accepted,n5_f2_n17_accepted,n5_f2_n18_accepted,n5_f2_n19_accepted,n6_f0_n0_accepted,n6_f0_n1_accepted,n6_f0_n2_accepted,n6_f0_n3_accepted,n6_f0_n4_accepted,n6_f0_n5_accepted,n6_f0_n7_accepted,n6_f0_n8_accepted,n6_f0_n9_accepted,n6_f0_n10_accepted,n6_f0_n11_accepted,n6_f0_n12_accepted,n6_f0_n13_accepted,n6_f0_n14_accepted,n6_f0_n15_accepted,n6_f0_n16_accepted,n6_f0_n17_accepted,n6_f0_n18_accepted,n6_f0_n19_accepted,n6_f1_n0_accepted,n6_f1_n1_accepted,n6_f1_n2_accepted,n6_f1_n3_accepted,n6_f1_n4_accepted,n6_f1_n5_accepted,n6_f1_n7_accepted,n6_f1_n8_accepted,n6_f1_n9_accepted,n6_f1_n10_accepted,n6_f1_n11_accepted,n6_f1_n12_accepted,n6_f1_n13_accepted,n6_f1_n14_accepted,n6_f1_n15_accepted,n6_f1_n16_accepted,n6_f1_n17_accepted,n6_f1_n18_accepted,n6_f1_n19_accepted,n6_f2_n0_accepted,n6_f2_n1_accepted,n6_f2_n2_accepted,n6_f2_n3_accepted,n6_f2_n4_accepted,n6_f2_n5_accepted,n6_f2_n7_accepted,n6_f2_n8_accepted,n6_f2_n9_accepted,n6_f2_n10_accepted,n6_f2_n11_accepted,n6_f2_n12_accepted,n6_f2_n13_accepted,n6_f2_n14_accepted,n6_f2_n15_accepted,n6_f2_n16_accepted,n6_f2_n17_accepted,n6_f2_n18_accepted,n6_f2_n19_accepted,n7_f0_n0_accepted,n7_f0_n1_accepted,n7_f0_n2_accepted,n7_f0_n3_accepted,n7_f0_n4_accepted,n7_f0_n5_accepted,n7_f0_n6_accepted,n7_f0_n8_accepted,n7_f0_n9_accepted,n7_f0_n10_accepted,n7_f0_n11_accepted,n7_f0_n12_accepted,n7_f0_n13_accepted,n7_f0_n14_accepted,n7_f0_n15_accepted,n7_f0_n16_accepted,n7_f0_n17_accepted,n7_f0_n18_accepted,n7_f0_n19_accepted,n7_f1_n0_accepted,n7_f1_n1_accepted,n7_f1_n2_accepted,n7_f1_n3_accepted,n7_f1_n4_accepted,n7_f1_n5_accepted,n7_f1_n6_accepted,n7_f1_n8_accepted,n7_f1_n9_accepted,n7_f1_n10_accepted,n7_f1_n11_accepted,n7_f1_n12_accepted,n7_f1_n13_accepted,n7_f1_n14_accepted,n7_f1_n15_accepted,n7_f1_n16_accepted,n7_f1_n17_accepted,n7_f1_n18_accepted,n7_f1_n19_accepted,n7_f2_n0_accepted,n7_f2_n1_accepted,n7_f2_n2_accepted,n7_f2_n3_accepted,n7_f2_n4_accepted,n7_f2_n5_accepted,n7_f2_n6_accepted,n7_f2_n8_accepted,n7_f2_n9_accepted,n7_f2_n10_accepted,n7_f2_n11_accepted,n7_f2_n12_accepted,n7_f2_n13_accepted,n7_f2_n14_accepted,n7_f2_n15_accepted,n7_f2_n16_accepted,n7_f2_n17_accepted,n7_f2_n18_accepted,n7_f2_n19_accepted,n8_f0_n0_accepted,n8_f0_n1_accepted,n8_f0_n2_accepted,n8_f0_n3_accepted,n8_f0_n4_accepted,n8_f0_n5_accepted,n8_f0_n6_accepted,n8_f0_n7_accepted,n8_f0_n9_accepted,n8_f0_n10_accepted,n8_f0_n11_accepted,n8_f0_n12_accepted,n8_f0_n13_accepted,n8_f0_n14_accepted,n8_f0_n15_accepted,n8_f0_n16_accepted,n8_f0_n17_accepted,n8_f0_n18_accepted,n8_f0_n19_accepted,n8_f1_n0_accepted,n8_f1_n1_accepted,n8_f1_n2_accepted,n8_f1_n3_accepted,n8_f1_n4_accepted,n8_f1_n5_accepted,n8_f1_n6_accepted,n8_f1_n7_accepted,n8_f1_n9_accepted,n8_f1_n10_accepted,n8_f1_n11_accepted,n8_f1_n12_accepted,n8_f1_n13_accepted,n8_f1_n14_accepted,n8_f1_n15_accepted,n8_f1_n16_accepted,n8_f1_n17_accepted,n8_f1_n18_accepted,n8_f1_n19_accepted,n8_f2_n0_accepted,n8_f2_n1_accepted,n8_f2_n2_accepted,n8_f2_n3_accepted,n8_f2_n4_accepted,n8_f2_n5_accepted,n8_f2_n6_accepted,n8_f2_n7_accepted,n8_f2_n9_accepted,n8_f2_n10_accepted,n8_f2_n11_accepted,n8_f2_n12_accepted,n8_f2_n13_accepted,n8_f2_n14_accepted,n8_f2_n15_accepted,n8_f2_n16_accepted,n8_f2_n17_accepted,n8_f2_n18_accepted,n8_f2_n19_accepted,n9_f0_n0_accepted,n9_f0_n1_accepted,n9_f0_n2_accepted,n9_f0_n3_accepted,n9_f0_n4_accepted,n9_f0_n5_accepted,n9_f0_n6_accepted,n9_f0_n7_accepted,n9_f0_n8_accepted,n9_f0_n10_accepted,n9_f0_n11_accepted,n9_f0_n12_accepted,n9_f0_n13_accepted,n9_f0_n14_accepted,n9_f0_n15_accepted,n9_f0_n16_accepted,n9_f0_n17_accepted,n9_f0_n18_accepted,n9_f0_n19_accepted,n9_f1_n0_accepted,n9_f1_n1_accepted,n9_f1_n2_accepted,n9_f1_n3_accepted,n9_f1_n4_accepted,n9_f1_n5_accepted,n9_f1_n6_accepted,n9_f1_n7_accepted,n9_f1_n8_accepted,n9_f1_n10_accepted,n9_f1_n11_accepted,n9_f1_n12_accepted,n9_f1_n13_accepted,n9_f1_n14_accepted,n9_f1_n15_accepted,n9_f1_n16_accepted,n9_f1_n17_accepted,n9_f1_n18_accepted,n9_f1_n19_accepted,n9_f2_n0_accepted,n9_f2_n1_accepted,n9_f2_n2_accepted,n9_f2_n3_accepted,n9_f2_n4_accepted,n9_f2_n5_accepted,n9_f2_n6_accepted,n9_f2_n7_accepted,n9_f2_n8_accepted,n9_f2_n10_accepted,n9_f2_n11_accepted,n9_f2_n12_accepted,n9_f2_n13_accepted,n9_f2_n14_accepted,n9_f2_n15_accepted,n9_f2_n16_accepted,n9_f2_n17_accepted,n9_f2_n18_accepted,n9_f2_n19_accepted,n10_f0_n0_accepted,n10_f0_n1_accepted,n10_f0_n2_accepted,n10_f0_n3_accepted,n10_f0_n4_accepted,n10_f0_n5_accepted,n10_f0_n6_accepted,n10_f0_n7_accepted,n10_f0_n8_accepted,n10_f0_n9_accepted,n10_f0_n11_accepted,n10_f0_n12_accepted,n10_f0_n13_accepted,n10_f0_n14_accepted,n10_f0_n15_accepted,n10_f0_n16_accepted,n10_f0_n17_accepted,n10_f0_n18_accepted,n10_f0_n19_accepted,n10_f1_n0_accepted,n10_f1_n1_accepted,n10_f1_n2_accepted,n10_f1_n3_accepted,n10_f1_n4_accepted,n10_f1_n5_accepted,n10_f1_n6_accepted,n10_f1_n7_accepted,n10_f1_n8_accepted,n10_f1_n9_accepted,n10_f1_n11_accepted,n10_f1_n12_accepted,n10_f1_n13_accepted,n10_f1_n14_accepted,n10_f1_n15_accepted,n10_f1_n16_accepted,n10_f1_n17_accepted,n10_f1_n18_accepted,n10_f1_n19_accepted,n10_f2_n0_accepted,n10_f2_n1_accepted,n10_f2_n2_accepted,n10_f2_n3_accepted,n10_f2_n4_accepted,n10_f2_n5_accepted,n10_f2_n6_accepted,n10_f2_n7_accepted,n10_f2_n8_accepted,n10_f2_n9_accepted,n10_f2_n11_accepted,n10_f2_n12_accepted,n10_f2_n13_accepted,n10_f2_n14_accepted,n10_f2_n15_accepted,n10_f2_n16_accepted,n10_f2_n17_accepted,n10_f2_n18_accepted,n10_f2_n19_accepted,n11_f0_n0_accepted,n11_f0_n1_accepted,n11_f0_n2_accepted,n11_f0_n3_accepted,n11_f0_n4_accepted,n11_f0_n5_accepted,n11_f0_n6_accepted,n11_f0_n7_accepted,n11_f0_n8_accepted,n11_f0_n9_accepted,n11_f0_n10_accepted,n11_f0_n12_accepted,n11_f0_n13_accepted,n11_f0_n14_accepted,n11_f0_n15_accepted,n11_f0_n16_accepted,n11_f0_n17_accepted,n11_f0_n18_accepted,n11_f0_n19_accepted,n11_f1_n0_accepted,n11_f1_n1_accepted,n11_f1_n2_accepted,n11_f1_n3_accepted,n11_f1_n4_accepted,n11_f1_n5_accepted,n11_f1_n6_accepted,n11_f1_n7_accepted,n11_f1_n8_accepted,n11_f1_n9_accepted,n11_f1_n10_accepted,n11_f1_n12_accepted,n11_f1_n13_accepted,n11_f1_n14_accepted,n11_f1_n15_accepted,n11_f1_n16_accepted,n11_f1_n17_accepted,n11_f1_n18_accepted,n11_f1_n19_accepted,n11_f2_n0_accepted,n11_f2_n1_accepted,n11_f2_n2_accepted,n11_f2_n3_accepted,n11_f2_n4_accepted,n11_f2_n5_accepted,n11_f2_n6_accepted,n11_f2_n7_accepted,n11_f2_n8_accepted,n11_f2_n9_accepted,n11_f2_n10_accepted,n11_f2_n12_accepted,n11_f2_n13_accepted,n11_f2_n14_accepted,n11_f2_n15_accepted,n11_f2_n16_accepted,n11_f2_n17_accepted,n11_f2_n18_accepted,n11_f2_n19_accepted,n12_f0_n0_accepted,n12_f0_n1_accepted,n12_f0_n2_accepted,n12_f0_n3_accepted,n12_f0_n4_accepted,n12_f0_n5_accepted,n12_f0_n6_accepted,n12_f0_n7_accepted,n12_f0_n8_accepted,n12_f0_n9_accepted,n12_f0_n10_accepted,n12_f0_n11_accepted,n12_f0_n13_accepted,n12_f0_n14_accepted,n12_f0_n15_accepted,n12_f0_n16_accepted,n12_f0_n17_accepted,n12_f0_n18_accepted,n12_f0_n19_accepted,n12_f1_n0_accepted,n12_f1_n1_accepted,n12_f1_n2_accepted,n12_f1_n3_accepted,n12_f1_n4_accepted,n12_f1_n5_accepted,n12_f1_n6_accepted,n12_f1_n7_accepted,n12_f1_n8_accepted,n12_f1_n9_accepted,n12_f1_n10_accepted,n12_f1_n11_accepted,n12_f1_n13_accepted,n12_f1_n14_accepted,n12_f1_n15_accepted,n12_f1_n16_accepted,n12_f1_n17_accepted,n12_f1_n18_accepted,n12_f1_n19_accepted,n12_f2_n0_accepted,n12_f2_n1_accepted,n12_f2_n2_accepted,n12_f2_n3_accepted,n12_f2_n4_accepted,n12_f2_n5_accepted,n12_f2_n6_accepted,n12_f2_n7_accepted,n12_f2_n8_accepted,n12_f2_n9_accepted,n12_f2_n10_accepted,n12_f2_n11_accepted,n12_f2_n13_accepted,n12_f2_n14_accepted,n12_f2_n15_accepted,n12_f2_n16_accepted,n12_f2_n17_accepted,n12_f2_n18_accepted,n12_f2_n19_accepted,n13_f0_n0_accepted,n13_f0_n1_accepted,n13_f0_n2_accepted,n13_f0_n3_accepted,n13_f0_n4_accepted,n13_f0_n5_accepted,n13_f0_n6_accepted,n13_f0_n7_accepted,n13_f0_n8_accepted,n13_f0_n9_accepted,n13_f0_n10_accepted,n13_f0_n11_accepted,n13_f0_n12_accepted,n13_f0_n14_accepted,n13_f0_n15_accepted,n13_f0_n16_accepted,n13_f0_n17_accepted,n13_f0_n18_accepted,n13_f0_n19_accepted,n13_f1_n0_accepted,n13_f1_n1_accepted,n13_f1_n2_accepted,n13_f1_n3_accepted,n13_f1_n4_accepted,n13_f1_n5_accepted,n13_f1_n6_accepted,n13_f1_n7_accepted,n13_f1_n8_accepted,n13_f1_n9_accepted,n13_f1_n10_accepted,n13_f1_n11_accepted,n13_f1_n12_accepted,n13_f1_n14_accepted,n13_f1_n15_accepted,n13_f1_n16_accepted,n13_f1_n17_accepted,n13_f1_n18_accepted,n13_f1_n19_accepted,n13_f2_n0_accepted,n13_f2_n1_accepted,n13_f2_n2_accepted,n13_f2_n3_accepted,n13_f2_n4_accepted,n13_f2_n5_accepted,n13_f2_n6_accepted,n13_f2_n7_accepted,n13_f2_n8_accepted,n13_f2_n9_accepted,n13_f2_n10_accepted,n13_f2_n11_accepted,n13_f2_n12_accepted,n13_f2_n14_accepted,n13_f2_n15_accepted,n13_f2_n16_accepted,n13_f2_n17_accepted,n13_f2_n18_accepted,n13_f2_n19_accepted,n14_f0_n0_accepted,n14_f0_n1_accepted,n14_f0_n2_accepted,n14_f0_n3_accepted,n14_f0_n4_accepted,n14_f0_n5_accepted,n14_f0_n6_accepted,n14_f0_n7_accepted,n14_f0_n8_accepted,n14_f0_n9_accepted,n14_f0_n10_accepted,n14_f0_n11_accepted,n14_f0_n12_accepted,n14_f0_n13_accepted,n14_f0_n15_accepted,n14_f0_n16_accepted,n14_f0_n17_accepted,n14_f0_n18_accepted,n14_f0_n19_accepted,n14_f1_n0_accepted,n14_f1_n1_accepted,n14_f1_n2_accepted,n14_f1_n3_accepted,n14_f1_n4_accepted,n14_f1_n5_accepted,n14_f1_n6_accepted,n14_f1_n7_accepted,n14_f1_n8_accepted,n14_f1_n9_accepted,n14_f1_n10_accepted,n14_f1_n11_accepted,n14_f1_n12_accepted,n14_f1_n13_accepted,n14_f1_n15_accepted,n14_f1_n16_accepted,n14_f1_n17_accepted,n14_f1_n18_accepted,n14_f1_n19_accepted,n14_f2_n0_accepted,n14_f2_n1_accepted,n14_f2_n2_accepted,n14_f2_n3_accepted,n14_f2_n4_accepted,n14_f2_n5_accepted,n14_f2_n6_accepted,n14_f2_n7_accepted,n14_f2_n8_accepted,n14_f2_n9_accepted,n14_f2_n10_accepted,n14_f2_n11_accepted,n14_f2_n12_accepted,n14_f2_n13_accepted,n14_f2_n15_accepted,n14_f2_n16_accepted,n14_f2_n17_accepted,n14_f2_n18_accepted,n14_f2_n19_accepted,n15_f0_n0_accepted,n15_f0_n1_accepted,n15_f0_n2_accepted,n15_f0_n3_accepted,n15_f0_n4_accepted,n15_f0_n5_accepted,n15_f0_n6_accepted,n15_f0_n7_accepted,n15_f0_n8_accepted,n15_f0_n9_accepted,n15_f0_n10_accepted,n15_f0_n11_accepted,n15_f0_n12_accepted,n15_f0_n13_accepted,n15_f0_n14_accepted,n15_f0_n16_accepted,n15_f0_n17_accepted,n15_f0_n18_accepted,n15_f0_n19_accepted,n15_f1_n0_accepted,n15_f1_n1_accepted,n15_f1_n2_accepted,n15_f1_n3_accepted,n15_f1_n4_accepted,n15_f1_n5_accepted,n15_f1_n6_accepted,n15_f1_n7_accepted,n15_f1_n8_accepted,n15_f1_n9_accepted,n15_f1_n10_accepted,n15_f1_n11_accepted,n15_f1_n12_accepted,n15_f1_n13_accepted,n15_f1_n14_accepted,n15_f1_n16_accepted,n15_f1_n17_accepted,n15_f1_n18_accepted,n15_f1_n19_accepted,n15_f2_n0_accepted,n15_f2_n1_accepted,n15_f2_n2_accepted,n15_f2_n3_accepted,n15_f2_n4_accepted,n15_f2_n5_accepted,n15_f2_n6_accepted,n15_f2_n7_accepted,n15_f2_n8_accepted,n15_f2_n9_accepted,n15_f2_n10_accepted,n15_f2_n11_accepted,n15_f2_n12_accepted,n15_f2_n13_accepted,n15_f2_n14_accepted,n15_f2_n16_accepted,n15_f2_n17_accepted,n15_f2_n18_accepted,n15_f2_n19_accepted,n16_f0_n0_accepted,n16_f0_n1_accepted,n16_f0_n2_accepted,n16_f0_n3_accepted,n16_f0_n4_accepted,n16_f0_n5_accepted,n16_f0_n6_accepted,n16_f0_n7_accepted,n16_f0_n8_accepted,n16_f0_n9_accepted,n16_f0_n10_accepted,n16_f0_n11_accepted,n16_f0_n12_accepted,n16_f0_n13_accepted,n16_f0_n14_accepted,n16_f0_n15_accepted,n16_f0_n17_accepted,n16_f0_n18_accepted,n16_f0_n19_accepted,n16_f1_n0_accepted,n16_f1_n1_accepted,n16_f1_n2_accepted,n16_f1_n3_accepted,n16_f1_n4_accepted,n16_f1_n5_accepted,n16_f1_n6_accepted,n16_f1_n7_accepted,n16_f1_n8_accepted,n16_f1_n9_accepted,n16_f1_n10_accepted,n16_f1_n11_accepted,n16_f1_n12_accepted,n16_f1_n13_accepted,n16_f1_n14_accepted,n16_f1_n15_accepted,n16_f1_n17_accepted,n16_f1_n18_accepted,n16_f1_n19_accepted,n16_f2_n0_accepted,n16_f2_n1_accepted,n16_f2_n2_accepted,n16_f2_n3_accepted,n16_f2_n4_accepted,n16_f2_n5_accepted,n16_f2_n6_accepted,n16_f2_n7_accepted,n16_f2_n8_accepted,n16_f2_n9_accepted,n16_f2_n10_accepted,n16_f2_n11_accepted,n16_f2_n12_accepted,n16_f2_n13_accepted,n16_f2_n14_accepted,n16_f2_n15_accepted,n16_f2_n17_accepted,n16_f2_n18_accepted,n16_f2_n19_accepted,n17_f0_n0_accepted,n17_f0_n1_accepted,n17_f0_n2_accepted,n17_f0_n3_accepted,n17_f0_n4_accepted,n17_f0_n5_accepted,n17_f0_n6_accepted,n17_f0_n7_accepted,n17_f0_n8_accepted,n17_f0_n9_accepted,n17_f0_n10_accepted,n17_f0_n11_accepted,n17_f0_n12_accepted,n17_f0_n13_accepted,n17_f0_n14_accepted,n17_f0_n15_accepted,n17_f0_n16_accepted,n17_f0_n18_accepted,n17_f0_n19_accepted,n17_f1_n0_accepted,n17_f1_n1_accepted,n17_f1_n2_accepted,n17_f1_n3_accepted,n17_f1_n4_accepted,n17_f1_n5_accepted,n17_f1_n6_accepted,n17_f1_n7_accepted,n17_f1_n8_accepted,n17_f1_n9_accepted,n17_f1_n10_accepted,n17_f1_n11_accepted,n17_f1_n12_accepted,n17_f1_n13_accepted,n17_f1_n14_accepted,n17_f1_n15_accepted,n17_f1_n16_accepted,n17_f1_n18_accepted,n17_f1_n19_accepted,n17_f2_n0_accepted,n17_f2_n1_accepted,n17_f2_n2_accepted,n17_f2_n3_accepted,n17_f2_n4_accepted,n17_f2_n5_accepted,n17_f2_n6_accepted,n17_f2_n7_accepted,n17_f2_n8_accepted,n17_f2_n9_accepted,n17_f2_n10_accepted,n17_f2_n11_accepted,n17_f2_n12_accepted,n17_f2_n13_accepted,n17_f2_n14_accepted,n17_f2_n15_accepted,n17_f2_n16_accepted,n17_f2_n18_accepted,n17_f2_n19_accepted,n18_f0_n0_accepted,n18_f0_n1_accepted,n18_f0_n2_accepted,n18_f0_n3_accepted,n18_f0_n4_accepted,n18_f0_n5_accepted,n18_f0_n6_accepted,n18_f0_n7_accepted,n18_f0_n8_accepted,n18_f0_n9_accepted,n18_f0_n10_accepted,n18_f0_n11_accepted,n18_f0_n12_accepted,n18_f0_n13_accepted,n18_f0_n14_accepted,n18_f0_n15_accepted,n18_f0_n16_accepted,n18_f0_n17_accepted,n18_f0_n19_accepted,n18_f1_n0_accepted,n18_f1_n1_accepted,n18_f1_n2_accepted,n18_f1_n3_accepted,n18_f1_n4_accepted,n18_f1_n5_accepted,n18_f1_n6_accepted,n18_f1_n7_accepted,n18_f1_n8_accepted,n18_f1_n9_accepted,n18_f1_n10_accepted,n18_f1_n11_accepted,n18_f1_n12_accepted,n18_f1_n13_accepted,n18_f1_n14_accepted,n18_f1_n15_accepted,n18_f1_n16_accepted,n18_f1_n17_accepted,n18_f1_n19_accepted,n18_f2_n0_accepted,n18_f2_n1_accepted,n18_f2_n2_accepted,n18_f2_n3_accepted,n18_f2_n4_accepted,n18_f2_n5_accepted,n18_f2_n6_accepted,n18_f2_n7_accepted,n18_f2_n8_accepted,n18_f2_n9_accepted,n18_f2_n10_accepted,n18_f2_n11_accepted,n18_f2_n12_accepted,n18_f2_n13_accepted,n18_f2_n14_accepted,n18_f2_n15_accepted,n18_f2_n16_accepted,n18_f2_n17_accepted,n18_f2_n19_accepted,n19_f0_n0_accepted,n19_f0_n1_accepted,n19_f0_n2_accepted,n19_f0_n3_accepted,n19_f0_n4_accepted,n19_f0_n5_accepted,n19_f0_n6_accepted,n19_f0_n7_accepted,n19_f0_n8_accepted,n19_f0_n9_accepted,n19_f0_n10_accepted,n19_f0_n11_accepted,n19_f0_n12_accepted,n19_f0_n13_accepted,n19_f0_n14_accepted,n19_f0_n15_accepted,n19_f0_n16_accepted,n19_f0_n17_accepted,n19_f0_n18_accepted,n19_f1_n0_accepted,n19_f1_n1_accepted,n19_f1_n2_accepted,n19_f1_n3_accepted,n19_f1_n4_accepted,n19_f1_n5_accepted,n19_f1_n6_accepted,n19_f1_n7_accepted,n19_f1_n8_accepted,n19_f1_n9_accepted,n19_f1_n10_accepted,n19_f1_n11_accepted,n19_f1_n12_accepted,n19_f1_n13_accepted,n19_f1_n14_accepted,n19_f1_n15_accepted,n19_f1_n16_accepted,n19_f1_n17_accepted,n19_f1_n18_accepted,n19_f2_n0_accepted,n19_f2_n1_accepted,n19_f2_n2_accepted,n19_f2_n3_accepted,n19_f2_n4_accepted,n19_f2_n5_accepted,n19_f2_n6_accepted,n19_f2_n7_accepted,n19_f2_n8_accepted,n19_f2_n9_accepted,n19_f2_n10_accepted,n19_f2_n11_accepted,n19_f2_n12_accepted,n19_f2_n13_accepted,n19_f2_n14_accepted,n19_f2_n15_accepted,n19_f2_n16_accepted,n19_f2_n17_accepted,n19_f2_n18_accepted
+0.0,0.11680911680911699,0.5584045584045585,0.3504273504273563,0.14529914529914834,0.0,0.14529914529914834,1.9166666666666663,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,1.7635327635327638,2.1452991452991466,1.717948717948719,0.5726495726495724,12.422364672364656,0.16587677725118688,0.33175355450237376,0.0,1.1232227488151665,0.3981042654028428,0.0,0.0995260663507107,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.7345971563981095,1.3636363636363635,0.5023696682464518,7.3093494183541345,2.274881516587687,0.0,0.0,0.6363636363636362,0.04210526315789487,0.10526315789473628,0.0,0.16842105263157947,0.10526315789473628,0.0,0.18947368421052602,0.0,0.0,1.0,0.0,0.43157894736842195,1.0803827751196171,1.0803827751196171,1.0803827751196171,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,19.649572649572644,4.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.436018957345972,0.0,0.0,0.0,0.4688995215311018,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,3.4889952153110038,0.0,0.0,0.0,6.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,9.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,24.0,30.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,3.431578947368422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.023504273504275863,0.25883190883190804,0.0,0.09999999999999999,0.09999999999999999,0.25883190883190804,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.8909952606635159,0.3127962085308127,0.19905213270143918,18.99999999999997,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,28.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,18.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.8544159544159555,1.4270655270655275,2.5047008547008556,0.0,1.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2274881516587612,0.0,0.7725118483412388,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.46445497630333,0.0,1.0,0.0,0.0,56.53554502369667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2909090909090901,0.0,0.0,0.0,0.0,0.7090909090909099,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,1.388625592417057,1.1232227488152091,0.0,10.488151658767734,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27368421052631153,0.22105263157895008,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11680911680911699,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.33175355450237376,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6363636363636362,0.4688995215311018,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0995260663507107,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9166666666666663,0.0,0.0,0.0,0.0,0.023504273504275863,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18947368421052602,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,4.8544159544159555,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,0.0,0.0,0.0,0.0,31.46445497630333,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.4889952153110038,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2909090909090901,0.27368421052631153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,1.4270655270655275,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3127962085308127,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,2.5047008547008556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.19905213270143918,0.0,0.0,7.0,1.2274881516587612,1.0,0.0,1.388625592417057,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22105263157895008,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25883190883190804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.99999999999997,3.0,24.0,18.0,0.0,0.0,0.0,1.1232227488152091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,1.7635327635327638,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,1.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7345971563981095,0.0,0.0,10.0,0.0,0.0,0.0,28.0,9.0,0.7725118483412388,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,6.0,0.0,0.0,3.431578947368422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1452991452991466,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,24.0,0.0,0.0,0.0,0.0,0.0,0.0,56.53554502369667,0.0,10.488151658767734,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7090909090909099,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.717948717948719,4.0,2.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5023696682464518,0.0,0.0,30.0,0.0,0.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5726495726495724,19.649572649572644,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.3093494183541345,26.436018957345972,0.0,13.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.422364672364656,4.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.274881516587687,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0803827751196171,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.6752136752136764,0.5584045584045585,0.3504273504273563,0.14529914529914834,0.0,1.1452991452991483,1.840170940170942,0.0,1.4102564102564124,1.0,0.0,1.0,1.0,1.7499999999999996,2.1452991452991443,1.717948717948719,1.5726495726495724,4.689031339031322,0.16587677725118688,0.16587677725118688,0.0,0.12322274881516648,0.4976303317535553,0.0,0.1990521327014214,0.6966824644549732,0.0,0.0995260663507107,0.0,0.0,0.0,0.0,1.0426540284360257,1.6966824644549803,1.5023696682464518,2.3127962085308127,28.497630331753527,0.0,0.0,0.10526315789473806,0.04210526315789487,0.08421052631578974,0.0,0.14736842105263293,0.10526315789473628,0.0,0.18947368421052602,0.0,0.0,0.0,0.0,0.43157894736842195,0.43157894736842195,1.4877192982456129,0.4877192982456128,1.4877192982456129,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,21.299145299145287,8.350427350427356,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.601895734597157,0.0,2.0,0.3684210526315792,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,9.589473684210526,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,2.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,10.0,0.0,2.0,53.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.013532763532764225,0.0,1.8411680911680874,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,1.0,0.0,0.0,0.0,8.27368421052632,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.22499999999999998,0.09999999999999999,0.22499999999999998,0.3500000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,7.199999999999999,0.9289099526066451,7.199999999999999,6.173459715639801,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,0.30877192982456114,0.30877192982456114,0.30877192982456114,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,15.0,0.0,33.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.0,0.0,0.0,13.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5385327635327644,0.617948717948719,1.5385327635327644,0.0,2.3049857549857524,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.847393364928923,0.0,0.0,0.0,0.6161137440758182,65.53649289099526,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5649122807017547,0.0,0.0,0.0,0.0,0.43508771929824536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6151658767772576,11.384834123222742,0.0,16.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22807017543859676,0.912280701754387,0.8596491228070162,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3684210526315792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473806,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.12322274881516648,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1990521327014214,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.840170940170942,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4102564102564124,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0995260663507107,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18947368421052602,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.22499999999999998,0.0,0.0,0.0,1.5385327635327644,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.199999999999999,0.0,5.0,19.0,0.0,10.847393364928923,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,1.0,0.0,1.0,0.07368421052631646,0.0,0.0,0.0,0.0,0.5649122807017547,0.22807017543859676,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,0.617948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9289099526066451,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30877192982456114,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.22499999999999998,0.0,0.0,0.0,1.5385327635327644,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.199999999999999,0.0,0.0,0.0,0.0,0.0,0.0,0.6151658767772576,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30877192982456114,0.0,0.0,0.0,0.0,0.0,0.0,0.912280701754387,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.3500000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,0.0,6.173459715639801,0.0,15.0,13.0,0.0,0.0,0.0,11.384834123222742,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.30877192982456114,0.0,0.0,0.0,0.0,0.0,0.0,0.8596491228070162,0.0,0.0,0.0,0.0,0.0,0.0,1.7499999999999996,0.0,0.0,0.0,0.013532763532764225,0.0,0.0,0.0,0.0,2.3049857549857524,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0426540284360257,0.0,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6161137440758182,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,9.589473684210526,1.0,0.0,8.27368421052632,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1452991452991443,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6966824644549803,0.0,0.0,0.0,0.0,0.0,2.0,33.0,5.0,0.0,65.53649289099526,0.0,16.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43508771929824536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.717948717948719,0.0,0.0,17.0,1.8411680911680874,0.0,2.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5023696682464518,14.601895734597157,23.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4877192982456129,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5726495726495724,21.299145299145287,0.0,6.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3127962085308127,0.0,0.0,53.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4877192982456128,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.689031339031322,8.350427350427356,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,28.497630331753527,2.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4877192982456129,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.6752136752136764,0.5584045584045585,0.3504273504273563,0.41025641025641235,0.0,0.14529914529914834,1.6068376068376091,0.0,1.4102564102564124,0.0,0.0,0.0,1.0,3.071225071225049,2.336182336182337,2.9088319088319112,2.7635327635327647,1.7635327635327647,0.16587677725118688,0.16587677725118688,0.0,0.3981042654028428,0.4976303317535553,0.0,0.29857819905213034,0.7962085308056857,0.0,0.1990521327014214,0.0,0.0,0.0,0.0,1.3127962085308127,0.00473933649290359,0.5023696682464518,2.3127962085308127,27.34597156398101,0.0,0.0,0.10526315789473806,0.04210526315789487,0.10526315789473628,0.0,0.1263157894736846,0.08421052631578974,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.3636363636363636,1.20382775119617,1.3636363636363635,0.07368421052631646,0.3636363636363636,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,6.0,0.0,0.0,19.649572649572644,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.70142180094787,0.0,7.0,0.3684210526315792,0.0,0.0,0.0,0.0,0.0631578947368423,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,6.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,14.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,19.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,0.0,3.0,1.0,20.0,47.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,1.074074074074094,0.0,0.0,0.7806267806267577,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,6.857416267942586,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,9.616113744075776,0.3127962085308127,5.16113744075831,2.4691943127962617,0.0,4.042654028435997,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,0.22105263157895033,0.3526315789473666,0.3526315789473666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333333,0.0,0.0,0.6666666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,26.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.287749287749289,0.5270655270655276,3.763532763532764,0.421652421652416,3.552713678800501e-15,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0758293838862585,0.0,0.0,0.0,0.9241706161137415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,51.383886255924125,0.0,20.616113744075875,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.056459330143536324,0.0,0.0,0.0,0.0,0.9435406698564637,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1908831908831914,1.8091168091168086,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,15.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3684210526315792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473806,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0631578947368423,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6068376068376091,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333333,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7962085308056857,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4102564102564124,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1990521327014214,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,1.0,0.6666666666666667,0.0,2.287749287749289,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.616113744075776,3.0,14.0,14.0,3.0758293838862585,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.07368421052631646,0.0,0.0,0.0,0.0,0.056459330143536324,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5270655270655276,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3127962085308127,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22105263157895033,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.763532763532764,0.0,0.0,0.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,0.0,5.16113744075831,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3526315789473666,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.421652421652416,0.0,0.0,1.8091168091168086,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4691943127962617,0.0,0.0,0.0,0.0,51.383886255924125,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3526315789473666,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,3.071225071225049,6.0,0.0,0.0,1.074074074074094,0.0,0.0,0.0,0.0,3.552713678800501e-15,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3127962085308127,0.0,12.0,3.0,0.0,0.0,0.0,0.0,0.0,0.9241706161137415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3636363636363636,6.0,0.0,0.0,6.857416267942586,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.336182336182337,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.00473933649290359,0.0,14.0,1.0,0.0,4.042654028435997,0.0,26.0,8.0,0.0,20.616113744075875,0.0,15.0,0.0,0.0,0.0,0.0,0.0,0.0,1.20382775119617,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9435406698564637,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9088319088319112,0.0,0.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5023696682464518,12.70142180094787,1.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.7635327635327647,19.649572649572644,0.0,1.0,0.7806267806267577,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3127962085308127,0.0,0.0,47.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7635327635327647,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,27.34597156398101,7.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3636363636363636,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.6752136752136764,0.5584045584045585,0.3504273504273563,1.1452991452991483,0.0,1.4102564102564124,1.4166666666666663,0.0,1.4166666666666663,0.6424501424501319,0.0,0.0,1.0,1.4166666666666663,1.4166666666666663,0.717948717948719,2.416666666666666,2.416666666666666,0.16587677725118688,0.16587677725118688,0.0,1.083333333333333,0.29857819905213034,0.0,0.4976303317535553,0.6966824644549732,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,1.083333333333333,1.2124802527645713,2.1943127962085365,2.6208530805687404,2.582938388625611,0.0,0.0,0.10526315789473806,0.04210526315789487,0.1263157894736846,0.0,0.10526315789473628,0.08421052631578974,0.0,0.14736842105263293,1.0,0.0,0.0,2.0,0.07368421052631646,0.7272727272727272,0.789473684210528,1.7894736842105279,1.0095693779904238,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.3147709320695098,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.121248025276461,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,7.0,0.0,5.873684210526314,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,7.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.0,39.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.5817663817663827,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.715789473684211,0.0,0.0,0.8947368421052637,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,1.5450236966824775,0.6966824644549803,1.8909952606635159,37.46919431279618,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22,0.22105263157895053,0.33789473684209903,0.22105263157895053,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,0.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25854700854701185,5.311965811965824,0.717948717948719,1.5726495726495717,0.0,1.1468660968660975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2389979688557964,1.7610020311442036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,39.4272173324303,0.0,0.0,0.0,0.1468630106070895,6.425919656962606,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2115789473684212,0.0,0.0,0.0,0.0,0.4937799043062222,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.45937711577534,9.232566012186709,1.3080568720379517,7.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473806,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083333333333333,0.3147709320695098,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1452991452991483,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4102564102564124,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666663,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666663,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25854700854701185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6424501424501319,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.311965811965822,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5450236966824775,0.0,0.0,0.0,0.0,39.4272173324303,9.45937711577534,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.22,0.0,0.0,0.0,0.0,0.2115789473684212,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549803,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22105263157895053,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5726495726495717,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8909952606635159,0.0,19.0,18.0,0.0,0.0,0.0,9.232566012186709,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.33789473684209903,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.0,0.0,37.46919431279618,0.0,9.0,0.0,0.0,0.0,0.0,1.3080568720379517,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.22105263157895053,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666663,6.0,0.0,0.0,0.5817663817663827,0.0,0.0,0.0,0.0,1.1468660968660975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083333333333333,0.0,0.0,39.0,0.0,0.0,0.0,0.0,0.0,1.2389979688557964,0.1468630106070895,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,4.0,0.0,0.0,0.715789473684211,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666663,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2124802527645713,14.121248025276461,30.0,20.0,0.0,0.0,0.0,0.0,9.0,1.7610020311442036,6.425919656962606,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7272727272727272,7.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4937799043062222,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1943127962085365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.789473684210528,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.416666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6208530805687404,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7894736842105279,5.873684210526314,0.0,0.0,0.8947368421052637,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.416666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.582938388625611,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0095693779904238,2.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.6752136752136764,0.5584045584045585,0.3504273504273563,0.41025641025641235,0.0,0.41025641025641235,1.583333333333333,0.0,1.583333333333333,0.0,0.0,1.0,2.0,1.583333333333333,1.7179487179487198,1.9088319088319112,2.5726495726495733,2.64601139601138,0.16587677725118688,0.16587677725118688,0.0,0.3981042654028428,0.3981042654028428,0.0,0.4976303317535553,0.6966824644549732,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,1.333333333333333,1.0047393364929036,0.15639810426540635,8.756714060031564,1.9289099526066495,0.0,0.0,0.10526315789473806,0.04210526315789487,0.1263157894736846,0.0,0.7272727272727272,0.7272727272727272,0.0,0.1263157894736846,0.2488038277511908,0.0,1.0,1.0,0.43157894736842195,1.727272727272727,0.43157894736842195,0.7272727272727272,0.5789473684210549,0.0,0.0,0.0,0.0,0.0,0.20512820512820618,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,3.0,0.0,0.0,17.58974358974359,6.205128205128204,0.16587677725118688,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.71090047393365,0.0,0.0,0.0,0.0,0.0,0.0,0.1894736842105269,0.3779904306220091,0.0,0.0,0.0,0.0,0.0,9.0,7.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,25.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,47.0,39.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.39999999999999997,0.0,1.4547008547008518,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.6666666666666665,2.9352290679304907,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,3.0736842105263165,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.09999999999999999,0.09999999999999999,0.09999999999999999,0.2333333333333351,0.2635327635327646,0.0,0.0,0.10313390313390025,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,0.3127962085308127,1.8909952606635159,1.1563981042654063,14.74881516587675,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23859649122806892,0.0,0.0,0.23859649122806892,0.23859649122806892,0.1052631578947384,0.17894736842105485,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25683760683760914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7431623931623909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,27.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9918803418803451,2.4706552706552674,0.617948717948719,1.1393162393162382,0.0,0.7801994301994308,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.725118483412316,0.2748815165876839,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,0.0,7.0,7.0,0.7156398104265804,2.2843601895734196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5799043062200948,0.0,0.0,0.0,0.0,0.4200956937799052,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30000000000000004,0.19999999999999998,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7772511848341281,3.222748815165872,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7221690590111732,0.8041467304625105,0.47368421052631643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473806,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20512820512820618,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1894736842105269,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7272727272727272,0.3779904306220091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.583333333333333,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.25683760683760914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7272727272727272,0.0,0.0,0.0,0.0,0.23859649122806892,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.583333333333333,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,0.9918803418803451,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,2.4706552706552674,0.0,0.30000000000000004,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,0.0,0.0,0.0,0.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2488038277511908,0.0,0.0,0.0,0.0,0.23859649122806892,0.0,0.0,0.0,0.0,0.5799043062200948,0.7221690590111732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09999999999999999,0.0,0.0,0.0,0.617948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3127962085308127,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23859649122806892,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.2333333333333351,0.0,0.0,0.0,1.1393162393162382,0.0,0.0,0.19999999999999998,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8909952606635159,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,9.0,0.0,0.0,0.0,0.1052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,0.8041467304625105,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.2635327635327646,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1563981042654063,0.0,1.0,24.0,1.725118483412316,7.0,0.0,0.7772511848341281,0.0,0.0,0.0,0.0,0.0,0.0,1.0,7.0,0.0,0.0,0.0,0.17894736842105485,0.0,0.0,0.0,0.0,0.0,0.0,0.47368421052631643,0.0,0.0,0.0,0.0,0.0,0.0,1.583333333333333,3.0,0.0,0.0,0.39999999999999997,0.0,0.0,0.0,0.0,0.7801994301994308,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.333333333333333,0.0,0.0,0.0,0.6666666666666665,14.74881516587675,0.0,27.0,0.0,0.2748815165876839,0.7156398104265804,0.0,3.222748815165872,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,4.0,0.0,0.0,3.0736842105263165,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7179487179487198,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0047393364929036,0.0,7.0,47.0,2.9352290679304907,17.0,0.0,0.0,0.0,0.0,2.2843601895734196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.727272727272727,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4200956937799052,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9088319088319112,0.0,1.0,18.0,1.4547008547008518,0.10313390313390025,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.15639810426540635,0.0,0.0,39.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5726495726495733,17.58974358974359,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.756714060031564,16.71090047393365,25.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7272727272727272,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.64601139601138,6.205128205128204,0.0,0.0,0.0,0.0,0.0,0.7431623931623909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9289099526066495,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5789473684210549,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,1.233618233618234,0.5584045584045585,0.41025641025641235,0.41025641025641235,0.0,0.6752136752136781,1.3418803418803458,0.0,0.9401709401709422,0.0,0.0,1.0,0.0,1.2499999999999998,0.717948717948719,0.717948717948719,3.980769230769214,1.7635327635327636,0.16587677725118688,0.0,0.0,0.3981042654028428,0.29857819905213034,0.0,0.5971563981042607,0.6966824644549732,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,1.2748815165876834,1.3127962085308127,1.5023696682464518,1.2748815165876834,22.881516587677716,0.0,0.0,0.10526315789473806,0.04210526315789487,0.14736842105263293,0.0,0.10526315789473628,0.3636363636363636,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.3636363636363636,0.14736842105263293,1.1617224880382733,0.07368421052631646,1.3636363636363635,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.794871794871753,16.794871794871835,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.876777251184834,0.0,0.0,6.0,0.3684210526315792,0.0,0.0,0.08421052631578974,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,4.0,0.0,4.0,4.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,0.0,28.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,3.0,4.0,2.0,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,45.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6303418803418843,0.0,0.0,0.0,0.0,0.0,0.3696581196581157,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.7014218009478697,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,4.141626794258375,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5450236966824775,0.3127962085308127,2.5829383886256068,2.559241706161103,44.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333333,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8782051282051249,0.9088319088319091,1.8782051282051266,0.0,0.3347578347578397,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.4549763033175225,7.0,0.41706161137440745,0.12796208530807007,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.25,0.25,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.322274881516549,0.6777251184834512,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35440467867445313,0.7859555553996158,1.859639765925931,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3684210526315792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.233618233618234,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5584045584045585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473806,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04210526315789487,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3418803418803458,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333333,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3636363636363636,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6303418803418843,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8782051282051249,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5450236966824775,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35440467867445313,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9088319088319091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3127962085308127,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8782051282051266,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5829383886256068,0.0,0.0,0.0,0.0,5.4549763033175225,0.0,3.322274881516549,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7859555553996158,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.559241706161103,0.0,22.0,22.0,1.0,7.0,0.0,0.6777251184834512,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.859639765925931,0.0,0.0,0.0,0.0,0.0,0.0,1.2499999999999998,0.0,0.0,3.0,0.3696581196581157,0.0,0.0,0.0,0.0,0.3347578347578397,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2748815165876834,0.0,0.0,0.0,0.7014218009478697,44.0,0.0,0.0,0.0,0.0,0.41706161137440745,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3636363636363636,4.0,0.0,0.0,4.141626794258375,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3127962085308127,11.876777251184834,29.0,26.0,2.0,0.0,0.0,0.0,0.0,0.0,0.12796208530807007,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,11.794871794871753,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5023696682464518,0.0,0.0,45.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1617224880382733,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.980769230769214,16.794871794871835,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2748815165876834,0.0,28.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7635327635327636,0.0,0.0,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.881516587677716,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,1.1818181818181817,0.0,0.3504273504273563,0.6752136752136781,0.0,0.6752136752136781,0.9401709401709422,0.0,1.1818181818181817,0.0,0.0,0.0,0.9228179228179094,1.1818181818181817,2.1818181818181817,2.1818181818181817,0.5726495726495724,0.9544159544159552,0.16587677725118688,0.0,0.0,1.222748815165879,0.4976303317535553,0.0,0.7962085308056857,0.5971563981042607,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.8909952606635159,0.00473933649290359,0.8483412322274901,9.696682464454947,2.5829383886256028,0.0,0.0,0.8181818181818181,0.08971291866028608,0.1263157894736846,0.0,0.0631578947368423,0.1263157894736846,0.0,0.10526315789473628,1.0,0.0,2.0,1.0,0.43157894736842195,0.8868421052631568,0.8868421052631568,0.8868421052631568,0.5789473684210549,0.0,0.051800051800052316,0.0,0.059829059829056064,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,3.0,0.0,12.0,1.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,1.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.43601895734597,0.0,0.0,0.0,0.6555023923444987,0.015550239234451091,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,61.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,83.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3981042654028428,0.0,0.5450236966824775,0.658767772511851,1.5829383886256068,2.502369668246452,0.0,0.0,0.31279620853077006,21.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2842105263157889,0.2842105263157889,0.14736842105263326,0.2842105263157889,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7583527583527605,1.536093536093536,0.717948717948719,1.4058904058904014,0.0,1.581714581714583,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.41832241832241995,0.5956635956635774,0.8407148407148544,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1818181818181817,0.051800051800052316,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8181818181818181,0.6555023923444987,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3504273504273563,0.059829059829056064,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.222748815165879,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08971291866028608,0.015550239234451091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7962085308056857,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0631578947368423,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1818181818181817,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7583527583527605,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.536093536093536,0.0,0.41832241832241995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5450236966824775,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.2842105263157889,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.658767772511851,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2842105263157889,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4058904058904014,0.0,0.0,0.5956635956635774,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5829383886256068,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.14736842105263326,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9228179228179094,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8407148407148544,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.502369668246452,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.2842105263157889,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1818181818181817,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.581714581714583,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,16.0,0.0,0.0,0.5052631578947384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1818181818181817,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.00473933649290359,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8868421052631568,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1818181818181817,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8483412322274901,0.0,0.0,0.0,0.0,0.31279620853077006,0.0,7.0,26.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8868421052631568,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5726495726495724,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.696682464454947,8.43601895734597,61.0,83.0,0.0,21.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8868421052631568,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9544159544159552,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5829383886256028,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5789473684210549,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,1.233618233618234,0.0,0.14529914529914834,0.6752136752136781,0.0,1.3636363636363635,0.9401709401709422,0.0,1.3636363636363635,0.0,0.9699559699559597,2.0,1.0,1.3636363636363635,0.9088319088319103,0.717948717948719,1.3636363636363635,0.9544159544159552,0.16587677725118688,0.0,0.0,0.3981042654028428,0.29857819905213034,0.0,0.7962085308056857,0.4976303317535553,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,6.191153238546562,1.6334913112164469,1.502369668246453,1.9289099526066462,1.890995260663517,0.0,0.0,0.4736842105263168,0.14736842105263293,0.16842105263157947,0.0,0.0631578947368423,0.14736842105263293,0.0,0.08421052631578974,0.0,0.0,1.0,1.0,0.43157894736842195,0.5052631578947384,1.7894736842105279,0.07368421052631646,2.1157894736842007,0.0,0.0,0.0,0.5299145299145298,0.0,0.9401709401709422,0.3115773115773146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.71090047393365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,4.0,6.8315789473684205,9.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,32.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,55.0,31.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6153846153846203,0.0,0.0,0.0,0.0,0.0,1.3998963998964002,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,1.5181674565560286,0.0,0.0,0.0,1.183254344391841,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.715789473684211,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,50.51658767772506,0.6966824644549803,2.241706161137472,2.5450236966824846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23157894736842136,0.38421052631578934,0.38421052631578934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5555925932098559,0.0,0.0,0.0,0.2701421800948083,1.1742652266953357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2842105263157876,0.0,0.0,0.0,0.0,0.7157894736842124,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.233618233618234,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4736842105263168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.5299145299145298,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.3115773115773146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7962085308056857,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0631578947368423,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6153846153846203,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,1.5181674565560286,50.51658767772506,0.0,0.0,0.0,0.0,0.5555925932098559,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23157894736842136,0.2842105263157876,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9699559699559597,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549803,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.38421052631578934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,55.0,0.0,2.241706161137472,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.38421052631578934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,32.0,31.0,0.0,2.5450236966824846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,1.3998963998964002,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.191153238546562,18.71090047393365,7.0,0.0,1.183254344391841,0.0,0.0,0.0,13.0,0.0,0.2701421800948083,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43157894736842195,2.0,2.0,0.0,0.715789473684211,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9088319088319103,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6334913112164469,0.0,0.0,0.0,0.0,0.0,0.0,8.0,17.0,0.0,1.1742652266953357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5052631578947384,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7157894736842124,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.502369668246453,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7894736842105279,6.8315789473684205,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9289099526066462,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9544159544159552,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.890995260663517,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1157894736842007,2.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.9544159544159552,0.0,0.18900543900543987,1.2727272727272725,0.0,1.2727272727272725,0.9401709401709422,0.0,0.9401709401709422,1.0,0.0,0.0,0.0,0.5726495726495724,1.316433566433564,0.9088319088319103,2.316433566433564,2.316433566433564,0.16587677725118688,0.5829383886255934,0.0,0.3981042654028428,0.29857819905213034,0.0,0.6966824644549732,0.4976303317535553,0.0,0.8720379146919441,0.0,0.0,0.0,0.0,0.5450236966824775,0.9668246445497743,1.848341232227491,2.582938388625611,9.54502369668242,0.0,0.0,0.4736842105263168,0.1263157894736846,0.16842105263157947,0.0,0.08421052631578974,0.14736842105263293,0.0,0.7997607655502382,0.0,0.0,0.0,1.0,0.7272727272727272,1.7997607655502381,0.7997607655502382,0.07368421052631646,1.7997607655502381,0.0,0.0,0.0,0.22125097125097248,0.0,0.6752136752136781,1.4024864024864057,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,2.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.71090047393365,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.0,14.0,0.0,0.0,32.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,31.0,57.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4024864024864057,0.0,0.0,0.0,0.8803418803418843,0.0,0.0,0.0,0.0,0.0,0.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,3.2748815165876834,0.0,0.4265402843601862,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,1.0622009569378004,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9289099526066451,1.0047393364929036,31.639810426540258,22.426540284360193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666666,0.6666666666666666,0.6666666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9544159544159552,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5829383886255934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4736842105263168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18900543900543987,0.22125097125097248,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.0,0.0,1.4024864024864057,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16842105263157947,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6752136752136781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1232227488151665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,1.4024864024864057,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6966824644549732,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4976303317535553,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8803418803418843,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1052631578947363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9401709401709422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8720379146919441,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7997607655502382,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9289099526066451,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0047393364929036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666666,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,3.2748815165876834,31.639810426540258,0.0,22.0,17.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.426540284360193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5726495726495724,3.0,0.0,0.0,0.1908831908831914,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5450236966824775,0.0,19.0,31.0,0.4265402843601862,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7272727272727272,2.0,0.0,0.0,1.0622009569378004,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.316433566433564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9668246445497743,0.0,14.0,57.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7997607655502381,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9088319088319103,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.848341232227491,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7997607655502382,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.316433566433564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.582938388625611,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.07368421052631646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.316433566433564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.54502369668242,16.71090047393365,32.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7997607655502381,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.23361823361823397,0.0,0.41025641025641235,1.3636363636363635,0.0,1.3636363636363635,1.6752136752136784,0.0,1.532356532356536,0.0,2.0,0.0,0.0,0.7635327635327638,0.717948717948719,2.9088319088319112,1.7635327635327647,0.2674362674362527,0.16587677725118688,0.0,0.0,0.3981042654028428,0.3981042654028428,0.0,0.5971563981042607,0.5971563981042607,0.0,1.0909090909090908,0.0,0.0,0.0,0.0,0.8909952606635159,2.541576906505816,1.541576906505816,1.541576906505816,2.2369668246445515,0.0,0.0,0.4736842105263168,0.1263157894736846,0.14736842105263293,0.0,0.909090909090909,0.10526315789473628,0.0,0.08421052631578974,0.0,0.0,0.0,1.0,0.7894736842105274,2.142583732057415,1.1425837320574148,1.1425837320574148,1.9368421052631593,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.3115773115773146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,8.543123543123539,0.0,0.0,18.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.5355450236966846,15.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.19617224880382733,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.0,0.0,0.0,59.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,10.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,92.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.25,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,3.572649572649574,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,3.601895734597157,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5062473071951699,39.98190435157258,0.35071090047394193,1.9668246445497743,0.1943127962085356,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06157731157731461,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,20.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14285714285714282,0.28571428571428575,0.28571428571428575,0.28571428571428575,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16587677725118688,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23361823361823397,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4736842105263168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41025641025641235,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,1.25,0.06157731157731461,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14736842105263293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29857819905213034,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1263157894736846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.3115773115773146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.909090909090909,0.19617224880382733,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6752136752136784,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5971563981042607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14529914529914834,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3981042654028428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.10526315789473628,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.532356532356536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14285714285714282,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0909090909090908,0.0,0.0,0.0,0.0,0.5062473071951699,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08421052631578974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.28571428571428575,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.0,1.0,0.0,39.98190435157258,0.0,20.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.28571428571428575,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35071090047394193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.28571428571428575,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,92.0,0.0,1.9668246445497743,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.5355450236966846,59.0,0.0,0.0,0.1943127962085356,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7635327635327638,1.0,1.0,4.0,3.5726495726495706,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8909952606635159,15.0,0.0,0.0,3.601895734597157,0.0,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7894736842105274,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.717948717948719,8.543123543123539,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.541576906505816,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.142583732057415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9088319088319112,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.541576906505816,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1425837320574148,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7635327635327647,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.541576906505816,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1425837320574148,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2674362674362527,18.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2369668246445515,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9368421052631593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_offloaded.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_offloaded.csv
new file mode 100644
index 0000000..7bb0853
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_offloaded.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.11680911680911699,0.33175355450237376,0.0,0.5584045584045585,0.0,1.105263157894738,0.3504273504273563,1.1232227488151665,0.04210526315789487,0.14529914529914834,0.3981042654028428,0.10526315789473628,0.3504273504273563,0.3981042654028428,0.04210526315789487,0.14529914529914834,0.0995260663507107,0.16842105263157947,1.9401709401709422,0.6966824644549732,0.10526315789473628,0.25883190883190804,0.5971563981042607,0.08421052631578974,1.1452991452991483,0.0,0.18947368421052602,4.954415954415955,43.355450236966846,6.053588516746405,1.5270655270655276,0.3127962085308127,0.0,2.763532763532764,10.815165876777257,1.22105263157895,0.25883190883190804,65.12322274881518,0.5052631578947384,4.954415954415955,48.50710900473935,9.863157894736844,2.1452991452991466,92.38733304610076,3.789473684210527,20.71794871794872,39.50236966824645,1.0803827751196171,29.222222222222214,47.74536837570011,1.0803827751196171,17.422364672364658,2.274881516587687,1.0803827751196171
+0.0,0.0,0.3684210526315792,0.0,0.16587677725118688,0.0,0.6752136752136764,0.16587677725118688,0.0,0.5584045584045585,0.0,0.10526315789473806,0.3504273504273563,0.12322274881516648,0.04210526315789487,0.14529914529914834,0.4976303317535553,0.08421052631578974,0.3504273504273563,0.3981042654028428,0.04210526315789487,1.1452991452991483,0.1990521327014214,0.14736842105263293,1.9401709401709422,0.6966824644549732,0.10526315789473628,0.14529914529914834,0.4976303317535553,0.08421052631578974,1.4102564102564124,0.0995260663507107,0.18947368421052602,2.7635327635327642,42.04739336492892,4.866666666666668,0.717948717948719,0.9289099526066451,0.30877192982456114,2.7635327635327642,7.815165876777257,1.221052631578948,1.35,63.55829383886254,3.1684210526315773,4.068518518518516,11.658767772511844,19.294736842105266,2.1452991452991443,123.23317535545024,2.866666666666667,23.559116809116805,41.10426540284361,1.4877192982456129,29.87179487179486,55.31279620853081,0.4877192982456128,13.039458689458678,31.497630331753527,1.4877192982456129
+0.0,0.0,0.3684210526315792,0.0,0.16587677725118688,0.0,0.6752136752136764,0.16587677725118688,0.0,0.5584045584045585,0.0,0.10526315789473806,0.3504273504273563,0.3981042654028428,0.04210526315789487,0.41025641025641235,0.4976303317535553,0.10526315789473628,0.3504273504273563,0.29857819905213034,0.0631578947368423,0.14529914529914834,0.29857819905213034,0.1263157894736846,1.9401709401709424,0.7962085308056857,0.08421052631578974,0.14529914529914834,0.3981042654028428,1.1052631578947363,1.4102564102564124,0.1990521327014214,0.16842105263157947,6.954415954415956,44.691943127962034,7.130143540669852,0.5270655270655276,0.3127962085308127,0.22105263157895033,3.954415954415955,16.16113744075831,0.8526315789473666,3.2307692307692246,54.85308056872039,0.8526315789473666,10.145299145299147,17.236966824644554,13.22105263157895,5.336182336182337,88.66350710900477,4.147368421052633,21.90883190883191,34.20379146919432,1.3636363636363635,24.193732193732167,49.31279620853081,0.07368421052631646,1.7635327635327647,35.34597156398101,0.3636363636363636
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.6752136752136764,0.16587677725118688,0.0,0.5584045584045585,0.0,0.10526315789473806,0.3504273504273563,1.3981042654028428,0.04210526315789487,1.1452991452991483,0.29857819905213034,0.1263157894736846,0.41025641025641235,0.3981042654028428,0.1263157894736846,1.4102564102564124,0.4976303317535553,0.10526315789473628,1.4166666666666663,0.6966824644549732,0.08421052631578974,0.14529914529914834,0.3981042654028428,1.1052631578947363,1.6752136752136781,0.3981042654028428,0.14736842105263293,5.954415954415954,50.43161814488812,1.4315789473684213,0.717948717948719,0.6966824644549803,0.22105263157895053,1.5726495726495717,48.123561272850225,0.33789473684209903,1.0,78.77725118483414,2.2210526315789507,9.145299145299147,48.46919431279622,4.789473684210527,1.4166666666666663,84.52064996614784,10.22105263157895,0.717948717948719,2.1943127962085365,7.789473684210528,2.416666666666666,2.6208530805687404,8.557894736842105,2.416666666666666,2.582938388625611,4.009569377990424
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.6752136752136764,0.16587677725118688,0.0,0.5584045584045585,0.0,0.10526315789473806,0.3504273504273563,0.3981042654028428,0.04210526315789487,0.41025641025641235,0.3981042654028428,0.1263157894736846,0.20512820512820618,1.1232227488151665,0.1894736842105269,0.41025641025641235,0.4976303317535553,1.1052631578947363,1.9401709401709422,0.6966824644549732,0.9658692185007961,0.14529914529914834,0.3981042654028428,1.1052631578947363,2.675213675213678,0.4976303317535553,0.1263157894736846,5.870655270655268,13.890995260663516,1.7894736842105279,0.717948717948719,0.3127962085308127,0.23859649122806892,2.5726495726495733,8.890995260663516,10.90940988835725,2.7635327635327647,35.65876777251185,8.652631578947371,5.763532763532764,47.96208530805689,7.505263157894738,1.7179487179487198,77.22432859399682,2.147368421052632,23.46666666666666,39.156398104265406,0.43157894736842195,27.162393162393165,50.46761453396521,0.7272727272727272,9.594301994301976,1.9289099526066495,0.5789473684210549
+0.0,0.0,0.3684210526315792,0.0,0.16587677725118688,0.0,1.233618233618234,0.0,0.0,0.5584045584045585,0.0,0.10526315789473806,0.41025641025641235,0.3981042654028428,0.1263157894736846,0.41025641025641235,0.29857819905213034,0.14736842105263293,0.41025641025641235,1.1232227488151665,0.1263157894736846,0.6752136752136781,0.5971563981042607,0.10526315789473628,1.675213675213679,0.6966824644549732,0.3636363636363636,0.8803418803418843,0.29857819905213034,0.10526315789473628,0.9401709401709422,0.5971563981042607,0.1263157894736846,2.128205128205125,0.5450236966824775,4.354404678674453,0.9088319088319091,0.3127962085308127,0.0,3.128205128205127,11.360189573459678,4.785955555399616,0.25,55.236966824644554,5.859639765925931,4.954415954415955,46.39336492890996,8.505263157894738,3.717948717948719,70.31753554502372,0.14736842105263293,16.512820512820472,46.50236966824645,1.1617224880382733,22.77564102564105,48.27488151658768,0.07368421052631646,13.763532763532764,28.881516587677716,1.3636363636363635
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,1.233618233618234,0.0,0.0,0.0,0.0,1.4736842105263168,0.41025641025641235,1.222748815165879,0.10526315789473717,0.6752136752136781,0.4976303317535553,0.1263157894736846,0.9401709401709422,1.3981042654028428,0.16842105263157947,0.6752136752136781,0.7962085308056857,0.0631578947368423,0.9401709401709422,0.5971563981042607,0.1263157894736846,0.14529914529914834,1.3981042654028428,1.1052631578947363,1.9401709401709422,0.6966824644549732,0.10526315789473628,4.954415954415956,0.5450236966824775,1.284210526315789,0.717948717948719,0.658767772511851,0.2842105263157889,14.001554001553979,1.5829383886256068,2.1473684210526334,2.763532763532764,2.502369668246452,1.284210526315789,2.7635327635327647,0.8909952606635159,16.93684210526316,2.1818181818181817,0.00473933649290359,0.8868421052631568,2.1818181818181817,39.16113744075826,0.8868421052631568,0.5726495726495724,183.1327014218009,0.8868421052631568,0.9544159544159552,2.5829383886256028,0.5789473684210549
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,1.233618233618234,0.0,0.0,0.0,0.0,0.4736842105263168,0.6752136752136781,0.3981042654028428,0.14736842105263293,0.6752136752136781,0.29857819905213034,0.16842105263157947,0.9401709401709422,1.1232227488151665,0.16842105263157947,1.6752136752136781,0.7962085308056857,0.0631578947368423,0.9401709401709422,0.4976303317535553,0.14736842105263293,0.6153846153846203,0.29857819905213034,0.08421052631578974,1.3636363636363635,0.6966824644549732,0.08421052631578974,0.0,58.59034772749095,2.515789473684209,0.9699559699559597,0.6966824644549803,0.38421052631578934,2.0,81.24170616113747,1.3842105263157893,1.0,65.54502369668248,1.0,2.763532763532764,46.35545023696686,5.147368421052633,0.9088319088319103,27.807756537911782,5.221052631578951,0.717948717948719,1.502369668246453,8.621052631578948,2.3636363636363633,1.9289099526066462,9.073684210526316,0.9544159544159552,1.890995260663517,5.115789473684201
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.9544159544159552,0.5829383886255934,0.0,0.0,0.0,0.4736842105263168,0.41025641025641235,0.3981042654028428,0.1263157894736846,2.675213675213678,0.29857819905213034,0.16842105263157947,0.6752136752136781,2.1232227488151665,0.14736842105263293,2.675213675213678,0.6966824644549732,0.08421052631578974,0.9401709401709422,0.4976303317535553,0.14736842105263293,0.8803418803418843,0.29857819905213034,1.1052631578947363,0.9401709401709422,0.8720379146919441,0.7997607655502382,1.6666666666666665,0.9289099526066451,0.0,0.6666666666666666,1.0047393364929036,0.0,0.6666666666666666,77.91469194312793,0.0,0.0,22.426540284360193,1.0,3.763532763532764,50.971563981042664,3.7894736842105274,1.316433566433564,71.96682464454977,1.7997607655502381,0.9088319088319103,1.848341232227491,0.7997607655502382,2.316433566433564,2.582938388625611,0.07368421052631646,2.316433566433564,59.25592417061607,1.7997607655502381
+0.0,0.16587677725118688,0.0,0.0,0.16587677725118688,0.0,0.23361823361823397,0.0,0.0,0.0,0.0,0.4736842105263168,0.41025641025641235,0.3981042654028428,0.1263157894736846,2.675213675213678,0.3981042654028428,0.14736842105263293,0.14529914529914834,0.29857819905213034,0.1263157894736846,1.6752136752136781,0.5971563981042607,1.1052631578947363,1.6752136752136784,0.5971563981042607,0.10526315789473628,0.14529914529914834,0.3981042654028428,0.10526315789473628,1.6752136752136788,1.5971563981042607,0.08421052631578974,0.28571428571428575,76.48190435157258,0.0,2.2857142857142856,0.35071090047394193,0.0,0.28571428571428575,94.46682464454977,0.0,0.0,65.72985781990522,1.0,10.336182336182334,24.492890995260673,0.7894736842105274,19.261072261072258,2.541576906505816,2.142583732057415,2.9088319088319112,1.541576906505816,1.1425837320574148,1.7635327635327647,1.541576906505816,1.1425837320574148,19.267436267436253,2.2369668246445515,1.9368421052631593
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_replicas.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_replicas.csv
new file mode 100644
index 0000000..15ef9a1
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_replicas.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,16.0,0.0,0.0,16.0,0.0,4.0,16.0,0.0,2.0,0.0,6.0,10.0,15.0,2.0,7.0,16.0,5.0,10.0,16.0,2.0,7.0,4.0,8.0,4.0,28.0,5.0,6.0,24.0,4.0,7.0,0.0,9.0,5.0,51.0,6.0,8.0,28.0,9.0,4.0,41.0,9.0,3.0,43.0,7.0,5.0,39.0,8.0,6.0,58.0,5.0,15.0,28.0,6.0,12.0,45.0,4.0,9.0,31.0,9.0
+0.0,0.0,4.0,0.0,16.0,0.0,6.0,8.0,0.0,2.0,0.0,6.0,10.0,15.0,2.0,7.0,20.0,4.0,10.0,16.0,2.0,7.0,8.0,7.0,4.0,28.0,5.0,7.0,20.0,4.0,6.0,4.0,9.0,4.0,49.0,6.0,9.0,24.0,9.0,4.0,41.0,9.0,4.0,41.0,9.0,5.0,27.0,12.0,6.0,70.0,6.0,16.0,28.0,5.0,12.0,48.0,3.0,7.0,40.0,10.0
+0.0,0.0,4.0,0.0,16.0,0.0,6.0,8.0,0.0,2.0,0.0,6.0,10.0,16.0,2.0,6.0,20.0,5.0,10.0,12.0,3.0,7.0,12.0,6.0,4.0,32.0,4.0,7.0,16.0,5.0,6.0,8.0,8.0,5.0,51.0,6.0,8.0,28.0,9.0,5.0,40.0,9.0,5.0,38.0,8.0,6.0,34.0,9.0,8.0,60.0,6.0,16.0,26.0,6.0,11.0,46.0,3.0,4.0,42.0,9.0
+0.0,16.0,0.0,0.0,16.0,0.0,6.0,8.0,0.0,2.0,0.0,6.0,10.0,16.0,2.0,7.0,12.0,6.0,6.0,16.0,6.0,6.0,20.0,5.0,5.0,28.0,4.0,7.0,16.0,5.0,5.0,16.0,7.0,5.0,55.0,4.0,9.0,24.0,9.0,3.0,53.0,7.0,4.0,44.0,9.0,6.0,45.0,5.0,8.0,57.0,9.0,9.0,11.0,8.0,4.0,30.0,8.0,4.0,33.0,11.0
+0.0,16.0,0.0,0.0,16.0,0.0,6.0,8.0,0.0,2.0,0.0,6.0,10.0,16.0,2.0,6.0,16.0,6.0,3.0,15.0,9.0,6.0,20.0,5.0,4.0,28.0,5.0,7.0,16.0,5.0,5.0,20.0,6.0,6.0,40.0,5.0,9.0,28.0,8.0,3.0,38.0,11.0,4.0,27.0,13.0,4.0,49.0,7.0,9.0,55.0,6.0,17.0,29.0,4.0,11.0,48.0,4.0,7.0,32.0,10.0
+0.0,0.0,4.0,0.0,16.0,0.0,8.0,0.0,0.0,2.0,0.0,6.0,6.0,16.0,6.0,6.0,12.0,7.0,6.0,15.0,6.0,5.0,24.0,5.0,5.0,28.0,4.0,8.0,12.0,5.0,4.0,24.0,6.0,5.0,36.0,5.0,10.0,28.0,7.0,5.0,37.0,8.0,3.0,34.0,12.0,5.0,48.0,7.0,10.0,54.0,6.0,14.0,30.0,4.0,10.0,49.0,3.0,8.0,41.0,11.0
+0.0,16.0,0.0,0.0,16.0,0.0,8.0,0.0,0.0,0.0,0.0,8.0,6.0,19.0,5.0,5.0,20.0,6.0,4.0,16.0,8.0,5.0,32.0,3.0,4.0,24.0,6.0,7.0,16.0,5.0,4.0,28.0,5.0,5.0,36.0,4.0,9.0,27.0,8.0,7.0,33.0,6.0,4.0,13.0,11.0,4.0,35.0,11.0,10.0,26.0,7.0,10.0,27.0,4.0,3.0,100.0,4.0,5.0,33.0,10.0
+0.0,16.0,0.0,0.0,16.0,0.0,8.0,0.0,0.0,0.0,0.0,8.0,5.0,16.0,7.0,5.0,12.0,8.0,4.0,15.0,8.0,5.0,32.0,3.0,4.0,20.0,7.0,9.0,12.0,4.0,5.0,28.0,4.0,4.0,57.0,5.0,10.0,24.0,8.0,4.0,60.0,5.0,4.0,36.0,11.0,4.0,51.0,6.0,10.0,39.0,9.0,9.0,13.0,8.0,4.0,32.0,7.0,5.0,35.0,12.0
+0.0,16.0,0.0,0.0,16.0,0.0,7.0,4.0,0.0,0.0,0.0,8.0,6.0,16.0,6.0,5.0,12.0,8.0,5.0,15.0,7.0,5.0,28.0,4.0,4.0,20.0,7.0,8.0,12.0,5.0,4.0,25.0,5.0,4.0,32.0,4.0,9.0,26.0,7.0,4.0,61.0,4.0,4.0,19.0,11.0,4.0,55.0,5.0,10.0,56.0,8.0,10.0,12.0,4.0,4.0,33.0,3.0,7.0,56.0,11.0
+0.0,16.0,0.0,0.0,16.0,0.0,8.0,0.0,0.0,0.0,0.0,8.0,6.0,16.0,6.0,5.0,16.0,7.0,7.0,12.0,6.0,5.0,24.0,5.0,5.0,24.0,5.0,7.0,16.0,5.0,5.0,24.0,4.0,4.0,64.0,4.0,10.0,25.0,7.0,4.0,64.0,4.0,4.0,36.0,11.0,7.0,44.0,5.0,15.0,30.0,9.0,10.0,15.0,4.0,4.0,35.0,4.0,12.0,34.0,11.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_residual_capacity.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_residual_capacity.csv
new file mode 100644
index 0000000..7743f00
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_residual_capacity.csv
@@ -0,0 +1,11 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,768.0,3328.0,1280.0,6656.0,4096.0,4864.0,6400.0
+0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,0.0,0.0,1792.0,0.0,768.0,768.0,256.0,2560.0,4096.0,5120.0,5120.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,1536.0,512.0,3072.0,3584.0,6656.0,8704.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1280.0,0.0,768.0,0.0,1792.0,768.0,12544.0,12800.0,8960.0
+0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,3072.0,0.0,512.0,256.0,768.0,3328.0,3840.0,5120.0,7168.0
+0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,5120.0,0.0,1792.0,512.0,0.0,2560.0,6656.0,6912.0,2816.0
+0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,0.0,0.0,6144.0,256.0,2816.0,5888.0,256.0,8704.0,11520.0,0.0,8960.0
+0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,768.0,0.0,0.0,0.0,1280.0,3328.0,12032.0,13312.0,6400.0
+0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,768.0,8192.0,1536.0,768.0,4352.0,1280.0,0.0,15360.0,17152.0,0.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1024.0,0.0,768.0,0.0,0.0,1024.0,512.0,14592.0,15616.0,512.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_solution.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_solution.csv
new file mode 100644
index 0000000..cba9d23
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_loc,n0_f1_loc,n0_f2_loc,n1_f0_loc,n1_f1_loc,n1_f2_loc,n2_f0_loc,n2_f1_loc,n2_f2_loc,n3_f0_loc,n3_f1_loc,n3_f2_loc,n4_f0_loc,n4_f1_loc,n4_f2_loc,n5_f0_loc,n5_f1_loc,n5_f2_loc,n6_f0_loc,n6_f1_loc,n6_f2_loc,n7_f0_loc,n7_f1_loc,n7_f2_loc,n8_f0_loc,n8_f1_loc,n8_f2_loc,n9_f0_loc,n9_f1_loc,n9_f2_loc,n10_f0_loc,n10_f1_loc,n10_f2_loc,n11_f0_loc,n11_f1_loc,n11_f2_loc,n12_f0_loc,n12_f1_loc,n12_f2_loc,n13_f0_loc,n13_f1_loc,n13_f2_loc,n14_f0_loc,n14_f1_loc,n14_f2_loc,n15_f0_loc,n15_f1_loc,n15_f2_loc,n16_f0_loc,n16_f1_loc,n16_f2_loc,n17_f0_loc,n17_f1_loc,n17_f2_loc,n18_f0_loc,n18_f1_loc,n18_f2_loc,n19_f0_loc,n19_f1_loc,n19_f2_loc,n0_f0_fwd,n0_f1_fwd,n0_f2_fwd,n1_f0_fwd,n1_f1_fwd,n1_f2_fwd,n2_f0_fwd,n2_f1_fwd,n2_f2_fwd,n3_f0_fwd,n3_f1_fwd,n3_f2_fwd,n4_f0_fwd,n4_f1_fwd,n4_f2_fwd,n5_f0_fwd,n5_f1_fwd,n5_f2_fwd,n6_f0_fwd,n6_f1_fwd,n6_f2_fwd,n7_f0_fwd,n7_f1_fwd,n7_f2_fwd,n8_f0_fwd,n8_f1_fwd,n8_f2_fwd,n9_f0_fwd,n9_f1_fwd,n9_f2_fwd,n10_f0_fwd,n10_f1_fwd,n10_f2_fwd,n11_f0_fwd,n11_f1_fwd,n11_f2_fwd,n12_f0_fwd,n12_f1_fwd,n12_f2_fwd,n13_f0_fwd,n13_f1_fwd,n13_f2_fwd,n14_f0_fwd,n14_f1_fwd,n14_f2_fwd,n15_f0_fwd,n15_f1_fwd,n15_f2_fwd,n16_f0_fwd,n16_f1_fwd,n16_f2_fwd,n17_f0_fwd,n17_f1_fwd,n17_f2_fwd,n18_f0_fwd,n18_f1_fwd,n18_f2_fwd,n19_f0_fwd,n19_f1_fwd,n19_f2_fwd,n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,15.0,0.0,0.0,15.0,0.0,9.0,30.0,0.0,4.0,0.0,9.0,27.0,33.0,4.0,19.0,36.0,10.0,27.0,36.0,4.0,19.0,9.0,16.0,9.0,63.0,10.0,16.0,54.0,8.0,18.0,0.0,18.0,11.0,92.0,7.0,24.0,74.0,21.0,10.0,98.0,20.0,9.0,49.0,16.0,11.0,55.0,9.0,17.0,59.0,8.0,27.0,34.0,13.0,9.0,71.0,8.0,11.0,80.0,20.0,23.0,15.0,6.999999999999998,28.0,27.0,12.0,2.0,0.0,2.0,23.0,77.0,0.0,0.0,0.0,3.5157894736842117,1.0,22.0,0.0,1.0,3.0,0.0,1.0,61.0,0.0,0.0,34.0,0.0,9.97706552706553,2.0,0.0,0.0,89.0,1.0,0.0,0.0,0.0,0.0,24.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7763568394002505e-15,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,15.484210526315788,0.0,0.0,0.0,0.0,0.0,19.0,0.0,0.0,1.0,0.0,0.0,0.0,4.02293447293447,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,3.0,0.0,15.0,0.0,13.0,15.0,0.0,4.0,0.0,10.0,27.0,34.0,4.0,19.0,45.0,8.0,27.0,36.0,4.0,18.0,18.0,14.0,9.0,63.0,10.0,19.0,45.0,8.0,15.0,9.0,18.0,10.0,88.0,7.0,28.0,62.0,20.0,10.0,101.0,20.0,11.0,45.0,18.0,11.0,60.0,9.0,17.0,62.0,9.0,27.0,33.0,10.0,8.0,72.0,6.0,9.0,74.0,22.0,21.0,37.0,5.0,30.0,17.0,14.0,0.0,23.0,4.0,23.0,84.0,0.0,2.0,0.0,9.357894736842109,1.0,22.0,0.9999999999999999,2.0,2.0,0.0,0.0,53.0,0.0,0.0,37.0,0.0,8.0,0.0,0.0,0.0,77.0,1.0,0.0,0.0,0.0,0.0,28.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,7.642105263157891,0.0,0.0,1.1102230246251565e-16,0.0,0.0,18.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,3.0,0.0,15.0,0.0,13.0,15.0,0.0,4.0,0.0,10.0,27.0,36.0,4.0,16.0,45.0,10.0,27.0,27.0,6.0,19.0,27.0,12.0,9.0,72.0,8.0,19.0,36.0,9.0,15.0,18.0,16.0,9.0,89.0,7.0,25.0,74.0,21.0,12.0,90.0,20.0,11.0,46.0,18.0,9.0,73.0,8.0,20.0,69.0,10.0,29.0,34.0,12.0,10.0,72.0,7.0,11.0,76.0,20.0,19.0,34.0,4.0,29.0,20.0,15.431578947368422,0.0,28.0,0.0,23.0,82.0,0.0,2.0,0.0,7.962679425837322,0.0,22.0,1.0,1.0,3.0,0.0,1.0,40.0,0.0,0.0,22.0,0.0,7.0,4.0,0.0,0.0,73.0,1.0,0.0,0.0,0.0,2.0,16.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.568421052631578,0.0,0.0,11.0,0.0,0.0,0.0,0.0,0.0,11.037320574162678,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,13.0,15.0,0.0,4.0,0.0,10.0,27.0,35.0,4.0,18.0,27.0,12.0,16.0,36.0,12.0,15.0,45.0,10.0,12.0,63.0,8.0,19.0,36.0,9.0,12.0,36.0,14.0,10.0,94.0,8.0,28.0,63.0,21.0,8.0,91.0,16.0,11.0,38.0,19.0,10.0,70.0,7.0,24.0,66.0,11.0,28.0,27.0,11.0,10.0,77.0,10.0,10.0,85.0,21.0,17.0,13.0,8.0,6.410256410256412,15.0,19.0,0.0,30.0,10.0,0.0,90.0,0.0,0.7270655270655311,0.0,2.715789473684211,0.0,42.0,1.0,0.0,0.0,0.0,0.0,28.0,0.0,0.0,27.0,0.0,9.007977207977223,3.0,0.0,0.0,46.0,0.7053588516746434,0.0,0.0,0.0,0.0,29.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.589743589743588,0.0,0.0,0.0,0.0,1.0,25.0,0.0,2.0,0.27293447293446893,0.0,14.284210526315789,0.0,0.0,0.0,13.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9920227920227767,0.0,0.0,0.0,0.0,0.2946411483253566,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,13.0,15.0,0.0,4.0,0.0,10.0,27.0,36.0,4.0,16.0,36.0,12.0,8.0,33.0,18.0,16.0,45.0,9.0,9.0,63.0,9.0,19.0,36.0,9.0,11.0,45.0,12.0,12.0,92.0,10.0,28.0,74.0,18.0,7.0,91.0,15.0,10.0,36.0,22.0,7.0,80.0,9.0,27.0,68.0,12.0,30.0,37.0,9.0,7.0,76.0,8.0,12.0,83.0,23.0,19.0,16.0,8.0,30.0,18.0,20.567464114832536,1.0,32.0,0.0,25.0,86.0,0.0,2.0,4.0,4.178947368421053,1.0,36.0,1.0,0.0,0.0,0.0,1.0,28.0,0.0,0.0,24.0,0.0,7.0,2.0,0.0,0.0,30.0,1.0,0.0,0.0,0.0,1.0,4.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43253588516746433,0.0,0.0,11.0,0.0,0.0,2.0,0.0,0.0,11.821052631578947,0.0,0.0,0.0,22.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,3.0,0.0,15.0,0.0,17.0,0.0,0.0,4.0,0.0,10.0,16.0,36.0,12.0,16.0,27.0,14.0,16.0,33.0,12.0,13.0,54.0,10.0,12.0,63.0,7.0,21.0,27.0,10.0,10.0,54.0,12.0,11.0,95.0,7.0,31.0,74.0,16.0,10.0,85.0,14.0,9.0,35.0,22.0,11.0,81.0,8.0,28.0,73.0,14.0,28.0,33.0,8.0,9.0,81.0,7.0,11.0,79.0,24.0,15.0,31.0,4.0,29.0,19.0,16.578947368421055,0.0,57.0,0.0,24.0,90.0,0.0,1.0,3.0,4.246889952153111,0.0,50.0,0.0,0.0,0.0,0.0,0.3333333333333333,22.0,0.0,0.0,22.0,0.0,5.000000000000001,1.0,0.0,0.0,13.0,0.0,0.0,0.0,0.0,1.0,4.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.421052631578945,0.0,0.0,14.0,0.0,0.0,2.0,11.0,0.0,2.7531100478468886,0.0,0.0,0.0,12.0,0.0,6.0,0.6666666666666667,0.0,0.0,0.0,0.0,0.0,-8.881784197001252e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,17.0,0.0,0.0,0.0,0.0,12.0,16.0,42.0,10.0,13.0,45.0,12.0,10.0,35.0,16.0,13.0,72.0,6.0,10.0,54.0,12.0,19.0,35.0,9.0,9.0,63.0,10.0,11.0,95.0,8.0,28.0,71.0,18.0,8.0,86.0,12.0,10.0,32.0,24.0,10.0,92.0,9.0,29.0,69.0,15.0,29.0,31.0,8.0,9.0,81.0,8.0,15.0,85.0,23.0,13.0,18.0,9.0,17.05180005180005,10.0,16.839473684210528,0.0,61.0,0.0,0.0,83.0,0.0,0.0,0.0,1.6105263157894747,0.0,28.0,1.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,26.0,0.0,6.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.94819994819995,0.0,7.160526315789472,0.0,0.0,14.0,30.0,0.0,0.0,11.0,0.0,5.389473684210525,0.0,0.0,0.0,19.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,17.0,0.0,0.0,0.0,0.0,13.0,13.0,36.0,14.0,13.0,27.0,16.0,10.0,33.0,16.0,12.0,72.0,6.0,10.0,45.0,14.0,24.0,27.0,8.0,12.0,63.0,8.0,12.0,92.0,9.0,30.0,63.0,18.0,10.0,78.0,10.0,11.0,30.0,24.0,10.0,89.0,9.0,31.0,75.0,16.0,28.0,33.0,10.0,10.0,83.0,7.0,15.0,91.0,23.0,15.0,16.0,8.0,2.781662781662787,20.0,24.0,0.0,63.0,5.0,0.0,89.0,0.0,2.0152810152810208,3.0,0.8000000000000007,0.0,56.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,30.0,0.0,0.0,0.0,1.0,0.0,2.0,1.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.21833721833721,0.0,0.0,0.0,0.0,9.0,29.0,0.0,0.0,10.98471898471898,0.0,1.1999999999999993,0.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,15.0,7.0,0.0,0.0,0.0,13.0,16.0,36.0,12.0,11.0,27.0,16.0,13.0,32.0,14.0,11.0,63.0,8.0,10.0,45.0,14.0,21.0,27.0,9.0,10.0,56.0,9.0,11.0,84.0,9.0,28.0,68.0,16.0,12.0,83.0,9.0,12.0,28.0,24.0,9.0,95.0,8.0,30.0,76.0,17.0,31.0,30.0,8.0,10.0,85.0,7.0,20.0,89.0,24.0,13.999999999999996,19.0,8.0,5.298951048951056,19.0,2.147368421052633,0.0,65.0,0.0,0.0,92.0,0.0,2.4737114737114814,4.0,2.1674641148325366,0.0,56.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,17.0,0.0,2.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.552713678800501e-15,0.0,0.0,21.701048951048943,0.0,21.852631578947367,1.0,0.0,13.0,32.0,0.0,1.0,6.526288526288519,0.0,0.8325358851674634,0.0,0.0,0.0,16.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,15.0,0.0,0.0,15.0,0.0,18.0,0.0,0.0,0.0,0.0,13.0,16.0,36.0,12.0,11.0,36.0,14.0,19.0,27.0,12.0,12.0,54.0,9.0,12.0,54.0,10.0,19.0,36.0,10.0,12.0,53.0,8.0,12.0,93.0,9.0,29.0,66.0,16.0,12.0,75.0,9.0,12.0,29.0,24.0,12.0,92.0,11.0,28.0,77.0,19.0,29.0,38.0,8.0,11.0,91.0,8.0,19.0,88.0,24.0,15.0,12.0,10.0,28.0,22.0,0.32248803827751193,1.0,74.0,0.0,15.0,93.0,0.0,4.9679487179487225,4.0,0.10526315789473628,0.0,43.0,0.0,0.06157731157731461,2.0,0.0,0.0,23.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.677511961722487,0.0,0.0,14.0,14.0,0.0,1.0,3.032051282051281,0.0,1.8947368421052637,0.0,0.0,0.0,6.938422688422685,0.0,0.0,0.0,4.0,0.0,0.0,3.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-07-20.999765/LSPc_utilization.csv b/test_instances/2026-06-30_15-07-20.999765/LSPc_utilization.csv
new file mode 100644
index 0000000..bfe79f4
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/LSPc_utilization.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.78975,0.79125,0.0,0.702,0.0,0.7124999999999999,0.78975,0.7736666666666667,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.78975,0.79125,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.658125,0.79125,0.7916666666666666,0.7799999999999999,0.7912500000000001,0.7916666666666666,0.7521428571428571,0.0,0.7916666666666666,0.5515714285714286,0.5437535014005602,0.3958333333333333,0.7521428571428572,0.7966326530612245,0.7916666666666666,0.6267857142857143,0.7204878048780488,0.7539682539682541,0.7521428571428572,0.34348837209302324,0.7755102040816327,0.5515714285714286,0.4250915750915751,0.3816964285714286,0.7103571428571428,0.3066256157635468,0.5428571428571429,0.4512857142857143,0.3660204081632653,0.7351190476190476,0.1880357142857143,0.47558730158730156,0.6785714285714286,0.30642857142857144,0.7778801843317972,0.7539682539682541
+0.0,0.0,0.7124999999999999,0.0,0.79125,0.0,0.7605,0.79125,0.0,0.702,0.0,0.7916666666666666,0.78975,0.7971111111111111,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.78975,0.79125,0.7916666666666666,0.7521428571428571,0.79125,0.7916666666666666,0.658125,0.79125,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.7312499999999998,0.79125,0.7916666666666666,0.6267857142857143,0.5413411078717202,0.3958333333333333,0.78,0.7786904761904762,0.7539682539682541,0.6267857142857143,0.7425435540069687,0.7539682539682541,0.6894642857142858,0.33083623693379793,0.6785714285714286,0.5515714285714286,0.6698412698412698,0.25446428571428575,0.7103571428571428,0.2669795918367347,0.5089285714285715,0.42308035714285713,0.35525510204081634,0.6785714285714286,0.16714285714285715,0.4521428571428572,0.6785714285714285,0.32234693877551024,0.5576428571428572,0.7464285714285714
+0.0,0.0,0.7124999999999999,0.0,0.79125,0.0,0.7605,0.79125,0.0,0.702,0.0,0.7916666666666666,0.78975,0.79125,0.7916666666666666,0.7799999999999999,0.79125,0.7916666666666666,0.78975,0.7912500000000001,0.7916666666666666,0.7939285714285713,0.7912500000000001,0.7916666666666666,0.658125,0.79125,0.7916666666666666,0.7939285714285713,0.79125,0.7125,0.7312499999999998,0.79125,0.7916666666666666,0.45128571428571435,0.5260224089635854,0.3958333333333333,0.7834821428571429,0.7966326530612245,0.7916666666666666,0.6017142857142858,0.6782142857142858,0.7539682539682541,0.5515714285714286,0.3648872180451128,0.7633928571428572,0.3760714285714286,0.6471848739495798,0.3015873015873016,0.6267857142857143,0.34664285714285714,0.5654761904761906,0.45441964285714287,0.3941758241758242,0.6785714285714285,0.22792207792207791,0.4718012422360249,0.7916666666666666,0.6894642857142858,0.5454421768707483,0.7539682539682541
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.7605,0.79125,0.0,0.702,0.0,0.7916666666666666,0.78975,0.7692708333333333,0.7916666666666666,0.7521428571428571,0.7912500000000001,0.7916666666666666,0.7799999999999999,0.79125,0.7916666666666666,0.7312499999999998,0.79125,0.7916666666666666,0.702,0.79125,0.7916666666666666,0.7939285714285713,0.79125,0.7125,0.702,0.79125,0.7916666666666666,0.5014285714285714,0.5151688311688312,0.6785714285714286,0.78,0.7912500000000001,0.7916666666666666,0.6685714285714286,0.5175471698113208,0.7755102040816327,0.6894642857142858,0.2603246753246753,0.7162698412698414,0.41785714285714287,0.4688888888888889,0.475,0.7521428571428572,0.34902255639097746,0.4146825396825397,0.78,0.7398701298701298,0.46651785714285715,0.6267857142857143,0.7736666666666667,0.4241071428571429,0.6267857142857143,0.7764069264069264,0.6477272727272727
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.7605,0.79125,0.0,0.702,0.0,0.7916666666666666,0.78975,0.79125,0.7916666666666666,0.7799999999999999,0.79125,0.7916666666666666,0.7799999999999999,0.7736666666666667,0.7916666666666666,0.7799999999999999,0.79125,0.7125,0.658125,0.79125,0.7125,0.7939285714285713,0.79125,0.7125,0.6435,0.79125,0.7916666666666666,0.5014285714285714,0.6932857142857143,0.6785714285714286,0.78,0.7966326530612245,0.7633928571428572,0.5850000000000001,0.7218421052631578,0.46266233766233766,0.6267857142857143,0.40190476190476193,0.5741758241758241,0.43875000000000003,0.4921282798833819,0.4362244897959184,0.7521428571428571,0.3726753246753247,0.6785714285714285,0.44243697478991595,0.3845812807881774,0.7633928571428572,0.15954545454545455,0.4772619047619047,0.6785714285714286,0.429795918367347,0.7818303571428572,0.7803571428571429
+0.0,0.0,0.7124999999999999,0.0,0.79125,0.0,0.745875,0.0,0.0,0.702,0.0,0.7916666666666666,0.7799999999999999,0.79125,0.7916666666666666,0.7799999999999999,0.7912500000000001,0.7916666666666666,0.7799999999999999,0.7736666666666667,0.7916666666666666,0.7605,0.7912500000000001,0.7916666666666666,0.702,0.79125,0.6927083333333333,0.7678125,0.7912500000000001,0.7916666666666666,0.73125,0.7912500000000001,0.7916666666666666,0.5515714285714286,0.795436507936508,0.475,0.7772142857142857,0.7966326530612245,0.7755102040816327,0.5014285714285714,0.6924710424710425,0.59375,0.7521428571428572,0.31029411764705883,0.6220238095238095,0.5515714285714286,0.5086607142857144,0.38775510204081637,0.7020000000000001,0.4074867724867725,0.7916666666666666,0.5014285714285714,0.3315714285714286,0.6785714285714286,0.22564285714285717,0.49827988338192425,0.7916666666666666,0.3447321428571429,0.580801393728223,0.7402597402597402
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.745875,0.0,0.0,0.0,0.0,0.7124999999999999,0.7799999999999999,0.7773684210526316,0.7916666666666666,0.7605,0.79125,0.7916666666666666,0.73125,0.7692708333333333,0.7916666666666666,0.7605,0.79125,0.7916666666666666,0.73125,0.7912500000000001,0.7916666666666666,0.7939285714285713,0.7692708333333333,0.7125,0.658125,0.79125,0.7916666666666666,0.5515714285714286,0.795436507936508,0.6785714285714286,0.78,0.7926455026455026,0.7633928571428572,0.28653061224489795,0.7855411255411255,0.6785714285714285,0.6267857142857143,0.741978021978022,0.7402597402597402,0.6267857142857143,0.7923265306122449,0.2775974025974026,0.7270714285714286,0.799945054945055,0.7270408163265306,0.7270714285714286,0.3460846560846561,0.6785714285714286,0.7521428571428572,0.24415714285714288,0.6785714285714286,0.7521428571428571,0.7764069264069264,0.7803571428571429
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.745875,0.0,0.0,0.0,0.0,0.771875,0.7605,0.79125,0.7916666666666666,0.7605,0.7912500000000001,0.7916666666666666,0.73125,0.7736666666666667,0.7916666666666666,0.702,0.79125,0.7916666666666666,0.73125,0.79125,0.7916666666666666,0.7799999999999999,0.7912500000000001,0.7916666666666666,0.702,0.79125,0.7916666666666666,0.7521428571428572,0.48651629072681707,0.6107142857142858,0.7521428571428571,0.7912500000000001,0.7633928571428572,0.6267857142857143,0.39185714285714285,0.6785714285714286,0.6894642857142858,0.2511904761904762,0.7402597402597402,0.6267857142857143,0.5260224089635854,0.5089285714285715,0.7772142857142857,0.5796703296703297,0.6031746031746033,0.78,0.7651648351648352,0.4241071428571429,0.6267857142857143,0.7818303571428572,0.3392857142857143,0.7521428571428571,0.7837142857142857,0.6502976190476191
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.7521428571428571,0.7384999999999999,0.0,0.0,0.0,0.771875,0.7799999999999999,0.79125,0.7916666666666666,0.6435,0.7912500000000001,0.7916666666666666,0.7605,0.7502222222222222,0.7916666666666666,0.6435,0.79125,0.7916666666666666,0.73125,0.79125,0.7916666666666666,0.7678125,0.7912500000000001,0.7125,0.73125,0.7877333333333334,0.7125,0.6894642857142858,0.79125,0.7633928571428572,0.78,0.7883516483516484,0.7755102040816327,0.7521428571428572,0.41014051522248246,0.7633928571428572,0.7521428571428572,0.44421052631578944,0.7402597402597402,0.5641071428571429,0.5206493506493507,0.5428571428571429,0.7521428571428571,0.4090816326530612,0.7209821428571429,0.7772142857142857,0.7535714285714286,0.6785714285714286,0.6267857142857143,0.7764069264069264,0.7916666666666666,0.7163265306122449,0.4790561224489796,0.7402597402597402
+0.0,0.79125,0.0,0.0,0.79125,0.0,0.78975,0.0,0.0,0.0,0.0,0.771875,0.7799999999999999,0.79125,0.7916666666666666,0.6435,0.79125,0.7916666666666666,0.7939285714285713,0.7912500000000001,0.7916666666666666,0.702,0.7912500000000001,0.7125,0.702,0.7912500000000001,0.7916666666666666,0.7939285714285713,0.79125,0.7916666666666666,0.702,0.7765972222222223,0.7916666666666666,0.7521428571428572,0.43801339285714286,0.7633928571428572,0.7270714285714286,0.7957714285714286,0.7755102040816327,0.7521428571428572,0.35323660714285715,0.7633928571428572,0.7521428571428572,0.24281746031746032,0.7402597402597402,0.429795918367347,0.6302597402597403,0.7464285714285714,0.468,0.7736666666666667,0.7162698412698414,0.7270714285714286,0.7636190476190475,0.6785714285714286,0.6894642857142858,0.7837142857142857,0.6785714285714286,0.3969642857142857,0.7801680672268908,0.7402597402597402
diff --git a/test_instances/2026-06-30_15-07-20.999765/base_instance_data.json b/test_instances/2026-06-30_15-07-20.999765/base_instance_data.json
new file mode 100644
index 0000000..707943f
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/base_instance_data.json
@@ -0,0 +1,1894 @@
+{
+  "None": {
+    "Nn": {
+      "None": 20
+    },
+    "Nf": {
+      "None": 3
+    },
+    "demand": {
+      "(1, 1)": 0.702,
+      "(1, 2)": 0.844,
+      "(1, 3)": 0.95,
+      "(2, 1)": 0.702,
+      "(2, 2)": 0.844,
+      "(2, 3)": 0.95,
+      "(3, 1)": 0.351,
+      "(3, 2)": 0.422,
+      "(3, 3)": 0.475,
+      "(4, 1)": 0.351,
+      "(4, 2)": 0.422,
+      "(4, 3)": 0.475,
+      "(5, 1)": 0.2925,
+      "(5, 2)": 0.3516666666666667,
+      "(5, 3)": 0.3958333333333333,
+      "(6, 1)": 0.2925,
+      "(6, 2)": 0.3516666666666667,
+      "(6, 3)": 0.3958333333333333,
+      "(7, 1)": 0.2925,
+      "(7, 2)": 0.3516666666666667,
+      "(7, 3)": 0.3958333333333333,
+      "(8, 1)": 0.2925,
+      "(8, 2)": 0.3516666666666667,
+      "(8, 3)": 0.3958333333333333,
+      "(9, 1)": 0.2925,
+      "(9, 2)": 0.3516666666666667,
+      "(9, 3)": 0.3958333333333333,
+      "(10, 1)": 0.2925,
+      "(10, 2)": 0.3516666666666667,
+      "(10, 3)": 0.3958333333333333,
+      "(11, 1)": 0.2925,
+      "(11, 2)": 0.3516666666666667,
+      "(11, 3)": 0.3958333333333333,
+      "(12, 1)": 0.2507142857142857,
+      "(12, 2)": 0.30142857142857143,
+      "(12, 3)": 0.3392857142857143,
+      "(13, 1)": 0.2507142857142857,
+      "(13, 2)": 0.30142857142857143,
+      "(13, 3)": 0.3392857142857143,
+      "(14, 1)": 0.2507142857142857,
+      "(14, 2)": 0.30142857142857143,
+      "(14, 3)": 0.3392857142857143,
+      "(15, 1)": 0.2507142857142857,
+      "(15, 2)": 0.30142857142857143,
+      "(15, 3)": 0.3392857142857143,
+      "(16, 1)": 0.2507142857142857,
+      "(16, 2)": 0.30142857142857143,
+      "(16, 3)": 0.3392857142857143,
+      "(17, 1)": 0.2507142857142857,
+      "(17, 2)": 0.30142857142857143,
+      "(17, 3)": 0.3392857142857143,
+      "(18, 1)": 0.2507142857142857,
+      "(18, 2)": 0.30142857142857143,
+      "(18, 3)": 0.3392857142857143,
+      "(19, 1)": 0.2507142857142857,
+      "(19, 2)": 0.30142857142857143,
+      "(19, 3)": 0.3392857142857143,
+      "(20, 1)": 0.2507142857142857,
+      "(20, 2)": 0.30142857142857143,
+      "(20, 3)": 0.3392857142857143
+    },
+    "memory_requirement": {
+      "1": 1024,
+      "2": 256,
+      "3": 1024
+    },
+    "memory_capacity": {
+      "1": 4096,
+      "2": 4096,
+      "3": 8192,
+      "4": 8192,
+      "5": 16384,
+      "6": 16384,
+      "7": 16384,
+      "8": 16384,
+      "9": 16384,
+      "10": 16384,
+      "11": 16384,
+      "12": 24576,
+      "13": 24576,
+      "14": 24576,
+      "15": 24576,
+      "16": 24576,
+      "17": 32768,
+      "18": 32768,
+      "19": 32768,
+      "20": 32768
+    },
+    "neighborhood": {
+      "(1, 1)": 0,
+      "(1, 2)": 1,
+      "(1, 3)": 1,
+      "(1, 4)": 1,
+      "(1, 5)": 1,
+      "(1, 6)": 1,
+      "(1, 7)": 0,
+      "(1, 8)": 1,
+      "(1, 9)": 1,
+      "(1, 10)": 0,
+      "(1, 11)": 1,
+      "(1, 12)": 0,
+      "(1, 13)": 0,
+      "(1, 14)": 0,
+      "(1, 15)": 0,
+      "(1, 16)": 1,
+      "(1, 17)": 1,
+      "(1, 18)": 1,
+      "(1, 19)": 1,
+      "(1, 20)": 1,
+      "(2, 1)": 1,
+      "(2, 2)": 0,
+      "(2, 3)": 1,
+      "(2, 4)": 1,
+      "(2, 5)": 1,
+      "(2, 6)": 0,
+      "(2, 7)": 1,
+      "(2, 8)": 1,
+      "(2, 9)": 0,
+      "(2, 10)": 0,
+      "(2, 11)": 0,
+      "(2, 12)": 0,
+      "(2, 13)": 0,
+      "(2, 14)": 0,
+      "(2, 15)": 0,
+      "(2, 16)": 0,
+      "(2, 17)": 0,
+      "(2, 18)": 0,
+      "(2, 19)": 0,
+      "(2, 20)": 0,
+      "(3, 1)": 1,
+      "(3, 2)": 1,
+      "(3, 3)": 0,
+      "(3, 4)": 1,
+      "(3, 5)": 0,
+      "(3, 6)": 0,
+      "(3, 7)": 0,
+      "(3, 8)": 0,
+      "(3, 9)": 0,
+      "(3, 10)": 0,
+      "(3, 11)": 0,
+      "(3, 12)": 0,
+      "(3, 13)": 0,
+      "(3, 14)": 0,
+      "(3, 15)": 0,
+      "(3, 16)": 0,
+      "(3, 17)": 0,
+      "(3, 18)": 0,
+      "(3, 19)": 0,
+      "(3, 20)": 0,
+      "(4, 1)": 1,
+      "(4, 2)": 1,
+      "(4, 3)": 1,
+      "(4, 4)": 0,
+      "(4, 5)": 1,
+      "(4, 6)": 0,
+      "(4, 7)": 0,
+      "(4, 8)": 0,
+      "(4, 9)": 0,
+      "(4, 10)": 0,
+      "(4, 11)": 0,
+      "(4, 12)": 0,
+      "(4, 13)": 0,
+      "(4, 14)": 0,
+      "(4, 15)": 0,
+      "(4, 16)": 0,
+      "(4, 17)": 0,
+      "(4, 18)": 0,
+      "(4, 19)": 0,
+      "(4, 20)": 0,
+      "(5, 1)": 1,
+      "(5, 2)": 1,
+      "(5, 3)": 0,
+      "(5, 4)": 1,
+      "(5, 5)": 0,
+      "(5, 6)": 1,
+      "(5, 7)": 1,
+      "(5, 8)": 0,
+      "(5, 9)": 0,
+      "(5, 10)": 1,
+      "(5, 11)": 0,
+      "(5, 12)": 0,
+      "(5, 13)": 0,
+      "(5, 14)": 0,
+      "(5, 15)": 0,
+      "(5, 16)": 1,
+      "(5, 17)": 0,
+      "(5, 18)": 0,
+      "(5, 19)": 0,
+      "(5, 20)": 0,
+      "(6, 1)": 1,
+      "(6, 2)": 0,
+      "(6, 3)": 0,
+      "(6, 4)": 0,
+      "(6, 5)": 1,
+      "(6, 6)": 0,
+      "(6, 7)": 1,
+      "(6, 8)": 1,
+      "(6, 9)": 1,
+      "(6, 10)": 1,
+      "(6, 11)": 1,
+      "(6, 12)": 1,
+      "(6, 13)": 1,
+      "(6, 14)": 1,
+      "(6, 15)": 1,
+      "(6, 16)": 0,
+      "(6, 17)": 0,
+      "(6, 18)": 0,
+      "(6, 19)": 0,
+      "(6, 20)": 0,
+      "(7, 1)": 0,
+      "(7, 2)": 1,
+      "(7, 3)": 0,
+      "(7, 4)": 0,
+      "(7, 5)": 1,
+      "(7, 6)": 1,
+      "(7, 7)": 0,
+      "(7, 8)": 1,
+      "(7, 9)": 0,
+      "(7, 10)": 0,
+      "(7, 11)": 0,
+      "(7, 12)": 0,
+      "(7, 13)": 0,
+      "(7, 14)": 0,
+      "(7, 15)": 0,
+      "(7, 16)": 0,
+      "(7, 17)": 0,
+      "(7, 18)": 0,
+      "(7, 19)": 0,
+      "(7, 20)": 0,
+      "(8, 1)": 1,
+      "(8, 2)": 1,
+      "(8, 3)": 0,
+      "(8, 4)": 0,
+      "(8, 5)": 0,
+      "(8, 6)": 1,
+      "(8, 7)": 1,
+      "(8, 8)": 0,
+      "(8, 9)": 1,
+      "(8, 10)": 0,
+      "(8, 11)": 0,
+      "(8, 12)": 0,
+      "(8, 13)": 0,
+      "(8, 14)": 0,
+      "(8, 15)": 0,
+      "(8, 16)": 0,
+      "(8, 17)": 0,
+      "(8, 18)": 0,
+      "(8, 19)": 0,
+      "(8, 20)": 0,
+      "(9, 1)": 1,
+      "(9, 2)": 0,
+      "(9, 3)": 0,
+      "(9, 4)": 0,
+      "(9, 5)": 0,
+      "(9, 6)": 1,
+      "(9, 7)": 0,
+      "(9, 8)": 1,
+      "(9, 9)": 0,
+      "(9, 10)": 0,
+      "(9, 11)": 0,
+      "(9, 12)": 0,
+      "(9, 13)": 0,
+      "(9, 14)": 0,
+      "(9, 15)": 0,
+      "(9, 16)": 0,
+      "(9, 17)": 0,
+      "(9, 18)": 0,
+      "(9, 19)": 0,
+      "(9, 20)": 0,
+      "(10, 1)": 0,
+      "(10, 2)": 0,
+      "(10, 3)": 0,
+      "(10, 4)": 0,
+      "(10, 5)": 1,
+      "(10, 6)": 1,
+      "(10, 7)": 0,
+      "(10, 8)": 0,
+      "(10, 9)": 0,
+      "(10, 10)": 0,
+      "(10, 11)": 1,
+      "(10, 12)": 1,
+      "(10, 13)": 1,
+      "(10, 14)": 1,
+      "(10, 15)": 0,
+      "(10, 16)": 1,
+      "(10, 17)": 0,
+      "(10, 18)": 0,
+      "(10, 19)": 0,
+      "(10, 20)": 0,
+      "(11, 1)": 1,
+      "(11, 2)": 0,
+      "(11, 3)": 0,
+      "(11, 4)": 0,
+      "(11, 5)": 0,
+      "(11, 6)": 1,
+      "(11, 7)": 0,
+      "(11, 8)": 0,
+      "(11, 9)": 0,
+      "(11, 10)": 1,
+      "(11, 11)": 0,
+      "(11, 12)": 1,
+      "(11, 13)": 0,
+      "(11, 14)": 0,
+      "(11, 15)": 0,
+      "(11, 16)": 1,
+      "(11, 17)": 1,
+      "(11, 18)": 0,
+      "(11, 19)": 0,
+      "(11, 20)": 0,
+      "(12, 1)": 0,
+      "(12, 2)": 0,
+      "(12, 3)": 0,
+      "(12, 4)": 0,
+      "(12, 5)": 0,
+      "(12, 6)": 1,
+      "(12, 7)": 0,
+      "(12, 8)": 0,
+      "(12, 9)": 0,
+      "(12, 10)": 1,
+      "(12, 11)": 1,
+      "(12, 12)": 0,
+      "(12, 13)": 1,
+      "(12, 14)": 0,
+      "(12, 15)": 0,
+      "(12, 16)": 0,
+      "(12, 17)": 0,
+      "(12, 18)": 0,
+      "(12, 19)": 0,
+      "(12, 20)": 0,
+      "(13, 1)": 0,
+      "(13, 2)": 0,
+      "(13, 3)": 0,
+      "(13, 4)": 0,
+      "(13, 5)": 0,
+      "(13, 6)": 1,
+      "(13, 7)": 0,
+      "(13, 8)": 0,
+      "(13, 9)": 0,
+      "(13, 10)": 1,
+      "(13, 11)": 0,
+      "(13, 12)": 1,
+      "(13, 13)": 0,
+      "(13, 14)": 1,
+      "(13, 15)": 1,
+      "(13, 16)": 0,
+      "(13, 17)": 0,
+      "(13, 18)": 0,
+      "(13, 19)": 0,
+      "(13, 20)": 0,
+      "(14, 1)": 0,
+      "(14, 2)": 0,
+      "(14, 3)": 0,
+      "(14, 4)": 0,
+      "(14, 5)": 0,
+      "(14, 6)": 1,
+      "(14, 7)": 0,
+      "(14, 8)": 0,
+      "(14, 9)": 0,
+      "(14, 10)": 1,
+      "(14, 11)": 0,
+      "(14, 12)": 0,
+      "(14, 13)": 1,
+      "(14, 14)": 0,
+      "(14, 15)": 1,
+      "(14, 16)": 0,
+      "(14, 17)": 0,
+      "(14, 18)": 0,
+      "(14, 19)": 0,
+      "(14, 20)": 0,
+      "(15, 1)": 0,
+      "(15, 2)": 0,
+      "(15, 3)": 0,
+      "(15, 4)": 0,
+      "(15, 5)": 0,
+      "(15, 6)": 1,
+      "(15, 7)": 0,
+      "(15, 8)": 0,
+      "(15, 9)": 0,
+      "(15, 10)": 0,
+      "(15, 11)": 0,
+      "(15, 12)": 0,
+      "(15, 13)": 1,
+      "(15, 14)": 1,
+      "(15, 15)": 0,
+      "(15, 16)": 0,
+      "(15, 17)": 0,
+      "(15, 18)": 0,
+      "(15, 19)": 0,
+      "(15, 20)": 0,
+      "(16, 1)": 1,
+      "(16, 2)": 0,
+      "(16, 3)": 0,
+      "(16, 4)": 0,
+      "(16, 5)": 1,
+      "(16, 6)": 0,
+      "(16, 7)": 0,
+      "(16, 8)": 0,
+      "(16, 9)": 0,
+      "(16, 10)": 1,
+      "(16, 11)": 1,
+      "(16, 12)": 0,
+      "(16, 13)": 0,
+      "(16, 14)": 0,
+      "(16, 15)": 0,
+      "(16, 16)": 0,
+      "(16, 17)": 1,
+      "(16, 18)": 1,
+      "(16, 19)": 0,
+      "(16, 20)": 1,
+      "(17, 1)": 1,
+      "(17, 2)": 0,
+      "(17, 3)": 0,
+      "(17, 4)": 0,
+      "(17, 5)": 0,
+      "(17, 6)": 0,
+      "(17, 7)": 0,
+      "(17, 8)": 0,
+      "(17, 9)": 0,
+      "(17, 10)": 0,
+      "(17, 11)": 1,
+      "(17, 12)": 0,
+      "(17, 13)": 0,
+      "(17, 14)": 0,
+      "(17, 15)": 0,
+      "(17, 16)": 1,
+      "(17, 17)": 0,
+      "(17, 18)": 1,
+      "(17, 19)": 1,
+      "(17, 20)": 0,
+      "(18, 1)": 1,
+      "(18, 2)": 0,
+      "(18, 3)": 0,
+      "(18, 4)": 0,
+      "(18, 5)": 0,
+      "(18, 6)": 0,
+      "(18, 7)": 0,
+      "(18, 8)": 0,
+      "(18, 9)": 0,
+      "(18, 10)": 0,
+      "(18, 11)": 0,
+      "(18, 12)": 0,
+      "(18, 13)": 0,
+      "(18, 14)": 0,
+      "(18, 15)": 0,
+      "(18, 16)": 1,
+      "(18, 17)": 1,
+      "(18, 18)": 0,
+      "(18, 19)": 1,
+      "(18, 20)": 1,
+      "(19, 1)": 1,
+      "(19, 2)": 0,
+      "(19, 3)": 0,
+      "(19, 4)": 0,
+      "(19, 5)": 0,
+      "(19, 6)": 0,
+      "(19, 7)": 0,
+      "(19, 8)": 0,
+      "(19, 9)": 0,
+      "(19, 10)": 0,
+      "(19, 11)": 0,
+      "(19, 12)": 0,
+      "(19, 13)": 0,
+      "(19, 14)": 0,
+      "(19, 15)": 0,
+      "(19, 16)": 0,
+      "(19, 17)": 1,
+      "(19, 18)": 1,
+      "(19, 19)": 0,
+      "(19, 20)": 0,
+      "(20, 1)": 1,
+      "(20, 2)": 0,
+      "(20, 3)": 0,
+      "(20, 4)": 0,
+      "(20, 5)": 0,
+      "(20, 6)": 0,
+      "(20, 7)": 0,
+      "(20, 8)": 0,
+      "(20, 9)": 0,
+      "(20, 10)": 0,
+      "(20, 11)": 0,
+      "(20, 12)": 0,
+      "(20, 13)": 0,
+      "(20, 14)": 0,
+      "(20, 15)": 0,
+      "(20, 16)": 1,
+      "(20, 17)": 0,
+      "(20, 18)": 1,
+      "(20, 19)": 0,
+      "(20, 20)": 0
+    },
+    "max_utilization": {
+      "1": 0.8,
+      "2": 0.8,
+      "3": 0.8
+    },
+    "alpha": {
+      "(1, 1)": 0.771,
+      "(1, 2)": 0.695,
+      "(1, 3)": 0.721,
+      "(2, 1)": 0.771,
+      "(2, 2)": 0.695,
+      "(2, 3)": 0.721,
+      "(3, 1)": 0.771,
+      "(3, 2)": 0.695,
+      "(3, 3)": 0.721,
+      "(4, 1)": 0.771,
+      "(4, 2)": 0.695,
+      "(4, 3)": 0.721,
+      "(5, 1)": 0.771,
+      "(5, 2)": 0.695,
+      "(5, 3)": 0.721,
+      "(6, 1)": 0.771,
+      "(6, 2)": 0.695,
+      "(6, 3)": 0.721,
+      "(7, 1)": 0.771,
+      "(7, 2)": 0.695,
+      "(7, 3)": 0.721,
+      "(8, 1)": 0.771,
+      "(8, 2)": 0.695,
+      "(8, 3)": 0.721,
+      "(9, 1)": 0.771,
+      "(9, 2)": 0.695,
+      "(9, 3)": 0.721,
+      "(10, 1)": 0.771,
+      "(10, 2)": 0.695,
+      "(10, 3)": 0.721,
+      "(11, 1)": 0.771,
+      "(11, 2)": 0.695,
+      "(11, 3)": 0.721,
+      "(12, 1)": 0.771,
+      "(12, 2)": 0.695,
+      "(12, 3)": 0.721,
+      "(13, 1)": 0.771,
+      "(13, 2)": 0.695,
+      "(13, 3)": 0.721,
+      "(14, 1)": 0.771,
+      "(14, 2)": 0.695,
+      "(14, 3)": 0.721,
+      "(15, 1)": 0.771,
+      "(15, 2)": 0.695,
+      "(15, 3)": 0.721,
+      "(16, 1)": 0.771,
+      "(16, 2)": 0.695,
+      "(16, 3)": 0.721,
+      "(17, 1)": 0.771,
+      "(17, 2)": 0.695,
+      "(17, 3)": 0.721,
+      "(18, 1)": 0.771,
+      "(18, 2)": 0.695,
+      "(18, 3)": 0.721,
+      "(19, 1)": 0.771,
+      "(19, 2)": 0.695,
+      "(19, 3)": 0.721,
+      "(20, 1)": 0.771,
+      "(20, 2)": 0.695,
+      "(20, 3)": 0.721
+    },
+    "beta": {
+      "(1, 1, 1)": 0.5,
+      "(1, 1, 2)": 0.5,
+      "(1, 1, 3)": 0.5,
+      "(1, 2, 1)": 0.5,
+      "(1, 2, 2)": 0.5,
+      "(1, 2, 3)": 0.5,
+      "(1, 3, 1)": 0.5,
+      "(1, 3, 2)": 0.5,
+      "(1, 3, 3)": 0.5,
+      "(1, 4, 1)": 0.5,
+      "(1, 4, 2)": 0.5,
+      "(1, 4, 3)": 0.5,
+      "(1, 5, 1)": 0.5,
+      "(1, 5, 2)": 0.5,
+      "(1, 5, 3)": 0.5,
+      "(1, 6, 1)": 0.5,
+      "(1, 6, 2)": 0.5,
+      "(1, 6, 3)": 0.5,
+      "(1, 7, 1)": 0.5,
+      "(1, 7, 2)": 0.5,
+      "(1, 7, 3)": 0.5,
+      "(1, 8, 1)": 0.5,
+      "(1, 8, 2)": 0.5,
+      "(1, 8, 3)": 0.5,
+      "(1, 9, 1)": 0.5,
+      "(1, 9, 2)": 0.5,
+      "(1, 9, 3)": 0.5,
+      "(1, 10, 1)": 0.5,
+      "(1, 10, 2)": 0.5,
+      "(1, 10, 3)": 0.5,
+      "(1, 11, 1)": 0.5,
+      "(1, 11, 2)": 0.5,
+      "(1, 11, 3)": 0.5,
+      "(1, 12, 1)": 0.5,
+      "(1, 12, 2)": 0.5,
+      "(1, 12, 3)": 0.5,
+      "(1, 13, 1)": 0.5,
+      "(1, 13, 2)": 0.5,
+      "(1, 13, 3)": 0.5,
+      "(1, 14, 1)": 0.5,
+      "(1, 14, 2)": 0.5,
+      "(1, 14, 3)": 0.5,
+      "(1, 15, 1)": 0.5,
+      "(1, 15, 2)": 0.5,
+      "(1, 15, 3)": 0.5,
+      "(1, 16, 1)": 0.5,
+      "(1, 16, 2)": 0.5,
+      "(1, 16, 3)": 0.5,
+      "(1, 17, 1)": 0.5,
+      "(1, 17, 2)": 0.5,
+      "(1, 17, 3)": 0.5,
+      "(1, 18, 1)": 0.5,
+      "(1, 18, 2)": 0.5,
+      "(1, 18, 3)": 0.5,
+      "(1, 19, 1)": 0.5,
+      "(1, 19, 2)": 0.5,
+      "(1, 19, 3)": 0.5,
+      "(1, 20, 1)": 0.5,
+      "(1, 20, 2)": 0.5,
+      "(1, 20, 3)": 0.5,
+      "(2, 1, 1)": 0.5,
+      "(2, 1, 2)": 0.5,
+      "(2, 1, 3)": 0.5,
+      "(2, 2, 1)": 0.5,
+      "(2, 2, 2)": 0.5,
+      "(2, 2, 3)": 0.5,
+      "(2, 3, 1)": 0.5,
+      "(2, 3, 2)": 0.5,
+      "(2, 3, 3)": 0.5,
+      "(2, 4, 1)": 0.5,
+      "(2, 4, 2)": 0.5,
+      "(2, 4, 3)": 0.5,
+      "(2, 5, 1)": 0.5,
+      "(2, 5, 2)": 0.5,
+      "(2, 5, 3)": 0.5,
+      "(2, 6, 1)": 0.5,
+      "(2, 6, 2)": 0.5,
+      "(2, 6, 3)": 0.5,
+      "(2, 7, 1)": 0.5,
+      "(2, 7, 2)": 0.5,
+      "(2, 7, 3)": 0.5,
+      "(2, 8, 1)": 0.5,
+      "(2, 8, 2)": 0.5,
+      "(2, 8, 3)": 0.5,
+      "(2, 9, 1)": 0.5,
+      "(2, 9, 2)": 0.5,
+      "(2, 9, 3)": 0.5,
+      "(2, 10, 1)": 0.5,
+      "(2, 10, 2)": 0.5,
+      "(2, 10, 3)": 0.5,
+      "(2, 11, 1)": 0.5,
+      "(2, 11, 2)": 0.5,
+      "(2, 11, 3)": 0.5,
+      "(2, 12, 1)": 0.5,
+      "(2, 12, 2)": 0.5,
+      "(2, 12, 3)": 0.5,
+      "(2, 13, 1)": 0.5,
+      "(2, 13, 2)": 0.5,
+      "(2, 13, 3)": 0.5,
+      "(2, 14, 1)": 0.5,
+      "(2, 14, 2)": 0.5,
+      "(2, 14, 3)": 0.5,
+      "(2, 15, 1)": 0.5,
+      "(2, 15, 2)": 0.5,
+      "(2, 15, 3)": 0.5,
+      "(2, 16, 1)": 0.5,
+      "(2, 16, 2)": 0.5,
+      "(2, 16, 3)": 0.5,
+      "(2, 17, 1)": 0.5,
+      "(2, 17, 2)": 0.5,
+      "(2, 17, 3)": 0.5,
+      "(2, 18, 1)": 0.5,
+      "(2, 18, 2)": 0.5,
+      "(2, 18, 3)": 0.5,
+      "(2, 19, 1)": 0.5,
+      "(2, 19, 2)": 0.5,
+      "(2, 19, 3)": 0.5,
+      "(2, 20, 1)": 0.5,
+      "(2, 20, 2)": 0.5,
+      "(2, 20, 3)": 0.5,
+      "(3, 1, 1)": 0.5,
+      "(3, 1, 2)": 0.5,
+      "(3, 1, 3)": 0.5,
+      "(3, 2, 1)": 0.5,
+      "(3, 2, 2)": 0.5,
+      "(3, 2, 3)": 0.5,
+      "(3, 3, 1)": 0.5,
+      "(3, 3, 2)": 0.5,
+      "(3, 3, 3)": 0.5,
+      "(3, 4, 1)": 0.5,
+      "(3, 4, 2)": 0.5,
+      "(3, 4, 3)": 0.5,
+      "(3, 5, 1)": 0.5,
+      "(3, 5, 2)": 0.5,
+      "(3, 5, 3)": 0.5,
+      "(3, 6, 1)": 0.5,
+      "(3, 6, 2)": 0.5,
+      "(3, 6, 3)": 0.5,
+      "(3, 7, 1)": 0.5,
+      "(3, 7, 2)": 0.5,
+      "(3, 7, 3)": 0.5,
+      "(3, 8, 1)": 0.5,
+      "(3, 8, 2)": 0.5,
+      "(3, 8, 3)": 0.5,
+      "(3, 9, 1)": 0.5,
+      "(3, 9, 2)": 0.5,
+      "(3, 9, 3)": 0.5,
+      "(3, 10, 1)": 0.5,
+      "(3, 10, 2)": 0.5,
+      "(3, 10, 3)": 0.5,
+      "(3, 11, 1)": 0.5,
+      "(3, 11, 2)": 0.5,
+      "(3, 11, 3)": 0.5,
+      "(3, 12, 1)": 0.5,
+      "(3, 12, 2)": 0.5,
+      "(3, 12, 3)": 0.5,
+      "(3, 13, 1)": 0.5,
+      "(3, 13, 2)": 0.5,
+      "(3, 13, 3)": 0.5,
+      "(3, 14, 1)": 0.5,
+      "(3, 14, 2)": 0.5,
+      "(3, 14, 3)": 0.5,
+      "(3, 15, 1)": 0.5,
+      "(3, 15, 2)": 0.5,
+      "(3, 15, 3)": 0.5,
+      "(3, 16, 1)": 0.5,
+      "(3, 16, 2)": 0.5,
+      "(3, 16, 3)": 0.5,
+      "(3, 17, 1)": 0.5,
+      "(3, 17, 2)": 0.5,
+      "(3, 17, 3)": 0.5,
+      "(3, 18, 1)": 0.5,
+      "(3, 18, 2)": 0.5,
+      "(3, 18, 3)": 0.5,
+      "(3, 19, 1)": 0.5,
+      "(3, 19, 2)": 0.5,
+      "(3, 19, 3)": 0.5,
+      "(3, 20, 1)": 0.5,
+      "(3, 20, 2)": 0.5,
+      "(3, 20, 3)": 0.5,
+      "(4, 1, 1)": 0.5,
+      "(4, 1, 2)": 0.5,
+      "(4, 1, 3)": 0.5,
+      "(4, 2, 1)": 0.5,
+      "(4, 2, 2)": 0.5,
+      "(4, 2, 3)": 0.5,
+      "(4, 3, 1)": 0.5,
+      "(4, 3, 2)": 0.5,
+      "(4, 3, 3)": 0.5,
+      "(4, 4, 1)": 0.5,
+      "(4, 4, 2)": 0.5,
+      "(4, 4, 3)": 0.5,
+      "(4, 5, 1)": 0.5,
+      "(4, 5, 2)": 0.5,
+      "(4, 5, 3)": 0.5,
+      "(4, 6, 1)": 0.5,
+      "(4, 6, 2)": 0.5,
+      "(4, 6, 3)": 0.5,
+      "(4, 7, 1)": 0.5,
+      "(4, 7, 2)": 0.5,
+      "(4, 7, 3)": 0.5,
+      "(4, 8, 1)": 0.5,
+      "(4, 8, 2)": 0.5,
+      "(4, 8, 3)": 0.5,
+      "(4, 9, 1)": 0.5,
+      "(4, 9, 2)": 0.5,
+      "(4, 9, 3)": 0.5,
+      "(4, 10, 1)": 0.5,
+      "(4, 10, 2)": 0.5,
+      "(4, 10, 3)": 0.5,
+      "(4, 11, 1)": 0.5,
+      "(4, 11, 2)": 0.5,
+      "(4, 11, 3)": 0.5,
+      "(4, 12, 1)": 0.5,
+      "(4, 12, 2)": 0.5,
+      "(4, 12, 3)": 0.5,
+      "(4, 13, 1)": 0.5,
+      "(4, 13, 2)": 0.5,
+      "(4, 13, 3)": 0.5,
+      "(4, 14, 1)": 0.5,
+      "(4, 14, 2)": 0.5,
+      "(4, 14, 3)": 0.5,
+      "(4, 15, 1)": 0.5,
+      "(4, 15, 2)": 0.5,
+      "(4, 15, 3)": 0.5,
+      "(4, 16, 1)": 0.5,
+      "(4, 16, 2)": 0.5,
+      "(4, 16, 3)": 0.5,
+      "(4, 17, 1)": 0.5,
+      "(4, 17, 2)": 0.5,
+      "(4, 17, 3)": 0.5,
+      "(4, 18, 1)": 0.5,
+      "(4, 18, 2)": 0.5,
+      "(4, 18, 3)": 0.5,
+      "(4, 19, 1)": 0.5,
+      "(4, 19, 2)": 0.5,
+      "(4, 19, 3)": 0.5,
+      "(4, 20, 1)": 0.5,
+      "(4, 20, 2)": 0.5,
+      "(4, 20, 3)": 0.5,
+      "(5, 1, 1)": 0.5,
+      "(5, 1, 2)": 0.5,
+      "(5, 1, 3)": 0.5,
+      "(5, 2, 1)": 0.5,
+      "(5, 2, 2)": 0.5,
+      "(5, 2, 3)": 0.5,
+      "(5, 3, 1)": 0.5,
+      "(5, 3, 2)": 0.5,
+      "(5, 3, 3)": 0.5,
+      "(5, 4, 1)": 0.5,
+      "(5, 4, 2)": 0.5,
+      "(5, 4, 3)": 0.5,
+      "(5, 5, 1)": 0.5,
+      "(5, 5, 2)": 0.5,
+      "(5, 5, 3)": 0.5,
+      "(5, 6, 1)": 0.5,
+      "(5, 6, 2)": 0.5,
+      "(5, 6, 3)": 0.5,
+      "(5, 7, 1)": 0.5,
+      "(5, 7, 2)": 0.5,
+      "(5, 7, 3)": 0.5,
+      "(5, 8, 1)": 0.5,
+      "(5, 8, 2)": 0.5,
+      "(5, 8, 3)": 0.5,
+      "(5, 9, 1)": 0.5,
+      "(5, 9, 2)": 0.5,
+      "(5, 9, 3)": 0.5,
+      "(5, 10, 1)": 0.5,
+      "(5, 10, 2)": 0.5,
+      "(5, 10, 3)": 0.5,
+      "(5, 11, 1)": 0.5,
+      "(5, 11, 2)": 0.5,
+      "(5, 11, 3)": 0.5,
+      "(5, 12, 1)": 0.5,
+      "(5, 12, 2)": 0.5,
+      "(5, 12, 3)": 0.5,
+      "(5, 13, 1)": 0.5,
+      "(5, 13, 2)": 0.5,
+      "(5, 13, 3)": 0.5,
+      "(5, 14, 1)": 0.5,
+      "(5, 14, 2)": 0.5,
+      "(5, 14, 3)": 0.5,
+      "(5, 15, 1)": 0.5,
+      "(5, 15, 2)": 0.5,
+      "(5, 15, 3)": 0.5,
+      "(5, 16, 1)": 0.5,
+      "(5, 16, 2)": 0.5,
+      "(5, 16, 3)": 0.5,
+      "(5, 17, 1)": 0.5,
+      "(5, 17, 2)": 0.5,
+      "(5, 17, 3)": 0.5,
+      "(5, 18, 1)": 0.5,
+      "(5, 18, 2)": 0.5,
+      "(5, 18, 3)": 0.5,
+      "(5, 19, 1)": 0.5,
+      "(5, 19, 2)": 0.5,
+      "(5, 19, 3)": 0.5,
+      "(5, 20, 1)": 0.5,
+      "(5, 20, 2)": 0.5,
+      "(5, 20, 3)": 0.5,
+      "(6, 1, 1)": 0.5,
+      "(6, 1, 2)": 0.5,
+      "(6, 1, 3)": 0.5,
+      "(6, 2, 1)": 0.5,
+      "(6, 2, 2)": 0.5,
+      "(6, 2, 3)": 0.5,
+      "(6, 3, 1)": 0.5,
+      "(6, 3, 2)": 0.5,
+      "(6, 3, 3)": 0.5,
+      "(6, 4, 1)": 0.5,
+      "(6, 4, 2)": 0.5,
+      "(6, 4, 3)": 0.5,
+      "(6, 5, 1)": 0.5,
+      "(6, 5, 2)": 0.5,
+      "(6, 5, 3)": 0.5,
+      "(6, 6, 1)": 0.5,
+      "(6, 6, 2)": 0.5,
+      "(6, 6, 3)": 0.5,
+      "(6, 7, 1)": 0.5,
+      "(6, 7, 2)": 0.5,
+      "(6, 7, 3)": 0.5,
+      "(6, 8, 1)": 0.5,
+      "(6, 8, 2)": 0.5,
+      "(6, 8, 3)": 0.5,
+      "(6, 9, 1)": 0.5,
+      "(6, 9, 2)": 0.5,
+      "(6, 9, 3)": 0.5,
+      "(6, 10, 1)": 0.5,
+      "(6, 10, 2)": 0.5,
+      "(6, 10, 3)": 0.5,
+      "(6, 11, 1)": 0.5,
+      "(6, 11, 2)": 0.5,
+      "(6, 11, 3)": 0.5,
+      "(6, 12, 1)": 0.5,
+      "(6, 12, 2)": 0.5,
+      "(6, 12, 3)": 0.5,
+      "(6, 13, 1)": 0.5,
+      "(6, 13, 2)": 0.5,
+      "(6, 13, 3)": 0.5,
+      "(6, 14, 1)": 0.5,
+      "(6, 14, 2)": 0.5,
+      "(6, 14, 3)": 0.5,
+      "(6, 15, 1)": 0.5,
+      "(6, 15, 2)": 0.5,
+      "(6, 15, 3)": 0.5,
+      "(6, 16, 1)": 0.5,
+      "(6, 16, 2)": 0.5,
+      "(6, 16, 3)": 0.5,
+      "(6, 17, 1)": 0.5,
+      "(6, 17, 2)": 0.5,
+      "(6, 17, 3)": 0.5,
+      "(6, 18, 1)": 0.5,
+      "(6, 18, 2)": 0.5,
+      "(6, 18, 3)": 0.5,
+      "(6, 19, 1)": 0.5,
+      "(6, 19, 2)": 0.5,
+      "(6, 19, 3)": 0.5,
+      "(6, 20, 1)": 0.5,
+      "(6, 20, 2)": 0.5,
+      "(6, 20, 3)": 0.5,
+      "(7, 1, 1)": 0.5,
+      "(7, 1, 2)": 0.5,
+      "(7, 1, 3)": 0.5,
+      "(7, 2, 1)": 0.5,
+      "(7, 2, 2)": 0.5,
+      "(7, 2, 3)": 0.5,
+      "(7, 3, 1)": 0.5,
+      "(7, 3, 2)": 0.5,
+      "(7, 3, 3)": 0.5,
+      "(7, 4, 1)": 0.5,
+      "(7, 4, 2)": 0.5,
+      "(7, 4, 3)": 0.5,
+      "(7, 5, 1)": 0.5,
+      "(7, 5, 2)": 0.5,
+      "(7, 5, 3)": 0.5,
+      "(7, 6, 1)": 0.5,
+      "(7, 6, 2)": 0.5,
+      "(7, 6, 3)": 0.5,
+      "(7, 7, 1)": 0.5,
+      "(7, 7, 2)": 0.5,
+      "(7, 7, 3)": 0.5,
+      "(7, 8, 1)": 0.5,
+      "(7, 8, 2)": 0.5,
+      "(7, 8, 3)": 0.5,
+      "(7, 9, 1)": 0.5,
+      "(7, 9, 2)": 0.5,
+      "(7, 9, 3)": 0.5,
+      "(7, 10, 1)": 0.5,
+      "(7, 10, 2)": 0.5,
+      "(7, 10, 3)": 0.5,
+      "(7, 11, 1)": 0.5,
+      "(7, 11, 2)": 0.5,
+      "(7, 11, 3)": 0.5,
+      "(7, 12, 1)": 0.5,
+      "(7, 12, 2)": 0.5,
+      "(7, 12, 3)": 0.5,
+      "(7, 13, 1)": 0.5,
+      "(7, 13, 2)": 0.5,
+      "(7, 13, 3)": 0.5,
+      "(7, 14, 1)": 0.5,
+      "(7, 14, 2)": 0.5,
+      "(7, 14, 3)": 0.5,
+      "(7, 15, 1)": 0.5,
+      "(7, 15, 2)": 0.5,
+      "(7, 15, 3)": 0.5,
+      "(7, 16, 1)": 0.5,
+      "(7, 16, 2)": 0.5,
+      "(7, 16, 3)": 0.5,
+      "(7, 17, 1)": 0.5,
+      "(7, 17, 2)": 0.5,
+      "(7, 17, 3)": 0.5,
+      "(7, 18, 1)": 0.5,
+      "(7, 18, 2)": 0.5,
+      "(7, 18, 3)": 0.5,
+      "(7, 19, 1)": 0.5,
+      "(7, 19, 2)": 0.5,
+      "(7, 19, 3)": 0.5,
+      "(7, 20, 1)": 0.5,
+      "(7, 20, 2)": 0.5,
+      "(7, 20, 3)": 0.5,
+      "(8, 1, 1)": 0.5,
+      "(8, 1, 2)": 0.5,
+      "(8, 1, 3)": 0.5,
+      "(8, 2, 1)": 0.5,
+      "(8, 2, 2)": 0.5,
+      "(8, 2, 3)": 0.5,
+      "(8, 3, 1)": 0.5,
+      "(8, 3, 2)": 0.5,
+      "(8, 3, 3)": 0.5,
+      "(8, 4, 1)": 0.5,
+      "(8, 4, 2)": 0.5,
+      "(8, 4, 3)": 0.5,
+      "(8, 5, 1)": 0.5,
+      "(8, 5, 2)": 0.5,
+      "(8, 5, 3)": 0.5,
+      "(8, 6, 1)": 0.5,
+      "(8, 6, 2)": 0.5,
+      "(8, 6, 3)": 0.5,
+      "(8, 7, 1)": 0.5,
+      "(8, 7, 2)": 0.5,
+      "(8, 7, 3)": 0.5,
+      "(8, 8, 1)": 0.5,
+      "(8, 8, 2)": 0.5,
+      "(8, 8, 3)": 0.5,
+      "(8, 9, 1)": 0.5,
+      "(8, 9, 2)": 0.5,
+      "(8, 9, 3)": 0.5,
+      "(8, 10, 1)": 0.5,
+      "(8, 10, 2)": 0.5,
+      "(8, 10, 3)": 0.5,
+      "(8, 11, 1)": 0.5,
+      "(8, 11, 2)": 0.5,
+      "(8, 11, 3)": 0.5,
+      "(8, 12, 1)": 0.5,
+      "(8, 12, 2)": 0.5,
+      "(8, 12, 3)": 0.5,
+      "(8, 13, 1)": 0.5,
+      "(8, 13, 2)": 0.5,
+      "(8, 13, 3)": 0.5,
+      "(8, 14, 1)": 0.5,
+      "(8, 14, 2)": 0.5,
+      "(8, 14, 3)": 0.5,
+      "(8, 15, 1)": 0.5,
+      "(8, 15, 2)": 0.5,
+      "(8, 15, 3)": 0.5,
+      "(8, 16, 1)": 0.5,
+      "(8, 16, 2)": 0.5,
+      "(8, 16, 3)": 0.5,
+      "(8, 17, 1)": 0.5,
+      "(8, 17, 2)": 0.5,
+      "(8, 17, 3)": 0.5,
+      "(8, 18, 1)": 0.5,
+      "(8, 18, 2)": 0.5,
+      "(8, 18, 3)": 0.5,
+      "(8, 19, 1)": 0.5,
+      "(8, 19, 2)": 0.5,
+      "(8, 19, 3)": 0.5,
+      "(8, 20, 1)": 0.5,
+      "(8, 20, 2)": 0.5,
+      "(8, 20, 3)": 0.5,
+      "(9, 1, 1)": 0.5,
+      "(9, 1, 2)": 0.5,
+      "(9, 1, 3)": 0.5,
+      "(9, 2, 1)": 0.5,
+      "(9, 2, 2)": 0.5,
+      "(9, 2, 3)": 0.5,
+      "(9, 3, 1)": 0.5,
+      "(9, 3, 2)": 0.5,
+      "(9, 3, 3)": 0.5,
+      "(9, 4, 1)": 0.5,
+      "(9, 4, 2)": 0.5,
+      "(9, 4, 3)": 0.5,
+      "(9, 5, 1)": 0.5,
+      "(9, 5, 2)": 0.5,
+      "(9, 5, 3)": 0.5,
+      "(9, 6, 1)": 0.5,
+      "(9, 6, 2)": 0.5,
+      "(9, 6, 3)": 0.5,
+      "(9, 7, 1)": 0.5,
+      "(9, 7, 2)": 0.5,
+      "(9, 7, 3)": 0.5,
+      "(9, 8, 1)": 0.5,
+      "(9, 8, 2)": 0.5,
+      "(9, 8, 3)": 0.5,
+      "(9, 9, 1)": 0.5,
+      "(9, 9, 2)": 0.5,
+      "(9, 9, 3)": 0.5,
+      "(9, 10, 1)": 0.5,
+      "(9, 10, 2)": 0.5,
+      "(9, 10, 3)": 0.5,
+      "(9, 11, 1)": 0.5,
+      "(9, 11, 2)": 0.5,
+      "(9, 11, 3)": 0.5,
+      "(9, 12, 1)": 0.5,
+      "(9, 12, 2)": 0.5,
+      "(9, 12, 3)": 0.5,
+      "(9, 13, 1)": 0.5,
+      "(9, 13, 2)": 0.5,
+      "(9, 13, 3)": 0.5,
+      "(9, 14, 1)": 0.5,
+      "(9, 14, 2)": 0.5,
+      "(9, 14, 3)": 0.5,
+      "(9, 15, 1)": 0.5,
+      "(9, 15, 2)": 0.5,
+      "(9, 15, 3)": 0.5,
+      "(9, 16, 1)": 0.5,
+      "(9, 16, 2)": 0.5,
+      "(9, 16, 3)": 0.5,
+      "(9, 17, 1)": 0.5,
+      "(9, 17, 2)": 0.5,
+      "(9, 17, 3)": 0.5,
+      "(9, 18, 1)": 0.5,
+      "(9, 18, 2)": 0.5,
+      "(9, 18, 3)": 0.5,
+      "(9, 19, 1)": 0.5,
+      "(9, 19, 2)": 0.5,
+      "(9, 19, 3)": 0.5,
+      "(9, 20, 1)": 0.5,
+      "(9, 20, 2)": 0.5,
+      "(9, 20, 3)": 0.5,
+      "(10, 1, 1)": 0.5,
+      "(10, 1, 2)": 0.5,
+      "(10, 1, 3)": 0.5,
+      "(10, 2, 1)": 0.5,
+      "(10, 2, 2)": 0.5,
+      "(10, 2, 3)": 0.5,
+      "(10, 3, 1)": 0.5,
+      "(10, 3, 2)": 0.5,
+      "(10, 3, 3)": 0.5,
+      "(10, 4, 1)": 0.5,
+      "(10, 4, 2)": 0.5,
+      "(10, 4, 3)": 0.5,
+      "(10, 5, 1)": 0.5,
+      "(10, 5, 2)": 0.5,
+      "(10, 5, 3)": 0.5,
+      "(10, 6, 1)": 0.5,
+      "(10, 6, 2)": 0.5,
+      "(10, 6, 3)": 0.5,
+      "(10, 7, 1)": 0.5,
+      "(10, 7, 2)": 0.5,
+      "(10, 7, 3)": 0.5,
+      "(10, 8, 1)": 0.5,
+      "(10, 8, 2)": 0.5,
+      "(10, 8, 3)": 0.5,
+      "(10, 9, 1)": 0.5,
+      "(10, 9, 2)": 0.5,
+      "(10, 9, 3)": 0.5,
+      "(10, 10, 1)": 0.5,
+      "(10, 10, 2)": 0.5,
+      "(10, 10, 3)": 0.5,
+      "(10, 11, 1)": 0.5,
+      "(10, 11, 2)": 0.5,
+      "(10, 11, 3)": 0.5,
+      "(10, 12, 1)": 0.5,
+      "(10, 12, 2)": 0.5,
+      "(10, 12, 3)": 0.5,
+      "(10, 13, 1)": 0.5,
+      "(10, 13, 2)": 0.5,
+      "(10, 13, 3)": 0.5,
+      "(10, 14, 1)": 0.5,
+      "(10, 14, 2)": 0.5,
+      "(10, 14, 3)": 0.5,
+      "(10, 15, 1)": 0.5,
+      "(10, 15, 2)": 0.5,
+      "(10, 15, 3)": 0.5,
+      "(10, 16, 1)": 0.5,
+      "(10, 16, 2)": 0.5,
+      "(10, 16, 3)": 0.5,
+      "(10, 17, 1)": 0.5,
+      "(10, 17, 2)": 0.5,
+      "(10, 17, 3)": 0.5,
+      "(10, 18, 1)": 0.5,
+      "(10, 18, 2)": 0.5,
+      "(10, 18, 3)": 0.5,
+      "(10, 19, 1)": 0.5,
+      "(10, 19, 2)": 0.5,
+      "(10, 19, 3)": 0.5,
+      "(10, 20, 1)": 0.5,
+      "(10, 20, 2)": 0.5,
+      "(10, 20, 3)": 0.5,
+      "(11, 1, 1)": 0.5,
+      "(11, 1, 2)": 0.5,
+      "(11, 1, 3)": 0.5,
+      "(11, 2, 1)": 0.5,
+      "(11, 2, 2)": 0.5,
+      "(11, 2, 3)": 0.5,
+      "(11, 3, 1)": 0.5,
+      "(11, 3, 2)": 0.5,
+      "(11, 3, 3)": 0.5,
+      "(11, 4, 1)": 0.5,
+      "(11, 4, 2)": 0.5,
+      "(11, 4, 3)": 0.5,
+      "(11, 5, 1)": 0.5,
+      "(11, 5, 2)": 0.5,
+      "(11, 5, 3)": 0.5,
+      "(11, 6, 1)": 0.5,
+      "(11, 6, 2)": 0.5,
+      "(11, 6, 3)": 0.5,
+      "(11, 7, 1)": 0.5,
+      "(11, 7, 2)": 0.5,
+      "(11, 7, 3)": 0.5,
+      "(11, 8, 1)": 0.5,
+      "(11, 8, 2)": 0.5,
+      "(11, 8, 3)": 0.5,
+      "(11, 9, 1)": 0.5,
+      "(11, 9, 2)": 0.5,
+      "(11, 9, 3)": 0.5,
+      "(11, 10, 1)": 0.5,
+      "(11, 10, 2)": 0.5,
+      "(11, 10, 3)": 0.5,
+      "(11, 11, 1)": 0.5,
+      "(11, 11, 2)": 0.5,
+      "(11, 11, 3)": 0.5,
+      "(11, 12, 1)": 0.5,
+      "(11, 12, 2)": 0.5,
+      "(11, 12, 3)": 0.5,
+      "(11, 13, 1)": 0.5,
+      "(11, 13, 2)": 0.5,
+      "(11, 13, 3)": 0.5,
+      "(11, 14, 1)": 0.5,
+      "(11, 14, 2)": 0.5,
+      "(11, 14, 3)": 0.5,
+      "(11, 15, 1)": 0.5,
+      "(11, 15, 2)": 0.5,
+      "(11, 15, 3)": 0.5,
+      "(11, 16, 1)": 0.5,
+      "(11, 16, 2)": 0.5,
+      "(11, 16, 3)": 0.5,
+      "(11, 17, 1)": 0.5,
+      "(11, 17, 2)": 0.5,
+      "(11, 17, 3)": 0.5,
+      "(11, 18, 1)": 0.5,
+      "(11, 18, 2)": 0.5,
+      "(11, 18, 3)": 0.5,
+      "(11, 19, 1)": 0.5,
+      "(11, 19, 2)": 0.5,
+      "(11, 19, 3)": 0.5,
+      "(11, 20, 1)": 0.5,
+      "(11, 20, 2)": 0.5,
+      "(11, 20, 3)": 0.5,
+      "(12, 1, 1)": 0.5,
+      "(12, 1, 2)": 0.5,
+      "(12, 1, 3)": 0.5,
+      "(12, 2, 1)": 0.5,
+      "(12, 2, 2)": 0.5,
+      "(12, 2, 3)": 0.5,
+      "(12, 3, 1)": 0.5,
+      "(12, 3, 2)": 0.5,
+      "(12, 3, 3)": 0.5,
+      "(12, 4, 1)": 0.5,
+      "(12, 4, 2)": 0.5,
+      "(12, 4, 3)": 0.5,
+      "(12, 5, 1)": 0.5,
+      "(12, 5, 2)": 0.5,
+      "(12, 5, 3)": 0.5,
+      "(12, 6, 1)": 0.5,
+      "(12, 6, 2)": 0.5,
+      "(12, 6, 3)": 0.5,
+      "(12, 7, 1)": 0.5,
+      "(12, 7, 2)": 0.5,
+      "(12, 7, 3)": 0.5,
+      "(12, 8, 1)": 0.5,
+      "(12, 8, 2)": 0.5,
+      "(12, 8, 3)": 0.5,
+      "(12, 9, 1)": 0.5,
+      "(12, 9, 2)": 0.5,
+      "(12, 9, 3)": 0.5,
+      "(12, 10, 1)": 0.5,
+      "(12, 10, 2)": 0.5,
+      "(12, 10, 3)": 0.5,
+      "(12, 11, 1)": 0.5,
+      "(12, 11, 2)": 0.5,
+      "(12, 11, 3)": 0.5,
+      "(12, 12, 1)": 0.5,
+      "(12, 12, 2)": 0.5,
+      "(12, 12, 3)": 0.5,
+      "(12, 13, 1)": 0.5,
+      "(12, 13, 2)": 0.5,
+      "(12, 13, 3)": 0.5,
+      "(12, 14, 1)": 0.5,
+      "(12, 14, 2)": 0.5,
+      "(12, 14, 3)": 0.5,
+      "(12, 15, 1)": 0.5,
+      "(12, 15, 2)": 0.5,
+      "(12, 15, 3)": 0.5,
+      "(12, 16, 1)": 0.5,
+      "(12, 16, 2)": 0.5,
+      "(12, 16, 3)": 0.5,
+      "(12, 17, 1)": 0.5,
+      "(12, 17, 2)": 0.5,
+      "(12, 17, 3)": 0.5,
+      "(12, 18, 1)": 0.5,
+      "(12, 18, 2)": 0.5,
+      "(12, 18, 3)": 0.5,
+      "(12, 19, 1)": 0.5,
+      "(12, 19, 2)": 0.5,
+      "(12, 19, 3)": 0.5,
+      "(12, 20, 1)": 0.5,
+      "(12, 20, 2)": 0.5,
+      "(12, 20, 3)": 0.5,
+      "(13, 1, 1)": 0.5,
+      "(13, 1, 2)": 0.5,
+      "(13, 1, 3)": 0.5,
+      "(13, 2, 1)": 0.5,
+      "(13, 2, 2)": 0.5,
+      "(13, 2, 3)": 0.5,
+      "(13, 3, 1)": 0.5,
+      "(13, 3, 2)": 0.5,
+      "(13, 3, 3)": 0.5,
+      "(13, 4, 1)": 0.5,
+      "(13, 4, 2)": 0.5,
+      "(13, 4, 3)": 0.5,
+      "(13, 5, 1)": 0.5,
+      "(13, 5, 2)": 0.5,
+      "(13, 5, 3)": 0.5,
+      "(13, 6, 1)": 0.5,
+      "(13, 6, 2)": 0.5,
+      "(13, 6, 3)": 0.5,
+      "(13, 7, 1)": 0.5,
+      "(13, 7, 2)": 0.5,
+      "(13, 7, 3)": 0.5,
+      "(13, 8, 1)": 0.5,
+      "(13, 8, 2)": 0.5,
+      "(13, 8, 3)": 0.5,
+      "(13, 9, 1)": 0.5,
+      "(13, 9, 2)": 0.5,
+      "(13, 9, 3)": 0.5,
+      "(13, 10, 1)": 0.5,
+      "(13, 10, 2)": 0.5,
+      "(13, 10, 3)": 0.5,
+      "(13, 11, 1)": 0.5,
+      "(13, 11, 2)": 0.5,
+      "(13, 11, 3)": 0.5,
+      "(13, 12, 1)": 0.5,
+      "(13, 12, 2)": 0.5,
+      "(13, 12, 3)": 0.5,
+      "(13, 13, 1)": 0.5,
+      "(13, 13, 2)": 0.5,
+      "(13, 13, 3)": 0.5,
+      "(13, 14, 1)": 0.5,
+      "(13, 14, 2)": 0.5,
+      "(13, 14, 3)": 0.5,
+      "(13, 15, 1)": 0.5,
+      "(13, 15, 2)": 0.5,
+      "(13, 15, 3)": 0.5,
+      "(13, 16, 1)": 0.5,
+      "(13, 16, 2)": 0.5,
+      "(13, 16, 3)": 0.5,
+      "(13, 17, 1)": 0.5,
+      "(13, 17, 2)": 0.5,
+      "(13, 17, 3)": 0.5,
+      "(13, 18, 1)": 0.5,
+      "(13, 18, 2)": 0.5,
+      "(13, 18, 3)": 0.5,
+      "(13, 19, 1)": 0.5,
+      "(13, 19, 2)": 0.5,
+      "(13, 19, 3)": 0.5,
+      "(13, 20, 1)": 0.5,
+      "(13, 20, 2)": 0.5,
+      "(13, 20, 3)": 0.5,
+      "(14, 1, 1)": 0.5,
+      "(14, 1, 2)": 0.5,
+      "(14, 1, 3)": 0.5,
+      "(14, 2, 1)": 0.5,
+      "(14, 2, 2)": 0.5,
+      "(14, 2, 3)": 0.5,
+      "(14, 3, 1)": 0.5,
+      "(14, 3, 2)": 0.5,
+      "(14, 3, 3)": 0.5,
+      "(14, 4, 1)": 0.5,
+      "(14, 4, 2)": 0.5,
+      "(14, 4, 3)": 0.5,
+      "(14, 5, 1)": 0.5,
+      "(14, 5, 2)": 0.5,
+      "(14, 5, 3)": 0.5,
+      "(14, 6, 1)": 0.5,
+      "(14, 6, 2)": 0.5,
+      "(14, 6, 3)": 0.5,
+      "(14, 7, 1)": 0.5,
+      "(14, 7, 2)": 0.5,
+      "(14, 7, 3)": 0.5,
+      "(14, 8, 1)": 0.5,
+      "(14, 8, 2)": 0.5,
+      "(14, 8, 3)": 0.5,
+      "(14, 9, 1)": 0.5,
+      "(14, 9, 2)": 0.5,
+      "(14, 9, 3)": 0.5,
+      "(14, 10, 1)": 0.5,
+      "(14, 10, 2)": 0.5,
+      "(14, 10, 3)": 0.5,
+      "(14, 11, 1)": 0.5,
+      "(14, 11, 2)": 0.5,
+      "(14, 11, 3)": 0.5,
+      "(14, 12, 1)": 0.5,
+      "(14, 12, 2)": 0.5,
+      "(14, 12, 3)": 0.5,
+      "(14, 13, 1)": 0.5,
+      "(14, 13, 2)": 0.5,
+      "(14, 13, 3)": 0.5,
+      "(14, 14, 1)": 0.5,
+      "(14, 14, 2)": 0.5,
+      "(14, 14, 3)": 0.5,
+      "(14, 15, 1)": 0.5,
+      "(14, 15, 2)": 0.5,
+      "(14, 15, 3)": 0.5,
+      "(14, 16, 1)": 0.5,
+      "(14, 16, 2)": 0.5,
+      "(14, 16, 3)": 0.5,
+      "(14, 17, 1)": 0.5,
+      "(14, 17, 2)": 0.5,
+      "(14, 17, 3)": 0.5,
+      "(14, 18, 1)": 0.5,
+      "(14, 18, 2)": 0.5,
+      "(14, 18, 3)": 0.5,
+      "(14, 19, 1)": 0.5,
+      "(14, 19, 2)": 0.5,
+      "(14, 19, 3)": 0.5,
+      "(14, 20, 1)": 0.5,
+      "(14, 20, 2)": 0.5,
+      "(14, 20, 3)": 0.5,
+      "(15, 1, 1)": 0.5,
+      "(15, 1, 2)": 0.5,
+      "(15, 1, 3)": 0.5,
+      "(15, 2, 1)": 0.5,
+      "(15, 2, 2)": 0.5,
+      "(15, 2, 3)": 0.5,
+      "(15, 3, 1)": 0.5,
+      "(15, 3, 2)": 0.5,
+      "(15, 3, 3)": 0.5,
+      "(15, 4, 1)": 0.5,
+      "(15, 4, 2)": 0.5,
+      "(15, 4, 3)": 0.5,
+      "(15, 5, 1)": 0.5,
+      "(15, 5, 2)": 0.5,
+      "(15, 5, 3)": 0.5,
+      "(15, 6, 1)": 0.5,
+      "(15, 6, 2)": 0.5,
+      "(15, 6, 3)": 0.5,
+      "(15, 7, 1)": 0.5,
+      "(15, 7, 2)": 0.5,
+      "(15, 7, 3)": 0.5,
+      "(15, 8, 1)": 0.5,
+      "(15, 8, 2)": 0.5,
+      "(15, 8, 3)": 0.5,
+      "(15, 9, 1)": 0.5,
+      "(15, 9, 2)": 0.5,
+      "(15, 9, 3)": 0.5,
+      "(15, 10, 1)": 0.5,
+      "(15, 10, 2)": 0.5,
+      "(15, 10, 3)": 0.5,
+      "(15, 11, 1)": 0.5,
+      "(15, 11, 2)": 0.5,
+      "(15, 11, 3)": 0.5,
+      "(15, 12, 1)": 0.5,
+      "(15, 12, 2)": 0.5,
+      "(15, 12, 3)": 0.5,
+      "(15, 13, 1)": 0.5,
+      "(15, 13, 2)": 0.5,
+      "(15, 13, 3)": 0.5,
+      "(15, 14, 1)": 0.5,
+      "(15, 14, 2)": 0.5,
+      "(15, 14, 3)": 0.5,
+      "(15, 15, 1)": 0.5,
+      "(15, 15, 2)": 0.5,
+      "(15, 15, 3)": 0.5,
+      "(15, 16, 1)": 0.5,
+      "(15, 16, 2)": 0.5,
+      "(15, 16, 3)": 0.5,
+      "(15, 17, 1)": 0.5,
+      "(15, 17, 2)": 0.5,
+      "(15, 17, 3)": 0.5,
+      "(15, 18, 1)": 0.5,
+      "(15, 18, 2)": 0.5,
+      "(15, 18, 3)": 0.5,
+      "(15, 19, 1)": 0.5,
+      "(15, 19, 2)": 0.5,
+      "(15, 19, 3)": 0.5,
+      "(15, 20, 1)": 0.5,
+      "(15, 20, 2)": 0.5,
+      "(15, 20, 3)": 0.5,
+      "(16, 1, 1)": 0.5,
+      "(16, 1, 2)": 0.5,
+      "(16, 1, 3)": 0.5,
+      "(16, 2, 1)": 0.5,
+      "(16, 2, 2)": 0.5,
+      "(16, 2, 3)": 0.5,
+      "(16, 3, 1)": 0.5,
+      "(16, 3, 2)": 0.5,
+      "(16, 3, 3)": 0.5,
+      "(16, 4, 1)": 0.5,
+      "(16, 4, 2)": 0.5,
+      "(16, 4, 3)": 0.5,
+      "(16, 5, 1)": 0.5,
+      "(16, 5, 2)": 0.5,
+      "(16, 5, 3)": 0.5,
+      "(16, 6, 1)": 0.5,
+      "(16, 6, 2)": 0.5,
+      "(16, 6, 3)": 0.5,
+      "(16, 7, 1)": 0.5,
+      "(16, 7, 2)": 0.5,
+      "(16, 7, 3)": 0.5,
+      "(16, 8, 1)": 0.5,
+      "(16, 8, 2)": 0.5,
+      "(16, 8, 3)": 0.5,
+      "(16, 9, 1)": 0.5,
+      "(16, 9, 2)": 0.5,
+      "(16, 9, 3)": 0.5,
+      "(16, 10, 1)": 0.5,
+      "(16, 10, 2)": 0.5,
+      "(16, 10, 3)": 0.5,
+      "(16, 11, 1)": 0.5,
+      "(16, 11, 2)": 0.5,
+      "(16, 11, 3)": 0.5,
+      "(16, 12, 1)": 0.5,
+      "(16, 12, 2)": 0.5,
+      "(16, 12, 3)": 0.5,
+      "(16, 13, 1)": 0.5,
+      "(16, 13, 2)": 0.5,
+      "(16, 13, 3)": 0.5,
+      "(16, 14, 1)": 0.5,
+      "(16, 14, 2)": 0.5,
+      "(16, 14, 3)": 0.5,
+      "(16, 15, 1)": 0.5,
+      "(16, 15, 2)": 0.5,
+      "(16, 15, 3)": 0.5,
+      "(16, 16, 1)": 0.5,
+      "(16, 16, 2)": 0.5,
+      "(16, 16, 3)": 0.5,
+      "(16, 17, 1)": 0.5,
+      "(16, 17, 2)": 0.5,
+      "(16, 17, 3)": 0.5,
+      "(16, 18, 1)": 0.5,
+      "(16, 18, 2)": 0.5,
+      "(16, 18, 3)": 0.5,
+      "(16, 19, 1)": 0.5,
+      "(16, 19, 2)": 0.5,
+      "(16, 19, 3)": 0.5,
+      "(16, 20, 1)": 0.5,
+      "(16, 20, 2)": 0.5,
+      "(16, 20, 3)": 0.5,
+      "(17, 1, 1)": 0.5,
+      "(17, 1, 2)": 0.5,
+      "(17, 1, 3)": 0.5,
+      "(17, 2, 1)": 0.5,
+      "(17, 2, 2)": 0.5,
+      "(17, 2, 3)": 0.5,
+      "(17, 3, 1)": 0.5,
+      "(17, 3, 2)": 0.5,
+      "(17, 3, 3)": 0.5,
+      "(17, 4, 1)": 0.5,
+      "(17, 4, 2)": 0.5,
+      "(17, 4, 3)": 0.5,
+      "(17, 5, 1)": 0.5,
+      "(17, 5, 2)": 0.5,
+      "(17, 5, 3)": 0.5,
+      "(17, 6, 1)": 0.5,
+      "(17, 6, 2)": 0.5,
+      "(17, 6, 3)": 0.5,
+      "(17, 7, 1)": 0.5,
+      "(17, 7, 2)": 0.5,
+      "(17, 7, 3)": 0.5,
+      "(17, 8, 1)": 0.5,
+      "(17, 8, 2)": 0.5,
+      "(17, 8, 3)": 0.5,
+      "(17, 9, 1)": 0.5,
+      "(17, 9, 2)": 0.5,
+      "(17, 9, 3)": 0.5,
+      "(17, 10, 1)": 0.5,
+      "(17, 10, 2)": 0.5,
+      "(17, 10, 3)": 0.5,
+      "(17, 11, 1)": 0.5,
+      "(17, 11, 2)": 0.5,
+      "(17, 11, 3)": 0.5,
+      "(17, 12, 1)": 0.5,
+      "(17, 12, 2)": 0.5,
+      "(17, 12, 3)": 0.5,
+      "(17, 13, 1)": 0.5,
+      "(17, 13, 2)": 0.5,
+      "(17, 13, 3)": 0.5,
+      "(17, 14, 1)": 0.5,
+      "(17, 14, 2)": 0.5,
+      "(17, 14, 3)": 0.5,
+      "(17, 15, 1)": 0.5,
+      "(17, 15, 2)": 0.5,
+      "(17, 15, 3)": 0.5,
+      "(17, 16, 1)": 0.5,
+      "(17, 16, 2)": 0.5,
+      "(17, 16, 3)": 0.5,
+      "(17, 17, 1)": 0.5,
+      "(17, 17, 2)": 0.5,
+      "(17, 17, 3)": 0.5,
+      "(17, 18, 1)": 0.5,
+      "(17, 18, 2)": 0.5,
+      "(17, 18, 3)": 0.5,
+      "(17, 19, 1)": 0.5,
+      "(17, 19, 2)": 0.5,
+      "(17, 19, 3)": 0.5,
+      "(17, 20, 1)": 0.5,
+      "(17, 20, 2)": 0.5,
+      "(17, 20, 3)": 0.5,
+      "(18, 1, 1)": 0.5,
+      "(18, 1, 2)": 0.5,
+      "(18, 1, 3)": 0.5,
+      "(18, 2, 1)": 0.5,
+      "(18, 2, 2)": 0.5,
+      "(18, 2, 3)": 0.5,
+      "(18, 3, 1)": 0.5,
+      "(18, 3, 2)": 0.5,
+      "(18, 3, 3)": 0.5,
+      "(18, 4, 1)": 0.5,
+      "(18, 4, 2)": 0.5,
+      "(18, 4, 3)": 0.5,
+      "(18, 5, 1)": 0.5,
+      "(18, 5, 2)": 0.5,
+      "(18, 5, 3)": 0.5,
+      "(18, 6, 1)": 0.5,
+      "(18, 6, 2)": 0.5,
+      "(18, 6, 3)": 0.5,
+      "(18, 7, 1)": 0.5,
+      "(18, 7, 2)": 0.5,
+      "(18, 7, 3)": 0.5,
+      "(18, 8, 1)": 0.5,
+      "(18, 8, 2)": 0.5,
+      "(18, 8, 3)": 0.5,
+      "(18, 9, 1)": 0.5,
+      "(18, 9, 2)": 0.5,
+      "(18, 9, 3)": 0.5,
+      "(18, 10, 1)": 0.5,
+      "(18, 10, 2)": 0.5,
+      "(18, 10, 3)": 0.5,
+      "(18, 11, 1)": 0.5,
+      "(18, 11, 2)": 0.5,
+      "(18, 11, 3)": 0.5,
+      "(18, 12, 1)": 0.5,
+      "(18, 12, 2)": 0.5,
+      "(18, 12, 3)": 0.5,
+      "(18, 13, 1)": 0.5,
+      "(18, 13, 2)": 0.5,
+      "(18, 13, 3)": 0.5,
+      "(18, 14, 1)": 0.5,
+      "(18, 14, 2)": 0.5,
+      "(18, 14, 3)": 0.5,
+      "(18, 15, 1)": 0.5,
+      "(18, 15, 2)": 0.5,
+      "(18, 15, 3)": 0.5,
+      "(18, 16, 1)": 0.5,
+      "(18, 16, 2)": 0.5,
+      "(18, 16, 3)": 0.5,
+      "(18, 17, 1)": 0.5,
+      "(18, 17, 2)": 0.5,
+      "(18, 17, 3)": 0.5,
+      "(18, 18, 1)": 0.5,
+      "(18, 18, 2)": 0.5,
+      "(18, 18, 3)": 0.5,
+      "(18, 19, 1)": 0.5,
+      "(18, 19, 2)": 0.5,
+      "(18, 19, 3)": 0.5,
+      "(18, 20, 1)": 0.5,
+      "(18, 20, 2)": 0.5,
+      "(18, 20, 3)": 0.5,
+      "(19, 1, 1)": 0.5,
+      "(19, 1, 2)": 0.5,
+      "(19, 1, 3)": 0.5,
+      "(19, 2, 1)": 0.5,
+      "(19, 2, 2)": 0.5,
+      "(19, 2, 3)": 0.5,
+      "(19, 3, 1)": 0.5,
+      "(19, 3, 2)": 0.5,
+      "(19, 3, 3)": 0.5,
+      "(19, 4, 1)": 0.5,
+      "(19, 4, 2)": 0.5,
+      "(19, 4, 3)": 0.5,
+      "(19, 5, 1)": 0.5,
+      "(19, 5, 2)": 0.5,
+      "(19, 5, 3)": 0.5,
+      "(19, 6, 1)": 0.5,
+      "(19, 6, 2)": 0.5,
+      "(19, 6, 3)": 0.5,
+      "(19, 7, 1)": 0.5,
+      "(19, 7, 2)": 0.5,
+      "(19, 7, 3)": 0.5,
+      "(19, 8, 1)": 0.5,
+      "(19, 8, 2)": 0.5,
+      "(19, 8, 3)": 0.5,
+      "(19, 9, 1)": 0.5,
+      "(19, 9, 2)": 0.5,
+      "(19, 9, 3)": 0.5,
+      "(19, 10, 1)": 0.5,
+      "(19, 10, 2)": 0.5,
+      "(19, 10, 3)": 0.5,
+      "(19, 11, 1)": 0.5,
+      "(19, 11, 2)": 0.5,
+      "(19, 11, 3)": 0.5,
+      "(19, 12, 1)": 0.5,
+      "(19, 12, 2)": 0.5,
+      "(19, 12, 3)": 0.5,
+      "(19, 13, 1)": 0.5,
+      "(19, 13, 2)": 0.5,
+      "(19, 13, 3)": 0.5,
+      "(19, 14, 1)": 0.5,
+      "(19, 14, 2)": 0.5,
+      "(19, 14, 3)": 0.5,
+      "(19, 15, 1)": 0.5,
+      "(19, 15, 2)": 0.5,
+      "(19, 15, 3)": 0.5,
+      "(19, 16, 1)": 0.5,
+      "(19, 16, 2)": 0.5,
+      "(19, 16, 3)": 0.5,
+      "(19, 17, 1)": 0.5,
+      "(19, 17, 2)": 0.5,
+      "(19, 17, 3)": 0.5,
+      "(19, 18, 1)": 0.5,
+      "(19, 18, 2)": 0.5,
+      "(19, 18, 3)": 0.5,
+      "(19, 19, 1)": 0.5,
+      "(19, 19, 2)": 0.5,
+      "(19, 19, 3)": 0.5,
+      "(19, 20, 1)": 0.5,
+      "(19, 20, 2)": 0.5,
+      "(19, 20, 3)": 0.5,
+      "(20, 1, 1)": 0.5,
+      "(20, 1, 2)": 0.5,
+      "(20, 1, 3)": 0.5,
+      "(20, 2, 1)": 0.5,
+      "(20, 2, 2)": 0.5,
+      "(20, 2, 3)": 0.5,
+      "(20, 3, 1)": 0.5,
+      "(20, 3, 2)": 0.5,
+      "(20, 3, 3)": 0.5,
+      "(20, 4, 1)": 0.5,
+      "(20, 4, 2)": 0.5,
+      "(20, 4, 3)": 0.5,
+      "(20, 5, 1)": 0.5,
+      "(20, 5, 2)": 0.5,
+      "(20, 5, 3)": 0.5,
+      "(20, 6, 1)": 0.5,
+      "(20, 6, 2)": 0.5,
+      "(20, 6, 3)": 0.5,
+      "(20, 7, 1)": 0.5,
+      "(20, 7, 2)": 0.5,
+      "(20, 7, 3)": 0.5,
+      "(20, 8, 1)": 0.5,
+      "(20, 8, 2)": 0.5,
+      "(20, 8, 3)": 0.5,
+      "(20, 9, 1)": 0.5,
+      "(20, 9, 2)": 0.5,
+      "(20, 9, 3)": 0.5,
+      "(20, 10, 1)": 0.5,
+      "(20, 10, 2)": 0.5,
+      "(20, 10, 3)": 0.5,
+      "(20, 11, 1)": 0.5,
+      "(20, 11, 2)": 0.5,
+      "(20, 11, 3)": 0.5,
+      "(20, 12, 1)": 0.5,
+      "(20, 12, 2)": 0.5,
+      "(20, 12, 3)": 0.5,
+      "(20, 13, 1)": 0.5,
+      "(20, 13, 2)": 0.5,
+      "(20, 13, 3)": 0.5,
+      "(20, 14, 1)": 0.5,
+      "(20, 14, 2)": 0.5,
+      "(20, 14, 3)": 0.5,
+      "(20, 15, 1)": 0.5,
+      "(20, 15, 2)": 0.5,
+      "(20, 15, 3)": 0.5,
+      "(20, 16, 1)": 0.5,
+      "(20, 16, 2)": 0.5,
+      "(20, 16, 3)": 0.5,
+      "(20, 17, 1)": 0.5,
+      "(20, 17, 2)": 0.5,
+      "(20, 17, 3)": 0.5,
+      "(20, 18, 1)": 0.5,
+      "(20, 18, 2)": 0.5,
+      "(20, 18, 3)": 0.5,
+      "(20, 19, 1)": 0.5,
+      "(20, 19, 2)": 0.5,
+      "(20, 19, 3)": 0.5,
+      "(20, 20, 1)": 0.0,
+      "(20, 20, 2)": 0.0,
+      "(20, 20, 3)": 0.0
+    },
+    "gamma": {
+      "(1, 1)": 1.0,
+      "(1, 2)": 1.0,
+      "(1, 3)": 1.0,
+      "(2, 1)": 1.0,
+      "(2, 2)": 1.0,
+      "(2, 3)": 1.0,
+      "(3, 1)": 1.0,
+      "(3, 2)": 1.0,
+      "(3, 3)": 1.0,
+      "(4, 1)": 1.0,
+      "(4, 2)": 1.0,
+      "(4, 3)": 1.0,
+      "(5, 1)": 1.0,
+      "(5, 2)": 1.0,
+      "(5, 3)": 1.0,
+      "(6, 1)": 1.0,
+      "(6, 2)": 1.0,
+      "(6, 3)": 1.0,
+      "(7, 1)": 1.0,
+      "(7, 2)": 1.0,
+      "(7, 3)": 1.0,
+      "(8, 1)": 1.0,
+      "(8, 2)": 1.0,
+      "(8, 3)": 1.0,
+      "(9, 1)": 1.0,
+      "(9, 2)": 1.0,
+      "(9, 3)": 1.0,
+      "(10, 1)": 1.0,
+      "(10, 2)": 1.0,
+      "(10, 3)": 1.0,
+      "(11, 1)": 1.0,
+      "(11, 2)": 1.0,
+      "(11, 3)": 1.0,
+      "(12, 1)": 1.0,
+      "(12, 2)": 1.0,
+      "(12, 3)": 1.0,
+      "(13, 1)": 1.0,
+      "(13, 2)": 1.0,
+      "(13, 3)": 1.0,
+      "(14, 1)": 1.0,
+      "(14, 2)": 1.0,
+      "(14, 3)": 1.0,
+      "(15, 1)": 1.0,
+      "(15, 2)": 1.0,
+      "(15, 3)": 1.0,
+      "(16, 1)": 1.0,
+      "(16, 2)": 1.0,
+      "(16, 3)": 1.0,
+      "(17, 1)": 1.0,
+      "(17, 2)": 1.0,
+      "(17, 3)": 1.0,
+      "(18, 1)": 1.0,
+      "(18, 2)": 1.0,
+      "(18, 3)": 1.0,
+      "(19, 1)": 1.0,
+      "(19, 2)": 1.0,
+      "(19, 3)": 1.0,
+      "(20, 1)": 1.0,
+      "(20, 2)": 1.0,
+      "(20, 3)": 1.0
+    },
+    "delta": {
+      "(1, 1)": 0.5,
+      "(1, 2)": 0.5,
+      "(1, 3)": 0.5,
+      "(2, 1)": 0.5,
+      "(2, 2)": 0.5,
+      "(2, 3)": 0.5,
+      "(3, 1)": 0.5,
+      "(3, 2)": 0.5,
+      "(3, 3)": 0.5,
+      "(4, 1)": 0.5,
+      "(4, 2)": 0.5,
+      "(4, 3)": 0.5,
+      "(5, 1)": 0.5,
+      "(5, 2)": 0.5,
+      "(5, 3)": 0.5,
+      "(6, 1)": 0.5,
+      "(6, 2)": 0.5,
+      "(6, 3)": 0.5,
+      "(7, 1)": 0.5,
+      "(7, 2)": 0.5,
+      "(7, 3)": 0.5,
+      "(8, 1)": 0.5,
+      "(8, 2)": 0.5,
+      "(8, 3)": 0.5,
+      "(9, 1)": 0.5,
+      "(9, 2)": 0.5,
+      "(9, 3)": 0.5,
+      "(10, 1)": 0.5,
+      "(10, 2)": 0.5,
+      "(10, 3)": 0.5,
+      "(11, 1)": 0.5,
+      "(11, 2)": 0.5,
+      "(11, 3)": 0.5,
+      "(12, 1)": 0.5,
+      "(12, 2)": 0.5,
+      "(12, 3)": 0.5,
+      "(13, 1)": 0.5,
+      "(13, 2)": 0.5,
+      "(13, 3)": 0.5,
+      "(14, 1)": 0.5,
+      "(14, 2)": 0.5,
+      "(14, 3)": 0.5,
+      "(15, 1)": 0.5,
+      "(15, 2)": 0.5,
+      "(15, 3)": 0.5,
+      "(16, 1)": 0.5,
+      "(16, 2)": 0.5,
+      "(16, 3)": 0.5,
+      "(17, 1)": 0.5,
+      "(17, 2)": 0.5,
+      "(17, 3)": 0.5,
+      "(18, 1)": 0.5,
+      "(18, 2)": 0.5,
+      "(18, 3)": 0.5,
+      "(19, 1)": 0.5,
+      "(19, 2)": 0.5,
+      "(19, 3)": 0.5,
+      "(20, 1)": 0.5,
+      "(20, 2)": 0.5,
+      "(20, 3)": 0.5
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-07-20.999765/config.json b/test_instances/2026-06-30_15-07-20.999765/config.json
new file mode 100644
index 0000000..7352deb
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/config.json
@@ -0,0 +1,50 @@
+{
+  "base_solution_folder": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb",
+  "verbose": 2,
+  "seed": 4850,
+  "max_steps": 100,
+  "min_run_time": 70,
+  "max_run_time": 80,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "MIPGap": 1e-05
+    },
+    "auction": {
+      "eta": 0.0,
+      "epsilon": 0.0001,
+      "zeta": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": true
+    },
+    "coordinator": {
+      "sorting_rule": "product"
+    },
+    "update_neighborhood": false,
+    "start_from_last_pi": false,
+    "use_detailed_pi": false
+  },
+  "checkpoint_interval": 10,
+  "max_iterations": 100,
+  "plot_interval": 100,
+  "patience": 10,
+  "sw_patience": 200,
+  "limits": {
+    "instance_type": "load_existing",
+    "Nn": {
+      "min": 20,
+      "max": 20
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_09-23-43.178775",
+    "load": {
+      "trace_type": "load_existing",
+      "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_09-23-43.178775"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-07-20.999765/graph/PLANAR b/test_instances/2026-06-30_15-07-20.999765/graph/PLANAR
new file mode 100644
index 0000000..e69de29
diff --git a/test_instances/2026-06-30_15-07-20.999765/graph/graph.png b/test_instances/2026-06-30_15-07-20.999765/graph/graph.png
new file mode 100644
index 0000000..ef59b35
Binary files /dev/null and b/test_instances/2026-06-30_15-07-20.999765/graph/graph.png differ
diff --git a/test_instances/2026-06-30_15-07-20.999765/input_requests_traces.json b/test_instances/2026-06-30_15-07-20.999765/input_requests_traces.json
new file mode 100644
index 0000000..0187432
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/input_requests_traces.json
@@ -0,0 +1,6128 @@
+{
+  "0": {
+    "0": [
+      18,
+      19,
+      19,
+      18,
+      18,
+      19,
+      20,
+      19,
+      20,
+      21,
+      23,
+      21,
+      23,
+      21,
+      21,
+      20,
+      20,
+      18,
+      17,
+      17,
+      15,
+      14,
+      15,
+      14,
+      13,
+      12,
+      10,
+      11,
+      10,
+      9,
+      9,
+      8,
+      9,
+      17,
+      16,
+      13,
+      15,
+      12,
+      14,
+      12,
+      12,
+      12,
+      9,
+      9,
+      9,
+      10,
+      10,
+      9,
+      11,
+      11,
+      11,
+      13,
+      12,
+      13,
+      13,
+      14,
+      16,
+      17,
+      18,
+      19,
+      19,
+      21,
+      22,
+      24,
+      24,
+      24,
+      26,
+      25,
+      25,
+      23,
+      23,
+      21,
+      19,
+      17,
+      19,
+      15,
+      13,
+      15,
+      14,
+      15,
+      11,
+      11,
+      11,
+      11,
+      11,
+      9,
+      10,
+      11,
+      10,
+      13,
+      13,
+      14,
+      14,
+      15,
+      18,
+      16,
+      18,
+      19,
+      19,
+      21
+    ],
+    "1": [
+      19,
+      17,
+      18,
+      18,
+      17,
+      17,
+      15,
+      18,
+      17,
+      18,
+      20,
+      21,
+      22,
+      21,
+      19,
+      20,
+      20,
+      21,
+      21,
+      21,
+      22,
+      22,
+      23,
+      24,
+      24,
+      24,
+      24,
+      23,
+      26,
+      26,
+      26,
+      26,
+      24,
+      24,
+      24,
+      23,
+      26,
+      23,
+      24,
+      24,
+      22,
+      20,
+      20,
+      18,
+      18,
+      17,
+      18,
+      16,
+      17,
+      14,
+      15,
+      14,
+      15,
+      15,
+      13,
+      13,
+      12,
+      12,
+      13,
+      11,
+      11,
+      10,
+      9,
+      11,
+      10,
+      8,
+      27,
+      26,
+      29,
+      27,
+      28,
+      30,
+      29,
+      29,
+      30,
+      29,
+      31,
+      29,
+      27,
+      28,
+      27,
+      26,
+      27,
+      25,
+      22,
+      23,
+      22,
+      20,
+      19,
+      20,
+      18,
+      16,
+      15,
+      14,
+      13,
+      12,
+      11,
+      10,
+      9,
+      19
+    ],
+    "2": [
+      18,
+      18,
+      18,
+      17,
+      17,
+      16,
+      18,
+      20,
+      21,
+      20,
+      21,
+      21,
+      21,
+      23,
+      23,
+      23,
+      21,
+      21,
+      22,
+      21,
+      21,
+      19,
+      19,
+      20,
+      20,
+      21,
+      20,
+      19,
+      17,
+      18,
+      17,
+      13,
+      15,
+      19,
+      18,
+      17,
+      17,
+      15,
+      14,
+      14,
+      14,
+      13,
+      13,
+      12,
+      12,
+      12,
+      10,
+      12,
+      11,
+      10,
+      10,
+      8,
+      12,
+      12,
+      11,
+      11,
+      10,
+      13,
+      15,
+      13,
+      16,
+      14,
+      14,
+      16,
+      18,
+      19,
+      10,
+      11,
+      10,
+      11,
+      11,
+      13,
+      13,
+      13,
+      14,
+      17,
+      17,
+      17,
+      16,
+      19,
+      19,
+      20,
+      20,
+      20,
+      24,
+      25,
+      25,
+      28,
+      26,
+      27,
+      27,
+      27,
+      27,
+      27,
+      27,
+      27,
+      29,
+      27,
+      27,
+      8
+    ],
+    "3": [
+      20,
+      19,
+      18,
+      18,
+      21,
+      21,
+      20,
+      22,
+      21,
+      20,
+      21,
+      20,
+      19,
+      18,
+      19,
+      16,
+      13,
+      13,
+      12,
+      10,
+      9,
+      7,
+      7,
+      7,
+      8,
+      8,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      18,
+      26,
+      25,
+      27,
+      27,
+      26,
+      27,
+      25,
+      24,
+      24,
+      23,
+      23,
+      23,
+      23,
+      23,
+      22,
+      20,
+      20,
+      19,
+      18,
+      17,
+      16,
+      17,
+      16,
+      15,
+      15,
+      14,
+      13,
+      12,
+      12,
+      10,
+      12,
+      11,
+      12,
+      25,
+      24,
+      26,
+      26,
+      27,
+      27,
+      27,
+      29,
+      29,
+      28,
+      30,
+      29,
+      32,
+      29,
+      33,
+      30,
+      29,
+      28,
+      29,
+      29,
+      26,
+      25,
+      25,
+      25,
+      22,
+      23,
+      19,
+      18,
+      17,
+      16,
+      15,
+      13,
+      14,
+      21
+    ],
+    "4": [
+      17,
+      19,
+      18,
+      17,
+      17,
+      17,
+      17,
+      19,
+      19,
+      20,
+      21,
+      21,
+      21,
+      21,
+      22,
+      23,
+      23,
+      22,
+      21,
+      21,
+      22,
+      21,
+      21,
+      20,
+      22,
+      21,
+      19,
+      20,
+      20,
+      18,
+      19,
+      18,
+      19,
+      27,
+      28,
+      27,
+      26,
+      27,
+      25,
+      26,
+      23,
+      24,
+      25,
+      23,
+      22,
+      23,
+      23,
+      21,
+      21,
+      24,
+      21,
+      21,
+      19,
+      19,
+      18,
+      19,
+      16,
+      17,
+      14,
+      15,
+      15,
+      14,
+      12,
+      11,
+      12,
+      11,
+      20,
+      24,
+      25,
+      26,
+      27,
+      29,
+      29,
+      28,
+      29,
+      28,
+      27,
+      26,
+      25,
+      24,
+      23,
+      19,
+      19,
+      16,
+      15,
+      13,
+      12,
+      12,
+      11,
+      10,
+      10,
+      10,
+      11,
+      13,
+      13,
+      13,
+      16,
+      18,
+      19,
+      14
+    ],
+    "5": [
+      18,
+      20,
+      21,
+      23,
+      21,
+      21,
+      20,
+      19,
+      16,
+      14,
+      13,
+      10,
+      9,
+      6,
+      7,
+      8,
+      10,
+      11,
+      13,
+      17,
+      18,
+      21,
+      23,
+      23,
+      22,
+      22,
+      19,
+      19,
+      16,
+      13,
+      10,
+      9,
+      8,
+      18,
+      20,
+      23,
+      26,
+      26,
+      29,
+      27,
+      29,
+      30,
+      30,
+      30,
+      29,
+      27,
+      28,
+      27,
+      25,
+      24,
+      22,
+      21,
+      19,
+      17,
+      16,
+      12,
+      11,
+      13,
+      8,
+      9,
+      9,
+      12,
+      14,
+      13,
+      14,
+      16,
+      26,
+      25,
+      24,
+      21,
+      20,
+      20,
+      16,
+      18,
+      17,
+      16,
+      13,
+      13,
+      11,
+      11,
+      11,
+      10,
+      8,
+      11,
+      10,
+      11,
+      9,
+      12,
+      12,
+      15,
+      13,
+      14,
+      15,
+      16,
+      17,
+      19,
+      18,
+      19,
+      21,
+      20
+    ],
+    "6": [
+      18,
+      18,
+      15,
+      18,
+      18,
+      18,
+      18,
+      17,
+      19,
+      19,
+      20,
+      20,
+      20,
+      20,
+      21,
+      22,
+      22,
+      22,
+      23,
+      21,
+      21,
+      23,
+      24,
+      22,
+      23,
+      24,
+      22,
+      24,
+      23,
+      23,
+      23,
+      23,
+      21,
+      10,
+      13,
+      16,
+      18,
+      22,
+      25,
+      28,
+      28,
+      28,
+      31,
+      29,
+      26,
+      21,
+      17,
+      16,
+      10,
+      9,
+      9,
+      10,
+      14,
+      17,
+      20,
+      24,
+      27,
+      31,
+      33,
+      32,
+      31,
+      32,
+      27,
+      22,
+      18,
+      15,
+      27,
+      26,
+      28,
+      29,
+      28,
+      29,
+      28,
+      29,
+      30,
+      28,
+      29,
+      27,
+      29,
+      26,
+      24,
+      25,
+      25,
+      24,
+      23,
+      24,
+      20,
+      20,
+      18,
+      17,
+      16,
+      14,
+      15,
+      12,
+      12,
+      11,
+      10,
+      9,
+      9,
+      23
+    ],
+    "7": [
+      18,
+      18,
+      18,
+      17,
+      17,
+      17,
+      18,
+      18,
+      18,
+      19,
+      20,
+      21,
+      21,
+      21,
+      22,
+      21,
+      22,
+      21,
+      20,
+      21,
+      22,
+      22,
+      23,
+      22,
+      23,
+      23,
+      25,
+      24,
+      24,
+      23,
+      23,
+      24,
+      23,
+      24,
+      27,
+      29,
+      28,
+      32,
+      29,
+      30,
+      27,
+      25,
+      25,
+      25,
+      22,
+      17,
+      17,
+      15,
+      13,
+      12,
+      11,
+      12,
+      11,
+      10,
+      12,
+      13,
+      15,
+      16,
+      18,
+      20,
+      24,
+      24,
+      24,
+      28,
+      31,
+      30,
+      25,
+      25,
+      23,
+      23,
+      20,
+      18,
+      20,
+      15,
+      17,
+      14,
+      14,
+      12,
+      11,
+      12,
+      8,
+      12,
+      11,
+      7,
+      8,
+      12,
+      11,
+      12,
+      12,
+      13,
+      14,
+      15,
+      17,
+      17,
+      17,
+      18,
+      19,
+      22,
+      20,
+      22
+    ],
+    "8": [
+      19,
+      21,
+      22,
+      22,
+      23,
+      20,
+      19,
+      16,
+      14,
+      11,
+      9,
+      7,
+      7,
+      8,
+      9,
+      12,
+      15,
+      17,
+      20,
+      22,
+      22,
+      22,
+      19,
+      19,
+      16,
+      11,
+      11,
+      9,
+      7,
+      8,
+      11,
+      13,
+      16,
+      22,
+      23,
+      21,
+      21,
+      22,
+      18,
+      18,
+      19,
+      19,
+      18,
+      17,
+      13,
+      15,
+      14,
+      13,
+      13,
+      13,
+      14,
+      14,
+      14,
+      10,
+      11,
+      12,
+      11,
+      10,
+      12,
+      11,
+      10,
+      12,
+      11,
+      11,
+      13,
+      13,
+      10,
+      9,
+      12,
+      9,
+      9,
+      9,
+      9,
+      12,
+      9,
+      12,
+      10,
+      10,
+      11,
+      12,
+      12,
+      12,
+      15,
+      15,
+      16,
+      15,
+      16,
+      17,
+      18,
+      18,
+      16,
+      19,
+      19,
+      17,
+      17,
+      21,
+      21,
+      19,
+      20,
+      23
+    ],
+    "9": [
+      19,
+      20,
+      22,
+      21,
+      23,
+      20,
+      18,
+      17,
+      13,
+      11,
+      7,
+      6,
+      5,
+      10,
+      13,
+      13,
+      17,
+      20,
+      21,
+      22,
+      21,
+      18,
+      17,
+      15,
+      12,
+      11,
+      7,
+      9,
+      10,
+      11,
+      16,
+      19,
+      22,
+      26,
+      26,
+      26,
+      25,
+      24,
+      25,
+      23,
+      24,
+      23,
+      21,
+      20,
+      22,
+      21,
+      16,
+      17,
+      18,
+      19,
+      18,
+      17,
+      16,
+      15,
+      16,
+      13,
+      16,
+      13,
+      10,
+      11,
+      12,
+      11,
+      12,
+      10,
+      10,
+      10,
+      29,
+      29,
+      28,
+      29,
+      30,
+      27,
+      26,
+      29,
+      26,
+      26,
+      25,
+      24,
+      23,
+      20,
+      21,
+      19,
+      17,
+      17,
+      15,
+      15,
+      15,
+      14,
+      10,
+      11,
+      11,
+      12,
+      11,
+      10,
+      8,
+      8,
+      10,
+      10,
+      9,
+      14
+    ],
+    "10": [
+      18,
+      17,
+      17,
+      17,
+      17,
+      18,
+      18,
+      17,
+      17,
+      19,
+      19,
+      21,
+      22,
+      21,
+      21,
+      22,
+      20,
+      21,
+      22,
+      22,
+      22,
+      22,
+      23,
+      23,
+      23,
+      22,
+      22,
+      22,
+      22,
+      22,
+      22,
+      21,
+      21,
+      23,
+      23,
+      22,
+      22,
+      21,
+      21,
+      22,
+      20,
+      18,
+      18,
+      19,
+      17,
+      17,
+      18,
+      14,
+      14,
+      13,
+      12,
+      11,
+      11,
+      11,
+      12,
+      12,
+      11,
+      9,
+      9,
+      11,
+      9,
+      10,
+      11,
+      11,
+      11,
+      11,
+      26,
+      23,
+      21,
+      19,
+      18,
+      15,
+      15,
+      12,
+      11,
+      10,
+      9,
+      12,
+      10,
+      12,
+      14,
+      15,
+      19,
+      21,
+      23,
+      24,
+      27,
+      30,
+      30,
+      29,
+      31,
+      28,
+      27,
+      27,
+      25,
+      22,
+      20,
+      18,
+      14,
+      21
+    ],
+    "11": [
+      17,
+      18,
+      18,
+      17,
+      15,
+      17,
+      17,
+      16,
+      18,
+      19,
+      19,
+      20,
+      20,
+      22,
+      20,
+      22,
+      21,
+      22,
+      23,
+      23,
+      22,
+      23,
+      23,
+      23,
+      23,
+      25,
+      25,
+      25,
+      26,
+      24,
+      25,
+      25,
+      22,
+      16,
+      18,
+      19,
+      21,
+      22,
+      25,
+      27,
+      28,
+      29,
+      29,
+      30,
+      30,
+      30,
+      30,
+      30,
+      28,
+      26,
+      23,
+      23,
+      21,
+      19,
+      16,
+      16,
+      14,
+      12,
+      10,
+      11,
+      11,
+      11,
+      10,
+      12,
+      12,
+      13,
+      8,
+      11,
+      9,
+      9,
+      11,
+      10,
+      9,
+      10,
+      12,
+      11,
+      11,
+      12,
+      11,
+      12,
+      12,
+      16,
+      13,
+      15,
+      16,
+      18,
+      19,
+      16,
+      20,
+      20,
+      20,
+      19,
+      20,
+      23,
+      21,
+      23,
+      22,
+      23,
+      23,
+      21
+    ],
+    "12": [
+      18,
+      16,
+      16,
+      17,
+      16,
+      16,
+      16,
+      17,
+      18,
+      18,
+      19,
+      20,
+      21,
+      21,
+      22,
+      21,
+      22,
+      21,
+      21,
+      22,
+      22,
+      23,
+      23,
+      23,
+      24,
+      25,
+      26,
+      25,
+      24,
+      23,
+      23,
+      22,
+      21,
+      9,
+      9,
+      11,
+      11,
+      14,
+      14,
+      15,
+      16,
+      18,
+      19,
+      19,
+      22,
+      27,
+      25,
+      29,
+      27,
+      30,
+      30,
+      32,
+      30,
+      32,
+      33,
+      33,
+      31,
+      28,
+      29,
+      26,
+      27,
+      24,
+      22,
+      19,
+      17,
+      16,
+      18,
+      20,
+      21,
+      23,
+      24,
+      28,
+      27,
+      28,
+      29,
+      32,
+      30,
+      30,
+      28,
+      29,
+      24,
+      24,
+      22,
+      21,
+      19,
+      15,
+      15,
+      14,
+      13,
+      10,
+      12,
+      10,
+      10,
+      9,
+      10,
+      11,
+      12,
+      14,
+      15,
+      22
+    ],
+    "13": [
+      19,
+      19,
+      17,
+      16,
+      16,
+      17,
+      18,
+      19,
+      19,
+      20,
+      21,
+      21,
+      23,
+      22,
+      22,
+      22,
+      22,
+      22,
+      22,
+      21,
+      22,
+      22,
+      22,
+      23,
+      22,
+      22,
+      23,
+      22,
+      24,
+      23,
+      22,
+      20,
+      20,
+      13,
+      13,
+      9,
+      12,
+      12,
+      10,
+      11,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      11,
+      14,
+      14,
+      15,
+      18,
+      15,
+      18,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      28,
+      27,
+      27,
+      29,
+      30,
+      29,
+      30,
+      15,
+      14,
+      14,
+      12,
+      10,
+      10,
+      12,
+      8,
+      7,
+      10,
+      8,
+      10,
+      12,
+      12,
+      14,
+      16,
+      15,
+      16,
+      18,
+      21,
+      22,
+      25,
+      25,
+      24,
+      26,
+      26,
+      29,
+      28,
+      28,
+      28,
+      27,
+      27,
+      27,
+      21
+    ],
+    "14": [
+      19,
+      19,
+      18,
+      18,
+      17,
+      18,
+      18,
+      18,
+      19,
+      21,
+      20,
+      21,
+      23,
+      23,
+      21,
+      23,
+      22,
+      22,
+      21,
+      20,
+      21,
+      20,
+      19,
+      20,
+      20,
+      20,
+      21,
+      21,
+      17,
+      20,
+      17,
+      16,
+      15,
+      15,
+      15,
+      14,
+      12,
+      11,
+      11,
+      10,
+      12,
+      11,
+      9,
+      10,
+      11,
+      11,
+      9,
+      8,
+      12,
+      12,
+      12,
+      13,
+      14,
+      16,
+      15,
+      16,
+      20,
+      19,
+      20,
+      20,
+      23,
+      24,
+      24,
+      27,
+      26,
+      28,
+      11,
+      12,
+      8,
+      9,
+      9,
+      11,
+      11,
+      11,
+      10,
+      9,
+      10,
+      11,
+      12,
+      12,
+      12,
+      11,
+      15,
+      15,
+      14,
+      14,
+      15,
+      14,
+      18,
+      17,
+      18,
+      18,
+      18,
+      19,
+      19,
+      19,
+      20,
+      20,
+      21,
+      10
+    ],
+    "15": [
+      19,
+      19,
+      20,
+      19,
+      21,
+      20,
+      20,
+      21,
+      21,
+      22,
+      19,
+      19,
+      18,
+      18,
+      16,
+      14,
+      14,
+      12,
+      9,
+      9,
+      9,
+      8,
+      7,
+      8,
+      8,
+      9,
+      10,
+      10,
+      11,
+      14,
+      15,
+      18,
+      21,
+      22,
+      21,
+      17,
+      14,
+      11,
+      11,
+      9,
+      10,
+      11,
+      12,
+      14,
+      16,
+      19,
+      23,
+      27,
+      29,
+      30,
+      32,
+      31,
+      32,
+      29,
+      28,
+      27,
+      21,
+      19,
+      16,
+      14,
+      13,
+      10,
+      11,
+      10,
+      11,
+      13,
+      17,
+      14,
+      14,
+      12,
+      11,
+      11,
+      9,
+      10,
+      7,
+      11,
+      10,
+      10,
+      9,
+      12,
+      12,
+      13,
+      13,
+      18,
+      21,
+      20,
+      23,
+      22,
+      24,
+      25,
+      25,
+      28,
+      28,
+      28,
+      29,
+      28,
+      27,
+      27,
+      25,
+      24
+    ],
+    "16": [
+      19,
+      20,
+      19,
+      21,
+      22,
+      22,
+      22,
+      21,
+      20,
+      18,
+      17,
+      15,
+      15,
+      13,
+      11,
+      9,
+      7,
+      8,
+      7,
+      8,
+      9,
+      9,
+      12,
+      12,
+      17,
+      19,
+      22,
+      23,
+      26,
+      26,
+      23,
+      26,
+      24,
+      12,
+      11,
+      12,
+      10,
+      11,
+      9,
+      9,
+      11,
+      9,
+      10,
+      10,
+      12,
+      13,
+      15,
+      15,
+      16,
+      17,
+      20,
+      20,
+      22,
+      25,
+      27,
+      25,
+      28,
+      28,
+      31,
+      29,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      9,
+      11,
+      11,
+      14,
+      17,
+      17,
+      20,
+      24,
+      27,
+      28,
+      29,
+      31,
+      30,
+      28,
+      28,
+      26,
+      24,
+      22,
+      19,
+      14,
+      15,
+      10,
+      11,
+      9,
+      10,
+      11,
+      12,
+      13,
+      16,
+      19,
+      21,
+      21,
+      24,
+      21
+    ],
+    "17": [
+      19,
+      17,
+      18,
+      18,
+      17,
+      17,
+      18,
+      17,
+      19,
+      20,
+      19,
+      20,
+      19,
+      21,
+      20,
+      22,
+      23,
+      22,
+      22,
+      22,
+      21,
+      22,
+      22,
+      23,
+      22,
+      22,
+      23,
+      24,
+      24,
+      24,
+      23,
+      24,
+      21,
+      25,
+      25,
+      23,
+      23,
+      18,
+      15,
+      14,
+      12,
+      12,
+      10,
+      10,
+      10,
+      11,
+      13,
+      17,
+      20,
+      26,
+      24,
+      29,
+      30,
+      32,
+      33,
+      32,
+      32,
+      32,
+      29,
+      28,
+      21,
+      21,
+      18,
+      14,
+      14,
+      13,
+      22,
+      25,
+      25,
+      26,
+      27,
+      27,
+      29,
+      28,
+      30,
+      28,
+      29,
+      28,
+      31,
+      29,
+      31,
+      29,
+      29,
+      28,
+      26,
+      27,
+      26,
+      25,
+      24,
+      22,
+      22,
+      19,
+      18,
+      18,
+      15,
+      15,
+      14,
+      14,
+      14,
+      24
+    ],
+    "18": [
+      19,
+      19,
+      20,
+      20,
+      21,
+      21,
+      21,
+      21,
+      22,
+      21,
+      21,
+      22,
+      20,
+      19,
+      18,
+      16,
+      14,
+      11,
+      11,
+      10,
+      9,
+      10,
+      8,
+      8,
+      8,
+      8,
+      9,
+      10,
+      10,
+      11,
+      13,
+      13,
+      14,
+      13,
+      9,
+      10,
+      8,
+      10,
+      14,
+      15,
+      18,
+      21,
+      25,
+      27,
+      30,
+      30,
+      29,
+      29,
+      30,
+      25,
+      24,
+      22,
+      17,
+      14,
+      11,
+      9,
+      11,
+      13,
+      13,
+      16,
+      18,
+      21,
+      27,
+      29,
+      29,
+      28,
+      10,
+      8,
+      9,
+      11,
+      9,
+      8,
+      10,
+      10,
+      7,
+      9,
+      9,
+      10,
+      10,
+      11,
+      12,
+      13,
+      13,
+      14,
+      14,
+      14,
+      13,
+      14,
+      15,
+      17,
+      16,
+      17,
+      17,
+      18,
+      18,
+      20,
+      19,
+      20,
+      19,
+      15
+    ],
+    "19": [
+      19,
+      19,
+      17,
+      17,
+      17,
+      17,
+      18,
+      18,
+      20,
+      19,
+      21,
+      22,
+      21,
+      22,
+      22,
+      21,
+      22,
+      23,
+      20,
+      21,
+      22,
+      20,
+      22,
+      21,
+      21,
+      22,
+      21,
+      20,
+      20,
+      19,
+      18,
+      16,
+      16,
+      10,
+      9,
+      10,
+      8,
+      11,
+      10,
+      11,
+      10,
+      12,
+      12,
+      12,
+      15,
+      15,
+      19,
+      19,
+      21,
+      20,
+      24,
+      26,
+      26,
+      30,
+      27,
+      31,
+      29,
+      31,
+      32,
+      33,
+      32,
+      30,
+      32,
+      30,
+      31,
+      29,
+      11,
+      8,
+      8,
+      10,
+      11,
+      9,
+      11,
+      10,
+      12,
+      11,
+      15,
+      15,
+      20,
+      19,
+      22,
+      22,
+      26,
+      26,
+      27,
+      28,
+      30,
+      30,
+      32,
+      30,
+      30,
+      30,
+      28,
+      28,
+      28,
+      23,
+      22,
+      21,
+      22,
+      11
+    ]
+  },
+  "1": {
+    "0": [
+      62,
+      69,
+      63,
+      59,
+      61,
+      60,
+      63,
+      62,
+      61,
+      59,
+      61,
+      66,
+      68,
+      68,
+      71,
+      72,
+      72,
+      74,
+      74,
+      68,
+      74,
+      78,
+      73,
+      77,
+      79,
+      71,
+      73,
+      73,
+      69,
+      68,
+      67,
+      68,
+      54,
+      74,
+      78,
+      77,
+      78,
+      78,
+      78,
+      71,
+      78,
+      77,
+      74,
+      77,
+      77,
+      71,
+      75,
+      74,
+      73,
+      66,
+      63,
+      57,
+      60,
+      54,
+      53,
+      57,
+      61,
+      51,
+      46,
+      46,
+      46,
+      44,
+      48,
+      45,
+      37,
+      35,
+      39,
+      35,
+      37,
+      34,
+      30,
+      37,
+      34,
+      28,
+      31,
+      31,
+      33,
+      31,
+      34,
+      27,
+      30,
+      35,
+      38,
+      40,
+      36,
+      41,
+      38,
+      45,
+      41,
+      41,
+      43,
+      48,
+      52,
+      52,
+      53,
+      51,
+      51,
+      59,
+      60,
+      53
+    ],
+    "1": [
+      61,
+      63,
+      62,
+      60,
+      58,
+      59,
+      60,
+      58,
+      61,
+      67,
+      61,
+      63,
+      66,
+      66,
+      68,
+      68,
+      73,
+      74,
+      70,
+      79,
+      77,
+      76,
+      79,
+      76,
+      75,
+      74,
+      74,
+      81,
+      71,
+      76,
+      73,
+      68,
+      69,
+      53,
+      66,
+      75,
+      81,
+      88,
+      97,
+      91,
+      83,
+      77,
+      63,
+      50,
+      47,
+      42,
+      37,
+      40,
+      47,
+      63,
+      71,
+      103,
+      107,
+      115,
+      116,
+      111,
+      112,
+      100,
+      80,
+      69,
+      56,
+      37,
+      41,
+      37,
+      37,
+      48,
+      39,
+      38,
+      37,
+      29,
+      42,
+      32,
+      35,
+      30,
+      33,
+      34,
+      25,
+      35,
+      34,
+      37,
+      31,
+      30,
+      27,
+      36,
+      36,
+      39,
+      41,
+      35,
+      37,
+      40,
+      42,
+      42,
+      41,
+      44,
+      50,
+      52,
+      50,
+      59,
+      57,
+      73
+    ],
+    "2": [
+      63,
+      67,
+      61,
+      60,
+      63,
+      58,
+      63,
+      64,
+      61,
+      65,
+      69,
+      63,
+      66,
+      69,
+      72,
+      70,
+      70,
+      73,
+      67,
+      68,
+      65,
+      69,
+      63,
+      66,
+      58,
+      58,
+      55,
+      56,
+      48,
+      39,
+      48,
+      39,
+      39,
+      63,
+      60,
+      59,
+      52,
+      54,
+      50,
+      42,
+      53,
+      43,
+      43,
+      43,
+      40,
+      41,
+      42,
+      35,
+      36,
+      33,
+      38,
+      41,
+      35,
+      34,
+      42,
+      43,
+      36,
+      38,
+      42,
+      42,
+      53,
+      49,
+      55,
+      58,
+      50,
+      58,
+      39,
+      38,
+      34,
+      36,
+      30,
+      38,
+      43,
+      45,
+      47,
+      57,
+      61,
+      63,
+      72,
+      74,
+      81,
+      82,
+      83,
+      88,
+      90,
+      87,
+      95,
+      87,
+      87,
+      85,
+      83,
+      82,
+      74,
+      73,
+      69,
+      62,
+      59,
+      52,
+      46,
+      57
+    ],
+    "3": [
+      63,
+      57,
+      64,
+      59,
+      61,
+      60,
+      58,
+      62,
+      62,
+      64,
+      60,
+      66,
+      64,
+      68,
+      65,
+      66,
+      74,
+      77,
+      74,
+      78,
+      76,
+      76,
+      80,
+      79,
+      73,
+      77,
+      72,
+      68,
+      72,
+      73,
+      69,
+      69,
+      60,
+      76,
+      77,
+      81,
+      79,
+      80,
+      75,
+      75,
+      83,
+      77,
+      80,
+      79,
+      82,
+      68,
+      75,
+      74,
+      73,
+      71,
+      79,
+      66,
+      64,
+      60,
+      55,
+      55,
+      54,
+      51,
+      48,
+      42,
+      48,
+      48,
+      39,
+      35,
+      38,
+      41,
+      75,
+      77,
+      75,
+      76,
+      77,
+      84,
+      82,
+      90,
+      86,
+      90,
+      83,
+      89,
+      92,
+      93,
+      88,
+      87,
+      91,
+      90,
+      87,
+      92,
+      84,
+      85,
+      86,
+      84,
+      80,
+      75,
+      73,
+      75,
+      68,
+      62,
+      64,
+      65,
+      54,
+      55
+    ],
+    "4": [
+      71,
+      64,
+      62,
+      69,
+      65,
+      66,
+      65,
+      66,
+      70,
+      68,
+      67,
+      64,
+      68,
+      64,
+      60,
+      58,
+      61,
+      56,
+      56,
+      49,
+      39,
+      39,
+      37,
+      41,
+      34,
+      28,
+      31,
+      30,
+      30,
+      31,
+      29,
+      33,
+      38,
+      71,
+      66,
+      65,
+      58,
+      57,
+      61,
+      58,
+      54,
+      59,
+      55,
+      48,
+      51,
+      52,
+      49,
+      46,
+      47,
+      40,
+      44,
+      41,
+      34,
+      41,
+      33,
+      36,
+      40,
+      40,
+      41,
+      38,
+      38,
+      37,
+      44,
+      43,
+      44,
+      46,
+      34,
+      29,
+      34,
+      37,
+      33,
+      34,
+      36,
+      35,
+      40,
+      39,
+      42,
+      39,
+      40,
+      40,
+      48,
+      49,
+      48,
+      55,
+      53,
+      56,
+      57,
+      59,
+      62,
+      63,
+      63,
+      66,
+      72,
+      78,
+      74,
+      76,
+      74,
+      76,
+      83,
+      34
+    ],
+    "5": [
+      63,
+      61,
+      66,
+      60,
+      61,
+      59,
+      62,
+      56,
+      56,
+      62,
+      61,
+      61,
+      61,
+      72,
+      69,
+      72,
+      69,
+      73,
+      75,
+      79,
+      82,
+      80,
+      79,
+      81,
+      80,
+      79,
+      79,
+      76,
+      76,
+      74,
+      76,
+      80,
+      71,
+      48,
+      40,
+      32,
+      33,
+      31,
+      37,
+      32,
+      44,
+      49,
+      67,
+      78,
+      83,
+      99,
+      114,
+      123,
+      114,
+      112,
+      101,
+      103,
+      83,
+      78,
+      63,
+      46,
+      50,
+      34,
+      33,
+      42,
+      40,
+      49,
+      62,
+      69,
+      78,
+      81,
+      55,
+      53,
+      57,
+      63,
+      58,
+      67,
+      67,
+      69,
+      72,
+      77,
+      73,
+      83,
+      83,
+      79,
+      76,
+      92,
+      84,
+      86,
+      90,
+      86,
+      90,
+      90,
+      93,
+      92,
+      95,
+      94,
+      86,
+      89,
+      88,
+      85,
+      86,
+      85,
+      83,
+      83
+    ],
+    "6": [
+      61,
+      61,
+      66,
+      62,
+      61,
+      66,
+      65,
+      65,
+      67,
+      68,
+      64,
+      69,
+      66,
+      69,
+      69,
+      70,
+      65,
+      64,
+      64,
+      62,
+      61,
+      62,
+      59,
+      55,
+      52,
+      53,
+      47,
+      43,
+      41,
+      39,
+      32,
+      37,
+      34,
+      48,
+      57,
+      61,
+      68,
+      68,
+      82,
+      87,
+      92,
+      93,
+      111,
+      109,
+      105,
+      112,
+      103,
+      99,
+      101,
+      95,
+      84,
+      75,
+      67,
+      66,
+      55,
+      55,
+      43,
+      46,
+      38,
+      42,
+      38,
+      30,
+      41,
+      37,
+      50,
+      50,
+      38,
+      37,
+      32,
+      34,
+      39,
+      38,
+      30,
+      36,
+      33,
+      33,
+      35,
+      33,
+      32,
+      29,
+      36,
+      32,
+      32,
+      38,
+      36,
+      37,
+      42,
+      41,
+      45,
+      42,
+      46,
+      48,
+      45,
+      49,
+      56,
+      56,
+      58,
+      65,
+      62,
+      87
+    ],
+    "7": [
+      64,
+      63,
+      67,
+      69,
+      70,
+      69,
+      71,
+      67,
+      67,
+      63,
+      64,
+      64,
+      60,
+      53,
+      50,
+      45,
+      39,
+      36,
+      34,
+      29,
+      28,
+      26,
+      29,
+      25,
+      31,
+      37,
+      41,
+      42,
+      53,
+      60,
+      69,
+      73,
+      85,
+      63,
+      57,
+      52,
+      48,
+      51,
+      45,
+      45,
+      41,
+      37,
+      42,
+      50,
+      38,
+      47,
+      37,
+      37,
+      42,
+      38,
+      39,
+      39,
+      40,
+      34,
+      41,
+      35,
+      46,
+      37,
+      50,
+      46,
+      54,
+      54,
+      50,
+      61,
+      65,
+      65,
+      58,
+      56,
+      65,
+      68,
+      70,
+      71,
+      67,
+      73,
+      73,
+      76,
+      79,
+      80,
+      85,
+      81,
+      80,
+      86,
+      86,
+      85,
+      86,
+      85,
+      95,
+      89,
+      90,
+      89,
+      89,
+      84,
+      92,
+      83,
+      87,
+      86,
+      85,
+      81,
+      75,
+      87
+    ],
+    "8": [
+      58,
+      67,
+      74,
+      69,
+      73,
+      68,
+      69,
+      71,
+      63,
+      58,
+      53,
+      48,
+      35,
+      32,
+      31,
+      27,
+      23,
+      26,
+      31,
+      33,
+      38,
+      51,
+      62,
+      66,
+      73,
+      80,
+      84,
+      86,
+      90,
+      81,
+      78,
+      70,
+      70,
+      76,
+      75,
+      76,
+      77,
+      73,
+      70,
+      74,
+      67,
+      71,
+      74,
+      74,
+      65,
+      66,
+      65,
+      69,
+      66,
+      59,
+      53,
+      56,
+      52,
+      47,
+      50,
+      46,
+      46,
+      41,
+      41,
+      40,
+      39,
+      41,
+      26,
+      32,
+      33,
+      32,
+      92,
+      92,
+      105,
+      104,
+      97,
+      100,
+      94,
+      90,
+      87,
+      85,
+      80,
+      75,
+      62,
+      57,
+      55,
+      44,
+      43,
+      34,
+      29,
+      29,
+      29,
+      36,
+      28,
+      32,
+      42,
+      34,
+      43,
+      52,
+      60,
+      66,
+      72,
+      76,
+      76,
+      47
+    ],
+    "9": [
+      63,
+      64,
+      63,
+      65,
+      63,
+      69,
+      66,
+      68,
+      70,
+      65,
+      69,
+      68,
+      66,
+      69,
+      65,
+      61,
+      68,
+      60,
+      60,
+      59,
+      60,
+      50,
+      50,
+      44,
+      42,
+      40,
+      32,
+      34,
+      33,
+      22,
+      29,
+      32,
+      33,
+      70,
+      72,
+      67,
+      69,
+      66,
+      62,
+      70,
+      69,
+      61,
+      55,
+      58,
+      65,
+      53,
+      53,
+      52,
+      53,
+      59,
+      44,
+      42,
+      42,
+      47,
+      49,
+      36,
+      33,
+      40,
+      40,
+      43,
+      32,
+      43,
+      36,
+      39,
+      47,
+      39,
+      76,
+      69,
+      57,
+      48,
+      56,
+      45,
+      40,
+      39,
+      38,
+      28,
+      35,
+      27,
+      28,
+      37,
+      36,
+      29,
+      37,
+      46,
+      44,
+      47,
+      50,
+      57,
+      57,
+      62,
+      69,
+      71,
+      74,
+      81,
+      80,
+      81,
+      85,
+      87,
+      90,
+      76
+    ],
+    "10": [
+      58,
+      64,
+      61,
+      64,
+      58,
+      58,
+      65,
+      62,
+      64,
+      59,
+      65,
+      67,
+      72,
+      68,
+      66,
+      72,
+      69,
+      69,
+      71,
+      75,
+      69,
+      70,
+      68,
+      68,
+      67,
+      69,
+      64,
+      59,
+      64,
+      60,
+      54,
+      50,
+      44,
+      86,
+      82,
+      81,
+      83,
+      78,
+      76,
+      77,
+      81,
+      79,
+      80,
+      84,
+      86,
+      80,
+      82,
+      75,
+      77,
+      76,
+      66,
+      67,
+      65,
+      61,
+      59,
+      58,
+      54,
+      48,
+      55,
+      48,
+      47,
+      51,
+      45,
+      39,
+      46,
+      36,
+      108,
+      99,
+      97,
+      97,
+      89,
+      86,
+      91,
+      82,
+      75,
+      67,
+      68,
+      65,
+      56,
+      53,
+      53,
+      46,
+      42,
+      38,
+      36,
+      36,
+      32,
+      33,
+      31,
+      31,
+      35,
+      31,
+      27,
+      32,
+      35,
+      37,
+      37,
+      40,
+      44,
+      31
+    ],
+    "11": [
+      67,
+      63,
+      59,
+      63,
+      61,
+      62,
+      61,
+      62,
+      59,
+      62,
+      61,
+      63,
+      64,
+      64,
+      68,
+      74,
+      74,
+      75,
+      73,
+      78,
+      77,
+      74,
+      71,
+      79,
+      74,
+      77,
+      81,
+      75,
+      77,
+      71,
+      71,
+      66,
+      73,
+      27,
+      20,
+      36,
+      29,
+      33,
+      32,
+      41,
+      44,
+      46,
+      56,
+      58,
+      65,
+      76,
+      80,
+      85,
+      88,
+      90,
+      102,
+      101,
+      104,
+      108,
+      113,
+      114,
+      114,
+      116,
+      110,
+      114,
+      108,
+      103,
+      103,
+      98,
+      87,
+      87,
+      83,
+      86,
+      92,
+      87,
+      92,
+      88,
+      89,
+      94,
+      92,
+      95,
+      95,
+      92,
+      84,
+      93,
+      90,
+      87,
+      89,
+      89,
+      84,
+      81,
+      81,
+      80,
+      76,
+      73,
+      73,
+      70,
+      63,
+      64,
+      59,
+      56,
+      52,
+      48,
+      47,
+      68
+    ],
+    "12": [
+      61,
+      64,
+      60,
+      60,
+      57,
+      57,
+      53,
+      56,
+      55,
+      57,
+      62,
+      59,
+      59,
+      63,
+      61,
+      67,
+      71,
+      71,
+      71,
+      82,
+      76,
+      78,
+      72,
+      87,
+      81,
+      86,
+      89,
+      82,
+      87,
+      89,
+      88,
+      90,
+      94,
+      36,
+      39,
+      40,
+      49,
+      58,
+      52,
+      62,
+      72,
+      83,
+      86,
+      94,
+      97,
+      103,
+      109,
+      117,
+      122,
+      117,
+      117,
+      107,
+      104,
+      106,
+      97,
+      95,
+      85,
+      85,
+      71,
+      65,
+      61,
+      51,
+      43,
+      45,
+      37,
+      39,
+      107,
+      101,
+      97,
+      96,
+      98,
+      91,
+      90,
+      92,
+      78,
+      78,
+      71,
+      66,
+      68,
+      66,
+      60,
+      58,
+      50,
+      45,
+      48,
+      42,
+      40,
+      38,
+      38,
+      33,
+      27,
+      31,
+      34,
+      27,
+      30,
+      30,
+      33,
+      30,
+      32,
+      65
+    ],
+    "13": [
+      62,
+      60,
+      52,
+      60,
+      58,
+      63,
+      58,
+      61,
+      58,
+      58,
+      60,
+      61,
+      64,
+      63,
+      65,
+      65,
+      67,
+      68,
+      77,
+      76,
+      76,
+      82,
+      80,
+      78,
+      87,
+      83,
+      86,
+      83,
+      84,
+      79,
+      89,
+      88,
+      85,
+      81,
+      80,
+      82,
+      75,
+      68,
+      75,
+      75,
+      77,
+      80,
+      72,
+      80,
+      74,
+      73,
+      81,
+      74,
+      76,
+      72,
+      69,
+      71,
+      64,
+      63,
+      61,
+      58,
+      56,
+      50,
+      50,
+      44,
+      42,
+      43,
+      44,
+      35,
+      37,
+      36,
+      99,
+      99,
+      102,
+      102,
+      98,
+      101,
+      90,
+      91,
+      91,
+      85,
+      86,
+      78,
+      83,
+      75,
+      72,
+      76,
+      71,
+      59,
+      64,
+      54,
+      48,
+      54,
+      51,
+      46,
+      39,
+      43,
+      39,
+      33,
+      33,
+      34,
+      22,
+      28,
+      29,
+      94
+    ],
+    "14": [
+      66,
+      65,
+      59,
+      64,
+      61,
+      59,
+      59,
+      60,
+      62,
+      59,
+      67,
+      64,
+      66,
+      65,
+      66,
+      70,
+      69,
+      75,
+      74,
+      72,
+      81,
+      81,
+      82,
+      79,
+      76,
+      79,
+      77,
+      78,
+      76,
+      81,
+      70,
+      73,
+      69,
+      80,
+      85,
+      82,
+      82,
+      79,
+      78,
+      77,
+      61,
+      55,
+      48,
+      50,
+      47,
+      39,
+      40,
+      40,
+      40,
+      41,
+      45,
+      53,
+      67,
+      70,
+      78,
+      91,
+      90,
+      102,
+      107,
+      110,
+      107,
+      116,
+      106,
+      104,
+      95,
+      82,
+      70,
+      66,
+      57,
+      57,
+      49,
+      45,
+      46,
+      38,
+      36,
+      35,
+      32,
+      30,
+      28,
+      29,
+      35,
+      36,
+      35,
+      37,
+      33,
+      45,
+      48,
+      47,
+      53,
+      63,
+      66,
+      65,
+      72,
+      78,
+      80,
+      79,
+      87,
+      87,
+      89,
+      71
+    ],
+    "15": [
+      60,
+      58,
+      59,
+      57,
+      59,
+      55,
+      58,
+      56,
+      59,
+      59,
+      61,
+      60,
+      60,
+      61,
+      69,
+      66,
+      70,
+      74,
+      75,
+      75,
+      79,
+      77,
+      81,
+      80,
+      83,
+      81,
+      84,
+      85,
+      86,
+      88,
+      89,
+      89,
+      92,
+      82,
+      86,
+      86,
+      88,
+      91,
+      90,
+      93,
+      80,
+      87,
+      75,
+      62,
+      71,
+      60,
+      51,
+      48,
+      40,
+      46,
+      37,
+      35,
+      40,
+      45,
+      53,
+      54,
+      66,
+      69,
+      81,
+      90,
+      94,
+      104,
+      106,
+      102,
+      107,
+      102,
+      37,
+      47,
+      48,
+      55,
+      55,
+      60,
+      73,
+      70,
+      80,
+      81,
+      92,
+      89,
+      95,
+      92,
+      93,
+      92,
+      93,
+      84,
+      89,
+      84,
+      77,
+      71,
+      72,
+      65,
+      57,
+      51,
+      50,
+      40,
+      35,
+      32,
+      37,
+      30,
+      29,
+      76
+    ],
+    "16": [
+      67,
+      61,
+      66,
+      64,
+      67,
+      67,
+      67,
+      67,
+      66,
+      71,
+      64,
+      68,
+      65,
+      63,
+      64,
+      61,
+      56,
+      57,
+      52,
+      49,
+      48,
+      43,
+      39,
+      35,
+      33,
+      28,
+      28,
+      34,
+      33,
+      36,
+      34,
+      29,
+      40,
+      37,
+      38,
+      39,
+      40,
+      34,
+      35,
+      31,
+      30,
+      39,
+      29,
+      33,
+      39,
+      47,
+      46,
+      50,
+      46,
+      52,
+      58,
+      58,
+      69,
+      69,
+      68,
+      67,
+      76,
+      82,
+      91,
+      86,
+      95,
+      99,
+      97,
+      98,
+      96,
+      101,
+      51,
+      61,
+      55,
+      58,
+      59,
+      62,
+      69,
+      66,
+      68,
+      73,
+      69,
+      75,
+      76,
+      77,
+      83,
+      83,
+      85,
+      86,
+      87,
+      90,
+      91,
+      92,
+      88,
+      88,
+      88,
+      92,
+      94,
+      86,
+      83,
+      88,
+      86,
+      82,
+      86,
+      35
+    ],
+    "17": [
+      64,
+      61,
+      60,
+      59,
+      61,
+      60,
+      58,
+      59,
+      56,
+      58,
+      59,
+      60,
+      65,
+      64,
+      69,
+      69,
+      69,
+      75,
+      75,
+      77,
+      80,
+      81,
+      80,
+      79,
+      84,
+      85,
+      86,
+      84,
+      79,
+      88,
+      81,
+      81,
+      78,
+      46,
+      40,
+      36,
+      33,
+      39,
+      33,
+      34,
+      35,
+      37,
+      36,
+      39,
+      35,
+      44,
+      37,
+      43,
+      43,
+      52,
+      60,
+      56,
+      61,
+      62,
+      63,
+      71,
+      73,
+      86,
+      80,
+      91,
+      90,
+      90,
+      89,
+      95,
+      101,
+      105,
+      36,
+      40,
+      32,
+      31,
+      34,
+      33,
+      34,
+      27,
+      37,
+      33,
+      31,
+      33,
+      30,
+      38,
+      34,
+      38,
+      37,
+      40,
+      41,
+      42,
+      42,
+      46,
+      48,
+      50,
+      52,
+      59,
+      56,
+      54,
+      57,
+      65,
+      60,
+      63,
+      69,
+      92
+    ],
+    "18": [
+      59,
+      64,
+      62,
+      64,
+      66,
+      69,
+      64,
+      64,
+      65,
+      68,
+      68,
+      65,
+      70,
+      66,
+      62,
+      59,
+      58,
+      54,
+      51,
+      47,
+      45,
+      43,
+      44,
+      30,
+      35,
+      32,
+      24,
+      31,
+      28,
+      32,
+      31,
+      35,
+      34,
+      54,
+      48,
+      46,
+      44,
+      46,
+      48,
+      40,
+      40,
+      37,
+      49,
+      36,
+      37,
+      39,
+      36,
+      36,
+      36,
+      39,
+      47,
+      44,
+      44,
+      45,
+      41,
+      55,
+      46,
+      53,
+      59,
+      60,
+      61,
+      64,
+      68,
+      72,
+      70,
+      69,
+      56,
+      67,
+      65,
+      71,
+      71,
+      72,
+      72,
+      77,
+      76,
+      81,
+      81,
+      83,
+      85,
+      91,
+      84,
+      89,
+      93,
+      89,
+      93,
+      90,
+      87,
+      90,
+      89,
+      89,
+      86,
+      84,
+      82,
+      84,
+      81,
+      80,
+      84,
+      73,
+      74,
+      29
+    ],
+    "19": [
+      64,
+      63,
+      71,
+      68,
+      69,
+      75,
+      72,
+      70,
+      72,
+      66,
+      63,
+      58,
+      53,
+      52,
+      46,
+      42,
+      39,
+      30,
+      33,
+      23,
+      26,
+      21,
+      28,
+      31,
+      42,
+      41,
+      51,
+      58,
+      61,
+      70,
+      81,
+      87,
+      95,
+      85,
+      90,
+      85,
+      93,
+      85,
+      82,
+      82,
+      75,
+      71,
+      63,
+      57,
+      54,
+      45,
+      46,
+      39,
+      37,
+      36,
+      42,
+      41,
+      53,
+      54,
+      66,
+      73,
+      74,
+      88,
+      94,
+      99,
+      108,
+      104,
+      113,
+      112,
+      103,
+      104,
+      65,
+      67,
+      78,
+      76,
+      80,
+      74,
+      76,
+      85,
+      83,
+      79,
+      85,
+      91,
+      89,
+      88,
+      92,
+      86,
+      91,
+      92,
+      96,
+      93,
+      91,
+      82,
+      85,
+      89,
+      83,
+      87,
+      87,
+      82,
+      78,
+      79,
+      75,
+      72,
+      71,
+      43
+    ]
+  },
+  "2": {
+    "0": [
+      13,
+      14,
+      14,
+      14,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      14,
+      14,
+      13,
+      12,
+      13,
+      12,
+      11,
+      9,
+      9,
+      9,
+      8,
+      8,
+      6,
+      6,
+      5,
+      6,
+      6,
+      6,
+      7,
+      7,
+      9,
+      10,
+      16,
+      16,
+      15,
+      16,
+      14,
+      15,
+      16,
+      14,
+      15,
+      15,
+      14,
+      15,
+      13,
+      14,
+      12,
+      13,
+      13,
+      13,
+      13,
+      13,
+      11,
+      10,
+      10,
+      11,
+      11,
+      9,
+      10,
+      9,
+      8,
+      8,
+      9,
+      9,
+      9,
+      8,
+      9,
+      7,
+      7,
+      7,
+      8,
+      7,
+      8,
+      8,
+      7,
+      9,
+      8,
+      8,
+      10,
+      10,
+      10,
+      10,
+      11,
+      11,
+      12,
+      11,
+      12,
+      13,
+      12,
+      12,
+      12,
+      13,
+      14,
+      14,
+      14,
+      15,
+      15,
+      16,
+      7
+    ],
+    "1": [
+      14,
+      14,
+      13,
+      14,
+      13,
+      14,
+      13,
+      13,
+      13,
+      13,
+      13,
+      14,
+      14,
+      14,
+      15,
+      15,
+      15,
+      15,
+      16,
+      15,
+      16,
+      16,
+      16,
+      15,
+      15,
+      16,
+      14,
+      15,
+      15,
+      15,
+      14,
+      14,
+      14,
+      10,
+      10,
+      10,
+      8,
+      10,
+      9,
+      7,
+      7,
+      8,
+      7,
+      7,
+      8,
+      8,
+      7,
+      7,
+      10,
+      10,
+      9,
+      11,
+      11,
+      13,
+      13,
+      12,
+      15,
+      15,
+      15,
+      17,
+      17,
+      17,
+      18,
+      18,
+      21,
+      19,
+      6,
+      7,
+      8,
+      8,
+      12,
+      14,
+      17,
+      19,
+      21,
+      24,
+      24,
+      24,
+      24,
+      23,
+      21,
+      20,
+      18,
+      17,
+      15,
+      12,
+      9,
+      9,
+      7,
+      6,
+      6,
+      6,
+      8,
+      8,
+      10,
+      11,
+      13,
+      13,
+      15,
+      13
+    ],
+    "2": [
+      13,
+      13,
+      13,
+      15,
+      14,
+      12,
+      14,
+      14,
+      13,
+      13,
+      14,
+      15,
+      14,
+      15,
+      14,
+      15,
+      15,
+      15,
+      15,
+      14,
+      15,
+      16,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      16,
+      13,
+      13,
+      12,
+      13,
+      8,
+      7,
+      7,
+      7,
+      7,
+      7,
+      8,
+      6,
+      7,
+      9,
+      8,
+      9,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      17,
+      16,
+      17,
+      20,
+      20,
+      21,
+      22,
+      23,
+      23,
+      23,
+      22,
+      24,
+      22,
+      23,
+      8,
+      9,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      11,
+      14,
+      14,
+      14,
+      13,
+      14,
+      15,
+      14,
+      16,
+      16,
+      16,
+      16,
+      18,
+      16,
+      18,
+      18,
+      19,
+      17,
+      18,
+      18,
+      18,
+      19,
+      18,
+      18,
+      19,
+      7
+    ],
+    "3": [
+      14,
+      14,
+      13,
+      12,
+      12,
+      13,
+      12,
+      12,
+      12,
+      13,
+      13,
+      12,
+      13,
+      12,
+      15,
+      13,
+      15,
+      14,
+      16,
+      16,
+      16,
+      16,
+      17,
+      17,
+      17,
+      18,
+      18,
+      20,
+      20,
+      19,
+      19,
+      19,
+      20,
+      14,
+      13,
+      14,
+      14,
+      14,
+      13,
+      13,
+      13,
+      12,
+      11,
+      12,
+      11,
+      12,
+      10,
+      10,
+      11,
+      12,
+      10,
+      9,
+      11,
+      10,
+      11,
+      10,
+      9,
+      9,
+      10,
+      10,
+      10,
+      9,
+      10,
+      11,
+      11,
+      11,
+      8,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      12,
+      12,
+      12,
+      12,
+      13,
+      14,
+      14,
+      14,
+      15,
+      17,
+      15,
+      17,
+      17,
+      17,
+      17,
+      18,
+      19,
+      18,
+      20,
+      18,
+      20,
+      18,
+      18,
+      19,
+      19,
+      18,
+      13
+    ],
+    "4": [
+      14,
+      13,
+      14,
+      13,
+      12,
+      13,
+      13,
+      15,
+      13,
+      13,
+      14,
+      13,
+      14,
+      15,
+      14,
+      15,
+      15,
+      16,
+      15,
+      15,
+      15,
+      15,
+      16,
+      14,
+      15,
+      16,
+      17,
+      15,
+      14,
+      15,
+      15,
+      15,
+      13,
+      15,
+      15,
+      16,
+      14,
+      16,
+      17,
+      16,
+      17,
+      16,
+      15,
+      14,
+      16,
+      16,
+      15,
+      15,
+      14,
+      13,
+      13,
+      12,
+      13,
+      12,
+      12,
+      13,
+      10,
+      8,
+      9,
+      9,
+      9,
+      8,
+      8,
+      9,
+      8,
+      8,
+      22,
+      23,
+      23,
+      22,
+      23,
+      21,
+      23,
+      21,
+      20,
+      19,
+      17,
+      16,
+      15,
+      14,
+      14,
+      13,
+      11,
+      9,
+      9,
+      7,
+      8,
+      8,
+      8,
+      7,
+      7,
+      6,
+      7,
+      7,
+      6,
+      6,
+      7,
+      7,
+      8,
+      13
+    ],
+    "5": [
+      13,
+      15,
+      14,
+      15,
+      15,
+      14,
+      15,
+      15,
+      14,
+      15,
+      14,
+      14,
+      13,
+      13,
+      13,
+      13,
+      13,
+      11,
+      12,
+      12,
+      11,
+      10,
+      8,
+      8,
+      8,
+      7,
+      8,
+      6,
+      7,
+      7,
+      7,
+      6,
+      6,
+      11,
+      11,
+      10,
+      11,
+      11,
+      10,
+      9,
+      10,
+      9,
+      11,
+      10,
+      7,
+      9,
+      11,
+      10,
+      9,
+      9,
+      7,
+      9,
+      10,
+      12,
+      10,
+      11,
+      13,
+      11,
+      13,
+      13,
+      15,
+      15,
+      15,
+      15,
+      15,
+      17,
+      6,
+      9,
+      7,
+      11,
+      10,
+      9,
+      11,
+      13,
+      13,
+      14,
+      13,
+      16,
+      16,
+      14,
+      14,
+      15,
+      16,
+      15,
+      17,
+      17,
+      17,
+      19,
+      17,
+      18,
+      19,
+      19,
+      19,
+      19,
+      19,
+      19,
+      19,
+      19,
+      18,
+      15
+    ],
+    "6": [
+      13,
+      14,
+      13,
+      12,
+      13,
+      12,
+      14,
+      12,
+      14,
+      12,
+      13,
+      13,
+      14,
+      14,
+      14,
+      14,
+      14,
+      15,
+      16,
+      15,
+      15,
+      16,
+      17,
+      17,
+      19,
+      18,
+      19,
+      18,
+      17,
+      18,
+      20,
+      18,
+      18,
+      8,
+      7,
+      7,
+      6,
+      6,
+      6,
+      9,
+      11,
+      14,
+      15,
+      20,
+      22,
+      26,
+      24,
+      26,
+      27,
+      26,
+      27,
+      22,
+      18,
+      18,
+      15,
+      11,
+      12,
+      10,
+      10,
+      10,
+      13,
+      13,
+      16,
+      19,
+      21,
+      23,
+      22,
+      22,
+      23,
+      21,
+      23,
+      22,
+      20,
+      19,
+      20,
+      18,
+      17,
+      16,
+      14,
+      12,
+      11,
+      11,
+      10,
+      9,
+      8,
+      8,
+      8,
+      7,
+      7,
+      7,
+      7,
+      8,
+      7,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      18
+    ],
+    "7": [
+      14,
+      13,
+      12,
+      14,
+      14,
+      12,
+      13,
+      13,
+      13,
+      13,
+      12,
+      13,
+      13,
+      14,
+      14,
+      14,
+      14,
+      15,
+      15,
+      16,
+      16,
+      16,
+      17,
+      18,
+      17,
+      17,
+      17,
+      17,
+      18,
+      18,
+      16,
+      16,
+      18,
+      16,
+      17,
+      17,
+      17,
+      17,
+      17,
+      17,
+      17,
+      18,
+      16,
+      17,
+      18,
+      17,
+      16,
+      17,
+      17,
+      16,
+      16,
+      15,
+      15,
+      16,
+      14,
+      13,
+      13,
+      12,
+      12,
+      9,
+      10,
+      10,
+      8,
+      8,
+      7,
+      8,
+      21,
+      20,
+      19,
+      18,
+      17,
+      15,
+      13,
+      10,
+      9,
+      10,
+      6,
+      6,
+      8,
+      9,
+      9,
+      10,
+      12,
+      14,
+      13,
+      16,
+      18,
+      18,
+      18,
+      20,
+      21,
+      21,
+      20,
+      18,
+      18,
+      17,
+      16,
+      15,
+      12,
+      21
+    ],
+    "8": [
+      12,
+      13,
+      14,
+      14,
+      13,
+      14,
+      14,
+      14,
+      14,
+      13,
+      14,
+      15,
+      14,
+      13,
+      14,
+      14,
+      14,
+      14,
+      14,
+      13,
+      14,
+      12,
+      13,
+      12,
+      11,
+      11,
+      10,
+      10,
+      9,
+      8,
+      8,
+      7,
+      7,
+      15,
+      15,
+      16,
+      14,
+      15,
+      15,
+      15,
+      15,
+      14,
+      15,
+      13,
+      14,
+      13,
+      13,
+      14,
+      11,
+      12,
+      13,
+      12,
+      10,
+      12,
+      10,
+      11,
+      9,
+      10,
+      9,
+      8,
+      10,
+      10,
+      8,
+      9,
+      10,
+      7,
+      19,
+      17,
+      15,
+      14,
+      10,
+      10,
+      8,
+      8,
+      9,
+      7,
+      12,
+      15,
+      15,
+      17,
+      20,
+      21,
+      22,
+      24,
+      21,
+      19,
+      18,
+      14,
+      13,
+      11,
+      8,
+      7,
+      7,
+      6,
+      7,
+      9,
+      9,
+      12,
+      12,
+      15
+    ],
+    "9": [
+      15,
+      13,
+      12,
+      12,
+      13,
+      12,
+      12,
+      12,
+      13,
+      12,
+      13,
+      12,
+      13,
+      15,
+      13,
+      13,
+      14,
+      13,
+      14,
+      15,
+      16,
+      16,
+      17,
+      17,
+      18,
+      19,
+      19,
+      20,
+      18,
+      20,
+      19,
+      20,
+      20,
+      17,
+      17,
+      16,
+      18,
+      17,
+      16,
+      16,
+      17,
+      16,
+      17,
+      17,
+      16,
+      17,
+      18,
+      17,
+      17,
+      15,
+      16,
+      16,
+      15,
+      14,
+      15,
+      14,
+      13,
+      13,
+      11,
+      9,
+      10,
+      9,
+      8,
+      8,
+      8,
+      9,
+      7,
+      8,
+      7,
+      8,
+      8,
+      8,
+      9,
+      9,
+      9,
+      10,
+      9,
+      9,
+      9,
+      10,
+      11,
+      11,
+      11,
+      9,
+      11,
+      12,
+      12,
+      12,
+      13,
+      13,
+      14,
+      13,
+      13,
+      13,
+      14,
+      16,
+      14,
+      14,
+      14,
+      15
+    ],
+    "10": [
+      13,
+      13,
+      15,
+      13,
+      14,
+      12,
+      13,
+      13,
+      13,
+      13,
+      13,
+      15,
+      12,
+      14,
+      14,
+      13,
+      14,
+      16,
+      16,
+      15,
+      15,
+      16,
+      18,
+      16,
+      16,
+      17,
+      17,
+      17,
+      17,
+      16,
+      17,
+      15,
+      15,
+      17,
+      16,
+      17,
+      17,
+      17,
+      16,
+      17,
+      17,
+      17,
+      16,
+      18,
+      16,
+      16,
+      16,
+      16,
+      14,
+      16,
+      17,
+      14,
+      15,
+      13,
+      13,
+      12,
+      14,
+      12,
+      10,
+      9,
+      10,
+      9,
+      10,
+      8,
+      8,
+      7,
+      23,
+      22,
+      22,
+      21,
+      19,
+      19,
+      17,
+      15,
+      13,
+      12,
+      10,
+      9,
+      9,
+      8,
+      7,
+      8,
+      6,
+      10,
+      11,
+      13,
+      14,
+      16,
+      17,
+      17,
+      18,
+      20,
+      18,
+      21,
+      20,
+      18,
+      18,
+      17,
+      16,
+      18
+    ],
+    "11": [
+      14,
+      13,
+      13,
+      13,
+      13,
+      14,
+      13,
+      13,
+      13,
+      13,
+      14,
+      13,
+      13,
+      15,
+      14,
+      14,
+      15,
+      15,
+      16,
+      16,
+      16,
+      17,
+      16,
+      16,
+      16,
+      16,
+      17,
+      14,
+      14,
+      14,
+      14,
+      15,
+      13,
+      18,
+      17,
+      17,
+      18,
+      18,
+      19,
+      17,
+      16,
+      17,
+      19,
+      18,
+      17,
+      18,
+      17,
+      16,
+      16,
+      19,
+      17,
+      15,
+      17,
+      15,
+      14,
+      14,
+      14,
+      12,
+      12,
+      11,
+      9,
+      10,
+      11,
+      9,
+      9,
+      9,
+      8,
+      7,
+      8,
+      6,
+      7,
+      7,
+      7,
+      8,
+      10,
+      7,
+      8,
+      9,
+      9,
+      9,
+      8,
+      9,
+      10,
+      8,
+      11,
+      10,
+      10,
+      11,
+      11,
+      13,
+      11,
+      11,
+      13,
+      14,
+      14,
+      13,
+      13,
+      14,
+      14,
+      13
+    ],
+    "12": [
+      14,
+      13,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      15,
+      14,
+      14,
+      14,
+      14,
+      13,
+      14,
+      11,
+      12,
+      11,
+      10,
+      9,
+      9,
+      8,
+      8,
+      7,
+      7,
+      5,
+      7,
+      5,
+      6,
+      6,
+      7,
+      7,
+      16,
+      18,
+      19,
+      19,
+      20,
+      21,
+      22,
+      21,
+      20,
+      19,
+      18,
+      18,
+      17,
+      14,
+      13,
+      10,
+      10,
+      10,
+      12,
+      10,
+      10,
+      12,
+      14,
+      13,
+      16,
+      19,
+      19,
+      19,
+      21,
+      23,
+      24,
+      25,
+      24,
+      23,
+      23,
+      23,
+      22,
+      22,
+      23,
+      22,
+      21,
+      20,
+      19,
+      18,
+      18,
+      16,
+      16,
+      15,
+      13,
+      13,
+      12,
+      10,
+      9,
+      7,
+      7,
+      7,
+      8,
+      6,
+      6,
+      7,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      8
+    ],
+    "13": [
+      14,
+      13,
+      13,
+      12,
+      13,
+      12,
+      12,
+      11,
+      12,
+      12,
+      13,
+      12,
+      14,
+      14,
+      13,
+      14,
+      14,
+      14,
+      15,
+      15,
+      17,
+      16,
+      16,
+      17,
+      19,
+      17,
+      18,
+      18,
+      18,
+      19,
+      18,
+      19,
+      19,
+      14,
+      15,
+      14,
+      14,
+      14,
+      13,
+      14,
+      15,
+      13,
+      13,
+      14,
+      12,
+      12,
+      13,
+      12,
+      12,
+      10,
+      10,
+      12,
+      10,
+      12,
+      10,
+      9,
+      8,
+      10,
+      9,
+      11,
+      9,
+      9,
+      10,
+      9,
+      8,
+      11,
+      22,
+      21,
+      22,
+      22,
+      20,
+      20,
+      20,
+      16,
+      15,
+      14,
+      12,
+      10,
+      9,
+      9,
+      7,
+      7,
+      8,
+      9,
+      9,
+      11,
+      11,
+      14,
+      15,
+      15,
+      16,
+      17,
+      18,
+      19,
+      19,
+      19,
+      19,
+      18,
+      16,
+      18
+    ],
+    "14": [
+      14,
+      13,
+      14,
+      14,
+      13,
+      13,
+      13,
+      13,
+      14,
+      13,
+      14,
+      14,
+      14,
+      14,
+      14,
+      15,
+      15,
+      15,
+      15,
+      16,
+      16,
+      16,
+      16,
+      17,
+      16,
+      16,
+      17,
+      16,
+      17,
+      17,
+      17,
+      16,
+      15,
+      15,
+      14,
+      13,
+      15,
+      13,
+      14,
+      13,
+      14,
+      12,
+      13,
+      12,
+      12,
+      11,
+      11,
+      11,
+      13,
+      12,
+      8,
+      12,
+      9,
+      10,
+      8,
+      9,
+      10,
+      10,
+      10,
+      10,
+      8,
+      9,
+      9,
+      8,
+      11,
+      9,
+      9,
+      11,
+      13,
+      16,
+      16,
+      18,
+      18,
+      19,
+      22,
+      22,
+      24,
+      24,
+      24,
+      24,
+      23,
+      22,
+      22,
+      20,
+      19,
+      15,
+      17,
+      15,
+      12,
+      12,
+      11,
+      9,
+      8,
+      7,
+      8,
+      7,
+      5,
+      6,
+      7,
+      17
+    ],
+    "15": [
+      13,
+      14,
+      12,
+      13,
+      13,
+      13,
+      12,
+      13,
+      12,
+      12,
+      13,
+      13,
+      13,
+      13,
+      14,
+      15,
+      14,
+      15,
+      14,
+      15,
+      15,
+      17,
+      17,
+      17,
+      17,
+      18,
+      18,
+      19,
+      18,
+      19,
+      19,
+      19,
+      20,
+      9,
+      10,
+      8,
+      9,
+      9,
+      8,
+      9,
+      7,
+      8,
+      6,
+      8,
+      7,
+      8,
+      9,
+      9,
+      9,
+      9,
+      9,
+      12,
+      13,
+      15,
+      16,
+      14,
+      17,
+      18,
+      18,
+      20,
+      19,
+      20,
+      21,
+      22,
+      21,
+      21,
+      9,
+      8,
+      7,
+      8,
+      9,
+      9,
+      8,
+      7,
+      9,
+      8,
+      9,
+      9,
+      8,
+      11,
+      11,
+      10,
+      13,
+      12,
+      11,
+      13,
+      12,
+      13,
+      13,
+      14,
+      15,
+      15,
+      14,
+      15,
+      15,
+      15,
+      15,
+      15,
+      16,
+      18
+    ],
+    "16": [
+      14,
+      14,
+      16,
+      15,
+      15,
+      15,
+      15,
+      16,
+      14,
+      14,
+      13,
+      12,
+      11,
+      10,
+      9,
+      7,
+      7,
+      7,
+      6,
+      5,
+      5,
+      4,
+      5,
+      6,
+      7,
+      9,
+      10,
+      10,
+      13,
+      14,
+      14,
+      17,
+      19,
+      14,
+      13,
+      13,
+      13,
+      14,
+      13,
+      13,
+      13,
+      12,
+      13,
+      11,
+      12,
+      10,
+      10,
+      10,
+      11,
+      10,
+      10,
+      9,
+      9,
+      9,
+      12,
+      10,
+      8,
+      10,
+      10,
+      9,
+      10,
+      11,
+      10,
+      11,
+      11,
+      11,
+      7,
+      7,
+      8,
+      8,
+      8,
+      9,
+      10,
+      11,
+      12,
+      14,
+      15,
+      16,
+      17,
+      19,
+      19,
+      18,
+      21,
+      22,
+      23,
+      22,
+      21,
+      22,
+      21,
+      20,
+      19,
+      19,
+      18,
+      16,
+      15,
+      13,
+      13,
+      10,
+      10,
+      12
+    ],
+    "17": [
+      16,
+      14,
+      13,
+      15,
+      15,
+      15,
+      14,
+      14,
+      15,
+      16,
+      15,
+      14,
+      13,
+      13,
+      13,
+      13,
+      12,
+      11,
+      11,
+      11,
+      9,
+      10,
+      8,
+      8,
+      7,
+      7,
+      7,
+      6,
+      6,
+      5,
+      7,
+      7,
+      6,
+      6,
+      7,
+      6,
+      8,
+      8,
+      9,
+      12,
+      13,
+      14,
+      16,
+      17,
+      18,
+      18,
+      22,
+      26,
+      26,
+      26,
+      30,
+      28,
+      32,
+      29,
+      29,
+      28,
+      27,
+      28,
+      27,
+      24,
+      22,
+      22,
+      20,
+      18,
+      16,
+      13,
+      16,
+      15,
+      15,
+      13,
+      13,
+      10,
+      12,
+      11,
+      9,
+      8,
+      8,
+      10,
+      8,
+      8,
+      8,
+      10,
+      8,
+      10,
+      8,
+      10,
+      12,
+      12,
+      13,
+      13,
+      15,
+      17,
+      16,
+      15,
+      16,
+      18,
+      18,
+      18,
+      18,
+      10
+    ],
+    "18": [
+      13,
+      13,
+      14,
+      13,
+      14,
+      15,
+      15,
+      15,
+      14,
+      14,
+      14,
+      15,
+      15,
+      13,
+      14,
+      13,
+      13,
+      12,
+      10,
+      10,
+      10,
+      9,
+      8,
+      8,
+      8,
+      7,
+      5,
+      6,
+      6,
+      6,
+      6,
+      6,
+      7,
+      18,
+      17,
+      20,
+      20,
+      19,
+      18,
+      18,
+      17,
+      15,
+      13,
+      12,
+      10,
+      9,
+      9,
+      7,
+      8,
+      10,
+      11,
+      13,
+      14,
+      16,
+      20,
+      22,
+      22,
+      24,
+      27,
+      29,
+      29,
+      27,
+      26,
+      24,
+      22,
+      23,
+      9,
+      8,
+      8,
+      8,
+      8,
+      6,
+      7,
+      10,
+      8,
+      7,
+      8,
+      7,
+      7,
+      8,
+      8,
+      9,
+      6,
+      8,
+      9,
+      9,
+      9,
+      8,
+      10,
+      10,
+      10,
+      12,
+      11,
+      10,
+      11,
+      12,
+      11,
+      11,
+      11,
+      8
+    ],
+    "19": [
+      12,
+      14,
+      14,
+      13,
+      13,
+      14,
+      13,
+      14,
+      14,
+      14,
+      14,
+      14,
+      14,
+      14,
+      14,
+      14,
+      14,
+      15,
+      15,
+      16,
+      15,
+      16,
+      15,
+      15,
+      16,
+      16,
+      15,
+      15,
+      16,
+      15,
+      13,
+      13,
+      11,
+      13,
+      14,
+      14,
+      13,
+      13,
+      13,
+      12,
+      12,
+      12,
+      12,
+      13,
+      11,
+      14,
+      11,
+      12,
+      11,
+      11,
+      11,
+      10,
+      9,
+      11,
+      9,
+      11,
+      10,
+      10,
+      10,
+      9,
+      9,
+      10,
+      9,
+      9,
+      9,
+      11,
+      15,
+      17,
+      18,
+      19,
+      20,
+      22,
+      20,
+      21,
+      23,
+      24,
+      23,
+      23,
+      24,
+      24,
+      23,
+      24,
+      23,
+      21,
+      21,
+      21,
+      21,
+      21,
+      19,
+      19,
+      18,
+      16,
+      18,
+      17,
+      16,
+      14,
+      14,
+      13,
+      11,
+      9
+    ]
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-07-20.999765/load_limits.json b/test_instances/2026-06-30_15-07-20.999765/load_limits.json
new file mode 100644
index 0000000..70ce0e1
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/load_limits.json
@@ -0,0 +1,69 @@
+{
+  "0": {
+    "0": null,
+    "1": null,
+    "2": null,
+    "3": null,
+    "4": null,
+    "5": null,
+    "6": null,
+    "7": null,
+    "8": null,
+    "9": null,
+    "10": null,
+    "11": null,
+    "12": null,
+    "13": null,
+    "14": null,
+    "15": null,
+    "16": null,
+    "17": null,
+    "18": null,
+    "19": null
+  },
+  "1": {
+    "0": 100.106,
+    "1": 100.106,
+    "2": 403.423,
+    "3": 403.423,
+    "4": 969.616,
+    "5": 969.616,
+    "6": 969.616,
+    "7": 969.616,
+    "8": 969.616,
+    "9": 969.616,
+    "10": 969.616,
+    "11": 1697.578,
+    "12": 1697.578,
+    "13": 1697.578,
+    "14": 1697.578,
+    "15": 1697.578,
+    "16": 2263.771,
+    "17": 2263.771,
+    "18": 2263.771,
+    "19": 2263.771
+  },
+  "2": {
+    "0": 21.456,
+    "1": 21.456,
+    "2": 88.825,
+    "3": 88.825,
+    "4": 214.579,
+    "5": 214.579,
+    "6": 214.579,
+    "7": 214.579,
+    "8": 214.579,
+    "9": 214.579,
+    "10": 214.579,
+    "11": 376.263,
+    "12": 376.263,
+    "13": 376.263,
+    "14": 376.263,
+    "15": 376.263,
+    "16": 502.018,
+    "17": 502.018,
+    "18": 502.018,
+    "19": 502.018
+  },
+  "load_existing": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_09-23-43.178775"
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-07-20.999765/obj.csv b/test_instances/2026-06-30_15-07-20.999765/obj.csv
new file mode 100644
index 0000000..2d49fc0
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+36.95864931027803
+37.82112741116574
+37.25832043782138
+35.60834835100418
+36.86247722193043
+36.62633575077564
+34.621191711529406
+35.39431245486941
+33.71503600109627
+35.74857946882959
diff --git a/test_instances/2026-06-30_15-07-20.999765/runtime.csv b/test_instances/2026-06-30_15-07-20.999765/runtime.csv
new file mode 100644
index 0000000..62f885f
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/runtime.csv
@@ -0,0 +1,11 @@
+tot
+0.7341216500000002
+0.6719155
+0.7770311999999999
+0.77332135
+0.72221705
+0.6859557000000001
+0.51717855
+0.69259385
+0.4653922000000001
+0.5882136499999999
diff --git a/test_instances/2026-06-30_15-07-20.999765/sp.png b/test_instances/2026-06-30_15-07-20.999765/sp.png
new file mode 100644
index 0000000..f858e5c
Binary files /dev/null and b/test_instances/2026-06-30_15-07-20.999765/sp.png differ
diff --git a/test_instances/2026-06-30_15-07-20.999765/termination_condition.csv b/test_instances/2026-06-30_15-07-20.999765/termination_condition.csv
new file mode 100644
index 0000000..eefc484
--- /dev/null
+++ b/test_instances/2026-06-30_15-07-20.999765/termination_condition.csv
@@ -0,0 +1,11 @@
+,0
+0,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.7341216500000002)
+1,max iterations reached (it: 99; best centralized it: 13; total runtime: 0.6719155)
+2,max iterations reached (it: 99; best centralized it: 15; total runtime: 0.7770311999999999)
+3,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.77332135)
+4,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.72221705)
+5,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.6859557000000001)
+6,max iterations reached (it: 99; best centralized it: 9; total runtime: 0.51717855)
+7,max iterations reached (it: 99; best centralized it: 12; total runtime: 0.69259385)
+8,max iterations reached (it: 99; best centralized it: 7; total runtime: 0.4653922000000001)
+9,max iterations reached (it: 99; best centralized it: 10; total runtime: 0.5882136499999999)
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloaded_processing.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloaded_processing.csv
new file mode 100644
index 0000000..85a2e24
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.43891402714931615,0.9185520361991024,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25000000000000355,0.49999999999999645,1.3333333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986465,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6578073089700998,0.0,0.3156146179402004,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6923076923076792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18936877076411962,0.0,1.1362126245847168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7556561085972646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,2.5022624434389087,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,2.968325791855193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316743123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.2093023255813975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.25,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1719457013574583,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.0,1.8144796380090469,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.2890365448504895,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.166666666666657,5.0,11.916666666666679,0.0,17.0,0.0,0.0,23.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,51.08597285067873,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.697674418604663,3.0,0.0,0.7209302325581319,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666643,0.0,16.0,3.9444444444444504,0.0,0.0,0.0,0.0,0.0,0.0,0.4722222222222139,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,45.83257918552036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.58471760797341,9.0,0.0,8.508305647840551,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,5.0,0.8333333333333357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,33.54298642533939,30.366515837104103,1.9638009049773757,40.561085972850684,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,18.0,0.0,14.302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2500000000000036,8.083333333333336,2.0,8.277777777777764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.615384615384642,0.0,0.0,1.0361990950226243,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,26.0,0.0,18.46511627906977,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,1.1666666666666785,3.0,7.694444444444436,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloading.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloading.csv
new file mode 100644
index 0000000..fd459a8
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/detailed_offloading.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.9592760180995477,1.239819004524887,0.8778280542986465,0.25339366515837014,0.6923076923076792,0.25339366515837014,0.0,0.0,8.0,0.1900452488687705,5.0,0.0,30.0,51.08597285067873,45.83257918552036,2.0,10.615384615384642,3.0,3.0,0.0,0.0,0.6578073089700998,0.4617940199335564,0.18936877076411962,0.7043189368770761,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,2.697674418604663,11.58471760797341,26.0,18.0,0.0,2.0,0.0,0.25000000000000355,0.25,0.5,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666643,0.8333333333333286,1.2500000000000036,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5022624434389087,0.0,2.968325791855193,2.1719457013574583,1.8144796380090469,0.0,0.0,33.54298642533939,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,0.0,3.2093023255813975,1.418604651162795,5.2890365448504895,3.0,9.0,18.0,26.0,0.0,0.0,0.3333333333333339,0.49999999999999645,0.0,0.0,0.0,0.0,0.0,0.0,4.5,0.0,3.25,0.0,2.166666666666657,0.0,0.0,8.083333333333336,1.1666666666666785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.7556561085972646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.366515837104103,0.0,0.0,0.0,0.0,0.0,0.3156146179402004,0.0,1.1362126245847168,0.0,0.8936877076411953,2.2724252491694372,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,5.0,16.0,5.0,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9638009049773757,1.0361990950226243,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7209302325581319,8.508305647840551,14.302325581395365,18.46511627906977,0.0,0.0,0.0,0.0,1.3333333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,11.916666666666679,3.9444444444444504,0.8333333333333357,8.277777777777764,7.694444444444436,0.0,0.0,0.0,0.0,0.43891402714931615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.561085972850684,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9185520361991024,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.06787330316743123,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,0.0,0.4722222222222139,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/local_processing.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/local_processing.csv
new file mode 100644
index 0000000..009ab20
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/local_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,8.0,28.0,0.0,0.0,106.0,0.0,0.0,86.0,7.0,0.0,104.0,41.0,17.0,147.0,21.0,20.0,104.0,28.0,27.0,86.0,31.0,30.0,173.0,36.0,0.0,67.0,33.0,23.0,78.0,28.0,35.0,144.0,34.0,58.0,160.0,73.0,35.0,59.0,25.0,25.0,80.0,68.0,19.0,136.0,23.0,40.0,63.0,31.0,47.0,151.0,38.0,38.0,62.0,22.0,17.0,88.0,50.0,55.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloaded_processing.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloaded_processing.csv
new file mode 100644
index 0000000..ee78788
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.3333333333333339,0.9592760180995477,0.0,0.0,2.5972850678733055,0.0,2.0833333333333335,0.8778280542986465,0.9734219269103002,1.25,0.25339366515837014,0.4617940199335564,0.5,0.6923076923076792,1.3255813953488365,0.0,0.25339366515837014,0.7043189368770761,0.5,0.8778280542986323,0.8936877076411953,0.0,0.7556561085972646,2.2724252491694372,0.0,10.968325791855193,2.083056478405318,4.5,0.1900452488687705,0.7043189368770761,0.0,8.036199095022624,3.2093023255813975,9.083333333333329,2.1719457013574583,1.418604651162795,0.0,31.814479638009047,11.28903654485049,59.583333333333336,51.552036199095014,6.418604651162795,21.83333333333333,45.83257918552036,29.09302325581396,6.666666666666664,108.43438914027155,58.302325581395365,19.611111111111104,15.651583710407266,62.46511627906977,19.861111111111114,3.0,0.0,0.0,3.0,2.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloading.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloading.csv
new file mode 100644
index 0000000..89774c3
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/offloading.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+163.0,63.0,13.0,43.0,68.0,20.0,32.0,10.61794019933555,33.0,3.0,41.99667774086382,37.0,45.0,0.0,1.0,0.9185520361991024,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,1.0,0.0,1.3055555555555425,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/rejections.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/rejections.csv
new file mode 100644
index 0000000..795ade3
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/rejections.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.0,0.0,0.0,0.0,9.0,59.38205980066445,0.0,0.0,6.0033222591361834,0.0,0.0,1.0,0.0,4.081447963800898,40.0,2.0,37.0,0.0,3.0,61.0,0.0,0.0,1.0,0.0,32.0,0.0,0.0,0.0,87.0,0.0,3.6944444444444575,0.0,0.0,0.0,0.0,0.0,6.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/replicas.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/replicas.csv
new file mode 100644
index 0000000..a84040e
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/replicas.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,8.0,16.0,0.0,0.0,30.0,0.0,1.0,24.0,3.0,1.0,24.0,13.0,7.0,34.0,7.0,8.0,24.0,9.0,11.0,20.0,10.0,12.0,40.0,12.0,0.0,18.0,11.0,11.0,18.0,9.0,14.0,30.0,10.0,23.0,32.0,20.0,12.0,18.0,10.0,29.0,26.0,20.0,14.0,36.0,14.0,16.0,34.0,24.0,23.0,33.0,27.0,20.0,13.0,6.0,6.0,18.0,14.0,19.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/residual_capacity.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/residual_capacity.csv
new file mode 100644
index 0000000..0c53080
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/residual_capacity.csv
@@ -0,0 +1,2 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,256.0,23296.0,11264.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc/70/utilization.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/utilization.csv
new file mode 100644
index 0000000..0d9fb68
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc/70/utilization.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.768,0.7735,0.0,0.0,0.7808666666666667,0.0,0.0,0.7919166666666667,0.7023333333333333,0.0,0.7980555555555555,0.7910897435897437,0.7771428571428572,0.79625,0.7525000000000001,0.8,0.7980555555555555,0.7803703703703704,0.7854545454545455,0.7919166666666667,0.7775833333333334,0.7999999999999999,0.7965208333333333,0.7525000000000001,0.0,0.6855092592592593,0.7525,0.6690909090909091,0.7980555555555555,0.7803703703703704,0.8,0.7577142857142858,0.731,0.6916770186335404,0.7892857142857144,0.7847500000000001,0.7999999999999999,0.517420634920635,0.5375,0.23645320197044337,0.48571428571428577,0.731,0.3722448979591837,0.5963492063492064,0.35321428571428576,0.6857142857142857,0.2925,0.27770833333333333,0.5604968944099379,0.7223160173160174,0.3025925925925926,0.5211428571428571,0.7528571428571429,0.7883333333333332,0.7771428571428571,0.7717460317460317,0.7678571428571429,0.7939849624060151
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_detailed_fwd_solution.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_detailed_fwd_solution.csv
new file mode 100644
index 0000000..c96d04a
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_detailed_fwd_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_n1_tot,n0_f0_n2_tot,n0_f0_n3_tot,n0_f0_n4_tot,n0_f0_n5_tot,n0_f0_n6_tot,n0_f0_n7_tot,n0_f0_n8_tot,n0_f0_n9_tot,n0_f0_n10_tot,n0_f0_n11_tot,n0_f0_n12_tot,n0_f0_n13_tot,n0_f0_n14_tot,n0_f0_n15_tot,n0_f0_n16_tot,n0_f0_n17_tot,n0_f0_n18_tot,n0_f0_n19_tot,n0_f1_n1_tot,n0_f1_n2_tot,n0_f1_n3_tot,n0_f1_n4_tot,n0_f1_n5_tot,n0_f1_n6_tot,n0_f1_n7_tot,n0_f1_n8_tot,n0_f1_n9_tot,n0_f1_n10_tot,n0_f1_n11_tot,n0_f1_n12_tot,n0_f1_n13_tot,n0_f1_n14_tot,n0_f1_n15_tot,n0_f1_n16_tot,n0_f1_n17_tot,n0_f1_n18_tot,n0_f1_n19_tot,n0_f2_n1_tot,n0_f2_n2_tot,n0_f2_n3_tot,n0_f2_n4_tot,n0_f2_n5_tot,n0_f2_n6_tot,n0_f2_n7_tot,n0_f2_n8_tot,n0_f2_n9_tot,n0_f2_n10_tot,n0_f2_n11_tot,n0_f2_n12_tot,n0_f2_n13_tot,n0_f2_n14_tot,n0_f2_n15_tot,n0_f2_n16_tot,n0_f2_n17_tot,n0_f2_n18_tot,n0_f2_n19_tot,n1_f0_n0_tot,n1_f0_n2_tot,n1_f0_n3_tot,n1_f0_n4_tot,n1_f0_n5_tot,n1_f0_n6_tot,n1_f0_n7_tot,n1_f0_n8_tot,n1_f0_n9_tot,n1_f0_n10_tot,n1_f0_n11_tot,n1_f0_n12_tot,n1_f0_n13_tot,n1_f0_n14_tot,n1_f0_n15_tot,n1_f0_n16_tot,n1_f0_n17_tot,n1_f0_n18_tot,n1_f0_n19_tot,n1_f1_n0_tot,n1_f1_n2_tot,n1_f1_n3_tot,n1_f1_n4_tot,n1_f1_n5_tot,n1_f1_n6_tot,n1_f1_n7_tot,n1_f1_n8_tot,n1_f1_n9_tot,n1_f1_n10_tot,n1_f1_n11_tot,n1_f1_n12_tot,n1_f1_n13_tot,n1_f1_n14_tot,n1_f1_n15_tot,n1_f1_n16_tot,n1_f1_n17_tot,n1_f1_n18_tot,n1_f1_n19_tot,n1_f2_n0_tot,n1_f2_n2_tot,n1_f2_n3_tot,n1_f2_n4_tot,n1_f2_n5_tot,n1_f2_n6_tot,n1_f2_n7_tot,n1_f2_n8_tot,n1_f2_n9_tot,n1_f2_n10_tot,n1_f2_n11_tot,n1_f2_n12_tot,n1_f2_n13_tot,n1_f2_n14_tot,n1_f2_n15_tot,n1_f2_n16_tot,n1_f2_n17_tot,n1_f2_n18_tot,n1_f2_n19_tot,n2_f0_n0_tot,n2_f0_n1_tot,n2_f0_n3_tot,n2_f0_n4_tot,n2_f0_n5_tot,n2_f0_n6_tot,n2_f0_n7_tot,n2_f0_n8_tot,n2_f0_n9_tot,n2_f0_n10_tot,n2_f0_n11_tot,n2_f0_n12_tot,n2_f0_n13_tot,n2_f0_n14_tot,n2_f0_n15_tot,n2_f0_n16_tot,n2_f0_n17_tot,n2_f0_n18_tot,n2_f0_n19_tot,n2_f1_n0_tot,n2_f1_n1_tot,n2_f1_n3_tot,n2_f1_n4_tot,n2_f1_n5_tot,n2_f1_n6_tot,n2_f1_n7_tot,n2_f1_n8_tot,n2_f1_n9_tot,n2_f1_n10_tot,n2_f1_n11_tot,n2_f1_n12_tot,n2_f1_n13_tot,n2_f1_n14_tot,n2_f1_n15_tot,n2_f1_n16_tot,n2_f1_n17_tot,n2_f1_n18_tot,n2_f1_n19_tot,n2_f2_n0_tot,n2_f2_n1_tot,n2_f2_n3_tot,n2_f2_n4_tot,n2_f2_n5_tot,n2_f2_n6_tot,n2_f2_n7_tot,n2_f2_n8_tot,n2_f2_n9_tot,n2_f2_n10_tot,n2_f2_n11_tot,n2_f2_n12_tot,n2_f2_n13_tot,n2_f2_n14_tot,n2_f2_n15_tot,n2_f2_n16_tot,n2_f2_n17_tot,n2_f2_n18_tot,n2_f2_n19_tot,n3_f0_n0_tot,n3_f0_n1_tot,n3_f0_n2_tot,n3_f0_n4_tot,n3_f0_n5_tot,n3_f0_n6_tot,n3_f0_n7_tot,n3_f0_n8_tot,n3_f0_n9_tot,n3_f0_n10_tot,n3_f0_n11_tot,n3_f0_n12_tot,n3_f0_n13_tot,n3_f0_n14_tot,n3_f0_n15_tot,n3_f0_n16_tot,n3_f0_n17_tot,n3_f0_n18_tot,n3_f0_n19_tot,n3_f1_n0_tot,n3_f1_n1_tot,n3_f1_n2_tot,n3_f1_n4_tot,n3_f1_n5_tot,n3_f1_n6_tot,n3_f1_n7_tot,n3_f1_n8_tot,n3_f1_n9_tot,n3_f1_n10_tot,n3_f1_n11_tot,n3_f1_n12_tot,n3_f1_n13_tot,n3_f1_n14_tot,n3_f1_n15_tot,n3_f1_n16_tot,n3_f1_n17_tot,n3_f1_n18_tot,n3_f1_n19_tot,n3_f2_n0_tot,n3_f2_n1_tot,n3_f2_n2_tot,n3_f2_n4_tot,n3_f2_n5_tot,n3_f2_n6_tot,n3_f2_n7_tot,n3_f2_n8_tot,n3_f2_n9_tot,n3_f2_n10_tot,n3_f2_n11_tot,n3_f2_n12_tot,n3_f2_n13_tot,n3_f2_n14_tot,n3_f2_n15_tot,n3_f2_n16_tot,n3_f2_n17_tot,n3_f2_n18_tot,n3_f2_n19_tot,n4_f0_n0_tot,n4_f0_n1_tot,n4_f0_n2_tot,n4_f0_n3_tot,n4_f0_n5_tot,n4_f0_n6_tot,n4_f0_n7_tot,n4_f0_n8_tot,n4_f0_n9_tot,n4_f0_n10_tot,n4_f0_n11_tot,n4_f0_n12_tot,n4_f0_n13_tot,n4_f0_n14_tot,n4_f0_n15_tot,n4_f0_n16_tot,n4_f0_n17_tot,n4_f0_n18_tot,n4_f0_n19_tot,n4_f1_n0_tot,n4_f1_n1_tot,n4_f1_n2_tot,n4_f1_n3_tot,n4_f1_n5_tot,n4_f1_n6_tot,n4_f1_n7_tot,n4_f1_n8_tot,n4_f1_n9_tot,n4_f1_n10_tot,n4_f1_n11_tot,n4_f1_n12_tot,n4_f1_n13_tot,n4_f1_n14_tot,n4_f1_n15_tot,n4_f1_n16_tot,n4_f1_n17_tot,n4_f1_n18_tot,n4_f1_n19_tot,n4_f2_n0_tot,n4_f2_n1_tot,n4_f2_n2_tot,n4_f2_n3_tot,n4_f2_n5_tot,n4_f2_n6_tot,n4_f2_n7_tot,n4_f2_n8_tot,n4_f2_n9_tot,n4_f2_n10_tot,n4_f2_n11_tot,n4_f2_n12_tot,n4_f2_n13_tot,n4_f2_n14_tot,n4_f2_n15_tot,n4_f2_n16_tot,n4_f2_n17_tot,n4_f2_n18_tot,n4_f2_n19_tot,n5_f0_n0_tot,n5_f0_n1_tot,n5_f0_n2_tot,n5_f0_n3_tot,n5_f0_n4_tot,n5_f0_n6_tot,n5_f0_n7_tot,n5_f0_n8_tot,n5_f0_n9_tot,n5_f0_n10_tot,n5_f0_n11_tot,n5_f0_n12_tot,n5_f0_n13_tot,n5_f0_n14_tot,n5_f0_n15_tot,n5_f0_n16_tot,n5_f0_n17_tot,n5_f0_n18_tot,n5_f0_n19_tot,n5_f1_n0_tot,n5_f1_n1_tot,n5_f1_n2_tot,n5_f1_n3_tot,n5_f1_n4_tot,n5_f1_n6_tot,n5_f1_n7_tot,n5_f1_n8_tot,n5_f1_n9_tot,n5_f1_n10_tot,n5_f1_n11_tot,n5_f1_n12_tot,n5_f1_n13_tot,n5_f1_n14_tot,n5_f1_n15_tot,n5_f1_n16_tot,n5_f1_n17_tot,n5_f1_n18_tot,n5_f1_n19_tot,n5_f2_n0_tot,n5_f2_n1_tot,n5_f2_n2_tot,n5_f2_n3_tot,n5_f2_n4_tot,n5_f2_n6_tot,n5_f2_n7_tot,n5_f2_n8_tot,n5_f2_n9_tot,n5_f2_n10_tot,n5_f2_n11_tot,n5_f2_n12_tot,n5_f2_n13_tot,n5_f2_n14_tot,n5_f2_n15_tot,n5_f2_n16_tot,n5_f2_n17_tot,n5_f2_n18_tot,n5_f2_n19_tot,n6_f0_n0_tot,n6_f0_n1_tot,n6_f0_n2_tot,n6_f0_n3_tot,n6_f0_n4_tot,n6_f0_n5_tot,n6_f0_n7_tot,n6_f0_n8_tot,n6_f0_n9_tot,n6_f0_n10_tot,n6_f0_n11_tot,n6_f0_n12_tot,n6_f0_n13_tot,n6_f0_n14_tot,n6_f0_n15_tot,n6_f0_n16_tot,n6_f0_n17_tot,n6_f0_n18_tot,n6_f0_n19_tot,n6_f1_n0_tot,n6_f1_n1_tot,n6_f1_n2_tot,n6_f1_n3_tot,n6_f1_n4_tot,n6_f1_n5_tot,n6_f1_n7_tot,n6_f1_n8_tot,n6_f1_n9_tot,n6_f1_n10_tot,n6_f1_n11_tot,n6_f1_n12_tot,n6_f1_n13_tot,n6_f1_n14_tot,n6_f1_n15_tot,n6_f1_n16_tot,n6_f1_n17_tot,n6_f1_n18_tot,n6_f1_n19_tot,n6_f2_n0_tot,n6_f2_n1_tot,n6_f2_n2_tot,n6_f2_n3_tot,n6_f2_n4_tot,n6_f2_n5_tot,n6_f2_n7_tot,n6_f2_n8_tot,n6_f2_n9_tot,n6_f2_n10_tot,n6_f2_n11_tot,n6_f2_n12_tot,n6_f2_n13_tot,n6_f2_n14_tot,n6_f2_n15_tot,n6_f2_n16_tot,n6_f2_n17_tot,n6_f2_n18_tot,n6_f2_n19_tot,n7_f0_n0_tot,n7_f0_n1_tot,n7_f0_n2_tot,n7_f0_n3_tot,n7_f0_n4_tot,n7_f0_n5_tot,n7_f0_n6_tot,n7_f0_n8_tot,n7_f0_n9_tot,n7_f0_n10_tot,n7_f0_n11_tot,n7_f0_n12_tot,n7_f0_n13_tot,n7_f0_n14_tot,n7_f0_n15_tot,n7_f0_n16_tot,n7_f0_n17_tot,n7_f0_n18_tot,n7_f0_n19_tot,n7_f1_n0_tot,n7_f1_n1_tot,n7_f1_n2_tot,n7_f1_n3_tot,n7_f1_n4_tot,n7_f1_n5_tot,n7_f1_n6_tot,n7_f1_n8_tot,n7_f1_n9_tot,n7_f1_n10_tot,n7_f1_n11_tot,n7_f1_n12_tot,n7_f1_n13_tot,n7_f1_n14_tot,n7_f1_n15_tot,n7_f1_n16_tot,n7_f1_n17_tot,n7_f1_n18_tot,n7_f1_n19_tot,n7_f2_n0_tot,n7_f2_n1_tot,n7_f2_n2_tot,n7_f2_n3_tot,n7_f2_n4_tot,n7_f2_n5_tot,n7_f2_n6_tot,n7_f2_n8_tot,n7_f2_n9_tot,n7_f2_n10_tot,n7_f2_n11_tot,n7_f2_n12_tot,n7_f2_n13_tot,n7_f2_n14_tot,n7_f2_n15_tot,n7_f2_n16_tot,n7_f2_n17_tot,n7_f2_n18_tot,n7_f2_n19_tot,n8_f0_n0_tot,n8_f0_n1_tot,n8_f0_n2_tot,n8_f0_n3_tot,n8_f0_n4_tot,n8_f0_n5_tot,n8_f0_n6_tot,n8_f0_n7_tot,n8_f0_n9_tot,n8_f0_n10_tot,n8_f0_n11_tot,n8_f0_n12_tot,n8_f0_n13_tot,n8_f0_n14_tot,n8_f0_n15_tot,n8_f0_n16_tot,n8_f0_n17_tot,n8_f0_n18_tot,n8_f0_n19_tot,n8_f1_n0_tot,n8_f1_n1_tot,n8_f1_n2_tot,n8_f1_n3_tot,n8_f1_n4_tot,n8_f1_n5_tot,n8_f1_n6_tot,n8_f1_n7_tot,n8_f1_n9_tot,n8_f1_n10_tot,n8_f1_n11_tot,n8_f1_n12_tot,n8_f1_n13_tot,n8_f1_n14_tot,n8_f1_n15_tot,n8_f1_n16_tot,n8_f1_n17_tot,n8_f1_n18_tot,n8_f1_n19_tot,n8_f2_n0_tot,n8_f2_n1_tot,n8_f2_n2_tot,n8_f2_n3_tot,n8_f2_n4_tot,n8_f2_n5_tot,n8_f2_n6_tot,n8_f2_n7_tot,n8_f2_n9_tot,n8_f2_n10_tot,n8_f2_n11_tot,n8_f2_n12_tot,n8_f2_n13_tot,n8_f2_n14_tot,n8_f2_n15_tot,n8_f2_n16_tot,n8_f2_n17_tot,n8_f2_n18_tot,n8_f2_n19_tot,n9_f0_n0_tot,n9_f0_n1_tot,n9_f0_n2_tot,n9_f0_n3_tot,n9_f0_n4_tot,n9_f0_n5_tot,n9_f0_n6_tot,n9_f0_n7_tot,n9_f0_n8_tot,n9_f0_n10_tot,n9_f0_n11_tot,n9_f0_n12_tot,n9_f0_n13_tot,n9_f0_n14_tot,n9_f0_n15_tot,n9_f0_n16_tot,n9_f0_n17_tot,n9_f0_n18_tot,n9_f0_n19_tot,n9_f1_n0_tot,n9_f1_n1_tot,n9_f1_n2_tot,n9_f1_n3_tot,n9_f1_n4_tot,n9_f1_n5_tot,n9_f1_n6_tot,n9_f1_n7_tot,n9_f1_n8_tot,n9_f1_n10_tot,n9_f1_n11_tot,n9_f1_n12_tot,n9_f1_n13_tot,n9_f1_n14_tot,n9_f1_n15_tot,n9_f1_n16_tot,n9_f1_n17_tot,n9_f1_n18_tot,n9_f1_n19_tot,n9_f2_n0_tot,n9_f2_n1_tot,n9_f2_n2_tot,n9_f2_n3_tot,n9_f2_n4_tot,n9_f2_n5_tot,n9_f2_n6_tot,n9_f2_n7_tot,n9_f2_n8_tot,n9_f2_n10_tot,n9_f2_n11_tot,n9_f2_n12_tot,n9_f2_n13_tot,n9_f2_n14_tot,n9_f2_n15_tot,n9_f2_n16_tot,n9_f2_n17_tot,n9_f2_n18_tot,n9_f2_n19_tot,n10_f0_n0_tot,n10_f0_n1_tot,n10_f0_n2_tot,n10_f0_n3_tot,n10_f0_n4_tot,n10_f0_n5_tot,n10_f0_n6_tot,n10_f0_n7_tot,n10_f0_n8_tot,n10_f0_n9_tot,n10_f0_n11_tot,n10_f0_n12_tot,n10_f0_n13_tot,n10_f0_n14_tot,n10_f0_n15_tot,n10_f0_n16_tot,n10_f0_n17_tot,n10_f0_n18_tot,n10_f0_n19_tot,n10_f1_n0_tot,n10_f1_n1_tot,n10_f1_n2_tot,n10_f1_n3_tot,n10_f1_n4_tot,n10_f1_n5_tot,n10_f1_n6_tot,n10_f1_n7_tot,n10_f1_n8_tot,n10_f1_n9_tot,n10_f1_n11_tot,n10_f1_n12_tot,n10_f1_n13_tot,n10_f1_n14_tot,n10_f1_n15_tot,n10_f1_n16_tot,n10_f1_n17_tot,n10_f1_n18_tot,n10_f1_n19_tot,n10_f2_n0_tot,n10_f2_n1_tot,n10_f2_n2_tot,n10_f2_n3_tot,n10_f2_n4_tot,n10_f2_n5_tot,n10_f2_n6_tot,n10_f2_n7_tot,n10_f2_n8_tot,n10_f2_n9_tot,n10_f2_n11_tot,n10_f2_n12_tot,n10_f2_n13_tot,n10_f2_n14_tot,n10_f2_n15_tot,n10_f2_n16_tot,n10_f2_n17_tot,n10_f2_n18_tot,n10_f2_n19_tot,n11_f0_n0_tot,n11_f0_n1_tot,n11_f0_n2_tot,n11_f0_n3_tot,n11_f0_n4_tot,n11_f0_n5_tot,n11_f0_n6_tot,n11_f0_n7_tot,n11_f0_n8_tot,n11_f0_n9_tot,n11_f0_n10_tot,n11_f0_n12_tot,n11_f0_n13_tot,n11_f0_n14_tot,n11_f0_n15_tot,n11_f0_n16_tot,n11_f0_n17_tot,n11_f0_n18_tot,n11_f0_n19_tot,n11_f1_n0_tot,n11_f1_n1_tot,n11_f1_n2_tot,n11_f1_n3_tot,n11_f1_n4_tot,n11_f1_n5_tot,n11_f1_n6_tot,n11_f1_n7_tot,n11_f1_n8_tot,n11_f1_n9_tot,n11_f1_n10_tot,n11_f1_n12_tot,n11_f1_n13_tot,n11_f1_n14_tot,n11_f1_n15_tot,n11_f1_n16_tot,n11_f1_n17_tot,n11_f1_n18_tot,n11_f1_n19_tot,n11_f2_n0_tot,n11_f2_n1_tot,n11_f2_n2_tot,n11_f2_n3_tot,n11_f2_n4_tot,n11_f2_n5_tot,n11_f2_n6_tot,n11_f2_n7_tot,n11_f2_n8_tot,n11_f2_n9_tot,n11_f2_n10_tot,n11_f2_n12_tot,n11_f2_n13_tot,n11_f2_n14_tot,n11_f2_n15_tot,n11_f2_n16_tot,n11_f2_n17_tot,n11_f2_n18_tot,n11_f2_n19_tot,n12_f0_n0_tot,n12_f0_n1_tot,n12_f0_n2_tot,n12_f0_n3_tot,n12_f0_n4_tot,n12_f0_n5_tot,n12_f0_n6_tot,n12_f0_n7_tot,n12_f0_n8_tot,n12_f0_n9_tot,n12_f0_n10_tot,n12_f0_n11_tot,n12_f0_n13_tot,n12_f0_n14_tot,n12_f0_n15_tot,n12_f0_n16_tot,n12_f0_n17_tot,n12_f0_n18_tot,n12_f0_n19_tot,n12_f1_n0_tot,n12_f1_n1_tot,n12_f1_n2_tot,n12_f1_n3_tot,n12_f1_n4_tot,n12_f1_n5_tot,n12_f1_n6_tot,n12_f1_n7_tot,n12_f1_n8_tot,n12_f1_n9_tot,n12_f1_n10_tot,n12_f1_n11_tot,n12_f1_n13_tot,n12_f1_n14_tot,n12_f1_n15_tot,n12_f1_n16_tot,n12_f1_n17_tot,n12_f1_n18_tot,n12_f1_n19_tot,n12_f2_n0_tot,n12_f2_n1_tot,n12_f2_n2_tot,n12_f2_n3_tot,n12_f2_n4_tot,n12_f2_n5_tot,n12_f2_n6_tot,n12_f2_n7_tot,n12_f2_n8_tot,n12_f2_n9_tot,n12_f2_n10_tot,n12_f2_n11_tot,n12_f2_n13_tot,n12_f2_n14_tot,n12_f2_n15_tot,n12_f2_n16_tot,n12_f2_n17_tot,n12_f2_n18_tot,n12_f2_n19_tot,n13_f0_n0_tot,n13_f0_n1_tot,n13_f0_n2_tot,n13_f0_n3_tot,n13_f0_n4_tot,n13_f0_n5_tot,n13_f0_n6_tot,n13_f0_n7_tot,n13_f0_n8_tot,n13_f0_n9_tot,n13_f0_n10_tot,n13_f0_n11_tot,n13_f0_n12_tot,n13_f0_n14_tot,n13_f0_n15_tot,n13_f0_n16_tot,n13_f0_n17_tot,n13_f0_n18_tot,n13_f0_n19_tot,n13_f1_n0_tot,n13_f1_n1_tot,n13_f1_n2_tot,n13_f1_n3_tot,n13_f1_n4_tot,n13_f1_n5_tot,n13_f1_n6_tot,n13_f1_n7_tot,n13_f1_n8_tot,n13_f1_n9_tot,n13_f1_n10_tot,n13_f1_n11_tot,n13_f1_n12_tot,n13_f1_n14_tot,n13_f1_n15_tot,n13_f1_n16_tot,n13_f1_n17_tot,n13_f1_n18_tot,n13_f1_n19_tot,n13_f2_n0_tot,n13_f2_n1_tot,n13_f2_n2_tot,n13_f2_n3_tot,n13_f2_n4_tot,n13_f2_n5_tot,n13_f2_n6_tot,n13_f2_n7_tot,n13_f2_n8_tot,n13_f2_n9_tot,n13_f2_n10_tot,n13_f2_n11_tot,n13_f2_n12_tot,n13_f2_n14_tot,n13_f2_n15_tot,n13_f2_n16_tot,n13_f2_n17_tot,n13_f2_n18_tot,n13_f2_n19_tot,n14_f0_n0_tot,n14_f0_n1_tot,n14_f0_n2_tot,n14_f0_n3_tot,n14_f0_n4_tot,n14_f0_n5_tot,n14_f0_n6_tot,n14_f0_n7_tot,n14_f0_n8_tot,n14_f0_n9_tot,n14_f0_n10_tot,n14_f0_n11_tot,n14_f0_n12_tot,n14_f0_n13_tot,n14_f0_n15_tot,n14_f0_n16_tot,n14_f0_n17_tot,n14_f0_n18_tot,n14_f0_n19_tot,n14_f1_n0_tot,n14_f1_n1_tot,n14_f1_n2_tot,n14_f1_n3_tot,n14_f1_n4_tot,n14_f1_n5_tot,n14_f1_n6_tot,n14_f1_n7_tot,n14_f1_n8_tot,n14_f1_n9_tot,n14_f1_n10_tot,n14_f1_n11_tot,n14_f1_n12_tot,n14_f1_n13_tot,n14_f1_n15_tot,n14_f1_n16_tot,n14_f1_n17_tot,n14_f1_n18_tot,n14_f1_n19_tot,n14_f2_n0_tot,n14_f2_n1_tot,n14_f2_n2_tot,n14_f2_n3_tot,n14_f2_n4_tot,n14_f2_n5_tot,n14_f2_n6_tot,n14_f2_n7_tot,n14_f2_n8_tot,n14_f2_n9_tot,n14_f2_n10_tot,n14_f2_n11_tot,n14_f2_n12_tot,n14_f2_n13_tot,n14_f2_n15_tot,n14_f2_n16_tot,n14_f2_n17_tot,n14_f2_n18_tot,n14_f2_n19_tot,n15_f0_n0_tot,n15_f0_n1_tot,n15_f0_n2_tot,n15_f0_n3_tot,n15_f0_n4_tot,n15_f0_n5_tot,n15_f0_n6_tot,n15_f0_n7_tot,n15_f0_n8_tot,n15_f0_n9_tot,n15_f0_n10_tot,n15_f0_n11_tot,n15_f0_n12_tot,n15_f0_n13_tot,n15_f0_n14_tot,n15_f0_n16_tot,n15_f0_n17_tot,n15_f0_n18_tot,n15_f0_n19_tot,n15_f1_n0_tot,n15_f1_n1_tot,n15_f1_n2_tot,n15_f1_n3_tot,n15_f1_n4_tot,n15_f1_n5_tot,n15_f1_n6_tot,n15_f1_n7_tot,n15_f1_n8_tot,n15_f1_n9_tot,n15_f1_n10_tot,n15_f1_n11_tot,n15_f1_n12_tot,n15_f1_n13_tot,n15_f1_n14_tot,n15_f1_n16_tot,n15_f1_n17_tot,n15_f1_n18_tot,n15_f1_n19_tot,n15_f2_n0_tot,n15_f2_n1_tot,n15_f2_n2_tot,n15_f2_n3_tot,n15_f2_n4_tot,n15_f2_n5_tot,n15_f2_n6_tot,n15_f2_n7_tot,n15_f2_n8_tot,n15_f2_n9_tot,n15_f2_n10_tot,n15_f2_n11_tot,n15_f2_n12_tot,n15_f2_n13_tot,n15_f2_n14_tot,n15_f2_n16_tot,n15_f2_n17_tot,n15_f2_n18_tot,n15_f2_n19_tot,n16_f0_n0_tot,n16_f0_n1_tot,n16_f0_n2_tot,n16_f0_n3_tot,n16_f0_n4_tot,n16_f0_n5_tot,n16_f0_n6_tot,n16_f0_n7_tot,n16_f0_n8_tot,n16_f0_n9_tot,n16_f0_n10_tot,n16_f0_n11_tot,n16_f0_n12_tot,n16_f0_n13_tot,n16_f0_n14_tot,n16_f0_n15_tot,n16_f0_n17_tot,n16_f0_n18_tot,n16_f0_n19_tot,n16_f1_n0_tot,n16_f1_n1_tot,n16_f1_n2_tot,n16_f1_n3_tot,n16_f1_n4_tot,n16_f1_n5_tot,n16_f1_n6_tot,n16_f1_n7_tot,n16_f1_n8_tot,n16_f1_n9_tot,n16_f1_n10_tot,n16_f1_n11_tot,n16_f1_n12_tot,n16_f1_n13_tot,n16_f1_n14_tot,n16_f1_n15_tot,n16_f1_n17_tot,n16_f1_n18_tot,n16_f1_n19_tot,n16_f2_n0_tot,n16_f2_n1_tot,n16_f2_n2_tot,n16_f2_n3_tot,n16_f2_n4_tot,n16_f2_n5_tot,n16_f2_n6_tot,n16_f2_n7_tot,n16_f2_n8_tot,n16_f2_n9_tot,n16_f2_n10_tot,n16_f2_n11_tot,n16_f2_n12_tot,n16_f2_n13_tot,n16_f2_n14_tot,n16_f2_n15_tot,n16_f2_n17_tot,n16_f2_n18_tot,n16_f2_n19_tot,n17_f0_n0_tot,n17_f0_n1_tot,n17_f0_n2_tot,n17_f0_n3_tot,n17_f0_n4_tot,n17_f0_n5_tot,n17_f0_n6_tot,n17_f0_n7_tot,n17_f0_n8_tot,n17_f0_n9_tot,n17_f0_n10_tot,n17_f0_n11_tot,n17_f0_n12_tot,n17_f0_n13_tot,n17_f0_n14_tot,n17_f0_n15_tot,n17_f0_n16_tot,n17_f0_n18_tot,n17_f0_n19_tot,n17_f1_n0_tot,n17_f1_n1_tot,n17_f1_n2_tot,n17_f1_n3_tot,n17_f1_n4_tot,n17_f1_n5_tot,n17_f1_n6_tot,n17_f1_n7_tot,n17_f1_n8_tot,n17_f1_n9_tot,n17_f1_n10_tot,n17_f1_n11_tot,n17_f1_n12_tot,n17_f1_n13_tot,n17_f1_n14_tot,n17_f1_n15_tot,n17_f1_n16_tot,n17_f1_n18_tot,n17_f1_n19_tot,n17_f2_n0_tot,n17_f2_n1_tot,n17_f2_n2_tot,n17_f2_n3_tot,n17_f2_n4_tot,n17_f2_n5_tot,n17_f2_n6_tot,n17_f2_n7_tot,n17_f2_n8_tot,n17_f2_n9_tot,n17_f2_n10_tot,n17_f2_n11_tot,n17_f2_n12_tot,n17_f2_n13_tot,n17_f2_n14_tot,n17_f2_n15_tot,n17_f2_n16_tot,n17_f2_n18_tot,n17_f2_n19_tot,n18_f0_n0_tot,n18_f0_n1_tot,n18_f0_n2_tot,n18_f0_n3_tot,n18_f0_n4_tot,n18_f0_n5_tot,n18_f0_n6_tot,n18_f0_n7_tot,n18_f0_n8_tot,n18_f0_n9_tot,n18_f0_n10_tot,n18_f0_n11_tot,n18_f0_n12_tot,n18_f0_n13_tot,n18_f0_n14_tot,n18_f0_n15_tot,n18_f0_n16_tot,n18_f0_n17_tot,n18_f0_n19_tot,n18_f1_n0_tot,n18_f1_n1_tot,n18_f1_n2_tot,n18_f1_n3_tot,n18_f1_n4_tot,n18_f1_n5_tot,n18_f1_n6_tot,n18_f1_n7_tot,n18_f1_n8_tot,n18_f1_n9_tot,n18_f1_n10_tot,n18_f1_n11_tot,n18_f1_n12_tot,n18_f1_n13_tot,n18_f1_n14_tot,n18_f1_n15_tot,n18_f1_n16_tot,n18_f1_n17_tot,n18_f1_n19_tot,n18_f2_n0_tot,n18_f2_n1_tot,n18_f2_n2_tot,n18_f2_n3_tot,n18_f2_n4_tot,n18_f2_n5_tot,n18_f2_n6_tot,n18_f2_n7_tot,n18_f2_n8_tot,n18_f2_n9_tot,n18_f2_n10_tot,n18_f2_n11_tot,n18_f2_n12_tot,n18_f2_n13_tot,n18_f2_n14_tot,n18_f2_n15_tot,n18_f2_n16_tot,n18_f2_n17_tot,n18_f2_n19_tot,n19_f0_n0_tot,n19_f0_n1_tot,n19_f0_n2_tot,n19_f0_n3_tot,n19_f0_n4_tot,n19_f0_n5_tot,n19_f0_n6_tot,n19_f0_n7_tot,n19_f0_n8_tot,n19_f0_n9_tot,n19_f0_n10_tot,n19_f0_n11_tot,n19_f0_n12_tot,n19_f0_n13_tot,n19_f0_n14_tot,n19_f0_n15_tot,n19_f0_n16_tot,n19_f0_n17_tot,n19_f0_n18_tot,n19_f1_n0_tot,n19_f1_n1_tot,n19_f1_n2_tot,n19_f1_n3_tot,n19_f1_n4_tot,n19_f1_n5_tot,n19_f1_n6_tot,n19_f1_n7_tot,n19_f1_n8_tot,n19_f1_n9_tot,n19_f1_n10_tot,n19_f1_n11_tot,n19_f1_n12_tot,n19_f1_n13_tot,n19_f1_n14_tot,n19_f1_n15_tot,n19_f1_n16_tot,n19_f1_n17_tot,n19_f1_n18_tot,n19_f2_n0_tot,n19_f2_n1_tot,n19_f2_n2_tot,n19_f2_n3_tot,n19_f2_n4_tot,n19_f2_n5_tot,n19_f2_n6_tot,n19_f2_n7_tot,n19_f2_n8_tot,n19_f2_n9_tot,n19_f2_n10_tot,n19_f2_n11_tot,n19_f2_n12_tot,n19_f2_n13_tot,n19_f2_n14_tot,n19_f2_n15_tot,n19_f2_n16_tot,n19_f2_n17_tot,n19_f2_n18_tot,n0_f0_n1_accepted,n0_f0_n2_accepted,n0_f0_n3_accepted,n0_f0_n4_accepted,n0_f0_n5_accepted,n0_f0_n6_accepted,n0_f0_n7_accepted,n0_f0_n8_accepted,n0_f0_n9_accepted,n0_f0_n10_accepted,n0_f0_n11_accepted,n0_f0_n12_accepted,n0_f0_n13_accepted,n0_f0_n14_accepted,n0_f0_n15_accepted,n0_f0_n16_accepted,n0_f0_n17_accepted,n0_f0_n18_accepted,n0_f0_n19_accepted,n0_f1_n1_accepted,n0_f1_n2_accepted,n0_f1_n3_accepted,n0_f1_n4_accepted,n0_f1_n5_accepted,n0_f1_n6_accepted,n0_f1_n7_accepted,n0_f1_n8_accepted,n0_f1_n9_accepted,n0_f1_n10_accepted,n0_f1_n11_accepted,n0_f1_n12_accepted,n0_f1_n13_accepted,n0_f1_n14_accepted,n0_f1_n15_accepted,n0_f1_n16_accepted,n0_f1_n17_accepted,n0_f1_n18_accepted,n0_f1_n19_accepted,n0_f2_n1_accepted,n0_f2_n2_accepted,n0_f2_n3_accepted,n0_f2_n4_accepted,n0_f2_n5_accepted,n0_f2_n6_accepted,n0_f2_n7_accepted,n0_f2_n8_accepted,n0_f2_n9_accepted,n0_f2_n10_accepted,n0_f2_n11_accepted,n0_f2_n12_accepted,n0_f2_n13_accepted,n0_f2_n14_accepted,n0_f2_n15_accepted,n0_f2_n16_accepted,n0_f2_n17_accepted,n0_f2_n18_accepted,n0_f2_n19_accepted,n1_f0_n0_accepted,n1_f0_n2_accepted,n1_f0_n3_accepted,n1_f0_n4_accepted,n1_f0_n5_accepted,n1_f0_n6_accepted,n1_f0_n7_accepted,n1_f0_n8_accepted,n1_f0_n9_accepted,n1_f0_n10_accepted,n1_f0_n11_accepted,n1_f0_n12_accepted,n1_f0_n13_accepted,n1_f0_n14_accepted,n1_f0_n15_accepted,n1_f0_n16_accepted,n1_f0_n17_accepted,n1_f0_n18_accepted,n1_f0_n19_accepted,n1_f1_n0_accepted,n1_f1_n2_accepted,n1_f1_n3_accepted,n1_f1_n4_accepted,n1_f1_n5_accepted,n1_f1_n6_accepted,n1_f1_n7_accepted,n1_f1_n8_accepted,n1_f1_n9_accepted,n1_f1_n10_accepted,n1_f1_n11_accepted,n1_f1_n12_accepted,n1_f1_n13_accepted,n1_f1_n14_accepted,n1_f1_n15_accepted,n1_f1_n16_accepted,n1_f1_n17_accepted,n1_f1_n18_accepted,n1_f1_n19_accepted,n1_f2_n0_accepted,n1_f2_n2_accepted,n1_f2_n3_accepted,n1_f2_n4_accepted,n1_f2_n5_accepted,n1_f2_n6_accepted,n1_f2_n7_accepted,n1_f2_n8_accepted,n1_f2_n9_accepted,n1_f2_n10_accepted,n1_f2_n11_accepted,n1_f2_n12_accepted,n1_f2_n13_accepted,n1_f2_n14_accepted,n1_f2_n15_accepted,n1_f2_n16_accepted,n1_f2_n17_accepted,n1_f2_n18_accepted,n1_f2_n19_accepted,n2_f0_n0_accepted,n2_f0_n1_accepted,n2_f0_n3_accepted,n2_f0_n4_accepted,n2_f0_n5_accepted,n2_f0_n6_accepted,n2_f0_n7_accepted,n2_f0_n8_accepted,n2_f0_n9_accepted,n2_f0_n10_accepted,n2_f0_n11_accepted,n2_f0_n12_accepted,n2_f0_n13_accepted,n2_f0_n14_accepted,n2_f0_n15_accepted,n2_f0_n16_accepted,n2_f0_n17_accepted,n2_f0_n18_accepted,n2_f0_n19_accepted,n2_f1_n0_accepted,n2_f1_n1_accepted,n2_f1_n3_accepted,n2_f1_n4_accepted,n2_f1_n5_accepted,n2_f1_n6_accepted,n2_f1_n7_accepted,n2_f1_n8_accepted,n2_f1_n9_accepted,n2_f1_n10_accepted,n2_f1_n11_accepted,n2_f1_n12_accepted,n2_f1_n13_accepted,n2_f1_n14_accepted,n2_f1_n15_accepted,n2_f1_n16_accepted,n2_f1_n17_accepted,n2_f1_n18_accepted,n2_f1_n19_accepted,n2_f2_n0_accepted,n2_f2_n1_accepted,n2_f2_n3_accepted,n2_f2_n4_accepted,n2_f2_n5_accepted,n2_f2_n6_accepted,n2_f2_n7_accepted,n2_f2_n8_accepted,n2_f2_n9_accepted,n2_f2_n10_accepted,n2_f2_n11_accepted,n2_f2_n12_accepted,n2_f2_n13_accepted,n2_f2_n14_accepted,n2_f2_n15_accepted,n2_f2_n16_accepted,n2_f2_n17_accepted,n2_f2_n18_accepted,n2_f2_n19_accepted,n3_f0_n0_accepted,n3_f0_n1_accepted,n3_f0_n2_accepted,n3_f0_n4_accepted,n3_f0_n5_accepted,n3_f0_n6_accepted,n3_f0_n7_accepted,n3_f0_n8_accepted,n3_f0_n9_accepted,n3_f0_n10_accepted,n3_f0_n11_accepted,n3_f0_n12_accepted,n3_f0_n13_accepted,n3_f0_n14_accepted,n3_f0_n15_accepted,n3_f0_n16_accepted,n3_f0_n17_accepted,n3_f0_n18_accepted,n3_f0_n19_accepted,n3_f1_n0_accepted,n3_f1_n1_accepted,n3_f1_n2_accepted,n3_f1_n4_accepted,n3_f1_n5_accepted,n3_f1_n6_accepted,n3_f1_n7_accepted,n3_f1_n8_accepted,n3_f1_n9_accepted,n3_f1_n10_accepted,n3_f1_n11_accepted,n3_f1_n12_accepted,n3_f1_n13_accepted,n3_f1_n14_accepted,n3_f1_n15_accepted,n3_f1_n16_accepted,n3_f1_n17_accepted,n3_f1_n18_accepted,n3_f1_n19_accepted,n3_f2_n0_accepted,n3_f2_n1_accepted,n3_f2_n2_accepted,n3_f2_n4_accepted,n3_f2_n5_accepted,n3_f2_n6_accepted,n3_f2_n7_accepted,n3_f2_n8_accepted,n3_f2_n9_accepted,n3_f2_n10_accepted,n3_f2_n11_accepted,n3_f2_n12_accepted,n3_f2_n13_accepted,n3_f2_n14_accepted,n3_f2_n15_accepted,n3_f2_n16_accepted,n3_f2_n17_accepted,n3_f2_n18_accepted,n3_f2_n19_accepted,n4_f0_n0_accepted,n4_f0_n1_accepted,n4_f0_n2_accepted,n4_f0_n3_accepted,n4_f0_n5_accepted,n4_f0_n6_accepted,n4_f0_n7_accepted,n4_f0_n8_accepted,n4_f0_n9_accepted,n4_f0_n10_accepted,n4_f0_n11_accepted,n4_f0_n12_accepted,n4_f0_n13_accepted,n4_f0_n14_accepted,n4_f0_n15_accepted,n4_f0_n16_accepted,n4_f0_n17_accepted,n4_f0_n18_accepted,n4_f0_n19_accepted,n4_f1_n0_accepted,n4_f1_n1_accepted,n4_f1_n2_accepted,n4_f1_n3_accepted,n4_f1_n5_accepted,n4_f1_n6_accepted,n4_f1_n7_accepted,n4_f1_n8_accepted,n4_f1_n9_accepted,n4_f1_n10_accepted,n4_f1_n11_accepted,n4_f1_n12_accepted,n4_f1_n13_accepted,n4_f1_n14_accepted,n4_f1_n15_accepted,n4_f1_n16_accepted,n4_f1_n17_accepted,n4_f1_n18_accepted,n4_f1_n19_accepted,n4_f2_n0_accepted,n4_f2_n1_accepted,n4_f2_n2_accepted,n4_f2_n3_accepted,n4_f2_n5_accepted,n4_f2_n6_accepted,n4_f2_n7_accepted,n4_f2_n8_accepted,n4_f2_n9_accepted,n4_f2_n10_accepted,n4_f2_n11_accepted,n4_f2_n12_accepted,n4_f2_n13_accepted,n4_f2_n14_accepted,n4_f2_n15_accepted,n4_f2_n16_accepted,n4_f2_n17_accepted,n4_f2_n18_accepted,n4_f2_n19_accepted,n5_f0_n0_accepted,n5_f0_n1_accepted,n5_f0_n2_accepted,n5_f0_n3_accepted,n5_f0_n4_accepted,n5_f0_n6_accepted,n5_f0_n7_accepted,n5_f0_n8_accepted,n5_f0_n9_accepted,n5_f0_n10_accepted,n5_f0_n11_accepted,n5_f0_n12_accepted,n5_f0_n13_accepted,n5_f0_n14_accepted,n5_f0_n15_accepted,n5_f0_n16_accepted,n5_f0_n17_accepted,n5_f0_n18_accepted,n5_f0_n19_accepted,n5_f1_n0_accepted,n5_f1_n1_accepted,n5_f1_n2_accepted,n5_f1_n3_accepted,n5_f1_n4_accepted,n5_f1_n6_accepted,n5_f1_n7_accepted,n5_f1_n8_accepted,n5_f1_n9_accepted,n5_f1_n10_accepted,n5_f1_n11_accepted,n5_f1_n12_accepted,n5_f1_n13_accepted,n5_f1_n14_accepted,n5_f1_n15_accepted,n5_f1_n16_accepted,n5_f1_n17_accepted,n5_f1_n18_accepted,n5_f1_n19_accepted,n5_f2_n0_accepted,n5_f2_n1_accepted,n5_f2_n2_accepted,n5_f2_n3_accepted,n5_f2_n4_accepted,n5_f2_n6_accepted,n5_f2_n7_accepted,n5_f2_n8_accepted,n5_f2_n9_accepted,n5_f2_n10_accepted,n5_f2_n11_accepted,n5_f2_n12_accepted,n5_f2_n13_accepted,n5_f2_n14_accepted,n5_f2_n15_accepted,n5_f2_n16_accepted,n5_f2_n17_accepted,n5_f2_n18_accepted,n5_f2_n19_accepted,n6_f0_n0_accepted,n6_f0_n1_accepted,n6_f0_n2_accepted,n6_f0_n3_accepted,n6_f0_n4_accepted,n6_f0_n5_accepted,n6_f0_n7_accepted,n6_f0_n8_accepted,n6_f0_n9_accepted,n6_f0_n10_accepted,n6_f0_n11_accepted,n6_f0_n12_accepted,n6_f0_n13_accepted,n6_f0_n14_accepted,n6_f0_n15_accepted,n6_f0_n16_accepted,n6_f0_n17_accepted,n6_f0_n18_accepted,n6_f0_n19_accepted,n6_f1_n0_accepted,n6_f1_n1_accepted,n6_f1_n2_accepted,n6_f1_n3_accepted,n6_f1_n4_accepted,n6_f1_n5_accepted,n6_f1_n7_accepted,n6_f1_n8_accepted,n6_f1_n9_accepted,n6_f1_n10_accepted,n6_f1_n11_accepted,n6_f1_n12_accepted,n6_f1_n13_accepted,n6_f1_n14_accepted,n6_f1_n15_accepted,n6_f1_n16_accepted,n6_f1_n17_accepted,n6_f1_n18_accepted,n6_f1_n19_accepted,n6_f2_n0_accepted,n6_f2_n1_accepted,n6_f2_n2_accepted,n6_f2_n3_accepted,n6_f2_n4_accepted,n6_f2_n5_accepted,n6_f2_n7_accepted,n6_f2_n8_accepted,n6_f2_n9_accepted,n6_f2_n10_accepted,n6_f2_n11_accepted,n6_f2_n12_accepted,n6_f2_n13_accepted,n6_f2_n14_accepted,n6_f2_n15_accepted,n6_f2_n16_accepted,n6_f2_n17_accepted,n6_f2_n18_accepted,n6_f2_n19_accepted,n7_f0_n0_accepted,n7_f0_n1_accepted,n7_f0_n2_accepted,n7_f0_n3_accepted,n7_f0_n4_accepted,n7_f0_n5_accepted,n7_f0_n6_accepted,n7_f0_n8_accepted,n7_f0_n9_accepted,n7_f0_n10_accepted,n7_f0_n11_accepted,n7_f0_n12_accepted,n7_f0_n13_accepted,n7_f0_n14_accepted,n7_f0_n15_accepted,n7_f0_n16_accepted,n7_f0_n17_accepted,n7_f0_n18_accepted,n7_f0_n19_accepted,n7_f1_n0_accepted,n7_f1_n1_accepted,n7_f1_n2_accepted,n7_f1_n3_accepted,n7_f1_n4_accepted,n7_f1_n5_accepted,n7_f1_n6_accepted,n7_f1_n8_accepted,n7_f1_n9_accepted,n7_f1_n10_accepted,n7_f1_n11_accepted,n7_f1_n12_accepted,n7_f1_n13_accepted,n7_f1_n14_accepted,n7_f1_n15_accepted,n7_f1_n16_accepted,n7_f1_n17_accepted,n7_f1_n18_accepted,n7_f1_n19_accepted,n7_f2_n0_accepted,n7_f2_n1_accepted,n7_f2_n2_accepted,n7_f2_n3_accepted,n7_f2_n4_accepted,n7_f2_n5_accepted,n7_f2_n6_accepted,n7_f2_n8_accepted,n7_f2_n9_accepted,n7_f2_n10_accepted,n7_f2_n11_accepted,n7_f2_n12_accepted,n7_f2_n13_accepted,n7_f2_n14_accepted,n7_f2_n15_accepted,n7_f2_n16_accepted,n7_f2_n17_accepted,n7_f2_n18_accepted,n7_f2_n19_accepted,n8_f0_n0_accepted,n8_f0_n1_accepted,n8_f0_n2_accepted,n8_f0_n3_accepted,n8_f0_n4_accepted,n8_f0_n5_accepted,n8_f0_n6_accepted,n8_f0_n7_accepted,n8_f0_n9_accepted,n8_f0_n10_accepted,n8_f0_n11_accepted,n8_f0_n12_accepted,n8_f0_n13_accepted,n8_f0_n14_accepted,n8_f0_n15_accepted,n8_f0_n16_accepted,n8_f0_n17_accepted,n8_f0_n18_accepted,n8_f0_n19_accepted,n8_f1_n0_accepted,n8_f1_n1_accepted,n8_f1_n2_accepted,n8_f1_n3_accepted,n8_f1_n4_accepted,n8_f1_n5_accepted,n8_f1_n6_accepted,n8_f1_n7_accepted,n8_f1_n9_accepted,n8_f1_n10_accepted,n8_f1_n11_accepted,n8_f1_n12_accepted,n8_f1_n13_accepted,n8_f1_n14_accepted,n8_f1_n15_accepted,n8_f1_n16_accepted,n8_f1_n17_accepted,n8_f1_n18_accepted,n8_f1_n19_accepted,n8_f2_n0_accepted,n8_f2_n1_accepted,n8_f2_n2_accepted,n8_f2_n3_accepted,n8_f2_n4_accepted,n8_f2_n5_accepted,n8_f2_n6_accepted,n8_f2_n7_accepted,n8_f2_n9_accepted,n8_f2_n10_accepted,n8_f2_n11_accepted,n8_f2_n12_accepted,n8_f2_n13_accepted,n8_f2_n14_accepted,n8_f2_n15_accepted,n8_f2_n16_accepted,n8_f2_n17_accepted,n8_f2_n18_accepted,n8_f2_n19_accepted,n9_f0_n0_accepted,n9_f0_n1_accepted,n9_f0_n2_accepted,n9_f0_n3_accepted,n9_f0_n4_accepted,n9_f0_n5_accepted,n9_f0_n6_accepted,n9_f0_n7_accepted,n9_f0_n8_accepted,n9_f0_n10_accepted,n9_f0_n11_accepted,n9_f0_n12_accepted,n9_f0_n13_accepted,n9_f0_n14_accepted,n9_f0_n15_accepted,n9_f0_n16_accepted,n9_f0_n17_accepted,n9_f0_n18_accepted,n9_f0_n19_accepted,n9_f1_n0_accepted,n9_f1_n1_accepted,n9_f1_n2_accepted,n9_f1_n3_accepted,n9_f1_n4_accepted,n9_f1_n5_accepted,n9_f1_n6_accepted,n9_f1_n7_accepted,n9_f1_n8_accepted,n9_f1_n10_accepted,n9_f1_n11_accepted,n9_f1_n12_accepted,n9_f1_n13_accepted,n9_f1_n14_accepted,n9_f1_n15_accepted,n9_f1_n16_accepted,n9_f1_n17_accepted,n9_f1_n18_accepted,n9_f1_n19_accepted,n9_f2_n0_accepted,n9_f2_n1_accepted,n9_f2_n2_accepted,n9_f2_n3_accepted,n9_f2_n4_accepted,n9_f2_n5_accepted,n9_f2_n6_accepted,n9_f2_n7_accepted,n9_f2_n8_accepted,n9_f2_n10_accepted,n9_f2_n11_accepted,n9_f2_n12_accepted,n9_f2_n13_accepted,n9_f2_n14_accepted,n9_f2_n15_accepted,n9_f2_n16_accepted,n9_f2_n17_accepted,n9_f2_n18_accepted,n9_f2_n19_accepted,n10_f0_n0_accepted,n10_f0_n1_accepted,n10_f0_n2_accepted,n10_f0_n3_accepted,n10_f0_n4_accepted,n10_f0_n5_accepted,n10_f0_n6_accepted,n10_f0_n7_accepted,n10_f0_n8_accepted,n10_f0_n9_accepted,n10_f0_n11_accepted,n10_f0_n12_accepted,n10_f0_n13_accepted,n10_f0_n14_accepted,n10_f0_n15_accepted,n10_f0_n16_accepted,n10_f0_n17_accepted,n10_f0_n18_accepted,n10_f0_n19_accepted,n10_f1_n0_accepted,n10_f1_n1_accepted,n10_f1_n2_accepted,n10_f1_n3_accepted,n10_f1_n4_accepted,n10_f1_n5_accepted,n10_f1_n6_accepted,n10_f1_n7_accepted,n10_f1_n8_accepted,n10_f1_n9_accepted,n10_f1_n11_accepted,n10_f1_n12_accepted,n10_f1_n13_accepted,n10_f1_n14_accepted,n10_f1_n15_accepted,n10_f1_n16_accepted,n10_f1_n17_accepted,n10_f1_n18_accepted,n10_f1_n19_accepted,n10_f2_n0_accepted,n10_f2_n1_accepted,n10_f2_n2_accepted,n10_f2_n3_accepted,n10_f2_n4_accepted,n10_f2_n5_accepted,n10_f2_n6_accepted,n10_f2_n7_accepted,n10_f2_n8_accepted,n10_f2_n9_accepted,n10_f2_n11_accepted,n10_f2_n12_accepted,n10_f2_n13_accepted,n10_f2_n14_accepted,n10_f2_n15_accepted,n10_f2_n16_accepted,n10_f2_n17_accepted,n10_f2_n18_accepted,n10_f2_n19_accepted,n11_f0_n0_accepted,n11_f0_n1_accepted,n11_f0_n2_accepted,n11_f0_n3_accepted,n11_f0_n4_accepted,n11_f0_n5_accepted,n11_f0_n6_accepted,n11_f0_n7_accepted,n11_f0_n8_accepted,n11_f0_n9_accepted,n11_f0_n10_accepted,n11_f0_n12_accepted,n11_f0_n13_accepted,n11_f0_n14_accepted,n11_f0_n15_accepted,n11_f0_n16_accepted,n11_f0_n17_accepted,n11_f0_n18_accepted,n11_f0_n19_accepted,n11_f1_n0_accepted,n11_f1_n1_accepted,n11_f1_n2_accepted,n11_f1_n3_accepted,n11_f1_n4_accepted,n11_f1_n5_accepted,n11_f1_n6_accepted,n11_f1_n7_accepted,n11_f1_n8_accepted,n11_f1_n9_accepted,n11_f1_n10_accepted,n11_f1_n12_accepted,n11_f1_n13_accepted,n11_f1_n14_accepted,n11_f1_n15_accepted,n11_f1_n16_accepted,n11_f1_n17_accepted,n11_f1_n18_accepted,n11_f1_n19_accepted,n11_f2_n0_accepted,n11_f2_n1_accepted,n11_f2_n2_accepted,n11_f2_n3_accepted,n11_f2_n4_accepted,n11_f2_n5_accepted,n11_f2_n6_accepted,n11_f2_n7_accepted,n11_f2_n8_accepted,n11_f2_n9_accepted,n11_f2_n10_accepted,n11_f2_n12_accepted,n11_f2_n13_accepted,n11_f2_n14_accepted,n11_f2_n15_accepted,n11_f2_n16_accepted,n11_f2_n17_accepted,n11_f2_n18_accepted,n11_f2_n19_accepted,n12_f0_n0_accepted,n12_f0_n1_accepted,n12_f0_n2_accepted,n12_f0_n3_accepted,n12_f0_n4_accepted,n12_f0_n5_accepted,n12_f0_n6_accepted,n12_f0_n7_accepted,n12_f0_n8_accepted,n12_f0_n9_accepted,n12_f0_n10_accepted,n12_f0_n11_accepted,n12_f0_n13_accepted,n12_f0_n14_accepted,n12_f0_n15_accepted,n12_f0_n16_accepted,n12_f0_n17_accepted,n12_f0_n18_accepted,n12_f0_n19_accepted,n12_f1_n0_accepted,n12_f1_n1_accepted,n12_f1_n2_accepted,n12_f1_n3_accepted,n12_f1_n4_accepted,n12_f1_n5_accepted,n12_f1_n6_accepted,n12_f1_n7_accepted,n12_f1_n8_accepted,n12_f1_n9_accepted,n12_f1_n10_accepted,n12_f1_n11_accepted,n12_f1_n13_accepted,n12_f1_n14_accepted,n12_f1_n15_accepted,n12_f1_n16_accepted,n12_f1_n17_accepted,n12_f1_n18_accepted,n12_f1_n19_accepted,n12_f2_n0_accepted,n12_f2_n1_accepted,n12_f2_n2_accepted,n12_f2_n3_accepted,n12_f2_n4_accepted,n12_f2_n5_accepted,n12_f2_n6_accepted,n12_f2_n7_accepted,n12_f2_n8_accepted,n12_f2_n9_accepted,n12_f2_n10_accepted,n12_f2_n11_accepted,n12_f2_n13_accepted,n12_f2_n14_accepted,n12_f2_n15_accepted,n12_f2_n16_accepted,n12_f2_n17_accepted,n12_f2_n18_accepted,n12_f2_n19_accepted,n13_f0_n0_accepted,n13_f0_n1_accepted,n13_f0_n2_accepted,n13_f0_n3_accepted,n13_f0_n4_accepted,n13_f0_n5_accepted,n13_f0_n6_accepted,n13_f0_n7_accepted,n13_f0_n8_accepted,n13_f0_n9_accepted,n13_f0_n10_accepted,n13_f0_n11_accepted,n13_f0_n12_accepted,n13_f0_n14_accepted,n13_f0_n15_accepted,n13_f0_n16_accepted,n13_f0_n17_accepted,n13_f0_n18_accepted,n13_f0_n19_accepted,n13_f1_n0_accepted,n13_f1_n1_accepted,n13_f1_n2_accepted,n13_f1_n3_accepted,n13_f1_n4_accepted,n13_f1_n5_accepted,n13_f1_n6_accepted,n13_f1_n7_accepted,n13_f1_n8_accepted,n13_f1_n9_accepted,n13_f1_n10_accepted,n13_f1_n11_accepted,n13_f1_n12_accepted,n13_f1_n14_accepted,n13_f1_n15_accepted,n13_f1_n16_accepted,n13_f1_n17_accepted,n13_f1_n18_accepted,n13_f1_n19_accepted,n13_f2_n0_accepted,n13_f2_n1_accepted,n13_f2_n2_accepted,n13_f2_n3_accepted,n13_f2_n4_accepted,n13_f2_n5_accepted,n13_f2_n6_accepted,n13_f2_n7_accepted,n13_f2_n8_accepted,n13_f2_n9_accepted,n13_f2_n10_accepted,n13_f2_n11_accepted,n13_f2_n12_accepted,n13_f2_n14_accepted,n13_f2_n15_accepted,n13_f2_n16_accepted,n13_f2_n17_accepted,n13_f2_n18_accepted,n13_f2_n19_accepted,n14_f0_n0_accepted,n14_f0_n1_accepted,n14_f0_n2_accepted,n14_f0_n3_accepted,n14_f0_n4_accepted,n14_f0_n5_accepted,n14_f0_n6_accepted,n14_f0_n7_accepted,n14_f0_n8_accepted,n14_f0_n9_accepted,n14_f0_n10_accepted,n14_f0_n11_accepted,n14_f0_n12_accepted,n14_f0_n13_accepted,n14_f0_n15_accepted,n14_f0_n16_accepted,n14_f0_n17_accepted,n14_f0_n18_accepted,n14_f0_n19_accepted,n14_f1_n0_accepted,n14_f1_n1_accepted,n14_f1_n2_accepted,n14_f1_n3_accepted,n14_f1_n4_accepted,n14_f1_n5_accepted,n14_f1_n6_accepted,n14_f1_n7_accepted,n14_f1_n8_accepted,n14_f1_n9_accepted,n14_f1_n10_accepted,n14_f1_n11_accepted,n14_f1_n12_accepted,n14_f1_n13_accepted,n14_f1_n15_accepted,n14_f1_n16_accepted,n14_f1_n17_accepted,n14_f1_n18_accepted,n14_f1_n19_accepted,n14_f2_n0_accepted,n14_f2_n1_accepted,n14_f2_n2_accepted,n14_f2_n3_accepted,n14_f2_n4_accepted,n14_f2_n5_accepted,n14_f2_n6_accepted,n14_f2_n7_accepted,n14_f2_n8_accepted,n14_f2_n9_accepted,n14_f2_n10_accepted,n14_f2_n11_accepted,n14_f2_n12_accepted,n14_f2_n13_accepted,n14_f2_n15_accepted,n14_f2_n16_accepted,n14_f2_n17_accepted,n14_f2_n18_accepted,n14_f2_n19_accepted,n15_f0_n0_accepted,n15_f0_n1_accepted,n15_f0_n2_accepted,n15_f0_n3_accepted,n15_f0_n4_accepted,n15_f0_n5_accepted,n15_f0_n6_accepted,n15_f0_n7_accepted,n15_f0_n8_accepted,n15_f0_n9_accepted,n15_f0_n10_accepted,n15_f0_n11_accepted,n15_f0_n12_accepted,n15_f0_n13_accepted,n15_f0_n14_accepted,n15_f0_n16_accepted,n15_f0_n17_accepted,n15_f0_n18_accepted,n15_f0_n19_accepted,n15_f1_n0_accepted,n15_f1_n1_accepted,n15_f1_n2_accepted,n15_f1_n3_accepted,n15_f1_n4_accepted,n15_f1_n5_accepted,n15_f1_n6_accepted,n15_f1_n7_accepted,n15_f1_n8_accepted,n15_f1_n9_accepted,n15_f1_n10_accepted,n15_f1_n11_accepted,n15_f1_n12_accepted,n15_f1_n13_accepted,n15_f1_n14_accepted,n15_f1_n16_accepted,n15_f1_n17_accepted,n15_f1_n18_accepted,n15_f1_n19_accepted,n15_f2_n0_accepted,n15_f2_n1_accepted,n15_f2_n2_accepted,n15_f2_n3_accepted,n15_f2_n4_accepted,n15_f2_n5_accepted,n15_f2_n6_accepted,n15_f2_n7_accepted,n15_f2_n8_accepted,n15_f2_n9_accepted,n15_f2_n10_accepted,n15_f2_n11_accepted,n15_f2_n12_accepted,n15_f2_n13_accepted,n15_f2_n14_accepted,n15_f2_n16_accepted,n15_f2_n17_accepted,n15_f2_n18_accepted,n15_f2_n19_accepted,n16_f0_n0_accepted,n16_f0_n1_accepted,n16_f0_n2_accepted,n16_f0_n3_accepted,n16_f0_n4_accepted,n16_f0_n5_accepted,n16_f0_n6_accepted,n16_f0_n7_accepted,n16_f0_n8_accepted,n16_f0_n9_accepted,n16_f0_n10_accepted,n16_f0_n11_accepted,n16_f0_n12_accepted,n16_f0_n13_accepted,n16_f0_n14_accepted,n16_f0_n15_accepted,n16_f0_n17_accepted,n16_f0_n18_accepted,n16_f0_n19_accepted,n16_f1_n0_accepted,n16_f1_n1_accepted,n16_f1_n2_accepted,n16_f1_n3_accepted,n16_f1_n4_accepted,n16_f1_n5_accepted,n16_f1_n6_accepted,n16_f1_n7_accepted,n16_f1_n8_accepted,n16_f1_n9_accepted,n16_f1_n10_accepted,n16_f1_n11_accepted,n16_f1_n12_accepted,n16_f1_n13_accepted,n16_f1_n14_accepted,n16_f1_n15_accepted,n16_f1_n17_accepted,n16_f1_n18_accepted,n16_f1_n19_accepted,n16_f2_n0_accepted,n16_f2_n1_accepted,n16_f2_n2_accepted,n16_f2_n3_accepted,n16_f2_n4_accepted,n16_f2_n5_accepted,n16_f2_n6_accepted,n16_f2_n7_accepted,n16_f2_n8_accepted,n16_f2_n9_accepted,n16_f2_n10_accepted,n16_f2_n11_accepted,n16_f2_n12_accepted,n16_f2_n13_accepted,n16_f2_n14_accepted,n16_f2_n15_accepted,n16_f2_n17_accepted,n16_f2_n18_accepted,n16_f2_n19_accepted,n17_f0_n0_accepted,n17_f0_n1_accepted,n17_f0_n2_accepted,n17_f0_n3_accepted,n17_f0_n4_accepted,n17_f0_n5_accepted,n17_f0_n6_accepted,n17_f0_n7_accepted,n17_f0_n8_accepted,n17_f0_n9_accepted,n17_f0_n10_accepted,n17_f0_n11_accepted,n17_f0_n12_accepted,n17_f0_n13_accepted,n17_f0_n14_accepted,n17_f0_n15_accepted,n17_f0_n16_accepted,n17_f0_n18_accepted,n17_f0_n19_accepted,n17_f1_n0_accepted,n17_f1_n1_accepted,n17_f1_n2_accepted,n17_f1_n3_accepted,n17_f1_n4_accepted,n17_f1_n5_accepted,n17_f1_n6_accepted,n17_f1_n7_accepted,n17_f1_n8_accepted,n17_f1_n9_accepted,n17_f1_n10_accepted,n17_f1_n11_accepted,n17_f1_n12_accepted,n17_f1_n13_accepted,n17_f1_n14_accepted,n17_f1_n15_accepted,n17_f1_n16_accepted,n17_f1_n18_accepted,n17_f1_n19_accepted,n17_f2_n0_accepted,n17_f2_n1_accepted,n17_f2_n2_accepted,n17_f2_n3_accepted,n17_f2_n4_accepted,n17_f2_n5_accepted,n17_f2_n6_accepted,n17_f2_n7_accepted,n17_f2_n8_accepted,n17_f2_n9_accepted,n17_f2_n10_accepted,n17_f2_n11_accepted,n17_f2_n12_accepted,n17_f2_n13_accepted,n17_f2_n14_accepted,n17_f2_n15_accepted,n17_f2_n16_accepted,n17_f2_n18_accepted,n17_f2_n19_accepted,n18_f0_n0_accepted,n18_f0_n1_accepted,n18_f0_n2_accepted,n18_f0_n3_accepted,n18_f0_n4_accepted,n18_f0_n5_accepted,n18_f0_n6_accepted,n18_f0_n7_accepted,n18_f0_n8_accepted,n18_f0_n9_accepted,n18_f0_n10_accepted,n18_f0_n11_accepted,n18_f0_n12_accepted,n18_f0_n13_accepted,n18_f0_n14_accepted,n18_f0_n15_accepted,n18_f0_n16_accepted,n18_f0_n17_accepted,n18_f0_n19_accepted,n18_f1_n0_accepted,n18_f1_n1_accepted,n18_f1_n2_accepted,n18_f1_n3_accepted,n18_f1_n4_accepted,n18_f1_n5_accepted,n18_f1_n6_accepted,n18_f1_n7_accepted,n18_f1_n8_accepted,n18_f1_n9_accepted,n18_f1_n10_accepted,n18_f1_n11_accepted,n18_f1_n12_accepted,n18_f1_n13_accepted,n18_f1_n14_accepted,n18_f1_n15_accepted,n18_f1_n16_accepted,n18_f1_n17_accepted,n18_f1_n19_accepted,n18_f2_n0_accepted,n18_f2_n1_accepted,n18_f2_n2_accepted,n18_f2_n3_accepted,n18_f2_n4_accepted,n18_f2_n5_accepted,n18_f2_n6_accepted,n18_f2_n7_accepted,n18_f2_n8_accepted,n18_f2_n9_accepted,n18_f2_n10_accepted,n18_f2_n11_accepted,n18_f2_n12_accepted,n18_f2_n13_accepted,n18_f2_n14_accepted,n18_f2_n15_accepted,n18_f2_n16_accepted,n18_f2_n17_accepted,n18_f2_n19_accepted,n19_f0_n0_accepted,n19_f0_n1_accepted,n19_f0_n2_accepted,n19_f0_n3_accepted,n19_f0_n4_accepted,n19_f0_n5_accepted,n19_f0_n6_accepted,n19_f0_n7_accepted,n19_f0_n8_accepted,n19_f0_n9_accepted,n19_f0_n10_accepted,n19_f0_n11_accepted,n19_f0_n12_accepted,n19_f0_n13_accepted,n19_f0_n14_accepted,n19_f0_n15_accepted,n19_f0_n16_accepted,n19_f0_n17_accepted,n19_f0_n18_accepted,n19_f1_n0_accepted,n19_f1_n1_accepted,n19_f1_n2_accepted,n19_f1_n3_accepted,n19_f1_n4_accepted,n19_f1_n5_accepted,n19_f1_n6_accepted,n19_f1_n7_accepted,n19_f1_n8_accepted,n19_f1_n9_accepted,n19_f1_n10_accepted,n19_f1_n11_accepted,n19_f1_n12_accepted,n19_f1_n13_accepted,n19_f1_n14_accepted,n19_f1_n15_accepted,n19_f1_n16_accepted,n19_f1_n17_accepted,n19_f1_n18_accepted,n19_f2_n0_accepted,n19_f2_n1_accepted,n19_f2_n2_accepted,n19_f2_n3_accepted,n19_f2_n4_accepted,n19_f2_n5_accepted,n19_f2_n6_accepted,n19_f2_n7_accepted,n19_f2_n8_accepted,n19_f2_n9_accepted,n19_f2_n10_accepted,n19_f2_n11_accepted,n19_f2_n12_accepted,n19_f2_n13_accepted,n19_f2_n14_accepted,n19_f2_n15_accepted,n19_f2_n16_accepted,n19_f2_n17_accepted,n19_f2_n18_accepted
+0.9592760180995477,1.239819004524887,0.8778280542986465,0.25339366515837014,0.6923076923076792,0.25339366515837014,0.0,0.0,8.0,0.1900452488687705,5.0,0.0,30.0,51.08597285067873,45.83257918552036,2.0,10.615384615384642,3.0,3.0,0.0,0.0,0.6578073089700998,0.4617940199335564,0.18936877076411962,0.7043189368770761,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,2.697674418604663,11.58471760797341,26.0,18.0,0.0,2.0,0.0,0.25000000000000355,0.25,0.5,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666643,0.8333333333333286,1.2500000000000036,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5022624434389087,0.0,2.968325791855193,2.1719457013574583,1.8144796380090469,0.0,0.0,33.54298642533939,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,0.0,3.2093023255813975,1.418604651162795,5.2890365448504895,3.0,9.0,18.0,26.0,0.0,0.0,0.3333333333333339,0.49999999999999645,0.0,0.0,0.0,0.0,0.0,0.0,4.5,0.0,3.25,0.0,2.166666666666657,0.0,0.0,8.083333333333336,1.1666666666666785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.7556561085972646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.366515837104103,0.0,0.0,0.0,0.0,0.0,0.3156146179402004,0.0,1.1362126245847168,0.0,0.8936877076411953,2.2724252491694372,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,5.0,16.0,5.0,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9638009049773757,1.0361990950226243,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7209302325581319,8.508305647840551,14.302325581395365,18.46511627906977,0.0,0.0,0.0,0.0,1.3333333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,11.916666666666679,3.9444444444444504,0.8333333333333357,8.277777777777764,7.694444444444436,0.0,0.0,0.0,0.0,0.43891402714931615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.561085972850684,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9185520361991024,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.06787330316743123,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,0.0,0.4722222222222139,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.43891402714931615,0.9185520361991024,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25000000000000355,0.49999999999999645,1.3333333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986465,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6578073089700998,0.0,0.3156146179402004,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6923076923076792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18936877076411962,0.0,1.1362126245847168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7556561085972646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,2.5022624434389087,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,2.968325791855193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316743123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.2093023255813975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.25,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1719457013574583,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.0,1.8144796380090469,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.2890365448504895,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.166666666666657,5.0,11.916666666666679,0.0,17.0,0.0,0.0,23.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,51.08597285067873,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4660633484162844,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.697674418604663,3.0,0.0,0.7209302325581319,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4166666666666643,0.0,16.0,3.9444444444444504,0.0,0.0,0.0,0.0,0.0,0.0,0.4722222222222139,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,45.83257918552036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.58471760797341,9.0,0.0,8.508305647840551,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,5.0,0.8333333333333357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,33.54298642533939,30.366515837104103,1.9638009049773757,40.561085972850684,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,18.0,0.0,14.302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2500000000000036,8.083333333333336,2.0,8.277777777777764,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.615384615384642,0.0,0.0,1.0361990950226243,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,26.0,0.0,18.46511627906977,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,1.1666666666666785,3.0,7.694444444444436,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.9592760180995477,0.8371040723981906,3.3574660633484115,0.5656108597284941,0.31674208144795557,0.8778280542986323,0.0,0.0,4.0,0.8778280542986323,0.0,0.0,81.88235294117652,31.289592760180994,23.036199095022624,1.0,4.0,0.0,2.0,0.0,0.0,0.3156146179401995,0.4617940199335564,0.5681063122923593,1.8936877076411953,0.0,0.0,0.0,0.514950166112957,0.0,0.0,0.0,0.9767441860465169,2.7674418604651194,22.50166112956809,37.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4166666666666643,0.8333333333333286,0.0,12.750000000000007,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.552238009049155,0.0,3.104072398190027,0.7647058823529278,34.57898371040789,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2724252491694372,0.0,3.6511627906976827,2.697674418604663,8.488372093023258,18.0,14.0,17.89036544850496,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5,0.0,1.3333333333333286,2.6666666666666643,12.166666666666671,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2533936651583701,0.06787330316740281,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.08305647840531805,0.0,0.0,0.0,0.0,10.212624584717602,3.0,3.0,18.0,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,5.04651162790698,5.325581395348841,19.88372093023253,7.744186046511643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.6666666666666643,6.666666666666671,19.25,9.41666666666665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3255900452494767,0.0,0.0,0.0,0.20361990950226527,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8371040723981906,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.3574660633484115,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5656108597284941,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5681063122923593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2533936651583701,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316740281,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,9.552238009049155,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3255900452494767,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.514950166112957,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.104072398190027,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.6511627906976827,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7647058823529278,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.697674418604663,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,81.88235294117652,34.57898371040789,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.488372093023258,10.212624584717602,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.166666666666671,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.289592760180994,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20361990950226527,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9767441860465169,18.0,3.0,5.04651162790698,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4166666666666643,0.0,0.0,3.6666666666666643,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.036199095022624,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.7674418604651194,14.0,3.0,5.325581395348841,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,0.0,6.666666666666671,0.0,1.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.50166112956809,17.89036544850496,18.0,19.88372093023253,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.5,19.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,37.0,0.0,11.0,7.744186046511643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.750000000000007,1.0,0.0,9.41666666666665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.9592760180995477,0.8371040723981906,1.117647058823536,0.5656108597284941,0.6923076923076792,2.565610859728494,0.0,0.0,4.0,0.31674208144795557,5.0,5.0,76.0,18.35746606334841,15.58823529411768,3.0,4.0,0.0,3.0,0.0,0.0,0.9734219269102997,0.4617940199335564,0.18936877076411962,1.7043189368770761,1.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.2558139534883779,2.3255813953488413,18.00664451827241,40.0,3.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,2.75,0.0,6.75,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.1900452488687705,0.0,4.307692307692292,4.90045248868779,15.438914027149366,20.0,3.162895927601781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083056478405318,0.0,1.9302325581395365,0.2558139534883779,5.767441860465119,22.0,14.0,23.963455149501648,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,2.5,0.6666666666666643,7.500000000000002,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.380090497737541,3.4298642533936885,0.0,10.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0830564784053216,0.6511627906976756,0.0,0.0,0.0,0.0,12.265780730897006,0.0,0.0,16.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30232558139534405,4.046511627906995,4.604651162790695,14.759136212624593,16.287375415282373,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.583333333333329,8.583333333333329,16.583333333333336,7.333333333333329,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9140271493212424,0.13574660633483404,0.06787330316740281,0.0,0.2714932126696823,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8371040723981906,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.117647058823536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9734219269102997,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5656108597284941,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6923076923076792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18936877076411962,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.565610859728494,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0830564784053216,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.380090497737541,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,4.1900452488687705,3.4298642533936885,0.0,0.0,0.0,0.0,0.0,0.0,0.9140271493212424,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,4.307692307692292,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13574660633483404,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,4.90045248868779,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316740281,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2558139534883779,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,76.0,15.438914027149366,0.0,0.0,66.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.767441860465119,12.265780730897006,0.30232558139534405,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.500000000000002,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.35746606334841,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2714932126696823,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2558139534883779,22.0,0.0,4.046511627906995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,6.583333333333329,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.58823529411768,3.162895927601781,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3255813953488413,14.0,0.0,4.604651162790695,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.75,0.0,0.0,8.583333333333329,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.00664451827241,23.963455149501648,16.0,14.759136212624593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,16.583333333333336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.0,0.0,0.0,16.287375415282373,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.75,7.0,0.0,7.333333333333329,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.3393665158371038,0.8371040723981906,0.35746606334841147,0.8778280542986323,0.06787330316740281,0.1900452488687705,0.0,0.0,4.0,0.6289592760180938,10.0,10.0,70.0,24.561085972850677,17.140271493212737,4.0,3.0,2.0,2.0,0.0,0.0,0.3156146179401995,0.8405315614617948,1.1893687707641196,0.7043189368770761,0.0,0.0,0.0,1.083056478405318,0.0,0.0,0.0,0.9767441860465169,2.3255813953488413,24.56478405315613,29.0,0.0,3.0,0.25,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.5,0.75,1.5,11.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.158371040723978,0.0,1.3755656108597236,0.7647058823529278,20.638009049773828,20.0,1.0633484162895428,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2724252491694372,0.0,0.9302325581395365,3.255813953488378,14.488372093023258,3.0,14.0,28.05315614617939,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5000000000000018,0.0,1.5,2.6666666666666643,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.941176470588232,0.380090497737541,0.0,0.0,5.678733031674227,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083056478405318,0.6511627906976756,0.0,0.0,0.0,0.0,2.0,0.0,3.0,19.0,7.0,0.0,0.0,0.0,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,2.0,21.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7601809954751104,0.23981900452488958,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7209302325581461,5.325581395348841,14.730897009966803,5.581395348837219,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5,0.0,0.0,0.0,0.0,6.333333333333329,1.8333333333333286,5.416666666666664,5.083333333333329,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,53.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4570135746605975,0.20361990950228426,0.0,0.3393665158371183,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3333333333333339,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3393665158371038,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8371040723981906,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35746606334841147,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8405315614617948,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316740281,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1893687707641196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.941176470588232,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.380090497737541,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,2.158371040723978,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5000000000000018,2.0,1.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6289592760180938,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,1.3755656108597236,5.678733031674227,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.4570135746605975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,0.7647058823529278,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20361990950228426,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.255813953488378,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,70.0,20.638009049773828,0.0,0.0,53.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.488372093023258,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.561085972850677,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3393665158371183,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9767441860465169,3.0,0.0,0.7209302325581461,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,6.333333333333329,0.0,4.0,0.0,0.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.140271493212737,1.0633484162895428,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3255813953488413,14.0,3.0,5.325581395348841,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.75,0.0,2.0,1.8333333333333286,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.7601809954751104,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.56478405315613,28.05315614617939,19.0,14.730897009966803,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5,0.0,21.0,5.416666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.23981900452488958,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,0.0,7.0,5.581395348837219,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,0.0,0.0,5.083333333333329,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.6199095022624435,0.8371040723981906,0.35746606334841147,0.5022624434389087,0.31674208144795557,0.1900452488687705,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,46.75113122171949,30.17194570135746,1.0,45.0,1.0,2.0,0.0,0.0,0.3156146179401995,1.0299003322259175,0.5681063122923593,0.8936877076411953,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,9.873754152823913,8.04651162790698,26.0,14.0,1.0,0.0,0.29166666666666696,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4166666666666643,2.6666666666666643,5.1250000000000036,8.0,0.0,2.0,0.6199095022624435,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1900452488687705,0.0,3.104072398190027,4.49321266968326,52.5927601809955,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2724252491694372,0.0,6.651162790697683,4.255813953488378,6.574750830564803,0.0531561461793828,0.0,26.192691029900317,11.0,0.0,0.0,1.166666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,4.5,3.5833333333333286,3.6666666666666643,0.0,0.0,1.7083333333333464,1.374999999999993,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.380090497737541,0.0,0.0,0.0,0.0,6.303167420814503,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.6511627906976756,0.0,0.0,0.0,3.0,22.79734219269102,7.0,3.0,10.0,0.0,0.0,0.0,0.0,3.875,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.041666666666668,7.0,2.0,14.0,0.0,0.0,0.0,0.003393410639846882,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0033937499978784853,0.0033937499978784853,0.9502262443438936,0.03959284502050279,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9335548172757768,4.883720930232556,16.714285714285737,7.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,5.0,1.75,0.9166666666666643,12.91666666666665,6.708333333333336,0.0,0.0,0.8563350961474839,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,1.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8597285067873299,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316741702,0.0,1.2138008201378105,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,0.4999750000000208,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666643,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6199095022624435,0.0,0.003393410639846882,0.8563350961474839,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.166666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6199095022624435,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8597285067873299,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29166666666666696,3.875,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8371040723981906,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35746606334841147,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5022624434389087,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0299003322259175,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5681063122923593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.380090497737541,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1900452488687705,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.104072398190027,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.651162790697683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.5,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.49321266968326,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.06787330316741702,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.255813953488378,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4999750000000208,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.5833333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,52.5927601809955,6.303167420814503,4.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.574750830564803,22.79734219269102,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.6666666666666643,8.041666666666668,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,46.75113122171949,0.0,0.0,0.0033937499978784853,5.0,0.0,0.0,0.0,0.0,0.0,1.2138008201378105,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.873754152823913,0.0531561461793828,7.0,1.9335548172757768,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4166666666666643,0.0,7.0,1.75,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.17194570135746,0.0,0.0,0.0033937499978784853,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.04651162790698,0.0,3.0,4.883720930232556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,2.0,0.9166666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.9502262443438936,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,26.192691029900317,10.0,16.714285714285737,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.1250000000000036,1.7083333333333464,14.0,12.91666666666665,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,45.0,0.0,0.0,0.03959284502050279,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,11.0,0.0,7.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,1.374999999999993,0.0,6.708333333333336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.6199095022624435,1.8371040723981906,3.1990950226244337,1.5022624434389087,0.43891402714931615,0.8144796380090469,0.0,0.0,0.0,0.5656108597284941,0.0,0.0,64.56108597285072,6.2895927601809944,10.171945701357458,4.0,1.0,1.0,4.0,0.0,0.0,0.235880398671096,0.6511627906976774,0.8405315614617948,0.8936877076411953,0.0,0.0,0.0,0.6511627906976756,0.0,2.5415282392026413,14.0,5.976744186046524,17.209302325581397,11.0,3.0,3.0,0.0,0.29166666666666696,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.5,0.0,0.0,0.0,2.4166666666666643,0.75,0.0,13.541666666666668,2.0,0.0,0.7194570135746603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,8.307692307692292,18.959276018099622,31.13574660633479,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4219269102990038,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.9302325581395365,6.435215946843883,13.534883720930239,7.0,7.0,3.0,3.0,0.0,0.0,0.29166666666666674,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6666666666666643,1.5833333333333286,0.9166666666666643,0.0,0.0,0.0,13.541666666666675,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,1.219269102990033,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,5.0,14.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.162790697674424,7.883720930232563,21.139534883720913,4.8139534883721,0.0,0.0,0.7916666666666667,0.7499999999999998,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,9.333333333333336,0.8333333333333286,13.999999999999993,3.499999999999986,7.791666666666693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2533936651583417,0.9999999999999999,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,25.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2533936651583488,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3167420814479556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,18.0,2.0,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3889148152468994,0.0,0.0,0.0,0.0,0.0,0.5694185180864535,0.7083333333333158,1.3333333333333313,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4444185180864363,0.0,0.0,3.8333333333333286,0.0,0.0,0.0,17.99999999999999,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7194570135746603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29166666666666674,0.0,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6199095022624435,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29166666666666696,0.0,0.7499999999999998,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8371040723981906,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.1990950226244337,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.235880398671096,2.4219269102990038,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5022624434389087,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976774,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43891402714931615,0.0,0.0,0.0,0.0,1.2533936651583488,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8405315614617948,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8144796380090469,0.0,0.0,0.0,0.0,1.2533936651583417,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9999999999999999,0.0,1.3167420814479556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.083056478405318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.219269102990033,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5656108597284941,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.307692307692292,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6666666666666643,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.3889148152468994,0.4444185180864363,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.959276018099622,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5415282392026413,6.435215946843883,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5833333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,64.56108597285072,31.13574660633479,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,13.534883720930239,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666643,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.2895927601809944,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.976744186046524,7.0,0.0,4.162790697674424,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4166666666666643,0.0,14.0,9.333333333333336,0.0,0.0,0.0,0.0,2.0,0.0,3.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.171945701357458,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.209302325581397,7.0,0.0,7.883720930232563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.75,0.0,5.0,0.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,3.0,0.0,21.139534883720913,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,13.999999999999993,0.0,14.0,0.0,0.0,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,3.0,0.0,4.8139534883721,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.541666666666668,13.541666666666675,4.0,3.499999999999986,1.0,0.0,0.0,5.0,2.0,0.5694185180864535,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,7.791666666666693,0.0,25.0,22.0,14.0,18.0,0.7083333333333158,17.99999999999999,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3333333333333313,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.239819004524887,2.3574660633484115,1.7194570135746616,0.06787330316740281,0.6923076923076792,0.8778280542986323,0.0,0.0,0.0,1.8461538461538396,0.0,0.0,63.194570135746815,15.425339366515828,8.579185520361847,0.0,0.0,1.0,3.0,0.0,0.3156146179401995,0.5514950166112982,0.5681063122923593,0.4617940199335564,0.8936877076411953,0.0,0.0,0.0,0.8405315614617948,0.0,0.0,0.0,1.5348837209302388,0.6046511627906987,0.0,0.0,2.0,51.22923588039866,0.25,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0833333333333357,3.6666666666666643,8.0,2.0,2.0,1.0,0.7194570135746603,0.0,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,3.565610859728494,0.0,0.3076923076922924,5.49321266968326,7.434389140271282,0.0,3.0,40.0,0.5203619909504624,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,1.9302325581395365,2.0930232558139608,0.7674418604651194,0.0,0.0,0.0,0.0,0.0,57.126245847176065,1.0833333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.486111111111109,5.236111111111109,4.486111111111109,3.7083333333333393,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.91029900332225,17.544850498338874,0.0,1.0,0.0,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,5.0,8.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20361990950226527,1.9321266968327087,1.6289592760180889,2.235294117646937,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,3.0,6.392026578073114,3.4318936877076354,10.17607973421925,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.864583333333329,10.322916666666668,10.822916666666668,10.989583333333332,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7142857142857141,0.8178733031673945,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.4678409825468917,0.0,0.0,0.0,0.0,0.0,0.3687707641195992,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.0,0.0,29.6312292358804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22689075630251787,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.7731092436974825,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,0.75,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.146179401993326,1.4883720930232622,2.3654485049834113,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9305555555555554,5.84722222222222,0.0,9.222222222222225,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7194570135746603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0833333333333335,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3574660633484115,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7194570135746616,0.9592760180995477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5514950166112982,0.0,0.0,0.3687707641195992,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06787330316740281,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5681063122923593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6923076923076792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7142857142857141,0.22689075630251787,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8178733031673945,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.565610859728494,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8461538461538396,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8405315614617948,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3076923076922924,0.0,0.0,0.0,0.0,4.0,0.75,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.486111111111109,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9305555555555554,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.49321266968326,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0930232558139608,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.236111111111109,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.84722222222222,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,63.194570135746815,7.434389140271282,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7674418604651194,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.486111111111109,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.425339366515828,0.0,0.0,0.20361990950226527,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5348837209302388,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0833333333333357,3.7083333333333393,1.0,10.864583333333329,0.0,0.0,0.0,0.0,0.0,0.0,9.222222222222225,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.579185520361847,3.0,0.0,1.9321266968327087,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6046511627906987,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.6666666666666643,0.0,0.0,10.322916666666668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.0,0.0,1.6289592760180889,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.91029900332225,6.392026578073114,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,10.822916666666668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5203619909504624,0.0,2.235294117646937,3.4678409825468917,5.7731092436974825,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.544850498338874,3.4318936877076354,0.0,1.0,1.0,0.0,13.0,4.146179401993326,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,10.989583333333332,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,10.17607973421925,29.6312292358804,0.0,0.0,0.0,0.0,1.4883720930232622,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,51.22923588039866,57.126245847176065,1.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3654485049834113,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.6199095022624435,0.35746606334841147,0.19909502262443368,1.7511312217194543,3.0045248868778174,0.8144796380090469,0.0,0.0,0.0,0.15837104072397779,0.0,0.0,0.0,9.719457013574697,35.375565610859724,20.0,15.0,4.0,0.0,0.0,0.3156146179401995,0.235880398671096,0.40863787375415317,0.08305647840531805,0.2724252491694372,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,3.255813953488378,0.6046511627906987,0.0,0.0,55.172757475083046,1.0,0.29166666666666696,0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5,1.75,0.0,0.0,0.45833333333333215,20.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.25339366515837,0.0,0.23981900452488958,6.452488687782804,55.81447963800905,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,3.3720930232558217,0.3720930232558217,2.4883720930232585,0.0,0.0,0.0,26.873754152823906,25.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.6666666666666643,2.6666666666666643,0.0,0.0,1.750000000000007,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29568106312292386,0.0,0.0,0.2724252491694372,0.6511627906976756,0.0,0.0,0.0,8.704318936877076,0.0,14.0,3.0,17.076411960132887,2.0,0.0,0.0,0.7916666666666667,0.7499999999999998,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,9.0,0.0,18.5,4.458333333333336,0.09954751131221684,0.7194570135746581,0.0,1.0045248868778174,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,14.038461538461508,28.807692307692324,16.69004524886879,17.640271493212683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18936877076412628,0.0,0.5248693252676464,0.0,0.0,0.0,0.0,1.1428809519841137,1.1428809519841137,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,5.791666666666671,0.9583333333333357,11.291666666666657,1.4583333333333357,12.0,12.0,0.0,0.0,0.0,0.0,0.0,0.3755656108597236,0.9411764705882338,1.126696832579185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,5.0,0.0,0.0,0.0,22.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6744186046511622,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,5.0,0.0,0.0,1.0,5.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7098955701912765,0.0,0.0,0.7098955701912765,0.0,1.1993117390457941,0.4019695463547749,2.455149501661161,2.5237780725557166,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7916666666666572,0.0,0.7916666666666714,0.8749999999999918,1.6249999999999976,1.916666666666682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.05316577986813011,0.386504430045288,0.386504430045288,0.0,0.1738253600412939,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.9166666666666643,1.6666666666666643,0.0,5.833333333333336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.09954751131221684,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6199095022624435,0.0,0.7194570135746581,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29166666666666696,0.7499999999999998,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35746606334841147,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.19909502262443368,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.235880398671096,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7511312217194543,0.0,0.0,1.0045248868778174,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.40863787375415317,0.0,0.29568106312292386,0.0,0.6744186046511622,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0045248868778174,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8144796380090469,0.0,0.0,0.0,0.3755656108597236,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9411764705882338,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.126696832579185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.25339366515837,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936877076411953,0.0,0.18936877076412628,0.0,0.0,0.0,0.0,0.0,0.05316577986813011,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.15837104072397779,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23981900452488958,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.3720930232558217,0.0,0.5248693252676464,2.0,0.0,0.0,0.0,0.0,0.7098955701912765,0.386504430045288,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.9166666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.452488687782804,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3720930232558217,8.704318936877076,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.386504430045288,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666643,5.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,1.6666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,55.81447963800905,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4883720930232585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.719457013574697,0.0,0.0,14.038461538461508,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.255813953488378,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7098955701912765,0.1738253600412939,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5,0.0,0.0,5.791666666666671,0.0,0.0,2.0,0.0,6.0,0.7916666666666572,5.833333333333336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,35.375565610859724,0.0,0.0,28.807692307692324,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6046511627906987,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.75,0.0,0.0,0.9583333333333357,0.0,1.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,20.0,0.0,0.0,16.69004524886879,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.076411960132887,1.1428809519841137,22.0,0.0,0.0,0.0,0.0,1.1993117390457941,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.750000000000007,9.0,11.291666666666657,0.0,5.0,0.0,0.0,0.0,0.7916666666666714,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.0,0.0,0.0,17.640271493212683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.873754152823906,2.0,1.1428809519841137,0.0,0.0,0.0,0.0,0.0,0.4019695463547749,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,0.0,1.4583333333333357,0.0,2.0,0.0,0.0,0.0,0.8749999999999918,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,55.172757475083046,25.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.455149501661161,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.45833333333333215,0.0,18.5,12.0,0.0,0.0,0.0,0.0,0.0,1.6249999999999976,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,8.0,2.5237780725557166,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,20.0,0.0,4.458333333333336,12.0,0.0,0.0,0.0,0.0,0.0,1.916666666666682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.6199095022624435,0.35746606334841147,0.19909502262443368,1.7511312217194543,0.31674208144795557,0.8144796380090469,0.0,0.0,0.0,3.126696832579185,0.0,0.0,0.0,0.6289592760180938,2.3076923076922924,0.0,62.87782805429868,2.0,3.0,0.0,0.3156146179401995,1.235880398671096,0.40863787375415317,0.7043189368770761,0.08305647840531805,0.0,0.0,0.0,0.029900332225913928,0.0,3.0,14.0,23.734219269102987,13.488372093023258,1.0,0.0,1.0,2.0,0.29166666666666674,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.333333333333332,2.5833333333333286,4.791666666666671,14.0,0.0,0.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.941176470588232,0.0,4.511312217194558,2.221719457013563,0.7466063348416299,0.0,0.0,17.339366515837128,48.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,4.093023255813961,21.976744186046517,22.468438538205962,9.0,0.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,8.250000000000007,7.666666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.43891402714931615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.307692307692314,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7916666666666667,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,6.0,0.0,3.0,5.0,15.0,0.0,0.0,8.916666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,85.69230769230771,3.3076923076922924,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,8.666666666666664,0.8333333333333357,3.2083333333333286,2.5,0.0,27.79166666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,27.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,33.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4208144796380253,0.0,0.8144796380090484,0.7647058823529151,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,10.583333333333329,2.4999999999999996,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9999999999999929,0.0,0.0,0.0,0.0,0.0,15.999999999999993,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6199095022624435,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.29166666666666674,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35746606334841147,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3156146179401995,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.19909502262443368,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.235880398671096,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7511312217194543,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.40863787375415317,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.31674208144795557,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8144796380090469,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25339366515837014,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43891402714931615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.941176470588232,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.126696832579185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.029900332225913928,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.511312217194558,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.093023255813961,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8333333333333286,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.221719457013563,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,21.976744186046517,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.250000000000007,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9999999999999929,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7466063348416299,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,22.468438538205962,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.666666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6289592760180938,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.734219269102987,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.333333333333332,0.0,3.0,8.666666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3076923076922924,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.488372093023258,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5833333333333286,0.0,5.0,0.8333333333333357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.339366515837128,4.307692307692314,85.69230769230771,3.0,4.0,7.0,1.0,7.0,2.4208144796380253,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.791666666666671,0.0,15.0,3.2083333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,62.87782805429868,48.0,0.0,3.3076923076922924,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,2.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8144796380090484,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,18.0,33.0,10.583333333333329,15.999999999999993,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7647058823529151,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.916666666666664,27.79166666666667,0.0,23.0,27.0,0.0,0.0,2.4999999999999996,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+1.239819004524887,0.8778280542986465,0.43891402714932326,0.7556561085972646,0.941176470588232,0.8144796380090469,0.0,0.0,0.0,2.470588235294116,0.0,0.0,0.0,0.6968325791855108,2.3076923076922924,0.0,67.45701357466068,2.0,3.0,0.0,0.631229235880399,1.5780730897009967,0.37873754152823924,1.7043189368770761,0.08305647840531805,0.0,0.0,0.0,0.2192691029900331,0.0,18.0,11.0,7.255813953488378,8.149501661129555,2.0,2.0,3.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.75,0.0,3.5,0.0,20.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5656108597284941,0.0,4.443438914027126,1.1538461538461462,2.882352941176464,0.0,0.0,25.71493212669688,43.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,6.372093023255822,8.534883720930239,31.631229235880383,3.0,7.0,0.0,0.0,0.0,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.8333333333333286,1.6666666666666643,2.6666666666666643,11.583333333333343,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7619047619047619,0.28571428571428564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9523809523809526,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.4617940199335573,0.0,0.0,0.0,4.0,8.0,0.0,1.0,0.0,0.0,0.0,0.0,0.7916666666666667,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,5.0,0.0,10.0,10.0,0.0,11.416666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,81.76018099547511,4.23981900452489,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,5.0,0.9166666666666572,0.8333333333333286,13.083333333333329,1.1666666666666643,0.0,18.00000000000002,0.0,0.0,0.0,0.0,0.0,0.0,0.6914889032536129,0.09437621202325536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2141348847231317,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7999999999999999,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.2,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,23.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,28.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.285067873303173,0.0,0.8823529411764591,0.8325791855203685,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255813975,0.2635658914728675,0.2635658914728675,0.2635658914728675,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,9.25,1.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41862558139532857,0.16279069767442422,0.0,0.4185837209302472,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.75,0.0,0.0,0.0,0.0,0.0,22.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.239819004524887,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.7916666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8778280542986465,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.631229235880399,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43891402714932326,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5780730897009967,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7556561085972646,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.37873754152823924,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.941176470588232,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7043189368770761,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8144796380090469,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.08305647840531805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7619047619047619,0.0,0.6914889032536129,0.7999999999999999,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2724252491694372,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.28571428571428564,0.0,0.09437621202325536,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335573,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5656108597284941,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4617940199335564,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.470588235294116,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2192691029900331,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.443438914027126,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.372093023255822,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41862558139532857,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.8333333333333286,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9166666666666714,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1538461538461462,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,18.0,8.534883720930239,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16279069767442422,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6666666666666643,0.0,7.0,0.0,0.0,1.0,0.0,0.0,0.0,0.75,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.882352941176464,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.0,31.631229235880383,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6666666666666643,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6968325791855108,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.255813953488378,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4185837209302472,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5,11.583333333333343,5.0,0.9166666666666572,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3076923076922924,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.149501661129555,7.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.75,5.0,0.0,0.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,25.71493212669688,0.9523809523809526,81.76018099547511,1.2141348847231317,3.2,6.0,0.0,2.0,4.285067873303173,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255813975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,13.083333333333329,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,67.45701357466068,43.0,0.0,4.23981900452489,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2635658914728675,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.5,0.0,10.0,1.1666666666666643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8823529411764591,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2635658914728675,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,17.0,28.0,9.25,22.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8325791855203685,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2635658914728675,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,20.0,0.0,11.416666666666664,18.00000000000002,1.0,22.0,7.0,0.0,0.0,1.8333333333333286,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_offloaded.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_offloaded.csv
new file mode 100644
index 0000000..224a7a1
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_offloaded.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.3333333333333339,0.9592760180995477,0.0,0.0,2.5972850678733055,0.0,2.0833333333333335,0.8778280542986465,0.9734219269103002,1.25,0.25339366515837014,0.4617940199335564,0.5,0.6923076923076792,1.3255813953488365,0.0,0.25339366515837014,0.7043189368770761,0.5,0.8778280542986323,0.8936877076411953,0.0,0.7556561085972646,2.2724252491694372,0.0,10.968325791855193,2.083056478405318,4.5,0.1900452488687705,0.7043189368770761,0.0,8.036199095022624,3.2093023255813975,9.083333333333329,2.1719457013574583,1.418604651162795,0.0,31.814479638009047,11.28903654485049,59.583333333333336,51.552036199095014,6.418604651162795,21.83333333333333,45.83257918552036,29.09302325581396,6.666666666666664,108.43438914027155,58.302325581395365,19.611111111111104,15.651583710407266,62.46511627906977,19.861111111111114,3.0,0.0,0.0,3.0,2.0,0.0
+0.0,0.0,0.3333333333333339,0.9592760180995477,0.0,0.0,0.8371040723981906,0.0,0.0,3.3574660633484115,0.3156146179401995,0.0,0.5656108597284941,0.4617940199335564,0.0,0.31674208144795557,0.5681063122923593,0.0,0.8778280542986323,1.8936877076411953,0.0,1.2533936651583701,0.7043189368770761,0.5,0.06787330316740281,0.08305647840531805,0.0,15.877828054298632,1.2724252491694372,1.5,0.8778280542986323,0.514950166112957,0.0,3.104072398190027,3.6511627906976827,1.3333333333333286,0.7647058823529278,2.697674418604663,2.6666666666666643,130.46133665158442,21.70099667774086,12.166666666666671,31.49321266968326,27.023255813953497,12.083333333333329,23.036199095022624,25.09302325581396,12.5,1.0,78.27574750830559,36.75,4.0,55.74418604651164,23.166666666666657,0.0,1.0,0.0,2.0,0.0,0.0
+0.0,0.0,0.3333333333333339,0.9592760180995477,0.0,0.0,0.8371040723981906,0.0,0.0,1.117647058823536,0.9734219269102997,0.0,0.5656108597284941,0.4617940199335564,0.0,0.6923076923076792,0.18936877076411962,0.0,2.565610859728494,1.7043189368770761,0.0,0.1900452488687705,2.0830564784053216,0.0,0.380090497737541,0.6511627906976756,0.0,12.533936651583701,1.083056478405318,1.0,0.31674208144795557,0.08305647840531805,0.0,19.443438914027126,1.9302325581395365,2.5,14.968325791855193,0.2558139534883779,0.6666666666666643,158.43891402714937,20.33554817275747,9.500000000000002,38.628959276018094,26.302325581395372,15.083333333333329,20.75113122171946,20.930232558139537,17.33333333333333,3.0,72.72923588039865,38.583333333333336,4.0,56.28737541528237,21.08333333333333,0.0,3.0,1.0,3.0,1.0,1.0
+0.0,0.0,0.3333333333333339,1.3393665158371038,0.0,1.0416666666666667,0.8371040723981906,0.0,0.0,0.35746606334841147,0.3156146179401995,0.0,0.8778280542986323,0.8405315614617948,0.5,0.06787330316740281,1.1893687707641196,0.0,0.1900452488687705,0.7043189368770761,0.0,0.941176470588232,1.083056478405318,0.0,0.380090497737541,0.6511627906976756,0.0,6.158371040723978,1.2724252491694372,6.000000000000002,0.6289592760180938,1.083056478405318,0.5,21.511312217194547,0.9302325581395365,1.5,20.968325791855214,3.255813953488378,2.6666666666666643,143.6380090497738,16.48837209302326,10.0,44.9004524886878,4.697674418604663,23.83333333333333,19.20361990950228,24.651162790697683,6.583333333333329,4.76018099547511,86.34883720930233,27.916666666666664,3.2398190045248896,41.58139534883722,16.08333333333333,2.0,0.0,1.0,2.0,3.0,0.0
+1.4796380090497743,0.0,1.166666666666667,2.4796380090497734,0.0,4.166666666666667,0.8371040723981906,0.0,0.0,0.35746606334841147,0.3156146179401995,0.0,0.5022624434389087,1.0299003322259175,0.0,0.31674208144795557,0.5681063122923593,0.0,0.1900452488687705,0.8936877076411953,0.5,0.31674208144795557,0.08305647840531805,0.0,0.380090497737541,0.6511627906976756,0.0,1.1900452488687705,2.2724252491694372,2.0,0.25339366515837014,0.2724252491694372,0.0,3.104072398190027,7.151187790697662,7.416666666666664,9.561085972850677,7.755788953488398,4.5,63.89592760181,29.37209302325582,16.708333333333332,52.96832579185518,18.860465116279073,11.166666666666664,30.175339451355338,15.930232558139537,5.583333333333329,1.9502262443438936,78.90697674418605,33.75,45.0395928450205,32.418604651162795,16.08333333333333,1.0,1.0,0.0,2.0,0.0,2.0
+0.7194570135746603,0.0,1.0833333333333335,1.6199095022624435,0.0,1.0416666666666667,1.8371040723981906,0.0,0.0,3.1990950226244337,2.6578073089700998,0.0,1.5022624434389087,0.6511627906976774,0.0,1.692307692307665,0.8405315614617948,0.0,2.0678733031673886,0.8936877076411953,0.5,2.3167420814479556,2.083056478405318,0.0,0.0,1.219269102990033,0.0,0.8778280542986323,0.2724252491694372,0.0,0.5656108597284941,0.6511627906976756,0.5,8.307692307692292,0.9302325581395365,7.5,18.959276018099622,8.976744186046524,1.5833333333333286,97.69683257918551,27.53488372093024,8.916666666666664,6.2895927601809944,17.13953488372095,31.58333333333333,10.171945701357458,32.09302325581396,6.583333333333329,4.0,35.13953488372091,59.99999999999999,1.0,10.8139534883721,43.15275185141978,1.0,3.0,107.5,4.0,0.0,1.3333333333333313
+0.7194570135746603,0.0,1.0833333333333335,1.239819004524887,0.0,1.0416666666666667,2.3574660633484115,0.3156146179401995,0.0,2.6787330316742093,0.9202657807308974,0.0,0.06787330316740281,0.5681063122923593,1.0,0.6923076923076792,0.4617940199335564,0.0,0.8778280542986323,0.8936877076411953,0.0,0.941176470588232,0.08305647840531805,0.0,1.0678733031673944,0.4617940199335564,0.0,3.565610859728494,0.08305647840531805,0.0,1.8461538461538396,0.8405315614617948,0.0,5.057692307692292,1.9302325581395365,10.416666666666664,5.49321266968326,2.0930232558139608,16.08333333333333,70.6289592760181,0.7674418604651194,12.486111111111109,15.628959276018094,15.534883720930239,27.87847222222223,13.511312217194556,3.6046511627906987,13.989583333333332,41.62895927601809,56.302325581395365,18.822916666666668,13.996606334841774,40.12292358803984,12.989583333333332,1.0,43.29568106312291,2.0,3.0,111.72093023255815,1.0
+1.3393665158371038,0.0,1.0416666666666667,2.3393665158371015,0.0,1.0416666666666667,0.35746606334841147,0.3156146179401995,0.0,0.19909502262443368,0.235880398671096,0.0,2.7556561085972717,1.3787375415282392,0.0,3.0045248868778174,0.08305647840531805,0.5,1.1900452488687705,0.2724252491694372,0.5,2.9411764705882337,0.2724252491694372,0.5,1.126696832579185,0.6511627906976756,0.0,2.25339366515837,1.1362222582734518,1.0,0.15837104072397779,0.6511627906976756,0.0,0.23981900452488958,6.993362348760033,5.583333333333329,8.452488687782804,14.462916390178187,12.333333333333329,55.81447963800905,2.4883720930232585,2.6666666666666643,23.757918552036205,18.13953488372095,22.916666666666664,64.18325791855204,3.6046511627906987,6.708333333333336,36.690045248868785,41.418604651162795,27.833333333333336,32.64027149321268,30.418604651162795,15.333333333333327,4.0,82.62790697674421,32.58333333333333,0.0,33.523778072555714,38.375000000000014
+1.239819004524887,0.0,1.0416666666666667,0.6199095022624435,0.0,1.0833333333333335,0.35746606334841147,0.3156146179401995,0.0,0.19909502262443368,1.235880398671096,0.0,1.7511312217194543,0.40863787375415317,0.0,0.31674208144795557,0.7043189368770761,0.0,0.8144796380090469,0.08305647840531805,0.0,0.25339366515837014,0.2724252491694372,0.0,0.43891402714931615,0.6511627906976756,0.5,0.941176470588232,0.4617940199335564,0.0,3.126696832579185,0.029900332225913928,0.0,4.511312217194558,4.093023255813961,3.75,2.221719457013563,24.976744186046517,15.25,0.7466063348416299,36.46843853820596,7.666666666666664,0.6289592760180938,32.73421926910299,13.999999999999996,2.3076923076922924,13.488372093023258,8.416666666666664,131.7601809954752,1.0,23.0,114.18552036199097,0.0,16.5,2.8144796380090487,1.0,82.58333333333331,3.7647058823529154,2.0,89.20833333333334
+1.239819004524887,0.0,1.0416666666666667,1.239819004524887,0.0,1.0416666666666667,0.8778280542986465,0.631229235880399,0.0,0.43891402714932326,1.5780730897009967,0.0,0.7556561085972646,0.37873754152823924,0.0,0.941176470588232,1.7043189368770761,0.0,0.8144796380090469,0.08305647840531805,0.0,3.2533936651583746,0.2724252491694372,0.0,0.380090497737541,0.4617940199335573,0.0,1.5656108597284941,0.4617940199335564,0.0,2.470588235294116,0.2192691029900331,0.0,4.443438914027126,6.7907186046511505,5.75,1.1538461538461462,30.697674418604663,10.416666666666664,2.882352941176464,50.63122923588038,7.666666666666664,0.6968325791855108,10.674397674418625,18.0,2.3076923076922924,16.149501661129555,6.583333333333329,125.12669683257926,2.2093023255813975,23.08333333333333,114.69683257918557,2.2635658914728674,14.666666666666664,2.882352941176459,3.2635658914728674,99.5,3.8325791855203684,0.2635658914728675,81.25000000000001
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_replicas.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_replicas.csv
new file mode 100644
index 0000000..f71cbd0
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_replicas.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,8.0,16.0,0.0,0.0,30.0,0.0,1.0,24.0,3.0,1.0,24.0,13.0,7.0,34.0,7.0,8.0,24.0,9.0,11.0,20.0,10.0,12.0,40.0,12.0,0.0,18.0,11.0,11.0,18.0,9.0,14.0,30.0,10.0,23.0,32.0,20.0,12.0,18.0,10.0,29.0,26.0,20.0,14.0,36.0,14.0,16.0,34.0,24.0,23.0,33.0,27.0,20.0,13.0,6.0,6.0,18.0,14.0,19.0
+0.0,0.0,8.0,16.0,0.0,0.0,32.0,0.0,0.0,28.0,2.0,0.0,22.0,13.0,8.0,30.0,3.0,14.0,20.0,10.0,12.0,24.0,9.0,11.0,38.0,11.0,2.0,20.0,12.0,9.0,20.0,8.0,14.0,31.0,12.0,20.0,26.0,19.0,16.0,37.0,14.0,15.0,22.0,25.0,11.0,32.0,14.0,18.0,13.0,30.0,27.0,31.0,26.0,22.0,11.0,7.0,7.0,18.0,12.0,16.0
+0.0,0.0,8.0,16.0,0.0,0.0,32.0,0.0,0.0,26.0,3.0,0.0,22.0,13.0,8.0,34.0,1.0,14.0,22.0,9.0,12.0,18.0,11.0,12.0,36.0,14.0,0.0,19.0,11.0,10.0,30.0,11.0,6.0,36.0,11.0,18.0,29.0,17.0,16.0,42.0,13.0,14.0,24.0,24.0,11.0,34.0,11.0,20.0,14.0,28.0,29.0,29.0,26.0,23.0,14.0,6.0,8.0,19.0,14.0,14.0
+0.0,0.0,8.0,14.0,0.0,1.0,32.0,0.0,0.0,28.0,2.0,0.0,20.0,15.0,7.0,38.0,1.0,12.0,18.0,9.0,14.0,26.0,11.0,8.0,36.0,14.0,0.0,15.0,12.0,12.0,28.0,11.0,7.0,37.0,11.0,18.0,29.0,17.0,16.0,40.0,13.0,15.0,28.0,19.0,14.0,35.0,12.0,17.0,13.0,31.0,25.0,33.0,23.0,23.0,10.0,6.0,6.0,20.0,13.0,12.0
+8.0,0.0,4.0,8.0,0.0,4.0,32.0,0.0,0.0,28.0,2.0,0.0,16.0,16.0,8.0,30.0,3.0,14.0,18.0,10.0,13.0,30.0,11.0,6.0,36.0,14.0,0.0,18.0,12.0,10.0,24.0,12.0,8.0,31.0,13.0,19.0,23.0,18.0,18.0,25.0,16.0,19.0,29.0,22.0,10.0,38.0,11.0,17.0,14.0,29.0,27.0,39.0,20.0,23.0,13.0,6.0,5.0,21.0,13.0,11.0
+12.0,0.0,2.0,14.0,0.0,1.0,32.0,0.0,0.0,30.0,1.0,0.0,16.0,14.0,10.0,34.0,15.0,0.0,38.0,10.0,3.0,30.0,11.0,6.0,30.0,17.0,0.0,20.0,12.0,10.0,22.0,14.0,7.0,35.0,11.0,18.0,24.0,18.0,17.0,31.0,16.0,16.0,20.0,21.0,17.0,34.0,14.0,17.0,16.0,19.0,36.0,33.0,15.0,32.0,11.0,7.0,42.0,23.0,14.0,8.0
+12.0,0.0,2.0,14.0,0.0,1.0,28.0,2.0,0.0,30.0,1.0,0.0,38.0,3.0,10.0,34.0,13.0,2.0,20.0,10.0,12.0,26.0,11.0,8.0,38.0,13.0,0.0,22.0,11.0,10.0,17.0,15.0,8.0,35.0,11.0,19.0,22.0,14.0,23.0,24.0,8.0,18.0,24.0,20.0,16.0,37.0,6.0,21.0,24.0,24.0,23.0,36.0,24.0,21.0,12.0,20.0,6.0,24.0,44.0,8.0
+14.0,0.0,1.0,14.0,0.0,1.0,28.0,2.0,0.0,10.0,11.0,0.0,40.0,2.0,10.0,32.0,11.0,5.0,18.0,12.0,11.0,26.0,12.0,7.0,12.0,14.0,12.0,24.0,12.0,8.0,15.0,14.0,10.0,33.0,14.0,17.0,22.0,17.0,20.0,23.0,9.0,16.0,27.0,21.0,13.0,48.0,6.0,17.0,26.0,20.0,26.0,40.0,20.0,20.0,11.0,30.0,17.0,25.0,24.0,19.0
+14.0,0.0,1.0,12.0,0.0,2.0,28.0,2.0,0.0,10.0,11.0,0.0,8.0,18.0,10.0,30.0,9.0,8.0,38.0,11.0,2.0,24.0,12.0,8.0,34.0,14.0,1.0,26.0,13.0,6.0,12.0,16.0,10.0,37.0,14.0,15.0,18.0,18.0,21.0,11.0,19.0,18.0,24.0,24.0,12.0,34.0,9.0,19.0,43.0,11.0,24.0,56.0,12.0,18.0,12.0,11.0,35.0,26.0,15.0,36.0
+14.0,0.0,1.0,14.0,0.0,1.0,24.0,4.0,0.0,12.0,10.0,0.0,40.0,2.0,10.0,26.0,9.0,10.0,38.0,11.0,2.0,24.0,12.0,8.0,34.0,13.0,2.0,26.0,13.0,6.0,13.0,17.0,8.0,36.0,14.0,15.0,17.0,19.0,19.0,13.0,23.0,18.0,25.0,18.0,12.0,34.0,10.0,17.0,45.0,10.0,23.0,55.0,14.0,16.0,13.0,12.0,41.0,27.0,15.0,35.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_residual_capacity.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_residual_capacity.csv
new file mode 100644
index 0000000..c885dba
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_residual_capacity.csv
@@ -0,0 +1,11 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,256.0,23296.0,11264.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,256.0,0.0,256.0,512.0,0.0,256.0,256.0,22784.0,13824.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,768.0,0.0,512.0,256.0,0.0,512.0,0.0,0.0,256.0,22016.0,13568.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,256.0,256.0,0.0,512.0,768.0,768.0,768.0,24064.0,14848.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,256.0,256.0,256.0,768.0,512.0,512.0,768.0,23808.0,15104.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,768.0,512.0,256.0,0.0,0.0,512.0,256.0,4864.0,15616.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,256.0,0.0,5120.0,0.0,1280.0,2560.0,512.0,16384.0,0.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,256.0,0.0,5888.0,256.0,512.0,2560.0,2048.0,5888.0,4352.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,2816.0,0.0,1536.0,3840.0,3072.0,6144.0,0.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,512.0,768.0,256.0,2816.0,2048.0,4352.0,3328.0,2304.0,256.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_solution.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_solution.csv
new file mode 100644
index 0000000..881a4a6
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_loc,n0_f1_loc,n0_f2_loc,n1_f0_loc,n1_f1_loc,n1_f2_loc,n2_f0_loc,n2_f1_loc,n2_f2_loc,n3_f0_loc,n3_f1_loc,n3_f2_loc,n4_f0_loc,n4_f1_loc,n4_f2_loc,n5_f0_loc,n5_f1_loc,n5_f2_loc,n6_f0_loc,n6_f1_loc,n6_f2_loc,n7_f0_loc,n7_f1_loc,n7_f2_loc,n8_f0_loc,n8_f1_loc,n8_f2_loc,n9_f0_loc,n9_f1_loc,n9_f2_loc,n10_f0_loc,n10_f1_loc,n10_f2_loc,n11_f0_loc,n11_f1_loc,n11_f2_loc,n12_f0_loc,n12_f1_loc,n12_f2_loc,n13_f0_loc,n13_f1_loc,n13_f2_loc,n14_f0_loc,n14_f1_loc,n14_f2_loc,n15_f0_loc,n15_f1_loc,n15_f2_loc,n16_f0_loc,n16_f1_loc,n16_f2_loc,n17_f0_loc,n17_f1_loc,n17_f2_loc,n18_f0_loc,n18_f1_loc,n18_f2_loc,n19_f0_loc,n19_f1_loc,n19_f2_loc,n0_f0_fwd,n0_f1_fwd,n0_f2_fwd,n1_f0_fwd,n1_f1_fwd,n1_f2_fwd,n2_f0_fwd,n2_f1_fwd,n2_f2_fwd,n3_f0_fwd,n3_f1_fwd,n3_f2_fwd,n4_f0_fwd,n4_f1_fwd,n4_f2_fwd,n5_f0_fwd,n5_f1_fwd,n5_f2_fwd,n6_f0_fwd,n6_f1_fwd,n6_f2_fwd,n7_f0_fwd,n7_f1_fwd,n7_f2_fwd,n8_f0_fwd,n8_f1_fwd,n8_f2_fwd,n9_f0_fwd,n9_f1_fwd,n9_f2_fwd,n10_f0_fwd,n10_f1_fwd,n10_f2_fwd,n11_f0_fwd,n11_f1_fwd,n11_f2_fwd,n12_f0_fwd,n12_f1_fwd,n12_f2_fwd,n13_f0_fwd,n13_f1_fwd,n13_f2_fwd,n14_f0_fwd,n14_f1_fwd,n14_f2_fwd,n15_f0_fwd,n15_f1_fwd,n15_f2_fwd,n16_f0_fwd,n16_f1_fwd,n16_f2_fwd,n17_f0_fwd,n17_f1_fwd,n17_f2_fwd,n18_f0_fwd,n18_f1_fwd,n18_f2_fwd,n19_f0_fwd,n19_f1_fwd,n19_f2_fwd,n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,8.0,28.0,0.0,0.0,106.0,0.0,0.0,86.0,7.0,0.0,104.0,41.0,17.0,147.0,21.0,20.0,104.0,28.0,27.0,86.0,31.0,30.0,173.0,36.0,0.0,67.0,33.0,23.0,78.0,28.0,35.0,144.0,34.0,58.0,160.0,73.0,35.0,59.0,25.0,25.0,80.0,68.0,19.0,136.0,23.0,40.0,63.0,31.0,47.0,151.0,38.0,38.0,62.0,22.0,17.0,88.0,50.0,55.0,163.0,63.0,13.0,43.0,68.0,20.0,32.0,10.61794019933555,33.0,3.0,41.99667774086382,37.0,45.0,0.0,1.0,0.9185520361991024,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.0,0.0,0.0,1.0,0.0,1.3055555555555425,0.0,0.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.0,59.38205980066445,0.0,0.0,6.0033222591361834,0.0,0.0,1.0,0.0,4.081447963800898,40.0,2.0,37.0,0.0,3.0,61.0,0.0,0.0,1.0,0.0,32.0,0.0,0.0,0.0,87.0,0.0,3.6944444444444575,0.0,0.0,0.0,0.0,0.0,6.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,8.0,28.0,0.0,0.0,115.0,0.0,0.0,98.0,5.0,0.0,95.0,41.0,20.0,130.0,9.0,35.0,86.0,30.0,30.0,103.0,28.0,27.0,165.0,35.0,5.0,71.0,37.0,21.0,86.0,25.0,35.0,154.0,41.0,57.0,131.0,68.0,44.0,54.0,30.0,30.0,80.0,66.0,20.0,139.0,27.0,40.0,64.0,33.0,42.0,153.0,41.0,41.0,55.0,25.0,20.0,89.0,44.0,46.0,155.0,68.0,14.0,48.0,66.0,19.0,1.321266968325773,46.0,18.0,0.0,41.0,38.999999999999986,14.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,0.0,0.0,2.529209954751742,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.678733031674227,14.0,14.0,0.0,0.0,5.000000000000014,50.0,2.0,1.0,37.0,54.0,2.0,75.0,0.0,1.0,48.0,1.0,1.0,3.0,1.0,36.0,0.0,0.0,0.0,70.47079004524826,1.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,8.0,28.0,0.0,0.0,115.0,0.0,0.0,93.0,7.0,0.0,95.0,41.0,20.0,147.0,3.0,35.0,93.0,27.0,30.0,78.0,33.0,30.0,156.0,44.0,0.0,70.0,34.0,24.0,130.0,35.0,15.0,163.0,39.0,50.0,132.0,63.0,46.0,54.0,28.0,31.0,83.0,63.0,17.0,151.0,20.0,41.0,67.0,29.0,46.0,142.0,38.0,46.0,70.0,19.0,22.0,93.0,51.0,39.0,141.0,69.0,12.0,52.0,69.0,19.0,19.0,30.000000000000004,24.0,0.0,40.0,39.08333333333332,66.0,0.0,0.0,2.0,2.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,1.3891402714931615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,34.0,12.0,0.0,0.0,0.9166666666666785,0.0,1.0,0.0,18.0,58.0,0.0,70.0,0.0,3.0,63.0,0.0,2.0,15.0,0.0,37.0,0.0,0.0,0.0,1.6108597285068385,2.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,8.0,24.0,0.0,0.0,115.0,0.0,0.0,101.0,5.0,0.0,86.0,47.0,17.0,165.0,2.0,30.0,78.0,28.0,35.0,112.0,34.0,20.0,156.0,44.0,0.0,59.0,37.0,24.0,121.0,34.0,17.0,166.0,40.0,51.0,121.0,60.0,44.0,59.0,31.0,33.0,92.0,66.0,17.0,158.0,20.0,43.0,61.0,29.0,45.0,164.0,44.0,51.0,48.0,22.0,16.0,99.0,45.0,35.0,151.00000000000003,64.0,16.0,46.0,65.0,17.0,17.0,32.734219269102994,25.791666666666668,1.0,26.35880398671101,20.16666666666665,58.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,-2.842170943040401e-14,0.0,0.0,4.0,0.0,0.0,0.0,27.265780730897006,10.208333333333332,0.0,10.64119601328899,17.83333333333335,30.0,1.0,1.0,3.0,61.0,5.0,97.0,0.0,0.0,4.0,0.0,12.0,14.0,2.0,34.0,0.0,0.0,0.0,0.0,0.0,21.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+13.0,0.0,3.0,12.0,0.0,0.0,115.0,0.0,0.0,101.0,5.0,0.0,69.0,50.0,20.0,130.0,9.0,35.0,78.0,31.0,32.0,130.0,35.0,15.0,156.0,44.0,0.0,77.0,36.0,23.0,104.0,38.0,20.0,154.0,41.0,48.0,107.0,59.0,48.0,62.0,30.0,38.0,94.0,63.0,18.0,162.0,25.0,44.0,69.0,29.0,45.0,152.0,42.0,51.0,64.0,21.0,14.0,104.0,48.0,30.0,130.0,62.0,21.0,62.0,57.0,18.0,7.0,46.53156146179401,34.91666666666667,5.0,30.950166112956865,29.29166666666665,11.856335096147484,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1414026300925575,1.0,1.8333333333333357,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,16.0,0.0,0.0,0.0,15.468438538205987,2.0833333333333286,0.0,0.049833887043135405,10.70833333333335,88.14366490385251,1.0,1.0,36.0,48.0,4.0,89.0,0.0,0.0,1.0,0.0,17.0,2.0,9.0,44.0,0.0,0.0,0.0,1.8585973699074425,0.0,15.166666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+21.0,0.0,1.0,23.0,0.0,0.0,114.0,0.0,0.0,105.0,0.0,0.0,68.0,44.0,25.0,146.0,47.0,0.0,163.0,31.0,7.0,128.0,33.0,15.0,130.0,53.0,0.0,86.0,38.0,25.0,95.0,44.0,17.0,169.0,40.0,45.0,102.0,58.0,48.0,59.0,32.0,37.0,95.0,61.0,18.0,162.0,20.0,43.0,77.0,33.0,45.0,166.0,45.0,50.0,54.0,23.0,15.0,112.0,52.0,22.0,101.0,60.0,20.0,60.0,43.5946843853821,18.0,0.0,3.302325581395351,37.0,0.0,38.0,42.0,0.0,0.0,1.0,4.253393665158342,0.0,39.0,1.2533936651583488,0.0,30.0,0.0,0.0,19.0,1.3167420814479556,0.0,40.0,0.0,0.0,3.0,0.0,0.0,22.277751851419755,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,5.0,16.405315614617898,0.0,0.0,49.69767441860465,0.0,8.0,0.0,0.0,96.0,11.0,0.0,10.746606334841658,1.0,0.0,3.746606334841651,0.0,0.0,0.0,0.0,0.0,37.683257918552044,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.7222481485802454,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+21.0,0.0,1.0,24.0,0.0,0.0,99.0,5.0,0.0,105.0,0.0,0.0,165.0,9.0,24.0,147.0,41.0,5.0,86.0,31.0,30.0,112.0,35.0,20.0,164.0,41.0,0.0,92.0,35.0,25.0,72.0,47.0,20.0,172.0,39.0,45.0,106.0,50.0,51.0,51.0,29.0,40.0,106.0,58.0,17.0,174.0,18.0,45.0,80.0,33.0,46.0,167.0,46.0,46.0,59.0,30.0,15.0,118.0,52.0,22.0,100.0,59.0,21.0,62.0,62.0,20.0,0.0,50.0,16.791666666666668,6.0,37.0,43.0,5.0,49.0,0.0,6.0,1.0,0.0,6.0,1.0,0.0,1.0,0.0,0.0,0.0,13.0,0.0,0.0,7.999999999999999,0.0,0.0,0.0,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,20.208333333333332,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,36.0,87.0,0.0,4.0,0.0,0.0,14.0,0.0,0.0,41.0,0.0,8.881784197001252e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+24.0,0.0,0.0,23.0,0.0,0.0,101.0,5.0,0.0,36.0,29.0,0.0,171.0,5.0,25.0,136.0,35.0,12.0,77.0,38.0,27.0,110.0,38.0,17.0,51.0,44.0,30.0,102.0,37.0,19.0,65.0,44.0,25.0,167.0,45.0,44.0,103.0,48.0,46.0,60.0,31.0,44.0,111.0,60.0,15.0,177.0,18.0,42.0,93.0,33.0,48.0,168.0,44.0,43.0,51.0,29.0,17.0,126.0,53.0,17.0,92.0,62.0,26.0,66.0,59.0,19.0,0.0,46.0,39.0,80.99999999999999,3.0,44.0,2.4434389140271424,51.0,0.0,0.0,0.6744186046511622,15.0,0.0,0.0,5.0,0.0,0.0,0.0,2.0,8.0,6.0,0.0,8.0,6.0,0.0,1.0,8.916666666666664,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,1.4210854715202004e-14,0.0,0.0,3.5565610859728576,1.0,0.0,0.0,0.3255813953488378,15.0,92.0,0.0,4.0,0.0,0.0,20.0,109.0,3.0,0.0,0.0,1.0,1.0,0.0,0.0,6.083333333333336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+24.0,0.0,0.0,21.0,0.0,1.0,101.0,5.0,0.0,36.0,28.0,0.0,33.0,57.0,25.0,130.0,28.0,20.0,164.0,35.0,5.0,104.0,38.0,20.0,147.0,44.0,0.0,112.0,41.0,15.0,49.0,51.0,25.0,183.0,48.0,40.0,89.0,42.0,46.0,55.0,32.0,44.0,121.0,56.0,21.0,170.0,20.0,47.0,86.0,39.0,47.0,169.0,44.0,36.0,58.0,39.0,18.0,128.0,53.0,15.0,78.0,61.00000000000001,24.0,75.0,57.99999999999999,17.0,5.0,0.9235880398671128,40.0,89.0,0.0,45.0,3.0,0.0,0.0,4.0,0.0,23.0,7.0,0.0,32.0,1.0,0.0,18.0,7.0,0.0,33.0,3.9999999999999893,0.0,14.0,0.0,0.0,16.999999999999986,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,-7.105427357601002e-15,0.0,4.0,7.105427357601002e-15,0.0,0.0,40.07641196013289,0.0,0.0,0.0,0.0,140.0,1.0,0.0,0.0,1.0,0.0,1.0,0.0,0.0,0.0,2.0,0.0,9.0,11.0,0.0,1.0658141036401503e-14,0.0,0.0,0.0,0.0,1.4210854715202004e-14,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+24.0,0.0,0.0,24.0,0.0,0.0,86.0,10.0,0.0,43.0,25.0,0.0,173.0,6.0,25.0,112.0,27.0,25.0,164.0,35.0,5.0,101.0,38.0,20.0,147.0,41.0,5.0,111.0,41.0,15.0,54.0,54.0,20.0,178.0,45.0,38.0,85.0,40.0,45.0,63.0,34.0,44.0,126.0,56.0,17.0,170.0,21.0,43.0,99.0,35.0,44.0,163.0,49.0,32.0,63.0,41.0,18.0,133.0,55.0,19.0,83.0,56.0,25.0,80.0,57.0,24.0,2.0,13.734219269102994,40.0,86.0,0.0,46.0,2.0,0.0,1.0,4.0,0.0,22.0,6.0,0.0,31.0,0.0,0.0,17.0,3.0,0.0,28.0,6.000000000000001,1.0,12.0,0.0,1.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,4.0,0.0,0.0,0.0,23.265780730897006,0.0,0.0,0.0,0.0,0.0,54.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,9.0,17.0,0.0,0.9999999999999991,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-11-12.143728/LSPc_utilization.csv b/test_instances/2026-06-30_15-11-12.143728/LSPc_utilization.csv
new file mode 100644
index 0000000..7281f14
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/LSPc_utilization.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.768,0.7735,0.0,0.0,0.7808666666666667,0.0,0.0,0.7919166666666667,0.7023333333333333,0.0,0.7980555555555555,0.7910897435897437,0.7771428571428572,0.79625,0.7525000000000001,0.8,0.7980555555555555,0.7803703703703704,0.7854545454545455,0.7919166666666667,0.7775833333333334,0.7999999999999999,0.7965208333333333,0.7525000000000001,0.0,0.6855092592592593,0.7525,0.6690909090909091,0.7980555555555555,0.7803703703703704,0.8,0.7577142857142858,0.731,0.6916770186335404,0.7892857142857144,0.7847500000000001,0.7999999999999999,0.517420634920635,0.5375,0.23645320197044337,0.48571428571428577,0.731,0.3722448979591837,0.5963492063492064,0.35321428571428576,0.6857142857142857,0.2925,0.27770833333333333,0.5604968944099379,0.7223160173160174,0.3025925925925926,0.5211428571428571,0.7528571428571429,0.7883333333333332,0.7771428571428571,0.7717460317460317,0.7678571428571429,0.7939849624060151
+0.0,0.0,0.768,0.7735,0.0,0.0,0.79421875,0.0,0.0,0.7735000000000001,0.7525,0.0,0.7952651515151515,0.7910897435897437,0.8,0.7980555555555555,0.7525000000000001,0.8,0.7919166666666667,0.7525000000000001,0.7999999999999999,0.7903819444444444,0.7803703703703704,0.7854545454545455,0.7996710526315789,0.7981060606060606,0.8,0.6537916666666667,0.7734027777777778,0.7466666666666666,0.7919166666666667,0.7838541666666667,0.8,0.7841935483870969,0.7345833333333333,0.7817142857142858,0.7953571428571429,0.7694736842105263,0.7542857142857143,0.23038610038610038,0.46071428571428574,0.5485714285714286,0.5740259740259741,0.5676,0.4987012987012987,0.6856919642857143,0.41464285714285715,0.6095238095238096,0.7771428571428571,0.2365,0.4266666666666667,0.7791013824884794,0.3390384615384615,0.5111688311688312,0.7892857142857143,0.7678571428571429,0.7836734693877551,0.780515873015873,0.7883333333333332,0.7885714285714286
+0.0,0.0,0.768,0.7735,0.0,0.0,0.79421875,0.0,0.0,0.7905,0.7023333333333333,0.0,0.7952651515151515,0.7910897435897437,0.8,0.79625,0.7525000000000001,0.8,0.7785227272727273,0.7525000000000001,0.7999999999999999,0.7980555555555555,0.7525,0.7999999999999999,0.7980555555555555,0.7883333333333333,0.0,0.6785087719298246,0.7753030303030304,0.768,0.7980555555555555,0.7981060606060606,0.7999999999999999,0.7147420634920635,0.7622727272727272,0.761904761904762,0.7185221674876847,0.7967647058823529,0.7885714285714286,0.20295918367346938,0.46307692307692305,0.6073469387755103,0.5459226190476191,0.564375,0.4238961038961039,0.7010714285714287,0.3909090909090909,0.5622857142857143,0.7554591836734694,0.22267857142857145,0.43507389162561577,0.7729556650246306,0.3142307692307692,0.5485714285714286,0.7892857142857144,0.6808333333333333,0.7542857142857143,0.7726691729323308,0.7832142857142858,0.7640816326530613
+0.0,0.0,0.768,0.7577142857142858,0.0,0.0,0.79421875,0.0,0.0,0.7971785714285715,0.7525,0.0,0.7919166666666667,0.7859444444444446,0.7771428571428572,0.7996710526315789,0.5016666666666667,0.7999999999999999,0.7980555555555555,0.7803703703703704,0.8,0.7933333333333334,0.7753030303030304,0.8,0.7980555555555555,0.7883333333333333,0.0,0.724388888888889,0.7734027777777778,0.64,0.7958630952380953,0.7753030303030304,0.7771428571428572,0.7082239382239383,0.7818181818181817,0.7771428571428571,0.6586453201970444,0.7588235294117647,0.7542857142857143,0.23283928571428572,0.5126923076923077,0.6034285714285714,0.5186734693877552,0.7468421052631579,0.3330612244897959,0.7126122448979593,0.35833333333333334,0.6937815126050421,0.7407142857142858,0.20112903225806453,0.4937142857142857,0.7845021645021645,0.41130434782608694,0.6081987577639751,0.7577142857142858,0.7883333333333332,0.7314285714285714,0.7813928571428572,0.7442307692307693,0.7999999999999999
+0.71825,0.0,0.5760000000000001,0.663,0.0,0.0,0.79421875,0.0,0.0,0.7971785714285715,0.7525,0.0,0.79421875,0.7838541666666667,0.8,0.7980555555555555,0.7525000000000001,0.8,0.7980555555555555,0.7775833333333334,0.7876923076923077,0.7980555555555555,0.7981060606060606,0.7999999999999999,0.7980555555555555,0.7883333333333333,0.0,0.7878240740740741,0.7525000000000001,0.736,0.7980555555555555,0.7943055555555557,0.8,0.7841935483870969,0.678076923076923,0.6929323308270677,0.7343788819875776,0.7047222222222222,0.7314285714285715,0.39148571428571427,0.403125,0.5485714285714286,0.5116748768472906,0.6156818181818182,0.49371428571428577,0.6729699248120301,0.48863636363636365,0.7099159663865546,0.7780102040816327,0.21500000000000002,0.4571428571428572,0.6152380952380953,0.45149999999999996,0.6081987577639751,0.7771428571428571,0.7525,0.768,0.7817687074829932,0.7938461538461539,0.7480519480519482
+0.7735,0.0,0.384,0.7261428571428572,0.0,0.0,0.7873125,0.0,0.0,0.7735000000000001,0.0,0.0,0.7827083333333333,0.7883333333333333,0.8,0.7908333333333334,0.7859444444444446,0.0,0.7899780701754386,0.7775833333333334,0.7466666666666667,0.7857777777777778,0.7525,0.7999999999999999,0.7980555555555555,0.7820098039215687,0.0,0.7919166666666667,0.7943055555555557,0.8,0.7952651515151515,0.7883333333333333,0.7771428571428572,0.7622244897959184,0.7818181818181817,0.6857142857142857,0.6708928571428571,0.6927777777777778,0.7744537815126051,0.3004377880184332,0.43,0.6342857142857143,0.7498214285714286,0.6245238095238095,0.2904201680672269,0.7521428571428571,0.3071428571428571,0.6937815126050421,0.7596875000000001,0.37342105263157893,0.34285714285714286,0.794069264069264,0.645,0.4285714285714286,0.7749350649350649,0.7064285714285715,0.0979591836734694,0.768695652173913,0.7985714285714286,0.7542857142857143
+0.7735,0.0,0.384,0.7577142857142858,0.0,0.0,0.7813928571428572,0.7525,0.0,0.7735000000000001,0.0,0.0,0.7996710526315789,0.7525000000000001,0.768,0.79625,0.7910897435897437,0.8,0.7919166666666667,0.7775833333333334,0.7999999999999999,0.7933333333333334,0.7981060606060606,0.8,0.7948245614035088,0.7910897435897437,0.0,0.7701515151515153,0.7981060606060606,0.8,0.78,0.7859444444444446,0.8,0.7757551020408163,0.7622727272727272,0.649624060150376,0.7605844155844156,0.7678571428571429,0.6081987577639751,0.33544642857142853,0.779375,0.6095238095238096,0.697202380952381,0.6235,0.2914285714285714,0.7423552123552124,0.645,0.5877551020408164,0.5261904761904762,0.29562499999999997,0.5485714285714286,0.732281746031746,0.41208333333333336,0.6008163265306122,0.7761309523809524,0.3225,0.6857142857142858,0.7761309523809524,0.2540909090909091,0.7542857142857143
+0.7577142857142858,0.0,0.0,0.7261428571428572,0.0,0.0,0.7971785714285715,0.7525,0.0,0.7956000000000001,0.7935454545454544,0.0,0.7873125,0.6270833333333334,0.8,0.7827083333333333,0.7981060606060606,0.768,0.7878240740740741,0.7943055555555557,0.7854545454545455,0.7791666666666667,0.7943055555555557,0.7771428571428572,0.7827083333333333,0.7883333333333333,0.7999999999999999,0.7827083333333333,0.7734027777777778,0.76,0.7980555555555555,0.7883333333333333,0.8,0.7988528138528138,0.6910714285714287,0.7099159663865546,0.7390584415584415,0.6070588235294118,0.6308571428571429,0.4118012422360248,0.7405555555555555,0.7542857142857143,0.648968253968254,0.6142857142857143,0.3164835164835165,0.5820982142857143,0.645,0.6776470588235295,0.5646428571428571,0.35475,0.5063736263736265,0.663,0.473,0.5897142857142857,0.7318831168831168,0.20783333333333334,0.2742857142857143,0.7956,0.47479166666666667,0.24541353383458647
+0.7577142857142858,0.0,0.0,0.7735,0.0,0.384,0.7971785714285715,0.7525,0.0,0.7956000000000001,0.7661818181818181,0.0,0.7596875000000001,0.7943055555555556,0.8,0.7980555555555555,0.7803703703703704,0.8,0.7948245614035088,0.7981060606060606,0.8,0.7980555555555555,0.7943055555555557,0.8,0.79625,0.7883333333333333,0.0,0.7933333333333334,0.7910897435897437,0.7999999999999999,0.752013888888889,0.79953125,0.8,0.7807528957528957,0.7371428571428572,0.7314285714285714,0.780515873015873,0.5016666666666666,0.6008163265306122,0.7892857142857143,0.3621052631578947,0.6704761904761906,0.7958630952380953,0.5016666666666666,0.48000000000000004,0.7892857142857143,0.47777777777777775,0.6784962406015037,0.3157142857142857,0.7622727272727272,0.5371428571428571,0.476390306122449,0.7883333333333332,0.5485714285714286,0.7629761904761905,0.7622727272727272,0.14106122448979594,0.7771428571428571,0.7596666666666666,0.1142857142857143
+0.7577142857142858,0.0,0.0,0.7577142857142858,0.0,0.0,0.7919166666666667,0.7525,0.0,0.7919166666666667,0.7525,0.0,0.7965208333333333,0.7525000000000001,0.8,0.7933333333333334,0.7525000000000001,0.8,0.7948245614035088,0.7981060606060606,0.8,0.7750347222222222,0.7943055555555557,0.8,0.79625,0.7910897435897437,0.8,0.78625,0.7910897435897437,0.7999999999999999,0.765,0.796764705882353,0.8,0.780515873015873,0.6910714285714287,0.694857142857143,0.7892857142857143,0.4526315789473684,0.649624060150376,0.765,0.3178260869565217,0.6704761904761906,0.7956,0.6688888888888889,0.38857142857142857,0.7892857142857143,0.45149999999999996,0.6937815126050421,0.3472857142857143,0.7525,0.52472049689441,0.4678311688311688,0.7525000000000001,0.5485714285714286,0.765,0.7345833333333333,0.12041811846689897,0.7775925925925926,0.7883333333333333,0.1488979591836735
diff --git a/test_instances/2026-06-30_15-11-12.143728/base_instance_data.json b/test_instances/2026-06-30_15-11-12.143728/base_instance_data.json
new file mode 100644
index 0000000..e1768d8
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/base_instance_data.json
@@ -0,0 +1,1894 @@
+{
+  "None": {
+    "Nn": {
+      "None": 20
+    },
+    "Nf": {
+      "None": 3
+    },
+    "demand": {
+      "(1, 1)": 0.442,
+      "(1, 2)": 0.602,
+      "(1, 3)": 0.768,
+      "(2, 1)": 0.442,
+      "(2, 2)": 0.602,
+      "(2, 3)": 0.768,
+      "(3, 1)": 0.221,
+      "(3, 2)": 0.301,
+      "(3, 3)": 0.384,
+      "(4, 1)": 0.221,
+      "(4, 2)": 0.301,
+      "(4, 3)": 0.384,
+      "(5, 1)": 0.18416666666666667,
+      "(5, 2)": 0.25083333333333335,
+      "(5, 3)": 0.32,
+      "(6, 1)": 0.18416666666666667,
+      "(6, 2)": 0.25083333333333335,
+      "(6, 3)": 0.32,
+      "(7, 1)": 0.18416666666666667,
+      "(7, 2)": 0.25083333333333335,
+      "(7, 3)": 0.32,
+      "(8, 1)": 0.18416666666666667,
+      "(8, 2)": 0.25083333333333335,
+      "(8, 3)": 0.32,
+      "(9, 1)": 0.18416666666666667,
+      "(9, 2)": 0.25083333333333335,
+      "(9, 3)": 0.32,
+      "(10, 1)": 0.18416666666666667,
+      "(10, 2)": 0.25083333333333335,
+      "(10, 3)": 0.32,
+      "(11, 1)": 0.18416666666666667,
+      "(11, 2)": 0.25083333333333335,
+      "(11, 3)": 0.32,
+      "(12, 1)": 0.15785714285714286,
+      "(12, 2)": 0.215,
+      "(12, 3)": 0.2742857142857143,
+      "(13, 1)": 0.15785714285714286,
+      "(13, 2)": 0.215,
+      "(13, 3)": 0.2742857142857143,
+      "(14, 1)": 0.15785714285714286,
+      "(14, 2)": 0.215,
+      "(14, 3)": 0.2742857142857143,
+      "(15, 1)": 0.15785714285714286,
+      "(15, 2)": 0.215,
+      "(15, 3)": 0.2742857142857143,
+      "(16, 1)": 0.15785714285714286,
+      "(16, 2)": 0.215,
+      "(16, 3)": 0.2742857142857143,
+      "(17, 1)": 0.15785714285714286,
+      "(17, 2)": 0.215,
+      "(17, 3)": 0.2742857142857143,
+      "(18, 1)": 0.15785714285714286,
+      "(18, 2)": 0.215,
+      "(18, 3)": 0.2742857142857143,
+      "(19, 1)": 0.15785714285714286,
+      "(19, 2)": 0.215,
+      "(19, 3)": 0.2742857142857143,
+      "(20, 1)": 0.15785714285714286,
+      "(20, 2)": 0.215,
+      "(20, 3)": 0.2742857142857143
+    },
+    "memory_requirement": {
+      "1": 256,
+      "2": 512,
+      "3": 512
+    },
+    "memory_capacity": {
+      "1": 4096,
+      "2": 4096,
+      "3": 8192,
+      "4": 8192,
+      "5": 16384,
+      "6": 16384,
+      "7": 16384,
+      "8": 16384,
+      "9": 16384,
+      "10": 16384,
+      "11": 16384,
+      "12": 24576,
+      "13": 24576,
+      "14": 24576,
+      "15": 24576,
+      "16": 24576,
+      "17": 32768,
+      "18": 32768,
+      "19": 32768,
+      "20": 32768
+    },
+    "neighborhood": {
+      "(1, 1)": 0,
+      "(1, 2)": 1,
+      "(1, 3)": 1,
+      "(1, 4)": 1,
+      "(1, 5)": 1,
+      "(1, 6)": 1,
+      "(1, 7)": 1,
+      "(1, 8)": 0,
+      "(1, 9)": 0,
+      "(1, 10)": 0,
+      "(1, 11)": 1,
+      "(1, 12)": 0,
+      "(1, 13)": 0,
+      "(1, 14)": 0,
+      "(1, 15)": 1,
+      "(1, 16)": 1,
+      "(1, 17)": 0,
+      "(1, 18)": 0,
+      "(1, 19)": 0,
+      "(1, 20)": 0,
+      "(2, 1)": 1,
+      "(2, 2)": 0,
+      "(2, 3)": 1,
+      "(2, 4)": 1,
+      "(2, 5)": 0,
+      "(2, 6)": 0,
+      "(2, 7)": 0,
+      "(2, 8)": 0,
+      "(2, 9)": 0,
+      "(2, 10)": 1,
+      "(2, 11)": 1,
+      "(2, 12)": 1,
+      "(2, 13)": 1,
+      "(2, 14)": 1,
+      "(2, 15)": 0,
+      "(2, 16)": 0,
+      "(2, 17)": 0,
+      "(2, 18)": 0,
+      "(2, 19)": 0,
+      "(2, 20)": 0,
+      "(3, 1)": 1,
+      "(3, 2)": 1,
+      "(3, 3)": 0,
+      "(3, 4)": 1,
+      "(3, 5)": 1,
+      "(3, 6)": 1,
+      "(3, 7)": 0,
+      "(3, 8)": 1,
+      "(3, 9)": 1,
+      "(3, 10)": 0,
+      "(3, 11)": 0,
+      "(3, 12)": 0,
+      "(3, 13)": 0,
+      "(3, 14)": 0,
+      "(3, 15)": 0,
+      "(3, 16)": 0,
+      "(3, 17)": 0,
+      "(3, 18)": 0,
+      "(3, 19)": 0,
+      "(3, 20)": 0,
+      "(4, 1)": 1,
+      "(4, 2)": 1,
+      "(4, 3)": 1,
+      "(4, 4)": 0,
+      "(4, 5)": 1,
+      "(4, 6)": 0,
+      "(4, 7)": 0,
+      "(4, 8)": 0,
+      "(4, 9)": 0,
+      "(4, 10)": 1,
+      "(4, 11)": 0,
+      "(4, 12)": 0,
+      "(4, 13)": 0,
+      "(4, 14)": 0,
+      "(4, 15)": 1,
+      "(4, 16)": 1,
+      "(4, 17)": 1,
+      "(4, 18)": 1,
+      "(4, 19)": 0,
+      "(4, 20)": 0,
+      "(5, 1)": 1,
+      "(5, 2)": 0,
+      "(5, 3)": 1,
+      "(5, 4)": 1,
+      "(5, 5)": 0,
+      "(5, 6)": 1,
+      "(5, 7)": 1,
+      "(5, 8)": 1,
+      "(5, 9)": 1,
+      "(5, 10)": 0,
+      "(5, 11)": 0,
+      "(5, 12)": 0,
+      "(5, 13)": 0,
+      "(5, 14)": 0,
+      "(5, 15)": 0,
+      "(5, 16)": 0,
+      "(5, 17)": 0,
+      "(5, 18)": 0,
+      "(5, 19)": 0,
+      "(5, 20)": 0,
+      "(6, 1)": 1,
+      "(6, 2)": 0,
+      "(6, 3)": 1,
+      "(6, 4)": 0,
+      "(6, 5)": 1,
+      "(6, 6)": 0,
+      "(6, 7)": 1,
+      "(6, 8)": 1,
+      "(6, 9)": 0,
+      "(6, 10)": 0,
+      "(6, 11)": 0,
+      "(6, 12)": 0,
+      "(6, 13)": 0,
+      "(6, 14)": 0,
+      "(6, 15)": 0,
+      "(6, 16)": 0,
+      "(6, 17)": 0,
+      "(6, 18)": 0,
+      "(6, 19)": 0,
+      "(6, 20)": 0,
+      "(7, 1)": 1,
+      "(7, 2)": 0,
+      "(7, 3)": 0,
+      "(7, 4)": 0,
+      "(7, 5)": 1,
+      "(7, 6)": 1,
+      "(7, 7)": 0,
+      "(7, 8)": 0,
+      "(7, 9)": 0,
+      "(7, 10)": 0,
+      "(7, 11)": 0,
+      "(7, 12)": 0,
+      "(7, 13)": 0,
+      "(7, 14)": 0,
+      "(7, 15)": 0,
+      "(7, 16)": 0,
+      "(7, 17)": 0,
+      "(7, 18)": 0,
+      "(7, 19)": 0,
+      "(7, 20)": 0,
+      "(8, 1)": 0,
+      "(8, 2)": 0,
+      "(8, 3)": 1,
+      "(8, 4)": 0,
+      "(8, 5)": 1,
+      "(8, 6)": 1,
+      "(8, 7)": 0,
+      "(8, 8)": 0,
+      "(8, 9)": 1,
+      "(8, 10)": 0,
+      "(8, 11)": 0,
+      "(8, 12)": 0,
+      "(8, 13)": 0,
+      "(8, 14)": 0,
+      "(8, 15)": 0,
+      "(8, 16)": 0,
+      "(8, 17)": 0,
+      "(8, 18)": 0,
+      "(8, 19)": 0,
+      "(8, 20)": 0,
+      "(9, 1)": 0,
+      "(9, 2)": 0,
+      "(9, 3)": 1,
+      "(9, 4)": 0,
+      "(9, 5)": 1,
+      "(9, 6)": 0,
+      "(9, 7)": 0,
+      "(9, 8)": 1,
+      "(9, 9)": 0,
+      "(9, 10)": 0,
+      "(9, 11)": 0,
+      "(9, 12)": 0,
+      "(9, 13)": 0,
+      "(9, 14)": 0,
+      "(9, 15)": 0,
+      "(9, 16)": 0,
+      "(9, 17)": 0,
+      "(9, 18)": 0,
+      "(9, 19)": 0,
+      "(9, 20)": 0,
+      "(10, 1)": 0,
+      "(10, 2)": 1,
+      "(10, 3)": 0,
+      "(10, 4)": 1,
+      "(10, 5)": 0,
+      "(10, 6)": 0,
+      "(10, 7)": 0,
+      "(10, 8)": 0,
+      "(10, 9)": 0,
+      "(10, 10)": 0,
+      "(10, 11)": 1,
+      "(10, 12)": 1,
+      "(10, 13)": 0,
+      "(10, 14)": 0,
+      "(10, 15)": 1,
+      "(10, 16)": 0,
+      "(10, 17)": 1,
+      "(10, 18)": 1,
+      "(10, 19)": 1,
+      "(10, 20)": 1,
+      "(11, 1)": 1,
+      "(11, 2)": 1,
+      "(11, 3)": 0,
+      "(11, 4)": 0,
+      "(11, 5)": 0,
+      "(11, 6)": 0,
+      "(11, 7)": 0,
+      "(11, 8)": 0,
+      "(11, 9)": 0,
+      "(11, 10)": 1,
+      "(11, 11)": 0,
+      "(11, 12)": 1,
+      "(11, 13)": 1,
+      "(11, 14)": 0,
+      "(11, 15)": 1,
+      "(11, 16)": 0,
+      "(11, 17)": 0,
+      "(11, 18)": 0,
+      "(11, 19)": 0,
+      "(11, 20)": 0,
+      "(12, 1)": 0,
+      "(12, 2)": 1,
+      "(12, 3)": 0,
+      "(12, 4)": 0,
+      "(12, 5)": 0,
+      "(12, 6)": 0,
+      "(12, 7)": 0,
+      "(12, 8)": 0,
+      "(12, 9)": 0,
+      "(12, 10)": 1,
+      "(12, 11)": 1,
+      "(12, 12)": 0,
+      "(12, 13)": 1,
+      "(12, 14)": 1,
+      "(12, 15)": 0,
+      "(12, 16)": 0,
+      "(12, 17)": 0,
+      "(12, 18)": 0,
+      "(12, 19)": 0,
+      "(12, 20)": 0,
+      "(13, 1)": 0,
+      "(13, 2)": 1,
+      "(13, 3)": 0,
+      "(13, 4)": 0,
+      "(13, 5)": 0,
+      "(13, 6)": 0,
+      "(13, 7)": 0,
+      "(13, 8)": 0,
+      "(13, 9)": 0,
+      "(13, 10)": 0,
+      "(13, 11)": 1,
+      "(13, 12)": 1,
+      "(13, 13)": 0,
+      "(13, 14)": 1,
+      "(13, 15)": 0,
+      "(13, 16)": 0,
+      "(13, 17)": 0,
+      "(13, 18)": 0,
+      "(13, 19)": 0,
+      "(13, 20)": 0,
+      "(14, 1)": 0,
+      "(14, 2)": 1,
+      "(14, 3)": 0,
+      "(14, 4)": 0,
+      "(14, 5)": 0,
+      "(14, 6)": 0,
+      "(14, 7)": 0,
+      "(14, 8)": 0,
+      "(14, 9)": 0,
+      "(14, 10)": 0,
+      "(14, 11)": 0,
+      "(14, 12)": 1,
+      "(14, 13)": 1,
+      "(14, 14)": 0,
+      "(14, 15)": 0,
+      "(14, 16)": 0,
+      "(14, 17)": 0,
+      "(14, 18)": 0,
+      "(14, 19)": 0,
+      "(14, 20)": 0,
+      "(15, 1)": 1,
+      "(15, 2)": 0,
+      "(15, 3)": 0,
+      "(15, 4)": 1,
+      "(15, 5)": 0,
+      "(15, 6)": 0,
+      "(15, 7)": 0,
+      "(15, 8)": 0,
+      "(15, 9)": 0,
+      "(15, 10)": 1,
+      "(15, 11)": 1,
+      "(15, 12)": 0,
+      "(15, 13)": 0,
+      "(15, 14)": 0,
+      "(15, 15)": 0,
+      "(15, 16)": 1,
+      "(15, 17)": 1,
+      "(15, 18)": 0,
+      "(15, 19)": 0,
+      "(15, 20)": 0,
+      "(16, 1)": 1,
+      "(16, 2)": 0,
+      "(16, 3)": 0,
+      "(16, 4)": 1,
+      "(16, 5)": 0,
+      "(16, 6)": 0,
+      "(16, 7)": 0,
+      "(16, 8)": 0,
+      "(16, 9)": 0,
+      "(16, 10)": 0,
+      "(16, 11)": 0,
+      "(16, 12)": 0,
+      "(16, 13)": 0,
+      "(16, 14)": 0,
+      "(16, 15)": 1,
+      "(16, 16)": 0,
+      "(16, 17)": 0,
+      "(16, 18)": 0,
+      "(16, 19)": 0,
+      "(16, 20)": 0,
+      "(17, 1)": 0,
+      "(17, 2)": 0,
+      "(17, 3)": 0,
+      "(17, 4)": 1,
+      "(17, 5)": 0,
+      "(17, 6)": 0,
+      "(17, 7)": 0,
+      "(17, 8)": 0,
+      "(17, 9)": 0,
+      "(17, 10)": 1,
+      "(17, 11)": 0,
+      "(17, 12)": 0,
+      "(17, 13)": 0,
+      "(17, 14)": 0,
+      "(17, 15)": 1,
+      "(17, 16)": 0,
+      "(17, 17)": 0,
+      "(17, 18)": 1,
+      "(17, 19)": 1,
+      "(17, 20)": 1,
+      "(18, 1)": 0,
+      "(18, 2)": 0,
+      "(18, 3)": 0,
+      "(18, 4)": 1,
+      "(18, 5)": 0,
+      "(18, 6)": 0,
+      "(18, 7)": 0,
+      "(18, 8)": 0,
+      "(18, 9)": 0,
+      "(18, 10)": 1,
+      "(18, 11)": 0,
+      "(18, 12)": 0,
+      "(18, 13)": 0,
+      "(18, 14)": 0,
+      "(18, 15)": 0,
+      "(18, 16)": 0,
+      "(18, 17)": 1,
+      "(18, 18)": 0,
+      "(18, 19)": 1,
+      "(18, 20)": 0,
+      "(19, 1)": 0,
+      "(19, 2)": 0,
+      "(19, 3)": 0,
+      "(19, 4)": 0,
+      "(19, 5)": 0,
+      "(19, 6)": 0,
+      "(19, 7)": 0,
+      "(19, 8)": 0,
+      "(19, 9)": 0,
+      "(19, 10)": 1,
+      "(19, 11)": 0,
+      "(19, 12)": 0,
+      "(19, 13)": 0,
+      "(19, 14)": 0,
+      "(19, 15)": 0,
+      "(19, 16)": 0,
+      "(19, 17)": 1,
+      "(19, 18)": 1,
+      "(19, 19)": 0,
+      "(19, 20)": 1,
+      "(20, 1)": 0,
+      "(20, 2)": 0,
+      "(20, 3)": 0,
+      "(20, 4)": 0,
+      "(20, 5)": 0,
+      "(20, 6)": 0,
+      "(20, 7)": 0,
+      "(20, 8)": 0,
+      "(20, 9)": 0,
+      "(20, 10)": 1,
+      "(20, 11)": 0,
+      "(20, 12)": 0,
+      "(20, 13)": 0,
+      "(20, 14)": 0,
+      "(20, 15)": 0,
+      "(20, 16)": 0,
+      "(20, 17)": 1,
+      "(20, 18)": 0,
+      "(20, 19)": 1,
+      "(20, 20)": 0
+    },
+    "max_utilization": {
+      "1": 0.8,
+      "2": 0.8,
+      "3": 0.8
+    },
+    "alpha": {
+      "(1, 1)": 0.767,
+      "(1, 2)": 0.715,
+      "(1, 3)": 0.653,
+      "(2, 1)": 0.767,
+      "(2, 2)": 0.715,
+      "(2, 3)": 0.653,
+      "(3, 1)": 0.767,
+      "(3, 2)": 0.715,
+      "(3, 3)": 0.653,
+      "(4, 1)": 0.767,
+      "(4, 2)": 0.715,
+      "(4, 3)": 0.653,
+      "(5, 1)": 0.767,
+      "(5, 2)": 0.715,
+      "(5, 3)": 0.653,
+      "(6, 1)": 0.767,
+      "(6, 2)": 0.715,
+      "(6, 3)": 0.653,
+      "(7, 1)": 0.767,
+      "(7, 2)": 0.715,
+      "(7, 3)": 0.653,
+      "(8, 1)": 0.767,
+      "(8, 2)": 0.715,
+      "(8, 3)": 0.653,
+      "(9, 1)": 0.767,
+      "(9, 2)": 0.715,
+      "(9, 3)": 0.653,
+      "(10, 1)": 0.767,
+      "(10, 2)": 0.715,
+      "(10, 3)": 0.653,
+      "(11, 1)": 0.767,
+      "(11, 2)": 0.715,
+      "(11, 3)": 0.653,
+      "(12, 1)": 0.767,
+      "(12, 2)": 0.715,
+      "(12, 3)": 0.653,
+      "(13, 1)": 0.767,
+      "(13, 2)": 0.715,
+      "(13, 3)": 0.653,
+      "(14, 1)": 0.767,
+      "(14, 2)": 0.715,
+      "(14, 3)": 0.653,
+      "(15, 1)": 0.767,
+      "(15, 2)": 0.715,
+      "(15, 3)": 0.653,
+      "(16, 1)": 0.767,
+      "(16, 2)": 0.715,
+      "(16, 3)": 0.653,
+      "(17, 1)": 0.767,
+      "(17, 2)": 0.715,
+      "(17, 3)": 0.653,
+      "(18, 1)": 0.767,
+      "(18, 2)": 0.715,
+      "(18, 3)": 0.653,
+      "(19, 1)": 0.767,
+      "(19, 2)": 0.715,
+      "(19, 3)": 0.653,
+      "(20, 1)": 0.767,
+      "(20, 2)": 0.715,
+      "(20, 3)": 0.653
+    },
+    "beta": {
+      "(1, 1, 1)": 0.5,
+      "(1, 1, 2)": 0.5,
+      "(1, 1, 3)": 0.5,
+      "(1, 2, 1)": 0.5,
+      "(1, 2, 2)": 0.5,
+      "(1, 2, 3)": 0.5,
+      "(1, 3, 1)": 0.5,
+      "(1, 3, 2)": 0.5,
+      "(1, 3, 3)": 0.5,
+      "(1, 4, 1)": 0.5,
+      "(1, 4, 2)": 0.5,
+      "(1, 4, 3)": 0.5,
+      "(1, 5, 1)": 0.5,
+      "(1, 5, 2)": 0.5,
+      "(1, 5, 3)": 0.5,
+      "(1, 6, 1)": 0.5,
+      "(1, 6, 2)": 0.5,
+      "(1, 6, 3)": 0.5,
+      "(1, 7, 1)": 0.5,
+      "(1, 7, 2)": 0.5,
+      "(1, 7, 3)": 0.5,
+      "(1, 8, 1)": 0.5,
+      "(1, 8, 2)": 0.5,
+      "(1, 8, 3)": 0.5,
+      "(1, 9, 1)": 0.5,
+      "(1, 9, 2)": 0.5,
+      "(1, 9, 3)": 0.5,
+      "(1, 10, 1)": 0.5,
+      "(1, 10, 2)": 0.5,
+      "(1, 10, 3)": 0.5,
+      "(1, 11, 1)": 0.5,
+      "(1, 11, 2)": 0.5,
+      "(1, 11, 3)": 0.5,
+      "(1, 12, 1)": 0.5,
+      "(1, 12, 2)": 0.5,
+      "(1, 12, 3)": 0.5,
+      "(1, 13, 1)": 0.5,
+      "(1, 13, 2)": 0.5,
+      "(1, 13, 3)": 0.5,
+      "(1, 14, 1)": 0.5,
+      "(1, 14, 2)": 0.5,
+      "(1, 14, 3)": 0.5,
+      "(1, 15, 1)": 0.5,
+      "(1, 15, 2)": 0.5,
+      "(1, 15, 3)": 0.5,
+      "(1, 16, 1)": 0.5,
+      "(1, 16, 2)": 0.5,
+      "(1, 16, 3)": 0.5,
+      "(1, 17, 1)": 0.5,
+      "(1, 17, 2)": 0.5,
+      "(1, 17, 3)": 0.5,
+      "(1, 18, 1)": 0.5,
+      "(1, 18, 2)": 0.5,
+      "(1, 18, 3)": 0.5,
+      "(1, 19, 1)": 0.5,
+      "(1, 19, 2)": 0.5,
+      "(1, 19, 3)": 0.5,
+      "(1, 20, 1)": 0.5,
+      "(1, 20, 2)": 0.5,
+      "(1, 20, 3)": 0.5,
+      "(2, 1, 1)": 0.5,
+      "(2, 1, 2)": 0.5,
+      "(2, 1, 3)": 0.5,
+      "(2, 2, 1)": 0.5,
+      "(2, 2, 2)": 0.5,
+      "(2, 2, 3)": 0.5,
+      "(2, 3, 1)": 0.5,
+      "(2, 3, 2)": 0.5,
+      "(2, 3, 3)": 0.5,
+      "(2, 4, 1)": 0.5,
+      "(2, 4, 2)": 0.5,
+      "(2, 4, 3)": 0.5,
+      "(2, 5, 1)": 0.5,
+      "(2, 5, 2)": 0.5,
+      "(2, 5, 3)": 0.5,
+      "(2, 6, 1)": 0.5,
+      "(2, 6, 2)": 0.5,
+      "(2, 6, 3)": 0.5,
+      "(2, 7, 1)": 0.5,
+      "(2, 7, 2)": 0.5,
+      "(2, 7, 3)": 0.5,
+      "(2, 8, 1)": 0.5,
+      "(2, 8, 2)": 0.5,
+      "(2, 8, 3)": 0.5,
+      "(2, 9, 1)": 0.5,
+      "(2, 9, 2)": 0.5,
+      "(2, 9, 3)": 0.5,
+      "(2, 10, 1)": 0.5,
+      "(2, 10, 2)": 0.5,
+      "(2, 10, 3)": 0.5,
+      "(2, 11, 1)": 0.5,
+      "(2, 11, 2)": 0.5,
+      "(2, 11, 3)": 0.5,
+      "(2, 12, 1)": 0.5,
+      "(2, 12, 2)": 0.5,
+      "(2, 12, 3)": 0.5,
+      "(2, 13, 1)": 0.5,
+      "(2, 13, 2)": 0.5,
+      "(2, 13, 3)": 0.5,
+      "(2, 14, 1)": 0.5,
+      "(2, 14, 2)": 0.5,
+      "(2, 14, 3)": 0.5,
+      "(2, 15, 1)": 0.5,
+      "(2, 15, 2)": 0.5,
+      "(2, 15, 3)": 0.5,
+      "(2, 16, 1)": 0.5,
+      "(2, 16, 2)": 0.5,
+      "(2, 16, 3)": 0.5,
+      "(2, 17, 1)": 0.5,
+      "(2, 17, 2)": 0.5,
+      "(2, 17, 3)": 0.5,
+      "(2, 18, 1)": 0.5,
+      "(2, 18, 2)": 0.5,
+      "(2, 18, 3)": 0.5,
+      "(2, 19, 1)": 0.5,
+      "(2, 19, 2)": 0.5,
+      "(2, 19, 3)": 0.5,
+      "(2, 20, 1)": 0.5,
+      "(2, 20, 2)": 0.5,
+      "(2, 20, 3)": 0.5,
+      "(3, 1, 1)": 0.5,
+      "(3, 1, 2)": 0.5,
+      "(3, 1, 3)": 0.5,
+      "(3, 2, 1)": 0.5,
+      "(3, 2, 2)": 0.5,
+      "(3, 2, 3)": 0.5,
+      "(3, 3, 1)": 0.5,
+      "(3, 3, 2)": 0.5,
+      "(3, 3, 3)": 0.5,
+      "(3, 4, 1)": 0.5,
+      "(3, 4, 2)": 0.5,
+      "(3, 4, 3)": 0.5,
+      "(3, 5, 1)": 0.5,
+      "(3, 5, 2)": 0.5,
+      "(3, 5, 3)": 0.5,
+      "(3, 6, 1)": 0.5,
+      "(3, 6, 2)": 0.5,
+      "(3, 6, 3)": 0.5,
+      "(3, 7, 1)": 0.5,
+      "(3, 7, 2)": 0.5,
+      "(3, 7, 3)": 0.5,
+      "(3, 8, 1)": 0.5,
+      "(3, 8, 2)": 0.5,
+      "(3, 8, 3)": 0.5,
+      "(3, 9, 1)": 0.5,
+      "(3, 9, 2)": 0.5,
+      "(3, 9, 3)": 0.5,
+      "(3, 10, 1)": 0.5,
+      "(3, 10, 2)": 0.5,
+      "(3, 10, 3)": 0.5,
+      "(3, 11, 1)": 0.5,
+      "(3, 11, 2)": 0.5,
+      "(3, 11, 3)": 0.5,
+      "(3, 12, 1)": 0.5,
+      "(3, 12, 2)": 0.5,
+      "(3, 12, 3)": 0.5,
+      "(3, 13, 1)": 0.5,
+      "(3, 13, 2)": 0.5,
+      "(3, 13, 3)": 0.5,
+      "(3, 14, 1)": 0.5,
+      "(3, 14, 2)": 0.5,
+      "(3, 14, 3)": 0.5,
+      "(3, 15, 1)": 0.5,
+      "(3, 15, 2)": 0.5,
+      "(3, 15, 3)": 0.5,
+      "(3, 16, 1)": 0.5,
+      "(3, 16, 2)": 0.5,
+      "(3, 16, 3)": 0.5,
+      "(3, 17, 1)": 0.5,
+      "(3, 17, 2)": 0.5,
+      "(3, 17, 3)": 0.5,
+      "(3, 18, 1)": 0.5,
+      "(3, 18, 2)": 0.5,
+      "(3, 18, 3)": 0.5,
+      "(3, 19, 1)": 0.5,
+      "(3, 19, 2)": 0.5,
+      "(3, 19, 3)": 0.5,
+      "(3, 20, 1)": 0.5,
+      "(3, 20, 2)": 0.5,
+      "(3, 20, 3)": 0.5,
+      "(4, 1, 1)": 0.5,
+      "(4, 1, 2)": 0.5,
+      "(4, 1, 3)": 0.5,
+      "(4, 2, 1)": 0.5,
+      "(4, 2, 2)": 0.5,
+      "(4, 2, 3)": 0.5,
+      "(4, 3, 1)": 0.5,
+      "(4, 3, 2)": 0.5,
+      "(4, 3, 3)": 0.5,
+      "(4, 4, 1)": 0.5,
+      "(4, 4, 2)": 0.5,
+      "(4, 4, 3)": 0.5,
+      "(4, 5, 1)": 0.5,
+      "(4, 5, 2)": 0.5,
+      "(4, 5, 3)": 0.5,
+      "(4, 6, 1)": 0.5,
+      "(4, 6, 2)": 0.5,
+      "(4, 6, 3)": 0.5,
+      "(4, 7, 1)": 0.5,
+      "(4, 7, 2)": 0.5,
+      "(4, 7, 3)": 0.5,
+      "(4, 8, 1)": 0.5,
+      "(4, 8, 2)": 0.5,
+      "(4, 8, 3)": 0.5,
+      "(4, 9, 1)": 0.5,
+      "(4, 9, 2)": 0.5,
+      "(4, 9, 3)": 0.5,
+      "(4, 10, 1)": 0.5,
+      "(4, 10, 2)": 0.5,
+      "(4, 10, 3)": 0.5,
+      "(4, 11, 1)": 0.5,
+      "(4, 11, 2)": 0.5,
+      "(4, 11, 3)": 0.5,
+      "(4, 12, 1)": 0.5,
+      "(4, 12, 2)": 0.5,
+      "(4, 12, 3)": 0.5,
+      "(4, 13, 1)": 0.5,
+      "(4, 13, 2)": 0.5,
+      "(4, 13, 3)": 0.5,
+      "(4, 14, 1)": 0.5,
+      "(4, 14, 2)": 0.5,
+      "(4, 14, 3)": 0.5,
+      "(4, 15, 1)": 0.5,
+      "(4, 15, 2)": 0.5,
+      "(4, 15, 3)": 0.5,
+      "(4, 16, 1)": 0.5,
+      "(4, 16, 2)": 0.5,
+      "(4, 16, 3)": 0.5,
+      "(4, 17, 1)": 0.5,
+      "(4, 17, 2)": 0.5,
+      "(4, 17, 3)": 0.5,
+      "(4, 18, 1)": 0.5,
+      "(4, 18, 2)": 0.5,
+      "(4, 18, 3)": 0.5,
+      "(4, 19, 1)": 0.5,
+      "(4, 19, 2)": 0.5,
+      "(4, 19, 3)": 0.5,
+      "(4, 20, 1)": 0.5,
+      "(4, 20, 2)": 0.5,
+      "(4, 20, 3)": 0.5,
+      "(5, 1, 1)": 0.5,
+      "(5, 1, 2)": 0.5,
+      "(5, 1, 3)": 0.5,
+      "(5, 2, 1)": 0.5,
+      "(5, 2, 2)": 0.5,
+      "(5, 2, 3)": 0.5,
+      "(5, 3, 1)": 0.5,
+      "(5, 3, 2)": 0.5,
+      "(5, 3, 3)": 0.5,
+      "(5, 4, 1)": 0.5,
+      "(5, 4, 2)": 0.5,
+      "(5, 4, 3)": 0.5,
+      "(5, 5, 1)": 0.5,
+      "(5, 5, 2)": 0.5,
+      "(5, 5, 3)": 0.5,
+      "(5, 6, 1)": 0.5,
+      "(5, 6, 2)": 0.5,
+      "(5, 6, 3)": 0.5,
+      "(5, 7, 1)": 0.5,
+      "(5, 7, 2)": 0.5,
+      "(5, 7, 3)": 0.5,
+      "(5, 8, 1)": 0.5,
+      "(5, 8, 2)": 0.5,
+      "(5, 8, 3)": 0.5,
+      "(5, 9, 1)": 0.5,
+      "(5, 9, 2)": 0.5,
+      "(5, 9, 3)": 0.5,
+      "(5, 10, 1)": 0.5,
+      "(5, 10, 2)": 0.5,
+      "(5, 10, 3)": 0.5,
+      "(5, 11, 1)": 0.5,
+      "(5, 11, 2)": 0.5,
+      "(5, 11, 3)": 0.5,
+      "(5, 12, 1)": 0.5,
+      "(5, 12, 2)": 0.5,
+      "(5, 12, 3)": 0.5,
+      "(5, 13, 1)": 0.5,
+      "(5, 13, 2)": 0.5,
+      "(5, 13, 3)": 0.5,
+      "(5, 14, 1)": 0.5,
+      "(5, 14, 2)": 0.5,
+      "(5, 14, 3)": 0.5,
+      "(5, 15, 1)": 0.5,
+      "(5, 15, 2)": 0.5,
+      "(5, 15, 3)": 0.5,
+      "(5, 16, 1)": 0.5,
+      "(5, 16, 2)": 0.5,
+      "(5, 16, 3)": 0.5,
+      "(5, 17, 1)": 0.5,
+      "(5, 17, 2)": 0.5,
+      "(5, 17, 3)": 0.5,
+      "(5, 18, 1)": 0.5,
+      "(5, 18, 2)": 0.5,
+      "(5, 18, 3)": 0.5,
+      "(5, 19, 1)": 0.5,
+      "(5, 19, 2)": 0.5,
+      "(5, 19, 3)": 0.5,
+      "(5, 20, 1)": 0.5,
+      "(5, 20, 2)": 0.5,
+      "(5, 20, 3)": 0.5,
+      "(6, 1, 1)": 0.5,
+      "(6, 1, 2)": 0.5,
+      "(6, 1, 3)": 0.5,
+      "(6, 2, 1)": 0.5,
+      "(6, 2, 2)": 0.5,
+      "(6, 2, 3)": 0.5,
+      "(6, 3, 1)": 0.5,
+      "(6, 3, 2)": 0.5,
+      "(6, 3, 3)": 0.5,
+      "(6, 4, 1)": 0.5,
+      "(6, 4, 2)": 0.5,
+      "(6, 4, 3)": 0.5,
+      "(6, 5, 1)": 0.5,
+      "(6, 5, 2)": 0.5,
+      "(6, 5, 3)": 0.5,
+      "(6, 6, 1)": 0.5,
+      "(6, 6, 2)": 0.5,
+      "(6, 6, 3)": 0.5,
+      "(6, 7, 1)": 0.5,
+      "(6, 7, 2)": 0.5,
+      "(6, 7, 3)": 0.5,
+      "(6, 8, 1)": 0.5,
+      "(6, 8, 2)": 0.5,
+      "(6, 8, 3)": 0.5,
+      "(6, 9, 1)": 0.5,
+      "(6, 9, 2)": 0.5,
+      "(6, 9, 3)": 0.5,
+      "(6, 10, 1)": 0.5,
+      "(6, 10, 2)": 0.5,
+      "(6, 10, 3)": 0.5,
+      "(6, 11, 1)": 0.5,
+      "(6, 11, 2)": 0.5,
+      "(6, 11, 3)": 0.5,
+      "(6, 12, 1)": 0.5,
+      "(6, 12, 2)": 0.5,
+      "(6, 12, 3)": 0.5,
+      "(6, 13, 1)": 0.5,
+      "(6, 13, 2)": 0.5,
+      "(6, 13, 3)": 0.5,
+      "(6, 14, 1)": 0.5,
+      "(6, 14, 2)": 0.5,
+      "(6, 14, 3)": 0.5,
+      "(6, 15, 1)": 0.5,
+      "(6, 15, 2)": 0.5,
+      "(6, 15, 3)": 0.5,
+      "(6, 16, 1)": 0.5,
+      "(6, 16, 2)": 0.5,
+      "(6, 16, 3)": 0.5,
+      "(6, 17, 1)": 0.5,
+      "(6, 17, 2)": 0.5,
+      "(6, 17, 3)": 0.5,
+      "(6, 18, 1)": 0.5,
+      "(6, 18, 2)": 0.5,
+      "(6, 18, 3)": 0.5,
+      "(6, 19, 1)": 0.5,
+      "(6, 19, 2)": 0.5,
+      "(6, 19, 3)": 0.5,
+      "(6, 20, 1)": 0.5,
+      "(6, 20, 2)": 0.5,
+      "(6, 20, 3)": 0.5,
+      "(7, 1, 1)": 0.5,
+      "(7, 1, 2)": 0.5,
+      "(7, 1, 3)": 0.5,
+      "(7, 2, 1)": 0.5,
+      "(7, 2, 2)": 0.5,
+      "(7, 2, 3)": 0.5,
+      "(7, 3, 1)": 0.5,
+      "(7, 3, 2)": 0.5,
+      "(7, 3, 3)": 0.5,
+      "(7, 4, 1)": 0.5,
+      "(7, 4, 2)": 0.5,
+      "(7, 4, 3)": 0.5,
+      "(7, 5, 1)": 0.5,
+      "(7, 5, 2)": 0.5,
+      "(7, 5, 3)": 0.5,
+      "(7, 6, 1)": 0.5,
+      "(7, 6, 2)": 0.5,
+      "(7, 6, 3)": 0.5,
+      "(7, 7, 1)": 0.5,
+      "(7, 7, 2)": 0.5,
+      "(7, 7, 3)": 0.5,
+      "(7, 8, 1)": 0.5,
+      "(7, 8, 2)": 0.5,
+      "(7, 8, 3)": 0.5,
+      "(7, 9, 1)": 0.5,
+      "(7, 9, 2)": 0.5,
+      "(7, 9, 3)": 0.5,
+      "(7, 10, 1)": 0.5,
+      "(7, 10, 2)": 0.5,
+      "(7, 10, 3)": 0.5,
+      "(7, 11, 1)": 0.5,
+      "(7, 11, 2)": 0.5,
+      "(7, 11, 3)": 0.5,
+      "(7, 12, 1)": 0.5,
+      "(7, 12, 2)": 0.5,
+      "(7, 12, 3)": 0.5,
+      "(7, 13, 1)": 0.5,
+      "(7, 13, 2)": 0.5,
+      "(7, 13, 3)": 0.5,
+      "(7, 14, 1)": 0.5,
+      "(7, 14, 2)": 0.5,
+      "(7, 14, 3)": 0.5,
+      "(7, 15, 1)": 0.5,
+      "(7, 15, 2)": 0.5,
+      "(7, 15, 3)": 0.5,
+      "(7, 16, 1)": 0.5,
+      "(7, 16, 2)": 0.5,
+      "(7, 16, 3)": 0.5,
+      "(7, 17, 1)": 0.5,
+      "(7, 17, 2)": 0.5,
+      "(7, 17, 3)": 0.5,
+      "(7, 18, 1)": 0.5,
+      "(7, 18, 2)": 0.5,
+      "(7, 18, 3)": 0.5,
+      "(7, 19, 1)": 0.5,
+      "(7, 19, 2)": 0.5,
+      "(7, 19, 3)": 0.5,
+      "(7, 20, 1)": 0.5,
+      "(7, 20, 2)": 0.5,
+      "(7, 20, 3)": 0.5,
+      "(8, 1, 1)": 0.5,
+      "(8, 1, 2)": 0.5,
+      "(8, 1, 3)": 0.5,
+      "(8, 2, 1)": 0.5,
+      "(8, 2, 2)": 0.5,
+      "(8, 2, 3)": 0.5,
+      "(8, 3, 1)": 0.5,
+      "(8, 3, 2)": 0.5,
+      "(8, 3, 3)": 0.5,
+      "(8, 4, 1)": 0.5,
+      "(8, 4, 2)": 0.5,
+      "(8, 4, 3)": 0.5,
+      "(8, 5, 1)": 0.5,
+      "(8, 5, 2)": 0.5,
+      "(8, 5, 3)": 0.5,
+      "(8, 6, 1)": 0.5,
+      "(8, 6, 2)": 0.5,
+      "(8, 6, 3)": 0.5,
+      "(8, 7, 1)": 0.5,
+      "(8, 7, 2)": 0.5,
+      "(8, 7, 3)": 0.5,
+      "(8, 8, 1)": 0.5,
+      "(8, 8, 2)": 0.5,
+      "(8, 8, 3)": 0.5,
+      "(8, 9, 1)": 0.5,
+      "(8, 9, 2)": 0.5,
+      "(8, 9, 3)": 0.5,
+      "(8, 10, 1)": 0.5,
+      "(8, 10, 2)": 0.5,
+      "(8, 10, 3)": 0.5,
+      "(8, 11, 1)": 0.5,
+      "(8, 11, 2)": 0.5,
+      "(8, 11, 3)": 0.5,
+      "(8, 12, 1)": 0.5,
+      "(8, 12, 2)": 0.5,
+      "(8, 12, 3)": 0.5,
+      "(8, 13, 1)": 0.5,
+      "(8, 13, 2)": 0.5,
+      "(8, 13, 3)": 0.5,
+      "(8, 14, 1)": 0.5,
+      "(8, 14, 2)": 0.5,
+      "(8, 14, 3)": 0.5,
+      "(8, 15, 1)": 0.5,
+      "(8, 15, 2)": 0.5,
+      "(8, 15, 3)": 0.5,
+      "(8, 16, 1)": 0.5,
+      "(8, 16, 2)": 0.5,
+      "(8, 16, 3)": 0.5,
+      "(8, 17, 1)": 0.5,
+      "(8, 17, 2)": 0.5,
+      "(8, 17, 3)": 0.5,
+      "(8, 18, 1)": 0.5,
+      "(8, 18, 2)": 0.5,
+      "(8, 18, 3)": 0.5,
+      "(8, 19, 1)": 0.5,
+      "(8, 19, 2)": 0.5,
+      "(8, 19, 3)": 0.5,
+      "(8, 20, 1)": 0.5,
+      "(8, 20, 2)": 0.5,
+      "(8, 20, 3)": 0.5,
+      "(9, 1, 1)": 0.5,
+      "(9, 1, 2)": 0.5,
+      "(9, 1, 3)": 0.5,
+      "(9, 2, 1)": 0.5,
+      "(9, 2, 2)": 0.5,
+      "(9, 2, 3)": 0.5,
+      "(9, 3, 1)": 0.5,
+      "(9, 3, 2)": 0.5,
+      "(9, 3, 3)": 0.5,
+      "(9, 4, 1)": 0.5,
+      "(9, 4, 2)": 0.5,
+      "(9, 4, 3)": 0.5,
+      "(9, 5, 1)": 0.5,
+      "(9, 5, 2)": 0.5,
+      "(9, 5, 3)": 0.5,
+      "(9, 6, 1)": 0.5,
+      "(9, 6, 2)": 0.5,
+      "(9, 6, 3)": 0.5,
+      "(9, 7, 1)": 0.5,
+      "(9, 7, 2)": 0.5,
+      "(9, 7, 3)": 0.5,
+      "(9, 8, 1)": 0.5,
+      "(9, 8, 2)": 0.5,
+      "(9, 8, 3)": 0.5,
+      "(9, 9, 1)": 0.5,
+      "(9, 9, 2)": 0.5,
+      "(9, 9, 3)": 0.5,
+      "(9, 10, 1)": 0.5,
+      "(9, 10, 2)": 0.5,
+      "(9, 10, 3)": 0.5,
+      "(9, 11, 1)": 0.5,
+      "(9, 11, 2)": 0.5,
+      "(9, 11, 3)": 0.5,
+      "(9, 12, 1)": 0.5,
+      "(9, 12, 2)": 0.5,
+      "(9, 12, 3)": 0.5,
+      "(9, 13, 1)": 0.5,
+      "(9, 13, 2)": 0.5,
+      "(9, 13, 3)": 0.5,
+      "(9, 14, 1)": 0.5,
+      "(9, 14, 2)": 0.5,
+      "(9, 14, 3)": 0.5,
+      "(9, 15, 1)": 0.5,
+      "(9, 15, 2)": 0.5,
+      "(9, 15, 3)": 0.5,
+      "(9, 16, 1)": 0.5,
+      "(9, 16, 2)": 0.5,
+      "(9, 16, 3)": 0.5,
+      "(9, 17, 1)": 0.5,
+      "(9, 17, 2)": 0.5,
+      "(9, 17, 3)": 0.5,
+      "(9, 18, 1)": 0.5,
+      "(9, 18, 2)": 0.5,
+      "(9, 18, 3)": 0.5,
+      "(9, 19, 1)": 0.5,
+      "(9, 19, 2)": 0.5,
+      "(9, 19, 3)": 0.5,
+      "(9, 20, 1)": 0.5,
+      "(9, 20, 2)": 0.5,
+      "(9, 20, 3)": 0.5,
+      "(10, 1, 1)": 0.5,
+      "(10, 1, 2)": 0.5,
+      "(10, 1, 3)": 0.5,
+      "(10, 2, 1)": 0.5,
+      "(10, 2, 2)": 0.5,
+      "(10, 2, 3)": 0.5,
+      "(10, 3, 1)": 0.5,
+      "(10, 3, 2)": 0.5,
+      "(10, 3, 3)": 0.5,
+      "(10, 4, 1)": 0.5,
+      "(10, 4, 2)": 0.5,
+      "(10, 4, 3)": 0.5,
+      "(10, 5, 1)": 0.5,
+      "(10, 5, 2)": 0.5,
+      "(10, 5, 3)": 0.5,
+      "(10, 6, 1)": 0.5,
+      "(10, 6, 2)": 0.5,
+      "(10, 6, 3)": 0.5,
+      "(10, 7, 1)": 0.5,
+      "(10, 7, 2)": 0.5,
+      "(10, 7, 3)": 0.5,
+      "(10, 8, 1)": 0.5,
+      "(10, 8, 2)": 0.5,
+      "(10, 8, 3)": 0.5,
+      "(10, 9, 1)": 0.5,
+      "(10, 9, 2)": 0.5,
+      "(10, 9, 3)": 0.5,
+      "(10, 10, 1)": 0.5,
+      "(10, 10, 2)": 0.5,
+      "(10, 10, 3)": 0.5,
+      "(10, 11, 1)": 0.5,
+      "(10, 11, 2)": 0.5,
+      "(10, 11, 3)": 0.5,
+      "(10, 12, 1)": 0.5,
+      "(10, 12, 2)": 0.5,
+      "(10, 12, 3)": 0.5,
+      "(10, 13, 1)": 0.5,
+      "(10, 13, 2)": 0.5,
+      "(10, 13, 3)": 0.5,
+      "(10, 14, 1)": 0.5,
+      "(10, 14, 2)": 0.5,
+      "(10, 14, 3)": 0.5,
+      "(10, 15, 1)": 0.5,
+      "(10, 15, 2)": 0.5,
+      "(10, 15, 3)": 0.5,
+      "(10, 16, 1)": 0.5,
+      "(10, 16, 2)": 0.5,
+      "(10, 16, 3)": 0.5,
+      "(10, 17, 1)": 0.5,
+      "(10, 17, 2)": 0.5,
+      "(10, 17, 3)": 0.5,
+      "(10, 18, 1)": 0.5,
+      "(10, 18, 2)": 0.5,
+      "(10, 18, 3)": 0.5,
+      "(10, 19, 1)": 0.5,
+      "(10, 19, 2)": 0.5,
+      "(10, 19, 3)": 0.5,
+      "(10, 20, 1)": 0.5,
+      "(10, 20, 2)": 0.5,
+      "(10, 20, 3)": 0.5,
+      "(11, 1, 1)": 0.5,
+      "(11, 1, 2)": 0.5,
+      "(11, 1, 3)": 0.5,
+      "(11, 2, 1)": 0.5,
+      "(11, 2, 2)": 0.5,
+      "(11, 2, 3)": 0.5,
+      "(11, 3, 1)": 0.5,
+      "(11, 3, 2)": 0.5,
+      "(11, 3, 3)": 0.5,
+      "(11, 4, 1)": 0.5,
+      "(11, 4, 2)": 0.5,
+      "(11, 4, 3)": 0.5,
+      "(11, 5, 1)": 0.5,
+      "(11, 5, 2)": 0.5,
+      "(11, 5, 3)": 0.5,
+      "(11, 6, 1)": 0.5,
+      "(11, 6, 2)": 0.5,
+      "(11, 6, 3)": 0.5,
+      "(11, 7, 1)": 0.5,
+      "(11, 7, 2)": 0.5,
+      "(11, 7, 3)": 0.5,
+      "(11, 8, 1)": 0.5,
+      "(11, 8, 2)": 0.5,
+      "(11, 8, 3)": 0.5,
+      "(11, 9, 1)": 0.5,
+      "(11, 9, 2)": 0.5,
+      "(11, 9, 3)": 0.5,
+      "(11, 10, 1)": 0.5,
+      "(11, 10, 2)": 0.5,
+      "(11, 10, 3)": 0.5,
+      "(11, 11, 1)": 0.5,
+      "(11, 11, 2)": 0.5,
+      "(11, 11, 3)": 0.5,
+      "(11, 12, 1)": 0.5,
+      "(11, 12, 2)": 0.5,
+      "(11, 12, 3)": 0.5,
+      "(11, 13, 1)": 0.5,
+      "(11, 13, 2)": 0.5,
+      "(11, 13, 3)": 0.5,
+      "(11, 14, 1)": 0.5,
+      "(11, 14, 2)": 0.5,
+      "(11, 14, 3)": 0.5,
+      "(11, 15, 1)": 0.5,
+      "(11, 15, 2)": 0.5,
+      "(11, 15, 3)": 0.5,
+      "(11, 16, 1)": 0.5,
+      "(11, 16, 2)": 0.5,
+      "(11, 16, 3)": 0.5,
+      "(11, 17, 1)": 0.5,
+      "(11, 17, 2)": 0.5,
+      "(11, 17, 3)": 0.5,
+      "(11, 18, 1)": 0.5,
+      "(11, 18, 2)": 0.5,
+      "(11, 18, 3)": 0.5,
+      "(11, 19, 1)": 0.5,
+      "(11, 19, 2)": 0.5,
+      "(11, 19, 3)": 0.5,
+      "(11, 20, 1)": 0.5,
+      "(11, 20, 2)": 0.5,
+      "(11, 20, 3)": 0.5,
+      "(12, 1, 1)": 0.5,
+      "(12, 1, 2)": 0.5,
+      "(12, 1, 3)": 0.5,
+      "(12, 2, 1)": 0.5,
+      "(12, 2, 2)": 0.5,
+      "(12, 2, 3)": 0.5,
+      "(12, 3, 1)": 0.5,
+      "(12, 3, 2)": 0.5,
+      "(12, 3, 3)": 0.5,
+      "(12, 4, 1)": 0.5,
+      "(12, 4, 2)": 0.5,
+      "(12, 4, 3)": 0.5,
+      "(12, 5, 1)": 0.5,
+      "(12, 5, 2)": 0.5,
+      "(12, 5, 3)": 0.5,
+      "(12, 6, 1)": 0.5,
+      "(12, 6, 2)": 0.5,
+      "(12, 6, 3)": 0.5,
+      "(12, 7, 1)": 0.5,
+      "(12, 7, 2)": 0.5,
+      "(12, 7, 3)": 0.5,
+      "(12, 8, 1)": 0.5,
+      "(12, 8, 2)": 0.5,
+      "(12, 8, 3)": 0.5,
+      "(12, 9, 1)": 0.5,
+      "(12, 9, 2)": 0.5,
+      "(12, 9, 3)": 0.5,
+      "(12, 10, 1)": 0.5,
+      "(12, 10, 2)": 0.5,
+      "(12, 10, 3)": 0.5,
+      "(12, 11, 1)": 0.5,
+      "(12, 11, 2)": 0.5,
+      "(12, 11, 3)": 0.5,
+      "(12, 12, 1)": 0.5,
+      "(12, 12, 2)": 0.5,
+      "(12, 12, 3)": 0.5,
+      "(12, 13, 1)": 0.5,
+      "(12, 13, 2)": 0.5,
+      "(12, 13, 3)": 0.5,
+      "(12, 14, 1)": 0.5,
+      "(12, 14, 2)": 0.5,
+      "(12, 14, 3)": 0.5,
+      "(12, 15, 1)": 0.5,
+      "(12, 15, 2)": 0.5,
+      "(12, 15, 3)": 0.5,
+      "(12, 16, 1)": 0.5,
+      "(12, 16, 2)": 0.5,
+      "(12, 16, 3)": 0.5,
+      "(12, 17, 1)": 0.5,
+      "(12, 17, 2)": 0.5,
+      "(12, 17, 3)": 0.5,
+      "(12, 18, 1)": 0.5,
+      "(12, 18, 2)": 0.5,
+      "(12, 18, 3)": 0.5,
+      "(12, 19, 1)": 0.5,
+      "(12, 19, 2)": 0.5,
+      "(12, 19, 3)": 0.5,
+      "(12, 20, 1)": 0.5,
+      "(12, 20, 2)": 0.5,
+      "(12, 20, 3)": 0.5,
+      "(13, 1, 1)": 0.5,
+      "(13, 1, 2)": 0.5,
+      "(13, 1, 3)": 0.5,
+      "(13, 2, 1)": 0.5,
+      "(13, 2, 2)": 0.5,
+      "(13, 2, 3)": 0.5,
+      "(13, 3, 1)": 0.5,
+      "(13, 3, 2)": 0.5,
+      "(13, 3, 3)": 0.5,
+      "(13, 4, 1)": 0.5,
+      "(13, 4, 2)": 0.5,
+      "(13, 4, 3)": 0.5,
+      "(13, 5, 1)": 0.5,
+      "(13, 5, 2)": 0.5,
+      "(13, 5, 3)": 0.5,
+      "(13, 6, 1)": 0.5,
+      "(13, 6, 2)": 0.5,
+      "(13, 6, 3)": 0.5,
+      "(13, 7, 1)": 0.5,
+      "(13, 7, 2)": 0.5,
+      "(13, 7, 3)": 0.5,
+      "(13, 8, 1)": 0.5,
+      "(13, 8, 2)": 0.5,
+      "(13, 8, 3)": 0.5,
+      "(13, 9, 1)": 0.5,
+      "(13, 9, 2)": 0.5,
+      "(13, 9, 3)": 0.5,
+      "(13, 10, 1)": 0.5,
+      "(13, 10, 2)": 0.5,
+      "(13, 10, 3)": 0.5,
+      "(13, 11, 1)": 0.5,
+      "(13, 11, 2)": 0.5,
+      "(13, 11, 3)": 0.5,
+      "(13, 12, 1)": 0.5,
+      "(13, 12, 2)": 0.5,
+      "(13, 12, 3)": 0.5,
+      "(13, 13, 1)": 0.5,
+      "(13, 13, 2)": 0.5,
+      "(13, 13, 3)": 0.5,
+      "(13, 14, 1)": 0.5,
+      "(13, 14, 2)": 0.5,
+      "(13, 14, 3)": 0.5,
+      "(13, 15, 1)": 0.5,
+      "(13, 15, 2)": 0.5,
+      "(13, 15, 3)": 0.5,
+      "(13, 16, 1)": 0.5,
+      "(13, 16, 2)": 0.5,
+      "(13, 16, 3)": 0.5,
+      "(13, 17, 1)": 0.5,
+      "(13, 17, 2)": 0.5,
+      "(13, 17, 3)": 0.5,
+      "(13, 18, 1)": 0.5,
+      "(13, 18, 2)": 0.5,
+      "(13, 18, 3)": 0.5,
+      "(13, 19, 1)": 0.5,
+      "(13, 19, 2)": 0.5,
+      "(13, 19, 3)": 0.5,
+      "(13, 20, 1)": 0.5,
+      "(13, 20, 2)": 0.5,
+      "(13, 20, 3)": 0.5,
+      "(14, 1, 1)": 0.5,
+      "(14, 1, 2)": 0.5,
+      "(14, 1, 3)": 0.5,
+      "(14, 2, 1)": 0.5,
+      "(14, 2, 2)": 0.5,
+      "(14, 2, 3)": 0.5,
+      "(14, 3, 1)": 0.5,
+      "(14, 3, 2)": 0.5,
+      "(14, 3, 3)": 0.5,
+      "(14, 4, 1)": 0.5,
+      "(14, 4, 2)": 0.5,
+      "(14, 4, 3)": 0.5,
+      "(14, 5, 1)": 0.5,
+      "(14, 5, 2)": 0.5,
+      "(14, 5, 3)": 0.5,
+      "(14, 6, 1)": 0.5,
+      "(14, 6, 2)": 0.5,
+      "(14, 6, 3)": 0.5,
+      "(14, 7, 1)": 0.5,
+      "(14, 7, 2)": 0.5,
+      "(14, 7, 3)": 0.5,
+      "(14, 8, 1)": 0.5,
+      "(14, 8, 2)": 0.5,
+      "(14, 8, 3)": 0.5,
+      "(14, 9, 1)": 0.5,
+      "(14, 9, 2)": 0.5,
+      "(14, 9, 3)": 0.5,
+      "(14, 10, 1)": 0.5,
+      "(14, 10, 2)": 0.5,
+      "(14, 10, 3)": 0.5,
+      "(14, 11, 1)": 0.5,
+      "(14, 11, 2)": 0.5,
+      "(14, 11, 3)": 0.5,
+      "(14, 12, 1)": 0.5,
+      "(14, 12, 2)": 0.5,
+      "(14, 12, 3)": 0.5,
+      "(14, 13, 1)": 0.5,
+      "(14, 13, 2)": 0.5,
+      "(14, 13, 3)": 0.5,
+      "(14, 14, 1)": 0.5,
+      "(14, 14, 2)": 0.5,
+      "(14, 14, 3)": 0.5,
+      "(14, 15, 1)": 0.5,
+      "(14, 15, 2)": 0.5,
+      "(14, 15, 3)": 0.5,
+      "(14, 16, 1)": 0.5,
+      "(14, 16, 2)": 0.5,
+      "(14, 16, 3)": 0.5,
+      "(14, 17, 1)": 0.5,
+      "(14, 17, 2)": 0.5,
+      "(14, 17, 3)": 0.5,
+      "(14, 18, 1)": 0.5,
+      "(14, 18, 2)": 0.5,
+      "(14, 18, 3)": 0.5,
+      "(14, 19, 1)": 0.5,
+      "(14, 19, 2)": 0.5,
+      "(14, 19, 3)": 0.5,
+      "(14, 20, 1)": 0.5,
+      "(14, 20, 2)": 0.5,
+      "(14, 20, 3)": 0.5,
+      "(15, 1, 1)": 0.5,
+      "(15, 1, 2)": 0.5,
+      "(15, 1, 3)": 0.5,
+      "(15, 2, 1)": 0.5,
+      "(15, 2, 2)": 0.5,
+      "(15, 2, 3)": 0.5,
+      "(15, 3, 1)": 0.5,
+      "(15, 3, 2)": 0.5,
+      "(15, 3, 3)": 0.5,
+      "(15, 4, 1)": 0.5,
+      "(15, 4, 2)": 0.5,
+      "(15, 4, 3)": 0.5,
+      "(15, 5, 1)": 0.5,
+      "(15, 5, 2)": 0.5,
+      "(15, 5, 3)": 0.5,
+      "(15, 6, 1)": 0.5,
+      "(15, 6, 2)": 0.5,
+      "(15, 6, 3)": 0.5,
+      "(15, 7, 1)": 0.5,
+      "(15, 7, 2)": 0.5,
+      "(15, 7, 3)": 0.5,
+      "(15, 8, 1)": 0.5,
+      "(15, 8, 2)": 0.5,
+      "(15, 8, 3)": 0.5,
+      "(15, 9, 1)": 0.5,
+      "(15, 9, 2)": 0.5,
+      "(15, 9, 3)": 0.5,
+      "(15, 10, 1)": 0.5,
+      "(15, 10, 2)": 0.5,
+      "(15, 10, 3)": 0.5,
+      "(15, 11, 1)": 0.5,
+      "(15, 11, 2)": 0.5,
+      "(15, 11, 3)": 0.5,
+      "(15, 12, 1)": 0.5,
+      "(15, 12, 2)": 0.5,
+      "(15, 12, 3)": 0.5,
+      "(15, 13, 1)": 0.5,
+      "(15, 13, 2)": 0.5,
+      "(15, 13, 3)": 0.5,
+      "(15, 14, 1)": 0.5,
+      "(15, 14, 2)": 0.5,
+      "(15, 14, 3)": 0.5,
+      "(15, 15, 1)": 0.5,
+      "(15, 15, 2)": 0.5,
+      "(15, 15, 3)": 0.5,
+      "(15, 16, 1)": 0.5,
+      "(15, 16, 2)": 0.5,
+      "(15, 16, 3)": 0.5,
+      "(15, 17, 1)": 0.5,
+      "(15, 17, 2)": 0.5,
+      "(15, 17, 3)": 0.5,
+      "(15, 18, 1)": 0.5,
+      "(15, 18, 2)": 0.5,
+      "(15, 18, 3)": 0.5,
+      "(15, 19, 1)": 0.5,
+      "(15, 19, 2)": 0.5,
+      "(15, 19, 3)": 0.5,
+      "(15, 20, 1)": 0.5,
+      "(15, 20, 2)": 0.5,
+      "(15, 20, 3)": 0.5,
+      "(16, 1, 1)": 0.5,
+      "(16, 1, 2)": 0.5,
+      "(16, 1, 3)": 0.5,
+      "(16, 2, 1)": 0.5,
+      "(16, 2, 2)": 0.5,
+      "(16, 2, 3)": 0.5,
+      "(16, 3, 1)": 0.5,
+      "(16, 3, 2)": 0.5,
+      "(16, 3, 3)": 0.5,
+      "(16, 4, 1)": 0.5,
+      "(16, 4, 2)": 0.5,
+      "(16, 4, 3)": 0.5,
+      "(16, 5, 1)": 0.5,
+      "(16, 5, 2)": 0.5,
+      "(16, 5, 3)": 0.5,
+      "(16, 6, 1)": 0.5,
+      "(16, 6, 2)": 0.5,
+      "(16, 6, 3)": 0.5,
+      "(16, 7, 1)": 0.5,
+      "(16, 7, 2)": 0.5,
+      "(16, 7, 3)": 0.5,
+      "(16, 8, 1)": 0.5,
+      "(16, 8, 2)": 0.5,
+      "(16, 8, 3)": 0.5,
+      "(16, 9, 1)": 0.5,
+      "(16, 9, 2)": 0.5,
+      "(16, 9, 3)": 0.5,
+      "(16, 10, 1)": 0.5,
+      "(16, 10, 2)": 0.5,
+      "(16, 10, 3)": 0.5,
+      "(16, 11, 1)": 0.5,
+      "(16, 11, 2)": 0.5,
+      "(16, 11, 3)": 0.5,
+      "(16, 12, 1)": 0.5,
+      "(16, 12, 2)": 0.5,
+      "(16, 12, 3)": 0.5,
+      "(16, 13, 1)": 0.5,
+      "(16, 13, 2)": 0.5,
+      "(16, 13, 3)": 0.5,
+      "(16, 14, 1)": 0.5,
+      "(16, 14, 2)": 0.5,
+      "(16, 14, 3)": 0.5,
+      "(16, 15, 1)": 0.5,
+      "(16, 15, 2)": 0.5,
+      "(16, 15, 3)": 0.5,
+      "(16, 16, 1)": 0.5,
+      "(16, 16, 2)": 0.5,
+      "(16, 16, 3)": 0.5,
+      "(16, 17, 1)": 0.5,
+      "(16, 17, 2)": 0.5,
+      "(16, 17, 3)": 0.5,
+      "(16, 18, 1)": 0.5,
+      "(16, 18, 2)": 0.5,
+      "(16, 18, 3)": 0.5,
+      "(16, 19, 1)": 0.5,
+      "(16, 19, 2)": 0.5,
+      "(16, 19, 3)": 0.5,
+      "(16, 20, 1)": 0.5,
+      "(16, 20, 2)": 0.5,
+      "(16, 20, 3)": 0.5,
+      "(17, 1, 1)": 0.5,
+      "(17, 1, 2)": 0.5,
+      "(17, 1, 3)": 0.5,
+      "(17, 2, 1)": 0.5,
+      "(17, 2, 2)": 0.5,
+      "(17, 2, 3)": 0.5,
+      "(17, 3, 1)": 0.5,
+      "(17, 3, 2)": 0.5,
+      "(17, 3, 3)": 0.5,
+      "(17, 4, 1)": 0.5,
+      "(17, 4, 2)": 0.5,
+      "(17, 4, 3)": 0.5,
+      "(17, 5, 1)": 0.5,
+      "(17, 5, 2)": 0.5,
+      "(17, 5, 3)": 0.5,
+      "(17, 6, 1)": 0.5,
+      "(17, 6, 2)": 0.5,
+      "(17, 6, 3)": 0.5,
+      "(17, 7, 1)": 0.5,
+      "(17, 7, 2)": 0.5,
+      "(17, 7, 3)": 0.5,
+      "(17, 8, 1)": 0.5,
+      "(17, 8, 2)": 0.5,
+      "(17, 8, 3)": 0.5,
+      "(17, 9, 1)": 0.5,
+      "(17, 9, 2)": 0.5,
+      "(17, 9, 3)": 0.5,
+      "(17, 10, 1)": 0.5,
+      "(17, 10, 2)": 0.5,
+      "(17, 10, 3)": 0.5,
+      "(17, 11, 1)": 0.5,
+      "(17, 11, 2)": 0.5,
+      "(17, 11, 3)": 0.5,
+      "(17, 12, 1)": 0.5,
+      "(17, 12, 2)": 0.5,
+      "(17, 12, 3)": 0.5,
+      "(17, 13, 1)": 0.5,
+      "(17, 13, 2)": 0.5,
+      "(17, 13, 3)": 0.5,
+      "(17, 14, 1)": 0.5,
+      "(17, 14, 2)": 0.5,
+      "(17, 14, 3)": 0.5,
+      "(17, 15, 1)": 0.5,
+      "(17, 15, 2)": 0.5,
+      "(17, 15, 3)": 0.5,
+      "(17, 16, 1)": 0.5,
+      "(17, 16, 2)": 0.5,
+      "(17, 16, 3)": 0.5,
+      "(17, 17, 1)": 0.5,
+      "(17, 17, 2)": 0.5,
+      "(17, 17, 3)": 0.5,
+      "(17, 18, 1)": 0.5,
+      "(17, 18, 2)": 0.5,
+      "(17, 18, 3)": 0.5,
+      "(17, 19, 1)": 0.5,
+      "(17, 19, 2)": 0.5,
+      "(17, 19, 3)": 0.5,
+      "(17, 20, 1)": 0.5,
+      "(17, 20, 2)": 0.5,
+      "(17, 20, 3)": 0.5,
+      "(18, 1, 1)": 0.5,
+      "(18, 1, 2)": 0.5,
+      "(18, 1, 3)": 0.5,
+      "(18, 2, 1)": 0.5,
+      "(18, 2, 2)": 0.5,
+      "(18, 2, 3)": 0.5,
+      "(18, 3, 1)": 0.5,
+      "(18, 3, 2)": 0.5,
+      "(18, 3, 3)": 0.5,
+      "(18, 4, 1)": 0.5,
+      "(18, 4, 2)": 0.5,
+      "(18, 4, 3)": 0.5,
+      "(18, 5, 1)": 0.5,
+      "(18, 5, 2)": 0.5,
+      "(18, 5, 3)": 0.5,
+      "(18, 6, 1)": 0.5,
+      "(18, 6, 2)": 0.5,
+      "(18, 6, 3)": 0.5,
+      "(18, 7, 1)": 0.5,
+      "(18, 7, 2)": 0.5,
+      "(18, 7, 3)": 0.5,
+      "(18, 8, 1)": 0.5,
+      "(18, 8, 2)": 0.5,
+      "(18, 8, 3)": 0.5,
+      "(18, 9, 1)": 0.5,
+      "(18, 9, 2)": 0.5,
+      "(18, 9, 3)": 0.5,
+      "(18, 10, 1)": 0.5,
+      "(18, 10, 2)": 0.5,
+      "(18, 10, 3)": 0.5,
+      "(18, 11, 1)": 0.5,
+      "(18, 11, 2)": 0.5,
+      "(18, 11, 3)": 0.5,
+      "(18, 12, 1)": 0.5,
+      "(18, 12, 2)": 0.5,
+      "(18, 12, 3)": 0.5,
+      "(18, 13, 1)": 0.5,
+      "(18, 13, 2)": 0.5,
+      "(18, 13, 3)": 0.5,
+      "(18, 14, 1)": 0.5,
+      "(18, 14, 2)": 0.5,
+      "(18, 14, 3)": 0.5,
+      "(18, 15, 1)": 0.5,
+      "(18, 15, 2)": 0.5,
+      "(18, 15, 3)": 0.5,
+      "(18, 16, 1)": 0.5,
+      "(18, 16, 2)": 0.5,
+      "(18, 16, 3)": 0.5,
+      "(18, 17, 1)": 0.5,
+      "(18, 17, 2)": 0.5,
+      "(18, 17, 3)": 0.5,
+      "(18, 18, 1)": 0.5,
+      "(18, 18, 2)": 0.5,
+      "(18, 18, 3)": 0.5,
+      "(18, 19, 1)": 0.5,
+      "(18, 19, 2)": 0.5,
+      "(18, 19, 3)": 0.5,
+      "(18, 20, 1)": 0.5,
+      "(18, 20, 2)": 0.5,
+      "(18, 20, 3)": 0.5,
+      "(19, 1, 1)": 0.5,
+      "(19, 1, 2)": 0.5,
+      "(19, 1, 3)": 0.5,
+      "(19, 2, 1)": 0.5,
+      "(19, 2, 2)": 0.5,
+      "(19, 2, 3)": 0.5,
+      "(19, 3, 1)": 0.5,
+      "(19, 3, 2)": 0.5,
+      "(19, 3, 3)": 0.5,
+      "(19, 4, 1)": 0.5,
+      "(19, 4, 2)": 0.5,
+      "(19, 4, 3)": 0.5,
+      "(19, 5, 1)": 0.5,
+      "(19, 5, 2)": 0.5,
+      "(19, 5, 3)": 0.5,
+      "(19, 6, 1)": 0.5,
+      "(19, 6, 2)": 0.5,
+      "(19, 6, 3)": 0.5,
+      "(19, 7, 1)": 0.5,
+      "(19, 7, 2)": 0.5,
+      "(19, 7, 3)": 0.5,
+      "(19, 8, 1)": 0.5,
+      "(19, 8, 2)": 0.5,
+      "(19, 8, 3)": 0.5,
+      "(19, 9, 1)": 0.5,
+      "(19, 9, 2)": 0.5,
+      "(19, 9, 3)": 0.5,
+      "(19, 10, 1)": 0.5,
+      "(19, 10, 2)": 0.5,
+      "(19, 10, 3)": 0.5,
+      "(19, 11, 1)": 0.5,
+      "(19, 11, 2)": 0.5,
+      "(19, 11, 3)": 0.5,
+      "(19, 12, 1)": 0.5,
+      "(19, 12, 2)": 0.5,
+      "(19, 12, 3)": 0.5,
+      "(19, 13, 1)": 0.5,
+      "(19, 13, 2)": 0.5,
+      "(19, 13, 3)": 0.5,
+      "(19, 14, 1)": 0.5,
+      "(19, 14, 2)": 0.5,
+      "(19, 14, 3)": 0.5,
+      "(19, 15, 1)": 0.5,
+      "(19, 15, 2)": 0.5,
+      "(19, 15, 3)": 0.5,
+      "(19, 16, 1)": 0.5,
+      "(19, 16, 2)": 0.5,
+      "(19, 16, 3)": 0.5,
+      "(19, 17, 1)": 0.5,
+      "(19, 17, 2)": 0.5,
+      "(19, 17, 3)": 0.5,
+      "(19, 18, 1)": 0.5,
+      "(19, 18, 2)": 0.5,
+      "(19, 18, 3)": 0.5,
+      "(19, 19, 1)": 0.5,
+      "(19, 19, 2)": 0.5,
+      "(19, 19, 3)": 0.5,
+      "(19, 20, 1)": 0.5,
+      "(19, 20, 2)": 0.5,
+      "(19, 20, 3)": 0.5,
+      "(20, 1, 1)": 0.5,
+      "(20, 1, 2)": 0.5,
+      "(20, 1, 3)": 0.5,
+      "(20, 2, 1)": 0.5,
+      "(20, 2, 2)": 0.5,
+      "(20, 2, 3)": 0.5,
+      "(20, 3, 1)": 0.5,
+      "(20, 3, 2)": 0.5,
+      "(20, 3, 3)": 0.5,
+      "(20, 4, 1)": 0.5,
+      "(20, 4, 2)": 0.5,
+      "(20, 4, 3)": 0.5,
+      "(20, 5, 1)": 0.5,
+      "(20, 5, 2)": 0.5,
+      "(20, 5, 3)": 0.5,
+      "(20, 6, 1)": 0.5,
+      "(20, 6, 2)": 0.5,
+      "(20, 6, 3)": 0.5,
+      "(20, 7, 1)": 0.5,
+      "(20, 7, 2)": 0.5,
+      "(20, 7, 3)": 0.5,
+      "(20, 8, 1)": 0.5,
+      "(20, 8, 2)": 0.5,
+      "(20, 8, 3)": 0.5,
+      "(20, 9, 1)": 0.5,
+      "(20, 9, 2)": 0.5,
+      "(20, 9, 3)": 0.5,
+      "(20, 10, 1)": 0.5,
+      "(20, 10, 2)": 0.5,
+      "(20, 10, 3)": 0.5,
+      "(20, 11, 1)": 0.5,
+      "(20, 11, 2)": 0.5,
+      "(20, 11, 3)": 0.5,
+      "(20, 12, 1)": 0.5,
+      "(20, 12, 2)": 0.5,
+      "(20, 12, 3)": 0.5,
+      "(20, 13, 1)": 0.5,
+      "(20, 13, 2)": 0.5,
+      "(20, 13, 3)": 0.5,
+      "(20, 14, 1)": 0.5,
+      "(20, 14, 2)": 0.5,
+      "(20, 14, 3)": 0.5,
+      "(20, 15, 1)": 0.5,
+      "(20, 15, 2)": 0.5,
+      "(20, 15, 3)": 0.5,
+      "(20, 16, 1)": 0.5,
+      "(20, 16, 2)": 0.5,
+      "(20, 16, 3)": 0.5,
+      "(20, 17, 1)": 0.5,
+      "(20, 17, 2)": 0.5,
+      "(20, 17, 3)": 0.5,
+      "(20, 18, 1)": 0.5,
+      "(20, 18, 2)": 0.5,
+      "(20, 18, 3)": 0.5,
+      "(20, 19, 1)": 0.5,
+      "(20, 19, 2)": 0.5,
+      "(20, 19, 3)": 0.5,
+      "(20, 20, 1)": 0.0,
+      "(20, 20, 2)": 0.0,
+      "(20, 20, 3)": 0.0
+    },
+    "gamma": {
+      "(1, 1)": 1.0,
+      "(1, 2)": 1.0,
+      "(1, 3)": 1.0,
+      "(2, 1)": 1.0,
+      "(2, 2)": 1.0,
+      "(2, 3)": 1.0,
+      "(3, 1)": 1.0,
+      "(3, 2)": 1.0,
+      "(3, 3)": 1.0,
+      "(4, 1)": 1.0,
+      "(4, 2)": 1.0,
+      "(4, 3)": 1.0,
+      "(5, 1)": 1.0,
+      "(5, 2)": 1.0,
+      "(5, 3)": 1.0,
+      "(6, 1)": 1.0,
+      "(6, 2)": 1.0,
+      "(6, 3)": 1.0,
+      "(7, 1)": 1.0,
+      "(7, 2)": 1.0,
+      "(7, 3)": 1.0,
+      "(8, 1)": 1.0,
+      "(8, 2)": 1.0,
+      "(8, 3)": 1.0,
+      "(9, 1)": 1.0,
+      "(9, 2)": 1.0,
+      "(9, 3)": 1.0,
+      "(10, 1)": 1.0,
+      "(10, 2)": 1.0,
+      "(10, 3)": 1.0,
+      "(11, 1)": 1.0,
+      "(11, 2)": 1.0,
+      "(11, 3)": 1.0,
+      "(12, 1)": 1.0,
+      "(12, 2)": 1.0,
+      "(12, 3)": 1.0,
+      "(13, 1)": 1.0,
+      "(13, 2)": 1.0,
+      "(13, 3)": 1.0,
+      "(14, 1)": 1.0,
+      "(14, 2)": 1.0,
+      "(14, 3)": 1.0,
+      "(15, 1)": 1.0,
+      "(15, 2)": 1.0,
+      "(15, 3)": 1.0,
+      "(16, 1)": 1.0,
+      "(16, 2)": 1.0,
+      "(16, 3)": 1.0,
+      "(17, 1)": 1.0,
+      "(17, 2)": 1.0,
+      "(17, 3)": 1.0,
+      "(18, 1)": 1.0,
+      "(18, 2)": 1.0,
+      "(18, 3)": 1.0,
+      "(19, 1)": 1.0,
+      "(19, 2)": 1.0,
+      "(19, 3)": 1.0,
+      "(20, 1)": 1.0,
+      "(20, 2)": 1.0,
+      "(20, 3)": 1.0
+    },
+    "delta": {
+      "(1, 1)": 0.5,
+      "(1, 2)": 0.5,
+      "(1, 3)": 0.5,
+      "(2, 1)": 0.5,
+      "(2, 2)": 0.5,
+      "(2, 3)": 0.5,
+      "(3, 1)": 0.5,
+      "(3, 2)": 0.5,
+      "(3, 3)": 0.5,
+      "(4, 1)": 0.5,
+      "(4, 2)": 0.5,
+      "(4, 3)": 0.5,
+      "(5, 1)": 0.5,
+      "(5, 2)": 0.5,
+      "(5, 3)": 0.5,
+      "(6, 1)": 0.5,
+      "(6, 2)": 0.5,
+      "(6, 3)": 0.5,
+      "(7, 1)": 0.5,
+      "(7, 2)": 0.5,
+      "(7, 3)": 0.5,
+      "(8, 1)": 0.5,
+      "(8, 2)": 0.5,
+      "(8, 3)": 0.5,
+      "(9, 1)": 0.5,
+      "(9, 2)": 0.5,
+      "(9, 3)": 0.5,
+      "(10, 1)": 0.5,
+      "(10, 2)": 0.5,
+      "(10, 3)": 0.5,
+      "(11, 1)": 0.5,
+      "(11, 2)": 0.5,
+      "(11, 3)": 0.5,
+      "(12, 1)": 0.5,
+      "(12, 2)": 0.5,
+      "(12, 3)": 0.5,
+      "(13, 1)": 0.5,
+      "(13, 2)": 0.5,
+      "(13, 3)": 0.5,
+      "(14, 1)": 0.5,
+      "(14, 2)": 0.5,
+      "(14, 3)": 0.5,
+      "(15, 1)": 0.5,
+      "(15, 2)": 0.5,
+      "(15, 3)": 0.5,
+      "(16, 1)": 0.5,
+      "(16, 2)": 0.5,
+      "(16, 3)": 0.5,
+      "(17, 1)": 0.5,
+      "(17, 2)": 0.5,
+      "(17, 3)": 0.5,
+      "(18, 1)": 0.5,
+      "(18, 2)": 0.5,
+      "(18, 3)": 0.5,
+      "(19, 1)": 0.5,
+      "(19, 2)": 0.5,
+      "(19, 3)": 0.5,
+      "(20, 1)": 0.5,
+      "(20, 2)": 0.5,
+      "(20, 3)": 0.5
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-11-12.143728/config.json b/test_instances/2026-06-30_15-11-12.143728/config.json
new file mode 100644
index 0000000..4a62bf9
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/config.json
@@ -0,0 +1,50 @@
+{
+  "base_solution_folder": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb",
+  "verbose": 2,
+  "seed": 7521,
+  "max_steps": 100,
+  "min_run_time": 70,
+  "max_run_time": 80,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "MIPGap": 1e-05
+    },
+    "auction": {
+      "eta": 0.0,
+      "epsilon": 0.0001,
+      "zeta": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": true
+    },
+    "coordinator": {
+      "sorting_rule": "product"
+    },
+    "update_neighborhood": false,
+    "start_from_last_pi": false,
+    "use_detailed_pi": false
+  },
+  "checkpoint_interval": 10,
+  "max_iterations": 100,
+  "plot_interval": 100,
+  "patience": 10,
+  "sw_patience": 200,
+  "limits": {
+    "instance_type": "load_existing",
+    "Nn": {
+      "min": 20,
+      "max": 20
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_10-46-29.818581",
+    "load": {
+      "trace_type": "load_existing",
+      "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_10-46-29.818581"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-11-12.143728/graph/PLANAR b/test_instances/2026-06-30_15-11-12.143728/graph/PLANAR
new file mode 100644
index 0000000..e69de29
diff --git a/test_instances/2026-06-30_15-11-12.143728/graph/graph.png b/test_instances/2026-06-30_15-11-12.143728/graph/graph.png
new file mode 100644
index 0000000..e486d38
Binary files /dev/null and b/test_instances/2026-06-30_15-11-12.143728/graph/graph.png differ
diff --git a/test_instances/2026-06-30_15-11-12.143728/input_requests_traces.json b/test_instances/2026-06-30_15-11-12.143728/input_requests_traces.json
new file mode 100644
index 0000000..4678995
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/input_requests_traces.json
@@ -0,0 +1,6128 @@
+{
+  "0": {
+    "0": [
+      124,
+      121,
+      110,
+      115,
+      108,
+      112,
+      114,
+      117,
+      106,
+      116,
+      122,
+      126,
+      118,
+      125,
+      121,
+      134,
+      137,
+      129,
+      141,
+      138,
+      139,
+      148,
+      140,
+      147,
+      150,
+      143,
+      149,
+      147,
+      161,
+      158,
+      162,
+      171,
+      164,
+      104,
+      86,
+      80,
+      84,
+      85,
+      81,
+      70,
+      61,
+      63,
+      64,
+      70,
+      65,
+      50,
+      69,
+      60,
+      74,
+      73,
+      75,
+      74,
+      85,
+      91,
+      103,
+      107,
+      110,
+      132,
+      143,
+      149,
+      152,
+      154,
+      170,
+      188,
+      174,
+      173,
+      186,
+      175,
+      172,
+      175,
+      163,
+      155,
+      141,
+      151,
+      148,
+      126,
+      125,
+      120,
+      106,
+      111,
+      100,
+      92,
+      89,
+      84,
+      77,
+      76,
+      67,
+      63,
+      66,
+      50,
+      60,
+      51,
+      60,
+      52,
+      63,
+      67,
+      74,
+      64,
+      79,
+      143
+    ],
+    "1": [
+      125,
+      119,
+      123,
+      123,
+      123,
+      132,
+      110,
+      126,
+      129,
+      128,
+      129,
+      132,
+      138,
+      137,
+      131,
+      145,
+      130,
+      125,
+      116,
+      113,
+      102,
+      95,
+      88,
+      88,
+      77,
+      79,
+      71,
+      65,
+      59,
+      56,
+      61,
+      46,
+      61,
+      85,
+      99,
+      111,
+      123,
+      124,
+      147,
+      158,
+      169,
+      184,
+      178,
+      181,
+      197,
+      190,
+      200,
+      202,
+      182,
+      171,
+      182,
+      160,
+      155,
+      139,
+      132,
+      132,
+      116,
+      114,
+      102,
+      85,
+      95,
+      78,
+      85,
+      78,
+      79,
+      77,
+      57,
+      52,
+      69,
+      73,
+      71,
+      76,
+      80,
+      74,
+      90,
+      88,
+      90,
+      94,
+      100,
+      108,
+      115,
+      115,
+      123,
+      134,
+      132,
+      129,
+      129,
+      135,
+      149,
+      145,
+      159,
+      160,
+      157,
+      165,
+      166,
+      176,
+      165,
+      175,
+      170,
+      159
+    ],
+    "2": [
+      133,
+      123,
+      123,
+      112,
+      115,
+      122,
+      123,
+      117,
+      124,
+      123,
+      129,
+      135,
+      130,
+      145,
+      141,
+      143,
+      136,
+      146,
+      147,
+      145,
+      143,
+      136,
+      140,
+      122,
+      119,
+      117,
+      113,
+      110,
+      122,
+      113,
+      103,
+      112,
+      104,
+      136,
+      127,
+      121,
+      112,
+      111,
+      113,
+      106,
+      93,
+      111,
+      98,
+      89,
+      94,
+      76,
+      71,
+      79,
+      59,
+      68,
+      71,
+      68,
+      74,
+      60,
+      77,
+      70,
+      78,
+      81,
+      74,
+      86,
+      97,
+      89,
+      99,
+      97,
+      110,
+      112,
+      196,
+      180,
+      157,
+      159,
+      147,
+      126,
+      134,
+      132,
+      122,
+      114,
+      99,
+      101,
+      106,
+      88,
+      88,
+      85,
+      70,
+      65,
+      61,
+      64,
+      63,
+      66,
+      45,
+      65,
+      56,
+      80,
+      61,
+      66,
+      76,
+      78,
+      102,
+      108,
+      101,
+      50
+    ],
+    "3": [
+      124,
+      115,
+      115,
+      127,
+      116,
+      106,
+      112,
+      114,
+      123,
+      125,
+      123,
+      129,
+      131,
+      137,
+      140,
+      138,
+      146,
+      153,
+      150,
+      137,
+      144,
+      137,
+      130,
+      131,
+      145,
+      132,
+      141,
+      130,
+      130,
+      119,
+      126,
+      117,
+      121,
+      109,
+      112,
+      139,
+      168,
+      175,
+      175,
+      172,
+      162,
+      141,
+      122,
+      111,
+      85,
+      74,
+      75,
+      69,
+      92,
+      95,
+      127,
+      157,
+      170,
+      202,
+      203,
+      220,
+      217,
+      204,
+      172,
+      146,
+      108,
+      110,
+      66,
+      69,
+      78,
+      90,
+      78,
+      75,
+      92,
+      84,
+      89,
+      98,
+      93,
+      102,
+      106,
+      113,
+      121,
+      117,
+      125,
+      129,
+      138,
+      148,
+      156,
+      168,
+      161,
+      153,
+      170,
+      166,
+      169,
+      171,
+      171,
+      179,
+      178,
+      177,
+      177,
+      176,
+      169,
+      178,
+      171,
+      108
+    ],
+    "4": [
+      110,
+      123,
+      139,
+      127,
+      145,
+      142,
+      138,
+      131,
+      125,
+      112,
+      113,
+      100,
+      80,
+      69,
+      74,
+      58,
+      57,
+      46,
+      45,
+      56,
+      59,
+      78,
+      89,
+      94,
+      115,
+      125,
+      129,
+      149,
+      148,
+      168,
+      167,
+      171,
+      152,
+      130,
+      136,
+      135,
+      143,
+      121,
+      120,
+      113,
+      110,
+      96,
+      103,
+      110,
+      87,
+      88,
+      91,
+      93,
+      90,
+      82,
+      80,
+      68,
+      61,
+      80,
+      67,
+      73,
+      77,
+      69,
+      73,
+      80,
+      81,
+      89,
+      91,
+      81,
+      79,
+      83,
+      151,
+      155,
+      147,
+      147,
+      149,
+      159,
+      161,
+      174,
+      169,
+      164,
+      170,
+      177,
+      176,
+      175,
+      178,
+      171,
+      173,
+      171,
+      171,
+      168,
+      153,
+      153,
+      149,
+      152,
+      138,
+      131,
+      125,
+      115,
+      113,
+      101,
+      90,
+      93,
+      82,
+      158
+    ],
+    "5": [
+      114,
+      120,
+      120,
+      121,
+      122,
+      110,
+      117,
+      120,
+      124,
+      130,
+      131,
+      124,
+      130,
+      131,
+      138,
+      134,
+      133,
+      150,
+      144,
+      146,
+      150,
+      144,
+      138,
+      136,
+      129,
+      137,
+      135,
+      131,
+      122,
+      128,
+      129,
+      131,
+      128,
+      154,
+      154,
+      145,
+      149,
+      137,
+      139,
+      140,
+      145,
+      143,
+      143,
+      136,
+      134,
+      124,
+      125,
+      115,
+      119,
+      111,
+      100,
+      103,
+      100,
+      102,
+      105,
+      95,
+      99,
+      97,
+      88,
+      93,
+      88,
+      77,
+      78,
+      94,
+      76,
+      57,
+      101,
+      106,
+      126,
+      142,
+      152,
+      167,
+      167,
+      168,
+      166,
+      161,
+      153,
+      136,
+      134,
+      116,
+      102,
+      84,
+      86,
+      56,
+      56,
+      57,
+      63,
+      78,
+      80,
+      91,
+      114,
+      123,
+      142,
+      153,
+      162,
+      183,
+      170,
+      174,
+      173,
+      108
+    ],
+    "6": [
+      130,
+      117,
+      107,
+      118,
+      120,
+      118,
+      116,
+      106,
+      115,
+      114,
+      108,
+      128,
+      136,
+      129,
+      128,
+      135,
+      148,
+      148,
+      152,
+      141,
+      139,
+      147,
+      141,
+      151,
+      143,
+      145,
+      151,
+      151,
+      144,
+      154,
+      157,
+      159,
+      164,
+      162,
+      169,
+      178,
+      173,
+      158,
+      147,
+      111,
+      93,
+      86,
+      53,
+      64,
+      63,
+      84,
+      104,
+      147,
+      154,
+      177,
+      192,
+      186,
+      196,
+      181,
+      155,
+      136,
+      111,
+      88,
+      90,
+      91,
+      94,
+      120,
+      143,
+      164,
+      195,
+      216,
+      104,
+      121,
+      122,
+      134,
+      141,
+      161,
+      163,
+      175,
+      167,
+      168,
+      179,
+      169,
+      172,
+      171,
+      157,
+      151,
+      137,
+      129,
+      108,
+      106,
+      106,
+      89,
+      81,
+      57,
+      57,
+      53,
+      61,
+      58,
+      56,
+      78,
+      76,
+      89,
+      92,
+      160
+    ],
+    "7": [
+      123,
+      125,
+      106,
+      106,
+      117,
+      111,
+      113,
+      112,
+      116,
+      109,
+      122,
+      118,
+      134,
+      135,
+      130,
+      132,
+      137,
+      146,
+      141,
+      147,
+      150,
+      150,
+      148,
+      155,
+      148,
+      149,
+      151,
+      155,
+      147,
+      160,
+      163,
+      157,
+      145,
+      147,
+      158,
+      144,
+      156,
+      142,
+      139,
+      140,
+      141,
+      140,
+      149,
+      141,
+      152,
+      139,
+      116,
+      137,
+      111,
+      119,
+      112,
+      109,
+      106,
+      121,
+      108,
+      116,
+      90,
+      102,
+      105,
+      105,
+      89,
+      91,
+      82,
+      67,
+      79,
+      70,
+      180,
+      178,
+      173,
+      163,
+      147,
+      151,
+      142,
+      116,
+      131,
+      128,
+      113,
+      110,
+      105,
+      101,
+      95,
+      91,
+      81,
+      69,
+      69,
+      68,
+      72,
+      58,
+      57,
+      55,
+      50,
+      57,
+      67,
+      65,
+      65,
+      73,
+      79,
+      87,
+      95,
+      165
+    ],
+    "8": [
+      125,
+      113,
+      125,
+      128,
+      121,
+      124,
+      128,
+      130,
+      129,
+      137,
+      130,
+      132,
+      137,
+      132,
+      134,
+      129,
+      127,
+      124,
+      109,
+      108,
+      100,
+      94,
+      85,
+      77,
+      69,
+      68,
+      53,
+      51,
+      65,
+      61,
+      55,
+      53,
+      62,
+      167,
+      171,
+      153,
+      156,
+      143,
+      151,
+      145,
+      151,
+      134,
+      143,
+      130,
+      140,
+      129,
+      126,
+      127,
+      108,
+      114,
+      108,
+      95,
+      100,
+      112,
+      94,
+      100,
+      104,
+      106,
+      83,
+      93,
+      83,
+      85,
+      90,
+      84,
+      66,
+      74,
+      175,
+      192,
+      179,
+      180,
+      174,
+      168,
+      171,
+      170,
+      158,
+      169,
+      164,
+      162,
+      163,
+      159,
+      147,
+      142,
+      128,
+      129,
+      122,
+      108,
+      110,
+      95,
+      92,
+      90,
+      79,
+      73,
+      71,
+      71,
+      61,
+      65,
+      65,
+      52,
+      63,
+      132
+    ],
+    "9": [
+      120,
+      116,
+      126,
+      122,
+      116,
+      109,
+      123,
+      120,
+      116,
+      128,
+      126,
+      126,
+      133,
+      129,
+      133,
+      139,
+      138,
+      146,
+      144,
+      132,
+      140,
+      140,
+      130,
+      129,
+      129,
+      126,
+      122,
+      125,
+      116,
+      117,
+      108,
+      105,
+      105,
+      140,
+      137,
+      141,
+      129,
+      128,
+      123,
+      121,
+      120,
+      107,
+      110,
+      108,
+      104,
+      106,
+      99,
+      93,
+      101,
+      98,
+      79,
+      73,
+      85,
+      76,
+      70,
+      83,
+      78,
+      88,
+      79,
+      78,
+      70,
+      83,
+      72,
+      86,
+      73,
+      79,
+      66,
+      62,
+      65,
+      67,
+      67,
+      71,
+      70,
+      59,
+      77,
+      86,
+      92,
+      102,
+      116,
+      118,
+      125,
+      146,
+      161,
+      159,
+      161,
+      175,
+      180,
+      175,
+      183,
+      182,
+      175,
+      166,
+      169,
+      158,
+      159,
+      138,
+      136,
+      126,
+      114,
+      74
+    ],
+    "10": [
+      129,
+      116,
+      120,
+      113,
+      116,
+      119,
+      122,
+      118,
+      123,
+      124,
+      130,
+      126,
+      143,
+      141,
+      141,
+      134,
+      134,
+      133,
+      134,
+      147,
+      132,
+      130,
+      123,
+      126,
+      120,
+      106,
+      113,
+      92,
+      93,
+      98,
+      90,
+      85,
+      80,
+      106,
+      88,
+      84,
+      77,
+      82,
+      88,
+      77,
+      70,
+      72,
+      74,
+      53,
+      56,
+      60,
+      58,
+      68,
+      57,
+      57,
+      79,
+      76,
+      80,
+      91,
+      90,
+      82,
+      113,
+      119,
+      127,
+      147,
+      160,
+      160,
+      156,
+      172,
+      165,
+      166,
+      173,
+      177,
+      184,
+      182,
+      166,
+      159,
+      133,
+      122,
+      108,
+      95,
+      72,
+      65,
+      49,
+      54,
+      65,
+      75,
+      84,
+      106,
+      123,
+      133,
+      149,
+      169,
+      181,
+      171,
+      175,
+      152,
+      149,
+      140,
+      124,
+      109,
+      87,
+      75,
+      64,
+      62
+    ],
+    "11": [
+      117,
+      107,
+      107,
+      113,
+      103,
+      101,
+      112,
+      118,
+      118,
+      123,
+      112,
+      121,
+      118,
+      118,
+      133,
+      133,
+      135,
+      135,
+      138,
+      145,
+      131,
+      142,
+      142,
+      144,
+      147,
+      151,
+      143,
+      157,
+      149,
+      158,
+      157,
+      171,
+      155,
+      161,
+      154,
+      167,
+      154,
+      142,
+      141,
+      146,
+      146,
+      134,
+      140,
+      135,
+      124,
+      127,
+      132,
+      128,
+      122,
+      111,
+      108,
+      106,
+      103,
+      101,
+      84,
+      100,
+      98,
+      97,
+      102,
+      93,
+      102,
+      89,
+      91,
+      62,
+      66,
+      73,
+      141,
+      134,
+      136,
+      142,
+      144,
+      154,
+      163,
+      166,
+      154,
+      169,
+      172,
+      167,
+      183,
+      178,
+      178,
+      184,
+      187,
+      177,
+      181,
+      169,
+      164,
+      173,
+      149,
+      162,
+      155,
+      140,
+      143,
+      138,
+      135,
+      132,
+      126,
+      108,
+      103,
+      126
+    ],
+    "12": [
+      107,
+      127,
+      134,
+      122,
+      126,
+      138,
+      130,
+      136,
+      132,
+      134,
+      128,
+      117,
+      117,
+      114,
+      100,
+      83,
+      78,
+      72,
+      64,
+      59,
+      49,
+      45,
+      49,
+      46,
+      56,
+      58,
+      64,
+      74,
+      90,
+      97,
+      113,
+      129,
+      139,
+      64,
+      67,
+      55,
+      52,
+      70,
+      62,
+      58,
+      67,
+      80,
+      72,
+      84,
+      86,
+      103,
+      109,
+      111,
+      122,
+      136,
+      138,
+      156,
+      162,
+      172,
+      186,
+      207,
+      214,
+      223,
+      242,
+      229,
+      249,
+      243,
+      232,
+      238,
+      201,
+      199,
+      177,
+      167,
+      162,
+      146,
+      160,
+      131,
+      132,
+      121,
+      107,
+      102,
+      106,
+      103,
+      89,
+      85,
+      75,
+      64,
+      80,
+      65,
+      71,
+      72,
+      61,
+      63,
+      68,
+      58,
+      67,
+      68,
+      63,
+      75,
+      91,
+      83,
+      94,
+      94,
+      120,
+      148
+    ],
+    "13": [
+      120,
+      121,
+      115,
+      112,
+      122,
+      122,
+      123,
+      121,
+      115,
+      126,
+      123,
+      139,
+      141,
+      138,
+      144,
+      138,
+      141,
+      137,
+      133,
+      125,
+      127,
+      113,
+      117,
+      113,
+      98,
+      101,
+      89,
+      82,
+      88,
+      82,
+      83,
+      66,
+      86,
+      87,
+      71,
+      73,
+      57,
+      61,
+      60,
+      72,
+      87,
+      113,
+      119,
+      155,
+      162,
+      189,
+      193,
+      187,
+      196,
+      185,
+      174,
+      159,
+      134,
+      114,
+      100,
+      95,
+      84,
+      70,
+      77,
+      77,
+      99,
+      128,
+      145,
+      156,
+      189,
+      185,
+      64,
+      67,
+      66,
+      62,
+      59,
+      54,
+      54,
+      59,
+      62,
+      59,
+      51,
+      60,
+      55,
+      63,
+      74,
+      65,
+      50,
+      65,
+      73,
+      67,
+      79,
+      79,
+      79,
+      76,
+      92,
+      83,
+      88,
+      98,
+      93,
+      107,
+      111,
+      106,
+      114,
+      87
+    ],
+    "14": [
+      110,
+      133,
+      142,
+      144,
+      136,
+      143,
+      132,
+      126,
+      111,
+      99,
+      95,
+      69,
+      54,
+      42,
+      51,
+      45,
+      66,
+      61,
+      83,
+      106,
+      117,
+      122,
+      135,
+      144,
+      155,
+      154,
+      140,
+      135,
+      119,
+      90,
+      81,
+      73,
+      66,
+      76,
+      73,
+      73,
+      73,
+      95,
+      106,
+      115,
+      116,
+      128,
+      144,
+      159,
+      165,
+      176,
+      183,
+      184,
+      200,
+      190,
+      194,
+      206,
+      201,
+      193,
+      204,
+      198,
+      184,
+      191,
+      188,
+      184,
+      152,
+      149,
+      134,
+      112,
+      110,
+      94,
+      77,
+      83,
+      74,
+      84,
+      80,
+      80,
+      83,
+      92,
+      94,
+      95,
+      106,
+      111,
+      121,
+      126,
+      121,
+      139,
+      134,
+      145,
+      144,
+      146,
+      158,
+      146,
+      163,
+      166,
+      167,
+      182,
+      176,
+      182,
+      174,
+      177,
+      174,
+      184,
+      176,
+      162
+    ],
+    "15": [
+      117,
+      131,
+      133,
+      141,
+      136,
+      138,
+      132,
+      133,
+      118,
+      113,
+      92,
+      87,
+      70,
+      59,
+      60,
+      52,
+      38,
+      41,
+      49,
+      60,
+      89,
+      90,
+      103,
+      124,
+      133,
+      147,
+      149,
+      163,
+      146,
+      148,
+      141,
+      129,
+      118,
+      116,
+      112,
+      105,
+      98,
+      95,
+      83,
+      90,
+      92,
+      78,
+      79,
+      72,
+      80,
+      83,
+      69,
+      58,
+      63,
+      68,
+      75,
+      70,
+      68,
+      77,
+      76,
+      88,
+      90,
+      92,
+      107,
+      109,
+      133,
+      118,
+      137,
+      130,
+      118,
+      153,
+      137,
+      136,
+      138,
+      142,
+      136,
+      139,
+      151,
+      158,
+      162,
+      162,
+      174,
+      177,
+      170,
+      170,
+      177,
+      170,
+      178,
+      175,
+      178,
+      181,
+      168,
+      167,
+      162,
+      162,
+      151,
+      147,
+      142,
+      135,
+      129,
+      122,
+      121,
+      115,
+      120,
+      69
+    ],
+    "16": [
+      120,
+      127,
+      119,
+      124,
+      129,
+      129,
+      132,
+      130,
+      137,
+      131,
+      134,
+      134,
+      123,
+      130,
+      119,
+      117,
+      111,
+      97,
+      90,
+      84,
+      79,
+      68,
+      69,
+      58,
+      52,
+      48,
+      57,
+      52,
+      56,
+      60,
+      66,
+      61,
+      83,
+      138,
+      163,
+      166,
+      168,
+      172,
+      182,
+      174,
+      176,
+      184,
+      167,
+      160,
+      152,
+      124,
+      119,
+      101,
+      91,
+      78,
+      65,
+      60,
+      85,
+      55,
+      81,
+      85,
+      93,
+      116,
+      119,
+      134,
+      155,
+      176,
+      180,
+      189,
+      205,
+      196,
+      70,
+      60,
+      60,
+      56,
+      63,
+      64,
+      67,
+      61,
+      69,
+      77,
+      80,
+      93,
+      86,
+      99,
+      99,
+      100,
+      105,
+      106,
+      124,
+      124,
+      120,
+      138,
+      125,
+      138,
+      138,
+      137,
+      144,
+      155,
+      149,
+      157,
+      165,
+      162,
+      168,
+      57
+    ],
+    "17": [
+      119,
+      120,
+      120,
+      114,
+      115,
+      104,
+      111,
+      110,
+      116,
+      110,
+      122,
+      128,
+      125,
+      128,
+      133,
+      149,
+      138,
+      141,
+      153,
+      140,
+      144,
+      142,
+      148,
+      141,
+      134,
+      141,
+      146,
+      143,
+      139,
+      143,
+      141,
+      152,
+      152,
+      102,
+      107,
+      115,
+      120,
+      147,
+      139,
+      161,
+      169,
+      171,
+      185,
+      193,
+      191,
+      202,
+      197,
+      174,
+      171,
+      182,
+      159,
+      162,
+      132,
+      132,
+      137,
+      106,
+      105,
+      94,
+      94,
+      97,
+      86,
+      83,
+      67,
+      72,
+      78,
+      79,
+      132,
+      134,
+      137,
+      132,
+      151,
+      153,
+      142,
+      164,
+      152,
+      166,
+      167,
+      168,
+      169,
+      163,
+      175,
+      191,
+      177,
+      180,
+      172,
+      177,
+      171,
+      175,
+      168,
+      167,
+      153,
+      155,
+      143,
+      140,
+      134,
+      127,
+      131,
+      125,
+      110,
+      170
+    ],
+    "18": [
+      118,
+      124,
+      115,
+      112,
+      115,
+      116,
+      113,
+      113,
+      125,
+      112,
+      123,
+      122,
+      129,
+      137,
+      129,
+      138,
+      143,
+      146,
+      136,
+      136,
+      142,
+      145,
+      148,
+      139,
+      139,
+      138,
+      142,
+      144,
+      156,
+      137,
+      153,
+      156,
+      153,
+      65,
+      68,
+      62,
+      68,
+      64,
+      67,
+      87,
+      84,
+      91,
+      107,
+      115,
+      127,
+      136,
+      147,
+      149,
+      160,
+      166,
+      174,
+      185,
+      196,
+      190,
+      224,
+      204,
+      230,
+      224,
+      228,
+      226,
+      212,
+      203,
+      206,
+      199,
+      170,
+      158,
+      66,
+      74,
+      59,
+      51,
+      62,
+      55,
+      70,
+      48,
+      64,
+      54,
+      59,
+      51,
+      58,
+      63,
+      66,
+      65,
+      66,
+      76,
+      71,
+      74,
+      70,
+      63,
+      84,
+      81,
+      90,
+      100,
+      92,
+      90,
+      103,
+      98,
+      106,
+      117,
+      114,
+      167
+    ],
+    "19": [
+      125,
+      111,
+      110,
+      118,
+      110,
+      114,
+      109,
+      112,
+      110,
+      117,
+      118,
+      119,
+      123,
+      133,
+      129,
+      135,
+      135,
+      133,
+      139,
+      143,
+      134,
+      145,
+      146,
+      144,
+      153,
+      153,
+      154,
+      153,
+      160,
+      164,
+      154,
+      164,
+      173,
+      161,
+      161,
+      163,
+      154,
+      159,
+      148,
+      152,
+      159,
+      151,
+      159,
+      143,
+      144,
+      149,
+      125,
+      129,
+      140,
+      129,
+      121,
+      136,
+      117,
+      121,
+      113,
+      111,
+      116,
+      105,
+      116,
+      109,
+      106,
+      85,
+      86,
+      72,
+      97,
+      76,
+      77,
+      82,
+      92,
+      87,
+      88,
+      89,
+      93,
+      99,
+      104,
+      112,
+      118,
+      126,
+      128,
+      133,
+      134,
+      131,
+      146,
+      153,
+      155,
+      162,
+      156,
+      160,
+      162,
+      171,
+      163,
+      172,
+      179,
+      175,
+      180,
+      165,
+      169,
+      179,
+      181,
+      104
+    ]
+  },
+  "1": {
+    "0": [
+      44,
+      44,
+      45,
+      44,
+      44,
+      46,
+      45,
+      44,
+      45,
+      46,
+      44,
+      45,
+      48,
+      47,
+      47,
+      48,
+      47,
+      48,
+      50,
+      47,
+      47,
+      46,
+      47,
+      46,
+      47,
+      49,
+      47,
+      46,
+      45,
+      44,
+      42,
+      42,
+      39,
+      32,
+      34,
+      32,
+      29,
+      30,
+      30,
+      27,
+      26,
+      23,
+      27,
+      20,
+      24,
+      22,
+      21,
+      21,
+      24,
+      32,
+      29,
+      35,
+      36,
+      37,
+      43,
+      40,
+      43,
+      47,
+      51,
+      56,
+      58,
+      61,
+      66,
+      63,
+      63,
+      71,
+      71,
+      65,
+      71,
+      66,
+      63,
+      68,
+      69,
+      64,
+      62,
+      60,
+      59,
+      62,
+      61,
+      56,
+      56,
+      52,
+      54,
+      45,
+      50,
+      45,
+      42,
+      40,
+      43,
+      42,
+      36,
+      33,
+      34,
+      33,
+      31,
+      26,
+      29,
+      23,
+      25,
+      29
+    ],
+    "1": [
+      43,
+      46,
+      43,
+      47,
+      45,
+      47,
+      46,
+      51,
+      49,
+      46,
+      48,
+      50,
+      48,
+      45,
+      42,
+      45,
+      41,
+      41,
+      40,
+      35,
+      35,
+      30,
+      28,
+      25,
+      24,
+      21,
+      21,
+      19,
+      22,
+      24,
+      20,
+      22,
+      24,
+      49,
+      52,
+      51,
+      52,
+      49,
+      47,
+      48,
+      45,
+      38,
+      36,
+      42,
+      38,
+      37,
+      30,
+      34,
+      35,
+      31,
+      28,
+      25,
+      27,
+      30,
+      26,
+      27,
+      27,
+      24,
+      24,
+      30,
+      26,
+      24,
+      29,
+      29,
+      28,
+      32,
+      72,
+      75,
+      72,
+      69,
+      68,
+      66,
+      69,
+      65,
+      57,
+      60,
+      62,
+      59,
+      58,
+      57,
+      54,
+      52,
+      48,
+      46,
+      44,
+      37,
+      37,
+      39,
+      35,
+      31,
+      33,
+      28,
+      31,
+      27,
+      27,
+      22,
+      25,
+      21,
+      24,
+      45
+    ],
+    "2": [
+      43,
+      45,
+      41,
+      42,
+      43,
+      42,
+      40,
+      42,
+      39,
+      43,
+      44,
+      41,
+      45,
+      41,
+      46,
+      44,
+      49,
+      45,
+      47,
+      50,
+      49,
+      52,
+      53,
+      51,
+      53,
+      54,
+      52,
+      51,
+      52,
+      54,
+      50,
+      51,
+      51,
+      34,
+      31,
+      30,
+      31,
+      28,
+      26,
+      27,
+      22,
+      25,
+      23,
+      22,
+      23,
+      23,
+      24,
+      18,
+      26,
+      27,
+      28,
+      33,
+      32,
+      36,
+      37,
+      41,
+      43,
+      46,
+      52,
+      54,
+      60,
+      58,
+      59,
+      62,
+      66,
+      65,
+      79,
+      74,
+      74,
+      73,
+      70,
+      60,
+      64,
+      60,
+      62,
+      53,
+      55,
+      51,
+      46,
+      47,
+      46,
+      44,
+      40,
+      40,
+      33,
+      33,
+      30,
+      28,
+      28,
+      25,
+      25,
+      22,
+      21,
+      18,
+      20,
+      21,
+      19,
+      19,
+      19,
+      58
+    ],
+    "3": [
+      43,
+      44,
+      42,
+      46,
+      43,
+      44,
+      42,
+      42,
+      44,
+      48,
+      46,
+      45,
+      48,
+      47,
+      48,
+      46,
+      49,
+      48,
+      47,
+      50,
+      47,
+      46,
+      47,
+      46,
+      47,
+      44,
+      45,
+      40,
+      40,
+      38,
+      41,
+      35,
+      37,
+      64,
+      61,
+      61,
+      54,
+      48,
+      42,
+      33,
+      33,
+      29,
+      27,
+      29,
+      23,
+      24,
+      28,
+      33,
+      37,
+      40,
+      55,
+      55,
+      67,
+      75,
+      74,
+      79,
+      77,
+      76,
+      71,
+      69,
+      68,
+      61,
+      51,
+      45,
+      46,
+      35,
+      74,
+      70,
+      63,
+      62,
+      55,
+      46,
+      47,
+      42,
+      36,
+      38,
+      37,
+      32,
+      28,
+      25,
+      27,
+      23,
+      23,
+      26,
+      18,
+      20,
+      19,
+      17,
+      20,
+      21,
+      24,
+      28,
+      26,
+      29,
+      33,
+      35,
+      40,
+      45,
+      45,
+      19
+    ],
+    "4": [
+      48,
+      44,
+      42,
+      40,
+      41,
+      38,
+      39,
+      43,
+      41,
+      41,
+      41,
+      42,
+      43,
+      47,
+      42,
+      43,
+      45,
+      46,
+      46,
+      48,
+      46,
+      45,
+      51,
+      54,
+      51,
+      53,
+      54,
+      54,
+      55,
+      56,
+      60,
+      58,
+      61,
+      57,
+      61,
+      60,
+      55,
+      56,
+      59,
+      56,
+      59,
+      53,
+      52,
+      48,
+      49,
+      41,
+      45,
+      45,
+      43,
+      38,
+      37,
+      39,
+      36,
+      38,
+      30,
+      32,
+      35,
+      30,
+      31,
+      32,
+      28,
+      29,
+      28,
+      24,
+      23,
+      24,
+      31,
+      32,
+      31,
+      36,
+      42,
+      43,
+      42,
+      48,
+      51,
+      55,
+      58,
+      57,
+      58,
+      60,
+      57,
+      55,
+      55,
+      56,
+      57,
+      47,
+      46,
+      45,
+      41,
+      39,
+      33,
+      36,
+      30,
+      32,
+      28,
+      25,
+      22,
+      23,
+      19,
+      41
+    ],
+    "5": [
+      42,
+      44,
+      43,
+      43,
+      46,
+      46,
+      43,
+      42,
+      44,
+      42,
+      44,
+      44,
+      42,
+      45,
+      49,
+      46,
+      47,
+      47,
+      48,
+      50,
+      52,
+      52,
+      52,
+      49,
+      48,
+      48,
+      50,
+      51,
+      49,
+      52,
+      50,
+      49,
+      52,
+      48,
+      50,
+      47,
+      48,
+      43,
+      45,
+      44,
+      41,
+      40,
+      35,
+      35,
+      36,
+      27,
+      31,
+      30,
+      26,
+      30,
+      27,
+      29,
+      24,
+      23,
+      26,
+      28,
+      23,
+      28,
+      27,
+      32,
+      26,
+      31,
+      30,
+      32,
+      32,
+      39,
+      34,
+      42,
+      51,
+      54,
+      61,
+      63,
+      63,
+      63,
+      57,
+      48,
+      42,
+      36,
+      29,
+      27,
+      20,
+      20,
+      19,
+      24,
+      30,
+      38,
+      43,
+      50,
+      53,
+      58,
+      55,
+      57,
+      51,
+      47,
+      37,
+      31,
+      25,
+      25,
+      20,
+      53
+    ],
+    "6": [
+      46,
+      48,
+      50,
+      52,
+      55,
+      53,
+      53,
+      49,
+      43,
+      37,
+      34,
+      34,
+      27,
+      21,
+      21,
+      18,
+      17,
+      15,
+      21,
+      24,
+      25,
+      30,
+      37,
+      38,
+      48,
+      47,
+      53,
+      55,
+      52,
+      50,
+      51,
+      47,
+      42,
+      31,
+      30,
+      28,
+      29,
+      28,
+      25,
+      24,
+      28,
+      21,
+      24,
+      24,
+      25,
+      26,
+      28,
+      29,
+      27,
+      33,
+      33,
+      38,
+      46,
+      43,
+      47,
+      45,
+      52,
+      60,
+      57,
+      65,
+      57,
+      68,
+      73,
+      68,
+      72,
+      76,
+      26,
+      31,
+      28,
+      29,
+      28,
+      30,
+      27,
+      28,
+      31,
+      31,
+      32,
+      38,
+      35,
+      35,
+      38,
+      38,
+      40,
+      41,
+      41,
+      43,
+      45,
+      46,
+      45,
+      51,
+      54,
+      52,
+      55,
+      57,
+      58,
+      59,
+      62,
+      62,
+      64,
+      24
+    ],
+    "7": [
+      44,
+      46,
+      48,
+      48,
+      48,
+      46,
+      46,
+      48,
+      47,
+      49,
+      47,
+      47,
+      46,
+      45,
+      46,
+      46,
+      44,
+      44,
+      45,
+      40,
+      38,
+      36,
+      33,
+      35,
+      28,
+      28,
+      29,
+      26,
+      25,
+      21,
+      20,
+      20,
+      19,
+      26,
+      21,
+      22,
+      23,
+      28,
+      32,
+      40,
+      44,
+      57,
+      64,
+      65,
+      70,
+      69,
+      70,
+      60,
+      57,
+      53,
+      48,
+      46,
+      32,
+      26,
+      24,
+      28,
+      26,
+      37,
+      36,
+      45,
+      56,
+      63,
+      67,
+      75,
+      74,
+      76,
+      31,
+      27,
+      33,
+      29,
+      31,
+      29,
+      33,
+      34,
+      35,
+      33,
+      35,
+      38,
+      40,
+      39,
+      39,
+      41,
+      41,
+      45,
+      48,
+      49,
+      51,
+      49,
+      46,
+      52,
+      53,
+      56,
+      58,
+      59,
+      60,
+      63,
+      64,
+      61,
+      67,
+      57
+    ],
+    "8": [
+      45,
+      41,
+      43,
+      40,
+      42,
+      41,
+      43,
+      40,
+      43,
+      43,
+      42,
+      41,
+      43,
+      42,
+      44,
+      44,
+      46,
+      48,
+      49,
+      49,
+      49,
+      49,
+      53,
+      52,
+      52,
+      52,
+      51,
+      57,
+      54,
+      58,
+      51,
+      59,
+      54,
+      56,
+      55,
+      55,
+      60,
+      54,
+      52,
+      54,
+      49,
+      55,
+      47,
+      49,
+      44,
+      43,
+      37,
+      37,
+      38,
+      33,
+      33,
+      31,
+      32,
+      31,
+      35,
+      33,
+      25,
+      24,
+      27,
+      25,
+      25,
+      25,
+      27,
+      30,
+      25,
+      28,
+      25,
+      32,
+      34,
+      34,
+      36,
+      36,
+      44,
+      46,
+      53,
+      53,
+      54,
+      55,
+      55,
+      58,
+      58,
+      56,
+      60,
+      56,
+      55,
+      55,
+      50,
+      52,
+      45,
+      43,
+      41,
+      39,
+      34,
+      32,
+      29,
+      25,
+      25,
+      22,
+      22,
+      57
+    ],
+    "9": [
+      38,
+      39,
+      45,
+      43,
+      36,
+      38,
+      40,
+      37,
+      44,
+      38,
+      42,
+      43,
+      42,
+      42,
+      46,
+      46,
+      48,
+      46,
+      47,
+      46,
+      49,
+      49,
+      51,
+      50,
+      50,
+      54,
+      53,
+      55,
+      58,
+      55,
+      58,
+      58,
+      59,
+      24,
+      23,
+      24,
+      23,
+      22,
+      21,
+      25,
+      25,
+      27,
+      31,
+      28,
+      27,
+      32,
+      33,
+      36,
+      37,
+      41,
+      45,
+      50,
+      58,
+      59,
+      60,
+      68,
+      68,
+      75,
+      73,
+      75,
+      77,
+      73,
+      76,
+      79,
+      78,
+      80,
+      34,
+      33,
+      36,
+      34,
+      33,
+      37,
+      34,
+      37,
+      36,
+      38,
+      43,
+      46,
+      41,
+      42,
+      45,
+      48,
+      50,
+      51,
+      50,
+      53,
+      54,
+      55,
+      56,
+      56,
+      55,
+      58,
+      59,
+      60,
+      60,
+      62,
+      62,
+      65,
+      63,
+      46
+    ],
+    "10": [
+      44,
+      40,
+      39,
+      41,
+      42,
+      39,
+      40,
+      39,
+      39,
+      40,
+      41,
+      43,
+      45,
+      41,
+      44,
+      44,
+      45,
+      48,
+      45,
+      48,
+      47,
+      49,
+      47,
+      53,
+      51,
+      51,
+      52,
+      55,
+      55,
+      56,
+      57,
+      57,
+      60,
+      44,
+      44,
+      53,
+      59,
+      66,
+      70,
+      66,
+      73,
+      74,
+      74,
+      70,
+      69,
+      67,
+      60,
+      59,
+      59,
+      48,
+      44,
+      37,
+      37,
+      30,
+      36,
+      27,
+      29,
+      27,
+      24,
+      25,
+      32,
+      28,
+      33,
+      37,
+      43,
+      43,
+      27,
+      25,
+      20,
+      27,
+      28,
+      26,
+      37,
+      34,
+      39,
+      44,
+      47,
+      45,
+      51,
+      55,
+      57,
+      59,
+      58,
+      59,
+      54,
+      56,
+      56,
+      54,
+      52,
+      48,
+      46,
+      47,
+      42,
+      39,
+      38,
+      33,
+      32,
+      29,
+      27,
+      46
+    ],
+    "11": [
+      44,
+      41,
+      42,
+      42,
+      41,
+      41,
+      43,
+      41,
+      43,
+      42,
+      46,
+      44,
+      45,
+      47,
+      47,
+      45,
+      46,
+      49,
+      47,
+      50,
+      50,
+      49,
+      52,
+      49,
+      51,
+      51,
+      49,
+      51,
+      53,
+      54,
+      51,
+      51,
+      51,
+      44,
+      35,
+      35,
+      27,
+      24,
+      27,
+      24,
+      28,
+      33,
+      39,
+      41,
+      46,
+      57,
+      62,
+      68,
+      70,
+      73,
+      71,
+      71,
+      69,
+      60,
+      56,
+      50,
+      44,
+      31,
+      37,
+      29,
+      27,
+      23,
+      30,
+      37,
+      36,
+      46,
+      34,
+      35,
+      35,
+      33,
+      34,
+      41,
+      39,
+      40,
+      41,
+      40,
+      39,
+      45,
+      48,
+      45,
+      45,
+      49,
+      54,
+      52,
+      53,
+      52,
+      54,
+      55,
+      54,
+      56,
+      54,
+      54,
+      58,
+      58,
+      63,
+      62,
+      61,
+      62,
+      63,
+      54
+    ],
+    "12": [
+      45,
+      44,
+      45,
+      41,
+      45,
+      44,
+      45,
+      48,
+      44,
+      44,
+      49,
+      46,
+      47,
+      49,
+      47,
+      47,
+      44,
+      45,
+      45,
+      44,
+      44,
+      42,
+      41,
+      36,
+      40,
+      37,
+      36,
+      36,
+      34,
+      29,
+      28,
+      29,
+      25,
+      61,
+      62,
+      64,
+      62,
+      64,
+      61,
+      58,
+      58,
+      61,
+      56,
+      54,
+      52,
+      53,
+      52,
+      47,
+      50,
+      49,
+      43,
+      43,
+      40,
+      39,
+      37,
+      38,
+      36,
+      36,
+      34,
+      31,
+      33,
+      32,
+      31,
+      29,
+      30,
+      28,
+      69,
+      74,
+      75,
+      69,
+      73,
+      68,
+      63,
+      60,
+      59,
+      58,
+      50,
+      48,
+      42,
+      40,
+      34,
+      31,
+      25,
+      22,
+      20,
+      18,
+      18,
+      18,
+      21,
+      22,
+      22,
+      25,
+      30,
+      33,
+      39,
+      43,
+      49,
+      54,
+      57,
+      29
+    ],
+    "13": [
+      44,
+      43,
+      45,
+      46,
+      43,
+      43,
+      46,
+      45,
+      45,
+      49,
+      46,
+      47,
+      48,
+      46,
+      46,
+      45,
+      44,
+      43,
+      41,
+      39,
+      40,
+      41,
+      35,
+      36,
+      31,
+      32,
+      29,
+      28,
+      22,
+      24,
+      24,
+      23,
+      24,
+      53,
+      50,
+      54,
+      47,
+      51,
+      46,
+      50,
+      46,
+      40,
+      37,
+      38,
+      32,
+      33,
+      38,
+      34,
+      28,
+      28,
+      27,
+      28,
+      22,
+      24,
+      27,
+      27,
+      26,
+      26,
+      26,
+      23,
+      26,
+      29,
+      29,
+      26,
+      30,
+      29,
+      29,
+      27,
+      27,
+      29,
+      25,
+      30,
+      28,
+      31,
+      30,
+      32,
+      29,
+      31,
+      32,
+      34,
+      38,
+      40,
+      38,
+      40,
+      41,
+      40,
+      44,
+      46,
+      46,
+      48,
+      55,
+      47,
+      55,
+      52,
+      60,
+      61,
+      61,
+      61,
+      59,
+      54
+    ],
+    "14": [
+      46,
+      44,
+      45,
+      43,
+      42,
+      42,
+      42,
+      44,
+      41,
+      45,
+      42,
+      43,
+      45,
+      48,
+      48,
+      47,
+      46,
+      47,
+      47,
+      48,
+      48,
+      51,
+      47,
+      47,
+      50,
+      47,
+      49,
+      48,
+      48,
+      48,
+      51,
+      47,
+      46,
+      22,
+      27,
+      24,
+      30,
+      34,
+      44,
+      40,
+      42,
+      51,
+      52,
+      56,
+      59,
+      59,
+      61,
+      70,
+      71,
+      71,
+      76,
+      69,
+      72,
+      67,
+      73,
+      73,
+      71,
+      69,
+      62,
+      62,
+      57,
+      50,
+      50,
+      43,
+      42,
+      36,
+      65,
+      65,
+      67,
+      69,
+      68,
+      66,
+      63,
+      66,
+      63,
+      61,
+      58,
+      60,
+      56,
+      56,
+      58,
+      59,
+      53,
+      56,
+      53,
+      53,
+      46,
+      44,
+      45,
+      45,
+      39,
+      36,
+      36,
+      38,
+      36,
+      34,
+      31,
+      28,
+      31,
+      49
+    ],
+    "15": [
+      45,
+      49,
+      45,
+      43,
+      42,
+      42,
+      41,
+      40,
+      40,
+      42,
+      42,
+      44,
+      43,
+      45,
+      47,
+      47,
+      47,
+      45,
+      48,
+      50,
+      49,
+      52,
+      48,
+      51,
+      52,
+      51,
+      53,
+      53,
+      57,
+      53,
+      54,
+      58,
+      56,
+      61,
+      61,
+      59,
+      61,
+      57,
+      60,
+      63,
+      60,
+      55,
+      56,
+      53,
+      55,
+      55,
+      47,
+      47,
+      46,
+      40,
+      43,
+      41,
+      40,
+      42,
+      36,
+      35,
+      35,
+      36,
+      34,
+      34,
+      29,
+      34,
+      30,
+      30,
+      23,
+      23,
+      28,
+      30,
+      21,
+      25,
+      23,
+      27,
+      20,
+      20,
+      25,
+      20,
+      18,
+      18,
+      20,
+      21,
+      20,
+      20,
+      23,
+      21,
+      26,
+      23,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31,
+      35,
+      33,
+      33,
+      38,
+      40,
+      39,
+      40,
+      50
+    ],
+    "16": [
+      43,
+      44,
+      48,
+      47,
+      50,
+      53,
+      52,
+      49,
+      50,
+      46,
+      43,
+      42,
+      39,
+      40,
+      31,
+      33,
+      29,
+      26,
+      23,
+      20,
+      19,
+      17,
+      17,
+      18,
+      17,
+      20,
+      21,
+      23,
+      29,
+      31,
+      40,
+      44,
+      48,
+      27,
+      24,
+      21,
+      23,
+      24,
+      24,
+      24,
+      26,
+      22,
+      26,
+      28,
+      32,
+      33,
+      36,
+      37,
+      41,
+      44,
+      53,
+      54,
+      58,
+      62,
+      60,
+      64,
+      73,
+      74,
+      73,
+      76,
+      78,
+      79,
+      76,
+      79,
+      75,
+      70,
+      31,
+      25,
+      30,
+      29,
+      31,
+      33,
+      29,
+      29,
+      29,
+      33,
+      33,
+      33,
+      39,
+      35,
+      37,
+      42,
+      42,
+      43,
+      43,
+      46,
+      49,
+      48,
+      52,
+      49,
+      55,
+      55,
+      53,
+      55,
+      57,
+      62,
+      62,
+      66,
+      67,
+      55
+    ],
+    "17": [
+      43,
+      45,
+      41,
+      44,
+      43,
+      44,
+      42,
+      44,
+      43,
+      45,
+      46,
+      46,
+      43,
+      47,
+      47,
+      48,
+      47,
+      49,
+      49,
+      48,
+      51,
+      49,
+      47,
+      49,
+      47,
+      52,
+      45,
+      47,
+      48,
+      46,
+      48,
+      48,
+      50,
+      60,
+      65,
+      68,
+      66,
+      62,
+      62,
+      65,
+      58,
+      60,
+      55,
+      59,
+      57,
+      54,
+      54,
+      48,
+      50,
+      47,
+      45,
+      40,
+      44,
+      46,
+      43,
+      45,
+      46,
+      38,
+      41,
+      36,
+      36,
+      34,
+      33,
+      29,
+      32,
+      28,
+      38,
+      37,
+      39,
+      38,
+      38,
+      41,
+      38,
+      44,
+      42,
+      45,
+      46,
+      44,
+      44,
+      49,
+      50,
+      52,
+      53,
+      50,
+      51,
+      55,
+      57,
+      56,
+      58,
+      56,
+      57,
+      56,
+      61,
+      62,
+      62,
+      64,
+      63,
+      62,
+      65,
+      45
+    ],
+    "18": [
+      45,
+      42,
+      44,
+      42,
+      44,
+      47,
+      46,
+      45,
+      47,
+      46,
+      46,
+      47,
+      44,
+      47,
+      48,
+      47,
+      47,
+      50,
+      47,
+      48,
+      46,
+      45,
+      43,
+      43,
+      40,
+      38,
+      40,
+      33,
+      37,
+      35,
+      30,
+      32,
+      30,
+      60,
+      65,
+      60,
+      59,
+      66,
+      61,
+      59,
+      59,
+      56,
+      60,
+      55,
+      50,
+      55,
+      51,
+      56,
+      47,
+      45,
+      41,
+      42,
+      39,
+      39,
+      42,
+      39,
+      39,
+      41,
+      41,
+      32,
+      35,
+      32,
+      28,
+      27,
+      32,
+      25,
+      33,
+      29,
+      27,
+      27,
+      22,
+      25,
+      19,
+      22,
+      21,
+      23,
+      30,
+      29,
+      39,
+      41,
+      41,
+      42,
+      45,
+      50,
+      53,
+      56,
+      55,
+      53,
+      56,
+      54,
+      57,
+      58,
+      54,
+      57,
+      52,
+      54,
+      51,
+      54,
+      46,
+      22
+    ],
+    "19": [
+      44,
+      44,
+      42,
+      44,
+      44,
+      42,
+      44,
+      46,
+      45,
+      45,
+      45,
+      46,
+      46,
+      45,
+      42,
+      47,
+      50,
+      48,
+      49,
+      47,
+      50,
+      50,
+      48,
+      50,
+      52,
+      50,
+      50,
+      47,
+      43,
+      48,
+      52,
+      47,
+      50,
+      24,
+      28,
+      31,
+      41,
+      42,
+      41,
+      50,
+      55,
+      58,
+      56,
+      61,
+      69,
+      71,
+      71,
+      70,
+      67,
+      73,
+      70,
+      72,
+      70,
+      70,
+      67,
+      59,
+      61,
+      51,
+      55,
+      48,
+      46,
+      43,
+      33,
+      35,
+      27,
+      23,
+      48,
+      47,
+      45,
+      45,
+      50,
+      44,
+      51,
+      45,
+      48,
+      52,
+      52,
+      53,
+      53,
+      55,
+      55,
+      55,
+      57,
+      55,
+      56,
+      61,
+      60,
+      58,
+      56,
+      56,
+      56,
+      59,
+      56,
+      58,
+      56,
+      59,
+      55,
+      56,
+      55,
+      45
+    ]
+  },
+  "2": {
+    "0": [
+      35,
+      35,
+      33,
+      33,
+      33,
+      34,
+      33,
+      32,
+      35,
+      36,
+      36,
+      37,
+      36,
+      38,
+      38,
+      39,
+      44,
+      41,
+      42,
+      40,
+      42,
+      41,
+      36,
+      38,
+      39,
+      36,
+      35,
+      34,
+      32,
+      30,
+      28,
+      30,
+      25,
+      18,
+      19,
+      20,
+      19,
+      17,
+      18,
+      15,
+      19,
+      17,
+      19,
+      20,
+      22,
+      27,
+      31,
+      28,
+      34,
+      36,
+      36,
+      41,
+      43,
+      47,
+      49,
+      51,
+      50,
+      52,
+      57,
+      56,
+      56,
+      55,
+      59,
+      59,
+      60,
+      58,
+      23,
+      25,
+      18,
+      22,
+      21,
+      22,
+      20,
+      24,
+      24,
+      21,
+      22,
+      26,
+      24,
+      25,
+      28,
+      29,
+      30,
+      32,
+      30,
+      33,
+      32,
+      33,
+      33,
+      32,
+      38,
+      36,
+      37,
+      39,
+      42,
+      38,
+      45,
+      42,
+      43,
+      17
+    ],
+    "1": [
+      37,
+      39,
+      39,
+      42,
+      39,
+      39,
+      35,
+      31,
+      27,
+      23,
+      22,
+      16,
+      14,
+      15,
+      12,
+      16,
+      20,
+      27,
+      32,
+      33,
+      39,
+      45,
+      47,
+      45,
+      45,
+      36,
+      35,
+      26,
+      22,
+      19,
+      16,
+      12,
+      18,
+      38,
+      41,
+      44,
+      47,
+      52,
+      47,
+      46,
+      40,
+      34,
+      30,
+      24,
+      21,
+      21,
+      23,
+      27,
+      30,
+      43,
+      51,
+      57,
+      61,
+      66,
+      62,
+      60,
+      52,
+      47,
+      38,
+      27,
+      24,
+      20,
+      23,
+      26,
+      32,
+      35,
+      24,
+      23,
+      20,
+      18,
+      20,
+      19,
+      19,
+      17,
+      18,
+      18,
+      20,
+      19,
+      18,
+      24,
+      18,
+      23,
+      25,
+      24,
+      25,
+      22,
+      27,
+      28,
+      30,
+      30,
+      30,
+      33,
+      33,
+      33,
+      36,
+      39,
+      38,
+      41,
+      40,
+      21
+    ],
+    "2": [
+      36,
+      32,
+      33,
+      31,
+      31,
+      33,
+      31,
+      33,
+      35,
+      32,
+      35,
+      33,
+      38,
+      39,
+      37,
+      38,
+      41,
+      41,
+      44,
+      42,
+      43,
+      43,
+      43,
+      44,
+      41,
+      45,
+      46,
+      46,
+      45,
+      44,
+      42,
+      44,
+      40,
+      34,
+      29,
+      30,
+      26,
+      24,
+      26,
+      25,
+      23,
+      25,
+      20,
+      21,
+      19,
+      19,
+      17,
+      17,
+      20,
+      17,
+      22,
+      22,
+      23,
+      24,
+      24,
+      26,
+      27,
+      27,
+      31,
+      30,
+      36,
+      35,
+      38,
+      36,
+      42,
+      39,
+      32,
+      34,
+      33,
+      34,
+      33,
+      32,
+      36,
+      36,
+      37,
+      37,
+      37,
+      39,
+      40,
+      40,
+      43,
+      39,
+      42,
+      42,
+      42,
+      44,
+      44,
+      46,
+      42,
+      42,
+      42,
+      41,
+      43,
+      42,
+      43,
+      48,
+      45,
+      46,
+      45,
+      50
+    ],
+    "3": [
+      33,
+      34,
+      32,
+      35,
+      36,
+      35,
+      37,
+      36,
+      35,
+      38,
+      36,
+      37,
+      37,
+      39,
+      37,
+      36,
+      34,
+      32,
+      29,
+      32,
+      26,
+      25,
+      25,
+      22,
+      21,
+      20,
+      17,
+      17,
+      15,
+      17,
+      17,
+      16,
+      20,
+      37,
+      35,
+      39,
+      34,
+      36,
+      35,
+      29,
+      32,
+      28,
+      32,
+      28,
+      25,
+      27,
+      30,
+      26,
+      24,
+      23,
+      23,
+      22,
+      23,
+      21,
+      22,
+      19,
+      24,
+      22,
+      19,
+      22,
+      22,
+      22,
+      23,
+      26,
+      26,
+      27,
+      38,
+      36,
+      43,
+      38,
+      37,
+      44,
+      40,
+      38,
+      40,
+      42,
+      43,
+      44,
+      45,
+      46,
+      46,
+      45,
+      46,
+      46,
+      47,
+      44,
+      43,
+      44,
+      43,
+      42,
+      39,
+      44,
+      40,
+      40,
+      41,
+      42,
+      40,
+      38,
+      36,
+      31
+    ],
+    "4": [
+      36,
+      32,
+      31,
+      33,
+      32,
+      33,
+      34,
+      33,
+      33,
+      34,
+      35,
+      36,
+      36,
+      37,
+      39,
+      38,
+      40,
+      42,
+      41,
+      45,
+      43,
+      43,
+      41,
+      44,
+      44,
+      46,
+      41,
+      46,
+      46,
+      45,
+      46,
+      39,
+      41,
+      28,
+      26,
+      23,
+      23,
+      21,
+      19,
+      18,
+      18,
+      22,
+      22,
+      20,
+      21,
+      19,
+      16,
+      18,
+      21,
+      25,
+      23,
+      23,
+      28,
+      25,
+      30,
+      29,
+      28,
+      32,
+      34,
+      38,
+      42,
+      42,
+      45,
+      48,
+      46,
+      46,
+      23,
+      23,
+      21,
+      22,
+      18,
+      21,
+      20,
+      18,
+      21,
+      26,
+      24,
+      25,
+      25,
+      26,
+      26,
+      27,
+      27,
+      28,
+      29,
+      30,
+      32,
+      31,
+      31,
+      33,
+      34,
+      36,
+      37,
+      39,
+      37,
+      38,
+      41,
+      44,
+      46,
+      42
+    ],
+    "5": [
+      33,
+      36,
+      35,
+      36,
+      38,
+      38,
+      38,
+      38,
+      36,
+      36,
+      37,
+      32,
+      33,
+      30,
+      27,
+      25,
+      24,
+      22,
+      20,
+      18,
+      15,
+      12,
+      14,
+      15,
+      16,
+      20,
+      23,
+      26,
+      29,
+      37,
+      37,
+      42,
+      46,
+      44,
+      44,
+      46,
+      44,
+      43,
+      42,
+      44,
+      42,
+      43,
+      38,
+      41,
+      42,
+      40,
+      38,
+      39,
+      39,
+      41,
+      37,
+      38,
+      30,
+      31,
+      31,
+      30,
+      28,
+      24,
+      23,
+      25,
+      22,
+      25,
+      22,
+      24,
+      17,
+      18,
+      36,
+      35,
+      40,
+      36,
+      39,
+      38,
+      35,
+      41,
+      39,
+      39,
+      41,
+      42,
+      43,
+      47,
+      43,
+      44,
+      44,
+      42,
+      44,
+      44,
+      47,
+      43,
+      44,
+      43,
+      43,
+      45,
+      41,
+      42,
+      42,
+      43,
+      44,
+      41,
+      42,
+      40
+    ],
+    "6": [
+      33,
+      35,
+      34,
+      30,
+      33,
+      35,
+      30,
+      32,
+      32,
+      35,
+      36,
+      36,
+      36,
+      38,
+      39,
+      38,
+      40,
+      40,
+      40,
+      40,
+      45,
+      42,
+      41,
+      42,
+      42,
+      43,
+      45,
+      43,
+      44,
+      39,
+      40,
+      35,
+      39,
+      33,
+      31,
+      32,
+      30,
+      24,
+      26,
+      23,
+      24,
+      22,
+      24,
+      22,
+      22,
+      21,
+      21,
+      18,
+      18,
+      20,
+      21,
+      19,
+      23,
+      23,
+      25,
+      26,
+      27,
+      29,
+      25,
+      31,
+      33,
+      31,
+      34,
+      32,
+      36,
+      39,
+      30,
+      28,
+      29,
+      33,
+      30,
+      31,
+      33,
+      35,
+      32,
+      37,
+      34,
+      36,
+      37,
+      36,
+      41,
+      40,
+      39,
+      42,
+      42,
+      42,
+      41,
+      41,
+      41,
+      43,
+      42,
+      43,
+      45,
+      44,
+      43,
+      46,
+      43,
+      46,
+      44,
+      39
+    ],
+    "7": [
+      39,
+      34,
+      36,
+      33,
+      34,
+      33,
+      35,
+      34,
+      34,
+      34,
+      36,
+      37,
+      36,
+      35,
+      40,
+      38,
+      40,
+      37,
+      42,
+      40,
+      41,
+      42,
+      41,
+      39,
+      37,
+      39,
+      38,
+      33,
+      35,
+      33,
+      30,
+      28,
+      29,
+      17,
+      16,
+      14,
+      17,
+      19,
+      16,
+      20,
+      22,
+      21,
+      26,
+      28,
+      32,
+      36,
+      39,
+      42,
+      46,
+      49,
+      55,
+      54,
+      58,
+      59,
+      66,
+      65,
+      69,
+      67,
+      64,
+      67,
+      64,
+      58,
+      62,
+      57,
+      56,
+      50,
+      24,
+      28,
+      31,
+      31,
+      30,
+      28,
+      32,
+      32,
+      32,
+      34,
+      34,
+      37,
+      38,
+      37,
+      37,
+      44,
+      38,
+      43,
+      41,
+      41,
+      41,
+      43,
+      41,
+      42,
+      43,
+      40,
+      43,
+      45,
+      48,
+      46,
+      47,
+      47,
+      46,
+      19
+    ],
+    "8": [
+      33,
+      35,
+      36,
+      39,
+      37,
+      37,
+      38,
+      38,
+      37,
+      36,
+      33,
+      31,
+      25,
+      23,
+      21,
+      21,
+      18,
+      16,
+      15,
+      13,
+      14,
+      15,
+      18,
+      19,
+      26,
+      28,
+      32,
+      35,
+      41,
+      47,
+      50,
+      52,
+      50,
+      46,
+      50,
+      47,
+      48,
+      48,
+      45,
+      40,
+      39,
+      40,
+      34,
+      32,
+      25,
+      22,
+      22,
+      22,
+      22,
+      20,
+      22,
+      28,
+      29,
+      35,
+      40,
+      48,
+      48,
+      55,
+      58,
+      61,
+      62,
+      64,
+      63,
+      62,
+      57,
+      53,
+      65,
+      65,
+      60,
+      59,
+      55,
+      53,
+      51,
+      47,
+      44,
+      41,
+      41,
+      36,
+      33,
+      33,
+      31,
+      26,
+      27,
+      24,
+      22,
+      19,
+      20,
+      18,
+      17,
+      16,
+      16,
+      14,
+      16,
+      15,
+      14,
+      12,
+      12,
+      13,
+      17,
+      20
+    ],
+    "9": [
+      33,
+      35,
+      38,
+      33,
+      34,
+      33,
+      37,
+      37,
+      37,
+      37,
+      37,
+      37,
+      38,
+      37,
+      38,
+      38,
+      38,
+      37,
+      34,
+      34,
+      31,
+      31,
+      29,
+      26,
+      26,
+      24,
+      21,
+      22,
+      20,
+      17,
+      15,
+      19,
+      17,
+      43,
+      45,
+      43,
+      45,
+      41,
+      40,
+      39,
+      41,
+      40,
+      40,
+      40,
+      43,
+      39,
+      38,
+      38,
+      34,
+      34,
+      30,
+      33,
+      27,
+      31,
+      28,
+      25,
+      27,
+      28,
+      29,
+      23,
+      19,
+      18,
+      19,
+      16,
+      19,
+      18,
+      25,
+      21,
+      22,
+      22,
+      23,
+      21,
+      24,
+      24,
+      23,
+      28,
+      25,
+      26,
+      29,
+      27,
+      30,
+      31,
+      34,
+      32,
+      35,
+      35,
+      37,
+      33,
+      36,
+      37,
+      37,
+      37,
+      38,
+      41,
+      39,
+      45,
+      42,
+      47,
+      48,
+      52
+    ],
+    "10": [
+      33,
+      34,
+      38,
+      38,
+      38,
+      37,
+      38,
+      37,
+      34,
+      34,
+      31,
+      28,
+      25,
+      21,
+      20,
+      18,
+      15,
+      12,
+      13,
+      15,
+      18,
+      19,
+      21,
+      28,
+      32,
+      36,
+      40,
+      45,
+      48,
+      52,
+      51,
+      55,
+      52,
+      17,
+      16,
+      17,
+      19,
+      18,
+      19,
+      21,
+      21,
+      20,
+      23,
+      22,
+      29,
+      33,
+      29,
+      41,
+      40,
+      44,
+      46,
+      54,
+      53,
+      57,
+      57,
+      57,
+      61,
+      67,
+      68,
+      62,
+      66,
+      64,
+      64,
+      59,
+      60,
+      55,
+      34,
+      33,
+      33,
+      32,
+      40,
+      37,
+      37,
+      38,
+      37,
+      40,
+      38,
+      40,
+      42,
+      43,
+      42,
+      43,
+      44,
+      42,
+      45,
+      44,
+      44,
+      43,
+      44,
+      44,
+      43,
+      44,
+      45,
+      42,
+      44,
+      43,
+      42,
+      43,
+      41,
+      49
+    ],
+    "11": [
+      36,
+      35,
+      35,
+      38,
+      35,
+      36,
+      35,
+      33,
+      39,
+      38,
+      38,
+      39,
+      39,
+      37,
+      37,
+      36,
+      38,
+      33,
+      31,
+      30,
+      28,
+      27,
+      27,
+      26,
+      23,
+      19,
+      20,
+      19,
+      18,
+      18,
+      19,
+      16,
+      18,
+      46,
+      47,
+      41,
+      46,
+      42,
+      45,
+      45,
+      44,
+      43,
+      41,
+      43,
+      43,
+      43,
+      46,
+      40,
+      46,
+      37,
+      39,
+      42,
+      39,
+      38,
+      37,
+      32,
+      33,
+      31,
+      31,
+      29,
+      24,
+      26,
+      27,
+      21,
+      25,
+      25,
+      63,
+      61,
+      59,
+      57,
+      58,
+      57,
+      50,
+      51,
+      48,
+      45,
+      45,
+      44,
+      40,
+      38,
+      34,
+      34,
+      31,
+      28,
+      26,
+      25,
+      21,
+      20,
+      20,
+      18,
+      18,
+      18,
+      17,
+      14,
+      15,
+      17,
+      14,
+      15,
+      14,
+      44
+    ],
+    "12": [
+      32,
+      33,
+      31,
+      31,
+      33,
+      32,
+      33,
+      32,
+      30,
+      32,
+      32,
+      36,
+      33,
+      39,
+      35,
+      41,
+      38,
+      42,
+      43,
+      41,
+      45,
+      43,
+      43,
+      46,
+      45,
+      49,
+      48,
+      46,
+      48,
+      46,
+      49,
+      49,
+      45,
+      24,
+      27,
+      32,
+      31,
+      36,
+      38,
+      43,
+      44,
+      49,
+      51,
+      55,
+      58,
+      62,
+      61,
+      62,
+      62,
+      56,
+      57,
+      50,
+      51,
+      49,
+      43,
+      41,
+      34,
+      31,
+      29,
+      27,
+      24,
+      24,
+      17,
+      21,
+      15,
+      25,
+      34,
+      36,
+      41,
+      41,
+      42,
+      44,
+      46,
+      44,
+      48,
+      48,
+      51,
+      46,
+      46,
+      45,
+      45,
+      40,
+      41,
+      38,
+      31,
+      31,
+      27,
+      24,
+      23,
+      22,
+      20,
+      16,
+      13,
+      15,
+      15,
+      13,
+      16,
+      17,
+      17,
+      47
+    ],
+    "13": [
+      34,
+      34,
+      36,
+      39,
+      36,
+      36,
+      36,
+      36,
+      38,
+      37,
+      36,
+      36,
+      34,
+      35,
+      35,
+      33,
+      29,
+      30,
+      26,
+      25,
+      21,
+      21,
+      18,
+      19,
+      16,
+      12,
+      14,
+      18,
+      15,
+      16,
+      21,
+      25,
+      27,
+      18,
+      13,
+      18,
+      20,
+      22,
+      30,
+      36,
+      41,
+      49,
+      56,
+      57,
+      55,
+      56,
+      56,
+      50,
+      44,
+      41,
+      34,
+      25,
+      24,
+      22,
+      22,
+      23,
+      27,
+      32,
+      43,
+      45,
+      57,
+      60,
+      61,
+      59,
+      59,
+      57,
+      23,
+      22,
+      21,
+      26,
+      25,
+      30,
+      31,
+      33,
+      38,
+      37,
+      40,
+      44,
+      44,
+      44,
+      46,
+      46,
+      45,
+      47,
+      46,
+      45,
+      42,
+      38,
+      39,
+      34,
+      33,
+      30,
+      28,
+      25,
+      24,
+      20,
+      20,
+      20,
+      17,
+      19
+    ],
+    "14": [
+      33,
+      33,
+      32,
+      33,
+      32,
+      31,
+      33,
+      31,
+      33,
+      32,
+      34,
+      36,
+      35,
+      36,
+      36,
+      40,
+      38,
+      39,
+      40,
+      41,
+      44,
+      46,
+      48,
+      45,
+      46,
+      47,
+      48,
+      49,
+      51,
+      49,
+      49,
+      48,
+      47,
+      46,
+      42,
+      36,
+      37,
+      37,
+      37,
+      38,
+      37,
+      37,
+      33,
+      34,
+      36,
+      31,
+      33,
+      35,
+      34,
+      26,
+      29,
+      25,
+      25,
+      22,
+      22,
+      28,
+      21,
+      25,
+      18,
+      24,
+      20,
+      19,
+      22,
+      19,
+      21,
+      19,
+      21,
+      21,
+      23,
+      22,
+      19,
+      20,
+      17,
+      17,
+      18,
+      18,
+      17,
+      15,
+      21,
+      17,
+      18,
+      19,
+      21,
+      18,
+      20,
+      20,
+      21,
+      18,
+      21,
+      27,
+      25,
+      24,
+      24,
+      30,
+      27,
+      29,
+      34,
+      33,
+      36,
+      43
+    ],
+    "15": [
+      36,
+      34,
+      32,
+      32,
+      34,
+      36,
+      37,
+      37,
+      38,
+      35,
+      36,
+      39,
+      37,
+      37,
+      38,
+      34,
+      34,
+      32,
+      30,
+      27,
+      26,
+      23,
+      21,
+      21,
+      19,
+      19,
+      16,
+      16,
+      17,
+      17,
+      18,
+      21,
+      19,
+      30,
+      37,
+      39,
+      40,
+      46,
+      50,
+      52,
+      51,
+      54,
+      54,
+      57,
+      56,
+      55,
+      52,
+      50,
+      45,
+      46,
+      43,
+      36,
+      36,
+      33,
+      27,
+      22,
+      26,
+      19,
+      20,
+      24,
+      22,
+      27,
+      20,
+      30,
+      34,
+      36,
+      42,
+      39,
+      42,
+      40,
+      40,
+      40,
+      41,
+      43,
+      44,
+      43,
+      45,
+      42,
+      47,
+      43,
+      47,
+      45,
+      45,
+      46,
+      48,
+      43,
+      44,
+      43,
+      43,
+      46,
+      42,
+      42,
+      44,
+      42,
+      41,
+      39,
+      42,
+      41,
+      41,
+      24
+    ],
+    "16": [
+      35,
+      31,
+      32,
+      33,
+      33,
+      33,
+      30,
+      33,
+      32,
+      32,
+      33,
+      34,
+      37,
+      37,
+      41,
+      41,
+      40,
+      43,
+      46,
+      43,
+      44,
+      43,
+      43,
+      46,
+      46,
+      47,
+      45,
+      47,
+      45,
+      45,
+      45,
+      47,
+      45,
+      40,
+      38,
+      36,
+      40,
+      37,
+      35,
+      37,
+      34,
+      33,
+      36,
+      34,
+      29,
+      31,
+      29,
+      29,
+      28,
+      29,
+      29,
+      24,
+      21,
+      23,
+      27,
+      19,
+      23,
+      22,
+      18,
+      24,
+      20,
+      25,
+      19,
+      22,
+      17,
+      19,
+      36,
+      42,
+      43,
+      45,
+      47,
+      42,
+      46,
+      45,
+      45,
+      45,
+      46,
+      48,
+      47,
+      44,
+      49,
+      47,
+      46,
+      48,
+      48,
+      43,
+      42,
+      43,
+      41,
+      39,
+      38,
+      40,
+      39,
+      36,
+      38,
+      39,
+      37,
+      34,
+      36,
+      54
+    ],
+    "17": [
+      33,
+      36,
+      33,
+      33,
+      33,
+      34,
+      33,
+      37,
+      36,
+      35,
+      37,
+      37,
+      40,
+      39,
+      40,
+      40,
+      38,
+      39,
+      39,
+      42,
+      38,
+      38,
+      40,
+      38,
+      34,
+      38,
+      35,
+      34,
+      32,
+      28,
+      29,
+      29,
+      27,
+      37,
+      36,
+      37,
+      34,
+      35,
+      34,
+      30,
+      27,
+      30,
+      30,
+      25,
+      28,
+      27,
+      29,
+      26,
+      25,
+      22,
+      23,
+      25,
+      24,
+      19,
+      18,
+      24,
+      22,
+      23,
+      24,
+      25,
+      25,
+      26,
+      23,
+      27,
+      24,
+      29,
+      24,
+      20,
+      28,
+      35,
+      38,
+      41,
+      46,
+      51,
+      51,
+      50,
+      46,
+      43,
+      36,
+      32,
+      26,
+      21,
+      17,
+      16,
+      15,
+      18,
+      20,
+      27,
+      31,
+      34,
+      38,
+      44,
+      43,
+      43,
+      42,
+      35,
+      35,
+      28,
+      25,
+      21
+    ],
+    "18": [
+      34,
+      32,
+      33,
+      32,
+      30,
+      31,
+      30,
+      30,
+      33,
+      32,
+      32,
+      34,
+      37,
+      37,
+      36,
+      37,
+      37,
+      42,
+      42,
+      43,
+      43,
+      46,
+      47,
+      45,
+      44,
+      46,
+      46,
+      50,
+      48,
+      50,
+      48,
+      51,
+      50,
+      47,
+      47,
+      45,
+      46,
+      44,
+      46,
+      43,
+      46,
+      43,
+      42,
+      44,
+      44,
+      42,
+      41,
+      40,
+      41,
+      44,
+      37,
+      40,
+      38,
+      37,
+      26,
+      34,
+      35,
+      29,
+      31,
+      29,
+      26,
+      26,
+      27,
+      24,
+      21,
+      23,
+      22,
+      28,
+      20,
+      17,
+      17,
+      20,
+      22,
+      16,
+      14,
+      15,
+      15,
+      17,
+      18,
+      18,
+      18,
+      19,
+      20,
+      19,
+      15,
+      20,
+      18,
+      24,
+      23,
+      23,
+      23,
+      21,
+      25,
+      27,
+      28,
+      29,
+      28,
+      32,
+      33,
+      37
+    ],
+    "19": [
+      30,
+      36,
+      36,
+      31,
+      34,
+      32,
+      33,
+      35,
+      33,
+      36,
+      35,
+      38,
+      38,
+      38,
+      39,
+      39,
+      40,
+      39,
+      38,
+      41,
+      41,
+      41,
+      42,
+      40,
+      44,
+      38,
+      38,
+      38,
+      35,
+      36,
+      35,
+      28,
+      32,
+      43,
+      45,
+      43,
+      39,
+      42,
+      37,
+      42,
+      41,
+      36,
+      37,
+      37,
+      37,
+      35,
+      37,
+      37,
+      32,
+      33,
+      27,
+      29,
+      28,
+      27,
+      30,
+      28,
+      23,
+      26,
+      26,
+      18,
+      21,
+      20,
+      18,
+      16,
+      17,
+      15,
+      65,
+      65,
+      60,
+      55,
+      55,
+      46,
+      39,
+      35,
+      30,
+      22,
+      22,
+      17,
+      15,
+      19,
+      17,
+      22,
+      24,
+      29,
+      33,
+      40,
+      41,
+      43,
+      41,
+      41,
+      41,
+      40,
+      34,
+      31,
+      26,
+      23,
+      21,
+      17,
+      17,
+      17
+    ]
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-11-12.143728/load_limits.json b/test_instances/2026-06-30_15-11-12.143728/load_limits.json
new file mode 100644
index 0000000..1ab4853
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/load_limits.json
@@ -0,0 +1,69 @@
+{
+  "0": {
+    "0": null,
+    "1": null,
+    "2": null,
+    "3": null,
+    "4": null,
+    "5": null,
+    "6": null,
+    "7": null,
+    "8": null,
+    "9": null,
+    "10": null,
+    "11": null,
+    "12": null,
+    "13": null,
+    "14": null,
+    "15": null,
+    "16": null,
+    "17": null,
+    "18": null,
+    "19": null
+  },
+  "1": {
+    "0": 69.875,
+    "1": 69.875,
+    "2": 282.499,
+    "3": 282.499,
+    "4": 679.399,
+    "5": 679.399,
+    "6": 679.399,
+    "7": 679.399,
+    "8": 679.399,
+    "9": 679.399,
+    "10": 679.399,
+    "11": 1189.698,
+    "12": 1189.698,
+    "13": 1189.698,
+    "14": 1189.698,
+    "15": 1189.698,
+    "16": 1586.597,
+    "17": 1586.597,
+    "18": 1586.597,
+    "19": 1586.597
+  },
+  "2": {
+    "0": 54.556,
+    "1": 54.556,
+    "2": 221.222,
+    "3": 221.222,
+    "4": 532.333,
+    "5": 532.333,
+    "6": 532.333,
+    "7": 532.333,
+    "8": 532.333,
+    "9": 532.333,
+    "10": 532.333,
+    "11": 932.333,
+    "12": 932.333,
+    "13": 932.333,
+    "14": 932.333,
+    "15": 932.333,
+    "16": 1243.444,
+    "17": 1243.444,
+    "18": 1243.444,
+    "19": 1243.444
+  },
+  "load_existing": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_10-46-29.818581"
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-11-12.143728/obj.csv b/test_instances/2026-06-30_15-11-12.143728/obj.csv
new file mode 100644
index 0000000..30ef094
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+34.07725189579878
+33.130297167478254
+33.28766575981739
+32.07671384443888
+32.01851310348214
+36.07592858639474
+34.517661584984516
+35.92112759935683
+36.77835857611594
+37.21165826842786
diff --git a/test_instances/2026-06-30_15-11-12.143728/runtime.csv b/test_instances/2026-06-30_15-11-12.143728/runtime.csv
new file mode 100644
index 0000000..b0b0516
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/runtime.csv
@@ -0,0 +1,11 @@
+tot
+0.7887977
+0.7384066499999999
+0.7000752499999999
+0.6898462
+0.8191956499999999
+0.84083975
+0.5784033
+0.7269458000000001
+0.5788372
+0.5803094999999999
diff --git a/test_instances/2026-06-30_15-11-12.143728/sp.png b/test_instances/2026-06-30_15-11-12.143728/sp.png
new file mode 100644
index 0000000..85e944b
Binary files /dev/null and b/test_instances/2026-06-30_15-11-12.143728/sp.png differ
diff --git a/test_instances/2026-06-30_15-11-12.143728/termination_condition.csv b/test_instances/2026-06-30_15-11-12.143728/termination_condition.csv
new file mode 100644
index 0000000..2488418
--- /dev/null
+++ b/test_instances/2026-06-30_15-11-12.143728/termination_condition.csv
@@ -0,0 +1,11 @@
+,0
+0,max iterations reached (it: 99; best centralized it: 15; total runtime: 0.7887977)
+1,max iterations reached (it: 99; best centralized it: 17; total runtime: 0.7384066499999999)
+2,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.7000752499999999)
+3,max iterations reached (it: 99; best centralized it: 13; total runtime: 0.6898462)
+4,max iterations reached (it: 99; best centralized it: 15; total runtime: 0.8191956499999999)
+5,max iterations reached (it: 99; best centralized it: 17; total runtime: 0.84083975)
+6,no available or convenient sellers (it: 12; best centralized it: 11; total runtime: 0.5784033)
+7,max iterations reached (it: 99; best centralized it: 14; total runtime: 0.7269458000000001)
+8,no available or convenient sellers (it: 11; best centralized it: 10; total runtime: 0.5788372)
+9,no available or convenient sellers (it: 10; best centralized it: 9; total runtime: 0.5803094999999999)
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloaded_processing.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloaded_processing.csv
new file mode 100644
index 0000000..4f1d89b
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.6511627906976747,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.28368794326240376,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6784140969163133,0.0,0.709251101321577,0.0,0.0,0.0,0.0,0.0,0.0,0.3744493392070438,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.116279069767451,0.0,0.0,0.7906976744185954,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.879432624113484,0.6524822695035439,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.720930232558146,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,5.0813703488372255,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,1.0,0.0,0.48815280464216215,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.12334801762114012,0.0,0.0,4.229074889867846,0.0,0.0,12.687224669603523,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4418604651162781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.0,0.0,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.008810572687224294,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7209302325581461,0.0,0.0,0.0,0.0,0.0,0.0,1.2093023255813904,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7268722466960327,0.0,0.0,0.0,0.0,0.0,0.0,0.4493392070484603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.6976744186046631,0.4999750000000208,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9339207048458036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25581395348837077,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.7911025145067763,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3255813953488378,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069804,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.4081237911025193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976685,0.0,0.0,0.0,54.69767441860466,3.0,0.0,29.348837209302275,84.0,0.0,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8297872340425556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,34.15418502202641,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1860465116279073,0.0,120.60465116279067,0.0,2.0,63.604651162790745,38.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,1.8105726872246635,0.0,0.0,0.0,0.0,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.32558139534884845,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3984526112185771,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8854625550660558,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372092693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.4152965828497808,0.125,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0881057268722145,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9302325581395365,0.0,33.02325581395348,0.0,8.0,0.0,27.709327325581384,17.0,0.0,0.0,0.0,0.0,2.1743936046511863,0.0,0.0,0.0,0.0,0.0,0.0,1.4268214055448178,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,0.6784140969162848,33.75330396475766,8.189427312775337,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5116279069767415,0.0,81.0,0.0,0.0,0.0,84.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069377,0.0,0.0,0.0,0.0,0.5764023210831262,7.44294003868472,8.382898130238516,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,1.7533039647576913,46.493392070484674,0.0,0.0,0.0,17.295154185022028,0.0,0.0,54.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,103.0,156.0,41.0,90.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8372093023256468,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.302325581395337,20.0,84.44186046511629,0.0,42.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.2733720180528758,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,48.40969162995599,8.0,9.0,0.6079295154184479,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,105.11627906976743,53.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2727272727272725,0.0,0.0,0.38684719535783785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,59.889867841409654,0.0,56.44052863436134,2.207048458149785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloading.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloading.csv
new file mode 100644
index 0000000..69b7c28
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/detailed_offloading.csv
@@ -0,0 +1,2 @@
+n0_f0_n1,n0_f0_n2,n0_f0_n3,n0_f0_n4,n0_f0_n5,n0_f0_n6,n0_f0_n7,n0_f0_n8,n0_f0_n9,n0_f0_n10,n0_f0_n11,n0_f0_n12,n0_f0_n13,n0_f0_n14,n0_f0_n15,n0_f0_n16,n0_f0_n17,n0_f0_n18,n0_f0_n19,n0_f1_n1,n0_f1_n2,n0_f1_n3,n0_f1_n4,n0_f1_n5,n0_f1_n6,n0_f1_n7,n0_f1_n8,n0_f1_n9,n0_f1_n10,n0_f1_n11,n0_f1_n12,n0_f1_n13,n0_f1_n14,n0_f1_n15,n0_f1_n16,n0_f1_n17,n0_f1_n18,n0_f1_n19,n0_f2_n1,n0_f2_n2,n0_f2_n3,n0_f2_n4,n0_f2_n5,n0_f2_n6,n0_f2_n7,n0_f2_n8,n0_f2_n9,n0_f2_n10,n0_f2_n11,n0_f2_n12,n0_f2_n13,n0_f2_n14,n0_f2_n15,n0_f2_n16,n0_f2_n17,n0_f2_n18,n0_f2_n19,n1_f0_n0,n1_f0_n2,n1_f0_n3,n1_f0_n4,n1_f0_n5,n1_f0_n6,n1_f0_n7,n1_f0_n8,n1_f0_n9,n1_f0_n10,n1_f0_n11,n1_f0_n12,n1_f0_n13,n1_f0_n14,n1_f0_n15,n1_f0_n16,n1_f0_n17,n1_f0_n18,n1_f0_n19,n1_f1_n0,n1_f1_n2,n1_f1_n3,n1_f1_n4,n1_f1_n5,n1_f1_n6,n1_f1_n7,n1_f1_n8,n1_f1_n9,n1_f1_n10,n1_f1_n11,n1_f1_n12,n1_f1_n13,n1_f1_n14,n1_f1_n15,n1_f1_n16,n1_f1_n17,n1_f1_n18,n1_f1_n19,n1_f2_n0,n1_f2_n2,n1_f2_n3,n1_f2_n4,n1_f2_n5,n1_f2_n6,n1_f2_n7,n1_f2_n8,n1_f2_n9,n1_f2_n10,n1_f2_n11,n1_f2_n12,n1_f2_n13,n1_f2_n14,n1_f2_n15,n1_f2_n16,n1_f2_n17,n1_f2_n18,n1_f2_n19,n2_f0_n0,n2_f0_n1,n2_f0_n3,n2_f0_n4,n2_f0_n5,n2_f0_n6,n2_f0_n7,n2_f0_n8,n2_f0_n9,n2_f0_n10,n2_f0_n11,n2_f0_n12,n2_f0_n13,n2_f0_n14,n2_f0_n15,n2_f0_n16,n2_f0_n17,n2_f0_n18,n2_f0_n19,n2_f1_n0,n2_f1_n1,n2_f1_n3,n2_f1_n4,n2_f1_n5,n2_f1_n6,n2_f1_n7,n2_f1_n8,n2_f1_n9,n2_f1_n10,n2_f1_n11,n2_f1_n12,n2_f1_n13,n2_f1_n14,n2_f1_n15,n2_f1_n16,n2_f1_n17,n2_f1_n18,n2_f1_n19,n2_f2_n0,n2_f2_n1,n2_f2_n3,n2_f2_n4,n2_f2_n5,n2_f2_n6,n2_f2_n7,n2_f2_n8,n2_f2_n9,n2_f2_n10,n2_f2_n11,n2_f2_n12,n2_f2_n13,n2_f2_n14,n2_f2_n15,n2_f2_n16,n2_f2_n17,n2_f2_n18,n2_f2_n19,n3_f0_n0,n3_f0_n1,n3_f0_n2,n3_f0_n4,n3_f0_n5,n3_f0_n6,n3_f0_n7,n3_f0_n8,n3_f0_n9,n3_f0_n10,n3_f0_n11,n3_f0_n12,n3_f0_n13,n3_f0_n14,n3_f0_n15,n3_f0_n16,n3_f0_n17,n3_f0_n18,n3_f0_n19,n3_f1_n0,n3_f1_n1,n3_f1_n2,n3_f1_n4,n3_f1_n5,n3_f1_n6,n3_f1_n7,n3_f1_n8,n3_f1_n9,n3_f1_n10,n3_f1_n11,n3_f1_n12,n3_f1_n13,n3_f1_n14,n3_f1_n15,n3_f1_n16,n3_f1_n17,n3_f1_n18,n3_f1_n19,n3_f2_n0,n3_f2_n1,n3_f2_n2,n3_f2_n4,n3_f2_n5,n3_f2_n6,n3_f2_n7,n3_f2_n8,n3_f2_n9,n3_f2_n10,n3_f2_n11,n3_f2_n12,n3_f2_n13,n3_f2_n14,n3_f2_n15,n3_f2_n16,n3_f2_n17,n3_f2_n18,n3_f2_n19,n4_f0_n0,n4_f0_n1,n4_f0_n2,n4_f0_n3,n4_f0_n5,n4_f0_n6,n4_f0_n7,n4_f0_n8,n4_f0_n9,n4_f0_n10,n4_f0_n11,n4_f0_n12,n4_f0_n13,n4_f0_n14,n4_f0_n15,n4_f0_n16,n4_f0_n17,n4_f0_n18,n4_f0_n19,n4_f1_n0,n4_f1_n1,n4_f1_n2,n4_f1_n3,n4_f1_n5,n4_f1_n6,n4_f1_n7,n4_f1_n8,n4_f1_n9,n4_f1_n10,n4_f1_n11,n4_f1_n12,n4_f1_n13,n4_f1_n14,n4_f1_n15,n4_f1_n16,n4_f1_n17,n4_f1_n18,n4_f1_n19,n4_f2_n0,n4_f2_n1,n4_f2_n2,n4_f2_n3,n4_f2_n5,n4_f2_n6,n4_f2_n7,n4_f2_n8,n4_f2_n9,n4_f2_n10,n4_f2_n11,n4_f2_n12,n4_f2_n13,n4_f2_n14,n4_f2_n15,n4_f2_n16,n4_f2_n17,n4_f2_n18,n4_f2_n19,n5_f0_n0,n5_f0_n1,n5_f0_n2,n5_f0_n3,n5_f0_n4,n5_f0_n6,n5_f0_n7,n5_f0_n8,n5_f0_n9,n5_f0_n10,n5_f0_n11,n5_f0_n12,n5_f0_n13,n5_f0_n14,n5_f0_n15,n5_f0_n16,n5_f0_n17,n5_f0_n18,n5_f0_n19,n5_f1_n0,n5_f1_n1,n5_f1_n2,n5_f1_n3,n5_f1_n4,n5_f1_n6,n5_f1_n7,n5_f1_n8,n5_f1_n9,n5_f1_n10,n5_f1_n11,n5_f1_n12,n5_f1_n13,n5_f1_n14,n5_f1_n15,n5_f1_n16,n5_f1_n17,n5_f1_n18,n5_f1_n19,n5_f2_n0,n5_f2_n1,n5_f2_n2,n5_f2_n3,n5_f2_n4,n5_f2_n6,n5_f2_n7,n5_f2_n8,n5_f2_n9,n5_f2_n10,n5_f2_n11,n5_f2_n12,n5_f2_n13,n5_f2_n14,n5_f2_n15,n5_f2_n16,n5_f2_n17,n5_f2_n18,n5_f2_n19,n6_f0_n0,n6_f0_n1,n6_f0_n2,n6_f0_n3,n6_f0_n4,n6_f0_n5,n6_f0_n7,n6_f0_n8,n6_f0_n9,n6_f0_n10,n6_f0_n11,n6_f0_n12,n6_f0_n13,n6_f0_n14,n6_f0_n15,n6_f0_n16,n6_f0_n17,n6_f0_n18,n6_f0_n19,n6_f1_n0,n6_f1_n1,n6_f1_n2,n6_f1_n3,n6_f1_n4,n6_f1_n5,n6_f1_n7,n6_f1_n8,n6_f1_n9,n6_f1_n10,n6_f1_n11,n6_f1_n12,n6_f1_n13,n6_f1_n14,n6_f1_n15,n6_f1_n16,n6_f1_n17,n6_f1_n18,n6_f1_n19,n6_f2_n0,n6_f2_n1,n6_f2_n2,n6_f2_n3,n6_f2_n4,n6_f2_n5,n6_f2_n7,n6_f2_n8,n6_f2_n9,n6_f2_n10,n6_f2_n11,n6_f2_n12,n6_f2_n13,n6_f2_n14,n6_f2_n15,n6_f2_n16,n6_f2_n17,n6_f2_n18,n6_f2_n19,n7_f0_n0,n7_f0_n1,n7_f0_n2,n7_f0_n3,n7_f0_n4,n7_f0_n5,n7_f0_n6,n7_f0_n8,n7_f0_n9,n7_f0_n10,n7_f0_n11,n7_f0_n12,n7_f0_n13,n7_f0_n14,n7_f0_n15,n7_f0_n16,n7_f0_n17,n7_f0_n18,n7_f0_n19,n7_f1_n0,n7_f1_n1,n7_f1_n2,n7_f1_n3,n7_f1_n4,n7_f1_n5,n7_f1_n6,n7_f1_n8,n7_f1_n9,n7_f1_n10,n7_f1_n11,n7_f1_n12,n7_f1_n13,n7_f1_n14,n7_f1_n15,n7_f1_n16,n7_f1_n17,n7_f1_n18,n7_f1_n19,n7_f2_n0,n7_f2_n1,n7_f2_n2,n7_f2_n3,n7_f2_n4,n7_f2_n5,n7_f2_n6,n7_f2_n8,n7_f2_n9,n7_f2_n10,n7_f2_n11,n7_f2_n12,n7_f2_n13,n7_f2_n14,n7_f2_n15,n7_f2_n16,n7_f2_n17,n7_f2_n18,n7_f2_n19,n8_f0_n0,n8_f0_n1,n8_f0_n2,n8_f0_n3,n8_f0_n4,n8_f0_n5,n8_f0_n6,n8_f0_n7,n8_f0_n9,n8_f0_n10,n8_f0_n11,n8_f0_n12,n8_f0_n13,n8_f0_n14,n8_f0_n15,n8_f0_n16,n8_f0_n17,n8_f0_n18,n8_f0_n19,n8_f1_n0,n8_f1_n1,n8_f1_n2,n8_f1_n3,n8_f1_n4,n8_f1_n5,n8_f1_n6,n8_f1_n7,n8_f1_n9,n8_f1_n10,n8_f1_n11,n8_f1_n12,n8_f1_n13,n8_f1_n14,n8_f1_n15,n8_f1_n16,n8_f1_n17,n8_f1_n18,n8_f1_n19,n8_f2_n0,n8_f2_n1,n8_f2_n2,n8_f2_n3,n8_f2_n4,n8_f2_n5,n8_f2_n6,n8_f2_n7,n8_f2_n9,n8_f2_n10,n8_f2_n11,n8_f2_n12,n8_f2_n13,n8_f2_n14,n8_f2_n15,n8_f2_n16,n8_f2_n17,n8_f2_n18,n8_f2_n19,n9_f0_n0,n9_f0_n1,n9_f0_n2,n9_f0_n3,n9_f0_n4,n9_f0_n5,n9_f0_n6,n9_f0_n7,n9_f0_n8,n9_f0_n10,n9_f0_n11,n9_f0_n12,n9_f0_n13,n9_f0_n14,n9_f0_n15,n9_f0_n16,n9_f0_n17,n9_f0_n18,n9_f0_n19,n9_f1_n0,n9_f1_n1,n9_f1_n2,n9_f1_n3,n9_f1_n4,n9_f1_n5,n9_f1_n6,n9_f1_n7,n9_f1_n8,n9_f1_n10,n9_f1_n11,n9_f1_n12,n9_f1_n13,n9_f1_n14,n9_f1_n15,n9_f1_n16,n9_f1_n17,n9_f1_n18,n9_f1_n19,n9_f2_n0,n9_f2_n1,n9_f2_n2,n9_f2_n3,n9_f2_n4,n9_f2_n5,n9_f2_n6,n9_f2_n7,n9_f2_n8,n9_f2_n10,n9_f2_n11,n9_f2_n12,n9_f2_n13,n9_f2_n14,n9_f2_n15,n9_f2_n16,n9_f2_n17,n9_f2_n18,n9_f2_n19,n10_f0_n0,n10_f0_n1,n10_f0_n2,n10_f0_n3,n10_f0_n4,n10_f0_n5,n10_f0_n6,n10_f0_n7,n10_f0_n8,n10_f0_n9,n10_f0_n11,n10_f0_n12,n10_f0_n13,n10_f0_n14,n10_f0_n15,n10_f0_n16,n10_f0_n17,n10_f0_n18,n10_f0_n19,n10_f1_n0,n10_f1_n1,n10_f1_n2,n10_f1_n3,n10_f1_n4,n10_f1_n5,n10_f1_n6,n10_f1_n7,n10_f1_n8,n10_f1_n9,n10_f1_n11,n10_f1_n12,n10_f1_n13,n10_f1_n14,n10_f1_n15,n10_f1_n16,n10_f1_n17,n10_f1_n18,n10_f1_n19,n10_f2_n0,n10_f2_n1,n10_f2_n2,n10_f2_n3,n10_f2_n4,n10_f2_n5,n10_f2_n6,n10_f2_n7,n10_f2_n8,n10_f2_n9,n10_f2_n11,n10_f2_n12,n10_f2_n13,n10_f2_n14,n10_f2_n15,n10_f2_n16,n10_f2_n17,n10_f2_n18,n10_f2_n19,n11_f0_n0,n11_f0_n1,n11_f0_n2,n11_f0_n3,n11_f0_n4,n11_f0_n5,n11_f0_n6,n11_f0_n7,n11_f0_n8,n11_f0_n9,n11_f0_n10,n11_f0_n12,n11_f0_n13,n11_f0_n14,n11_f0_n15,n11_f0_n16,n11_f0_n17,n11_f0_n18,n11_f0_n19,n11_f1_n0,n11_f1_n1,n11_f1_n2,n11_f1_n3,n11_f1_n4,n11_f1_n5,n11_f1_n6,n11_f1_n7,n11_f1_n8,n11_f1_n9,n11_f1_n10,n11_f1_n12,n11_f1_n13,n11_f1_n14,n11_f1_n15,n11_f1_n16,n11_f1_n17,n11_f1_n18,n11_f1_n19,n11_f2_n0,n11_f2_n1,n11_f2_n2,n11_f2_n3,n11_f2_n4,n11_f2_n5,n11_f2_n6,n11_f2_n7,n11_f2_n8,n11_f2_n9,n11_f2_n10,n11_f2_n12,n11_f2_n13,n11_f2_n14,n11_f2_n15,n11_f2_n16,n11_f2_n17,n11_f2_n18,n11_f2_n19,n12_f0_n0,n12_f0_n1,n12_f0_n2,n12_f0_n3,n12_f0_n4,n12_f0_n5,n12_f0_n6,n12_f0_n7,n12_f0_n8,n12_f0_n9,n12_f0_n10,n12_f0_n11,n12_f0_n13,n12_f0_n14,n12_f0_n15,n12_f0_n16,n12_f0_n17,n12_f0_n18,n12_f0_n19,n12_f1_n0,n12_f1_n1,n12_f1_n2,n12_f1_n3,n12_f1_n4,n12_f1_n5,n12_f1_n6,n12_f1_n7,n12_f1_n8,n12_f1_n9,n12_f1_n10,n12_f1_n11,n12_f1_n13,n12_f1_n14,n12_f1_n15,n12_f1_n16,n12_f1_n17,n12_f1_n18,n12_f1_n19,n12_f2_n0,n12_f2_n1,n12_f2_n2,n12_f2_n3,n12_f2_n4,n12_f2_n5,n12_f2_n6,n12_f2_n7,n12_f2_n8,n12_f2_n9,n12_f2_n10,n12_f2_n11,n12_f2_n13,n12_f2_n14,n12_f2_n15,n12_f2_n16,n12_f2_n17,n12_f2_n18,n12_f2_n19,n13_f0_n0,n13_f0_n1,n13_f0_n2,n13_f0_n3,n13_f0_n4,n13_f0_n5,n13_f0_n6,n13_f0_n7,n13_f0_n8,n13_f0_n9,n13_f0_n10,n13_f0_n11,n13_f0_n12,n13_f0_n14,n13_f0_n15,n13_f0_n16,n13_f0_n17,n13_f0_n18,n13_f0_n19,n13_f1_n0,n13_f1_n1,n13_f1_n2,n13_f1_n3,n13_f1_n4,n13_f1_n5,n13_f1_n6,n13_f1_n7,n13_f1_n8,n13_f1_n9,n13_f1_n10,n13_f1_n11,n13_f1_n12,n13_f1_n14,n13_f1_n15,n13_f1_n16,n13_f1_n17,n13_f1_n18,n13_f1_n19,n13_f2_n0,n13_f2_n1,n13_f2_n2,n13_f2_n3,n13_f2_n4,n13_f2_n5,n13_f2_n6,n13_f2_n7,n13_f2_n8,n13_f2_n9,n13_f2_n10,n13_f2_n11,n13_f2_n12,n13_f2_n14,n13_f2_n15,n13_f2_n16,n13_f2_n17,n13_f2_n18,n13_f2_n19,n14_f0_n0,n14_f0_n1,n14_f0_n2,n14_f0_n3,n14_f0_n4,n14_f0_n5,n14_f0_n6,n14_f0_n7,n14_f0_n8,n14_f0_n9,n14_f0_n10,n14_f0_n11,n14_f0_n12,n14_f0_n13,n14_f0_n15,n14_f0_n16,n14_f0_n17,n14_f0_n18,n14_f0_n19,n14_f1_n0,n14_f1_n1,n14_f1_n2,n14_f1_n3,n14_f1_n4,n14_f1_n5,n14_f1_n6,n14_f1_n7,n14_f1_n8,n14_f1_n9,n14_f1_n10,n14_f1_n11,n14_f1_n12,n14_f1_n13,n14_f1_n15,n14_f1_n16,n14_f1_n17,n14_f1_n18,n14_f1_n19,n14_f2_n0,n14_f2_n1,n14_f2_n2,n14_f2_n3,n14_f2_n4,n14_f2_n5,n14_f2_n6,n14_f2_n7,n14_f2_n8,n14_f2_n9,n14_f2_n10,n14_f2_n11,n14_f2_n12,n14_f2_n13,n14_f2_n15,n14_f2_n16,n14_f2_n17,n14_f2_n18,n14_f2_n19,n15_f0_n0,n15_f0_n1,n15_f0_n2,n15_f0_n3,n15_f0_n4,n15_f0_n5,n15_f0_n6,n15_f0_n7,n15_f0_n8,n15_f0_n9,n15_f0_n10,n15_f0_n11,n15_f0_n12,n15_f0_n13,n15_f0_n14,n15_f0_n16,n15_f0_n17,n15_f0_n18,n15_f0_n19,n15_f1_n0,n15_f1_n1,n15_f1_n2,n15_f1_n3,n15_f1_n4,n15_f1_n5,n15_f1_n6,n15_f1_n7,n15_f1_n8,n15_f1_n9,n15_f1_n10,n15_f1_n11,n15_f1_n12,n15_f1_n13,n15_f1_n14,n15_f1_n16,n15_f1_n17,n15_f1_n18,n15_f1_n19,n15_f2_n0,n15_f2_n1,n15_f2_n2,n15_f2_n3,n15_f2_n4,n15_f2_n5,n15_f2_n6,n15_f2_n7,n15_f2_n8,n15_f2_n9,n15_f2_n10,n15_f2_n11,n15_f2_n12,n15_f2_n13,n15_f2_n14,n15_f2_n16,n15_f2_n17,n15_f2_n18,n15_f2_n19,n16_f0_n0,n16_f0_n1,n16_f0_n2,n16_f0_n3,n16_f0_n4,n16_f0_n5,n16_f0_n6,n16_f0_n7,n16_f0_n8,n16_f0_n9,n16_f0_n10,n16_f0_n11,n16_f0_n12,n16_f0_n13,n16_f0_n14,n16_f0_n15,n16_f0_n17,n16_f0_n18,n16_f0_n19,n16_f1_n0,n16_f1_n1,n16_f1_n2,n16_f1_n3,n16_f1_n4,n16_f1_n5,n16_f1_n6,n16_f1_n7,n16_f1_n8,n16_f1_n9,n16_f1_n10,n16_f1_n11,n16_f1_n12,n16_f1_n13,n16_f1_n14,n16_f1_n15,n16_f1_n17,n16_f1_n18,n16_f1_n19,n16_f2_n0,n16_f2_n1,n16_f2_n2,n16_f2_n3,n16_f2_n4,n16_f2_n5,n16_f2_n6,n16_f2_n7,n16_f2_n8,n16_f2_n9,n16_f2_n10,n16_f2_n11,n16_f2_n12,n16_f2_n13,n16_f2_n14,n16_f2_n15,n16_f2_n17,n16_f2_n18,n16_f2_n19,n17_f0_n0,n17_f0_n1,n17_f0_n2,n17_f0_n3,n17_f0_n4,n17_f0_n5,n17_f0_n6,n17_f0_n7,n17_f0_n8,n17_f0_n9,n17_f0_n10,n17_f0_n11,n17_f0_n12,n17_f0_n13,n17_f0_n14,n17_f0_n15,n17_f0_n16,n17_f0_n18,n17_f0_n19,n17_f1_n0,n17_f1_n1,n17_f1_n2,n17_f1_n3,n17_f1_n4,n17_f1_n5,n17_f1_n6,n17_f1_n7,n17_f1_n8,n17_f1_n9,n17_f1_n10,n17_f1_n11,n17_f1_n12,n17_f1_n13,n17_f1_n14,n17_f1_n15,n17_f1_n16,n17_f1_n18,n17_f1_n19,n17_f2_n0,n17_f2_n1,n17_f2_n2,n17_f2_n3,n17_f2_n4,n17_f2_n5,n17_f2_n6,n17_f2_n7,n17_f2_n8,n17_f2_n9,n17_f2_n10,n17_f2_n11,n17_f2_n12,n17_f2_n13,n17_f2_n14,n17_f2_n15,n17_f2_n16,n17_f2_n18,n17_f2_n19,n18_f0_n0,n18_f0_n1,n18_f0_n2,n18_f0_n3,n18_f0_n4,n18_f0_n5,n18_f0_n6,n18_f0_n7,n18_f0_n8,n18_f0_n9,n18_f0_n10,n18_f0_n11,n18_f0_n12,n18_f0_n13,n18_f0_n14,n18_f0_n15,n18_f0_n16,n18_f0_n17,n18_f0_n19,n18_f1_n0,n18_f1_n1,n18_f1_n2,n18_f1_n3,n18_f1_n4,n18_f1_n5,n18_f1_n6,n18_f1_n7,n18_f1_n8,n18_f1_n9,n18_f1_n10,n18_f1_n11,n18_f1_n12,n18_f1_n13,n18_f1_n14,n18_f1_n15,n18_f1_n16,n18_f1_n17,n18_f1_n19,n18_f2_n0,n18_f2_n1,n18_f2_n2,n18_f2_n3,n18_f2_n4,n18_f2_n5,n18_f2_n6,n18_f2_n7,n18_f2_n8,n18_f2_n9,n18_f2_n10,n18_f2_n11,n18_f2_n12,n18_f2_n13,n18_f2_n14,n18_f2_n15,n18_f2_n16,n18_f2_n17,n18_f2_n19,n19_f0_n0,n19_f0_n1,n19_f0_n2,n19_f0_n3,n19_f0_n4,n19_f0_n5,n19_f0_n6,n19_f0_n7,n19_f0_n8,n19_f0_n9,n19_f0_n10,n19_f0_n11,n19_f0_n12,n19_f0_n13,n19_f0_n14,n19_f0_n15,n19_f0_n16,n19_f0_n17,n19_f0_n18,n19_f1_n0,n19_f1_n1,n19_f1_n2,n19_f1_n3,n19_f1_n4,n19_f1_n5,n19_f1_n6,n19_f1_n7,n19_f1_n8,n19_f1_n9,n19_f1_n10,n19_f1_n11,n19_f1_n12,n19_f1_n13,n19_f1_n14,n19_f1_n15,n19_f1_n16,n19_f1_n17,n19_f1_n18,n19_f2_n0,n19_f2_n1,n19_f2_n2,n19_f2_n3,n19_f2_n4,n19_f2_n5,n19_f2_n6,n19_f2_n7,n19_f2_n8,n19_f2_n9,n19_f2_n10,n19_f2_n11,n19_f2_n12,n19_f2_n13,n19_f2_n14,n19_f2_n15,n19_f2_n16,n19_f2_n17,n19_f2_n18
+0.0,0.0,1.116279069767451,0.0,2.720930232558146,0.4418604651162781,1.7209302325581461,1.0,0.25581395348837077,0.3255813953488378,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.302325581395337,105.11627906976743,0.34751773049645607,0.39007092198582427,0.879432624113484,0.0851063829787364,1.2727272727272725,1.2727272727272725,1.0851063829787364,0.0,1.2727272727272725,1.2727272727272725,0.0,0.0,0.0,0.0,0.0,0.5764023210831262,2.0,1.2727272727272725,2.2727272727272725,0.0,0.6784140969163133,0.0,0.4977973568281868,0.12334801762114012,0.008810572687224294,0.7268722466960327,0.0,0.5506607929515468,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,48.40969162995599,59.889867841409654,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,103.0,20.0,53.0,0.34751773049645607,0.28368794326240376,0.6524822695035439,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,7.44294003868472,0.0,0.2733720180528758,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,24.0,29.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976685,0.0,0.32558139534884845,0.13953488372092693,2.9302325581395365,1.5116279069767415,156.0,84.44186046511629,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.7911025145067763,0.4081237911025193,0.8297872340425556,0.0,1.3984526112185771,1.4152965828497808,1.4268214055448178,8.382898130238516,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,34.15418502202641,0.0,0.8854625550660558,1.0881057268722145,0.6784140969162848,1.7533039647576913,0.0,9.0,56.44052863436134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,41.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48815280464216215,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.125,0.0,0.0,0.0,0.0,0.38684719535783785,0.0,0.0,0.709251101321577,0.0,4.229074889867846,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,0.0,33.75330396475766,46.493392070484674,0.0,0.6079295154184479,2.207048458149785,0.0,0.0,0.0,0.7906976744185954,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1860465116279073,0.0,0.0,33.02325581395348,81.0,90.0,42.0,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.0909090909090909,0.0909090909090909,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8105726872246635,0.0,0.0,8.189427312775337,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6976744186046631,0.0,0.0,54.69767441860466,120.60465116279067,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,0.0,0.4999750000000208,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.687224669603523,0.0,0.9339207048458036,0.0,0.0,14.0,0.0,0.0,0.0,22.0,17.295154185022028,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,5.0813703488372255,0.0,1.2093023255813904,0.0,0.0,0.0,2.0,0.0,0.0,27.709327325581384,84.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4493392070484603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069804,29.348837209302275,63.604651162790745,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976747,0.0,0.0,0.0,0.0,0.0,0.0,0.0,84.0,38.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3744493392070438,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,0.0,0.0,0.0,54.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1743936046511863,1.0465116279069377,1.8372093023256468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/local_processing.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/local_processing.csv
new file mode 100644
index 0000000..f019304
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/local_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,41.0,0.0,26.0,35.0,0.0,0.0,68.0,101.0,81.0,41.0,76.0,47.0,63.0,74.0,78.0,67.0,39.0,25.0,31.0,164.0,103.0,49.0,65.0,42.0,63.0,76.0,84.0,23.0,135.0,103.0,47.0,65.0,167.0,70.0,166.0,218.0,49.0,179.0,98.0,66.0,74.0,145.0,25.0,137.0,217.0,25.0,101.0,168.0,62.0,82.0,105.0,45.0,194.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloaded_processing.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloaded_processing.csv
new file mode 100644
index 0000000..0e9f5b5
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloaded_processing.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,4.651162790697675,0.673758865248228,1.762114537444934,1.9069767441860463,1.879432624113484,0.0,0.0,0.0851063829787364,0.4977973568281868,8.302325581395351,3.003304319793677,17.03964757709251,0.4418604651162781,1.515151515151515,0.008810572687224294,2.9302325581395365,1.0851063829787364,1.176211453744493,2.197649418604684,0.0,0.9339207048458036,0.25581395348837077,2.0638297872340488,0.5506607929515468,2.372093023255818,1.6808510638297918,0.1145374449339207,182.6976744186046,0.8297872340425556,55.15418502202641,225.39534883720933,0.24242424242424238,23.810572687224663,1.3255813953488484,1.489361702127668,0.8854625550660558,0.13953488372092693,2.6312056737588714,1.0881057268722145,90.83720930232559,1.5177304964539087,88.62114537444928,167.55813953488368,16.402240490006363,148.5418502202644,391.8372093023256,2.0,0.0,147.74418604651163,1.5460992907801483,66.01762114537443,158.11627906976742,2.6595744680851103,118.53744493392078
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloading.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloading.csv
new file mode 100644
index 0000000..7587b68
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/offloading.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+115.0,14.0,111.0,176.0,11.0,67.0,246.0,15.0,104.0,41.0,1.0,100.0,248.0,0.9999999999999998,10.0,0.0,0.0,0.0,184.0,0.0,0.0,4.0,0.0,66.91629955947135,124.0,0.0,0.4493392070484603,111.0,0.0,0.0,122.65116279069767,0.0,64.37444933920705,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,1.0,5.058114534883771,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/rejections.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/rejections.csv
new file mode 100644
index 0000000..50197c3
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/rejections.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,1.0,1.0,0.0,0.0,2.220446049250313e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.083700440528645,0.0,0.0,4.55066079295154,0.0,0.0,0.0,0.34883720930233153,0.0,52.62555066079295,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,1.0,1.9418854651162292,0.0,30.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/replicas.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/replicas.csv
new file mode 100644
index 0000000..d850497
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/replicas.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,8.0,0.0,0.0,8.0,0.0,2.0,15.0,1.0,12.0,13.0,0.0,0.0,20.0,48.0,32.0,13.0,44.0,17.0,19.0,35.0,29.0,20.0,19.0,10.0,10.0,78.0,37.0,15.0,31.0,16.0,19.0,36.0,82.0,6.0,78.0,101.0,12.0,36.0,52.0,18.0,68.0,67.0,13.0,73.0,58.0,17.0,66.0,96.0,11.0,116.0,187.0,7.0,41.0,97.0,16.0,60.0,81.0,12.0,127.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/residual_capacity.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/residual_capacity.csv
new file mode 100644
index 0000000..82dbe6e
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/residual_capacity.csv
@@ -0,0 +1,2 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,128.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1024.0,896.0,0.0,0.0,0.0,0.0,0.0,4480.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc/70/utilization.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/utilization.csv
new file mode 100644
index 0000000..a510d86
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc/70/utilization.csv
@@ -0,0 +1,2 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.7707999999999999,0.0,0.7453333333333333,0.7592307692307692,0.0,0.0,0.7989999999999999,0.7960763888888889,0.7256250000000001,0.7411538461538462,0.6534848484848484,0.7925490196078432,0.7792105263157895,0.799904761904762,0.7710344827586206,0.78725,0.7765789473684211,0.7166666666666667,0.7284999999999999,0.7954700854700855,0.7980180180180181,0.7676666666666666,0.7932795698924732,0.7525000000000001,0.7792105263157895,0.7987037037037037,0.25170731707317073,0.7721428571428571,0.5612637362637364,0.2505799151343706,0.7889285714285714,0.5855158730158732,0.7891208791208791,0.7833333333333333,0.791638655462185,0.7994882729211087,0.7592307692307692,0.7951663405088064,0.4151724137931035,0.782016806722689,0.3635930735930737,0.37113095238095234,0.4577922077922078,0.3829926108374385,0.2851336898395722,0.7193877551020408,0.7988501742160279,0.42556701030927835,0.7805357142857143,0.44319047619047625,0.31851851851851853,0.755357142857143,0.49536557930258723
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_detailed_fwd_solution.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_detailed_fwd_solution.csv
new file mode 100644
index 0000000..deb7cb6
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_detailed_fwd_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_n1_tot,n0_f0_n2_tot,n0_f0_n3_tot,n0_f0_n4_tot,n0_f0_n5_tot,n0_f0_n6_tot,n0_f0_n7_tot,n0_f0_n8_tot,n0_f0_n9_tot,n0_f0_n10_tot,n0_f0_n11_tot,n0_f0_n12_tot,n0_f0_n13_tot,n0_f0_n14_tot,n0_f0_n15_tot,n0_f0_n16_tot,n0_f0_n17_tot,n0_f0_n18_tot,n0_f0_n19_tot,n0_f1_n1_tot,n0_f1_n2_tot,n0_f1_n3_tot,n0_f1_n4_tot,n0_f1_n5_tot,n0_f1_n6_tot,n0_f1_n7_tot,n0_f1_n8_tot,n0_f1_n9_tot,n0_f1_n10_tot,n0_f1_n11_tot,n0_f1_n12_tot,n0_f1_n13_tot,n0_f1_n14_tot,n0_f1_n15_tot,n0_f1_n16_tot,n0_f1_n17_tot,n0_f1_n18_tot,n0_f1_n19_tot,n0_f2_n1_tot,n0_f2_n2_tot,n0_f2_n3_tot,n0_f2_n4_tot,n0_f2_n5_tot,n0_f2_n6_tot,n0_f2_n7_tot,n0_f2_n8_tot,n0_f2_n9_tot,n0_f2_n10_tot,n0_f2_n11_tot,n0_f2_n12_tot,n0_f2_n13_tot,n0_f2_n14_tot,n0_f2_n15_tot,n0_f2_n16_tot,n0_f2_n17_tot,n0_f2_n18_tot,n0_f2_n19_tot,n1_f0_n0_tot,n1_f0_n2_tot,n1_f0_n3_tot,n1_f0_n4_tot,n1_f0_n5_tot,n1_f0_n6_tot,n1_f0_n7_tot,n1_f0_n8_tot,n1_f0_n9_tot,n1_f0_n10_tot,n1_f0_n11_tot,n1_f0_n12_tot,n1_f0_n13_tot,n1_f0_n14_tot,n1_f0_n15_tot,n1_f0_n16_tot,n1_f0_n17_tot,n1_f0_n18_tot,n1_f0_n19_tot,n1_f1_n0_tot,n1_f1_n2_tot,n1_f1_n3_tot,n1_f1_n4_tot,n1_f1_n5_tot,n1_f1_n6_tot,n1_f1_n7_tot,n1_f1_n8_tot,n1_f1_n9_tot,n1_f1_n10_tot,n1_f1_n11_tot,n1_f1_n12_tot,n1_f1_n13_tot,n1_f1_n14_tot,n1_f1_n15_tot,n1_f1_n16_tot,n1_f1_n17_tot,n1_f1_n18_tot,n1_f1_n19_tot,n1_f2_n0_tot,n1_f2_n2_tot,n1_f2_n3_tot,n1_f2_n4_tot,n1_f2_n5_tot,n1_f2_n6_tot,n1_f2_n7_tot,n1_f2_n8_tot,n1_f2_n9_tot,n1_f2_n10_tot,n1_f2_n11_tot,n1_f2_n12_tot,n1_f2_n13_tot,n1_f2_n14_tot,n1_f2_n15_tot,n1_f2_n16_tot,n1_f2_n17_tot,n1_f2_n18_tot,n1_f2_n19_tot,n2_f0_n0_tot,n2_f0_n1_tot,n2_f0_n3_tot,n2_f0_n4_tot,n2_f0_n5_tot,n2_f0_n6_tot,n2_f0_n7_tot,n2_f0_n8_tot,n2_f0_n9_tot,n2_f0_n10_tot,n2_f0_n11_tot,n2_f0_n12_tot,n2_f0_n13_tot,n2_f0_n14_tot,n2_f0_n15_tot,n2_f0_n16_tot,n2_f0_n17_tot,n2_f0_n18_tot,n2_f0_n19_tot,n2_f1_n0_tot,n2_f1_n1_tot,n2_f1_n3_tot,n2_f1_n4_tot,n2_f1_n5_tot,n2_f1_n6_tot,n2_f1_n7_tot,n2_f1_n8_tot,n2_f1_n9_tot,n2_f1_n10_tot,n2_f1_n11_tot,n2_f1_n12_tot,n2_f1_n13_tot,n2_f1_n14_tot,n2_f1_n15_tot,n2_f1_n16_tot,n2_f1_n17_tot,n2_f1_n18_tot,n2_f1_n19_tot,n2_f2_n0_tot,n2_f2_n1_tot,n2_f2_n3_tot,n2_f2_n4_tot,n2_f2_n5_tot,n2_f2_n6_tot,n2_f2_n7_tot,n2_f2_n8_tot,n2_f2_n9_tot,n2_f2_n10_tot,n2_f2_n11_tot,n2_f2_n12_tot,n2_f2_n13_tot,n2_f2_n14_tot,n2_f2_n15_tot,n2_f2_n16_tot,n2_f2_n17_tot,n2_f2_n18_tot,n2_f2_n19_tot,n3_f0_n0_tot,n3_f0_n1_tot,n3_f0_n2_tot,n3_f0_n4_tot,n3_f0_n5_tot,n3_f0_n6_tot,n3_f0_n7_tot,n3_f0_n8_tot,n3_f0_n9_tot,n3_f0_n10_tot,n3_f0_n11_tot,n3_f0_n12_tot,n3_f0_n13_tot,n3_f0_n14_tot,n3_f0_n15_tot,n3_f0_n16_tot,n3_f0_n17_tot,n3_f0_n18_tot,n3_f0_n19_tot,n3_f1_n0_tot,n3_f1_n1_tot,n3_f1_n2_tot,n3_f1_n4_tot,n3_f1_n5_tot,n3_f1_n6_tot,n3_f1_n7_tot,n3_f1_n8_tot,n3_f1_n9_tot,n3_f1_n10_tot,n3_f1_n11_tot,n3_f1_n12_tot,n3_f1_n13_tot,n3_f1_n14_tot,n3_f1_n15_tot,n3_f1_n16_tot,n3_f1_n17_tot,n3_f1_n18_tot,n3_f1_n19_tot,n3_f2_n0_tot,n3_f2_n1_tot,n3_f2_n2_tot,n3_f2_n4_tot,n3_f2_n5_tot,n3_f2_n6_tot,n3_f2_n7_tot,n3_f2_n8_tot,n3_f2_n9_tot,n3_f2_n10_tot,n3_f2_n11_tot,n3_f2_n12_tot,n3_f2_n13_tot,n3_f2_n14_tot,n3_f2_n15_tot,n3_f2_n16_tot,n3_f2_n17_tot,n3_f2_n18_tot,n3_f2_n19_tot,n4_f0_n0_tot,n4_f0_n1_tot,n4_f0_n2_tot,n4_f0_n3_tot,n4_f0_n5_tot,n4_f0_n6_tot,n4_f0_n7_tot,n4_f0_n8_tot,n4_f0_n9_tot,n4_f0_n10_tot,n4_f0_n11_tot,n4_f0_n12_tot,n4_f0_n13_tot,n4_f0_n14_tot,n4_f0_n15_tot,n4_f0_n16_tot,n4_f0_n17_tot,n4_f0_n18_tot,n4_f0_n19_tot,n4_f1_n0_tot,n4_f1_n1_tot,n4_f1_n2_tot,n4_f1_n3_tot,n4_f1_n5_tot,n4_f1_n6_tot,n4_f1_n7_tot,n4_f1_n8_tot,n4_f1_n9_tot,n4_f1_n10_tot,n4_f1_n11_tot,n4_f1_n12_tot,n4_f1_n13_tot,n4_f1_n14_tot,n4_f1_n15_tot,n4_f1_n16_tot,n4_f1_n17_tot,n4_f1_n18_tot,n4_f1_n19_tot,n4_f2_n0_tot,n4_f2_n1_tot,n4_f2_n2_tot,n4_f2_n3_tot,n4_f2_n5_tot,n4_f2_n6_tot,n4_f2_n7_tot,n4_f2_n8_tot,n4_f2_n9_tot,n4_f2_n10_tot,n4_f2_n11_tot,n4_f2_n12_tot,n4_f2_n13_tot,n4_f2_n14_tot,n4_f2_n15_tot,n4_f2_n16_tot,n4_f2_n17_tot,n4_f2_n18_tot,n4_f2_n19_tot,n5_f0_n0_tot,n5_f0_n1_tot,n5_f0_n2_tot,n5_f0_n3_tot,n5_f0_n4_tot,n5_f0_n6_tot,n5_f0_n7_tot,n5_f0_n8_tot,n5_f0_n9_tot,n5_f0_n10_tot,n5_f0_n11_tot,n5_f0_n12_tot,n5_f0_n13_tot,n5_f0_n14_tot,n5_f0_n15_tot,n5_f0_n16_tot,n5_f0_n17_tot,n5_f0_n18_tot,n5_f0_n19_tot,n5_f1_n0_tot,n5_f1_n1_tot,n5_f1_n2_tot,n5_f1_n3_tot,n5_f1_n4_tot,n5_f1_n6_tot,n5_f1_n7_tot,n5_f1_n8_tot,n5_f1_n9_tot,n5_f1_n10_tot,n5_f1_n11_tot,n5_f1_n12_tot,n5_f1_n13_tot,n5_f1_n14_tot,n5_f1_n15_tot,n5_f1_n16_tot,n5_f1_n17_tot,n5_f1_n18_tot,n5_f1_n19_tot,n5_f2_n0_tot,n5_f2_n1_tot,n5_f2_n2_tot,n5_f2_n3_tot,n5_f2_n4_tot,n5_f2_n6_tot,n5_f2_n7_tot,n5_f2_n8_tot,n5_f2_n9_tot,n5_f2_n10_tot,n5_f2_n11_tot,n5_f2_n12_tot,n5_f2_n13_tot,n5_f2_n14_tot,n5_f2_n15_tot,n5_f2_n16_tot,n5_f2_n17_tot,n5_f2_n18_tot,n5_f2_n19_tot,n6_f0_n0_tot,n6_f0_n1_tot,n6_f0_n2_tot,n6_f0_n3_tot,n6_f0_n4_tot,n6_f0_n5_tot,n6_f0_n7_tot,n6_f0_n8_tot,n6_f0_n9_tot,n6_f0_n10_tot,n6_f0_n11_tot,n6_f0_n12_tot,n6_f0_n13_tot,n6_f0_n14_tot,n6_f0_n15_tot,n6_f0_n16_tot,n6_f0_n17_tot,n6_f0_n18_tot,n6_f0_n19_tot,n6_f1_n0_tot,n6_f1_n1_tot,n6_f1_n2_tot,n6_f1_n3_tot,n6_f1_n4_tot,n6_f1_n5_tot,n6_f1_n7_tot,n6_f1_n8_tot,n6_f1_n9_tot,n6_f1_n10_tot,n6_f1_n11_tot,n6_f1_n12_tot,n6_f1_n13_tot,n6_f1_n14_tot,n6_f1_n15_tot,n6_f1_n16_tot,n6_f1_n17_tot,n6_f1_n18_tot,n6_f1_n19_tot,n6_f2_n0_tot,n6_f2_n1_tot,n6_f2_n2_tot,n6_f2_n3_tot,n6_f2_n4_tot,n6_f2_n5_tot,n6_f2_n7_tot,n6_f2_n8_tot,n6_f2_n9_tot,n6_f2_n10_tot,n6_f2_n11_tot,n6_f2_n12_tot,n6_f2_n13_tot,n6_f2_n14_tot,n6_f2_n15_tot,n6_f2_n16_tot,n6_f2_n17_tot,n6_f2_n18_tot,n6_f2_n19_tot,n7_f0_n0_tot,n7_f0_n1_tot,n7_f0_n2_tot,n7_f0_n3_tot,n7_f0_n4_tot,n7_f0_n5_tot,n7_f0_n6_tot,n7_f0_n8_tot,n7_f0_n9_tot,n7_f0_n10_tot,n7_f0_n11_tot,n7_f0_n12_tot,n7_f0_n13_tot,n7_f0_n14_tot,n7_f0_n15_tot,n7_f0_n16_tot,n7_f0_n17_tot,n7_f0_n18_tot,n7_f0_n19_tot,n7_f1_n0_tot,n7_f1_n1_tot,n7_f1_n2_tot,n7_f1_n3_tot,n7_f1_n4_tot,n7_f1_n5_tot,n7_f1_n6_tot,n7_f1_n8_tot,n7_f1_n9_tot,n7_f1_n10_tot,n7_f1_n11_tot,n7_f1_n12_tot,n7_f1_n13_tot,n7_f1_n14_tot,n7_f1_n15_tot,n7_f1_n16_tot,n7_f1_n17_tot,n7_f1_n18_tot,n7_f1_n19_tot,n7_f2_n0_tot,n7_f2_n1_tot,n7_f2_n2_tot,n7_f2_n3_tot,n7_f2_n4_tot,n7_f2_n5_tot,n7_f2_n6_tot,n7_f2_n8_tot,n7_f2_n9_tot,n7_f2_n10_tot,n7_f2_n11_tot,n7_f2_n12_tot,n7_f2_n13_tot,n7_f2_n14_tot,n7_f2_n15_tot,n7_f2_n16_tot,n7_f2_n17_tot,n7_f2_n18_tot,n7_f2_n19_tot,n8_f0_n0_tot,n8_f0_n1_tot,n8_f0_n2_tot,n8_f0_n3_tot,n8_f0_n4_tot,n8_f0_n5_tot,n8_f0_n6_tot,n8_f0_n7_tot,n8_f0_n9_tot,n8_f0_n10_tot,n8_f0_n11_tot,n8_f0_n12_tot,n8_f0_n13_tot,n8_f0_n14_tot,n8_f0_n15_tot,n8_f0_n16_tot,n8_f0_n17_tot,n8_f0_n18_tot,n8_f0_n19_tot,n8_f1_n0_tot,n8_f1_n1_tot,n8_f1_n2_tot,n8_f1_n3_tot,n8_f1_n4_tot,n8_f1_n5_tot,n8_f1_n6_tot,n8_f1_n7_tot,n8_f1_n9_tot,n8_f1_n10_tot,n8_f1_n11_tot,n8_f1_n12_tot,n8_f1_n13_tot,n8_f1_n14_tot,n8_f1_n15_tot,n8_f1_n16_tot,n8_f1_n17_tot,n8_f1_n18_tot,n8_f1_n19_tot,n8_f2_n0_tot,n8_f2_n1_tot,n8_f2_n2_tot,n8_f2_n3_tot,n8_f2_n4_tot,n8_f2_n5_tot,n8_f2_n6_tot,n8_f2_n7_tot,n8_f2_n9_tot,n8_f2_n10_tot,n8_f2_n11_tot,n8_f2_n12_tot,n8_f2_n13_tot,n8_f2_n14_tot,n8_f2_n15_tot,n8_f2_n16_tot,n8_f2_n17_tot,n8_f2_n18_tot,n8_f2_n19_tot,n9_f0_n0_tot,n9_f0_n1_tot,n9_f0_n2_tot,n9_f0_n3_tot,n9_f0_n4_tot,n9_f0_n5_tot,n9_f0_n6_tot,n9_f0_n7_tot,n9_f0_n8_tot,n9_f0_n10_tot,n9_f0_n11_tot,n9_f0_n12_tot,n9_f0_n13_tot,n9_f0_n14_tot,n9_f0_n15_tot,n9_f0_n16_tot,n9_f0_n17_tot,n9_f0_n18_tot,n9_f0_n19_tot,n9_f1_n0_tot,n9_f1_n1_tot,n9_f1_n2_tot,n9_f1_n3_tot,n9_f1_n4_tot,n9_f1_n5_tot,n9_f1_n6_tot,n9_f1_n7_tot,n9_f1_n8_tot,n9_f1_n10_tot,n9_f1_n11_tot,n9_f1_n12_tot,n9_f1_n13_tot,n9_f1_n14_tot,n9_f1_n15_tot,n9_f1_n16_tot,n9_f1_n17_tot,n9_f1_n18_tot,n9_f1_n19_tot,n9_f2_n0_tot,n9_f2_n1_tot,n9_f2_n2_tot,n9_f2_n3_tot,n9_f2_n4_tot,n9_f2_n5_tot,n9_f2_n6_tot,n9_f2_n7_tot,n9_f2_n8_tot,n9_f2_n10_tot,n9_f2_n11_tot,n9_f2_n12_tot,n9_f2_n13_tot,n9_f2_n14_tot,n9_f2_n15_tot,n9_f2_n16_tot,n9_f2_n17_tot,n9_f2_n18_tot,n9_f2_n19_tot,n10_f0_n0_tot,n10_f0_n1_tot,n10_f0_n2_tot,n10_f0_n3_tot,n10_f0_n4_tot,n10_f0_n5_tot,n10_f0_n6_tot,n10_f0_n7_tot,n10_f0_n8_tot,n10_f0_n9_tot,n10_f0_n11_tot,n10_f0_n12_tot,n10_f0_n13_tot,n10_f0_n14_tot,n10_f0_n15_tot,n10_f0_n16_tot,n10_f0_n17_tot,n10_f0_n18_tot,n10_f0_n19_tot,n10_f1_n0_tot,n10_f1_n1_tot,n10_f1_n2_tot,n10_f1_n3_tot,n10_f1_n4_tot,n10_f1_n5_tot,n10_f1_n6_tot,n10_f1_n7_tot,n10_f1_n8_tot,n10_f1_n9_tot,n10_f1_n11_tot,n10_f1_n12_tot,n10_f1_n13_tot,n10_f1_n14_tot,n10_f1_n15_tot,n10_f1_n16_tot,n10_f1_n17_tot,n10_f1_n18_tot,n10_f1_n19_tot,n10_f2_n0_tot,n10_f2_n1_tot,n10_f2_n2_tot,n10_f2_n3_tot,n10_f2_n4_tot,n10_f2_n5_tot,n10_f2_n6_tot,n10_f2_n7_tot,n10_f2_n8_tot,n10_f2_n9_tot,n10_f2_n11_tot,n10_f2_n12_tot,n10_f2_n13_tot,n10_f2_n14_tot,n10_f2_n15_tot,n10_f2_n16_tot,n10_f2_n17_tot,n10_f2_n18_tot,n10_f2_n19_tot,n11_f0_n0_tot,n11_f0_n1_tot,n11_f0_n2_tot,n11_f0_n3_tot,n11_f0_n4_tot,n11_f0_n5_tot,n11_f0_n6_tot,n11_f0_n7_tot,n11_f0_n8_tot,n11_f0_n9_tot,n11_f0_n10_tot,n11_f0_n12_tot,n11_f0_n13_tot,n11_f0_n14_tot,n11_f0_n15_tot,n11_f0_n16_tot,n11_f0_n17_tot,n11_f0_n18_tot,n11_f0_n19_tot,n11_f1_n0_tot,n11_f1_n1_tot,n11_f1_n2_tot,n11_f1_n3_tot,n11_f1_n4_tot,n11_f1_n5_tot,n11_f1_n6_tot,n11_f1_n7_tot,n11_f1_n8_tot,n11_f1_n9_tot,n11_f1_n10_tot,n11_f1_n12_tot,n11_f1_n13_tot,n11_f1_n14_tot,n11_f1_n15_tot,n11_f1_n16_tot,n11_f1_n17_tot,n11_f1_n18_tot,n11_f1_n19_tot,n11_f2_n0_tot,n11_f2_n1_tot,n11_f2_n2_tot,n11_f2_n3_tot,n11_f2_n4_tot,n11_f2_n5_tot,n11_f2_n6_tot,n11_f2_n7_tot,n11_f2_n8_tot,n11_f2_n9_tot,n11_f2_n10_tot,n11_f2_n12_tot,n11_f2_n13_tot,n11_f2_n14_tot,n11_f2_n15_tot,n11_f2_n16_tot,n11_f2_n17_tot,n11_f2_n18_tot,n11_f2_n19_tot,n12_f0_n0_tot,n12_f0_n1_tot,n12_f0_n2_tot,n12_f0_n3_tot,n12_f0_n4_tot,n12_f0_n5_tot,n12_f0_n6_tot,n12_f0_n7_tot,n12_f0_n8_tot,n12_f0_n9_tot,n12_f0_n10_tot,n12_f0_n11_tot,n12_f0_n13_tot,n12_f0_n14_tot,n12_f0_n15_tot,n12_f0_n16_tot,n12_f0_n17_tot,n12_f0_n18_tot,n12_f0_n19_tot,n12_f1_n0_tot,n12_f1_n1_tot,n12_f1_n2_tot,n12_f1_n3_tot,n12_f1_n4_tot,n12_f1_n5_tot,n12_f1_n6_tot,n12_f1_n7_tot,n12_f1_n8_tot,n12_f1_n9_tot,n12_f1_n10_tot,n12_f1_n11_tot,n12_f1_n13_tot,n12_f1_n14_tot,n12_f1_n15_tot,n12_f1_n16_tot,n12_f1_n17_tot,n12_f1_n18_tot,n12_f1_n19_tot,n12_f2_n0_tot,n12_f2_n1_tot,n12_f2_n2_tot,n12_f2_n3_tot,n12_f2_n4_tot,n12_f2_n5_tot,n12_f2_n6_tot,n12_f2_n7_tot,n12_f2_n8_tot,n12_f2_n9_tot,n12_f2_n10_tot,n12_f2_n11_tot,n12_f2_n13_tot,n12_f2_n14_tot,n12_f2_n15_tot,n12_f2_n16_tot,n12_f2_n17_tot,n12_f2_n18_tot,n12_f2_n19_tot,n13_f0_n0_tot,n13_f0_n1_tot,n13_f0_n2_tot,n13_f0_n3_tot,n13_f0_n4_tot,n13_f0_n5_tot,n13_f0_n6_tot,n13_f0_n7_tot,n13_f0_n8_tot,n13_f0_n9_tot,n13_f0_n10_tot,n13_f0_n11_tot,n13_f0_n12_tot,n13_f0_n14_tot,n13_f0_n15_tot,n13_f0_n16_tot,n13_f0_n17_tot,n13_f0_n18_tot,n13_f0_n19_tot,n13_f1_n0_tot,n13_f1_n1_tot,n13_f1_n2_tot,n13_f1_n3_tot,n13_f1_n4_tot,n13_f1_n5_tot,n13_f1_n6_tot,n13_f1_n7_tot,n13_f1_n8_tot,n13_f1_n9_tot,n13_f1_n10_tot,n13_f1_n11_tot,n13_f1_n12_tot,n13_f1_n14_tot,n13_f1_n15_tot,n13_f1_n16_tot,n13_f1_n17_tot,n13_f1_n18_tot,n13_f1_n19_tot,n13_f2_n0_tot,n13_f2_n1_tot,n13_f2_n2_tot,n13_f2_n3_tot,n13_f2_n4_tot,n13_f2_n5_tot,n13_f2_n6_tot,n13_f2_n7_tot,n13_f2_n8_tot,n13_f2_n9_tot,n13_f2_n10_tot,n13_f2_n11_tot,n13_f2_n12_tot,n13_f2_n14_tot,n13_f2_n15_tot,n13_f2_n16_tot,n13_f2_n17_tot,n13_f2_n18_tot,n13_f2_n19_tot,n14_f0_n0_tot,n14_f0_n1_tot,n14_f0_n2_tot,n14_f0_n3_tot,n14_f0_n4_tot,n14_f0_n5_tot,n14_f0_n6_tot,n14_f0_n7_tot,n14_f0_n8_tot,n14_f0_n9_tot,n14_f0_n10_tot,n14_f0_n11_tot,n14_f0_n12_tot,n14_f0_n13_tot,n14_f0_n15_tot,n14_f0_n16_tot,n14_f0_n17_tot,n14_f0_n18_tot,n14_f0_n19_tot,n14_f1_n0_tot,n14_f1_n1_tot,n14_f1_n2_tot,n14_f1_n3_tot,n14_f1_n4_tot,n14_f1_n5_tot,n14_f1_n6_tot,n14_f1_n7_tot,n14_f1_n8_tot,n14_f1_n9_tot,n14_f1_n10_tot,n14_f1_n11_tot,n14_f1_n12_tot,n14_f1_n13_tot,n14_f1_n15_tot,n14_f1_n16_tot,n14_f1_n17_tot,n14_f1_n18_tot,n14_f1_n19_tot,n14_f2_n0_tot,n14_f2_n1_tot,n14_f2_n2_tot,n14_f2_n3_tot,n14_f2_n4_tot,n14_f2_n5_tot,n14_f2_n6_tot,n14_f2_n7_tot,n14_f2_n8_tot,n14_f2_n9_tot,n14_f2_n10_tot,n14_f2_n11_tot,n14_f2_n12_tot,n14_f2_n13_tot,n14_f2_n15_tot,n14_f2_n16_tot,n14_f2_n17_tot,n14_f2_n18_tot,n14_f2_n19_tot,n15_f0_n0_tot,n15_f0_n1_tot,n15_f0_n2_tot,n15_f0_n3_tot,n15_f0_n4_tot,n15_f0_n5_tot,n15_f0_n6_tot,n15_f0_n7_tot,n15_f0_n8_tot,n15_f0_n9_tot,n15_f0_n10_tot,n15_f0_n11_tot,n15_f0_n12_tot,n15_f0_n13_tot,n15_f0_n14_tot,n15_f0_n16_tot,n15_f0_n17_tot,n15_f0_n18_tot,n15_f0_n19_tot,n15_f1_n0_tot,n15_f1_n1_tot,n15_f1_n2_tot,n15_f1_n3_tot,n15_f1_n4_tot,n15_f1_n5_tot,n15_f1_n6_tot,n15_f1_n7_tot,n15_f1_n8_tot,n15_f1_n9_tot,n15_f1_n10_tot,n15_f1_n11_tot,n15_f1_n12_tot,n15_f1_n13_tot,n15_f1_n14_tot,n15_f1_n16_tot,n15_f1_n17_tot,n15_f1_n18_tot,n15_f1_n19_tot,n15_f2_n0_tot,n15_f2_n1_tot,n15_f2_n2_tot,n15_f2_n3_tot,n15_f2_n4_tot,n15_f2_n5_tot,n15_f2_n6_tot,n15_f2_n7_tot,n15_f2_n8_tot,n15_f2_n9_tot,n15_f2_n10_tot,n15_f2_n11_tot,n15_f2_n12_tot,n15_f2_n13_tot,n15_f2_n14_tot,n15_f2_n16_tot,n15_f2_n17_tot,n15_f2_n18_tot,n15_f2_n19_tot,n16_f0_n0_tot,n16_f0_n1_tot,n16_f0_n2_tot,n16_f0_n3_tot,n16_f0_n4_tot,n16_f0_n5_tot,n16_f0_n6_tot,n16_f0_n7_tot,n16_f0_n8_tot,n16_f0_n9_tot,n16_f0_n10_tot,n16_f0_n11_tot,n16_f0_n12_tot,n16_f0_n13_tot,n16_f0_n14_tot,n16_f0_n15_tot,n16_f0_n17_tot,n16_f0_n18_tot,n16_f0_n19_tot,n16_f1_n0_tot,n16_f1_n1_tot,n16_f1_n2_tot,n16_f1_n3_tot,n16_f1_n4_tot,n16_f1_n5_tot,n16_f1_n6_tot,n16_f1_n7_tot,n16_f1_n8_tot,n16_f1_n9_tot,n16_f1_n10_tot,n16_f1_n11_tot,n16_f1_n12_tot,n16_f1_n13_tot,n16_f1_n14_tot,n16_f1_n15_tot,n16_f1_n17_tot,n16_f1_n18_tot,n16_f1_n19_tot,n16_f2_n0_tot,n16_f2_n1_tot,n16_f2_n2_tot,n16_f2_n3_tot,n16_f2_n4_tot,n16_f2_n5_tot,n16_f2_n6_tot,n16_f2_n7_tot,n16_f2_n8_tot,n16_f2_n9_tot,n16_f2_n10_tot,n16_f2_n11_tot,n16_f2_n12_tot,n16_f2_n13_tot,n16_f2_n14_tot,n16_f2_n15_tot,n16_f2_n17_tot,n16_f2_n18_tot,n16_f2_n19_tot,n17_f0_n0_tot,n17_f0_n1_tot,n17_f0_n2_tot,n17_f0_n3_tot,n17_f0_n4_tot,n17_f0_n5_tot,n17_f0_n6_tot,n17_f0_n7_tot,n17_f0_n8_tot,n17_f0_n9_tot,n17_f0_n10_tot,n17_f0_n11_tot,n17_f0_n12_tot,n17_f0_n13_tot,n17_f0_n14_tot,n17_f0_n15_tot,n17_f0_n16_tot,n17_f0_n18_tot,n17_f0_n19_tot,n17_f1_n0_tot,n17_f1_n1_tot,n17_f1_n2_tot,n17_f1_n3_tot,n17_f1_n4_tot,n17_f1_n5_tot,n17_f1_n6_tot,n17_f1_n7_tot,n17_f1_n8_tot,n17_f1_n9_tot,n17_f1_n10_tot,n17_f1_n11_tot,n17_f1_n12_tot,n17_f1_n13_tot,n17_f1_n14_tot,n17_f1_n15_tot,n17_f1_n16_tot,n17_f1_n18_tot,n17_f1_n19_tot,n17_f2_n0_tot,n17_f2_n1_tot,n17_f2_n2_tot,n17_f2_n3_tot,n17_f2_n4_tot,n17_f2_n5_tot,n17_f2_n6_tot,n17_f2_n7_tot,n17_f2_n8_tot,n17_f2_n9_tot,n17_f2_n10_tot,n17_f2_n11_tot,n17_f2_n12_tot,n17_f2_n13_tot,n17_f2_n14_tot,n17_f2_n15_tot,n17_f2_n16_tot,n17_f2_n18_tot,n17_f2_n19_tot,n18_f0_n0_tot,n18_f0_n1_tot,n18_f0_n2_tot,n18_f0_n3_tot,n18_f0_n4_tot,n18_f0_n5_tot,n18_f0_n6_tot,n18_f0_n7_tot,n18_f0_n8_tot,n18_f0_n9_tot,n18_f0_n10_tot,n18_f0_n11_tot,n18_f0_n12_tot,n18_f0_n13_tot,n18_f0_n14_tot,n18_f0_n15_tot,n18_f0_n16_tot,n18_f0_n17_tot,n18_f0_n19_tot,n18_f1_n0_tot,n18_f1_n1_tot,n18_f1_n2_tot,n18_f1_n3_tot,n18_f1_n4_tot,n18_f1_n5_tot,n18_f1_n6_tot,n18_f1_n7_tot,n18_f1_n8_tot,n18_f1_n9_tot,n18_f1_n10_tot,n18_f1_n11_tot,n18_f1_n12_tot,n18_f1_n13_tot,n18_f1_n14_tot,n18_f1_n15_tot,n18_f1_n16_tot,n18_f1_n17_tot,n18_f1_n19_tot,n18_f2_n0_tot,n18_f2_n1_tot,n18_f2_n2_tot,n18_f2_n3_tot,n18_f2_n4_tot,n18_f2_n5_tot,n18_f2_n6_tot,n18_f2_n7_tot,n18_f2_n8_tot,n18_f2_n9_tot,n18_f2_n10_tot,n18_f2_n11_tot,n18_f2_n12_tot,n18_f2_n13_tot,n18_f2_n14_tot,n18_f2_n15_tot,n18_f2_n16_tot,n18_f2_n17_tot,n18_f2_n19_tot,n19_f0_n0_tot,n19_f0_n1_tot,n19_f0_n2_tot,n19_f0_n3_tot,n19_f0_n4_tot,n19_f0_n5_tot,n19_f0_n6_tot,n19_f0_n7_tot,n19_f0_n8_tot,n19_f0_n9_tot,n19_f0_n10_tot,n19_f0_n11_tot,n19_f0_n12_tot,n19_f0_n13_tot,n19_f0_n14_tot,n19_f0_n15_tot,n19_f0_n16_tot,n19_f0_n17_tot,n19_f0_n18_tot,n19_f1_n0_tot,n19_f1_n1_tot,n19_f1_n2_tot,n19_f1_n3_tot,n19_f1_n4_tot,n19_f1_n5_tot,n19_f1_n6_tot,n19_f1_n7_tot,n19_f1_n8_tot,n19_f1_n9_tot,n19_f1_n10_tot,n19_f1_n11_tot,n19_f1_n12_tot,n19_f1_n13_tot,n19_f1_n14_tot,n19_f1_n15_tot,n19_f1_n16_tot,n19_f1_n17_tot,n19_f1_n18_tot,n19_f2_n0_tot,n19_f2_n1_tot,n19_f2_n2_tot,n19_f2_n3_tot,n19_f2_n4_tot,n19_f2_n5_tot,n19_f2_n6_tot,n19_f2_n7_tot,n19_f2_n8_tot,n19_f2_n9_tot,n19_f2_n10_tot,n19_f2_n11_tot,n19_f2_n12_tot,n19_f2_n13_tot,n19_f2_n14_tot,n19_f2_n15_tot,n19_f2_n16_tot,n19_f2_n17_tot,n19_f2_n18_tot,n0_f0_n1_accepted,n0_f0_n2_accepted,n0_f0_n3_accepted,n0_f0_n4_accepted,n0_f0_n5_accepted,n0_f0_n6_accepted,n0_f0_n7_accepted,n0_f0_n8_accepted,n0_f0_n9_accepted,n0_f0_n10_accepted,n0_f0_n11_accepted,n0_f0_n12_accepted,n0_f0_n13_accepted,n0_f0_n14_accepted,n0_f0_n15_accepted,n0_f0_n16_accepted,n0_f0_n17_accepted,n0_f0_n18_accepted,n0_f0_n19_accepted,n0_f1_n1_accepted,n0_f1_n2_accepted,n0_f1_n3_accepted,n0_f1_n4_accepted,n0_f1_n5_accepted,n0_f1_n6_accepted,n0_f1_n7_accepted,n0_f1_n8_accepted,n0_f1_n9_accepted,n0_f1_n10_accepted,n0_f1_n11_accepted,n0_f1_n12_accepted,n0_f1_n13_accepted,n0_f1_n14_accepted,n0_f1_n15_accepted,n0_f1_n16_accepted,n0_f1_n17_accepted,n0_f1_n18_accepted,n0_f1_n19_accepted,n0_f2_n1_accepted,n0_f2_n2_accepted,n0_f2_n3_accepted,n0_f2_n4_accepted,n0_f2_n5_accepted,n0_f2_n6_accepted,n0_f2_n7_accepted,n0_f2_n8_accepted,n0_f2_n9_accepted,n0_f2_n10_accepted,n0_f2_n11_accepted,n0_f2_n12_accepted,n0_f2_n13_accepted,n0_f2_n14_accepted,n0_f2_n15_accepted,n0_f2_n16_accepted,n0_f2_n17_accepted,n0_f2_n18_accepted,n0_f2_n19_accepted,n1_f0_n0_accepted,n1_f0_n2_accepted,n1_f0_n3_accepted,n1_f0_n4_accepted,n1_f0_n5_accepted,n1_f0_n6_accepted,n1_f0_n7_accepted,n1_f0_n8_accepted,n1_f0_n9_accepted,n1_f0_n10_accepted,n1_f0_n11_accepted,n1_f0_n12_accepted,n1_f0_n13_accepted,n1_f0_n14_accepted,n1_f0_n15_accepted,n1_f0_n16_accepted,n1_f0_n17_accepted,n1_f0_n18_accepted,n1_f0_n19_accepted,n1_f1_n0_accepted,n1_f1_n2_accepted,n1_f1_n3_accepted,n1_f1_n4_accepted,n1_f1_n5_accepted,n1_f1_n6_accepted,n1_f1_n7_accepted,n1_f1_n8_accepted,n1_f1_n9_accepted,n1_f1_n10_accepted,n1_f1_n11_accepted,n1_f1_n12_accepted,n1_f1_n13_accepted,n1_f1_n14_accepted,n1_f1_n15_accepted,n1_f1_n16_accepted,n1_f1_n17_accepted,n1_f1_n18_accepted,n1_f1_n19_accepted,n1_f2_n0_accepted,n1_f2_n2_accepted,n1_f2_n3_accepted,n1_f2_n4_accepted,n1_f2_n5_accepted,n1_f2_n6_accepted,n1_f2_n7_accepted,n1_f2_n8_accepted,n1_f2_n9_accepted,n1_f2_n10_accepted,n1_f2_n11_accepted,n1_f2_n12_accepted,n1_f2_n13_accepted,n1_f2_n14_accepted,n1_f2_n15_accepted,n1_f2_n16_accepted,n1_f2_n17_accepted,n1_f2_n18_accepted,n1_f2_n19_accepted,n2_f0_n0_accepted,n2_f0_n1_accepted,n2_f0_n3_accepted,n2_f0_n4_accepted,n2_f0_n5_accepted,n2_f0_n6_accepted,n2_f0_n7_accepted,n2_f0_n8_accepted,n2_f0_n9_accepted,n2_f0_n10_accepted,n2_f0_n11_accepted,n2_f0_n12_accepted,n2_f0_n13_accepted,n2_f0_n14_accepted,n2_f0_n15_accepted,n2_f0_n16_accepted,n2_f0_n17_accepted,n2_f0_n18_accepted,n2_f0_n19_accepted,n2_f1_n0_accepted,n2_f1_n1_accepted,n2_f1_n3_accepted,n2_f1_n4_accepted,n2_f1_n5_accepted,n2_f1_n6_accepted,n2_f1_n7_accepted,n2_f1_n8_accepted,n2_f1_n9_accepted,n2_f1_n10_accepted,n2_f1_n11_accepted,n2_f1_n12_accepted,n2_f1_n13_accepted,n2_f1_n14_accepted,n2_f1_n15_accepted,n2_f1_n16_accepted,n2_f1_n17_accepted,n2_f1_n18_accepted,n2_f1_n19_accepted,n2_f2_n0_accepted,n2_f2_n1_accepted,n2_f2_n3_accepted,n2_f2_n4_accepted,n2_f2_n5_accepted,n2_f2_n6_accepted,n2_f2_n7_accepted,n2_f2_n8_accepted,n2_f2_n9_accepted,n2_f2_n10_accepted,n2_f2_n11_accepted,n2_f2_n12_accepted,n2_f2_n13_accepted,n2_f2_n14_accepted,n2_f2_n15_accepted,n2_f2_n16_accepted,n2_f2_n17_accepted,n2_f2_n18_accepted,n2_f2_n19_accepted,n3_f0_n0_accepted,n3_f0_n1_accepted,n3_f0_n2_accepted,n3_f0_n4_accepted,n3_f0_n5_accepted,n3_f0_n6_accepted,n3_f0_n7_accepted,n3_f0_n8_accepted,n3_f0_n9_accepted,n3_f0_n10_accepted,n3_f0_n11_accepted,n3_f0_n12_accepted,n3_f0_n13_accepted,n3_f0_n14_accepted,n3_f0_n15_accepted,n3_f0_n16_accepted,n3_f0_n17_accepted,n3_f0_n18_accepted,n3_f0_n19_accepted,n3_f1_n0_accepted,n3_f1_n1_accepted,n3_f1_n2_accepted,n3_f1_n4_accepted,n3_f1_n5_accepted,n3_f1_n6_accepted,n3_f1_n7_accepted,n3_f1_n8_accepted,n3_f1_n9_accepted,n3_f1_n10_accepted,n3_f1_n11_accepted,n3_f1_n12_accepted,n3_f1_n13_accepted,n3_f1_n14_accepted,n3_f1_n15_accepted,n3_f1_n16_accepted,n3_f1_n17_accepted,n3_f1_n18_accepted,n3_f1_n19_accepted,n3_f2_n0_accepted,n3_f2_n1_accepted,n3_f2_n2_accepted,n3_f2_n4_accepted,n3_f2_n5_accepted,n3_f2_n6_accepted,n3_f2_n7_accepted,n3_f2_n8_accepted,n3_f2_n9_accepted,n3_f2_n10_accepted,n3_f2_n11_accepted,n3_f2_n12_accepted,n3_f2_n13_accepted,n3_f2_n14_accepted,n3_f2_n15_accepted,n3_f2_n16_accepted,n3_f2_n17_accepted,n3_f2_n18_accepted,n3_f2_n19_accepted,n4_f0_n0_accepted,n4_f0_n1_accepted,n4_f0_n2_accepted,n4_f0_n3_accepted,n4_f0_n5_accepted,n4_f0_n6_accepted,n4_f0_n7_accepted,n4_f0_n8_accepted,n4_f0_n9_accepted,n4_f0_n10_accepted,n4_f0_n11_accepted,n4_f0_n12_accepted,n4_f0_n13_accepted,n4_f0_n14_accepted,n4_f0_n15_accepted,n4_f0_n16_accepted,n4_f0_n17_accepted,n4_f0_n18_accepted,n4_f0_n19_accepted,n4_f1_n0_accepted,n4_f1_n1_accepted,n4_f1_n2_accepted,n4_f1_n3_accepted,n4_f1_n5_accepted,n4_f1_n6_accepted,n4_f1_n7_accepted,n4_f1_n8_accepted,n4_f1_n9_accepted,n4_f1_n10_accepted,n4_f1_n11_accepted,n4_f1_n12_accepted,n4_f1_n13_accepted,n4_f1_n14_accepted,n4_f1_n15_accepted,n4_f1_n16_accepted,n4_f1_n17_accepted,n4_f1_n18_accepted,n4_f1_n19_accepted,n4_f2_n0_accepted,n4_f2_n1_accepted,n4_f2_n2_accepted,n4_f2_n3_accepted,n4_f2_n5_accepted,n4_f2_n6_accepted,n4_f2_n7_accepted,n4_f2_n8_accepted,n4_f2_n9_accepted,n4_f2_n10_accepted,n4_f2_n11_accepted,n4_f2_n12_accepted,n4_f2_n13_accepted,n4_f2_n14_accepted,n4_f2_n15_accepted,n4_f2_n16_accepted,n4_f2_n17_accepted,n4_f2_n18_accepted,n4_f2_n19_accepted,n5_f0_n0_accepted,n5_f0_n1_accepted,n5_f0_n2_accepted,n5_f0_n3_accepted,n5_f0_n4_accepted,n5_f0_n6_accepted,n5_f0_n7_accepted,n5_f0_n8_accepted,n5_f0_n9_accepted,n5_f0_n10_accepted,n5_f0_n11_accepted,n5_f0_n12_accepted,n5_f0_n13_accepted,n5_f0_n14_accepted,n5_f0_n15_accepted,n5_f0_n16_accepted,n5_f0_n17_accepted,n5_f0_n18_accepted,n5_f0_n19_accepted,n5_f1_n0_accepted,n5_f1_n1_accepted,n5_f1_n2_accepted,n5_f1_n3_accepted,n5_f1_n4_accepted,n5_f1_n6_accepted,n5_f1_n7_accepted,n5_f1_n8_accepted,n5_f1_n9_accepted,n5_f1_n10_accepted,n5_f1_n11_accepted,n5_f1_n12_accepted,n5_f1_n13_accepted,n5_f1_n14_accepted,n5_f1_n15_accepted,n5_f1_n16_accepted,n5_f1_n17_accepted,n5_f1_n18_accepted,n5_f1_n19_accepted,n5_f2_n0_accepted,n5_f2_n1_accepted,n5_f2_n2_accepted,n5_f2_n3_accepted,n5_f2_n4_accepted,n5_f2_n6_accepted,n5_f2_n7_accepted,n5_f2_n8_accepted,n5_f2_n9_accepted,n5_f2_n10_accepted,n5_f2_n11_accepted,n5_f2_n12_accepted,n5_f2_n13_accepted,n5_f2_n14_accepted,n5_f2_n15_accepted,n5_f2_n16_accepted,n5_f2_n17_accepted,n5_f2_n18_accepted,n5_f2_n19_accepted,n6_f0_n0_accepted,n6_f0_n1_accepted,n6_f0_n2_accepted,n6_f0_n3_accepted,n6_f0_n4_accepted,n6_f0_n5_accepted,n6_f0_n7_accepted,n6_f0_n8_accepted,n6_f0_n9_accepted,n6_f0_n10_accepted,n6_f0_n11_accepted,n6_f0_n12_accepted,n6_f0_n13_accepted,n6_f0_n14_accepted,n6_f0_n15_accepted,n6_f0_n16_accepted,n6_f0_n17_accepted,n6_f0_n18_accepted,n6_f0_n19_accepted,n6_f1_n0_accepted,n6_f1_n1_accepted,n6_f1_n2_accepted,n6_f1_n3_accepted,n6_f1_n4_accepted,n6_f1_n5_accepted,n6_f1_n7_accepted,n6_f1_n8_accepted,n6_f1_n9_accepted,n6_f1_n10_accepted,n6_f1_n11_accepted,n6_f1_n12_accepted,n6_f1_n13_accepted,n6_f1_n14_accepted,n6_f1_n15_accepted,n6_f1_n16_accepted,n6_f1_n17_accepted,n6_f1_n18_accepted,n6_f1_n19_accepted,n6_f2_n0_accepted,n6_f2_n1_accepted,n6_f2_n2_accepted,n6_f2_n3_accepted,n6_f2_n4_accepted,n6_f2_n5_accepted,n6_f2_n7_accepted,n6_f2_n8_accepted,n6_f2_n9_accepted,n6_f2_n10_accepted,n6_f2_n11_accepted,n6_f2_n12_accepted,n6_f2_n13_accepted,n6_f2_n14_accepted,n6_f2_n15_accepted,n6_f2_n16_accepted,n6_f2_n17_accepted,n6_f2_n18_accepted,n6_f2_n19_accepted,n7_f0_n0_accepted,n7_f0_n1_accepted,n7_f0_n2_accepted,n7_f0_n3_accepted,n7_f0_n4_accepted,n7_f0_n5_accepted,n7_f0_n6_accepted,n7_f0_n8_accepted,n7_f0_n9_accepted,n7_f0_n10_accepted,n7_f0_n11_accepted,n7_f0_n12_accepted,n7_f0_n13_accepted,n7_f0_n14_accepted,n7_f0_n15_accepted,n7_f0_n16_accepted,n7_f0_n17_accepted,n7_f0_n18_accepted,n7_f0_n19_accepted,n7_f1_n0_accepted,n7_f1_n1_accepted,n7_f1_n2_accepted,n7_f1_n3_accepted,n7_f1_n4_accepted,n7_f1_n5_accepted,n7_f1_n6_accepted,n7_f1_n8_accepted,n7_f1_n9_accepted,n7_f1_n10_accepted,n7_f1_n11_accepted,n7_f1_n12_accepted,n7_f1_n13_accepted,n7_f1_n14_accepted,n7_f1_n15_accepted,n7_f1_n16_accepted,n7_f1_n17_accepted,n7_f1_n18_accepted,n7_f1_n19_accepted,n7_f2_n0_accepted,n7_f2_n1_accepted,n7_f2_n2_accepted,n7_f2_n3_accepted,n7_f2_n4_accepted,n7_f2_n5_accepted,n7_f2_n6_accepted,n7_f2_n8_accepted,n7_f2_n9_accepted,n7_f2_n10_accepted,n7_f2_n11_accepted,n7_f2_n12_accepted,n7_f2_n13_accepted,n7_f2_n14_accepted,n7_f2_n15_accepted,n7_f2_n16_accepted,n7_f2_n17_accepted,n7_f2_n18_accepted,n7_f2_n19_accepted,n8_f0_n0_accepted,n8_f0_n1_accepted,n8_f0_n2_accepted,n8_f0_n3_accepted,n8_f0_n4_accepted,n8_f0_n5_accepted,n8_f0_n6_accepted,n8_f0_n7_accepted,n8_f0_n9_accepted,n8_f0_n10_accepted,n8_f0_n11_accepted,n8_f0_n12_accepted,n8_f0_n13_accepted,n8_f0_n14_accepted,n8_f0_n15_accepted,n8_f0_n16_accepted,n8_f0_n17_accepted,n8_f0_n18_accepted,n8_f0_n19_accepted,n8_f1_n0_accepted,n8_f1_n1_accepted,n8_f1_n2_accepted,n8_f1_n3_accepted,n8_f1_n4_accepted,n8_f1_n5_accepted,n8_f1_n6_accepted,n8_f1_n7_accepted,n8_f1_n9_accepted,n8_f1_n10_accepted,n8_f1_n11_accepted,n8_f1_n12_accepted,n8_f1_n13_accepted,n8_f1_n14_accepted,n8_f1_n15_accepted,n8_f1_n16_accepted,n8_f1_n17_accepted,n8_f1_n18_accepted,n8_f1_n19_accepted,n8_f2_n0_accepted,n8_f2_n1_accepted,n8_f2_n2_accepted,n8_f2_n3_accepted,n8_f2_n4_accepted,n8_f2_n5_accepted,n8_f2_n6_accepted,n8_f2_n7_accepted,n8_f2_n9_accepted,n8_f2_n10_accepted,n8_f2_n11_accepted,n8_f2_n12_accepted,n8_f2_n13_accepted,n8_f2_n14_accepted,n8_f2_n15_accepted,n8_f2_n16_accepted,n8_f2_n17_accepted,n8_f2_n18_accepted,n8_f2_n19_accepted,n9_f0_n0_accepted,n9_f0_n1_accepted,n9_f0_n2_accepted,n9_f0_n3_accepted,n9_f0_n4_accepted,n9_f0_n5_accepted,n9_f0_n6_accepted,n9_f0_n7_accepted,n9_f0_n8_accepted,n9_f0_n10_accepted,n9_f0_n11_accepted,n9_f0_n12_accepted,n9_f0_n13_accepted,n9_f0_n14_accepted,n9_f0_n15_accepted,n9_f0_n16_accepted,n9_f0_n17_accepted,n9_f0_n18_accepted,n9_f0_n19_accepted,n9_f1_n0_accepted,n9_f1_n1_accepted,n9_f1_n2_accepted,n9_f1_n3_accepted,n9_f1_n4_accepted,n9_f1_n5_accepted,n9_f1_n6_accepted,n9_f1_n7_accepted,n9_f1_n8_accepted,n9_f1_n10_accepted,n9_f1_n11_accepted,n9_f1_n12_accepted,n9_f1_n13_accepted,n9_f1_n14_accepted,n9_f1_n15_accepted,n9_f1_n16_accepted,n9_f1_n17_accepted,n9_f1_n18_accepted,n9_f1_n19_accepted,n9_f2_n0_accepted,n9_f2_n1_accepted,n9_f2_n2_accepted,n9_f2_n3_accepted,n9_f2_n4_accepted,n9_f2_n5_accepted,n9_f2_n6_accepted,n9_f2_n7_accepted,n9_f2_n8_accepted,n9_f2_n10_accepted,n9_f2_n11_accepted,n9_f2_n12_accepted,n9_f2_n13_accepted,n9_f2_n14_accepted,n9_f2_n15_accepted,n9_f2_n16_accepted,n9_f2_n17_accepted,n9_f2_n18_accepted,n9_f2_n19_accepted,n10_f0_n0_accepted,n10_f0_n1_accepted,n10_f0_n2_accepted,n10_f0_n3_accepted,n10_f0_n4_accepted,n10_f0_n5_accepted,n10_f0_n6_accepted,n10_f0_n7_accepted,n10_f0_n8_accepted,n10_f0_n9_accepted,n10_f0_n11_accepted,n10_f0_n12_accepted,n10_f0_n13_accepted,n10_f0_n14_accepted,n10_f0_n15_accepted,n10_f0_n16_accepted,n10_f0_n17_accepted,n10_f0_n18_accepted,n10_f0_n19_accepted,n10_f1_n0_accepted,n10_f1_n1_accepted,n10_f1_n2_accepted,n10_f1_n3_accepted,n10_f1_n4_accepted,n10_f1_n5_accepted,n10_f1_n6_accepted,n10_f1_n7_accepted,n10_f1_n8_accepted,n10_f1_n9_accepted,n10_f1_n11_accepted,n10_f1_n12_accepted,n10_f1_n13_accepted,n10_f1_n14_accepted,n10_f1_n15_accepted,n10_f1_n16_accepted,n10_f1_n17_accepted,n10_f1_n18_accepted,n10_f1_n19_accepted,n10_f2_n0_accepted,n10_f2_n1_accepted,n10_f2_n2_accepted,n10_f2_n3_accepted,n10_f2_n4_accepted,n10_f2_n5_accepted,n10_f2_n6_accepted,n10_f2_n7_accepted,n10_f2_n8_accepted,n10_f2_n9_accepted,n10_f2_n11_accepted,n10_f2_n12_accepted,n10_f2_n13_accepted,n10_f2_n14_accepted,n10_f2_n15_accepted,n10_f2_n16_accepted,n10_f2_n17_accepted,n10_f2_n18_accepted,n10_f2_n19_accepted,n11_f0_n0_accepted,n11_f0_n1_accepted,n11_f0_n2_accepted,n11_f0_n3_accepted,n11_f0_n4_accepted,n11_f0_n5_accepted,n11_f0_n6_accepted,n11_f0_n7_accepted,n11_f0_n8_accepted,n11_f0_n9_accepted,n11_f0_n10_accepted,n11_f0_n12_accepted,n11_f0_n13_accepted,n11_f0_n14_accepted,n11_f0_n15_accepted,n11_f0_n16_accepted,n11_f0_n17_accepted,n11_f0_n18_accepted,n11_f0_n19_accepted,n11_f1_n0_accepted,n11_f1_n1_accepted,n11_f1_n2_accepted,n11_f1_n3_accepted,n11_f1_n4_accepted,n11_f1_n5_accepted,n11_f1_n6_accepted,n11_f1_n7_accepted,n11_f1_n8_accepted,n11_f1_n9_accepted,n11_f1_n10_accepted,n11_f1_n12_accepted,n11_f1_n13_accepted,n11_f1_n14_accepted,n11_f1_n15_accepted,n11_f1_n16_accepted,n11_f1_n17_accepted,n11_f1_n18_accepted,n11_f1_n19_accepted,n11_f2_n0_accepted,n11_f2_n1_accepted,n11_f2_n2_accepted,n11_f2_n3_accepted,n11_f2_n4_accepted,n11_f2_n5_accepted,n11_f2_n6_accepted,n11_f2_n7_accepted,n11_f2_n8_accepted,n11_f2_n9_accepted,n11_f2_n10_accepted,n11_f2_n12_accepted,n11_f2_n13_accepted,n11_f2_n14_accepted,n11_f2_n15_accepted,n11_f2_n16_accepted,n11_f2_n17_accepted,n11_f2_n18_accepted,n11_f2_n19_accepted,n12_f0_n0_accepted,n12_f0_n1_accepted,n12_f0_n2_accepted,n12_f0_n3_accepted,n12_f0_n4_accepted,n12_f0_n5_accepted,n12_f0_n6_accepted,n12_f0_n7_accepted,n12_f0_n8_accepted,n12_f0_n9_accepted,n12_f0_n10_accepted,n12_f0_n11_accepted,n12_f0_n13_accepted,n12_f0_n14_accepted,n12_f0_n15_accepted,n12_f0_n16_accepted,n12_f0_n17_accepted,n12_f0_n18_accepted,n12_f0_n19_accepted,n12_f1_n0_accepted,n12_f1_n1_accepted,n12_f1_n2_accepted,n12_f1_n3_accepted,n12_f1_n4_accepted,n12_f1_n5_accepted,n12_f1_n6_accepted,n12_f1_n7_accepted,n12_f1_n8_accepted,n12_f1_n9_accepted,n12_f1_n10_accepted,n12_f1_n11_accepted,n12_f1_n13_accepted,n12_f1_n14_accepted,n12_f1_n15_accepted,n12_f1_n16_accepted,n12_f1_n17_accepted,n12_f1_n18_accepted,n12_f1_n19_accepted,n12_f2_n0_accepted,n12_f2_n1_accepted,n12_f2_n2_accepted,n12_f2_n3_accepted,n12_f2_n4_accepted,n12_f2_n5_accepted,n12_f2_n6_accepted,n12_f2_n7_accepted,n12_f2_n8_accepted,n12_f2_n9_accepted,n12_f2_n10_accepted,n12_f2_n11_accepted,n12_f2_n13_accepted,n12_f2_n14_accepted,n12_f2_n15_accepted,n12_f2_n16_accepted,n12_f2_n17_accepted,n12_f2_n18_accepted,n12_f2_n19_accepted,n13_f0_n0_accepted,n13_f0_n1_accepted,n13_f0_n2_accepted,n13_f0_n3_accepted,n13_f0_n4_accepted,n13_f0_n5_accepted,n13_f0_n6_accepted,n13_f0_n7_accepted,n13_f0_n8_accepted,n13_f0_n9_accepted,n13_f0_n10_accepted,n13_f0_n11_accepted,n13_f0_n12_accepted,n13_f0_n14_accepted,n13_f0_n15_accepted,n13_f0_n16_accepted,n13_f0_n17_accepted,n13_f0_n18_accepted,n13_f0_n19_accepted,n13_f1_n0_accepted,n13_f1_n1_accepted,n13_f1_n2_accepted,n13_f1_n3_accepted,n13_f1_n4_accepted,n13_f1_n5_accepted,n13_f1_n6_accepted,n13_f1_n7_accepted,n13_f1_n8_accepted,n13_f1_n9_accepted,n13_f1_n10_accepted,n13_f1_n11_accepted,n13_f1_n12_accepted,n13_f1_n14_accepted,n13_f1_n15_accepted,n13_f1_n16_accepted,n13_f1_n17_accepted,n13_f1_n18_accepted,n13_f1_n19_accepted,n13_f2_n0_accepted,n13_f2_n1_accepted,n13_f2_n2_accepted,n13_f2_n3_accepted,n13_f2_n4_accepted,n13_f2_n5_accepted,n13_f2_n6_accepted,n13_f2_n7_accepted,n13_f2_n8_accepted,n13_f2_n9_accepted,n13_f2_n10_accepted,n13_f2_n11_accepted,n13_f2_n12_accepted,n13_f2_n14_accepted,n13_f2_n15_accepted,n13_f2_n16_accepted,n13_f2_n17_accepted,n13_f2_n18_accepted,n13_f2_n19_accepted,n14_f0_n0_accepted,n14_f0_n1_accepted,n14_f0_n2_accepted,n14_f0_n3_accepted,n14_f0_n4_accepted,n14_f0_n5_accepted,n14_f0_n6_accepted,n14_f0_n7_accepted,n14_f0_n8_accepted,n14_f0_n9_accepted,n14_f0_n10_accepted,n14_f0_n11_accepted,n14_f0_n12_accepted,n14_f0_n13_accepted,n14_f0_n15_accepted,n14_f0_n16_accepted,n14_f0_n17_accepted,n14_f0_n18_accepted,n14_f0_n19_accepted,n14_f1_n0_accepted,n14_f1_n1_accepted,n14_f1_n2_accepted,n14_f1_n3_accepted,n14_f1_n4_accepted,n14_f1_n5_accepted,n14_f1_n6_accepted,n14_f1_n7_accepted,n14_f1_n8_accepted,n14_f1_n9_accepted,n14_f1_n10_accepted,n14_f1_n11_accepted,n14_f1_n12_accepted,n14_f1_n13_accepted,n14_f1_n15_accepted,n14_f1_n16_accepted,n14_f1_n17_accepted,n14_f1_n18_accepted,n14_f1_n19_accepted,n14_f2_n0_accepted,n14_f2_n1_accepted,n14_f2_n2_accepted,n14_f2_n3_accepted,n14_f2_n4_accepted,n14_f2_n5_accepted,n14_f2_n6_accepted,n14_f2_n7_accepted,n14_f2_n8_accepted,n14_f2_n9_accepted,n14_f2_n10_accepted,n14_f2_n11_accepted,n14_f2_n12_accepted,n14_f2_n13_accepted,n14_f2_n15_accepted,n14_f2_n16_accepted,n14_f2_n17_accepted,n14_f2_n18_accepted,n14_f2_n19_accepted,n15_f0_n0_accepted,n15_f0_n1_accepted,n15_f0_n2_accepted,n15_f0_n3_accepted,n15_f0_n4_accepted,n15_f0_n5_accepted,n15_f0_n6_accepted,n15_f0_n7_accepted,n15_f0_n8_accepted,n15_f0_n9_accepted,n15_f0_n10_accepted,n15_f0_n11_accepted,n15_f0_n12_accepted,n15_f0_n13_accepted,n15_f0_n14_accepted,n15_f0_n16_accepted,n15_f0_n17_accepted,n15_f0_n18_accepted,n15_f0_n19_accepted,n15_f1_n0_accepted,n15_f1_n1_accepted,n15_f1_n2_accepted,n15_f1_n3_accepted,n15_f1_n4_accepted,n15_f1_n5_accepted,n15_f1_n6_accepted,n15_f1_n7_accepted,n15_f1_n8_accepted,n15_f1_n9_accepted,n15_f1_n10_accepted,n15_f1_n11_accepted,n15_f1_n12_accepted,n15_f1_n13_accepted,n15_f1_n14_accepted,n15_f1_n16_accepted,n15_f1_n17_accepted,n15_f1_n18_accepted,n15_f1_n19_accepted,n15_f2_n0_accepted,n15_f2_n1_accepted,n15_f2_n2_accepted,n15_f2_n3_accepted,n15_f2_n4_accepted,n15_f2_n5_accepted,n15_f2_n6_accepted,n15_f2_n7_accepted,n15_f2_n8_accepted,n15_f2_n9_accepted,n15_f2_n10_accepted,n15_f2_n11_accepted,n15_f2_n12_accepted,n15_f2_n13_accepted,n15_f2_n14_accepted,n15_f2_n16_accepted,n15_f2_n17_accepted,n15_f2_n18_accepted,n15_f2_n19_accepted,n16_f0_n0_accepted,n16_f0_n1_accepted,n16_f0_n2_accepted,n16_f0_n3_accepted,n16_f0_n4_accepted,n16_f0_n5_accepted,n16_f0_n6_accepted,n16_f0_n7_accepted,n16_f0_n8_accepted,n16_f0_n9_accepted,n16_f0_n10_accepted,n16_f0_n11_accepted,n16_f0_n12_accepted,n16_f0_n13_accepted,n16_f0_n14_accepted,n16_f0_n15_accepted,n16_f0_n17_accepted,n16_f0_n18_accepted,n16_f0_n19_accepted,n16_f1_n0_accepted,n16_f1_n1_accepted,n16_f1_n2_accepted,n16_f1_n3_accepted,n16_f1_n4_accepted,n16_f1_n5_accepted,n16_f1_n6_accepted,n16_f1_n7_accepted,n16_f1_n8_accepted,n16_f1_n9_accepted,n16_f1_n10_accepted,n16_f1_n11_accepted,n16_f1_n12_accepted,n16_f1_n13_accepted,n16_f1_n14_accepted,n16_f1_n15_accepted,n16_f1_n17_accepted,n16_f1_n18_accepted,n16_f1_n19_accepted,n16_f2_n0_accepted,n16_f2_n1_accepted,n16_f2_n2_accepted,n16_f2_n3_accepted,n16_f2_n4_accepted,n16_f2_n5_accepted,n16_f2_n6_accepted,n16_f2_n7_accepted,n16_f2_n8_accepted,n16_f2_n9_accepted,n16_f2_n10_accepted,n16_f2_n11_accepted,n16_f2_n12_accepted,n16_f2_n13_accepted,n16_f2_n14_accepted,n16_f2_n15_accepted,n16_f2_n17_accepted,n16_f2_n18_accepted,n16_f2_n19_accepted,n17_f0_n0_accepted,n17_f0_n1_accepted,n17_f0_n2_accepted,n17_f0_n3_accepted,n17_f0_n4_accepted,n17_f0_n5_accepted,n17_f0_n6_accepted,n17_f0_n7_accepted,n17_f0_n8_accepted,n17_f0_n9_accepted,n17_f0_n10_accepted,n17_f0_n11_accepted,n17_f0_n12_accepted,n17_f0_n13_accepted,n17_f0_n14_accepted,n17_f0_n15_accepted,n17_f0_n16_accepted,n17_f0_n18_accepted,n17_f0_n19_accepted,n17_f1_n0_accepted,n17_f1_n1_accepted,n17_f1_n2_accepted,n17_f1_n3_accepted,n17_f1_n4_accepted,n17_f1_n5_accepted,n17_f1_n6_accepted,n17_f1_n7_accepted,n17_f1_n8_accepted,n17_f1_n9_accepted,n17_f1_n10_accepted,n17_f1_n11_accepted,n17_f1_n12_accepted,n17_f1_n13_accepted,n17_f1_n14_accepted,n17_f1_n15_accepted,n17_f1_n16_accepted,n17_f1_n18_accepted,n17_f1_n19_accepted,n17_f2_n0_accepted,n17_f2_n1_accepted,n17_f2_n2_accepted,n17_f2_n3_accepted,n17_f2_n4_accepted,n17_f2_n5_accepted,n17_f2_n6_accepted,n17_f2_n7_accepted,n17_f2_n8_accepted,n17_f2_n9_accepted,n17_f2_n10_accepted,n17_f2_n11_accepted,n17_f2_n12_accepted,n17_f2_n13_accepted,n17_f2_n14_accepted,n17_f2_n15_accepted,n17_f2_n16_accepted,n17_f2_n18_accepted,n17_f2_n19_accepted,n18_f0_n0_accepted,n18_f0_n1_accepted,n18_f0_n2_accepted,n18_f0_n3_accepted,n18_f0_n4_accepted,n18_f0_n5_accepted,n18_f0_n6_accepted,n18_f0_n7_accepted,n18_f0_n8_accepted,n18_f0_n9_accepted,n18_f0_n10_accepted,n18_f0_n11_accepted,n18_f0_n12_accepted,n18_f0_n13_accepted,n18_f0_n14_accepted,n18_f0_n15_accepted,n18_f0_n16_accepted,n18_f0_n17_accepted,n18_f0_n19_accepted,n18_f1_n0_accepted,n18_f1_n1_accepted,n18_f1_n2_accepted,n18_f1_n3_accepted,n18_f1_n4_accepted,n18_f1_n5_accepted,n18_f1_n6_accepted,n18_f1_n7_accepted,n18_f1_n8_accepted,n18_f1_n9_accepted,n18_f1_n10_accepted,n18_f1_n11_accepted,n18_f1_n12_accepted,n18_f1_n13_accepted,n18_f1_n14_accepted,n18_f1_n15_accepted,n18_f1_n16_accepted,n18_f1_n17_accepted,n18_f1_n19_accepted,n18_f2_n0_accepted,n18_f2_n1_accepted,n18_f2_n2_accepted,n18_f2_n3_accepted,n18_f2_n4_accepted,n18_f2_n5_accepted,n18_f2_n6_accepted,n18_f2_n7_accepted,n18_f2_n8_accepted,n18_f2_n9_accepted,n18_f2_n10_accepted,n18_f2_n11_accepted,n18_f2_n12_accepted,n18_f2_n13_accepted,n18_f2_n14_accepted,n18_f2_n15_accepted,n18_f2_n16_accepted,n18_f2_n17_accepted,n18_f2_n19_accepted,n19_f0_n0_accepted,n19_f0_n1_accepted,n19_f0_n2_accepted,n19_f0_n3_accepted,n19_f0_n4_accepted,n19_f0_n5_accepted,n19_f0_n6_accepted,n19_f0_n7_accepted,n19_f0_n8_accepted,n19_f0_n9_accepted,n19_f0_n10_accepted,n19_f0_n11_accepted,n19_f0_n12_accepted,n19_f0_n13_accepted,n19_f0_n14_accepted,n19_f0_n15_accepted,n19_f0_n16_accepted,n19_f0_n17_accepted,n19_f0_n18_accepted,n19_f1_n0_accepted,n19_f1_n1_accepted,n19_f1_n2_accepted,n19_f1_n3_accepted,n19_f1_n4_accepted,n19_f1_n5_accepted,n19_f1_n6_accepted,n19_f1_n7_accepted,n19_f1_n8_accepted,n19_f1_n9_accepted,n19_f1_n10_accepted,n19_f1_n11_accepted,n19_f1_n12_accepted,n19_f1_n13_accepted,n19_f1_n14_accepted,n19_f1_n15_accepted,n19_f1_n16_accepted,n19_f1_n17_accepted,n19_f1_n18_accepted,n19_f2_n0_accepted,n19_f2_n1_accepted,n19_f2_n2_accepted,n19_f2_n3_accepted,n19_f2_n4_accepted,n19_f2_n5_accepted,n19_f2_n6_accepted,n19_f2_n7_accepted,n19_f2_n8_accepted,n19_f2_n9_accepted,n19_f2_n10_accepted,n19_f2_n11_accepted,n19_f2_n12_accepted,n19_f2_n13_accepted,n19_f2_n14_accepted,n19_f2_n15_accepted,n19_f2_n16_accepted,n19_f2_n17_accepted,n19_f2_n18_accepted
+0.0,0.0,1.116279069767451,0.0,2.720930232558146,0.4418604651162781,1.7209302325581461,1.0,0.25581395348837077,0.3255813953488378,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.302325581395337,105.11627906976743,0.34751773049645607,0.39007092198582427,0.879432624113484,0.0851063829787364,1.2727272727272725,1.2727272727272725,1.0851063829787364,0.0,1.2727272727272725,1.2727272727272725,0.0,0.0,0.0,0.0,0.0,0.5764023210831262,2.0,1.2727272727272725,2.2727272727272725,0.0,0.6784140969163133,0.0,0.4977973568281868,0.12334801762114012,0.008810572687224294,0.7268722466960327,0.0,0.5506607929515468,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,48.40969162995599,59.889867841409654,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,103.0,20.0,53.0,0.34751773049645607,0.28368794326240376,0.6524822695035439,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,7.44294003868472,0.0,0.2733720180528758,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,0.0,0.0,0.0,24.0,29.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976685,0.0,0.32558139534884845,0.13953488372092693,2.9302325581395365,1.5116279069767415,156.0,84.44186046511629,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.7911025145067763,0.4081237911025193,0.8297872340425556,0.0,1.3984526112185771,1.4152965828497808,1.4268214055448178,8.382898130238516,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,34.15418502202641,0.0,0.8854625550660558,1.0881057268722145,0.6784140969162848,1.7533039647576913,0.0,9.0,56.44052863436134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,41.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48815280464216215,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.125,0.0,0.0,0.0,0.0,0.38684719535783785,0.0,0.0,0.709251101321577,0.0,4.229074889867846,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,0.0,33.75330396475766,46.493392070484674,0.0,0.6079295154184479,2.207048458149785,0.0,0.0,0.0,0.7906976744185954,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1860465116279073,0.0,0.0,33.02325581395348,81.0,90.0,42.0,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.0909090909090909,0.0909090909090909,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8105726872246635,0.0,0.0,8.189427312775337,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6976744186046631,0.0,0.0,54.69767441860466,120.60465116279067,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,0.0,0.4999750000000208,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.687224669603523,0.0,0.9339207048458036,0.0,0.0,14.0,0.0,0.0,0.0,22.0,17.295154185022028,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,5.0813703488372255,0.0,1.2093023255813904,0.0,0.0,0.0,2.0,0.0,0.0,27.709327325581384,84.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4493392070484603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069804,29.348837209302275,63.604651162790745,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976747,0.0,0.0,0.0,0.0,0.0,0.0,0.0,84.0,38.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3744493392070438,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,0.0,0.0,0.0,54.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.1743936046511863,1.0465116279069377,1.8372093023256468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.6511627906976747,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.28368794326240376,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6784140969163133,0.0,0.709251101321577,0.0,0.0,0.0,0.0,0.0,0.0,0.3744493392070438,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.116279069767451,0.0,0.0,0.7906976744185954,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.879432624113484,0.6524822695035439,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.720930232558146,0.0,0.0,0.0,0.0,0.0,0.5000249999999792,5.0813703488372255,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,1.0,0.0,0.48815280464216215,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.12334801762114012,0.0,0.0,4.229074889867846,0.0,0.0,12.687224669603523,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4418604651162781,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.0,0.0,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.008810572687224294,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7209302325581461,0.0,0.0,0.0,0.0,0.0,0.0,1.2093023255813904,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7268722466960327,0.0,0.0,0.0,0.0,0.0,0.0,0.4493392070484603,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.6976744186046631,0.4999750000000208,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9339207048458036,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25581395348837077,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.7911025145067763,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3255813953488378,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069804,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.0,0.4081237911025193,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976685,0.0,0.0,0.0,54.69767441860466,3.0,0.0,29.348837209302275,84.0,0.0,11.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8297872340425556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.0,34.15418502202641,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1860465116279073,0.0,120.60465116279067,0.0,2.0,63.604651162790745,38.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.24242424242424238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,1.8105726872246635,0.0,0.0,0.0,0.0,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.32558139534884845,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3984526112185771,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8854625550660558,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372092693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.4152965828497808,0.125,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0881057268722145,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9302325581395365,0.0,33.02325581395348,0.0,8.0,0.0,27.709327325581384,17.0,0.0,0.0,0.0,0.0,2.1743936046511863,0.0,0.0,0.0,0.0,0.0,0.0,1.4268214055448178,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,0.6784140969162848,33.75330396475766,8.189427312775337,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5116279069767415,0.0,81.0,0.0,0.0,0.0,84.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069377,0.0,0.0,0.0,0.0,0.5764023210831262,7.44294003868472,8.382898130238516,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,1.7533039647576913,46.493392070484674,0.0,0.0,0.0,17.295154185022028,0.0,0.0,54.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,103.0,156.0,41.0,90.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8372093023256468,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.302325581395337,20.0,84.44186046511629,0.0,42.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2727272727272725,0.2733720180528758,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,48.40969162995599,8.0,9.0,0.6079295154184479,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,105.11627906976743,53.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2727272727272725,0.0,0.0,0.38684719535783785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,59.889867841409654,0.0,56.44052863436134,2.207048458149785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,0.0,0.0,0.7209302325581461,0.48837209302325846,0.9302325581395365,0.0,0.418604651162795,0.5348837209302246,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069662,102.86046511627907,0.34751773049645607,0.39007092198582427,0.7163120567375927,0.6808510638297918,1.3636363636363635,1.3636363636363635,0.6808510638297918,0.0,1.3636363636363635,0.27659574468086134,0.0,2.7085751128303954,0.0,0.0,0.0,0.0,3.0,1.3636363636363635,0.7446808510638334,0.0,0.0,0.09691629955947256,0.9559471365638785,2.0088105726872243,1.1233480176211401,0.8414096916299627,0.0,1.5506607929515468,0.6872246696035234,0.0,1.0,0.0,0.0,0.0,0.0,0.0,40.71365638766521,68.02202643171805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,87.0,0.0,72.0,0.34751773049645607,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.498388136686,0.0,4.154094132817544,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.77092511013214,61.22907488986786,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9069767441860535,0.0,0.30232558139533694,0.5581395348837077,1.418604651162795,1.5116279069767415,164.0,57.302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2959381044487477,0.0,3.801418439716315,0.0,0.48936170212766683,1.421018697614449,1.3359123146357268,6.656350741457095,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.616740088105729,0.0,0.7533039647576913,0.7577092511012893,2.8105726872246635,64.41850220264315,0.0,38.64317180616747,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,91.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22907488986784585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.0,0.0,0.16299559471367786,0.6079295154184763,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,76.20930232558139,0.0,0.0,48.0,46.0,3.0,60.790697674418595,1.0,0.0,0.0,0.0,0.0,0.2374274661508712,0.4,0.0,0.0,0.0,0.0,0.10467440361052915,0.8942617666022358,0.0,0.1818181818181818,0.1818181818181818,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0748898678413907,0.0,0.0,0.0,3.9251101321586095,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0697674418604919,0.0,0.0,95.0,80.0,0.0,0.0,0.0,0.0,0.0,17.930232558139494,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25,0.32147001934237146,0.42852998065762865,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,21.1453744493392,0.0,2.2466960352422944,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255813904,0.0,0.0,103.79069767441861,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,31.0,0.27906976744185386,0.0,0.0,0.0,53.720930232558146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,21.99999999999997,0.0,0.0,0.0,19.0,32.0,0.0,43.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.627906976744157,0.0,0.0,7.372093023255843,21.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.67441860465118,55.09302325581396,2.2325581395348593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7163120567375927,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09691629955947256,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6808510638297918,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9559471365638785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7209302325581461,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,1.0,0.0,0.0,0.2374274661508712,0.0,0.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0088105726872243,4.0,0.0,0.22907488986784585,0.0,0.0,21.1453744493392,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,1.0,0.0,0.0,0.4,0.0,0.32147001934237146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1233480176211401,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255813904,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6808510638297918,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8414096916299627,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0697674418604919,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.42852998065762865,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2466960352422944,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.2959381044487477,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5348837209302246,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27659574468086134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6872246696035234,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.9069767441860535,0.0,0.0,0.0,95.0,4.0,103.79069767441861,31.0,0.0,0.0,0.627906976744157,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.801418439716315,0.0,0.10467440361052915,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.616740088105729,0.0,0.0,0.0,0.0,0.0,0.0,0.0,21.99999999999997,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,76.20930232558139,0.0,80.0,0.0,0.0,0.27906976744185386,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.7085751128303954,0.0,0.0,0.0,0.8942617666022358,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0748898678413907,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30232558139533694,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48936170212766683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7533039647576913,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5581395348837077,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.421018697614449,0.0,0.1818181818181818,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7577092511012893,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.418604651162795,0.0,48.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,7.372093023255843,24.67441860465118,0.0,0.0,0.0,0.0,0.0,0.0,1.3359123146357268,0.0,0.1818181818181818,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.8105726872246635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5116279069767415,0.0,46.0,0.0,0.0,0.0,0.0,53.720930232558146,0.0,0.0,0.0,21.0,55.09302325581396,0.0,0.0,0.0,0.0,0.0,8.498388136686,6.656350741457095,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,64.41850220264315,66.0,3.9251101321586095,0.0,0.0,1.0,0.0,0.0,32.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,87.0,164.0,91.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2325581395348593,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069662,0.0,57.302325581395365,0.0,60.790697674418595,0.0,17.930232558139494,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,4.154094132817544,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.71365638766521,11.77092511013214,38.64317180616747,0.16299559471367786,0.0,0.0,0.0,1.0,0.0,0.0,43.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,102.86046511627907,72.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7446808510638334,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,68.02202643171805,61.22907488986786,4.0,0.6079295154184763,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,0.04651162790698038,0.0,1.139534883720927,0.7674418604651123,0.13953488372092693,0.0,0.34883720930233153,0.16279069767441,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.813953488372107,117.5813953488372,0.34751773049645607,0.39007092198582427,1.4545454545454544,1.0851063829787364,1.4545454545454544,0.27659574468086134,1.0851063829787364,0.0,1.4545454545454544,0.0851063829787364,0.4577691811733775,1.0,0.0,0.0,0.0,1.0,1.0,1.4545454545454544,3.454545454545454,0.0,0.0,0.480176211453748,0.4977973568281868,0.32158590308370094,0.5506607929515468,0.4977973568281868,0.0,0.7797356828193784,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,1.0,43.53744493392075,65.22026431718058,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,74.0,0.0,54.0,0.34751773049645607,0.0,0.21921341070277367,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.341715022566076,0.0,5.091553836234694,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,17.0,0.0,0.0,41.0,0.0,0.0,16.0,0.0,0.0,0.0,0.023255813953483084,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6046511627906952,0.0,0.09302325581396076,0.9069767441860392,43.0232558139535,4.883720930232556,95.0,70.46511627906978,0.0,0.0,0.0,0.0425531914893611,0.0,0.0,0.0,0.0,0.0,1.4177949709864723,0.0,2.343649258542937,0.0,1.5177304964539022,0.574468085106389,3.8391360412636075,3.2646679561573304,0.0,0.0,0.0,0.0,0.0,0.28634361233480377,0.0,12.0,0.0,0.0,0.0,0.0,0.0,21.083700440528602,0.0,1.3524229074889718,0.9515418502202522,7.123348017620884,20.955947136563864,32.24669603524262,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.76744186046511,0.0,0.0,0.0,42.0,0.0,0.0,1.7674418604651123,1.4651162790697754,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.1453744493392,0.0,0.0,0.0,0.0,0.0,4.449339207048581,14.0,0.0,0.4008810572687196,13.0,0.0,0.0,0.9471365638765974,31.0572687224669,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,84.0,30.232558139534888,0.0,0.0,0.0,60.0,0.0,67.76744186046511,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5682819383259883,0.0,0.0,0.0,0.0,0.0,0.0,2.2378854625549707,1.8149779735682614,0.0,0.0,8.37885462555078,0.0,0.0,0.0,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,1.860465116279073,0.0,0.0,37.0,79.76744186046511,0.0,0.0,0.0,0.0,44.372093023255815,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.096916299559453,0.0,1.5903083700440703,0.0,0.0,3.9823788546255514,14.0,0.0,0.0,3.0,0.0,0.0,41.330396475770925,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,18.0,0.0,0.0,9.0,14.0,42.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20704845814977124,0.0,0.7929515418502288,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,57.697674418604635,14.232558139534888,0.0,0.0,0.0,44.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.999999999999993,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,83.0,28.0,32.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.48837209302323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.255813953488374,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,25.09302325581396,39.16279069767444,3.48837209302323,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16666666666666663,0.16666666666666663,0.6666666666666667,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04651162790698038,0.0,0.023255813953483084,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.255813953488374,0.0,0.0,0.0,0.0,0.0,1.4545454545454544,0.21921341070277367,0.0425531914893611,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.480176211453748,0.0,0.28634361233480377,0.5682819383259883,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.139534883720927,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4545454545454544,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.32158590308370094,0.0,12.0,9.1453744493392,0.0,0.0,8.096916299559453,0.20704845814977124,0.0,9.999999999999993,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7674418604651123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27659574468086134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372092693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.7929515418502288,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.860465116279073,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5903083700440703,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4545454545454544,0.0,1.4177949709864723,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7797356828193784,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16279069767441,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6046511627906952,40.76744186046511,84.0,0.0,37.0,0.0,29.0,57.697674418604635,0.0,0.0,5.48837209302323,0.0,0.0,0.0,0.0,0.0,0.0,0.4577691811733775,0.0,2.343649258542937,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,10.0,21.083700440528602,4.449339207048581,2.2378854625549707,0.0,0.0,3.9823788546255514,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.232558139534888,0.0,79.76744186046511,0.0,18.0,14.232558139534888,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,0.0,14.0,1.8149779735682614,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09302325581396076,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5177304964539022,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3524229074889718,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9069767441860392,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.574468085106389,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9515418502202522,0.4008810572687196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,43.0232558139535,42.0,0.0,0.0,0.0,0.0,9.0,0.0,0.0,0.0,0.0,0.0,25.09302325581396,0.0,0.0,0.0,0.0,0.0,0.0,3.8391360412636075,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16666666666666663,0.0,0.0,0.0,0.0,0.0,41.0,7.123348017620884,13.0,8.37885462555078,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.883720930232556,0.0,60.0,0.0,0.0,0.0,14.0,44.0,0.0,0.0,0.0,0.0,39.16279069767444,0.0,0.0,0.0,0.0,1.0,6.341715022566076,3.2646679561573304,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16666666666666663,0.0,0.0,0.0,0.0,0.0,0.0,20.955947136563864,0.0,0.0,0.0,0.0,0.0,0.0,0.0,83.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,74.0,95.0,0.0,0.0,0.0,44.372093023255815,0.0,42.0,0.0,0.0,0.0,0.0,0.0,3.48837209302323,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6666666666666667,0.0,0.0,0.0,0.0,1.0,0.0,32.24669603524262,0.0,0.0,0.0,0.0,0.0,0.0,0.0,28.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,2.813953488372107,0.0,70.46511627906978,1.7674418604651123,67.76744186046511,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4545454545454544,5.091553836234694,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,43.53744493392075,16.0,0.0,0.9471365638765974,0.0,0.0,0.0,41.330396475770925,0.0,0.0,32.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,117.5813953488372,54.0,0.0,1.4651162790697754,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.454545454545454,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,65.22026431718058,0.0,17.0,31.0572687224669,18.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,0.1860465116279073,0.0,1.9302325581395365,0.9767441860465169,0.1860465116279073,0.0,0.3953488372093048,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5581395348837077,109.76744186046511,0.34751773049645607,0.39007092198582427,0.39007092198582427,1.0851063829787364,1.0425531914893682,0.27659574468086134,1.3636363636363635,2.0,1.3636363636363635,0.48936170212766683,0.0,1.0,0.0,0.0,0.11476466795609852,2.0,1.0,1.3636363636363635,0.7730496453900741,0.0,0.0,0.24669603524229444,0.4977973568281868,0.6651982378854626,1.6651982378854626,0.7797356828193784,0.0,1.8942731277533085,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.850220264317215,68.28634361233478,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,85.0,0.0,34.0,0.34751773049645607,0.0,0.44680851063828975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.172147001934242,3.0335267569310123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.0,0.0,17.0,0.0,0.0,0.0,0.32558139534884134,0.0,0.0,0.0,0.0,0.0,0.0,1.0930232558139608,3.1627906976744242,3.51162790697677,0.5813953488372192,0.04651162790696617,80.65116279069767,4.32558139534882,58.0,24.302325581395337,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9129593810444983,0.0,1.801418439716315,0.0,1.5177304964539113,1.3636363636363635,2.374597034171561,6.0296582849773515,0.0,0.0,0.0,0.0,0.0,0.23788546255507015,0.0,6.660792951541964,0.0,0.0,0.0,0.0,0.14537444933920796,44.74449339207047,14.0,0.28634361233477534,0.9559471365638501,32.01321585903082,15.95594713656385,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,78.0,18.093023255813932,0.0,0.0,0.0,0.0,0.0,1.9069767441860677,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18246292714378476,0.0,2.0,0.0,0.9087685364281075,0.9087685364281075,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,13.0,27.0,25.0,1.5022026431717563,6.497797356828244,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,78.0,66.97674418604652,0.0,0.0,0.0,0.0,0.0,84.02325581395348,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2775330396475695,0.7973568281937133,0.0,0.0,0.0,0.0,0.0,10.506607929515578,14.814977973568261,0.0,0.0,0.6035242290748783,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,36.0,0.0,0.5813953488372192,0.0,0.0,26.0,14.162790697674438,0.0,0.0,0.0,85.25581395348834,0.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.030837004405285,0.0,0.2995594713656402,0.0,0.0,18.0,0.0,0.0,0.0,12.0,0.0,0.0,0.0,2.70044052863436,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,18.0,9.0,0.0,0.0,8.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,20.581395348837205,20.465116279069747,0.0,0.0,0.0,102.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,78.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,0.0,19.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8139534883720643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.465116279069763,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.034883720930203,0.18604651162797836,27.313953488372057,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13656387665196235,1.8634361233480377,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1860465116279073,0.0,0.32558139534884134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.465116279069763,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.44680851063828975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.24669603524229444,0.0,0.23788546255507015,1.2775330396475695,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9302325581395365,0.0,0.0,0.0,0.0,36.0,0.0,1.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6651982378854626,0.0,6.660792951541964,1.0,0.7973568281937133,0.0,19.030837004405285,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9767441860465169,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27659574468086134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6651982378854626,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1860465116279073,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7797356828193784,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5813953488372192,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2995594713656402,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3953488372093048,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.0,1.9129593810444983,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8942731277533085,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0930232558139608,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48936170212766683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.14537444933920796,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.1627906976744242,78.0,78.0,0.0,26.0,0.0,18.0,20.581395348837205,0.0,0.0,0.8139534883720643,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.801418439716315,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,44.74449339207047,0.0,10.506607929515578,0.0,0.0,18.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.51162790697677,18.093023255813932,66.97674418604652,0.0,14.162790697674438,0.0,9.0,20.465116279069747,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,14.814977973568261,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5813953488372192,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5177304964539113,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.28634361233477534,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.04651162790696617,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,0.18246292714378476,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9559471365638501,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,80.65116279069767,0.0,0.0,0.0,0.0,1.0,8.0,0.0,0.0,0.0,0.0,0.0,26.034883720930203,0.0,0.0,0.0,0.0,0.11476466795609852,0.0,2.374597034171561,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,32.01321585903082,13.0,0.6035242290748783,0.0,0.0,12.0,0.0,0.0,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.32558139534882,0.0,0.0,0.0,85.25581395348834,0.0,19.0,102.0,78.0,0.0,0.0,0.0,0.18604651162797836,0.0,0.0,0.0,0.0,2.0,0.0,6.0296582849773515,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.0,15.95594713656385,27.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13656387665196235,0.0,0.0,0.0,0.0,0.0,85.0,58.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,27.313953488372057,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,25.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8634361233480377,0.0,0.0,0.0,0.0,2.5581395348837077,0.0,24.302325581395337,1.9069767441860677,84.02325581395348,0.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3636363636363635,8.172147001934242,0.0,0.9087685364281075,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.850220264317215,17.0,4.0,1.5022026431717563,0.0,0.0,0.0,0.0,0.0,0.0,19.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,109.76744186046511,34.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7730496453900741,3.0335267569310123,0.0,0.9087685364281075,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,68.28634361233478,0.0,0.0,6.497797356828244,0.0,0.0,0.0,2.70044052863436,0.0,0.0,13.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.0,0.2093023255813975,0.0,1.3023255813953512,0.7674418604651123,0.34883720930233153,0.0,0.34883720930233153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0697674418604777,119.953488372093,0.34751773049645607,0.39007092198582427,0.39007092198582427,0.0851063829787364,1.0425531914893682,2.4197292069631864,0.4680851063829863,0.0,1.2765957446808613,0.48936170212766683,0.0,2.0,0.0,0.0,2.0,1.0,2.0,1.5454545454545452,1.5454545454545452,0.0,0.0,0.5330396475770982,0.4977973568281868,1.7797356828193784,0.5506607929515468,0.23788546255507015,0.0,1.321585903083701,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,1.0,62.54625550660796,67.41850220264314,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,76.0,0.0,26.0,0.34751773049645607,0.0,0.44680851063828975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,7.057382333978085,2.1482914248871694,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,9.0,0.0,0.0,29.0,29.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418604651162795,0.0,0.5581395348837077,0.9069767441860392,2.116279069767444,1.813953488372107,144.18604651162792,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8297872340425556,0.0,0.5177304964539076,0.574468085106389,1.4893617021276693,6.588652482269478,0.0,0.0,0.0,0.0,0.0,0.4757709251101261,0.0,9.264317180616814,0.0,0.0,0.0,0.0,0.0,28.083700440528602,0.0,0.15418502202641093,0.9515418502202522,2.8105726872246635,63.25991189427313,0.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.279069767441854,81.0,1.1395348837209553,0.5813953488371908,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.772404900064473,0.0,0.0,2.2275950999355274,0.0,0.0,0.0,0.0,1.3083700440527934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,44.0,30.678414096916413,0.0,1.405286343612289,0.6079295154185047,0.0,0.0,0.0,1.0465116279069768,0.0,0.0,0.0,0.0,0.0,0.0,23.0,0.48837209302325846,0.0,0.0,40.95348837209302,61.0,0.0,107.51162790697674,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7533039647577098,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.3039647577092595,0.0,0.0,34.94273127753303,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,27.906976744186053,0.0,0.418604651162795,0.0,0.0,38.0,33.0,0.0,1.0,11.0,21.09302325581396,0.0,6.581395348837191,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8568665377176785,0.8297872340425556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3133462282397659,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7577092511013177,0.0,0.0,38.24229074889868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,60.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,0.1860465116279073,56.16279069767437,38.69767441860466,0.0,0.0,2.953488372093048,0.0,0.0,0.0,38.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,20.0,39.0,0.0,0.0,10.0,0.0,0.0,15.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,0.0,0.0,0.0,0.0,30.0,1.0,0.0,0.0,0.0,36.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,11.11627906976749,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.720930232558137,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,39.27906976744185,2.930232558139494,2.2325581395348593,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255813975,0.0,0.0,1.0465116279069768,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.720930232558137,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.44680851063828975,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5330396475770982,0.0,0.4757709251101261,0.7533039647577098,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3023255813953512,0.0,0.0,0.0,0.0,27.906976744186053,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7797356828193784,0.0,9.264317180616814,1.3083700440527934,0.0,0.0,0.0,1.0,0.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7674418604651123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.4197292069631864,0.0,0.0,0.0,0.0,0.0,0.8568665377176785,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4680851063829863,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23788546255507015,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8297872340425556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7577092511013177,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2765957446808613,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.321585903083701,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1860465116279073,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48936170212766683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418604651162795,0.0,23.0,0.0,38.0,0.0,8.0,56.16279069767437,20.0,0.0,11.11627906976749,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.8297872340425556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,17.0,28.083700440528602,0.0,0.0,0.0,0.0,38.24229074889868,0.0,0.0,30.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48837209302325846,0.0,33.0,0.0,0.0,38.69767441860466,39.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,9.0,0.0,0.0,5.3039647577092595,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5581395348837077,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5177304964539076,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.15418502202641093,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9069767441860392,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.574468085106389,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9515418502202522,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.116279069767444,0.0,40.95348837209302,0.0,11.0,0.0,0.0,2.953488372093048,10.0,0.0,0.0,0.0,39.27906976744185,0.0,0.0,0.0,0.0,2.0,0.0,1.4893617021276693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,2.8105726872246635,44.0,34.94273127753303,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.813953488372107,22.279069767441854,61.0,0.0,21.09302325581396,2.0,60.0,0.0,0.0,0.0,0.0,0.0,2.930232558139494,0.0,0.0,0.0,0.0,1.0,0.0,6.588652482269478,7.772404900064473,0.0,0.0,0.0,0.3133462282397659,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,63.25991189427313,30.678414096916413,0.0,0.0,0.0,0.0,0.0,0.0,36.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,76.0,144.18604651162792,81.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2325581395348593,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0697674418604777,0.0,0.0,1.1395348837209553,107.51162790697674,0.0,6.581395348837191,0.0,0.0,0.0,15.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5454545454545452,7.057382333978085,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,62.54625550660796,0.0,20.0,1.405286343612289,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,119.953488372093,26.0,0.0,0.5813953488371908,0.0,0.0,14.0,0.0,0.0,38.0,9.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5454545454545452,2.1482914248871694,0.0,2.2275950999355274,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,67.41850220264314,0.0,0.0,0.6079295154185047,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.023255813953497295,0.46511627906976827,0.0,1.2558139534883708,0.9302325581395365,0.7209302325581461,0.0,0.13953488372092693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06976744186047767,120.39534883720927,0.34751773049645607,1.021276595744684,0.836879432624114,0.8936170212766115,1.2340425531914931,1.4680851063829863,0.6595744680851112,0.0,0.27659574468086134,0.48936170212766683,0.0,0.0,0.0,0.0,1.0,3.0,2.0,1.6363636363636362,3.136686009026379,0.0,0.0,0.9118942731277571,0.5814977973568318,0.5506607929515468,0.008810572687224294,0.8105726872246635,0.0,0.20704845814977801,0.1145374449339207,0.0,0.0,0.0,0.0,0.0,33.18502202643175,1.0,39.21145374449338,46.41850220264314,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,82.0,0.0,5.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9948420373952342,9.65764023210831,0.0,0.0,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,27.0,7.0,0.0,0.0,41.0,24.0,0.0,0.0,0.0,0.0,0.0,0.32558139534884134,0.0,0.0,0.0,0.0,0.0,0.0,0.5813953488372094,1.7209302325581461,0.0,0.6046511627907023,0.3720930232558146,40.04651162790698,0.3488372093023031,58.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8014184397163161,0.0,0.5177304964539088,0.4545454545454545,0.48936170212766805,0.7163120567375939,0.0,0.0,2.0206318504190586,0.0,0.0,0.23788546255507015,0.0,0.0,0.0,0.0,0.0,0.0,0.6960352422907476,2.480176211453724,3.431718061673962,0.41850220264313975,1.0176211453744202,21.546255506607906,21.63436123348012,26.53744493392091,19.0,22.0,0.0,0.0,0.1860465116279002,0.0,0.0,0.0,0.0,0.0,0.0,0.0,38.0,8.976744186046488,0.0,0.0,62.0,0.0,0.0,0.9534883720930338,1.8837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.063185041908453,0.0,1.0631850419084543,0.0,22.87362991618309,7.0,0.0,0.0,0.0,0.0,2.12334801762114,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.47136563876651394,0.40528634361234595,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,100.0,26.74418604651163,0.0,0.0,0.0,0.0,0.0,98.25581395348837,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.76211453744493,14.164757709251091,0.0,0.0,0.0,0.0,0.0,3.709631293142156,14.229455081688418,0.4008810572687196,0.6887272659480044,19.04443305525668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,33.0,0.0,0.11627906976744384,0.0,0.0,34.0,17.0,0.0,0.0,0.0,0.0,34.883720930232556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.429955947136577,0.0,1.0396475770925093,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.48837209302325846,0.0,0.4186046511627808,0.0,1.0,21.0,3.0,1.0,0.0,4.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.11627906976744,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5581395348837077,0.11627906976747227,0.0,0.0,0.0,123.20930232558138,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.651162790697674,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,169.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,26.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,31.09302325581399,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8604651162790655,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.302325581395365,16.790697674418617,32.04651162790695,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.023255813953497295,0.0,0.1860465116279002,0.0,0.0,0.0,0.0,0.0,2.11627906976744,4.651162790697674,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.021276595744684,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.46511627906976827,0.0,0.32558139534884134,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,1.8604651162790655,0.0,0.0,0.0,0.0,0.0,0.836879432624114,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9118942731277571,0.0,0.23788546255507015,2.76211453744493,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8936170212766115,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5814977973568318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2558139534883708,0.0,0.0,0.0,0.0,33.0,0.0,0.48837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2340425531914931,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,8.0,0.0,2.12334801762114,14.164757709251091,0.0,7.429955947136577,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9302325581395365,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4680851063829863,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.008810572687224294,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7209302325581461,0.0,0.0,0.0,0.0,0.0,0.0,0.4186046511627808,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6595744680851112,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8105726872246635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11627906976744384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0396475770925093,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372092693,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27659574468086134,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20704845814977801,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5813953488372094,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48936170212766683,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.1145374449339207,0.0,0.6960352422907476,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7209302325581461,38.0,100.0,0.0,34.0,0.0,21.0,0.5581395348837077,0.0,0.0,31.09302325581399,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8014184397163161,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,27.0,2.480176211453724,0.0,3.709631293142156,0.0,0.0,0.0,0.0,0.0,22.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.976744186046488,26.74418604651163,0.0,17.0,0.0,3.0,0.11627906976747227,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,7.0,3.431718061673962,0.0,14.229455081688418,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6046511627907023,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5177304964539088,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.41850220264313975,0.0,0.4008810572687196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3720930232558146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4545454545454545,2.063185041908453,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0176211453744202,0.0,0.6887272659480044,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,40.04651162790698,62.0,0.0,0.0,0.0,5.0,4.0,0.0,0.0,0.0,0.0,0.0,8.302325581395365,0.0,0.0,0.0,0.0,1.0,0.0,0.48936170212766805,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,41.0,21.546255506607906,0.0,19.04443305525668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3488372093023031,0.0,0.0,0.0,0.0,0.0,0.0,123.20930232558138,169.0,0.0,0.0,0.0,16.790697674418617,0.0,0.0,0.0,0.0,3.0,0.0,0.7163120567375939,1.0631850419084543,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,33.18502202643175,24.0,21.63436123348012,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,82.0,58.0,0.0,0.0,0.0,34.883720930232556,0.0,3.0,0.0,0.0,0.0,0.0,0.0,32.04651162790695,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,26.53744493392091,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.06976744186047767,0.0,0.0,0.9534883720930338,98.25581395348837,0.0,0.0,0.0,0.0,17.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6363636363636362,0.9948420373952342,0.0,22.87362991618309,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,39.21145374449338,0.0,19.0,0.47136563876651394,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,120.39534883720927,5.0,0.0,1.8837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.136686009026379,9.65764023210831,2.0206318504190586,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,46.41850220264314,0.0,22.0,0.40528634361234595,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,1.0930232558139608,0.13953488372093403,0.0,1.0465116279069804,0.6744186046511658,0.5116279069767415,0.0,0.3255813953488378,0.16279069767441,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.09302325581396076,126.953488372093,0.34751773049645607,0.39007092198582427,0.6950354609929121,0.0851063829787364,1.727272727272727,1.727272727272727,0.0425531914893682,0.0,1.727272727272727,1.0851063829787364,0.0,1.785944551901947,1.0,0.0,2.0,2.0,1.0,1.6595744680851112,1.727272727272727,0.0,0.7621145374449341,1.674008810572694,0.4977973568281868,0.7797356828193784,1.7797356828193784,0.5286343612334861,0.0,1.5814977973568318,1.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,2.0,47.66519823788549,66.6167400881057,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,57.0,0.0,23.0,0.34751773049645607,0.30496453900708786,0.14184397163120188,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20567375886525419,0.0,7.0,7.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,33.0,2.0,0.0,0.0,39.0,0.0,0.0,17.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5116279069767415,0.0,0.27906976744185386,0.25581395348837077,2.139534883720927,1.0465116279069662,71.76744186046514,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35783365570600933,0.0,0.7105093488072252,0.0,0.39845261121857717,0.3636363636363636,0.37008381689233644,1.7994842037394883,0.0,0.0,0.0,0.0,0.0,0.23788546255506304,0.0,10.0,0.0,0.0,0.0,0.0,0.48898678414096963,7.480176211453724,0.0,0.6211453744493269,0.6211453744493269,2.678414096916285,69.08370044052863,21.788546255506674,12.0,14.0,0.0,0.0,1.2325581395348766,0.0,0.0,0.0,0.0,0.0,0.0,0.0,41.3953488372094,26.0,0.0,0.0,26.0,0.0,14.0,1.255813953488314,1.1162790697674154,0.0,0.0,0.8581560283687963,0.0,8.315280464216642,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0973565441650623,0.0,6.0,0.0,10.327530625402957,8.401676337846546,0.0,0.0,0.5242290748898677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6475770925110487,0.0,0.0,0.22026431718057893,0.6079295154185047,0.0,0.0,0.0,0.32558139534883423,33.0,0.0,0.0,0.0,0.0,0.0,16.0,2.7674418604651123,0.0,0.0,0.0,60.0,0.0,62.90697674418605,35.0,0.0,0.0,0.0,0.0,0.0,0.3365570599613224,0.0,0.0,0.0,0.0,0.0909090909090909,0.39071566731140484,0.0909090909090909,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0881057268722145,0.0,0.0,42.911894273127785,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.48837209302325846,0.0,0.5348837209302246,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,67.51162790697674,13.465116279069775,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2687224669603552,0.0,0.0,0.0,0.0,0.0,0.0,10.731277533039645,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,37.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2325581395348948,1.2093023255813193,2.534883720930253,0.0,0.0,24.02325581395354,100.0,0.0,60.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,62.0,0.0,0.0,0.0,33.0,54.0,0.0,34.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,69.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.325581395348838,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,61.674418604651166,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,2.325581395348836,6.511627906976743,0.0,0.0,0.0,0.0,0.0,0.0,1.0,53.06976744186055,0.0,0.0,1.6279069767441143,1.1395348837209553,3.3023255813953085,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5770925110132197,0.0,0.42290748898677744,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0930232558139608,0.0,1.2325581395348766,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.325581395348838,2.325581395348836,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.30496453900708786,0.8581560283687963,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7621145374449341,0.0,0.5242290748898677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372093403,0.0,0.0,0.32558139534883423,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.511627906976743,0.0,0.0,0.0,0.0,0.0,0.6950354609929121,0.14184397163120188,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.674008810572694,0.0,0.23788546255506304,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069804,0.0,0.0,0.0,33.0,0.48837209302325846,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.727272727272727,0.0,0.0,8.315280464216642,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7797356828193784,0.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6744186046511658,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.727272727272727,0.0,0.0,0.0,0.3365570599613224,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7797356828193784,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5116279069767415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5286343612334861,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5348837209302246,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2687224669603552,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3255813953488378,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.727272727272727,0.0,0.35783365570600933,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5814977973568318,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.16279069767441,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2325581395348948,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1145374449339207,0.0,0.48898678414096963,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5116279069767415,41.3953488372094,16.0,0.0,0.0,0.0,0.0,1.2093023255813193,62.0,0.0,61.674418604651166,53.06976744186055,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7105093488072252,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,33.0,7.480176211453724,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,26.0,2.7674418604651123,0.0,0.0,0.0,0.0,2.534883720930253,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.785944551901947,0.0,0.0,0.0,0.39071566731140484,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,1.0881057268722145,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27906976744185386,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.39845261121857717,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6211453744493269,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25581395348837077,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3636363636363636,2.0973565441650623,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6211453744493269,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.139534883720927,26.0,0.0,0.0,0.0,0.0,0.0,24.02325581395354,33.0,0.0,0.0,0.0,1.6279069767441143,0.0,0.0,0.0,0.0,2.0,0.0,0.37008381689233644,0.0,0.0909090909090909,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,39.0,2.678414096916285,2.6475770925110487,42.911894273127785,0.0,0.0,10.731277533039645,1.0,0.0,3.0,0.0,0.0,1.0,0.5770925110132197,0.0,0.0,0.0,0.0,0.0,0.0,1.0465116279069662,0.0,60.0,0.0,0.0,0.0,3.0,100.0,54.0,0.0,0.0,0.0,1.1395348837209553,0.0,0.0,0.0,0.0,2.0,0.20567375886525419,1.7994842037394883,6.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,69.08370044052863,0.0,0.0,0.0,0.0,0.0,0.0,0.0,69.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,57.0,71.76744186046514,14.0,0.0,0.0,67.51162790697674,2.0,37.0,0.0,0.0,0.0,0.0,0.0,3.3023255813953085,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,21.788546255506674,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.42290748898677744,0.0,0.0,0.0,0.0,0.09302325581396076,0.0,0.0,1.255813953488314,62.90697674418605,0.0,13.465116279069775,0.0,0.0,60.0,34.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6595744680851112,7.0,0.0,10.327530625402957,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,47.66519823788549,17.0,12.0,0.22026431718057893,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,126.953488372093,23.0,0.0,1.1162790697674154,35.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.727272727272727,7.0,0.0,8.401676337846546,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.6167400881057,0.0,14.0,0.6079295154185047,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,2.418604651162793,0.837209302325586,0.0,0.6279069767441854,0.418604651162795,0.5116279069767415,0.0,0.27906976744186096,0.11627906976744384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.83720930232559,135.953488372093,0.34751773049645607,0.6950354609929121,0.8199011390500612,1.0851063829787364,1.6363636363636362,2.063829787234052,0.0425531914893682,1.0,0.6808510638297918,1.2765957446808613,2.0,1.0,0.0,0.0,0.0,0.0,2.0,0.687943262411352,2.6643026004727726,0.0,0.0,0.7224669603524347,0.4977973568281868,1.7797356828193784,2.092511013215862,0.5286343612334861,0.0,1.4669603524229018,0.4581497797356828,16.691629955947178,2.0,0.0,0.0,24.0,32.0,0.0,28.013215859030822,19.748898678414065,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,57.0,0.0,15.0,0.34751773049645607,0.0,0.016978293574052783,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.635503975929492,0.0,0.286343612334802,0.0,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,53.577092511013234,0.0,41.13656387665196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.046511627906966,0.0,0.3720930232558146,0.30232558139533694,1.6511627906976685,3.0697674418604777,63.558139534883736,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,19.854625550660728,0.0,1.0176211453744202,0.7533039647576913,42.74449339207047,70.6299559471367,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,106.0,0.0,0.0,0.0,0.0,0.02127659574468055,0.0,0.19342359767891937,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4893617021276668,0.0,0.0,0.0,23.82978723404255,18.466150870406185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.20930232558139394,0.48837209302325135,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2558139534883708,0.0,0.0,0.0,81.30232558139535,43.0,77.74418604651163,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.475770925110132,0.0,0.4581497797356917,0.0,0.0,0.0,0.0,0.0,7.4493392070484745,3.488986784140934,0.0,0.0,28.074889867841392,5.052863436123374,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.67441860465115,0.0,0.32558139534884845,0.0,0.0,8.0,0.0,0.0,0.0,0.0,5.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.23788546255507015,0.0,0.0,19.76211453744493,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.023255813953512,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,32.97674418604649,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3488372093023244,0.0,0.0,2.0,0.0,0.0,0.0,0.8139534883720927,25.97674418604653,19.790697674418595,0.0,0.0,45.0,54.0,0.0,25.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,55.0,3.0,0.0,0.0,9.0,0.0,0.0,27.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,28.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,34.744186046511615,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7446808510638359,0.0,0.0,0.0,0.0,0.0,0.0,0.25531914893616414,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,22.8837209302325,2.5348837209302815,2.581395348837219,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.418604651162793,0.0,0.0,0.20930232558139394,0.0,0.0,0.0,0.0,0.3488372093023244,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6950354609929121,0.0,0.02127659574468055,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.286343612334802,0.0,1.475770925110132,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.837209302325586,0.0,0.0,0.48837209302325135,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8199011390500612,0.016978293574052783,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7224669603524347,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6279069767441854,0.0,0.0,0.0,0.0,22.67441860465115,0.0,8.023255813953512,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6363636363636362,0.0,0.0,0.19342359767891937,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7797356828193784,8.0,0.0,0.0,0.4581497797356917,0.0,2.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418604651162795,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.063829787234052,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.092511013215862,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5116279069767415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0425531914893682,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5286343612334861,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.32558139534884845,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23788546255507015,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27906976744186096,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6808510638297918,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4669603524229018,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11627906976744384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8139534883720927,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2765957446808613,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4581497797356828,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.046511627906966,0.0,0.0,0.0,8.0,0.0,0.0,25.97674418604653,55.0,0.0,34.744186046511615,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7446808510638359,0.0,0.0,0.0,0.0,0.0,0.0,16.691629955947178,0.0,19.854625550660728,0.0,7.4493392070484745,0.0,0.0,19.76211453744493,0.0,0.0,28.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2558139534883708,0.0,0.0,0.0,0.0,19.790697674418595,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,3.488986784140934,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3720930232558146,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0176211453744202,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.30232558139533694,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4893617021276668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7533039647576913,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6511627906976685,0.0,0.0,0.0,0.0,0.0,0.0,45.0,9.0,0.0,0.0,0.0,22.8837209302325,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,0.0,42.74449339207047,0.0,28.074889867841392,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0697674418604777,0.0,81.30232558139535,0.0,5.0,0.0,32.97674418604649,54.0,0.0,0.0,0.0,0.0,2.5348837209302815,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,32.0,53.577092511013234,70.6299559471367,0.0,5.052863436123374,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,57.0,63.558139534883736,106.0,43.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.581395348837219,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.83720930232559,0.0,0.0,0.0,77.74418604651163,0.0,0.0,0.0,0.0,25.0,27.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.687943262411352,0.0,0.0,23.82978723404255,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,28.013215859030822,41.13656387665196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,135.953488372093,15.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.6643026004727726,16.635503975929492,0.0,18.466150870406185,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.25531914893616414,0.0,0.0,0.0,0.0,0.0,19.748898678414065,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,0.11627906976744384,0.13953488372093403,0.0,2.2093023255814046,0.2093023255814046,1.5116279069767415,0.0,0.27906976744186096,0.6511627906976685,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3488372093023315,127.53488372093021,0.34751773049645607,0.39007092198582427,0.6950354609929121,0.0851063829787364,1.909090909090909,1.8510638297872362,0.23404255319149314,0.0,1.4893617021276668,1.8723404255319238,0.5519019987104521,3.0,1.0,0.0,2.0,0.0,2.0,1.7163120567375927,1.8581560283687963,0.0,0.0,0.674008810572694,0.4977973568281868,2.0088105726872243,0.35242290748898597,0.44493392070484106,0.0,0.5506607929515468,1.1145374449339207,0.0,0.0,0.0,0.0,0.0,0.0,2.0,66.54185022026434,74.81497797356826,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.0,0.0,0.0,37.0,0.34751773049645607,0.1631205673758842,0.16312056737588243,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,7.789650749498264,8.536590385253511,0.0,0.286343612334802,1.0,0.0,10.0,0.0,0.0,0.0,0.0,0.0,24.0,0.0,0.0,0.0,24.0,29.0,0.0,1.2114537444933546,24.50220264317184,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.581395348837219,0.0,0.11627906976744384,0.06976744186047767,1.8837209302325562,68.3488372093023,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.14537444933920796,4.744493392070467,0.0,0.6167400881057006,1.220264317180579,69.66079295154195,32.6123348017621,0.0,24.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,134.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3249516441005842,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5177304964539076,0.0,0.0,0.0,19.952128747600376,19.20518911184513,0.0,0.0,0.0,0.0,0.5726872246696075,0.0,0.0,0.0,0.0,0.0,4.418502202643168,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.008810572687224294,0.0,0.0,2.2093023255813935,2.1860465116279033,0.0,0.0,0.0,0.0,0.0,0.0,54.3953488372093,0.7906976744185954,0.0,0.0,45.0,8.0,0.0,87.41860465116281,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22114764667962356,0.29094132817533974,0.29094132817533974,0.0,0.19696969696969696,0.0,0.0,0.0,0.0,0.0,0.0,3.237885462555066,0.8557268722467377,15.181718061674044,0.0,0.0,0.0,0.0,0.0,23.56497797356833,0.6872246696034949,0.4008810572687196,0.0,1.0715859030836121,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,0.0,0.32558139534884845,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.674418604651152,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.22026431718062156,0.0,0.7797356828193784,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.581395348837205,0.0,0.0,0.0,0.0,10.418604651162795,0.0,0.0,0.0,0.0,0.0,40.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3023255813953547,63.790697674418595,0.0,0.0,0.0,0.0,0.0,89.90697674418604,16.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,14.0,0.0,0.0,0.0,0.0,0.0,130.0,36.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,21.441860465116292,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4883965116278735,1.3953488372093388,2.1162546511627878,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.26402321083173597,0.3679883945841321,0.3679883945841321,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11627906976744384,0.0,0.0,2.2093023255813935,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.39007092198582427,0.1631205673758842,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.286343612334802,0.0,3.237885462555066,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.13953488372093403,0.0,0.0,2.1860465116279033,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6950354609929121,0.16312056737588243,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.674008810572694,1.0,0.0,0.8557268722467377,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.2093023255814046,0.0,0.0,0.0,0.0,5.0,0.0,0.581395348837205,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.909090909090909,0.0,0.0,1.3249516441005842,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0088105726872243,10.0,0.0,0.5726872246696075,15.181718061674044,0.22026431718062156,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255814046,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8510638297872362,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.35242290748898597,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5116279069767415,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23404255319149314,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.44493392070484106,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.32558139534884845,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7797356828193784,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27906976744186096,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4893617021276668,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5506607929515468,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6511627906976685,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3023255813953547,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8723404255319238,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.1145374449339207,0.0,0.14537444933920796,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.581395348837219,0.0,54.3953488372093,0.0,0.0,0.0,10.418604651162795,63.790697674418595,14.0,2.0,21.441860465116292,0.0,0.0,0.0,0.0,0.0,0.0,0.5519019987104521,1.0,0.0,0.0,0.22114764667962356,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.0,4.744493392070467,4.418502202643168,23.56497797356833,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7906976744185954,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.29094132817533974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6872246696034949,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11627906976744384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.29094132817533974,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6167400881057006,0.0,0.4008810572687196,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06976744186047767,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5177304964539076,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.220264317180579,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8837209302325562,0.0,45.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4883965116278735,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.19696969696969696,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.26402321083173597,0.0,0.0,0.0,0.0,0.0,24.0,69.66079295154195,0.0,1.0715859030836121,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,30.0,68.3488372093023,134.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3953488372093388,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3679883945841321,0.0,0.0,0.0,0.0,0.0,29.0,32.6123348017621,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,15.674418604651152,0.0,40.0,89.90697674418604,130.0,0.0,0.0,0.0,2.1162546511627878,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.3679883945841321,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.3488372093023315,0.0,0.0,0.0,87.41860465116281,0.0,0.0,0.0,0.0,16.0,36.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7163120567375927,7.789650749498264,0.0,19.952128747600376,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,66.54185022026434,1.2114537444933546,24.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,127.53488372093021,37.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.8581560283687963,8.536590385253511,0.0,19.20518911184513,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,74.81497797356826,24.50220264317184,2.0,0.008810572687224294,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.5581395348837219,1.4186046511627914,0.46511627906976827,0.0,1.3720930232558146,1.7906976744186096,0.6744186046511658,0.0,0.11627906976744384,0.2325581395348877,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.2790697674418254,136.09302325581396,0.418439716312057,1.6950354609929121,0.836879432624114,0.0851063829787364,1.9999999999999998,0.8510638297872362,0.23404255319149314,0.0,0.0851063829787364,2.0638297872340488,1.0,0.0,0.0,0.0,3.0,0.0,3.0,0.7163120567375927,6.014184397163074,0.0,0.0,0.9118942731277571,0.4977973568281868,1.352422907488986,1.5506607929515468,0.9867841409691493,0.0,0.4669603524229018,0.8017621145374445,0.0,0.0,0.0,0.0,0.0,54.13656387665202,1.0,41.28193832599118,47.01321585903082,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,63.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.652482269503544,0.0,0.0,2.0,0.0,4.0,2.0,0.0,0.0,0.0,0.0,29.0,0.0,0.0,0.0,39.0,11.0,0.0,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,0.34883720930233153,0.06976744186047767,1.3953488372092977,55.83720930232556,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.643171806167401,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11453744493392293,2.1453744493391866,0.0,0.7533039647576913,0.7533039647576913,74.00881057268776,56.58149779735635,0.0,0.0,0.0,0.0,0.6046511627906968,0.1860465116279073,0.0,9.67441860465118,5.0,0.0,0.0,0.0,0.0,42.0,0.0,0.0,0.0,16.0,57.0,0.0,6.046511627906966,0.48837209302325846,0.0,0.5106382978723403,0.02127659574468055,0.0,0.23404255319149336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5177304964539076,0.0,0.0,0.0,29.808510638297804,12.907801418439774,0.0,0.0,0.0,0.0,0.22907488986784585,0.0,0.0,0.0,0.0,0.0,1.8986784140969264,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8722466960352279,0.0,0.0,0.0,1.860465116279069,4.279069767441854,0.581395348837205,0.0,0.0,0.0,0.0,32.0,0.27906976744185386,0.0,0.0,39.27906976744187,0.0,0.0,65.72093023255815,42.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.19696969696969696,0.2676767676767677,0.2676767676767677,0.0,0.2676767676767677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11453744493391582,0.0,0.0,0.0,0.0,52.39647577092515,0.4889867841409341,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.16279069767441,0.7906976744185954,0.8604651162790731,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.43612334801762387,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2093023255813904,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,8.0,2.0,0.0,0.0,0.2093023255814046,23.674418604651123,0.0,0.0,0.0,0.0,0.0,0.0,51.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5477111540941386,0.0,0.0,0.0,0.0,0.0,0.4522888459058614,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.9118942731277,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34751773049645607,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5581395348837219,0.0,0.6046511627906968,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.418439716312057,0.0,0.5106382978723403,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.643171806167401,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.4186046511627914,0.0,0.1860465116279073,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.6950354609929121,0.0,0.02127659574468055,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.46511627906976827,0.0,0.0,1.860465116279069,0.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.836879432624114,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9118942731277571,2.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4977973568281868,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3720930232558146,0.0,0.0,9.67441860465118,4.279069767441854,0.0,3.16279069767441,0.0,8.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.9999999999999998,0.0,0.0,0.23404255319149336,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.352422907488986,4.0,0.0,0.22907488986784585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.7906976744186096,0.0,0.0,5.0,0.581395348837205,0.0,0.7906976744185954,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8510638297872362,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.5506607929515468,2.0,0.0,0.0,0.11453744493391582,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.6744186046511658,0.0,0.0,0.0,0.0,0.0,0.0,1.2093023255813904,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.23404255319149314,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9867841409691493,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8604651162790731,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.43612334801762387,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.11627906976744384,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0851063829787364,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4669603524229018,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2325581395348877,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2093023255814046,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0638297872340488,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8017621145374445,0.0,0.11453744493392293,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,42.0,32.0,0.0,0.0,0.0,0.0,23.674418604651123,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.19696969696969696,0.0,0.0,0.0,0.0,0.0,0.0,0.5477111540941386,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,29.0,2.1453744493391866,1.8986784140969264,52.39647577092515,0.0,0.0,1.0,0.0,0.0,0.0,3.9118942731277,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.27906976744185386,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2676767676767677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4889867841409341,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.2676767676767677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7533039647576913,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.06976744186047767,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.5177304964539076,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7533039647576913,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.3953488372092977,16.0,39.27906976744187,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.2676767676767677,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,39.0,74.00881057268776,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,63.0,55.83720930232556,57.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,54.13656387665202,11.0,56.58149779735635,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.2790697674418254,0.0,0.0,6.046511627906966,65.72093023255815,0.0,0.0,0.0,0.0,51.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.7163120567375927,0.0,0.0,29.808510638297804,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.4522888459058614,0.0,0.0,0.0,0.0,0.0,0.0,41.28193832599118,12.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,136.09302325581396,0.0,0.0,0.48837209302325846,42.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,6.014184397163074,16.652482269503544,0.0,12.907801418439774,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,47.01321585903082,0.0,0.0,0.8722466960352279,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_offloaded.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_offloaded.csv
new file mode 100644
index 0000000..54a3137
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_offloaded.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,4.651162790697675,0.673758865248228,1.762114537444934,1.9069767441860463,1.879432624113484,0.0,0.0,0.0851063829787364,0.4977973568281868,8.302325581395351,3.003304319793677,17.03964757709251,0.4418604651162781,1.515151515151515,0.008810572687224294,2.9302325581395365,1.0851063829787364,1.176211453744493,2.197649418604684,0.0,0.9339207048458036,0.25581395348837077,2.0638297872340488,0.5506607929515468,2.372093023255818,1.6808510638297918,0.1145374449339207,182.6976744186046,0.8297872340425556,55.15418502202641,225.39534883720933,0.24242424242424238,23.810572687224663,1.3255813953488484,1.489361702127668,0.8854625550660558,0.13953488372092693,2.6312056737588714,1.0881057268722145,90.83720930232559,1.5177304964539087,88.62114537444928,167.55813953488368,16.402240490006363,148.5418502202644,391.8372093023256,2.0,0.0,147.74418604651163,1.5460992907801483,66.01762114537443,158.11627906976742,2.6595744680851103,118.53744493392078
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,0.0,0.39007092198582427,0.0,0.0,0.7163120567375927,0.09691629955947256,0.0,0.6808510638297918,0.9559471365638785,8.720930232558146,2.8510638297872344,27.38325991189427,0.48837209302325846,3.0851063829787346,1.1233480176211401,1.139534883720927,0.6808510638297918,0.8414096916299627,1.0697674418604919,0.42852998065762865,2.2466960352422944,0.418604651162795,1.6595744680851112,1.5506607929515468,0.5348837209302246,0.27659574468086134,0.6872246696035234,237.32558139534882,4.906092843326844,24.6167400881057,156.48837209302326,3.602836879432631,2.0748898678413905,0.30232558139533694,0.48936170212766683,0.7533039647576913,0.5581395348837077,1.6028368794326309,0.7577092511012893,83.46511627906982,1.5177304964539087,21.810572687224663,177.32558139534885,15.154738878143094,167.34361233480175,347.23255813953483,3.0,0.0,137.06976744186042,5.517730496453908,135.2907488986785,175.86046511627907,0.7446808510638334,134.85903083700438
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,0.0,0.39007092198582427,0.0,2.3255813953488373,1.7163120567375891,1.33480176211454,0.0,1.0851063829787364,0.4977973568281868,3.139534883720927,2.454545454545454,39.77092511013212,0.7674418604651123,0.27659574468086134,0.5506607929515468,0.13953488372092693,1.0851063829787364,1.2907488986784155,1.860465116279073,0.0,1.5903083700440703,0.34883720930233153,2.8723404255319265,0.7797356828193784,0.16279069767441,0.0851063829787364,0.1145374449339207,255.55813953488368,2.8014184397163144,55.753303964757706,142.2325581395349,1.0,46.81497797356826,0.09302325581396076,1.5177304964539022,1.3524229074889718,0.9069767441860392,0.574468085106389,1.3524229074889718,119.11627906976746,4.0058027079302745,72.50220264317167,162.046511627907,10.773049645390072,103.95594713656386,258.86046511627904,1.6666666666666667,62.24669603524262,142.8139534883721,6.546099290780148,133.81497797356826,173.04651162790697,3.454545454545454,131.2775330396475
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,0.0,0.39007092198582427,0.0,6.976744186046512,0.836879432624114,1.762114537444934,0.0,1.0851063829787364,0.4977973568281868,40.93023255813954,1.0425531914893682,28.154185022026425,0.9767441860465169,0.27659574468086134,1.6651982378854626,0.1860465116279073,1.3636363636363635,0.7797356828193784,0.5813953488372192,2.0,0.2995594713656402,0.3953488372093048,3.276595744680862,1.8942731277533085,1.0930232558139608,0.48936170212766683,0.25991189427312866,224.5581395348837,1.801418439716315,74.25110132158605,132.2093023255814,1.0,28.81497797356826,0.5813953488372192,1.5177304964539113,0.28634361233477534,0.04651162790696617,1.5460992907801483,0.9559471365638501,115.68604651162786,2.4893617021276597,69.6167400881057,288.76744186046517,10.029658284977351,109.09251101321581,170.31395348837205,1.0,26.863436123348038,132.7906976744186,10.444551901998713,82.35242290748897,144.7674418604651,4.715344938749194,90.48458149779738
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,0.0,0.39007092198582427,0.0,6.976744186046512,0.836879432624114,1.762114537444934,0.0,0.0851063829787364,0.4977973568281868,34.209302325581405,1.0425531914893682,20.352422907488986,0.7674418604651123,3.276595744680865,0.5506607929515468,0.34883720930233153,0.4680851063829863,0.23788546255507015,0.418604651162795,0.8297872340425556,0.7577092511013177,0.34883720930233153,1.2765957446808613,1.321585903083701,0.1860465116279073,0.48936170212766683,0.1145374449339207,156.69767441860466,3.8297872340425556,114.32599118942728,111.18604651162792,2.0,15.30396475770926,0.5581395348837077,0.5177304964539076,0.15418502202641093,1.9069767441860392,0.574468085106389,0.9515418502202522,106.30232558139535,3.4893617021276695,110.75330396475769,171.11627906976742,16.674403610573716,158.93832599118954,303.4186046511628,2.0,1.0,132.30232558139537,8.60283687943263,85.95154185022025,207.5348837209302,5.921341070277242,68.02643171806164
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,6.976744186046512,1.021276595744684,0.0,4.651162790697676,0.836879432624114,3.911894273127757,0.0,0.8936170212766115,0.5814977973568318,34.74418604651163,1.2340425531914931,32.268722466960355,0.9302325581395365,1.4680851063829863,0.008810572687224294,1.139534883720927,0.6595744680851112,0.8105726872246635,0.11627906976744384,0.0,1.0396475770925093,0.13953488372092693,0.27659574468086134,0.20704845814977801,1.5813953488372094,0.48936170212766683,0.8105726872246684,226.37209302325584,0.8014184397163161,55.189807504595876,55.83720930232559,0.0,24.66117314336238,1.6046511627907023,0.5177304964539088,0.8193832599118593,0.3720930232558146,2.5177304964539076,1.7063484113224245,119.34883720930235,1.4893617021276682,81.59068856186458,309.3488372093023,4.779497098646049,78.81938325991187,209.9302325581395,2.0,55.53744493392091,117.27906976744188,25.504835589941962,58.6828193832599,127.27906976744185,21.81495809155375,68.82378854625549
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,6.976744186046512,1.5531914893617085,1.2863436123348018,6.976744186046512,0.836879432624114,1.911894273127757,0.0,0.0851063829787364,0.4977973568281868,34.53488372093024,10.042553191489368,10.779735682819378,0.6744186046511658,2.0638297872340496,1.7797356828193784,0.5116279069767415,0.0425531914893682,0.5286343612334861,0.5348837209302246,0.0,0.2687224669603552,0.3255813953488378,2.0851063829787364,1.5814977973568318,2.395348837209305,1.0851063829787364,1.6035242290748903,235.86046511627916,0.8014184397163161,40.480176211453724,31.302325581395365,2.176660219213352,3.0881057268722145,0.27906976744185386,1.489361702127668,0.6211453744493269,0.25581395348837077,2.460992907801426,0.6211453744493269,86.79069767441858,2.4609929078014274,103.54625550660799,219.18604651162792,10.005157962604741,138.08370044052862,252.5813953488372,1.0,29.21145374449345,171.7209302325581,18.98710509348807,76.88546255506607,186.06976744186042,17.128949065119272,81.2246696035242
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,2.9767441860465116,0.7163120567375927,1.762114537444934,1.3255813953488373,0.836879432624114,0.7224669603524347,0.0,1.0851063829787364,0.4977973568281868,33.32558139534885,1.8297872340425556,26.23788546255507,0.418604651162795,2.063829787234052,2.092511013215862,0.5116279069767415,0.0425531914893682,0.5286343612334861,0.32558139534884845,1.0,0.23788546255507015,0.27906976744186096,0.6808510638297918,1.4669603524229018,0.9302325581395365,1.2765957446808613,0.4581497797356828,125.76744186046511,2.744680851063836,92.75770925110132,25.046511627906966,1.0,5.488986784140934,0.3720930232558146,0.0,1.0176211453744202,0.30232558139533694,1.4893617021276668,0.7533039647576913,78.53488372093017,0.0,94.81938325991186,178.88372093023258,0.0,165.2599118942733,272.13953488372096,2.0,1.0,130.58139534883722,24.5177304964539,69.14977973568278,151.953488372093,38.02127659574462,19.748898678414065
+0.0,0.34751773049645607,0.0,0.0,0.34751773049645607,0.0,2.3255813953488373,0.5531914893617085,3.524229074889868,2.3255813953488373,0.8581560283687946,2.5297356828194317,0.0,0.0851063829787364,0.4977973568281868,7.79069767441861,3.234042553191493,29.983480176211497,0.2093023255814046,1.8510638297872362,0.35242290748898597,1.5116279069767415,0.23404255319149314,0.44493392070484106,0.32558139534884845,0.0,1.7797356828193784,0.27906976744186096,1.4893617021276668,0.5506607929515468,0.9534883720930232,1.8723404255319238,1.2599118942731287,168.6279069767442,1.7730496453900757,59.72797356828197,0.7906976744185954,3.29094132817534,0.6872246696034949,0.11627906976744384,1.2909413281753397,1.0176211453744202,0.06976744186047767,0.5177304964539076,1.220264317180579,47.37211744186043,2.4609929078014328,94.73237885462557,241.74418604651163,0.3679883945841321,61.6123348017621,277.69765,2.367988394584132,2.0,141.76744186046514,29.458091553836233,91.75330396475769,165.53488372093022,29.599935525467437,101.32599118942733
+0.0,0.34751773049645607,0.0,1.1627906976744187,0.9290780141843973,0.643171806167401,1.6046511627906987,1.7163120567375927,0.0,4.325581395348838,0.836879432624114,3.911894273127757,0.0,0.0851063829787364,0.4977973568281868,26.48837209302326,2.234042553191493,5.581497797356832,10.16279069767441,0.8510638297872362,3.6651982378854626,1.8837209302325562,0.23404255319149314,0.9867841409691493,0.8604651162790731,0.0,0.43612334801762387,0.11627906976744384,0.0851063829787364,0.4669603524229018,0.4418604651162923,2.0638297872340488,0.9162995594713674,98.02325581395345,1.7446808510638356,90.35242290748897,0.27906976744185386,0.2676767676767677,0.4889867841409341,0.34883720930233153,0.2676767676767677,0.7533039647576913,0.06976744186047767,2.5177304964539076,0.7533039647576913,56.674418604651166,3.2676767676767677,113.00881057268776,175.83720930232556,0.0,121.71806167400837,1.0,3.0,1.0,127.04651162790694,30.97711154094126,53.28193832599118,178.58139534883722,35.57446808510639,47.88546255506605
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_replicas.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_replicas.csv
new file mode 100644
index 0000000..493813f
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_replicas.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,8.0,0.0,0.0,8.0,0.0,2.0,15.0,1.0,12.0,13.0,0.0,0.0,20.0,48.0,32.0,13.0,44.0,17.0,19.0,35.0,29.0,20.0,19.0,10.0,10.0,78.0,37.0,15.0,31.0,16.0,19.0,36.0,82.0,6.0,78.0,101.0,12.0,36.0,52.0,18.0,68.0,67.0,13.0,73.0,58.0,17.0,66.0,96.0,11.0,116.0,187.0,7.0,41.0,97.0,16.0,60.0,81.0,12.0,127.0
+0.0,8.0,0.0,0.0,8.0,0.0,0.0,16.0,0.0,0.0,14.0,8.0,0.0,19.0,52.0,33.0,12.0,47.0,12.0,20.0,36.0,28.0,15.0,40.0,20.0,9.0,72.0,41.0,14.0,31.0,50.0,18.0,6.0,99.0,9.0,57.0,84.0,14.0,28.0,52.0,18.0,68.0,53.0,14.0,83.0,55.0,17.0,36.0,99.0,10.0,117.0,169.0,7.0,59.0,93.0,18.0,91.0,91.0,9.0,129.0
+0.0,8.0,0.0,0.0,8.0,0.0,0.0,16.0,0.0,1.0,15.0,3.0,0.0,20.0,48.0,29.0,12.0,48.0,25.0,18.0,31.0,28.0,20.0,20.0,21.0,8.0,75.0,27.0,17.0,33.0,47.0,20.0,1.0,96.0,7.0,68.0,83.0,13.0,57.0,56.0,17.0,68.0,49.0,15.0,83.0,63.0,18.0,57.0,96.0,8.0,85.0,148.0,6.0,84.0,97.0,17.0,91.0,94.0,10.0,122.0
+0.0,8.0,0.0,0.0,8.0,0.0,0.0,16.0,0.0,3.0,15.0,1.0,0.0,20.0,48.0,43.0,10.0,45.0,24.0,18.0,32.0,23.0,18.0,33.0,45.0,7.0,55.0,22.0,18.0,34.0,33.0,21.0,11.0,96.0,7.0,68.0,79.0,14.0,57.0,57.0,17.0,67.0,51.0,16.0,77.0,61.0,18.0,57.0,132.0,9.0,88.0,126.0,6.0,80.0,93.0,16.0,73.0,89.0,9.0,103.0
+0.0,8.0,0.0,0.0,8.0,0.0,0.0,16.0,0.0,3.0,15.0,1.0,0.0,20.0,48.0,44.0,10.0,42.0,25.0,18.0,31.0,27.0,16.0,37.0,37.0,8.0,59.0,27.0,18.0,29.0,23.0,21.0,21.0,77.0,7.0,87.0,75.0,15.0,57.0,53.0,17.0,71.0,55.0,15.0,77.0,52.0,18.0,68.0,106.0,12.0,102.0,158.0,6.0,74.0,95.0,16.0,71.0,111.0,9.0,90.0
+0.0,8.0,0.0,0.0,8.0,0.0,3.0,15.0,0.0,2.0,7.0,34.0,0.0,22.0,40.0,49.0,8.0,46.0,29.0,16.0,35.0,28.0,14.0,44.0,52.0,8.0,44.0,28.0,18.0,28.0,1.0,21.0,43.0,107.0,7.0,57.0,59.0,15.0,73.0,55.0,17.0,69.0,47.0,17.0,77.0,60.0,18.0,60.0,146.0,11.0,66.0,132.0,7.0,96.0,91.0,19.0,63.0,91.0,12.0,90.0
+0.0,8.0,0.0,0.0,8.0,0.0,3.0,15.0,1.0,3.0,7.0,33.0,0.0,20.0,48.0,50.0,10.0,38.0,35.0,15.0,33.0,31.0,10.0,57.0,50.0,8.0,46.0,8.0,20.0,40.0,1.0,20.0,47.0,118.0,7.0,46.0,55.0,15.0,73.0,48.0,18.0,72.0,44.0,19.0,72.0,50.0,19.0,66.0,118.0,13.0,86.0,143.0,6.0,89.0,112.0,17.0,69.0,109.0,12.0,90.0
+0.0,8.0,0.0,0.0,8.0,0.0,3.0,15.0,1.0,1.0,6.0,39.0,0.0,20.0,48.0,52.0,7.0,45.0,41.0,15.0,27.0,31.0,10.0,57.0,51.0,10.0,37.0,13.0,19.0,39.0,29.0,18.0,27.0,89.0,9.0,67.0,51.0,16.0,77.0,53.0,17.0,71.0,52.0,18.0,68.0,50.0,18.0,66.0,109.0,13.0,95.0,153.0,7.0,75.0,98.0,17.0,73.0,104.0,17.0,61.0
+0.0,8.0,0.0,0.0,8.0,0.0,1.0,15.0,2.0,1.0,7.0,34.0,0.0,20.0,48.0,44.0,8.0,49.0,42.0,12.0,38.0,31.0,8.0,65.0,51.0,11.0,33.0,13.0,21.0,31.0,1.0,17.0,59.0,108.0,8.0,52.0,50.0,18.0,70.0,57.0,18.0,63.0,55.0,17.0,69.0,37.0,19.0,66.0,128.0,15.0,55.0,150.0,7.0,78.0,103.0,17.0,78.0,108.0,12.0,92.0
+0.0,8.0,0.0,1.0,7.0,1.0,8.0,14.0,0.0,2.0,7.0,34.0,0.0,20.0,48.0,55.0,8.0,40.0,47.0,12.0,32.0,34.0,8.0,62.0,58.0,10.0,30.0,9.0,20.0,39.0,60.0,15.0,8.0,90.0,9.0,65.0,48.0,17.0,76.0,60.0,16.0,68.0,55.0,17.0,68.0,42.0,19.0,74.0,109.0,17.0,73.0,67.0,7.0,72.0,98.0,18.0,73.0,113.0,15.0,64.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_residual_capacity.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_residual_capacity.csv
new file mode 100644
index 0000000..2c299f8
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_residual_capacity.csv
@@ -0,0 +1,11 @@
+n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19
+0.0,0.0,128.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1024.0,896.0,0.0,0.0,0.0,0.0,0.0,4480.0,0.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3072.0,0.0,0.0,4224.0,0.0,0.0,0.0,0.0
+0.0,0.0,0.0,0.0,0.0,384.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5504.0,0.0,0.0,0.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,256.0,0.0,3328.0,3328.0,3584.0
+0.0,0.0,0.0,0.0,0.0,256.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3328.0,2432.0
+0.0,0.0,128.0,0.0,0.0,128.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3328.0,3456.0
+0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,0.0,0.0,0.0,896.0,1152.0
+0.0,0.0,0.0,0.0,0.0,384.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,512.0,0.0,0.0,2176.0,2944.0
+0.0,0.0,128.0,128.0,0.0,384.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1664.0,1664.0,0.0,896.0,1024.0
+0.0,256.0,0.0,0.0,0.0,128.0,128.0,0.0,0.0,0.0,0.0,128.0,0.0,0.0,128.0,0.0,768.0,11392.0,1664.0,2432.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_solution.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_solution.csv
new file mode 100644
index 0000000..a3bd2bc
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_solution.csv
@@ -0,0 +1,11 @@
+n0_f0_loc,n0_f1_loc,n0_f2_loc,n1_f0_loc,n1_f1_loc,n1_f2_loc,n2_f0_loc,n2_f1_loc,n2_f2_loc,n3_f0_loc,n3_f1_loc,n3_f2_loc,n4_f0_loc,n4_f1_loc,n4_f2_loc,n5_f0_loc,n5_f1_loc,n5_f2_loc,n6_f0_loc,n6_f1_loc,n6_f2_loc,n7_f0_loc,n7_f1_loc,n7_f2_loc,n8_f0_loc,n8_f1_loc,n8_f2_loc,n9_f0_loc,n9_f1_loc,n9_f2_loc,n10_f0_loc,n10_f1_loc,n10_f2_loc,n11_f0_loc,n11_f1_loc,n11_f2_loc,n12_f0_loc,n12_f1_loc,n12_f2_loc,n13_f0_loc,n13_f1_loc,n13_f2_loc,n14_f0_loc,n14_f1_loc,n14_f2_loc,n15_f0_loc,n15_f1_loc,n15_f2_loc,n16_f0_loc,n16_f1_loc,n16_f2_loc,n17_f0_loc,n17_f1_loc,n17_f2_loc,n18_f0_loc,n18_f1_loc,n18_f2_loc,n19_f0_loc,n19_f1_loc,n19_f2_loc,n0_f0_fwd,n0_f1_fwd,n0_f2_fwd,n1_f0_fwd,n1_f1_fwd,n1_f2_fwd,n2_f0_fwd,n2_f1_fwd,n2_f2_fwd,n3_f0_fwd,n3_f1_fwd,n3_f2_fwd,n4_f0_fwd,n4_f1_fwd,n4_f2_fwd,n5_f0_fwd,n5_f1_fwd,n5_f2_fwd,n6_f0_fwd,n6_f1_fwd,n6_f2_fwd,n7_f0_fwd,n7_f1_fwd,n7_f2_fwd,n8_f0_fwd,n8_f1_fwd,n8_f2_fwd,n9_f0_fwd,n9_f1_fwd,n9_f2_fwd,n10_f0_fwd,n10_f1_fwd,n10_f2_fwd,n11_f0_fwd,n11_f1_fwd,n11_f2_fwd,n12_f0_fwd,n12_f1_fwd,n12_f2_fwd,n13_f0_fwd,n13_f1_fwd,n13_f2_fwd,n14_f0_fwd,n14_f1_fwd,n14_f2_fwd,n15_f0_fwd,n15_f1_fwd,n15_f2_fwd,n16_f0_fwd,n16_f1_fwd,n16_f2_fwd,n17_f0_fwd,n17_f1_fwd,n17_f2_fwd,n18_f0_fwd,n18_f1_fwd,n18_f2_fwd,n19_f0_fwd,n19_f1_fwd,n19_f2_fwd,n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,41.0,0.0,26.0,35.0,0.0,0.0,68.0,101.0,81.0,41.0,76.0,47.0,63.0,74.0,78.0,67.0,39.0,25.0,31.0,164.0,103.0,49.0,65.0,42.0,63.0,76.0,84.0,23.0,135.0,103.0,47.0,65.0,167.0,70.0,166.0,218.0,49.0,179.0,98.0,66.0,74.0,145.0,25.0,137.0,217.0,25.0,101.0,168.0,62.0,82.0,105.0,45.0,194.0,115.0,14.0,111.0,176.0,11.0,67.0,246.0,15.0,104.0,41.0,1.0,100.0,248.0,0.9999999999999998,10.0,0.0,0.0,0.0,184.0,0.0,0.0,4.0,0.0,66.91629955947135,124.0,0.0,0.4493392070484603,111.0,0.0,0.0,122.65116279069767,0.0,64.37444933920705,0.0,0.0,0.0,0.0,0.0,0.0,12.0,0.0,1.0,5.058114534883771,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,1.0,1.0,0.0,0.0,2.220446049250313e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.083700440528645,0.0,0.0,4.55066079295154,0.0,0.0,0.0,0.34883720930233153,0.0,52.62555066079295,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,1.0,1.9418854651162292,0.0,30.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,45.0,0.0,0.0,39.0,14.0,0.0,64.0,109.0,83.0,38.0,72.0,33.0,65.0,75.0,77.0,50.0,83.0,54.0,30.0,150.0,114.0,46.0,64.0,139.0,61.0,12.0,85.0,27.0,116.0,117.0,52.0,67.0,169.0,71.0,167.0,172.0,54.0,204.0,93.0,66.0,67.0,145.0,23.0,121.0,203.0,24.0,145.0,165.0,64.0,89.0,120.0,35.0,183.0,107.0,15.0,117.0,159.0,15.0,77.0,228.0,14.0,114.0,91.0,0.0,67.0,235.0,1.9999999999999996,5.0,0.0,0.0,0.0,194.0,0.0,0.0,4.0,1.0,26.392070484581495,104.0,0.0,0.0,93.0,0.0,0.0,2.0,1.0,115.99999999999997,0.0,0.0,0.0,0.0,0.0,0.0,29.0,0.0,0.0,82.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.440892098500626e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,14.0,6.607929515418505,1.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,76.00000000000003,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,45.0,0.0,0.0,40.0,3.0,0.0,67.0,101.0,77.0,38.0,61.0,69.0,61.0,65.0,78.0,67.0,41.0,56.0,27.0,157.0,75.0,55.0,69.0,131.0,68.0,2.0,57.0,25.0,112.0,128.0,50.0,93.0,182.0,66.0,166.0,158.0,59.0,203.0,86.0,66.0,68.0,150.0,21.0,105.0,223.0,22.0,144.0,173.0,60.0,90.0,133.0,36.0,169.0,123.0,16.0,113.0,128.0,13.0,84.0,216.0,13.0,113.0,86.0,0.0,73.0,242.0,0.0,31.0,0.0,0.0,0.0,165.0,0.0,0.0,0.0,0.0,72.0,112.0,0.0,1.0,115.93023255813952,0.0,0.0,0.0,0.0,167.0,0.0,0.0,0.0,0.0,0.0,0.0,5.48837209302323,0.0,0.0,70.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,2.0,0.0,1.0,27.069767441860478,0.0,0.0,26.0,0.0,23.0,0.0,0.0,0.0,0.0,0.0,0.0,4.51162790697677,0.0,13.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,45.0,0.0,0.0,41.0,0.0,0.0,67.0,101.0,79.0,33.0,67.0,66.0,61.0,66.0,64.0,59.0,69.0,125.0,21.0,116.0,61.0,58.0,70.0,91.0,71.0,23.0,88.0,26.0,93.0,125.0,54.0,111.0,185.0,66.0,165.0,166.0,62.0,189.0,82.0,69.0,71.0,141.0,24.0,108.0,239.0,22.0,169.0,170.0,53.0,97.0,145.0,31.0,163.0,116.0,15.0,115.0,119.0,12.0,83.0,176.0,15.0,119.0,99.0,4.0,74.0,229.0,0.0,28.0,0.0,0.0,0.0,182.0,0.0,0.0,1.0,0.0,52.030837004405285,55.0,0.0,0.0,145.04651162790697,0.0,0.0,78.0,0.0,44.0,0.0,0.0,0.0,0.0,0.0,0.0,0.8139534883720643,0.0,1.0,60.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16.969162995594715,0.0,0.0,0.0,8.953488372093034,0.0,0.0,0.0,0.0,124.0,0.0,0.0,0.0,0.0,0.0,0.0,3.1860465116279357,3.0,10.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,45.0,0.0,0.0,41.0,0.0,0.0,68.0,101.0,88.0,33.0,68.0,69.0,58.0,65.0,75.0,54.0,78.0,102.0,24.0,124.0,75.0,60.0,60.0,64.0,71.0,44.0,94.0,23.0,98.0,133.0,57.0,125.0,172.0,67.0,175.0,177.0,59.0,189.0,63.0,68.0,57.0,174.0,29.0,92.0,211.0,21.0,181.0,177.0,54.0,89.0,153.0,28.0,154.0,125.0,17.0,136.0,102.0,13.0,84.0,150.0,10.0,125.0,105.0,10.0,78.0,234.0,0.0,43.0,0.0,0.0,0.0,153.0,0.0,0.0,2.0,2.0,39.0,68.0,0.0,1.0,141.0,0.0,0.0,93.0,1.0,74.0,0.0,0.0,0.0,0.0,0.0,0.0,11.11627906976749,0.0,1.0,50.16279069767434,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,55.0,0.0,0.0,0.0,0.0,0.0,0.0,27.88372093023251,0.0,0.0,3.837209302325661,0.0,15.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,41.0,0.0,0.0,19.0,56.0,0.0,74.0,84.0,102.0,26.0,65.0,80.0,53.0,74.0,77.0,47.0,92.0,145.0,27.0,92.0,78.0,61.0,59.0,1.0,71.0,90.0,122.0,27.0,84.0,136.0,59.0,154.0,177.0,67.0,169.0,152.0,65.0,188.0,76.0,70.0,65.0,166.0,36.0,84.0,218.0,25.0,181.0,179.0,49.0,96.0,169.0,23.0,153.0,124.0,18.0,123.0,87.0,11.0,107.0,102.0,5.0,119.0,112.0,33.0,3.0,225.0,0.0,55.0,0.0,0.0,0.0,119.0,0.0,0.0,5.0,0.0,8.469603524229086,35.90697674418604,0.0,0.0,143.0,0.0,0.0,174.65116279069767,0.0,48.0,0.0,0.0,0.0,0.0,0.0,0.0,31.09302325581399,0.0,0.0,59.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,29.530396475770914,0.09302325581396076,0.0,0.0,0.0,0.0,0.0,0.34883720930233153,0.0,51.0,0.0,0.0,0.0,0.0,0.0,0.0,0.9069767441860108,2.0,16.0,1.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,41.0,0.0,0.0,19.0,56.0,0.0,68.0,101.0,105.0,24.0,69.0,97.0,49.0,68.0,86.0,34.0,120.0,139.0,27.0,97.0,22.0,66.0,83.0,0.0,67.0,97.0,146.0,27.0,73.0,147.0,57.0,177.0,156.0,70.0,177.0,143.0,73.0,177.0,76.0,73.0,57.0,165.0,41.0,74.0,213.0,22.0,190.0,192.0,46.0,93.0,168.0,28.0,140.0,131.0,19.0,125.0,80.0,15.0,91.0,76.0,4.0,139.0,111.0,36.0,4.0,210.0,0.9999999999999999,49.0,0.0,0.0,0.0,82.0,0.0,0.0,2.0,0.0,11.0,40.0,0.0,1.0,189.0,0.0,0.0,183.0,0.0,72.0,0.0,0.0,0.0,0.0,0.0,0.0,64.0,0.0,1.0,68.9767441860465,0.0,0.9999999999999971,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,3.0,0.0,0.0,1.1102230246251565e-16,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,4.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,8.023255813953497,0.0,2.886579864025407e-15,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,4.0,41.0,0.0,1.0,16.0,68.0,0.0,67.0,101.0,111.0,22.0,68.0,114.0,49.0,55.0,86.0,34.0,120.0,142.0,33.0,78.0,36.0,64.0,81.0,80.0,60.0,56.0,164.0,33.0,72.0,141.0,62.0,184.0,172.0,67.0,174.0,169.0,70.0,167.0,83.0,71.0,68.0,176.0,51.0,69.0,226.0,25.0,184.0,188.0,43.0,110.0,186.0,26.0,130.0,142.0,18.0,130.0,72.0,17.0,103.0,71.0,0.0,135.0,106.0,44.0,0.0,206.0,0.0,46.0,0.0,0.0,0.0,36.0,0.0,0.0,0.0,0.0,22.0,41.0,0.0,0.0,172.93023255813955,0.0,0.0,94.0,0.0,46.0,0.0,0.0,0.0,0.0,0.0,0.0,34.744186046511615,1.0,1.0,28.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,5.0,1.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0697674418604493,0.0,0.0,2.0,0.0,63.0,0.0,0.0,0.0,0.0,0.0,0.0,6.255813953488385,0.0,15.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,11.0,0.0,0.0,42.0,0.0,0.0,19.0,56.0,0.0,68.0,101.0,115.0,24.0,72.0,117.0,39.0,80.0,85.0,27.0,137.0,142.0,37.0,68.0,36.0,70.0,65.0,0.0,56.0,123.0,183.0,30.0,67.0,162.0,68.0,172.0,185.0,70.0,154.0,179.0,67.0,169.0,73.0,73.0,66.0,175.0,59.0,74.0,210.0,25.0,190.0,193.0,38.0,100.0,186.0,18.0,125.0,135.0,21.0,149.0,67.0,18.0,114.0,73.0,0.0,135.0,134.0,41.0,5.0,201.0,1.0,45.0,0.0,0.0,0.0,21.0,0.0,1.0,0.0,0.0,3.0,51.0,0.0,0.0,170.0,0.0,0.0,180.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,0.0,21.441860465116292,0.0,3.0,4.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,44.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5581395348837077,0.0,26.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+0.0,11.0,0.0,0.0,9.0,0.0,17.0,38.0,0.0,0.0,19.0,56.0,0.0,68.0,101.0,127.0,25.0,79.0,121.0,40.0,64.0,93.0,27.0,130.0,161.0,34.0,63.0,25.0,68.0,82.0,167.0,49.0,16.0,195.0,34.0,70.0,156.0,67.0,187.0,195.0,63.0,167.0,179.0,65.0,167.0,80.0,72.0,69.0,179.0,67.0,58.0,217.0,24.0,176.0,192.0,39.0,126.0,189.0,24.0,110.0,145.0,22.0,150.0,63.0,17.0,99.0,58.0,0.0,135.0,137.0,46.0,3.0,186.0,1.0,53.0,0.0,0.0,0.0,0.0,0.0,0.0,4.8139534883720785,0.0,2.436123348017624,1.2093023255813904,0.0,0.0,86.88372093023253,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,3.9118942731277,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0,0.0,1.0,1.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.18604651162792152,0.0,11.563876651982376,16.79069767441861,0.0,0.0,97.11627906976747,0.0,0.0,1.0,0.0,145.0,0.0,0.0,0.0,0.0,0.0,1.0881057268722998,5.0,2.0,20.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
diff --git a/test_instances/2026-06-30_15-15-13.347285/LSPc_utilization.csv b/test_instances/2026-06-30_15-15-13.347285/LSPc_utilization.csv
new file mode 100644
index 0000000..a6f6c26
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/LSPc_utilization.csv
@@ -0,0 +1,11 @@
+n0_f0,n0_f1,n0_f2,n1_f0,n1_f1,n1_f2,n2_f0,n2_f1,n2_f2,n3_f0,n3_f1,n3_f2,n4_f0,n4_f1,n4_f2,n5_f0,n5_f1,n5_f2,n6_f0,n6_f1,n6_f2,n7_f0,n7_f1,n7_f2,n8_f0,n8_f1,n8_f2,n9_f0,n9_f1,n9_f2,n10_f0,n10_f1,n10_f2,n11_f0,n11_f1,n11_f2,n12_f0,n12_f1,n12_f2,n13_f0,n13_f1,n13_f2,n14_f0,n14_f1,n14_f2,n15_f0,n15_f1,n15_f2,n16_f0,n16_f1,n16_f2,n17_f0,n17_f1,n17_f2,n18_f0,n18_f1,n18_f2,n19_f0,n19_f1,n19_f2
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.7707999999999999,0.0,0.7453333333333333,0.7592307692307692,0.0,0.0,0.7989999999999999,0.7960763888888889,0.7256250000000001,0.7411538461538462,0.6534848484848484,0.7925490196078432,0.7792105263157895,0.799904761904762,0.7710344827586206,0.78725,0.7765789473684211,0.7166666666666667,0.7284999999999999,0.7954700854700855,0.7980180180180181,0.7676666666666666,0.7932795698924732,0.7525000000000001,0.7792105263157895,0.7987037037037037,0.25170731707317073,0.7721428571428571,0.5612637362637364,0.2505799151343706,0.7889285714285714,0.5855158730158732,0.7891208791208791,0.7833333333333333,0.791638655462185,0.7994882729211087,0.7592307692307692,0.7951663405088064,0.4151724137931035,0.782016806722689,0.3635930735930737,0.37113095238095234,0.4577922077922078,0.3829926108374385,0.2851336898395722,0.7193877551020408,0.7988501742160279,0.42556701030927835,0.7805357142857143,0.44319047619047625,0.31851851851851853,0.755357142857143,0.49536557930258723
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.793125,0.0,0.0,0.7855714285714285,0.7945,0.0,0.791578947368421,0.7930448717948718,0.721010101010101,0.7441666666666666,0.5795744680851064,0.7883333333333334,0.7637499999999999,0.7881944444444444,0.7883333333333333,0.7833333333333333,0.7850416666666666,0.774,0.7833333333333333,0.7881944444444444,0.7970731707317074,0.772142857142857,0.7810752688172043,0.7969333333333334,0.7963888888888888,0.7566666666666667,0.21096681096681097,0.6042857142857143,0.659949874686717,0.34224489795918367,0.7481632653061225,0.7759693877551023,0.7985714285714286,0.7945238095238095,0.7964075630252102,0.7974123989218329,0.7769387755102041,0.797039586919105,0.41548051948051945,0.782016806722689,0.6035317460317462,0.35988455988455986,0.46328571428571425,0.3353724053724054,0.2951479289940829,0.6906122448979592,0.7969733656174336,0.4359447004608295,0.7161904761904762,0.31715855572998436,0.32401883830455264,0.7833333333333333,0.4600332225913622
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.793125,0.0,0.0,0.752,0.454,0.0,0.78725,0.7960763888888889,0.7611494252873563,0.7441666666666666,0.4807986111111111,0.7912,0.7963888888888888,0.7932795698924732,0.7985714285714286,0.78725,0.7755833333333333,0.7644444444444445,0.793125,0.7919777777777778,0.7962962962962963,0.7602941176470588,0.791060606060606,0.7990070921985816,0.7989999999999999,0.7566666666666667,0.14589285714285713,0.7193877551020408,0.5341176470588236,0.37893287435456113,0.7747252747252747,0.5290977443609024,0.7985714285714286,0.782016806722689,0.791638655462185,0.7923032069970846,0.7922857142857143,0.7931325301204821,0.3354195011337869,0.7385714285714285,0.3868671679197996,0.38392857142857145,0.52875,0.4005882352941177,0.3702316602316602,0.7385714285714285,0.5559183673469389,0.43823269513991164,0.7109243697478992,0.32072213500784935,0.3476595744680851,0.7251428571428572,0.44921545667447316
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.793125,0.0,0.0,0.7707999999999999,0.0,0.0,0.78725,0.7960763888888889,0.5266666666666667,0.7755,0.5632962962962964,0.7883333333333334,0.7963888888888888,0.7803125000000001,0.7976811594202899,0.7702777777777777,0.791060606060606,0.7962962962962964,0.705,0.7979393939393941,0.7948484848484849,0.7572222222222221,0.778921568627451,0.7905050505050506,0.7945238095238094,0.7910606060606061,0.22523809523809524,0.7481632653061225,0.4435084033613446,0.3887884267631103,0.7769387755102041,0.6315037593984963,0.7974937343358396,0.782016806722689,0.7986140724946696,0.7997759103641456,0.7805357142857143,0.7959740259740261,0.330304449648712,0.7721428571428572,0.40393483709273187,0.26246753246753246,0.5371428571428571,0.39798701298701306,0.46607709750566895,0.7385714285714285,0.6850535714285716,0.44915514592933947,0.6672321428571428,0.4309001956947163,0.4003210272873194,0.6938095238095239,0.5131900138696256
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.793125,0.0,0.0,0.7707999999999999,0.0,0.0,0.7989999999999999,0.7960763888888889,0.5733333333333334,0.7755,0.6125396825396825,0.7912,0.7572222222222221,0.7932795698924732,0.7962962962962963,0.793125,0.7975675675675676,0.7902702702702703,0.705,0.7951412429378532,0.7962962962962963,0.7833333333333333,0.7827586206896553,0.7976811594202899,0.7945238095238094,0.7926984126984128,0.2999628942486085,0.6618367346938775,0.3652873563218391,0.4357333333333333,0.7654285714285715,0.7111528822055139,0.7974123989218329,0.7938655462184874,0.7992957746478874,0.7907532467532468,0.7922857142857143,0.7959740259740261,0.2976923076923077,0.7609523809523809,0.271827731092437,0.4033423180592992,0.4867857142857143,0.2924929971988796,0.3281374321880651,0.7050000000000001,0.7931853281853283,0.4578045112781955,0.6798214285714286,0.40649899396378275,0.33868725868725874,0.6266666666666666,0.554888888888889
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.7707999999999999,0.0,0.0,0.7654285714285713,0.7477647058823529,0.0,0.7904545454545455,0.7945,0.5967346938775511,0.7637499999999999,0.5346014492753624,0.7908045977011494,0.7784375,0.799904761904762,0.7883333333333333,0.7889285714285714,0.7910606060606061,0.7993589743589744,0.793125,0.7910606060606061,0.7985714285714286,0.7963888888888888,0.797202380952381,0.2866666666666667,0.7945238095238094,0.7918604651162792,0.28016021361815757,0.7769387755102041,0.47789473684210537,0.5663922518159806,0.7922857142857143,0.6841095890410961,0.7907532467532468,0.7938655462184874,0.7942650103519671,0.7946504559270517,0.7701680672268908,0.7917625231910947,0.31123809523809526,0.7833333333333333,0.3513095238095239,0.2793737769080235,0.6592207792207793,0.41272727272727283,0.40580086580086583,0.7193877551020408,0.6114136904761905,0.4833281004709576,0.5194736842105263,0.4941496598639457,0.45632653061224493,0.38607142857142857,0.5512857142857144
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.7707999999999999,0.0,0.0,0.7654285714285713,0.7704242424242425,0.0,0.7989999999999999,0.7960763888888889,0.602,0.564,0.6869736842105263,0.7944761904761906,0.7676666666666666,0.7795959595959596,0.7952688172043012,0.7989999999999999,0.7964912280701756,0.7969333333333334,0.793125,0.7977898550724639,0.7883333333333333,0.7755,0.7850416666666666,0.0,0.78725,0.7808156028368796,0.3040193704600484,0.7769387755102041,0.5146273291925467,0.6567272727272727,0.7654285714285715,0.7862818003913895,0.7985714285714286,0.7833333333333333,0.797202380952381,0.7985714285714285,0.7739097744360902,0.797202380952381,0.3734857142857143,0.7739097744360902,0.2800649350649351,0.34358353510895884,0.6352747252747253,0.2790365448504984,0.365994005994006,0.7385714285714285,0.692295345104334,0.42122448979591837,0.5450420168067227,0.437080745341615,0.37871559633027524,0.47,0.5044444444444445
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.4586666666666666,0.7707999999999999,0.0,0.344,0.7519999999999999,0.7915897435897435,0.0,0.78725,0.7960763888888889,0.6119230769230769,0.7385714285714285,0.5717037037037037,0.7970731707317074,0.7676666666666666,0.770679012345679,0.7952688172043012,0.7989999999999999,0.7964912280701756,0.798169934640523,0.7755,0.7975675675675676,0.7938461538461539,0.791578947368421,0.7857692307692309,0.7908045977011494,0.7833333333333333,0.7846913580246914,0.452776886035313,0.7385714285714285,0.34848614072494677,0.6793277310924369,0.7805357142857143,0.7749165120593694,0.7974123989218329,0.7938655462184874,0.794728370221328,0.7985714285714286,0.7833333333333333,0.7964075630252102,0.4078857142857143,0.7945238095238095,0.3341125541125542,0.3967496723460026,0.7902197802197802,0.23553383458646618,0.3629505135387488,0.7193877551020408,0.7955809523809525,0.47137026239067054,0.5094957983193277,0.4886497064579257,0.43945054945054945,0.30806722689075633,0.6911007025761126
+0.0,0.7755,0.0,0.0,0.7755,0.0,0.0,0.7896,0.0,0.0,0.7654285714285713,0.7477647058823529,0.0,0.7989999999999999,0.7960763888888889,0.7492424242424243,0.705,0.5559183673469388,0.7985714285714286,0.7637499999999999,0.7964912280701755,0.7860215053763441,0.793125,0.7974102564102564,0.798169934640523,0.7904545454545455,0.7795959595959596,0.7938461538461539,0.7833333333333333,0.7932795698924732,0.0,0.7741176470588236,0.7887288135593221,0.41634920634920636,0.7553571428571428,0.41782967032967044,0.7961142857142858,0.7609523809523809,0.7968163265306124,0.7974937343358396,0.7833333333333333,0.7926984126984129,0.7996883116883117,0.7938655462184874,0.7942650103519671,0.48478764478764474,0.7739097744360902,0.32428571428571434,0.3359375,0.7922857142857143,0.4363116883116884,0.34400000000000003,0.7193877551020408,0.7899267399267401,0.46041608876560336,0.4502521008403361,0.4157509157509159,0.42317460317460315,0.30214285714285716,0.44060559006211186
+0.0,0.7755,0.0,0.0,0.7251428571428571,0.0,0.731,0.7654285714285713,0.0,0.0,0.7654285714285713,0.7477647058823529,0.0,0.7989999999999999,0.7960763888888889,0.6619393939393939,0.734375,0.7472083333333334,0.7380141843971632,0.7833333333333332,0.7566666666666667,0.7841176470588236,0.793125,0.7932795698924732,0.7957471264367817,0.7989999999999999,0.7945,0.7962962962962963,0.7989999999999999,0.7954700854700855,0.7978888888888889,0.7676666666666666,0.7566666666666667,0.5323809523809524,0.7609523809523809,0.3492307692307693,0.7985714285714286,0.7938655462184874,0.7979135338345866,0.7985714285714286,0.793125,0.7964075630252102,0.7996883116883117,0.7701680672268908,0.7964075630252102,0.4680272108843538,0.7633082706766917,0.3023745173745174,0.4035124508519004,0.7938655462184874,0.2576516634050881,0.7958208955223881,0.6906122448979592,0.7926984126984128,0.48139941690962096,0.43642857142857144,0.5597260273972604,0.4109734513274336,0.3222857142857143,0.5573660714285715
diff --git a/test_instances/2026-06-30_15-15-13.347285/base_instance_data.json b/test_instances/2026-06-30_15-15-13.347285/base_instance_data.json
new file mode 100644
index 0000000..405322d
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/base_instance_data.json
@@ -0,0 +1,1894 @@
+{
+  "None": {
+    "Nn": {
+      "None": 20
+    },
+    "Nf": {
+      "None": 3
+    },
+    "demand": {
+      "(1, 1)": 0.688,
+      "(1, 2)": 0.564,
+      "(1, 3)": 0.908,
+      "(2, 1)": 0.688,
+      "(2, 2)": 0.564,
+      "(2, 3)": 0.908,
+      "(3, 1)": 0.344,
+      "(3, 2)": 0.282,
+      "(3, 3)": 0.454,
+      "(4, 1)": 0.344,
+      "(4, 2)": 0.282,
+      "(4, 3)": 0.454,
+      "(5, 1)": 0.2866666666666667,
+      "(5, 2)": 0.235,
+      "(5, 3)": 0.37833333333333335,
+      "(6, 1)": 0.2866666666666667,
+      "(6, 2)": 0.235,
+      "(6, 3)": 0.37833333333333335,
+      "(7, 1)": 0.2866666666666667,
+      "(7, 2)": 0.235,
+      "(7, 3)": 0.37833333333333335,
+      "(8, 1)": 0.2866666666666667,
+      "(8, 2)": 0.235,
+      "(8, 3)": 0.37833333333333335,
+      "(9, 1)": 0.2866666666666667,
+      "(9, 2)": 0.235,
+      "(9, 3)": 0.37833333333333335,
+      "(10, 1)": 0.2866666666666667,
+      "(10, 2)": 0.235,
+      "(10, 3)": 0.37833333333333335,
+      "(11, 1)": 0.2866666666666667,
+      "(11, 2)": 0.235,
+      "(11, 3)": 0.37833333333333335,
+      "(12, 1)": 0.24571428571428572,
+      "(12, 2)": 0.20142857142857143,
+      "(12, 3)": 0.32428571428571434,
+      "(13, 1)": 0.24571428571428572,
+      "(13, 2)": 0.20142857142857143,
+      "(13, 3)": 0.32428571428571434,
+      "(14, 1)": 0.24571428571428572,
+      "(14, 2)": 0.20142857142857143,
+      "(14, 3)": 0.32428571428571434,
+      "(15, 1)": 0.24571428571428572,
+      "(15, 2)": 0.20142857142857143,
+      "(15, 3)": 0.32428571428571434,
+      "(16, 1)": 0.24571428571428572,
+      "(16, 2)": 0.20142857142857143,
+      "(16, 3)": 0.32428571428571434,
+      "(17, 1)": 0.24571428571428572,
+      "(17, 2)": 0.20142857142857143,
+      "(17, 3)": 0.32428571428571434,
+      "(18, 1)": 0.24571428571428572,
+      "(18, 2)": 0.20142857142857143,
+      "(18, 3)": 0.32428571428571434,
+      "(19, 1)": 0.24571428571428572,
+      "(19, 2)": 0.20142857142857143,
+      "(19, 3)": 0.32428571428571434,
+      "(20, 1)": 0.24571428571428572,
+      "(20, 2)": 0.20142857142857143,
+      "(20, 3)": 0.32428571428571434
+    },
+    "memory_requirement": {
+      "1": 128,
+      "2": 512,
+      "3": 128
+    },
+    "memory_capacity": {
+      "1": 4096,
+      "2": 4096,
+      "3": 8192,
+      "4": 8192,
+      "5": 16384,
+      "6": 16384,
+      "7": 16384,
+      "8": 16384,
+      "9": 16384,
+      "10": 16384,
+      "11": 16384,
+      "12": 24576,
+      "13": 24576,
+      "14": 24576,
+      "15": 24576,
+      "16": 24576,
+      "17": 32768,
+      "18": 32768,
+      "19": 32768,
+      "20": 32768
+    },
+    "neighborhood": {
+      "(1, 1)": 0,
+      "(1, 2)": 1,
+      "(1, 3)": 1,
+      "(1, 4)": 1,
+      "(1, 5)": 1,
+      "(1, 6)": 1,
+      "(1, 7)": 1,
+      "(1, 8)": 1,
+      "(1, 9)": 0,
+      "(1, 10)": 1,
+      "(1, 11)": 1,
+      "(1, 12)": 0,
+      "(1, 13)": 0,
+      "(1, 14)": 0,
+      "(1, 15)": 0,
+      "(1, 16)": 0,
+      "(1, 17)": 0,
+      "(1, 18)": 0,
+      "(1, 19)": 1,
+      "(1, 20)": 1,
+      "(2, 1)": 1,
+      "(2, 2)": 0,
+      "(2, 3)": 1,
+      "(2, 4)": 1,
+      "(2, 5)": 0,
+      "(2, 6)": 0,
+      "(2, 7)": 0,
+      "(2, 8)": 0,
+      "(2, 9)": 0,
+      "(2, 10)": 0,
+      "(2, 11)": 0,
+      "(2, 12)": 0,
+      "(2, 13)": 0,
+      "(2, 14)": 0,
+      "(2, 15)": 0,
+      "(2, 16)": 0,
+      "(2, 17)": 0,
+      "(2, 18)": 0,
+      "(2, 19)": 1,
+      "(2, 20)": 0,
+      "(3, 1)": 1,
+      "(3, 2)": 1,
+      "(3, 3)": 0,
+      "(3, 4)": 1,
+      "(3, 5)": 1,
+      "(3, 6)": 0,
+      "(3, 7)": 0,
+      "(3, 8)": 0,
+      "(3, 9)": 0,
+      "(3, 10)": 1,
+      "(3, 11)": 1,
+      "(3, 12)": 1,
+      "(3, 13)": 0,
+      "(3, 14)": 1,
+      "(3, 15)": 1,
+      "(3, 16)": 1,
+      "(3, 17)": 1,
+      "(3, 18)": 0,
+      "(3, 19)": 0,
+      "(3, 20)": 0,
+      "(4, 1)": 1,
+      "(4, 2)": 1,
+      "(4, 3)": 1,
+      "(4, 4)": 0,
+      "(4, 5)": 1,
+      "(4, 6)": 1,
+      "(4, 7)": 0,
+      "(4, 8)": 0,
+      "(4, 9)": 0,
+      "(4, 10)": 0,
+      "(4, 11)": 0,
+      "(4, 12)": 0,
+      "(4, 13)": 0,
+      "(4, 14)": 0,
+      "(4, 15)": 1,
+      "(4, 16)": 0,
+      "(4, 17)": 0,
+      "(4, 18)": 0,
+      "(4, 19)": 1,
+      "(4, 20)": 1,
+      "(5, 1)": 1,
+      "(5, 2)": 0,
+      "(5, 3)": 1,
+      "(5, 4)": 1,
+      "(5, 5)": 0,
+      "(5, 6)": 1,
+      "(5, 7)": 1,
+      "(5, 8)": 0,
+      "(5, 9)": 0,
+      "(5, 10)": 1,
+      "(5, 11)": 0,
+      "(5, 12)": 1,
+      "(5, 13)": 1,
+      "(5, 14)": 1,
+      "(5, 15)": 1,
+      "(5, 16)": 1,
+      "(5, 17)": 0,
+      "(5, 18)": 0,
+      "(5, 19)": 0,
+      "(5, 20)": 0,
+      "(6, 1)": 1,
+      "(6, 2)": 0,
+      "(6, 3)": 0,
+      "(6, 4)": 1,
+      "(6, 5)": 1,
+      "(6, 6)": 0,
+      "(6, 7)": 1,
+      "(6, 8)": 1,
+      "(6, 9)": 1,
+      "(6, 10)": 0,
+      "(6, 11)": 0,
+      "(6, 12)": 0,
+      "(6, 13)": 0,
+      "(6, 14)": 0,
+      "(6, 15)": 0,
+      "(6, 16)": 0,
+      "(6, 17)": 0,
+      "(6, 18)": 0,
+      "(6, 19)": 0,
+      "(6, 20)": 0,
+      "(7, 1)": 1,
+      "(7, 2)": 0,
+      "(7, 3)": 0,
+      "(7, 4)": 0,
+      "(7, 5)": 1,
+      "(7, 6)": 1,
+      "(7, 7)": 0,
+      "(7, 8)": 1,
+      "(7, 9)": 1,
+      "(7, 10)": 0,
+      "(7, 11)": 0,
+      "(7, 12)": 0,
+      "(7, 13)": 0,
+      "(7, 14)": 0,
+      "(7, 15)": 0,
+      "(7, 16)": 0,
+      "(7, 17)": 0,
+      "(7, 18)": 0,
+      "(7, 19)": 0,
+      "(7, 20)": 0,
+      "(8, 1)": 1,
+      "(8, 2)": 0,
+      "(8, 3)": 0,
+      "(8, 4)": 0,
+      "(8, 5)": 0,
+      "(8, 6)": 1,
+      "(8, 7)": 1,
+      "(8, 8)": 0,
+      "(8, 9)": 1,
+      "(8, 10)": 0,
+      "(8, 11)": 0,
+      "(8, 12)": 0,
+      "(8, 13)": 0,
+      "(8, 14)": 0,
+      "(8, 15)": 0,
+      "(8, 16)": 0,
+      "(8, 17)": 0,
+      "(8, 18)": 0,
+      "(8, 19)": 0,
+      "(8, 20)": 0,
+      "(9, 1)": 0,
+      "(9, 2)": 0,
+      "(9, 3)": 0,
+      "(9, 4)": 0,
+      "(9, 5)": 0,
+      "(9, 6)": 1,
+      "(9, 7)": 1,
+      "(9, 8)": 1,
+      "(9, 9)": 0,
+      "(9, 10)": 0,
+      "(9, 11)": 0,
+      "(9, 12)": 0,
+      "(9, 13)": 0,
+      "(9, 14)": 0,
+      "(9, 15)": 0,
+      "(9, 16)": 0,
+      "(9, 17)": 0,
+      "(9, 18)": 0,
+      "(9, 19)": 0,
+      "(9, 20)": 0,
+      "(10, 1)": 1,
+      "(10, 2)": 0,
+      "(10, 3)": 1,
+      "(10, 4)": 0,
+      "(10, 5)": 1,
+      "(10, 6)": 0,
+      "(10, 7)": 0,
+      "(10, 8)": 0,
+      "(10, 9)": 0,
+      "(10, 10)": 0,
+      "(10, 11)": 1,
+      "(10, 12)": 1,
+      "(10, 13)": 1,
+      "(10, 14)": 0,
+      "(10, 15)": 0,
+      "(10, 16)": 0,
+      "(10, 17)": 0,
+      "(10, 18)": 0,
+      "(10, 19)": 0,
+      "(10, 20)": 0,
+      "(11, 1)": 1,
+      "(11, 2)": 0,
+      "(11, 3)": 1,
+      "(11, 4)": 0,
+      "(11, 5)": 0,
+      "(11, 6)": 0,
+      "(11, 7)": 0,
+      "(11, 8)": 0,
+      "(11, 9)": 0,
+      "(11, 10)": 1,
+      "(11, 11)": 0,
+      "(11, 12)": 0,
+      "(11, 13)": 0,
+      "(11, 14)": 0,
+      "(11, 15)": 0,
+      "(11, 16)": 0,
+      "(11, 17)": 0,
+      "(11, 18)": 0,
+      "(11, 19)": 0,
+      "(11, 20)": 0,
+      "(12, 1)": 0,
+      "(12, 2)": 0,
+      "(12, 3)": 1,
+      "(12, 4)": 0,
+      "(12, 5)": 1,
+      "(12, 6)": 0,
+      "(12, 7)": 0,
+      "(12, 8)": 0,
+      "(12, 9)": 0,
+      "(12, 10)": 1,
+      "(12, 11)": 0,
+      "(12, 12)": 0,
+      "(12, 13)": 1,
+      "(12, 14)": 1,
+      "(12, 15)": 0,
+      "(12, 16)": 0,
+      "(12, 17)": 0,
+      "(12, 18)": 0,
+      "(12, 19)": 0,
+      "(12, 20)": 0,
+      "(13, 1)": 0,
+      "(13, 2)": 0,
+      "(13, 3)": 0,
+      "(13, 4)": 0,
+      "(13, 5)": 1,
+      "(13, 6)": 0,
+      "(13, 7)": 0,
+      "(13, 8)": 0,
+      "(13, 9)": 0,
+      "(13, 10)": 1,
+      "(13, 11)": 0,
+      "(13, 12)": 1,
+      "(13, 13)": 0,
+      "(13, 14)": 0,
+      "(13, 15)": 0,
+      "(13, 16)": 0,
+      "(13, 17)": 0,
+      "(13, 18)": 0,
+      "(13, 19)": 0,
+      "(13, 20)": 0,
+      "(14, 1)": 0,
+      "(14, 2)": 0,
+      "(14, 3)": 1,
+      "(14, 4)": 0,
+      "(14, 5)": 1,
+      "(14, 6)": 0,
+      "(14, 7)": 0,
+      "(14, 8)": 0,
+      "(14, 9)": 0,
+      "(14, 10)": 0,
+      "(14, 11)": 0,
+      "(14, 12)": 1,
+      "(14, 13)": 0,
+      "(14, 14)": 0,
+      "(14, 15)": 0,
+      "(14, 16)": 0,
+      "(14, 17)": 0,
+      "(14, 18)": 0,
+      "(14, 19)": 0,
+      "(14, 20)": 0,
+      "(15, 1)": 0,
+      "(15, 2)": 0,
+      "(15, 3)": 1,
+      "(15, 4)": 1,
+      "(15, 5)": 1,
+      "(15, 6)": 0,
+      "(15, 7)": 0,
+      "(15, 8)": 0,
+      "(15, 9)": 0,
+      "(15, 10)": 0,
+      "(15, 11)": 0,
+      "(15, 12)": 0,
+      "(15, 13)": 0,
+      "(15, 14)": 0,
+      "(15, 15)": 0,
+      "(15, 16)": 1,
+      "(15, 17)": 1,
+      "(15, 18)": 1,
+      "(15, 19)": 0,
+      "(15, 20)": 0,
+      "(16, 1)": 0,
+      "(16, 2)": 0,
+      "(16, 3)": 1,
+      "(16, 4)": 0,
+      "(16, 5)": 1,
+      "(16, 6)": 0,
+      "(16, 7)": 0,
+      "(16, 8)": 0,
+      "(16, 9)": 0,
+      "(16, 10)": 0,
+      "(16, 11)": 0,
+      "(16, 12)": 0,
+      "(16, 13)": 0,
+      "(16, 14)": 0,
+      "(16, 15)": 1,
+      "(16, 16)": 0,
+      "(16, 17)": 1,
+      "(16, 18)": 1,
+      "(16, 19)": 0,
+      "(16, 20)": 0,
+      "(17, 1)": 0,
+      "(17, 2)": 0,
+      "(17, 3)": 1,
+      "(17, 4)": 0,
+      "(17, 5)": 0,
+      "(17, 6)": 0,
+      "(17, 7)": 0,
+      "(17, 8)": 0,
+      "(17, 9)": 0,
+      "(17, 10)": 0,
+      "(17, 11)": 0,
+      "(17, 12)": 0,
+      "(17, 13)": 0,
+      "(17, 14)": 0,
+      "(17, 15)": 1,
+      "(17, 16)": 1,
+      "(17, 17)": 0,
+      "(17, 18)": 1,
+      "(17, 19)": 0,
+      "(17, 20)": 0,
+      "(18, 1)": 0,
+      "(18, 2)": 0,
+      "(18, 3)": 0,
+      "(18, 4)": 0,
+      "(18, 5)": 0,
+      "(18, 6)": 0,
+      "(18, 7)": 0,
+      "(18, 8)": 0,
+      "(18, 9)": 0,
+      "(18, 10)": 0,
+      "(18, 11)": 0,
+      "(18, 12)": 0,
+      "(18, 13)": 0,
+      "(18, 14)": 0,
+      "(18, 15)": 1,
+      "(18, 16)": 1,
+      "(18, 17)": 1,
+      "(18, 18)": 0,
+      "(18, 19)": 0,
+      "(18, 20)": 0,
+      "(19, 1)": 1,
+      "(19, 2)": 1,
+      "(19, 3)": 0,
+      "(19, 4)": 1,
+      "(19, 5)": 0,
+      "(19, 6)": 0,
+      "(19, 7)": 0,
+      "(19, 8)": 0,
+      "(19, 9)": 0,
+      "(19, 10)": 0,
+      "(19, 11)": 0,
+      "(19, 12)": 0,
+      "(19, 13)": 0,
+      "(19, 14)": 0,
+      "(19, 15)": 0,
+      "(19, 16)": 0,
+      "(19, 17)": 0,
+      "(19, 18)": 0,
+      "(19, 19)": 0,
+      "(19, 20)": 1,
+      "(20, 1)": 1,
+      "(20, 2)": 0,
+      "(20, 3)": 0,
+      "(20, 4)": 1,
+      "(20, 5)": 0,
+      "(20, 6)": 0,
+      "(20, 7)": 0,
+      "(20, 8)": 0,
+      "(20, 9)": 0,
+      "(20, 10)": 0,
+      "(20, 11)": 0,
+      "(20, 12)": 0,
+      "(20, 13)": 0,
+      "(20, 14)": 0,
+      "(20, 15)": 0,
+      "(20, 16)": 0,
+      "(20, 17)": 0,
+      "(20, 18)": 0,
+      "(20, 19)": 1,
+      "(20, 20)": 0
+    },
+    "max_utilization": {
+      "1": 0.8,
+      "2": 0.8,
+      "3": 0.8
+    },
+    "alpha": {
+      "(1, 1)": 0.618,
+      "(1, 2)": 0.876,
+      "(1, 3)": 0.687,
+      "(2, 1)": 0.618,
+      "(2, 2)": 0.876,
+      "(2, 3)": 0.687,
+      "(3, 1)": 0.618,
+      "(3, 2)": 0.876,
+      "(3, 3)": 0.687,
+      "(4, 1)": 0.618,
+      "(4, 2)": 0.876,
+      "(4, 3)": 0.687,
+      "(5, 1)": 0.618,
+      "(5, 2)": 0.876,
+      "(5, 3)": 0.687,
+      "(6, 1)": 0.618,
+      "(6, 2)": 0.876,
+      "(6, 3)": 0.687,
+      "(7, 1)": 0.618,
+      "(7, 2)": 0.876,
+      "(7, 3)": 0.687,
+      "(8, 1)": 0.618,
+      "(8, 2)": 0.876,
+      "(8, 3)": 0.687,
+      "(9, 1)": 0.618,
+      "(9, 2)": 0.876,
+      "(9, 3)": 0.687,
+      "(10, 1)": 0.618,
+      "(10, 2)": 0.876,
+      "(10, 3)": 0.687,
+      "(11, 1)": 0.618,
+      "(11, 2)": 0.876,
+      "(11, 3)": 0.687,
+      "(12, 1)": 0.618,
+      "(12, 2)": 0.876,
+      "(12, 3)": 0.687,
+      "(13, 1)": 0.618,
+      "(13, 2)": 0.876,
+      "(13, 3)": 0.687,
+      "(14, 1)": 0.618,
+      "(14, 2)": 0.876,
+      "(14, 3)": 0.687,
+      "(15, 1)": 0.618,
+      "(15, 2)": 0.876,
+      "(15, 3)": 0.687,
+      "(16, 1)": 0.618,
+      "(16, 2)": 0.876,
+      "(16, 3)": 0.687,
+      "(17, 1)": 0.618,
+      "(17, 2)": 0.876,
+      "(17, 3)": 0.687,
+      "(18, 1)": 0.618,
+      "(18, 2)": 0.876,
+      "(18, 3)": 0.687,
+      "(19, 1)": 0.618,
+      "(19, 2)": 0.876,
+      "(19, 3)": 0.687,
+      "(20, 1)": 0.618,
+      "(20, 2)": 0.876,
+      "(20, 3)": 0.687
+    },
+    "beta": {
+      "(1, 1, 1)": 0.5,
+      "(1, 1, 2)": 0.5,
+      "(1, 1, 3)": 0.5,
+      "(1, 2, 1)": 0.5,
+      "(1, 2, 2)": 0.5,
+      "(1, 2, 3)": 0.5,
+      "(1, 3, 1)": 0.5,
+      "(1, 3, 2)": 0.5,
+      "(1, 3, 3)": 0.5,
+      "(1, 4, 1)": 0.5,
+      "(1, 4, 2)": 0.5,
+      "(1, 4, 3)": 0.5,
+      "(1, 5, 1)": 0.5,
+      "(1, 5, 2)": 0.5,
+      "(1, 5, 3)": 0.5,
+      "(1, 6, 1)": 0.5,
+      "(1, 6, 2)": 0.5,
+      "(1, 6, 3)": 0.5,
+      "(1, 7, 1)": 0.5,
+      "(1, 7, 2)": 0.5,
+      "(1, 7, 3)": 0.5,
+      "(1, 8, 1)": 0.5,
+      "(1, 8, 2)": 0.5,
+      "(1, 8, 3)": 0.5,
+      "(1, 9, 1)": 0.5,
+      "(1, 9, 2)": 0.5,
+      "(1, 9, 3)": 0.5,
+      "(1, 10, 1)": 0.5,
+      "(1, 10, 2)": 0.5,
+      "(1, 10, 3)": 0.5,
+      "(1, 11, 1)": 0.5,
+      "(1, 11, 2)": 0.5,
+      "(1, 11, 3)": 0.5,
+      "(1, 12, 1)": 0.5,
+      "(1, 12, 2)": 0.5,
+      "(1, 12, 3)": 0.5,
+      "(1, 13, 1)": 0.5,
+      "(1, 13, 2)": 0.5,
+      "(1, 13, 3)": 0.5,
+      "(1, 14, 1)": 0.5,
+      "(1, 14, 2)": 0.5,
+      "(1, 14, 3)": 0.5,
+      "(1, 15, 1)": 0.5,
+      "(1, 15, 2)": 0.5,
+      "(1, 15, 3)": 0.5,
+      "(1, 16, 1)": 0.5,
+      "(1, 16, 2)": 0.5,
+      "(1, 16, 3)": 0.5,
+      "(1, 17, 1)": 0.5,
+      "(1, 17, 2)": 0.5,
+      "(1, 17, 3)": 0.5,
+      "(1, 18, 1)": 0.5,
+      "(1, 18, 2)": 0.5,
+      "(1, 18, 3)": 0.5,
+      "(1, 19, 1)": 0.5,
+      "(1, 19, 2)": 0.5,
+      "(1, 19, 3)": 0.5,
+      "(1, 20, 1)": 0.5,
+      "(1, 20, 2)": 0.5,
+      "(1, 20, 3)": 0.5,
+      "(2, 1, 1)": 0.5,
+      "(2, 1, 2)": 0.5,
+      "(2, 1, 3)": 0.5,
+      "(2, 2, 1)": 0.5,
+      "(2, 2, 2)": 0.5,
+      "(2, 2, 3)": 0.5,
+      "(2, 3, 1)": 0.5,
+      "(2, 3, 2)": 0.5,
+      "(2, 3, 3)": 0.5,
+      "(2, 4, 1)": 0.5,
+      "(2, 4, 2)": 0.5,
+      "(2, 4, 3)": 0.5,
+      "(2, 5, 1)": 0.5,
+      "(2, 5, 2)": 0.5,
+      "(2, 5, 3)": 0.5,
+      "(2, 6, 1)": 0.5,
+      "(2, 6, 2)": 0.5,
+      "(2, 6, 3)": 0.5,
+      "(2, 7, 1)": 0.5,
+      "(2, 7, 2)": 0.5,
+      "(2, 7, 3)": 0.5,
+      "(2, 8, 1)": 0.5,
+      "(2, 8, 2)": 0.5,
+      "(2, 8, 3)": 0.5,
+      "(2, 9, 1)": 0.5,
+      "(2, 9, 2)": 0.5,
+      "(2, 9, 3)": 0.5,
+      "(2, 10, 1)": 0.5,
+      "(2, 10, 2)": 0.5,
+      "(2, 10, 3)": 0.5,
+      "(2, 11, 1)": 0.5,
+      "(2, 11, 2)": 0.5,
+      "(2, 11, 3)": 0.5,
+      "(2, 12, 1)": 0.5,
+      "(2, 12, 2)": 0.5,
+      "(2, 12, 3)": 0.5,
+      "(2, 13, 1)": 0.5,
+      "(2, 13, 2)": 0.5,
+      "(2, 13, 3)": 0.5,
+      "(2, 14, 1)": 0.5,
+      "(2, 14, 2)": 0.5,
+      "(2, 14, 3)": 0.5,
+      "(2, 15, 1)": 0.5,
+      "(2, 15, 2)": 0.5,
+      "(2, 15, 3)": 0.5,
+      "(2, 16, 1)": 0.5,
+      "(2, 16, 2)": 0.5,
+      "(2, 16, 3)": 0.5,
+      "(2, 17, 1)": 0.5,
+      "(2, 17, 2)": 0.5,
+      "(2, 17, 3)": 0.5,
+      "(2, 18, 1)": 0.5,
+      "(2, 18, 2)": 0.5,
+      "(2, 18, 3)": 0.5,
+      "(2, 19, 1)": 0.5,
+      "(2, 19, 2)": 0.5,
+      "(2, 19, 3)": 0.5,
+      "(2, 20, 1)": 0.5,
+      "(2, 20, 2)": 0.5,
+      "(2, 20, 3)": 0.5,
+      "(3, 1, 1)": 0.5,
+      "(3, 1, 2)": 0.5,
+      "(3, 1, 3)": 0.5,
+      "(3, 2, 1)": 0.5,
+      "(3, 2, 2)": 0.5,
+      "(3, 2, 3)": 0.5,
+      "(3, 3, 1)": 0.5,
+      "(3, 3, 2)": 0.5,
+      "(3, 3, 3)": 0.5,
+      "(3, 4, 1)": 0.5,
+      "(3, 4, 2)": 0.5,
+      "(3, 4, 3)": 0.5,
+      "(3, 5, 1)": 0.5,
+      "(3, 5, 2)": 0.5,
+      "(3, 5, 3)": 0.5,
+      "(3, 6, 1)": 0.5,
+      "(3, 6, 2)": 0.5,
+      "(3, 6, 3)": 0.5,
+      "(3, 7, 1)": 0.5,
+      "(3, 7, 2)": 0.5,
+      "(3, 7, 3)": 0.5,
+      "(3, 8, 1)": 0.5,
+      "(3, 8, 2)": 0.5,
+      "(3, 8, 3)": 0.5,
+      "(3, 9, 1)": 0.5,
+      "(3, 9, 2)": 0.5,
+      "(3, 9, 3)": 0.5,
+      "(3, 10, 1)": 0.5,
+      "(3, 10, 2)": 0.5,
+      "(3, 10, 3)": 0.5,
+      "(3, 11, 1)": 0.5,
+      "(3, 11, 2)": 0.5,
+      "(3, 11, 3)": 0.5,
+      "(3, 12, 1)": 0.5,
+      "(3, 12, 2)": 0.5,
+      "(3, 12, 3)": 0.5,
+      "(3, 13, 1)": 0.5,
+      "(3, 13, 2)": 0.5,
+      "(3, 13, 3)": 0.5,
+      "(3, 14, 1)": 0.5,
+      "(3, 14, 2)": 0.5,
+      "(3, 14, 3)": 0.5,
+      "(3, 15, 1)": 0.5,
+      "(3, 15, 2)": 0.5,
+      "(3, 15, 3)": 0.5,
+      "(3, 16, 1)": 0.5,
+      "(3, 16, 2)": 0.5,
+      "(3, 16, 3)": 0.5,
+      "(3, 17, 1)": 0.5,
+      "(3, 17, 2)": 0.5,
+      "(3, 17, 3)": 0.5,
+      "(3, 18, 1)": 0.5,
+      "(3, 18, 2)": 0.5,
+      "(3, 18, 3)": 0.5,
+      "(3, 19, 1)": 0.5,
+      "(3, 19, 2)": 0.5,
+      "(3, 19, 3)": 0.5,
+      "(3, 20, 1)": 0.5,
+      "(3, 20, 2)": 0.5,
+      "(3, 20, 3)": 0.5,
+      "(4, 1, 1)": 0.5,
+      "(4, 1, 2)": 0.5,
+      "(4, 1, 3)": 0.5,
+      "(4, 2, 1)": 0.5,
+      "(4, 2, 2)": 0.5,
+      "(4, 2, 3)": 0.5,
+      "(4, 3, 1)": 0.5,
+      "(4, 3, 2)": 0.5,
+      "(4, 3, 3)": 0.5,
+      "(4, 4, 1)": 0.5,
+      "(4, 4, 2)": 0.5,
+      "(4, 4, 3)": 0.5,
+      "(4, 5, 1)": 0.5,
+      "(4, 5, 2)": 0.5,
+      "(4, 5, 3)": 0.5,
+      "(4, 6, 1)": 0.5,
+      "(4, 6, 2)": 0.5,
+      "(4, 6, 3)": 0.5,
+      "(4, 7, 1)": 0.5,
+      "(4, 7, 2)": 0.5,
+      "(4, 7, 3)": 0.5,
+      "(4, 8, 1)": 0.5,
+      "(4, 8, 2)": 0.5,
+      "(4, 8, 3)": 0.5,
+      "(4, 9, 1)": 0.5,
+      "(4, 9, 2)": 0.5,
+      "(4, 9, 3)": 0.5,
+      "(4, 10, 1)": 0.5,
+      "(4, 10, 2)": 0.5,
+      "(4, 10, 3)": 0.5,
+      "(4, 11, 1)": 0.5,
+      "(4, 11, 2)": 0.5,
+      "(4, 11, 3)": 0.5,
+      "(4, 12, 1)": 0.5,
+      "(4, 12, 2)": 0.5,
+      "(4, 12, 3)": 0.5,
+      "(4, 13, 1)": 0.5,
+      "(4, 13, 2)": 0.5,
+      "(4, 13, 3)": 0.5,
+      "(4, 14, 1)": 0.5,
+      "(4, 14, 2)": 0.5,
+      "(4, 14, 3)": 0.5,
+      "(4, 15, 1)": 0.5,
+      "(4, 15, 2)": 0.5,
+      "(4, 15, 3)": 0.5,
+      "(4, 16, 1)": 0.5,
+      "(4, 16, 2)": 0.5,
+      "(4, 16, 3)": 0.5,
+      "(4, 17, 1)": 0.5,
+      "(4, 17, 2)": 0.5,
+      "(4, 17, 3)": 0.5,
+      "(4, 18, 1)": 0.5,
+      "(4, 18, 2)": 0.5,
+      "(4, 18, 3)": 0.5,
+      "(4, 19, 1)": 0.5,
+      "(4, 19, 2)": 0.5,
+      "(4, 19, 3)": 0.5,
+      "(4, 20, 1)": 0.5,
+      "(4, 20, 2)": 0.5,
+      "(4, 20, 3)": 0.5,
+      "(5, 1, 1)": 0.5,
+      "(5, 1, 2)": 0.5,
+      "(5, 1, 3)": 0.5,
+      "(5, 2, 1)": 0.5,
+      "(5, 2, 2)": 0.5,
+      "(5, 2, 3)": 0.5,
+      "(5, 3, 1)": 0.5,
+      "(5, 3, 2)": 0.5,
+      "(5, 3, 3)": 0.5,
+      "(5, 4, 1)": 0.5,
+      "(5, 4, 2)": 0.5,
+      "(5, 4, 3)": 0.5,
+      "(5, 5, 1)": 0.5,
+      "(5, 5, 2)": 0.5,
+      "(5, 5, 3)": 0.5,
+      "(5, 6, 1)": 0.5,
+      "(5, 6, 2)": 0.5,
+      "(5, 6, 3)": 0.5,
+      "(5, 7, 1)": 0.5,
+      "(5, 7, 2)": 0.5,
+      "(5, 7, 3)": 0.5,
+      "(5, 8, 1)": 0.5,
+      "(5, 8, 2)": 0.5,
+      "(5, 8, 3)": 0.5,
+      "(5, 9, 1)": 0.5,
+      "(5, 9, 2)": 0.5,
+      "(5, 9, 3)": 0.5,
+      "(5, 10, 1)": 0.5,
+      "(5, 10, 2)": 0.5,
+      "(5, 10, 3)": 0.5,
+      "(5, 11, 1)": 0.5,
+      "(5, 11, 2)": 0.5,
+      "(5, 11, 3)": 0.5,
+      "(5, 12, 1)": 0.5,
+      "(5, 12, 2)": 0.5,
+      "(5, 12, 3)": 0.5,
+      "(5, 13, 1)": 0.5,
+      "(5, 13, 2)": 0.5,
+      "(5, 13, 3)": 0.5,
+      "(5, 14, 1)": 0.5,
+      "(5, 14, 2)": 0.5,
+      "(5, 14, 3)": 0.5,
+      "(5, 15, 1)": 0.5,
+      "(5, 15, 2)": 0.5,
+      "(5, 15, 3)": 0.5,
+      "(5, 16, 1)": 0.5,
+      "(5, 16, 2)": 0.5,
+      "(5, 16, 3)": 0.5,
+      "(5, 17, 1)": 0.5,
+      "(5, 17, 2)": 0.5,
+      "(5, 17, 3)": 0.5,
+      "(5, 18, 1)": 0.5,
+      "(5, 18, 2)": 0.5,
+      "(5, 18, 3)": 0.5,
+      "(5, 19, 1)": 0.5,
+      "(5, 19, 2)": 0.5,
+      "(5, 19, 3)": 0.5,
+      "(5, 20, 1)": 0.5,
+      "(5, 20, 2)": 0.5,
+      "(5, 20, 3)": 0.5,
+      "(6, 1, 1)": 0.5,
+      "(6, 1, 2)": 0.5,
+      "(6, 1, 3)": 0.5,
+      "(6, 2, 1)": 0.5,
+      "(6, 2, 2)": 0.5,
+      "(6, 2, 3)": 0.5,
+      "(6, 3, 1)": 0.5,
+      "(6, 3, 2)": 0.5,
+      "(6, 3, 3)": 0.5,
+      "(6, 4, 1)": 0.5,
+      "(6, 4, 2)": 0.5,
+      "(6, 4, 3)": 0.5,
+      "(6, 5, 1)": 0.5,
+      "(6, 5, 2)": 0.5,
+      "(6, 5, 3)": 0.5,
+      "(6, 6, 1)": 0.5,
+      "(6, 6, 2)": 0.5,
+      "(6, 6, 3)": 0.5,
+      "(6, 7, 1)": 0.5,
+      "(6, 7, 2)": 0.5,
+      "(6, 7, 3)": 0.5,
+      "(6, 8, 1)": 0.5,
+      "(6, 8, 2)": 0.5,
+      "(6, 8, 3)": 0.5,
+      "(6, 9, 1)": 0.5,
+      "(6, 9, 2)": 0.5,
+      "(6, 9, 3)": 0.5,
+      "(6, 10, 1)": 0.5,
+      "(6, 10, 2)": 0.5,
+      "(6, 10, 3)": 0.5,
+      "(6, 11, 1)": 0.5,
+      "(6, 11, 2)": 0.5,
+      "(6, 11, 3)": 0.5,
+      "(6, 12, 1)": 0.5,
+      "(6, 12, 2)": 0.5,
+      "(6, 12, 3)": 0.5,
+      "(6, 13, 1)": 0.5,
+      "(6, 13, 2)": 0.5,
+      "(6, 13, 3)": 0.5,
+      "(6, 14, 1)": 0.5,
+      "(6, 14, 2)": 0.5,
+      "(6, 14, 3)": 0.5,
+      "(6, 15, 1)": 0.5,
+      "(6, 15, 2)": 0.5,
+      "(6, 15, 3)": 0.5,
+      "(6, 16, 1)": 0.5,
+      "(6, 16, 2)": 0.5,
+      "(6, 16, 3)": 0.5,
+      "(6, 17, 1)": 0.5,
+      "(6, 17, 2)": 0.5,
+      "(6, 17, 3)": 0.5,
+      "(6, 18, 1)": 0.5,
+      "(6, 18, 2)": 0.5,
+      "(6, 18, 3)": 0.5,
+      "(6, 19, 1)": 0.5,
+      "(6, 19, 2)": 0.5,
+      "(6, 19, 3)": 0.5,
+      "(6, 20, 1)": 0.5,
+      "(6, 20, 2)": 0.5,
+      "(6, 20, 3)": 0.5,
+      "(7, 1, 1)": 0.5,
+      "(7, 1, 2)": 0.5,
+      "(7, 1, 3)": 0.5,
+      "(7, 2, 1)": 0.5,
+      "(7, 2, 2)": 0.5,
+      "(7, 2, 3)": 0.5,
+      "(7, 3, 1)": 0.5,
+      "(7, 3, 2)": 0.5,
+      "(7, 3, 3)": 0.5,
+      "(7, 4, 1)": 0.5,
+      "(7, 4, 2)": 0.5,
+      "(7, 4, 3)": 0.5,
+      "(7, 5, 1)": 0.5,
+      "(7, 5, 2)": 0.5,
+      "(7, 5, 3)": 0.5,
+      "(7, 6, 1)": 0.5,
+      "(7, 6, 2)": 0.5,
+      "(7, 6, 3)": 0.5,
+      "(7, 7, 1)": 0.5,
+      "(7, 7, 2)": 0.5,
+      "(7, 7, 3)": 0.5,
+      "(7, 8, 1)": 0.5,
+      "(7, 8, 2)": 0.5,
+      "(7, 8, 3)": 0.5,
+      "(7, 9, 1)": 0.5,
+      "(7, 9, 2)": 0.5,
+      "(7, 9, 3)": 0.5,
+      "(7, 10, 1)": 0.5,
+      "(7, 10, 2)": 0.5,
+      "(7, 10, 3)": 0.5,
+      "(7, 11, 1)": 0.5,
+      "(7, 11, 2)": 0.5,
+      "(7, 11, 3)": 0.5,
+      "(7, 12, 1)": 0.5,
+      "(7, 12, 2)": 0.5,
+      "(7, 12, 3)": 0.5,
+      "(7, 13, 1)": 0.5,
+      "(7, 13, 2)": 0.5,
+      "(7, 13, 3)": 0.5,
+      "(7, 14, 1)": 0.5,
+      "(7, 14, 2)": 0.5,
+      "(7, 14, 3)": 0.5,
+      "(7, 15, 1)": 0.5,
+      "(7, 15, 2)": 0.5,
+      "(7, 15, 3)": 0.5,
+      "(7, 16, 1)": 0.5,
+      "(7, 16, 2)": 0.5,
+      "(7, 16, 3)": 0.5,
+      "(7, 17, 1)": 0.5,
+      "(7, 17, 2)": 0.5,
+      "(7, 17, 3)": 0.5,
+      "(7, 18, 1)": 0.5,
+      "(7, 18, 2)": 0.5,
+      "(7, 18, 3)": 0.5,
+      "(7, 19, 1)": 0.5,
+      "(7, 19, 2)": 0.5,
+      "(7, 19, 3)": 0.5,
+      "(7, 20, 1)": 0.5,
+      "(7, 20, 2)": 0.5,
+      "(7, 20, 3)": 0.5,
+      "(8, 1, 1)": 0.5,
+      "(8, 1, 2)": 0.5,
+      "(8, 1, 3)": 0.5,
+      "(8, 2, 1)": 0.5,
+      "(8, 2, 2)": 0.5,
+      "(8, 2, 3)": 0.5,
+      "(8, 3, 1)": 0.5,
+      "(8, 3, 2)": 0.5,
+      "(8, 3, 3)": 0.5,
+      "(8, 4, 1)": 0.5,
+      "(8, 4, 2)": 0.5,
+      "(8, 4, 3)": 0.5,
+      "(8, 5, 1)": 0.5,
+      "(8, 5, 2)": 0.5,
+      "(8, 5, 3)": 0.5,
+      "(8, 6, 1)": 0.5,
+      "(8, 6, 2)": 0.5,
+      "(8, 6, 3)": 0.5,
+      "(8, 7, 1)": 0.5,
+      "(8, 7, 2)": 0.5,
+      "(8, 7, 3)": 0.5,
+      "(8, 8, 1)": 0.5,
+      "(8, 8, 2)": 0.5,
+      "(8, 8, 3)": 0.5,
+      "(8, 9, 1)": 0.5,
+      "(8, 9, 2)": 0.5,
+      "(8, 9, 3)": 0.5,
+      "(8, 10, 1)": 0.5,
+      "(8, 10, 2)": 0.5,
+      "(8, 10, 3)": 0.5,
+      "(8, 11, 1)": 0.5,
+      "(8, 11, 2)": 0.5,
+      "(8, 11, 3)": 0.5,
+      "(8, 12, 1)": 0.5,
+      "(8, 12, 2)": 0.5,
+      "(8, 12, 3)": 0.5,
+      "(8, 13, 1)": 0.5,
+      "(8, 13, 2)": 0.5,
+      "(8, 13, 3)": 0.5,
+      "(8, 14, 1)": 0.5,
+      "(8, 14, 2)": 0.5,
+      "(8, 14, 3)": 0.5,
+      "(8, 15, 1)": 0.5,
+      "(8, 15, 2)": 0.5,
+      "(8, 15, 3)": 0.5,
+      "(8, 16, 1)": 0.5,
+      "(8, 16, 2)": 0.5,
+      "(8, 16, 3)": 0.5,
+      "(8, 17, 1)": 0.5,
+      "(8, 17, 2)": 0.5,
+      "(8, 17, 3)": 0.5,
+      "(8, 18, 1)": 0.5,
+      "(8, 18, 2)": 0.5,
+      "(8, 18, 3)": 0.5,
+      "(8, 19, 1)": 0.5,
+      "(8, 19, 2)": 0.5,
+      "(8, 19, 3)": 0.5,
+      "(8, 20, 1)": 0.5,
+      "(8, 20, 2)": 0.5,
+      "(8, 20, 3)": 0.5,
+      "(9, 1, 1)": 0.5,
+      "(9, 1, 2)": 0.5,
+      "(9, 1, 3)": 0.5,
+      "(9, 2, 1)": 0.5,
+      "(9, 2, 2)": 0.5,
+      "(9, 2, 3)": 0.5,
+      "(9, 3, 1)": 0.5,
+      "(9, 3, 2)": 0.5,
+      "(9, 3, 3)": 0.5,
+      "(9, 4, 1)": 0.5,
+      "(9, 4, 2)": 0.5,
+      "(9, 4, 3)": 0.5,
+      "(9, 5, 1)": 0.5,
+      "(9, 5, 2)": 0.5,
+      "(9, 5, 3)": 0.5,
+      "(9, 6, 1)": 0.5,
+      "(9, 6, 2)": 0.5,
+      "(9, 6, 3)": 0.5,
+      "(9, 7, 1)": 0.5,
+      "(9, 7, 2)": 0.5,
+      "(9, 7, 3)": 0.5,
+      "(9, 8, 1)": 0.5,
+      "(9, 8, 2)": 0.5,
+      "(9, 8, 3)": 0.5,
+      "(9, 9, 1)": 0.5,
+      "(9, 9, 2)": 0.5,
+      "(9, 9, 3)": 0.5,
+      "(9, 10, 1)": 0.5,
+      "(9, 10, 2)": 0.5,
+      "(9, 10, 3)": 0.5,
+      "(9, 11, 1)": 0.5,
+      "(9, 11, 2)": 0.5,
+      "(9, 11, 3)": 0.5,
+      "(9, 12, 1)": 0.5,
+      "(9, 12, 2)": 0.5,
+      "(9, 12, 3)": 0.5,
+      "(9, 13, 1)": 0.5,
+      "(9, 13, 2)": 0.5,
+      "(9, 13, 3)": 0.5,
+      "(9, 14, 1)": 0.5,
+      "(9, 14, 2)": 0.5,
+      "(9, 14, 3)": 0.5,
+      "(9, 15, 1)": 0.5,
+      "(9, 15, 2)": 0.5,
+      "(9, 15, 3)": 0.5,
+      "(9, 16, 1)": 0.5,
+      "(9, 16, 2)": 0.5,
+      "(9, 16, 3)": 0.5,
+      "(9, 17, 1)": 0.5,
+      "(9, 17, 2)": 0.5,
+      "(9, 17, 3)": 0.5,
+      "(9, 18, 1)": 0.5,
+      "(9, 18, 2)": 0.5,
+      "(9, 18, 3)": 0.5,
+      "(9, 19, 1)": 0.5,
+      "(9, 19, 2)": 0.5,
+      "(9, 19, 3)": 0.5,
+      "(9, 20, 1)": 0.5,
+      "(9, 20, 2)": 0.5,
+      "(9, 20, 3)": 0.5,
+      "(10, 1, 1)": 0.5,
+      "(10, 1, 2)": 0.5,
+      "(10, 1, 3)": 0.5,
+      "(10, 2, 1)": 0.5,
+      "(10, 2, 2)": 0.5,
+      "(10, 2, 3)": 0.5,
+      "(10, 3, 1)": 0.5,
+      "(10, 3, 2)": 0.5,
+      "(10, 3, 3)": 0.5,
+      "(10, 4, 1)": 0.5,
+      "(10, 4, 2)": 0.5,
+      "(10, 4, 3)": 0.5,
+      "(10, 5, 1)": 0.5,
+      "(10, 5, 2)": 0.5,
+      "(10, 5, 3)": 0.5,
+      "(10, 6, 1)": 0.5,
+      "(10, 6, 2)": 0.5,
+      "(10, 6, 3)": 0.5,
+      "(10, 7, 1)": 0.5,
+      "(10, 7, 2)": 0.5,
+      "(10, 7, 3)": 0.5,
+      "(10, 8, 1)": 0.5,
+      "(10, 8, 2)": 0.5,
+      "(10, 8, 3)": 0.5,
+      "(10, 9, 1)": 0.5,
+      "(10, 9, 2)": 0.5,
+      "(10, 9, 3)": 0.5,
+      "(10, 10, 1)": 0.5,
+      "(10, 10, 2)": 0.5,
+      "(10, 10, 3)": 0.5,
+      "(10, 11, 1)": 0.5,
+      "(10, 11, 2)": 0.5,
+      "(10, 11, 3)": 0.5,
+      "(10, 12, 1)": 0.5,
+      "(10, 12, 2)": 0.5,
+      "(10, 12, 3)": 0.5,
+      "(10, 13, 1)": 0.5,
+      "(10, 13, 2)": 0.5,
+      "(10, 13, 3)": 0.5,
+      "(10, 14, 1)": 0.5,
+      "(10, 14, 2)": 0.5,
+      "(10, 14, 3)": 0.5,
+      "(10, 15, 1)": 0.5,
+      "(10, 15, 2)": 0.5,
+      "(10, 15, 3)": 0.5,
+      "(10, 16, 1)": 0.5,
+      "(10, 16, 2)": 0.5,
+      "(10, 16, 3)": 0.5,
+      "(10, 17, 1)": 0.5,
+      "(10, 17, 2)": 0.5,
+      "(10, 17, 3)": 0.5,
+      "(10, 18, 1)": 0.5,
+      "(10, 18, 2)": 0.5,
+      "(10, 18, 3)": 0.5,
+      "(10, 19, 1)": 0.5,
+      "(10, 19, 2)": 0.5,
+      "(10, 19, 3)": 0.5,
+      "(10, 20, 1)": 0.5,
+      "(10, 20, 2)": 0.5,
+      "(10, 20, 3)": 0.5,
+      "(11, 1, 1)": 0.5,
+      "(11, 1, 2)": 0.5,
+      "(11, 1, 3)": 0.5,
+      "(11, 2, 1)": 0.5,
+      "(11, 2, 2)": 0.5,
+      "(11, 2, 3)": 0.5,
+      "(11, 3, 1)": 0.5,
+      "(11, 3, 2)": 0.5,
+      "(11, 3, 3)": 0.5,
+      "(11, 4, 1)": 0.5,
+      "(11, 4, 2)": 0.5,
+      "(11, 4, 3)": 0.5,
+      "(11, 5, 1)": 0.5,
+      "(11, 5, 2)": 0.5,
+      "(11, 5, 3)": 0.5,
+      "(11, 6, 1)": 0.5,
+      "(11, 6, 2)": 0.5,
+      "(11, 6, 3)": 0.5,
+      "(11, 7, 1)": 0.5,
+      "(11, 7, 2)": 0.5,
+      "(11, 7, 3)": 0.5,
+      "(11, 8, 1)": 0.5,
+      "(11, 8, 2)": 0.5,
+      "(11, 8, 3)": 0.5,
+      "(11, 9, 1)": 0.5,
+      "(11, 9, 2)": 0.5,
+      "(11, 9, 3)": 0.5,
+      "(11, 10, 1)": 0.5,
+      "(11, 10, 2)": 0.5,
+      "(11, 10, 3)": 0.5,
+      "(11, 11, 1)": 0.5,
+      "(11, 11, 2)": 0.5,
+      "(11, 11, 3)": 0.5,
+      "(11, 12, 1)": 0.5,
+      "(11, 12, 2)": 0.5,
+      "(11, 12, 3)": 0.5,
+      "(11, 13, 1)": 0.5,
+      "(11, 13, 2)": 0.5,
+      "(11, 13, 3)": 0.5,
+      "(11, 14, 1)": 0.5,
+      "(11, 14, 2)": 0.5,
+      "(11, 14, 3)": 0.5,
+      "(11, 15, 1)": 0.5,
+      "(11, 15, 2)": 0.5,
+      "(11, 15, 3)": 0.5,
+      "(11, 16, 1)": 0.5,
+      "(11, 16, 2)": 0.5,
+      "(11, 16, 3)": 0.5,
+      "(11, 17, 1)": 0.5,
+      "(11, 17, 2)": 0.5,
+      "(11, 17, 3)": 0.5,
+      "(11, 18, 1)": 0.5,
+      "(11, 18, 2)": 0.5,
+      "(11, 18, 3)": 0.5,
+      "(11, 19, 1)": 0.5,
+      "(11, 19, 2)": 0.5,
+      "(11, 19, 3)": 0.5,
+      "(11, 20, 1)": 0.5,
+      "(11, 20, 2)": 0.5,
+      "(11, 20, 3)": 0.5,
+      "(12, 1, 1)": 0.5,
+      "(12, 1, 2)": 0.5,
+      "(12, 1, 3)": 0.5,
+      "(12, 2, 1)": 0.5,
+      "(12, 2, 2)": 0.5,
+      "(12, 2, 3)": 0.5,
+      "(12, 3, 1)": 0.5,
+      "(12, 3, 2)": 0.5,
+      "(12, 3, 3)": 0.5,
+      "(12, 4, 1)": 0.5,
+      "(12, 4, 2)": 0.5,
+      "(12, 4, 3)": 0.5,
+      "(12, 5, 1)": 0.5,
+      "(12, 5, 2)": 0.5,
+      "(12, 5, 3)": 0.5,
+      "(12, 6, 1)": 0.5,
+      "(12, 6, 2)": 0.5,
+      "(12, 6, 3)": 0.5,
+      "(12, 7, 1)": 0.5,
+      "(12, 7, 2)": 0.5,
+      "(12, 7, 3)": 0.5,
+      "(12, 8, 1)": 0.5,
+      "(12, 8, 2)": 0.5,
+      "(12, 8, 3)": 0.5,
+      "(12, 9, 1)": 0.5,
+      "(12, 9, 2)": 0.5,
+      "(12, 9, 3)": 0.5,
+      "(12, 10, 1)": 0.5,
+      "(12, 10, 2)": 0.5,
+      "(12, 10, 3)": 0.5,
+      "(12, 11, 1)": 0.5,
+      "(12, 11, 2)": 0.5,
+      "(12, 11, 3)": 0.5,
+      "(12, 12, 1)": 0.5,
+      "(12, 12, 2)": 0.5,
+      "(12, 12, 3)": 0.5,
+      "(12, 13, 1)": 0.5,
+      "(12, 13, 2)": 0.5,
+      "(12, 13, 3)": 0.5,
+      "(12, 14, 1)": 0.5,
+      "(12, 14, 2)": 0.5,
+      "(12, 14, 3)": 0.5,
+      "(12, 15, 1)": 0.5,
+      "(12, 15, 2)": 0.5,
+      "(12, 15, 3)": 0.5,
+      "(12, 16, 1)": 0.5,
+      "(12, 16, 2)": 0.5,
+      "(12, 16, 3)": 0.5,
+      "(12, 17, 1)": 0.5,
+      "(12, 17, 2)": 0.5,
+      "(12, 17, 3)": 0.5,
+      "(12, 18, 1)": 0.5,
+      "(12, 18, 2)": 0.5,
+      "(12, 18, 3)": 0.5,
+      "(12, 19, 1)": 0.5,
+      "(12, 19, 2)": 0.5,
+      "(12, 19, 3)": 0.5,
+      "(12, 20, 1)": 0.5,
+      "(12, 20, 2)": 0.5,
+      "(12, 20, 3)": 0.5,
+      "(13, 1, 1)": 0.5,
+      "(13, 1, 2)": 0.5,
+      "(13, 1, 3)": 0.5,
+      "(13, 2, 1)": 0.5,
+      "(13, 2, 2)": 0.5,
+      "(13, 2, 3)": 0.5,
+      "(13, 3, 1)": 0.5,
+      "(13, 3, 2)": 0.5,
+      "(13, 3, 3)": 0.5,
+      "(13, 4, 1)": 0.5,
+      "(13, 4, 2)": 0.5,
+      "(13, 4, 3)": 0.5,
+      "(13, 5, 1)": 0.5,
+      "(13, 5, 2)": 0.5,
+      "(13, 5, 3)": 0.5,
+      "(13, 6, 1)": 0.5,
+      "(13, 6, 2)": 0.5,
+      "(13, 6, 3)": 0.5,
+      "(13, 7, 1)": 0.5,
+      "(13, 7, 2)": 0.5,
+      "(13, 7, 3)": 0.5,
+      "(13, 8, 1)": 0.5,
+      "(13, 8, 2)": 0.5,
+      "(13, 8, 3)": 0.5,
+      "(13, 9, 1)": 0.5,
+      "(13, 9, 2)": 0.5,
+      "(13, 9, 3)": 0.5,
+      "(13, 10, 1)": 0.5,
+      "(13, 10, 2)": 0.5,
+      "(13, 10, 3)": 0.5,
+      "(13, 11, 1)": 0.5,
+      "(13, 11, 2)": 0.5,
+      "(13, 11, 3)": 0.5,
+      "(13, 12, 1)": 0.5,
+      "(13, 12, 2)": 0.5,
+      "(13, 12, 3)": 0.5,
+      "(13, 13, 1)": 0.5,
+      "(13, 13, 2)": 0.5,
+      "(13, 13, 3)": 0.5,
+      "(13, 14, 1)": 0.5,
+      "(13, 14, 2)": 0.5,
+      "(13, 14, 3)": 0.5,
+      "(13, 15, 1)": 0.5,
+      "(13, 15, 2)": 0.5,
+      "(13, 15, 3)": 0.5,
+      "(13, 16, 1)": 0.5,
+      "(13, 16, 2)": 0.5,
+      "(13, 16, 3)": 0.5,
+      "(13, 17, 1)": 0.5,
+      "(13, 17, 2)": 0.5,
+      "(13, 17, 3)": 0.5,
+      "(13, 18, 1)": 0.5,
+      "(13, 18, 2)": 0.5,
+      "(13, 18, 3)": 0.5,
+      "(13, 19, 1)": 0.5,
+      "(13, 19, 2)": 0.5,
+      "(13, 19, 3)": 0.5,
+      "(13, 20, 1)": 0.5,
+      "(13, 20, 2)": 0.5,
+      "(13, 20, 3)": 0.5,
+      "(14, 1, 1)": 0.5,
+      "(14, 1, 2)": 0.5,
+      "(14, 1, 3)": 0.5,
+      "(14, 2, 1)": 0.5,
+      "(14, 2, 2)": 0.5,
+      "(14, 2, 3)": 0.5,
+      "(14, 3, 1)": 0.5,
+      "(14, 3, 2)": 0.5,
+      "(14, 3, 3)": 0.5,
+      "(14, 4, 1)": 0.5,
+      "(14, 4, 2)": 0.5,
+      "(14, 4, 3)": 0.5,
+      "(14, 5, 1)": 0.5,
+      "(14, 5, 2)": 0.5,
+      "(14, 5, 3)": 0.5,
+      "(14, 6, 1)": 0.5,
+      "(14, 6, 2)": 0.5,
+      "(14, 6, 3)": 0.5,
+      "(14, 7, 1)": 0.5,
+      "(14, 7, 2)": 0.5,
+      "(14, 7, 3)": 0.5,
+      "(14, 8, 1)": 0.5,
+      "(14, 8, 2)": 0.5,
+      "(14, 8, 3)": 0.5,
+      "(14, 9, 1)": 0.5,
+      "(14, 9, 2)": 0.5,
+      "(14, 9, 3)": 0.5,
+      "(14, 10, 1)": 0.5,
+      "(14, 10, 2)": 0.5,
+      "(14, 10, 3)": 0.5,
+      "(14, 11, 1)": 0.5,
+      "(14, 11, 2)": 0.5,
+      "(14, 11, 3)": 0.5,
+      "(14, 12, 1)": 0.5,
+      "(14, 12, 2)": 0.5,
+      "(14, 12, 3)": 0.5,
+      "(14, 13, 1)": 0.5,
+      "(14, 13, 2)": 0.5,
+      "(14, 13, 3)": 0.5,
+      "(14, 14, 1)": 0.5,
+      "(14, 14, 2)": 0.5,
+      "(14, 14, 3)": 0.5,
+      "(14, 15, 1)": 0.5,
+      "(14, 15, 2)": 0.5,
+      "(14, 15, 3)": 0.5,
+      "(14, 16, 1)": 0.5,
+      "(14, 16, 2)": 0.5,
+      "(14, 16, 3)": 0.5,
+      "(14, 17, 1)": 0.5,
+      "(14, 17, 2)": 0.5,
+      "(14, 17, 3)": 0.5,
+      "(14, 18, 1)": 0.5,
+      "(14, 18, 2)": 0.5,
+      "(14, 18, 3)": 0.5,
+      "(14, 19, 1)": 0.5,
+      "(14, 19, 2)": 0.5,
+      "(14, 19, 3)": 0.5,
+      "(14, 20, 1)": 0.5,
+      "(14, 20, 2)": 0.5,
+      "(14, 20, 3)": 0.5,
+      "(15, 1, 1)": 0.5,
+      "(15, 1, 2)": 0.5,
+      "(15, 1, 3)": 0.5,
+      "(15, 2, 1)": 0.5,
+      "(15, 2, 2)": 0.5,
+      "(15, 2, 3)": 0.5,
+      "(15, 3, 1)": 0.5,
+      "(15, 3, 2)": 0.5,
+      "(15, 3, 3)": 0.5,
+      "(15, 4, 1)": 0.5,
+      "(15, 4, 2)": 0.5,
+      "(15, 4, 3)": 0.5,
+      "(15, 5, 1)": 0.5,
+      "(15, 5, 2)": 0.5,
+      "(15, 5, 3)": 0.5,
+      "(15, 6, 1)": 0.5,
+      "(15, 6, 2)": 0.5,
+      "(15, 6, 3)": 0.5,
+      "(15, 7, 1)": 0.5,
+      "(15, 7, 2)": 0.5,
+      "(15, 7, 3)": 0.5,
+      "(15, 8, 1)": 0.5,
+      "(15, 8, 2)": 0.5,
+      "(15, 8, 3)": 0.5,
+      "(15, 9, 1)": 0.5,
+      "(15, 9, 2)": 0.5,
+      "(15, 9, 3)": 0.5,
+      "(15, 10, 1)": 0.5,
+      "(15, 10, 2)": 0.5,
+      "(15, 10, 3)": 0.5,
+      "(15, 11, 1)": 0.5,
+      "(15, 11, 2)": 0.5,
+      "(15, 11, 3)": 0.5,
+      "(15, 12, 1)": 0.5,
+      "(15, 12, 2)": 0.5,
+      "(15, 12, 3)": 0.5,
+      "(15, 13, 1)": 0.5,
+      "(15, 13, 2)": 0.5,
+      "(15, 13, 3)": 0.5,
+      "(15, 14, 1)": 0.5,
+      "(15, 14, 2)": 0.5,
+      "(15, 14, 3)": 0.5,
+      "(15, 15, 1)": 0.5,
+      "(15, 15, 2)": 0.5,
+      "(15, 15, 3)": 0.5,
+      "(15, 16, 1)": 0.5,
+      "(15, 16, 2)": 0.5,
+      "(15, 16, 3)": 0.5,
+      "(15, 17, 1)": 0.5,
+      "(15, 17, 2)": 0.5,
+      "(15, 17, 3)": 0.5,
+      "(15, 18, 1)": 0.5,
+      "(15, 18, 2)": 0.5,
+      "(15, 18, 3)": 0.5,
+      "(15, 19, 1)": 0.5,
+      "(15, 19, 2)": 0.5,
+      "(15, 19, 3)": 0.5,
+      "(15, 20, 1)": 0.5,
+      "(15, 20, 2)": 0.5,
+      "(15, 20, 3)": 0.5,
+      "(16, 1, 1)": 0.5,
+      "(16, 1, 2)": 0.5,
+      "(16, 1, 3)": 0.5,
+      "(16, 2, 1)": 0.5,
+      "(16, 2, 2)": 0.5,
+      "(16, 2, 3)": 0.5,
+      "(16, 3, 1)": 0.5,
+      "(16, 3, 2)": 0.5,
+      "(16, 3, 3)": 0.5,
+      "(16, 4, 1)": 0.5,
+      "(16, 4, 2)": 0.5,
+      "(16, 4, 3)": 0.5,
+      "(16, 5, 1)": 0.5,
+      "(16, 5, 2)": 0.5,
+      "(16, 5, 3)": 0.5,
+      "(16, 6, 1)": 0.5,
+      "(16, 6, 2)": 0.5,
+      "(16, 6, 3)": 0.5,
+      "(16, 7, 1)": 0.5,
+      "(16, 7, 2)": 0.5,
+      "(16, 7, 3)": 0.5,
+      "(16, 8, 1)": 0.5,
+      "(16, 8, 2)": 0.5,
+      "(16, 8, 3)": 0.5,
+      "(16, 9, 1)": 0.5,
+      "(16, 9, 2)": 0.5,
+      "(16, 9, 3)": 0.5,
+      "(16, 10, 1)": 0.5,
+      "(16, 10, 2)": 0.5,
+      "(16, 10, 3)": 0.5,
+      "(16, 11, 1)": 0.5,
+      "(16, 11, 2)": 0.5,
+      "(16, 11, 3)": 0.5,
+      "(16, 12, 1)": 0.5,
+      "(16, 12, 2)": 0.5,
+      "(16, 12, 3)": 0.5,
+      "(16, 13, 1)": 0.5,
+      "(16, 13, 2)": 0.5,
+      "(16, 13, 3)": 0.5,
+      "(16, 14, 1)": 0.5,
+      "(16, 14, 2)": 0.5,
+      "(16, 14, 3)": 0.5,
+      "(16, 15, 1)": 0.5,
+      "(16, 15, 2)": 0.5,
+      "(16, 15, 3)": 0.5,
+      "(16, 16, 1)": 0.5,
+      "(16, 16, 2)": 0.5,
+      "(16, 16, 3)": 0.5,
+      "(16, 17, 1)": 0.5,
+      "(16, 17, 2)": 0.5,
+      "(16, 17, 3)": 0.5,
+      "(16, 18, 1)": 0.5,
+      "(16, 18, 2)": 0.5,
+      "(16, 18, 3)": 0.5,
+      "(16, 19, 1)": 0.5,
+      "(16, 19, 2)": 0.5,
+      "(16, 19, 3)": 0.5,
+      "(16, 20, 1)": 0.5,
+      "(16, 20, 2)": 0.5,
+      "(16, 20, 3)": 0.5,
+      "(17, 1, 1)": 0.5,
+      "(17, 1, 2)": 0.5,
+      "(17, 1, 3)": 0.5,
+      "(17, 2, 1)": 0.5,
+      "(17, 2, 2)": 0.5,
+      "(17, 2, 3)": 0.5,
+      "(17, 3, 1)": 0.5,
+      "(17, 3, 2)": 0.5,
+      "(17, 3, 3)": 0.5,
+      "(17, 4, 1)": 0.5,
+      "(17, 4, 2)": 0.5,
+      "(17, 4, 3)": 0.5,
+      "(17, 5, 1)": 0.5,
+      "(17, 5, 2)": 0.5,
+      "(17, 5, 3)": 0.5,
+      "(17, 6, 1)": 0.5,
+      "(17, 6, 2)": 0.5,
+      "(17, 6, 3)": 0.5,
+      "(17, 7, 1)": 0.5,
+      "(17, 7, 2)": 0.5,
+      "(17, 7, 3)": 0.5,
+      "(17, 8, 1)": 0.5,
+      "(17, 8, 2)": 0.5,
+      "(17, 8, 3)": 0.5,
+      "(17, 9, 1)": 0.5,
+      "(17, 9, 2)": 0.5,
+      "(17, 9, 3)": 0.5,
+      "(17, 10, 1)": 0.5,
+      "(17, 10, 2)": 0.5,
+      "(17, 10, 3)": 0.5,
+      "(17, 11, 1)": 0.5,
+      "(17, 11, 2)": 0.5,
+      "(17, 11, 3)": 0.5,
+      "(17, 12, 1)": 0.5,
+      "(17, 12, 2)": 0.5,
+      "(17, 12, 3)": 0.5,
+      "(17, 13, 1)": 0.5,
+      "(17, 13, 2)": 0.5,
+      "(17, 13, 3)": 0.5,
+      "(17, 14, 1)": 0.5,
+      "(17, 14, 2)": 0.5,
+      "(17, 14, 3)": 0.5,
+      "(17, 15, 1)": 0.5,
+      "(17, 15, 2)": 0.5,
+      "(17, 15, 3)": 0.5,
+      "(17, 16, 1)": 0.5,
+      "(17, 16, 2)": 0.5,
+      "(17, 16, 3)": 0.5,
+      "(17, 17, 1)": 0.5,
+      "(17, 17, 2)": 0.5,
+      "(17, 17, 3)": 0.5,
+      "(17, 18, 1)": 0.5,
+      "(17, 18, 2)": 0.5,
+      "(17, 18, 3)": 0.5,
+      "(17, 19, 1)": 0.5,
+      "(17, 19, 2)": 0.5,
+      "(17, 19, 3)": 0.5,
+      "(17, 20, 1)": 0.5,
+      "(17, 20, 2)": 0.5,
+      "(17, 20, 3)": 0.5,
+      "(18, 1, 1)": 0.5,
+      "(18, 1, 2)": 0.5,
+      "(18, 1, 3)": 0.5,
+      "(18, 2, 1)": 0.5,
+      "(18, 2, 2)": 0.5,
+      "(18, 2, 3)": 0.5,
+      "(18, 3, 1)": 0.5,
+      "(18, 3, 2)": 0.5,
+      "(18, 3, 3)": 0.5,
+      "(18, 4, 1)": 0.5,
+      "(18, 4, 2)": 0.5,
+      "(18, 4, 3)": 0.5,
+      "(18, 5, 1)": 0.5,
+      "(18, 5, 2)": 0.5,
+      "(18, 5, 3)": 0.5,
+      "(18, 6, 1)": 0.5,
+      "(18, 6, 2)": 0.5,
+      "(18, 6, 3)": 0.5,
+      "(18, 7, 1)": 0.5,
+      "(18, 7, 2)": 0.5,
+      "(18, 7, 3)": 0.5,
+      "(18, 8, 1)": 0.5,
+      "(18, 8, 2)": 0.5,
+      "(18, 8, 3)": 0.5,
+      "(18, 9, 1)": 0.5,
+      "(18, 9, 2)": 0.5,
+      "(18, 9, 3)": 0.5,
+      "(18, 10, 1)": 0.5,
+      "(18, 10, 2)": 0.5,
+      "(18, 10, 3)": 0.5,
+      "(18, 11, 1)": 0.5,
+      "(18, 11, 2)": 0.5,
+      "(18, 11, 3)": 0.5,
+      "(18, 12, 1)": 0.5,
+      "(18, 12, 2)": 0.5,
+      "(18, 12, 3)": 0.5,
+      "(18, 13, 1)": 0.5,
+      "(18, 13, 2)": 0.5,
+      "(18, 13, 3)": 0.5,
+      "(18, 14, 1)": 0.5,
+      "(18, 14, 2)": 0.5,
+      "(18, 14, 3)": 0.5,
+      "(18, 15, 1)": 0.5,
+      "(18, 15, 2)": 0.5,
+      "(18, 15, 3)": 0.5,
+      "(18, 16, 1)": 0.5,
+      "(18, 16, 2)": 0.5,
+      "(18, 16, 3)": 0.5,
+      "(18, 17, 1)": 0.5,
+      "(18, 17, 2)": 0.5,
+      "(18, 17, 3)": 0.5,
+      "(18, 18, 1)": 0.5,
+      "(18, 18, 2)": 0.5,
+      "(18, 18, 3)": 0.5,
+      "(18, 19, 1)": 0.5,
+      "(18, 19, 2)": 0.5,
+      "(18, 19, 3)": 0.5,
+      "(18, 20, 1)": 0.5,
+      "(18, 20, 2)": 0.5,
+      "(18, 20, 3)": 0.5,
+      "(19, 1, 1)": 0.5,
+      "(19, 1, 2)": 0.5,
+      "(19, 1, 3)": 0.5,
+      "(19, 2, 1)": 0.5,
+      "(19, 2, 2)": 0.5,
+      "(19, 2, 3)": 0.5,
+      "(19, 3, 1)": 0.5,
+      "(19, 3, 2)": 0.5,
+      "(19, 3, 3)": 0.5,
+      "(19, 4, 1)": 0.5,
+      "(19, 4, 2)": 0.5,
+      "(19, 4, 3)": 0.5,
+      "(19, 5, 1)": 0.5,
+      "(19, 5, 2)": 0.5,
+      "(19, 5, 3)": 0.5,
+      "(19, 6, 1)": 0.5,
+      "(19, 6, 2)": 0.5,
+      "(19, 6, 3)": 0.5,
+      "(19, 7, 1)": 0.5,
+      "(19, 7, 2)": 0.5,
+      "(19, 7, 3)": 0.5,
+      "(19, 8, 1)": 0.5,
+      "(19, 8, 2)": 0.5,
+      "(19, 8, 3)": 0.5,
+      "(19, 9, 1)": 0.5,
+      "(19, 9, 2)": 0.5,
+      "(19, 9, 3)": 0.5,
+      "(19, 10, 1)": 0.5,
+      "(19, 10, 2)": 0.5,
+      "(19, 10, 3)": 0.5,
+      "(19, 11, 1)": 0.5,
+      "(19, 11, 2)": 0.5,
+      "(19, 11, 3)": 0.5,
+      "(19, 12, 1)": 0.5,
+      "(19, 12, 2)": 0.5,
+      "(19, 12, 3)": 0.5,
+      "(19, 13, 1)": 0.5,
+      "(19, 13, 2)": 0.5,
+      "(19, 13, 3)": 0.5,
+      "(19, 14, 1)": 0.5,
+      "(19, 14, 2)": 0.5,
+      "(19, 14, 3)": 0.5,
+      "(19, 15, 1)": 0.5,
+      "(19, 15, 2)": 0.5,
+      "(19, 15, 3)": 0.5,
+      "(19, 16, 1)": 0.5,
+      "(19, 16, 2)": 0.5,
+      "(19, 16, 3)": 0.5,
+      "(19, 17, 1)": 0.5,
+      "(19, 17, 2)": 0.5,
+      "(19, 17, 3)": 0.5,
+      "(19, 18, 1)": 0.5,
+      "(19, 18, 2)": 0.5,
+      "(19, 18, 3)": 0.5,
+      "(19, 19, 1)": 0.5,
+      "(19, 19, 2)": 0.5,
+      "(19, 19, 3)": 0.5,
+      "(19, 20, 1)": 0.5,
+      "(19, 20, 2)": 0.5,
+      "(19, 20, 3)": 0.5,
+      "(20, 1, 1)": 0.5,
+      "(20, 1, 2)": 0.5,
+      "(20, 1, 3)": 0.5,
+      "(20, 2, 1)": 0.5,
+      "(20, 2, 2)": 0.5,
+      "(20, 2, 3)": 0.5,
+      "(20, 3, 1)": 0.5,
+      "(20, 3, 2)": 0.5,
+      "(20, 3, 3)": 0.5,
+      "(20, 4, 1)": 0.5,
+      "(20, 4, 2)": 0.5,
+      "(20, 4, 3)": 0.5,
+      "(20, 5, 1)": 0.5,
+      "(20, 5, 2)": 0.5,
+      "(20, 5, 3)": 0.5,
+      "(20, 6, 1)": 0.5,
+      "(20, 6, 2)": 0.5,
+      "(20, 6, 3)": 0.5,
+      "(20, 7, 1)": 0.5,
+      "(20, 7, 2)": 0.5,
+      "(20, 7, 3)": 0.5,
+      "(20, 8, 1)": 0.5,
+      "(20, 8, 2)": 0.5,
+      "(20, 8, 3)": 0.5,
+      "(20, 9, 1)": 0.5,
+      "(20, 9, 2)": 0.5,
+      "(20, 9, 3)": 0.5,
+      "(20, 10, 1)": 0.5,
+      "(20, 10, 2)": 0.5,
+      "(20, 10, 3)": 0.5,
+      "(20, 11, 1)": 0.5,
+      "(20, 11, 2)": 0.5,
+      "(20, 11, 3)": 0.5,
+      "(20, 12, 1)": 0.5,
+      "(20, 12, 2)": 0.5,
+      "(20, 12, 3)": 0.5,
+      "(20, 13, 1)": 0.5,
+      "(20, 13, 2)": 0.5,
+      "(20, 13, 3)": 0.5,
+      "(20, 14, 1)": 0.5,
+      "(20, 14, 2)": 0.5,
+      "(20, 14, 3)": 0.5,
+      "(20, 15, 1)": 0.5,
+      "(20, 15, 2)": 0.5,
+      "(20, 15, 3)": 0.5,
+      "(20, 16, 1)": 0.5,
+      "(20, 16, 2)": 0.5,
+      "(20, 16, 3)": 0.5,
+      "(20, 17, 1)": 0.5,
+      "(20, 17, 2)": 0.5,
+      "(20, 17, 3)": 0.5,
+      "(20, 18, 1)": 0.5,
+      "(20, 18, 2)": 0.5,
+      "(20, 18, 3)": 0.5,
+      "(20, 19, 1)": 0.5,
+      "(20, 19, 2)": 0.5,
+      "(20, 19, 3)": 0.5,
+      "(20, 20, 1)": 0.0,
+      "(20, 20, 2)": 0.0,
+      "(20, 20, 3)": 0.0
+    },
+    "gamma": {
+      "(1, 1)": 1.0,
+      "(1, 2)": 1.0,
+      "(1, 3)": 1.0,
+      "(2, 1)": 1.0,
+      "(2, 2)": 1.0,
+      "(2, 3)": 1.0,
+      "(3, 1)": 1.0,
+      "(3, 2)": 1.0,
+      "(3, 3)": 1.0,
+      "(4, 1)": 1.0,
+      "(4, 2)": 1.0,
+      "(4, 3)": 1.0,
+      "(5, 1)": 1.0,
+      "(5, 2)": 1.0,
+      "(5, 3)": 1.0,
+      "(6, 1)": 1.0,
+      "(6, 2)": 1.0,
+      "(6, 3)": 1.0,
+      "(7, 1)": 1.0,
+      "(7, 2)": 1.0,
+      "(7, 3)": 1.0,
+      "(8, 1)": 1.0,
+      "(8, 2)": 1.0,
+      "(8, 3)": 1.0,
+      "(9, 1)": 1.0,
+      "(9, 2)": 1.0,
+      "(9, 3)": 1.0,
+      "(10, 1)": 1.0,
+      "(10, 2)": 1.0,
+      "(10, 3)": 1.0,
+      "(11, 1)": 1.0,
+      "(11, 2)": 1.0,
+      "(11, 3)": 1.0,
+      "(12, 1)": 1.0,
+      "(12, 2)": 1.0,
+      "(12, 3)": 1.0,
+      "(13, 1)": 1.0,
+      "(13, 2)": 1.0,
+      "(13, 3)": 1.0,
+      "(14, 1)": 1.0,
+      "(14, 2)": 1.0,
+      "(14, 3)": 1.0,
+      "(15, 1)": 1.0,
+      "(15, 2)": 1.0,
+      "(15, 3)": 1.0,
+      "(16, 1)": 1.0,
+      "(16, 2)": 1.0,
+      "(16, 3)": 1.0,
+      "(17, 1)": 1.0,
+      "(17, 2)": 1.0,
+      "(17, 3)": 1.0,
+      "(18, 1)": 1.0,
+      "(18, 2)": 1.0,
+      "(18, 3)": 1.0,
+      "(19, 1)": 1.0,
+      "(19, 2)": 1.0,
+      "(19, 3)": 1.0,
+      "(20, 1)": 1.0,
+      "(20, 2)": 1.0,
+      "(20, 3)": 1.0
+    },
+    "delta": {
+      "(1, 1)": 0.5,
+      "(1, 2)": 0.5,
+      "(1, 3)": 0.5,
+      "(2, 1)": 0.5,
+      "(2, 2)": 0.5,
+      "(2, 3)": 0.5,
+      "(3, 1)": 0.5,
+      "(3, 2)": 0.5,
+      "(3, 3)": 0.5,
+      "(4, 1)": 0.5,
+      "(4, 2)": 0.5,
+      "(4, 3)": 0.5,
+      "(5, 1)": 0.5,
+      "(5, 2)": 0.5,
+      "(5, 3)": 0.5,
+      "(6, 1)": 0.5,
+      "(6, 2)": 0.5,
+      "(6, 3)": 0.5,
+      "(7, 1)": 0.5,
+      "(7, 2)": 0.5,
+      "(7, 3)": 0.5,
+      "(8, 1)": 0.5,
+      "(8, 2)": 0.5,
+      "(8, 3)": 0.5,
+      "(9, 1)": 0.5,
+      "(9, 2)": 0.5,
+      "(9, 3)": 0.5,
+      "(10, 1)": 0.5,
+      "(10, 2)": 0.5,
+      "(10, 3)": 0.5,
+      "(11, 1)": 0.5,
+      "(11, 2)": 0.5,
+      "(11, 3)": 0.5,
+      "(12, 1)": 0.5,
+      "(12, 2)": 0.5,
+      "(12, 3)": 0.5,
+      "(13, 1)": 0.5,
+      "(13, 2)": 0.5,
+      "(13, 3)": 0.5,
+      "(14, 1)": 0.5,
+      "(14, 2)": 0.5,
+      "(14, 3)": 0.5,
+      "(15, 1)": 0.5,
+      "(15, 2)": 0.5,
+      "(15, 3)": 0.5,
+      "(16, 1)": 0.5,
+      "(16, 2)": 0.5,
+      "(16, 3)": 0.5,
+      "(17, 1)": 0.5,
+      "(17, 2)": 0.5,
+      "(17, 3)": 0.5,
+      "(18, 1)": 0.5,
+      "(18, 2)": 0.5,
+      "(18, 3)": 0.5,
+      "(19, 1)": 0.5,
+      "(19, 2)": 0.5,
+      "(19, 3)": 0.5,
+      "(20, 1)": 0.5,
+      "(20, 2)": 0.5,
+      "(20, 3)": 0.5
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-15-13.347285/config.json b/test_instances/2026-06-30_15-15-13.347285/config.json
new file mode 100644
index 0000000..287c374
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/config.json
@@ -0,0 +1,50 @@
+{
+  "base_solution_folder": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb",
+  "verbose": 2,
+  "seed": 3865,
+  "max_steps": 100,
+  "min_run_time": 70,
+  "max_run_time": 80,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "MIPGap": 1e-05
+    },
+    "auction": {
+      "eta": 0.0,
+      "epsilon": 0.0001,
+      "zeta": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": true
+    },
+    "coordinator": {
+      "sorting_rule": "product"
+    },
+    "update_neighborhood": false,
+    "start_from_last_pi": false,
+    "use_detailed_pi": false
+  },
+  "checkpoint_interval": 10,
+  "max_iterations": 100,
+  "plot_interval": 100,
+  "patience": 10,
+  "sw_patience": 200,
+  "limits": {
+    "instance_type": "load_existing",
+    "Nn": {
+      "min": 20,
+      "max": 20
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_12-19-08.038762",
+    "load": {
+      "trace_type": "load_existing",
+      "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_12-19-08.038762"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-15-13.347285/graph/PLANAR b/test_instances/2026-06-30_15-15-13.347285/graph/PLANAR
new file mode 100644
index 0000000..e69de29
diff --git a/test_instances/2026-06-30_15-15-13.347285/graph/graph.png b/test_instances/2026-06-30_15-15-13.347285/graph/graph.png
new file mode 100644
index 0000000..27c9d6e
Binary files /dev/null and b/test_instances/2026-06-30_15-15-13.347285/graph/graph.png differ
diff --git a/test_instances/2026-06-30_15-15-13.347285/input_requests_traces.json b/test_instances/2026-06-30_15-15-13.347285/input_requests_traces.json
new file mode 100644
index 0000000..244b6a6
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/input_requests_traces.json
@@ -0,0 +1,6128 @@
+{
+  "0": {
+    "0": [
+      151,
+      161,
+      136,
+      155,
+      156,
+      154,
+      159,
+      153,
+      171,
+      174,
+      173,
+      172,
+      189,
+      180,
+      177,
+      167,
+      171,
+      163,
+      170,
+      162,
+      158,
+      159,
+      156,
+      164,
+      163,
+      171,
+      167,
+      159,
+      177,
+      187,
+      169,
+      176,
+      164,
+      139,
+      147,
+      170,
+      177,
+      182,
+      191,
+      206,
+      220,
+      223,
+      235,
+      236,
+      240,
+      237,
+      241,
+      247,
+      224,
+      234,
+      205,
+      202,
+      191,
+      174,
+      148,
+      134,
+      126,
+      120,
+      117,
+      91,
+      90,
+      91,
+      86,
+      92,
+      97,
+      95,
+      100,
+      98,
+      107,
+      79,
+      115,
+      107,
+      123,
+      116,
+      125,
+      124,
+      131,
+      142,
+      135,
+      145,
+      142,
+      139,
+      138,
+      143,
+      147,
+      167,
+      166,
+      158,
+      166,
+      167,
+      169,
+      181,
+      192,
+      186,
+      206,
+      200,
+      194,
+      217,
+      210,
+      169
+    ],
+    "1": [
+      151,
+      176,
+      185,
+      188,
+      193,
+      166,
+      167,
+      135,
+      123,
+      100,
+      85,
+      66,
+      63,
+      72,
+      65,
+      101,
+      118,
+      129,
+      132,
+      160,
+      154,
+      154,
+      151,
+      144,
+      122,
+      109,
+      78,
+      70,
+      51,
+      77,
+      82,
+      100,
+      135,
+      218,
+      192,
+      188,
+      164,
+      173,
+      156,
+      159,
+      154,
+      143,
+      143,
+      134,
+      132,
+      110,
+      129,
+      111,
+      118,
+      96,
+      98,
+      106,
+      92,
+      106,
+      94,
+      86,
+      82,
+      95,
+      86,
+      82,
+      87,
+      96,
+      86,
+      76,
+      86,
+      83,
+      260,
+      236,
+      220,
+      213,
+      176,
+      159,
+      128,
+      119,
+      102,
+      87,
+      80,
+      72,
+      67,
+      63,
+      65,
+      75,
+      94,
+      102,
+      119,
+      125,
+      132,
+      158,
+      160,
+      183,
+      188,
+      194,
+      195,
+      208,
+      193,
+      183,
+      179,
+      166,
+      160,
+      184
+    ],
+    "2": [
+      142,
+      149,
+      142,
+      140,
+      144,
+      158,
+      147,
+      160,
+      167,
+      168,
+      179,
+      175,
+      186,
+      173,
+      194,
+      165,
+      177,
+      164,
+      164,
+      161,
+      159,
+      155,
+      161,
+      169,
+      156,
+      165,
+      176,
+      165,
+      174,
+      177,
+      175,
+      174,
+      186,
+      149,
+      168,
+      172,
+      196,
+      195,
+      208,
+      212,
+      227,
+      225,
+      230,
+      228,
+      238,
+      242,
+      249,
+      235,
+      224,
+      208,
+      203,
+      194,
+      168,
+      160,
+      141,
+      137,
+      101,
+      107,
+      86,
+      97,
+      78,
+      94,
+      81,
+      107,
+      84,
+      106,
+      203,
+      223,
+      235,
+      241,
+      246,
+      228,
+      216,
+      176,
+      150,
+      102,
+      76,
+      80,
+      73,
+      76,
+      99,
+      131,
+      126,
+      143,
+      175,
+      179,
+      189,
+      181,
+      168,
+      154,
+      131,
+      95,
+      95,
+      79,
+      59,
+      70,
+      83,
+      106,
+      121,
+      187
+    ],
+    "3": [
+      155,
+      142,
+      149,
+      142,
+      136,
+      146,
+      145,
+      147,
+      155,
+      165,
+      156,
+      163,
+      164,
+      171,
+      172,
+      171,
+      175,
+      163,
+      171,
+      162,
+      170,
+      170,
+      157,
+      169,
+      170,
+      180,
+      189,
+      185,
+      200,
+      182,
+      192,
+      207,
+      210,
+      206,
+      202,
+      213,
+      188,
+      200,
+      190,
+      183,
+      171,
+      164,
+      151,
+      147,
+      167,
+      144,
+      159,
+      133,
+      149,
+      138,
+      130,
+      142,
+      115,
+      138,
+      131,
+      107,
+      108,
+      84,
+      108,
+      98,
+      96,
+      82,
+      93,
+      88,
+      89,
+      72,
+      95,
+      89,
+      84,
+      81,
+      68,
+      91,
+      86,
+      99,
+      105,
+      112,
+      111,
+      108,
+      134,
+      137,
+      137,
+      147,
+      168,
+      167,
+      169,
+      171,
+      180,
+      184,
+      203,
+      184,
+      191,
+      194,
+      178,
+      180,
+      184,
+      176,
+      179,
+      157,
+      144,
+      225
+    ],
+    "4": [
+      145,
+      145,
+      147,
+      143,
+      150,
+      143,
+      158,
+      154,
+      167,
+      162,
+      173,
+      176,
+      179,
+      179,
+      176,
+      177,
+      178,
+      182,
+      173,
+      172,
+      174,
+      160,
+      163,
+      163,
+      170,
+      170,
+      168,
+      178,
+      181,
+      181,
+      176,
+      164,
+      182,
+      250,
+      245,
+      230,
+      233,
+      212,
+      204,
+      198,
+      178,
+      173,
+      134,
+      137,
+      119,
+      110,
+      102,
+      90,
+      80,
+      85,
+      100,
+      93,
+      123,
+      153,
+      146,
+      162,
+      198,
+      219,
+      239,
+      249,
+      244,
+      261,
+      267,
+      252,
+      238,
+      223,
+      242,
+      242,
+      252,
+      241,
+      248,
+      235,
+      242,
+      229,
+      234,
+      225,
+      210,
+      206,
+      201,
+      186,
+      179,
+      166,
+      171,
+      145,
+      151,
+      138,
+      125,
+      115,
+      115,
+      91,
+      91,
+      90,
+      87,
+      99,
+      87,
+      83,
+      88,
+      70,
+      59,
+      194
+    ],
+    "5": [
+      145,
+      136,
+      147,
+      147,
+      145,
+      137,
+      141,
+      139,
+      150,
+      150,
+      158,
+      159,
+      161,
+      170,
+      165,
+      173,
+      160,
+      158,
+      161,
+      164,
+      165,
+      164,
+      168,
+      171,
+      168,
+      182,
+      189,
+      189,
+      208,
+      212,
+      227,
+      227,
+      215,
+      161,
+      181,
+      196,
+      206,
+      204,
+      217,
+      228,
+      224,
+      231,
+      249,
+      230,
+      220,
+      226,
+      213,
+      202,
+      181,
+      183,
+      152,
+      149,
+      164,
+      104,
+      108,
+      105,
+      88,
+      81,
+      93,
+      86,
+      99,
+      110,
+      114,
+      117,
+      126,
+      147,
+      102,
+      93,
+      99,
+      71,
+      81,
+      83,
+      77,
+      79,
+      88,
+      102,
+      105,
+      111,
+      115,
+      127,
+      141,
+      138,
+      138,
+      157,
+      159,
+      177,
+      170,
+      181,
+      182,
+      184,
+      197,
+      185,
+      184,
+      190,
+      185,
+      177,
+      177,
+      173,
+      179,
+      158
+    ],
+    "6": [
+      155,
+      141,
+      149,
+      143,
+      157,
+      158,
+      151,
+      157,
+      167,
+      165,
+      160,
+      174,
+      193,
+      177,
+      174,
+      177,
+      177,
+      168,
+      166,
+      169,
+      147,
+      146,
+      147,
+      154,
+      148,
+      148,
+      151,
+      149,
+      130,
+      143,
+      133,
+      130,
+      117,
+      115,
+      98,
+      86,
+      83,
+      85,
+      80,
+      81,
+      93,
+      84,
+      78,
+      91,
+      87,
+      105,
+      100,
+      117,
+      120,
+      142,
+      130,
+      156,
+      157,
+      187,
+      184,
+      201,
+      213,
+      206,
+      209,
+      229,
+      242,
+      227,
+      239,
+      248,
+      251,
+      246,
+      171,
+      176,
+      207,
+      216,
+      231,
+      227,
+      234,
+      248,
+      222,
+      199,
+      179,
+      150,
+      138,
+      121,
+      99,
+      77,
+      63,
+      61,
+      63,
+      75,
+      73,
+      97,
+      102,
+      122,
+      143,
+      173,
+      169,
+      184,
+      191,
+      196,
+      191,
+      194,
+      182,
+      80
+    ],
+    "7": [
+      156,
+      168,
+      152,
+      152,
+      156,
+      162,
+      143,
+      159,
+      163,
+      168,
+      184,
+      187,
+      186,
+      169,
+      177,
+      177,
+      163,
+      175,
+      161,
+      151,
+      144,
+      143,
+      149,
+      140,
+      148,
+      136,
+      122,
+      135,
+      132,
+      129,
+      138,
+      121,
+      120,
+      175,
+      156,
+      150,
+      151,
+      137,
+      103,
+      114,
+      105,
+      109,
+      110,
+      105,
+      104,
+      92,
+      80,
+      96,
+      94,
+      88,
+      84,
+      81,
+      99,
+      95,
+      103,
+      109,
+      115,
+      111,
+      96,
+      122,
+      117,
+      127,
+      126,
+      119,
+      135,
+      152,
+      125,
+      102,
+      102,
+      107,
+      82,
+      82,
+      78,
+      65,
+      77,
+      83,
+      88,
+      86,
+      85,
+      98,
+      95,
+      105,
+      113,
+      118,
+      127,
+      132,
+      147,
+      151,
+      159,
+      165,
+      170,
+      187,
+      175,
+      194,
+      202,
+      208,
+      202,
+      205,
+      206,
+      81
+    ],
+    "8": [
+      161,
+      176,
+      188,
+      184,
+      190,
+      170,
+      181,
+      162,
+      134,
+      123,
+      114,
+      103,
+      75,
+      60,
+      52,
+      57,
+      70,
+      73,
+      91,
+      114,
+      142,
+      144,
+      156,
+      165,
+      174,
+      168,
+      171,
+      167,
+      145,
+      130,
+      104,
+      94,
+      91,
+      123,
+      135,
+      160,
+      183,
+      200,
+      219,
+      217,
+      221,
+      206,
+      200,
+      169,
+      137,
+      118,
+      83,
+      96,
+      78,
+      78,
+      107,
+      131,
+      175,
+      208,
+      235,
+      246,
+      264,
+      272,
+      237,
+      227,
+      194,
+      173,
+      144,
+      110,
+      89,
+      91,
+      130,
+      147,
+      143,
+      151,
+      149,
+      159,
+      170,
+      180,
+      171,
+      181,
+      179,
+      183,
+      193,
+      179,
+      188,
+      182,
+      192,
+      186,
+      181,
+      177,
+      174,
+      185,
+      173,
+      188,
+      186,
+      186,
+      198,
+      205,
+      192,
+      189,
+      181,
+      187,
+      197,
+      219
+    ],
+    "9": [
+      151,
+      157,
+      151,
+      152,
+      157,
+      158,
+      157,
+      171,
+      171,
+      175,
+      172,
+      179,
+      183,
+      176,
+      179,
+      176,
+      171,
+      170,
+      161,
+      159,
+      148,
+      149,
+      127,
+      132,
+      141,
+      134,
+      127,
+      128,
+      133,
+      113,
+      138,
+      110,
+      98,
+      147,
+      129,
+      142,
+      123,
+      118,
+      125,
+      84,
+      97,
+      95,
+      91,
+      89,
+      80,
+      78,
+      94,
+      79,
+      88,
+      92,
+      91,
+      88,
+      99,
+      91,
+      113,
+      93,
+      110,
+      125,
+      131,
+      137,
+      156,
+      157,
+      166,
+      165,
+      170,
+      174,
+      185,
+      195,
+      196,
+      197,
+      214,
+      207,
+      218,
+      215,
+      216,
+      221,
+      211,
+      210,
+      206,
+      209,
+      198,
+      202,
+      182,
+      186,
+      179,
+      184,
+      174,
+      170,
+      175,
+      165,
+      169,
+      163,
+      156,
+      146,
+      147,
+      144,
+      135,
+      130,
+      133,
+      92
+    ],
+    "10": [
+      159,
+      177,
+      184,
+      202,
+      188,
+      181,
+      163,
+      144,
+      126,
+      101,
+      78,
+      64,
+      70,
+      67,
+      78,
+      103,
+      118,
+      133,
+      164,
+      154,
+      159,
+      157,
+      139,
+      130,
+      105,
+      97,
+      76,
+      75,
+      72,
+      79,
+      101,
+      131,
+      149,
+      165,
+      185,
+      188,
+      191,
+      187,
+      221,
+      215,
+      224,
+      231,
+      233,
+      236,
+      240,
+      231,
+      206,
+      220,
+      216,
+      176,
+      191,
+      183,
+      146,
+      126,
+      133,
+      112,
+      79,
+      102,
+      91,
+      93,
+      99,
+      109,
+      78,
+      109,
+      126,
+      119,
+      123,
+      143,
+      133,
+      131,
+      165,
+      141,
+      157,
+      169,
+      161,
+      176,
+      183,
+      176,
+      180,
+      171,
+      180,
+      190,
+      184,
+      184,
+      180,
+      177,
+      189,
+      189,
+      199,
+      182,
+      194,
+      185,
+      192,
+      191,
+      193,
+      202,
+      192,
+      198,
+      197,
+      221
+    ],
+    "11": [
+      170,
+      138,
+      155,
+      140,
+      130,
+      149,
+      145,
+      141,
+      154,
+      146,
+      158,
+      159,
+      160,
+      170,
+      170,
+      163,
+      155,
+      166,
+      160,
+      158,
+      164,
+      165,
+      164,
+      166,
+      190,
+      179,
+      191,
+      192,
+      203,
+      209,
+      215,
+      213,
+      233,
+      73,
+      100,
+      81,
+      89,
+      91,
+      97,
+      99,
+      110,
+      129,
+      140,
+      145,
+      172,
+      179,
+      193,
+      205,
+      221,
+      247,
+      244,
+      256,
+      260,
+      252,
+      263,
+      271,
+      270,
+      272,
+      256,
+      254,
+      247,
+      227,
+      227,
+      209,
+      173,
+      165,
+      201,
+      162,
+      139,
+      115,
+      84,
+      85,
+      57,
+      88,
+      94,
+      122,
+      146,
+      164,
+      183,
+      195,
+      203,
+      205,
+      179,
+      191,
+      158,
+      141,
+      110,
+      92,
+      72,
+      74,
+      62,
+      62,
+      77,
+      66,
+      102,
+      122,
+      146,
+      177,
+      189,
+      169
+    ],
+    "12": [
+      170,
+      139,
+      149,
+      151,
+      160,
+      154,
+      159,
+      167,
+      163,
+      173,
+      178,
+      175,
+      179,
+      177,
+      182,
+      178,
+      179,
+      162,
+      164,
+      151,
+      148,
+      147,
+      138,
+      140,
+      135,
+      120,
+      117,
+      126,
+      118,
+      123,
+      115,
+      119,
+      98,
+      168,
+      158,
+      158,
+      143,
+      129,
+      136,
+      127,
+      126,
+      111,
+      105,
+      91,
+      93,
+      92,
+      87,
+      87,
+      90,
+      104,
+      98,
+      90,
+      90,
+      93,
+      81,
+      102,
+      95,
+      100,
+      116,
+      113,
+      97,
+      127,
+      128,
+      120,
+      133,
+      126,
+      102,
+      110,
+      99,
+      117,
+      103,
+      117,
+      128,
+      125,
+      133,
+      136,
+      147,
+      141,
+      164,
+      156,
+      150,
+      150,
+      148,
+      150,
+      159,
+      157,
+      171,
+      170,
+      151,
+      175,
+      184,
+      184,
+      185,
+      194,
+      197,
+      202,
+      199,
+      206,
+      211,
+      92
+    ],
+    "13": [
+      145,
+      158,
+      141,
+      152,
+      146,
+      151,
+      154,
+      159,
+      162,
+      169,
+      173,
+      172,
+      179,
+      181,
+      193,
+      176,
+      166,
+      189,
+      167,
+      155,
+      158,
+      165,
+      160,
+      148,
+      155,
+      155,
+      159,
+      160,
+      166,
+      154,
+      162,
+      156,
+      152,
+      159,
+      179,
+      196,
+      209,
+      228,
+      222,
+      231,
+      221,
+      244,
+      238,
+      233,
+      222,
+      237,
+      201,
+      200,
+      186,
+      172,
+      174,
+      146,
+      132,
+      120,
+      99,
+      95,
+      99,
+      83,
+      89,
+      82,
+      112,
+      98,
+      132,
+      149,
+      138,
+      159,
+      122,
+      145,
+      149,
+      171,
+      181,
+      198,
+      192,
+      189,
+      211,
+      209,
+      220,
+      213,
+      207,
+      200,
+      196,
+      183,
+      182,
+      171,
+      154,
+      138,
+      127,
+      120,
+      99,
+      97,
+      87,
+      79,
+      69,
+      68,
+      66,
+      63,
+      65,
+      69,
+      75,
+      124
+    ],
+    "14": [
+      162,
+      144,
+      134,
+      151,
+      129,
+      134,
+      145,
+      154,
+      145,
+      152,
+      162,
+      160,
+      151,
+      166,
+      159,
+      165,
+      165,
+      165,
+      146,
+      160,
+      157,
+      157,
+      168,
+      169,
+      181,
+      181,
+      184,
+      192,
+      190,
+      207,
+      205,
+      216,
+      227,
+      92,
+      98,
+      66,
+      84,
+      75,
+      86,
+      81,
+      99,
+      109,
+      104,
+      116,
+      125,
+      136,
+      157,
+      153,
+      176,
+      184,
+      210,
+      194,
+      219,
+      237,
+      236,
+      250,
+      257,
+      256,
+      265,
+      258,
+      267,
+      246,
+      250,
+      250,
+      243,
+      242,
+      247,
+      240,
+      242,
+      249,
+      225,
+      254,
+      229,
+      226,
+      231,
+      212,
+      220,
+      197,
+      183,
+      179,
+      177,
+      161,
+      160,
+      138,
+      138,
+      127,
+      115,
+      108,
+      92,
+      97,
+      93,
+      75,
+      99,
+      79,
+      74,
+      66,
+      57,
+      55,
+      66,
+      149
+    ],
+    "15": [
+      153,
+      161,
+      152,
+      133,
+      157,
+      155,
+      164,
+      162,
+      160,
+      168,
+      177,
+      176,
+      183,
+      194,
+      183,
+      187,
+      171,
+      164,
+      156,
+      160,
+      170,
+      157,
+      153,
+      158,
+      158,
+      144,
+      167,
+      165,
+      155,
+      160,
+      163,
+      152,
+      153,
+      168,
+      137,
+      124,
+      95,
+      105,
+      77,
+      74,
+      82,
+      92,
+      131,
+      139,
+      183,
+      187,
+      210,
+      235,
+      247,
+      268,
+      258,
+      261,
+      231,
+      203,
+      193,
+      174,
+      145,
+      118,
+      87,
+      95,
+      76,
+      96,
+      99,
+      109,
+      138,
+      164,
+      137,
+      136,
+      119,
+      92,
+      98,
+      93,
+      86,
+      82,
+      63,
+      76,
+      76,
+      83,
+      73,
+      80,
+      81,
+      102,
+      105,
+      107,
+      117,
+      120,
+      146,
+      143,
+      154,
+      163,
+      167,
+      178,
+      188,
+      187,
+      198,
+      194,
+      207,
+      200,
+      197,
+      112
+    ],
+    "16": [
+      150,
+      157,
+      153,
+      149,
+      140,
+      148,
+      151,
+      147,
+      156,
+      174,
+      166,
+      175,
+      174,
+      175,
+      173,
+      171,
+      165,
+      162,
+      166,
+      160,
+      166,
+      153,
+      171,
+      164,
+      158,
+      175,
+      171,
+      173,
+      185,
+      188,
+      176,
+      185,
+      186,
+      209,
+      202,
+      187,
+      182,
+      174,
+      163,
+      159,
+      152,
+      143,
+      132,
+      134,
+      116,
+      118,
+      124,
+      117,
+      113,
+      104,
+      114,
+      97,
+      95,
+      102,
+      95,
+      100,
+      90,
+      95,
+      105,
+      80,
+      101,
+      87,
+      74,
+      88,
+      101,
+      87,
+      111,
+      138,
+      119,
+      144,
+      145,
+      145,
+      150,
+      141,
+      174,
+      166,
+      165,
+      176,
+      175,
+      179,
+      175,
+      154,
+      184,
+      169,
+      166,
+      181,
+      172,
+      179,
+      190,
+      190,
+      179,
+      192,
+      198,
+      188,
+      188,
+      203,
+      199,
+      202,
+      186,
+      213
+    ],
+    "17": [
+      153,
+      165,
+      158,
+      144,
+      139,
+      151,
+      157,
+      165,
+      168,
+      169,
+      175,
+      188,
+      179,
+      195,
+      184,
+      176,
+      172,
+      170,
+      172,
+      155,
+      145,
+      160,
+      147,
+      130,
+      137,
+      144,
+      153,
+      146,
+      147,
+      143,
+      138,
+      137,
+      125,
+      84,
+      88,
+      79,
+      76,
+      78,
+      80,
+      96,
+      78,
+      86,
+      96,
+      115,
+      112,
+      140,
+      147,
+      158,
+      153,
+      167,
+      191,
+      196,
+      216,
+      221,
+      229,
+      238,
+      266,
+      251,
+      261,
+      256,
+      267,
+      263,
+      252,
+      240,
+      253,
+      234,
+      198,
+      193,
+      205,
+      208,
+      217,
+      203,
+      223,
+      239,
+      211,
+      218,
+      213,
+      226,
+      210,
+      217,
+      196,
+      201,
+      192,
+      199,
+      186,
+      178,
+      180,
+      163,
+      180,
+      163,
+      163,
+      161,
+      153,
+      150,
+      140,
+      140,
+      146,
+      131,
+      121,
+      71
+    ],
+    "18": [
+      158,
+      145,
+      155,
+      153,
+      140,
+      142,
+      139,
+      155,
+      157,
+      166,
+      172,
+      181,
+      171,
+      179,
+      180,
+      182,
+      180,
+      170,
+      172,
+      165,
+      157,
+      160,
+      166,
+      162,
+      160,
+      168,
+      171,
+      172,
+      177,
+      177,
+      169,
+      180,
+      174,
+      235,
+      227,
+      235,
+      234,
+      237,
+      230,
+      224,
+      192,
+      190,
+      183,
+      193,
+      162,
+      146,
+      128,
+      121,
+      111,
+      101,
+      84,
+      84,
+      76,
+      79,
+      95,
+      107,
+      126,
+      141,
+      170,
+      185,
+      194,
+      196,
+      232,
+      250,
+      234,
+      239,
+      157,
+      150,
+      164,
+      164,
+      168,
+      165,
+      173,
+      170,
+      177,
+      179,
+      192,
+      188,
+      193,
+      192,
+      198,
+      197,
+      186,
+      187,
+      181,
+      179,
+      185,
+      185,
+      183,
+      189,
+      184,
+      186,
+      175,
+      180,
+      176,
+      187,
+      181,
+      182,
+      179,
+      165
+    ],
+    "19": [
+      167,
+      164,
+      173,
+      179,
+      188,
+      182,
+      177,
+      171,
+      143,
+      128,
+      108,
+      95,
+      74,
+      67,
+      68,
+      57,
+      68,
+      74,
+      83,
+      106,
+      111,
+      136,
+      158,
+      163,
+      162,
+      174,
+      173,
+      172,
+      156,
+      130,
+      121,
+      109,
+      84,
+      63,
+      74,
+      81,
+      92,
+      89,
+      97,
+      113,
+      123,
+      112,
+      118,
+      135,
+      150,
+      169,
+      196,
+      198,
+      231,
+      234,
+      237,
+      250,
+      253,
+      252,
+      273,
+      271,
+      266,
+      263,
+      258,
+      267,
+      238,
+      234,
+      224,
+      202,
+      195,
+      175,
+      88,
+      83,
+      85,
+      112,
+      105,
+      120,
+      133,
+      145,
+      153,
+      169,
+      168,
+      186,
+      186,
+      189,
+      203,
+      197,
+      195,
+      196,
+      190,
+      176,
+      176,
+      173,
+      177,
+      167,
+      150,
+      149,
+      136,
+      126,
+      119,
+      97,
+      97,
+      76,
+      85,
+      194
+    ]
+  },
+  "1": {
+    "0": [
+      46,
+      46,
+      47,
+      43,
+      43,
+      41,
+      41,
+      42,
+      41,
+      47,
+      46,
+      48,
+      48,
+      49,
+      51,
+      52,
+      54,
+      54,
+      56,
+      56,
+      58,
+      57,
+      58,
+      61,
+      62,
+      64,
+      65,
+      71,
+      65,
+      67,
+      67,
+      60,
+      64,
+      60,
+      61,
+      57,
+      60,
+      63,
+      60,
+      54,
+      60,
+      58,
+      60,
+      59,
+      61,
+      54,
+      60,
+      58,
+      53,
+      55,
+      53,
+      51,
+      48,
+      51,
+      48,
+      43,
+      46,
+      42,
+      39,
+      39,
+      35,
+      37,
+      32,
+      28,
+      35,
+      31,
+      22,
+      26,
+      25,
+      25,
+      25,
+      26,
+      27,
+      26,
+      28,
+      29,
+      30,
+      29,
+      32,
+      33,
+      32,
+      40,
+      44,
+      45,
+      46,
+      47,
+      51,
+      51,
+      54,
+      53,
+      54,
+      59,
+      62,
+      62,
+      62,
+      62,
+      63,
+      70,
+      66,
+      38
+    ],
+    "1": [
+      49,
+      43,
+      44,
+      43,
+      44,
+      42,
+      44,
+      39,
+      45,
+      49,
+      48,
+      46,
+      52,
+      55,
+      53,
+      52,
+      57,
+      53,
+      54,
+      55,
+      54,
+      59,
+      57,
+      63,
+      58,
+      66,
+      64,
+      61,
+      64,
+      63,
+      62,
+      59,
+      57,
+      49,
+      51,
+      50,
+      49,
+      47,
+      47,
+      44,
+      41,
+      41,
+      41,
+      41,
+      36,
+      35,
+      39,
+      37,
+      40,
+      32,
+      35,
+      38,
+      37,
+      23,
+      30,
+      31,
+      26,
+      32,
+      27,
+      30,
+      26,
+      27,
+      33,
+      32,
+      29,
+      30,
+      25,
+      23,
+      21,
+      24,
+      22,
+      26,
+      24,
+      23,
+      24,
+      22,
+      26,
+      28,
+      29,
+      28,
+      32,
+      33,
+      37,
+      36,
+      36,
+      42,
+      40,
+      42,
+      46,
+      45,
+      46,
+      50,
+      54,
+      49,
+      62,
+      59,
+      60,
+      58,
+      60,
+      60
+    ],
+    "2": [
+      46,
+      44,
+      48,
+      46,
+      42,
+      44,
+      44,
+      46,
+      50,
+      50,
+      53,
+      50,
+      56,
+      56,
+      55,
+      55,
+      54,
+      56,
+      56,
+      53,
+      58,
+      55,
+      56,
+      54,
+      53,
+      52,
+      54,
+      48,
+      48,
+      48,
+      45,
+      43,
+      39,
+      31,
+      30,
+      39,
+      40,
+      48,
+      53,
+      55,
+      63,
+      68,
+      75,
+      74,
+      78,
+      79,
+      81,
+      83,
+      81,
+      74,
+      77,
+      71,
+      73,
+      67,
+      61,
+      58,
+      54,
+      54,
+      44,
+      43,
+      35,
+      33,
+      27,
+      30,
+      31,
+      30,
+      69,
+      70,
+      73,
+      64,
+      60,
+      59,
+      58,
+      60,
+      55,
+      50,
+      49,
+      42,
+      45,
+      39,
+      38,
+      36,
+      31,
+      32,
+      24,
+      28,
+      27,
+      26,
+      21,
+      24,
+      28,
+      22,
+      25,
+      30,
+      32,
+      35,
+      31,
+      34,
+      44,
+      25
+    ],
+    "3": [
+      42,
+      44,
+      42,
+      45,
+      43,
+      45,
+      42,
+      44,
+      42,
+      47,
+      47,
+      48,
+      50,
+      51,
+      52,
+      53,
+      54,
+      55,
+      53,
+      56,
+      59,
+      57,
+      60,
+      62,
+      62,
+      64,
+      62,
+      65,
+      71,
+      66,
+      60,
+      63,
+      60,
+      51,
+      47,
+      49,
+      48,
+      47,
+      44,
+      45,
+      42,
+      41,
+      41,
+      39,
+      39,
+      38,
+      39,
+      36,
+      34,
+      36,
+      33,
+      33,
+      29,
+      35,
+      32,
+      29,
+      26,
+      28,
+      31,
+      29,
+      36,
+      29,
+      27,
+      32,
+      38,
+      35,
+      28,
+      27,
+      29,
+      35,
+      37,
+      39,
+      41,
+      49,
+      55,
+      55,
+      58,
+      61,
+      63,
+      68,
+      69,
+      72,
+      70,
+      67,
+      71,
+      66,
+      66,
+      64,
+      65,
+      59,
+      55,
+      51,
+      44,
+      37,
+      37,
+      29,
+      29,
+      29,
+      23,
+      54
+    ],
+    "4": [
+      47,
+      45,
+      43,
+      43,
+      43,
+      42,
+      40,
+      45,
+      46,
+      47,
+      48,
+      52,
+      49,
+      51,
+      51,
+      51,
+      56,
+      56,
+      56,
+      54,
+      57,
+      60,
+      59,
+      59,
+      63,
+      62,
+      62,
+      64,
+      66,
+      64,
+      61,
+      56,
+      58,
+      42,
+      39,
+      41,
+      36,
+      33,
+      31,
+      33,
+      31,
+      30,
+      25,
+      28,
+      24,
+      26,
+      26,
+      28,
+      24,
+      29,
+      28,
+      30,
+      31,
+      29,
+      33,
+      39,
+      37,
+      39,
+      45,
+      42,
+      45,
+      50,
+      55,
+      54,
+      53,
+      57,
+      58,
+      65,
+      62,
+      68,
+      69,
+      66,
+      67,
+      67,
+      68,
+      74,
+      69,
+      67,
+      69,
+      69,
+      71,
+      67,
+      67,
+      66,
+      64,
+      63,
+      63,
+      56,
+      56,
+      53,
+      57,
+      51,
+      45,
+      44,
+      40,
+      39,
+      38,
+      34,
+      34,
+      58
+    ],
+    "5": [
+      48,
+      48,
+      51,
+      52,
+      53,
+      54,
+      54,
+      51,
+      51,
+      49,
+      45,
+      39,
+      34,
+      31,
+      29,
+      24,
+      17,
+      20,
+      20,
+      22,
+      21,
+      24,
+      33,
+      35,
+      45,
+      50,
+      54,
+      60,
+      64,
+      68,
+      68,
+      67,
+      63,
+      20,
+      22,
+      17,
+      19,
+      19,
+      30,
+      26,
+      34,
+      34,
+      38,
+      45,
+      48,
+      54,
+      57,
+      64,
+      71,
+      74,
+      77,
+      82,
+      80,
+      86,
+      85,
+      90,
+      93,
+      86,
+      84,
+      83,
+      84,
+      79,
+      77,
+      74,
+      69,
+      62,
+      59,
+      57,
+      50,
+      46,
+      41,
+      38,
+      38,
+      33,
+      33,
+      26,
+      24,
+      22,
+      24,
+      25,
+      24,
+      25,
+      22,
+      23,
+      27,
+      28,
+      32,
+      32,
+      35,
+      38,
+      44,
+      42,
+      49,
+      54,
+      56,
+      61,
+      60,
+      63,
+      71,
+      61
+    ],
+    "6": [
+      50,
+      52,
+      59,
+      57,
+      56,
+      52,
+      48,
+      43,
+      33,
+      26,
+      18,
+      17,
+      16,
+      19,
+      26,
+      30,
+      38,
+      49,
+      49,
+      53,
+      56,
+      56,
+      50,
+      43,
+      37,
+      32,
+      26,
+      23,
+      20,
+      22,
+      30,
+      40,
+      49,
+      50,
+      51,
+      50,
+      53,
+      47,
+      45,
+      46,
+      49,
+      48,
+      42,
+      42,
+      42,
+      39,
+      40,
+      41,
+      41,
+      36,
+      38,
+      35,
+      38,
+      33,
+      27,
+      28,
+      34,
+      32,
+      32,
+      31,
+      26,
+      27,
+      30,
+      28,
+      29,
+      31,
+      72,
+      68,
+      72,
+      66,
+      63,
+      65,
+      61,
+      61,
+      58,
+      53,
+      49,
+      49,
+      39,
+      40,
+      39,
+      35,
+      38,
+      30,
+      31,
+      27,
+      31,
+      27,
+      27,
+      24,
+      21,
+      20,
+      30,
+      25,
+      30,
+      31,
+      30,
+      28,
+      35,
+      60
+    ],
+    "7": [
+      46,
+      47,
+      48,
+      47,
+      49,
+      46,
+      47,
+      48,
+      52,
+      52,
+      54,
+      54,
+      55,
+      53,
+      54,
+      53,
+      52,
+      47,
+      45,
+      45,
+      37,
+      39,
+      40,
+      36,
+      35,
+      31,
+      33,
+      28,
+      27,
+      25,
+      26,
+      28,
+      22,
+      23,
+      23,
+      20,
+      23,
+      22,
+      25,
+      27,
+      26,
+      27,
+      32,
+      37,
+      38,
+      43,
+      53,
+      63,
+      58,
+      63,
+      71,
+      71,
+      76,
+      85,
+      83,
+      79,
+      85,
+      90,
+      90,
+      85,
+      88,
+      87,
+      87,
+      83,
+      81,
+      77,
+      59,
+      64,
+      67,
+      72,
+      67,
+      65,
+      67,
+      59,
+      56,
+      47,
+      34,
+      34,
+      27,
+      27,
+      26,
+      23,
+      25,
+      27,
+      41,
+      43,
+      51,
+      57,
+      65,
+      73,
+      75,
+      76,
+      73,
+      68,
+      64,
+      61,
+      52,
+      43,
+      32,
+      57
+    ],
+    "8": [
+      47,
+      56,
+      57,
+      53,
+      56,
+      51,
+      50,
+      41,
+      35,
+      26,
+      20,
+      19,
+      18,
+      18,
+      29,
+      29,
+      38,
+      44,
+      51,
+      55,
+      56,
+      61,
+      51,
+      46,
+      34,
+      37,
+      24,
+      21,
+      21,
+      23,
+      28,
+      39,
+      47,
+      45,
+      42,
+      43,
+      41,
+      41,
+      38,
+      36,
+      37,
+      31,
+      37,
+      36,
+      39,
+      31,
+      35,
+      33,
+      29,
+      26,
+      29,
+      33,
+      24,
+      27,
+      28,
+      27,
+      28,
+      27,
+      30,
+      34,
+      31,
+      33,
+      31,
+      39,
+      37,
+      49,
+      51,
+      47,
+      39,
+      37,
+      31,
+      30,
+      27,
+      21,
+      24,
+      27,
+      27,
+      33,
+      37,
+      34,
+      42,
+      52,
+      51,
+      58,
+      63,
+      70,
+      71,
+      76,
+      73,
+      74,
+      71,
+      65,
+      61,
+      56,
+      43,
+      40,
+      37,
+      35,
+      25,
+      59
+    ],
+    "9": [
+      46,
+      46,
+      42,
+      40,
+      42,
+      42,
+      43,
+      42,
+      43,
+      44,
+      46,
+      50,
+      51,
+      54,
+      52,
+      54,
+      54,
+      58,
+      54,
+      55,
+      60,
+      57,
+      63,
+      63,
+      63,
+      61,
+      58,
+      68,
+      61,
+      66,
+      64,
+      64,
+      59,
+      55,
+      54,
+      55,
+      54,
+      53,
+      54,
+      52,
+      51,
+      45,
+      51,
+      56,
+      48,
+      47,
+      44,
+      42,
+      46,
+      40,
+      44,
+      39,
+      33,
+      39,
+      38,
+      34,
+      36,
+      28,
+      26,
+      30,
+      28,
+      31,
+      24,
+      27,
+      25,
+      27,
+      30,
+      32,
+      35,
+      42,
+      49,
+      46,
+      55,
+      58,
+      60,
+      61,
+      66,
+      64,
+      70,
+      68,
+      67,
+      65,
+      69,
+      65,
+      65,
+      59,
+      54,
+      51,
+      49,
+      48,
+      45,
+      37,
+      33,
+      29,
+      28,
+      28,
+      27,
+      26,
+      25,
+      47
+    ],
+    "10": [
+      47,
+      44,
+      44,
+      45,
+      47,
+      47,
+      48,
+      49,
+      50,
+      51,
+      53,
+      52,
+      56,
+      55,
+      55,
+      53,
+      54,
+      52,
+      52,
+      49,
+      46,
+      45,
+      42,
+      44,
+      45,
+      40,
+      40,
+      34,
+      33,
+      31,
+      32,
+      28,
+      24,
+      23,
+      23,
+      17,
+      21,
+      23,
+      25,
+      29,
+      29,
+      34,
+      36,
+      40,
+      44,
+      46,
+      51,
+      55,
+      64,
+      65,
+      69,
+      69,
+      79,
+      80,
+      81,
+      82,
+      89,
+      87,
+      85,
+      85,
+      87,
+      77,
+      84,
+      78,
+      79,
+      75,
+      39,
+      41,
+      47,
+      52,
+      63,
+      62,
+      68,
+      71,
+      72,
+      71,
+      67,
+      60,
+      56,
+      49,
+      41,
+      39,
+      38,
+      27,
+      25,
+      19,
+      25,
+      29,
+      31,
+      37,
+      50,
+      55,
+      57,
+      70,
+      70,
+      72,
+      74,
+      79,
+      74,
+      47
+    ],
+    "11": [
+      50,
+      47,
+      46,
+      47,
+      46,
+      48,
+      49,
+      50,
+      50,
+      52,
+      55,
+      55,
+      55,
+      53,
+      57,
+      54,
+      53,
+      53,
+      52,
+      49,
+      47,
+      41,
+      41,
+      42,
+      35,
+      38,
+      35,
+      30,
+      30,
+      28,
+      25,
+      23,
+      24,
+      33,
+      29,
+      28,
+      25,
+      27,
+      22,
+      23,
+      24,
+      28,
+      25,
+      22,
+      27,
+      28,
+      33,
+      31,
+      34,
+      36,
+      38,
+      46,
+      48,
+      43,
+      55,
+      54,
+      54,
+      59,
+      62,
+      68,
+      68,
+      68,
+      75,
+      77,
+      82,
+      80,
+      25,
+      21,
+      25,
+      22,
+      23,
+      27,
+      25,
+      26,
+      23,
+      27,
+      27,
+      33,
+      30,
+      34,
+      34,
+      35,
+      39,
+      42,
+      40,
+      45,
+      48,
+      47,
+      51,
+      54,
+      52,
+      56,
+      62,
+      64,
+      63,
+      65,
+      67,
+      65,
+      69,
+      61
+    ],
+    "12": [
+      47,
+      44,
+      42,
+      38,
+      40,
+      43,
+      41,
+      42,
+      42,
+      45,
+      48,
+      51,
+      51,
+      51,
+      52,
+      55,
+      54,
+      56,
+      51,
+      53,
+      57,
+      56,
+      59,
+      58,
+      64,
+      59,
+      62,
+      64,
+      67,
+      66,
+      66,
+      63,
+      63,
+      59,
+      58,
+      60,
+      58,
+      60,
+      54,
+      61,
+      54,
+      60,
+      53,
+      54,
+      57,
+      60,
+      56,
+      53,
+      53,
+      55,
+      51,
+      47,
+      47,
+      46,
+      49,
+      47,
+      40,
+      39,
+      33,
+      37,
+      35,
+      36,
+      35,
+      29,
+      32,
+      29,
+      40,
+      48,
+      47,
+      52,
+      47,
+      52,
+      50,
+      54,
+      57,
+      59,
+      57,
+      62,
+      68,
+      68,
+      64,
+      68,
+      68,
+      69,
+      70,
+      73,
+      70,
+      76,
+      71,
+      75,
+      75,
+      73,
+      73,
+      69,
+      66,
+      70,
+      59,
+      63,
+      60,
+      46
+    ],
+    "13": [
+      45,
+      51,
+      49,
+      51,
+      53,
+      57,
+      52,
+      56,
+      53,
+      48,
+      49,
+      46,
+      40,
+      36,
+      32,
+      27,
+      23,
+      20,
+      18,
+      20,
+      19,
+      20,
+      23,
+      31,
+      32,
+      37,
+      46,
+      51,
+      55,
+      59,
+      61,
+      68,
+      64,
+      59,
+      67,
+      67,
+      66,
+      66,
+      65,
+      66,
+      58,
+      58,
+      51,
+      48,
+      42,
+      43,
+      35,
+      33,
+      27,
+      31,
+      26,
+      34,
+      35,
+      38,
+      36,
+      46,
+      51,
+      65,
+      63,
+      71,
+      76,
+      75,
+      80,
+      87,
+      79,
+      82,
+      63,
+      62,
+      67,
+      63,
+      70,
+      71,
+      66,
+      69,
+      67,
+      69,
+      70,
+      68,
+      70,
+      65,
+      63,
+      62,
+      58,
+      61,
+      57,
+      60,
+      56,
+      57,
+      55,
+      50,
+      41,
+      47,
+      43,
+      39,
+      42,
+      31,
+      36,
+      31,
+      27,
+      25
+    ],
+    "14": [
+      50,
+      47,
+      49,
+      47,
+      45,
+      44,
+      50,
+      50,
+      52,
+      51,
+      49,
+      55,
+      56,
+      56,
+      54,
+      51,
+      56,
+      47,
+      51,
+      49,
+      50,
+      46,
+      44,
+      42,
+      40,
+      41,
+      38,
+      35,
+      33,
+      30,
+      28,
+      28,
+      23,
+      58,
+      59,
+      60,
+      59,
+      58,
+      57,
+      61,
+      61,
+      60,
+      58,
+      60,
+      61,
+      63,
+      56,
+      58,
+      61,
+      57,
+      58,
+      54,
+      52,
+      53,
+      56,
+      50,
+      48,
+      45,
+      42,
+      36,
+      41,
+      41,
+      37,
+      33,
+      35,
+      36,
+      33,
+      35,
+      44,
+      51,
+      49,
+      54,
+      60,
+      62,
+      59,
+      65,
+      73,
+      70,
+      68,
+      65,
+      66,
+      63,
+      61,
+      58,
+      57,
+      50,
+      48,
+      41,
+      38,
+      32,
+      31,
+      32,
+      25,
+      26,
+      22,
+      19,
+      27,
+      26,
+      26,
+      44
+    ],
+    "15": [
+      46,
+      52,
+      48,
+      51,
+      51,
+      52,
+      54,
+      53,
+      52,
+      50,
+      50,
+      48,
+      42,
+      41,
+      33,
+      35,
+      27,
+      24,
+      22,
+      18,
+      19,
+      18,
+      20,
+      20,
+      22,
+      30,
+      34,
+      38,
+      44,
+      47,
+      51,
+      55,
+      63,
+      59,
+      61,
+      61,
+      61,
+      58,
+      63,
+      61,
+      60,
+      61,
+      59,
+      56,
+      56,
+      60,
+      59,
+      53,
+      57,
+      56,
+      57,
+      58,
+      54,
+      53,
+      45,
+      45,
+      40,
+      38,
+      45,
+      37,
+      35,
+      35,
+      36,
+      33,
+      30,
+      27,
+      54,
+      58,
+      54,
+      60,
+      66,
+      66,
+      66,
+      69,
+      68,
+      70,
+      73,
+      71,
+      73,
+      72,
+      73,
+      70,
+      69,
+      69,
+      72,
+      70,
+      68,
+      66,
+      64,
+      64,
+      62,
+      56,
+      54,
+      51,
+      52,
+      51,
+      43,
+      37,
+      38,
+      38
+    ],
+    "16": [
+      43,
+      46,
+      42,
+      45,
+      43,
+      47,
+      41,
+      49,
+      42,
+      46,
+      51,
+      48,
+      49,
+      53,
+      53,
+      55,
+      55,
+      52,
+      52,
+      57,
+      57,
+      58,
+      58,
+      60,
+      63,
+      60,
+      64,
+      70,
+      61,
+      62,
+      60,
+      57,
+      59,
+      53,
+      50,
+      53,
+      49,
+      50,
+      53,
+      48,
+      48,
+      46,
+      51,
+      45,
+      50,
+      41,
+      39,
+      41,
+      44,
+      45,
+      36,
+      37,
+      39,
+      33,
+      33,
+      36,
+      31,
+      33,
+      33,
+      30,
+      26,
+      23,
+      25,
+      29,
+      31,
+      31,
+      54,
+      49,
+      39,
+      30,
+      25,
+      23,
+      21,
+      24,
+      29,
+      36,
+      41,
+      51,
+      59,
+      67,
+      71,
+      69,
+      70,
+      69,
+      67,
+      55,
+      46,
+      41,
+      34,
+      27,
+      24,
+      25,
+      25,
+      34,
+      37,
+      42,
+      53,
+      60,
+      68,
+      59
+    ],
+    "17": [
+      51,
+      48,
+      45,
+      44,
+      48,
+      49,
+      50,
+      48,
+      51,
+      51,
+      53,
+      50,
+      52,
+      53,
+      51,
+      54,
+      52,
+      52,
+      51,
+      50,
+      42,
+      49,
+      44,
+      43,
+      44,
+      39,
+      39,
+      34,
+      34,
+      33,
+      29,
+      23,
+      28,
+      56,
+      63,
+      65,
+      67,
+      65,
+      68,
+      64,
+      65,
+      60,
+      58,
+      57,
+      45,
+      45,
+      38,
+      38,
+      30,
+      31,
+      29,
+      24,
+      30,
+      29,
+      35,
+      40,
+      46,
+      48,
+      56,
+      64,
+      70,
+      76,
+      74,
+      81,
+      78,
+      83,
+      28,
+      27,
+      27,
+      22,
+      25,
+      24,
+      22,
+      22,
+      21,
+      25,
+      22,
+      25,
+      25,
+      24,
+      29,
+      29,
+      34,
+      34,
+      29,
+      35,
+      31,
+      41,
+      38,
+      41,
+      44,
+      46,
+      47,
+      45,
+      48,
+      51,
+      53,
+      54,
+      52,
+      41
+    ],
+    "18": [
+      47,
+      45,
+      49,
+      55,
+      50,
+      50,
+      49,
+      53,
+      55,
+      54,
+      55,
+      52,
+      52,
+      47,
+      48,
+      44,
+      42,
+      37,
+      38,
+      33,
+      32,
+      25,
+      23,
+      22,
+      25,
+      22,
+      18,
+      19,
+      23,
+      22,
+      27,
+      28,
+      36,
+      51,
+      51,
+      47,
+      50,
+      49,
+      44,
+      47,
+      48,
+      45,
+      42,
+      36,
+      41,
+      43,
+      40,
+      32,
+      33,
+      36,
+      32,
+      30,
+      33,
+      32,
+      30,
+      30,
+      27,
+      27,
+      26,
+      27,
+      26,
+      34,
+      31,
+      27,
+      31,
+      36,
+      71,
+      70,
+      68,
+      62,
+      62,
+      64,
+      60,
+      53,
+      54,
+      49,
+      46,
+      43,
+      38,
+      39,
+      34,
+      30,
+      28,
+      32,
+      27,
+      29,
+      27,
+      23,
+      23,
+      23,
+      22,
+      22,
+      22,
+      27,
+      29,
+      32,
+      31,
+      36,
+      39,
+      24
+    ],
+    "19": [
+      45,
+      44,
+      44,
+      45,
+      44,
+      43,
+      49,
+      47,
+      50,
+      52,
+      51,
+      58,
+      55,
+      57,
+      52,
+      56,
+      48,
+      56,
+      57,
+      57,
+      52,
+      54,
+      56,
+      54,
+      57,
+      55,
+      60,
+      54,
+      51,
+      47,
+      47,
+      43,
+      37,
+      61,
+      55,
+      60,
+      58,
+      61,
+      62,
+      60,
+      58,
+      60,
+      61,
+      61,
+      61,
+      62,
+      55,
+      60,
+      59,
+      59,
+      58,
+      55,
+      54,
+      55,
+      55,
+      51,
+      47,
+      41,
+      44,
+      36,
+      39,
+      40,
+      36,
+      36,
+      34,
+      30,
+      57,
+      50,
+      46,
+      43,
+      45,
+      35,
+      36,
+      31,
+      28,
+      23,
+      28,
+      26,
+      18,
+      24,
+      24,
+      23,
+      20,
+      27,
+      27,
+      29,
+      35,
+      35,
+      42,
+      44,
+      45,
+      52,
+      52,
+      59,
+      57,
+      63,
+      65,
+      67,
+      69,
+      34
+    ]
+  },
+  "2": {
+    "0": [
+      114,
+      112,
+      109,
+      104,
+      109,
+      110,
+      110,
+      107,
+      99,
+      114,
+      111,
+      113,
+      126,
+      119,
+      128,
+      131,
+      129,
+      134,
+      138,
+      139,
+      144,
+      136,
+      162,
+      154,
+      167,
+      165,
+      172,
+      164,
+      179,
+      171,
+      172,
+      165,
+      169,
+      123,
+      121,
+      99,
+      79,
+      63,
+      76,
+      62,
+      58,
+      56,
+      58,
+      78,
+      90,
+      119,
+      120,
+      161,
+      166,
+      191,
+      197,
+      222,
+      221,
+      219,
+      208,
+      197,
+      183,
+      148,
+      139,
+      116,
+      91,
+      90,
+      71,
+      55,
+      82,
+      81,
+      87,
+      95,
+      90,
+      102,
+      111,
+      117,
+      113,
+      115,
+      136,
+      123,
+      125,
+      130,
+      149,
+      150,
+      146,
+      149,
+      172,
+      172,
+      176,
+      179,
+      170,
+      185,
+      174,
+      178,
+      176,
+      164,
+      163,
+      157,
+      153,
+      150,
+      140,
+      141,
+      143,
+      154
+    ],
+    "1": [
+      118,
+      122,
+      129,
+      119,
+      121,
+      125,
+      129,
+      126,
+      121,
+      126,
+      133,
+      128,
+      126,
+      127,
+      131,
+      123,
+      124,
+      119,
+      109,
+      107,
+      97,
+      96,
+      97,
+      86,
+      84,
+      80,
+      68,
+      67,
+      53,
+      70,
+      45,
+      36,
+      62,
+      141,
+      131,
+      127,
+      116,
+      118,
+      118,
+      108,
+      104,
+      110,
+      116,
+      107,
+      98,
+      90,
+      104,
+      93,
+      94,
+      82,
+      85,
+      69,
+      84,
+      78,
+      86,
+      80,
+      82,
+      72,
+      74,
+      98,
+      76,
+      83,
+      71,
+      76,
+      87,
+      72,
+      66,
+      72,
+      80,
+      73,
+      67,
+      77,
+      84,
+      83,
+      84,
+      107,
+      91,
+      103,
+      114,
+      99,
+      107,
+      107,
+      124,
+      139,
+      132,
+      135,
+      132,
+      147,
+      150,
+      148,
+      148,
+      144,
+      142,
+      137,
+      136,
+      137,
+      145,
+      141,
+      145,
+      139
+    ],
+    "2": [
+      115,
+      122,
+      110,
+      121,
+      118,
+      115,
+      127,
+      128,
+      127,
+      127,
+      127,
+      130,
+      128,
+      130,
+      125,
+      123,
+      116,
+      117,
+      109,
+      103,
+      102,
+      92,
+      95,
+      87,
+      85,
+      69,
+      68,
+      75,
+      57,
+      51,
+      58,
+      56,
+      61,
+      102,
+      95,
+      82,
+      77,
+      79,
+      76,
+      67,
+      54,
+      72,
+      58,
+      65,
+      63,
+      54,
+      60,
+      56,
+      74,
+      71,
+      81,
+      72,
+      93,
+      92,
+      92,
+      109,
+      111,
+      123,
+      128,
+      124,
+      146,
+      149,
+      157,
+      161,
+      161,
+      162,
+      76,
+      90,
+      91,
+      99,
+      104,
+      114,
+      113,
+      119,
+      125,
+      119,
+      139,
+      135,
+      135,
+      135,
+      154,
+      154,
+      162,
+      162,
+      170,
+      164,
+      171,
+      168,
+      179,
+      167,
+      164,
+      165,
+      159,
+      166,
+      153,
+      155,
+      147,
+      153,
+      148,
+      133
+    ],
+    "3": [
+      112,
+      122,
+      132,
+      133,
+      138,
+      127,
+      131,
+      122,
+      127,
+      115,
+      103,
+      98,
+      90,
+      84,
+      76,
+      74,
+      56,
+      52,
+      55,
+      48,
+      49,
+      51,
+      70,
+      80,
+      88,
+      111,
+      133,
+      150,
+      168,
+      164,
+      174,
+      183,
+      176,
+      93,
+      110,
+      119,
+      127,
+      140,
+      152,
+      150,
+      172,
+      171,
+      180,
+      179,
+      176,
+      185,
+      180,
+      161,
+      178,
+      170,
+      150,
+      142,
+      128,
+      113,
+      119,
+      106,
+      111,
+      84,
+      83,
+      82,
+      74,
+      88,
+      74,
+      86,
+      85,
+      112,
+      129,
+      134,
+      107,
+      98,
+      100,
+      81,
+      80,
+      74,
+      78,
+      59,
+      60,
+      68,
+      61,
+      59,
+      60,
+      78,
+      77,
+      87,
+      90,
+      114,
+      113,
+      107,
+      110,
+      127,
+      129,
+      145,
+      146,
+      134,
+      140,
+      140,
+      138,
+      148,
+      144,
+      86
+    ],
+    "4": [
+      108,
+      121,
+      120,
+      119,
+      119,
+      125,
+      131,
+      130,
+      135,
+      132,
+      134,
+      130,
+      126,
+      118,
+      119,
+      107,
+      107,
+      101,
+      91,
+      90,
+      83,
+      81,
+      71,
+      60,
+      68,
+      59,
+      55,
+      54,
+      55,
+      61,
+      81,
+      78,
+      84,
+      74,
+      75,
+      63,
+      65,
+      62,
+      46,
+      55,
+      53,
+      44,
+      52,
+      63,
+      57,
+      71,
+      79,
+      76,
+      78,
+      89,
+      99,
+      114,
+      112,
+      131,
+      140,
+      143,
+      149,
+      176,
+      172,
+      188,
+      192,
+      186,
+      193,
+      200,
+      189,
+      188,
+      90,
+      92,
+      100,
+      120,
+      111,
+      114,
+      132,
+      129,
+      144,
+      139,
+      150,
+      147,
+      146,
+      154,
+      160,
+      166,
+      162,
+      172,
+      183,
+      180,
+      182,
+      196,
+      176,
+      172,
+      173,
+      165,
+      158,
+      149,
+      157,
+      156,
+      140,
+      141,
+      140,
+      51
+    ],
+    "5": [
+      122,
+      124,
+      114,
+      125,
+      119,
+      119,
+      127,
+      122,
+      129,
+      127,
+      125,
+      126,
+      136,
+      121,
+      111,
+      116,
+      106,
+      108,
+      95,
+      89,
+      77,
+      71,
+      70,
+      64,
+      60,
+      57,
+      57,
+      49,
+      55,
+      56,
+      70,
+      72,
+      73,
+      127,
+      102,
+      106,
+      106,
+      97,
+      90,
+      84,
+      91,
+      72,
+      71,
+      73,
+      77,
+      73,
+      76,
+      75,
+      64,
+      71,
+      73,
+      71,
+      70,
+      72,
+      70,
+      77,
+      79,
+      70,
+      79,
+      99,
+      96,
+      103,
+      118,
+      108,
+      92,
+      116,
+      66,
+      65,
+      74,
+      65,
+      76,
+      72,
+      61,
+      67,
+      68,
+      65,
+      69,
+      68,
+      72,
+      79,
+      69,
+      69,
+      77,
+      86,
+      94,
+      98,
+      109,
+      103,
+      94,
+      105,
+      94,
+      108,
+      104,
+      117,
+      111,
+      109,
+      113,
+      117,
+      107,
+      70
+    ],
+    "6": [
+      117,
+      120,
+      111,
+      103,
+      112,
+      112,
+      103,
+      115,
+      112,
+      114,
+      122,
+      121,
+      130,
+      121,
+      129,
+      132,
+      140,
+      139,
+      137,
+      144,
+      156,
+      151,
+      154,
+      149,
+      159,
+      159,
+      167,
+      158,
+      167,
+      163,
+      149,
+      146,
+      135,
+      100,
+      99,
+      132,
+      149,
+      145,
+      153,
+      164,
+      162,
+      173,
+      165,
+      179,
+      181,
+      180,
+      166,
+      161,
+      153,
+      151,
+      135,
+      127,
+      119,
+      115,
+      86,
+      83,
+      94,
+      89,
+      80,
+      62,
+      79,
+      71,
+      89,
+      98,
+      118,
+      109,
+      81,
+      55,
+      69,
+      65,
+      74,
+      75,
+      65,
+      66,
+      65,
+      74,
+      68,
+      55,
+      81,
+      64,
+      74,
+      65,
+      74,
+      66,
+      75,
+      80,
+      87,
+      88,
+      94,
+      91,
+      98,
+      88,
+      90,
+      98,
+      94,
+      88,
+      101,
+      99,
+      92,
+      155
+    ],
+    "7": [
+      114,
+      115,
+      125,
+      124,
+      130,
+      121,
+      121,
+      124,
+      132,
+      117,
+      133,
+      133,
+      125,
+      126,
+      127,
+      118,
+      116,
+      121,
+      108,
+      104,
+      98,
+      85,
+      85,
+      86,
+      73,
+      64,
+      65,
+      68,
+      53,
+      56,
+      69,
+      60,
+      61,
+      83,
+      97,
+      98,
+      112,
+      120,
+      135,
+      139,
+      149,
+      166,
+      175,
+      176,
+      188,
+      180,
+      185,
+      185,
+      189,
+      184,
+      179,
+      178,
+      148,
+      154,
+      142,
+      143,
+      119,
+      117,
+      104,
+      79,
+      79,
+      74,
+      69,
+      61,
+      69,
+      90,
+      79,
+      101,
+      91,
+      105,
+      110,
+      116,
+      114,
+      138,
+      117,
+      130,
+      131,
+      142,
+      140,
+      144,
+      153,
+      163,
+      157,
+      156,
+      158,
+      178,
+      172,
+      168,
+      182,
+      175,
+      165,
+      172,
+      159,
+      153,
+      160,
+      141,
+      152,
+      150,
+      143,
+      122
+    ],
+    "8": [
+      124,
+      108,
+      116,
+      115,
+      110,
+      114,
+      111,
+      116,
+      132,
+      125,
+      127,
+      127,
+      125,
+      136,
+      135,
+      130,
+      142,
+      134,
+      135,
+      132,
+      131,
+      129,
+      133,
+      122,
+      121,
+      119,
+      112,
+      101,
+      117,
+      105,
+      94,
+      97,
+      85,
+      151,
+      160,
+      160,
+      158,
+      167,
+      163,
+      164,
+      161,
+      162,
+      149,
+      134,
+      130,
+      113,
+      108,
+      97,
+      86,
+      82,
+      81,
+      81,
+      72,
+      78,
+      88,
+      88,
+      88,
+      115,
+      133,
+      148,
+      166,
+      172,
+      187,
+      205,
+      201,
+      188,
+      195,
+      193,
+      198,
+      188,
+      169,
+      152,
+      159,
+      116,
+      125,
+      92,
+      98,
+      78,
+      68,
+      63,
+      62,
+      56,
+      72,
+      78,
+      89,
+      92,
+      105,
+      118,
+      134,
+      144,
+      157,
+      148,
+      165,
+      153,
+      153,
+      147,
+      150,
+      149,
+      138,
+      70
+    ],
+    "9": [
+      119,
+      104,
+      121,
+      106,
+      106,
+      107,
+      98,
+      104,
+      105,
+      107,
+      105,
+      110,
+      118,
+      125,
+      125,
+      120,
+      126,
+      123,
+      135,
+      148,
+      146,
+      148,
+      150,
+      165,
+      162,
+      169,
+      166,
+      162,
+      184,
+      175,
+      174,
+      184,
+      176,
+      162,
+      158,
+      169,
+      167,
+      161,
+      150,
+      142,
+      130,
+      123,
+      109,
+      89,
+      88,
+      74,
+      73,
+      65,
+      61,
+      67,
+      77,
+      84,
+      106,
+      110,
+      127,
+      151,
+      161,
+      180,
+      202,
+      211,
+      222,
+      224,
+      233,
+      213,
+      201,
+      193,
+      66,
+      67,
+      76,
+      61,
+      65,
+      64,
+      69,
+      70,
+      60,
+      59,
+      83,
+      81,
+      65,
+      82,
+      78,
+      94,
+      73,
+      82,
+      78,
+      95,
+      98,
+      99,
+      95,
+      89,
+      89,
+      99,
+      93,
+      100,
+      104,
+      105,
+      102,
+      104,
+      106,
+      120
+    ],
+    "10": [
+      122,
+      127,
+      132,
+      142,
+      143,
+      133,
+      128,
+      99,
+      92,
+      69,
+      57,
+      52,
+      46,
+      38,
+      58,
+      78,
+      94,
+      104,
+      124,
+      132,
+      146,
+      148,
+      138,
+      135,
+      121,
+      93,
+      81,
+      59,
+      51,
+      73,
+      74,
+      100,
+      120,
+      160,
+      158,
+      150,
+      149,
+      138,
+      150,
+      143,
+      144,
+      137,
+      137,
+      140,
+      126,
+      132,
+      136,
+      133,
+      118,
+      118,
+      133,
+      125,
+      116,
+      115,
+      119,
+      125,
+      116,
+      114,
+      102,
+      98,
+      93,
+      91,
+      80,
+      91,
+      80,
+      77,
+      202,
+      193,
+      211,
+      212,
+      193,
+      204,
+      192,
+      191,
+      173,
+      189,
+      173,
+      165,
+      167,
+      161,
+      154,
+      144,
+      128,
+      133,
+      125,
+      119,
+      110,
+      86,
+      84,
+      75,
+      78,
+      67,
+      60,
+      61,
+      49,
+      51,
+      53,
+      38,
+      51,
+      158
+    ],
+    "11": [
+      121,
+      106,
+      105,
+      117,
+      101,
+      111,
+      107,
+      113,
+      109,
+      122,
+      115,
+      126,
+      124,
+      127,
+      124,
+      129,
+      129,
+      136,
+      147,
+      157,
+      142,
+      145,
+      153,
+      164,
+      147,
+      161,
+      162,
+      157,
+      158,
+      158,
+      152,
+      143,
+      137,
+      137,
+      136,
+      139,
+      131,
+      134,
+      122,
+      125,
+      121,
+      121,
+      108,
+      104,
+      105,
+      104,
+      107,
+      96,
+      102,
+      95,
+      99,
+      91,
+      106,
+      84,
+      77,
+      83,
+      83,
+      81,
+      96,
+      73,
+      76,
+      73,
+      84,
+      73,
+      64,
+      78,
+      158,
+      156,
+      135,
+      129,
+      135,
+      116,
+      112,
+      93,
+      98,
+      84,
+      73,
+      72,
+      67,
+      70,
+      58,
+      69,
+      66,
+      59,
+      89,
+      80,
+      90,
+      90,
+      102,
+      109,
+      101,
+      114,
+      127,
+      122,
+      123,
+      124,
+      138,
+      137,
+      131,
+      170
+    ],
+    "12": [
+      117,
+      112,
+      113,
+      109,
+      106,
+      114,
+      113,
+      125,
+      112,
+      125,
+      126,
+      121,
+      125,
+      125,
+      131,
+      136,
+      135,
+      136,
+      137,
+      147,
+      147,
+      151,
+      143,
+      146,
+      134,
+      148,
+      141,
+      136,
+      138,
+      135,
+      129,
+      122,
+      112,
+      162,
+      151,
+      141,
+      152,
+      139,
+      143,
+      140,
+      134,
+      137,
+      128,
+      124,
+      121,
+      129,
+      117,
+      126,
+      123,
+      121,
+      106,
+      113,
+      112,
+      101,
+      112,
+      106,
+      103,
+      101,
+      90,
+      99,
+      94,
+      94,
+      72,
+      67,
+      77,
+      70,
+      114,
+      80,
+      67,
+      73,
+      65,
+      67,
+      93,
+      111,
+      125,
+      154,
+      177,
+      184,
+      172,
+      192,
+      182,
+      171,
+      157,
+      128,
+      120,
+      82,
+      73,
+      68,
+      54,
+      67,
+      77,
+      81,
+      101,
+      123,
+      126,
+      135,
+      142,
+      145,
+      140,
+      83
+    ],
+    "13": [
+      124,
+      121,
+      117,
+      117,
+      112,
+      126,
+      118,
+      122,
+      123,
+      133,
+      134,
+      127,
+      129,
+      127,
+      127,
+      121,
+      122,
+      119,
+      120,
+      105,
+      96,
+      94,
+      92,
+      83,
+      92,
+      85,
+      64,
+      74,
+      61,
+      55,
+      64,
+      72,
+      50,
+      148,
+      149,
+      143,
+      143,
+      132,
+      129,
+      130,
+      145,
+      125,
+      135,
+      126,
+      130,
+      128,
+      120,
+      111,
+      110,
+      100,
+      104,
+      126,
+      105,
+      110,
+      118,
+      98,
+      93,
+      90,
+      110,
+      79,
+      99,
+      76,
+      62,
+      80,
+      73,
+      59,
+      143,
+      153,
+      146,
+      152,
+      168,
+      167,
+      179,
+      176,
+      176,
+      185,
+      178,
+      190,
+      183,
+      187,
+      203,
+      192,
+      196,
+      190,
+      187,
+      185,
+      174,
+      172,
+      177,
+      167,
+      152,
+      143,
+      141,
+      134,
+      120,
+      120,
+      102,
+      107,
+      98,
+      146
+    ],
+    "14": [
+      121,
+      115,
+      111,
+      115,
+      108,
+      103,
+      112,
+      104,
+      114,
+      113,
+      105,
+      112,
+      110,
+      131,
+      127,
+      125,
+      136,
+      136,
+      143,
+      149,
+      161,
+      157,
+      160,
+      164,
+      156,
+      163,
+      172,
+      173,
+      176,
+      171,
+      168,
+      160,
+      162,
+      108,
+      118,
+      132,
+      139,
+      154,
+      153,
+      173,
+      177,
+      175,
+      169,
+      166,
+      181,
+      165,
+      167,
+      155,
+      153,
+      148,
+      136,
+      120,
+      103,
+      104,
+      82,
+      80,
+      73,
+      61,
+      74,
+      87,
+      82,
+      82,
+      101,
+      110,
+      111,
+      112,
+      191,
+      206,
+      200,
+      214,
+      209,
+      204,
+      205,
+      191,
+      204,
+      191,
+      178,
+      168,
+      169,
+      167,
+      155,
+      159,
+      149,
+      147,
+      129,
+      124,
+      120,
+      120,
+      108,
+      102,
+      93,
+      83,
+      79,
+      59,
+      65,
+      61,
+      59,
+      42,
+      49,
+      153
+    ],
+    "15": [
+      118,
+      107,
+      105,
+      108,
+      109,
+      100,
+      104,
+      110,
+      109,
+      106,
+      103,
+      110,
+      113,
+      120,
+      125,
+      127,
+      123,
+      131,
+      130,
+      139,
+      143,
+      156,
+      147,
+      157,
+      163,
+      166,
+      165,
+      189,
+      176,
+      169,
+      160,
+      177,
+      173,
+      133,
+      118,
+      122,
+      122,
+      120,
+      111,
+      109,
+      102,
+      95,
+      91,
+      99,
+      82,
+      85,
+      85,
+      91,
+      82,
+      88,
+      80,
+      84,
+      89,
+      93,
+      79,
+      68,
+      91,
+      90,
+      73,
+      84,
+      82,
+      82,
+      89,
+      79,
+      73,
+      80,
+      87,
+      87,
+      77,
+      75,
+      74,
+      67,
+      68,
+      71,
+      57,
+      65,
+      57,
+      68,
+      66,
+      69,
+      63,
+      67,
+      72,
+      69,
+      70,
+      86,
+      75,
+      83,
+      73,
+      78,
+      78,
+      85,
+      85,
+      79,
+      88,
+      89,
+      94,
+      84,
+      95,
+      133
+    ],
+    "16": [
+      114,
+      120,
+      109,
+      110,
+      116,
+      115,
+      114,
+      116,
+      107,
+      121,
+      123,
+      124,
+      131,
+      133,
+      124,
+      137,
+      139,
+      147,
+      141,
+      136,
+      143,
+      151,
+      142,
+      152,
+      146,
+      155,
+      156,
+      151,
+      145,
+      131,
+      130,
+      120,
+      124,
+      64,
+      59,
+      52,
+      60,
+      50,
+      59,
+      68,
+      59,
+      69,
+      68,
+      88,
+      94,
+      94,
+      103,
+      120,
+      139,
+      140,
+      158,
+      162,
+      190,
+      196,
+      197,
+      202,
+      229,
+      233,
+      228,
+      216,
+      214,
+      233,
+      222,
+      207,
+      203,
+      189,
+      166,
+      167,
+      156,
+      135,
+      137,
+      121,
+      105,
+      108,
+      92,
+      84,
+      74,
+      69,
+      74,
+      58,
+      65,
+      74,
+      65,
+      73,
+      72,
+      67,
+      76,
+      84,
+      88,
+      96,
+      96,
+      112,
+      108,
+      112,
+      110,
+      118,
+      115,
+      123,
+      129,
+      98
+    ],
+    "17": [
+      123,
+      124,
+      120,
+      122,
+      128,
+      124,
+      122,
+      125,
+      118,
+      130,
+      124,
+      130,
+      132,
+      128,
+      120,
+      113,
+      112,
+      106,
+      94,
+      89,
+      87,
+      90,
+      76,
+      72,
+      73,
+      57,
+      67,
+      60,
+      54,
+      51,
+      52,
+      59,
+      62,
+      51,
+      58,
+      58,
+      44,
+      64,
+      63,
+      57,
+      63,
+      64,
+      72,
+      76,
+      90,
+      89,
+      105,
+      119,
+      140,
+      146,
+      157,
+      171,
+      182,
+      187,
+      212,
+      224,
+      213,
+      231,
+      226,
+      237,
+      237,
+      218,
+      211,
+      217,
+      197,
+      181,
+      70,
+      63,
+      94,
+      116,
+      101,
+      145,
+      144,
+      169,
+      181,
+      181,
+      190,
+      184,
+      190,
+      176,
+      179,
+      157,
+      144,
+      126,
+      99,
+      82,
+      73,
+      68,
+      53,
+      54,
+      58,
+      66,
+      70,
+      87,
+      96,
+      105,
+      112,
+      125,
+      137,
+      83
+    ],
+    "18": [
+      115,
+      121,
+      115,
+      109,
+      110,
+      108,
+      105,
+      110,
+      115,
+      110,
+      122,
+      122,
+      118,
+      129,
+      128,
+      131,
+      135,
+      136,
+      143,
+      142,
+      147,
+      156,
+      143,
+      151,
+      160,
+      164,
+      160,
+      160,
+      158,
+      169,
+      161,
+      154,
+      143,
+      100,
+      115,
+      123,
+      134,
+      138,
+      139,
+      152,
+      159,
+      172,
+      193,
+      179,
+      175,
+      185,
+      165,
+      169,
+      157,
+      162,
+      135,
+      123,
+      125,
+      115,
+      107,
+      101,
+      88,
+      95,
+      85,
+      81,
+      76,
+      87,
+      80,
+      89,
+      105,
+      116,
+      72,
+      72,
+      78,
+      68,
+      82,
+      89,
+      90,
+      97,
+      89,
+      96,
+      93,
+      110,
+      100,
+      126,
+      125,
+      122,
+      118,
+      143,
+      130,
+      130,
+      143,
+      147,
+      153,
+      153,
+      157,
+      147,
+      138,
+      154,
+      146,
+      143,
+      139,
+      145,
+      141,
+      164
+    ],
+    "19": [
+      109,
+      121,
+      130,
+      131,
+      131,
+      136,
+      135,
+      130,
+      125,
+      115,
+      115,
+      107,
+      89,
+      83,
+      76,
+      74,
+      59,
+      49,
+      52,
+      46,
+      49,
+      58,
+      67,
+      68,
+      83,
+      100,
+      115,
+      140,
+      142,
+      161,
+      173,
+      160,
+      181,
+      128,
+      137,
+      133,
+      117,
+      125,
+      120,
+      115,
+      108,
+      101,
+      112,
+      99,
+      96,
+      94,
+      91,
+      97,
+      76,
+      70,
+      84,
+      69,
+      66,
+      78,
+      85,
+      82,
+      80,
+      76,
+      68,
+      84,
+      73,
+      70,
+      86,
+      69,
+      78,
+      74,
+      208,
+      206,
+      208,
+      197,
+      194,
+      183,
+      169,
+      163,
+      154,
+      153,
+      140,
+      130,
+      125,
+      110,
+      98,
+      90,
+      102,
+      78,
+      81,
+      74,
+      73,
+      50,
+      66,
+      48,
+      64,
+      51,
+      58,
+      51,
+      65,
+      71,
+      62,
+      61,
+      68,
+      59
+    ]
+  }
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-15-13.347285/load_limits.json b/test_instances/2026-06-30_15-15-13.347285/load_limits.json
new file mode 100644
index 0000000..7f564d8
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/load_limits.json
@@ -0,0 +1,69 @@
+{
+  "0": {
+    "0": null,
+    "1": null,
+    "2": null,
+    "3": null,
+    "4": null,
+    "5": null,
+    "6": null,
+    "7": null,
+    "8": null,
+    "9": null,
+    "10": null,
+    "11": null,
+    "12": null,
+    "13": null,
+    "14": null,
+    "15": null,
+    "16": null,
+    "17": null,
+    "18": null,
+    "19": null
+  },
+  "1": {
+    "0": 74.65,
+    "1": 74.65,
+    "2": 301.6,
+    "3": 301.6,
+    "4": 725.241,
+    "5": 725.241,
+    "6": 725.241,
+    "7": 725.241,
+    "8": 725.241,
+    "9": 725.241,
+    "10": 725.241,
+    "11": 1269.922,
+    "12": 1269.922,
+    "13": 1269.922,
+    "14": 1269.922,
+    "15": 1269.922,
+    "16": 1693.563,
+    "17": 1693.563,
+    "18": 1693.563,
+    "19": 1693.563
+  },
+  "2": {
+    "0": 186.959,
+    "1": 186.959,
+    "2": 750.836,
+    "3": 750.836,
+    "4": 1803.405,
+    "5": 1803.405,
+    "6": 1803.405,
+    "7": 1803.405,
+    "8": 1803.405,
+    "9": 1803.405,
+    "10": 1803.405,
+    "11": 3156.709,
+    "12": 3156.709,
+    "13": 3156.709,
+    "14": 3156.709,
+    "15": 3156.709,
+    "16": 4209.279,
+    "17": 4209.279,
+    "18": 4209.279,
+    "19": 4209.279
+  },
+  "load_existing": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar/2026-05-17_12-19-08.038762"
+}
\ No newline at end of file
diff --git a/test_instances/2026-06-30_15-15-13.347285/obj.csv b/test_instances/2026-06-30_15-15-13.347285/obj.csv
new file mode 100644
index 0000000..3863383
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+40.21367593943416
+40.13632391443889
+40.170102975081726
+39.56876068140957
+40.098438500783686
+39.956221513069856
+40.84701213507882
+40.31037533695431
+40.46716495283335
+38.46882179601036
diff --git a/test_instances/2026-06-30_15-15-13.347285/runtime.csv b/test_instances/2026-06-30_15-15-13.347285/runtime.csv
new file mode 100644
index 0000000..b98e724
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/runtime.csv
@@ -0,0 +1,11 @@
+tot
+0.8093307999999999
+0.67520105
+0.8487232
+0.79612425
+0.7487035000000001
+1.08775235
+0.8335367499999998
+0.612548
+0.83312485
+0.8403228500000001
diff --git a/test_instances/2026-06-30_15-15-13.347285/sp.png b/test_instances/2026-06-30_15-15-13.347285/sp.png
new file mode 100644
index 0000000..9431fff
Binary files /dev/null and b/test_instances/2026-06-30_15-15-13.347285/sp.png differ
diff --git a/test_instances/2026-06-30_15-15-13.347285/termination_condition.csv b/test_instances/2026-06-30_15-15-13.347285/termination_condition.csv
new file mode 100644
index 0000000..22bec1e
--- /dev/null
+++ b/test_instances/2026-06-30_15-15-13.347285/termination_condition.csv
@@ -0,0 +1,11 @@
+,0
+0,max iterations reached (it: 99; best centralized it: 13; total runtime: 0.8093307999999999)
+1,no available or convenient sellers (it: 12; best centralized it: 11; total runtime: 0.67520105)
+2,no available or convenient sellers (it: 18; best centralized it: 17; total runtime: 0.8487232)
+3,no available or convenient sellers (it: 18; best centralized it: 17; total runtime: 0.79612425)
+4,no available or convenient sellers (it: 15; best centralized it: 14; total runtime: 0.7487035000000001)
+5,max iterations reached (it: 99; best centralized it: 23; total runtime: 1.08775235)
+6,no available or convenient sellers (it: 18; best centralized it: 17; total runtime: 0.8335367499999998)
+7,no available or convenient sellers (it: 11; best centralized it: 10; total runtime: 0.612548)
+8,max iterations reached (it: 99; best centralized it: 16; total runtime: 0.83312485)
+9,max iterations reached (it: 99; best centralized it: 15; total runtime: 0.8403228500000001)
diff --git a/test_instances/config.json b/test_instances/config.json
new file mode 100644
index 0000000..ff3c973
--- /dev/null
+++ b/test_instances/config.json
@@ -0,0 +1,50 @@
+{
+  "base_solution_folder": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb",
+  "verbose": 2,
+  "seed": 4850,
+  "max_steps": 100,
+  "min_run_time": 70,
+  "max_run_time": 80,
+  "solver_name": "gurobi_direct",
+  "solver_options": {
+    "general": {
+      "TimeLimit": 120,
+      "MIPGap": 1e-05
+    },
+    "auction": {
+      "eta": 0.0,
+      "epsilon": 0.0001,
+      "zeta": 0.01,
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+      "unit_bids": true
+    },
+    "coordinator": {
+      "sorting_rule": "product"
+    },
+    "update_neighborhood": false,
+    "start_from_last_pi": false,
+    "use_detailed_pi": false
+  },
+  "checkpoint_interval": 10,
+  "max_iterations": 100,
+  "plot_interval": 100,
+  "patience": 10,
+  "sw_patience": 200,
+  "limits": {
+    "instance_type": "load_existing",
+    "Nn": {
+      "values": [
+        20
+      ]
+    },
+    "Nf": {
+      "min": 3,
+      "max": 3
+    },
+    "path": "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar",
+    "load": {
+      "trace_type": "load_existing"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test_instances/experiments.json b/test_instances/experiments.json
new file mode 100644
index 0000000..252b5fc
--- /dev/null
+++ b/test_instances/experiments.json
@@ -0,0 +1,25 @@
+{
+  "experiments_list": [
+    [
+      20,
+      4850
+    ],
+    [
+      20,
+      7521
+    ],
+    [
+      20,
+      3865
+    ]
+  ],
+  "centralized": [],
+  "faas-macro": [],
+  "faas-macro-v0": [],
+  "faas-madea": [],
+  "hierarchical": [
+    "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-07-20.999765",
+    "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-11-12.143728",
+    "solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-15-13.347285"
+  ]
+}
\ No newline at end of file
diff --git a/test_instances/postprocessing/20_3865/fwd_by_function.csv b/test_instances/postprocessing/20_3865/fwd_by_function.csv
new file mode 100644
index 0000000..59be2ad
--- /dev/null
+++ b/test_instances/postprocessing/20_3865/fwd_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,11677.918579651163,tot
+f1,623.0,tot
+f2,5145.9806167400875,tot
+f0,1388.7092773255815,0
+f1,42.0,0
+f2,524.7400881057268,0
+f0,1328.0,1
+f1,48.0,1
+f2,522.3920704845815,1
+f0,1263.4186046511627,2
+f1,43.0,2
+f2,655.0,2
+f0,1260.860465116279,3
+f1,46.0,3
+f2,518.0308370044053,3
+f0,1234.2790697674418,4
+f1,53.0,4
+f2,581.0,4
+f0,1217.6511627906978,5
+f1,67.0,5
+f2,465.4696035242291,5
+f0,1236.9767441860465,6
+f1,75.0,6
+f2,494.0,6
+f0,1003.6744186046511,7
+f1,80.0,7
+f2,484.0,7
+f0,1059.4418604651164,8
+f1,82.0,8
+f2,455.0,8
+f0,684.906976744186,9
+f1,87.0,9
+f2,446.34801762114535,9
diff --git a/test_instances/postprocessing/20_3865/fwd_by_function.png b/test_instances/postprocessing/20_3865/fwd_by_function.png
new file mode 100644
index 0000000..7949d5f
Binary files /dev/null and b/test_instances/postprocessing/20_3865/fwd_by_function.png differ
diff --git a/test_instances/postprocessing/20_3865/iterations_HierarchicalAuction.png b/test_instances/postprocessing/20_3865/iterations_HierarchicalAuction.png
new file mode 100644
index 0000000..0ee109b
Binary files /dev/null and b/test_instances/postprocessing/20_3865/iterations_HierarchicalAuction.png differ
diff --git a/test_instances/postprocessing/20_3865/loc_by_function.csv b/test_instances/postprocessing/20_3865/loc_by_function.csv
new file mode 100644
index 0000000..b3a3baf
--- /dev/null
+++ b/test_instances/postprocessing/20_3865/loc_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,19052.0,tot
+f1,8697.0,tot
+f2,17453.0,tot
+f0,1707.0,0
+f1,892.0,0
+f2,1728.0,0
+f0,1769.0,1
+f1,876.0,1
+f2,1738.0,1
+f0,1776.0,2
+f1,895.0,2
+f2,1649.0,2
+f0,1827.0,3
+f1,885.0,3
+f2,1678.0,3
+f0,1827.0,4
+f1,882.0,4
+f2,1700.0,4
+f0,1878.0,5
+f1,862.0,5
+f2,1786.0,5
+f0,1855.0,6
+f1,854.0,6
+f2,1849.0,6
+f0,2079.0,7
+f1,856.0,7
+f2,1785.0,7
+f0,2041.0,8
+f1,852.0,8
+f2,1819.0,8
+f0,2293.0,9
+f1,843.0,9
+f2,1721.0,9
diff --git a/test_instances/postprocessing/20_3865/loc_by_function.png b/test_instances/postprocessing/20_3865/loc_by_function.png
new file mode 100644
index 0000000..6dfaf33
Binary files /dev/null and b/test_instances/postprocessing/20_3865/loc_by_function.png differ
diff --git a/test_instances/postprocessing/20_3865/obj.csv b/test_instances/postprocessing/20_3865/obj.csv
new file mode 100644
index 0000000..3863383
--- /dev/null
+++ b/test_instances/postprocessing/20_3865/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+40.21367593943416
+40.13632391443889
+40.170102975081726
+39.56876068140957
+40.098438500783686
+39.956221513069856
+40.84701213507882
+40.31037533695431
+40.46716495283335
+38.46882179601036
diff --git a/test_instances/postprocessing/20_3865/obj.png b/test_instances/postprocessing/20_3865/obj.png
new file mode 100644
index 0000000..725da1a
Binary files /dev/null and b/test_instances/postprocessing/20_3865/obj.png differ
diff --git a/test_instances/postprocessing/20_3865/rej_by_function.csv b/test_instances/postprocessing/20_3865/rej_by_function.csv
new file mode 100644
index 0000000..90e036a
--- /dev/null
+++ b/test_instances/postprocessing/20_3865/rej_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,265.08142034883736,tot
+f1,63.0,tot
+f2,868.0193832599119,tot
+f0,5.290722674418561,0
+f1,5.0,0
+f2,92.25991189427313,0
+f0,2.0,1
+f1,14.0,1
+f2,84.60792951541853,1
+f0,60.58139534883725,2
+f1,1.0,2
+f2,43.0,2
+f0,12.13953488372097,3
+f1,7.0,3
+f2,150.96916299559473,3
+f0,36.720930232558175,4
+f1,4.0,4
+f2,70.0,4
+f0,3.348837209302303,5
+f1,9.0,5
+f2,97.53039647577091,5
+f0,8.023255813953497,6
+f1,7.0,6
+f2,4.000000000000003,6
+f0,15.325581395348834,7
+f1,2.0,7
+f2,78.0,7
+f0,0.5581395348837077,8
+f1,6.0,8
+f2,70.0,8
+f0,121.09302325581402,9
+f1,8.0,9
+f2,177.65198237885468,9
diff --git a/test_instances/postprocessing/20_3865/rej_by_function.png b/test_instances/postprocessing/20_3865/rej_by_function.png
new file mode 100644
index 0000000..e4f8e87
Binary files /dev/null and b/test_instances/postprocessing/20_3865/rej_by_function.png differ
diff --git a/test_instances/postprocessing/20_3865/runtime_HierarchicalAuction.csv b/test_instances/postprocessing/20_3865/runtime_HierarchicalAuction.csv
new file mode 100644
index 0000000..82a3a4d
--- /dev/null
+++ b/test_instances/postprocessing/20_3865/runtime_HierarchicalAuction.csv
@@ -0,0 +1,11 @@
+,tot
+0,0.8093307999999999
+1,0.67520105
+2,0.8487232
+3,0.79612425
+4,0.7487035000000001
+5,1.08775235
+6,0.8335367499999998
+7,0.612548
+8,0.83312485
+9,0.8403228500000001
diff --git a/test_instances/postprocessing/20_4850/fwd_by_function.csv b/test_instances/postprocessing/20_4850/fwd_by_function.csv
new file mode 100644
index 0000000..4d02592
--- /dev/null
+++ b/test_instances/postprocessing/20_4850/fwd_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,602.1066304066305,tot
+f1,3090.0,tot
+f2,290.2539234449761,tot
+f0,88.97706552706553,0
+f1,354.0,0
+f2,26.515789473684208,0
+f0,87.0,1
+f1,380.0,1
+f2,36.357894736842105,1
+f0,84.0,2
+f1,344.0,2
+f2,30.394258373205744,2
+f0,33.14529914529916,3
+f1,323.0,3
+f2,41.42114832535886,3
+f0,87.0,4
+f1,280.0,4
+f2,36.74641148325359,4
+f0,75.33333333333333,5
+f1,312.0,5
+f2,27.825837320574166,5
+f0,38.05180005180005,6
+f1,238.0,6
+f2,28.450000000000003,6
+f0,19.796943796943808,7
+f1,290.0,7
+f2,39.8,7
+f0,23.772662522662536,8
+f1,295.0,8
+f2,12.31483253588517,8
+f0,65.02952602952604,9
+f1,274.0,9
+f2,10.427751196172249,9
diff --git a/test_instances/postprocessing/20_4850/fwd_by_function.png b/test_instances/postprocessing/20_4850/fwd_by_function.png
new file mode 100644
index 0000000..a1107c8
Binary files /dev/null and b/test_instances/postprocessing/20_4850/fwd_by_function.png differ
diff --git a/test_instances/postprocessing/20_4850/iterations_HierarchicalAuction.png b/test_instances/postprocessing/20_4850/iterations_HierarchicalAuction.png
new file mode 100644
index 0000000..f67e7e7
Binary files /dev/null and b/test_instances/postprocessing/20_4850/iterations_HierarchicalAuction.png differ
diff --git a/test_instances/postprocessing/20_4850/loc_by_function.csv b/test_instances/postprocessing/20_4850/loc_by_function.csv
new file mode 100644
index 0000000..1a2e966
--- /dev/null
+++ b/test_instances/postprocessing/20_4850/loc_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,2732.0,tot
+f1,9470.0,tot
+f2,2090.0,tot
+f0,277.0,0
+f1,903.0,0
+f2,201.0,0
+f0,282.0,1
+f1,877.0,1
+f2,200.0,1
+f0,285.0,2
+f1,914.0,2
+f2,201.0,2
+f0,275.0,3
+f1,934.0,3
+f2,203.0,3
+f0,263.0,4
+f1,976.0,4
+f2,209.0,4
+f0,273.0,5
+f1,945.0,5
+f2,210.0,5
+f0,256.0,6
+f1,1018.0,6
+f2,212.0,6
+f0,268.0,7
+f1,967.0,7
+f2,221.0,7
+f0,270.0,8
+f1,961.0,8
+f2,217.0,8
+f0,283.0,9
+f1,975.0,9
+f2,216.0,9
diff --git a/test_instances/postprocessing/20_4850/loc_by_function.png b/test_instances/postprocessing/20_4850/loc_by_function.png
new file mode 100644
index 0000000..b117a94
Binary files /dev/null and b/test_instances/postprocessing/20_4850/loc_by_function.png differ
diff --git a/test_instances/postprocessing/20_4850/obj.csv b/test_instances/postprocessing/20_4850/obj.csv
new file mode 100644
index 0000000..2d49fc0
--- /dev/null
+++ b/test_instances/postprocessing/20_4850/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+36.95864931027803
+37.82112741116574
+37.25832043782138
+35.60834835100418
+36.86247722193043
+36.62633575077564
+34.621191711529406
+35.39431245486941
+33.71503600109627
+35.74857946882959
diff --git a/test_instances/postprocessing/20_4850/obj.png b/test_instances/postprocessing/20_4850/obj.png
new file mode 100644
index 0000000..87149fc
Binary files /dev/null and b/test_instances/postprocessing/20_4850/obj.png differ
diff --git a/test_instances/postprocessing/20_4850/rej_by_function.csv b/test_instances/postprocessing/20_4850/rej_by_function.csv
new file mode 100644
index 0000000..972ff42
--- /dev/null
+++ b/test_instances/postprocessing/20_4850/rej_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,371.8933695933695,tot
+f1,8.0,tot
+f2,322.7460765550239,tot
+f0,4.02293447293447,0
+f1,0.0,0
+f2,43.48421052631579,0
+f0,0.0,1
+f1,1.0,1
+f2,33.64210526315789,1
+f0,0.0,2
+f1,0.0,2
+f2,38.605741626794256,2
+f0,61.85470085470084,3
+f1,0.0,3
+f2,24.578851674641143,3
+f0,22.0,4
+f1,0.0,4
+f2,27.25358851674641,4
+f0,23.666666666666664,5
+f1,0.0,5
+f2,32.174162679425834,5
+f0,74.94819994819994,6
+f1,0.0,6
+f2,27.549999999999997,6
+f0,83.20305620305619,7
+f1,0.0,7
+f2,11.2,7
+f0,78.22733747733747,8
+f1,0.0,8
+f2,37.68516746411483,8
+f0,23.970473970473968,9
+f1,7.0,9
+f2,46.57224880382775,9
diff --git a/test_instances/postprocessing/20_4850/rej_by_function.png b/test_instances/postprocessing/20_4850/rej_by_function.png
new file mode 100644
index 0000000..e314d5c
Binary files /dev/null and b/test_instances/postprocessing/20_4850/rej_by_function.png differ
diff --git a/test_instances/postprocessing/20_4850/runtime_HierarchicalAuction.csv b/test_instances/postprocessing/20_4850/runtime_HierarchicalAuction.csv
new file mode 100644
index 0000000..fd6faf0
--- /dev/null
+++ b/test_instances/postprocessing/20_4850/runtime_HierarchicalAuction.csv
@@ -0,0 +1,11 @@
+,tot
+0,0.7341216500000002
+1,0.6719155
+2,0.7770311999999999
+3,0.77332135
+4,0.72221705
+5,0.6859557000000001
+6,0.51717855
+7,0.69259385
+8,0.4653922000000001
+9,0.5882136499999999
diff --git a/test_instances/postprocessing/20_7521/fwd_by_function.csv b/test_instances/postprocessing/20_7521/fwd_by_function.csv
new file mode 100644
index 0000000..ffc1b68
--- /dev/null
+++ b/test_instances/postprocessing/20_7521/fwd_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,2425.4228752828017,tot
+f1,1912.418604651163,tot
+f2,1650.8749740736419,tot
+f0,287.9185520361991,0
+f1,183.61461794019937,0
+f2,145.80555555555554,0
+f0,220.8504769230775,1
+f1,221.0,1
+f2,102.99999999999999,1
+f0,282.38914027149315,2
+f1,210.0,2
+f2,108.08333333333331,2
+f0,274.0,3
+f1,188.093023255814,3
+f2,97.95833333333331,3
+f0,217.99773772624005,4
+f1,197.4817275747509,4
+f2,105.04166666666666,4
+f0,167.82352941176464,5
+f1,144.89700996677746,5
+f2,271.27775185141974,5
+f0,186.0,6
+f1,280.0,6
+f2,118.79166666666667,6
+f0,243.44343891402713,7
+f1,238.67441860465115,7
+f2,168.91666666666666,7
+f0,273.0,8
+f1,119.92358803986711,8
+f2,263.0,8
+f0,272.0,9
+f1,128.734219269103,9
+f2,269.0,9
diff --git a/test_instances/postprocessing/20_7521/fwd_by_function.png b/test_instances/postprocessing/20_7521/fwd_by_function.png
new file mode 100644
index 0000000..3c08e7f
Binary files /dev/null and b/test_instances/postprocessing/20_7521/fwd_by_function.png differ
diff --git a/test_instances/postprocessing/20_7521/iterations_HierarchicalAuction.png b/test_instances/postprocessing/20_7521/iterations_HierarchicalAuction.png
new file mode 100644
index 0000000..dd2e562
Binary files /dev/null and b/test_instances/postprocessing/20_7521/iterations_HierarchicalAuction.png differ
diff --git a/test_instances/postprocessing/20_7521/loc_by_function.csv b/test_instances/postprocessing/20_7521/loc_by_function.csv
new file mode 100644
index 0000000..dd7043f
--- /dev/null
+++ b/test_instances/postprocessing/20_7521/loc_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,19962.0,tot
+f1,6184.0,tot
+f2,4661.0,tot
+f0,1922.0,0
+f1,589.0,0
+f2,494.0,0
+f0,1896.0,1
+f1,585.0,1
+f2,521.0,1
+f0,1960.0,2
+f1,574.0,2
+f2,500.0,2
+f0,1985.0,3
+f1,588.0,3
+f2,486.0,3
+f0,1953.0,4
+f1,606.0,4
+f2,484.0,4
+f0,2075.0,5
+f1,654.0,5
+f2,413.0,5
+f0,2120.0,6
+f1,599.0,6
+f2,452.0,6
+f0,1952.0,7
+f1,636.0,7
+f2,471.0,7
+f0,1980.0,8
+f1,700.0,8
+f2,425.0,8
+f0,2119.0,9
+f1,653.0,9
+f2,415.0,9
diff --git a/test_instances/postprocessing/20_7521/loc_by_function.png b/test_instances/postprocessing/20_7521/loc_by_function.png
new file mode 100644
index 0000000..7b8988e
Binary files /dev/null and b/test_instances/postprocessing/20_7521/loc_by_function.png differ
diff --git a/test_instances/postprocessing/20_7521/obj.csv b/test_instances/postprocessing/20_7521/obj.csv
new file mode 100644
index 0000000..30ef094
--- /dev/null
+++ b/test_instances/postprocessing/20_7521/obj.csv
@@ -0,0 +1,11 @@
+HierarchicalAuction
+34.07725189579878
+33.130297167478254
+33.28766575981739
+32.07671384443888
+32.01851310348214
+36.07592858639474
+34.517661584984516
+35.92112759935683
+36.77835857611594
+37.21165826842786
diff --git a/test_instances/postprocessing/20_7521/obj.png b/test_instances/postprocessing/20_7521/obj.png
new file mode 100644
index 0000000..f562f83
Binary files /dev/null and b/test_instances/postprocessing/20_7521/obj.png differ
diff --git a/test_instances/postprocessing/20_7521/rej_by_function.csv b/test_instances/postprocessing/20_7521/rej_by_function.csv
new file mode 100644
index 0000000..57c907f
--- /dev/null
+++ b/test_instances/postprocessing/20_7521/rej_by_function.csv
@@ -0,0 +1,34 @@
+function,HierarchicalAuction,time
+f0,1711.5771247171983,tot
+f1,683.5813953488371,tot
+f2,544.1250259263581,tot
+f0,199.08144796380088,0
+f1,106.38538205980063,0
+f2,47.19444444444446,0
+f0,293.1495230769225,1
+f1,73.0,1
+f2,62.000000000000014,1
+f0,167.61085972850685,2
+f1,95.0,2
+f2,76.91666666666669,2
+f0,151.99999999999997,3
+f1,101.906976744186,3
+f2,101.04166666666669,3
+f0,239.00226227375995,4
+f1,73.51827242524912,4
+f2,93.95833333333334,4
+f0,165.17647058823536,5
+f1,78.10299003322254,5
+f2,1.7222481485802454,5
+f0,105.0,6
+f1,8.881784197001252e-16,6
+f2,115.20833333333333,6
+f0,213.55656108597287,7
+f1,5.325581395348838,7
+f2,46.083333333333336,7
+f0,158.0,8
+f1,55.07641196013289,8
+f2,1.4210854715202004e-14,8
+f0,19.0,9
+f1,95.265780730897,9
+f2,0.0,9
diff --git a/test_instances/postprocessing/20_7521/rej_by_function.png b/test_instances/postprocessing/20_7521/rej_by_function.png
new file mode 100644
index 0000000..566a179
Binary files /dev/null and b/test_instances/postprocessing/20_7521/rej_by_function.png differ
diff --git a/test_instances/postprocessing/20_7521/runtime_HierarchicalAuction.csv b/test_instances/postprocessing/20_7521/runtime_HierarchicalAuction.csv
new file mode 100644
index 0000000..cc7f630
--- /dev/null
+++ b/test_instances/postprocessing/20_7521/runtime_HierarchicalAuction.csv
@@ -0,0 +1,11 @@
+,tot
+0,0.7887977
+1,0.7384066499999999
+2,0.7000752499999999
+3,0.6898462
+4,0.8191956499999999
+5,0.84083975
+6,0.5784033
+7,0.7269458000000001
+8,0.5788372
+9,0.5803094999999999
diff --git a/test_instances/postprocessing/i_termination_condition.png b/test_instances/postprocessing/i_termination_condition.png
new file mode 100644
index 0000000..347936b
Binary files /dev/null and b/test_instances/postprocessing/i_termination_condition.png differ
diff --git a/test_instances/postprocessing/ping_pong_problems.txt b/test_instances/postprocessing/ping_pong_problems.txt
new file mode 100644
index 0000000..0207398
--- /dev/null
+++ b/test_instances/postprocessing/ping_pong_problems.txt
@@ -0,0 +1,3 @@
+['20_4850', 'hierarchical', 'solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-07-20.999765']
+['20_7521', 'hierarchical', 'solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-11-12.143728']
+['20_3865', 'hierarchical', 'solutions/heterogeneousnodes_equalbeta-3classes-fixed_sum_auto_avg-Nf_3-k_3-planar-hierarchicalb/2026-06-30_15-15-13.347285']
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..ee4027f
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,10 @@
+import matplotlib
+import sys
+from pathlib import Path
+
+
+matplotlib.use("Agg")
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+  sys.path.insert(0, str(ROOT))
diff --git a/tests/test_algorithm_helpers.py b/tests/test_algorithm_helpers.py
new file mode 100644
index 0000000..6f5bb60
--- /dev/null
+++ b/tests/test_algorithm_helpers.py
@@ -0,0 +1,397 @@
+import numpy as np
+import pandas as pd
+import pytest
+from networkx import Graph
+
+import decentralized_auction
+import generate_data
+import run_faasmadea
+from heuristic_coordinator import GreedyCoordinator
+
+
+def _auction_data():
+  return {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 2},
+      "demand": {
+        (1, 1): 1.0,
+        (1, 2): 2.0,
+        (2, 1): 1.0,
+        (2, 2): 2.0,
+      },
+      "max_utilization": {1: 10.0, 2: 10.0},
+      "beta": {
+        (i, j, f): (5.0 if i != j else 0.0)
+        for i in (1, 2)
+        for j in (1, 2)
+        for f in (1, 2)
+      },
+      "memory_requirement": {1: 2, 2: 3},
+    }
+  }
+
+
+def test_faasmadea_stopping_capacity_utility_and_bid_helpers():
+  data = _auction_data()
+  x = np.array([[1.0, 2.0], [0.0, 0.0]])
+  y = np.zeros((2, 2, 2))
+  y[0, 1, 0] = 2.0
+  r = np.array([[1.0, 1.0], [1.0, 1.0]])
+
+  assert run_faasmadea.check_stopping_criteria(
+    4,
+    5,
+    blackboard = np.ones((2, 2)),
+    sp_omega = np.ones((2, 2)),
+    rmp_omega = np.zeros((2, 2)),
+    sp_y = y,
+    tolerance = 1e-6,
+    total_runtime = 0.0,
+    time_limit = 10.0,
+  ) == (True, "max iterations reached")
+  assert run_faasmadea.check_stopping_criteria(
+    0,
+    5,
+    blackboard = np.zeros((2, 2)),
+    sp_omega = np.ones((2, 2)),
+    rmp_omega = np.zeros((2, 2)),
+    sp_y = y,
+    tolerance = 1e-6,
+    total_runtime = 0.0,
+    time_limit = 10.0,
+  ) == (True, "no capacity left")
+
+  cap, residual, ell = run_faasmadea.compute_residual_capacity(x, y, r, data)
+  assert cap[0, 0] == 10.0
+  assert residual[1, 0] == 8.0
+  assert ell[1, 0] == 2.0
+
+  utility = run_faasmadea.compute_utility(
+    p = np.zeros((2, 2, 2)),
+    data = data,
+    auction_options = {"latency_weight": 0.5, "fairness_weight": 0.25},
+    latency = np.array([[0.0, 1.0], [1.0, 0.0]]),
+    fairness = np.ones((2, 2)),
+  )
+  assert utility[0, 1, 0] == pytest.approx(4.25)
+
+  bids = pd.DataFrame({
+    "i": [0, 0],
+    "j": [1, 1],
+    "f": [0, 0],
+    "d": [2.0, 3.0],
+    "b": [4.0, 3.0],
+  })
+  p = np.ones((2, 2))
+  y_eval, p_eval, _, _ = run_faasmadea.evaluate_bids(
+    bids,
+    blackboard = np.array([[0.0, 0.0], [4.0, 0.0]]),
+    data = data,
+    ell = ell,
+    p = p,
+    capacity = cap,
+    u0 = np.zeros((2, 2)),
+    auction_options = {"eta": 0.5, "zeta": 0.1},
+  )
+  assert y_eval[0, 1, 0] == 4.0
+  assert p_eval[1, 0] > 3.0
+
+  matrix = run_faasmadea.data_dict_to_matrix(data[None]["beta"], 2, 2)
+  assert matrix[0, 1, 0] == 5.0
+  additional, rho = run_faasmadea.start_additional_replicas(
+    pd.DataFrame({"j": [1, 1, 1], "f": [0, 0, 1]}),
+    np.zeros((2, 2)),
+    data,
+    np.array([0.0, 10.0]),
+  )
+  assert additional[1, 0] == 3
+  assert additional[1, 1] == 1
+  assert rho[1] == 1.0
+
+
+def test_evaluate_bids_eta_schedule_and_scalar_and_n_auctions_guard():
+  data = _auction_data()
+  x = np.array([[1.0, 2.0], [0.0, 0.0]])
+  y = np.zeros((2, 2, 2))
+  y[0, 1, 0] = 2.0
+  r = np.array([[1.0, 1.0], [1.0, 1.0]])
+  cap, residual, ell = run_faasmadea.compute_residual_capacity(x, y, r, data)
+  bids = pd.DataFrame({
+    "i": [0, 0],
+    "j": [1, 1],
+    "f": [0, 0],
+    "d": [2.0, 3.0],
+    "b": [4.0, 3.0],
+  })
+  p = np.ones((2, 2))
+  blackboard = np.array([[0.0, 0.0], [4.0, 0.0]])
+  # scalar eta still works (backward compatible)
+  _, p_scalar, _, _ = run_faasmadea.evaluate_bids(
+    bids, blackboard = blackboard, data = data, ell = ell, p = p.copy(),
+    capacity = cap, u0 = np.zeros((2, 2)),
+    auction_options = {"eta": 0.5, "zeta": 0.1},
+  )
+  # a per-iteration eta schedule: it=0 must use eta[0]
+  _, p_it0, _, _ = run_faasmadea.evaluate_bids(
+    bids, blackboard = blackboard, data = data, ell = ell, p = p.copy(),
+    capacity = cap, u0 = np.zeros((2, 2)),
+    auction_options = {"eta": [0.5, 0.3, 0.15], "zeta": 0.1}, it = 0,
+  )
+  assert p_it0[1, 0] == pytest.approx(p_scalar[1, 0])
+  # it beyond the schedule length clamps to the last value, no IndexError
+  _, p_it_over, _, _ = run_faasmadea.evaluate_bids(
+    bids, blackboard = blackboard, data = data, ell = ell, p = p.copy(),
+    capacity = cap, u0 = np.zeros((2, 2)),
+    auction_options = {"eta": [0.5, 0.3, 0.15], "zeta": 0.1}, it = 99,
+  )
+  assert p_it_over[1, 0] != pytest.approx(p_it0[1, 0])
+  # n_auctions == 0 (no potential sellers) must not raise ZeroDivisionError
+  y_empty, _, _, n_auctions = run_faasmadea.evaluate_bids(
+    pd.DataFrame(columns = ["i", "j", "f", "d", "b"]),
+    blackboard = np.zeros((2, 2)), data = data, last_y = np.zeros((2, 2, 2)),
+    ell = ell, p = p.copy(), capacity = cap, u0 = np.zeros((2, 2)),
+    auction_options = {"eta": 0.5, "zeta": 0.1},
+  )
+  assert n_auctions == 0
+  assert 1.0 / max(n_auctions, 1) == 1.0  # would raise ZeroDivisionError pre-fix
+
+
+def test_decentralized_auction_bid_definition_and_helpers():
+  data = _auction_data()
+  omega = np.array([[4.0, 0.0], [0.0, 0.0]])
+  blackboard = np.array([[0.0, 0.0], [3.0, 0.0]])
+  neighborhood = np.array([[0, 1], [1, 0]])
+  options = {
+    "latency_weight": 0.0,
+    "fairness_weight": 0.0,
+    "epsilon": 0.1,
+    "eta": 0.5,
+    "zeta": 0.1,
+  }
+
+  bids, memory_bids = decentralized_auction.define_bids(
+    omega,
+    blackboard,
+    p = np.zeros((2, 2)),
+    data = data,
+    neighborhood = neighborhood,
+    rho = np.array([0.0, 5.0]),
+    auction_options = options,
+    latency = np.zeros((2, 2)),
+    fairness = np.zeros((2, 2)),
+    delta = np.zeros((2, 2)),
+  )
+  assert memory_bids.empty
+  assert bids.loc[0, "j"] == 1
+  assert bids.loc[0, "d"] == 3.0
+
+  y, prices = decentralized_auction.evaluate_bids(
+    bids,
+    blackboard,
+    data,
+    ell = np.zeros((2, 2)),
+    p = np.zeros((2, 2)),
+    capacity = np.ones((2, 2)) * 10,
+    u0 = np.zeros((2, 2)),
+    auction_options = options,
+  )
+  assert y[0, 1, 0] == 3.0
+  assert prices[1, 0] > 0
+
+  no_capacity_bids, memory_bids = decentralized_auction.define_bids(
+    omega,
+    np.zeros((2, 2)),
+    p = np.zeros((2, 2)),
+    data = data,
+    neighborhood = neighborhood,
+    rho = np.array([0.0, 5.0]),
+    auction_options = options,
+    latency = np.zeros((2, 2)),
+    fairness = np.zeros((2, 2)),
+    delta = np.zeros((2, 2)),
+  )
+  assert no_capacity_bids.empty
+  assert memory_bids.loc[0, "j"] == 1
+
+  neigh = decentralized_auction.neigh_dict_to_matrix(
+    {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+    2,
+  )
+  assert neigh[0, 1] == 1
+  stop, why = decentralized_auction.check_stopping_criteria(
+    0,
+    5,
+    blackboard = np.ones((2, 2)),
+    omega = np.zeros((2, 2)),
+    rmp_omega = np.ones((2, 2)),
+    bids = bids,
+    memory_bids = memory_bids,
+    tolerance = 1e-6,
+    total_runtime = 0.0,
+    time_limit = 10.0,
+  )
+  assert stop is True
+  assert why == "all load assigned"
+
+
+def test_decentralized_auction_rejects_ping_pong_in_same_round():
+  data = _auction_data()
+  options = {
+    "latency_weight": 0.0,
+    "fairness_weight": 0.0,
+    "epsilon": 0.1,
+    "eta": 0.0,
+    "zeta": 0.1,
+  }
+  bids, _ = decentralized_auction.define_bids(
+    omega = np.ones((2, 2)),
+    blackboard = np.ones((2, 2)),
+    p = np.zeros((2, 2)),
+    data = data,
+    neighborhood = np.array([[0, 1], [1, 0]]),
+    rho = np.zeros(2),
+    auction_options = options,
+    latency = np.zeros((2, 2)),
+    fairness = np.zeros((2, 2)),
+    delta = np.zeros((2, 2)),
+  )
+
+  y, _ = decentralized_auction.evaluate_bids(
+    bids,
+    blackboard = np.ones((2, 2)),
+    data = data,
+    ell = np.zeros((2, 2)),
+    p = np.zeros((2, 2)),
+    capacity = np.ones((2, 2)),
+    u0 = np.zeros((2, 2)),
+    auction_options = options,
+  )
+
+  assert not ((y.sum(axis=1) > 0) & (y.sum(axis=0) > 0)).any()
+
+
+def test_start_additional_replicas_redistributes_fractional_memory_remainder():
+  data = _auction_data()
+  data[None]["memory_requirement"] = {1: 4, 2: 4}
+
+  additional, rho = run_faasmadea.start_additional_replicas(
+    pd.DataFrame({"j": [1, 1], "f": [0, 1]}),
+    np.zeros((2, 2)), data, np.array([0.0, 5.0]),
+  )
+
+  assert additional[1].sum() == 1
+  assert additional[1, 0] == 1
+  assert rho[1] == 1.0
+
+
+def test_greedy_coordinator_solves_simple_offloading_instance():
+  coordinator = GreedyCoordinator()
+  instance = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+      "omega_bar": {(1, 1): 2.0, (2, 1): 0.0},
+      "beta": {(1, 1, 1): 0.0, (1, 2, 1): 5.0, (2, 1, 1): 5.0, (2, 2, 1): 0.0},
+      "gamma": {(1, 1): 1.0, (2, 1): 1.0},
+      "incoming_load": {(1, 1): 3.0, (2, 1): 0.1},
+      "x_bar": {(1, 1): 1.0, (2, 1): 0.1},
+      "r_bar": {(1, 1): 1.0, (2, 1): 0.0},
+      "demand": {(1, 1): 1.0, (2, 1): 1.0},
+      "max_utilization": {1: 10.0},
+      "memory_capacity": {1: 10.0, 2: 10.0},
+      "memory_requirement": {1: 1.0},
+    },
+    "sp_rho": np.array([0.0, 10.0]),
+  }
+
+  profit, isolated = coordinator._sort_by_offloading_profit(instance)
+  utilization = coordinator._compute_utilization(
+    instance[None]["demand"],
+    instance[None]["x_bar"],
+    np.zeros((2, 2, 1)),
+    np.zeros((2, 1)),
+    instance[None]["r_bar"],
+  )
+  solution = coordinator.solve(instance, {"sorting_rule": "product"})
+
+  assert isolated == []
+  assert profit.iloc[0]["product"] == 10.0
+  assert utilization[0, 0] == 1.0
+  assert solution["termination_condition"] == "done"
+  assert np.array(solution["y"]).reshape((2, 2, 1))[0, 1, 0] == 2.0
+
+
+def test_generate_data_random_components_cover_value_modes():
+  rng = np.random.default_rng(42)
+  graph = Graph()
+  graph.add_edge(0, 1)
+  limits = {
+    "weights": {
+      "edge_network_latency": {"min": 1, "max": 2},
+      "edge_bandwidth": {"min": 10, "max": 20},
+      "alpha": {"min": 1.0, "max": 2.0},
+      "beta_multiplier": {"min": 2.0, "max": 3.0},
+      "gamma": {"min": 0.1, "max": 0.2},
+      "delta_multiplier": {"min": 0.1, "max": 0.2},
+    },
+    "demand": {"values": [1.0, 2.0]},
+    "memory_capacity": {"values": [8, 16]},
+    "memory_requirement": {"min": 1, "max": 3},
+    "neighborhood": {"p": 1.0},
+  }
+
+  graph = generate_data.add_network_latency(graph, limits, rng)
+  demand = generate_data.generate_demand(2, 2, limits, rng)
+  neighborhood, generated_graph = generate_data.generate_neighborhood(2, limits, rng)
+  alpha, beta, gamma, delta = generate_data.generate_weights(
+    2,
+    2,
+    limits,
+    rng,
+    generated_graph,
+  )
+  memory_capacity, speedup = generate_data.generate_memory_capacity(2, limits, rng)
+  memory_requirement = generate_data.generate_memory_requirement(2, limits, rng)
+
+  assert graph.edges[0, 1]["network_latency"] >= 1
+  assert np.allclose(demand, np.array([1.0, 2.0]))
+  assert neighborhood[0, 1] == 1
+  assert len(alpha) == 2
+  assert beta.shape == (2, 2, 2)
+  assert gamma.shape == (2, 2)
+  assert delta.shape == (2, 2)
+  assert memory_capacity == [8, 16]
+  assert speedup == [1.0, 1.0]
+  assert len(memory_requirement) == 2
+
+
+def test_random_instance_data_builds_auto_load_limits():
+  limits = {
+    "Nn": {"min": 2, "max": 2},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"p": 1.0},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    },
+    "demand": {"values": [1.0]},
+    "memory_requirement": {"values": [2]},
+    "memory_capacity": {"values": [10, 12]},
+    "max_utilization": {"min": 0.5, "max": 0.5},
+    "load": {"values": ["auto"], "trace_type": "fixed_sum"},
+  }
+
+  data, load_limits, graph = generate_data.generate_data(
+    "random",
+    rng = np.random.default_rng(7),
+    limits = limits,
+  )
+
+  assert data[None]["Nn"][None] == 2
+  assert data[None]["Nf"][None] == 1
+  assert load_limits[0][0] > 0
+  assert graph.number_of_nodes() == 2
diff --git a/tests/test_analysis_extended.py b/tests/test_analysis_extended.py
new file mode 100644
index 0000000..dc0280f
--- /dev/null
+++ b/tests/test_analysis_extended.py
@@ -0,0 +1,155 @@
+import json
+from pathlib import Path
+
+import pandas as pd
+
+import fwd_analysis
+import what_if_analysis
+from logs_postprocessing import (
+  parse_log_file,
+  parse_faasmacro_log_file,
+  get_faasmacro_runtime,
+)
+
+
+def _write_lines(path: Path, lines: list[str]):
+  path.write_text("\n".join(lines + [""]), encoding="utf-8")
+
+
+def _write_model_outputs(folder: Path, model: str):
+  solution = pd.DataFrame({
+    "n0_f0_loc": [3.0, 0.0],
+    "n1_f0_loc": [4.0, 5.0],
+    "n0_f0_fwd": [2.0, 1.0],
+    "n1_f0_fwd": [1.0, 2.0],
+    "n0_f0": [0.0, 1.0],
+    "n1_f0": [2.0, 0.0],
+  })
+  replicas = pd.DataFrame({"n0_f0": [1.0, 1.0], "n1_f0": [2.0, 2.0]})
+  detailed = pd.DataFrame({
+    "n0_f0_n1_tot": [2.0, 1.0],
+    "n1_f0_n0_tot": [1.0, 2.0],
+    "n0_f0_n1_accepted": [1.5, 0.5],
+    "n1_f0_n0_accepted": [0.5, 1.5],
+  })
+  utilization = pd.DataFrame({"n0_f0": [0.5, 0.2], "n1_f0": [0.7, 0.8]})
+  solution.to_csv(folder / f"{model}_solution.csv", index=False)
+  replicas.to_csv(folder / f"{model}_replicas.csv", index=False)
+  detailed.to_csv(folder / f"{model}_detailed_fwd_solution.csv", index=False)
+  utilization.to_csv(folder / f"{model}_utilization.csv", index=False)
+
+
+# --- fwd_analysis ---
+
+def test_count_requests_two_timesteps(tmp_path):
+  _write_model_outputs(tmp_path, "ModelX")
+  (tmp_path / "base_instance_data.json").write_text(
+    json.dumps({"None": {"Nn": {"None": 2}, "Nf": {"None": 1}}}),
+    encoding="utf-8",
+  )
+
+  local, sentrecv, rejected = fwd_analysis.count_requests(str(tmp_path), "ModelX")
+
+  assert len(local["t"].unique()) == 2
+  assert "f0" in local.columns
+  assert "f0_sent" in sentrecv.columns
+  assert "f0_recv" in sentrecv.columns
+
+
+def test_filter_traces_classifies_only_local():
+  sentrecv = pd.DataFrame({"t": [0, 1], "sent": [0.0, 0.0]})
+  rejected = pd.DataFrame({"t": [0, 1], "all": [0.0, 0.0]})
+
+  only_local, with_offloading, with_reject = fwd_analysis.filter_traces(sentrecv, rejected)
+
+  assert only_local == [0, 1]
+  assert with_offloading == []
+  assert with_reject == []
+
+
+def test_filter_traces_classifies_with_offloading():
+  sentrecv = pd.DataFrame({"t": [0], "sent": [5.0]})
+  rejected = pd.DataFrame({"t": [0], "all": [0.0]})
+
+  only_local, with_offloading, with_reject = fwd_analysis.filter_traces(sentrecv, rejected)
+
+  assert only_local == []
+  assert with_offloading == [0]
+  assert with_reject == []
+
+
+# --- what_if_analysis ---
+
+def test_add_time_merges_best_solution_with_logs():
+  best = pd.DataFrame({
+    "exp": ["a", "a"],
+    "Nn": [2, 2],
+    "time": [0, 1],
+    "best_solution_it": [1, 2],
+    "obj": [10.0, 12.0],
+  })
+  logs = pd.DataFrame({
+    "exp": ["a", "a"],
+    "Nn": [2, 2],
+    "time": [0, 1],
+    "iteration": [1, 2],
+    "measured_total_time": [3.0, 5.0],
+  })
+  result = what_if_analysis.add_time(best, logs)
+
+  assert "measured_total_time" in result.columns
+  assert result.loc[0, "obj"] == 10.0
+
+
+def test_find_best_iterations_faas_macro(tmp_path):
+  (tmp_path / "base_instance_data.json").write_text(
+    json.dumps({"None": {"Nn": {"None": 2}}}),
+    encoding="utf-8",
+  )
+  _write_model_outputs(tmp_path, "LSP")
+  _write_lines(
+    tmp_path / "out.log",
+    [
+      "t = 0",
+      "    it = 0 (psi = 1.0)",
+      "        compute_social_welfare: DONE (ok; current: 10.0; sw: 12.0)",
+      "        rmp: DONE (optimal; obj = 5.0)",
+      "        sp: DONE  (ok; obj = 7.0; runtime = 0.3)",
+      "        best solution updated; obj = 12.0",
+      "        best centralized solution updated; obj = 5.0",
+      "    TOTAL RUNTIME [s] = 2.0 (wallclock: 3.0)",
+      "All solutions saved",
+    ],
+  )
+
+  sw, cobj = what_if_analysis.find_best_iterations(str(tmp_path))
+
+  assert len(sw) > 0
+  assert len(cobj) > 0
+  assert sw.loc[0, "method"] == "faas-macro"
+
+
+def test_get_faasmacro_runtime_handles_missing_columns():
+  logs = pd.DataFrame({
+    "exp": ["exp"],
+    "time": [0],
+    "iteration": [0],
+    "social_welfare_runtime": [1.0],
+  })
+  out = get_faasmacro_runtime(logs, "/tmp")
+  assert "tot" in out.columns
+
+
+def test_what_if_compute_minmaxavg_in_milestone_all_stats():
+  tvals = pd.DataFrame({
+    "Nn": [2, 3, 4],
+    "obj": [10.0, 12.0, 14.0],
+    "measured_total_time": [3.0, 5.0, 7.0],
+    "dev": [0.0, 20.0, 30.0],
+    "centralized_dev": [1.0, 2.0, 3.0],
+  })
+  metrics = what_if_analysis.compute_minmaxavg_in_milestone(tvals, 30)
+
+  assert set(metrics["which"].unique()) == {"min", "max", "avg"}
+  assert len(metrics) == 3
+  assert metrics.loc[metrics["which"] == "avg", "obj"].iloc[0] == 12.0
diff --git a/tests/test_benchmark_planar_3reg.py b/tests/test_benchmark_planar_3reg.py
new file mode 100644
index 0000000..b005fa1
--- /dev/null
+++ b/tests/test_benchmark_planar_3reg.py
@@ -0,0 +1,105 @@
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from benchmark_planar_3reg import (
+  aggregate_results,
+  build_base_config,
+  render_html_report,
+  run_benchmark,
+  write_report,
+)
+
+
+def test_aggregate_results_computes_mean_and_std():
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+    {"Nn": 20, "seed": 1, "model": "centralized", "objective": 14.0, "wallclock_s": 3.0},
+    {"Nn": 20, "seed": 0, "model": "hierarchical", "objective": 8.0, "wallclock_s": 2.0},
+    {"Nn": 20, "seed": 1, "model": "hierarchical", "objective": 12.0, "wallclock_s": 4.0},
+  ])
+
+  summary = aggregate_results(raw)
+  row = summary[(summary["Nn"] == 20) & (summary["model"] == "centralized")].iloc[0]
+
+  assert row["objective_mean"] == 12.0
+  assert row["objective_std"] == pytest.approx(2.8284271247)
+  assert row["wallclock_mean_s"] == 2.0
+  assert row["wallclock_std_s"] == pytest.approx(1.4142135623)
+  assert row["runs"] == 2
+
+
+def test_render_html_report_contains_summary_and_raw_tables(tmp_path: Path):
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+  ])
+  summary = pd.DataFrame([
+    {
+      "Nn": 20,
+      "model": "centralized",
+      "objective_mean": 10.0,
+      "objective_std": 0.0,
+      "wallclock_mean_s": 1.0,
+      "wallclock_std_s": 0.0,
+      "runs": 1,
+    },
+  ])
+
+  html_path = tmp_path / "report.html"
+  render_html_report(
+    summary,
+    raw,
+    html_path,
+    meta={"sizes": [20, 40, 50], "seeds": [0, 1, 2, 3, 4]},
+  )
+
+  text = html_path.read_text()
+  assert "<html" in text.lower()
+  assert "Summary" in text
+  assert "Raw Results" in text
+  assert "centralized" in text
+
+
+def test_build_base_config_uses_requested_sizes_and_seed(tmp_path: Path):
+  config = build_base_config(tmp_path, nn=20, seed=3)
+  assert config["limits"]["Nn"]["min"] == 20
+  assert config["limits"]["Nn"]["max"] == 20
+  assert config["seed"] == 3
+  assert config["solver_name"] == "gurobi_direct"
+  assert config["limits"]["neighborhood"] == {"type": "planar", "degree": 3}
+
+
+def test_run_benchmark_collects_three_models(monkeypatch, tmp_path: Path):
+  def fake_run(config, **_kwargs):
+    folder = tmp_path / f"{Path(config['base_solution_folder']).name}-out"
+    folder.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame({"LoadManagementModel": [11.0]}).to_csv(folder / "obj.csv", index=False)
+    pd.DataFrame({"runtime": [1.0]}).to_csv(folder / "runtime.csv", index=False)
+    pd.DataFrame({"0": ["optimal"]}).to_csv(folder / "termination_condition.csv", index=False)
+    return str(folder)
+
+  monkeypatch.setattr("benchmark_planar_3reg.run_centralized", fake_run)
+  monkeypatch.setattr("benchmark_planar_3reg.run_distributed", fake_run)
+  monkeypatch.setattr("benchmark_planar_3reg.run_hierarchical", fake_run)
+
+  raw = run_benchmark(output_root=tmp_path, sizes=[20], seeds=[0], solver_name="gurobi_direct")
+  assert set(raw["model"]) == {"centralized", "distributed", "hierarchical"}
+  assert len(raw) == 3
+
+
+def test_report_writer_creates_csv_and_html(tmp_path: Path):
+  raw = pd.DataFrame([
+    {"Nn": 20, "seed": 0, "model": "centralized", "objective": 10.0, "wallclock_s": 1.0},
+    {"Nn": 20, "seed": 1, "model": "centralized", "objective": 14.0, "wallclock_s": 3.0},
+  ])
+  summary = aggregate_results(raw)
+
+  write_report(raw, summary, tmp_path, meta={"sizes": [20], "seeds": [0, 1]})
+
+  assert (tmp_path / "raw_results.csv").exists()
+  assert (tmp_path / "summary.csv").exists()
+  html = (tmp_path / "summary.html").read_text()
+  assert "Planar Benchmark" in html
+  assert "Objective mean" in html
+  assert "Wallclock mean" in html
diff --git a/tests/test_bestresponse_e2e.py b/tests/test_bestresponse_e2e.py
new file mode 100644
index 0000000..434072d
--- /dev/null
+++ b/tests/test_bestresponse_e2e.py
@@ -0,0 +1,123 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_bestresponse import run_br_s, run_br_r, run_br_o
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "br_s": {"latency_weight": 0.0, "fairness_weight": 0.0},
+      "br_r": {"latency_weight": 0.0, "fairness_weight": 0.0},
+      "br_o": {"latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def _assert_artifacts(folder, column):
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert column in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj[column], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_br_s_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_s(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-S",
+  )
+
+
+def test_br_r_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_r(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-R",
+  )
+
+
+def test_br_o_artifacts(tmp_path):
+  _require_gurobi()
+  _assert_artifacts(
+    run_br_o(_e2e_config(tmp_path), parallelism=0, disable_plotting=True),
+    "FaaS-MABR-O",
+  )
+
+
+def test_br_s_reproducible(tmp_path):
+  _require_gurobi()
+  fa = run_br_s(
+    _e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  fb = run_br_s(
+    _e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+  oa = pd.read_csv(Path(fa, "obj.csv"))["FaaS-MABR-S"].to_numpy()
+  ob = pd.read_csv(Path(fb, "obj.csv"))["FaaS-MABR-S"].to_numpy()
+  assert oa.shape == ob.shape and oa.shape[0] >= 1
+  assert np.allclose(oa, ob)
+
+
+def test_br_r_reproducible(tmp_path):
+  _require_gurobi()
+  fa = run_br_r(
+    _e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  fb = run_br_r(
+    _e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+  oa = pd.read_csv(Path(fa, "obj.csv"))["FaaS-MABR-R"].to_numpy()
+  ob = pd.read_csv(Path(fb, "obj.csv"))["FaaS-MABR-R"].to_numpy()
+  assert oa.shape == ob.shape and oa.shape[0] >= 1
+  assert np.allclose(oa, ob)
diff --git a/tests/test_bestresponse_helpers.py b/tests/test_bestresponse_helpers.py
new file mode 100644
index 0000000..47e12b8
--- /dev/null
+++ b/tests/test_bestresponse_helpers.py
@@ -0,0 +1,214 @@
+import numpy as np
+import pandas as pd
+
+from decentralized_bestresponse import best_response_sweep
+
+
+def _base_data(Nn=4, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _full_neighborhood(Nn=4):
+  return np.ones((Nn, Nn)) - np.eye(Nn)
+
+
+def _opts():
+  return {"latency_weight": 0.0, "fairness_weight": 0.0}
+
+
+def test_sweep_ledger_is_order_dependent():
+  # buyers 0 and 1 both want 2 from the only capacity seller 2 (cap 2);
+  # in a fixed sequential sweep, node 0 (first) takes it all, node 1 gets none.
+  data = _base_data(Nn=3, Nf=1)
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0; omega[1, 0] = 2.0
+  residual = np.zeros((3, 1)); residual[2, 0] = 2.0
+  neighborhood = np.zeros((3, 3))
+  neighborhood[0, 2] = 1; neighborhood[1, 2] = 1
+  rho = np.zeros((3,))
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, rho, _opts(),
+    np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert y[0, 2, 0] == 2.0      # first node claimed the shared capacity
+  assert y[1, 2, 0] == 0.0      # later node saw the decremented ledger
+  assert placed == 2.0
+  assert rt == 0.0
+
+
+def test_sweep_fixed_order_is_deterministic():
+  data = _base_data()
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  omega = np.zeros((4, 1)); omega[0, 0] = 3.0
+  residual = np.zeros((4, 1)); residual[1, 0] = 2; residual[2, 0] = 2
+  args = (omega, residual, data, _full_neighborhood(), np.zeros((4,)),
+          _opts(), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  y1, *_ = best_response_sweep(*args, force_memory_bids=False,
+                               order="fixed", response="greedy")
+  y2, *_ = best_response_sweep(*args, force_memory_bids=False,
+                               order="fixed", response="greedy")
+  assert np.array_equal(y1, y2)
+
+
+def test_sweep_random_order_reproducible_with_same_seed():
+  data = _base_data()
+  for j in [1, 2, 3]:
+    data[None]["beta"][(1, j + 1, 1)] = float(j)
+  omega = np.zeros((4, 1)); omega[0, 0] = 2.0
+  residual = np.zeros((4, 1)); residual[1, 0] = 1; residual[2, 0] = 1; residual[3, 0] = 1
+  args = (omega, residual, data, _full_neighborhood(), np.zeros((4,)),
+          _opts(), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  y1, *_ = best_response_sweep(*args, force_memory_bids=False, order="random",
+                               response="greedy", rng=np.random.default_rng(7))
+  y2, *_ = best_response_sweep(*args, force_memory_bids=False, order="random",
+                               response="greedy", rng=np.random.default_rng(7))
+  assert np.array_equal(y1, y2)
+
+
+def test_sweep_threshold_excludes_unconvenient_seller():
+  data = _base_data(Nn=2, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = -1.0   # score -1.0 <= -0.05 => excluded
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 5
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, np.zeros((2,)), _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert placed == 0.0
+  assert len(mem) == 0
+
+
+def test_sweep_emits_memory_bids_when_no_capacity():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  residual = np.zeros((2, 1))                 # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0           # neighbour 1 has spare memory
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, rho, _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert placed == 0.0
+  assert list(mem[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_sweep_reopt_branch_caps_omega_via_reopt_fn():
+  # response="reopt" calls reopt_fn before placement; a fake fn halves omega.
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 4.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 10
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+  calls = {}
+
+  def fake_reopt(node, omega_ub_row):
+    calls["node"] = node
+    calls["ub"] = list(omega_ub_row)
+    return np.array([2.0]), 0.5     # capped to 2.0, 0.5s runtime
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, np.zeros((2,)), _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="reopt", reopt_fn=fake_reopt)
+
+  assert calls["node"] == 0
+  assert calls["ub"] == [10.0]      # accessible neighbour capacity
+  assert placed == 2.0              # placed the capped amount, not 4.0
+  assert rt == 0.5
+
+
+def test_sweep_emits_block_a_memory_bid_for_capacity_and_memory_seller():
+  # Block A fires when buyer has UNMET demand (shortfall) AND a neighbour is
+  # both a capacity seller that passed the admission threshold (in `score`)
+  # AND a memory seller (rho > 0).
+  # Setup: buyer i=0 wants 5, seller j=1 has capacity 2 → shortfall after
+  # placing 2.  j=1 also has rho=3 → it is a memory seller.
+  # Block A emits (0,1,0) because j=1 is in score AND potential_memory.
+  # Block B emits nothing because potential_memory - potential_capacity = {}
+  # (j=1 has residual_capacity[1,0]=2 >= 1, so it IS in potential_capacity).
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 5.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 2.0
+  rho = np.zeros((2,)); rho[1] = 3.0
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  y, mem, n_active, placed, rt = best_response_sweep(
+    omega, residual, data, neighborhood, rho, _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy")
+
+  assert placed == 2.0
+  assert len(mem) == 1
+  assert list(mem[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_sweep_revises_existing_buyer_allocation_as_coordinate_delta():
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 1.0
+  data[None]["beta"][(1, 3, 1)] = 5.0
+  target_omega = np.zeros((3, 1)); target_omega[0, 0] = 2.0
+  residual = np.zeros((3, 1)); residual[2, 0] = 2.0
+  current_y = np.zeros((3, 3, 1)); current_y[0, 1, 0] = 2.0
+  neighborhood = np.zeros((3, 3)); neighborhood[0, 1:] = 1
+
+  delta_y, _, n_active, placed, _ = best_response_sweep(
+    target_omega, residual, data, neighborhood, np.zeros(3), _opts(),
+    np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+    order="fixed", response="greedy", current_y=current_y,
+  )
+
+  assert n_active == 1
+  assert placed == 2.0
+  assert delta_y[0, 1, 0] == -2.0
+  assert delta_y[0, 2, 0] == 2.0
+  assert delta_y.sum() == 0.0
+
+
+def test_sweep_counts_buyer_that_cannot_place_as_active():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+
+  _, _, n_active, placed, _ = best_response_sweep(
+    omega, np.zeros((2, 1)), data,
+    np.array([[0.0, 1.0], [1.0, 0.0]]), np.zeros(2), _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+    order="fixed", response="greedy",
+  )
+
+  assert n_active == 1
+  assert placed == 0.0
+
+
+def test_sweep_force_memory_bids_includes_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  residual = np.zeros((2, 1)); residual[1, 0] = 1.0
+  rho = np.zeros(2); rho[1] = 2.0
+
+  _, memory_bids, _, _, _ = best_response_sweep(
+    omega, residual, data, np.array([[0.0, 1.0], [1.0, 0.0]]),
+    rho, _opts(), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=True, order="fixed", response="greedy",
+  )
+
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
diff --git a/tests/test_bestresponse_reopt.py b/tests/test_bestresponse_reopt.py
new file mode 100644
index 0000000..62f14eb
--- /dev/null
+++ b/tests/test_bestresponse_reopt.py
@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import numpy as np
+import pyomo.environ as pyo
+import pytest
+
+from run_centralized_model import init_problem, update_data, get_current_load
+from decentralized_bestresponse import reoptimize_node
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _tiny_instance(tmp_path: Path):
+  limits = {
+    "Nn": {"min": 3, "max": 3},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"p": 1.0},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 1.5, "max": 2.0},
+      "gamma": {"min": 0.05, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.2},
+    },
+    "demand": {"values": [1.0]},
+    "memory_capacity": {"values": [12, 12, 12]},
+    "memory_requirement": {"values": [2]},
+    "max_utilization": {"min": 0.7, "max": 0.7},
+    "load": {"trace_type": "clipped",
+             "min": {"min": 2.0, "max": 2.0},
+             "max": {"min": 3.0, "max": 3.0}},
+  }
+  base, traces, agents, graph = init_problem(
+    limits, "clipped", 4, 21, str(tmp_path))
+  loadt = get_current_load(traces, agents, 1)
+  data = update_data(base, {"incoming_load": loadt})
+  return data
+
+
+def test_reoptimize_node_respects_cap_and_reduces_offload(tmp_path):
+  _require_gurobi()
+  data = _tiny_instance(tmp_path)
+  Nf = data[None]["Nf"][None]
+
+  loose = np.full(Nf, 1e9)
+  tight = np.zeros(Nf)        # no neighbour capacity at all
+
+  omega_loose, rt1 = reoptimize_node(
+    0, loose, data, "gurobi", {"OutputFlag": 0}, 0, use_fixed_r=False)
+  omega_tight, rt2 = reoptimize_node(
+    0, tight, data, "gurobi", {"OutputFlag": 0}, 0, use_fixed_r=False)
+
+  assert (omega_tight <= tight + 1e-6).all()    # cap respected (omega ~ 0)
+  assert omega_tight.sum() <= omega_loose.sum() + 1e-6  # capping cannot raise offload
+  assert rt1 >= 0 and rt2 >= 0
diff --git a/tests/test_bestresponse_run.py b/tests/test_bestresponse_run.py
new file mode 100644
index 0000000..71910cd
--- /dev/null
+++ b/tests/test_bestresponse_run.py
@@ -0,0 +1,89 @@
+import numpy as np
+import networkx as nx
+
+import decentralized_bestresponse as mabr
+
+
+def test_run_br_o_uses_fixed_replicas_and_does_not_mutate_options(tmp_path, monkeypatch):
+  seen = {}
+  base_data = {None: {"Nn": {None: 1}, "Nf": {None: 1}, "neighborhood": {(1, 1): 0}}}
+
+  monkeypatch.setattr(mabr, "init_problem",
+    lambda *a, **k: (base_data, {}, [], nx.empty_graph(1)))
+  monkeypatch.setattr(mabr, "load_solution",
+    lambda folder, model: ("s", "rep", "fwd", None, None), raising=False)
+  monkeypatch.setattr(mabr, "encode_solution",
+    lambda Nn, Nf, s, d, r, t: (None, None, None, np.array([[3]]), None), raising=False)
+  monkeypatch.setattr(mabr, "LSP", lambda: "LSP")
+  monkeypatch.setattr(mabr, "LSP_fixedr", lambda: "LSP_fixedr", raising=False)
+  monkeypatch.setattr(mabr, "LSPr", lambda: seen.setdefault("spr", "LSPr"))
+  monkeypatch.setattr(
+    mabr, "LSPr_fixedr", lambda: seen.setdefault("spr", "LSPr_fixedr"),
+    raising=False,
+  )
+
+  def _solve_subproblem(sp_data, agents, sp, *a):
+    seen["sp"] = sp
+    seen["r_bar"] = dict(sp_data[None].get("r_bar", {}))
+    return (sp_data, np.zeros((1, 1)), None, None, np.zeros((1, 1)),
+            np.ones((1, 1)), np.array([5.0]), np.zeros((1, 1)),
+            {"tot": 0.0}, {"tot": "ok"}, {"tot": 0.0})
+
+  monkeypatch.setattr(mabr, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(mabr, "get_current_load", lambda *a: {})
+  monkeypatch.setattr(mabr, "update_data", lambda data, u: data)
+  monkeypatch.setattr(mabr, "compute_residual_capacity",
+    lambda *a: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))))
+  def _best_response_sweep(*args, **kwargs):
+    seen["coordination_rho"] = np.array(args[4], copy=True)
+    return (
+      np.zeros((1, 1, 1)),
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": []}),
+      0, 0.0, 0.0,
+    )
+
+  monkeypatch.setattr(mabr, "best_response_sweep", _best_response_sweep)
+  monkeypatch.setattr(mabr, "combine_solutions",
+    lambda *a: {"sp": {"x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)),
+                       "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1))}})
+  monkeypatch.setattr(mabr, "compute_centralized_objective", lambda *a: -1.0)
+  monkeypatch.setattr(mabr, "check_feasibility", lambda *a: (True, "ok"))
+  decoded = []
+
+  def _decode(sp_data, solution, complete, arg):
+    decoded.append(solution)
+    assert solution is not None
+    return complete, None, 1.0
+
+  monkeypatch.setattr(mabr, "decode_solutions", _decode)
+  monkeypatch.setattr(mabr, "join_complete_solution", lambda comp: ({}, {}, {}))
+  monkeypatch.setattr(mabr, "save_checkpoint", lambda *a: None)
+  monkeypatch.setattr(mabr, "save_solution", lambda *a: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {"general": {"TimeLimit": 10},
+                       "br_o": {}},
+    "max_iterations": 1, "patience": 1, "max_steps": 1,
+    "min_run_time": 0, "max_run_time": 0, "run_time_step": 1,
+    "checkpoint_interval": 1, "verbose": 0,
+    "opt_solution_folder": "centralized-folder",
+  }
+
+  mabr.run_br_o(config, parallelism=0, disable_plotting=True)
+
+  assert seen["sp"] == "LSP_fixedr"
+  assert seen["spr"] == "LSPr_fixedr"
+  assert seen["r_bar"] == {(1, 1): 3}
+  assert (seen["coordination_rho"] == 0).all()
+  assert len(decoded) == 2
+  assert "latency_weight" not in config["solver_options"]["br_o"]
+
+
+def test_mabr_runtime_excludes_reoptimization_before_amortizing():
+  compute = getattr(mabr, "compute_sweep_runtime", None)
+  assert compute is not None
+  assert compute(elapsed=11.0, reopt_runtime=10.0, n_active=2) == 10.5
diff --git a/tests/test_bestresponse_wiring.py b/tests/test_bestresponse_wiring.py
new file mode 100644
index 0000000..641ef52
--- /dev/null
+++ b/tests/test_bestresponse_wiring.py
@@ -0,0 +1,37 @@
+import json
+from pathlib import Path
+
+import run
+
+
+def test_methods_choice_accepts_faas_br(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-br-s", "faas-br-r", "faas-br-o"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert {"faas-br-s", "faas-br-r", "faas-br-o"}.issubset(set(args.methods))
+
+
+def test_run_module_exposes_br_runners():
+  for name in ("run_br_s", "run_br_r", "run_br_o"):
+    assert callable(getattr(run, name))
+
+
+def test_planar_config_has_br_blocks():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  so = config["solver_options"]
+  assert "br_s" in so and "br_r" in so and "br_o" in so
+
+
+def test_compare_results_palette_includes_mabr():
+  import inspect
+  import compare_results
+  src = inspect.getsource(compare_results)
+  assert '"FaaS-MABR-S"' in src and '"FaaS-MABR-R"' in src and '"FaaS-MABR-O"' in src
+
+
+def test_compare_results_defaults_include_mabr(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  import compare_results
+  args = compare_results.parse_arguments()
+  assert {"FaaS-MABR-S", "FaaS-MABR-R", "FaaS-MABR-O"}.issubset(set(args.models))
diff --git a/tests/test_centralized_feasibility.py b/tests/test_centralized_feasibility.py
new file mode 100644
index 0000000..42c11ae
--- /dev/null
+++ b/tests/test_centralized_feasibility.py
@@ -0,0 +1,183 @@
+import numpy as np
+import pytest
+
+from utils.centralized import validate_centralized_solution
+
+
+@pytest.fixture
+def solution():
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "incoming_load": {(1, 1): 4.0, (2, 1): 4.0},
+      "demand": {(1, 1): 0.1, (2, 1): 0.1},
+      "max_utilization": {1: 0.8},
+      "memory_requirement": {1: 2},
+      "memory_capacity": {1: 4, 2: 4},
+      "neighborhood": {
+        (1, 1): 0, (1, 2): 0, (2, 1): 1, (2, 2): 0,
+      },
+    }
+  }
+  x = np.array([[4.0], [2.0]])
+  y = np.zeros((2, 2, 1))
+  y[1, 0, 0] = 2.0
+  z = np.zeros((2, 1))
+  r = np.ones((2, 1))
+  return x, y, z, r, data
+
+
+def test_accepts_valid_arrays(solution):
+  validate_centralized_solution(*solution)
+
+
+def test_accepts_sparse_neighborhood_with_zero_defaults(solution):
+  x, y, z, r, data = solution
+  data[None]["neighborhood"] = {(2, 1): 1}
+  validate_centralized_solution(x, y, z, r, data)
+
+
+def test_accepts_values_within_tolerance(solution):
+  x, y, z, r, data = solution
+  z[0, 0] = -0.5e-6
+  r[0, 0] = 1 + 0.5e-6
+  validate_centralized_solution(x, y, z, r, data)
+
+
+def test_accepts_unsigned_zero_replicas_for_zero_load(solution):
+  x, y, z, _, data = solution
+  x[:] = 0
+  y[:] = 0
+  for index in data[None]["incoming_load"]:
+    data[None]["incoming_load"][index] = 0
+  validate_centralized_solution(
+    x, y, z, np.zeros((2, 1), dtype = np.uint64), data
+  )
+
+
+@pytest.mark.parametrize(
+  "tolerance",
+  [-1, np.nan, np.inf, -np.inf, "bad", "1e-6", None, 1 + 1j],
+)
+def test_rejects_invalid_tolerance(solution, tolerance):
+  with pytest.raises(ValueError, match = "tolerance"):
+    validate_centralized_solution(*solution, tolerance = tolerance)
+
+
+@pytest.mark.parametrize("edge", [(0, 0, 0), (0, 1, 0), (1, 1, 0)])
+def test_rejects_non_neighbor_and_self_offload(solution, edge):
+  x, y, z, r, data = solution
+  y[:] = 0
+  y[edge] = 1
+  x[edge[0], 0] = 3
+  with pytest.raises(ValueError, match = rf"offload_only_to_neighbors \({edge[0] + 1},{edge[1] + 1},1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_ping_pong(solution):
+  x, y, z, r, data = solution
+  x[:] = 3
+  data[None]["neighborhood"][(1, 2)] = 1
+  y[1, 0, 0] = 1
+  y[0, 1, 0] = 1
+  with pytest.raises(ValueError, match = r"no_ping_pong \(1,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_traffic_loss(solution):
+  x, y, z, r, data = solution
+  x[0, 0] = 1
+  with pytest.raises(ValueError, match = r"no_traffic_loss \(1,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_utilization_above_replica_capacity(solution):
+  x, y, z, r, data = solution
+  data[None]["demand"][(2, 1)] = 0.5
+  with pytest.raises(ValueError, match = r"utilization_equilibrium \(2,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_overprovisioning(solution):
+  x, y, z, r, data = solution
+  r[0, 0] = 2
+  with pytest.raises(ValueError, match = r"utilization_equilibrium2 \(1,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_memory_excess(solution):
+  x, y, z, r, data = solution
+  data[None]["memory_capacity"][1] = 1
+  with pytest.raises(ValueError, match = r"residual_capacity \(1"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+@pytest.mark.parametrize("name,index", [("x", (0, 0)), ("y", (0, 1, 0)), ("z", (0, 0)), ("r", (0, 0))])
+def test_rejects_negative_variables(solution, name, index):
+  x, y, z, r, data = solution
+  arrays = {"x": x, "y": y, "z": z, "r": r}
+  arrays[name][index] = -1e-3
+  shown_index = ",".join(str(i + 1) for i in index)
+  domain = "NonNegativeIntegers" if name == "r" else "NonNegativeReals"
+  with pytest.raises(ValueError, match = rf"{name} domain {domain} \({shown_index}\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+def test_rejects_non_integer_replicas(solution):
+  x, y, z, r, data = solution
+  r[0, 0] = 1.5
+  with pytest.raises(ValueError, match = r"r domain NonNegativeIntegers \(1,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+@pytest.mark.parametrize(
+  "value",
+  [np.nan, np.inf, -np.inf, 1 + 1j, "bad", pytest.param(object(), id = "object")],
+)
+@pytest.mark.parametrize(
+  "name,index,domain",
+  [
+    ("x", (0, 0), "NonNegativeReals"),
+    ("y", (0, 0, 0), "NonNegativeReals"),
+    ("z", (0, 0), "NonNegativeReals"),
+    ("r", (0, 0), "NonNegativeIntegers"),
+  ],
+)
+def test_rejects_invalid_variable_values(solution, name, index, domain, value):
+  x, y, z, r, data = solution
+  arrays = {"x": x, "y": y, "z": z, "r": r}
+  dtype = complex if isinstance(value, complex) else object
+  if isinstance(value, float):
+    dtype = float
+  arrays[name] = arrays[name].astype(dtype)
+  arrays[name][index] = value
+  shown_index = ",".join(str(i + 1) for i in index)
+  with pytest.raises(ValueError, match = rf"{name} domain {domain} \({shown_index}\)"):
+    validate_centralized_solution(
+      arrays["x"], arrays["y"], arrays["z"], arrays["r"], data
+    )
+
+
+@pytest.mark.parametrize(
+  "value,dtype",
+  [("bad", object), ([1, 2], object), (1 + 1j, complex)],
+)
+def test_reports_actual_non_first_invalid_index(solution, value, dtype):
+  x, y, z, r, data = solution
+  x = x.astype(dtype)
+  x[1, 0] = value
+  with pytest.raises(ValueError, match = r"x domain NonNegativeReals \(2,1\)"):
+    validate_centralized_solution(x, y, z, r, data)
+
+
+@pytest.mark.parametrize(
+  "name,bad_shape",
+  [("x", (1, 1)), ("y", (2, 1, 1)), ("z", (2, 2)), ("r", (1, 1))],
+)
+def test_rejects_bad_shapes(solution, name, bad_shape):
+  x, y, z, r, data = solution
+  arrays = {"x": x, "y": y, "z": z, "r": r}
+  arrays[name] = np.zeros(bad_shape)
+  with pytest.raises(ValueError, match = rf"{name} shape"):
+    validate_centralized_solution(arrays["x"], arrays["y"], arrays["z"], arrays["r"], data)
diff --git a/tests/test_convert_data_format.py b/tests/test_convert_data_format.py
new file mode 100644
index 0000000..53b65e0
--- /dev/null
+++ b/tests/test_convert_data_format.py
@@ -0,0 +1,117 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+import yaml
+
+from convert_data_format import (
+  build_arrivals_list,
+  build_base_spec_dict,
+  compute_avg_demand,
+  load_and_convert,
+  update_arrivals_info,
+  update_functions_info,
+  update_nodes_info,
+)
+
+
+def _sample_requests():
+  return {
+    0: {0: np.array([1.0, 2.0]), 1: np.array([3.0, 4.0])},
+    1: {0: np.array([5.0, 6.0]), 1: np.array([7.0, 8.0])},
+  }
+
+
+def _sample_instance_data():
+  return {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 2},
+      "memory_requirement": {1: 128, 2: 256},
+      "memory_capacity": {1: 1024, 2: 2048},
+      "demand": {
+        (1, 1): 1.0,
+        (2, 1): 3.0,
+        (1, 2): 2.0,
+        (2, 2): 6.0,
+      },
+    }
+  }
+
+
+def test_build_base_spec_dict_defaults():
+  spec = build_base_spec_dict()
+  assert spec["classes"][0]["name"] == "critical"
+  assert spec["nodes"] == []
+  assert spec["functions"] == []
+  assert spec["arrivals"] == []
+
+
+def test_build_arrivals_list_layout():
+  arrivals = build_arrivals_list(_sample_requests(), mt = 0, Mt = 2, ts = 1)
+  assert len(arrivals) == 2
+  assert len(arrivals[0]) == 4
+  assert arrivals[0][0] == {"node": "n1", "function": "f1", "rate": 1.0}
+  assert arrivals[1][-1] == {"node": "n2", "function": "f2", "rate": 8.0}
+
+
+def test_update_arrivals_info_is_pure():
+  base = build_base_spec_dict()
+  updated = update_arrivals_info(base, _sample_requests(), t = 1)
+  assert len(base["arrivals"]) == 0
+  assert len(updated["arrivals"]) == 4
+  assert updated["arrivals"][0]["rate"] == 2.0
+
+
+def test_compute_avg_demand_returns_mean_and_sample_std():
+  demand = _sample_instance_data()[None]["demand"]
+  mean, std = compute_avg_demand(demand, Nn = 2, Nf = 2)
+
+  assert mean[0] == pytest.approx(2.0)
+  assert mean[1] == pytest.approx(4.0)
+  assert std[0] == pytest.approx(np.sqrt(2.0))
+  assert std[1] == pytest.approx(np.sqrt(8.0))
+
+
+def test_update_functions_info_and_nodes_info():
+  base = build_base_spec_dict()
+  instance_data = _sample_instance_data()
+
+  with_nodes = update_nodes_info(base, instance_data)
+  assert [n["name"] for n in with_nodes["nodes"]] == ["n1", "n2", "cloud"]
+
+  with_functions = update_functions_info(base, instance_data)
+  assert [f["name"] for f in with_functions["functions"]] == ["f1", "f2"]
+  assert with_functions["functions"][0]["memory"] == 128
+  assert with_functions["classes"][0]["max_resp_time"] > 0
+
+
+def test_load_and_convert_writes_base_spec(tmp_path: Path):
+  instance_folder = tmp_path / "inst"
+  dest_folder = tmp_path / "out"
+  instance_folder.mkdir()
+
+  base_payload = {
+    "None": {
+      "Nn": {"None": 2},
+      "Nf": {"None": 2},
+      "memory_requirement": {"1": 128, "2": 256},
+      "memory_capacity": {"1": 1024, "2": 2048},
+      "demand": {
+        "(1, 1)": 1.0,
+        "(2, 1)": 3.0,
+        "(1, 2)": 2.0,
+        "(2, 2)": 6.0,
+      },
+    }
+  }
+  (instance_folder / "base_instance_data.json").write_text(json.dumps(base_payload))
+  (instance_folder / "load_limits.json").write_text(json.dumps({"0": {"0": {"min": 1, "max": 2}}}))
+
+  spec = load_and_convert(str(instance_folder), str(dest_folder))
+  assert len(spec["nodes"]) == 3
+  assert (dest_folder / "base_spec.yaml").exists()
+
+  loaded = yaml.safe_load((dest_folder / "base_spec.yaml").read_text())
+  assert loaded["functions"][0]["name"] == "f1"
diff --git a/tests/test_coverage_expansion.py b/tests/test_coverage_expansion.py
new file mode 100644
index 0000000..8196ad5
--- /dev/null
+++ b/tests/test_coverage_expansion.py
@@ -0,0 +1,451 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+def test_hierarchical_auction_public_imports():
+  import hierarchical_auction as ha
+
+  assert ha.AcceptedAllocation is not None
+  assert ha.TokenRequest is not None
+  assert ha.HierarchicalAuctionEngine is not None
+  assert ha.LevelResult is not None
+
+import compare_results
+import fwd_analysis
+import postprocessing
+import run
+import what_if_analysis
+from logs_postprocessing import (
+  get_faasmacro_runtime,
+  parse_faasmacro_log_file,
+  parse_faasmadea0_log_file,
+  parse_logs,
+)
+
+
+def _write_lines(path: Path, lines: list[str]):
+  path.write_text("\n".join(lines + [""]), encoding = "utf-8")
+
+
+def _write_model_outputs(folder: Path, model: str):
+  solution = pd.DataFrame({
+    "n0_f0_loc": [3.0, 0.0],
+    "n1_f0_loc": [4.0, 5.0],
+    "n0_f0_fwd": [2.0, 1.0],
+    "n1_f0_fwd": [1.0, 2.0],
+    "n0_f0": [0.0, 1.0],
+    "n1_f0": [2.0, 0.0],
+  })
+  replicas = pd.DataFrame({"n0_f0": [1.0, 1.0], "n1_f0": [2.0, 2.0]})
+  detailed = pd.DataFrame({
+    "n0_f0_n1_tot": [2.0, 1.0],
+    "n1_f0_n0_tot": [1.0, 2.0],
+    "n0_f0_n1_accepted": [1.5, 0.5],
+    "n1_f0_n0_accepted": [0.5, 1.5],
+  })
+  utilization = pd.DataFrame({"n0_f0": [0.5, 0.2], "n1_f0": [0.7, 0.8]})
+  solution.to_csv(folder / f"{model}_solution.csv", index = False)
+  replicas.to_csv(folder / f"{model}_replicas.csv", index = False)
+  detailed.to_csv(folder / f"{model}_detailed_fwd_solution.csv", index = False)
+  utilization.to_csv(folder / f"{model}_utilization.csv", index = False)
+  pd.DataFrame({"SP/coord": [10.0, 11.0]}).to_csv(folder / "obj.csv", index = False)
+
+
+def test_parse_faasmacro_log_file_extracts_iterations_and_best_solutions(tmp_path):
+  _write_lines(
+    tmp_path / "out.log",
+    [
+      "t = 0",
+      "    it = 0 (psi = 1.0)",
+      "        compute_social_welfare: DONE (ok; current: 10.0; sw: 12.0; runtime = 0.1)",
+      "        rmp: DONE (optimal; obj = 5.0; runtime = 0.2)",
+      "        sp: DONE  (ok; obj = 7.0; runtime = 0.3)",
+      "        best solution updated; obj = 12.0",
+      "        best centralized solution updated; obj = 5.0",
+      "    it = 1 (psi = 0.5)",
+      "        compute_social_welfare: DONE (ok; current: 11.0; sw: 13.0)",
+      "        rmp: DONE (optimal; obj = 4.0)",
+      "        sp: DONE  (ok; obj = 6.0; runtime = 0.4)",
+      "    TOTAL RUNTIME [s] = 2.0 (wallclock: 3.0)",
+      "All solutions saved",
+    ],
+  )
+
+  logs_df, best = parse_faasmacro_log_file(str(tmp_path), "exp", pd.DataFrame(), {}, 2)
+
+  assert list(logs_df["iteration"]) == [0, 1]
+  assert logs_df.loc[0, "social_welfare_runtime"] == 0.1
+  assert pd.isna(logs_df.loc[1, "coord_runtime"])
+  assert list(logs_df["measured_total_time"]) == [2.0, 2.0]
+  assert best["social_welfare"].loc[0, "obj"] == 12.0
+  assert best["centralized"].loc[0, "obj"] == 5.0
+
+
+def test_parse_faasmadea0_log_file_reuses_step_sp_runtime(tmp_path):
+  _write_lines(
+    tmp_path / "out.log",
+    [
+      "t = 0",
+      "    sp: DONE  (ok; obj = 12.0; runtime = 2.5)",
+      "    it = 0",
+      "        define_bids: DONE; runtime = 0.5)",
+      "        evaluate_bids: DONE; runtime = 0.25)",
+      "        best solution updated; obj = 8.0",
+      "        best centralized solution updated; obj = 7.0",
+      "    TOTAL RUNTIME [s] = 3.25 (wallclock: 4.0)",
+      "All solutions saved",
+    ],
+  )
+
+  logs_df, best = parse_faasmadea0_log_file(str(tmp_path), "exp0", pd.DataFrame(), {}, 3)
+
+  assert logs_df.loc[0, "sp_runtime"] == 2.5
+  assert logs_df.loc[0, "define_bids_runtime"] == 0.5
+  assert best["social_welfare"].loc[0, "best_solution_it"] == 0
+
+
+def test_parse_logs_dispatches_macro_and_madea_runs(tmp_path):
+  macro = tmp_path / "macro"
+  madea = tmp_path / "madea"
+  macro.mkdir()
+  madea.mkdir()
+  for folder, extra_file in [(macro, "LRMP_solution.csv"), (madea, None)]:
+    (folder / "LSP_solution.csv").write_text("", encoding = "utf-8")
+    if extra_file:
+      (folder / extra_file).write_text("", encoding = "utf-8")
+    (folder / "base_instance_data.json").write_text(
+      json.dumps({"None": {"Nn": {"None": 2}}}),
+      encoding = "utf-8",
+    )
+  _write_lines(
+    macro / "out.log",
+    [
+      "t = 0",
+      "    it = 0 (psi = 1.0)",
+      "        compute_social_welfare: DONE (ok; current: 10.0; sw: 12.0)",
+      "        rmp: DONE (optimal; obj = 5.0)",
+      "        sp: DONE  (ok; obj = 7.0; runtime = 0.3)",
+      "    TOTAL RUNTIME [s] = 2.0 (wallclock: 3.0)",
+      "All solutions saved",
+    ],
+  )
+  _write_lines(
+    madea / "out.log",
+    [
+      "t = 0",
+      "    it = 0",
+      "        sp: DONE  (ok; obj = 12.0; runtime = 2.5)",
+      "        define_bids: DONE; runtime = 0.5)",
+      "        evaluate_bids: DONE; runtime = 0.25)",
+      "    TOTAL RUNTIME [s] = 3.25 (wallclock: 4.0)",
+      "All solutions saved",
+    ],
+  )
+
+  logs_df, _ = parse_logs(str(tmp_path))
+
+  assert set(logs_df["exp"]) == {"macro", "madea"}
+  assert list(logs_df["Nn"].unique()) == [2]
+
+
+def test_get_faasmacro_runtime_computes_iteration_totals(tmp_path):
+  logs = pd.DataFrame({
+    "exp": ["exp", "exp"],
+    "time": [0, 0],
+    "iteration": [0, 1],
+    "social_welfare_runtime": [1.0, 2.0],
+    "coord_runtime": [3.0, 4.0],
+    "sp_runtime": [5.0, 6.0],
+  })
+
+  out = get_faasmacro_runtime(logs, str(tmp_path))
+
+  assert out.loc[0, "tot"] == 21.0
+  assert out.loc[0, "min"] == 9.0
+  assert out.loc[0, "max"] == 12.0
+
+
+def test_postprocessing_loads_counts_and_detects_ping_pong(tmp_path):
+  _write_model_outputs(tmp_path, "ModelA")
+
+  solution, replicas, detailed, utilization, obj = postprocessing.load_solution(
+    str(tmp_path), "ModelA"
+  )
+  assert "FaaS-MACrO" in obj.columns
+  assert list(utilization.columns) == ["n0_f0", "n1_f0"]
+
+  local, fwd, rejected, replica_counts, ping_pong = postprocessing.load_models_results(
+    str(tmp_path),
+    ["ModelA"],
+    ["Readable"],
+  )
+
+  assert local["by_node"]["tot"].loc["n0", "Readable"] == 3.0
+  assert fwd["by_function"]["tot"].loc["f0", "Readable"] == 6.0
+  assert rejected["by_node"]["tot"].loc["n1", "Readable"] == 2.0
+  assert replica_counts["by_node"]["tot"].loc["n1", "Readable"] == 4.0
+  assert ping_pong["Readable"]
+  assert detailed.loc[0, "n0_f0_n1_tot"] == 2.0
+  assert solution.loc[1, "n0_f0"] == 1.0
+
+
+def test_postprocessing_plot_helpers_write_outputs(tmp_path):
+  df = pd.DataFrame({
+    "n0_f0": [1.0, 2.0],
+    "n1_f0": [3.0, 4.0],
+    "node": ["n0", "n1"],
+    "function": ["f0", "f0"],
+  })
+
+  tot = postprocessing.plot_count(df, "function", str(tmp_path), plot_all = False)
+  postprocessing.plot_global_count(
+    {"by_function": {"tot": tot[["tot"]]}},
+    "local",
+    plot_folder = str(tmp_path),
+  )
+
+  assert (tmp_path / "function_tot.png").exists()
+  assert (tmp_path / "local-by_function-tot.png").exists()
+
+
+def test_fwd_analysis_counts_and_filters_requests(tmp_path):
+  _write_model_outputs(tmp_path, "ModelA")
+  (tmp_path / "base_instance_data.json").write_text(
+    json.dumps({"None": {"Nn": {"None": 2}, "Nf": {"None": 1}}}),
+    encoding = "utf-8",
+  )
+
+  local, sentrecv, rejected = fwd_analysis.count_requests(str(tmp_path), "ModelA")
+  only_local, with_offloading, with_reject = fwd_analysis.filter_traces(sentrecv, rejected)
+
+  assert local.groupby("t")["all"].sum().loc[0] == 7.0
+  assert sentrecv.groupby("t")["sent"].sum().loc[0] == 3.0
+  assert rejected.groupby("t")["all"].sum().loc[1] == 1.0
+  assert only_local == []
+  assert with_offloading == []
+  assert with_reject == [0, 1]
+
+
+def test_what_if_small_dataframe_helpers(tmp_path):
+  best = pd.DataFrame({
+    "exp": ["a"],
+    "Nn": [2],
+    "time": [0],
+    "best_solution_it": [1],
+    "obj": [10.0],
+  })
+  logs = pd.DataFrame({
+    "exp": ["a"],
+    "Nn": [2],
+    "time": [0],
+    "iteration": [1],
+    "measured_total_time": [3.0],
+  })
+  with_time = what_if_analysis.add_time(best, logs)
+  metrics = what_if_analysis.compute_minmaxavg_in_milestone(
+    pd.DataFrame({
+      "Nn": [2, 3],
+      "obj": [10.0, 12.0],
+      "measured_total_time": [3.0, 5.0],
+      "dev": [0.0, 20.0],
+      "centralized_dev": [1.0, 2.0],
+    }),
+    30,
+  )
+
+  assert with_time.loc[0, "measured_total_time"] == 3.0
+  assert set(metrics["which"]) == {"min", "max", "avg"}
+
+
+def test_compare_results_plotters_and_csv_loader(tmp_path):
+  models = ["LoadManagementModel", "FaaS-MACrO"]
+  obj = pd.DataFrame({
+    "Nn": [2, 2, 3, 3],
+    "dev": [0.0, 1.0, 2.0, 3.0],
+    "LoadManagementModel": [10.0, 11.0, 12.0, 13.0],
+    "FaaS-MACrO": [9.0, 10.0, 11.0, 12.0],
+  })
+  runtime = pd.DataFrame({
+    "Nn": [2, 2, 3, 3],
+    "dev": [1.0, 1.1, 1.2, 1.3],
+    "iteration": [1, 2, 3, 4],
+    "best_iteration": [1, 1, 2, 2],
+    "LoadManagementModel": [5.0, 6.0, 7.0, 8.0],
+    "FaaS-MACrO": [6.0, 7.0, 8.0, 9.0],
+  })
+  rej = pd.DataFrame({
+    "Nn": [2, 2, 3, 3],
+    "dev": [0.0, -1.0, 1.0, 2.0],
+    "LoadManagementModel": [1.0, 2.0, 3.0, 4.0],
+    "FaaS-MACrO": [1.5, 2.5, 3.5, 4.5],
+  })
+  obj.to_csv(tmp_path / "obj.csv", index = False)
+  runtime.to_csv(tmp_path / "runtime.csv", index = False)
+  rej.to_csv(tmp_path / "rejections.csv", index = False)
+
+  loaded_obj, loaded_rej, loaded_runtime = compare_results.compare_results(
+    str(tmp_path),
+    "Nn",
+    "Nodes",
+    models,
+  )
+
+  assert loaded_obj.shape == obj.shape
+  assert loaded_rej.shape == rej.shape
+  assert loaded_runtime.shape == runtime.shape
+  assert (tmp_path / "box.png").exists()
+  assert (tmp_path / "box_detailed.png").exists()
+  assert (tmp_path / "bars.png").exists()
+  assert (tmp_path / "violin_detailed.png").exists()
+
+
+def test_run_results_postprocessing_aggregates_synthetic_experiment(tmp_path):
+  centralized = tmp_path / "centralized_exp"
+  macro = tmp_path / "macro_exp"
+  centralized.mkdir()
+  macro.mkdir()
+  _write_model_outputs(centralized, "LoadManagementModel")
+  _write_model_outputs(macro, "LSP")
+  pd.DataFrame({"LoadManagementModel": [1.0, 1.5]}).to_csv(
+    centralized / "runtime.csv",
+    index = False,
+  )
+  pd.DataFrame({"tot": [2.0, 2.5]}).to_csv(macro / "runtime.csv", index = False)
+  pd.DataFrame({
+    "0": [
+      "steady (it: 2; obj. deviation: 0.0; best it: 1)",
+      "dev below tol (it: 3; obj. deviation: 0.1)",
+    ]
+  }).to_csv(macro / "termination_condition.csv")
+
+  solution_folders = {
+    "experiments_list": [[2, 123]],
+    "centralized": [str(centralized)],
+    "faas-macro": [str(macro)],
+  }
+
+  run.results_postprocessing(
+    solution_folders,
+    str(tmp_path),
+    loop_over = "Nn",
+    methods = ["centralized", "faas-macro"],
+  )
+
+  post_folder = tmp_path / "postprocessing"
+  assert (post_folder / "obj.csv").exists()
+  assert (post_folder / "runtime.csv").exists()
+  assert (post_folder / "rejections.csv").exists()
+  assert (post_folder / "ping_pong_problems.txt").exists()
+
+
+def test_run_results_postprocessing_ignores_generate_only(tmp_path):
+  solution_folders = {
+    "experiments_list": [[2, 123]],
+    "centralized": [str(tmp_path / "generated_instance")],
+  }
+
+  run.results_postprocessing(
+    solution_folders,
+    str(tmp_path),
+    loop_over = "Nn",
+    methods = ["generate_only"],
+  )
+
+  assert (tmp_path / "postprocessing" / "ping_pong_problems.txt").exists()
+
+
+def test_postprocessing_history_and_boxplot_helpers(tmp_path):
+  input_requests = {
+    0: {
+      0: np.array([2.0, 3.0]),
+      1: np.array([1.0, 2.0]),
+    }
+  }
+  solution = pd.DataFrame({
+    "n0_f0_loc": [1.0, 2.0],
+    "n0_f0_fwd": [0.5, 0.5],
+    "n0_f0": [0.0, 0.0],
+    "n1_f0_loc": [1.0, 1.0],
+    "n1_f0_fwd": [0.0, 0.5],
+    "n1_f0": [0.0, 0.0],
+  })
+  utilization = pd.DataFrame({"n0_f0": [0.5, 0.6], "n1_f0": [0.3, 0.4]})
+  replicas = pd.DataFrame({"n0_f0": [1.0, 1.0], "n1_f0": [1.0, 2.0]})
+  offloaded = pd.DataFrame({
+    "n0_f0_accepted": [0.0, 0.5],
+    "n1_f0_accepted": [0.5, 0.0],
+  })
+
+  postprocessing.plot_history(
+    input_requests,
+    min_run_time = 0,
+    max_run_time = 2,
+    run_time_step = 1,
+    solution = solution,
+    utilization = utilization,
+    replicas = replicas,
+    offloaded = offloaded,
+    obj_values = [10.0, 9.0],
+    plot_filename = str(tmp_path / "history.png"),
+  )
+  postprocessing.runtime_obj_boxplot(
+    pd.DataFrame({
+      "method": ["A", "A", "B", "B"],
+      "Nn": [2, 3, 2, 3],
+      "runtime": [1.0, 2.0, 1.5, 2.5],
+    }),
+    "runtime",
+    str(tmp_path),
+    "runtime_box",
+  )
+
+  assert (tmp_path / "history.png").exists()
+  assert (tmp_path / "runtime_box.png").exists()
+
+
+def test_postprocessing_plot_history_handles_single_node_single_function(tmp_path):
+  input_requests = {0: {0: np.array([2.0, 3.0])}}
+  solution = pd.DataFrame({
+    "n0_f0_loc": [1.0, 2.0],
+    "n0_f0_fwd": [0.0, 0.0],
+    "n0_f0": [0.0, 0.0],
+  })
+  utilization = pd.DataFrame({"n0_f0": [0.5, 0.6]})
+  replicas = pd.DataFrame({"n0_f0": [1.0, 1.0]})
+  offloaded = pd.DataFrame({"n0_f0_accepted": [0.0, 0.0]})
+
+  postprocessing.plot_history(
+    input_requests,
+    min_run_time = 0,
+    max_run_time = 2,
+    run_time_step = 1,
+    solution = solution,
+    utilization = utilization,
+    replicas = replicas,
+    offloaded = offloaded,
+    obj_values = [10.0, 9.0],
+    plot_filename = str(tmp_path / "history-single.png"),
+  )
+
+  assert (tmp_path / "history-single.png").exists()
+
+
+def test_what_if_analyze_final_results_writes_deviation_outputs(tmp_path):
+  last_by_sw = pd.DataFrame({
+    "best_solution_it": [1, 2],
+    "obj": [10.0, 12.0],
+  })
+  last_by_cobj = pd.DataFrame({
+    "best_solution_it": [2, 4],
+    "obj": [11.0, 15.0],
+  })
+
+  what_if_analysis.analyze_final_results(last_by_sw, last_by_cobj, str(tmp_path))
+
+  assert (tmp_path / "best_solution_obj.png").exists()
+  assert (tmp_path / "best_solution_obj_dev.png").exists()
+  out = pd.read_csv(tmp_path / "best_solution_obj.csv")
+  assert "obj_dev" in out.columns
diff --git a/tests/test_diffusion_e2e.py b/tests/test_diffusion_e2e.py
new file mode 100644
index 0000000..836176e
--- /dev/null
+++ b/tests/test_diffusion_e2e.py
@@ -0,0 +1,73 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_diffusion import run as run_diffusion
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _diffusion_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "diffusion": {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_diffusion_runner_produces_expected_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_diffusion(
+    _diffusion_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert "FaaS-MADiG" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MADiG"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
diff --git a/tests/test_diffusion_helpers.py b/tests/test_diffusion_helpers.py
new file mode 100644
index 0000000..741b2c1
--- /dev/null
+++ b/tests/test_diffusion_helpers.py
@@ -0,0 +1,247 @@
+import numpy as np
+import pandas as pd
+
+from decentralized_diffusion import define_assignments, evaluate_assignments
+
+
+def _base_data(Nn=3, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _ring_neighborhood(Nn=3):
+  neighborhood = np.zeros((Nn, Nn))
+  for n in range(Nn):
+    neighborhood[n, (n + 1) % Nn] = 1
+    neighborhood[n, (n - 1) % Nn] = 1
+  return neighborhood
+
+
+def test_define_assignments_greedy_by_utility_no_price_column():
+  data = _base_data(Nn=3, Nf=1)
+  # buyer 0 prefers seller 1 (beta 2.0) over seller 2 (beta 1.0)
+  data[None]["beta"][(1, 2, 1)] = 2.0
+  data[None]["beta"][(1, 3, 1)] = 1.0
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  rho = np.zeros((3,))
+  options = {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False}
+  latency = np.zeros((3, 3))
+  fairness = np.zeros((3, 1))
+
+  bids, memory_bids, n_buyers = define_assignments(
+    omega, blackboard, data, _ring_neighborhood(3), rho,
+    options, latency, fairness, force_memory_bids=False,
+  )
+
+  assert n_buyers == 1
+  assert "b" not in bids.columns
+  assert list(bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+  assert bids.iloc[0]["d"] == 2.0
+  assert bids.iloc[0]["utility"] == 2.0
+  assert len(memory_bids) == 0
+
+
+def test_define_assignments_requests_replicas_when_no_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((2, 1))           # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0       # neighbor 1 has spare memory
+  options = {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False}
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  bids, memory_bids, _ = define_assignments(
+    omega, blackboard, data, neighborhood, rho,
+    options, np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=False,
+  )
+
+  assert len(bids) == 0
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_define_assignments_tied_score_prefers_lower_seller_index():
+  data = _base_data(Nn=3, Nf=1)
+  omega = np.zeros((3, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((3, 1)); blackboard[1:, 0] = 1.0
+
+  bids, _, _ = define_assignments(
+    omega, blackboard, data, _ring_neighborhood(3), np.zeros(3),
+    {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+  )
+
+  assert bids.iloc[0]["j"] == 1
+
+
+def test_evaluate_assignments_respects_capacity_and_tiebreaks_by_buyer():
+  data = _base_data(Nn=3, Nf=1)
+  # two buyers tie on utility for seller 1; capacity only fits one fully
+  bids = pd.DataFrame({
+    "i": [2, 0],
+    "j": [1, 1],
+    "f": [0, 0],
+    "d": [2.0, 2.0],
+    "utility": [5.0, 5.0],
+  })
+  residual_capacity = np.zeros((3, 1)); residual_capacity[1, 0] = 3.0
+  ell = np.zeros((3, 1))
+  r = np.zeros((3, 1))
+  rho = np.zeros((3,))
+
+  y, additional_replicas, n_sellers = evaluate_assignments(
+    bids, residual_capacity, data, ell, r, rho,
+    tentatively_start_replicas=False,
+  )
+
+  assert y[:, 1, 0].sum() == 3.0            # never exceeds capacity
+  assert y[0, 1, 0] == 2.0                  # lower buyer index served first
+  assert y[2, 1, 0] == 1.0
+  assert (additional_replicas == 0).all()
+  assert n_sellers == 1
+
+
+def test_evaluate_assignments_is_deterministic_and_returns_no_price():
+  data = _base_data(Nn=3, Nf=1)
+  bids = pd.DataFrame({
+    "i": [2, 0], "j": [1, 1], "f": [0, 0],
+    "d": [2.0, 2.0], "utility": [5.0, 5.0],
+  })
+  residual_capacity = np.zeros((3, 1)); residual_capacity[1, 0] = 3.0
+  args = (bids, residual_capacity, data, np.zeros((3, 1)),
+          np.zeros((3, 1)), np.zeros((3,)))
+
+  first = evaluate_assignments(*args, tentatively_start_replicas=False)
+  second = evaluate_assignments(*args, tentatively_start_replicas=False)
+
+  assert len(first) == 3                    # (y, additional_replicas, n_sellers)
+  assert np.array_equal(first[0], second[0])
+
+
+def test_evaluate_assignments_replaces_lower_score_incumbent_when_full():
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 5.0
+  data[None]["beta"][(3, 2, 1)] = 1.0
+  bids = pd.DataFrame({
+    "i": [0, 0, 0],
+    "j": [1, 1, 1],
+    "f": [0, 0, 0],
+    "d": [1.0, 1.0, 1.0],
+    "utility": [5.0, 5.0, 5.0],
+  })
+  residual_capacity = np.zeros((3, 1))
+  residual_capacity[1, 0] = 1.0
+  last_y = np.zeros((3, 3, 1))
+  last_y[2, 1, 0] = 2.0
+
+  delta_y, _, _ = evaluate_assignments(
+    bids,
+    residual_capacity,
+    data,
+    ell = np.zeros((3, 1)),
+    r = np.ones((3, 1)),
+    initial_rho = np.zeros((3,)),
+    tentatively_start_replicas = False,
+    last_y = last_y,
+    diffusion_options = {
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+    latency = np.zeros((3, 3)),
+    fairness = np.zeros((3, 1)),
+  )
+
+  assert delta_y[0, 1, 0] == 3.0
+  assert delta_y[2, 1, 0] == -2.0
+
+
+def test_evaluate_assignments_preserves_fractional_capacity():
+  data = _base_data(Nn=2, Nf=1)
+  bids = pd.DataFrame({
+    "i": [0], "j": [1], "f": [0], "d": [2.0], "utility": [1.0],
+  })
+  residual_capacity = np.zeros((2, 1))
+  residual_capacity[1, 0] = 1.8
+
+  y, _, _ = evaluate_assignments(
+    bids, residual_capacity, data, np.zeros((2, 1)),
+    np.ones((2, 1)), np.zeros(2), tentatively_start_replicas=False,
+  )
+
+  assert y[:, 1, 0].sum() == 1.8
+
+
+def test_evaluate_assignments_reassigns_unfilled_part_of_batched_bid():
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 5.0
+  data[None]["beta"][(3, 2, 1)] = 1.0
+  bids = pd.DataFrame({
+    "i": [0], "j": [1], "f": [0], "d": [3.0], "utility": [5.0],
+  })
+  residual_capacity = np.zeros((3, 1))
+  residual_capacity[1, 0] = 1.0
+  last_y = np.zeros((3, 3, 1))
+  last_y[2, 1, 0] = 2.0
+
+  delta_y, _, _ = evaluate_assignments(
+    bids, residual_capacity, data, np.zeros((3, 1)),
+    np.ones((3, 1)), np.zeros(3), tentatively_start_replicas=False,
+    last_y=last_y,
+    diffusion_options={"latency_weight": 0.0, "fairness_weight": 0.0},
+    latency=np.zeros((3, 3)), fairness=np.zeros((3, 1)),
+  )
+
+  assert delta_y[0, 1, 0] == 3.0
+  assert delta_y[2, 1, 0] == -2.0
+
+
+def test_evaluate_assignments_can_reassign_completely_full_seller():
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 5.0
+  data[None]["beta"][(3, 2, 1)] = 1.0
+  bids = pd.DataFrame({
+    "i": [0], "j": [1], "f": [0], "d": [2.0], "utility": [5.0],
+  })
+  last_y = np.zeros((3, 3, 1))
+  last_y[2, 1, 0] = 2.0
+
+  delta_y, _, n_sellers = evaluate_assignments(
+    bids, np.zeros((3, 1)), data, np.zeros((3, 1)),
+    np.ones((3, 1)), np.zeros(3), tentatively_start_replicas=False,
+    last_y=last_y,
+    diffusion_options={"latency_weight": 0.0, "fairness_weight": 0.0},
+    latency=np.zeros((3, 3)), fairness=np.zeros((3, 1)),
+  )
+
+  assert n_sellers == 1
+  assert delta_y[0, 1, 0] == 2.0
+  assert delta_y[2, 1, 0] == -2.0
+
+
+def test_define_assignments_force_memory_bids_includes_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.array([[1.0], [0.0]])
+  blackboard = np.array([[0.0], [1.0]])
+  rho = np.array([0.0, 2.0])
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  _, memory_bids, _ = define_assignments(
+    omega, blackboard, data, neighborhood, rho,
+    {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=True,
+  )
+
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
diff --git a/tests/test_diffusion_wiring.py b/tests/test_diffusion_wiring.py
new file mode 100644
index 0000000..107ad39
--- /dev/null
+++ b/tests/test_diffusion_wiring.py
@@ -0,0 +1,181 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import networkx as nx
+
+import decentralized_diffusion
+import run
+
+
+def test_methods_choice_accepts_faas_diffuse(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-diffuse"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-diffuse" in args.methods
+
+
+def test_run_module_exposes_diffusion_runner():
+  assert hasattr(run, "run_diffusion")
+  assert callable(run.run_diffusion)
+
+
+def test_planar_config_has_diffusion_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  diffusion = config["solver_options"]["diffusion"]
+  assert "latency_weight" in diffusion
+  assert "fairness_weight" in diffusion
+
+
+def test_compare_results_palette_includes_madig():
+  import inspect
+
+  import compare_results
+
+  source = inspect.getsource(compare_results)
+  assert '"FaaS-MADiG"' in source
+
+
+def test_compare_results_defaults_include_madig(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  import compare_results
+
+  args = compare_results.parse_arguments()
+
+  assert "FaaS-MADiG" in args.models
+
+
+def test_set_solution_folder_tolerates_missing_method_key():
+  solution_folders = {"experiments_list": []}  # simulates a pre-feature experiments.json
+  run.set_solution_folder(solution_folders, "faas-diffuse", 0, "/some/folder")
+  assert solution_folders["faas-diffuse"][0] == "/some/folder"
+
+
+def test_diffusion_run_uses_fixed_replicas_without_mutating_options(tmp_path, monkeypatch):
+  seen = {}
+  base_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0},
+    }
+  }
+
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "init_problem",
+    lambda *args, **kwargs: (base_data, {}, [], nx.empty_graph(1)),
+  )
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "load_solution",
+    lambda folder, model: ("opt_solution", "opt_replicas", "opt_detailed", None, None),
+    raising=False,
+  )
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "encode_solution",
+    lambda Nn, Nf, solution, detailed, replicas, t: (None, None, None, np.array([[3]]), None),
+    raising=False,
+  )
+  monkeypatch.setattr(decentralized_diffusion, "LSP", lambda: "LSP")
+  monkeypatch.setattr(decentralized_diffusion, "LSP_fixedr", lambda: "LSP_fixedr", raising=False)
+  monkeypatch.setattr(
+    decentralized_diffusion, "LSPr", lambda: seen.setdefault("spr", "LSPr")
+  )
+  monkeypatch.setattr(
+    decentralized_diffusion, "LSPr_fixedr",
+    lambda: seen.setdefault("spr", "LSPr_fixedr"), raising=False,
+  )
+
+  def _solve_subproblem(sp_data, agents, sp, *args):
+    seen["sp"] = sp
+    seen["r_bar"] = dict(sp_data[None].get("r_bar", {}))
+    return (
+      sp_data,
+      np.zeros((1, 1)),
+      None,
+      None,
+      np.zeros((1, 1)),
+      np.ones((1, 1)),
+      np.array([5.0]),
+      np.zeros((1, 1)),
+      {"tot": 0.0},
+      {"tot": "ok"},
+      {"tot": 0.0},
+    )
+
+  monkeypatch.setattr(decentralized_diffusion, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(decentralized_diffusion, "get_current_load", lambda *args: {})
+  monkeypatch.setattr(decentralized_diffusion, "update_data", lambda data, update: data)
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "compute_residual_capacity",
+    lambda *args: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))),
+  )
+  def _define_assignments(*args, **kwargs):
+    seen["coordination_rho"] = np.array(args[4], copy=True)
+    return (
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": [], "d": [], "utility": []}),
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": []}),
+      0,
+    )
+
+  monkeypatch.setattr(decentralized_diffusion, "define_assignments", _define_assignments)
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "combine_solutions",
+    lambda *args: {"sp": {"x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)), "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1))}},
+  )
+  monkeypatch.setattr(decentralized_diffusion, "compute_centralized_objective", lambda *args: -1.0)
+  monkeypatch.setattr(decentralized_diffusion, "check_feasibility", lambda *args: (True, "ok"))
+  decoded = []
+
+  def _decode(sp_data, solution, complete, arg):
+    decoded.append(solution)
+    assert solution is not None
+    return complete, None, 1.0
+
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "decode_solutions",
+    _decode,
+  )
+  monkeypatch.setattr(
+    decentralized_diffusion,
+    "join_complete_solution",
+    lambda complete: ({}, {}, {}),
+  )
+  monkeypatch.setattr(decentralized_diffusion, "save_checkpoint", lambda *args: None)
+  monkeypatch.setattr(decentralized_diffusion, "save_solution", lambda *args: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {
+      "general": {"TimeLimit": 10},
+      "auction": {"unit_bids": True},
+      "diffusion": {"latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 1,
+    "patience": 1,
+    "max_steps": 1,
+    "min_run_time": 0,
+    "max_run_time": 0,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "verbose": 0,
+    "opt_solution_folder": "centralized-folder",
+  }
+
+  decentralized_diffusion.run(config, parallelism=0, disable_plotting=True)
+
+  assert seen["sp"] == "LSP_fixedr"
+  assert seen["spr"] == "LSPr_fixedr"
+  assert seen["r_bar"] == {(1, 1): 3}
+  assert (seen["coordination_rho"] == 0).all()
+  assert len(decoded) == 2
+  assert "unit_bids" not in config["solver_options"]["diffusion"]
diff --git a/tests/test_dual_e2e.py b/tests/test_dual_e2e.py
new file mode 100644
index 0000000..b659a66
--- /dev/null
+++ b/tests/test_dual_e2e.py
@@ -0,0 +1,165 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_dual import _capacity_state, run as run_dual
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _dual_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "dual": {
+        "alpha0": 1.0, "step_rule": "sqrt", "max_inner_iterations": 30,
+        "gap_tolerance": 0.01, "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_capacity_state_reflects_newly_started_replicas():
+  sp_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "max_utilization": {1: 2.0},
+      "demand": {(1, 1): 1.0},
+    }
+  }
+  sp_x = np.array([[1.5]])
+  y = np.zeros((1, 1, 1))
+  sp_r = np.array([[1.0]])
+
+  capacity, residual_capacity, ell, blackboard = _capacity_state(
+    sp_x, y, sp_r, sp_data
+  )
+  assert capacity[0, 0] == pytest.approx(2.0)
+  assert residual_capacity[0, 0] == pytest.approx(0.5)
+  assert ell[0, 0] == pytest.approx(1.5)
+  assert blackboard[0, 0] == pytest.approx(0.5)
+
+  sp_r += np.array([[1.0]])
+
+  capacity, residual_capacity, ell, blackboard = _capacity_state(
+    sp_x, y, sp_r, sp_data
+  )
+  assert capacity[0, 0] == pytest.approx(4.0)
+  assert residual_capacity[0, 0] == pytest.approx(2.5)
+  assert ell[0, 0] == pytest.approx(1.5)
+  assert blackboard[0, 0] == pytest.approx(2.5)
+
+
+def test_dual_runner_produces_expected_artifacts_with_gap(tmp_path):
+  _require_gurobi()
+  folder = run_dual(
+    _dual_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert len(obj) >= 1
+  assert "FaaS-MALD" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MALD"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  certificate = pd.read_csv(Path(folder, "coordination_certificate.csv"))
+  assert list(certificate.columns) == [
+    "timestep",
+    "outer_iteration",
+    "LB",
+    "UB",
+    "gap",
+    "inner_iterations",
+    "stop_reason",
+  ]
+  assert len(certificate) >= 1
+  assert (certificate["UB"] >= certificate["LB"]).all()
+  assert (certificate["gap"] >= -1e-8).all()
+
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert tc.iloc[:, -1].astype(str).str.contains("fixed-C gap:").all()
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_dual_runner_is_reproducible_for_same_seed(tmp_path):
+  _require_gurobi()
+  folder_a = run_dual(
+    _dual_e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  folder_b = run_dual(
+    _dual_e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+
+  obj_a = pd.read_csv(Path(folder_a, "obj.csv"))["FaaS-MALD"].to_numpy()
+  obj_b = pd.read_csv(Path(folder_b, "obj.csv"))["FaaS-MALD"].to_numpy()
+  certificate_cols = [
+    "timestep",
+    "outer_iteration",
+    "LB",
+    "UB",
+    "gap",
+    "inner_iterations",
+  ]
+  certificate_a = pd.read_csv(
+    Path(folder_a, "coordination_certificate.csv")
+  )[certificate_cols]
+  certificate_b = pd.read_csv(
+    Path(folder_b, "coordination_certificate.csv")
+  )[certificate_cols]
+
+  assert obj_a.shape[0] >= 1
+  assert obj_a.shape == obj_b.shape
+  assert np.allclose(obj_a, obj_b)
+  pd.testing.assert_frame_equal(certificate_a, certificate_b)
+
+
+def test_dual_defaults_applied_without_dual_options_key(tmp_path):
+  _require_gurobi()
+  config = _dual_e2e_config(tmp_path)
+  del config["solver_options"]["dual"]
+  folder = run_dual(config, parallelism=0, disable_plotting=True)
+  assert Path(folder, "obj.csv").exists()
diff --git a/tests/test_dual_helpers.py b/tests/test_dual_helpers.py
new file mode 100644
index 0000000..a97c493
--- /dev/null
+++ b/tests/test_dual_helpers.py
@@ -0,0 +1,417 @@
+import numpy as np
+import pandas as pd
+import pytest
+from scipy.optimize import linprog
+
+from decentralized_dual import (
+  buyer_price_response,
+  dual_coordination_round,
+  pair_scores,
+)
+
+
+def make_data(Nn=3, Nf=1, beta=None, gamma=0.05):
+  data = {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "beta": {}, "gamma": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "demand": {(j + 1, f + 1): 1.0 for j in range(Nn) for f in range(Nf)},
+    "max_utilization": {f + 1: 0.7 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = gamma
+      for j in range(Nn):
+        b = 1.0 if beta is None else beta[i][j][f]
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = b
+  return data
+
+
+def full_neighborhood(Nn):
+  return np.ones((Nn, Nn)) - np.eye(Nn)
+
+
+DUAL_OPTIONS = {"latency_weight": 0.0, "fairness_weight": 0.0}
+
+
+def test_pair_scores_masks_non_neighbors_and_nonpositive_cloud_advantage():
+  Nn, Nf = 3, 1
+  beta = [[[1.0] for _ in range(Nn)] for _ in range(Nn)]
+  beta[0][2][0] = -0.2
+  data = make_data(Nn, Nf, beta=beta, gamma=0.05)
+  neighborhood = full_neighborhood(Nn)
+  neighborhood[0, 1] = 0
+  s, elig = pair_scores(
+    data, neighborhood, np.zeros((Nn, Nn)), np.zeros((Nn, Nf)), DUAL_OPTIONS
+  )
+  assert not elig[0, 1, 0] and not elig[0, 2, 0] and not elig[0, 0, 0]
+  assert elig[1, 0, 0] and s[1, 0, 0] == 1.05
+  assert s[0, 1, 0] == -np.inf
+  assert s[0, 2, 0] == -np.inf
+
+
+def test_buyer_response_zero_prices_picks_best_score_seller():
+  Nn, Nf = 3, 1
+  beta = [[[1.0] for _ in range(Nn)] for _ in range(Nn)]
+  beta[0][1][0] = 2.0
+  data = make_data(Nn, Nf, beta=beta, gamma=0.2)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 5.0
+  capacity = np.full((Nn, Nf), 3.0)
+  bids, demand, dual_term = buyer_price_response(
+    omega, capacity, np.zeros((Nn, Nf)), s, elig
+  )
+  assert demand[1, 0] == 5.0 and demand[2, 0] == 0.0
+  assert dual_term == 5.0 * 2.2
+  first = bids.iloc[0]
+  assert (first.j, first.d, first.utility) == (1, 3.0, 2.2)
+  assert bids["d"].sum() == 5.0
+
+
+def test_buyer_response_price_shifts_demand():
+  Nn, Nf = 3, 1
+  beta = [[[1.0] for _ in range(Nn)] for _ in range(Nn)]
+  beta[0][1][0] = 2.0
+  data = make_data(Nn, Nf, beta=beta, gamma=0.2)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 5.0
+  lam = np.zeros((Nn, Nf)); lam[1, 0] = 1.5
+  bids, demand, dual_term = buyer_price_response(
+    omega, np.full((Nn, Nf), 10.0), lam, s, elig
+  )
+  assert demand[2, 0] == 5.0 and demand[1, 0] == 0.0
+  assert dual_term == 5.0 * 1.2
+
+
+def test_buyer_response_uses_best_positive_advantage_for_buyer_term():
+  Nn, Nf = 3, 1
+  beta = [[[1.0] for _ in range(Nn)] for _ in range(Nn)]
+  beta[0][1][0] = 3.0
+  beta[0][2][0] = 2.0
+  data = make_data(Nn, Nf, beta=beta, gamma=0.1)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 4.0
+  capacity = np.zeros((Nn, Nf)); capacity[2, 0] = 4.0
+  lam = np.zeros((Nn, Nf)); lam[1, 0] = 0.5
+  bids, demand, dual_term = buyer_price_response(omega, capacity, lam, s, elig)
+  assert demand[1, 0] == 4.0 and demand[2, 0] == 0.0
+  assert dual_term == 4.0 * 2.6
+  assert bids["j"].tolist() == [2]
+
+
+def test_buyer_response_tie_uses_lower_seller_index():
+  Nn, Nf = 3, 1
+  data = make_data(Nn, Nf, gamma=0.2)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 5.0
+  bids, demand, _ = buyer_price_response(
+    omega, np.full((Nn, Nf), 3.0), np.zeros((Nn, Nf)), s, elig
+  )
+  assert demand[1, 0] == 5.0 and demand[2, 0] == 0.0
+  assert bids["j"].tolist() == [1, 2]
+
+
+def test_buyer_response_all_priced_out_yields_empty():
+  Nn, Nf = 2, 1
+  data = make_data(Nn, Nf, gamma=0.2)
+  s, elig = pair_scores(
+    data, full_neighborhood(Nn), np.zeros((Nn, Nn)), np.zeros((Nn, Nf)),
+    DUAL_OPTIONS,
+  )
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 4.0
+  lam = np.full((Nn, Nf), 10.0)
+  bids, demand, dual_term = buyer_price_response(
+    omega, np.full((Nn, Nf), 10.0), lam, s, elig
+  )
+  assert len(bids) == 0 and demand.sum() == 0.0 and dual_term == 0.0
+
+
+def coordination_lp_optimum(omega, capacity, s, elig):
+  """Brute-force the coordination LP with scipy (test oracle)."""
+  Nn, Nf = omega.shape
+  pairs = [(i, j, f) for i in range(Nn) for j in range(Nn) for f in range(Nf)
+           if elig[i, j, f]]
+  if not pairs:
+    return 0.0
+  c = [-s[i, j, f] for (i, j, f) in pairs]
+  A, b = [], []
+  for i in range(Nn):
+    for f in range(Nf):
+      A.append([1.0 if (p[0], p[2]) == (i, f) else 0.0 for p in pairs])
+      b.append(float(omega[i, f]))
+  for j in range(Nn):
+    for f in range(Nf):
+      A.append([1.0 if (p[1], p[2]) == (j, f) else 0.0 for p in pairs])
+      b.append(float(capacity[j, f]))
+  res = linprog(c, A_ub=A, b_ub=b, bounds=[(0, None)] * len(pairs))
+  assert res.success
+  return -res.fun
+
+
+def dual_round_setup(Nn=4, Nf=2, seed=7):
+  rng = np.random.default_rng(seed)
+  beta = [[[float(rng.uniform(0.5, 2.0)) for _ in range(Nf)]
+           for _ in range(Nn)] for _ in range(Nn)]
+  data = make_data(Nn, Nf, beta=beta)
+  neighborhood = full_neighborhood(Nn)
+  omega = rng.uniform(0.0, 4.0, size=(Nn, Nf))
+  capacity = rng.uniform(0.0, 3.0, size=(Nn, Nf))
+  return data, neighborhood, omega, capacity
+
+
+DUAL_ROUND_OPTIONS = {
+  "alpha0": 0.5, "step_rule": "sqrt", "theta": 1.0,
+  "max_inner_iterations": 300, "gap_tolerance": 0.01,
+  "latency_weight": 0.0, "fairness_weight": 0.0,
+}
+
+
+def run_round(data, neighborhood, omega, capacity, options=None):
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  return dual_coordination_round(
+    omega, capacity, data, neighborhood,
+    rho=np.zeros(Nn), dual_options=options or DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)), fairness=np.zeros((Nn, Nf)),
+  )
+
+
+def test_certificate_brackets_lp_optimum_and_gap_closes():
+  data, neighborhood, omega, capacity = dual_round_setup()
+  y_inc, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  s, elig = pair_scores(
+    data, neighborhood, np.zeros_like(neighborhood),
+    np.zeros(omega.shape), DUAL_ROUND_OPTIONS,
+  )
+  # the round enforces no_ping_pong: a node with residual demand for f cannot
+  # also host f, so the certificate brackets the LP with those sellers removed
+  # (their advertised capacity zeroed), not the unconstrained LP.
+  constrained_capacity = np.where(omega > 1e-6, 0.0, capacity)
+  opt = coordination_lp_optimum(omega, constrained_capacity, s, elig)
+  assert gap_info["UB"] >= opt - 1e-6
+  assert gap_info["LB"] <= opt + 1e-6
+  assert gap_info["gap"] <= 0.05
+  val = float((np.where(elig, s, 0.0) * y_inc).sum())
+  assert abs(val - gap_info["LB"]) <= 1e-6
+
+
+def test_best_lb_is_monotone_nondecreasing():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=11)
+  _, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  hist = gap_info["lb_history"]
+  assert all(b >= a - 1e-12 for a, b in zip(hist, hist[1:]))
+
+
+def test_recovered_increment_is_feasible():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=3)
+  y_inc, _, _, _ = run_round(data, neighborhood, omega, capacity)
+  assert (y_inc >= -1e-9).all()
+  assert (y_inc.sum(axis=1) <= omega + 1e-6).all()
+  assert (y_inc.sum(axis=0) <= capacity + 1e-6).all()
+
+
+def test_price_rises_on_oversubscribed_seller():
+  Nn, Nf = 3, 1
+  beta = [[[1.0] for _ in range(Nn)] for _ in range(Nn)]
+  beta[0][2][0] = 5.0
+  beta[1][2][0] = 5.0
+  data = make_data(Nn, Nf, beta=beta)
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 4.0; omega[1, 0] = 4.0
+  capacity = np.zeros((Nn, Nf)); capacity[2, 0] = 2.0; capacity[0, 0] = 6.0
+  capacity[1, 0] = 6.0
+  _, _, gap_info, _ = run_round(data, full_neighborhood(Nn), omega, capacity)
+  assert gap_info["lam"][2, 0] > 0.0
+
+
+def test_no_demand_returns_zero_gap_and_empty_outputs():
+  data, neighborhood, _, capacity = dual_round_setup()
+  omega = np.zeros((4, 2))
+  y_inc, memory_bids, gap_info, n_active = run_round(
+    data, neighborhood, omega, capacity
+  )
+  assert y_inc.sum() == 0.0
+  assert len(memory_bids) == 0 and n_active == 0
+  assert gap_info["LB"] == 0.0 and gap_info["UB"] == 0.0
+
+
+def test_zero_capacity_with_demand_exits_after_first_iteration():
+  data, neighborhood, omega, _ = dual_round_setup()
+  capacity = np.zeros_like(omega)
+  y_inc, _, gap_info, _ = run_round(data, neighborhood, omega, capacity)
+  assert y_inc.sum() == 0.0
+  assert gap_info["LB"] == 0.0
+  assert gap_info["inner_iterations"] == 1
+  # the zero assignment is certified optimal: no eligible seller has capacity
+  assert gap_info["UB"] == 0.0 and gap_info["gap"] == 0.0
+
+
+def test_single_inner_iteration_yields_valid_certificate():
+  data, neighborhood, omega, capacity = dual_round_setup(seed=5)
+  options = {**DUAL_ROUND_OPTIONS, "max_inner_iterations": 1}
+  y_inc, _, gap_info, _ = run_round(
+    data, neighborhood, omega, capacity, options
+  )
+  assert gap_info["inner_iterations"] == 1
+  assert np.isfinite(gap_info["UB"])
+  assert gap_info["UB"] + 1e-9 >= gap_info["LB"] >= 0.0
+  assert (y_inc >= -1e-9).all()
+  assert (y_inc.sum(axis=1) <= omega + 1e-6).all()
+  assert (y_inc.sum(axis=0) <= capacity + 1e-6).all()
+
+
+@pytest.mark.parametrize("value", [0, False, True, 1.5])
+def test_positive_demand_rejects_invalid_inner_iterations(value):
+  data, neighborhood, omega, capacity = dual_round_setup()
+  options = {**DUAL_ROUND_OPTIONS, "max_inner_iterations": value}
+  with np.testing.assert_raises_regex(ValueError, "max_inner_iterations"):
+    run_round(data, neighborhood, omega, capacity, options)
+
+
+def test_unknown_step_rule_is_rejected():
+  data, neighborhood, omega, capacity = dual_round_setup()
+  options = {**DUAL_ROUND_OPTIONS, "step_rule": "unknown"}
+  with np.testing.assert_raises_regex(ValueError, "step_rule"):
+    run_round(data, neighborhood, omega, capacity, options)
+
+
+@pytest.mark.parametrize(
+  ("overrides", "match"),
+  [
+    ({"alpha0": 0.0}, "alpha0"),
+    ({"step_rule": "polyak", "theta": 0.0}, "theta"),
+    ({"gap_tolerance": -0.1}, "gap_tolerance"),
+    ({"latency_weight": np.nan}, "latency_weight"),
+    ({"fairness_weight": np.inf}, "fairness_weight"),
+  ],
+)
+def test_invalid_dual_numeric_options_are_rejected(overrides, match):
+  data, neighborhood, omega, capacity = dual_round_setup()
+  options = {**DUAL_ROUND_OPTIONS, **overrides}
+  with pytest.raises(ValueError, match=match):
+    run_round(data, neighborhood, omega, capacity, options)
+
+
+def test_gap_info_keeps_best_lambda_not_last_iterate(monkeypatch):
+  calls = iter([
+    (
+      pd.DataFrame([{"i": 0, "j": 1, "f": 0, "d": 1.0, "utility": 1.0}]),
+      np.array([[1.0], [0.0]]),
+      1.0,
+    ),
+    (
+      pd.DataFrame([{"i": 0, "j": 1, "f": 0, "d": 1.0, "utility": 1.0}]),
+      np.array([[1.0], [0.0]]),
+      10.0,
+    ),
+  ])
+
+  def fake_buyer_price_response(*_args, **_kwargs):
+    return next(calls)
+
+  def fake_evaluate_assignments(*_args, **_kwargs):
+    return np.zeros((2, 2, 1)), np.zeros((2, 1)), None
+
+  monkeypatch.setattr("decentralized_dual.buyer_price_response", fake_buyer_price_response)
+  monkeypatch.setattr("decentralized_dual.evaluate_assignments", fake_evaluate_assignments)
+
+  data = make_data(2, 1)
+  options = {**DUAL_ROUND_OPTIONS, "max_inner_iterations": 2, "gap_tolerance": 0.0}
+  _, _, gap_info, _ = dual_coordination_round(
+    omega=np.array([[1.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0]]),
+    data=data,
+    neighborhood=full_neighborhood(2),
+    rho=np.zeros(2),
+    dual_options=options,
+    latency=np.zeros((2, 2)),
+    fairness=np.zeros((2, 1)),
+  )
+
+  np.testing.assert_array_equal(gap_info["best_lam"], np.zeros((2, 1)))
+  assert gap_info["lam"][0, 0] > 0.0
+
+
+def test_round_keeps_best_assignment_without_post_loop_reevaluation(monkeypatch):
+  calls = iter([
+    (
+      pd.DataFrame([{"i": 0, "j": 1, "f": 0, "d": 1.0, "utility": 1.0}]),
+      np.array([[1.0], [0.0]]),
+      1.0,
+    ),
+    (
+      pd.DataFrame([{"i": 0, "j": 1, "f": 0, "d": 1.0, "utility": 1.0}]),
+      np.array([[1.0], [0.0]]),
+      10.0,
+    ),
+  ])
+  evaluations = []
+
+  def fake_buyer_price_response(*_args, **_kwargs):
+    return next(calls)
+
+  def fake_evaluate_assignments(*args, **kwargs):
+    evaluations.append((args, kwargs))
+    y = np.zeros((2, 2, 1))
+    y[0, 1, 0] = float(len(evaluations))
+    return y, None, None
+
+  monkeypatch.setattr("decentralized_dual.buyer_price_response", fake_buyer_price_response)
+  monkeypatch.setattr("decentralized_dual.evaluate_assignments", fake_evaluate_assignments)
+
+  _, _, gap_info, _ = dual_coordination_round(
+    omega=np.array([[1.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0]]),
+    data=make_data(2, 1),
+    neighborhood=full_neighborhood(2),
+    rho=np.zeros(2),
+    dual_options={**DUAL_ROUND_OPTIONS, "max_inner_iterations": 2, "gap_tolerance": 0.0},
+    latency=np.zeros((2, 2)),
+    fairness=np.zeros((2, 1)),
+  )
+
+  assert len(evaluations) == gap_info["inner_iterations"]
+
+
+def test_memory_bids_are_emitted_only_for_unplaced_demand():
+  Nn, Nf = 2, 1
+  data = make_data(Nn, Nf)
+  neighborhood = full_neighborhood(Nn)
+  omega = np.zeros((Nn, Nf)); omega[0, 0] = 1.0
+  capacity = np.zeros((Nn, Nf)); capacity[1, 0] = 1.0
+  rho = np.array([0.0, 2.0])
+  empty = dual_coordination_round(
+    omega=omega,
+    residual_capacity=capacity,
+    data=data,
+    neighborhood=neighborhood,
+    rho=rho,
+    dual_options=DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)),
+    fairness=np.zeros((Nn, Nf)),
+  )[1]
+  assert list(empty.columns) == ["i", "j", "f"] and empty.empty
+
+  blocked = dual_coordination_round(
+    omega=omega,
+    residual_capacity=np.zeros((Nn, Nf)),
+    data=data,
+    neighborhood=neighborhood,
+    rho=rho,
+    dual_options=DUAL_ROUND_OPTIONS,
+    latency=np.zeros((Nn, Nn)),
+    fairness=np.zeros((Nn, Nf)),
+  )[1]
+  assert list(blocked.columns) == ["i", "j", "f"]
+  assert blocked.to_dict("records") == [{"i": 0, "j": 1, "f": 0}]
diff --git a/tests/test_e2e_gurobi_planar.py b/tests/test_e2e_gurobi_planar.py
new file mode 100644
index 0000000..ff61956
--- /dev/null
+++ b/tests/test_e2e_gurobi_planar.py
@@ -0,0 +1,191 @@
+import json
+from pathlib import Path
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from generate_data import generate_neighborhood
+from run_centralized_model import run as run_centralized
+from hierarchical_auction.madea_runner import run as run_hierarchical_madea
+from hierarchical_auction.runner import run as run_hierarchical
+from run_faasmacro import run as run_faasmacro
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _planar_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {
+        "type": "euclidean_planar", "mean_degree": 3, "density": 1.0,
+      },
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3, 0.15],
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "sw_patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "max_hierarchy_depth": 3,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def _assert_generated_graph_is_planar_degree_three(folder: str) -> None:
+  base_data = json.loads(Path(folder, "base_instance_data.json").read_text())
+  n_nodes = base_data["None"]["Nn"]["None"]
+  neighborhood = np.zeros((n_nodes, n_nodes), dtype=int)
+  for raw_key, value in base_data["None"]["neighborhood"].items():
+    i, j = (int(part.strip()) for part in raw_key.strip("()").split(","))
+    neighborhood[i - 1, j - 1] = int(value)
+  graph = nx.from_numpy_array(neighborhood)
+
+  assert n_nodes >= 10
+  assert nx.is_connected(graph)
+  assert nx.check_planarity(graph)[0] is True
+  assert graph.number_of_edges() == round(n_nodes * 3 / 2)
+
+
+def _flatten_text(df: pd.DataFrame) -> str:
+  return "\n".join(df.astype(str).to_numpy().ravel())
+
+
+def _assert_finite_objectives(folder: str) -> None:
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  value_columns = obj.loc[:, ~obj.columns.str.startswith("Unnamed")]
+  numeric = value_columns.apply(pd.to_numeric, errors="coerce")
+  assert not numeric.empty
+  assert np.isfinite(numeric.to_numpy()).all()
+
+
+def _read_final_objective(folder: str, column: str) -> float:
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  series = pd.to_numeric(obj[column], errors="coerce").dropna()
+  assert not series.empty
+  return float(series.iloc[-1])
+
+
+def test_centralized_distributed_and_hierarchical_run_on_planar_degree_three_graph(
+  tmp_path,
+  caplog,
+):
+  _require_gurobi()
+  config = _planar_e2e_config(tmp_path)
+  neighborhood, graph = generate_neighborhood(
+    10,
+    config["limits"],
+    np.random.default_rng(config["seed"]),
+  )
+  assert neighborhood.shape == (10, 10)
+  assert nx.is_connected(graph)
+  assert nx.check_planarity(graph)[0] is True
+  assert graph.number_of_edges() == round(10 * 3 / 2)
+
+  centralized_folder = run_centralized(
+    {**config, "base_solution_folder": str(tmp_path / "centralized")},
+    disable_plotting=True,
+  )
+  faasmacro_folder = run_faasmacro(
+    {**config, "base_solution_folder": str(tmp_path / "faas_macro")},
+    parallelism=0,
+    disable_plotting=True,
+  )
+  hierarchical_folder = run_hierarchical(
+    {**config, "base_solution_folder": str(tmp_path / "hierarchical")},
+    parallelism=0,
+    disable_plotting=True,
+  )
+
+  _assert_generated_graph_is_planar_degree_three(centralized_folder)
+  _assert_generated_graph_is_planar_degree_three(faasmacro_folder)
+  _assert_generated_graph_is_planar_degree_three(hierarchical_folder)
+
+  centralized_tc = pd.read_csv(Path(centralized_folder, "termination_condition.csv"))
+  faasmacro_tc = pd.read_csv(Path(faasmacro_folder, "termination_condition.csv"))
+  hierarchical_tc = pd.read_csv(Path(hierarchical_folder, "termination_condition.csv"))
+
+  _assert_finite_objectives(centralized_folder)
+  _assert_finite_objectives(faasmacro_folder)
+  _assert_finite_objectives(hierarchical_folder)
+  assert (
+    _read_final_objective(hierarchical_folder, "HierarchicalAuction")
+    <= _read_final_objective(centralized_folder, "LoadManagementModel") + 1e-6
+  )
+  assert Path(faasmacro_folder, "LSPc_solution.csv").exists()
+  assert Path(hierarchical_folder, "LSPc_solution.csv").exists()
+
+  assert centralized_tc["LoadManagementModel"].tolist() == ["optimal"]
+  assert _flatten_text(faasmacro_tc)
+  assert _flatten_text(hierarchical_tc)
+  assert "Implicitly replacing the Component attribute OBJ" not in caplog.text
+
+
+def test_hierarchical_preserves_negative_best_objective(tmp_path):
+  _require_gurobi()
+  config = _planar_e2e_config(tmp_path)
+  config["limits"]["weights"]["alpha"] = {"min": 0.0, "max": 0.0}
+  config["limits"]["weights"]["beta_multiplier"] = {"min": 0.0, "max": 0.0}
+  config["limits"]["memory_capacity"] = {"values": [0] * 10}
+
+  folder = run_hierarchical(
+    {**config, "base_solution_folder": str(tmp_path / "hierarchical_negative")},
+    parallelism=0,
+    disable_plotting=True,
+  )
+
+  assert _read_final_objective(folder, "HierarchicalAuction") < 0.0
+
+
+def test_hierarchical_madea_runs_on_planar_degree_three_graph(tmp_path):
+  _require_gurobi()
+  config = _planar_e2e_config(tmp_path)
+  folder = run_hierarchical_madea(
+    {**config, "base_solution_folder": str(tmp_path / "hierarchical_madea")},
+    parallelism=0,
+    disable_plotting=True,
+  )
+
+  _assert_generated_graph_is_planar_degree_three(folder)
+  _assert_finite_objectives(folder)
+  assert Path(folder, "LSPc_solution.csv").exists()
+  assert "HierarchicalMADeA" in pd.read_csv(Path(folder, "obj.csv")).columns
diff --git a/tests/test_faas_helpers_extended.py b/tests/test_faas_helpers_extended.py
new file mode 100644
index 0000000..f106e61
--- /dev/null
+++ b/tests/test_faas_helpers_extended.py
@@ -0,0 +1,281 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from run_faasmacro import (
+  compute_centralized_objective,
+  compute_lower_bound,
+  combine_solutions,
+)
+from run_faasmadea import (
+  data_dict_to_matrix,
+  check_stopping_criteria as madea_check_stopping,
+  compute_residual_capacity as madea_compute_residual,
+  compute_utility,
+)
+from postprocessing import (
+  add_node_function_info,
+  group_count,
+  invert_count,
+)
+
+
+# --- run_faasmacro helper tests ---
+
+def _sp_data():
+  return {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "alpha": {(1, 1): 1.0, (2, 1): 0.8},
+      "beta": {(1, 1, 1): 0.0, (1, 2, 1): 0.9, (2, 1, 1): 0.9, (2, 2, 1): 0.0},
+      "gamma": {(1, 1): 0.1, (2, 1): 0.2},
+      "incoming_load": {(1, 1): 10.0, (2, 1): 5.0},
+      "demand": {(1, 1): 1.0, (2, 1): 2.0},
+      "max_utilization": {1: 6.0},
+      "neighborhood": {
+        (1, 1): 0, (1, 2): 1,
+        (2, 1): 1, (2, 2): 0,
+      },
+      "memory_capacity": {1: 100, 2: 100},
+      "memory_requirement": {1: 2},
+    }
+  }
+
+
+def test_compute_centralized_objective_basic():
+  sp_data = _sp_data()
+  sp_x = np.array([[8.0], [2.0]])
+  sp_y = np.zeros((2, 2, 1))
+  sp_y[0, 1, 0] = 2.0
+  sp_z = np.array([[0.0], [1.0]])
+
+  obj = compute_centralized_objective(sp_data, sp_x, sp_y, sp_z)
+  assert isinstance(obj, float)
+  assert obj > 0
+
+
+def test_compute_centralized_objective_all_local():
+  sp_data = _sp_data()
+  sp_x = np.array([[10.0], [5.0]])
+  sp_y = np.zeros((2, 2, 1))
+  sp_z = np.zeros((2, 1))
+
+  obj = compute_centralized_objective(sp_data, sp_x, sp_y, sp_z)
+  assert isinstance(obj, float)
+
+
+def test_compute_lower_bound_simple():
+  sp_obj = 10.0
+  pi = {1: 0.5}
+  Nfthr = [2.0]
+  loadt = {(1, 1): 5.0, (2, 1): 3.0}
+  lb = compute_lower_bound(sp_obj, pi, Nfthr, loadt, 2, np.array([[3.0], [2.0]]))
+  assert lb == pytest.approx(9.5)
+
+
+def test_combine_solutions_builds_dict():
+  sp_x = np.array([[3.0], [4.0]])
+  spr_r = np.array([[1], [2]])
+  sp_rho = np.array([10.0, 20.0])
+  rmp_x = np.zeros((2, 1))
+  rmp_y = np.zeros((2, 2, 1))
+  rmp_y[0, 1, 0] = 2.0
+  rmp_z = np.array([[0.0], [1.0]])
+  rmp_r = np.zeros((2, 1))
+  rmp_xi = np.zeros((2, 2, 1))
+  rmp_rho = np.array([5.0, 8.0])
+
+  result = combine_solutions(
+    2, 1, _sp_data(), {(1, 1): 10.0, (2, 1): 5.0},
+    sp_x, spr_r, sp_rho, rmp_x, rmp_y, rmp_z, rmp_r, rmp_xi, rmp_rho,
+  )
+
+  assert "sp" in result
+  assert result["sp"]["x"][0, 0] == 3.0
+
+
+def test_combine_solutions_snapshots_offloading_before_later_iterations():
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 2.0
+  result = combine_solutions(
+    2, 1, _sp_data(), {(1, 1): 10.0, (2, 1): 5.0},
+    np.array([[3.0], [4.0]]), np.array([[1], [2]]),
+    np.array([10.0, 20.0]), np.zeros((2, 1)), y,
+    np.zeros((2, 1)), np.zeros((2, 1)), np.zeros((2, 2, 1)),
+    np.array([5.0, 8.0]),
+  )
+
+  y[0, 1, 0] += 0.014
+
+  managed_load = (
+    result["sp"]["x"][0, 0]
+    + result["sp"]["y"][0, :, 0].sum()
+    + result["sp"]["z"][0, 0]
+  )
+  assert managed_load == pytest.approx(10.0)
+
+
+def test_combine_solutions_rejects_offload_to_non_neighbor():
+  sp_data = _sp_data()
+  sp_data[None]["neighborhood"][(1, 2)] = 0
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 2.0
+
+  with pytest.raises(ValueError) as error:
+    combine_solutions(
+      2, 1, sp_data, {(1, 1): 10.0, (2, 1): 5.0},
+      np.array([[3.0], [4.0]]), np.array([[1], [2]]),
+      np.array([10.0, 20.0]), np.zeros((2, 1)), y,
+      np.array([[0.0], [1.0]]), np.zeros((2, 1)),
+      np.zeros((2, 2, 1)), np.array([5.0, 8.0]),
+    )
+
+  assert str(error.value) == "offload_only_to_neighbors (1,2,1)"
+
+
+def test_combine_solutions_tightens_over_allocated_replicas():
+  # Incoming load is 10 (node 1) and 5 (node 2); both process locally (3 and 4)
+  # and reject the rest. Node 1 serves utilization 3.0 (demand 1.0 * local 3.0),
+  # which needs only ceil(3.0 / 6.0) = 1 replica, but the heuristic over-allocated
+  # 5. Node 2 serves utilization 8.0 (demand 2.0 * local 4.0), needing
+  # ceil(8.0 / 6.0) = 2. combine_solutions must tighten r to the centralized
+  # replica equilibrium so the produced solution is centrally feasible (r does not
+  # affect the welfare objective). Without tightening it raises
+  # utilization_equilibrium2 (1,1).
+  sp_data = _sp_data()
+  result = combine_solutions(
+    2, 1, sp_data, {(1, 1): 10.0, (2, 1): 5.0},
+    np.array([[3.0], [4.0]]), np.array([[5], [2]]),
+    np.array([10.0, 20.0]), np.zeros((2, 1)), np.zeros((2, 2, 1)),
+    np.zeros((2, 1)), np.zeros((2, 1)), np.zeros((2, 2, 1)),
+    np.array([5.0, 8.0]),
+  )
+
+  assert result["sp"]["r"][0, 0] == 1
+  assert result["sp"]["r"][1, 0] == 2
+
+
+# --- run_faasmadea helper tests ---
+
+def test_data_dict_to_matrix_3d():
+  data_dict = {
+    (1, 1, 1): 0.0, (1, 2, 1): 5.0,
+    (2, 1, 1): 3.0, (2, 2, 1): 0.0,
+  }
+  mat = data_dict_to_matrix(data_dict, 2, 1)
+  assert mat.shape == (2, 2, 1)
+  assert mat[0, 1, 0] == 5.0
+  assert mat[1, 0, 0] == 3.0
+
+
+def test_madea_check_stopping_criteria_reached_time_limit():
+  stop, why = madea_check_stopping(
+    it=0, max_iterations=10,
+    blackboard=np.ones((2, 2)),
+    sp_omega=np.array([[1.0, 0.0], [0.0, 1.0]]),
+    rmp_omega=np.array([[0.0, 1.0], [1.0, 0.0]]),
+    sp_y=np.ones((2, 2, 2)),
+    tolerance=1e-6,
+    total_runtime=15.0,
+    time_limit=10.0,
+  )
+  assert stop is True
+  assert "time limit" in why
+
+
+def test_madea_check_stopping_criteria_feasible_solution():
+  stop, why = madea_check_stopping(
+    it=0, max_iterations=10,
+    blackboard=np.ones((2, 2)),
+    sp_omega=np.ones((2, 2)),
+    rmp_omega=np.ones((2, 2)),
+    sp_y=np.ones((2, 2, 2)),
+    tolerance=1e-6,
+    total_runtime=1.0,
+    time_limit=100.0,
+  )
+  assert stop is True
+  assert "feasible" in why
+
+
+def test_madea_compute_residual_capacity_zero_replicas():
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "demand": {(1, 1): 1.0, (2, 1): 2.0},
+      "max_utilization": {1: 1.0},
+    }
+  }
+  x = np.array([[0.0], [0.0]])
+  y = np.zeros((2, 2, 1))
+  r = np.array([[0.0], [0.0]])
+
+  cap, residual, ell = madea_compute_residual(x, y, r, data)
+
+  assert cap[0, 0] == 0.0
+  assert residual[0, 0] == 0.0
+  assert ell[0, 0] == 0.0
+
+
+def test_compute_utility_all_positive():
+  data = _sp_data()
+  data[None]["beta"] = {
+    (1, 1, 1): 0.0, (1, 2, 1): 5.0,
+    (2, 1, 1): 3.0, (2, 2, 1): 0.0,
+  }
+
+  utility = compute_utility(
+    p=np.zeros((2, 2, 1)),
+    data=data,
+    auction_options={"latency_weight": 0.1, "fairness_weight": 0.2},
+    latency=np.array([[0.0, 1.0], [1.0, 0.0]]),
+    fairness=np.ones((2, 2)),
+  )
+
+  assert utility.shape == (2, 2, 1)
+  assert utility[0, 1, 0] > 0
+
+
+# --- postprocessing helpers ---
+
+def test_add_node_function_info_parses_index():
+  df = pd.DataFrame({
+    "n0_f0": [1.0],
+    "n0_f1": [3.0],
+    "n1_f0": [5.0],
+  })
+
+  result = add_node_function_info(df, np.array(["n0_f0", "n0_f1", "n1_f0"]))
+
+  assert "node" in result.columns
+  assert "function" in result.columns
+  assert result.loc["n0_f0", "node"] == "n0"
+  assert result.loc["n0_f0", "function"] == "f0"
+
+
+def test_group_count_sums_by_key():
+  df = pd.DataFrame({
+    "node": ["n0", "n0", "n1"],
+    0: [1.0, 2.0, 3.0],
+    1: [4.0, 5.0, 6.0],
+  })
+
+  result = group_count(df, "node")
+
+  assert "tot" in result.columns
+  assert result.loc["n0", "tot"] == 12.0
+  assert result.loc["n1", "tot"] == 9.0
+
+
+def test_invert_count_flattens_nested_dict():
+  original = {
+    0: {"model_a": 1.0, "model_b": 2.0},
+    1: {"model_a": 3.0, "model_b": 4.0},
+  }
+
+  result = invert_count(original)
+
+  assert result.index.names == ["time", "model"]
+  assert result.loc[(0, "model_a"), 0] == 1.0
diff --git a/tests/test_gcaa_e2e.py b/tests/test_gcaa_e2e.py
new file mode 100644
index 0000000..7e473d1
--- /dev/null
+++ b/tests/test_gcaa_e2e.py
@@ -0,0 +1,78 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+from parse import parse
+
+from decentralized_gcaa import run as run_gcaa
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "gcaa": {
+        "unit_bids": True, "epsilon": 0.01,
+        "latency_weight": 0.0, "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 50,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_run_gcaa_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_gcaa(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert "FaaS-MAGCAA" in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MAGCAA"], errors="coerce")).all()
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert len(tc) >= 1
+  for s in tc["0"]:
+    assert parse(
+      "{} (it: {}; obj. deviation: {}; best it: {}; total runtime: {})", s
+    ) is not None
diff --git a/tests/test_gcaa_helpers.py b/tests/test_gcaa_helpers.py
new file mode 100644
index 0000000..fcc4e64
--- /dev/null
+++ b/tests/test_gcaa_helpers.py
@@ -0,0 +1,80 @@
+import numpy as np
+import pandas as pd
+
+from decentralized_gcaa import resolve_gcaa_round
+
+
+def _bids(rows):
+  return pd.DataFrame(rows, columns=["i", "j", "f", "d", "b", "utility"])
+
+
+def test_empty_bids_returns_zero_allocation():
+  residual_capacity = np.ones((2, 1))
+  y_round = resolve_gcaa_round(_bids([]), residual_capacity)
+  assert y_round.shape == (2, 2, 1)
+  assert (y_round == 0).all()
+
+
+def test_single_winner_per_contested_task():
+  # agents 0 and 1 both target seller 1 / function 0; agent 1 has the
+  # higher utility and must be the sole winner this round
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+    {"i": 1, "j": 1, "f": 0, "d": 1, "b": 0.7, "utility": 2.0},
+  ])
+  residual_capacity = np.array([[0.0], [5.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round[1, 1, 0] == 1.0
+  assert y_round[0, 1, 0] == 0.0
+  assert y_round.sum() == 1.0
+
+
+def test_agent_proposes_only_its_best_task():
+  # agent 0 has bid rows for two different sellers; only the
+  # higher-utility one (seller 2) should be proposed this round
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.1, "utility": 0.5},
+    {"i": 0, "j": 2, "f": 0, "d": 1, "b": 0.9, "utility": 3.0},
+  ])
+  residual_capacity = np.array([[5.0], [5.0], [5.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round[0, 2, 0] == 1.0
+  assert y_round[0, 1, 0] == 0.0
+
+
+def test_seller_with_no_residual_capacity_is_skipped():
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+  ])
+  residual_capacity = np.array([[5.0], [0.0]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round.sum() == 0.0
+
+
+def test_bid_larger_than_residual_capacity_is_skipped():
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+  ])
+  residual_capacity = np.array([[5.0], [0.4]])
+  y_round = resolve_gcaa_round(bids, residual_capacity)
+  assert y_round.sum() == 0.0
+
+
+def test_receiving_agent_cannot_offload_same_function():
+  bids = _bids([
+    {"i": 1, "j": 2, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+  ])
+  current_y = np.zeros((3, 3, 1))
+  current_y[0, 1, 0] = 1.0
+  y_round = resolve_gcaa_round(bids, np.ones((3, 1)), current_y)
+  assert y_round.sum() == 0.0
+
+
+def test_round_does_not_create_ping_pong_chain():
+  bids = _bids([
+    {"i": 0, "j": 1, "f": 0, "d": 1, "b": 0.8, "utility": 2.0},
+    {"i": 1, "j": 2, "f": 0, "d": 1, "b": 0.5, "utility": 1.0},
+  ])
+  y_round = resolve_gcaa_round(bids, np.ones((3, 1)), np.zeros((3, 3, 1)))
+  assert y_round[0, 1, 0] == 1.0
+  assert y_round[1, 2, 0] == 0.0
diff --git a/tests/test_gcaa_wiring.py b/tests/test_gcaa_wiring.py
new file mode 100644
index 0000000..2abe7c5
--- /dev/null
+++ b/tests/test_gcaa_wiring.py
@@ -0,0 +1,156 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import networkx as nx
+import pandas as pd
+import pytest
+
+import decentralized_gcaa
+import run
+
+
+def test_methods_choice_accepts_faas_gcaa(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-gcaa"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-gcaa" in args.methods
+
+
+def test_run_module_exposes_gcaa_runner():
+  assert hasattr(run, "run_gcaa")
+  assert callable(run.run_gcaa)
+
+
+def test_method_result_models_has_gcaa_entry():
+  assert run.METHOD_RESULT_MODELS["faas-gcaa"] == ("LSPc", "FaaS-MAGCAA")
+
+
+def test_planar_config_has_gcaa_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  gcaa = config["solver_options"]["gcaa"]
+  assert gcaa["unit_bids"] is True
+  assert "latency_weight" in gcaa
+  assert "fairness_weight" in gcaa
+
+
+def test_set_solution_folder_tolerates_missing_method_key():
+  solution_folders = {"experiments_list": []}
+  run.set_solution_folder(solution_folders, "faas-gcaa", 0, "/some/folder")
+  assert solution_folders["faas-gcaa"][0] == "/some/folder"
+
+
+def test_gcaa_run_requires_unit_bids(tmp_path):
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {}},
+    "solver_name": "mock",
+    "solver_options": {"gcaa": {"unit_bids": False}},
+    "max_iterations": 1,
+    "max_steps": 1,
+    "checkpoint_interval": 1,
+  }
+  with pytest.raises(ValueError, match="unit_bids must be true"):
+    decentralized_gcaa.run(config, parallelism=0)
+
+
+def test_gcaa_run_stops_when_no_bids_available(tmp_path, monkeypatch):
+  base_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0},
+    }
+  }
+  monkeypatch.setattr(
+    decentralized_gcaa, "init_problem",
+    lambda *args, **kwargs: (base_data, {}, [], nx.empty_graph(1)),
+  )
+  monkeypatch.setattr(decentralized_gcaa, "get_current_load", lambda *args: {})
+  monkeypatch.setattr(decentralized_gcaa, "update_data", lambda data, update: data)
+  monkeypatch.setattr(decentralized_gcaa, "LSP", lambda: "LSP")
+  monkeypatch.setattr(decentralized_gcaa, "LSPr", lambda: "LSPr")
+
+  def _solve_subproblem(sp_data, agents, sp, *args):
+    return (
+      sp_data,
+      np.zeros((1, 1)),
+      None,
+      None,
+      np.zeros((1, 1)),   # sp_omega: no residual load -> no bids
+      np.ones((1, 1)),
+      np.array([0.0]),
+      np.zeros((1, 1)),
+      {"tot": 0.0},
+      {"tot": "ok"},
+      {"tot": 0.0},
+    )
+
+  monkeypatch.setattr(decentralized_gcaa, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(
+    decentralized_gcaa, "compute_residual_capacity",
+    lambda *args: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))),
+  )
+  monkeypatch.setattr(
+    decentralized_gcaa, "define_bids",
+    lambda *args, **kwargs: (
+      pd.DataFrame({"i": [], "j": [], "f": [], "d": [], "b": [], "utility": []}),
+      pd.DataFrame({"i": [], "j": [], "f": []}),
+      1,
+    ),
+  )
+  expected_solution = {"sp": {
+    "x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)),
+    "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1)),
+  }}
+  monkeypatch.setattr(
+    decentralized_gcaa, "combine_solutions", lambda *args: expected_solution,
+  )
+  monkeypatch.setattr(
+    decentralized_gcaa, "compute_centralized_objective", lambda *args: -np.inf
+  )
+  monkeypatch.setattr(decentralized_gcaa, "check_feasibility", lambda *args: (True, "ok"))
+
+  decoded = []
+
+  def _decode(sp_data, solution, complete, arg):
+    decoded.append(solution)
+    return complete, None, 1.0
+
+  monkeypatch.setattr(decentralized_gcaa, "decode_solutions", _decode)
+  monkeypatch.setattr(
+    decentralized_gcaa, "join_complete_solution", lambda complete: ({}, {}, {})
+  )
+  monkeypatch.setattr(decentralized_gcaa, "save_checkpoint", lambda *args: None)
+  monkeypatch.setattr(decentralized_gcaa, "save_solution", lambda *args: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {
+      "general": {"TimeLimit": 10},
+      "gcaa": {
+        "unit_bids": True, "epsilon": 0.01,
+        "latency_weight": 0.0, "fairness_weight": 0.0,
+      },
+    },
+    "max_iterations": 5,
+    "max_steps": 1,
+    "min_run_time": 0,
+    "max_run_time": 0,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "verbose": 0,
+  }
+
+  decentralized_gcaa.run(config, parallelism=0, disable_plotting=True)
+
+  assert len(decoded) == 2
+  assert all(solution is not None for solution in decoded)
+  for solution in decoded:
+    for name, expected in expected_solution["sp"].items():
+      assert np.array_equal(solution["sp"][name], expected)
diff --git a/tests/test_generate_data_extended.py b/tests/test_generate_data_extended.py
new file mode 100644
index 0000000..00e97bc
--- /dev/null
+++ b/tests/test_generate_data_extended.py
@@ -0,0 +1,336 @@
+import numpy as np
+import networkx as nx
+import pytest
+from networkx import Graph
+
+from generate_data import (
+  add_network_latency,
+  generate_data,
+  generate_demand,
+  generate_memory_capacity,
+  generate_memory_requirement,
+  generate_neighborhood,
+  generate_weights,
+  random_instance_data,
+)
+
+
+def _rng(seed=42):
+  return np.random.default_rng(seed)
+
+
+def test_generate_demand_heterogeneous():
+  limits = {"demand": {"type": "heterogeneous", "min": 1, "max": 5}}
+  demand = generate_demand(2, 3, limits, _rng())
+  assert demand.shape == (2, 3)
+
+
+def test_generate_demand_from_values():
+  limits = {"demand": {"values": [1.5, 2.5]}}
+  demand = generate_demand(2, 2, limits, _rng())
+  assert np.allclose(demand, [1.5, 2.5])
+
+
+def test_generate_memory_capacity_last_repeated_covers_remaining():
+  rng = _rng()
+  limits = {
+    "memory_capacity": {
+      "repeated_values": [(0.3, 32), (0.3, 64), (0.4, 128)],
+    },
+    "demand": {},
+  }
+  capacity, speedup = generate_memory_capacity(10, limits, rng)
+  assert len(capacity) == 10
+  assert all(isinstance(c, int) for c in capacity)
+
+
+def test_generate_memory_capacity_random_values():
+  rng = _rng()
+  limits = {"memory_capacity": {"min": 4, "max": 16}}
+  capacity, speedup = generate_memory_capacity(3, limits, rng)
+  assert len(capacity) == 3
+  assert len(speedup) == 3
+  assert all(s == 1.0 for s in speedup)
+
+
+def test_generate_memory_requirement_random_range():
+  rng = _rng()
+  limits = {"memory_requirement": {"min": 1, "max": 5}}
+  req = generate_memory_requirement(4, limits, rng)
+  assert len(req) == 4
+  assert all(1 <= r <= 5 for r in req)
+
+
+def test_generate_neighborhood_with_k_regular():
+  rng = _rng()
+  limits = {"neighborhood": {"k": 3}}
+  neighborhood, graph = generate_neighborhood(6, limits, rng)
+  assert neighborhood.shape == (6, 6)
+  assert graph.number_of_nodes() == 6
+  assert not np.allclose(neighborhood, np.zeros((6, 6)))
+
+
+def test_probability_neighborhood_is_connected():
+  limits = {"neighborhood": {"p": 1.0}}
+  matrix, graph = generate_neighborhood(4, limits, _rng(1))
+  assert nx.is_connected(graph)
+  assert matrix.shape == (4, 4)
+
+
+def test_probability_neighborhood_rejects_impossible_connectivity():
+  limits = {"neighborhood": {"p": 0.0}}
+  with pytest.raises(ValueError, match="connected random neighborhood"):
+    generate_neighborhood(4, limits, _rng(1))
+
+
+def test_fixed_edge_neighborhood_is_connected_and_exact():
+  limits = {"neighborhood": {"m": 30}}
+
+  _, graph = generate_neighborhood(20, limits, _rng(3))
+
+  assert nx.is_connected(graph)
+  assert graph.number_of_edges() == 30
+
+
+def test_regular_neighborhood_is_connected():
+  limits = {"neighborhood": {"k": 3}}
+
+  _, graph = generate_neighborhood(20, limits, _rng(3))
+
+  assert nx.is_connected(graph)
+
+
+def test_generate_euclidean_planar_neighborhood_with_target_mean_degree():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 3, "density": 0.5,
+    }
+  }
+
+  neighborhood, graph = generate_neighborhood(20, limits, _rng(7))
+  positions = nx.get_node_attributes(graph, "pos")
+
+  assert neighborhood.shape == (20, 20)
+  assert nx.is_connected(graph)
+  assert nx.check_planarity(graph)[0] is True
+  assert graph.number_of_edges() == round(20 * 3 / 2)
+  assert len(positions) == 20
+  assert all(0 <= x <= np.sqrt(20 / 0.5) for x, _ in positions.values())
+  assert all(0 <= y <= np.sqrt(20 / 0.5) for _, y in positions.values())
+  assert all(data["edge_length"] > 0 for _, _, data in graph.edges(data=True))
+
+
+def test_euclidean_planar_neighborhood_changes_with_seed():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 3, "density": 1.0,
+    }
+  }
+
+  _, first = generate_neighborhood(20, limits, _rng(1))
+  _, second = generate_neighborhood(20, limits, _rng(2))
+
+  assert nx.get_node_attributes(first, "pos") != nx.get_node_attributes(
+    second, "pos"
+  )
+
+
+def test_euclidean_planar_neighborhood_rejects_infeasible_edge_budget():
+  limits = {
+    "neighborhood": {
+      "type": "euclidean_planar", "mean_degree": 1, "density": 1.0,
+    }
+  }
+
+  with pytest.raises(ValueError, match="connected Euclidean planar"):
+    generate_neighborhood(20, limits, _rng(1))
+
+
+def test_generate_weights_with_initialization_time():
+  rng = _rng()
+  graph = Graph()
+  graph.add_edge(0, 1)
+  graph.edges[0, 1]["network_latency"] = 2.0
+  graph.edges[0, 1]["edge_bandwidth"] = 100
+
+  limits = {
+    "weights": {
+      "initialization_time": {"min": 1.0, "max": 1.0},
+      "input_data": {"min": 100, "max": 100},
+      "cloud_bandwidth": {"min": 50, "max": 50},
+      "cloud_network_latency": {"min": 0.5, "max": 0.5},
+    }
+  }
+  alpha, beta, gamma, delta = generate_weights(2, 1, limits, rng, graph)
+
+  assert len(alpha) == 1
+  assert beta.shape == (2, 2, 1)
+  assert gamma.shape == (2, 1)
+  assert delta.shape == (2, 1)
+  assert beta[0, 1, 0] >= 0
+  assert np.isfinite(gamma).all()
+
+
+def test_generate_weights_homogeneous():
+  rng = _rng()
+  graph = Graph()
+  graph.add_edge(0, 1)
+
+  limits = {
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    }
+  }
+  alpha, beta, gamma, delta = generate_weights(2, 2, limits, rng, graph)
+
+  assert len(alpha) == 2
+  assert beta.shape == (2, 2, 2)
+  assert gamma.shape == (2, 2)
+  assert delta.shape == (2, 2)
+
+
+def test_generate_weights_heterogeneous():
+  rng = _rng()
+  graph = Graph()
+  graph.add_edge(0, 1)
+
+  limits = {
+    "weights": {
+      "type": "heterogeneous",
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    }
+  }
+  alpha, beta, gamma, delta = generate_weights(2, 1, limits, rng, graph)
+
+  assert len(alpha) == 1
+  assert beta.shape == (2, 2, 1)
+
+
+def test_add_network_latency_without_weights():
+  graph = Graph()
+  graph.add_edge(0, 1)
+  rng = _rng()
+  limits = {}
+  result = add_network_latency(graph, limits, rng)
+  assert result.edges[0, 1]["network_latency"] == 1.0
+
+
+def test_add_network_latency_from_euclidean_length():
+  graph = Graph()
+  graph.add_edge(0, 1, edge_length=2.5)
+  limits = {
+    "weights": {
+      "edge_network_latency": {
+        "mode": "euclidean",
+        "base": 1.0,
+        "distance_factor": 2.0,
+        "jitter": {"min": 0.0, "max": 0.0},
+      }
+    }
+  }
+
+  result = add_network_latency(graph, limits, _rng(1))
+
+  assert result.edges[0, 1]["network_latency"] == 6.0
+
+
+def test_permuted_euclidean_latency_preserves_values():
+  graph = nx.path_graph(4)
+  for index, edge in enumerate(graph.edges(), start=1):
+    graph.edges[edge]["edge_length"] = float(index)
+  base = {
+    "base": 0.0,
+    "distance_factor": 1.0,
+    "jitter": {"min": 0.0, "max": 0.0},
+  }
+
+  direct = add_network_latency(
+    graph.copy(),
+    {"weights": {"edge_network_latency": {**base, "mode": "euclidean"}}},
+    _rng(2),
+  )
+  permuted = add_network_latency(
+    graph.copy(),
+    {
+      "weights": {
+        "edge_network_latency": {**base, "mode": "euclidean_permuted"}
+      }
+    },
+    _rng(2),
+  )
+  direct_values = nx.get_edge_attributes(direct, "network_latency")
+  permuted_values = nx.get_edge_attributes(permuted, "network_latency")
+
+  assert sorted(direct_values.values()) == sorted(permuted_values.values())
+  assert direct_values != permuted_values
+
+
+def test_random_instance_data_load_from_values():
+  limits = {
+    "Nn": {"min": 2, "max": 2},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"p": 1.0},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    },
+    "demand": {"values": [1.0]},
+    "memory_requirement": {"values": [2]},
+    "memory_capacity": {"values": [10, 12]},
+    "max_utilization": {"min": 0.5, "max": 0.5},
+    "load": {"values": [3.0], "trace_type": "fixed_sum"},
+  }
+  data, load_limits, graph = random_instance_data(limits, _rng())
+  assert data[None]["Nn"][None] == 2
+  assert load_limits[0][0] == 3.0
+
+
+def test_random_instance_data_load_default():
+  limits = {
+    "Nn": {"min": 2, "max": 2},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"p": 1.0},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    },
+    "demand": {"values": [1.0]},
+    "memory_requirement": {"values": [2]},
+    "memory_capacity": {"values": [10, 12]},
+    "max_utilization": {"min": 0.5, "max": 0.5},
+    "load": {"min": {"min": 1, "max": 2}, "max": {"min": 5, "max": 6}, "trace_type": "fixed_sum"},
+  }
+  data, load_limits, graph = random_instance_data(limits, _rng())
+  assert len(load_limits) == 1  # Nf = 1
+  assert load_limits[0][0]["min"] >= 1
+
+
+def test_random_instance_data_heterogeneous_demand():
+  limits = {
+    "Nn": {"min": 2, "max": 2},
+    "Nf": {"min": 1, "max": 1},
+    "neighborhood": {"p": 1.0},
+    "weights": {
+      "alpha": {"min": 1.0, "max": 1.0},
+      "beta_multiplier": {"min": 2.0, "max": 2.0},
+      "gamma": {"min": 0.1, "max": 0.1},
+      "delta_multiplier": {"min": 0.1, "max": 0.1},
+    },
+    "demand": {"type": "heterogeneous", "min": 1, "max": 3},
+    "memory_requirement": {"values": [2]},
+    "memory_capacity": {"values": [10, 12]},
+    "max_utilization": {"min": 0.5, "max": 0.5},
+    "load": {"min": {"min": 1, "max": 2}, "max": {"min": 5, "max": 6}, "trace_type": "fixed_sum"},
+  }
+  data, load_limits, graph = random_instance_data(limits, _rng())
+  assert data[None]["Nn"][None] == 2
diff --git a/tests/test_generate_data_helpers.py b/tests/test_generate_data_helpers.py
new file mode 100644
index 0000000..f38b191
--- /dev/null
+++ b/tests/test_generate_data_helpers.py
@@ -0,0 +1,47 @@
+import numpy as np
+import pytest
+
+from generate_data import (
+  generate_data,
+  generate_memory_capacity,
+  generate_memory_requirement,
+  update_data,
+)
+
+
+def test_update_data_returns_deep_copy():
+  data = {None: {"a": {"x": 1}, "b": 2}}
+  updated = update_data(data, {"b": 9})
+  assert updated[None]["b"] == 9
+  assert data[None]["b"] == 2
+  updated[None]["a"]["x"] = 42
+  assert data[None]["a"]["x"] == 1
+
+
+def test_generate_memory_capacity_repeated_values_covers_all_nodes():
+  rng = np.random.default_rng(3)
+  limits = {
+    "memory_capacity": {
+      "repeated_values": [(0.4, 64), (0.6, 128)],
+    },
+    "demand": {
+      "speedup_factors": {"64": 1.0, "128": 2.0},
+    },
+  }
+  capacity, speedup = generate_memory_capacity(5, limits, rng)
+  assert len(capacity) == 5
+  assert len(speedup) == 5
+  assert set(capacity).issubset({64, 128})
+  assert set(speedup).issubset({1.0, 2.0})
+
+
+def test_generate_memory_requirement_from_values():
+  rng = np.random.default_rng(9)
+  limits = {"memory_requirement": {"values": [10, 20, 30]}}
+  req = generate_memory_requirement(3, limits, rng)
+  assert req == [10, 20, 30]
+
+
+def test_generate_data_invalid_scenario_raises():
+  with pytest.raises(KeyError, match = "Undefined scenario"):
+    generate_data("bad-scenario", rng = np.random.default_rng(1), limits = {})
diff --git a/tests/test_hierarchical_engine.py b/tests/test_hierarchical_engine.py
new file mode 100644
index 0000000..3f560d7
--- /dev/null
+++ b/tests/test_hierarchical_engine.py
@@ -0,0 +1,358 @@
+import numpy as np
+import pytest
+
+from hierarchical_auction.engine import HierarchicalAuctionEngine
+
+
+def test_level2_rejects_non_neighbor_allocation():
+  neighborhood = np.array([
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0],
+  ], dtype=float)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+  y = np.zeros((3, 3, 1))
+  omega = np.array([[3.0], [0.0], [0.0]])
+  residual_capacity = np.array([[0.0], [0.0], [5.0]])
+  node_prices = np.zeros((3, 1))
+  latency = np.zeros((3, 3))
+  fairness = np.zeros((3, 1))
+
+  result = engine.run_higher_levels(
+    y=y,
+    omega=omega,
+    residual_capacity=residual_capacity,
+    node_prices=node_prices,
+    latency=latency,
+    fairness=fairness,
+  )
+
+  assert result.y[0, 2, 0] == 0.0
+  assert result.omega[0, 0] == 3.0
+  assert result.accepted_allocations == []
+
+
+def test_service_quantum_converts_tokens_to_capacity_quantity():
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([2.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 1)),
+    omega=np.array([[4.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0], [4.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.y[0, 2, 0] == 4.0
+  assert result.omega[0, 0] == 0.0
+  assert sum(a.tokens for a in result.accepted_allocations) == 2
+
+
+def test_higher_level_auction_never_allocates_to_same_node():
+  neighborhood = np.array([
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0],
+  ], dtype=float)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 1)),
+    omega=np.array([[2.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[10.0], [0.0], [0.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.y[0, 0, 0] == 0.0
+  assert result.omega[0, 0] == 2.0
+  assert result.accepted_allocations == []
+
+
+def test_higher_level_auction_rejects_buyer_that_already_receives():
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.array([
+      [[0.0], [0.0], [0.0]],
+      [[1.0], [0.0], [0.0]],
+      [[0.0], [0.0], [0.0]],
+    ]),
+    omega=np.array([[3.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0], [5.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.y[0, 2, 0] == 0.0
+  assert result.y[1, 0, 0] == 1.0
+  assert result.omega[0, 0] == 3.0
+  assert result.accepted_allocations == []
+
+
+def test_higher_level_auction_rejects_seller_that_already_sends():
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.array([
+      [[0.0], [1.0], [0.0]],
+      [[0.0], [0.0], [0.0]],
+      [[0.0], [0.0], [0.0]],
+    ]),
+    omega=np.array([[0.0], [0.0], [3.0]]),
+    residual_capacity=np.array([[5.0], [0.0], [0.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.y[2, 0, 0] == 0.0
+  assert result.y[0, 1, 0] == 1.0
+  assert result.omega[2, 0] == 3.0
+  assert result.accepted_allocations == []
+
+
+def test_higher_level_auction_prefers_best_effective_seller():
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.5, 0.3],
+      "latency_weight": 1.0,
+      "fairness_weight": 0.0,
+    },
+  )
+  latency = np.array([
+    [0.0, 100.0, 0.0],
+    [0.0, 0.0, 0.0],
+    [0.0, 0.0, 0.0],
+  ])
+
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 1)),
+    omega=np.array([[2.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [2.0], [2.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=latency,
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.y[0, 1, 0] == 0.0
+  assert result.y[0, 2, 0] == 2.0
+  assert result.omega[0, 0] == 0.0
+
+
+def test_higher_level_auction_rejects_non_positive_effective_bid():
+  neighborhood = np.array([
+    [0, 1, 0],
+    [1, 0, 1],
+    [0, 1, 0],
+  ], dtype=float)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=1,
+    service_quantum=np.array([1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.0, 0.0],
+      "latency_weight": 1.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 1)),
+    omega=np.array([[2.0], [0.0], [0.0]]),
+    residual_capacity=np.array([[0.0], [0.0], [5.0]]),
+    node_prices=np.zeros((3, 1)),
+    latency=np.array([
+      [0.0, 0.0, 10.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+    ]),
+    fairness=np.zeros((3, 1)),
+  )
+
+  assert result.accepted_allocations == []
+  assert result.y[0, 2, 0] == 0.0
+  assert result.omega[0, 0] == 2.0
+
+
+def test_price_computed_correctly_in_zero_price_two_function_network():
+  """Regression: price computation must not rely on zero sentinel.
+
+  With eta=0 and zero node prices, structure_price = 0 legitimately.
+  The effective bid = max(0 + epsilon, 0) = epsilon > 0, so allocation
+  must still happen for both functions.
+  """
+  neighborhood = np.ones((3, 3), dtype=float) - np.eye(3)
+  engine = HierarchicalAuctionEngine(
+    neighborhood=neighborhood,
+    num_functions=2,
+    service_quantum=np.array([1.0, 1.0]),
+    max_depth=2,
+    auction_options={
+      "epsilon": 0.01,
+      "eta": [0.0, 0.0],
+      "latency_weight": 0.0,
+      "fairness_weight": 0.0,
+    },
+  )
+
+  result = engine.run_higher_levels(
+    y=np.zeros((3, 3, 2)),
+    omega=np.array([[3.0, 2.0], [0.0, 0.0], [0.0, 0.0]]),
+    residual_capacity=np.array([[0.0, 0.0], [0.0, 0.0], [5.0, 5.0]]),
+    node_prices=np.zeros((3, 2)),
+    latency=np.zeros((3, 3)),
+    fairness=np.zeros((3, 2)),
+  )
+
+  assert result.y[0, 2, 0] == 3.0
+  assert result.y[0, 2, 1] == 2.0
+  assert result.omega[0, 0] == 0.0
+  assert result.omega[0, 1] == 0.0
+
+
+def test_engine_stops_early_when_no_capacity_available():
+    """No seller has capacity — engine must return immediately with empty allocations."""
+    neighborhood = np.array([
+        [0, 1, 0],
+        [1, 0, 1],
+        [0, 1, 0],
+    ], dtype=float)
+    engine = HierarchicalAuctionEngine(
+        neighborhood=neighborhood,
+        num_functions=1,
+        service_quantum=np.array([1.0]),
+        max_depth=5,
+        auction_options={
+            "epsilon": 0.01,
+            "eta": [0.5, 0.3, 0.2, 0.1, 0.05],
+            "latency_weight": 0.0,
+            "fairness_weight": 0.0,
+        },
+    )
+
+    result = engine.run_higher_levels(
+        y=np.zeros((3, 3, 1)),
+        omega=np.array([[3.0], [0.0], [0.0]]),
+        residual_capacity=np.zeros((3, 1)),
+        node_prices=np.zeros((3, 1)),
+        latency=np.zeros((3, 3)),
+        fairness=np.zeros((3, 1)),
+    )
+
+    assert result.accepted_allocations == []
+    assert result.omega[0, 0] == 3.0
+    assert result.y[0, :, 0].sum() == 0.0
+
+
+def test_engine_multi_level_cascade_terminates_cleanly():
+    """Engine must iterate levels without error and not over-allocate.
+
+    Topology: linear chain 0-1-2-3-4.
+    omega[0] = 2.0, residual_capacity[4] = 5.0.
+    Node 4 may not be reachable at level 2 depending on aggregation,
+    but the engine must terminate without AssertionError and the
+    total allocated flow must equal 2.0 - remaining omega.
+    """
+    n = 5
+    neighborhood = np.zeros((n, n), dtype=float)
+    for i in range(n - 1):
+        neighborhood[i, i + 1] = 1.0
+        neighborhood[i + 1, i] = 1.0
+
+    engine = HierarchicalAuctionEngine(
+        neighborhood=neighborhood,
+        num_functions=1,
+        service_quantum=np.array([1.0]),
+        max_depth=4,
+        auction_options={
+            "epsilon": 0.01,
+            "eta": [0.5, 0.4, 0.3, 0.2],
+            "latency_weight": 0.0,
+            "fairness_weight": 0.0,
+        },
+    )
+
+    result = engine.run_higher_levels(
+        y=np.zeros((n, n, 1)),
+        omega=np.array([[2.0], [0.0], [0.0], [0.0], [0.0]]),
+        residual_capacity=np.array([[0.0], [0.0], [0.0], [0.0], [5.0]]),
+        node_prices=np.zeros((n, 1)),
+        latency=np.zeros((n, n)),
+        fairness=np.zeros((n, 1)),
+    )
+
+    assert result.omega[0, 0] >= 0.0
+    total_allocated = result.y[0, :, 0].sum()
+    assert total_allocated == pytest.approx(2.0 - result.omega[0, 0])
+    assert result.y[0, 0, 0] == 0.0   # no self-allocation
+    assert total_allocated <= 2.0
diff --git a/tests/test_hierarchical_flow_mapper.py b/tests/test_hierarchical_flow_mapper.py
new file mode 100644
index 0000000..3891999
--- /dev/null
+++ b/tests/test_hierarchical_flow_mapper.py
@@ -0,0 +1,48 @@
+import numpy as np
+
+from hierarchical_auction.flow_mapper import apply_allocations
+from hierarchical_auction.types import AcceptedAllocation
+
+
+def test_apply_allocations_updates_y_and_residual_demand():
+  y = np.zeros((3, 3, 1))
+  omega = np.array([[5.0], [0.0], [0.0]])
+  allocations = [
+    AcceptedAllocation(
+      level=2,
+      buyer_structure=0,
+      buyer_node=0,
+      seller_node=2,
+      function=0,
+      tokens=3,
+      quantity=3.0,
+      bid_value=1.0,
+    )
+  ]
+  new_y, new_omega = apply_allocations(y, omega, allocations)
+  assert new_y[0, 2, 0] == 3.0
+  assert new_omega[0, 0] == 2.0
+
+
+def test_apply_allocations_clips_to_remaining_demand():
+  y = np.zeros((2, 2, 1))
+  omega = np.array([[2.0], [0.0]])
+  allocations = [
+    AcceptedAllocation(2, 0, 0, 1, 0, 5, 5.0, 1.0)
+  ]
+  new_y, new_omega = apply_allocations(y, omega, allocations)
+  assert new_y[0, 1, 0] == 2.0
+  assert new_omega[0, 0] == 0.0
+
+
+def test_apply_allocations_does_not_mutate_inputs():
+  y = np.zeros((2, 2, 1))
+  omega = np.array([[3.0], [0.0]])
+  y_orig = y.copy()
+  omega_orig = omega.copy()
+  allocations = [
+    AcceptedAllocation(2, 0, 0, 1, 0, 2, 2.0, 1.0)
+  ]
+  apply_allocations(y, omega, allocations)
+  assert np.array_equal(y, y_orig)
+  assert np.array_equal(omega, omega_orig)
diff --git a/tests/test_hierarchical_madea_runner.py b/tests/test_hierarchical_madea_runner.py
new file mode 100644
index 0000000..997d5b6
--- /dev/null
+++ b/tests/test_hierarchical_madea_runner.py
@@ -0,0 +1,65 @@
+import numpy as np
+import pandas as pd
+
+import run_faasmadea as madea
+import run
+from hierarchical_auction import madea_runner
+
+
+def test_reuses_production_madea_helpers_without_wrapping_them():
+  assert madea_runner.define_bids is madea.define_bids
+  assert madea_runner.evaluate_bids is madea.evaluate_bids
+  assert madea_runner.compute_residual_capacity is madea.compute_residual_capacity
+  assert madea_runner.check_stopping_criteria is madea.check_stopping_criteria
+  assert madea_runner.start_additional_replicas is madea.start_additional_replicas
+
+
+def test_build_auction_options_preserves_madea_options():
+  config = {
+    "solver_options": {
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3, 0.1],
+        "zeta": 0.1,
+        "latency_weight": 0.25,
+        "fairness_weight": 0.5,
+        "unit_bids": True,
+      }
+    }
+  }
+  options = madea_runner.build_auction_options(config)
+  assert options["unit_bids"] is True
+  assert options["eta"] == [0.5, 0.3, 0.1]
+  assert madea_runner.level1_options(options)["eta"] == 0.5
+
+
+def test_compute_offloaded_demand_sums_seller_axis():
+  y = np.zeros((2, 3, 1))
+  y[0, 1, 0] = 2.0
+  y[0, 2, 0] = 3.0
+  assert np.array_equal(
+    madea_runner.compute_offloaded_demand(y), np.array([[5.0], [0.0]]),
+  )
+
+
+def test_bids_for_stopping_records_hierarchical_progress():
+  assert len(madea_runner.bids_for_stopping(pd.DataFrame(), 2)) == 1
+  assert madea_runner.bids_for_stopping(pd.DataFrame(), 0).empty
+
+
+def test_run_py_accepts_and_exposes_hierarchical_madea(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["run.py", "--methods", "hierarchical-madea"],
+  )
+  assert run.parse_arguments().methods == ["hierarchical-madea"]
+  assert run.run_hierarchical_madea is madea_runner.run
+  assert run.METHOD_RESULT_MODELS["hierarchical-madea"] == (
+    "LSPc", "HierarchicalMADeA",
+  )
+
+
+def test_compare_results_defaults_include_hierarchical_madea(monkeypatch):
+  import compare_results
+
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  assert "HierarchicalMADeA" in compare_results.parse_arguments().models
diff --git a/tests/test_hierarchical_pricing.py b/tests/test_hierarchical_pricing.py
new file mode 100644
index 0000000..c06ac5f
--- /dev/null
+++ b/tests/test_hierarchical_pricing.py
@@ -0,0 +1,37 @@
+import numpy as np
+import pytest
+
+from hierarchical_auction.pricing import (
+  compute_effective_bid,
+  compute_structure_price,
+  generate_structure_bid,
+)
+from hierarchical_auction.structure import Structure
+
+
+def test_structure_price_matches_pdf_equation_27():
+  structure = Structure(level=2, root_node=0, member_nodes={0, 1},
+                        adjacent_structures=set(), num_functions=1)
+  structure.residual_demand[:] = [6.0]
+  node_prices = np.array([[0.2], [0.4]])
+  node_tokens = np.array([[4], [2]])
+  price = compute_structure_price(structure, node_prices, node_tokens, eta=0.5)
+  assert price[0] == pytest.approx(0.3 + 0.5 * (6.0 / (6.0 + 6.0 + 1e-6)))
+
+
+def test_bid_to_node_is_at_least_node_price():
+  structure_price = 0.1
+  node_price = 0.5
+  assert generate_structure_bid(structure_price, node_price, epsilon=0.01) == 0.5
+
+
+def test_effective_bid_penalizes_latency_and_fairness():
+  effective = compute_effective_bid(
+    bid=2.0,
+    node_price=0.5,
+    latency=3.0,
+    fairness=4.0,
+    latency_weight=0.1,
+    fairness_weight=0.2,
+  )
+  assert effective == pytest.approx(2.0 - 0.5 - 0.3 - 0.8)
diff --git a/tests/test_hierarchical_runner.py b/tests/test_hierarchical_runner.py
new file mode 100644
index 0000000..9b36770
--- /dev/null
+++ b/tests/test_hierarchical_runner.py
@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+
+from hierarchical_auction.runner import (
+  build_auction_options,
+  compute_offloaded_demand,
+  bids_for_stopping,
+)
+
+
+def test_build_auction_options_accepts_scalar_or_list_eta():
+  config = {
+    "solver_options": {
+      "auction": {
+        "epsilon": 0.01,
+        "eta": [0.5, 0.3],
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      }
+    }
+  }
+  opts = build_auction_options(config)
+  assert opts["eta"] == [0.5, 0.3]
+
+
+def test_build_auction_options_scalar_eta():
+  config = {
+    "solver_options": {
+      "auction": {
+        "epsilon": 0.01,
+        "eta": 0.5,
+        "zeta": 0.1,
+        "latency_weight": 0.0,
+        "fairness_weight": 0.0,
+      }
+    }
+  }
+  opts = build_auction_options(config)
+  assert opts["eta"] == 0.5
+
+
+def test_compute_offloaded_demand_sums_seller_axis():
+  y = np.zeros((2, 3, 2))
+  y[0, 1, 0] = 3.0
+  y[0, 2, 0] = 4.0
+  y[1, 0, 1] = 5.0
+
+  rmp_omega = compute_offloaded_demand(y)
+
+  assert np.array_equal(rmp_omega, np.array([
+    [7.0, 0.0],
+    [0.0, 5.0],
+  ]))
+
+
+def test_bids_for_stopping_keeps_loop_alive_after_hierarchical_progress():
+  bids = bids_for_stopping(
+    pd.DataFrame(),
+    hierarchical_allocations_count=2,
+  )
+  assert len(bids) == 1
+
+
+def test_bids_for_stopping_keeps_empty_bids_when_no_progress():
+  bids = bids_for_stopping(
+    pd.DataFrame(),
+    hierarchical_allocations_count=0,
+  )
+  assert len(bids) == 0
+
+
+def test_extract_graph_latency_returns_numpy_array_with_edge_weights():
+  import networkx as nx
+  from hierarchical_auction.runner import _extract_latency
+
+  g = nx.path_graph(3)
+  nx.set_edge_attributes(
+    g, {(0, 1): 5.0, (1, 2): 3.0}, "network_latency"
+  )
+  lat = _extract_latency(g)
+
+  assert isinstance(lat, np.ndarray)
+  assert lat.shape == (3, 3)
+  assert lat[0, 1] == 5.0
+  assert lat[1, 0] == 5.0   # undirected
+  assert lat[1, 2] == 3.0
+  assert lat[0, 0] == 0.0
+
+
+def test_run_py_accepts_hierarchical_method(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv",
+    ["run.py", "-c", "config_files/config.json", "--methods", "hierarchical"],
+  )
+  from run import parse_arguments
+  args = parse_arguments()
+  assert args.methods == ["hierarchical"]
diff --git a/tests/test_hierarchical_structure_graph.py b/tests/test_hierarchical_structure_graph.py
new file mode 100644
index 0000000..d796b9b
--- /dev/null
+++ b/tests/test_hierarchical_structure_graph.py
@@ -0,0 +1,38 @@
+import numpy as np
+
+from hierarchical_auction.structure_graph import StructureGraph
+
+
+def chain_graph(size: int) -> np.ndarray:
+  graph = np.zeros((size, size), dtype=float)
+  for i in range(size - 1):
+    graph[i, i + 1] = 1.0
+    graph[i + 1, i] = 1.0
+  return graph
+
+
+def test_level1_structure_is_one_hop_neighborhood():
+  sg = StructureGraph(chain_graph(4))
+  structures = sg.build_level1(num_functions=2)
+  assert structures[0].member_nodes == {0, 1}
+  assert structures[1].member_nodes == {0, 1, 2}
+  assert structures[2].member_nodes == {1, 2, 3}
+  assert structures[3].member_nodes == {2, 3}
+
+
+def test_adjacency_uses_physical_edge_between_members():
+  sg = StructureGraph(chain_graph(5))
+  structures = sg.build_level1(num_functions=1)
+  # S_0 = {0,1}, S_2 = {1,2,3}: edge (1,2) exists → adjacent
+  assert sg.are_adjacent(structures[0], structures[2]) is True
+  # S_0 = {0,1}, S_4 = {3,4}: no edge between {0,1} and {3,4} → not adjacent
+  assert sg.are_adjacent(structures[0], structures[4]) is False
+
+
+def test_aggregation_rebuilds_adjacency_for_new_level():
+  sg = StructureGraph(chain_graph(5))
+  level1 = sg.build_level1(num_functions=1)
+  level2 = sg.aggregate_to_next_level(level1, num_functions=1)
+  assert all(s.level == 2 for s in level2.values())
+  assert level1[0].member_nodes.issubset(level2[0].member_nodes)
+  assert all(root not in s.adjacent_structures for root, s in level2.items())
diff --git a/tests/test_hierarchical_token_manager.py b/tests/test_hierarchical_token_manager.py
new file mode 100644
index 0000000..cc95b57
--- /dev/null
+++ b/tests/test_hierarchical_token_manager.py
@@ -0,0 +1,125 @@
+import numpy as np
+import pytest
+
+from hierarchical_auction.token_manager import CapacityTokenManager
+from hierarchical_auction.types import TokenRequest
+
+
+def make_request(root: int, tokens: int, bid: float) -> TokenRequest:
+  return TokenRequest(
+    level=2,
+    buyer_structure=root,
+    buyer_node=root,
+    seller_node=0,
+    function=0,
+    tokens=tokens,
+    bid_value=bid,
+    quantity=float(tokens),
+  )
+
+
+def test_collects_oversubscribed_requests_before_resolution():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 6, 10.0))
+  manager.request(make_request(2, 8, 5.0))
+  assert len(manager.pending_requests(0, 0)) == 2
+  assert manager.available_tokens(0, 0) == 10
+
+
+def test_resolve_conflicts_does_not_exceed_node_tokens():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 6, 10.0))
+  manager.request(make_request(2, 8, 5.0))
+  accepted = manager.resolve_node_function(0, 0)
+  assert sum(a.tokens for a in accepted) == 10
+  assert accepted[0].buyer_structure == 1
+  assert accepted[0].tokens == 6
+  assert accepted[1].tokens == 4
+
+
+def test_commit_is_cumulative_across_rounds():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 4, 1.0))
+  accepted = manager.resolve_node_function(0, 0)
+  manager.commit(accepted)
+  assert manager.available_tokens(0, 0) == 6
+
+  manager.request(make_request(2, 5, 1.0))
+  accepted = manager.resolve_node_function(0, 0)
+  manager.commit(accepted)
+  assert manager.available_tokens(0, 0) == 1
+
+
+def test_partial_acceptance_preserves_request_quantity_ratio():
+  manager = CapacityTokenManager(np.array([[4.0]]), np.array([2.0]))
+  manager.request(TokenRequest(
+    level=2,
+    buyer_structure=1,
+    buyer_node=1,
+    seller_node=0,
+    function=0,
+    tokens=1,
+    bid_value=10.0,
+    quantity=2.0,
+  ))
+  manager.request(TokenRequest(
+    level=2,
+    buyer_structure=2,
+    buyer_node=2,
+    seller_node=0,
+    function=0,
+    tokens=2,
+    bid_value=5.0,
+    quantity=4.0,
+  ))
+
+  accepted = manager.resolve_node_function(0, 0)
+
+  assert [a.tokens for a in accepted] == [1, 1]
+  assert [a.quantity for a in accepted] == [2.0, 2.0]
+
+
+def test_partial_acceptance_uses_service_quantum_not_average_quantity():
+  manager = CapacityTokenManager(np.array([[2.0]]), np.array([2.0]))
+  manager.request(TokenRequest(
+    level=2,
+    buyer_structure=1,
+    buyer_node=1,
+    seller_node=0,
+    function=0,
+    tokens=2,
+    bid_value=1.0,
+    quantity=3.0,
+  ))
+
+  accepted = manager.resolve_node_function(0, 0)
+
+  assert len(accepted) == 1
+  assert accepted[0].tokens == 1
+  assert accepted[0].quantity == 2.0
+
+
+def test_check_global_feasibility_detects_over_committed_state():
+  manager = CapacityTokenManager(np.array([[3.0]]), np.array([1.0]))
+  # Manually corrupt token state to simulate over-commitment
+  manager._current_tokens[0, 0] = -1
+  assert manager.check_global_feasibility() is False
+
+
+def test_check_global_feasibility_passes_after_valid_commits():
+  manager = CapacityTokenManager(np.array([[10.0]]), np.array([1.0]))
+  manager.request(make_request(1, 6, 10.0))
+  accepted = manager.resolve_node_function(0, 0)
+  manager.commit(accepted)
+  assert manager.check_global_feasibility() is True
+
+
+def test_service_quantum_must_be_positive():
+  with pytest.raises(ValueError, match="service_quantum must be positive"):
+    CapacityTokenManager(np.array([[10.0]]), np.array([0.0]))
+
+
+def test_negative_residual_capacity_is_clipped_to_zero_tokens():
+  manager = CapacityTokenManager(np.array([[-5.0]]), np.array([1.0]))
+  assert manager.available_tokens(0, 0) == 0
+  assert manager.check_global_feasibility() is True
diff --git a/tests/test_hierarchical_types.py b/tests/test_hierarchical_types.py
new file mode 100644
index 0000000..2e0961c
--- /dev/null
+++ b/tests/test_hierarchical_types.py
@@ -0,0 +1,34 @@
+import pytest
+
+from hierarchical_auction.types import AcceptedAllocation, TokenRequest
+
+
+def test_token_request_rejects_negative_quantity():
+  with pytest.raises(ValueError, match="tokens must be positive"):
+    TokenRequest(
+      level=2,
+      buyer_structure=0,
+      buyer_node=0,
+      seller_node=1,
+      function=0,
+      tokens=0,
+      bid_value=1.0,
+      quantity=0.0,
+    )
+
+
+def test_accepted_allocation_records_concrete_flow():
+  allocation = AcceptedAllocation(
+    level=2,
+    buyer_structure=0,
+    buyer_node=0,
+    seller_node=3,
+    function=1,
+    tokens=4,
+    quantity=4.0,
+    bid_value=2.5,
+  )
+  assert allocation.buyer_node == 0
+  assert allocation.seller_node == 3
+  assert allocation.function == 1
+  assert allocation.quantity == 4.0
diff --git a/tests/test_load_generator.py b/tests/test_load_generator.py
new file mode 100644
index 0000000..fd6e691
--- /dev/null
+++ b/tests/test_load_generator.py
@@ -0,0 +1,90 @@
+import numpy as np
+import pytest
+
+from load_generator import LoadGenerator, rescale
+
+
+def test_rescale_maps_interval():
+  assert rescale(5, 0, 10, 0, 100) == 50
+
+
+def test_impose_system_workload_with_scalar_total():
+  lg = LoadGenerator()
+  base = {
+    0: np.array([1.0, 3.0, 0.0]),
+    1: np.array([1.0, 1.0, 0.0]),
+  }
+  out = lg._impose_system_workload(8.0, base)
+
+  assert out[0].shape == (3,)
+  for t in range(3):
+    assert pytest.approx(out[0][t] + out[1][t], rel = 1e-6) == 8.0
+
+
+def test_impose_system_workload_handles_zero_total_column():
+  lg = LoadGenerator()
+  base = {
+    0: np.array([0.0, 0.0]),
+    1: np.array([0.0, 0.0]),
+  }
+  out = lg._impose_system_workload(np.array([10.0, 6.0]), base)
+  assert np.allclose(out[0], np.array([5.0, 3.0]))
+  assert np.allclose(out[1], np.array([5.0, 3.0]))
+
+
+def test_generate_traces_clipped_stays_in_bounds():
+  lg = LoadGenerator(average_requests = 20, amplitude_requests = 100)
+  rng = np.random.default_rng(7)
+  limits = {
+    0: {"min": 10, "max": 20},
+    1: {"min": 5, "max": 15},
+  }
+  traces = lg.generate_traces(40, limits, rng, trace_type = "clipped")
+
+  assert set(traces.keys()) == {0, 1}
+  assert np.all((traces[0] >= 10) & (traces[0] <= 20))
+  assert np.all((traces[1] >= 5) & (traces[1] <= 15))
+
+
+def test_generate_traces_sinusoidal_integer_values():
+  lg = LoadGenerator()
+  rng = np.random.default_rng(3)
+  limits = {0: {"min": 1, "max": 3}}
+  traces = lg.generate_traces(
+    12,
+    limits,
+    rng,
+    trace_type = "sinusoidal",
+    only_integer_values = True,
+  )
+  assert traces[0].dtype.kind in ("i", "u")
+  assert np.all((traces[0] >= 1) & (traces[0] <= 3))
+
+
+def test_generate_traces_fixed_sum_modes():
+  lg = LoadGenerator(average_requests = 100, amplitude_requests = 10, noise_ratio = 0.0)
+  rng = np.random.default_rng(11)
+
+  fixed_limits = {0: 10.0, 1: 20.0}
+  traces = lg.generate_traces(20, fixed_limits, rng, trace_type = "fixed_sum")
+  for t in range(20):
+    assert pytest.approx(traces[0][t] + traces[1][t], rel = 1e-6) == 15.0
+
+  minmax_limits = {0: {"max": 9.0}, 1: {"max": 30.0}}
+  traces_min = lg.generate_traces(
+    8, minmax_limits, np.random.default_rng(12), trace_type = "fixed_sum_min"
+  )
+  traces_max = lg.generate_traces(
+    8, minmax_limits, np.random.default_rng(13), trace_type = "fixed_sum_max"
+  )
+  for t in range(8):
+    assert pytest.approx(traces_min[0][t] + traces_min[1][t], rel = 1e-6) == 9.0
+    assert pytest.approx(traces_max[0][t] + traces_max[1][t], rel = 1e-6) == 30.0
+
+
+def test_generate_traces_invalid_type_raises():
+  lg = LoadGenerator()
+  rng = np.random.default_rng(1)
+  limits = {0: {"min": 1, "max": 3}}
+  with pytest.raises(KeyError, match = "not supported"):
+    lg.generate_traces(10, limits, rng, trace_type = "bad-type")
diff --git a/tests/test_logs_postprocessing.py b/tests/test_logs_postprocessing.py
new file mode 100644
index 0000000..b86228c
--- /dev/null
+++ b/tests/test_logs_postprocessing.py
@@ -0,0 +1,29 @@
+import pandas as pd
+
+from logs_postprocessing import parse_faasmadea_log_file
+
+
+def test_parse_faasmadea_log_file_reads_sp_runtime(tmp_path):
+  (tmp_path / "out.log").write_text(
+    "\n".join([
+      "t = 0",
+      "    it = 0",
+      "        sp: DONE  (ok; obj = 12.0; runtime = 2.5)",
+      "        define_bids: DONE; runtime = 0.5)",
+      "        evaluate_bids: DONE; runtime = 0.25)",
+      "    TOTAL RUNTIME [s] = 3.25 (wallclock: 4.0)",
+      "All solutions saved",
+      "",
+    ]),
+    encoding = "utf-8",
+  )
+
+  logs_df, _ = parse_faasmadea_log_file(
+    str(tmp_path),
+    "exp0",
+    pd.DataFrame(),
+    {},
+    Nn = 2,
+  )
+
+  assert logs_df.loc[0, "sp_runtime"] == 2.5
diff --git a/tests/test_lsp_capped.py b/tests/test_lsp_capped.py
new file mode 100644
index 0000000..90614ff
--- /dev/null
+++ b/tests/test_lsp_capped.py
@@ -0,0 +1,16 @@
+from models.sp import LSP, LSP_fixedr, LSP_capped, LSP_capped_fixedr
+
+
+def test_lsp_capped_subclasses_lsp_and_adds_cap():
+  m = LSP_capped()
+  assert isinstance(m, LSP)
+  assert m.model.component("omega_ub") is not None
+  assert m.model.component("cap_offloading") is not None
+
+
+def test_lsp_capped_fixedr_subclasses_fixedr_and_adds_cap():
+  m = LSP_capped_fixedr()
+  assert isinstance(m, LSP_fixedr)
+  assert m.model.component("omega_ub") is not None
+  assert m.model.component("cap_offloading") is not None
+  assert m.model.component("fix_r") is not None
diff --git a/tests/test_madea_swap_fix.py b/tests/test_madea_swap_fix.py
new file mode 100644
index 0000000..666c8a3
--- /dev/null
+++ b/tests/test_madea_swap_fix.py
@@ -0,0 +1,53 @@
+"""Regression for the swap-branch over-subtraction in run_faasmadea.evaluate_bids.
+
+When a seller j is full and a higher bid displaces a previous buyer, the swap
+loop removed the full bid quantity `d` from the incumbent instead of capping it
+at what the incumbent actually holds (`max_to_remove`). The last bid overshot,
+driving the accumulated y negative (and violating j's capacity).
+"""
+
+import numpy as np
+import pandas as pd
+
+from run_faasmadea import evaluate_bids
+
+
+def _base_data(Nn=4, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "beta": {}, "gamma": {}, "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def test_swap_does_not_oversubtract_incumbent():
+  data = _base_data(Nn=4)
+  # seller 1 hosts capacity 2; incumbent buyer 3 currently holds 1 unit there
+  last_y = np.zeros((4, 4, 1)); last_y[3, 1, 0] = 1.0
+  blackboard = np.zeros((4, 1)); blackboard[1, 0] = 2.0
+  # buyer 2 fills the capacity in the main loop; buyer 0 overflows with d=5 > 1
+  bids = pd.DataFrame({
+    "i": [2, 0], "j": [1, 1], "f": [0, 0], "d": [2.0, 5.0], "b": [10.0, 5.0],
+  })
+  capacity = np.ones((4, 1)) * 10.0
+  y, _, _, _ = evaluate_bids(
+    bids, blackboard, data, last_y,
+    np.zeros((4, 1)), np.zeros((4, 1)), capacity, np.zeros((4, 1)),
+    {"eta": 0.0, "zeta": 0.0},
+  )
+  accumulated = last_y + y
+  assert (accumulated >= -1e-9).all(), accumulated[3, 1, 0]
+  # incumbent can lose at most what it held (1); the displacer gains that much
+  assert accumulated[3, 1, 0] >= 0.0
+  assert y[0, 1, 0] <= last_y[3, 1, 0] + 1e-9
+  # the swap runs at exhausted residual, so this round's net placement at
+  # seller 1 stays within the advertised residual capacity
+  assert y[:, 1, 0].sum() <= blackboard[1, 0] + 1e-9
diff --git a/tests/test_merge_sol_dict.py b/tests/test_merge_sol_dict.py
new file mode 100644
index 0000000..3bf7a71
--- /dev/null
+++ b/tests/test_merge_sol_dict.py
@@ -0,0 +1,35 @@
+"""merge_sol_dict must tolerate methods covering different timestep ranges.
+
+Merging a baseline whose solution has more timesteps than another method (e.g. a
+stale centralized folder from a run with a longer horizon) used to crash with
+KeyError on the missing 't = N'. Postprocessing should skip the absent method
+for that timestep instead.
+"""
+
+import pandas as pd
+
+from run import merge_sol_dict
+
+
+def _cnt(key, values, idx):
+  return pd.DataFrame({key: values}, index=idx)
+
+
+def test_merge_tolerates_missing_timestep():
+  idx = ["f1", "f2"]
+  a = {
+    "tot": _cnt("tot", [3, 4], idx),
+    "t = 0": _cnt("t = 0", [1, 2], idx),
+    "t = 1": _cnt("t = 1", [2, 2], idx),   # baseline has an extra timestep
+  }
+  b = {
+    "tot": _cnt("tot", [1, 1], idx),
+    "t = 0": _cnt("t = 0", [1, 1], idx),
+    # no "t = 1": previously KeyError inside merge_sol_dict
+  }
+  out = merge_sol_dict([a, b], ["A", "B"])
+  assert set(out["time"]) == {"tot", 0, 1}
+  # shared timestep keeps both methods (B joins without suffix, no name clash)
+  assert "t = 0_A" in out.columns and "t = 0" in out.columns
+  # the baseline-only timestep survives with just method A, no crash
+  assert "t = 1_A" in out.columns
diff --git a/tests/test_model_construction.py b/tests/test_model_construction.py
new file mode 100644
index 0000000..21b48c7
--- /dev/null
+++ b/tests/test_model_construction.py
@@ -0,0 +1,459 @@
+import pyomo.environ as pyo
+import logging
+from models.model import (
+  BaseAbstractModel,
+  BaseLoadManagementModel,
+  BaseCentralizedModel,
+  LoadManagementModel,
+  PYO_VAR_TYPE,
+  PYO_PARAM_TYPE,
+  _solver_option_name,
+)
+from models.sp import (
+  SPAbstractModel,
+  LSP_v0,
+  LSP,
+  LSPr_v0,
+  LSPr,
+  LSP_fixedr_v0,
+  LSP_fixedr,
+  LSPr_fixedr,
+)
+from models.rmp import (
+  RMPAbstractModel,
+  RMPCentralized,
+  LRMP,
+  LRMP_freeMemory,
+)
+from models.auction_models import (
+  BuyerNodeModel,
+  SellerNodeModel,
+  BuyerNodeModel_fixedr,
+)
+import models.model as model_module
+
+
+class FakeSolveResults:
+  def __init__(self):
+    self.solver = type(
+      "FakeSolverStatus",
+      (),
+      {
+        "status": model_module.SolverStatus.ok,
+        "termination_condition": model_module.TerminationCondition.optimal,
+      },
+    )()
+    self.solution = []
+
+
+class FakeInstance:
+  OBJ = 0
+
+  def component_objects(self, *_args, **_kwargs):
+    return []
+
+
+class FakeSolver:
+  def __init__(self, fail_on_warmstart=False):
+    self.options = {}
+    self.fail_on_warmstart = fail_on_warmstart
+    self.solve_kwargs = []
+
+  def solve(self, _instance, **kwargs):
+    self.solve_kwargs.append(kwargs)
+    if self.fail_on_warmstart and "warmstart" in kwargs:
+      raise ValueError("key 'warmstart' not defined")
+    return FakeSolveResults()
+
+
+class WarmstartModel(BaseAbstractModel):
+  def _provide_initial_solution(self, instance, initial_solution):
+    return instance
+
+
+def test_base_abstract_model_has_name_and_model():
+  m = BaseAbstractModel()
+  assert m.name == "BaseAbstractModel"
+  assert isinstance(m.model, pyo.AbstractModel)
+
+
+def test_base_load_management_model_has_params_and_sets():
+  m = BaseLoadManagementModel()
+  assert m.name == "BaseLoadManagementModel"
+  model = m.model
+  assert model.Nn.domain == pyo.NonNegativeIntegers
+  assert model.Nf.domain == pyo.NonNegativeIntegers
+  assert model.N.ctype is not None
+  assert model.F.ctype is not None
+  assert model.incoming_load is not None
+  assert model.demand is not None
+  assert model.max_utilization is not None
+  assert model.memory_requirement is not None
+  assert model.memory_capacity is not None
+
+
+def test_base_centralized_model_has_routing_vars_and_constraints():
+  m = BaseCentralizedModel()
+  assert m.name == "BaseCentralizedModel"
+  model = m.model
+  assert model.x is not None
+  assert model.y is not None
+  assert model.z is not None
+  assert model.r is not None
+  assert model.alpha is not None
+  assert model.beta is not None
+  assert model.gamma is not None
+  assert model.neighborhood is not None
+
+
+def test_base_centralized_model_constraint_rules():
+  m = BaseCentralizedModel()
+  assert m.no_traffic_loss is not None
+  assert m.offload_only_to_neighbors is not None
+
+
+def test_load_management_model_adds_ping_pong_and_objective():
+  m = LoadManagementModel()
+  assert m.name == "LoadManagementModel"
+  model = m.model
+  assert model.i_sends_f is not None
+  assert model.i_receives_f is not None
+  assert model.utilization_equilibrium is not None
+  assert model.utilization_equilibrium2 is not None
+  assert model.residual_capacity is not None
+  assert model.no_ping_pong1 is not None
+  assert model.no_ping_pong2 is not None
+  assert model.no_ping_pong3 is not None
+  assert model.OBJ is not None
+
+
+def test_generate_instance_creates_concrete_model():
+  m = LoadManagementModel()
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "incoming_load": {(1, 1): 10.0, (2, 1): 5.0},
+      "demand": {(1, 1): 1.0, (2, 1): 2.0},
+      "max_utilization": {1: 0.8},
+      "memory_requirement": {1: 2},
+      "memory_capacity": {1: 10, 2: 20},
+      "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+      "beta": {
+        (1, 1, 1): 0.0, (1, 2, 1): 0.9, (2, 1, 1): 0.9, (2, 2, 1): 0.0,
+      },
+      "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+      "neighborhood": {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+    }
+  }
+  instance = m.generate_instance(data)
+  assert instance.Nn.value == 2
+  assert instance.Nf.value == 1
+
+
+def test_base_abstract_model_generate_instance():
+  m = BaseAbstractModel()
+  data = {None: {}}
+  instance = m.generate_instance(data)
+  assert instance is not None
+
+
+def test_base_abstract_model_solve_method_exists():
+  m = BaseAbstractModel()
+  assert hasattr(m, "solve")
+
+
+def test_model_objective_overrides_are_explicit(caplog):
+  caplog.set_level(logging.WARNING)
+
+  _ = LSP()
+  _ = LSPr()
+
+  assert "Implicitly replacing the Component attribute OBJ" not in caplog.text
+
+
+def test_solve_does_not_pass_disabled_warmstart(monkeypatch):
+  solver = FakeSolver()
+  monkeypatch.setattr(model_module, "_SOLVER_CACHE", {})
+  monkeypatch.setattr(model_module.pyo, "SolverFactory", lambda _name: solver)
+
+  solution = BaseAbstractModel().solve(FakeInstance(), {}, solver_name="glpk")
+
+  assert solution["solution_exists"] is True
+  assert solver.solve_kwargs == [{}]
+
+
+def test_solve_maps_glpk_time_limit_option(monkeypatch):
+  solver = FakeSolver()
+  monkeypatch.setattr(model_module, "_SOLVER_CACHE", {})
+  monkeypatch.setattr(model_module.pyo, "SolverFactory", lambda _name: solver)
+
+  solution = BaseAbstractModel().solve(FakeInstance(), {"TimeLimit": 7}, solver_name="glpk")
+
+  assert solution["solution_exists"] is True
+  assert solver.options == {"tmlim": 7}
+
+
+def test_solver_option_name_keeps_time_limit_for_non_glpk():
+  assert _solver_option_name("gurobi", "TimeLimit") == "TimeLimit"
+
+
+def test_solve_passes_enabled_warmstart_for_initial_solution(monkeypatch):
+  solver = FakeSolver()
+  monkeypatch.setattr(model_module, "_SOLVER_CACHE", {})
+  monkeypatch.setattr(model_module.pyo, "SolverFactory", lambda _name: solver)
+
+  solution = WarmstartModel().solve(FakeInstance(), {}, initial_solution={}, solver_name="gurobi")
+
+  assert solution["solution_exists"] is True
+  assert solver.solve_kwargs == [{"warmstart": True}]
+
+
+def test_solve_retries_without_warmstart_when_solver_rejects_it(monkeypatch):
+  solver = FakeSolver(fail_on_warmstart=True)
+  monkeypatch.setattr(model_module, "_SOLVER_CACHE", {})
+  monkeypatch.setattr(model_module.pyo, "SolverFactory", lambda _name: solver)
+
+  solution = WarmstartModel().solve(FakeInstance(), {}, initial_solution={}, solver_name="glpk")
+
+  assert solution["solution_exists"] is True
+  assert solver.solve_kwargs == [{"warmstart": True}, {}]
+
+
+def test_base_load_management_model_inherits_from_base_abstract():
+  m = BaseLoadManagementModel()
+  assert isinstance(m, BaseAbstractModel)
+
+
+def test_base_centralized_model_inherits_from_base_load_management():
+  m = BaseCentralizedModel()
+  assert isinstance(m, BaseLoadManagementModel)
+
+
+def test_load_management_model_inheritance_chain():
+  m = LoadManagementModel()
+  assert isinstance(m, BaseCentralizedModel)
+
+
+# ---- SP models ----
+
+
+def test_sp_abstract_model_has_whoami_and_vars():
+  m = SPAbstractModel()
+  assert m.name == "SPAbstractModel"
+  model = m.model
+  assert model.whoami is not None
+  assert model.x is not None
+  assert model.r is not None
+  assert model.alpha is not None
+  assert model.delta is not None
+
+
+def test_lsp_v0_model_has_omega_and_constraints():
+  m = LSP_v0()
+  assert m.name == "LSP_v0"
+  model = m.model
+  assert model.omega is not None
+  assert model.pi is not None
+  assert model.no_traffic_loss_v0 is not None
+  assert model.utilization_equilibrium is not None
+  assert model.utilization_equilibrium2 is not None
+  assert model.residual_capacity is not None
+  assert model.OBJ is not None
+
+
+def test_lsp_model_adds_rejections():
+  m = LSP()
+  assert m.name == "LSP"
+  model = m.model
+  assert model.z is not None
+  assert model.gamma is not None
+  assert model.no_traffic_loss is not None
+  assert model.OBJ is not None
+
+
+def test_lspr_v0_model_has_assigned_offloading():
+  m = LSPr_v0()
+  assert m.name == "LSPr_v0"
+  model = m.model
+  assert model.omega_bar is not None
+  assert model.y_bar is not None
+  assert model.no_traffic_loss_v0 is not None
+
+
+def test_lspr_v0_omega_bar_and_y_bar_domain_is_nonnegative_reals():
+  # Regression: omega_bar and y_bar were declared within=PYO_VAR_TYPE
+  # (NonNegativeIntegers), but they store previous-iteration solver outputs
+  # which can be fractional. The domain must be NonNegativeReals.
+  m = LSPr_v0()
+  assert m.model.omega_bar.domain == pyo.NonNegativeReals
+  assert m.model.y_bar.domain == pyo.NonNegativeReals
+  assert m.model.omega_bar.domain == PYO_PARAM_TYPE
+  assert m.model.y_bar.domain == PYO_PARAM_TYPE
+
+
+def test_lspr_v0_generate_instance_accepts_float_omega_bar():
+  # Regression: RuntimeError "value not in domain NonNegativeIntegers" when
+  # a solver returns fractional omega values (e.g. 0.51) stored in omega_bar.
+  m = LSPr_v0()
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "whoami": {None: 1},
+      "incoming_load": {(1, 1): 10.0, (2, 1): 5.0},
+      "demand": {(1, 1): 1.0, (2, 1): 1.0},
+      "max_utilization": {1: 0.8},
+      "memory_requirement": {1: 2},
+      "memory_capacity": {1: 10, 2: 10},
+      "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+      "delta": {(1, 1): 0.9, (2, 1): 0.9},
+      "omega_bar": {(1, 1): 0.51, (2, 1): 0.0},
+      "y_bar": {(1, 1, 1): 0.17, (1, 2, 1): 0.0, (2, 1, 1): 0.0, (2, 2, 1): 0.0},
+    }
+  }
+  instance = m.generate_instance(data)
+  assert instance is not None
+  assert abs(pyo.value(instance.omega_bar[1, 1]) - 0.51) < 1e-9
+
+
+def test_lspr_model_adds_rejections_to_lspr_v0():
+  m = LSPr()
+  assert m.name == "LSPr"
+  model = m.model
+  assert model.z is not None
+  assert model.gamma is not None
+  assert model.no_traffic_loss is not None
+
+
+def test_lsp_fixedr_v0_fixes_replicas():
+  m = LSP_fixedr_v0()
+  assert m.name == "LSP_fixedr_v0"
+  model = m.model
+  assert model.r_bar is not None
+  assert model.fix_r is not None
+
+
+def test_lsp_fixedr_fixes_replicas_with_rejections():
+  m = LSP_fixedr()
+  assert m.name == "LSP_fixedr"
+  model = m.model
+  assert model.r_bar is not None
+  assert model.fix_r is not None
+  assert model.z is not None
+
+
+def test_lspr_fixedr_fixes_replicas_for_restricted():
+  m = LSPr_fixedr()
+  assert m.name == "LSPr_fixedr"
+  model = m.model
+  assert model.r_bar is not None
+  assert model.fix_r is not None
+
+
+# ---- RMP models ----
+
+
+def test_rmp_abstract_model_has_xbar_and_rbar():
+  m = RMPAbstractModel()
+  assert m.name == "RMPAbstractModel"
+  model = m.model
+  assert model.neighborhood is not None
+  assert model.beta is not None
+  assert model.x_bar is not None
+  assert model.r_bar is not None
+
+
+def test_rmp_centralized_has_y_and_offload_constraint():
+  m = RMPCentralized()
+  assert m.name == "RMPCentralized"
+  model = m.model
+  assert model.y is not None
+  assert model.offload_only_to_neighbors is not None
+
+
+def test_lrmp_model_has_full_formulation():
+  m = LRMP()
+  assert m.name == "LRMP"
+  model = m.model
+  assert model.omega_bar is not None
+  assert model.gamma is not None
+  assert model.r is not None
+  assert model.i_sends_f is not None
+  assert model.i_receives_f is not None
+  assert model.no_traffic_loss is not None
+  assert model.capacity_constraints is not None
+  assert model.residual_capacity is not None
+  assert model.no_ping_pong1 is not None
+  assert model.no_ping_pong2 is not None
+  assert model.no_ping_pong3 is not None
+  assert model.OBJ is not None
+
+
+def test_lrmp_free_memory_model_has_capacity_constraints2():
+  m = LRMP_freeMemory()
+  assert m.name == "LRMP_freeMemory"
+  model = m.model
+  assert model.omega_bar is not None
+  assert model.r is not None
+  assert model.capacity_constraints is not None
+  assert model.capacity_constraints2 is not None
+  assert model.no_traffic_loss is not None
+
+
+# ---- Auction models ----
+
+
+def test_buyer_node_model_has_demand_and_bids():
+  m = BuyerNodeModel()
+  assert m.name == "BuyerNodeModel"
+  model = m.model
+  assert model.neighborhood is not None
+  assert model.beta is not None
+  assert model.gamma is not None
+  assert model.c is not None
+  assert model.d is not None
+  assert model.z is not None
+  assert model.offload_only_to_neighbors is not None
+  assert model.no_traffic_loss is not None
+  assert model.OBJ is not None
+
+
+def test_seller_node_model_has_d_bar_and_whoami():
+  m = SellerNodeModel()
+  assert m.name == "SellerNodeModel"
+  model = m.model
+  assert model.whoami is not None
+  assert model.d_bar is not None
+  assert model.r is not None
+  assert model.d is not None
+  assert model.no_traffic_loss is not None
+  assert model.utilization_equilibrium is not None
+  assert model.utilization_equilibrium2 is not None
+  assert model.residual_capacity is not None
+  assert model.OBJ is not None
+
+
+def test_buyer_node_model_fixedr_fixes_replicas():
+  m = BuyerNodeModel_fixedr()
+  assert m.name == "BuyerNodeModel_fixedr"
+  model = m.model
+  assert model.r_bar is not None
+  assert model.fix_r is not None
+
+
+def test_pyo_var_type_is_non_negative_integers():
+  assert PYO_VAR_TYPE == pyo.NonNegativeIntegers
+
+
+def test_solve_caches_solver_per_name(monkeypatch):
+  calls = []
+  monkeypatch.setattr(model_module, "_SOLVER_CACHE", {})
+  monkeypatch.setattr(
+    model_module.pyo, "SolverFactory",
+    lambda name: calls.append(name) or FakeSolver(),
+  )
+  m = BaseAbstractModel()
+  m.solve(FakeInstance(), {}, solver_name="glpk")
+  m.solve(FakeInstance(), {}, solver_name="glpk")
+  assert calls == ["glpk"]  # factory hit once, then reused
diff --git a/tests/test_no_ping_pong_guard.py b/tests/test_no_ping_pong_guard.py
new file mode 100644
index 0000000..591c72d
--- /dev/null
+++ b/tests/test_no_ping_pong_guard.py
@@ -0,0 +1,157 @@
+"""Regression tests for the shared no_ping_pong guard.
+
+The FRALB no_ping_pong constraint (validate_centralized_solution) forbids a node
+from both sending and receiving the same function. The decentralized methods that
+accumulate ``y`` across rounds must not produce such a state. Two reference
+implementations already inline this (decentralized_auction / _potentialgame);
+these tests pin the behaviour for the ones that had no guard: diffusion, powerd,
+dual, bestresponse and run_faasmadea. The invariant enforced everywhere: a node
+that is a *sender* of f (residual demand ``omega`` or already-forwarded ``y``)
+is never picked as a *host* of f.
+"""
+
+import numpy as np
+import pandas as pd
+
+from utils.centralized import ping_pong_forbidden_hosts
+from decentralized_diffusion import define_assignments
+from decentralized_powerd import sample_assignments
+from decentralized_bestresponse import best_response_sweep
+from decentralized_dual import dual_coordination_round
+from run_faasmadea import evaluate_bids
+
+
+def _base_data(Nn=3, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _ring(Nn=3):
+  neighborhood = np.zeros((Nn, Nn))
+  for n in range(Nn):
+    neighborhood[n, (n + 1) % Nn] = 1
+    neighborhood[n, (n - 1) % Nn] = 1
+  return neighborhood
+
+
+DIFF_OPTIONS = {"latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False}
+POWERD_OPTIONS = {**DIFF_OPTIONS, "d": 2, "criterion": "score"}
+
+
+def _no_ping_pong(y, tol=1e-9):
+  sends = y.sum(axis=1) > tol
+  receives = y.sum(axis=0) > tol
+  return not (sends & receives).any()
+
+
+def test_helper_flags_senders_only():
+  omega = np.array([[1.0], [0.0], [0.0]])
+  y = np.zeros((3, 3, 1)); y[1, 2, 0] = 4.0            # node 1 already forwarded f
+  forbidden = ping_pong_forbidden_hosts(omega, y)
+  assert forbidden[0, 0] and forbidden[1, 0] and not forbidden[2, 0]
+
+
+def test_diffusion_excludes_seller_with_residual_demand():
+  data = _base_data()
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0; omega[1, 0] = 1.0  # 1 is a sender
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  bids, _, _ = define_assignments(
+    omega, blackboard, data, _ring(), np.zeros(3),
+    DIFF_OPTIONS, np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+  )
+  assert (bids["j"] != 1).all()               # node 1 must not host despite capacity
+  assert (bids["j"] == 2).all()
+
+
+def test_diffusion_excludes_seller_that_already_forwarded():
+  data = _base_data()
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  current_y = np.zeros((3, 3, 1)); current_y[1, 2, 0] = 3.0   # node 1 sent already
+  bids, _, _ = define_assignments(
+    omega, blackboard, data, _ring(), np.zeros(3),
+    DIFF_OPTIONS, np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+    current_y=current_y,
+  )
+  assert (bids["j"] != 1).all()
+
+
+def test_powerd_excludes_seller_with_residual_demand():
+  data = _base_data()
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0; omega[1, 0] = 1.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, _ring(), np.zeros(3),
+    POWERD_OPTIONS, np.zeros((3, 3)), np.zeros((3, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0),
+  )
+  assert (bids["j"] != 1).all()
+
+
+def test_bestresponse_receiver_does_not_offload_and_sender_not_host():
+  data = _base_data()
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0     # node 0 wants to offload
+  residual_capacity = np.zeros((3, 1)); residual_capacity[1, 0] = 5.0
+  current_y = np.zeros((3, 3, 1))
+  current_y[2, 0, 0] = 3.0     # node 2 -> node 0: node 0 already RECEIVES f
+  current_y[1, 2, 0] = 1.0     # node 1 already SENDS f
+  y_inc, _, _, _, _ = best_response_sweep(
+    omega, residual_capacity, data, _ring(), np.zeros(3),
+    DIFF_OPTIONS, np.zeros((3, 3)), np.zeros((3, 1)), force_memory_bids=False,
+    order="fixed", response="greedy", current_y=current_y,
+  )
+  final_y = current_y + y_inc
+  assert final_y[0, :, 0].sum() == 0.0          # receiver 0 must not send f
+  assert _no_ping_pong(final_y)
+
+
+def test_madea_evaluate_bids_recovers_ping_pong_free_y():
+  data = _base_data()
+  # node 1 already forwarded f (1 -> 0): node 1 is a sender, node 0 a receiver
+  last_y = np.zeros((3, 3, 1)); last_y[1, 0, 0] = 2.0
+  blackboard = np.zeros((3, 1)); blackboard[0, 0] = 5.0; blackboard[1, 0] = 5.0
+  bids = pd.DataFrame({
+    "i": [2, 2], "j": [0, 1], "f": [0, 0], "d": [2.0, 2.0], "b": [1.0, 1.0],
+  })
+  capacity = np.ones((3, 1)) * 10.0
+  y, _, _, _ = evaluate_bids(
+    bids, blackboard, data, last_y,
+    np.zeros((3, 1)), np.zeros((3, 1)), capacity, np.zeros((3, 1)),
+    {"eta": 0.0, "zeta": 0.0},
+  )
+  assert y[:, 1, 0].sum() == 0.0                # node 1 sent already -> no host
+  assert y[2, 0, 0] == 2.0                      # host that only received still accepts
+  assert _no_ping_pong(last_y + y)
+
+
+def test_dual_round_recovers_ping_pong_free_y():
+  data = _base_data(Nn=3, Nf=1)
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.0; omega[1, 0] = 1.0
+  residual_capacity = np.zeros((3, 1))
+  residual_capacity[1, 0] = 3.0     # node 1 is buyer AND advertises capacity
+  residual_capacity[2, 0] = 3.0
+  options = {
+    "alpha0": 0.5, "step_rule": "sqrt", "theta": 1.0,
+    "max_inner_iterations": 100, "gap_tolerance": 0.01,
+    "latency_weight": 0.0, "fairness_weight": 0.0,
+  }
+  y_inc, _, _, _ = dual_coordination_round(
+    omega, residual_capacity, data, _ring(), np.zeros(3),
+    options, np.zeros((3, 3)), np.zeros((3, 1)),
+  )
+  assert y_inc[:, 1, 0].sum() == 0.0            # node 1 has residual demand -> no host
+  assert _no_ping_pong(y_inc)
diff --git a/tests/test_paper_experiment_suites.py b/tests/test_paper_experiment_suites.py
new file mode 100644
index 0000000..c89e0df
--- /dev/null
+++ b/tests/test_paper_experiment_suites.py
@@ -0,0 +1,200 @@
+import json
+
+import numpy as np
+
+from generators.generate_data import generate_data
+from remote_experiments.batch import Batch
+from remote_experiments.definitions import paper
+from remote_experiments.definitions import list_suites
+from remote_experiments.definitions.paper import (
+  build_e0, build_e1, build_e2, build_e3, build_e4, build_e5, build_e6, build_e7,
+  build_screening,
+)
+
+
+def test_paper_suites_are_registered():
+  expected = {
+    "paper-e0-pilot", "paper-e1-quality-runtime", "paper-e2-scalability",
+    "paper-e3-topology", "paper-e4-robustness", "paper-e5-dynamics",
+    "paper-e6-ablation", "paper-e7-tradeoffs", "paper-e8-spatial-latency",
+    "paper-a-screening",
+  }
+  assert expected <= set(list_suites())
+
+
+def test_screening_count_algorithms_and_no_centralized():
+  experiments = build_screening()
+  assert len(experiments) == 260                      # 13 algos x {50,100}x{2,4} x 5 seeds
+  algos = {e.algorithm for e in experiments}
+  assert "centralized" not in algos
+  assert "hierarchical-madea" in algos                # reference for obj_best
+  assert algos == set(paper.SCREENING_CANDIDATES) | {"hierarchical-madea"}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {50, 100}
+  assert len({e.id for e in experiments}) == 260
+
+
+def test_e0_default_count():
+  assert len(build_e0()) == 120
+
+
+def test_e1_default_count_and_unique_ids():
+  experiments = build_e1()
+  assert len(experiments) == 180                    # 3 nodes x 2 funcs x 6 algos x 5 seeds
+  assert len({e.id for e in experiments}) == 180
+  assert set(e.algorithm for e in experiments) == set(paper._final_algorithms())
+
+
+def test_e1_expands_function_vectors_and_output_folder():
+  experiments = build_e1(seeds=(1001,), algorithms=("hierarchical",))
+  four_functions = next(
+    e for e in experiments if e.config["limits"]["Nf"]["min"] == 4
+  )
+  limits = four_functions.config["limits"]
+  assert limits["demand"]["values"] == [1.0, 1.2, 1.0, 1.2]
+  assert limits["memory_requirement"]["values"] == [2, 3, 2, 3]
+  assert four_functions.config["base_solution_folder"] == f"solutions/{four_functions.id}"
+
+
+def test_e2_count_and_centralized_size_limit():
+  experiments = build_e2()
+  assert len(experiments) == 480
+  centralized_sizes = {
+    e.config["limits"]["Nn"]["min"]
+    for e in experiments if e.algorithm == "centralized"
+  }
+  assert centralized_sizes == {10, 20}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {10, 20, 50, 100, 200, 500}
+
+
+def test_e3_count_and_topology_coverage():
+  assert len(build_e3()) == 180
+  experiments = build_e3(seeds=(1001,))
+  topologies = {
+    tuple(sorted(e.config["limits"]["neighborhood"].items()))
+    for e in experiments
+  }
+  assert topologies == {
+    (("density", 1.0), ("mean_degree", 3), ("type", "euclidean_planar")),
+    (("density", 1.0), ("mean_degree", 5), ("type", "euclidean_planar")),
+    (("k", 3),), (("k", 5),), (("m", 75),), (("m", 125),),
+  }
+
+
+def test_e4_count_and_conditions():
+  experiments = build_e4()
+  conditions = {
+    "baseline", "load-low", "load-high", "memory-scarce", "memory-ample",
+    "nodes-homogeneous", "nodes-heterogeneous",
+  }
+  assert len(experiments) == 7 * 6 * 5
+  assert {
+    next(condition for condition in conditions if f"-{condition}-" in e.id)
+    for e in experiments
+  } == conditions
+
+
+def test_e5_count_trace_coverage_and_steps():
+  experiments = build_e5()
+  assert len(experiments) == 3 * 6 * 5
+  assert {e.config["limits"]["load"]["trace_type"] for e in experiments} == {
+    "sinusoidal", "clipped", "fixed_sum_minmax",
+  }
+  assert {e.config["max_steps"] for e in experiments} == {100}
+
+
+def test_e6_default_count_and_hierarchical_only():
+  experiments = build_e6()
+  assert len(experiments) == 100                    # 10 variants x 1 node x 2 topo x 5
+  assert {e.algorithm for e in experiments} == {"hierarchical-madea"}
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {50}
+
+
+def test_e7_default_count_and_weight_pairs():
+  experiments = build_e7()
+  assert len(experiments) == 7 * 2 * 4 * 5          # 4 = tunable subset of FINAL
+  sections = {
+    "hierarchical-madea": "auction", "faas-madea": "auction",
+    "faas-diffuse": "diffusion", "faas-powd": "powerd",
+  }
+  assert {e.algorithm for e in experiments} == set(sections)
+  assert {
+    (
+      e.config["solver_options"][sections[e.algorithm]]["latency_weight"],
+      e.config["solver_options"][sections[e.algorithm]]["fairness_weight"],
+    )
+    for e in experiments
+  } == {
+    (0, 0), (0.25, 0), (1, 0), (0, 0.25),
+    (0, 1), (0.25, 0.25), (1, 1),
+  }
+
+
+def test_e8_default_count_and_spatial_latency_coverage():
+  experiments = paper.build_e8()
+  sections = {
+    "hierarchical-madea": "auction", "faas-madea": "auction",
+    "faas-diffuse": "diffusion", "faas-powd": "powerd",
+  }
+
+  assert len(experiments) == 3 * 2 * 4 * 5
+  assert {e.config["limits"]["Nn"]["min"] for e in experiments} == {20, 50, 100}
+  assert {
+    e.config["limits"]["weights"]["edge_network_latency"]["mode"]
+    for e in experiments
+  } == {"euclidean", "euclidean_permuted"}
+  assert {
+    e.config["solver_options"][sections[e.algorithm]]["latency_weight"]
+    for e in experiments
+  } == {0.25}
+
+
+def test_paper_experiments_round_trip_as_batch(tmp_path):
+  experiments = build_e1(seeds=(1001,), algorithms=("hierarchical",))
+  path = tmp_path / "batch.json"
+  expected = Batch(suite="paper-e1-quality-runtime", experiments=tuple(experiments))
+  expected.save(path)
+  assert Batch.load(path) == expected
+  assert all(
+    e.config["base_solution_folder"] == f"solutions/{e.id}"
+    for e in experiments
+  )
+
+
+def test_generated_config_builds_a_real_instance():
+  experiment = build_e1(seeds=(1001,), algorithms=("hierarchical",))[0]
+  data, _, graph = generate_data(
+    "random", np.random.default_rng(experiment.seed), experiment.config["limits"],
+  )
+  assert data[None]["Nn"][None] == 10
+  assert data[None]["Nf"][None] == 2
+  assert graph.number_of_nodes() == 10
+
+
+def test_survivors_fallback_when_file_absent(tmp_path, monkeypatch):
+  monkeypatch.setattr(paper, "SURVIVORS_PATH", tmp_path / "missing.json")
+  assert paper._survivors() == paper.DEFAULT_SURVIVORS
+  assert paper._final_algorithms() == paper.ANCHORS + paper.DEFAULT_SURVIVORS
+
+
+def test_survivors_read_from_file(tmp_path, monkeypatch):
+  path = tmp_path / "survivors.json"
+  path.write_text(json.dumps({"survivors": ["faas-gcaa", "faas-pg-s", "faas-powd", "faas-diffuse"]}))
+  monkeypatch.setattr(paper, "SURVIVORS_PATH", path)
+  assert paper._survivors() == ("faas-gcaa", "faas-pg-s", "faas-powd", "faas-diffuse")
+
+
+def test_survivors_fallback_on_malformed_json(tmp_path, monkeypatch):
+  path = tmp_path / "survivors.json"
+  path.write_text("{ not json")
+  monkeypatch.setattr(paper, "SURVIVORS_PATH", path)
+  assert paper._survivors() == paper.DEFAULT_SURVIVORS
+
+
+def test_confirmatory_seeds_are_five():
+  assert len(paper.CONFIRMATORY_SEEDS) == 5
+
+
+def test_tunable_filters_non_weight_algorithms():
+  assert paper._tunable(("hierarchical-madea", "faas-powd", "faas-br-o")) == (
+    "hierarchical-madea", "faas-powd",
+  )
diff --git a/tests/test_parse_args_extended.py b/tests/test_parse_args_extended.py
new file mode 100644
index 0000000..415b4ef
--- /dev/null
+++ b/tests/test_parse_args_extended.py
@@ -0,0 +1,173 @@
+"""Tests for parse_arguments across all modules and remaining edge cases."""
+
+import sys
+
+import numpy as np
+import pandas as pd
+
+
+def test_decentralized_auction_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv",
+    ["prog", "-c", "config_files/test.json", "-j", "2", "--disable_plotting"],
+  )
+  from decentralized_auction import parse_arguments
+  args = parse_arguments()
+  assert args.config == "config_files/test.json"
+  assert args.parallelism == 2
+  assert args.disable_plotting is True
+
+
+def test_decentralized_auction_parse_args_defaults(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["prog"])
+  from decentralized_auction import parse_arguments
+  args = parse_arguments()
+  assert args.config == "manual_config.json"
+  assert args.parallelism == -1
+  assert args.disable_plotting is False
+
+
+def test_run_centralized_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "-c", "my_config.json", "--disable_plotting"],
+  )
+  from run_centralized_model import parse_arguments
+  args = parse_arguments()
+  assert args.config == "my_config.json"
+  assert args.disable_plotting is True
+
+
+def test_run_faasmacro_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "-c", "cfg.json", "-j", "4"],
+  )
+  from run_faasmacro import parse_arguments
+  args = parse_arguments()
+  assert args.config == "cfg.json"
+  assert args.parallelism == 4
+
+
+def test_run_faasmadea_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "--disable_plotting"],
+  )
+  from run_faasmadea import parse_arguments
+  args = parse_arguments()
+  assert args.disable_plotting is True
+
+
+def test_what_if_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "-f", "/tmp/experiment", "-m", "0", "30", "60"],
+  )
+  from what_if_analysis import parse_arguments
+  args = parse_arguments()
+  assert args.base_folder == "/tmp/experiment"
+  assert args.milestones == ["0", "30", "60"]
+
+
+def test_postprocessing_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "-i", "/tmp/results", "--models", "A", "B"],
+  )
+  from postprocessing import parse_arguments
+  args = parse_arguments()
+  assert args.postprocessing_folder == "/tmp/results"
+  assert args.models == ["A", "B"]
+
+
+def test_hierarchical_runner_parse_args(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["prog", "-c", "hier_config.json", "-j", "0"],
+  )
+  from hierarchical_auction.runner import parse_arguments
+  args = parse_arguments()
+  assert args.config == "hier_config.json"
+  assert args.parallelism == 0
+
+
+def test_run_py_parse_args_methods(monkeypatch):
+  monkeypatch.setattr(
+    "sys.argv", ["run.py", "-c", "config_files/config.json", "--methods", "hierarchical"],
+  )
+  from run import parse_arguments
+  args = parse_arguments()
+  assert args.methods == ["hierarchical"]
+
+
+# --- Additional decentralized_auction edge cases ---
+
+def test_check_stopping_criteria_no_capacity_left():
+  from decentralized_auction import check_stopping_criteria
+  stop, why = check_stopping_criteria(
+    0, 5,
+    blackboard=np.zeros((2, 2)),
+    omega=np.ones((2, 2)),
+    rmp_omega=np.ones((2, 2)),
+    bids=pd.DataFrame({"a": [1]}),
+    memory_bids=pd.DataFrame({"b": [1]}),
+    tolerance=1e-6,
+    total_runtime=1.0,
+    time_limit=100.0,
+  )
+  assert stop is True
+  assert why == "no capacity left"
+
+
+def test_check_stopping_criteria_load_cannot_be_assigned():
+  from decentralized_auction import check_stopping_criteria
+  stop, why = check_stopping_criteria(
+    0, 5,
+    blackboard=np.ones((2, 2)),
+    omega=np.ones((2, 2)),
+    rmp_omega=np.zeros((2, 2)),
+    bids=pd.DataFrame({"a": [1]}),
+    memory_bids=pd.DataFrame({"b": [1]}),
+    tolerance=1e-6,
+    total_runtime=1.0,
+    time_limit=100.0,
+  )
+  assert stop is True
+  assert "cannot be assigned" in why
+
+
+# --- Additional postprocessing test ---
+
+def test_postprocessing_load_solution_formats_columns(tmp_path):
+  from postprocessing import load_solution
+
+  solution = pd.DataFrame({
+    "n0_f0_loc": [1.0, 2.0],
+    "n0_f0_fwd": [0.5, 0.5],
+    "n0_f0": [0.0, 0.0],
+    "n1_f0_loc": [3.0, 4.0],
+    "n1_f0_fwd": [0.0, 0.5],
+    "n1_f0": [0.0, 0.0],
+  })
+  replicas = pd.DataFrame({"n0_f0": [1.0, 2.0], "n1_f0": [2.0, 3.0]})
+  detailed = pd.DataFrame({
+    "n0_f0_n1_tot": [1.0, 0.5],
+    "n1_f0_n0_tot": [0.0, 2.0],
+  })
+  utilization = pd.DataFrame({"n0_f0": [0.5, 0.6], "n1_f0": [0.3, 0.4]})
+  pd.DataFrame({"SP/coord": [10.0, 12.0]}).to_csv(tmp_path / "obj.csv", index=False)
+  solution.to_csv(tmp_path / "ModelX_solution.csv", index=False)
+  replicas.to_csv(tmp_path / "ModelX_replicas.csv", index=False)
+  detailed.to_csv(tmp_path / "ModelX_detailed_fwd_solution.csv", index=False)
+  utilization.to_csv(tmp_path / "ModelX_utilization.csv", index=False)
+
+  sol, rep, det, util, obj = load_solution(str(tmp_path), "ModelX")
+
+  assert "n0_f0_loc" in sol.columns
+  assert det.loc[0, "n0_f0_n1_tot"] == 1.0
+  assert rep.loc[1, "n1_f0"] == 3.0
+
+
+# --- Additional load_generator test ---
+
+def test_load_generator_initialization_and_trace_limits():
+  from load_generator import LoadGenerator
+
+  lg = LoadGenerator(average_requests=50, amplitude_requests=25)
+  assert lg.average_requests == 50
+  assert lg.amplitude_requests == 25
diff --git a/tests/test_plasma_baselines.py b/tests/test_plasma_baselines.py
new file mode 100644
index 0000000..93990ba
--- /dev/null
+++ b/tests/test_plasma_baselines.py
@@ -0,0 +1,181 @@
+import numpy as np
+import pytest
+
+from plasma.baselines.milp_baseline import routing_lp, shed_overflow
+from plasma.baselines import madea_iface
+from plasma.eval.regret import adaptation_lag, cumulative_regret
+
+
+def test_routing_lp_prefers_local_when_capacity_allows():
+  lam = np.array([[10.0]])
+  r = np.array([[5]])
+  u_max = np.array([[4.0]])
+  alpha = np.array([[2.0]])
+  beta = np.zeros((1, 1, 1))
+  gamma = np.array([[1.0]])
+  adjacency = np.zeros((1, 1))
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert x[0, 0] == pytest.approx(10.0)
+  assert z[0, 0] == pytest.approx(0.0)
+  assert obj == pytest.approx(2.0)  # alpha * x / lam
+
+
+def test_routing_lp_offloads_overflow_to_neighbor():
+  lam = np.array([[10.0], [0.0]])
+  r = np.array([[1], [5]])
+  u_max = np.array([[4.0], [4.0]])
+  alpha = np.full((2, 1), 2.0)
+  beta = np.zeros((2, 2, 1)); beta[0, 1, 0] = 1.5
+  gamma = np.full((2, 1), 5.0)
+  adjacency = np.array([[0, 1], [1, 0]])
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert x[0, 0] == pytest.approx(4.0)
+  assert y[0, 1, 0] == pytest.approx(6.0)
+  assert z[0, 0] == pytest.approx(0.0)
+
+
+def test_routing_lp_respects_receiver_capacity():
+  lam = np.array([[10.0], [0.0]])
+  r = np.array([[0], [1]])
+  u_max = np.array([[4.0], [4.0]])
+  alpha = np.full((2, 1), 2.0)
+  beta = np.zeros((2, 2, 1)); beta[0, 1, 0] = 1.5
+  gamma = np.full((2, 1), 0.1)
+  adjacency = np.array([[0, 1], [1, 0]])
+  obj, x, y, z = routing_lp(lam, r, u_max, alpha, beta, gamma, adjacency)
+  assert y[0, 1, 0] == pytest.approx(4.0)
+  assert z[0, 0] == pytest.approx(6.0)
+
+
+def test_shed_overflow_sheds_x_then_phantom_y():
+  # held plan: node 0 handles x=30 locally and forwards y=20 to node 1;
+  # true load collapses to lam=10 -- x must be shed to 0 first, then the
+  # remaining 10 units of overflow scaled out of the outgoing y row so no
+  # phantom (never-arrived) traffic is credited to the objective.
+  x = np.array([[30.0], [0.0]])
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 20.0
+  lam = np.array([[10.0], [0.0]])
+  x_eff, y_eff, z_eff = shed_overflow(x, y, lam)
+  assert x_eff[0, 0] == pytest.approx(0.0)
+  assert y_eff[0, 1, 0] == pytest.approx(10.0)
+  assert z_eff[0, 0] == pytest.approx(0.0)
+  handled = x_eff + y_eff.sum(axis=1) + z_eff
+  assert handled == pytest.approx(lam)
+
+
+def test_madea_iface_reexports_runner():
+  import run_faasmadea
+  assert madea_iface.run_madea is run_faasmadea.run
+
+
+def test_greedy_baseline_conserves_traffic():
+  from plasma.baselines.greedy_baseline import solve
+  data = _tiny_instance()
+  x, y, z, r = solve(data, {})
+  Nn = data[None]["Nn"][None]
+  Nf = data[None]["Nf"][None]
+  for n in range(Nn):
+    for f in range(Nf):
+      load = data[None]["incoming_load"][(n + 1, f + 1)]
+      assert x[n, f] + y[n, :, f].sum() + z[n, f] == pytest.approx(load)
+
+
+def _tiny_instance():
+  Nn, Nf = 2, 1
+  return {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "neighborhood": {(1, 1): 0, (1, 2): 1, (2, 1): 1, (2, 2): 0},
+    "alpha": {(1, 1): 2.0, (2, 1): 2.0},
+    "beta": {(1, 1, 1): 0.0, (1, 2, 1): 1.5, (2, 1, 1): 1.5, (2, 2, 1): 0.0},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.7},
+    "memory_capacity": {1: 4, 2: 4},
+    "memory_requirement": {1: 2},
+    "incoming_load": {(1, 1): 10, (2, 1): 1},
+  }}
+
+
+def test_cumulative_regret():
+  method = np.array([1.0, 1.0, 2.0])
+  oracle = np.array([2.0, 2.0, 2.0])
+  assert cumulative_regret(method, oracle).tolist() == [1.0, 2.0, 2.0]
+
+
+def test_adaptation_lag_measures_recovery():
+  times = np.arange(6, dtype=float)
+  oracle = np.full(6, 10.0)
+  method = np.array([10.0, 10.0, 2.0, 5.0, 9.5, 9.8])  # change point at t=2
+  lag = adaptation_lag(times, method, oracle, change_points=[2.0])
+  assert lag == [2.0]  # recovered at t=4 (9.5 >= 9.0)
+
+
+def test_adaptation_lag_nan_when_never_recovering():
+  times = np.arange(3, dtype=float)
+  lag = adaptation_lag(times, np.zeros(3), np.full(3, 10.0),
+                       change_points=[0.0])
+  assert np.isnan(lag[0])
+
+
+def _scenario_config(tmp_path, Nn=3, max_steps=6):
+  return {
+    "base_solution_folder": str(tmp_path),
+    "verbose": 0,
+    "seed": 7,
+    "max_steps": max_steps,
+    "min_run_time": 0,
+    "max_run_time": max_steps,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "solver_name": "none",
+    "solver_options": {
+      "plasma": {"rounds_per_step": 5, "k_sb": 2, "n_sb_steps": 100,
+                 "n_hyst": 1}
+    },
+    "limits": {
+      "Nn": {"min": Nn, "max": Nn},
+      "Nf": {"min": 2, "max": 2},
+      "neighborhood": {"m": Nn - 1},
+      "demand": {"values": [1.0, 1.2]},
+      "memory_capacity": {"min": 12, "max": 12},
+      "memory_requirement": {"values": [2, 3]},
+      "max_utilization": {"min": 0.65, "max": 0.75},
+      "load": {"trace_type": "sinusoidal",
+               "min": {"min": 5, "max": 10},
+               "max": {"min": 20, "max": 30}},
+      "weights": {"alpha": {"min": 1.0, "max": 1.5},
+                  "beta_multiplier": {"min": 1.5, "max": 2.5},
+                  "gamma": {"min": 0.05, "max": 0.15},
+                  "delta_multiplier": {"min": 0.1, "max": 0.2}},
+    },
+  }
+
+
+def _solver_available(name="gurobi"):
+  try:
+    from pyomo.environ import SolverFactory
+    return SolverFactory(name).available(exception_flag=False)
+  except Exception:
+    return False
+
+
+def test_sweep_driver_runs_grid(tmp_path):
+  from plasma.eval.sweep import sweep
+  config = _scenario_config(tmp_path)
+  df = sweep(config, {"mu": [0.1, 0.3]})
+  assert len(df) == 2
+  assert set(df["mu"]) == {0.1, 0.3}
+  assert df["obj_mean"].notna().all()
+
+
+@pytest.mark.skipif(not _solver_available(), reason="no MILP solver")
+def test_scenario_driver_produces_comparison(tmp_path):
+  from plasma.eval.scenario import run_scenario
+  config = _scenario_config(tmp_path)
+  df = run_scenario(config, kill=(1, 2, 4), solver_name="gurobi",
+                    solver_options={"OutputFlag": 0})
+  assert list(df.columns) == ["t", "plasma", "oracle", "stale_milp",
+                              "greedy", "plasma_msgs_per_node_s"]
+  assert len(df) == 6
+  assert (df["oracle"] >= df["plasma"] - 1e-6).all()  # oracle upper-bounds
diff --git a/tests/test_plasma_clock.py b/tests/test_plasma_clock.py
new file mode 100644
index 0000000..30e6b30
--- /dev/null
+++ b/tests/test_plasma_clock.py
@@ -0,0 +1,128 @@
+from plasma.sim.clock import RoundClock
+
+
+def test_events_delivered_before_round_callback():
+  clock = RoundClock()
+  trace = []
+  clock.schedule(1, lambda: trace.append("hb@1"))
+  clock.run(2, on_round=lambda r: trace.append(f"round{r}"))
+  assert trace == ["round0", "hb@1", "round1"]
+
+
+def test_fifo_tie_break():
+  clock = RoundClock()
+  trace = []
+  clock.schedule(0, lambda: trace.append("a"))
+  clock.schedule(0, lambda: trace.append("b"))
+  clock.run(1, on_round=lambda r: None)
+  assert trace == ["a", "b"]
+
+
+def test_round_counter_persists_across_runs():
+  clock = RoundClock()
+  seen = []
+  clock.run(3, on_round=seen.append)
+  clock.run(2, on_round=seen.append)
+  assert seen == [0, 1, 2, 3, 4]
+
+
+def test_past_due_events_flush():
+  clock = RoundClock()
+  trace = []
+  clock.run(2, on_round=lambda r: None)
+  clock.schedule(0, lambda: trace.append("late"))
+  clock.run(1, on_round=lambda r: trace.append(f"round{r}"))
+  assert trace == ["late", "round2"]
+
+
+import numpy as np
+
+from plasma.core.node import NodeParams, PlasmaNode
+from plasma.core.types import PlasmaOptions
+from plasma.engine import PlasmaEngine
+
+
+def _line_engine(Nn=2, Nf=1, opts=None, seed=0, u_max=5.0, ram_cap=8.0):
+  opts = opts or PlasmaOptions(k_sb=0)
+  rng = np.random.default_rng(seed)
+  nodes = []
+  for i in range(Nn):
+    nbrs = tuple(j for j in (i - 1, i + 1) if 0 <= j < Nn)
+    params = NodeParams(
+      node_id=i, nbrs=nbrs, alpha=np.full(Nf, 2.0), gamma=np.full(Nf, 0.1),
+      beta=np.full((len(nbrs), Nf), 1.5), u_max=np.full(Nf, u_max),
+      ram_cap=ram_cap, ram_req=np.full(Nf, 2.0),
+    )
+    node = PlasmaNode(params, opts, np.random.default_rng(seed + i))
+    node.init_replicas()
+    nodes.append(node)
+  return PlasmaEngine(nodes, opts, rng), nodes
+
+
+def test_traffic_conservation_every_round():
+  engine, _ = _line_engine()
+  arrivals = np.array([[8], [8]])
+  res = engine.run_rounds(5, arrivals)
+  total = res.x + res.z + res.y.sum(axis=1)
+  np.testing.assert_allclose(total, arrivals.astype(float))
+
+
+def test_xi_transposes_y():
+  engine, _ = _line_engine()
+  res = engine.run_rounds(5, np.array([[20], [0]]))
+  np.testing.assert_allclose(res.xi[1, 0, :], res.y[0, 1, :])
+
+
+def test_dead_node_traffic_redistributes():
+  # 3-node line, kill the middle node: node 0 must stop forwarding to it.
+  # node 0 is deliberately undersized (capacity 5 < 20 arrivals/round) so it
+  # relies on node 1 for the overflow -- the default init_replicas() spread
+  # would exactly cover 20 arrivals with no forced forwarding at all.
+  opts = PlasmaOptions(k_sb=0)
+  engine, nodes = _line_engine(Nn=3, opts=opts)
+  nodes[0].r = np.array([1])
+  engine.run_rounds(5, np.array([[20], [0], [0]]))
+  engine.set_alive(1, False)
+  # pure evaporation ((1-mu)^n) needs ~90 rounds from the reinforced level
+  # reached above to clear the D_min floor at mu=0.1; 10*staleness_rounds
+  # only covers the routing/gate-closing side of "redistributes", not full
+  # numeric decay to the floor
+  res = engine.run_rounds(100, np.array([[20], [0], [0]]))
+  assert res.y[0, 1, 0] == 0.0  # nothing ACKed by a dead node
+  # conductance toward the dead neighbor decayed to the floor
+  col = 2 + nodes[0].params.nbrs.index(1)
+  assert nodes[0].D[0, col] <= opts.D_min * 1.01
+
+
+def test_phase_locked_commit_thrash_vs_randomized():
+  # adversarial: 2-node line, shared demand pulse, SB every round
+  def run(p_commit):
+    opts = PlasmaOptions(k_sb=1, n_hyst=1, p_commit=p_commit, n_sb_steps=150)
+    engine, nodes = _line_engine(Nn=2, opts=opts, seed=3, ram_cap=4.0)
+    flips = 0
+    prev = [n.r.copy() for n in nodes]
+    for _ in range(20):
+      engine.run_rounds(1, np.array([[12], [12]]))
+      for k, n in enumerate(nodes):
+        if not np.array_equal(prev[k], n.r):
+          flips += 1
+        prev[k] = n.r.copy()
+    return flips
+
+  thrash = run(p_commit=1.0)
+  calm = run(p_commit=0.5)
+  assert calm <= thrash
+
+
+def test_settles_within_20_slow_ticks_with_default_p_commit():
+  opts = PlasmaOptions(k_sb=1, n_hyst=2, p_commit=0.5, n_sb_steps=150)
+  engine, nodes = _line_engine(Nn=2, opts=opts, seed=3, ram_cap=4.0)
+  last_change = 0
+  prev = [n.r.copy() for n in nodes]
+  for tick in range(1, 21):
+    engine.run_rounds(1, np.array([[12], [12]]))
+    for k, n in enumerate(nodes):
+      if not np.array_equal(prev[k], n.r):
+        last_change = tick
+        prev[k] = n.r.copy()
+  assert last_change < 20
diff --git a/tests/test_plasma_e2e.py b/tests/test_plasma_e2e.py
new file mode 100644
index 0000000..ace2aa1
--- /dev/null
+++ b/tests/test_plasma_e2e.py
@@ -0,0 +1,183 @@
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from plasma.runner import run as run_plasma
+
+
+def _config(tmp_path, Nn=3, max_steps=3):
+  return {
+    "base_solution_folder": str(tmp_path),
+    "verbose": 0,
+    "seed": 42,
+    "max_steps": max_steps,
+    "min_run_time": 0,
+    # ub = max_run_time (unequal min/max branch, mirroring decentralized_gcaa's
+    # range(min_run_time, ub, run_time_step)) -- must equal max_steps for the
+    # loop to cover all max_steps timesteps
+    "max_run_time": max_steps,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "solver_name": "none",
+    "solver_options": {
+      "plasma": {"rounds_per_step": 5, "k_sb": 2, "n_sb_steps": 100,
+                 "n_hyst": 1}
+    },
+    "limits": {
+      "Nn": {"min": Nn, "max": Nn},
+      "Nf": {"min": 2, "max": 2},
+      "neighborhood": {"m": Nn - 1},   # a line/tree on 3 nodes
+      "demand": {"values": [1.0, 1.2]},
+      "memory_capacity": {"min": 12, "max": 12},
+      "memory_requirement": {"values": [2, 3]},
+      "max_utilization": {"min": 0.65, "max": 0.75},
+      "load": {"trace_type": "sinusoidal",
+               "min": {"min": 5, "max": 10},
+               "max": {"min": 20, "max": 30}},
+      "weights": {"alpha": {"min": 1.0, "max": 1.5},
+                  "beta_multiplier": {"min": 1.5, "max": 2.5},
+                  "gamma": {"min": 0.05, "max": 0.15},
+                  "delta_multiplier": {"min": 0.1, "max": 0.2}},
+    },
+  }
+
+
+def test_runner_produces_lspc_artifacts(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  for name in ("LSPc_solution.csv", "LSPc_offloaded.csv",
+               "LSPc_utilization.csv", "LSPc_replicas.csv",
+               "LSPc_detailed_fwd_solution.csv",
+               "LSPc_residual_capacity.csv", "obj.csv", "runtime.csv",
+               "termination_condition.csv", "plasma_messages.csv",
+               "config.json"):
+    assert os.path.exists(os.path.join(folder, name)), name
+
+
+def test_runner_objective_column_is_plasma(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  obj = pd.read_csv(os.path.join(folder, "obj.csv"))
+  assert list(obj.columns) == ["Plasma"]
+  assert len(obj) == 3
+
+
+def test_runner_is_deterministic_given_seed(tmp_path):
+  f1 = run_plasma(_config(tmp_path / "a"), parallelism=0)
+  f2 = run_plasma(_config(tmp_path / "b"), parallelism=0)
+  o1 = pd.read_csv(os.path.join(f1, "obj.csv"))
+  o2 = pd.read_csv(os.path.join(f2, "obj.csv"))
+  pd.testing.assert_frame_equal(o1, o2)
+
+
+def test_runner_messages_bounded(tmp_path):
+  folder = run_plasma(_config(tmp_path), parallelism=0)
+  msgs = pd.read_csv(os.path.join(folder, "plasma_messages.csv"))
+  assert (msgs["hb_per_node_s"] <= 2.0 + 1e-9).all()  # deg <= 2 on a tree of 3
+
+
+import run as run_module
+
+
+def test_methods_choice_accepts_plasma(monkeypatch):
+  argv = ["run.py", "-c", "config_files/plasma_comparison.json",
+          "--methods", "plasma"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run_module.parse_arguments()
+  assert "plasma" in args.methods
+
+
+def test_run_module_exposes_plasma_runner():
+  assert callable(run_module.run_plasma)
+
+
+def test_method_result_models_has_plasma_entry():
+  assert run_module.METHOD_RESULT_MODELS["plasma"] == ("LSPc", "Plasma")
+
+
+def test_plasma_comparison_config_exists_and_has_section():
+  config = json.loads(
+    Path("config_files/plasma_comparison.json").read_text()
+  )
+  assert "plasma" in config["solver_options"]
+
+
+def test_set_solution_folder_tolerates_missing_plasma_key():
+  solution_folders = {"experiments_list": []}
+  run_module.set_solution_folder(solution_folders, "plasma", 0, "/x")
+  assert solution_folders["plasma"][0] == "/x"
+
+
+def test_runner_supports_w_not_one(tmp_path):
+  cfg1 = _config(tmp_path / "w1")
+  folder1 = run_plasma(cfg1, parallelism=0)
+  cfg2 = _config(tmp_path / "w2")
+  cfg2["solver_options"]["plasma"]["W"] = 2.0
+  folder2 = run_plasma(cfg2, parallelism=0)  # must not trip check_feasibility
+  obj = pd.read_csv(os.path.join(folder2, "obj.csv"))["Plasma"]
+  assert np.isfinite(obj).all()
+  # same seed => identical per-second load traces, so a W=2 window handles
+  # ~2x the requests of a W=1 window (every LSPc_solution column is a
+  # per-window request count)
+  def _total(folder):
+    sol = pd.read_csv(os.path.join(folder, "LSPc_solution.csv"))
+    return sol.select_dtypes(include=[np.number]).to_numpy().sum()
+  ratio = _total(folder2) / _total(folder1)
+  assert 1.8 <= ratio <= 2.2, ratio
+
+
+from plasma.runner import objective_load
+
+
+def test_objective_load_floors_zero_pairs_only():
+  load = {(1, 1): 0, (1, 2): 7}
+  assert objective_load(load) == {(1, 1): 1, (1, 2): 7}
+
+
+def _solver_available(name="gurobi"):
+  try:
+    from pyomo.environ import SolverFactory
+    return SolverFactory(name).available(exception_flag=False)
+  except Exception:
+    return False
+
+
+@pytest.mark.skipif(not _solver_available(), reason="no MILP solver")
+def test_plasma_gap_vs_milp_on_small_graph(tmp_path):
+  from generators.generate_data import update_data
+  from plasma.baselines.milp_baseline import solve_snapshot
+  from run_centralized_model import init_problem
+  from utils.centralized import get_current_load
+  config = _config(tmp_path, Nn=3, max_steps=6)
+  config["solver_options"]["plasma"]["rounds_per_step"] = 30
+  folder = run_plasma(config, parallelism=0)
+  plasma_obj = pd.read_csv(os.path.join(folder, "obj.csv"))["Plasma"]
+  # dynamic oracle on the same instance/traces (re-generated: same seed)
+  oracle_folder = tmp_path / "oracle"
+  oracle_folder.mkdir()
+  base, traces, agents, _ = init_problem(
+    config["limits"], "sinusoidal", config["max_steps"], config["seed"],
+    str(oracle_folder),
+  )
+  # mirror plasma.runner.run's own t-range exactly (min_run_time..ub,
+  # run_time_step) so oracle[t] and plasma_obj[t] score the same timestep
+  min_run_time = config.get("min_run_time", 0)
+  max_run_time = config.get("max_run_time", config["max_steps"])
+  run_time_step = config.get("run_time_step", 1)
+  ub = (
+    max_run_time + run_time_step
+  ) if max_run_time == min_run_time else max_run_time
+  oracle = []
+  for t in range(min_run_time, ub, run_time_step):
+    loadt = get_current_load(traces, agents, t)
+    loadt = {k: int(round(v)) for k, v in loadt.items()}
+    data = update_data(base, {"incoming_load": loadt})
+    oracle.append(solve_snapshot(data, "gurobi", {"OutputFlag": 0})[4])
+  assert len(oracle) == len(plasma_obj)
+  # late-horizon gap (after Layer A/B settle): within 35% of the oracle
+  # (M5's 10% target applies to the tuned 20-node run, not this smoke)
+  late_p = plasma_obj.iloc[-2:].mean()
+  late_o = np.mean(oracle[-2:])
+  assert late_p >= late_o - abs(late_o) * 0.35
diff --git a/tests/test_plasma_protocol.py b/tests/test_plasma_protocol.py
new file mode 100644
index 0000000..dbd5436
--- /dev/null
+++ b/tests/test_plasma_protocol.py
@@ -0,0 +1,124 @@
+import dataclasses
+
+import numpy as np
+import pytest
+
+from plasma.core.protocol import HeartbeatCache, decode_heartbeat, encode_heartbeat
+from plasma.core.types import LOCAL, REJ, Heartbeat, PlasmaOptions
+
+
+def test_target_columns():
+  assert LOCAL == 0
+  assert REJ == 1
+
+
+def test_options_defaults():
+  opts = PlasmaOptions()
+  assert opts.W == 1.0
+  assert opts.k_sb == 10
+  assert opts.mu == 0.1
+  assert opts.p_commit == 0.5
+  assert opts.n_hyst == 2
+  assert opts.staleness_rounds == 3
+  assert opts.rare_function_mode == "sampled"
+
+
+def test_options_from_config_overrides():
+  config = {"solver_options": {"plasma": {"mu": 0.2, "k_sb": 5}}}
+  opts = PlasmaOptions.from_config(config)
+  assert opts.mu == 0.2
+  assert opts.k_sb == 5
+  assert opts.W == 1.0
+
+
+def test_options_frozen():
+  with pytest.raises(dataclasses.FrozenInstanceError):
+    PlasmaOptions().mu = 0.5
+
+
+def test_options_rejects_execution_mode():
+  config = {"solver_options": {"plasma": {"execution_mode": "async"}}}
+  with pytest.raises(TypeError):
+    PlasmaOptions.from_config(config)
+
+
+def _hb(node=3, seq=7):
+  return Heartbeat(node=node, seq=seq, spare=(1.0, 0.0), alpha=(2.0, 2.5),
+                   pull=(0.0, 4.0))
+
+
+def test_heartbeat_roundtrip():
+  hb = _hb()
+  assert decode_heartbeat(encode_heartbeat(hb)) == hb
+
+
+def test_heartbeat_field_whitelist():
+  msg = encode_heartbeat(_hb())
+  assert set(msg) == {"node", "seq", "spare", "alpha", "pull"}
+  msg["ram_capacity"] = 64  # privacy violation: must be rejected
+  with pytest.raises(ValueError):
+    decode_heartbeat(msg)
+
+
+def test_stale_neighbor_treated_as_zero_spare():
+  cache = HeartbeatCache()
+  cache.store(_hb(node=3), round_=10)
+  fresh = cache.spare(3, now_round=12, staleness_rounds=3, Nf=2)
+  stale = cache.spare(3, now_round=14, staleness_rounds=3, Nf=2)
+  assert fresh.tolist() == [1.0, 0.0]
+  assert stale.tolist() == [0.0, 0.0]
+
+
+def test_unknown_neighbor_is_zero_spare():
+  cache = HeartbeatCache()
+  assert cache.spare(9, now_round=0, staleness_rounds=3, Nf=2).tolist() == [0.0, 0.0]
+
+
+def test_pull_in_sums_fresh_neighbors_only():
+  cache = HeartbeatCache()
+  cache.store(_hb(node=1), round_=10)   # pull (0, 4)
+  cache.store(_hb(node=2), round_=1)    # stale at now=12
+  pull = cache.pull_in(now_round=12, staleness_rounds=3, Nf=2)
+  assert pull.tolist() == [0.0, 4.0]
+
+
+from plasma.engine import PlasmaEngine  # noqa: F401 (import checks packaging)
+
+
+def test_message_budget_heartbeats_bounded_by_degree():
+  from plasma.core.node import NodeParams, PlasmaNode
+  from plasma.core.types import PlasmaOptions
+  opts = PlasmaOptions(k_sb=0, hb_loss=0.0)
+  rng = np.random.default_rng(0)
+  params0 = NodeParams(node_id=0, nbrs=(1,), alpha=np.ones(1),
+                       gamma=np.ones(1), beta=np.ones((1, 1)),
+                       u_max=np.ones(1), ram_cap=4.0, ram_req=np.ones(1))
+  params1 = NodeParams(node_id=1, nbrs=(0,), alpha=np.ones(1),
+                       gamma=np.ones(1), beta=np.ones((1, 1)),
+                       u_max=np.ones(1), ram_cap=4.0, ram_req=np.ones(1))
+  nodes = [PlasmaNode(params0, opts, np.random.default_rng(1)),
+           PlasmaNode(params1, opts, np.random.default_rng(2))]
+  engine = PlasmaEngine(nodes, opts, rng)
+  engine.run_rounds(10, np.zeros((2, 1), dtype=int))
+  # exactly deg(i) heartbeats per node per round, no hidden channels
+  assert engine.hb_count == 10 * 2 * 1
+
+
+def test_options_reject_nonpositive_rounds_per_step():
+  with pytest.raises(ValueError, match="rounds_per_step"):
+    PlasmaOptions(rounds_per_step=0)
+
+
+def test_options_reject_nonpositive_w():
+  with pytest.raises(ValueError, match="W"):
+    PlasmaOptions(W=0.0)
+
+
+def test_options_reject_latency_beyond_staleness():
+  with pytest.raises(ValueError, match="hb_latency_rounds"):
+    PlasmaOptions(hb_latency_rounds=4, staleness_rounds=3)
+
+
+def test_options_reject_unknown_sbm_method():
+  with pytest.raises(ValueError, match="sbm_method"):
+    PlasmaOptions(sbm_method="quantum")
diff --git a/tests/test_plasma_routing.py b/tests/test_plasma_routing.py
new file mode 100644
index 0000000..62a3e0b
--- /dev/null
+++ b/tests/test_plasma_routing.py
@@ -0,0 +1,248 @@
+import numpy as np
+import pytest
+
+from plasma.baselines.milp_baseline import routing_lp
+from plasma.engine import PlasmaEngine
+from plasma.core.types import LOCAL, REJ, PlasmaOptions
+from plasma.core.routing import choose_target, target_weights, update_conductance
+
+
+def test_local_gate_closes_local_column():
+  D_f = np.array([10.0, 0.1, 5.0])  # LOCAL, REJ, one neighbor
+  w = target_weights(D_f, local_open=False, nbr_spare=np.array([1.0]),
+                     eps_explore=0.01)
+  assert w[LOCAL] == 0.0
+  assert w[2] == 5.0
+
+
+def test_neighbor_without_spare_gets_exploration_floor():
+  D_f = np.array([1.0, 0.1, 4.0])
+  w = target_weights(D_f, local_open=True, nbr_spare=np.array([0.0]),
+                     eps_explore=0.01)
+  assert w[2] == pytest.approx(4.0 * 0.01)
+
+
+def test_choose_target_unsplittable_is_argmax():
+  rng = np.random.default_rng(0)
+  w = np.array([1.0, 0.5, 7.0])
+  assert choose_target(rng, w, unsplittable=True) == 2
+
+
+def test_choose_target_sampled_follows_weights():
+  rng = np.random.default_rng(0)
+  w = np.array([0.0, 0.0, 1.0])
+  assert choose_target(rng, w, unsplittable=False) == 2
+
+
+def test_conductance_reinforces_accepted_traffic():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 1.0)
+  phi = np.array([[10.0, 0.0, 0.0]])
+  rewards = np.array([[2.0, 0.0, 0.0]])
+  D2 = update_conductance(D, phi, rewards, opts)
+  assert D2[0, LOCAL] == pytest.approx(0.9 * 1.0 + 0.1 * 10.0 * 2.0)
+
+
+def test_dead_neighbor_conductance_decays_to_floor():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 100.0)
+  phi = np.zeros((1, 3))
+  rewards = np.zeros((1, 3))
+  for _ in range(200):
+    D = update_conductance(D, phi, rewards, opts)
+  # pure evaporation: (1-mu)^200 * 100 << D_min -> clipped at floor
+  assert D[0, 2] == pytest.approx(opts.D_min)
+
+
+def test_conductance_clipped_above():
+  opts = PlasmaOptions()
+  D = np.full((1, 3), 1.0)
+  phi = np.full((1, 3), 1e9)
+  rewards = np.full((1, 3), 1e9)
+  D2 = update_conductance(D, phi, rewards, opts)
+  assert (D2 <= opts.D_max).all()
+
+
+from plasma.core.node import NodeParams, PlasmaNode
+
+
+def _node(r=(2,), u_max=(5.0,), nbrs=(1,), opts=None, beta=1.5):
+  Nf = len(u_max)
+  params = NodeParams(
+    node_id=0, nbrs=tuple(nbrs), alpha=np.full(Nf, 2.0),
+    gamma=np.full(Nf, 0.1), beta=np.full((len(nbrs), Nf), beta),
+    u_max=np.array(u_max), ram_cap=100.0, ram_req=np.full(Nf, 2.0),
+  )
+  node = PlasmaNode(params, opts or PlasmaOptions(), np.random.default_rng(0))
+  node.r = np.array(r, dtype=int)
+  return node
+
+
+def _fresh_spare_hb(node, nbr, spare, Nf=1):
+  from plasma.core.types import Heartbeat
+  node.on_heartbeat(Heartbeat(node=nbr, seq=1, spare=(spare,) * Nf,
+                              alpha=(1.0,) * Nf, pull=(0.0,) * Nf), round_=0)
+
+
+def test_capacity_gate_never_admits_beyond_r_umax():
+  node = _node(r=(2,), u_max=(5.0,))  # capacity 10 req/window
+  node.begin_window()
+  desired = node.route_window(np.array([100]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 10                       # local-first fills capacity
+  assert counts.z[0] + desired[0].sum() == 90    # overflow rejected or forwarded
+
+
+def test_incoming_forwards_share_the_same_capacity():
+  node = _node(r=(1,), u_max=(3.0,))
+  node.begin_window()
+  assert node.accept_forwards(0, 10, sender=1) == 3
+  desired = node.route_window(np.array([5]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 0                        # capacity consumed by forwards
+
+
+def test_nack_counts_as_origin_rejection_and_pull():
+  node = _node()
+  node.begin_window()
+  node.route_window(np.array([10]), round_=0)  # saturate local capacity (10)
+  node.record_forward_results(0, k=0, attempted=2, accepted=1)
+  counts = node.end_window()
+  # capacity is exhausted, so the NACKed unit has no room to retry locally
+  assert counts.z[0] == 1 and counts.y[0, 0] == 1
+  # pull is accounted at routing time, not at result recording
+  assert node.make_heartbeat().pull[0] == 0
+
+
+def test_pull_counts_overflow_exactly_once():
+  from plasma.core.types import Heartbeat
+  node = _node(r=(1,), u_max=(5.0,))  # capacity 5
+  node.begin_window()
+  # fresh heartbeat opens the neighbor gate so overflow actually forwards
+  node.on_heartbeat(
+    Heartbeat(node=1, seq=1, spare=(50.0,), alpha=(2.0,), pull=(0.0,)),
+    round_=0,
+  )
+  desired = node.route_window(np.array([50]), round_=0)
+  assert desired[0].sum() > 0  # some overflow really was forwarded
+  for k in range(desired.shape[1]):
+    n = int(desired[0, k])
+    if n:
+      node.record_forward_results(0, k, n, accepted=0)  # all NACKed
+  node.end_window()
+  assert node.make_heartbeat().pull[0] == 45  # exactly the overflow, not more
+
+
+def test_zero_replicas_rejects_or_forwards_everything():
+  node = _node(r=(0,))
+  node.begin_window()
+  desired = node.route_window(np.array([20]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 0
+  assert counts.z[0] + desired[0].sum() == 20
+
+
+def test_dead_node_admits_nothing():
+  node = _node()
+  node.alive = False
+  assert node.accept_forwards(0, 5, sender=1) == 0
+
+
+def test_end_window_reinforces_local_conductance():
+  node = _node(r=(4,), u_max=(100.0,))
+  node.begin_window()
+  node.route_window(np.array([50]), round_=0)
+  d_before = node.D[0, LOCAL]
+  node.end_window()
+  assert node.D[0, LOCAL] > d_before  # phi*alpha > evaporation at D_init
+
+
+def test_spare_advertises_floored_capacity():
+  node = _node(r=(1,), u_max=(2.085,))  # capacity_units = 2
+  node.begin_window()
+  assert node.accept_forwards(0, 3, sender=1) == 2  # floored capacity exhausted
+  node.end_window()
+  hb = node.make_heartbeat()
+  assert hb.spare[0] == 0.0  # not 0.085: nothing more is admittable
+
+
+def test_physarum_converges_to_lp_routing_fractions():
+  # 2-node line, fixed replicas, stationary integer traffic (lambda = 40):
+  # node 0 undersized -> LP says: serve 20 locally, forward 20.
+  opts = PlasmaOptions(k_sb=0, hb_latency_rounds=1)
+  rng = np.random.default_rng(7)
+  make = lambda i, nbrs: PlasmaNode(
+    NodeParams(
+      node_id=i, nbrs=nbrs, alpha=np.array([2.0]), gamma=np.array([0.1]),
+      beta=np.full((len(nbrs), 1), 1.5), u_max=np.array([10.0]),
+      ram_cap=100.0, ram_req=np.array([2.0]),
+    ), opts, np.random.default_rng(10 + i))
+  n0, n1 = make(0, (1,)), make(1, (0,))
+  n0.r = np.array([2])   # capacity 20
+  n1.r = np.array([4])   # capacity 40
+  engine = PlasmaEngine([n0, n1], opts, rng)
+  arrivals = np.array([[40], [0]])
+  engine.run_rounds(150, arrivals)         # burn-in
+  x_acc = np.zeros(1); y_acc = 0.0
+  for _ in range(50):                      # measure 50 windows
+    res = engine.run_rounds(1, arrivals)
+    x_acc += res.x[0]; y_acc += res.y[0, 1, 0]
+  lp_obj, lp_x, lp_y, lp_z = routing_lp(
+    lam=np.array([[40.0], [0.0]]), r=np.array([[2], [4]]),
+    u_max=np.full((2, 1), 10.0), alpha=np.full((2, 1), 2.0),
+    beta=np.array([[[0.0], [1.5]], [[1.5], [0.0]]]),
+    gamma=np.full((2, 1), 0.1), adjacency=np.array([[0, 1], [1, 0]]),
+  )
+  assert abs(x_acc[0] / 50 - lp_x[0, 0]) / 40.0 <= 0.05   # +-5% band
+  assert abs(y_acc / 50 - lp_y[0, 1, 0]) / 40.0 <= 0.05
+
+
+def test_local_first_admission_fills_local_capacity_before_any_forward():
+  # capacity 10: local-first admits exactly 10, the rest is overflow
+  node = _node(r=(2,), u_max=(5.0,))
+  node.begin_window()
+  desired = node.route_window(np.array([15]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 10
+  assert counts.z[0] + desired[0].sum() == 5
+
+
+def test_reward_aware_prefers_high_beta_neighbor_over_local():
+  node = _node(r=(4,), u_max=(5.0,), beta=3.0)   # beta 3.0 > alpha 2.0
+  _fresh_spare_hb(node, 1, spare=8.0)
+  node.begin_window()
+  desired = node.route_window(np.array([10]), round_=0)
+  counts = node.end_window()
+  assert desired[0, 0] == 8          # up to advertised spare goes to the neighbor
+  assert counts.x[0] == 2            # remainder served locally (capacity 20)
+  assert counts.z[0] == 0
+
+
+def test_alpha_dominant_degenerates_to_local_first():
+  node = _node(r=(4,), u_max=(5.0,), beta=1.5)   # beta 1.5 < alpha 2.0
+  _fresh_spare_hb(node, 1, spare=8.0)
+  node.begin_window()
+  desired = node.route_window(np.array([10]), round_=0)
+  counts = node.end_window()
+  assert counts.x[0] == 10           # all local, exactly today's behavior
+  assert desired[0].sum() == 0
+
+
+def test_anti_ping_pong_blocks_preferred_forward():
+  node = _node(r=(4,), u_max=(5.0,), beta=3.0)
+  _fresh_spare_hb(node, 1, spare=8.0)
+  node.begin_window()
+  assert node.accept_forwards(0, 3, sender=1) == 3   # we accepted from nbr 1
+  node.end_window()                                   # snapshot recv_from
+  node.begin_window()
+  desired = node.route_window(np.array([10]), round_=0)
+  assert desired[0, 0] == 0          # preferred forwarding to 1 is blocked
+
+
+def test_nack_retries_locally_before_rejecting():
+  node = _node(r=(4,), u_max=(5.0,))  # capacity 20, plenty free
+  node.begin_window()
+  node.record_forward_results(0, k=0, attempted=5, accepted=0)
+  counts = node.end_window()
+  assert counts.x[0] == 5            # NACKed requests served locally
+  assert counts.z[0] == 0
diff --git a/tests/test_plasma_sbm.py b/tests/test_plasma_sbm.py
new file mode 100644
index 0000000..3907f18
--- /dev/null
+++ b/tests/test_plasma_sbm.py
@@ -0,0 +1,229 @@
+import numpy as np
+import pytest
+
+from plasma.core.types import PlasmaOptions
+from plasma.core.sbm import (
+  HamiltonianContext, bits_per_fn, brute_force, decode_spins, dsb_minimize,
+  exact_minimize, hamiltonian, r_max_per_fn, repair,
+)
+
+
+def test_encoding_roundtrip():
+  r_max = np.array([5, 0, 1])
+  bits = bits_per_fn(r_max)
+  assert bits.tolist() == [3, 0, 1]
+  # spins for r = (5, -, 1): 5 = 101b -> bits (1,0,1) -> spins (+1,-1,+1)
+  s = np.array([1, -1, 1, 1])
+  assert decode_spins(s, bits, r_max).tolist() == [5, 0, 1]
+
+
+def test_decode_clips_to_r_max():
+  r_max = np.array([5])           # 3 bits encode up to 7
+  s = np.array([1, 1, 1])         # decodes to 7
+  assert decode_spins(s, bits_per_fn(r_max), r_max).tolist() == [5]
+
+
+def _ctx(**over):
+  base = dict(
+    benefit=np.array([3.0, 1.0]), ram_req=np.array([2.0, 2.0]), ram_cap=8.0,
+    demand_hat=np.array([4.0, 1.0]), margin=np.array([1.0, 0.5]),
+    u_max=np.array([5.0, 5.0]), r_prev=np.array([1, 0]),
+    A=10.0, B=1.0, C=0.1, switch_cost=1.0,
+    alpha=np.array([2.0, 1.0]), demand_target=np.array([4.0, 1.0]),
+  )
+  base.update(over)
+  return HamiltonianContext(**base)
+
+
+def test_hamiltonian_penalizes_ram_violation():
+  ctx = _ctx()
+  ok = hamiltonian(np.array([2, 2]), ctx)       # RAM = 8 <= 8
+  bad = hamiltonian(np.array([3, 2]), ctx)      # RAM = 10 > 8
+  assert bad > ok
+
+
+def test_hamiltonian_churn_term():
+  ctx = _ctx(B=0.0, A=0.0, benefit=np.zeros(2), alpha=np.zeros(2))
+  h_stay = hamiltonian(np.array([1, 0]), ctx)
+  h_move = hamiltonian(np.array([3, 2]), ctx)
+  assert h_move == pytest.approx(h_stay + 0.1 * 1.0 * (2 + 2))
+
+
+def test_repair_restores_feasibility_dropping_lowest_benefit():
+  r = np.array([3, 3])  # RAM = 12 > 8
+  fixed = repair(r, benefit=np.array([3.0, 1.0]), ram_req=np.array([2.0, 2.0]),
+                 ram_cap=8.0)
+  assert (fixed * np.array([2.0, 2.0])).sum() <= 8.0
+  assert fixed[0] >= fixed[1]  # low-benefit f=1 dropped first
+
+
+def test_dsb_matches_brute_force_on_random_hamiltonians():
+  opts = PlasmaOptions(n_sb_steps=400)
+  hits = 0
+  trials = 200
+  for trial in range(trials):
+    rng = np.random.default_rng(trial)
+    n = 8
+    J = rng.normal(size=(n, n)); J = (J + J.T) / 2; np.fill_diagonal(J, 0.0)
+    h = rng.normal(size=n)
+
+    def H(s, J=J, h=h):
+      return float(-0.5 * s @ J @ s - h @ s)
+
+    s_star = brute_force(H, n)
+    s_dsb = dsb_minimize(H, n, opts, rng)
+    if H(s_dsb) <= H(s_star) + 1e-9:
+      hits += 1
+  assert hits >= 0.95 * trials
+
+
+def test_brute_force_exact_on_tiny_instance():
+  def H(s):
+    return float(-(s[0] * s[1]) - s[0])  # ground state (+1, +1)
+  assert brute_force(H, 2).tolist() == [1, 1]
+
+
+from plasma.core.node import NodeParams, PlasmaNode
+
+
+def _sb_node(p_commit=1.0, n_hyst=1, k_sb=1, ram_cap=8.0):
+  params = NodeParams(
+    node_id=0, nbrs=(), alpha=np.array([3.0, 1.0]),
+    gamma=np.array([0.1, 0.1]), beta=np.zeros((0, 2)),
+    u_max=np.array([5.0, 5.0]), ram_cap=ram_cap, ram_req=np.array([2.0, 2.0]),
+  )
+  opts = PlasmaOptions(p_commit=p_commit, n_hyst=n_hyst, k_sb=k_sb,
+                       n_sb_steps=200)
+  return PlasmaNode(params, opts, np.random.default_rng(1))
+
+
+def test_init_replicas_spread_fills_ram_round_robin():
+  node = _sb_node()
+  node.init_replicas()
+  assert (node.r * node.params.ram_req).sum() <= node.params.ram_cap
+  assert node.r.sum() == 4  # 8 RAM / 2 per replica
+
+
+def test_sb_pass_grows_replicas_under_demand():
+  node = _sb_node(n_hyst=1)
+  node.r = np.zeros(2, dtype=int)
+  node.lam_hat = np.array([8.0, 0.0])
+  committed = node.sb_pass(round_=0)
+  assert committed
+  assert node.r[0] >= 1
+  assert (node.r * node.params.ram_req).sum() <= node.params.ram_cap
+
+
+def test_rejected_own_demand_still_drives_provisioning():
+  # a node with r=0 rejects everything; its provisioning target must still
+  # see the full arrival rate (lam_hat), not the accepted traffic (zero)
+  node = _sb_node(n_hyst=1)
+  node.r = np.zeros(2, dtype=int)
+  node.begin_window()
+  node.route_window(np.array([12, 0]), round_=0)
+  node.end_window()  # everything was rejected or forwarded; nothing accepted
+  committed = node.sb_pass(round_=0)
+  assert committed
+  assert node.r[0] >= 1  # grows replicas from rejected demand
+
+
+def test_hysteresis_requires_consecutive_confirmations():
+  node = _sb_node(n_hyst=2)
+  node.r = np.zeros(2, dtype=int)
+  node.lam_hat = np.array([8.0, 0.0])
+  assert node.sb_pass(round_=0) is False  # first proposal only counts
+  assert node.sb_pass(round_=1) is True   # second consecutive -> commit
+
+
+def test_p_commit_zero_never_commits():
+  node = _sb_node(p_commit=0.0, n_hyst=1)
+  node.lam_hat = np.array([8.0, 0.0])
+  for k in range(5):
+    assert node.sb_pass(round_=k) is False
+  assert node.r.sum() == 0
+
+
+def test_committed_r_is_always_ram_feasible():
+  node = _sb_node(n_hyst=1, ram_cap=4.0)
+  node.lam_hat = np.array([50.0, 50.0])  # wants far more than RAM allows
+  node.sb_pass(round_=0)
+  assert (node.r * node.params.ram_req).sum() <= 4.0
+
+
+def test_exact_matches_brute_force_ground_state():
+  rng = np.random.default_rng(0)
+  for trial in range(50):
+    Nf = 3
+    ram_req = rng.integers(1, 4, Nf).astype(float)
+    ram_cap = float(rng.integers(4, 13))
+    r_max = np.floor(ram_cap / ram_req).astype(int)
+    ctx = HamiltonianContext(
+      benefit=rng.uniform(0, 5, Nf), ram_req=ram_req, ram_cap=ram_cap,
+      demand_hat=rng.uniform(0, 10, Nf), margin=rng.uniform(0, 2, Nf),
+      u_max=rng.uniform(1, 6, Nf), r_prev=rng.integers(0, 3, Nf),
+      A=10.0, B=1.0, C=0.1, switch_cost=1.0,
+      alpha=rng.uniform(0.5, 3, Nf), demand_target=rng.uniform(0, 12, Nf),
+    )
+    r_star = exact_minimize(ctx, r_max)
+    assert (ctx.ram_req * r_star).sum() <= ctx.ram_cap + 1e-9
+    # brute force over all feasible r
+    from itertools import product as iproduct
+    best = min(
+      (hamiltonian(np.array(rr), ctx)
+       for rr in iproduct(*[range(m + 1) for m in r_max])
+       if (ctx.ram_req * np.array(rr)).sum() <= ctx.ram_cap + 1e-9))
+    assert hamiltonian(r_star, ctx) <= best + 1e-9
+
+
+def test_exact_rejects_fractional_ram():
+  ctx = _ctx(ram_req=np.array([1.5, 2.0]))
+  with pytest.raises(ValueError, match="dsb"):
+    exact_minimize(ctx, np.array([5, 4]))
+
+
+def test_sb_pass_exact_is_deterministic():
+  a = _sb_node(n_hyst=1)
+  b = _sb_node(n_hyst=1)
+  for node in (a, b):
+    node.lam_hat = np.array([8.0, 3.0])
+    node.sb_pass(round_=0)
+  assert np.array_equal(a.r, b.r)
+
+
+def test_exact_minimize_fast_on_large_ram():
+  import time
+  ctx = HamiltonianContext(
+    benefit=np.array([3.0, 1.0, 2.0]), ram_req=np.array([128.0, 512.0, 128.0]),
+    ram_cap=32768.0, demand_hat=np.array([40.0, 10.0, 30.0]),
+    margin=np.array([2.0, 1.0, 2.0]), u_max=np.array([1.2, 1.1, 0.9]),
+    r_prev=np.array([0, 0, 0]), A=10.0, B=1.0, C=0.1, switch_cost=1.0,
+    alpha=np.array([2.0, 1.5, 1.8]), demand_target=np.array([45.0, 12.0, 33.0]),
+  )
+  r_max = np.floor(ctx.ram_cap / ctx.ram_req).astype(int)
+  start = time.perf_counter()
+  r = exact_minimize(ctx, r_max)
+  elapsed = time.perf_counter() - start
+  assert (ctx.ram_req * r).sum() <= ctx.ram_cap + 1e-9
+  assert elapsed < 0.5  # was ~1.7s before gcd scaling
+
+
+def test_field_saturates_at_demand():
+  # replicas beyond served demand must not improve the Hamiltonian
+  ctx = _ctx(demand_target=np.array([6.0, 0.0]), u_max=np.array([3.0, 3.0]),
+             r_prev=np.array([2, 0]), B=0.0, C=0.0, A=0.0)
+  h_enough = hamiltonian(np.array([2, 0]), ctx)   # 2*3 = 6 serves it all
+  h_extra = hamiltonian(np.array([4, 0]), ctx)    # extra capacity is idle
+  assert h_extra == pytest.approx(h_enough)
+
+
+def test_exact_prefers_high_throughput_allocation():
+  # same RAM cost, f0 yields more served demand per replica -> DP must pick f0
+  # benefit favors f1: the old linear field (-benefit*r) would pick f1 here,
+  # so this assertion only passes under the served-demand field
+  ctx = _ctx(alpha=np.array([1.0, 1.0]), u_max=np.array([4.0, 1.0]),
+             demand_target=np.array([8.0, 8.0]), ram_req=np.array([2.0, 2.0]),
+             ram_cap=4.0, r_prev=np.array([0, 0]),
+             demand_hat=np.array([0.0, 0.0]), margin=np.array([0.0, 0.0]),
+             B=0.0, C=0.0, benefit=np.array([1.0, 3.0]))
+  r = exact_minimize(ctx, np.array([2, 2]))
+  assert r[0] == 2 and r[1] == 0  # all RAM to the high-throughput function
diff --git a/tests/test_potentialgame_e2e.py b/tests/test_potentialgame_e2e.py
new file mode 100644
index 0000000..70a1bdf
--- /dev/null
+++ b/tests/test_potentialgame_e2e.py
@@ -0,0 +1,90 @@
+# tests/test_potentialgame_e2e.py
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+from parse import parse
+
+from decentralized_potentialgame import run_pg_s, run_pg_r
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "pg_s": {"epsilon": 1e-6},
+      "pg_r": {"epsilon": 1e-6},
+    },
+    "max_iterations": 3,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def _assert_artifacts(folder, column):
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert column in obj.columns
+  assert len(obj) >= 1
+  assert np.isfinite(pd.to_numeric(obj[column], errors="coerce")).all()
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+  tc = pd.read_csv(Path(folder, "termination_condition.csv"))
+  assert len(tc) >= 1
+  for s in tc["0"]:
+    assert parse(
+      "{} (it: {}; obj. deviation: {}; best it: {}; total runtime: {})", s
+    ) is not None
+
+
+def test_run_pg_s_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_pg_s(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  _assert_artifacts(folder, "FaaS-MAPG-S")
+
+
+def test_run_pg_r_produces_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_pg_r(
+    _e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+  _assert_artifacts(folder, "FaaS-MAPG-R")
diff --git a/tests/test_potentialgame_helpers.py b/tests/test_potentialgame_helpers.py
new file mode 100644
index 0000000..7c8d5c1
--- /dev/null
+++ b/tests/test_potentialgame_helpers.py
@@ -0,0 +1,62 @@
+import numpy as np
+
+from decentralized_potentialgame import (
+  compute_node_utility,
+  compute_z,
+  split_omega,
+)
+from utils.faasmacro import compute_centralized_objective
+
+
+def _data_3n_1f():
+  # 3 nodes, 1 function; node 0 offloads, nodes 1-2 are sellers
+  return {None: {
+    "Nn": {None: 3},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 4.0, (3, 1): 4.0},
+    "demand": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100, 3: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "delta": {(i, 1): 0.2 for i in (1, 2, 3)},
+    "gamma": {(i, 1): 0.1 for i in (1, 2, 3)},
+    "beta": {
+      (1, 2, 1): 2.0, (1, 3, 1): 1.5,
+      (2, 1, 1): 1.0, (2, 3, 1): 1.0,
+      (3, 1, 1): 1.0, (3, 2, 1): 1.0,
+    },
+  }}
+
+
+def test_split_omega_prefers_higher_beta_and_respects_ledger():
+  data = _data_3n_1f()
+  ledger = np.array([[0.0], [1.5], [10.0]])
+  row = split_omega(0, np.array([4.0]), ledger, {1, 2}, data)
+  # 1.5 to node 1 (beta 2.0, capped by ledger), remaining 2.5 to node 2
+  assert np.isclose(row[1, 0], 1.5)
+  assert np.isclose(row[2, 0], 2.5)
+  # ledger consumed in place
+  assert np.isclose(ledger[1, 0], 0.0)
+  assert np.isclose(ledger[2, 0], 7.5)
+
+
+def test_split_omega_skips_inconvenient_sellers():
+  data = _data_3n_1f()
+  data[None]["beta"][(1, 2, 1)] = -0.2  # below -gamma = -0.1: worse than Cloud
+  ledger = np.array([[0.0], [10.0], [10.0]])
+  row = split_omega(0, np.array([4.0]), ledger, {1, 2}, data)
+  assert np.isclose(row[1, 0], 0.0)
+  assert np.isclose(row[2, 0], 4.0)
+
+
+def test_node_utilities_sum_to_potential():
+  data = _data_3n_1f()
+  x = np.array([[2.0], [4.0], [4.0]])
+  y = np.zeros((3, 3, 1))
+  y[0, 1, 0] = 1.0
+  z = compute_z(x, y, data)
+  assert np.isclose(z[0, 0], 1.0)  # 4 - 2 - 1
+  phi = compute_centralized_objective(data, x, y, z)
+  total = sum(compute_node_utility(i, x, y, z, data) for i in range(3))
+  assert np.isclose(total, phi)
diff --git a/tests/test_potentialgame_model.py b/tests/test_potentialgame_model.py
new file mode 100644
index 0000000..7304e43
--- /dev/null
+++ b/tests/test_potentialgame_model.py
@@ -0,0 +1,62 @@
+# tests/test_potentialgame_model.py
+import pyomo.environ as pyo
+import pytest
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _tiny_pg_data():
+  # 2 nodes, 1 function. Node 1 is the mover; node 2 exists only as index.
+  # demand=1.0, U_max=0.8 -> each replica serves 0.8 req/s.
+  return {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "whoami": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 4.0},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+    "delta": {(1, 1): 0.2, (2, 1): 0.2},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "pi": {1: 0.0},
+    # node 2 has committed 2.4 req/s of inbound traffic onto node 1
+    "y_bar": {(2, 1, 1): 2.4},
+    "omega_ub": {1: 1.0},
+  }}
+
+
+def test_lsp_pg_respects_inbound_commitments_and_cap():
+  _require_gurobi()
+  from models.sp import LSP_pg
+  model = LSP_pg()
+  instance = model.generate_instance(_tiny_pg_data())
+  sol = model.solve(instance, {"OutputFlag": 0}, "gurobi")
+  assert sol["solution_exists"]
+  r = sol["r"][0]
+  x = sol["x"][0]
+  omega = sol["omega"][0]
+  # replicas must cover local load PLUS the 2.4 committed inbound
+  assert 1.0 * (x + 2.4) <= r * 0.8 + 1e-6
+  # offloading capped by omega_ub
+  assert omega <= 1.0 + 1e-6
+  # flow conservation: x + omega + z == load
+  z = sol["z"][0]
+  assert abs(x + omega + z - 4.0) <= 1e-6
+
+
+def test_lsp_pg_fixedr_pins_replicas():
+  _require_gurobi()
+  from models.sp import LSP_pg_fixedr
+  data = _tiny_pg_data()
+  data[None]["r_bar"] = {(1, 1): 6, (2, 1): 0}
+  model = LSP_pg_fixedr()
+  instance = model.generate_instance(data)
+  sol = model.solve(instance, {"OutputFlag": 0}, "gurobi")
+  assert sol["solution_exists"]
+  assert abs(sol["r"][0] - 6) <= 1e-6
diff --git a/tests/test_potentialgame_sweep.py b/tests/test_potentialgame_sweep.py
new file mode 100644
index 0000000..284ffd3
--- /dev/null
+++ b/tests/test_potentialgame_sweep.py
@@ -0,0 +1,216 @@
+import numpy as np
+import pytest
+
+from decentralized_potentialgame import (
+  check_pg_stopping,
+  compute_z,
+  node_move,
+  potential_game_sweep,
+)
+from run_faasmadea import compute_residual_capacity
+from utils.faasmacro import compute_centralized_objective
+
+
+def _data_2n_1f():
+  # node 0: load 4, initially served locally (r=5 -> cap 4.0)
+  # node 1: load 0-ish, big idle capacity (r=10 -> cap 8.0)
+  # beta(0->1)=2.0 > alpha=1.0: offloading everything is the improving move
+  return {None: {
+    "Nn": {None: 2},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 0.001},
+    "demand": {(1, 1): 1.0, (2, 1): 1.0},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(1, 1): 1.0, (2, 1): 1.0},
+    "delta": {(1, 1): 0.2, (2, 1): 0.2},
+    "gamma": {(1, 1): 0.1, (2, 1): 0.1},
+    "beta": {(1, 2, 1): 2.0, (2, 1, 1): 0.5},
+    "neighborhood": {(1, 2): 1, (2, 1): 1},
+  }}
+
+
+def _state():
+  x = np.array([[4.0], [0.001]])
+  y = np.zeros((2, 2, 1))
+  r = np.array([[5.0], [10.0]])
+  return x, y, r
+
+
+def _offload_all_proposal(i, omega_ub_row):
+  # node 0 proposes moving everything out; node 1 proposes staying put
+  if i == 0:
+    return (
+      np.array([0.0]), np.array([0.0]),
+      np.minimum(np.array([4.0]), omega_ub_row), 0.0,
+    )
+  return np.array([0.001]), np.array([10.0]), np.array([0.0]), 0.0
+
+
+def test_node_move_accepts_improving_move_and_updates_state():
+  data = _data_2n_1f()
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  rho = np.zeros(2)
+  accepted, delta_u, bids, _ = node_move(
+    0, x, y, r, data, neighborhood, rho, 1e-6, _offload_all_proposal, 1e-9
+  )
+  assert accepted
+  assert delta_u > 0
+  # 4.0 offloaded to node 1 (residual cap 8.0 - 0.001)
+  assert np.isclose(y[0, 1, 0], 4.0)
+  assert np.isclose(x[0, 0], 0.0)
+
+
+def test_node_move_rejects_non_improving_move():
+  data = _data_2n_1f()
+  data[None]["beta"][(1, 2, 1)] = 0.5  # now worse than serving locally
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  accepted, _, _, _ = node_move(
+    0, x, y, r, data, neighborhood, np.zeros(2), 1e-6,
+    _offload_all_proposal, 1e-9,
+  )
+  assert not accepted
+  # state untouched
+  assert np.isclose(x[0, 0], 4.0)
+  assert np.isclose(y.sum(), 0.0)
+
+
+def test_sweep_raises_potential_then_certifies_equilibrium():
+  data = _data_2n_1f()
+  x, y, r = _state()
+  neighborhood = np.array([[0, 1], [1, 0]])
+  rng = np.random.default_rng(0)
+  phi0 = compute_centralized_objective(data, x, y, compute_z(x, y, data))
+  n_acc, delta_phi, bids, _ = potential_game_sweep(
+    x, y, r, data, neighborhood, np.zeros(2), 1e-6, 1e-9,
+    "fixed", rng, _offload_all_proposal,
+  )
+  phi1 = compute_centralized_objective(data, x, y, compute_z(x, y, data))
+  assert n_acc == 1
+  assert delta_phi > 0
+  assert np.isclose(phi1 - phi0, delta_phi)
+  # second sweep: same proposal is no longer an improvement -> equilibrium
+  n_acc2, delta_phi2, _, _ = potential_game_sweep(
+    x, y, r, data, neighborhood, np.zeros(2), 1e-6, 1e-9,
+    "fixed", rng, _offload_all_proposal,
+  )
+  assert n_acc2 == 0
+  assert np.isclose(delta_phi2, 0.0)
+  stop, why = check_pg_stopping(1, 100, n_acc2, 0, 0.0, np.inf)
+  assert stop and why == "epsilon-Nash equilibrium certified"
+  # ledger conservation: residual capacity consistent with committed flows
+  _, residual, ell = compute_residual_capacity(x, y, r, data)
+  assert np.isclose(ell[1, 0], 4.001)
+
+
+def test_check_pg_stopping_guards():
+  stop, why = check_pg_stopping(99, 100, 5, 0, 0.0, np.inf)
+  assert stop and why == "max iterations reached"
+  stop, why = check_pg_stopping(0, 100, 5, 0, 100.0, 50.0)
+  assert stop and "time limit" in why
+  stop, why = check_pg_stopping(0, 100, 5, 0, 0.0, np.inf)
+  assert not stop
+
+
+def test_node_move_blocks_offload_of_committed_inbound_function():
+  # node 0 already receives f from node 1: node 0 must not offload f
+  # (FRALB no_ping_pong), even when offloading would improve its utility
+  data = _data_2n_1f()
+  data[None]["incoming_load"][(2, 1)] = 4.0
+  x = np.array([[4.0], [2.0]])
+  y = np.zeros((2, 2, 1))
+  y[1, 0, 0] = 2.0  # committed inbound onto node 0
+  r = np.array([[10.0], [3.0]])
+  neighborhood = np.array([[0, 1], [1, 0]])
+  seen_ub = {}
+
+  def probe_proposal(i, omega_ub_row):
+    seen_ub[i] = omega_ub_row.copy()
+    return np.array([0.0]), np.array([0.0]), np.array([4.0]), 0.0
+
+  accepted, _, _, _ = node_move(
+    0, x, y, r, data, neighborhood, np.zeros(2), 1e-6, probe_proposal, 1e-9
+  )
+  # the cap advertised to the proposal must be zero for the inbound function
+  assert np.isclose(seen_ub[0][0], 0.0)
+  # and even a rogue proposal cannot place anything (omega clamped to cap)
+  assert np.isclose(y[0, :, 0].sum(), 0.0)
+
+
+def test_node_move_excludes_sellers_that_offload_same_function():
+  # 3 nodes: node 1 currently offloads f to node 2, so node 1 must not be a
+  # seller of f for node 0 despite having residual capacity
+  data = {None: {
+    "Nn": {None: 3},
+    "Nf": {None: 1},
+    "incoming_load": {(1, 1): 4.0, (2, 1): 4.0, (3, 1): 4.0},
+    "demand": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "max_utilization": {1: 0.8},
+    "memory_capacity": {1: 100, 2: 100, 3: 100},
+    "memory_requirement": {1: 2},
+    "alpha": {(i, 1): 1.0 for i in (1, 2, 3)},
+    "delta": {(i, 1): 0.2 for i in (1, 2, 3)},
+    "gamma": {(i, 1): 0.1 for i in (1, 2, 3)},
+    "beta": {
+      (1, 2, 1): 2.0, (1, 3, 1): 1.5,
+      (2, 1, 1): 1.0, (2, 3, 1): 1.0,
+      (3, 1, 1): 1.0, (3, 2, 1): 1.0,
+    },
+    "neighborhood": {
+      (1, 2): 1, (1, 3): 1, (2, 1): 1, (2, 3): 1, (3, 1): 1, (3, 2): 1,
+    },
+  }}
+  x = np.array([[4.0], [2.0], [4.0]])
+  y = np.zeros((3, 3, 1))
+  y[1, 2, 0] = 2.0  # node 1 offloads f to node 2
+  # node 1 has spare capacity (r=10 -> cap 8, serves only x=2), node 2 is full
+  r = np.array([[5.0], [10.0], [8.0]])
+  neighborhood = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])
+
+  def offload_all(i, omega_ub_row):
+    return (
+      np.array([0.0]), np.array([0.0]),
+      np.minimum(np.array([4.0]), omega_ub_row), 0.0,
+    )
+
+  node_move(
+    0, x, y, r, data, neighborhood, np.zeros(3), 1e-6, offload_all, 1e-9
+  )
+  # nothing may be placed on node 1 (it offloads f): no ping-pong
+  assert np.isclose(y[0, 1, 0], 0.0)
+  # combined y must satisfy the centralized no-ping-pong invariant
+  assert not ((y.sum(axis=1) > 1e-9) & (y.sum(axis=0) > 1e-9)).any()
+
+
+def test_node_move_bids_on_memory_when_cloud_residue_remains():
+  # ledger is empty (neighbour saturated), so the capped proposal asks for
+  # omega=0 and places 0; the z>0 residue must still trigger memory bids
+  # towards neighbours with memory slack
+  data = _data_2n_1f()
+  x = np.array([[3.0], [4.0]])  # node 0: 1.0 unserved -> z; node 1 full
+  y = np.zeros((2, 2, 1))
+  r = np.array([[3.75], [5.0]])  # node 1: cap 4.0 == x -> residual 0
+  neighborhood = np.array([[0, 1], [1, 0]])
+  rho = np.array([0.0, 10.0])  # node 1 has memory slack
+
+  def capped_proposal(i, omega_ub_row):
+    return np.array([3.0]), np.array([3.75]), omega_ub_row.copy(), 0.0
+
+  _, _, bids, _ = node_move(
+    0, x, y, r, data, neighborhood, rho, 1e-6, capped_proposal, 1e-9
+  )
+  assert bids["j"] == [1] and bids["f"] == [0]
+
+
+def test_compute_rho_tracks_committed_replicas():
+  from decentralized_potentialgame import compute_rho
+  data = _data_2n_1f()  # memory_capacity 100, memory_requirement 2
+  r = np.array([[5.0], [10.0]])
+  rho = compute_rho(r, data)
+  assert np.allclose(rho, [90.0, 80.0])
+  # replicas grown by a move: slack must shrink accordingly
+  r[0, 0] = 50.0
+  assert np.allclose(compute_rho(r, data), [0.0, 80.0])
diff --git a/tests/test_powerd_e2e.py b/tests/test_powerd_e2e.py
new file mode 100644
index 0000000..b76c540
--- /dev/null
+++ b/tests/test_powerd_e2e.py
@@ -0,0 +1,92 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyomo.environ as pyo
+import pytest
+
+from decentralized_powerd import run as run_powerd
+
+
+def _require_gurobi() -> None:
+  solver = pyo.SolverFactory("gurobi")
+  if not solver.available(exception_flag=False):
+    pytest.skip("Gurobi solver is not available")
+
+
+def _powerd_e2e_config(base_solution_folder: Path) -> dict:
+  return {
+    "base_solution_folder": str(base_solution_folder),
+    "seed": 21,
+    "limits": {
+      "Nn": {"min": 10, "max": 10},
+      "Nf": {"min": 1, "max": 1},
+      "neighborhood": {"type": "planar", "degree": 3},
+      "weights": {
+        "alpha": {"min": 1.0, "max": 1.0},
+        "beta_multiplier": {"min": 1.5, "max": 2.0},
+        "gamma": {"min": 0.05, "max": 0.1},
+        "delta_multiplier": {"min": 0.1, "max": 0.2},
+      },
+      "demand": {"values": [1.0]},
+      "memory_capacity": {"values": [12] * 10},
+      "memory_requirement": {"values": [2]},
+      "max_utilization": {"min": 0.7, "max": 0.7},
+      "load": {
+        "trace_type": "clipped",
+        "min": {"min": 2.0, "max": 2.0},
+        "max": {"min": 3.0, "max": 3.0},
+      },
+    },
+    "solver_name": "gurobi",
+    "solver_options": {
+      "general": {"TimeLimit": 60, "OutputFlag": 0},
+      "powerd": {"d": 2, "criterion": "score",
+                 "latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False},
+    },
+    "max_iterations": 2,
+    "patience": 1,
+    "max_steps": 8,
+    "min_run_time": 1,
+    "max_run_time": 1,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "tolerance": 1e-6,
+    "verbose": 0,
+  }
+
+
+def test_powerd_runner_produces_expected_artifacts(tmp_path):
+  _require_gurobi()
+  folder = run_powerd(
+    _powerd_e2e_config(tmp_path), parallelism=0, disable_plotting=True
+  )
+
+  obj = pd.read_csv(Path(folder, "obj.csv"))
+  assert len(obj) >= 1
+  assert "FaaS-MAPoD" in obj.columns
+  assert np.isfinite(pd.to_numeric(obj["FaaS-MAPoD"], errors="coerce")).all()
+
+  runtime = pd.read_csv(Path(folder, "runtime.csv"))
+  assert "tot" in runtime.columns
+  assert (runtime["tot"] >= 0).all()
+
+  assert Path(folder, "termination_condition.csv").exists()
+  assert Path(folder, "LSPc_solution.csv").exists()
+
+
+def test_powerd_runner_is_reproducible_for_same_seed(tmp_path):
+  _require_gurobi()
+  folder_a = run_powerd(
+    _powerd_e2e_config(tmp_path / "a"), parallelism=0, disable_plotting=True
+  )
+  folder_b = run_powerd(
+    _powerd_e2e_config(tmp_path / "b"), parallelism=0, disable_plotting=True
+  )
+
+  obj_a = pd.read_csv(Path(folder_a, "obj.csv"))["FaaS-MAPoD"].to_numpy()
+  obj_b = pd.read_csv(Path(folder_b, "obj.csv"))["FaaS-MAPoD"].to_numpy()
+
+  assert obj_a.shape[0] >= 1
+  assert obj_a.shape == obj_b.shape
+  assert np.allclose(obj_a, obj_b)
diff --git a/tests/test_powerd_fractional_omega.py b/tests/test_powerd_fractional_omega.py
new file mode 100644
index 0000000..b33a8f8
--- /dev/null
+++ b/tests/test_powerd_fractional_omega.py
@@ -0,0 +1,55 @@
+"""powerd.sample_assignments must terminate with fractional residual demand.
+
+With integer decision variables (VAR_TYPE = int) a fractional omega made the
+greedy sampling loop spin forever: once the residual dropped below one unit,
+q = int(...) became 0, assigned never grew and a seller with spare capacity was
+never dropped. The loop must stop instead of appending zero-quantity bids.
+"""
+
+import numpy as np
+
+from decentralized_powerd import sample_assignments
+
+
+def _base_data(Nn=3, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn}, "Nf": {None: Nf},
+    "beta": {}, "gamma": {}, "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _ring(Nn=3):
+  n = np.zeros((Nn, Nn))
+  for k in range(Nn):
+    n[k, (k + 1) % Nn] = 1
+    n[k, (k - 1) % Nn] = 1
+  return n
+
+
+def test_sample_assignments_terminates_on_fractional_omega():
+  data = _base_data()
+  omega = np.zeros((3, 1)); omega[0, 0] = 2.5      # fractional residual demand
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 5.0; blackboard[2, 0] = 5.0
+  options = {
+    "latency_weight": 0.0, "fairness_weight": 0.0, "unit_bids": False,
+    "d": 2, "criterion": "score",
+  }
+  # would hang before the fix; pytest-timeout not required, the guard bounds it
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, _ring(), np.zeros(3),
+    options, np.zeros((3, 3)), np.zeros((3, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0),
+  )
+  placed = bids["d"].sum() if len(bids) else 0
+  assert placed <= omega[0, 0] + 1e-9        # never over-offloads
+  assert placed == 2                          # integer part of 2.5 is placed
+  assert (bids["d"] > 0).all()                # no zero-quantity bids
diff --git a/tests/test_powerd_helpers.py b/tests/test_powerd_helpers.py
new file mode 100644
index 0000000..ad8cb6c
--- /dev/null
+++ b/tests/test_powerd_helpers.py
@@ -0,0 +1,242 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from decentralized_powerd import sample_assignments
+from decentralized_diffusion import define_assignments
+
+
+def _base_data(Nn=4, Nf=1):
+  data = {None: {
+    "Nn": {None: Nn},
+    "Nf": {None: Nf},
+    "beta": {},
+    "gamma": {},
+    "demand": {},
+    "memory_requirement": {f + 1: 2 for f in range(Nf)},
+    "max_utilization": {f + 1: 0.8 for f in range(Nf)},
+  }}
+  for i in range(Nn):
+    for f in range(Nf):
+      data[None]["gamma"][(i + 1, f + 1)] = 0.05
+      data[None]["demand"][(i + 1, f + 1)] = 1.0
+      for j in range(Nn):
+        data[None]["beta"][(i + 1, j + 1, f + 1)] = 1.0
+  return data
+
+
+def _full_neighborhood(Nn=4):
+  neighborhood = np.ones((Nn, Nn)) - np.eye(Nn)
+  return neighborhood
+
+
+def _opts(d=2, criterion="score", unit_bids=False):
+  return {
+    "d": d, "criterion": criterion, "unit_bids": unit_bids,
+    "latency_weight": 0.0, "fairness_weight": 0.0,
+  }
+
+
+def test_sample_assignments_rejects_invalid_sample_size():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 1
+  rho = np.zeros((2,))
+
+  with pytest.raises(ValueError, match="powerd d"):
+    sample_assignments(
+      omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+      _opts(d=0), np.zeros((2, 2)), np.zeros((2, 1)),
+      force_memory_bids=False, rng=np.random.default_rng(0))
+
+
+def test_sample_assignments_rejects_unknown_criterion():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 1
+  rho = np.zeros((2,))
+
+  with pytest.raises(ValueError, match="criterion"):
+    sample_assignments(
+      omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+      _opts(criterion="typo"), np.zeros((2, 2)), np.zeros((2, 1)),
+      force_memory_bids=False, rng=np.random.default_rng(0))
+
+
+def test_sample_assignments_samples_candidates_in_sorted_order():
+  class RecordingRng:
+    def __init__(self):
+      self.seen = None
+
+    def choice(self, values, size, replace):
+      self.seen = list(values)
+      return np.array(values[:size])
+
+  data = _base_data(Nn=10, Nf=1)
+  omega = np.zeros((10, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((10, 1))
+  for j in [2, 5, 9]:
+    blackboard[j, 0] = 1
+  neighborhood = np.zeros((10, 10))
+  neighborhood[0, [2, 5, 9]] = 1
+  rho = np.zeros((10,))
+  rng = RecordingRng()
+
+  sample_assignments(
+    omega, blackboard, data, neighborhood, rho,
+    _opts(d=3), np.zeros((10, 10)), np.zeros((10, 1)),
+    force_memory_bids=False, rng=rng)
+
+  assert rng.seen == [2, 5, 9]
+
+
+def test_sample_assignments_is_deterministic_given_seed():
+  data = _base_data()
+  # distinct betas so the random sampling has something to choose between
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  data[None]["beta"][(1, 4, 1)] = 1.5
+  omega = np.zeros((4, 1)); omega[0, 0] = 6.0
+  blackboard = np.zeros((4, 1)); blackboard[1, 0] = 2; blackboard[2, 0] = 2; blackboard[3, 0] = 2
+  rho = np.zeros((4,))
+  args = (omega, blackboard, data, _full_neighborhood(), rho,
+          _opts(d=2), np.zeros((4, 4)), np.zeros((4, 1)))
+
+  bids1, _, _ = sample_assignments(*args, force_memory_bids=False,
+                                   rng=np.random.default_rng(123))
+  bids2, _, _ = sample_assignments(*args, force_memory_bids=False,
+                                   rng=np.random.default_rng(123))
+
+  pd.testing.assert_frame_equal(bids1, bids2)
+
+
+def test_sample_assignments_degenerates_to_madig_when_d_covers_candidates():
+  # d >= |candidates|, criterion="score", unique scores => same as FaaS-MADiG
+  data = _base_data()
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  data[None]["beta"][(1, 4, 1)] = 1.0
+  omega = np.zeros((4, 1)); omega[0, 0] = 4.0
+  blackboard = np.zeros((4, 1)); blackboard[1, 0] = 2; blackboard[2, 0] = 2; blackboard[3, 0] = 2
+  rho = np.zeros((4,))
+  common = (omega, blackboard, data, _full_neighborhood(), rho)
+  geo = (np.zeros((4, 4)), np.zeros((4, 1)))
+
+  sampled, _, _ = sample_assignments(
+    *common, _opts(d=99, criterion="score"), *geo,
+    force_memory_bids=False, rng=np.random.default_rng(0))
+  greedy, _, _ = define_assignments(
+    *common, _opts(d=99, criterion="score"), *geo, force_memory_bids=False)
+
+  pd.testing.assert_frame_equal(
+    sampled.reset_index(drop=True), greedy.reset_index(drop=True))
+
+
+def test_sample_assignments_capacity_criterion_prefers_largest_capacity():
+  # score ranks seller 1 best, but seller 2 advertises far more capacity;
+  # with d covering both, criterion="capacity" must pick seller 2 first.
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 9.0   # seller 1: best score, small capacity
+  data[None]["beta"][(1, 3, 1)] = 1.0   # seller 2: worse score, big capacity
+  omega = np.zeros((3, 1)); omega[0, 0] = 3.0
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 1; blackboard[2, 0] = 10
+  rho = np.zeros((3,))
+
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, _full_neighborhood(3), rho,
+    _opts(d=99, criterion="capacity"), np.zeros((3, 3)), np.zeros((3, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  first = bids.iloc[0]
+  assert first["j"] == 2           # largest-capacity seller picked first
+  assert first["d"] == 3.0
+
+
+def test_sample_assignments_threshold_excludes_unconvenient_seller():
+  data = _base_data(Nn=2, Nf=1)
+  data[None]["gamma"][(1, 1)] = 0.05    # score 0.0 > -0.05 holds; flip sign below
+  data[None]["beta"][(1, 2, 1)] = -1.0  # score -1.0 <= -0.05 => excluded
+  omega = np.zeros((2, 1)); omega[0, 0] = 1.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 5
+  rho = np.zeros((2,))
+
+  bids, memory_bids, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 0
+  assert len(memory_bids) == 0
+
+
+def test_sample_assignments_requests_replicas_when_no_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 2.0
+  blackboard = np.zeros((2, 1))           # no capacity sellers
+  rho = np.zeros((2,)); rho[1] = 4.0       # neighbour 1 has spare memory
+
+  bids, memory_bids, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 0
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
+
+
+def test_sample_assignments_replica_bid_for_capacity_and_memory_seller():
+  # parity with define_assignments: a neighbour that is BOTH a capacity seller
+  # and has free memory (rho>0) must receive a replica-expansion memory bid
+  # when demand is unmet -- the second emission block, exercised with rho>0.
+  data = _base_data(Nn=3, Nf=1)
+  data[None]["beta"][(1, 2, 1)] = 3.0
+  data[None]["beta"][(1, 3, 1)] = 2.0
+  omega = np.zeros((3, 1)); omega[0, 0] = 10.0   # more than total capacity
+  blackboard = np.zeros((3, 1)); blackboard[1, 0] = 2; blackboard[2, 0] = 2
+  rho = np.zeros((3,)); rho[1] = 4.0; rho[2] = 4.0  # both sellers have free RAM
+  common = (omega, blackboard, data, _full_neighborhood(3), rho)
+  geo = (np.zeros((3, 3)), np.zeros((3, 1)))
+
+  sampled_bids, sampled_mem, _ = sample_assignments(
+    *common, _opts(d=99, criterion="score"), *geo,
+    force_memory_bids=False, rng=np.random.default_rng(0))
+  greedy_bids, greedy_mem, _ = define_assignments(
+    *common, _opts(d=99, criterion="score"), *geo, force_memory_bids=False)
+
+  assert len(sampled_mem) > 0   # the capacity+memory block fired
+  pd.testing.assert_frame_equal(
+    sampled_mem.reset_index(drop=True), greedy_mem.reset_index(drop=True))
+  pd.testing.assert_frame_equal(
+    sampled_bids.reset_index(drop=True), greedy_bids.reset_index(drop=True))
+
+
+def test_sample_assignments_unit_bids_emits_one_unit_per_request():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.zeros((2, 1)); omega[0, 0] = 3.0
+  blackboard = np.zeros((2, 1)); blackboard[1, 0] = 3
+  rho = np.zeros((2,))
+
+  bids, _, _ = sample_assignments(
+    omega, blackboard, data, np.array([[0.0, 1.0], [1.0, 0.0]]), rho,
+    _opts(d=2, unit_bids=True), np.zeros((2, 2)), np.zeros((2, 1)),
+    force_memory_bids=False, rng=np.random.default_rng(0))
+
+  assert len(bids) == 3
+  assert (bids["d"] == 1).all()
+  assert (bids["j"] == 1).all()
+
+
+def test_sample_assignments_force_memory_bids_includes_capacity_seller():
+  data = _base_data(Nn=2, Nf=1)
+  omega = np.array([[1.0], [0.0]])
+  blackboard = np.array([[0.0], [1.0]])
+  rho = np.array([0.0, 2.0])
+  neighborhood = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+  _, memory_bids, _ = sample_assignments(
+    omega, blackboard, data, neighborhood, rho, _opts(),
+    np.zeros((2, 2)), np.zeros((2, 1)), force_memory_bids=True,
+    rng=np.random.default_rng(0),
+  )
+
+  assert list(memory_bids[["i", "j", "f"]].iloc[0]) == [0, 1, 0]
diff --git a/tests/test_powerd_wiring.py b/tests/test_powerd_wiring.py
new file mode 100644
index 0000000..45e29f7
--- /dev/null
+++ b/tests/test_powerd_wiring.py
@@ -0,0 +1,171 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import networkx as nx
+import pytest
+
+import decentralized_powerd
+
+
+def test_powerd_run_uses_fixed_replicas_without_mutating_options(tmp_path, monkeypatch):
+  seen = {}
+  base_data = {
+    None: {
+      "Nn": {None: 1},
+      "Nf": {None: 1},
+      "neighborhood": {(1, 1): 0},
+    }
+  }
+
+  monkeypatch.setattr(
+    decentralized_powerd, "init_problem",
+    lambda *args, **kwargs: (base_data, {}, [], nx.empty_graph(1)),
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "load_solution",
+    lambda folder, model: ("opt_solution", "opt_replicas", "opt_detailed", None, None),
+    raising=False,
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "encode_solution",
+    lambda Nn, Nf, solution, detailed, replicas, t: (None, None, None, np.array([[3]]), None),
+    raising=False,
+  )
+  monkeypatch.setattr(decentralized_powerd, "LSP", lambda: "LSP")
+  monkeypatch.setattr(decentralized_powerd, "LSP_fixedr", lambda: "LSP_fixedr", raising=False)
+  monkeypatch.setattr(
+    decentralized_powerd, "LSPr", lambda: seen.setdefault("spr", "LSPr")
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "LSPr_fixedr",
+    lambda: seen.setdefault("spr", "LSPr_fixedr"), raising=False,
+  )
+
+  def _solve_subproblem(sp_data, agents, sp, *args):
+    seen["sp"] = sp
+    seen["r_bar"] = dict(sp_data[None].get("r_bar", {}))
+    return (
+      sp_data, np.zeros((1, 1)), None, None, np.zeros((1, 1)),
+      np.ones((1, 1)), np.array([5.0]), np.zeros((1, 1)),
+      {"tot": 0.0}, {"tot": "ok"}, {"tot": 0.0},
+    )
+
+  monkeypatch.setattr(decentralized_powerd, "solve_subproblem", _solve_subproblem)
+  monkeypatch.setattr(decentralized_powerd, "get_current_load", lambda *args: {})
+  monkeypatch.setattr(decentralized_powerd, "update_data", lambda data, update: data)
+  monkeypatch.setattr(
+    decentralized_powerd, "compute_residual_capacity",
+    lambda *args: (np.zeros((1, 1)), np.zeros((1, 1)), np.zeros((1, 1))),
+  )
+  def _sample_assignments(*args, **kwargs):
+    seen["coordination_rho"] = np.array(args[4], copy=True)
+    return (
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": [], "d": [], "utility": []}),
+      __import__("pandas").DataFrame({"i": [], "j": [], "f": []}),
+      0,
+    )
+
+  monkeypatch.setattr(decentralized_powerd, "sample_assignments", _sample_assignments)
+  monkeypatch.setattr(
+    decentralized_powerd, "combine_solutions",
+    lambda *args: {"sp": {"x": np.zeros((1, 1)), "y": np.zeros((1, 1, 1)), "z": np.zeros((1, 1)), "r": np.ones((1, 1)), "U": np.zeros((1, 1))}},
+  )
+  monkeypatch.setattr(decentralized_powerd, "compute_centralized_objective", lambda *args: -1.0)
+  monkeypatch.setattr(decentralized_powerd, "check_feasibility", lambda *args: (True, "ok"))
+  decoded = []
+
+  def _decode(sp_data, solution, complete, arg):
+    decoded.append(solution)
+    assert solution is not None
+    return complete, None, 1.0
+
+  monkeypatch.setattr(
+    decentralized_powerd, "decode_solutions",
+    _decode,
+  )
+  monkeypatch.setattr(
+    decentralized_powerd, "join_complete_solution",
+    lambda complete: ({}, {}, {}),
+  )
+  monkeypatch.setattr(decentralized_powerd, "save_checkpoint", lambda *args: None)
+  monkeypatch.setattr(decentralized_powerd, "save_solution", lambda *args: None)
+
+  config = {
+    "base_solution_folder": str(tmp_path),
+    "seed": 1,
+    "limits": {"load": {"trace_type": "fixed_sum"}},
+    "solver_name": "mock",
+    "solver_options": {
+      "general": {"TimeLimit": 10},
+      "auction": {"unit_bids": True},
+      "powerd": {"latency_weight": 0.0, "fairness_weight": 0.0},
+    },
+    "max_iterations": 1,
+    "patience": 1,
+    "max_steps": 1,
+    "min_run_time": 0,
+    "max_run_time": 0,
+    "run_time_step": 1,
+    "checkpoint_interval": 1,
+    "verbose": 0,
+    "opt_solution_folder": "centralized-folder",
+  }
+
+  decentralized_powerd.run(config, parallelism=0, disable_plotting=True)
+
+  assert seen["sp"] == "LSP_fixedr"
+  assert seen["spr"] == "LSPr_fixedr"
+  assert seen["r_bar"] == {(1, 1): 3}
+  assert (seen["coordination_rho"] == 0).all()
+  assert len(decoded) == 2
+  # run() applied its defaults to a COPY, not the input config
+  assert "d" not in config["solver_options"]["powerd"]
+  assert "unit_bids" not in config["solver_options"]["powerd"]
+
+
+import run
+
+
+def test_methods_choice_accepts_faas_powd(monkeypatch):
+  argv = ["run.py", "-c", "config_files/planar_comparison.json",
+          "--methods", "faas-powd"]
+  monkeypatch.setattr("sys.argv", argv)
+  args = run.parse_arguments()
+  assert "faas-powd" in args.methods
+
+
+def test_run_fix_r_help_mentions_diffusion_and_powerd(monkeypatch, capsys):
+  monkeypatch.setattr("sys.argv", ["run.py", "--help"])
+  with pytest.raises(SystemExit):
+    run.parse_arguments()
+
+  out = capsys.readouterr().out
+  assert "FaaS-MADiG" in out
+  assert "FaaS-MAPoD" in out
+
+
+def test_run_module_exposes_powerd_runner():
+  assert hasattr(run, "run_powerd")
+  assert callable(run.run_powerd)
+
+
+def test_planar_config_has_powerd_section():
+  config = json.loads(Path("config_files/planar_comparison.json").read_text())
+  powerd = config["solver_options"]["powerd"]
+  assert powerd["d"] == 2
+  assert powerd["criterion"] == "score"
+
+
+def test_compare_results_palette_includes_mapod():
+  import inspect
+  import compare_results
+  source = inspect.getsource(compare_results)
+  assert '"FaaS-MAPoD"' in source
+
+
+def test_compare_results_defaults_include_mapod(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["compare_results.py", "-i", "solutions/demo"])
+  import compare_results
+  args = compare_results.parse_arguments()
+  assert "FaaS-MAPoD" in args.models
diff --git a/tests/test_remote_experiments_batch.py b/tests/test_remote_experiments_batch.py
new file mode 100644
index 0000000..33d213f
--- /dev/null
+++ b/tests/test_remote_experiments_batch.py
@@ -0,0 +1,33 @@
+import json
+
+from remote_experiments.batch import Batch, Experiment
+
+
+def _experiment(id="e1", seed=1):
+  return Experiment(
+    id=id, suite="smoke", algorithm="centralized", seed=seed,
+    graph_params={"Nn": 10}, load_params={"trace_type": "sinusoidal"},
+    config={"seed": seed, "base_solution_folder": f"solutions/{id}"},
+  )
+
+
+def test_experiment_round_trips_through_dict():
+  e = _experiment()
+  assert Experiment.from_dict(e.to_dict()) == e
+
+
+def test_batch_save_and_load_round_trips(tmp_path):
+  batch = Batch(suite="smoke", experiments=(_experiment("e1", 1), _experiment("e2", 2)))
+  path = tmp_path / "batch.json"
+  batch.save(path)
+  loaded = Batch.load(path)
+  assert loaded == batch
+
+
+def test_batch_save_writes_readable_json(tmp_path):
+  batch = Batch(suite="smoke", experiments=(_experiment(),))
+  path = tmp_path / "batch.json"
+  batch.save(path)
+  raw = json.loads(path.read_text())
+  assert raw["suite"] == "smoke"
+  assert raw["experiments"][0]["id"] == "e1"
diff --git a/tests/test_remote_experiments_campaign.py b/tests/test_remote_experiments_campaign.py
new file mode 100644
index 0000000..e8720af
--- /dev/null
+++ b/tests/test_remote_experiments_campaign.py
@@ -0,0 +1,80 @@
+import argparse
+import json
+
+import remote_experiments.campaign as campaign
+
+
+def _fake_args(tmp_path):
+  return argparse.Namespace(
+    inventory=str(tmp_path / "inventory.yaml"),
+    results_dir=str(tmp_path / "results"),
+    instances=str(tmp_path / "instances"),
+    gurobi_license=None,
+    project_path=".",
+    python_version="3.10.19",
+    uv_version="0.11.25",
+  )
+
+
+def test_campaign_runs_screening_then_selects_then_confirms(tmp_path, monkeypatch):
+  calls = []
+
+  def fake_run_suite(suite, args, state):
+    calls.append(suite)
+    return True
+
+  def fake_select(batch, results_dir, **kw):
+    return ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+
+  monkeypatch.setattr(campaign, "_run_suite", fake_run_suite)
+  monkeypatch.setattr(campaign, "select_survivors", fake_select)
+  monkeypatch.setattr(campaign, "SURVIVORS_PATH", tmp_path / "survivors.json")
+  monkeypatch.setattr(campaign, "STATE_PATH", tmp_path / "campaign-state.json")
+
+  args = _fake_args(tmp_path)
+  campaign.run_campaign(args)
+
+  assert calls[0] == "paper-a-screening"
+  assert calls[1:] == list(campaign.CONFIRMATORY_SUITES)
+  survivors = json.loads((tmp_path / "survivors.json").read_text())["survivors"]
+  assert survivors == ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+
+
+def test_campaign_resumes_from_state(tmp_path, monkeypatch):
+  calls = []
+  monkeypatch.setattr(campaign, "_run_suite", lambda s, a, st: (calls.append(s), True)[1])
+  monkeypatch.setattr(campaign, "select_survivors", lambda *a, **k: ["x", "y", "z", "w"])
+  monkeypatch.setattr(campaign, "SURVIVORS_PATH", tmp_path / "survivors.json")
+  state = tmp_path / "campaign-state.json"
+  monkeypatch.setattr(campaign, "STATE_PATH", state)
+  (tmp_path / "survivors.json").write_text(json.dumps({"survivors": ["x", "y", "z", "w"]}))
+  state.write_text(json.dumps({"stage": "confirm", "done_suites": ["paper-e1-quality-runtime"]}))
+
+  campaign.run_campaign(_fake_args(tmp_path))
+  assert "paper-a-screening" not in calls
+  assert "paper-e1-quality-runtime" not in calls
+  assert calls[0] == "paper-e2-scalability"
+
+
+def test_campaign_does_not_advance_state_on_interrupted_suite(tmp_path, monkeypatch, capsys):
+  calls = []
+
+  def fake_run_suite(suite, args, state):
+    calls.append(suite)
+    return suite != "paper-e2-scalability"  # interrupted mid-run
+
+  monkeypatch.setattr(campaign, "_run_suite", fake_run_suite)
+  monkeypatch.setattr(campaign, "select_survivors", lambda *a, **k: ["x", "y", "z", "w"])
+  monkeypatch.setattr(campaign, "SURVIVORS_PATH", tmp_path / "survivors.json")
+  state = tmp_path / "campaign-state.json"
+  monkeypatch.setattr(campaign, "STATE_PATH", state)
+  (tmp_path / "survivors.json").write_text(json.dumps({"survivors": ["x", "y", "z", "w"]}))
+  state.write_text(json.dumps({"stage": "confirm", "done_suites": ["paper-e1-quality-runtime"]}))
+
+  campaign.run_campaign(_fake_args(tmp_path))
+
+  assert calls == ["paper-e2-scalability"]  # stopped, no later suite ran
+  saved = json.loads(state.read_text())
+  assert saved["stage"] == "confirm"
+  assert "paper-e2-scalability" not in saved["done_suites"]
+  assert "interrupted" in capsys.readouterr().out
diff --git a/tests/test_remote_experiments_cli.py b/tests/test_remote_experiments_cli.py
new file mode 100644
index 0000000..2973ce2
--- /dev/null
+++ b/tests/test_remote_experiments_cli.py
@@ -0,0 +1,175 @@
+import json
+from dataclasses import replace
+
+import pytest
+from ray_dispatcher import JobHandle, JobStatus
+
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.cli import build_parser, cmd_define, cmd_materialize, cmd_run
+from remote_experiments.definitions.paper import build_e0
+from remote_experiments.instances import instance_id, materialize_batch
+from remote_experiments.manifest import Manifest
+
+
+def test_define_accepts_registered_suite_name():
+  parser = build_parser()
+  args = parser.parse_args(["define", "smoke", "-o", "/tmp/x.json"])
+  assert args.suite == "smoke"
+
+
+def test_define_rejects_unregistered_suite_name():
+  parser = build_parser()
+  with pytest.raises(SystemExit):
+    parser.parse_args(["define", "does-not-exist", "-o", "/tmp/x.json"])
+
+
+def test_cmd_define_writes_batch_file(tmp_path):
+  out_path = tmp_path / "out" / "batch.json"
+  args = build_parser().parse_args(["define", "smoke", "-o", str(out_path)])
+  cmd_define(args)
+  loaded = Batch.load(out_path)
+  assert loaded.suite == "smoke"
+  assert len(loaded.experiments) == 22  # 2 seeds x 11 algorithms
+
+
+def test_cmd_define_output_is_valid_json(tmp_path):
+  out_path = tmp_path / "batch.json"
+  cmd_define(build_parser().parse_args(["define", "smoke", "-o", str(out_path)]))
+  raw = json.loads(out_path.read_text())
+  assert raw["suite"] == "smoke"
+
+
+def test_run_subcommand_parses_required_arguments():
+  parser = build_parser()
+  args = parser.parse_args(["run", "batches/foo.json", "--inventory", "inv.yaml"])
+  assert args.batch_file == "batches/foo.json"
+  assert args.inventory == "inv.yaml"
+  assert args.results_dir == "./results"
+  assert args.instances == "remote_experiments/instances"
+
+
+def test_materialize_subcommand_parses_output_root():
+  args = build_parser().parse_args([
+    "materialize", "batches/foo.json", "-o", "/tmp/instances",
+  ])
+  assert args.batch_file == "batches/foo.json"
+  assert args.output == "/tmp/instances"
+
+
+def test_cmd_materialize_writes_suite_instances(tmp_path):
+  experiment = build_e0(seeds=(42,), algorithms=("centralized",))[0]
+  batch_path = tmp_path / "batch.json"
+  Batch(suite=experiment.suite, experiments=(experiment,)).save(batch_path)
+  output_root = tmp_path / "instances"
+
+  args = build_parser().parse_args([
+    "materialize", str(batch_path), "-o", str(output_root),
+  ])
+  cmd_materialize(args)
+
+  assert (
+    output_root / experiment.suite / "data" / instance_id(experiment)
+    / "metadata.json"
+  ).exists()
+
+
+class _FakeDispatcher:
+  """Context-manager FakeDispatcher matching ray_dispatcher.Dispatcher's duck type.
+
+  Adapted from tests/test_remote_experiments_runner.py's FakeDispatcher — same
+  submit/status/cancel/running_hosts contract, plus __enter__/__exit__ since
+  cmd_run uses `with Dispatcher(...) as dispatcher:`.
+  """
+
+  def __init__(self, *_args, **_kwargs):
+    self._sequences = {"e1": [JobStatus.RUNNING, JobStatus.SUCCEEDED]}
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, *exc_info):
+    return False
+
+  def submit(self, jobs, *, batch_id=None):
+    return [JobHandle(batch_id="b1", job_id=j.id, token=j.id) for j in jobs]
+
+  def status(self, handle):
+    seq = self._sequences[handle.job_id]
+    return seq.pop(0) if len(seq) > 1 else seq[0]
+
+  def cancel(self, handle):
+    pass
+
+  def running_hosts(self):
+    return {"e1": "10.0.0.10"}
+
+
+def _write_smoke_batch(tmp_path):
+  """Save a single-experiment batch (id 'e1') and materialize its instances."""
+  source = build_e0(seeds=(42,), algorithms=("centralized",))[0]
+  config = dict(source.config, base_solution_folder="solutions/e1")
+  experiment = replace(source, id="e1", config=config)
+  batch = Batch(suite=source.suite, experiments=(experiment,))
+  batch_path = tmp_path / "b.json"
+  batch.save(batch_path)
+  materialize_batch(batch, tmp_path / "instances")
+  return batch_path
+
+
+def _write_inventory(tmp_path):
+  inventory_path = tmp_path / "inventory.yaml"
+  inventory_path.write_text("hosts:\n  - host: 10.0.0.10\n    user: ubuntu\n    slots: 1\n")
+  return inventory_path
+
+
+def test_cmd_run_wires_dispatcher_into_manifest(tmp_path, monkeypatch):
+  batch_path = _write_smoke_batch(tmp_path)
+  inventory_path = _write_inventory(tmp_path)
+
+  monkeypatch.setattr("remote_experiments.cli.Dispatcher", _FakeDispatcher)
+  monkeypatch.setattr("builtins.input", lambda prompt: "all")
+
+  args = build_parser().parse_args([
+    "run", str(batch_path), "--inventory", str(inventory_path),
+    "--instances", str(tmp_path / "instances"),
+  ])
+  cmd_run(args)
+
+  manifest = Manifest(batch_path.with_suffix(".manifest.json"))
+  assert manifest.status("e1") == "succeeded"
+  assert manifest.host("e1") == "10.0.0.10"
+
+
+def test_cmd_run_yes_skips_prompt(tmp_path, monkeypatch):
+  batch = _write_smoke_batch(tmp_path)
+  monkeypatch.setattr("remote_experiments.cli.Dispatcher", _FakeDispatcher)
+  monkeypatch.setattr(
+    "builtins.input",
+    lambda prompt: (_ for _ in ()).throw(AssertionError("prompt must not be called")),
+  )
+  args = build_parser().parse_args([
+    "run", str(batch), "--inventory", str(_write_inventory(tmp_path)), "--yes",
+    "--instances", str(tmp_path / "instances"),
+  ])
+  cmd_run(args)  # must not raise
+
+
+def test_cmd_run_reports_terminal_failures(tmp_path, monkeypatch, capsys):
+  class _FailedDispatcher(_FakeDispatcher):
+    def __init__(self, *_args, **_kwargs):
+      self._sequences = {"e1": [JobStatus.FAILED]}
+
+  batch_path = _write_smoke_batch(tmp_path)
+  inventory_path = _write_inventory(tmp_path)
+
+  monkeypatch.setattr("remote_experiments.cli.Dispatcher", _FailedDispatcher)
+  monkeypatch.setattr("builtins.input", lambda prompt: "all")
+  args = build_parser().parse_args([
+    "run", str(batch_path), "--inventory", str(inventory_path),
+    "--instances", str(tmp_path / "instances"),
+  ])
+  cmd_run(args)
+
+  output = capsys.readouterr().out
+  assert "batch finished with 1 unsuccessful experiment" in output
+  assert "batch complete" not in output
diff --git a/tests/test_remote_experiments_dependencies.py b/tests/test_remote_experiments_dependencies.py
new file mode 100644
index 0000000..66d217d
--- /dev/null
+++ b/tests/test_remote_experiments_dependencies.py
@@ -0,0 +1,12 @@
+from pathlib import Path
+
+import tomli
+
+
+def test_ray_dispatcher_source_is_remote_resolvable():
+  config = tomli.loads(Path("pyproject.toml").read_text())
+  source = config["tool"]["uv"]["sources"]["ray-dispatcher"]
+  assert source == {
+    "git": "https://github.com/miciav/ray-dispatcher.git",
+    "tag": "v0.1.1",
+  }
diff --git a/tests/test_remote_experiments_instances.py b/tests/test_remote_experiments_instances.py
new file mode 100644
index 0000000..a0da000
--- /dev/null
+++ b/tests/test_remote_experiments_instances.py
@@ -0,0 +1,91 @@
+import copy
+import json
+from dataclasses import replace
+
+import pytest
+
+from remote_experiments.batch import Batch
+from remote_experiments.definitions.paper import build_e0
+from remote_experiments.instances import (
+  instance_id,
+  load_materialized_instance,
+  materialize_batch,
+  validate_instance,
+)
+
+
+def _experiments():
+  return build_e0(
+    seeds=(42,), algorithms=("centralized", "hierarchical"),
+  )[:2]
+
+
+def test_instance_identity_ignores_algorithm_configuration():
+  centralized, hierarchical = _experiments()
+  assert instance_id(centralized) == instance_id(hierarchical)
+
+
+def test_instance_identity_ignores_algorithm_seed():
+  experiment = _experiments()[0]
+  config = copy.deepcopy(experiment.config)
+  config["seed"] = 999
+  changed = replace(experiment, seed=999, config=config)
+  assert instance_id(experiment) == instance_id(changed)
+
+
+def test_instance_identity_changes_with_generation_inputs():
+  experiment = _experiments()[0]
+  changed = copy.deepcopy(experiment)
+  changed.config["limits"]["memory_capacity"] = {"min": 24, "max": 24}
+  assert instance_id(experiment) != instance_id(changed)
+
+
+def test_materialize_batch_deduplicates_and_writes_complete_instance(tmp_path):
+  experiments = _experiments()
+  suite_path = materialize_batch(
+    Batch(suite="smoke", experiments=tuple(experiments)), tmp_path,
+  )
+
+  data_dirs = list((suite_path / "data").iterdir())
+  assert len(data_dirs) == 1
+  assert {path.name for path in data_dirs[0].iterdir()} == {
+    "base_instance_data.json",
+    "load_limits.json",
+    "input_requests_traces.json",
+    "graph.json",
+    "metadata.json",
+  }
+  manifest = json.loads((suite_path / "manifest.json").read_text())
+  assert manifest["experiments"] == {
+    experiment.id: instance_id(experiment) for experiment in experiments
+  }
+  assert (suite_path / "README.md").exists()
+
+
+def test_materialized_instance_round_trips_load_and_graph(tmp_path):
+  experiment = _experiments()[0]
+  suite_path = materialize_batch(
+    Batch(suite="smoke", experiments=(experiment,)), tmp_path,
+  )
+  instance_path = suite_path / "data" / instance_id(experiment)
+
+  base_data, traces, agents, graph = load_materialized_instance(instance_path)
+
+  assert base_data[None]["Nn"][None] == 10
+  assert len(traces[0][0]) == experiment.config["max_steps"]
+  assert list(agents) == list(range(10))
+  assert graph.number_of_nodes() == 10
+  assert all("network_latency" in attrs for _, _, attrs in graph.edges(data=True))
+
+
+def test_validate_instance_rejects_checksum_mismatch(tmp_path):
+  experiment = _experiments()[0]
+  suite_path = materialize_batch(
+    Batch(suite="smoke", experiments=(experiment,)), tmp_path,
+  )
+  instance_path = suite_path / "data" / instance_id(experiment)
+  graph_path = instance_path / "graph.json"
+  graph_path.write_text(graph_path.read_text() + "\n")
+
+  with pytest.raises(ValueError, match="checksum mismatch.*graph.json"):
+    validate_instance(instance_path)
diff --git a/tests/test_remote_experiments_jobs.py b/tests/test_remote_experiments_jobs.py
new file mode 100644
index 0000000..ce29efc
--- /dev/null
+++ b/tests/test_remote_experiments_jobs.py
@@ -0,0 +1,107 @@
+import json
+
+import pytest
+
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.definitions.paper import build_e0
+from remote_experiments.instances import instance_id, materialize_batch
+from remote_experiments.jobs import SCRIPT_BY_ALGORITHM, experiment_to_job
+
+
+def _experiment(algorithm="centralized"):
+  return Experiment(
+    id="e1", suite="smoke", algorithm=algorithm, seed=1,
+    graph_params={}, load_params={}, config={"seed": 1, "base_solution_folder": "solutions/e1"},
+  )
+
+
+def test_all_fifteen_algorithms_are_mapped():
+  expected = {
+    "centralized", "faas-macro", "faas-macro-v0", "faas-madea", "hierarchical",
+    "hierarchical-madea",
+    "faas-diffuse", "faas-powd", "faas-br-s", "faas-br-r", "faas-br-o",
+    "faas-pg-s", "faas-pg-r", "faas-gcaa", "plasma",
+  }
+  assert set(SCRIPT_BY_ALGORITHM) == expected
+
+
+def test_experiment_to_job_builds_expected_command_for_variant_algorithm(tmp_path):
+  job = experiment_to_job(_experiment("faas-br-r"), tmp_path)
+  assert job.command == (
+    "python", "decentralized_bestresponse.py", "-c", "config.json",
+    "--disable_plotting", "--variant", "r",
+  )
+
+
+def test_experiment_to_job_builds_expected_command_for_plain_algorithm(tmp_path):
+  job = experiment_to_job(_experiment("centralized"), tmp_path)
+  assert job.command == (
+    "python", "run_centralized_model.py", "-c", "config.json", "--disable_plotting",
+  )
+
+
+def test_experiment_to_job_runs_hierarchical_as_module(tmp_path):
+  job = experiment_to_job(_experiment("hierarchical"), tmp_path)
+  assert job.command == (
+    "python", "-m", "hierarchical_auction.runner", "-c", "config.json",
+    "--disable_plotting",
+  )
+
+
+def test_experiment_to_job_runs_hierarchical_madea_as_module(tmp_path):
+  job = experiment_to_job(_experiment("hierarchical-madea"), tmp_path)
+  assert job.command == (
+    "python", "-m", "hierarchical_auction.madea_runner", "-c", "config.json",
+    "--disable_plotting",
+  )
+
+
+def test_experiment_to_job_writes_config_file(tmp_path):
+  job = experiment_to_job(_experiment(), tmp_path)
+  config_path = tmp_path / "e1.json"
+  assert config_path.exists()
+  assert json.loads(config_path.read_text())["seed"] == 1
+  assert job.inputs[0].destination == "config.json"
+
+
+def test_experiment_to_job_output_matches_experiment_id(tmp_path):
+  job = experiment_to_job(_experiment(), tmp_path)
+  assert job.outputs[0].source == "solutions/e1"
+  assert job.outputs[0].destination == "e1"
+
+
+def test_experiment_to_job_unknown_algorithm_raises(tmp_path):
+  with pytest.raises(KeyError):
+    experiment_to_job(_experiment("nope"), tmp_path)
+
+
+def test_experiment_to_job_transfers_and_selects_materialized_instance(tmp_path):
+  experiment = build_e0(seeds=(42,), algorithms=("centralized",))[0]
+  instances_root = tmp_path / "instances"
+  materialize_batch(
+    Batch(suite=experiment.suite, experiments=(experiment,)), instances_root,
+  )
+
+  job = experiment_to_job(experiment, tmp_path / "configs", instances_root)
+
+  config = json.loads((tmp_path / "configs" / f"{experiment.id}.json").read_text())
+  assert config["limits"] == {
+    "instance_type": "materialized",
+    "path": "instance",
+    "load": {"trace_type": "load_existing", "path": "instance"},
+  }
+  assert {item.destination for item in job.inputs} == {
+    "config.json",
+    "instance/base_instance_data.json",
+    "instance/load_limits.json",
+    "instance/input_requests_traces.json",
+    "instance/graph.json",
+    "instance/metadata.json",
+  }
+  assert any(instance_id(experiment) in item.source for item in job.inputs)
+
+
+def test_experiment_to_job_rejects_missing_materialized_instance(tmp_path):
+  experiment = build_e0(seeds=(42,), algorithms=("centralized",))[0]
+  with pytest.raises(ValueError, match="missing instance metadata"):
+    experiment_to_job(experiment, tmp_path / "configs", tmp_path / "instances")
diff --git a/tests/test_remote_experiments_manifest.py b/tests/test_remote_experiments_manifest.py
new file mode 100644
index 0000000..8fa5e38
--- /dev/null
+++ b/tests/test_remote_experiments_manifest.py
@@ -0,0 +1,37 @@
+from remote_experiments.manifest import Manifest
+
+
+def test_unknown_experiment_status_is_never_run(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  assert manifest.status("e1") == "never_run"
+
+
+def test_record_updates_status_and_persists(tmp_path):
+  path = tmp_path / "m.json"
+  manifest = Manifest(path)
+  manifest.record("e1", status="running", host="vm1")
+  assert manifest.status("e1") == "running"
+  assert manifest.host("e1") == "vm1"
+  assert path.exists()
+
+
+def test_record_partial_update_preserves_other_fields(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  manifest.record("e1", status="succeeded", duration_s=12.5)
+  assert manifest.host("e1") == "vm1"
+  assert manifest.duration("e1") == 12.5
+
+
+def test_manifest_reloads_from_disk(tmp_path):
+  path = tmp_path / "m.json"
+  Manifest(path).record("e1", status="succeeded")
+  reloaded = Manifest(path)
+  assert reloaded.status("e1") == "succeeded"
+
+
+def test_pending_ids_excludes_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded")
+  manifest.record("e2", status="failed")
+  assert manifest.pending_ids(["e1", "e2", "e3"]) == ["e2", "e3"]
diff --git a/tests/test_remote_experiments_registry.py b/tests/test_remote_experiments_registry.py
new file mode 100644
index 0000000..38e5871
--- /dev/null
+++ b/tests/test_remote_experiments_registry.py
@@ -0,0 +1,28 @@
+import pytest
+
+from remote_experiments.definitions import get_suite, list_suites, register_suite
+
+
+def test_get_suite_unknown_raises_key_error():
+  with pytest.raises(KeyError):
+    get_suite("does-not-exist")
+
+
+def test_register_suite_makes_it_listable():
+  @register_suite("__test_registry_suite__")
+  def build():
+    return []
+
+  assert "__test_registry_suite__" in list_suites()
+  assert get_suite("__test_registry_suite__") is build
+
+
+def test_register_suite_rejects_duplicate_name():
+  @register_suite("__test_dup__")
+  def build_a():
+    return []
+
+  with pytest.raises(ValueError):
+    @register_suite("__test_dup__")
+    def build_b():
+      return []
diff --git a/tests/test_remote_experiments_results_reader.py b/tests/test_remote_experiments_results_reader.py
new file mode 100644
index 0000000..b12917d
--- /dev/null
+++ b/tests/test_remote_experiments_results_reader.py
@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import pytest
+
+from remote_experiments.results_reader import (
+  read_run_objective, read_run_runtime, run_failed,
+)
+
+
+def _make_run(tmp_path: Path, obj_rows, runtime_rows=None) -> Path:
+  run = tmp_path / "exp-id" / "2026-07-06_00-00-00.000000"
+  run.mkdir(parents=True)
+  if obj_rows is not None:
+    (run / "obj.csv").write_text("Model\n" + "\n".join(str(v) for v in obj_rows) + "\n")
+  if runtime_rows is not None:
+    (run / "runtime.csv").write_text("tot\n" + "\n".join(str(v) for v in runtime_rows) + "\n")
+  return tmp_path / "exp-id"
+
+
+def test_read_objective_is_column_mean(tmp_path):
+  run = _make_run(tmp_path, [10.0, 20.0, 30.0])
+  assert read_run_objective(run) == 20.0
+
+
+def test_read_runtime_is_column_mean(tmp_path):
+  run = _make_run(tmp_path, [1.0], runtime_rows=[0.2, 0.4])
+  assert read_run_runtime(run) == pytest.approx(0.3)
+
+
+def test_missing_obj_is_failure(tmp_path):
+  run = _make_run(tmp_path, None)
+  assert read_run_objective(run) is None
+  assert run_failed(run) is True
+
+
+def test_present_obj_is_not_failure(tmp_path):
+  run = _make_run(tmp_path, [5.0])
+  assert run_failed(run) is False
diff --git a/tests/test_remote_experiments_runner.py b/tests/test_remote_experiments_runner.py
new file mode 100644
index 0000000..4c547c9
--- /dev/null
+++ b/tests/test_remote_experiments_runner.py
@@ -0,0 +1,95 @@
+from ray_dispatcher import Job, JobHandle, JobStatus
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.runner import run_batch
+
+
+class FakeDispatcher:
+  def __init__(self, status_sequences, hosts=None):
+    self._sequences = {k: list(v) for k, v in status_sequences.items()}
+    self._hosts = hosts or {}
+    self.cancelled: list[str] = []
+    self.submitted_batch_id = None
+
+  def submit(self, jobs, *, batch_id=None):
+    self.submitted_batch_id = batch_id
+    return [JobHandle(batch_id="b1", job_id=j.id, token=j.id) for j in jobs]
+
+  def status(self, handle):
+    seq = self._sequences[handle.job_id]
+    return seq.pop(0) if len(seq) > 1 else seq[0]
+
+  def cancel(self, handle):
+    self.cancelled.append(handle.job_id)
+
+  def running_hosts(self):
+    return dict(self._hosts)
+
+
+def _jobs(*ids):
+  return [Job(id=i, command=("echo",)) for i in ids]
+
+
+def test_run_batch_records_succeeded_status_and_host(tmp_path):
+  dispatcher = FakeDispatcher(
+    {"e1": [JobStatus.RUNNING, JobStatus.SUCCEEDED]}, hosts={"e1": "vm1"}
+  )
+  manifest = Manifest(tmp_path / "m.json")
+  ticks = []
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=ticks.append, sleep=lambda s: None
+  )
+  assert completed is True
+  assert manifest.status("e1") == "succeeded"
+  assert manifest.host("e1") == "vm1"
+  assert len(ticks) >= 1
+
+
+def test_run_batch_records_duration_from_submit_to_terminal(tmp_path):
+  times = iter([100.0, 105.0])
+  dispatcher = FakeDispatcher({"e1": [JobStatus.SUCCEEDED]}, hosts={})
+  manifest = Manifest(tmp_path / "m.json")
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None,
+    sleep=lambda s: None, now=lambda: next(times),
+  )
+  assert completed is True
+  assert manifest.duration("e1") == 5.0
+
+
+def test_run_batch_stops_and_cancels_on_keyboard_interrupt(tmp_path):
+  dispatcher = FakeDispatcher({"e1": [JobStatus.RUNNING] * 5}, hosts={"e1": "vm1"})
+  manifest = Manifest(tmp_path / "m.json")
+
+  def _raising_sleep(_seconds):
+    raise KeyboardInterrupt
+
+  completed = run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None, sleep=_raising_sleep
+  )
+  assert completed is False
+  assert "e1" in dispatcher.cancelled
+  assert manifest.status("e1") == "cancelled"
+
+
+def test_run_batch_forwards_batch_id_to_submit(tmp_path):
+  dispatcher = FakeDispatcher({"e1": [JobStatus.SUCCEEDED]})
+  manifest = Manifest(tmp_path / "m.json")
+  run_batch(
+    dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None, sleep=lambda s: None,
+    batch_id="paper-e1-quality-runtime",
+  )
+  assert dispatcher.submitted_batch_id == "paper-e1-quality-runtime"
+
+
+def test_run_batch_preserves_host_after_lease_released_before_terminal_is_observed(tmp_path):
+  hosts_per_tick = [{"e1": "vm1"}, {}]
+
+  class _Dispatcher(FakeDispatcher):
+    def running_hosts(self):
+      return hosts_per_tick.pop(0) if hosts_per_tick else {}
+
+  dispatcher = _Dispatcher({"e1": [JobStatus.RUNNING, JobStatus.SUCCEEDED]})
+  manifest = Manifest(tmp_path / "m.json")
+  run_batch(dispatcher, _jobs("e1"), manifest, on_tick=lambda h: None, sleep=lambda s: None)
+  assert manifest.host("e1") == "vm1"
diff --git a/tests/test_remote_experiments_selection.py b/tests/test_remote_experiments_selection.py
new file mode 100644
index 0000000..0028b61
--- /dev/null
+++ b/tests/test_remote_experiments_selection.py
@@ -0,0 +1,35 @@
+import pytest
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.selection import default_selection, parse_selection
+
+
+def test_parse_selection_all_returns_every_index():
+  assert parse_selection("all", 5) == [0, 1, 2, 3, 4]
+
+
+def test_parse_selection_empty_returns_every_index():
+  assert parse_selection("", 5) == [0, 1, 2, 3, 4]
+
+
+def test_parse_selection_comma_list():
+  assert parse_selection("0,2,4", 5) == [0, 2, 4]
+
+
+def test_parse_selection_range():
+  assert parse_selection("1-3", 5) == [1, 2, 3]
+
+
+def test_parse_selection_mixed():
+  assert parse_selection("0, 2-3", 5) == [0, 2, 3]
+
+
+def test_parse_selection_out_of_range_raises():
+  with pytest.raises(ValueError):
+    parse_selection("9", 5)
+
+
+def test_default_selection_skips_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded")
+  assert default_selection(["e1", "e2", "e3"], manifest) == [1, 2]
diff --git a/tests/test_remote_experiments_smoke_suite.py b/tests/test_remote_experiments_smoke_suite.py
new file mode 100644
index 0000000..80a3fbf
--- /dev/null
+++ b/tests/test_remote_experiments_smoke_suite.py
@@ -0,0 +1,31 @@
+from remote_experiments.definitions import get_suite
+from remote_experiments.definitions.smoke import ALGORITHMS, build
+
+
+def test_smoke_suite_is_registered():
+  assert get_suite("smoke") is build
+
+
+def test_build_produces_one_experiment_per_seed_and_algorithm():
+  experiments = build(seeds=(1, 2), algorithms=("centralized", "faas-macro"))
+  assert len(experiments) == 4
+
+
+def test_build_produces_unique_ids():
+  experiments = build(seeds=(1, 2), algorithms=("centralized", "faas-macro"))
+  ids = [e.id for e in experiments]
+  assert len(ids) == len(set(ids))
+
+
+def test_build_sets_seed_in_config_and_base_solution_folder():
+  experiments = build(seeds=(7,), algorithms=("centralized",))
+  e = experiments[0]
+  assert e.config["seed"] == 7
+  assert e.config["base_solution_folder"] == f"solutions/{e.id}"
+
+
+def test_build_default_covers_all_eleven_algorithms():
+  experiments = build()
+  assert {e.algorithm for e in experiments} == set(ALGORITHMS)
+  assert len(ALGORITHMS) == 11
+  assert {"hierarchical", "hierarchical-madea"} <= set(ALGORITHMS)
diff --git a/tests/test_remote_experiments_stats.py b/tests/test_remote_experiments_stats.py
new file mode 100644
index 0000000..5fa7b1a
--- /dev/null
+++ b/tests/test_remote_experiments_stats.py
@@ -0,0 +1,85 @@
+import pytest
+from ray_dispatcher import Inventory, RemoteHost
+
+from remote_experiments.manifest import Manifest
+from remote_experiments.stats import estimate_eta, summarize
+
+
+def test_estimate_eta_zero_remaining_is_zero():
+  assert estimate_eta(avg_duration_s=10.0, remaining=0, total_slots=2) == 0.0
+
+
+def test_estimate_eta_divides_by_total_slots():
+  assert estimate_eta(avg_duration_s=10.0, remaining=4, total_slots=2) == 20.0
+
+
+def test_estimate_eta_rejects_zero_slots():
+  with pytest.raises(ValueError):
+    estimate_eta(avg_duration_s=10.0, remaining=1, total_slots=0)
+
+
+def _inventory():
+  return Inventory((
+    RemoteHost("vm1", user="ubuntu", slots=2),
+    RemoteHost("vm2", user="ubuntu", slots=1),
+  ))
+
+
+def test_summarize_counts_by_status(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", host="vm1", duration_s=10.0)
+  manifest.record("e2", status="running", host="vm1")
+  manifest.record("e3", status="never_run")
+  stats = summarize(["e1", "e2", "e3"], manifest, _inventory(), {"e2": "vm1"}, elapsed_s=60.0)
+  assert stats.total == 3
+  assert stats.succeeded == 1
+  assert stats.running == 1
+  assert stats.pending == 1
+  assert stats.failed == 0
+
+
+def test_summarize_eta_uses_succeeded_average_duration(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", host="vm1", duration_s=10.0)
+  manifest.record("e2", status="running", host="vm1")
+  stats = summarize(["e1", "e2"], manifest, _inventory(), {"e2": "vm1"}, elapsed_s=60.0)
+  assert stats.eta_s == 10.0 / 3  # avg_duration=10, remaining=1, total_slots=3
+
+
+def test_summarize_eta_none_without_any_succeeded(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  stats = summarize(["e1"], manifest, _inventory(), {"e1": "vm1"}, elapsed_s=60.0)
+  assert stats.eta_s is None
+
+
+def test_summarize_attributes_current_jobs_per_host(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running")
+  manifest.record("e2", status="running")
+  stats = summarize(
+    ["e1", "e2"], manifest, _inventory(), {"e1": "vm1", "e2": "vm2"}, elapsed_s=10.0
+  )
+  vm1 = next(h for h in stats.hosts if h.host == "vm1")
+  vm2 = next(h for h in stats.hosts if h.host == "vm2")
+  assert vm1.current_jobs == ("e1",)
+  assert vm1.slots_busy == 1
+  assert vm2.current_jobs == ("e2",)
+
+
+def test_summarize_throughput_per_minute(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="succeeded", duration_s=5.0)
+  stats = summarize(["e1"], manifest, _inventory(), {}, elapsed_s=30.0)
+  assert stats.throughput_per_min == 2.0  # 1 succeeded in 30s -> 2/min
+
+
+def test_summarize_throughput_excludes_successes_from_before_session(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("old", status="succeeded", duration_s=5.0)
+  manifest.record("new", status="succeeded", duration_s=5.0)
+  stats = summarize(
+    ["old", "new"], manifest, _inventory(), {}, elapsed_s=30.0,
+    succeeded_at_start=1,
+  )
+  assert stats.throughput_per_min == 2.0
diff --git a/tests/test_remote_experiments_survivors.py b/tests/test_remote_experiments_survivors.py
new file mode 100644
index 0000000..3a828de
--- /dev/null
+++ b/tests/test_remote_experiments_survivors.py
@@ -0,0 +1,80 @@
+import pytest
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.survivors import select_survivors, SurvivorSelectionError
+
+
+def _exp(algo, nodes, seed):
+  return Experiment(
+    id=f"paper-a-screening-n{nodes}-f2-planar3-{algo}-s{seed}",
+    suite="paper-a-screening", algorithm=algo, seed=seed,
+    graph_params={"Nn": {"min": nodes, "max": nodes}, "Nf": {"min": 2, "max": 2}},
+    load_params={}, config={},
+  )
+
+
+def _write_result(results_dir, exp, obj, runtime=0.1):
+  run = results_dir / exp.id / "2026-07-06_00-00-00.000000"
+  run.mkdir(parents=True)
+  if obj is not None:
+    (run / "obj.csv").write_text(f"Model\n{obj}\n")
+  (run / "runtime.csv").write_text(f"tot\n{runtime}\n")
+
+
+def test_selects_lowest_relative_deficit(tmp_path):
+  # per instance obj_best is the max; rank candidates by mean deficit to it
+  objs = {  # algo -> obj on the single instance (n50, seed1)
+    "hierarchical-madea": 100.0,  # anchor, best, but not promotable
+    "faas-madea": 99.0, "faas-diffuse": 98.0, "faas-powd": 97.0,
+    "faas-br-o": 96.0, "faas-gcaa": 50.0,
+  }
+  exps = [_exp(a, 50, 1) for a in objs]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  for e in exps:
+    _write_result(tmp_path, e, objs[e.algorithm])
+  survivors = select_survivors(batch, tmp_path, n=4)
+  assert survivors == ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+  assert "hierarchical-madea" not in survivors
+
+
+def test_runtime_breaks_ties(tmp_path):
+  exps = [_exp("faas-madea", 50, 1), _exp("faas-powd", 50, 1),
+          _exp("hierarchical-madea", 50, 1)]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  _write_result(tmp_path, exps[0], 90.0, runtime=0.5)
+  _write_result(tmp_path, exps[1], 90.0, runtime=0.1)   # same obj, faster
+  _write_result(tmp_path, exps[2], 100.0, runtime=0.9)
+  assert select_survivors(batch, tmp_path, n=1) == ["faas-powd"]
+
+
+def _write_real_layout_result(root, suite, exp, obj, runtime=0.1):
+  # real ray_dispatcher output tree: <root>/<suite>/<e.id>/outputs/<e.id>/<ts>/obj.csv
+  run = root / suite / exp.id / "outputs" / exp.id / "2026-07-06_00-00-00.000000"
+  run.mkdir(parents=True)
+  (run / "obj.csv").write_text(f"Model\n{obj}\n")
+  (run / "runtime.csv").write_text(f"tot\n{runtime}\n")
+
+
+def test_selects_survivors_from_real_nested_ray_dispatcher_layout(tmp_path):
+  suite = "paper-a-screening"
+  objs = {
+    "hierarchical-madea": 100.0,
+    "faas-madea": 99.0, "faas-diffuse": 98.0, "faas-powd": 97.0,
+    "faas-br-o": 96.0, "faas-gcaa": 50.0,
+  }
+  exps = [_exp(a, 50, 1) for a in objs]
+  batch = Batch(suite=suite, experiments=tuple(exps))
+  for e in exps:
+    _write_real_layout_result(tmp_path, suite, e, objs[e.algorithm])
+
+  survivors = select_survivors(batch, tmp_path / suite, n=4)
+  assert survivors == ["faas-madea", "faas-diffuse", "faas-powd", "faas-br-o"]
+  assert "hierarchical-madea" not in survivors
+
+
+def test_guard_trips_on_too_many_failures(tmp_path):
+  exps = [_exp("faas-madea", 50, 1), _exp("faas-powd", 50, 1)]
+  batch = Batch(suite="paper-a-screening", experiments=tuple(exps))
+  _write_result(tmp_path, exps[0], 90.0)
+  _write_result(tmp_path, exps[1], None)   # failed
+  with pytest.raises(SurvivorSelectionError):
+    select_survivors(batch, tmp_path, n=1, min_valid_fraction=0.8)
diff --git a/tests/test_remote_experiments_tui.py b/tests/test_remote_experiments_tui.py
new file mode 100644
index 0000000..9c90e12
--- /dev/null
+++ b/tests/test_remote_experiments_tui.py
@@ -0,0 +1,29 @@
+from rich.console import Console
+from ray_dispatcher import Inventory, RemoteHost
+
+from remote_experiments.batch import Batch, Experiment
+from remote_experiments.manifest import Manifest
+from remote_experiments.stats import summarize
+from remote_experiments.tui import render
+
+
+def _batch():
+  return Batch(suite="smoke", experiments=(
+    Experiment(id="e1", suite="smoke", algorithm="centralized", seed=1,
+               graph_params={}, load_params={}, config={}),
+  ))
+
+
+def test_render_includes_experiment_status_and_host(tmp_path):
+  manifest = Manifest(tmp_path / "m.json")
+  manifest.record("e1", status="running", host="vm1")
+  inventory = Inventory((RemoteHost("vm1", user="ubuntu", slots=1),))
+  stats = summarize(["e1"], manifest, inventory, {"e1": "vm1"}, elapsed_s=10.0)
+  layout = render(_batch(), manifest, stats)
+
+  console = Console(record=True, width=120)
+  console.print(layout)
+  output = console.export_text()
+  assert "e1" in output
+  assert "running" in output
+  assert "vm1" in output
diff --git a/tests/test_run_centralized_extended.py b/tests/test_run_centralized_extended.py
new file mode 100644
index 0000000..9efc76a
--- /dev/null
+++ b/tests/test_run_centralized_extended.py
@@ -0,0 +1,304 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from run_centralized_model import (
+  compute_utilization,
+  decode_solution,
+  encode_solution,
+  extract_solution,
+  init_complete_solution,
+  init_empty_solution,
+  join_complete_solution,
+  save_checkpoint,
+  save_solution,
+)
+
+
+def _make_data(Nn=2, Nf=1):
+  return {
+    None: {
+      "Nn": {None: Nn},
+      "Nf": {None: Nf},
+      "demand": {(n + 1, f + 1): 1.0 for n in range(Nn) for f in range(Nf)},
+      "incoming_load": {(n + 1, f + 1): 10.0 for n in range(Nn) for f in range(Nf)},
+      "memory_capacity": {n + 1: 100 for n in range(Nn)},
+      "memory_requirement": {f + 1: 2 for f in range(Nf)},
+      "max_utilization": {f + 1: 1.0 for f in range(Nf)},
+    }
+  }
+
+
+def test_compute_utilization_basic():
+  data = _make_data()
+  solution = {
+    "x": [2.0, 1.0],
+    "y": [0.0, 3.0, 0.0, 0.0],
+    "z": [0.0, 0.0],
+    "r": [1.0, 2.0],
+  }
+  u = compute_utilization(data, solution)
+  assert u.shape == (2, 1)
+  assert u[0, 0] == pytest.approx(2.0)
+  assert u[1, 0] == pytest.approx(2.0)
+
+
+def test_compute_utilization_xi_path():
+  """xi is computed by extract_solution as y transposed: xi[m,n,f] = y[n,m,f].
+  When y is non-zero, xi != 0 so the xi-branch fires."""
+  data = _make_data()
+  solution = {
+    "x": [2.0, 1.0],
+    "y": [0.0, 3.0, 0.0, 0.0],  # y[0,1,0] = 3, so xi[1,0,0] = 3
+    "z": [0.0, 0.0],
+    "r": [1.0, 2.0],
+  }
+  u = compute_utilization(data, solution)
+  assert u.shape == (2, 1)
+  # xi[0,:,0] = [y[0,0,0]=0, y[1,0,0]=0] → sum=0 → u[0,0] = (2+0)/1 = 2.0
+  # xi[1,:,0] = [y[0,1,0]=3, y[1,1,0]=0] → sum=3 → u[1,0] = (1+3)/2 = 2.0
+  assert u[0, 0] == pytest.approx(2.0)
+  assert u[1, 0] == pytest.approx(2.0)
+
+
+def test_compute_utilization_zero_replicas():
+  data = _make_data()
+  solution = {
+    "x": [2.0, 1.0],
+    "y": [0.0, 0.0, 0.0, 0.0],
+    "z": [0.0, 0.0],
+    "r": [0.0, 0.0],
+  }
+  u = compute_utilization(data, solution)
+  assert u[0, 0] == 0.0
+  assert u[1, 0] == 0.0
+
+
+def test_encode_solution_basic():
+  solution = pd.DataFrame({
+    "n0_f0_loc": [3.0],
+    "n0_f0": [1.0],
+    "n1_f0_loc": [4.0],
+    "n1_f0": [0.0],
+  })
+  # Column naming: "tot" suffix triggers xi_exist path in encode_solution
+  detailed = pd.DataFrame({
+    "n0_f0_n1": [2.0],
+    "n1_f0_n0": [1.0],
+  })
+  replicas = pd.DataFrame({"n0_f0": [1.0], "n1_f0": [2.0]})
+
+  x, y, z, r, xi = encode_solution(2, 1, solution, detailed, replicas, t=0)
+
+  assert x[0, 0] == 3.0
+  assert x[1, 0] == 4.0
+  assert y[0, 1, 0] == 2.0
+  assert y[1, 0, 0] == 1.0
+  assert z[0, 0] == 1.0
+  assert z[1, 0] == 0.0
+  assert r[0, 0] == 1.0
+  assert r[1, 0] == 2.0
+  assert xi is None  # no "tot" suffix → xi_exist = False
+
+
+def test_encode_solution_with_accepted():
+  solution = pd.DataFrame({
+    "n0_f0_loc": [1.0],
+    "n0_f0": [0.0],
+    "n1_f0_loc": [2.0],
+    "n1_f0": [0.0],
+  })
+  detailed = pd.DataFrame({
+    "n0_f0_n1_tot": [3.0],
+    "n0_f0_n1_accepted": [2.5],
+    "n1_f0_n0_tot": [4.0],
+    "n1_f0_n0_accepted": [3.5],
+  })
+  replicas = pd.DataFrame({"n0_f0": [1.0], "n1_f0": [2.0]})
+
+  x, y, z, r, xi = encode_solution(2, 1, solution, detailed, replicas, t=0)
+
+  assert xi is not None
+  assert xi.shape == (2, 2, 1)
+  assert xi[0, 1, 0] == 2.5
+  assert xi[1, 0, 0] == 3.5
+
+
+def test_extract_solution_from_solution_dict():
+  data = _make_data()
+  solution = {
+    "x": [3.0, 4.0],
+    "y": [0.0, 2.0, 1.0, 0.0],
+    "z": [0.0, 1.0],
+    "r": [1.0, 2.0],
+    "omega": [2.0, 1.0],
+    "obj": 5.0,
+  }
+  x, y, z, r, xi, omega, rho, obj = extract_solution(data, solution)
+
+  assert x[0, 0] == 3.0
+  assert y[0, 1, 0] == 2.0
+  assert z[1, 0] == 1.0
+  assert r[0, 0] == 1.0
+  assert omega[0, 0] == 2.0
+  assert obj == 5.0
+  assert rho.shape == (2,)
+
+
+def test_extract_solution_from_data_bars():
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 1},
+      "x_bar": {(1, 1): 3.0, (2, 1): 4.0},
+      "y_bar": {(1, 1, 1): 0.0, (1, 2, 1): 2.0, (2, 1, 1): 1.0, (2, 2, 1): 0.0},
+      "z_bar": {(1, 1): 0.0, (2, 1): 1.0},
+      "r_bar": {(1, 1): 1, (2, 1): 2},
+      "omega_bar": {(1, 1): 2.0, (2, 1): 1.0},
+      "memory_capacity": {1: 100, 2: 100},
+      "memory_requirement": {1: 2},
+    }
+  }
+  x, y, z, r, xi, omega, rho, obj = extract_solution(data, {})
+
+  assert x[0, 0] == 3.0
+  assert y[0, 1, 0] == 2.0
+  assert z[1, 0] == 1.0
+  assert r[0, 0] == 1
+  assert omega[0, 0] == 2.0
+  assert np.isnan(obj)
+
+
+def test_extract_solution_with_d_variable():
+  data = _make_data()
+  solution = {"d": [0.0, 2.0, 1.0, 0.0], "r": [1.0, 2.0]}
+  x, y, z, r, xi, omega, rho, obj = extract_solution(data, solution)
+
+  assert y[0, 1, 0] == 2.0
+  assert omega[0, 0] == 2.0
+
+
+def test_extract_solution_with_r_bar():
+  data = _make_data()
+  data[None]["r_bar"] = {(1, 1): 1, (2, 1): 2}
+  solution = {"r": [3.0, 4.0]}
+  x, y, z, r, xi, omega, rho, obj = extract_solution(data, solution)
+
+  assert r[0, 0] == 4
+  assert r[1, 0] == 6
+
+
+def test_decode_solution_merges_all_components():
+  complete = init_complete_solution()
+  x = np.array([[3.0, 0.0], [4.0, 0.0]])
+  y = np.zeros((2, 2, 2))
+  y[0, 1, 0] = 2.0
+  z = np.zeros((2, 2))
+  z[1, 0] = 1.0
+  r = np.array([[1, 1], [2, 2]])
+  xi = np.zeros((2, 2, 2))
+  rho = np.array([10.0, 20.0])
+  U = np.array([[0.5, 0.0], [0.7, 0.0]])
+
+  result = decode_solution(x, y, z, r, xi, rho, U, complete)
+
+  assert "local_processing" in result
+  assert "offloading" in result
+  assert "rejections" in result
+  assert "replicas" in result
+  assert "utilization" in result
+  assert result["residual_capacity"].loc[0, "n0"] == 10.0
+
+
+def test_decode_solution_without_xi_uses_count_offloaded():
+  complete = init_complete_solution()
+  x = np.array([[3.0], [4.0]])
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 2.0
+  z = np.zeros((2, 1))
+  r = np.array([[1], [2]])
+  rho = np.array([10.0, 20.0])
+  U = np.array([[0.5], [0.7]])
+
+  result = decode_solution(x, y, z, r, None, rho, U, complete)
+
+  assert "offloaded_processing" in result
+  assert "detailed_offloaded_processing" in result
+  assert "n0_f0_accepted" in result["offloaded_processing"].columns
+
+
+def test_init_complete_solution_has_all_keys():
+  cs = init_complete_solution()
+  expected = [
+    "local_processing", "offloading", "detailed_offloading",
+    "rejections", "replicas", "utilization",
+    "offloaded_processing", "detailed_offloaded_processing",
+    "residual_capacity",
+  ]
+  for key in expected:
+    assert key in cs
+
+
+def test_init_empty_solution_returns_zero_arrays():
+  x, y, z, r, xi, omega, rho, obj, U = init_empty_solution(2, 3)
+  assert x.shape == (2, 3)
+  assert y.shape == (2, 2, 3)
+  assert z.shape == (2, 3)
+  assert r.shape == (2, 3)
+  assert xi.shape == (2, 2, 3)
+  assert omega.shape == (2, 3)
+  assert rho.shape == (2,)
+  assert obj is None
+  assert U.shape == (2, 3)
+  assert x.sum() == 0.0
+
+
+def test_join_complete_solution_builds_expected_columns():
+  cs = init_complete_solution()
+  # Build up with distinct column names per component to avoid join ambiguity
+  cs["local_processing"] = pd.DataFrame({"n0_f0": [1.0, 2.0]})
+  cs["offloading"] = pd.DataFrame({"n0_f0": [0.5, 0.5]})
+  cs["rejections"] = pd.DataFrame({"n0_f0": [0.0, 0.0]})
+  cs["detailed_offloading"] = pd.DataFrame({"n0_f0_n1": [0.5, 0.5]})
+  cs["detailed_offloaded_processing"] = pd.DataFrame({"n1_f0_n0": [0.5, 0.5]})
+
+  solution, offloaded, detailed = join_complete_solution(cs)
+
+  assert "n0_f0_loc" in solution.columns
+  assert "n0_f0_fwd" in solution.columns
+  assert "n0_f0" in solution.columns
+  assert isinstance(detailed, pd.DataFrame)
+
+
+def test_save_and_load_checkpoint(tmp_path):
+  cs = {
+    "local_processing": pd.DataFrame({"n0_f0": [1.0]}),
+    "replicas": pd.DataFrame({"n0_f0": [2.0]}),
+  }
+
+  save_checkpoint(cs, str(tmp_path), t=0)
+
+  from run_centralized_model import load_checkpoint
+  loaded = load_checkpoint(str(tmp_path), t=0)
+
+  assert loaded["local_processing"].loc[0, "n0_f0"] == 1.0
+  assert loaded["replicas"].loc[0, "n0_f0"] == 2.0
+
+
+def test_save_solution_writes_all_components(tmp_path):
+  solution = pd.DataFrame({"n0_f0_loc": [1.0]})
+  offloaded = pd.DataFrame({"n0_f0_accepted": [0.5]})
+  cs = init_complete_solution()
+  cs["utilization"] = pd.DataFrame({"n0_f0": [0.5]})
+  cs["replicas"] = pd.DataFrame({"n0_f0": [2.0]})
+  cs["residual_capacity"] = pd.DataFrame({"n0": [10.0]})
+  detailed = pd.DataFrame({"n0_f0_n1_tot": [0.0]})
+
+  save_solution(solution, offloaded, cs, detailed, "Test", str(tmp_path))
+
+  assert (tmp_path / "Test_solution.csv").exists()
+  assert (tmp_path / "Test_offloaded.csv").exists()
+  assert (tmp_path / "Test_utilization.csv").exists()
+  assert (tmp_path / "Test_replicas.csv").exists()
+  assert (tmp_path / "Test_detailed_fwd_solution.csv").exists()
+  assert (tmp_path / "Test_residual_capacity.csv").exists()
diff --git a/tests/test_run_faasmacro_helpers.py b/tests/test_run_faasmacro_helpers.py
new file mode 100644
index 0000000..097ce28
--- /dev/null
+++ b/tests/test_run_faasmacro_helpers.py
@@ -0,0 +1,175 @@
+from collections import deque
+
+import numpy as np
+import pytest
+
+from run_faasmacro import (
+  check_stopping_criteria,
+  compute_deviation,
+  merge_agents_solutions,
+  prepare_master_data,
+  update_neighborhood,
+  update_prices,
+)
+
+
+def _base_data():
+  return {
+    None: {
+      "Nn": {None: 2},
+      "Nf": {None: 2},
+      "memory_capacity": {1: 10, 2: 12},
+      "memory_requirement": {1: 2, 2: 3},
+      "demand": {(1, 1): 2.0, (2, 1): 2.0, (1, 2): 4.0, (2, 2): 4.0},
+      "max_utilization": {1: 0.5, 2: 0.5},
+    }
+  }
+
+
+def test_check_stopping_criteria_max_iteration():
+  stop, why, new_psi = check_stopping_criteria(
+    it = 4,
+    max_iterations = 5,
+    sp_omega = np.array([[0.0]]),
+    rmp_omega = np.array([[1.0]]),
+    pi_queue = deque(maxlen = 2),
+    dev_queue = deque([np.array([1.0])], maxlen = 2),
+    sw_queue = deque(maxlen = 2),
+    current_sw_queue = deque(maxlen = 2),
+    odev_queue = deque(maxlen = 2),
+    psi = 2.0,
+    tolerance = 1e-3,
+    total_runtime = 1.0,
+    time_limit = 100.0,
+  )
+  assert stop is True
+  assert why == "max iterations reached"
+  assert new_psi == 2.0
+
+
+def test_check_stopping_criteria_discount_psi_when_stagnating():
+  current_sw_queue = deque([1.0, 1.1], maxlen = 2)
+  stop, why, new_psi = check_stopping_criteria(
+    it = 0,
+    max_iterations = 10,
+    sp_omega = np.array([[1.0, 2.0]]),
+    rmp_omega = np.array([[0.0, 0.0]]),
+    pi_queue = deque([{1: 0.1, 2: 0.2}], maxlen = 3),
+    dev_queue = deque([np.array([1.0, 1.0])], maxlen = 3),
+    sw_queue = deque([1.0], maxlen = 3),
+    current_sw_queue = current_sw_queue,
+    odev_queue = deque([1.0], maxlen = 3),
+    psi = 2.0,
+    tolerance = 1e-3,
+    total_runtime = 1.0,
+    time_limit = 100.0,
+  )
+  assert stop is False
+  assert why is None
+  assert new_psi == 1.0
+  assert len(current_sw_queue) == 0
+
+
+def test_compute_deviation_and_detailed_deviation():
+  rmp_data = _base_data()
+  sp_x = np.array([[1.0, 0.0], [1.0, 0.0]])
+  sp_omega = np.array([[0.2, 0.1], [0.3, 0.2]])
+  rmp_r = np.array([[4.0, 2.0], [4.0, 2.0]])
+  rmp_omega = np.array([[0.1, 0.0], [0.2, 0.1]])
+
+  dev, nf_thr, detailed = compute_deviation(rmp_data, sp_x, sp_omega, rmp_r, rmp_omega)
+  assert dev.shape == (2,)
+  assert nf_thr == [0.0, 0.5]
+  assert detailed.shape == (2, 2)
+  assert detailed[0, 0] == pytest.approx(0.1)
+
+
+def test_update_neighborhood_removes_incoming_edges_to_saturated_nodes():
+  neighborhood = {
+    (1, 1): 0, (1, 2): 1,
+    (2, 1): 1, (2, 2): 0,
+  }
+  out = update_neighborhood(
+    neighborhood,
+    sp_rho = np.array([0.0, 4.0]),
+    sp_omega = np.zeros((2, 1)),
+  )
+  assert out[(2, 1)] == 0
+  assert out[(1, 2)] == 1
+
+
+def test_update_prices_updates_functional_and_detailed_components():
+  old_pi = {1: 1.0, 2: 2.0}
+  old_detailed_pi = np.array([[1.0, 1.0], [0.5, 0.5]])
+  dev = np.array([0.0, 2.0])
+  detailed_dev = np.array([[0.0, 1.0], [0.0, -1.0]])
+
+  pi, detailed = update_prices(
+    dev = dev,
+    detailed_dev = detailed_dev,
+    psi = 1.0,
+    delta_w = 2.0,
+    old_pi = old_pi,
+    old_detailed_pi = old_detailed_pi,
+  )
+  assert pi[1] == 1.0
+  assert pi[2] == pytest.approx(3.0)
+  assert detailed[0, 1] == pytest.approx(2.0)
+  assert detailed[1, 1] == pytest.approx(0.0)
+
+
+def test_prepare_master_data_clips_negative_values():
+  base_data = _base_data()
+  sp_solution = (
+    np.array([[1.0, -1.0], [2.0, -2.0]]),
+    np.array([
+      [[0.0, -1.0], [1.0, 0.0]],
+      [[-3.0, 0.0], [0.0, 2.0]],
+    ]),
+    np.array([[0.0, -4.0], [1.0, -1.0]]),
+    np.array([[0.2, -0.3], [0.4, 0.5]]),
+    np.array([[1.0, -2.0], [2.0, -3.0]]),
+    np.array([1.0, 2.0]),
+  )
+  out = prepare_master_data(base_data, sp_solution)
+  assert out[None]["x_bar"][(1, 2)] == 0
+  assert out[None]["d_bar"][(2, 1, 1)] == 0
+  assert out[None]["z_bar"][(1, 2)] == 0
+  assert out[None]["r_bar"][(2, 2)] == 0
+  assert out[None]["omega_bar"][(1, 2)] == 0
+
+
+def test_merge_agents_solutions_aggregates_obj_tc_runtime():
+  data = _base_data()
+  agents_sol = {
+    0: {
+      "x": [1.0, 2.0],
+      "y": [0.0, 0.0, 0.0, 0.0],
+      "z": [0.0, 1.0],
+      "omega": [0.0, 0.0],
+      "r": [1.0, 1.0],
+      "obj": 5.0,
+      "termination_condition": "ok0",
+      "runtime": 2.0,
+    },
+    1: {
+      "x": [3.0, 4.0],
+      "y": [0.0, 0.0, 0.0, 0.0],
+      "z": [0.0, 2.0],
+      "omega": [0.0, 0.0],
+      "r": [2.0, 1.0],
+      "obj": 7.0,
+      "termination_condition": "ok1",
+      "runtime": 4.0,
+    },
+  }
+  x, y, z, omega, r, rho, obj, tc, runtime = merge_agents_solutions(data, agents_sol)
+  assert x.shape == (2, 2)
+  assert y.shape == (2, 2, 2)
+  assert z.shape == (2, 2)
+  assert omega.shape == (2, 2)
+  assert r.shape == (2, 2)
+  assert rho.shape == (2,)
+  assert obj["tot"] == pytest.approx(12.0)
+  assert tc["tot"] == "ok0-ok1"
+  assert runtime["tot"] == pytest.approx(3.0)
diff --git a/tests/test_run_faasmacro_v0_flag.py b/tests/test_run_faasmacro_v0_flag.py
new file mode 100644
index 0000000..88f537a
--- /dev/null
+++ b/tests/test_run_faasmacro_v0_flag.py
@@ -0,0 +1,13 @@
+import run_faasmacro
+
+
+def test_parse_arguments_default_v0_is_false(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["run_faasmacro.py"])
+  args = run_faasmacro.parse_arguments()
+  assert args.v0 is False
+
+
+def test_parse_arguments_accepts_v0_flag(monkeypatch):
+  monkeypatch.setattr("sys.argv", ["run_faasmacro.py", "--v0"])
+  args = run_faasmacro.parse_arguments()
+  assert args.v0 is True
diff --git a/tests/test_run_helpers.py b/tests/test_run_helpers.py
new file mode 100644
index 0000000..b0915c6
--- /dev/null
+++ b/tests/test_run_helpers.py
@@ -0,0 +1,228 @@
+from pathlib import Path
+import json
+
+import numpy as np
+import pandas as pd
+import pytest
+
+import run
+from remote_experiments.batch import Batch
+from remote_experiments.definitions.paper import build_e0
+from remote_experiments.instances import instance_id, materialize_batch
+from run import (
+  generate_experiments_list,
+  load_obj_value,
+  load_termination_condition,
+  merge_sol_dict,
+)
+from run_centralized_model import (
+  compute_residual_capacity,
+  count_offloaded_processing,
+  get_current_load,
+  init_problem,
+  update_1d_variables,
+  update_2d_variables,
+  update_3d_variables,
+)
+
+
+def test_generate_experiments_list_with_values():
+  out = generate_experiments_list({"values": [2, 4]}, seed = 123, n_experiments = 3)
+  assert len(out) == 6
+  assert out[0] == [2, 123]
+  assert out[1] == [4, 123]
+
+
+def test_generate_experiments_list_with_range_step():
+  out = generate_experiments_list(
+    {"min": 1, "max": 5, "step": 2},
+    seed = 99,
+    n_experiments = 1,
+  )
+  assert out == [[1, 99], [3, 99], [5, 99]]
+
+
+def test_load_obj_value_absent_and_present(tmp_path: Path):
+  assert load_obj_value(str(tmp_path)).empty
+
+  df = pd.DataFrame({
+    "Unnamed: 0": [0, 1],
+    "SP/coord": [10.0, 11.0],
+    "x": [1, 2],
+  })
+  df.to_csv(tmp_path / "obj.csv", index = False)
+  out = load_obj_value(str(tmp_path))
+  assert "Unnamed: 0" not in out.columns
+  assert "SP/coord" not in out.columns
+  assert "FaaS-MACrO" in out.columns
+
+
+def test_load_termination_condition_non_centralized(tmp_path: Path):
+  raw = pd.DataFrame({
+    "Unnamed: 0": [0, 1, 2],
+    "0": [
+      "dev below tol (it: 5; obj. deviation: 0.01)",
+      "steady (it: 7; obj. deviation: 0.0; best it: 6)",
+      "reached time limit: 12.0 >= 10.0 (it: 8; obj. deviation: None; best it: 7; total runtime: 22.5)",
+    ],
+  })
+  raw.to_csv(tmp_path / "termination_condition.csv", index = False)
+
+  out = load_termination_condition(str(tmp_path), centralized = False)
+  assert list(out["time"]) == [0, 1, 2]
+  assert list(out["iteration"]) == [5, 7, 8]
+  assert out.loc[2, "criterion"] == "reached time limit (10.0)"
+  assert out.loc[2, "deviation"] == "None"
+  assert out.loc[1, "best_iteration"] == 6
+
+
+def test_load_termination_condition_centralized(tmp_path: Path):
+  pd.DataFrame({"0": ["ok", "ok"]}).to_csv(
+    tmp_path / "termination_condition.csv",
+    index = False,
+  )
+  out = load_termination_condition(str(tmp_path), centralized = True)
+  assert list(out["time"]) == [0, 1]
+
+
+def test_merge_sol_dict_merges_total_and_time_rows():
+  a = {
+    "tot": pd.DataFrame({"tot": [10]}, index = ["metric"]),
+    "it 0": pd.DataFrame({"it 0": [1]}, index = ["metric"]),
+  }
+  b = {
+    "tot": pd.DataFrame({"tot": [20]}, index = ["metric"]),
+    "it 0": pd.DataFrame({"it 0": [2]}, index = ["metric"]),
+  }
+  merged = merge_sol_dict([a, b], ["A", "B"])
+  assert "tot_A" in merged.columns
+  assert "tot" in merged.columns
+  assert "it 0_A" in merged.columns
+  assert "it 0" in merged.columns
+  assert set(merged["time"].astype(str)) == {"tot", "0"}
+
+
+def test_compute_residual_capacity_with_and_without_indices():
+  data = {
+    None: {
+      "Nn": {None: 2},
+      "memory_capacity": {1: 10, 2: 20},
+      "memory_requirement": {1: 2, 2: 3},
+    }
+  }
+  r = np.array([[1, 2], [3, 1]])
+  rho = compute_residual_capacity(data, r)
+  assert np.allclose(rho, np.array([2, 11]))
+
+  sub_data = {**data, "indices": [1]}
+  rho_sub = compute_residual_capacity(sub_data, np.array([[3, 1]]))
+  assert np.allclose(rho_sub, np.array([11, 0]))
+
+
+def test_update_variable_helpers_and_count_offloaded():
+  res_1d = update_1d_variables(np.array([1.0, 2.0]), pd.DataFrame())
+  assert list(res_1d.columns) == ["n0", "n1"]
+
+  res_2d = update_2d_variables(np.array([[1.0, 2.0], [3.0, 4.0]]), pd.DataFrame())
+  assert list(res_2d.columns) == ["n0_f0", "n0_f1", "n1_f0", "n1_f1"]
+
+  y = np.zeros((2, 2, 1))
+  y[0, 1, 0] = 5
+  y[1, 0, 0] = 6
+  offloading, detailed = update_3d_variables(y, pd.DataFrame(), pd.DataFrame())
+  assert offloading.loc[0, "n0_f0"] == 5
+  assert offloading.loc[0, "n1_f0"] == 6
+  assert detailed.loc[0, "n0_f0_n1"] == 5
+  assert detailed.loc[0, "n1_f0_n0"] == 6
+
+  offloaded, detailed_offloaded = count_offloaded_processing(detailed, Nn = 2, Nf = 1)
+  assert detailed_offloaded.empty
+  assert offloaded.loc[0, "n0_f0_accepted"] == 6
+  assert offloaded.loc[0, "n1_f0_accepted"] == 5
+
+
+def test_get_current_load_maps_agents_and_functions():
+  input_requests = {
+    0: {0: np.array([1.0, 2.0]), 1: np.array([3.0, 4.0])},
+    1: {0: np.array([5.0, 6.0]), 1: np.array([7.0, 8.0])},
+  }
+  out = get_current_load(input_requests, agents = [0, 1], t = 1)
+  assert out[(1, 1)] == 2.0
+  assert out[(2, 1)] == 4.0
+  assert out[(1, 2)] == 6.0
+  assert out[(2, 2)] == 8.0
+
+
+def test_init_problem_loads_exact_materialized_instance(tmp_path: Path):
+  experiment = build_e0(seeds=(42,), algorithms=("centralized",))[0]
+  instances_root = tmp_path / "instances"
+  suite_path = materialize_batch(
+    Batch(suite=experiment.suite, experiments=(experiment,)), instances_root,
+  )
+  instance_path = suite_path / "data" / instance_id(experiment)
+  solution_path = tmp_path / "solution"
+  solution_path.mkdir()
+  limits = {
+    "instance_type": "materialized",
+    "path": str(instance_path),
+    "load": {"trace_type": "load_existing", "path": str(instance_path)},
+  }
+
+  base_data, traces, agents, graph = init_problem(
+    limits, "load_existing", experiment.config["max_steps"], 999, str(solution_path),
+  )
+
+  assert base_data[None]["Nn"][None] == 10
+  assert len(traces[0][0]) == experiment.config["max_steps"]
+  assert list(agents) == list(range(10))
+  stored_graph = json.loads((instance_path / "graph.json").read_text())
+  assert graph.number_of_edges() == len(stored_graph["edges"])
+  assert all("edge_length" in attrs for _, _, attrs in graph.edges(data=True))
+  for filename in (
+      "base_instance_data.json", "load_limits.json", "input_requests_traces.json",
+      "graph.json", "metadata.json",
+    ):
+    assert (solution_path / filename).read_bytes() == (instance_path / filename).read_bytes()
+
+
+def test_run_updates_existing_method_slot_when_resuming(tmp_path: Path, monkeypatch):
+  base_folder = tmp_path / "runs"
+  base_folder.mkdir()
+  (base_folder / "experiments.json").write_text(
+    """
+{
+  "experiments_list": [[2, 123]],
+  "centralized": ["centralized_existing"],
+  "faas-macro": [null],
+  "faas-macro-v0": [],
+  "faas-madea": [],
+  "hierarchical": []
+}
+""".strip(),
+  )
+  config = {
+    "seed": 123,
+    "verbose": 0,
+    "base_solution_folder": str(base_folder),
+    "limits": {
+      "Nn": {"values": [2]},
+      "neighborhood": {},
+    },
+  }
+
+  monkeypatch.setattr(run, "run_iterations", lambda *args, **kwargs: "macro_new")
+  monkeypatch.setattr(run, "results_postprocessing", lambda *args, **kwargs: None)
+
+  run.run(
+    config,
+    str(base_folder),
+    n_experiments = 1,
+    methods = ["faas-macro"],
+    fix_r = False,
+    sp_parallelism = 0,
+    enable_plotting = False,
+    loop_over = "Nn",
+  )
+
+  out = json.loads((base_folder / "experiments.json").read_text())
+  assert out["faas-macro"] == ["macro_new"]
diff --git a/tests/test_tight_model.py b/tests/test_tight_model.py
new file mode 100644
index 0000000..978455f
--- /dev/null
+++ b/tests/test_tight_model.py
@@ -0,0 +1,60 @@
+"""TightLoadManagementModel matches LoadManagementModel on random instances."""
+import numpy as np
+import pytest
+
+from generators.generate_data import generate_data, update_data
+from generators.generate_load import generate_load_traces
+from models.model import LoadManagementModel, TightLoadManagementModel
+from utils.centralized import get_current_load
+
+pytest.importorskip("gurobipy")
+
+LIMITS = {
+  "Nn": {"min": 15, "max": 15},
+  "Nf": {"min": 2, "max": 2},
+  "neighborhood": {"p": 0.3},
+  "demand": {"values": [1.0, 1.2]},
+  "memory_capacity": {"min": 12, "max": 12},
+  "memory_requirement": {"values": [2, 3]},
+  "max_utilization": {"min": 0.65, "max": 0.75},
+  "load": {
+    "trace_type": "sinusoidal",
+    "min": {"min": 5, "max": 10},
+    "max": {"min": 50, "max": 100},
+  },
+  "weights": {
+    "alpha": {"min": 1.0, "max": 1.5},
+    "beta_multiplier": {"min": 1.5, "max": 2.5},
+    "gamma": {"min": 0.05, "max": 0.15},
+    "delta_multiplier": {"min": 0.1, "max": 0.2},
+  },
+}
+SOLVER_OPTIONS = {"MIPGap": 1e-6, "TimeLimit": 120, "OutputFlag": 0}
+
+
+def _solve(model_cls, data):
+  M = model_cls()
+  instance = M.generate_instance(data)
+  solution = M.solve(instance, SOLVER_OPTIONS, "gurobi")
+  assert solution["solution_exists"], solution["termination_condition"]
+  return solution
+
+
+@pytest.mark.parametrize("seed", [42, 7])
+def test_tight_model_matches_original(seed):
+  rng = np.random.default_rng(seed=seed)
+  base_data, load_limits, _ = generate_data("random", rng=rng, limits=LIMITS)
+  traces = generate_load_traces(
+    load_limits, 3, seed, "sinusoidal", None, enable_plotting=False
+  )
+  load = get_current_load(traces, list(range(15)), 0)
+  data = update_data(base_data, {"incoming_load": load})
+
+  original = _solve(LoadManagementModel, data)
+  tight = _solve(TightLoadManagementModel, data)
+
+  # same objective up to the epsilon replica penalty and MIP gap
+  penalty = 1e-4 * sum(tight["r"])
+  assert tight["obj"] + penalty == pytest.approx(original["obj"], rel=1e-4)
+  # replicas stay minimal even without utilization_equilibrium2
+  assert sum(tight["r"]) <= sum(original["r"]) + 1e-6
diff --git a/tests/test_utilities.py b/tests/test_utilities.py
new file mode 100644
index 0000000..337df2c
--- /dev/null
+++ b/tests/test_utilities.py
@@ -0,0 +1,129 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from utilities import (
+  NpEncoder,
+  delete_tuples,
+  float_to_int,
+  generate_random_float,
+  generate_random_int,
+  int_keys_decoder,
+  load_base_instance,
+  load_requests_traces,
+  reconcile_paths,
+  restore_types,
+)
+
+
+def test_np_encoder_serializes_numpy_types():
+  payload = {
+    "i": np.int64(4),
+    "f": np.float64(1.5),
+    "a": np.array([1, 2, 3]),
+  }
+  decoded = json.loads(json.dumps(payload, cls = NpEncoder))
+  assert decoded == {"i": 4, "f": 1.5, "a": [1, 2, 3]}
+
+
+def test_delete_tuples_converts_tuple_keys_recursively():
+  raw = {
+    (1, 2): {"nested": {(3, 4): 7}},
+    "k": 8,
+    3: "int-key",
+  }
+  out = delete_tuples(raw)
+  assert "(1, 2)" in out
+  assert "(3, 4)" in out["(1, 2)"]["nested"]
+  assert out["k"] == 8
+  assert out[3] == "int-key"
+
+
+@pytest.mark.parametrize(
+  ("value", "approx_tol", "expected"),
+  [
+    (0.0, 1e-6, 0),
+    (0.2, 1e-6, 1),
+    (1.000001, 1e-4, 1),
+    (1.2, 1e-6, 2),
+    (2.0, 1e-6, 2),
+  ],
+)
+def test_float_to_int_cases(value, approx_tol, expected):
+  assert float_to_int(value, approx_tol) == expected
+
+
+def test_generate_random_float_from_range_and_values():
+  rng = np.random.default_rng(42)
+  sampled = generate_random_float(rng, {"min": 1.0, "max": 2.0})
+  assert 1.0 <= sampled <= 2.0
+
+  sampled_from_values = generate_random_float(rng, {"values_from": [3.0, 4.0]})
+  assert sampled_from_values in [3.0, 4.0]
+
+
+def test_generate_random_float_missing_limits_raises():
+  rng = np.random.default_rng(1)
+  with pytest.raises(ValueError, match = "Missing values"):
+    generate_random_float(rng, {})
+
+
+def test_generate_random_int_from_range_and_values():
+  rng = np.random.default_rng(2)
+  sampled = generate_random_int(rng, {"min": 3, "max": 5})
+  assert sampled in [3, 4, 5]
+
+  sampled_from_values = generate_random_int(rng, {"values_from": [10, 20]})
+  assert sampled_from_values in [10, 20]
+
+
+def test_int_keys_decoder_and_restore_types():
+  assert int_keys_decoder([("1", "a"), ("2", "b")]) == {1: "a", 2: "b"}
+
+  restored = restore_types({"(1, 2)": {"3": 4}})
+  assert (1, 2) in restored
+  assert restored[(1, 2)][3] == 4
+
+
+def test_reconcile_paths_cases():
+  absolute = reconcile_paths("solutions/a", "/tmp/x")
+  assert absolute == "/tmp/x"
+
+  common = reconcile_paths(
+    "/home/user/proj/solutions/a",
+    "solutions/b/c",
+  )
+  assert common == "/home/user/proj/solutions/b/c"
+
+  passthrough = reconcile_paths("x/y", "relative/path")
+  assert passthrough == "relative/path"
+
+
+def test_load_base_instance_and_requests_traces(tmp_path: Path):
+  base_data = {"None": {"Nn": {"None": 2}, "(1, 1)": 3}}
+  limits_data = {"0": {"0": {"min": 1, "max": 2}}}
+  (tmp_path / "base_instance_data.json").write_text(json.dumps(base_data))
+  (tmp_path / "load_limits.json").write_text(json.dumps(limits_data))
+
+  base_instance, load_limits = load_base_instance(str(tmp_path))
+  assert base_instance[None]["Nn"][None] == 2
+  assert base_instance[None][(1, 1)] == 3
+  assert 0 in load_limits
+
+  traces = {
+    "0": {"0": [1.0, 2.0, 3.0], "1": [4.0, 5.0, 6.0]},
+    "1": {"0": [7.0, 8.0, 9.0], "1": [1.0, 1.0, 1.0]},
+  }
+  (tmp_path / "input_requests_traces.json").write_text(json.dumps(traces))
+  (tmp_path / "config.json").write_text(
+    json.dumps({"min_run_time": 1, "max_run_time": 2, "run_time_step": 1, "max_steps": 3})
+  )
+
+  requests, mt, Mt, ts = load_requests_traces(str(tmp_path))
+  assert mt == 1
+  assert Mt == 2
+  assert ts == 1
+  assert isinstance(requests[0][0], np.ndarray)
+  assert requests[1][1][0] == 1.0
diff --git a/utilities.py b/utilities.py
new file mode 100644
index 0000000..c338c82
--- /dev/null
+++ b/utilities.py
@@ -0,0 +1 @@
+from utils.common import *  # noqa: F403
diff --git a/utils/centralized.py b/utils/centralized.py
index 9cf879c..cb0537f 100644
--- a/utils/centralized.py
+++ b/utils/centralized.py
@@ -2,6 +2,137 @@
 import numpy as np
 
 
+def ping_pong_forbidden_hosts(omega, y, tolerance = 1e-6) -> np.array:
+  """(Nn, Nf) boolean mask of (node, function) pairs that must NOT host f.
+
+  A node is forbidden as host (receiver) of f when it is already a *sender* of
+  f: either it still has residual demand to offload (``omega``) or it has
+  already forwarded some load for f (``y`` summed over receivers, axis 1).
+  Excluding these nodes from the seller side each round is what keeps the
+  decentralized methods that accumulate ``y`` inside the FRALB no_ping_pong
+  constraint enforced by validate_centralized_solution. Mirrors the guards
+  already inlined in decentralized_auction / _gcaa / _potentialgame.
+  """
+  omega = np.asarray(omega)
+  y = np.asarray(y)
+  return (omega > tolerance) | (y.sum(axis = 1) > tolerance)
+
+
+def validate_centralized_solution(x, y, z, r, data, tolerance = 1e-6) -> None:
+  try:
+    tolerance_value = np.asarray(tolerance)
+  except (TypeError, ValueError, OverflowError):
+    raise ValueError(f"tolerance domain NonNegativeReal: {tolerance!r}")
+  if tolerance_value.shape or tolerance_value.dtype.kind not in "buif":
+    raise ValueError(f"tolerance domain NonNegativeReal: {tolerance!r}")
+  tolerance = float(tolerance_value)
+  if not np.isfinite(tolerance) or tolerance < 0:
+    raise ValueError(f"tolerance domain NonNegativeReal: {tolerance!r}")
+
+  values = data[None]
+  Nn, Nf = values["Nn"][None], values["Nf"][None]
+  arrays = {
+    "x": np.asarray(x), "y": np.asarray(y),
+    "z": np.asarray(z), "r": np.asarray(r),
+  }
+  expected_shapes = {
+    "x": (Nn, Nf), "y": (Nn, Nn, Nf),
+    "z": (Nn, Nf), "r": (Nn, Nf),
+  }
+  for name, array in arrays.items():
+    if array.shape != expected_shapes[name]:
+      raise ValueError(
+        f"{name} shape: {array.shape} != {expected_shapes[name]}"
+      )
+
+  for name, array in arrays.items():
+    domain = "NonNegativeIntegers" if name == "r" else "NonNegativeReals"
+    if array.dtype.kind not in "buif":
+      converted = np.empty(array.shape)
+      for index, value in np.ndenumerate(array):
+        scalar = np.asarray(value)
+        invalid_scalar = (
+          bool(scalar.shape)
+          or scalar.dtype.kind not in "buifc"
+          or (scalar.dtype.kind == "c" and scalar.imag != 0)
+        )
+        if invalid_scalar:
+          shown = ",".join(str(i + 1) for i in index)
+          raise ValueError(f"{name} domain {domain} ({shown}): {value!r}")
+        converted[index] = scalar.real
+      array = arrays[name] = converted
+    invalid = ~np.isfinite(array) | (array < -tolerance)
+    if invalid.any():
+      index = tuple(np.argwhere(invalid)[0])
+      shown = ",".join(str(i + 1) for i in index)
+      raise ValueError(
+        f"{name} domain {domain} ({shown}): {array[index]}"
+      )
+  invalid = np.abs(arrays["r"] - np.rint(arrays["r"])) > tolerance
+  if invalid.any():
+    index = tuple(np.argwhere(invalid)[0])
+    shown = ",".join(str(i + 1) for i in index)
+    raise ValueError(
+      f"r domain NonNegativeIntegers ({shown}): {arrays['r'][index]}"
+    )
+
+  x, y, z, r = (
+    arrays[name].astype(float, copy = False) for name in ("x", "y", "z", "r")
+  )
+  incoming_load = np.array([
+    [values["incoming_load"][(n + 1, f + 1)] for f in range(Nf)]
+    for n in range(Nn)
+  ])
+  neighborhood = np.zeros((Nn, Nn))
+  for (n, m), is_neighbor in values["neighborhood"].items():
+    neighborhood[n - 1, m - 1] = is_neighbor
+  invalid = y - incoming_load[:, None, :] * neighborhood[:, :, None] > tolerance
+  if invalid.any():
+    n, m, f = np.argwhere(invalid)[0]
+    raise ValueError(f"offload_only_to_neighbors ({n + 1},{m + 1},{f + 1})")
+
+  invalid = (y.sum(axis = 1) > tolerance) & (y.sum(axis = 0) > tolerance)
+  if invalid.any():
+    n, f = np.argwhere(invalid)[0]
+    raise ValueError(f"no_ping_pong ({n + 1},{f + 1})")
+
+  invalid = np.abs(x + y.sum(axis = 1) + z - incoming_load) > tolerance
+  if invalid.any():
+    n, f = np.argwhere(invalid)[0]
+    raise ValueError(f"no_traffic_loss ({n + 1},{f + 1})")
+
+  demand = np.array([
+    [values["demand"][(n + 1, f + 1)] for f in range(Nf)]
+    for n in range(Nn)
+  ])
+  max_utilization = np.array([
+    values["max_utilization"][f + 1] for f in range(Nf)
+  ])
+  utilization = demand * (x + y.sum(axis = 0))
+  invalid = utilization - r * max_utilization > tolerance
+  if invalid.any():
+    n, f = np.argwhere(invalid)[0]
+    raise ValueError(f"utilization_equilibrium ({n + 1},{f + 1})")
+  invalid = (r - 1) * max_utilization - utilization > tolerance
+  if invalid.any():
+    n, f = np.argwhere(invalid)[0]
+    raise ValueError(f"utilization_equilibrium2 ({n + 1},{f + 1})")
+
+  memory_requirement = np.array([
+    values["memory_requirement"][f + 1] for f in range(Nf)
+  ])
+  memory_capacity = np.array([
+    values["memory_capacity"][n + 1] for n in range(Nn)
+  ])
+  invalid = r @ memory_requirement - memory_capacity > tolerance
+  if invalid.any():
+    n = np.argwhere(invalid)[0, 0]
+    raise ValueError(
+      f"residual_capacity ({n + 1}: "
+      f"{r[n,:] @ memory_requirement} > {memory_capacity[n]})"
+    )
+
+
 def check_feasibility(
       x: np.array, 
       omega: np.array, 
diff --git a/utils/common.py b/utils/common.py
index a2ddf31..cee6393 100644
--- a/utils/common.py
+++ b/utils/common.py
@@ -21,7 +21,7 @@ def delete_tuples(_dict: dict):
   """Delete tuple keys recursively from all of the dictionaries"""
   serializable_dict = {}
   for key, value in _dict.items():
-    new_key = key if not isinstance(key, tuple) is not None else str(key)
+    new_key = str(key) if isinstance(key, tuple) or key is None else key
     if isinstance(value, dict):
       serializable_dict[new_key] = delete_tuples(value)
     else:
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..4dcd123
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1265 @@
+version = 1
+revision = 3
+requires-python = "==3.10.*"
+
+[[package]]
+name = "ast-serialize"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/9d/09e27731bd5864a9ce04e3244074e674bb8936bf62b45e0357248717adac/ast_serialize-0.5.0.tar.gz", hash = "sha256:5880091bfe6f4f986f22866375c2e884843e7a0b6343ae41aeea659613d879b6", size = 61157, upload-time = "2026-05-17T17:48:29.429Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/9e/dc2530acb3a60dc6e46d65abf27d1d9f86721694757906a148d90a6860de/ast_serialize-0.5.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0668aa9459cfa8c9c49ddd2163ebcf43088ba045ef7492af6fe22e0098303101", size = 1191380, upload-time = "2026-05-17T17:48:03.738Z" },
+    { url = "https://files.pythonhosted.org/packages/26/0a/bd3d18a582f273d6c843d16bb9e22e9e16365ff7991e92f18f798e9f1224/ast_serialize-0.5.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bf683d6363edf2b39eed6b6d4fe22d34b6203867a67e27134d9e2a2680c4bc4a", size = 1183879, upload-time = "2026-05-17T17:48:05.463Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ae/1f919100f8620887af58fcc381c61a1f218cdf89c6e155f87b213e61010a/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc22cf0c9be65e71cf88fda130af60d61eb4a79370ad4cfe7900d48a4aa2211", size = 1244529, upload-time = "2026-05-17T17:48:07.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/ca/6376559dcce707cdbc1d0d9a13c8d3baaaa501e949ce0ebdc4230cd881aa/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f66173891548c9f2726bf27957b41cabce12fa679dc6da505ddbde4d4b3b31cf", size = 1240560, upload-time = "2026-05-17T17:48:08.46Z" },
+    { url = "https://files.pythonhosted.org/packages/35/b2/a620e206b5aeb7efbf2710336df57d457cffbb3991076bbcc1147ef9abd4/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e42d729ef2be96a14efbad355093284739e3670ece3e534f82cc8832790911d9", size = 1451172, upload-time = "2026-05-17T17:48:09.922Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/e0/4ad5c04c24a40481b2935ce9a0ccdb6023dc8b667167d06ae530cc3512f2/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b725026bafa801dbd7310eb13a75f0a2e370e7e51b2cb225f9d21fcfadf919ee", size = 1265072, upload-time = "2026-05-17T17:48:11.469Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/71/4d1d479aa56d0101c40e17720c3d6ac2af7269ea0487a80b18e7bfd1a5b7/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b54f60c1d78767a53b67eaa663f0dfac3afe606aa07f1301572f588b73d64809", size = 1270488, upload-time = "2026-05-17T17:48:13.575Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4f/0de1bbe06f6edef9fde4ed12ca8e7b3ec7e6e2bd4e672c5af487f7957665/ast_serialize-0.5.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:27d51654fc240a1e87e742d353d98eb45b75f62f129086b3596ab53df2ac2a43", size = 1260702, upload-time = "2026-05-17T17:48:15.141Z" },
+    { url = "https://files.pythonhosted.org/packages/75/61/e00872439cfdddcc3c1b6cdaa6e5d904ba8e26a18807c67c4e14409d0ca8/ast_serialize-0.5.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c36237c46dd1674542f2109740ea5ea485a169bf1431939ada0434e17934", size = 1311182, upload-time = "2026-05-17T17:48:16.779Z" },
+    { url = "https://files.pythonhosted.org/packages/76/8e/699a5b955f7926956c95e9e1d74132acad73c2fe7a426f94da89123c20aa/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1943db345233cc7194a470f13afa9c59772c0b123dea0c9414c4d4ca54369759", size = 1421410, upload-time = "2026-05-17T17:48:18.527Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ae/d5b7626874478997adc7a29ab28accf21e596fb590c944290401dfd0b29e/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df1c00022cbbcb064bfaa505aa9c9295362443ce5dacb459d1331d3da353f887", size = 1516587, upload-time = "2026-05-17T17:48:20.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ce/b59e02a82d9c4244d64cde502e0b00e83e38816abe19155ceb5437402c7f/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:cae65289fc456fde04af979a2be09302ef5d8ab92ef23e596d6746dc267ada27", size = 1515171, upload-time = "2026-05-17T17:48:21.921Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/38/d8d90042747d05aa08d4efcf1c99035a5f670a6bf4c214d31644392afbca/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:239a4c354e8d676e9d94631d1d4a64edc6b266f86ff3a5a80aedd344f342c01d", size = 1464668, upload-time = "2026-05-17T17:48:23.544Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/51/5b840c4df7334104cecffa28f23904fe81ca89ca223d2450e288de39fd3c/ast_serialize-0.5.0-cp39-abi3-win32.whl", hash = "sha256:143a4ef63285a075871908fda3672dc21864b83a8ec3ee12304aa3e4c5387b9a", size = 1068311, upload-time = "2026-05-17T17:48:25.027Z" },
+    { url = "https://files.pythonhosted.org/packages/41/11/ca5672c7d491825bc4cd6702dea106a6b60d928707712ec257c7833ae476/ast_serialize-0.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:cf25572c526add400f26a4750dc6ce0c3bb93fc1f75e7ae0cad4ce4f2cd5c590", size = 1108931, upload-time = "2026-05-17T17:48:26.591Z" },
+    { url = "https://files.pythonhosted.org/packages/45/19/cc8bd127d28a43da249aa955cfd164cf8fd534e79e42cea96c4854d72fd0/ast_serialize-0.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:92a31c9c20d25a076edaeec76b128a3535d74a24f340b9a8a7e96c9b86dc9642", size = 1081181, upload-time = "2026-05-17T17:48:28.122Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "bcrypt"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/36/3329e2518d70ad8e2e5817d5a4cac6bba05a47767ec416c7d020a965f408/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd", size = 25386, upload-time = "2025-09-25T19:50:47.829Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/29/6237f151fbfe295fe3e074ecc6d44228faa1e842a81f6d34a02937ee1736/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b", size = 494553, upload-time = "2025-09-25T19:49:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b6/4c1205dde5e464ea3bd88e8742e19f899c16fa8916fb8510a851fae985b5/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb", size = 275009, upload-time = "2025-09-25T19:49:50.581Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/71/427945e6ead72ccffe77894b2655b695ccf14ae1866cd977e185d606dd2f/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef", size = 278029, upload-time = "2025-09-25T19:49:52.533Z" },
+    { url = "https://files.pythonhosted.org/packages/17/72/c344825e3b83c5389a369c8a8e58ffe1480b8a699f46c127c34580c4666b/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd", size = 275907, upload-time = "2025-09-25T19:49:54.709Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7e/d4e47d2df1641a36d1212e5c0514f5291e1a956a7749f1e595c07a972038/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd", size = 296500, upload-time = "2025-09-25T19:49:56.013Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c3/0ae57a68be2039287ec28bc463b82e4b8dc23f9d12c0be331f4782e19108/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464", size = 278412, upload-time = "2025-09-25T19:49:57.356Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2b/77424511adb11e6a99e3a00dcc7745034bee89036ad7d7e255a7e47be7d8/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75", size = 275486, upload-time = "2025-09-25T19:49:59.116Z" },
+    { url = "https://files.pythonhosted.org/packages/43/0a/405c753f6158e0f3f14b00b462d8bca31296f7ecfc8fc8bc7919c0c7d73a/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff", size = 277940, upload-time = "2025-09-25T19:50:00.869Z" },
+    { url = "https://files.pythonhosted.org/packages/62/83/b3efc285d4aadc1fa83db385ec64dcfa1707e890eb42f03b127d66ac1b7b/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4", size = 310776, upload-time = "2025-09-25T19:50:02.393Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7d/47ee337dacecde6d234890fe929936cb03ebc4c3a7460854bbd9c97780b8/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb", size = 312922, upload-time = "2025-09-25T19:50:04.232Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3a/43d494dfb728f55f4e1cf8fd435d50c16a2d75493225b54c8d06122523c6/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c", size = 341367, upload-time = "2025-09-25T19:50:05.559Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ab/a0727a4547e383e2e22a630e0f908113db37904f58719dc48d4622139b5c/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb", size = 359187, upload-time = "2025-09-25T19:50:06.916Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bb/461f352fdca663524b4643d8b09e8435b4990f17fbf4fea6bc2a90aa0cc7/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538", size = 153752, upload-time = "2025-09-25T19:50:08.515Z" },
+    { url = "https://files.pythonhosted.org/packages/41/aa/4190e60921927b7056820291f56fc57d00d04757c8b316b2d3c0d1d6da2c/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9", size = 150881, upload-time = "2025-09-25T19:50:09.742Z" },
+    { url = "https://files.pythonhosted.org/packages/54/12/cd77221719d0b39ac0b55dbd39358db1cd1246e0282e104366ebbfb8266a/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980", size = 144931, upload-time = "2025-09-25T19:50:11.016Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/2af136406e1c3839aea9ecadc2f6be2bcd1eff255bd451dd39bcf302c47a/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a", size = 495313, upload-time = "2025-09-25T19:50:12.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ee/2f4985dbad090ace5ad1f7dd8ff94477fe089b5fab2040bd784a3d5f187b/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191", size = 275290, upload-time = "2025-09-25T19:50:13.673Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/6e/b77ade812672d15cf50842e167eead80ac3514f3beacac8902915417f8b7/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254", size = 278253, upload-time = "2025-09-25T19:50:15.089Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c4/ed00ed32f1040f7990dac7115f82273e3c03da1e1a1587a778d8cea496d8/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db", size = 276084, upload-time = "2025-09-25T19:50:16.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c4/fa6e16145e145e87f1fa351bbd54b429354fd72145cd3d4e0c5157cf4c70/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac", size = 297185, upload-time = "2025-09-25T19:50:18.525Z" },
+    { url = "https://files.pythonhosted.org/packages/24/b4/11f8a31d8b67cca3371e046db49baa7c0594d71eb40ac8121e2fc0888db0/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822", size = 278656, upload-time = "2025-09-25T19:50:19.809Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/31/79f11865f8078e192847d2cb526e3fa27c200933c982c5b2869720fa5fce/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8", size = 275662, upload-time = "2025-09-25T19:50:21.567Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/8d/5e43d9584b3b3591a6f9b68f755a4da879a59712981ef5ad2a0ac1379f7a/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a", size = 278240, upload-time = "2025-09-25T19:50:23.305Z" },
+    { url = "https://files.pythonhosted.org/packages/89/48/44590e3fc158620f680a978aafe8f87a4c4320da81ed11552f0323aa9a57/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1", size = 311152, upload-time = "2025-09-25T19:50:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/e4fbfc46f14f47b0d20493669a625da5827d07e8a88ee460af6cd9768b44/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42", size = 313284, upload-time = "2025-09-25T19:50:26.268Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ae/479f81d3f4594456a01ea2f05b132a519eff9ab5768a70430fa1132384b1/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10", size = 341643, upload-time = "2025-09-25T19:50:28.02Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d2/36a086dee1473b14276cd6ea7f61aef3b2648710b5d7f1c9e032c29b859f/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172", size = 359698, upload-time = "2025-09-25T19:50:31.347Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" },
+    { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.6.17"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/c7/424b75da314c1045981bd9777432fad05a9e0c69daa4ed7e308bbaffe405/certifi-2026.6.17.tar.gz", hash = "sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432", size = 134594, upload-time = "2026-06-17T10:31:07.894Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl", hash = "sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db", size = 133289, upload-time = "2026-06-17T10:31:06.348Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" },
+    { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" },
+    { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" },
+    { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" },
+    { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" },
+    { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/08/0f303cb0b529e456bb116f2d50565a482694fbb94340bf56d44677e7ed03/charset_normalizer-3.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cdd68a1fb318e290a2077696b7eb7a21a49163c455979c639bf5a5dcdc46617d", size = 315182, upload-time = "2026-04-02T09:25:40.673Z" },
+    { url = "https://files.pythonhosted.org/packages/24/47/b192933e94b546f1b1fe4df9cc1f84fcdbf2359f8d1081d46dd029b50207/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e17b8d5d6a8c47c85e68ca8379def1303fd360c3e22093a807cd34a71cd082b8", size = 209329, upload-time = "2026-04-02T09:25:42.354Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b4/01fa81c5ca6141024d89a8fc15968002b71da7f825dd14113207113fabbd/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:511ef87c8aec0783e08ac18565a16d435372bc1ac25a91e6ac7f5ef2b0bff790", size = 231230, upload-time = "2026-04-02T09:25:44.281Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f7/7b991776844dfa058017e600e6e55ff01984a063290ca5622c0b63162f68/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:007d05ec7321d12a40227aae9e2bc6dca73f3cb21058999a1df9e193555a9dcc", size = 225890, upload-time = "2026-04-02T09:25:45.475Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e7/bed0024a0f4ab0c8a9c64d4445f39b30c99bd1acd228291959e3de664247/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf29836da5119f3c8a8a70667b0ef5fdca3bb12f80fd06487cfa575b3909b393", size = 216930, upload-time = "2026-04-02T09:25:46.58Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ab/b18f0ab31cdd7b3ddb8bb76c4a414aeb8160c9810fdf1bc62f269a539d87/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:12d8baf840cc7889b37c7c770f478adea7adce3dcb3944d02ec87508e2dcf153", size = 202109, upload-time = "2026-04-02T09:25:48.031Z" },
+    { url = "https://files.pythonhosted.org/packages/82/e5/7e9440768a06dfb3075936490cb82dbf0ee20a133bf0dd8551fa096914ec/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d560742f3c0d62afaccf9f41fe485ed69bd7661a241f86a3ef0f0fb8b1a397af", size = 214684, upload-time = "2026-04-02T09:25:49.245Z" },
+    { url = "https://files.pythonhosted.org/packages/71/94/8c61d8da9f062fdf457c80acfa25060ec22bf1d34bbeaca4350f13bcfd07/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b14b2d9dac08e28bb8046a1a0434b1750eb221c8f5b87a68f4fa11a6f97b5e34", size = 212785, upload-time = "2026-04-02T09:25:50.671Z" },
+    { url = "https://files.pythonhosted.org/packages/66/cd/6e9889c648e72c0ab2e5967528bb83508f354d706637bc7097190c874e13/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:bc17a677b21b3502a21f66a8cc64f5bfad4df8a0b8434d661666f8ce90ac3af1", size = 203055, upload-time = "2026-04-02T09:25:51.802Z" },
+    { url = "https://files.pythonhosted.org/packages/92/2e/7a951d6a08aefb7eb8e1b54cdfb580b1365afdd9dd484dc4bee9e5d8f258/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:750e02e074872a3fad7f233b47734166440af3cdea0add3e95163110816d6752", size = 232502, upload-time = "2026-04-02T09:25:53.388Z" },
+    { url = "https://files.pythonhosted.org/packages/58/d5/abcf2d83bf8e0a1286df55cd0dc1d49af0da4282aa77e986df343e7de124/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:4e5163c14bffd570ef2affbfdd77bba66383890797df43dc8b4cc7d6f500bf53", size = 214295, upload-time = "2026-04-02T09:25:54.765Z" },
+    { url = "https://files.pythonhosted.org/packages/47/3a/7d4cd7ed54be99973a0dc176032cba5cb1f258082c31fa6df35cff46acfc/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6ed74185b2db44f41ef35fd1617c5888e59792da9bbc9190d6c7300617182616", size = 227145, upload-time = "2026-04-02T09:25:55.904Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/98/3a45bf8247889cf28262ebd3d0872edff11565b2a1e3064ccb132db3fbb0/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:94e1885b270625a9a828c9793b4d52a64445299baa1fea5a173bf1d3dd9a1a5a", size = 218884, upload-time = "2026-04-02T09:25:57.074Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/80/2e8b7f8915ed5c9ef13aa828d82738e33888c485b65ebf744d615040c7ea/charset_normalizer-3.4.7-cp310-cp310-win32.whl", hash = "sha256:6785f414ae0f3c733c437e0f3929197934f526d19dfaa75e18fdb4f94c6fb374", size = 148343, upload-time = "2026-04-02T09:25:58.199Z" },
+    { url = "https://files.pythonhosted.org/packages/35/1b/3b8c8c77184af465ee9ad88b5aea46ea6b2e1f7b9dc9502891e37af21e30/charset_normalizer-3.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:6696b7688f54f5af4462118f0bfa7c1621eeb87154f77fa04b9295ce7a8f2943", size = 159174, upload-time = "2026-04-02T09:25:59.322Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/feb40dca40dbb21e0a908801782d9288c64fc8d8e562c2098e9994c8c21b/charset_normalizer-3.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:66671f93accb62ed07da56613636f3641f1a12c13046ce91ffc923721f23c008", size = 147805, upload-time = "2026-04-02T09:26:00.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/d4/81420972a676e8ffea40450d8c8c92943e7218a78fe9b64359836cc9876b/click-8.4.2.tar.gz", hash = "sha256:9a6cea6e60b17ebe0a44c5cc636d94f09bd66142c1cd7d8b4cd731c4917a15f6", size = 338000, upload-time = "2026-06-24T17:45:15.148Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl", hash = "sha256:e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76", size = 119243, upload-time = "2026-06-24T17:45:13.73Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" },
+    { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" },
+    { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" },
+    { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/7f/d0720730a397a999ffc0fd3f5bebef347338e3a47b727da66fbb228e2ff2/coverage-7.14.0.tar.gz", hash = "sha256:057a6af2f160a85384cde4ab36f0d2777bae1057bae255f95413cdd382aa5c74", size = 919489, upload-time = "2026-05-10T18:02:31.397Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/9d/7c83ef51c3eb495f10010094e661833588b7709946da634c8b66520b97c7/coverage-7.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:84c32d90bf4537f0e7b4dec9aaa9a938fb8205136b9d2ecf4d7629d5262dc075", size = 219668, upload-time = "2026-05-10T17:59:23.106Z" },
+    { url = "https://files.pythonhosted.org/packages/24/34/898546aefbd28f0af131201d0dc852c9e976f817bd7d5bfb8dc4e02863bb/coverage-7.14.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7c843572c605ab51cfdb5c6b5f2586e2a8467c0d28eca4bdef4ec70c5fecbd82", size = 220192, upload-time = "2026-05-10T17:59:26.095Z" },
+    { url = "https://files.pythonhosted.org/packages/df/4a/b457c88aca72b0df13a98167ebd5d947135ccd9881ea88ce6a570e13aa9b/coverage-7.14.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0c451757d3fa2603354fdc789b5e58a0e327a117c370a40e3476ba4eabab228c", size = 246932, upload-time = "2026-05-10T17:59:27.806Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d9/92600e89486fd074c50f0117422b2c9592c3e144e2f25bd5ac0bc62bc7a0/coverage-7.14.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3fd43f0616e765ab78d069cf8358def7363957a45cee446d65c502dcfeea7893", size = 248762, upload-time = "2026-05-10T17:59:29.479Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/e1/9ea1eb9c311da7f15853559dc1d9d82bef88ecd3e59fbeb51f16bc2ffa91/coverage-7.14.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:731e535b1498b27d13594a0527a79b0510867b0ad891532be41cb883f2128e20", size = 250625, upload-time = "2026-05-10T17:59:31.33Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/03/57afca1b8106f8549a5329139315041fe166d6099bd9381346b9430dfbd1/coverage-7.14.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c7492f2d493b976941c7ca050f273cbda2f43c381124f7586a3e3c16d1804fec", size = 252539, upload-time = "2026-05-10T17:59:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/57/5e/2e9fc63c9928119c1dbae02222be51407d3e7ebac5811ebbda4af3557795/coverage-7.14.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc38367eaa2abb1b766ac333142bce7655335a73537f5c8b75aaa89c2b987757", size = 247636, upload-time = "2026-05-10T17:59:34.599Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/e2/0b7898cda21041cc67546e19b80ba66cbbb47cbece52a76a5904de6a3aaf/coverage-7.14.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0a951308cde22cf77f953955a754d04dccb57fe3bb8e345d685778ed9fc1632a", size = 248666, upload-time = "2026-05-10T17:59:36.232Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/d33662a2fdaef23229c15921f39c84ec38441f3069ba26e134ed402c833b/coverage-7.14.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fab3877e4ebb06bd9d4d4d00ee53309ee5478e66873c66a382272e3ee33eb7ea", size = 246670, upload-time = "2026-05-10T17:59:38.029Z" },
+    { url = "https://files.pythonhosted.org/packages/99/b2/533942c3bfbf6770b5c32d7f2ff029fe013dba31f3fe8b45cabbb250365e/coverage-7.14.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b812eb847b19876ebf33fb6c4f11819af05ab6050b0bfa1bc53412ae81779adb", size = 250484, upload-time = "2026-05-10T17:59:39.974Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/00/15acbad83a96de13c73831486c7627bfed73dfaec53b04e4a6315edf3fd8/coverage-7.14.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d9c8ef6ed820c433de075657d72dda1f89a2984955e58b8a75feb3f184250218", size = 246942, upload-time = "2026-05-10T17:59:41.659Z" },
+    { url = "https://files.pythonhosted.org/packages/70/db/cef0228de493f2c740c760a9057a61d00c6849480073b70a75b87c7d4bab/coverage-7.14.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d128b1bba9361fbaaf6a19e179e6cfd6a9103ce0c0555876f72780acc93efd85", size = 247544, upload-time = "2026-05-10T17:59:43.471Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a0/d9ef8e148f3025c2ae8401d77cda1502b6d2a4d8102603a8af31460aedb6/coverage-7.14.0-cp310-cp310-win32.whl", hash = "sha256:65f267ca1370726ec2c1aa38bbe4df9a71a740f22878d2d4bf59d71a4cd8d323", size = 222285, upload-time = "2026-05-10T17:59:44.908Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c0/30c454c7d3cf47b2805d4e06f12443f5eece8a5d030d3b0350e7b74ecb49/coverage-7.14.0-cp310-cp310-win_amd64.whl", hash = "sha256:b34ece8065914f938ed7f2c5872bb865336977a52919149846eac3744327267a", size = 223215, upload-time = "2026-05-10T17:59:46.779Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/cb8e80d6f9f55b99588625062822bf946cf03ed06315df4bd8397f5632a1/coverage-7.14.0-py3-none-any.whl", hash = "sha256:8de5b61163aee3d05c8a2beab6f47913df7981dad1baf82c414d99158c286ab1", size = 211764, upload-time = "2026-05-10T18:02:29.538Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli" },
+]
+
+[[package]]
+name = "cryptography"
+version = "49.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/99/d1c90d6041656cc6ee229dc99cd67fd0cd5aec3c5f7d72fffc27cc750054/cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493", size = 854345, upload-time = "2026-06-12T20:02:30.512Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/22/adf66990e63584a68dfb50c24f48a125c07b1699899381c8151e63ed458c/cryptography-49.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:966fe0e9c67490071f14c0d2b1cb2dfb3023c5ce39457343931415f08382f2db", size = 4032100, upload-time = "2026-06-12T20:02:32.143Z" },
+    { url = "https://files.pythonhosted.org/packages/09/41/3797cfaf69cae04a13ee78ebd83f0678d9c02b4779d21ce24445326f1a69/cryptography-49.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:36d1709f992593689b45bda411498d62c6e365f2ca00b84657d4dadd24de16db", size = 4692978, upload-time = "2026-06-12T20:01:21.305Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8b/43011f7ebe515a8aa20d61f290a326cd890c2e738e16e59eaff8d9c3a412/cryptography-49.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0e959b578856a3924bc0cbb710fc12c387b9412a951389f3ca61704a9e25f325", size = 4716422, upload-time = "2026-06-12T20:01:48.566Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/91/01ce7303a4579e6d3a6abef01bd322848e9ea7a219adcabc5048b9033571/cryptography-49.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:53ecee2e23f7169b6117e99fc8a944e5e50f79e69758a83b52a00cb98ab2b2d2", size = 4700503, upload-time = "2026-06-12T20:02:47.091Z" },
+    { url = "https://files.pythonhosted.org/packages/62/99/a2c95cf8293f07491e9e27c20cc4dcd18176d944e674679adeb1d0173fd6/cryptography-49.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2eda353d8a27bcbcaa4cbed18994a74ab4d19a2ca897db188ea269ab9b71419b", size = 5309779, upload-time = "2026-06-12T20:02:08.987Z" },
+    { url = "https://files.pythonhosted.org/packages/20/2c/0622f20ff02b2ef32558733443805dc82fd4c275be01b2d19d14676f3a1b/cryptography-49.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2afe9051da7ae7bd5905da5a949280c7d2bb75682e188f650a9d0f2756b834c6", size = 4749683, upload-time = "2026-06-12T20:02:03.335Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/5b/c5246635d5fd3b64e0d45ae10e99fd32fe9676a79915ccfe5a61ba9af1a5/cryptography-49.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:0b82e28ee398a386f0807bba7884d30f25218855690f45115831bcce5d90822c", size = 4337874, upload-time = "2026-06-12T20:02:54.323Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/88/05563c7fe2e914e87d1a536d06fe83e66b4e1d95cb593e05aea375531da8/cryptography-49.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ccac2bfebc306b862133e3bb71f3f6ee8bb525240089b2d952e4144b3a6d5da7", size = 4700283, upload-time = "2026-06-12T20:01:34.822Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/b6/d7696e4e890d6ae1469935164c9e5215c557671cb78d6e3f458ccceaa632/cryptography-49.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d0527ce944105f257f605a827d6ebead966c752038b6e8656abb9c5edee6fc68", size = 5265844, upload-time = "2026-06-12T20:01:24.09Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3c/f3ad17eecc1a57b0ba236dc01f90e783c51f4a2f35f64777cc4f47a184b2/cryptography-49.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:cbc77da8c523d5abd028635ba850a6966fcee2c82e2bf65a41d1d8afe0f98be9", size = 4749290, upload-time = "2026-06-12T20:01:30.848Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/01/339573cf1023163a400b0b5d16f6d507de413b9f60be6fd1b77feeaf6737/cryptography-49.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b87e65d263b3e5d3bb92a57e2a6638e2f31110fa7aa890c7b2dbba42248d0a3f", size = 4834612, upload-time = "2026-06-12T20:01:29.246Z" },
+    { url = "https://files.pythonhosted.org/packages/71/fd/577302e213a1be9468f92d1afef66fcf1ef83d516819d9992ca547f592bd/cryptography-49.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:66ec79c3904820572d7e987abdf304281f141d37ad9a489b8e97066e7b9b6459", size = 4980804, upload-time = "2026-06-12T20:01:42.853Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/09/f42b1d190c5ba75f72062a387f8030d1d75f6ab035788f1d9c4b01de6525/cryptography-49.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:e5dfc1e64de5677cec922ffa8da89c546d0415bf6efdf081842e5d44c84e1f0e", size = 3810026, upload-time = "2026-06-12T20:02:39.262Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/5bb823f5bedcf80718cea7fbc95ec5515cca3769633c4b01a32be7f30e7c/cryptography-49.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ec5e529fb80935c94fe7b729f9972b50e351a0e6b50aa294fd5cabb109fcc29a", size = 4025947, upload-time = "2026-06-12T20:01:25.745Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/df/40577043ca124e17012f408ddddaeb213b856336ac82ddb3bc915f39e29f/cryptography-49.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f78ff2c9ed8dc2d036b0f4d640e22522213d047c1b14e61205a7e55c80a494d4", size = 4692429, upload-time = "2026-06-12T20:01:53.628Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/99/2d13299eb3dd27b02dcfaafcc91d6b5cb3329f7cbd6d8f51921acd566c1a/cryptography-49.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:35b151772baff2c74cba7fa290ceaff4c3b11c0c881eb93eb5dbc05a7cfbba18", size = 4700968, upload-time = "2026-06-12T20:02:45.383Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/4d/9c0cd02f95e2602dd5e563da149ee0830abef3537be8b34dc56281ebe27a/cryptography-49.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0f21641cf4b30fca7aee061ced0ec7ad7b073518088b7c9969a297c0ae796c69", size = 4697758, upload-time = "2026-06-12T20:01:41.13Z" },
+    { url = "https://files.pythonhosted.org/packages/24/01/186c825898477d77e2324d5360fefe622ff1d8d1963ec0554e2cada8ec77/cryptography-49.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9e82dcc8e56052715fb18b2429e3bca4823b1629136a2084fc45a9a5cecb9b64", size = 5298863, upload-time = "2026-06-12T20:02:24.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/7b/62cbbab75d0659865bf0273790031544a0b16c8072d258f9428dcd8190dc/cryptography-49.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6f2debedf9ca60cf1d5bd466475638af5130f89965605cd818484d19987d3a21", size = 4735983, upload-time = "2026-06-12T20:01:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/72/3e798c064bc39e471008075d0f9bc9daf77a80879c092e4a8e170c585ed4/cryptography-49.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:8c25ceb16df5b9435f3f6a9829204985b0e0cbee3b48aacd432c7d2c850b44d9", size = 4334173, upload-time = "2026-06-12T20:01:44.743Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/ee/6fca21d1ac73e06f8bef71940abfd4d2f6472b4bca284d770f32bd4086f6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:28d8b15e6275f12c8a207dc309dfa957903c927d08d0cc937ee3f63f200693cc", size = 4697298, upload-time = "2026-06-12T20:02:20.918Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d0/a5fcd3515f0bae49a7b6d0413cc1bdccdcc1fc0047037a0d480642cdc5d6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6fc361c34fb6aac015ce19435876635e5c6d21db31998b0920f675f131e043b8", size = 5254338, upload-time = "2026-06-12T20:02:22.737Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/84/84fe36f19caf857d61cb7fc9c63035a47ffabd84ea12d1d393148efa3615/cryptography-49.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2400ef9c9e2299a25614eb1dea3db54a69b1349efd043bfac9c67630d136df36", size = 4735650, upload-time = "2026-06-12T20:02:41.389Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/a0/db537264e234f7273a73ec020873d6d6b39dfd8a53db78b550ca8320440e/cryptography-49.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:67e1d20ad9ef3a563c59ef22e7a8a0b8210bd26604369ea4a30a7c66aefe504e", size = 4834820, upload-time = "2026-06-12T20:01:51.847Z" },
+    { url = "https://files.pythonhosted.org/packages/93/77/8df9eb486495979bccecd1062e2eaf435250e84437040295b57d09048b0b/cryptography-49.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:42b0684e0e40cf26122427802486f6d93aea593612603a94fbf260c7eb1e9c1b", size = 4967968, upload-time = "2026-06-12T20:02:12.524Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/e6/f60198ea8d9dfa15fff9ed4ca02ce362f6eadd9ba757dcc50634c4257b63/cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001", size = 3785547, upload-time = "2026-06-12T20:02:26.847Z" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "decorator"
+version = "5.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" },
+]
+
+[[package]]
+name = "dfaasoptimizer"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "gurobipy" },
+    { name = "kiwisolver" },
+    { name = "matplotlib" },
+    { name = "networkx" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "parse" },
+    { name = "pillow" },
+    { name = "ply" },
+    { name = "pyomo" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "pyyaml" },
+    { name = "ray-dispatcher" },
+    { name = "rich" },
+    { name = "scipy" },
+    { name = "seaborn" },
+    { name = "six" },
+    { name = "tqdm" },
+    { name = "tzdata" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "mypy" },
+    { name = "pandas-stubs" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+    { name = "types-pyyaml" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "contourpy", specifier = "==1.3.2" },
+    { name = "cycler", specifier = "==0.12.1" },
+    { name = "fonttools", specifier = "==4.59.0" },
+    { name = "gurobipy", specifier = "==12.0.3" },
+    { name = "kiwisolver", specifier = "==1.4.8" },
+    { name = "matplotlib", specifier = "==3.10.3" },
+    { name = "networkx", specifier = "==3.4.2" },
+    { name = "numpy", specifier = "==2.2.6" },
+    { name = "packaging", specifier = "==25.0" },
+    { name = "pandas", specifier = "==2.3.1" },
+    { name = "parse", specifier = "==1.20.2" },
+    { name = "pillow", specifier = "==11.3.0" },
+    { name = "ply", specifier = "==3.11" },
+    { name = "pyomo", specifier = "==6.9.2" },
+    { name = "pyparsing", specifier = "==3.2.3" },
+    { name = "python-dateutil", specifier = "==2.9.0.post0" },
+    { name = "pytz", specifier = "==2025.2" },
+    { name = "pyyaml", specifier = ">=6.0.2" },
+    { name = "ray-dispatcher", git = "https://github.com/miciav/ray-dispatcher.git?tag=v0.1.1" },
+    { name = "rich", specifier = ">=13,<15" },
+    { name = "scipy", specifier = "==1.15.3" },
+    { name = "seaborn", specifier = ">=0.13.2" },
+    { name = "six", specifier = "==1.17.0" },
+    { name = "tqdm", specifier = "==4.67.1" },
+    { name = "tzdata", specifier = "==2025.2" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "mypy", specifier = ">=2.1.0" },
+    { name = "pandas-stubs", specifier = ">=2.3.3.260113" },
+    { name = "pre-commit", specifier = ">=4.6.0" },
+    { name = "pytest", specifier = ">=9.0.3" },
+    { name = "pytest-cov", specifier = ">=7.1.0" },
+    { name = "ruff", specifier = ">=0.15.13" },
+    { name = "types-pyyaml", specifier = ">=6.0.12.20260518" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "fabric"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "decorator" },
+    { name = "deprecated" },
+    { name = "invoke" },
+    { name = "paramiko" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/7e/29cd6237c3b7ce79c3ca945eb99ab5affd101db54b2f7a78dde0cfa19fd4/fabric-3.2.3.tar.gz", hash = "sha256:dcbd2c47ad87688facaef5cc11aab6d1ec9ed05645fed97a5de7204d5d17cc44", size = 183497, upload-time = "2026-04-06T00:00:11.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/f9/f8497ef8b873a8bb2a750ee2a6c5f0fc22258e1acb6245fd237042a6c279/fabric-3.2.3-py3-none-any.whl", hash = "sha256:ce61917f4f398018337ce279b357650a3a74baecf3fdd53a5839013944af965e", size = 59502, upload-time = "2026-04-06T00:00:10.176Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.29.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.59.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/27/ec3c723bfdf86f34c5c82bf6305df3e0f0d8ea798d2d3a7cb0c0a866d286/fonttools-4.59.0.tar.gz", hash = "sha256:be392ec3529e2f57faa28709d60723a763904f71a2b63aabe14fee6648fe3b14", size = 3532521, upload-time = "2025-07-16T12:04:54.613Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/1f/3dcae710b7c4b56e79442b03db64f6c9f10c3348f7af40339dffcefb581e/fonttools-4.59.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:524133c1be38445c5c0575eacea42dbd44374b310b1ffc4b60ff01d881fabb96", size = 2761846, upload-time = "2025-07-16T12:03:33.267Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0e/ae3a1884fa1549acac1191cc9ec039142f6ac0e9cbc139c2e6a3dab967da/fonttools-4.59.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:21e606b2d38fed938dde871c5736822dd6bda7a4631b92e509a1f5cd1b90c5df", size = 2332060, upload-time = "2025-07-16T12:03:36.472Z" },
+    { url = "https://files.pythonhosted.org/packages/75/46/58bff92a7216829159ac7bdb1d05a48ad1b8ab8c539555f12d29fdecfdd4/fonttools-4.59.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e93df708c69a193fc7987192f94df250f83f3851fda49413f02ba5dded639482", size = 4852354, upload-time = "2025-07-16T12:03:39.102Z" },
+    { url = "https://files.pythonhosted.org/packages/05/57/767e31e48861045d89691128bd81fd4c62b62150f9a17a666f731ce4f197/fonttools-4.59.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:62224a9bb85b4b66d1b46d45cbe43d71cbf8f527d332b177e3b96191ffbc1e64", size = 4781132, upload-time = "2025-07-16T12:03:41.415Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/78/adb5e9b0af5c6ce469e8b0e112f144eaa84b30dd72a486e9c778a9b03b31/fonttools-4.59.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8974b2a266b54c96709bd5e239979cddfd2dbceed331aa567ea1d7c4a2202db", size = 4832901, upload-time = "2025-07-16T12:03:43.115Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/92/bc3881097fbf3d56d112bec308c863c058e5d4c9c65f534e8ae58450ab8a/fonttools-4.59.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:209b75943d158f610b78320eacb5539aa9e920bee2c775445b2846c65d20e19d", size = 4940140, upload-time = "2025-07-16T12:03:44.781Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/54/39cdb23f0eeda2e07ae9cb189f2b6f41da89aabc682d3a387b3ff4a4ed29/fonttools-4.59.0-cp310-cp310-win32.whl", hash = "sha256:4c908a7036f0f3677f8afa577bcd973e3e20ddd2f7c42a33208d18bee95cdb6f", size = 2215890, upload-time = "2025-07-16T12:03:46.961Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/eb/f8388d9e19f95d8df2449febe9b1a38ddd758cfdb7d6de3a05198d785d61/fonttools-4.59.0-cp310-cp310-win_amd64.whl", hash = "sha256:8b4309a2775e4feee7356e63b163969a215d663399cce1b3d3b65e7ec2d9680e", size = 2260191, upload-time = "2025-07-16T12:03:48.908Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9c/df0ef2c51845a13043e5088f7bb988ca6cd5bb82d5d4203d6a158aa58cf2/fonttools-4.59.0-py3-none-any.whl", hash = "sha256:241313683afd3baacb32a6bd124d0bce7404bc5280e12e291bae1b9bba28711d", size = 1128050, upload-time = "2025-07-16T12:04:52.687Z" },
+]
+
+[[package]]
+name = "gurobipy"
+version = "12.0.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/30/674bbda2fb1f090126f6d6c4fabfb62b0b2d278901dcf394be2700a1b0e4/gurobipy-12.0.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:83882c4552e2b2f1bd70623b9822d307bd5119154d3d9ff5a0071a681c9a29a5", size = 12303819, upload-time = "2025-07-15T07:16:37.556Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/e3017ec540fd1b9eb7a8c198801bf412b9a29e552e517f16b41f306224cb/gurobipy-12.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1e6881e29f870f639bd005b53c217a58a8ad1f54c94d8f14269002654de515fa", size = 62776784, upload-time = "2025-07-15T07:17:27.083Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/75/8060a741bcde24816dee956a6cb70c8f794a1db4896bb6816b7ea088e488/gurobipy-12.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f188e4685969f05604be52855814072d963d53b1cf94d0f3f1bc5b56f4468ebb", size = 14493872, upload-time = "2025-07-15T07:17:39.031Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/99/42a427a05f23b65477fb5d6135af5b61223ffc545c78a7835df72f44e28f/gurobipy-12.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:552443272db1e8c533a96ca6afb52267650374d01f08102b94d68312b23b4318", size = 11231795, upload-time = "2025-07-15T07:17:51.898Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "invoke"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/bd/b461d3424a24c80490313fd77feeb666ca4f6a28c7e72713e3d9095719b4/invoke-2.2.1.tar.gz", hash = "sha256:515bf49b4a48932b79b024590348da22f39c4942dff991ad1fb8b8baea1be707", size = 304762, upload-time = "2025-10-11T00:36:35.172Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/4b/b99e37f88336009971405cbb7630610322ed6fbfa31e1d7ab3fbf3049a2d/invoke-2.2.1-py3-none-any.whl", hash = "sha256:2413bc441b376e5cd3f55bb5d364f973ad8bdd7bf87e53c79de3c11bf3feecc8", size = 160287, upload-time = "2025-10-11T00:36:33.703Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538, upload-time = "2024-12-24T18:30:51.519Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623, upload-time = "2024-12-24T18:28:17.687Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720, upload-time = "2024-12-24T18:28:19.158Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413, upload-time = "2024-12-24T18:28:20.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826, upload-time = "2024-12-24T18:28:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231, upload-time = "2024-12-24T18:28:23.851Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938, upload-time = "2024-12-24T18:28:26.687Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799, upload-time = "2024-12-24T18:28:30.538Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362, upload-time = "2024-12-24T18:28:32.943Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695, upload-time = "2024-12-24T18:28:35.641Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802, upload-time = "2024-12-24T18:28:38.357Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646, upload-time = "2024-12-24T18:28:40.941Z" },
+    { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260, upload-time = "2024-12-24T18:28:42.273Z" },
+    { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633, upload-time = "2024-12-24T18:28:44.87Z" },
+    { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885, upload-time = "2024-12-24T18:28:47.346Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175, upload-time = "2024-12-24T18:28:49.651Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403, upload-time = "2024-12-24T18:30:41.372Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657, upload-time = "2024-12-24T18:30:42.392Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948, upload-time = "2024-12-24T18:30:44.703Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186, upload-time = "2024-12-24T18:30:45.654Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279, upload-time = "2024-12-24T18:30:47.951Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762, upload-time = "2024-12-24T18:30:48.903Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/10/37fd9e9ba96cb0bd742dfb20fc3d082e54bdbec759d7300df927f360ef07/librt-0.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6e94ebfcfa2d5e9926d6c3b9aa4617ffc42a845b4321fb84021b872358c82a0f", size = 141706, upload-time = "2026-05-10T18:15:16.129Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/72/1b1466f358e4a0b728051f69bc27e67b432c6eaa2e05b88db49d3785ae0d/librt-0.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ae627397a2f351560440d872d6f7c8dbb4072e57868e7b2fc5b8b430fe489d45", size = 142605, upload-time = "2026-05-10T18:15:18.148Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/85/ed26dd2f6bc9a0baf48306433e579e8d354d70b2bcb78134ed950a5d0e1e/librt-0.11.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc329359321b67d24efdf4bc69012b0597001649544db662c001db5a0184794c", size = 476555, upload-time = "2026-05-10T18:15:19.569Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/11891191c0e0a3fd617724e891f6e67a71a7658974a892b9a9a97fdb2977/librt-0.11.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:7e82e642ab0f7608ce2fe53d76ca2280a9ee33a1b06556142c7c6fe80a86fc33", size = 468434, upload-time = "2026-05-10T18:15:20.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/50/5ec949d7f9ce1a07af903aa3e13abb98b717923bdead6e719b2f824ccc07/librt-0.11.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88145c15c67731d54283d135b03244028c750cc9edc334a96a4f5950ebdb2884", size = 496918, upload-time = "2026-05-10T18:15:22.616Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/c4/177336c7524e34875a38bf668e88b193a6723a4eb4045d07f74df6e1506c/librt-0.11.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9d36a51b3d93320b686588e27123f4995804dbf1bce81df78c02fc3c6eea9280", size = 490334, upload-time = "2026-05-10T18:15:24.2Z" },
+    { url = "https://files.pythonhosted.org/packages/13/1f/da3112f7569eda3b49f9a2629bae1fe059812b6085df16c885f6454dff49/librt-0.11.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d00f3ac06a2a8b246327f11e186a53a100a4d5c7ed52346367e5ec751d51586c", size = 511287, upload-time = "2026-05-10T18:15:26.226Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/94/03fec301522e172d105581431223be56b27594ff46440ebfbb658a3735d5/librt-0.11.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:461bbceede621f1ffb8839755f8663e886087ee7af16294cab7fb4d782c62eeb", size = 517202, upload-time = "2026-05-10T18:15:27.965Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/6e/339f6e5a7b413ce014f1917a756dae630fe59cc99f34153205b1cb540901/librt-0.11.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0cad8a4d6a8ff03c9b76f9414caccd78e7cfbc8a2e12fa334d8e1d9932753783", size = 497517, upload-time = "2026-05-10T18:15:29.614Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/43/acdd5ce317cb46e8253ca9bfbdb8b12e68a24d745949336a7f3d5fb79ba0/librt-0.11.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f37aa505b3cf60701562eddb32df74b12a9e380c207fd8b06dd157a943ac7ea0", size = 538878, upload-time = "2026-05-10T18:15:30.928Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b5/7a25bb12e3172839f647f196b3e988318b7bb1ca7501732a225c4dce2ec0/librt-0.11.0-cp310-cp310-win32.whl", hash = "sha256:94663a21534637f0e787ec2a2a756022df6e5b7b2335a5cdd7d8e33d68a2af89", size = 100070, upload-time = "2026-05-10T18:15:32.551Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0d/ebbcf4d77999c02c937b05d2b90ff4cd4dcc7e9a365ba132329ac1fe7a0f/librt-0.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:dec7db73758c2b54953fd8b7fe348c45188fe26b39ee18446196edd08453a5d4", size = 117918, upload-time = "2026-05-10T18:15:33.678Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/91/d49359a21893183ed2a5b6c76bec40e0b1dcbf8ca148f864d134897cfc75/matplotlib-3.10.3.tar.gz", hash = "sha256:2f82d2c5bb7ae93aaaa4cd42aca65d76ce6376f83304fa3a630b569aca274df0", size = 34799811, upload-time = "2025-05-08T19:10:54.39Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/ea/2bba25d289d389c7451f331ecd593944b3705f06ddf593fa7be75037d308/matplotlib-3.10.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:213fadd6348d106ca7db99e113f1bea1e65e383c3ba76e8556ba4a3054b65ae7", size = 8167862, upload-time = "2025-05-08T19:09:39.563Z" },
+    { url = "https://files.pythonhosted.org/packages/41/81/cc70b5138c926604e8c9ed810ed4c79e8116ba72e02230852f5c12c87ba2/matplotlib-3.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3bec61cb8221f0ca6313889308326e7bb303d0d302c5cc9e523b2f2e6c73deb", size = 8042149, upload-time = "2025-05-08T19:09:42.413Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9a/0ff45b6bfa42bb16de597e6058edf2361c298ad5ef93b327728145161bbf/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c21ae75651c0231b3ba014b6d5e08fb969c40cdb5a011e33e99ed0c9ea86ecb", size = 8453719, upload-time = "2025-05-08T19:09:44.901Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c7/1866e972fed6d71ef136efbc980d4d1854ab7ef1ea8152bbd995ca231c81/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a49e39755580b08e30e3620efc659330eac5d6534ab7eae50fa5e31f53ee4e30", size = 8590801, upload-time = "2025-05-08T19:09:47.404Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b9/748f6626d534ab7e255bdc39dc22634d337cf3ce200f261b5d65742044a1/matplotlib-3.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cf4636203e1190871d3a73664dea03d26fb019b66692cbfd642faafdad6208e8", size = 9402111, upload-time = "2025-05-08T19:09:49.474Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/78/8bf07bd8fb67ea5665a6af188e70b57fcb2ab67057daa06b85a08e59160a/matplotlib-3.10.3-cp310-cp310-win_amd64.whl", hash = "sha256:fd5641a9bb9d55f4dd2afe897a53b537c834b9012684c8444cc105895c8c16fd", size = 8057213, upload-time = "2025-05-08T19:09:51.489Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/d1/f54d43e95384b312ffa4a74a4326c722f3b8187aaaa12e9a84cdf3037131/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:86ab63d66bbc83fdb6733471d3bff40897c1e9921cba112accd748eee4bce5e4", size = 8162896, upload-time = "2025-05-08T19:10:46.432Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/fbfc00c2346177c95b353dcf9b5a004106abe8730a62cb6f27e79df0a698/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a48f9c08bf7444b5d2391a83e75edb464ccda3c380384b36532a0962593a1751", size = 8039702, upload-time = "2025-05-08T19:10:49.634Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b9/59e120d24a2ec5fc2d30646adb2efb4621aab3c6d83d66fb2a7a182db032/matplotlib-3.10.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb73d8aa75a237457988f9765e4dfe1c0d2453c5ca4eabc897d4309672c8e014", size = 8594298, upload-time = "2025-05-08T19:10:51.738Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", hash = "sha256:04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647", size = 183960, upload-time = "2026-06-18T16:13:52.594Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/16/f70100614b69feb3ade7285f08c9c52d6cda0a5c03f3f5e2facd63acb211/msgpack-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8c7b398c56ff125feae96c2737abfec5595f1fa0aa186df60c56040b8accb95c", size = 82926, upload-time = "2026-06-18T16:12:31.531Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/3c/08ecd5cdfe4e2de43aec79062028ad0f7b2d9b1fea5430068c198ba570da/msgpack-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1548006a91aa93c5da81f3bdcebc1a0d10cea2d25969754fbe848da622b2b895", size = 82730, upload-time = "2026-06-18T16:12:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/19/9f/a70c9cb1a04ecc134005149367dcfe35d167284e8f65035a1e4156ad17b5/msgpack-1.2.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1dabedcd0f23559f3596428c6589c1cd8c6eaed3a0d720795b07b0225d769203", size = 400729, upload-time = "2026-06-18T16:12:34.052Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/7f/5ce020168cf0439041526e95aa068c722c016aee21624e331aeabeee2e8e/msgpack-1.2.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83efa1c898e0fc5380fc0cabbf75164c52e3b5cbb45973710d75821928380c73", size = 407625, upload-time = "2026-06-18T16:12:35.239Z" },
+    { url = "https://files.pythonhosted.org/packages/79/70/fb7668ce0386819303047057aef6fc1da73b584291d9cff82b821744e2ef/msgpack-1.2.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01e2dd6c9b19d333a00282330cc8a73d38d8dabc306dc5b42cd668c3ac82e833", size = 377891, upload-time = "2026-06-18T16:12:36.684Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/dc/9ebe654a73c3aed2e40aa6b52e3c2a02b5f53ef0085fa235a45d5b367f87/msgpack-1.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:350cb813d0af6e65d2f7ef0d729f7ff5be5a8bce03665892f43e5883d4ecc1b8", size = 391987, upload-time = "2026-06-18T16:12:37.839Z" },
+    { url = "https://files.pythonhosted.org/packages/42/eb/b67cf64218a2fa25e1c671fe1d3dbb06cbeb973e71bc4b822da079862d0b/msgpack-1.2.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ee1d9ed27d0497b848923746cf762ed2e7db24f4be7eec8e5cbe8c766aa707b7", size = 374603, upload-time = "2026-06-18T16:12:39.221Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2e/9ee200cde32fd1a0101b4006202fde554c1860adfb9bf7bff31ea4c08df8/msgpack-1.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:633727297ed063441fd1cda2288865487f33ad14eeb8831afb5f0c396a62cfce", size = 405121, upload-time = "2026-06-18T16:12:40.524Z" },
+    { url = "https://files.pythonhosted.org/packages/43/b6/f10117be7ca7a51e8feed699a907b8e663a8cd66e115ae6b4fb30cc7945c/msgpack-1.2.1-cp310-cp310-win32.whl", hash = "sha256:298872ecf9e61950f1c6af4ca969b859ee91783bb920ef6e6172697d0c8aad74", size = 64088, upload-time = "2026-06-18T16:12:41.762Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/93/89976c696fb0224662239d952c47b4d1661b34d79a332ef5584facaa8579/msgpack-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:2ff164c1b0bcb740b073b99e945234d0212852fa378e44a208c425379140dbeb", size = 70113, upload-time = "2026-06-18T16:12:42.78Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ast-serialize" },
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "tomli" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/15/cca9d88503549ed6fedeaa1d448cdddd542ee8a490232d732e278036fbf2/mypy-2.1.0.tar.gz", hash = "sha256:81e76ad12c2d804512e9b13240d1588316531bfba07558286078bfbce9613633", size = 3898359, upload-time = "2026-05-11T18:37:36.237Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/71/d351dca3e9b30da2328ee9d445c88b8388072808ebfbc49eb69d30b67749/mypy-2.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:11a6beb180257a805961aea9ec591bbd0bd17f1e18d35b8456d57aee5bedfedc", size = 14778792, upload-time = "2026-05-11T18:36:23.605Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/45/7d51594b644c17c0bcf74ed8cd5fc33b324276d708e8506f220b70dab9d9/mypy-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8ef78c1d306bbf9a8a12f526c44902c9c28dffd6c52c52bf6a72641ce18d3849", size = 13645739, upload-time = "2026-05-11T18:37:22.752Z" },
+    { url = "https://files.pythonhosted.org/packages/65/01/455c31b170e9468265074840bf18863a8482a24103fdaabe4e199392aa5f/mypy-2.1.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c209a90853081ff01d01ee895cafe10f7db1474e0d95beaeef0f6c1db9119bbd", size = 14074199, upload-time = "2026-05-11T18:35:09.292Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5a/93093f0b29a9e982deafde698f740a2eb2e05886e79ccf0594c7fd5413a3/mypy-2.1.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47cebf61abde7c088a4e27718a8b13a81655686b2e9c251f5c0915a802248166", size = 14953128, upload-time = "2026-05-11T18:31:57.678Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/2f/a196f5331d96170ad3d28f144d2aba690d4b2911381f68d51e489c7ab82a/mypy-2.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d57a90ae5e872138a425ec328edbc9b235d1934c4377881a33ec05b341acc9a8", size = 15249378, upload-time = "2026-05-11T18:33:00.101Z" },
+    { url = "https://files.pythonhosted.org/packages/54/de/94d321cc12da9f71341ac0c270efbed5c725750c7b4c334d957de9a087d9/mypy-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:aea7f7a8a55b459c34275fc468ada6ca7c173a5e43a68f5dbe588a563d8a06b8", size = 11060994, upload-time = "2026-05-11T18:33:18.848Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/62/0c27ca55219a7c764a7fb88c7bb2b7b2f9780ade8bbf16bc8ed8400eef6b/mypy-2.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:c989640253f0d76843e9c6c1bbf4bd48c5e85ada61bde4beb37cb3eca035685e", size = 9976743, upload-time = "2026-05-11T18:31:25.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/2a/13ca1f292f6db1b98ff495ef3467736b331621c5917cad984b7043e7348d/mypy-2.1.0-py3-none-any.whl", hash = "sha256:a663814603a5c563fb87a4f96fb473eeb30d1f5a4885afcf44f9db000a366289", size = 2693302, upload-time = "2026-05-11T18:31:29.246Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/6f/75aa71f8a14267117adeeed5d21b204770189c0a0025acbdc03c337b28fc/pandas-2.3.1.tar.gz", hash = "sha256:0a95b9ac964fe83ce317827f80304d37388ea77616b1425f0ae41c9d2d0d7bb2", size = 4487493, upload-time = "2025-07-07T19:20:04.079Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/ca/aa97b47287221fa37a49634532e520300088e290b20d690b21ce3e448143/pandas-2.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:22c2e866f7209ebc3a8f08d75766566aae02bcc91d196935a1d9e59c7b990ac9", size = 11542731, upload-time = "2025-07-07T19:18:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/7938dddc5f01e18e573dcfb0f1b8c9357d9b5fa6ffdee6e605b92efbdff2/pandas-2.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3583d348546201aff730c8c47e49bc159833f971c2899d6097bce68b9112a4f1", size = 10790031, upload-time = "2025-07-07T19:18:16.611Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/2f/9af748366763b2a494fed477f88051dbf06f56053d5c00eba652697e3f94/pandas-2.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f951fbb702dacd390561e0ea45cdd8ecfa7fb56935eb3dd78e306c19104b9b0", size = 11724083, upload-time = "2025-07-07T19:18:20.512Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/95/79ab37aa4c25d1e7df953dde407bb9c3e4ae47d154bc0dd1692f3a6dcf8c/pandas-2.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd05b72ec02ebfb993569b4931b2e16fbb4d6ad6ce80224a3ee838387d83a191", size = 12342360, upload-time = "2025-07-07T19:18:23.194Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a7/d65e5d8665c12c3c6ff5edd9709d5836ec9b6f80071b7f4a718c6106e86e/pandas-2.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1b916a627919a247d865aed068eb65eb91a344b13f5b57ab9f610b7716c92de1", size = 13202098, upload-time = "2025-07-07T19:18:25.558Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f3/4c1dbd754dbaa79dbf8b537800cb2fa1a6e534764fef50ab1f7533226c5c/pandas-2.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fe67dc676818c186d5a3d5425250e40f179c2a89145df477dd82945eaea89e97", size = 13837228, upload-time = "2025-07-07T19:18:28.344Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/d6/d7f5777162aa9b48ec3910bca5a58c9b5927cfd9cfde3aa64322f5ba4b9f/pandas-2.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:2eb789ae0274672acbd3c575b0598d213345660120a257b47b5dafdc618aec83", size = 11336561, upload-time = "2025-07-07T19:18:31.211Z" },
+]
+
+[[package]]
+name = "pandas-stubs"
+version = "2.3.3.260113"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "types-pytz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/92/5d/be23854a73fda69f1dbdda7bc10fbd6f930bd1fa87aaec389f00c901c1e8/pandas_stubs-2.3.3.260113.tar.gz", hash = "sha256:076e3724bcaa73de78932b012ec64b3010463d377fa63116f4e6850643d93800", size = 116131, upload-time = "2026-01-13T22:30:16.704Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/c6/df1fe324248424f77b89371116dab5243db7f052c32cc9fe7442ad9c5f75/pandas_stubs-2.3.3.260113-py3-none-any.whl", hash = "sha256:ec070b5c576e1badf12544ae50385872f0631fc35d99d00dc598c2954ec564d3", size = 168246, upload-time = "2026-01-13T22:30:15.244Z" },
+]
+
+[[package]]
+name = "paramiko"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bcrypt" },
+    { name = "cryptography" },
+    { name = "invoke" },
+    { name = "pynacl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/93/dcc25d52f49022ae6175d15e6bd751f1acc99b98bc61fc55e5155a7be2e7/paramiko-5.0.0.tar.gz", hash = "sha256:36763b5b95c2a0dcfdf1abc48e48156ee425b21efe2f0e787c2dd5a95c0e5e79", size = 1548586, upload-time = "2026-05-09T18:28:52.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/5b/eadf6d45de38d30ab603f49393b6cd2cbe7e233af8cf90197e32782b68a9/paramiko-5.0.0-py3-none-any.whl", hash = "sha256:b7044611c30140d9a75261653210e2002977b71a0497ff3ba0d98d7edbf62f7c", size = 208919, upload-time = "2026-05-09T18:28:50.295Z" },
+]
+
+[[package]]
+name = "parse"
+version = "1.20.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/78/d9b09ba24bb36ef8b83b71be547e118d46214735b6dfb39e4bfde0e9b9dd/parse-1.20.2.tar.gz", hash = "sha256:b41d604d16503c79d81af5165155c0b20f6c8d6c559efa66b4b695c3e5a0a0ce", size = 29391, upload-time = "2024-06-11T04:41:57.34Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/31/ba45bf0b2aa7898d81cbbfac0e88c267befb59ad91a19e36e1bc5578ddb1/parse-1.20.2-py2.py3-none-any.whl", hash = "sha256:967095588cb802add9177d0c0b6133b5ba33b1ea9007ca800e526f42a85af558", size = 20126, upload-time = "2024-06-11T04:41:55.057Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "11.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload-time = "2025-07-01T09:13:39.342Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload-time = "2025-07-01T09:13:41.835Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload-time = "2025-07-03T13:09:47.439Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload-time = "2025-07-03T13:09:51.796Z" },
+    { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload-time = "2025-07-01T09:13:43.865Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload-time = "2025-07-01T09:13:46.161Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload-time = "2025-07-01T09:13:47.829Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/3a/b13f36832ea6d279a697231658199e0a03cd87ef12048016bdcc84131601/pillow-11.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e", size = 6708372, upload-time = "2025-07-01T09:13:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/e4/61b2e1a7528740efbc70b3d581f33937e38e98ef3d50b05007267a55bcb2/pillow-11.3.0-cp310-cp310-win32.whl", hash = "sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6", size = 6277090, upload-time = "2025-07-01T09:13:53.915Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d3/60c781c83a785d6afbd6a326ed4d759d141de43aa7365725cbcd65ce5e54/pillow-11.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f", size = 6985988, upload-time = "2025-07-01T09:13:55.699Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload-time = "2025-07-01T09:13:57.497Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload-time = "2025-07-01T09:16:09.961Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload-time = "2025-07-01T09:16:11.913Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload-time = "2025-07-03T13:11:10.201Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload-time = "2025-07-03T13:11:15.68Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload-time = "2025-07-01T09:16:13.74Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload-time = "2025-07-01T09:16:16.107Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload-time = "2025-07-01T09:16:18.07Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "ply"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130, upload-time = "2018-02-15T19:01:31.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.35.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/01/9ef0afd7999eb9badb3a768b4aedd78c86d4c65cfaf1958ab276199e76b4/protobuf-7.35.1.tar.gz", hash = "sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a", size = 458717, upload-time = "2026-06-11T21:55:40.257Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/03/8aeeb7458d22546bf64b5250ca1daeb5ff757d900e8e4a7476c6f0db843e/protobuf-7.35.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6", size = 433226, upload-time = "2026-06-11T21:55:31.719Z" },
+    { url = "https://files.pythonhosted.org/packages/37/4b/dfb89eb0e652a1ff073c39a59fb5e3a83cfe9b57a2c83fa6d78270101767/protobuf-7.35.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799", size = 328847, upload-time = "2026-06-11T21:55:34.035Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/58/dc12f2cd484951524af6e3382c785869b9b3fb5e52ee95ae23add53ee8f9/protobuf-7.35.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4", size = 344030, upload-time = "2026-06-11T21:55:34.941Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/be/5b3cfe508bfab6761414ff944e3366eb13be4fd71efcd69450f89ba39f43/protobuf-7.35.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4", size = 327130, upload-time = "2026-06-11T21:55:35.921Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/bc/6d6c7ba8709c85f8f2c390b2b118d6fb08a783676a572271851bf45a7d22/protobuf-7.35.1-cp310-abi3-win32.whl", hash = "sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30", size = 428945, upload-time = "2026-06-11T21:55:37.034Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/19/8d0cb6f20a1ef7b18f1c8986ad5783f22f84cce39c6ce9a6e645ea55192e/protobuf-7.35.1-cp310-abi3-win_amd64.whl", hash = "sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87", size = 439996, upload-time = "2026-06-11T21:55:38.123Z" },
+    { url = "https://files.pythonhosted.org/packages/19/c7/5f7c636ec43e0c545e28d1f1db71990108306f7bdcb89f069ba97e428e7f/protobuf-7.35.1-py3-none-any.whl", hash = "sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9", size = 171659, upload-time = "2026-06-11T21:55:39.155Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pynacl"
+version = "1.6.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692, upload-time = "2026-01-01T17:48:10.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/7b/4845bbf88e94586ec47a432da4e9107e3fc3ce37eb412b1398630a37f7dd/pynacl-1.6.2-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:c949ea47e4206af7c8f604b8278093b674f7c79ed0d4719cc836902bf4517465", size = 388458, upload-time = "2026-01-01T17:32:16.829Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b4/e927e0653ba63b02a4ca5b4d852a8d1d678afbf69b3dbf9c4d0785ac905c/pynacl-1.6.2-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8845c0631c0be43abdd865511c41eab235e0be69c81dc66a50911594198679b0", size = 800020, upload-time = "2026-01-01T17:32:18.34Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/81/d60984052df5c97b1d24365bc1e30024379b42c4edcd79d2436b1b9806f2/pynacl-1.6.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22de65bb9010a725b0dac248f353bb072969c94fa8d6b1f34b87d7953cf7bbe4", size = 1399174, upload-time = "2026-01-01T17:32:20.239Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f7/322f2f9915c4ef27d140101dd0ed26b479f7e6f5f183590fd32dfc48c4d3/pynacl-1.6.2-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46065496ab748469cdd999246d17e301b2c24ae2fdf739132e580a0e94c94a87", size = 835085, upload-time = "2026-01-01T17:32:22.24Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d0/f301f83ac8dbe53442c5a43f6a39016f94f754d7a9815a875b65e218a307/pynacl-1.6.2-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a66d6fb6ae7661c58995f9c6435bda2b1e68b54b598a6a10247bfcdadac996c", size = 1437614, upload-time = "2026-01-01T17:32:23.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/58/fc6e649762b029315325ace1a8c6be66125e42f67416d3dbd47b69563d61/pynacl-1.6.2-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:26bfcd00dcf2cf160f122186af731ae30ab120c18e8375684ec2670dccd28130", size = 818251, upload-time = "2026-01-01T17:32:25.69Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a8/b917096b1accc9acd878819a49d3d84875731a41eb665f6ebc826b1af99e/pynacl-1.6.2-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c8a231e36ec2cab018c4ad4358c386e36eede0319a0c41fed24f840b1dac59f6", size = 1402859, upload-time = "2026-01-01T17:32:27.215Z" },
+    { url = "https://files.pythonhosted.org/packages/85/42/fe60b5f4473e12c72f977548e4028156f4d340b884c635ec6b063fe7e9a5/pynacl-1.6.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:68be3a09455743ff9505491220b64440ced8973fe930f270c8e07ccfa25b1f9e", size = 791926, upload-time = "2026-01-01T17:32:29.314Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f9/e40e318c604259301cc091a2a63f237d9e7b424c4851cafaea4ea7c4834e/pynacl-1.6.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b097553b380236d51ed11356c953bf8ce36a29a3e596e934ecabe76c985a577", size = 1363101, upload-time = "2026-01-01T17:32:31.263Z" },
+    { url = "https://files.pythonhosted.org/packages/48/47/e761c254f410c023a469284a9bc210933e18588ca87706ae93002c05114c/pynacl-1.6.2-cp38-abi3-win32.whl", hash = "sha256:5811c72b473b2f38f7e2a3dc4f8642e3a3e9b5e7317266e4ced1fba85cae41aa", size = 227421, upload-time = "2026-01-01T17:32:33.076Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ad/334600e8cacc7d86587fe5f565480fde569dfb487389c8e1be56ac21d8ac/pynacl-1.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:62985f233210dee6548c223301b6c25440852e13d59a8b81490203c3227c5ba0", size = 239754, upload-time = "2026-01-01T17:32:34.557Z" },
+    { url = "https://files.pythonhosted.org/packages/29/7d/5945b5af29534641820d3bd7b00962abbbdfee84ec7e19f0d5b3175f9a31/pynacl-1.6.2-cp38-abi3-win_arm64.whl", hash = "sha256:834a43af110f743a754448463e8fd61259cd4ab5bbedcf70f9dabad1d28a394c", size = 184801, upload-time = "2026-01-01T17:32:36.309Z" },
+]
+
+[[package]]
+name = "pyomo"
+version = "6.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ply" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/53/69/84bbedd016eb8a4ab2bcc9dbffd346b266ff631d44552baea01b87862555/pyomo-6.9.2.tar.gz", hash = "sha256:81b2b14ea619244824e1c547cc12602fe9a6e19309cbf0742868c5b1ef37cb35", size = 2946406, upload-time = "2025-04-16T18:55:23.354Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/69/f712dc53897e85485b4e4528202c61af0db6866ae01fe1f3f8e17920f72b/pyomo-6.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2574b833784551bb2ee45b3f371d7cf5589f5b2a4864920780c1ba33293bd4df", size = 5695274, upload-time = "2025-04-16T19:06:39.13Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/c4/e3bef6632094baa7fe10887609d9528751b226c1f5e0a13ffca86b31ab44/pyomo-6.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:64e491759e370272597b57fe33b20cafb47452019ab60811082ee5691dd61857", size = 5500932, upload-time = "2025-04-16T19:06:41.266Z" },
+    { url = "https://files.pythonhosted.org/packages/94/a1/c84a2e3c0a9c3f04605f105b048d1c9d3ca66880ebd3d8b6e3f3c72b26da/pyomo-6.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:870055e0aab64d814862c6e59f7f267e6dc5739f4714789452d584a6399ee91a", size = 13199464, upload-time = "2025-04-16T19:51:11.826Z" },
+    { url = "https://files.pythonhosted.org/packages/21/0c/920b57c3ca07b3fb214ba8cc39f0e638144822ba4deb9e20ddf8c88a5912/pyomo-6.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:120c84a895803af9b37bfd3955fefcd484b005477ec20e9cacf7ed0dfa9a4680", size = 13358782, upload-time = "2025-04-16T18:58:17.28Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/37/42d58dc4e1d1e99608399751f5ee18c211d96c3ef478497afb12038fbd41/pyomo-6.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:3df7548815ee4639600668808da4239e43263005ce55d94357053cf8fb0d6454", size = 5146445, upload-time = "2025-04-16T18:58:19.598Z" },
+    { url = "https://files.pythonhosted.org/packages/38/78/2dc7f8f17e34ee6c91911cb193dcad2e758c5db34029aa99a66aa3be32a6/pyomo-6.9.2-cp310-cp310-win_arm64.whl", hash = "sha256:a2c92c8533b4797d08513e944ea32ad862308b8d6d3c4805dff183bb59d65b95", size = 4952186, upload-time = "2025-04-16T18:58:22.212Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/88/0a07233e39357d3d620186485b927074d6d0ae0f64ad72cc5222ae05844e/pyomo-6.9.2-py3-none-any.whl", hash = "sha256:13ebb2f974f97afa626c2712d4f27e09a1c3d18ca11755676b743504a76e5161", size = 3799154, upload-time = "2025-04-16T18:55:52.044Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608, upload-time = "2025-03-25T05:01:28.114Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload-time = "2025-03-25T05:01:24.908Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-discovery"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/48/60/e88788207d81e46362cfbef0d4aaf4c0f49efc3c12d4c3fa3f542c34ebec/python_discovery-1.3.1.tar.gz", hash = "sha256:62f6db28064c9613e7ca76cb3f00c38c839a07c31c00dfe7ed0986493d2150a6", size = 68011, upload-time = "2026-05-12T20:53:36.336Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/6f/a05a317a66fee0aad270011461f1a63a453ed12471249f172f7d2e2bc7b4/python_discovery-1.3.1-py3-none-any.whl", hash = "sha256:ed188687ebb3b82c01a17cd5ac62fc94d9f6487a7f1a0f9dfe89753fec91039c", size = 33185, upload-time = "2026-05-12T20:53:34.969Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+]
+
+[[package]]
+name = "ray"
+version = "2.56.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "filelock" },
+    { name = "jsonschema" },
+    { name = "msgpack" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "pyyaml" },
+    { name = "requests" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c0/d6ffbe8ae2e2e10ea07aa08ea2dd35597239f0b3faaa29b5d7bbc405ab32/ray-2.56.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f34b2345a47ad144292c1b34eeba2ed8d556078f7bd118d1adf2090d5199c843", size = 66362009, upload-time = "2026-06-29T20:50:14.442Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/15/037f9eac9d3d43079611ca6af58c34b2a4271b9a94d57679356981b7b8e9/ray-2.56.0-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:15ea7ac36bfa3961c1eb2b2a099ed7dcf892f001f462920b6ec379ccafb038b0", size = 73212371, upload-time = "2026-06-29T20:50:21.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/a3/2d0fbe2d8808ae8837885051f149cefdca3e869eaef4c65618173fa63db5/ray-2.56.0-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:58be75df2d4a6a85b5e514e4d3261760fe21cc09ba974ce22cc08a8e4e07c449", size = 74067715, upload-time = "2026-06-29T20:50:26.661Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/05/70492aed281a235421ffd116b2eb74f127f387580bb63a7f8ce5c901169e/ray-2.56.0-cp310-cp310-win_amd64.whl", hash = "sha256:b837c5a905647c9b6a4f55061c2782437da24009e4eb4781db1c9c4badc84d0b", size = 28394809, upload-time = "2026-06-29T20:50:31.035Z" },
+]
+
+[[package]]
+name = "ray-dispatcher"
+version = "0.1.1"
+source = { git = "https://github.com/miciav/ray-dispatcher.git?tag=v0.1.1#8705c08e896978dd5bda030cc54af9bdf6a3ab89" }
+dependencies = [
+    { name = "fabric" },
+    { name = "pyyaml" },
+    { name = "ray" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/67/cae617f1351490c25a4b8ac3b8b63a4dda609295d8222bad12242dfdc629/rich-14.3.4.tar.gz", hash = "sha256:817e02727f2b25b40ef56f5aa2217f400c8489f79ca8f46ea2b70dd5e14558a9", size = 230524, upload-time = "2026-04-11T02:57:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/76/6d163cfac87b632216f71879e6b2cf17163f773ff59c00b5ff4900a80fa3/rich-14.3.4-py3-none-any.whl", hash = "sha256:07e7adb4690f68864777b1450859253bed81a99a31ac321ac1817b2313558952", size = 310480, upload-time = "2026-04-11T02:57:47.484Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" },
+    { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/21/a7d5c126d5b557715ef81098f3db2fe20f622a039ff2e626af28d674ab80/ruff-0.15.13.tar.gz", hash = "sha256:f9d89f17f7ba7fb2ed42921f0df75da797a9a5d71bc39049e2c687cf2baf44b7", size = 4678180, upload-time = "2026-05-14T13:44:37.869Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/61/11d458dc6ac22504fd8e237b29dfd40504c7fbbcc8930402cfe51a8e63ed/ruff-0.15.13-py3-none-linux_armv6l.whl", hash = "sha256:444b580fc72fd6887e650acd3e575e18cdc79dbcf42fb4030b491057921f61f8", size = 10738279, upload-time = "2026-05-14T13:44:18.7Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ca/caa871ee7be718c45256fada4e16a218ee3e33f0c4a46b729a60a24912e6/ruff-0.15.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6590d009e7cb7ebf36f83dbdd44a3fa48a0994ff6f1cdc1b08006abe58f98dc7", size = 11124798, upload-time = "2026-05-14T13:44:06.427Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/19/43f5f2e568dddde567fc41f8471f9432c09563e19d3e617a48cfa52f8f0a/ruff-0.15.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1c26d2f66163deeb6e08d8b39fbbe983ce3c71cea06a6d7591cfd1421793c629", size = 10460761, upload-time = "2026-05-14T13:44:04.375Z" },
+    { url = "https://files.pythonhosted.org/packages/99/df/cf938cd6de3003178f03ad7c1ea2a6c099468c03a35037985070b37e76be/ruff-0.15.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dbd6f94b434f896308e4d57fb7bfde0d02b99f7a64b3bdab0fdfa6a864203a5", size = 10804451, upload-time = "2026-05-14T13:44:25.221Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7d/5d0973129b154ded2225729169d7068f26b467760b146493fde138415f23/ruff-0.15.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf3259f3be4d181bda591da5db2571aed6853c6a048157756448020bc6c5cd22", size = 10534285, upload-time = "2026-05-14T13:44:08.888Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e3/6b999bbc66cd51e5f073842bc2a3995e99c5e0e72e16b15e7261f7abf57a/ruff-0.15.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae9c17e5eb4430c154e76abc25d79a318190f5a997f38fb6b114416c5319ffc9", size = 11312063, upload-time = "2026-05-14T13:44:11.274Z" },
+    { url = "https://files.pythonhosted.org/packages/af/5a/642639e9f5db04f1e97fbd6e091c6fd20725bdf072fb114d00eefb9e6eb8/ruff-0.15.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e2e39bff6c341f4b577a21b801326fab0b11847f48fcaa83f00a113c9b3cb55", size = 12183079, upload-time = "2026-05-14T13:44:01.634Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4c/7585735f6b53b0f12de13618b2f7d250a844f018822efc899df2e7b8295f/ruff-0.15.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e8d9a8e08013542e94d3220bc5b62cc3e5ef87c5f74bff367d3fac14fab013e6", size = 11440833, upload-time = "2026-05-14T13:43:59.043Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/31/bf1a0803d077e679cfeee5f2f67290a0fa79c7385b5d9a8c17b9db2c48f0/ruff-0.15.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc411dfebe5eebe55ce041c6ae080eb7668955e866daa2fbb16692a784f1c4ca", size = 11434486, upload-time = "2026-05-14T13:44:27.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4e/62c9b999875d4f14db80f277c030578f5e249c9852d65b7ac7ad0b43c041/ruff-0.15.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:768494eb08b9cee54e2fd27969966f74db5a57f6eaa7a90fcb3306af34dfc4bd", size = 11385189, upload-time = "2026-05-14T13:44:13.704Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/89/7e959047a104df3eb12863447c110140191fc5b6c4f379ea2e803fcdb0e4/ruff-0.15.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:fb75f9a3a7e42ffe117d734494e6c5e5cb3565d66e12612cb63d0e572a41a5b6", size = 10781380, upload-time = "2026-05-14T13:43:56.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/52/5fd18f3b88cab63e88aa11516b3b4e1e5f720e5c330f8dbe5c26210f41f8/ruff-0.15.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8cb74dd33bb2f6613faf7fc03b660053b5ac4f80e706d5788c6335e2a8048d51", size = 10540605, upload-time = "2026-05-14T13:44:20.748Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/e0/9e35f338990d3e41a82875ff7053ffe97541dae81c9d02143177f381d572/ruff-0.15.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7ef823f817fcd191dc934e984be9cf4094f808effa16f2542ad8e821ba02bbf2", size = 11036554, upload-time = "2026-05-14T13:44:16.256Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/13/070fb048c24080fba188f66371e2a92785be257ad02242066dc7255ac6e9/ruff-0.15.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f345a13937bd7f09f6f5d19fa0721b0c103e00e7f62bc67089a8e5e037719e0b", size = 11528133, upload-time = "2026-05-14T13:44:22.808Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8c/b1e1666aef7fc6555094d73ae6cd981701781ae85b97ceefc0eebd0b4668/ruff-0.15.13-py3-none-win32.whl", hash = "sha256:4044f94208b3b05ba0fc4a4abd0558cf4d6459bd18325eead7fd8cc66f909b41", size = 10721455, upload-time = "2026-05-14T13:44:35.697Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a6/870a3e8a50590bb92be184ad928c2922f088b00d9dc5c5ec7b924ee08c22/ruff-0.15.13-py3-none-win_amd64.whl", hash = "sha256:7064884d442b7d477b4e7473d12da7f08851d2b1982763c5d3f388a19468a1a4", size = 11900409, upload-time = "2026-05-14T13:44:30.389Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/36/9c015cd052fca743dae8cb2aeb16b551444787467db42ceab0fc968865af/ruff-0.15.13-py3-none-win_arm64.whl", hash = "sha256:2471da9bd1068c8c064b5fd9c0c4b6dddffd6369cb1cd68b29993b1709ff1b21", size = 11179336, upload-time = "2026-05-14T13:44:33.026Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.15.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" },
+    { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" },
+]
+
+[[package]]
+name = "seaborn"
+version = "0.13.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
+]
+
+[[package]]
+name = "types-pytz"
+version = "2026.2.0.20260518"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/d9/9fa4019d2235bd374293e1fd4153879b28b6ae1d2bae98addd352c9713f2/types_pytz-2026.2.0.20260518.tar.gz", hash = "sha256:e5d254329e9c4e91f0781b22c43a4bb2d10bb044d97b24c4b05d45567b0eae16", size = 10871, upload-time = "2026-05-18T06:02:45.789Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/89/41e80670779a223d8bc8bc83019a619988cfa5c432cedac5cec23884fbc4/types_pytz-2026.2.0.20260518-py3-none-any.whl", hash = "sha256:3a12eaa38f476bd650902a9c9bb442f03f3c7dee2be5c5848bce61bd708d205a", size = 10125, upload-time = "2026-05-18T06:02:44.968Z" },
+]
+
+[[package]]
+name = "types-pyyaml"
+version = "6.0.12.20260518"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b8/83/4a1afc3fbfcf5b8d46fc390cd95ed6b0dc9010a265f4e9f46314efffa37a/types_pyyaml-6.0.12.20260518.tar.gz", hash = "sha256:d917f83fb38462550338c1297faedd860b3ec83912b96b1e3d73255f7473e466", size = 17850, upload-time = "2026-05-18T06:01:58.675Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/a2/c01db32be2ae7d6a1689972f3c492b149ee4e164b12fdfd9f64b50888215/types_pyyaml-6.0.12.20260518-py3-none-any.whl", hash = "sha256:d2150f75a231c9fe9c7463bd29487d93e60bac90400287351384bc2284eba7cd", size = 20312, upload-time = "2026-05-18T06:01:57.368Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "21.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/15/ba/1f6e8c957e4932be060dcdc482d339c12e0216351478add3645cdaa53c05/virtualenv-21.3.3.tar.gz", hash = "sha256:f5bda277e553b1c2b3c1a8debfc30496e1288cc93ce6b7b71b3280047e317328", size = 7613784, upload-time = "2026-05-13T18:01:30.19Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/34/a9dbe051de88a63eb7408ea66630bac38e72f7f6077d4be58737106860d9/virtualenv-21.3.3-py3-none-any.whl", hash = "sha256:7d5987d8369e098e41406efb780a3d4ca79280097293899e351a6407ee153ab3", size = 7594554, upload-time = "2026-05-13T18:01:27.815Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "2.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/a4/282c8e64300a59fc834518a54bf0afabb4ff9218b5fa76958b450459a844/wrapt-2.2.2.tar.gz", hash = "sha256:0788e321027c999bf221b667bd4a54aaefd1a36283749a860ac3eb77daed0302", size = 129068, upload-time = "2026-06-20T23:49:44.49Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/8b/59781d0fe7b0adfbea37f600857de4be68921e454aeecf1a11bda35cdccc/wrapt-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:055e6fcfaa28e58c6a8c247d48b92be9d56f818b7068aa4f22b15b3343a09931", size = 80556, upload-time = "2026-06-20T23:47:28.473Z" },
+    { url = "https://files.pythonhosted.org/packages/94/dc/66c61aca927230c9cf97a3cb005c803971a1076ff9f7d61085d035c20085/wrapt-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8374eb6b1a58809211e84ff835a182bb17ab2807a5bfef23204c8cff38178a00", size = 81648, upload-time = "2026-06-20T23:47:30.504Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1b/545eee1c18f3af4cf140bb5822b6ef81ebe569df0a63ac109973103a30a5/wrapt-2.2.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:656593bb3f5529f03d27af4136c4d7b11990e470bcbc6fefa5ef218695bece55", size = 152956, upload-time = "2026-06-20T23:47:31.867Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a7/6f42a3d03e44dc612a5dcff324e7366075a7857f0be2d49a8cb8a68279b8/wrapt-2.2.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfb00cb7bb22099e2f64b7340fb96113639aa7260c0972af3797ace2297b936c", size = 154771, upload-time = "2026-06-20T23:47:33.352Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/55/4d76175aaa97523c38f1d28f79d18ab41a1b116814158a818bc0eba00571/wrapt-2.2.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e7f10ee0bd53673bfd52b67cbce83336fe6cad90d2377b03baf66491d2bbfb91", size = 149460, upload-time = "2026-06-20T23:47:34.712Z" },
+    { url = "https://files.pythonhosted.org/packages/84/9b/12e23264d8f4735e8483262f95c5a6b03c3665fd2a84bdf99a45b6a2f4ec/wrapt-2.2.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4402f57c5f0d0579599858ffbdd9bf4e3f0972f51096f2bd6cc7dab6b76ee49e", size = 153648, upload-time = "2026-06-20T23:47:36.092Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a3/bcd5ec37289dcd85ecd4d15395a6a6063d60bc45ff94a9d77814e1e54d64/wrapt-2.2.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:3a4eb7964ff4643d333c84f880bcf554652b2a1050aebc54ae696327f61acfaf", size = 148502, upload-time = "2026-06-20T23:47:37.623Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/be/716d708f607fa70f8a6eb47dff8ee945d5278dfc89ffeeff33039d052e63/wrapt-2.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e542b7c5af91e2123a8aabf19894319d5ec4268d2a9ffd2f239386133fc47746", size = 152238, upload-time = "2026-06-20T23:47:39.118Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/c0/1a48e7e54501274f5d906f18372221b13183b0afbb5b8bb4c7ca0392c0b4/wrapt-2.2.2-cp310-cp310-win32.whl", hash = "sha256:6e7e45b43d3c774d244fe7264378f5a3f0f383bc55a54a9866434e524540110f", size = 77278, upload-time = "2026-06-20T23:47:40.476Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/82/9cd69a1af288fbdedf01a10e3c8a0b6890b08c7f3f96d36a213699dbcd94/wrapt-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:955f1d6e72a352e478de8d8b503abe301c5e139a141b62eb0923bd694995025f", size = 80131, upload-time = "2026-06-20T23:47:41.785Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/73/8db7e27daef37ae70a53ea62bef7fe80cc51a8b5e9e9181a8be6eb9a999c/wrapt-2.2.2-cp310-cp310-win_arm64.whl", hash = "sha256:b89d8d73c82db2bb7e6090b3afd7973f980d24e905cc34394eab60b884b3bf67", size = 79615, upload-time = "2026-06-20T23:47:43.109Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d2/6317eb6d4554855bbf12d61857774af34747bf88a42c19bf306de67e2fa3/wrapt-2.2.2-py3-none-any.whl", hash = "sha256:5bad217350f19ce99ca5b5e71d406765ea86fe541628426772b657375ee1c048", size = 61460, upload-time = "2026-06-20T23:49:42.966Z" },
+]
diff --git a/what_if_analysis.py b/what_if_analysis.py
index a181183..09a12be 100644
--- a/what_if_analysis.py
+++ b/what_if_analysis.py
@@ -41,8 +41,11 @@ def parse_arguments() -> argparse.Namespace:
 
 
 def add_time(
-    best_sol_df: pd.DataFrame, loop_over: str, logs_df: pd.DataFrame
+    best_sol_df: pd.DataFrame, loop_over: str = "Nn", logs_df: pd.DataFrame = None
   ) -> pd.DataFrame:
+  if logs_df is None:
+    logs_df = loop_over
+    loop_over = "Nn"
   columns = ["exp",loop_over,"time","iteration"]
   if loop_over != "Nn":
     columns += ["Nn"]
@@ -158,7 +161,7 @@ def analyze_final_results(
 
 
 def compute_minmaxavg_in_milestone(
-    tvals: pd.DataFrame, milestone: float
+    tvals: pd.DataFrame, milestone: float, loop_over: str = "Nn"
   ) -> pd.DataFrame:
   columns = [loop_over,"obj","measured_total_time","dev","centralized_dev"]
   metrics_by_milestones = pd.DataFrame()
@@ -306,7 +309,9 @@ def compute_progressive_deviation(
           markersize = 10
         )
         # -- add to metrics
-        mmm = compute_minmaxavg_in_milestone(tvals_at_max, milestones[idx])
+        mmm = compute_minmaxavg_in_milestone(
+          tvals_at_max, milestones[idx], loop_over
+        )
         metrics_by_milestones = pd.concat(
           [metrics_by_milestones, mmm], ignore_index = True
         )
@@ -326,7 +331,7 @@ def compute_progressive_deviation(
         markersize = 10
       )
       # -- add to metrics
-      mmm = compute_minmaxavg_in_milestone(tvals_at_max, 3600)
+      mmm = compute_minmaxavg_in_milestone(tvals_at_max, 3600, loop_over)
       metrics_by_milestones = pd.concat(
         [metrics_by_milestones, mmm], ignore_index = True
       )
@@ -350,8 +355,8 @@ def compute_progressive_deviation(
 
 
 def find_best_iterations(
-    experiment_folder: str, loop_over: str
-  ) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    experiment_folder: str, loop_over: str = "Nn"
+  ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
   # build folder to store the analysis outcomes
   output_folder = os.path.join(experiment_folder, "postprocessing")
   os.makedirs(output_folder, exist_ok = True)
@@ -364,22 +369,31 @@ def find_best_iterations(
     Nn = int(data["None"]["Nn"]["None"])
   # get the "loop_over" value
   loop_over_val = None
-  with open(
-      os.path.join(experiment_folder, "config.json"), "r"
-    ) as istream:
-    base_config = json.load(istream)
-    exp_values = base_config["limits"].get(loop_over)
-    if exp_values is None:
-      exp_values = base_config["limits"]["neighborhood"][loop_over]
-      loop_over_val = exp_values
-    else:
-      loop_over_val = exp_values["min"]
+  config_path = os.path.join(experiment_folder, "config.json")
+  if os.path.exists(config_path):
+    with open(config_path, "r") as istream:
+      base_config = json.load(istream)
+      exp_values = base_config["limits"].get(loop_over)
+      if exp_values is None:
+        exp_values = base_config["limits"]["neighborhood"][loop_over]
+        loop_over_val = exp_values
+      else:
+        loop_over_val = exp_values["min"]
+  else:
+    loop_over_val = Nn if loop_over == "Nn" else None
   # check the method to consider
   method_name = None
-  with open(os.path.join(experiment_folder, "obj.csv"), "r") as istream:
-    mname = istream.readline()
-    method_name = "faas-macro" if "MACrO" in mname else (
-      "faas-madea" if "MADeA" in mname else "centralized"
+  obj_path = os.path.join(experiment_folder, "obj.csv")
+  if os.path.exists(obj_path):
+    with open(obj_path, "r") as istream:
+      mname = istream.readline()
+      method_name = "faas-macro" if "MACrO" in mname else (
+        "faas-madea" if "MADeA" in mname else "centralized"
+      )
+  else:
+    files = os.listdir(experiment_folder)
+    method_name = "faas-macro" if "LSP_solution.csv" in files else (
+      "faas-madea" if "LSPc_solution.csv" in files else "centralized"
     )
   # parse logs file
   exp = os.path.basename(experiment_folder)
@@ -466,9 +480,10 @@ def find_best_iterations(
   )
   plt.close()
   # add method name
+  logs_df["method"] = method_name
   best_sol_df["social_welfare"]["method"] = method_name
   best_sol_df["centralized"]["method"] = method_name
-  return best_sol_df["social_welfare"], best_sol_df["centralized"]
+  return best_sol_df["social_welfare"], best_sol_df["centralized"], logs_df
 
 
 def main(base_folder: str, loop_over: str, milestones: list):
@@ -478,6 +493,7 @@ def main(base_folder: str, loop_over: str, milestones: list):
   # load information
   by_social_welfare = pd.DataFrame()
   by_centralized_objective = pd.DataFrame()
+  all_logs_df = pd.DataFrame()
   for foldername in os.listdir(base_folder):
     experiment_folder = os.path.join(base_folder, foldername)
     if os.path.isdir(experiment_folder) and not foldername.startswith("."):
@@ -486,13 +502,16 @@ def main(base_folder: str, loop_over: str, milestones: list):
             "LSPc_solution.csv" in os.listdir(experiment_folder)
         ):
         print(foldername)
-        sw, cobj = find_best_iterations(experiment_folder, loop_over)
+        sw, cobj, ldf = find_best_iterations(experiment_folder, loop_over)
         by_social_welfare = pd.concat(
           [by_social_welfare, sw], ignore_index = True
         )
         by_centralized_objective = pd.concat(
           [by_centralized_objective, cobj], ignore_index = True
         )
+        all_logs_df = pd.concat(
+          [all_logs_df, ldf], ignore_index = True
+        )
   # analyze final result
   last_by_sw = by_social_welfare.groupby(
     ["method", "exp", loop_over, "time"]
@@ -505,6 +524,10 @@ def main(base_folder: str, loop_over: str, milestones: list):
   compute_progressive_deviation(
     by_centralized_objective, loop_over, milestones, output_folder
   )
+  # save logs
+  all_logs_df.to_csv(
+    os.path.join(output_folder, "all_logs_df.csv"), index = False
+  )
 
 
 if __name__ == "__main__":
@@ -513,4 +536,3 @@ def main(base_folder: str, loop_over: str, milestones: list):
   loop_over = args.loop_over
   milestones = [int(m) for m in args.milestones]
   main(base_folder, loop_over, milestones)
-