[
  {
    "id": "L0.R0.hello-world",
    "title": "Hello World conformance slot",
    "level": 0,
    "status": "Draft",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 0,
    "cases": 1,
    "max_program_len": 256,
    "max_steps_per_case": 100000,
    "max_output_len": 0,
    "max_memory_cells": 59049,
    "purpose": "Historical classic Malbolge Hello World conformance slot: a clean halt with zero output."
  },
  {
    "id": "L0.R1.echo-1-demo",
    "title": "Echo one byte demo",
    "level": 0,
    "status": "Frozen",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 64,
    "max_steps_per_case": 32,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Bootstrap slot: proof that a real classic Malbolge program can pass verification."
  },
  {
    "id": "L1.R0.echo-1",
    "title": "Echo one byte",
    "level": 1,
    "status": "Frozen",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 64,
    "max_steps_per_case": 32,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "The smallest public candidate rung: synthesize a program that echoes the first input byte."
  },
  {
    "id": "L1.R1.echo-2",
    "title": "Echo two bytes",
    "level": 1,
    "status": "Calibration",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 2,
    "cases": 1,
    "max_program_len": 128,
    "max_steps_per_case": 256,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "Extend echo-prefix synthesis from one byte to two bytes."
  },
  {
    "id": "L1.R2.echo-4",
    "title": "Echo four bytes",
    "level": 1,
    "status": "Calibration",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 4,
    "cases": 1,
    "max_program_len": 256,
    "max_steps_per_case": 1024,
    "max_output_len": 4,
    "max_memory_cells": 59049,
    "purpose": "Longer straight-line copying with more room for agent mistakes."
  },
  {
    "id": "L1.R3.echo-2-multicase",
    "title": "Echo two bytes across multiple cases",
    "level": 1,
    "status": "Calibration",
    "family": "EchoPrefix",
    "transform": "Identity",
    "output_bytes": 2,
    "cases": 2,
    "max_program_len": 256,
    "max_steps_per_case": 1024,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "Require one program to survive multiple hash-derived inputs."
  },
  {
    "id": "L2.R0.xor-1",
    "title": "Xor one byte",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 256,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Apply the v0 xor-mask transform to the first byte.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.R0d.xor-1-len4096",
    "title": "Xor one byte with 4096-byte program cap",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Same v0 xor-mask task as L2.R0.xor-1, with only the program-length cap relaxed for calibration.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.R0c.crazy-mask-1",
    "title": "Crazy-mask one byte",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "CrazyMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 512,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Apply output = crazy(input, 0x51) mod 256 to the first byte. The transform is per-trit realizable inside a CRAZY-chain dispatch, so this rung demands totality over all 256 inputs without XOR's binary-carry obstruction. It sits between the finite-map rungs and full xor-1.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.FM0.xor51-map2",
    "title": "Finite-map xor51 over two published bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6
    ],
    "output_bytes": 1,
    "cases": 2,
    "max_program_len": 512,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Require one candidate to map the published bytes 0x02->0x53 and 0x06->0x57. This is finite-map calibration, not full byte-wide xor1."
  },
  {
    "id": "L2.FM1.xor51-map4",
    "title": "Finite-map xor51 over four published bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48
    ],
    "output_bytes": 1,
    "cases": 4,
    "max_program_len": 1024,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Extend finite-map xor51 routing to four published one-byte inputs. This remains a published finite map, not hidden holdout generality."
  },
  {
    "id": "L2.FM1b.xor51-map6",
    "title": "Finite-map xor51 over six published bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48,
      130,
      111
    ],
    "output_bytes": 1,
    "cases": 6,
    "max_program_len": 1536,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Half-step between map4 and map8: the four map4 bytes plus the first two map8 extension bytes. Sized for single-dispatch routing with richer lane shapes."
  },
  {
    "id": "L2.FM1c.xor51-map7a",
    "title": "Finite-map xor51 over seven published bytes (map8 minus 0xc0)",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48,
      130,
      111,
      167
    ],
    "output_bytes": 1,
    "cases": 7,
    "max_program_len": 1792,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Fills the map6-to-map8 difficulty cliff from the easy side: the six map6 bytes plus 0xa7. Dispatch feasibility: 539 separating configs, against 1261 for map6 and 39 for map8 (measured with `malbolge-rungs feasibility`)."
  },
  {
    "id": "L2.FM1d.xor51-map7b",
    "title": "Finite-map xor51 over seven published bytes (map8 minus 0xa7)",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48,
      130,
      111,
      192
    ],
    "output_bytes": 1,
    "cases": 7,
    "max_program_len": 1792,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "The steep half of the map6-to-map8 cliff: the six map6 bytes plus 0xc0, the input that collapses dispatch separation. Dispatch feasibility: 50 separating configs, against 1261 for map6 and 39 for map8."
  },
  {
    "id": "L2.FM2.xor51-map8",
    "title": "Finite-map xor51 over eight published bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48,
      130,
      111,
      167,
      192
    ],
    "output_bytes": 1,
    "cases": 8,
    "max_program_len": 2048,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Bridge known finite-map/routing evidence toward the full XOR frontier with eight published one-byte inputs."
  },
  {
    "id": "L2.FM2h.xor51-map12-hi",
    "title": "Finite-map xor51 over twelve high-range bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      165,
      224,
      144,
      156,
      132,
      161,
      189,
      200,
      190,
      249,
      134,
      221
    ],
    "output_bytes": 1,
    "cases": 12,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Input-placement probe: twelve inputs drawn deterministically from 0x80..=0xff (sha256(\"mal51-fm-hi-v0:<counter>\") first byte, filtered, deduplicated). High-range inputs admit identity-dispatch landings above the prefix/data zone, isolating routing capacity from the low-landing structural problem."
  },
  {
    "id": "L2.FM2l.xor51-map12-low",
    "title": "Finite-map xor51 over twelve low-range bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      8,
      55,
      53,
      26,
      42,
      50,
      56,
      47,
      13,
      24,
      59,
      20
    ],
    "output_bytes": 1,
    "cases": 12,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Input-placement probe: twelve inputs drawn deterministically from 0x00..=0x40 (sha256(\"mal51-fm-low-v0:<counter>\") first byte, filtered, deduplicated). Same count as map12-hi but inputs whose natural landings collide with prefix and dispatch data, exercising the low-landing problem specifically."
  },
  {
    "id": "L2.FM3.xor51-map16",
    "title": "Finite-map xor51 over sixteen published bytes",
    "level": 2,
    "status": "Calibration",
    "family": "FiniteMap",
    "transform": "XorMask",
    "finite_map_inputs": [
      2,
      6,
      9,
      48,
      130,
      111,
      167,
      192,
      197,
      246,
      28,
      135,
      240,
      45,
      74,
      133
    ],
    "output_bytes": 1,
    "cases": 16,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "The largest v0 finite-map xor51 calibration rung. Passing it is meaningful routing evidence but still does not solve full byte-wide xor1."
  },
  {
    "id": "L2.C0.xor51-cov32",
    "title": "Xor-mask coverage over at least 32 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 32,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "All 256 single-byte inputs are enumerated; the candidate must halt with the correct xor51 output on at least 32 of them. Mismatches and non-halting runs on other inputs are tolerated. This makes partial-coverage progress deterministic and measurable."
  },
  {
    "id": "L2.C0a.xor51-cov34",
    "title": "Xor-mask coverage over at least 34 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 34,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Coverage-ladder step between cov32 and cov36: all 256 single-byte inputs, at least 34 exact xor51 outputs required, failures elsewhere tolerated. Added 2026-08-10 and strictly additive. 34 is the exhaustive ceiling of the branchless CRAZY/ROTATE family, so this step asks for that family's optimum realized in the machine; cov36 and up cannot be reached without input-dependent branching."
  },
  {
    "id": "L2.C0b.xor51-cov36",
    "title": "Xor-mask coverage over at least 36 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 36,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Coverage-ladder step between cov32 and cov64: all 256 single-byte inputs, at least 36 exact xor51 outputs required, failures elsewhere tolerated."
  },
  {
    "id": "L2.C0c.xor51-cov40",
    "title": "Xor-mask coverage over at least 40 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 40,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Coverage-ladder step between cov32 and cov64: all 256 single-byte inputs, at least 40 exact xor51 outputs required, failures elsewhere tolerated."
  },
  {
    "id": "L2.C0d.xor51-cov48",
    "title": "Xor-mask coverage over at least 48 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 48,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Coverage-ladder step between cov32 and cov64: all 256 single-byte inputs, at least 48 exact xor51 outputs required, failures elsewhere tolerated."
  },
  {
    "id": "L2.C0e.xor51-cov48-len2048",
    "title": "Xor-mask coverage over at least 48 of 256 inputs, in 2048 bytes",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 48,
    "max_program_len": 2048,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Length-pressure variant of cov48, added 2026-08-10 and strictly additive. Same threshold, half the space: the shipped cov48 program scores 71/256 in 3178 bytes, so this rung asks for the same coverage in less room. It isolates program size as its own axis, which is what separates the 256-byte transform rungs from the 4096-byte coverage rungs."
  },
  {
    "id": "L2.C1.xor51-cov64",
    "title": "Xor-mask coverage over at least 64 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 64,
    "max_program_len": 4096,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Same all-256 coverage scoring as cov32 with the threshold raised to 64. Passing it requires beating the shared-operand-pool ceiling of single-dispatch station architectures."
  },
  {
    "id": "L2.R1.reverse-1",
    "title": "Reverse one byte",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "Reverse",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 256,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "One-byte reverse is behaviorally trivial but useful as a transform-family sanity check.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.R2.rotate-1",
    "title": "Rotate one byte",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "RotateLeft",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 256,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Rotate the first input byte left by one bit.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.R3.xor-2-multicase",
    "title": "Xor two bytes across multiple cases",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 2,
    "cases": 2,
    "max_program_len": 384,
    "max_steps_per_case": 4096,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "Discourage constant-output shortcuts by requiring a transform over two cases.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L3.R0.reverse-2-multicase",
    "title": "Reverse two bytes across multiple cases",
    "level": 3,
    "status": "Calibration",
    "family": "Transform",
    "transform": "Reverse",
    "output_bytes": 2,
    "cases": 3,
    "max_program_len": 512,
    "max_steps_per_case": 8192,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "A small but real input-dependent transformation over several cases.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L3.R1.xor-4-length-cap",
    "title": "Xor four bytes with length pressure",
    "level": 3,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 4,
    "cases": 2,
    "max_program_len": 256,
    "max_steps_per_case": 8192,
    "max_output_len": 4,
    "max_memory_cells": 59049,
    "purpose": "Four-byte transform with a cap intended to expose brittle generated code.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L3.R2.mixed-transform-small",
    "title": "Small mixed transform",
    "level": 3,
    "status": "Draft",
    "family": "Transform",
    "transform": "NibbleMap",
    "output_bytes": 2,
    "cases": 3,
    "max_program_len": 512,
    "max_steps_per_case": 16384,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "Draft rung for compact deterministic byte remapping tasks.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L4.R0.hash-prefix-1",
    "title": "Hash prefix one byte",
    "level": 4,
    "status": "Draft",
    "family": "HashPrefix",
    "transform": "Identity",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 1024,
    "max_steps_per_case": 100000,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "A public finite lookup task. Five deterministic epochs fix five public input/target rows; the program is not given the seed, so clearing this shows a five-row map fits the machine, not that anything hash-like was computed.",
    "min_epochs": 5
  },
  {
    "id": "L4.R1.hash-prefix-1-multicase",
    "title": "Hash prefix one byte across multiple cases",
    "level": 4,
    "status": "Draft",
    "family": "HashPrefix",
    "transform": "Identity",
    "output_bytes": 1,
    "cases": 3,
    "max_program_len": 1024,
    "max_steps_per_case": 250000,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "A public finite lookup task: fifteen public input/target rows (five epochs, three cases). The program is not given the seed; nothing about hash computation is tested.",
    "min_epochs": 5
  },
  {
    "id": "L4.R2.hash-prefix-length-pressure",
    "title": "Hash prefix with length pressure",
    "level": 4,
    "status": "Draft",
    "family": "HashPrefix",
    "transform": "Identity",
    "output_bytes": 1,
    "cases": 2,
    "max_program_len": 256,
    "max_steps_per_case": 250000,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "A public finite lookup task under length pressure: ten public input/target rows (five epochs, two cases) against a 256-byte program cap.",
    "min_epochs": 5
  },
  {
    "id": "L5.R0.future-transform",
    "title": "Future transform placeholder",
    "level": 5,
    "status": "Draft",
    "family": "Transform",
    "transform": "NibbleMap",
    "output_bytes": 4,
    "cases": 4,
    "max_program_len": 1024,
    "max_steps_per_case": 1000000,
    "max_output_len": 4,
    "max_memory_cells": 59049,
    "purpose": "Reserved for a future calibrated transform rung.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L5.R1.future-hash-prefix",
    "title": "Future hash-prefix placeholder",
    "level": 5,
    "status": "Draft",
    "family": "HashPrefix",
    "transform": "Identity",
    "output_bytes": 2,
    "cases": 4,
    "max_program_len": 2048,
    "max_steps_per_case": 2000000,
    "max_output_len": 2,
    "max_memory_cells": 59049,
    "purpose": "Reserved for a future frontier hash-prefix rung after empirical calibration.",
    "min_epochs": 5
  },
  {
    "id": "L2.C2.xor51-cov96",
    "title": "Xor-mask coverage over at least 96 of 256 inputs",
    "level": 2,
    "status": "Calibration",
    "family": "CoverageTransform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 256,
    "min_correct_cases": 96,
    "max_program_len": 8192,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Coverage-ladder step above cov64, added 2026-08-10 and strictly additive. The 4096-byte cap is raised to 8192 here on purpose: the cov48 solve reached 71/256 using 3178 of its 4096 bytes at ~45 bytes per correct case, so a 96-case threshold under the old cap would test whether the program fits rather than how far coverage reaches. Program size is isolated instead by the cov48-len2048 rung."
  },
  {
    "level": 6,
    "status": "Frontier",
    "family": "Stream",
    "finite_map_inputs": [],
    "cases": 3,
    "min_input_len": 1,
    "max_input_len": 255,
    "min_epochs": 27,
    "max_memory_cells": 59049,
    "id": "L6.S0.cat",
    "transform": "Identity",
    "output_bytes": 255,
    "max_output_len": 255,
    "max_program_len": 4096,
    "max_steps_per_case": 262144,
    "title": "Echo the whole input, whatever its length",
    "purpose": "Every other rung on this ladder fixes the output width in its definition, so a candidate can be written straight-line: consume a known number of bytes, emit a known number back. This family is designed to pressure iteration instead. The input length is drawn from the challenge seed \u2014 the bounds are public, but the length of any given case is not knowable in advance \u2014 so the intended program reads until the input runs out: the VM sets a to the all-2s word on a read past the end, and that is the only signal it gets. That means a loop, and in classic Malbolge a loop is the hard part: every cell that executes is enciphered immediately afterwards, so the body is different code on its second pass and must either restore itself or ride the 94-cycle back to its starting values. Known to be possible \u2014 the published Malbolge programs that loop, from 99-bottles to the Nagoya LISP interpreter, all solve exactly this. The cases are deterministic and public (27 epochs of 3), so a pass does not prove a loop was used \u2014 a program could in principle dispatch on an identifying prefix and emit memorized answers \u2014 but unrolling by position is priced out: input up to 255 bytes against a 4096-byte cap leaves about 16 bytes per position, far under what an IN plus an end-of-input test plus a conditional jump plus an OUT costs under loader validity. Python: print(input()). The intended minimum: read a byte, emit it, repeat until the input ends."
  },
  {
    "level": 6,
    "status": "Frontier",
    "family": "Stream",
    "finite_map_inputs": [],
    "cases": 3,
    "min_input_len": 1,
    "max_input_len": 255,
    "min_epochs": 27,
    "max_memory_cells": 59049,
    "id": "L6.S1.length",
    "transform": "Length",
    "output_bytes": 1,
    "max_output_len": 1,
    "max_program_len": 4096,
    "max_steps_per_case": 262144,
    "title": "Output the number of input bytes",
    "purpose": "Every other rung on this ladder fixes the output width in its definition, so a candidate can be written straight-line: consume a known number of bytes, emit a known number back. This family is designed to pressure iteration instead. The input length is drawn from the challenge seed \u2014 the bounds are public, but the length of any given case is not knowable in advance \u2014 so the intended program reads until the input runs out: the VM sets a to the all-2s word on a read past the end, and that is the only signal it gets. That means a loop, and in classic Malbolge a loop is the hard part: every cell that executes is enciphered immediately afterwards, so the body is different code on its second pass and must either restore itself or ride the 94-cycle back to its starting values. Known to be possible \u2014 the published Malbolge programs that loop, from 99-bottles to the Nagoya LISP interpreter, all solve exactly this. The cases are deterministic and public (27 epochs of 3), so a pass does not prove a loop was used \u2014 a program could in principle dispatch on an identifying prefix and emit memorized answers \u2014 but unrolling by position is priced out: input up to 255 bytes against a 4096-byte cap leaves about 16 bytes per position, far under what an IN plus an end-of-input test plus a conditional jump plus an OUT costs under loader validity. Python: print(len(input())). Adds a counter that must survive the encipherment of the loop body it lives beside."
  },
  {
    "level": 6,
    "status": "Frontier",
    "family": "Stream",
    "finite_map_inputs": [],
    "cases": 3,
    "min_input_len": 1,
    "max_input_len": 255,
    "min_epochs": 27,
    "max_memory_cells": 59049,
    "id": "L6.S2.checksum",
    "transform": "Checksum",
    "output_bytes": 1,
    "max_output_len": 1,
    "max_program_len": 4096,
    "max_steps_per_case": 262144,
    "title": "Output the sum of the input bytes, mod 256",
    "purpose": "Every other rung on this ladder fixes the output width in its definition, so a candidate can be written straight-line: consume a known number of bytes, emit a known number back. This family is designed to pressure iteration instead. The input length is drawn from the challenge seed \u2014 the bounds are public, but the length of any given case is not knowable in advance \u2014 so the intended program reads until the input runs out: the VM sets a to the all-2s word on a read past the end, and that is the only signal it gets. That means a loop, and in classic Malbolge a loop is the hard part: every cell that executes is enciphered immediately afterwards, so the body is different code on its second pass and must either restore itself or ride the 94-cycle back to its starting values. Known to be possible \u2014 the published Malbolge programs that loop, from 99-bottles to the Nagoya LISP interpreter, all solve exactly this. The cases are deterministic and public (27 epochs of 3), so a pass does not prove a loop was used \u2014 a program could in principle dispatch on an identifying prefix and emit memorized answers \u2014 but unrolling by position is priced out: input up to 255 bytes against a 4096-byte cap leaves about 16 bytes per position, far under what an IN plus an end-of-input test plus a conditional jump plus an OUT costs under loader validity. Python: print(sum(data) % 256). A counter that accumulates input rather than counting, so it also has to add under the trit arithmetic."
  },
  {
    "level": 6,
    "status": "Frontier",
    "family": "Stream",
    "finite_map_inputs": [],
    "cases": 3,
    "min_input_len": 1,
    "max_input_len": 255,
    "min_epochs": 27,
    "max_memory_cells": 59049,
    "id": "L6.S3.reverse",
    "transform": "Reverse",
    "output_bytes": 255,
    "max_output_len": 255,
    "max_program_len": 4096,
    "max_steps_per_case": 262144,
    "title": "Echo the whole input backwards",
    "purpose": "Every other rung on this ladder fixes the output width in its definition, so a candidate can be written straight-line: consume a known number of bytes, emit a known number back. This family is designed to pressure iteration instead. The input length is drawn from the challenge seed \u2014 the bounds are public, but the length of any given case is not knowable in advance \u2014 so the intended program reads until the input runs out: the VM sets a to the all-2s word on a read past the end, and that is the only signal it gets. That means a loop, and in classic Malbolge a loop is the hard part: every cell that executes is enciphered immediately afterwards, so the body is different code on its second pass and must either restore itself or ride the 94-cycle back to its starting values. Known to be possible \u2014 the published Malbolge programs that loop, from 99-bottles to the Nagoya LISP interpreter, all solve exactly this. The cases are deterministic and public (27 epochs of 3), so a pass does not prove a loop was used \u2014 a program could in principle dispatch on an identifying prefix and emit memorized answers \u2014 but unrolling by position is priced out: input up to 255 bytes against a 4096-byte cap leaves about 16 bytes per position, far under what an IN plus an end-of-input test plus a conditional jump plus an OUT costs under loader validity. Python: print(input()[::-1]). Needs the input stored before any of it is emitted, then traversed backwards \u2014 storage as well as iteration."
  },
  {
    "id": "L2.X2048.xor-1-len2048",
    "title": "Single-byte XOR, 2048-byte cap",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 2048,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Added 2026-09-05 as a provisional compression milestone. Same exhaustive first-byte XOR contract and 2048-step limit as xor-1-len4096; only the source-size budget is tightened. The size variants have a provable relative order. No success-rate calibration is claimed.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.X1024.xor-1-len1024",
    "title": "Single-byte XOR, 1024-byte cap",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 1024,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Added 2026-09-05 as a provisional compression milestone. Same exhaustive first-byte XOR contract and 2048-step limit as xor-1-len4096; only the source-size budget is tightened. The size variants have a provable relative order. No success-rate calibration is claimed.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  },
  {
    "id": "L2.X512.xor-1-len512",
    "title": "Single-byte XOR, 512-byte cap",
    "level": 2,
    "status": "Calibration",
    "family": "Transform",
    "transform": "XorMask",
    "output_bytes": 1,
    "cases": 1,
    "max_program_len": 512,
    "max_steps_per_case": 2048,
    "max_output_len": 1,
    "max_memory_cells": 59049,
    "purpose": "Added 2026-09-05 as a provisional compression milestone. Same exhaustive first-byte XOR contract and 2048-step limit as xor-1-len4096; only the source-size budget is tightened. The size variants have a provable relative order. No success-rate calibration is claimed.",
    "min_epochs": 256,
    "exhaustive_first_byte": true
  }
]