diff --git a/wai/wai-quantum-serve/Cargo.lock b/wai/wai-quantum-serve/Cargo.lock
index dfd94bbcb..8ce676bc5 100644
--- a/wai/wai-quantum-serve/Cargo.lock
+++ b/wai/wai-quantum-serve/Cargo.lock
@@ -589,7 +589,7 @@ dependencies = [
 
 [[package]]
 name = "wai-quantum"
-version = "0.3.28"
+version = "0.3.29"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-quantum/Cargo.lock b/wai/wai-quantum/Cargo.lock
index 47acef1df..22101dd04 100644
--- a/wai/wai-quantum/Cargo.lock
+++ b/wai/wai-quantum/Cargo.lock
@@ -415,7 +415,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "wai-quantum"
-version = "0.3.28"
+version = "0.3.29"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-quantum/Cargo.toml b/wai/wai-quantum/Cargo.toml
index ba231cd9c..2b032b640 100644
--- a/wai/wai-quantum/Cargo.toml
+++ b/wai/wai-quantum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wai-quantum"
-version = "0.3.28"
+version = "0.3.29"
 edition = "2024"
 rust-version = "1.97"
 license = "Apache-2.0"
@@ -65,6 +65,9 @@ quantum_gbs = []
 # The dense state vector at any angle: gate fusion, diagonal fast paths, threads,
 # the same bits everywhere.
 quantum_sv = []
+# Architecture-level estimation: yoked storage, magic-state cultivation, CCZ
+# factories and reaction-limited time, assembled into whole-machine estimates.
+quantum_arch = []
 # Mixed states and the observables that distinguish quantum theory from a classical
 # account: density matrices, the partial trace, exact Pauli expectations, CHSH.
 quantum_info = ["quantum"]
@@ -104,13 +107,17 @@ quantum_phasor_meter = ["_signing"]
 
 # Everything.
 full = [
-    "quantum", "quantum_toolchain", "quantum_mps", "quantum_stabilizer", "quantum_pauli", "quantum_spd", "quantum_spd_receipt", "quantum_bptn", "quantum_resource", "quantum_resource_receipt", "quantum_frame", "quantum_tn", "quantum_gbs", "quantum_sv", "quantum_qir", "quantum_info", "quantum_qudit", "quantum_comm", "quantum_source", "quantum_channel",
+    "quantum", "quantum_toolchain", "quantum_mps", "quantum_stabilizer", "quantum_pauli", "quantum_spd", "quantum_spd_receipt", "quantum_bptn", "quantum_resource", "quantum_resource_receipt", "quantum_frame", "quantum_tn", "quantum_gbs", "quantum_sv", "quantum_arch", "quantum_qir", "quantum_info", "quantum_qudit", "quantum_comm", "quantum_source", "quantum_channel",
     "quantum_receipt", "quantum_ops", "quantum_cal", "quantum_mitigate", "quantum_qec",
     "quantum_control", "quantum_noise", "quantum_compile", "quantum_atom", "quantum_qbom",
     "quantum_vml", "quantum_phasor", "quantum_qfhrr", "quantum_kernel", "quantum_qdata",
     "quantum_phasor_meter",
 ]
 
+[[example]]
+name = "arch_factoring"
+required-features = ["quantum_arch"]
+
 [[example]]
 name = "sv_run"
 required-features = ["quantum_sv"]
diff --git a/wai/wai-quantum/README.md b/wai/wai-quantum/README.md
index 031959f77..4b984f261 100644
--- a/wai/wai-quantum/README.md
+++ b/wai/wai-quantum/README.md
@@ -64,6 +64,7 @@ never creates information.
 | `quantum_bptn` | **tensor-network states on the hardware graph**: simple-update evolution with belief-propagation environments and re-gauging, the device's couplings applied a layer at a time in parallel (bit-identical to one at a time). Exact on trees; on the 127-qubit lattice it gives the exactly computed 5-step magnetization to 4e-7 at bond dimension 32 — an independent check on sparse Pauli dynamics, whose errors it does not share |
 | `quantum_resource` | **fault-tolerant resource estimation**: from a program's logical counts (qubits, T, Toffoli and rotation gates, measurements) to code distance, T-state factories found by exhaustive search, physical qubits and runtime, on six reference qubits and three codes, with the qubits-versus-time frontier. Reproduces the published worked examples to their printed precision |
 | `quantum_resource_receipt` | a signed, energy-accounted receipt over an estimate, re-checkable bit for bit on any machine |
+| `quantum_arch` | **architecture-level estimation**: yoked surface-code storage (row and grid parity checks over patches, hot and cold), magic-state cultivation read off the published simulation curves, CCZ factories, and a clock set by whichever is slowest of lattice surgery, the magic-state supply and the control loop. Assembles whole-machine estimates; its storage search matches the source's footprint tool layout for layout |
 | `quantum_receipt` | signed, energy-accounted receipt over a reconstruction |
 | `quantum_ops` | the operations/attestation layer |
 | `quantum_cal`, `quantum_control`, `quantum_noise` | calibration, filter-function robust control, DD noise spectroscopy, Cycle-Benchmarking noise learning |
@@ -152,6 +153,32 @@ search limits, to the bit). Re-running it anywhere must reproduce every figure,
 down to each factory round, and the bytes are the same natively and as a WASI
 component.
 
+## Architecture
+
+```sh
+wai-quantum arch factoring --bits 2048     # the whole machine, region by region
+wai-quantum arch storage --target 1e-15    # cheapest plain, row- and grid-yoked layouts
+wai-quantum arch cultivate --p 1e-3 --target 1e-7
+```
+
+Most of the recent fall in projected fault-tolerant cost comes from the
+architecture around the code, not from better qubits. Idle qubits sit in yoked
+storage (arXiv:2312.04522). T states are cultivated inside one patch rather
+than distilled (arXiv:2409.17595). The clock runs at the pace of the slowest of
+lattice surgery, the magic-state supply and the control loop. `quantum_arch`
+prices each of these.
+
+It re-runs the 2025 estimate that 2048-bit factoring takes under a week on
+under a million noisy qubits (arXiv:2505.15917).
+- **Reproduced.** Its 897,864 physical qubits, its storage density of
+  429.03 qubits per logical qubit, and its Toffoli counts for every tabulated
+  key size, each to the reference implementation's own rounding.
+- **Corrected.** Re-running it surfaced six places where the source disagrees
+  with itself, each documented in the module. Its hot-storage count is below
+  its own peak formula. Its cold storage assumes fractional blocks. Its
+  printed runtime is 14% above its own tallies. With every correction applied,
+  the machine needs 958,480 qubits and 4.3 days. The conclusion holds.
+
 ## Error correction at circuit level
 
 An error-correction experiment is a noisy Clifford circuit, its detectors and
diff --git a/wai/wai-quantum/examples/arch_factoring.rs b/wai/wai-quantum/examples/arch_factoring.rs
new file mode 100644
index 000000000..836b428e3
--- /dev/null
+++ b/wai/wai-quantum/examples/arch_factoring.rs
@@ -0,0 +1,28 @@
+//! Re-run a published factoring estimate on a whole machine, and print every
+//! region, the clock and the totals.
+//!
+//! ```text
+//! cargo run --release --example arch_factoring --features quantum_arch -- [BITS]
+//! ```
+use wai_quantum::quantum_arch::{factoring_estimate, FactoringParams, Machine, PhaseupCount};
+
+fn main() {
+    let bits: u32 = std::env::args().nth(1).map_or(2048, |a| a.parse().expect("modulus bits"));
+    let params = FactoringParams::published(bits).expect("one of 1024, 1536, 2048, 3072, 4096, 6144, 8192");
+    let machine = Machine::published();
+    let e = factoring_estimate(&params, &machine).expect("estimate");
+    println!("modulus bits        {bits}");
+    println!("logical qubits      {} cold + {} hot (peak {})", e.cold_logical, e.hot_logical, params.peak_logical_qubits());
+    println!("hot distance        {}", e.hot_distance);
+    for (b, k) in &e.cold.blocks {
+        println!("cold block          {k} × {}×{} grid at d={} ({} logical, {:.2} qubits each)", b.rows - 1, b.cols - 1, b.distance, b.logical, b.qubits_per_logical());
+    }
+    println!("physical qubits     {} cold + {} hot + {} compute = {}", e.cold_qubits, e.hot_qubits, e.compute_qubits, e.physical_qubits());
+    println!("T state             d1={} error {:.2e} at {:.0} qubit·rounds", e.t_state.d1, e.t_state.error, e.t_state.volume);
+    println!("CCZ                 {:.1} rounds per factory, error {:.1e}", e.ccz_rounds, e.ccz_error);
+    println!("clock               step {:.1} µs ({:?}-bound)", e.timing.step_us(), e.timing.bound());
+    println!("toffolis per shot   {:.4e} (source rule {:.4e}, as stated {:.4e})", e.toffolis_per_shot, params.toffolis_per_shot_source_rule(PhaseupCount::AsCoded), params.toffolis_per_shot_source_rule(PhaseupCount::AsStated));
+    println!("hours per shot      {:.3} at the clock, {:.3} at whole milliseconds", e.hours_per_shot, e.hours_per_shot_rounded);
+    println!("shots               {:.3} expected, survival {:.4}", e.expected_shots, e.shot_survival);
+    println!("days                {:.3}", e.days);
+}
diff --git a/wai/wai-quantum/src/lib.rs b/wai/wai-quantum/src/lib.rs
index a30de7c50..772ac7e41 100644
--- a/wai/wai-quantum/src/lib.rs
+++ b/wai/wai-quantum/src/lib.rs
@@ -35,7 +35,8 @@ pub mod gates;
     feature = "quantum_frame",
     feature = "quantum_tn",
     feature = "quantum_gbs",
-    feature = "quantum_sv"
+    feature = "quantum_sv",
+    feature = "quantum_arch"
 ))]
 mod repro;
 
@@ -99,6 +100,9 @@ pub mod quantum_resource;
 #[cfg(feature = "quantum_resource_receipt")]
 pub mod quantum_resource_receipt;
 
+#[cfg(feature = "quantum_arch")]
+pub mod quantum_arch;
+
 #[cfg(feature = "quantum_frame")]
 pub mod quantum_frame;
 
diff --git a/wai/wai-quantum/src/quantum_arch.rs b/wai/wai-quantum/src/quantum_arch.rs
new file mode 100644
index 000000000..bd9009557
--- /dev/null
+++ b/wai/wai-quantum/src/quantum_arch.rs
@@ -0,0 +1,1357 @@
+//! Architecture-level ESTIMATION — `wai.quantum.arch`.
+//!
+//! Since 2023 the projected cost of a fault-tolerant computation has fallen by
+//! an order of magnitude without a better qubit. The savings come from the
+//! architecture around the code:
+//!
+//! - **Yoked storage** (arXiv:2312.04522). Idle logical qubits sit in
+//!   surface-code patches bound together by row (and column) parity checks.
+//!   This takes about a third of the qubits of plain patches at the same
+//!   error.
+//! - **Magic-state cultivation** (arXiv:2409.17595). A T state is grown inside
+//!   one patch and kept only if every check passes, instead of being distilled
+//!   from fifteen.
+//! - **Reaction-limited scheduling.** A step runs at the pace of the slowest of
+//!   three things: lattice surgery, the magic-state supply, or the classical
+//!   control loop.
+//!
+//! This module prices all three and assembles them into a whole-machine
+//! estimate. As in the planar estimator (`quantum_resource`), every number is a
+//! deterministic function of its inputs: `+ − × ÷` and in-crate logarithms,
+//! with the same bits on every machine.
+//!
+//! # Storage
+//!
+//! A patch of distance `d` covers `2(d+1)²` physical qubits; the margin leaves
+//! room for lattice surgery. Storage errors follow path-counting fits. Each
+//! fit gives the logical error per patch per round:
+//!
+//! ```text
+//! p = r^(a−1) · n^(b−1) / (C · Λ^d)
+//! ```
+//!
+//! Here `r` is the number of rounds between yoke checks and `n` the number of
+//! patches per yoked block. The exponents are `(a, b) = (1, 1)` for plain
+//! patches, `(2, 2)` for row yokes and `(4, 2)` for grid yokes. This is
+//! multiplied by `n / k` to give the error per *logical* qubit per round.
+//!
+//! - **Cold storage.** Blocks share one hallway that walks through them to
+//!   measure the yokes. A row-yoked block of `g` groups is checked every
+//!   `(8g + 2)·d` rounds. A `w × w` grid block is checked every `(25w + 4)·d`
+//!   rounds and stores `w² − 4w + 2` logical qubits in `(w+1)²` patches.
+//! - **Hot storage.** Every patch faces an access hallway. Row yokes are
+//!   checked every `50d` rounds.
+//!
+//! The search for the cheapest layout per logical qubit is held to the source's
+//! own footprint tool. There are three fit sets ([`StorageModel::si1000`],
+//! [`StorageModel::uniform`], [`StorageModel::uniform_refit`]). For each, the
+//! layout is checked at 61 targets from 10⁻¹⁸ to 10⁻³, for plain, row-yoked
+//! and grid-yoked storage, cold and hot. Every distance, block shape and
+//! qubit count is identical.
+//!
+//! # Magic states
+//!
+//! [`cultivate`] reads the cheapest T state meeting an error target off the
+//! cultivation curves. Those curves come from the published end-to-end
+//! simulations: 10⁹–10¹² shots per point, released under Apache-2.0. A curve
+//! gives the expected qubit·rounds per kept state (retries included) at each
+//! postselection cutoff, for injection distance 3 or 5 and noise 5·10⁻⁴,
+//! 10⁻³ or 2·10⁻³.
+//!
+//! The simulations swap the T gate for an S gate, so they can run on a
+//! stabilizer simulator. As the source does, the error is then doubled to
+//! stand in for T.
+//!
+//! [`CczFactory`] turns eight T states into one CCZ state, with output error
+//! `28·p_T²` (arXiv:1212.5069). The factory is a 3 × 4 block of patches running
+//! six layers of temporally encoded lattice surgery.
+//!
+//! # Time
+//!
+//! [`Timing`] sets the clock. A step takes the longest of three times:
+//! - the lattice-surgery period, `d` rounds;
+//! - the CCZ supply period, rounds per CCZ divided by the number of factories;
+//! - the reaction time of the control system.
+//!
+//! [`Timing::bound`] says which of the three binds.
+//!
+//! On that clock:
+//! - an `n`-bit addition consumes `n − 1` CCZ states and then uncomputes, for
+//!   `2(n−1)` steps;
+//! - a lookup over `w` address bits takes `2ʷ − 1` steps;
+//! - a phaseup takes half a lookup.
+//!
+//! # The 2025 factoring estimate, re-run
+//!
+//! arXiv:2505.15917 estimates that a 2048-bit RSA modulus can be factored in
+//! under a week on under a million noisy qubits. Its assumptions are:
+//! - a square grid;
+//! - a uniform error rate of 10⁻³;
+//! - a 1 µs cycle;
+//! - a 10 µs reaction time.
+//!
+//! [`FactoringParams`] carries its algorithm parameters. [`factoring_estimate`]
+//! re-runs the whole estimate from them.
+//!
+//! **Reproduced.**
+//! - **Physical qubits.** The total of 897,864 is reproduced exactly from the
+//!   source's layout:
+//!   - 1280 cold logical qubits at 430 qubits each;
+//!   - 131 hot patches at distance 25;
+//!   - a 7 × 18 compute region holding six factories.
+//! - **Cold-storage density.** The 430 is the published fit evaluated. Grid
+//!   blocks 16 patches wide at distance 11 give 429.03 qubits per logical
+//!   qubit at 10⁻¹⁵ per round.
+//! - **Logical counts.** The source's Toffoli count, `6.5·10⁹` per factoring,
+//!   and its 1399 logical qubits follow from its operation tallies under its
+//!   counting rule.
+//!
+//! **Where the source disagrees with itself.** Re-running it surfaced six
+//! places. None of them moves the conclusion: under a million qubits and under
+//! a week.
+//! - **Runtime per shot.** The source's tallies, at its stated durations (2 ms
+//!   per addition and per lookup, 1 ms per phaseup), give 10.62 h per shot.
+//!   It prints 12.07 h, so its own estimate is conservative by 14%.
+//! - **Hot storage.** The layout keeps 131 logical qubits hot, but the source
+//!   gives three other counts.
+//!   - Its peak formula `m + 3f + 2ℓ + len m` evaluates to 1432 at loop 4,
+//!     which is 152 hot.
+//!   - The text prints 1409 beside that formula.
+//!   - Its table gives 1399, which is 119 hot.
+//!
+//!   At 152 hot the machine takes 926,256 physical qubits, still under a
+//!   million.
+//! - **Phaseup Toffolis.** The source's reference counting code has an exponent
+//!   sign slip. It evaluates a phaseup with a 6-bit address to 0.25 Toffolis;
+//!   the text says 8. Counting as the text states adds 1.7% to the total.
+//! - **Loop 4.** The table lists 1.5 additions and 2.5 lookups per iteration.
+//!   The reference code performs 2.5 additions and 1.5 lookups. Both take
+//!   2 ms, so the runtime is unchanged.
+//! - **Cultivation.** The source reads 30,000 qubit·rounds for a 10⁻⁷ T state
+//!   off a figure. The data behind that figure give about 22,600. This makes
+//!   the factory estimate conservative as well.
+//! - **Block granularity.** 1280 logical qubits do not fill whole 194-qubit
+//!   grid blocks. Seven whole blocks cost 582,624 physical qubits, not
+//!   550,400.
+//!
+//! [`factoring_estimate`] applies every correction. It finds 958,480 physical
+//! qubits:
+//! - seven cold grid blocks, 582,624;
+//! - 152 hot patches, 205,504;
+//! - the compute region, 170,352.
+//!
+//! At the clock, with each operation rounded up to a whole millisecond, a shot
+//! takes 10.58 h. A factoring takes 4.3 days, shots lost to logical errors
+//! included.
+//!
+//! # Honest boundaries
+//!
+//! - **Fits are fits.** The storage formulas are path-counting extrapolations
+//!   from simulations at one noise strength, 10⁻³. Their authors call them
+//!   conservative. Outside that regime they are guesses.
+//! - **Cultivation is tabulated, not modelled.** Only the three simulated noise
+//!   strengths are supported; [`cultivate`] refuses any other. Between
+//!   tabulated cutoffs the volume is interpolated log-linearly. Points backed
+//!   by few failures (see [`CultivationPoint::failures`]) are uncertain by a
+//!   factor of a few.
+//! - **The factoring workload is the source's.** The operation tallies and the
+//!   deviation rate come from it, and are reproduced, not re-derived. The
+//!   residue-system search behind them is a conjecture of the source
+//!   (its Assumption 1).
+//! - **Lattice surgery is priced, not routed.** Operation times are lower
+//!   bounds from the CCZ count and the layer count. There is no placement or
+//!   routing.
+
+use crate::repro::{exp, ln};
+
+/// Physical qubits a distance-`d` patch covers, with room for lattice surgery:
+/// `2(d+1)²`.
+pub fn patch_qubits(d: u32) -> u64 {
+    2 * u64::from(d + 1) * u64::from(d + 1)
+}
+
+/// A path-counting fit for the logical error of stored patches.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct StorageFit {
+    /// The error suppression factor `Λ` per unit of distance.
+    pub suppression: f64,
+    /// The divisor `C`.
+    pub divisor: f64,
+    /// `a`: the error grows as `r^(a−1)` in the rounds between yoke checks.
+    pub round_exponent: u32,
+    /// `b`: the error grows as `n^(b−1)` in the patches per block.
+    pub patch_exponent: u32,
+}
+
+impl StorageFit {
+    /// Logical error per patch per round at distance `d`, with `rounds`
+    /// between yoke checks and `patches` per block.
+    pub fn per_patch_round(&self, d: u32, rounds: u64, patches: u64) -> f64 {
+        let mut scale = self.divisor;
+        for _ in 0..d {
+            scale *= self.suppression;
+        }
+        let mut x = 1.0;
+        for _ in 1..self.round_exponent {
+            x *= rounds as f64;
+        }
+        for _ in 1..self.patch_exponent {
+            x *= patches as f64;
+        }
+        x / scale
+    }
+
+    /// The plain-patch fit equivalent to a threshold model
+    /// `P(d) = a·(p/p*)^((d+1)/2)` per round, at physical error `p`. For
+    /// example, the fit `quantum_match` measures from its own memory
+    /// experiments.
+    pub fn flat_from_threshold(prefactor: f64, threshold: f64, p: f64) -> StorageFit {
+        let ratio_sqrt = exp(0.5 * ln(p / threshold));
+        StorageFit {
+            suppression: 1.0 / ratio_sqrt,
+            divisor: 1.0 / (prefactor * ratio_sqrt),
+            round_exponent: 1,
+            patch_exponent: 1,
+        }
+    }
+}
+
+/// Fits for plain, row-yoked and grid-yoked patches.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct StorageModel {
+    pub flat: StorageFit,
+    pub rows: StorageFit,
+    pub grid: StorageFit,
+}
+
+const fn fit(suppression: f64, divisor: f64, round_exponent: u32, patch_exponent: u32) -> StorageFit {
+    StorageFit { suppression, divisor, round_exponent, patch_exponent }
+}
+
+impl StorageModel {
+    /// arXiv:2312.04522, main text. SI1000 circuit noise at `p = 10⁻³`, fitted
+    /// to one significant figure.
+    pub fn si1000() -> StorageModel {
+        StorageModel { flat: fit(3.0, 20.0, 1, 1), rows: fit(8.0, 500.0, 2, 2), grid: fit(50.0, 200_000.0, 4, 2) }
+    }
+
+    /// arXiv:2312.04522, supplementary note 1. Uniform depolarizing circuit
+    /// noise at `p = 10⁻³`, fitted to one significant figure.
+    pub fn uniform() -> StorageModel {
+        StorageModel { flat: fit(4.0, 10.0, 1, 1), rows: fit(10.0, 2000.0, 2, 2), grid: fit(200.0, 20_000.0, 4, 2) }
+    }
+
+    /// The uniform-noise fits refitted to one and a half significant figures,
+    /// as used by arXiv:2505.15917 (its storage figure). More pessimistic than
+    /// [`StorageModel::uniform`].
+    pub fn uniform_refit() -> StorageModel {
+        StorageModel { flat: fit(3.5, 40.0, 1, 1), rows: fit(15.0, 100.0, 2, 2), grid: fit(150.0, 50_000.0, 4, 2) }
+    }
+}
+
+/// Where a block sits: cold (dense, shared check hallway) or hot (every patch
+/// faces an access hallway).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Storage {
+    Cold,
+    Hot,
+}
+
+/// How a block's patches are bound together.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Yoke {
+    /// Plain patches.
+    None,
+    /// One parity check along each row of patches (distance-2 outer code).
+    Rows,
+    /// Parity checks along rows and columns of a square (distance-4 outer
+    /// code). Cold storage only.
+    Grid,
+}
+
+/// A stored block: its shape, its distance and how well it keeps.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct StorageBlock {
+    pub storage: Storage,
+    pub yoke: Yoke,
+    /// Patch distance.
+    pub distance: u32,
+    /// The distance a plain patch would need for the same target; sets the
+    /// height of hot-storage access hallways.
+    pub hallway_distance: u32,
+    /// Patches per yoked group (a row), or `w²` for a grid.
+    pub patches_per_group: u32,
+    /// Groups (rows) in the block.
+    pub groups: u32,
+    /// Footprint, in patches, including hallways and workspace.
+    pub rows: u32,
+    pub cols: u32,
+    /// Logical qubits the block stores.
+    pub logical: u32,
+    /// Rounds between yoke checks.
+    pub rounds_between_checks: u64,
+    /// Logical error per logical qubit per round.
+    pub error_per_logical_round: f64,
+}
+
+impl StorageBlock {
+    /// Physical qubits the block covers. A hot block's access hallways are
+    /// `d0 + 1` patches tall, where `d0` is the plain-patch distance.
+    pub fn physical_qubits(&self) -> u64 {
+        let patch = patch_qubits(self.distance);
+        match self.storage {
+            Storage::Cold => patch * u64::from(self.rows) * u64::from(self.cols),
+            Storage::Hot => {
+                let hallways = u64::from(self.groups.div_ceil(2));
+                let code_rows = u64::from(self.rows) - hallways;
+                let hallway_patch = 2 * u64::from(self.distance + 1) * u64::from(self.hallway_distance + 1);
+                patch * code_rows * u64::from(self.cols) + hallway_patch * hallways * u64::from(self.cols)
+            }
+        }
+    }
+
+    /// Physical qubits per stored logical qubit.
+    pub fn qubits_per_logical(&self) -> f64 {
+        self.physical_qubits() as f64 / f64::from(self.logical)
+    }
+}
+
+const MAX_DISTANCE: u32 = 200;
+
+/// The smallest plain-patch distance (at least 3) whose per-round error meets
+/// `target`; `None` past distance 200.
+pub fn flat_distance(model: &StorageModel, target: f64) -> Option<u32> {
+    (3..=MAX_DISTANCE).find(|&d| model.flat.per_patch_round(d, 1, 1) <= target)
+}
+
+/// A rectangular block: `groups` rows of `patches_per_group` patches, plain or
+/// row-yoked, at the smallest distance meeting `target` per logical qubit per
+/// round. A row-yoked group must have an even number of patches, two of which
+/// hold the yokes. `None` if no distance up to 200 meets the target, or the
+/// shape stores nothing.
+pub fn rectangular_block(model: &StorageModel, storage: Storage, yoke: Yoke, patches_per_group: u32, groups: u32, target: f64) -> Option<StorageBlock> {
+    let yokes = match yoke {
+        Yoke::None => 0,
+        Yoke::Rows => 2,
+        Yoke::Grid => return None,
+    };
+    if groups == 0 || (yokes > 0 && patches_per_group % 2 == 1) || patches_per_group <= yokes {
+        return None;
+    }
+    let fit = if yokes == 0 { &model.flat } else { &model.rows };
+    let per_group = patches_per_group - yokes;
+    let mut d = 3;
+    let (rounds, error) = loop {
+        let rounds = match storage {
+            Storage::Hot => 50 * u64::from(d),
+            Storage::Cold => (u64::from(groups) * 8 + 2) * u64::from(d),
+        };
+        let error = fit.per_patch_round(d, rounds, u64::from(patches_per_group)) * f64::from(patches_per_group) / f64::from(per_group);
+        if error <= target {
+            break (rounds, error);
+        }
+        if d >= MAX_DISTANCE {
+            return None;
+        }
+        d += 1;
+    };
+    let (mut rows, mut cols) = (groups, patches_per_group);
+    match storage {
+        Storage::Hot => {
+            cols += 1;
+            rows += groups.div_ceil(2);
+        }
+        Storage::Cold => {
+            if yokes > 0 {
+                rows += 1;
+            }
+        }
+    }
+    Some(StorageBlock {
+        storage,
+        yoke,
+        distance: d,
+        hallway_distance: flat_distance(model, target)?,
+        patches_per_group,
+        groups,
+        rows,
+        cols,
+        logical: per_group * groups,
+        rounds_between_checks: rounds,
+        error_per_logical_round: error,
+    })
+}
+
+/// A cold `w × w` grid-yoked block (`w` a positive multiple of 4), at the
+/// smallest distance meeting `target` per logical qubit per round. It stores
+/// `w² − 4w + 2` logical qubits in `(w+1)²` patches (one row and one column of
+/// workspace).
+pub fn grid_block(model: &StorageModel, width: u32, target: f64) -> Option<StorageBlock> {
+    if width == 0 || !width.is_multiple_of(4) {
+        return None;
+    }
+    let patches = width * width;
+    let logical = patches - 4 * width + 2;
+    let mut d = 3;
+    let (rounds, error) = loop {
+        let rounds = u64::from(d) * u64::from(width) * 25 + u64::from(d) * 4;
+        let error = model.grid.per_patch_round(d, rounds, u64::from(patches)) * f64::from(patches) / f64::from(logical);
+        if error <= target {
+            break (rounds, error);
+        }
+        if d >= MAX_DISTANCE {
+            return None;
+        }
+        d += 1;
+    };
+    Some(StorageBlock {
+        storage: Storage::Cold,
+        yoke: Yoke::Grid,
+        distance: d,
+        hallway_distance: flat_distance(model, target)?,
+        patches_per_group: patches,
+        groups: 1,
+        rows: width + 1,
+        cols: width + 1,
+        logical,
+        rounds_between_checks: rounds,
+        error_per_logical_round: error,
+    })
+}
+
+/// The cheapest block per logical qubit storing at most `max_logical` logical
+/// qubits. Rectangular blocks try 4 to 200 patches per group and every group
+/// count. Grid blocks try every width that fits. The first minimum wins, in
+/// order of patches per group and then groups (or width).
+pub fn best_block(model: &StorageModel, storage: Storage, yoke: Yoke, target: f64, max_logical: u32) -> Option<StorageBlock> {
+    let mut best: Option<(f64, StorageBlock)> = None;
+    let mut consider = |b: StorageBlock| {
+        let rate = b.qubits_per_logical();
+        if best.as_ref().is_none_or(|(r, _)| rate < *r) {
+            best = Some((rate, b));
+        }
+    };
+    match yoke {
+        Yoke::Grid => {
+            if storage == Storage::Hot {
+                return None;
+            }
+            let mut w = 4;
+            while w * w - 4 * w + 2 <= max_logical {
+                if let Some(b) = grid_block(model, w, target) {
+                    consider(b);
+                }
+                w += 4;
+            }
+        }
+        Yoke::None | Yoke::Rows => {
+            let yokes = if yoke == Yoke::Rows { 2 } else { 0 };
+            for n in 4..=200u32 {
+                if n <= yokes {
+                    continue;
+                }
+                let per_group = n - yokes;
+                for groups in 1..=max_logical.div_ceil(per_group) {
+                    if per_group * groups > max_logical {
+                        continue;
+                    }
+                    if let Some(b) = rectangular_block(model, storage, yoke, n, groups, target) {
+                        consider(b);
+                    }
+                }
+            }
+        }
+    }
+    best.map(|(_, b)| b)
+}
+
+/// How a number of logical qubits is stored: whole blocks.
+#[derive(Clone, Debug, PartialEq)]
+pub struct StoragePlan {
+    /// The blocks, with how many of each.
+    pub blocks: Vec<(StorageBlock, u64)>,
+    /// Logical qubits asked for.
+    pub logical: u64,
+}
+
+impl StoragePlan {
+    pub fn physical_qubits(&self) -> u64 {
+        self.blocks.iter().map(|(b, k)| b.physical_qubits() * k).sum()
+    }
+    /// Logical qubits the blocks can hold (at least [`StoragePlan::logical`]).
+    pub fn capacity(&self) -> u64 {
+        self.blocks.iter().map(|(b, k)| u64::from(b.logical) * k).sum()
+    }
+}
+
+/// Store `logical` qubits in whole cold blocks of one kind of yoke. A plan is
+/// copies of one block shape, plus at most one block of another shape for the
+/// remainder. Every pair of shapes holding at most `max_block` logical qubits
+/// is tried, and the plan with the fewest physical qubits is kept. The shapes
+/// are grid widths from 4, and rectangles of up to 200 patches per group and
+/// 16 groups.
+///
+/// The fits were drawn from blocks of up to 256 patches. The source's own
+/// layouts cap a block at 250 logical qubits. Larger blocks extrapolate the
+/// fits, and they look cheaper than they have been shown to be.
+pub fn store(model: &StorageModel, yoke: Yoke, target: f64, logical: u64, max_block: u32) -> Option<StoragePlan> {
+    if logical == 0 {
+        return Some(StoragePlan { blocks: Vec::new(), logical });
+    }
+    let mut shapes: Vec<StorageBlock> = Vec::new();
+    match yoke {
+        Yoke::Grid => {
+            let mut w = 4;
+            while w * w - 4 * w + 2 <= max_block {
+                shapes.extend(grid_block(model, w, target));
+                w += 4;
+            }
+        }
+        Yoke::None | Yoke::Rows => {
+            for n in 4..=200u32 {
+                for groups in 1..=16 {
+                    shapes.extend(rectangular_block(model, Storage::Cold, yoke, n, groups, target).filter(|b| b.logical <= max_block));
+                }
+            }
+        }
+    }
+    let mut best: Option<(u64, StoragePlan)> = None;
+    let mut consider = |blocks: Vec<(StorageBlock, u64)>| {
+        let plan = StoragePlan { blocks, logical };
+        let cost = plan.physical_qubits();
+        if best.as_ref().is_none_or(|(c, _)| cost < *c) {
+            best = Some((cost, plan));
+        }
+    };
+    for main in &shapes {
+        let cap = u64::from(main.logical);
+        consider(vec![(*main, logical.div_ceil(cap))]);
+        for rest in &shapes {
+            let rest_cap = u64::from(rest.logical);
+            let copies = logical.saturating_sub(rest_cap).div_ceil(cap);
+            let mut blocks = vec![(*rest, 1)];
+            if copies > 0 {
+                blocks.insert(0, (*main, copies));
+            }
+            consider(blocks);
+        }
+    }
+    best.map(|(_, plan)| plan)
+}
+
+/// One point on a published cultivation curve: a postselection cutoff, with
+/// what it keeps and what it costs.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CultivationPoint {
+    /// Injection (colour-code) distance, 3 or 5.
+    pub d1: u32,
+    /// Uniform circuit noise strength.
+    pub p: f64,
+    /// Kept shots and failures among them, as simulated.
+    pub kept: u64,
+    pub failures: u64,
+    /// Expected qubit·rounds per kept state, retries included.
+    pub volume: f64,
+}
+
+impl CultivationPoint {
+    /// Logical error of a kept T state: twice the simulated S-state rate.
+    pub fn error(&self) -> f64 {
+        2.0 * self.failures as f64 / self.kept as f64
+    }
+}
+
+/// `(d1, p, kept, failures, qubit·rounds)`. These are the representative
+/// cutoffs of the end-to-end cultivation simulations of arXiv:2409.17595
+/// (data: doi:10.5281/zenodo.13777072, Apache-2.0). Each curve escapes into a
+/// distance-15 surface code. The volumes are the source's own: the circuit's
+/// growth-weighted qubit·rounds divided by the keep rate. The error falls
+/// down each curve as the volume rises.
+#[rustfmt::skip]
+const CULTIVATION: [(u32, f64, u64, u64, u32); 78] = [
+    (3, 5e-4, 507_113_042, 76, 4434), (3, 5e-4, 567_320_249, 112, 3963), (3, 5e-4, 630_762_204, 260, 3564),
+    (3, 5e-4, 702_651_030, 4541, 3200),
+    (3, 1e-3, 225_419_907, 299, 8071), (3, 1e-3, 257_427_648, 383, 7067), (3, 1e-3, 289_504_256, 486, 6284),
+    (3, 1e-3, 326_502_293, 677, 5572), (3, 1e-3, 367_643_011, 1251, 4948), (3, 1e-3, 423_967_169, 6213, 4291),
+    (3, 1e-3, 471_154_637, 15137, 3861), (3, 1e-3, 524_756_158, 169_010, 3467),
+    (3, 2e-3, 32_114_403, 400, 37284), (3, 2e-3, 40_189_645, 555, 29793), (3, 2e-3, 44_762_157, 671, 26749),
+    (3, 2e-3, 53_846_749, 921, 22236), (3, 2e-3, 64_036_036, 1342, 18698), (3, 2e-3, 73_311_524, 1827, 16332),
+    (3, 2e-3, 82_408_196, 2507, 14530), (3, 2e-3, 92_020_117, 3438, 13012), (3, 2e-3, 107_411_997, 5695, 11147),
+    (3, 2e-3, 124_485_101, 11808, 9618), (3, 2e-3, 144_091_705, 20247, 8310), (3, 2e-3, 165_174_154, 33151, 7249),
+    (3, 2e-3, 187_192_142, 58772, 6396), (3, 2e-3, 208_384_384, 107_491, 5746), (3, 2e-3, 237_794_538, 258_511, 5035),
+    (3, 2e-3, 264_661_056, 825_206, 4524),
+    (5, 5e-4, 92_480_789_479, 2, 18963), (5, 5e-4, 119_289_578_411, 3, 14702), (5, 5e-4, 133_864_311_235, 4, 13101),
+    (5, 5e-4, 149_019_473_596, 16, 11769), (5, 5e-4, 168_245_418_061, 42, 10424), (5, 5e-4, 190_063_821_114, 101, 9227),
+    (5, 5e-4, 213_505_407_573, 1225, 8214), (5, 5e-4, 237_773_048_111, 3798, 7376),
+    (5, 1e-3, 5_072_794_335, 2, 127_164), (5, 1e-3, 6_326_363_510, 3, 101_967), (5, 1e-3, 7_316_858_650, 5, 88163),
+    (5, 1e-3, 8_528_845_303, 7, 75635), (5, 1e-3, 11_303_894_346, 12, 57067), (5, 1e-3, 12_580_794_262, 17, 51275),
+    (5, 1e-3, 14_509_395_372, 43, 44459), (5, 1e-3, 17_056_858_658, 85, 37819), (5, 1e-3, 19_856_355_181, 130, 32487),
+    (5, 1e-3, 22_392_999_123, 361, 28807), (5, 1e-3, 24_893_295_331, 855, 25914), (5, 1e-3, 27_896_134_842, 1269, 23124),
+    (5, 1e-3, 31_155_995_215, 2210, 20705), (5, 1e-3, 34_799_549_714, 3586, 18537), (5, 1e-3, 38_815_144_303, 5781, 16619),
+    (5, 1e-3, 43_978_628_618, 15089, 14668), (5, 1e-3, 49_076_765_044, 88245, 13144),
+    (5, 2e-3, 19_158_113, 1, 2_657_934), (5, 2e-3, 26_331_515, 2, 1_933_842), (5, 2e-3, 31_195_093, 3, 1_632_340),
+    (5, 2e-3, 37_354_668, 6, 1_363_176), (5, 2e-3, 43_645_077, 10, 1_166_706), (5, 2e-3, 50_852_147, 13, 1_001_354),
+    (5, 2e-3, 58_670_182, 18, 867_919), (5, 2e-3, 65_338_141, 27, 779_346), (5, 2e-3, 73_001_601, 36, 697_533),
+    (5, 2e-3, 86_267_386, 63, 590_269), (5, 2e-3, 111_432_443, 95, 456_967), (5, 2e-3, 130_018_899, 134, 391_643),
+    (5, 2e-3, 156_035_212, 195, 326_343), (5, 2e-3, 186_603_798, 300, 272_883), (5, 2e-3, 217_837_248, 492, 233_757),
+    (5, 2e-3, 247_509_021, 780, 205_734), (5, 2e-3, 286_129_637, 1187, 177_965), (5, 2e-3, 338_075_961, 1890, 150_620),
+    (5, 2e-3, 389_809_192, 3249, 130_631), (5, 2e-3, 438_097_321, 5457, 116_232), (5, 2e-3, 499_133_825, 10420, 102_019),
+    (5, 2e-3, 555_534_346, 19226, 91661), (5, 2e-3, 628_514_709, 51577, 81018), (5, 2e-3, 700_358_340, 175_735, 72707),
+    (5, 2e-3, 778_533_166, 1_971_026, 65406),
+];
+
+/// Every tabulated cultivation point, ordered by `(d1, p)` and then by rising
+/// error.
+pub fn cultivation_points() -> Vec<CultivationPoint> {
+    CULTIVATION
+        .iter()
+        .map(|&(d1, p, kept, failures, volume)| CultivationPoint { d1, p, kept, failures, volume: f64::from(volume) })
+        .collect()
+}
+
+/// A cultivated T state: its error, its expected cost and how it was grown.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CultivatedT {
+    pub error: f64,
+    /// Expected qubit·rounds per kept state.
+    pub volume: f64,
+    pub d1: u32,
+}
+
+/// The cheapest cultivated T state with error at most `target` at noise `p`.
+/// The volume is interpolated log-linearly in `(ln error, ln volume)` between
+/// the tabulated cutoffs that bracket the target. `None` if `p` is not one of
+/// the simulated strengths (5·10⁻⁴, 10⁻³, 2·10⁻³) or no curve reaches the
+/// target.
+pub fn cultivate(p: f64, target: f64) -> Option<CultivatedT> {
+    let points = cultivation_points();
+    let mut best: Option<CultivatedT> = None;
+    for d1 in [3, 5] {
+        let curve: Vec<&CultivationPoint> = points.iter().filter(|q| q.d1 == d1 && q.p == p).collect();
+        let Some(first) = curve.first() else { continue };
+        if first.error() > target {
+            continue;
+        }
+        // Points rise in error and fall in volume. Take the last point at or
+        // below the target, and interpolate towards the next one up.
+        let k = curve.iter().rposition(|q| q.error() <= target).unwrap_or(0);
+        let lo = curve[k];
+        let found = match curve.get(k + 1) {
+            Some(hi) if target > lo.error() => {
+                let t = (ln(target) - ln(lo.error())) / (ln(hi.error()) - ln(lo.error()));
+                CultivatedT { error: target, volume: exp(ln(lo.volume) + t * (ln(hi.volume) - ln(lo.volume))), d1 }
+            }
+            _ => CultivatedT { error: lo.error(), volume: lo.volume, d1 },
+        };
+        if best.is_none_or(|b| found.volume < b.volume) {
+            best = Some(found);
+        }
+    }
+    best
+}
+
+/// A CCZ factory fed by cultivated T states: `t_states` T states in, one CCZ
+/// state out.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CczFactory {
+    /// Footprint, in patches.
+    pub width: u32,
+    pub height: u32,
+    /// Layers of lattice surgery per CCZ state.
+    pub layers: u32,
+    /// Rounds per layer, as a fraction of `d` (2/3 with temporally encoded
+    /// lattice surgery).
+    pub layer_fraction: f64,
+    /// T states consumed per CCZ state.
+    pub t_states: u32,
+    /// Output error is `suppression · p_T²`.
+    pub suppression: f64,
+}
+
+impl CczFactory {
+    /// 8T-to-CCZ distillation (arXiv:1212.5069), in a 3 × 4 patch layout
+    /// (arXiv:2409.17595, figure 24) of six temporally encoded layers.
+    pub fn eight_t() -> CczFactory {
+        CczFactory { width: 4, height: 3, layers: 6, layer_fraction: 2.0 / 3.0, t_states: 8, suppression: 28.0 }
+    }
+
+    /// Physical qubits at patch distance `d`.
+    pub fn physical_qubits(&self, d: u32) -> u64 {
+        u64::from(self.width * self.height) * patch_qubits(d)
+    }
+
+    /// Rounds per CCZ state. The T states are cultivated inside the
+    /// footprint, each costing `t_volume` qubit·rounds. The lattice surgery
+    /// follows.
+    pub fn rounds_per_ccz(&self, d: u32, t_volume: f64) -> f64 {
+        let cultivation = f64::from(self.t_states) * t_volume / self.physical_qubits(d) as f64;
+        cultivation + f64::from(self.layers) * self.layer_fraction * f64::from(d)
+    }
+
+    /// Error of a CCZ state built from T states of error `t_error`.
+    pub fn error(&self, t_error: f64) -> f64 {
+        self.suppression * t_error * t_error
+    }
+}
+
+/// What sets the pace of a step.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Bound {
+    /// Lattice surgery: `d` rounds per step.
+    Surgery,
+    /// The CCZ supply.
+    MagicStates,
+    /// The classical control loop.
+    Reaction,
+}
+
+/// The machine's clock.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Timing {
+    /// Surface-code cycle, µs.
+    pub cycle_us: f64,
+    /// Control-system reaction time, µs.
+    pub reaction_us: f64,
+    /// Patch distance in the compute region.
+    pub distance: u32,
+    /// Rounds per CCZ state per factory.
+    pub ccz_rounds: f64,
+    pub factories: u32,
+}
+
+impl Timing {
+    /// One lattice-surgery step: `d` cycles.
+    pub fn surgery_us(&self) -> f64 {
+        f64::from(self.distance) * self.cycle_us
+    }
+    /// Time between CCZ states from all factories together.
+    pub fn ccz_period_us(&self) -> f64 {
+        self.ccz_rounds * self.cycle_us / f64::from(self.factories)
+    }
+    /// A step: the slowest of surgery, CCZ supply and reaction.
+    pub fn step_us(&self) -> f64 {
+        self.surgery_us().max(self.ccz_period_us()).max(self.reaction_us)
+    }
+    /// Which of the three sets [`Timing::step_us`] (surgery on a tie).
+    pub fn bound(&self) -> Bound {
+        let step = self.step_us();
+        if self.surgery_us() == step {
+            Bound::Surgery
+        } else if self.ccz_period_us() == step {
+            Bound::MagicStates
+        } else {
+            Bound::Reaction
+        }
+    }
+    /// An `n`-bit addition: `n − 1` CCZ states, then an uncompute of the same
+    /// length.
+    pub fn add_us(&self, n: u32) -> f64 {
+        2.0 * f64::from(n.saturating_sub(1)) * self.step_us()
+    }
+    /// A table lookup over `w` address bits: `2ʷ − 1` layers, enough for its
+    /// `2ʷ − w − 1` CCZ states.
+    pub fn lookup_us(&self, w: u32) -> f64 {
+        ((1u64 << w) - 1) as f64 * self.step_us()
+    }
+    /// A phaseup over `w` address bits: at most half a lookup.
+    pub fn phaseup_us(&self, w: u32) -> f64 {
+        self.lookup_us(w) / 2.0
+    }
+}
+
+/// The parameters of the approximate-residue factoring algorithm of
+/// arXiv:2505.15917 (its table 4).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FactoringParams {
+    /// Bits in the modulus.
+    pub n: u32,
+    /// Ekerå–Håstad parameter.
+    pub s: u32,
+    /// Bits per prime of the residue system.
+    pub prime_bits: u32,
+    /// Window sizes of loops 1, 3 and 4.
+    pub w1: u32,
+    pub w3: u32,
+    pub w4: u32,
+    /// Bits of the truncated accumulator.
+    pub accumulator_bits: u32,
+    /// Shot failure rate from the approximation (simulated by the source).
+    pub deviant: f64,
+}
+
+impl FactoringParams {
+    /// The source's highlighted parameters for `n` ∈ {1024, 1536, 2048, 3072,
+    /// 4096, 6144, 8192}.
+    pub fn published(n: u32) -> Option<FactoringParams> {
+        let (s, prime_bits, w1, w3, w4, accumulator_bits, deviant) = match n {
+            1024 => (8, 18, 6, 3, 6, 28, 0.0287),
+            1536 => (8, 21, 6, 3, 5, 31, 0.0183),
+            2048 => (8, 21, 6, 3, 5, 33, 0.0125),
+            3072 => (8, 21, 6, 3, 5, 35, 0.0091),
+            4096 => (8, 24, 6, 3, 5, 36, 0.0080),
+            6144 => (8, 24, 6, 3, 5, 39, 0.0042),
+            8192 => (8, 24, 6, 3, 5, 40, 0.0040),
+            _ => return None,
+        };
+        Some(FactoringParams { n, s, prime_bits, w1, w3, w4, accumulator_bits, deviant })
+    }
+
+    /// Input qubits `m = ⌈n(1/2 + 1/(2s))⌉ + ⌈n/(2s)⌉`.
+    pub fn input_qubits(&self) -> u64 {
+        let n = u64::from(self.n);
+        let s = u64::from(self.s);
+        (n * (s + 1)).div_ceil(2 * s) + n.div_ceil(2 * s)
+    }
+
+    /// Primes in the residue system: enough `ℓ`-bit primes to cover `n` bits
+    /// per multiplication, `|P| = ⌈n·⌈m/w₁⌉/ℓ⌉`.
+    pub fn primes(&self) -> u64 {
+        (u64::from(self.n) * self.input_qubits().div_ceil(u64::from(self.w1))).div_ceil(u64::from(self.prime_bits))
+    }
+
+    /// Expected shots per factoring: `(s+1)/(1 − P_deviant)/0.99`.
+    pub fn expected_shots(&self) -> f64 {
+        f64::from(self.s + 1) / (1.0 - self.deviant) / 0.99
+    }
+
+    /// The operation tallies of one shot.
+    pub fn tallies(&self) -> Vec<Subroutine> {
+        let p = self.primes();
+        let m = self.input_qubits();
+        let len_m = u64::from(64 - m.leading_zeros());
+        let (l, f) = (u64::from(self.prime_bits), u64::from(self.accumulator_bits));
+        let win1 = m.div_ceil(u64::from(self.w1));
+        let win3 = l.div_ceil(u64::from(self.w3));
+        let win4 = l.div_ceil(u64::from(self.w4));
+        let (w1, w3, w4) = (self.w1, self.w3, self.w4);
+        let sub = |name, family, iterations: u64, halves: [u64; 3], add_bits, lookup_bits, phaseup_bits| Subroutine {
+            name,
+            family,
+            iterations,
+            half_adds: halves[0],
+            half_lookups: halves[1],
+            half_phaseups: halves[2],
+            add_bits: add_bits as u32,
+            lookup_bits,
+            phaseup_bits,
+        };
+        vec![
+            sub("loop1", 1, (p + 1) * win1, [2, 2, 0], l + len_m, w1, 0),
+            sub("loop2", 2, p * len_m, [4, 0, 0], l + len_m, 0, 0),
+            sub("loop3 startup", 3, p, [0, 2, 0], 0, 2 * w3, 0),
+            sub("loop3 body", 3, p * (win3 - 2) * win3, [4, 2, 0], l + 1, 2 * w3, 0),
+            sub("loop4", 4, p * win4, [5, 3, 2], f + 1, w4, w4),
+            sub("unloop3 body", 5, p * (win3 - 2) * 2 * win3, [5, 3, 2], l + 1, 2 * w3, 2 * w3),
+            sub("unloop3 cleanup", 5, p, [0, 0, 2], 0, 0, 2 * w3),
+            sub("unloop2", 6, p * len_m, [4, 0, 0], l + len_m, 0, 0),
+        ]
+    }
+
+    /// Peak logical qubits by the source's qubit tally (its table 5): loop 4
+    /// holds `m + 3f + 2ℓ + len m`.
+    pub fn peak_logical_qubits(&self) -> u64 {
+        let m = self.input_qubits();
+        let len_m = u64::from(64 - m.leading_zeros());
+        m + 3 * u64::from(self.accumulator_bits) + 2 * u64::from(self.prime_bits) + len_m
+    }
+
+    /// Logical qubits by the source's reference code (its table 4 column):
+    /// `m + (ℓ + len m) + ℓ + f + max(ℓ, f, ℓ + len m)`.
+    pub fn table_logical_qubits(&self) -> u64 {
+        let m = self.input_qubits();
+        let len_m = u64::from(64 - m.leading_zeros());
+        let (l, f) = (u64::from(self.prime_bits), u64::from(self.accumulator_bits));
+        m + (l + len_m) + l + f + l.max(f).max(l + len_m)
+    }
+
+    /// Toffolis per shot, operation by operation:
+    /// - an `n`-bit addition is `n − 1`;
+    /// - a lookup over `w` bits is `2ʷ − w − 1`;
+    /// - a phaseup over `w` bits is `⌈√(2ʷ)⌉`, so 8 at 6 bits, as the source's
+    ///   text states.
+    pub fn toffolis_per_shot(&self) -> f64 {
+        self.tallies()
+            .iter()
+            .map(|s| {
+                let add = f64::from(s.add_bits.saturating_sub(1));
+                let lookup = ((1u64 << s.lookup_bits) - u64::from(s.lookup_bits) - 1) as f64;
+                let phaseup = isqrt_ceil(1u64 << s.phaseup_bits) as f64;
+                s.adds() * add + s.lookups() * lookup + s.phaseups() * phaseup
+            })
+            .sum()
+    }
+
+    /// Toffolis per shot by the source's reference counting rule, the rule
+    /// behind its published count:
+    /// - every operation in a subroutine is priced at that subroutine's
+    ///   largest size;
+    /// - an addition costs its full register width;
+    /// - a lookup over `N` entries costs `N − bitlen(N) − 1`.
+    ///
+    /// The rule prices a phaseup over `N` entries at
+    /// `2^(⌊N₁/2⌋−N₁−1) + 2^(⌊N₂/2⌋−N₂−1)`, a quarter of a Toffoli at 6 address
+    /// bits. [`PhaseupCount::AsStated`] substitutes the text's `⌈√N⌉`.
+    pub fn toffolis_per_shot_source_rule(&self, phaseups: PhaseupCount) -> f64 {
+        let tallies = self.tallies();
+        (1..=6)
+            .map(|family| {
+                let rows: Vec<&Subroutine> = tallies.iter().filter(|s| s.family == family).collect();
+                let add_bits = rows.iter().map(|s| s.add_bits).max().unwrap_or(0);
+                let lookup_bits = rows.iter().filter(|s| s.half_lookups > 0).map(|s| s.lookup_bits).max().unwrap_or(0);
+                let phaseup_bits = rows.iter().filter(|s| s.half_phaseups > 0).map(|s| s.phaseup_bits).max().unwrap_or(0);
+                let (adds, lookups, flips) = rows.iter().fold((0.0, 0.0, 0.0), |(a, l, p), s| (a + s.adds(), l + s.lookups(), p + s.phaseups()));
+                let mut total = adds * f64::from(add_bits);
+                if lookups > 0.0 {
+                    let big_n = 1u64 << lookup_bits;
+                    total += lookups * (big_n - u64::from(64 - big_n.leading_zeros()) - 1) as f64;
+                }
+                if flips > 0.0 {
+                    total += flips
+                        * match phaseups {
+                            PhaseupCount::AsCoded => {
+                                let bits = 64 - (1u64 << phaseup_bits).leading_zeros() as i32;
+                                let (n1, n2) = (bits / 2, bits - bits / 2);
+                                pow2(n1 / 2 - n1 - 1) + pow2(n2 / 2 - n2 - 1)
+                            }
+                            PhaseupCount::AsStated => isqrt_ceil(1u64 << phaseup_bits) as f64,
+                        };
+                }
+                total
+            })
+            .sum()
+    }
+}
+
+/// How the source rule prices a phaseup.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PhaseupCount {
+    /// As the reference counting code evaluates it: a quarter of a Toffoli at
+    /// 6 address bits.
+    AsCoded,
+    /// As the text states: `⌈√N⌉`, so 8 at 6 address bits.
+    AsStated,
+}
+
+fn pow2(e: i32) -> f64 {
+    let mut x = 1.0;
+    for _ in 0..e.unsigned_abs() {
+        x = if e < 0 { x / 2.0 } else { x * 2.0 };
+    }
+    x
+}
+
+fn isqrt_ceil(x: u64) -> u64 {
+    let mut r = (x as f64).sqrt() as u64;
+    while r * r > x {
+        r -= 1;
+    }
+    while r * r < x {
+        r += 1;
+    }
+    r
+}
+
+/// One subroutine of the factoring algorithm: how often it runs and what each
+/// iteration does. Operation counts are kept in halves, because loop 4 and
+/// unloop 3 average two and a half additions per iteration.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Subroutine {
+    pub name: &'static str,
+    /// Which of the six loops it belongs to (1 to 6: loop 1, 2, 3, 4,
+    /// unloop 3, unloop 2).
+    pub family: u32,
+    pub iterations: u64,
+    pub half_adds: u64,
+    pub half_lookups: u64,
+    pub half_phaseups: u64,
+    /// Largest addition, in bits.
+    pub add_bits: u32,
+    /// Largest lookup and phaseup, in address bits.
+    pub lookup_bits: u32,
+    pub phaseup_bits: u32,
+}
+
+impl Subroutine {
+    pub fn adds(&self) -> f64 {
+        (self.iterations * self.half_adds) as f64 / 2.0
+    }
+    pub fn lookups(&self) -> f64 {
+        (self.iterations * self.half_lookups) as f64 / 2.0
+    }
+    pub fn phaseups(&self) -> f64 {
+        (self.iterations * self.half_phaseups) as f64 / 2.0
+    }
+}
+
+/// The physical assumptions of a whole-machine estimate.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Machine {
+    /// Uniform circuit noise strength.
+    pub p: f64,
+    pub cycle_us: f64,
+    pub reaction_us: f64,
+    pub storage: StorageModel,
+    /// Target logical error per logical qubit per round, for every stored
+    /// qubit.
+    pub target: f64,
+    pub factory: CczFactory,
+    pub factories: u32,
+    /// Columns of lattice-surgery workspace beside the factories.
+    pub workspace_cols: u32,
+    /// Error target for each T state fed to a factory.
+    pub t_target: f64,
+    /// Largest cold block, in logical qubits (see [`store`]).
+    pub max_block: u32,
+}
+
+impl Machine {
+    /// The source's machine:
+    /// - `p = 10⁻³`, a 1 µs cycle and a 10 µs reaction time;
+    /// - refitted storage at 10⁻¹⁵ per logical qubit per round;
+    /// - six 8T-to-CCZ factories with three columns of workspace;
+    /// - 10⁻⁷ T states.
+    pub fn published() -> Machine {
+        Machine {
+            p: 1e-3,
+            cycle_us: 1.0,
+            reaction_us: 10.0,
+            storage: StorageModel::uniform_refit(),
+            target: 1e-15,
+            factory: CczFactory::eight_t(),
+            factories: 6,
+            workspace_cols: 3,
+            t_target: 1e-7,
+            max_block: 250,
+        }
+    }
+}
+
+/// A whole-machine estimate of the factoring algorithm.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FactoringEstimate {
+    pub params: FactoringParams,
+    /// Logical qubits: the input register stays cold, the rest is hot.
+    pub cold_logical: u64,
+    pub hot_logical: u64,
+    /// Hot-patch distance and the cold storage plan.
+    pub hot_distance: u32,
+    pub cold: StoragePlan,
+    /// Physical qubits in each region.
+    pub cold_qubits: u64,
+    pub hot_qubits: u64,
+    pub compute_qubits: u64,
+    /// The T state each factory consumes, and its CCZ output error.
+    pub t_state: CultivatedT,
+    pub ccz_error: f64,
+    /// Rounds per CCZ per factory.
+    pub ccz_rounds: f64,
+    pub timing: Timing,
+    /// Hours per shot at the clock's lower bound.
+    pub hours_per_shot: f64,
+    /// Hours per shot with every operation rounded up to a whole millisecond,
+    /// the source's allowance for moving qubits in and out.
+    pub hours_per_shot_rounded: f64,
+    /// Expected shots, the chance a shot has no logical error, and expected
+    /// days per factoring (shots lost to logical errors included, at the
+    /// rounded durations).
+    pub expected_shots: f64,
+    pub shot_survival: f64,
+    pub days: f64,
+    pub toffolis_per_shot: f64,
+}
+
+impl FactoringEstimate {
+    pub fn physical_qubits(&self) -> u64 {
+        self.cold_qubits + self.hot_qubits + self.compute_qubits
+    }
+}
+
+/// Why a whole-machine estimate could not be made.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ArchError {
+    /// No plain-patch distance up to 200 meets the storage target.
+    Distance,
+    /// No yoked layout meets the storage target.
+    Storage,
+    /// No cultivation curve at this noise strength reaches the T target.
+    Cultivation,
+}
+
+impl core::fmt::Display for ArchError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(match self {
+            ArchError::Distance => "no patch distance up to 200 meets the storage target",
+            ArchError::Storage => "no yoked storage layout meets the storage target",
+            ArchError::Cultivation => "no cultivation curve at this noise strength reaches the T target",
+        })
+    }
+}
+
+impl std::error::Error for ArchError {}
+
+/// Re-run the factoring estimate on `machine`.
+///
+/// - **Cold storage.** The `m` input qubits sit in whole grid-yoked blocks,
+///   via [`store`].
+/// - **Hot storage.** The rest of the peak sits in plain patches.
+/// - **Compute region.** `factories` factories are stacked beside the
+///   workspace columns.
+/// - **Time.** Every operation in the tallies runs on the [`Timing`] clock,
+///   which is set by the cultivated T states.
+/// - **Survival.** A shot survives when no stored logical qubit fails for its
+///   whole duration.
+pub fn factoring_estimate(params: &FactoringParams, machine: &Machine) -> Result<FactoringEstimate, ArchError> {
+    let d = flat_distance(&machine.storage, machine.target).ok_or(ArchError::Distance)?;
+    let cold_logical = params.input_qubits();
+    let hot_logical = params.peak_logical_qubits() - cold_logical;
+    let cold = store(&machine.storage, Yoke::Grid, machine.target, cold_logical, machine.max_block).ok_or(ArchError::Storage)?;
+    let t_state = cultivate(machine.p, machine.t_target).ok_or(ArchError::Cultivation)?;
+    let ccz_rounds = machine.factory.rounds_per_ccz(d, t_state.volume);
+    let timing = Timing { cycle_us: machine.cycle_us, reaction_us: machine.reaction_us, distance: d, ccz_rounds, factories: machine.factories };
+    let whole_ms = |us: f64| (us / 1000.0).ceil() * 1000.0;
+    let (mut micros, mut micros_rounded) = (0.0, 0.0);
+    for s in params.tallies() {
+        let ops = [(s.adds(), timing.add_us(s.add_bits)), (s.lookups(), timing.lookup_us(s.lookup_bits)), (s.phaseups(), timing.phaseup_us(s.phaseup_bits))];
+        for (count, us) in ops {
+            micros += count * us;
+            micros_rounded += count * whole_ms(us);
+        }
+    }
+    let compute_patches = u64::from((machine.factory.width + machine.workspace_cols) * machine.factory.height * machine.factories);
+    let (cold_qubits, hot_qubits, compute_qubits) = (cold.physical_qubits(), hot_logical * patch_qubits(d), compute_patches * patch_qubits(d));
+    let stored = (cold_logical + hot_logical + compute_patches) as f64;
+    let rounds = micros_rounded / machine.cycle_us;
+    let shot_survival = exp(-(stored * rounds * machine.target));
+    let expected_shots = params.expected_shots();
+    let (hours_per_shot, hours_per_shot_rounded) = (micros / 3.6e9, micros_rounded / 3.6e9);
+    Ok(FactoringEstimate {
+        params: *params,
+        cold_logical,
+        hot_logical,
+        hot_distance: d,
+        cold,
+        cold_qubits,
+        hot_qubits,
+        compute_qubits,
+        t_state,
+        ccz_error: machine.factory.error(t_state.error),
+        ccz_rounds,
+        timing,
+        hours_per_shot,
+        hours_per_shot_rounded,
+        expected_shots,
+        shot_survival,
+        days: hours_per_shot_rounded * expected_shots / shot_survival / 24.0,
+        toffolis_per_shot: params.toffolis_per_shot(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rsa() -> FactoringParams {
+        FactoringParams::published(2048).unwrap()
+    }
+
+    #[test]
+    fn refitted_storage_gives_the_published_densities() {
+        let m = StorageModel::uniform_refit();
+        assert_eq!(flat_distance(&m, 1e-15), Some(25));
+        assert_eq!(patch_qubits(25), 1352);
+        let g = grid_block(&m, 16, 1e-15).unwrap();
+        assert_eq!((g.distance, g.logical, g.rows, g.cols), (11, 194, 17, 17));
+        assert_eq!(g.physical_qubits(), 83_232);
+        assert!((g.qubits_per_logical() - 429.03).abs() < 0.01, "{}", g.qubits_per_logical());
+        // Its stated rounding: 430 per logical qubit.
+        assert_eq!(1280 * 430 + 131 * 1352 + 7 * 18 * 1352, 897_864);
+    }
+
+    #[test]
+    fn uniform_grids_reach_the_supplements_density() {
+        // Supplementary note 1: about 350 physical qubits per logical qubit
+        // at about 10⁻¹² per round.
+        let g = best_block(&StorageModel::uniform(), Storage::Cold, Yoke::Grid, 1e-12, 250).unwrap();
+        assert!((340.0..370.0).contains(&g.qubits_per_logical()), "{}", g.qubits_per_logical());
+    }
+
+    #[test]
+    fn the_layout_search_matches_the_source_tool_everywhere() {
+        let data = include_str!("../tests/data/yoked_footprint_oracle.csv");
+        let mut checked = 0;
+        for line in data.lines().skip(1) {
+            let f: Vec<&str> = line.split(',').collect();
+            let model = match f[0] {
+                "si1000" => StorageModel::si1000(),
+                "uniform" => StorageModel::uniform(),
+                "uniform_refit" => StorageModel::uniform_refit(),
+                other => panic!("{other}"),
+            };
+            let storage = if f[1] == "hot" { Storage::Hot } else { Storage::Cold };
+            let target: f64 = f[3].parse().unwrap();
+            let got = match f[2] {
+                "0" => best_block(&model, storage, Yoke::None, target, 250),
+                "2" => best_block(&model, storage, Yoke::Rows, target, 250),
+                "64" => grid_block(&model, 16, target),
+                other => panic!("{other}"),
+            }
+            .unwrap_or_else(|| panic!("no layout for {line}"));
+            let want: Vec<u64> = f[4..11].iter().map(|x| x.parse().unwrap()).collect();
+            let have = [got.distance, got.groups, got.patches_per_group, got.rows, got.cols, got.logical].map(u64::from);
+            assert_eq!(&have[..], &want[..6], "{line}");
+            assert_eq!(got.rounds_between_checks, want[6], "{line}");
+            // The tool leaves the hallway distance unset for grids, which
+            // have no hallways.
+            if f[11] != "None" {
+                assert_eq!(got.hallway_distance.to_string(), f[11], "{line}");
+            }
+            let rate: f64 = f[12].parse().unwrap();
+            assert_eq!(got.qubits_per_logical(), rate, "{line}");
+            let lerp: f64 = f[13].parse().unwrap();
+            assert!((got.error_per_logical_round / lerp - 1.0).abs() < 1e-12, "{line}");
+            checked += 1;
+        }
+        assert_eq!(checked, 915);
+    }
+
+    #[test]
+    fn whole_blocks_cost_more_than_the_rate_suggests() {
+        let m = StorageModel::uniform_refit();
+        let plan = store(&m, Yoke::Grid, 1e-15, 1280, 250).unwrap();
+        assert!(plan.capacity() >= 1280);
+        let widths: Vec<(u32, u64)> = plan.blocks.iter().map(|(b, k)| (b.rows - 1, *k)).collect();
+        assert_eq!(widths, vec![(16, 7)]);
+        assert_eq!(plan.physical_qubits(), 582_624);
+        // Past the simulated block sizes the fits promise more: a 32-wide grid
+        // at 410 qubits per logical qubit.
+        let wide = store(&m, Yoke::Grid, 1e-15, 1280, 1000).unwrap();
+        assert!(wide.physical_qubits() < 1280 * 430);
+        assert!(wide.blocks.iter().any(|(b, _)| b.rows - 1 == 32));
+    }
+
+    #[test]
+    fn cultivation_reads_the_published_curves() {
+        let t = cultivate(1e-3, 1e-7).unwrap();
+        assert_eq!(t.d1, 5);
+        assert!((22_000.0..23_200.0).contains(&t.volume), "{}", t.volume);
+        // Well above the distance-5 curve's reach, distance 3 is cheaper.
+        let cheap = cultivate(1e-3, 1e-4).unwrap();
+        assert_eq!(cheap.d1, 3);
+        // Below every curve: nothing.
+        assert_eq!(cultivate(1e-3, 1e-12), None);
+        // Unsimulated noise: refused.
+        assert_eq!(cultivate(7e-4, 1e-6), None);
+        // Each curve rises in error as it falls in volume.
+        let pts = cultivation_points();
+        for w in pts.windows(2) {
+            if (w[0].d1, w[0].p) == (w[1].d1, w[1].p) {
+                assert!(w[1].error() > w[0].error() && w[1].volume < w[0].volume);
+            }
+        }
+    }
+
+    #[test]
+    fn the_factory_and_clock_reproduce_the_sources_arithmetic() {
+        let f = CczFactory::eight_t();
+        assert_eq!(f.physical_qubits(25), 16_224);
+        // 8 × 30,000 / 16,224 + 6 × (2/3) × 25 = 114.79 rounds ("114.7").
+        assert!((f.rounds_per_ccz(25, 30_000.0) - 114.79).abs() < 0.01);
+        assert!(f.error(1e-7) < 1e-12);
+        // Rounded up to 150 for slack: six factories match the 25 µs surgery
+        // period.
+        let t = Timing { cycle_us: 1.0, reaction_us: 10.0, distance: 25, ccz_rounds: 150.0, factories: 6 };
+        assert_eq!((t.surgery_us(), t.ccz_period_us(), t.step_us()), (25.0, 25.0, 25.0));
+        assert_eq!(t.bound(), Bound::Surgery);
+        assert_eq!(t.add_us(33), 1600.0);
+        assert_eq!(t.lookup_us(6), 1575.0);
+        let slow = Timing { reaction_us: 40.0, ..t };
+        assert_eq!(slow.bound(), Bound::Reaction);
+        let starved = Timing { factories: 2, ..t };
+        assert_eq!(starved.bound(), Bound::MagicStates);
+    }
+
+    #[test]
+    fn the_logical_counts_reproduce_the_published_table() {
+        let p = rsa();
+        assert_eq!(p.input_qubits(), 1280);
+        assert_eq!(p.primes(), 20_871);
+        assert_eq!(p.table_logical_qubits(), 1399);
+        assert_eq!(p.peak_logical_qubits(), 1432);
+        // The published count: 6.5·10⁹ Toffolis per factoring.
+        let per_shot = p.toffolis_per_shot_source_rule(PhaseupCount::AsCoded);
+        let published = per_shot * f64::from(p.s + 1) / (1.0 - p.deviant);
+        assert!((6.45e9..6.55e9).contains(&published), "{published:e}");
+        // The reference tally rounds loop 4's half operations to integers; held
+        // in halves here, it is 29.5 Toffolis lower.
+        assert_eq!(per_shot, 712_920_014.5);
+        // Every published row. The reference implementation's counts and keep
+        // rates (its simulated `1 − P_deviant`, printed rounded in the table)
+        // agree to its rounding of half operations.
+        for (n, keep, tofs, qubits) in [
+            (1024, 0.971_311_569_213_867_2, 1_083_979_446.0, 742),
+            (1536, 0.981_724_202_632_904, 3_117_105_798.0, 1074),
+            (2048, 0.987_522_467_970_848_1, 6_497_351_306.0, 1399),
+            (3072, 0.990_862_101_316_452, 18_500_632_076.0, 2043),
+            (4096, 0.992_021_542_042_493_8, 40_261_413_896.0, 2692),
+            (6144, 0.995_758_056_640_625, 119_251_229_120.0, 3978),
+            (8192, 0.996_010_778_006_166_2, 266_770_779_692.0, 5261),
+        ] {
+            let q = FactoringParams::published(n).unwrap();
+            assert_eq!(q.table_logical_qubits(), qubits, "n={n}");
+            assert!((1.0 - q.deviant - keep).abs() < 5e-5, "n={n}");
+            let t = q.toffolis_per_shot_source_rule(PhaseupCount::AsCoded) * f64::from(q.s + 1) / keep;
+            assert!((t / tofs - 1.0).abs() < 1e-7, "n={n}: {t} vs {tofs}");
+        }
+    }
+
+    #[test]
+    fn the_phaseup_rule_undercounts() {
+        let p = rsa();
+        let coded = p.toffolis_per_shot_source_rule(PhaseupCount::AsCoded);
+        let stated = p.toffolis_per_shot_source_rule(PhaseupCount::AsStated);
+        // 1,481,841 six-bit phaseups at 8 rather than 0.25, and 104,355
+        // five-bit ones at 6.
+        assert_eq!(stated - coded, 1_481_841.0 * 7.75 + 104_355.0 * 5.75);
+        assert!((0.016..0.018).contains(&(stated / coded - 1.0)), "{}", stated / coded - 1.0);
+        // Counted operation by operation, at full sizes, the total lands
+        // between the two.
+        let own = p.toffolis_per_shot();
+        assert!(own < stated, "{own} {stated}");
+    }
+
+    #[test]
+    fn the_stated_durations_give_ten_point_six_hours_not_twelve() {
+        // 2 ms per addition and per lookup, 1 ms per phaseup.
+        let ms: f64 = rsa().tallies().iter().map(|s| 2.0 * (s.adds() + s.lookups()) + s.phaseups()).sum();
+        let hours = ms / 3.6e6;
+        assert!((hours - 10.621).abs() < 0.001, "{hours}");
+        assert!(hours < 12.07 / 1.13);
+    }
+
+    #[test]
+    fn the_whole_machine_stays_under_a_million_qubits_and_a_week() {
+        let e = factoring_estimate(&rsa(), &Machine::published()).unwrap();
+        assert_eq!(e.hot_distance, 25);
+        assert_eq!(e.hot_logical, 152);
+        assert_eq!(e.compute_qubits, 170_352);
+        assert_eq!(e.cold_qubits, 582_624);
+        assert_eq!(e.physical_qubits(), 958_480);
+        assert!(e.physical_qubits() < 1_000_000);
+        assert_eq!(e.t_state.d1, 5);
+        assert!(e.ccz_error < 1e-12);
+        assert_eq!(e.timing.bound(), Bound::Surgery);
+        assert!(e.days < 7.0, "{}", e.days);
+        // At the source's own hot count the total is 926,256 rather than 897,864.
+        assert_eq!(1280 * 430 + 152 * 1352 + 7 * 18 * 1352, 926_256);
+    }
+
+    #[test]
+    fn a_measured_fit_converts_to_a_storage_fit() {
+        // a = 0.023, p* = 0.01 at p = 10⁻³: Λ = √10 and C = 1/(a·√0.1).
+        let f = StorageFit::flat_from_threshold(0.023, 0.01, 1e-3);
+        assert!((f.suppression - 10f64.sqrt()).abs() < 1e-12);
+        assert!((f.per_patch_round(9, 1, 1) - 0.023 * 1e-5).abs() < 1e-18);
+        let m = StorageModel { flat: f, ..StorageModel::uniform_refit() };
+        assert_eq!(flat_distance(&m, 1e-15), Some(26));
+    }
+}
diff --git a/wai/wai-quantum/src/repro.rs b/wai/wai-quantum/src/repro.rs
index 6836204df..f740492b5 100644
--- a/wai/wai-quantum/src/repro.rs
+++ b/wai/wai-quantum/src/repro.rs
@@ -34,28 +34,28 @@ pub use trig::sin_cos;
 // Natural logarithm
 // ---------------------------------------------------------------------------
 
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LN2_HI: f64 = 6.931_471_803_691_238_164_90e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LN2_LO: f64 = 1.908_214_929_270_587_700_02e-10;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG1: f64 = 6.666_666_666_666_735_130e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG2: f64 = 3.999_999_999_940_941_908e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG3: f64 = 2.857_142_874_366_239_149e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG4: f64 = 2.222_219_843_214_978_396e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG5: f64 = 1.818_357_216_161_805_012e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG6: f64 = 1.531_383_769_920_937_332e-1;
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const LG7: f64 = 1.479_819_860_511_658_591e-1;
 
 /// The natural logarithm, within an ulp of the true value: `−∞` at zero, NaN
 /// below it.
-#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 pub fn ln(x: f64) -> f64 {
     let mut bits = x.to_bits();
     let mut hx = (bits >> 32) as u32;
@@ -99,7 +99,7 @@ pub fn ln(x: f64) -> f64 {
 // Exponential
 // ---------------------------------------------------------------------------
 
-#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 const EXP_P: [f64; 5] = [
     1.666_666_666_666_660_190_37e-1,
     -2.777_777_777_701_559_338_42e-3,
@@ -111,7 +111,7 @@ const EXP_P: [f64; 5] = [
 /// `eˣ`, bit-identical on every IEEE-754 platform: fdlibm's algorithm
 /// (reduction by `ln 2` in two parts, a rational approximation on
 /// `[−ln2/2, ln2/2]`), using only `+ − × ÷`. Within an ulp of the true value.
-#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+#[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
 pub fn exp(x: f64) -> f64 {
     const LN2_HI_E: f64 = 6.931_471_803_691_238_164_90e-1;
     const LN2_LO_E: f64 = 1.908_214_929_270_587_700_02e-10;
@@ -312,7 +312,7 @@ mod tests {
     #[allow(unused_imports)]
     use super::*;
 
-    #[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+    #[cfg(any(feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
     #[test]
     fn exp_is_within_an_ulp_of_the_platform() {
         let mut s = 0x9e37_79b9_7f4a_7c15u64;
@@ -355,7 +355,7 @@ mod tests {
         })
     }
 
-    #[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs"))]
+    #[cfg(any(feature = "quantum_vml", feature = "quantum_kernel", feature = "quantum_resource", feature = "quantum_frame", feature = "quantum_tn", feature = "quantum_gbs", feature = "quantum_arch"))]
     #[test]
     fn ln_is_within_an_ulp_of_the_platform() {
         for x in inputs().filter(|&x| x > 0.0) {
diff --git a/wai/wai-quantum/tests/bit_identity.rs b/wai/wai-quantum/tests/bit_identity.rs
index 4c9455c68..5f2f4064a 100644
--- a/wai/wai-quantum/tests/bit_identity.rs
+++ b/wai/wai-quantum/tests/bit_identity.rs
@@ -19,7 +19,8 @@
     feature = "quantum_frame",
     feature = "quantum_tn",
     feature = "quantum_gbs",
-    feature = "quantum_sv"
+    feature = "quantum_sv",
+    feature = "quantum_arch"
 ))]
 
 use wai_quantum::*;
@@ -294,3 +295,47 @@ fn dense_state_vector() {
     assert_eq!(digest(&v), 0xd0df_e437_5b28_903f);
 }
 
+
+/// Storage layouts under every fit set, cultivation interpolation (in-crate
+/// `ln` and `exp`), the threshold-to-storage conversion, and the whole factoring
+/// machine at three key sizes.
+#[test]
+fn architecture_estimates() {
+    use quantum_arch::*;
+    let mut v = Vec::new();
+    for model in [StorageModel::si1000(), StorageModel::uniform(), StorageModel::uniform_refit()] {
+        for target in [1e-9, 3.7e-13, 1e-15] {
+            for b in [
+                best_block(&model, Storage::Cold, Yoke::Rows, target, 250),
+                best_block(&model, Storage::Hot, Yoke::Rows, target, 250),
+                grid_block(&model, 16, target),
+            ]
+            .into_iter()
+            .flatten()
+            {
+                v.push(f64::from(b.distance));
+                v.push(b.qubits_per_logical());
+                v.push(b.error_per_logical_round);
+            }
+        }
+    }
+    for (p, t) in [(5e-4, 3.3e-9), (1e-3, 1e-7), (1e-3, 4.4e-6), (2e-3, 2.2e-5)] {
+        let c = cultivate(p, t).unwrap();
+        v.push(c.volume);
+        v.push(c.error);
+    }
+    let f = StorageFit::flat_from_threshold(0.023, 0.0100, 1e-3);
+    v.push(f.suppression);
+    v.push(f.per_patch_round(17, 1, 1));
+    for bits in [1024, 2048, 4096] {
+        let e = factoring_estimate(&FactoringParams::published(bits).unwrap(), &Machine::published()).unwrap();
+        v.push(e.physical_qubits() as f64);
+        v.push(e.ccz_rounds);
+        v.push(e.hours_per_shot);
+        v.push(e.hours_per_shot_rounded);
+        v.push(e.shot_survival);
+        v.push(e.days);
+        v.push(e.toffolis_per_shot);
+    }
+    assert_eq!(digest(&v), 0xd166_b4c6_c731_7a52);
+}
diff --git a/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv b/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv
new file mode 100644
index 000000000..f9a649d16
--- /dev/null
+++ b/wai/wai-quantum/tests/data/yoked_footprint_oracle.csv
@@ -0,0 +1,916 @@
+set,storage,yokes,target,d,groups,ppg,rows,cols,logical,r,d0,rate,lerp
+si1000,cold,0,1e-18,35,1,4,1,4,4,350,35,2592.0,9.9936949580635e-19
+si1000,cold,0,1.778279410038923e-18,35,1,4,1,4,4,350,35,2592.0,9.9936949580635e-19
+si1000,cold,0,3.1622776601683795e-18,34,1,4,1,4,4,340,34,2450.0,2.99810848741905e-18
+si1000,cold,0,5.623413251903491e-18,34,1,4,1,4,4,340,34,2450.0,2.99810848741905e-18
+si1000,cold,0,1e-17,33,1,4,1,4,4,330,33,2312.0,8.994325462257151e-18
+si1000,cold,0,1.7782794100389228e-17,33,1,4,1,4,4,330,33,2312.0,8.994325462257151e-18
+si1000,cold,0,3.1622776601683796e-17,32,1,4,1,4,4,320,32,2178.0,2.698297638677145e-17
+si1000,cold,0,5.62341325190349e-17,32,1,4,1,4,4,320,32,2178.0,2.698297638677145e-17
+si1000,cold,0,1e-16,31,1,4,1,4,4,310,31,2048.0,8.094892916031435e-17
+si1000,cold,0,1.7782794100389228e-16,31,1,4,1,4,4,310,31,2048.0,8.094892916031435e-17
+si1000,cold,0,3.1622776601683793e-16,30,1,4,1,4,4,300,30,1922.0,2.4284678748094307e-16
+si1000,cold,0,5.623413251903491e-16,30,1,4,1,4,4,300,30,1922.0,2.4284678748094307e-16
+si1000,cold,0,1e-15,29,1,4,1,4,4,290,29,1800.0,7.285403624428292e-16
+si1000,cold,0,1.7782794100389227e-15,29,1,4,1,4,4,290,29,1800.0,7.285403624428292e-16
+si1000,cold,0,3.1622776601683794e-15,28,1,4,1,4,4,280,28,1682.0,2.1856210873284874e-15
+si1000,cold,0,5.6234132519034904e-15,28,1,4,1,4,4,280,28,1682.0,2.1856210873284874e-15
+si1000,cold,0,1e-14,27,1,4,1,4,4,270,27,1568.0,6.556863261985463e-15
+si1000,cold,0,1.7782794100389227e-14,27,1,4,1,4,4,270,27,1568.0,6.556863261985463e-15
+si1000,cold,0,3.1622776601683796e-14,26,1,4,1,4,4,260,26,1458.0,1.9670589785956387e-14
+si1000,cold,0,5.6234132519034906e-14,26,1,4,1,4,4,260,26,1458.0,1.9670589785956387e-14
+si1000,cold,0,1e-13,25,1,4,1,4,4,250,25,1352.0,5.901176935786916e-14
+si1000,cold,0,1.7782794100389227e-13,24,1,4,1,4,4,240,24,1250.0,1.770353080736075e-13
+si1000,cold,0,3.162277660168379e-13,24,1,4,1,4,4,240,24,1250.0,1.770353080736075e-13
+si1000,cold,0,5.62341325190349e-13,23,1,4,1,4,4,230,23,1152.0,5.311059242208225e-13
+si1000,cold,0,1e-12,23,1,4,1,4,4,230,23,1152.0,5.311059242208225e-13
+si1000,cold,0,1.7782794100389228e-12,22,1,4,1,4,4,220,22,1058.0,1.5933177726624674e-12
+si1000,cold,0,3.1622776601683794e-12,22,1,4,1,4,4,220,22,1058.0,1.5933177726624674e-12
+si1000,cold,0,5.6234132519034904e-12,21,1,4,1,4,4,210,21,968.0,4.779953317987403e-12
+si1000,cold,0,1e-11,21,1,4,1,4,4,210,21,968.0,4.779953317987403e-12
+si1000,cold,0,1.7782794100389227e-11,20,1,4,1,4,4,200,20,882.0,1.4339859953962207e-11
+si1000,cold,0,3.1622776601683794e-11,20,1,4,1,4,4,200,20,882.0,1.4339859953962207e-11
+si1000,cold,0,5.6234132519034906e-11,19,1,4,1,4,4,190,19,800.0,4.3019579861886616e-11
+si1000,cold,0,1e-10,19,1,4,1,4,4,190,19,800.0,4.3019579861886616e-11
+si1000,cold,0,1.778279410038923e-10,18,1,4,1,4,4,180,18,722.0,1.2905873958565984e-10
+si1000,cold,0,3.1622776601683795e-10,18,1,4,1,4,4,180,18,722.0,1.2905873958565984e-10
+si1000,cold,0,5.623413251903491e-10,17,1,4,1,4,4,170,17,648.0,3.871762187569796e-10
+si1000,cold,0,1e-09,17,1,4,1,4,4,170,17,648.0,3.871762187569796e-10
+si1000,cold,0,1.7782794100389228e-09,16,1,4,1,4,4,160,16,578.0,1.1615286562709387e-09
+si1000,cold,0,3.1622776601683795e-09,16,1,4,1,4,4,160,16,578.0,1.1615286562709387e-09
+si1000,cold,0,5.623413251903491e-09,15,1,4,1,4,4,150,15,512.0,3.4845859688128162e-09
+si1000,cold,0,1e-08,15,1,4,1,4,4,150,15,512.0,3.4845859688128162e-09
+si1000,cold,0,1.7782794100389228e-08,14,1,4,1,4,4,140,14,450.0,1.0453757906438449e-08
+si1000,cold,0,3.162277660168379e-08,13,1,4,1,4,4,130,13,392.0,3.1361273719315344e-08
+si1000,cold,0,5.6234132519034905e-08,13,1,4,1,4,4,130,13,392.0,3.1361273719315344e-08
+si1000,cold,0,1e-07,12,1,4,1,4,4,120,12,338.0,9.408382115794604e-08
+si1000,cold,0,1.7782794100389227e-07,12,1,4,1,4,4,120,12,338.0,9.408382115794604e-08
+si1000,cold,0,3.162277660168379e-07,11,1,4,1,4,4,110,11,288.0,2.822514634738381e-07
+si1000,cold,0,5.62341325190349e-07,11,1,4,1,4,4,110,11,288.0,2.822514634738381e-07
+si1000,cold,0,1e-06,10,1,4,1,4,4,100,10,242.0,8.467543904215143e-07
+si1000,cold,0,1.778279410038923e-06,10,1,4,1,4,4,100,10,242.0,8.467543904215143e-07
+si1000,cold,0,3.162277660168379e-06,9,1,4,1,4,4,90,9,200.0,2.5402631712645428e-06
+si1000,cold,0,5.623413251903491e-06,9,1,4,1,4,4,90,9,200.0,2.5402631712645428e-06
+si1000,cold,0,1e-05,8,1,4,1,4,4,80,8,162.0,7.6207895137936296e-06
+si1000,cold,0,1.778279410038923e-05,8,1,4,1,4,4,80,8,162.0,7.6207895137936296e-06
+si1000,cold,0,3.1622776601683795e-05,7,1,4,1,4,4,70,7,128.0,2.2862368541380887e-05
+si1000,cold,0,5.623413251903491e-05,7,1,4,1,4,4,70,7,128.0,2.2862368541380887e-05
+si1000,cold,0,0.0001,6,1,4,1,4,4,60,6,98.0,6.858710562414265e-05
+si1000,cold,0,0.00017782794100389227,6,1,4,1,4,4,60,6,98.0,6.858710562414265e-05
+si1000,cold,0,0.00031622776601683794,5,1,4,1,4,4,50,5,72.0,0.000205761316872428
+si1000,cold,0,0.0005623413251903491,5,1,4,1,4,4,50,5,72.0,0.000205761316872428
+si1000,cold,0,0.001,4,1,4,1,4,4,40,4,50.0,0.0006172839506172839
+si1000,cold,2,1e-18,22,9,20,10,20,162,1628,35,1306.1728395061727,9.80600631559112e-19
+si1000,cold,2,1.778279410038923e-18,22,11,24,12,24,242,1980,35,1259.107438016529,1.4051260155412135e-18
+si1000,cold,2,3.1622776601683795e-18,22,11,24,12,24,242,1980,34,1259.107438016529,1.4051260155412135e-18
+si1000,cold,2,5.623413251903491e-18,21,6,22,7,22,120,1050,34,1242.2666666666667,5.509915440571334e-18
+si1000,cold,2,1e-17,21,11,22,12,22,220,1890,33,1161.6,9.917847793028402e-18
+si1000,cold,2,1.7782794100389228e-17,21,11,24,12,24,242,1890,33,1152.0,1.0730053209587449e-17
+si1000,cold,2,3.1622776601683796e-17,21,11,24,12,24,242,1890,32,1152.0,1.0730053209587449e-17
+si1000,cold,2,5.62341325190349e-17,20,8,22,9,22,160,1320,32,1091.475,5.5414006716603137e-17
+si1000,cold,2,1e-16,20,11,24,12,24,242,1800,31,1049.6528925619834,8.175278635876152e-17
+si1000,cold,2,1.7782794100389228e-16,20,11,24,12,24,242,1800,31,1049.6528925619834,8.175278635876152e-17
+si1000,cold,2,3.1622776601683793e-16,19,7,18,8,18,112,1102,30,1028.5714285714287,3.0968977382528356e-16
+si1000,cold,2,5.623413251903491e-16,19,9,26,10,26,216,1406,30,962.9629629629629,5.495927786943374e-16
+si1000,cold,2,1e-15,19,11,24,12,24,242,1710,29,952.0661157024794,6.213211763265875e-16
+si1000,cold,2,1.7782794100389227e-15,19,11,24,12,24,242,1710,29,952.0661157024794,6.213211763265875e-16
+si1000,cold,2,3.1622776601683794e-15,18,7,24,8,24,154,1044,28,900.1558441558442,3.0346634296372278e-15
+si1000,cold,2,5.6234132519034904e-15,18,11,24,12,24,242,1620,28,859.2396694214876,4.708960494264664e-15
+si1000,cold,2,1e-14,18,11,24,12,24,242,1620,27,859.2396694214876,4.708960494264664e-15
+si1000,cold,2,1.7782794100389227e-14,17,7,18,8,18,112,986,27,833.1428571428571,1.773381441694255e-14
+si1000,cold,2,3.1622776601683796e-14,17,9,26,10,26,216,1258,26,780.0,3.1471418064181e-14
+si1000,cold,2,5.6234132519034906e-14,17,11,24,12,24,242,1530,26,771.1735537190083,3.5578812623333014e-14
+si1000,cold,2,1e-13,17,11,24,12,24,242,1530,25,771.1735537190083,3.5578812623333014e-14
+si1000,cold,2,1.7782794100389227e-13,16,7,24,8,24,154,928,24,720.6233766233767,1.7263863066380675e-13
+si1000,cold,2,3.162277660168379e-13,16,11,24,12,24,242,1440,24,687.8677685950413,2.678875303403898e-13
+si1000,cold,2,5.62341325190349e-13,16,11,24,12,24,242,1440,23,687.8677685950413,2.678875303403898e-13
+si1000,cold,2,1e-12,15,6,20,7,20,108,750,23,663.7037037037037,9.473903143468003e-13
+si1000,cold,2,1.7782794100389228e-12,15,9,26,10,26,216,1110,22,616.2962962962963,1.7772094906831626e-12
+si1000,cold,2,3.1622776601683794e-12,15,11,24,12,24,242,1350,22,609.3223140495868,2.0091564775529236e-12
+si1000,cold,2,5.6234132519034904e-12,14,5,18,6,18,80,588,21,607.5,5.414676707005128e-12
+si1000,cold,2,1e-11,14,7,24,8,24,154,812,21,561.038961038961,9.667763317173176e-12
+si1000,cold,2,1.7782794100389227e-11,14,11,24,12,24,242,1260,20,535.5371900826447,1.500170169906183e-11
+si1000,cold,2,3.1622776601683794e-11,14,11,24,12,24,242,1260,20,535.5371900826447,1.500170169906183e-11
+si1000,cold,2,5.6234132519034906e-11,13,7,18,8,18,112,754,19,504.0,5.554647941607982e-11
+si1000,cold,2,1e-10,13,9,26,10,26,216,962,19,471.85185185185185,9.857588641655941e-11
+si1000,cold,2,1.778279410038923e-10,13,11,24,12,24,242,1170,18,466.5123966942149,1.1144121262160213e-10
+si1000,cold,2,3.1622776601683795e-10,12,5,18,6,18,80,504,18,456.3,2.9703369364142417e-10
+si1000,cold,2,5.623413251903491e-10,12,8,22,9,22,160,792,17,418.275,5.578156560659408e-10
+si1000,cold,2,1e-09,12,11,24,12,24,242,1080,17,402.24793388429754,8.229504932056774e-10
+si1000,cold,2,1.7782794100389228e-09,12,11,24,12,24,242,1080,16,402.24793388429754,8.229504932056774e-10
+si1000,cold,2,3.1622776601683795e-09,11,6,22,7,22,120,550,16,369.6,3.0989758670330053e-09
+si1000,cold,2,5.623413251903491e-09,11,11,22,12,22,220,990,15,345.6,5.578156560659409e-09
+si1000,cold,2,1e-08,11,11,24,12,24,242,990,15,342.74380165289256,6.0349702835082995e-09
+si1000,cold,2,1.7782794100389228e-08,10,7,14,8,14,84,580,14,322.6666666666667,1.7645458380381265e-08
+si1000,cold,2,3.162277660168379e-08,10,9,20,10,20,162,740,13,298.7654320987654,3.063016467624241e-08
+si1000,cold,2,5.6234132519034905e-08,10,11,24,12,24,242,900,13,288.0,4.389069297096946e-08
+si1000,cold,2,1e-07,9,6,12,7,12,60,450,12,280.0,9.655952453613282e-08
+si1000,cold,2,1.7782794100389227e-07,9,7,20,8,20,126,522,12,253.96825396825398,1.7285346984863283e-07
+si1000,cold,2,3.162277660168379e-07,9,11,24,12,24,242,810,11,238.01652892561984,3.160129893909801e-07
+si1000,cold,2,5.62341325190349e-07,8,4,14,5,14,48,272,11,236.25,5.29607137044271e-07
+si1000,cold,2,1e-06,8,6,18,7,18,96,400,10,212.625,9.65595245361328e-07
+si1000,cold,2,1.778279410038923e-06,8,8,26,9,26,192,528,10,197.4375,1.7728805541992187e-06
+si1000,cold,2,3.162277660168379e-06,8,11,24,12,24,242,720,9,192.79338842975207,2.2472034801136364e-06
+si1000,cold,2,5.623413251903491e-06,7,6,14,7,14,72,350,9,174.22222222222223,5.45183817545573e-06
+si1000,cold,2,1e-05,7,8,20,9,20,144,462,8,160.0,9.791056315104167e-06
+si1000,cold,2,1.778279410038923e-05,7,11,24,12,24,242,630,8,152.3305785123967,1.5730424360795456e-05
+si1000,cold,2,3.1622776601683795e-05,6,5,14,6,14,60,252,7,137.2,3.1402587890625004e-05
+si1000,cold,2,5.623413251903491e-05,6,6,22,7,22,120,300,7,125.76666666666667,5.5389404296875e-05
+si1000,cold,2,0.0001,6,11,22,12,22,220,540,6,117.6,9.970092773437501e-05
+si1000,cold,2,0.00017782794100389227,5,4,14,5,14,48,170,6,105.0,0.0001694742838541667
+si1000,cold,2,0.00031622776601683794,5,6,18,7,18,96,250,5,94.5,0.000308990478515625
+si1000,cold,2,0.0005623413251903491,5,10,20,11,20,180,410,5,88.0,0.0005560980902777779
+si1000,cold,2,0.001,4,4,12,5,12,40,136,4,75.0,0.0009562500000000001
+si1000,cold,64,1e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19
+si1000,cold,64,1.778279410038923e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19
+si1000,cold,64,3.1622776601683795e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19
+si1000,cold,64,5.623413251903491e-18,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19
+si1000,cold,64,1e-17,16,1,256,17,17,194,6464,None,861.0412371134021,2.9897314430924283e-19
+si1000,cold,64,1.7782794100389228e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,3.1622776601683796e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,5.62341325190349e-17,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,1e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,1.7782794100389228e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,3.1622776601683793e-16,15,1,256,17,17,194,6060,None,762.7216494845361,1.2317313989791198e-17
+si1000,cold,64,5.623413251903491e-16,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,1e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,1.7782794100389227e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,3.1622776601683794e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,5.6234132519034904e-15,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,1e-14,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,1.7782794100389227e-14,14,1,256,17,17,194,5656,None,670.360824742268,5.007216235257339e-16
+si1000,cold,64,3.1622776601683796e-14,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,5.6234132519034906e-14,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,1e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,1.7782794100389227e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,3.162277660168379e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,5.62341325190349e-13,13,1,256,17,17,194,5252,None,583.9587628865979,2.0045288026349078e-14
+si1000,cold,64,1e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,1.7782794100389228e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,3.1622776601683794e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,5.6234132519034904e-12,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,1e-11,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,1.7782794100389227e-11,12,1,256,17,17,194,4848,None,503.5154639175258,7.883080953466364e-13
+si1000,cold,64,3.1622776601683794e-11,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,5.6234132519034906e-11,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,1e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,1.778279410038923e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,3.1622776601683795e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,5.623413251903491e-10,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,1e-09,11,1,256,17,17,194,4444,None,429.03092783505156,3.035989800076311e-11
+si1000,cold,64,1.7782794100389228e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,3.1622776601683795e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,5.623413251903491e-09,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,1e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,1.7782794100389228e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,3.162277660168379e-08,10,1,256,17,17,194,4040,None,360.50515463917526,1.1404920360917772e-09
+si1000,cold,64,5.6234132519034905e-08,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,1e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,1.7782794100389227e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,3.162277660168379e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,5.62341325190349e-07,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,1e-06,9,1,256,17,17,194,3636,None,297.9381443298969,4.1570934715545284e-08
+si1000,cold,64,1.778279410038923e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,3.162277660168379e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,5.623413251903491e-06,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,1e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,1.778279410038923e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,3.1622776601683795e-05,8,1,256,17,17,194,3232,None,241.3298969072165,1.4598298061974746e-06
+si1000,cold,64,5.623413251903491e-05,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,cold,64,0.0001,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,cold,64,0.00017782794100389227,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,cold,64,0.00031622776601683794,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,cold,64,0.0005623413251903491,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,cold,64,0.001,7,1,256,17,17,194,2828,None,190.68041237113403,4.889859604743495e-05
+si1000,hot,0,1e-18,35,2,125,3,126,250,1750,35,3919.104,9.9936949580635e-19
+si1000,hot,0,1.778279410038923e-18,35,2,125,3,126,250,1750,35,3919.104,9.9936949580635e-19
+si1000,hot,0,3.1622776601683795e-18,34,2,125,3,126,250,1700,34,3704.4,2.99810848741905e-18
+si1000,hot,0,5.623413251903491e-18,34,2,125,3,126,250,1700,34,3704.4,2.99810848741905e-18
+si1000,hot,0,1e-17,33,2,125,3,126,250,1650,33,3495.744,8.994325462257151e-18
+si1000,hot,0,1.7782794100389228e-17,33,2,125,3,126,250,1650,33,3495.744,8.994325462257151e-18
+si1000,hot,0,3.1622776601683796e-17,32,2,125,3,126,250,1600,32,3293.136,2.698297638677145e-17
+si1000,hot,0,5.62341325190349e-17,32,2,125,3,126,250,1600,32,3293.136,2.698297638677145e-17
+si1000,hot,0,1e-16,31,2,125,3,126,250,1550,31,3096.576,8.094892916031435e-17
+si1000,hot,0,1.7782794100389228e-16,31,2,125,3,126,250,1550,31,3096.576,8.094892916031435e-17
+si1000,hot,0,3.1622776601683793e-16,30,2,125,3,126,250,1500,30,2906.064,2.4284678748094307e-16
+si1000,hot,0,5.623413251903491e-16,30,2,125,3,126,250,1500,30,2906.064,2.4284678748094307e-16
+si1000,hot,0,1e-15,29,2,125,3,126,250,1450,29,2721.6,7.285403624428292e-16
+si1000,hot,0,1.7782794100389227e-15,29,2,125,3,126,250,1450,29,2721.6,7.285403624428292e-16
+si1000,hot,0,3.1622776601683794e-15,28,2,125,3,126,250,1400,28,2543.184,2.1856210873284874e-15
+si1000,hot,0,5.6234132519034904e-15,28,2,125,3,126,250,1400,28,2543.184,2.1856210873284874e-15
+si1000,hot,0,1e-14,27,2,125,3,126,250,1350,27,2370.816,6.556863261985463e-15
+si1000,hot,0,1.7782794100389227e-14,27,2,125,3,126,250,1350,27,2370.816,6.556863261985463e-15
+si1000,hot,0,3.1622776601683796e-14,26,2,125,3,126,250,1300,26,2204.496,1.9670589785956387e-14
+si1000,hot,0,5.6234132519034906e-14,26,2,125,3,126,250,1300,26,2204.496,1.9670589785956387e-14
+si1000,hot,0,1e-13,25,2,125,3,126,250,1250,25,2044.224,5.901176935786916e-14
+si1000,hot,0,1.7782794100389227e-13,24,2,125,3,126,250,1200,24,1890.0,1.770353080736075e-13
+si1000,hot,0,3.162277660168379e-13,24,2,125,3,126,250,1200,24,1890.0,1.770353080736075e-13
+si1000,hot,0,5.62341325190349e-13,23,2,125,3,126,250,1150,23,1741.824,5.311059242208225e-13
+si1000,hot,0,1e-12,23,2,125,3,126,250,1150,23,1741.824,5.311059242208225e-13
+si1000,hot,0,1.7782794100389228e-12,22,2,125,3,126,250,1100,22,1599.696,1.5933177726624674e-12
+si1000,hot,0,3.1622776601683794e-12,22,2,125,3,126,250,1100,22,1599.696,1.5933177726624674e-12
+si1000,hot,0,5.6234132519034904e-12,21,2,125,3,126,250,1050,21,1463.616,4.779953317987403e-12
+si1000,hot,0,1e-11,21,2,125,3,126,250,1050,21,1463.616,4.779953317987403e-12
+si1000,hot,0,1.7782794100389227e-11,20,2,125,3,126,250,1000,20,1333.584,1.4339859953962207e-11
+si1000,hot,0,3.1622776601683794e-11,20,2,125,3,126,250,1000,20,1333.584,1.4339859953962207e-11
+si1000,hot,0,5.6234132519034906e-11,19,2,125,3,126,250,950,19,1209.6,4.3019579861886616e-11
+si1000,hot,0,1e-10,19,2,125,3,126,250,950,19,1209.6,4.3019579861886616e-11
+si1000,hot,0,1.778279410038923e-10,18,2,125,3,126,250,900,18,1091.664,1.2905873958565984e-10
+si1000,hot,0,3.1622776601683795e-10,18,2,125,3,126,250,900,18,1091.664,1.2905873958565984e-10
+si1000,hot,0,5.623413251903491e-10,17,2,125,3,126,250,850,17,979.776,3.871762187569796e-10
+si1000,hot,0,1e-09,17,2,125,3,126,250,850,17,979.776,3.871762187569796e-10
+si1000,hot,0,1.7782794100389228e-09,16,2,125,3,126,250,800,16,873.936,1.1615286562709387e-09
+si1000,hot,0,3.1622776601683795e-09,16,2,125,3,126,250,800,16,873.936,1.1615286562709387e-09
+si1000,hot,0,5.623413251903491e-09,15,2,125,3,126,250,750,15,774.144,3.4845859688128162e-09
+si1000,hot,0,1e-08,15,2,125,3,126,250,750,15,774.144,3.4845859688128162e-09
+si1000,hot,0,1.7782794100389228e-08,14,2,125,3,126,250,700,14,680.4,1.0453757906438449e-08
+si1000,hot,0,3.162277660168379e-08,13,2,125,3,126,250,650,13,592.704,3.1361273719315344e-08
+si1000,hot,0,5.6234132519034905e-08,13,2,125,3,126,250,650,13,592.704,3.1361273719315344e-08
+si1000,hot,0,1e-07,12,2,125,3,126,250,600,12,511.056,9.408382115794604e-08
+si1000,hot,0,1.7782794100389227e-07,12,2,125,3,126,250,600,12,511.056,9.408382115794604e-08
+si1000,hot,0,3.162277660168379e-07,11,2,125,3,126,250,550,11,435.456,2.822514634738381e-07
+si1000,hot,0,5.62341325190349e-07,11,2,125,3,126,250,550,11,435.456,2.822514634738381e-07
+si1000,hot,0,1e-06,10,2,125,3,126,250,500,10,365.904,8.467543904215143e-07
+si1000,hot,0,1.778279410038923e-06,10,2,125,3,126,250,500,10,365.904,8.467543904215143e-07
+si1000,hot,0,3.162277660168379e-06,9,2,125,3,126,250,450,9,302.4,2.5402631712645428e-06
+si1000,hot,0,5.623413251903491e-06,9,2,125,3,126,250,450,9,302.4,2.5402631712645428e-06
+si1000,hot,0,1e-05,8,2,125,3,126,250,400,8,244.944,7.6207895137936296e-06
+si1000,hot,0,1.778279410038923e-05,8,2,125,3,126,250,400,8,244.944,7.6207895137936296e-06
+si1000,hot,0,3.1622776601683795e-05,7,2,125,3,126,250,350,7,193.536,2.2862368541380887e-05
+si1000,hot,0,5.623413251903491e-05,7,2,125,3,126,250,350,7,193.536,2.2862368541380887e-05
+si1000,hot,0,0.0001,6,2,125,3,126,250,300,6,148.176,6.858710562414265e-05
+si1000,hot,0,0.00017782794100389227,6,2,125,3,126,250,300,6,148.176,6.858710562414265e-05
+si1000,hot,0,0.00031622776601683794,5,2,125,3,126,250,250,5,108.864,0.000205761316872428
+si1000,hot,0,0.0005623413251903491,5,2,125,3,126,250,250,5,108.864,0.000205761316872428
+si1000,hot,0,0.001,4,2,125,3,126,250,200,4,75.6,0.0006172839506172839
+si1000,hot,2,1e-18,23,2,126,3,127,248,1150,35,2064.7741935483873,4.988586881032472e-19
+si1000,hot,2,1.778279410038923e-18,22,2,56,3,57,108,1100,35,1990.7777777777778,1.7315110250953687e-18
+si1000,hot,2,3.1622776601683795e-18,22,2,104,3,105,204,1100,34,1917.7941176470588,3.1616185704322395e-18
+si1000,hot,2,5.623413251903491e-18,22,2,126,3,127,248,1100,34,1908.0725806451612,3.817353439398761e-18
+si1000,hot,2,1e-17,21,2,40,3,41,76,1050,33,1851.4736842105262,9.586629735661302e-18
+si1000,hot,2,1.7782794100389228e-17,21,2,76,3,77,148,1050,33,1785.5675675675675,1.7771538745108342e-17
+si1000,hot,2,3.1622776601683796e-17,21,2,126,3,127,248,1050,32,1734.983870967742,2.915069899177236e-17
+si1000,hot,2,5.62341325190349e-17,21,2,126,3,127,248,1050,32,1734.983870967742,2.915069899177236e-17
+si1000,hot,2,1e-16,20,2,54,3,55,104,1000,31,1643.6538461538462,9.727795492208403e-17
+si1000,hot,2,1.7782794100389228e-16,20,2,100,3,101,196,1000,31,1601.5714285714287,1.7701259958947012e-16
+si1000,hot,2,3.1622776601683793e-16,20,2,126,3,127,248,1000,30,1570.0887096774193,2.22100563746837e-16
+si1000,hot,2,5.623413251903491e-16,19,2,40,3,41,76,950,30,1532.1052631578948,5.551115123125783e-16
+si1000,hot,2,1e-15,19,2,72,3,73,140,950,29,1460.0,9.76361848513209e-16
+si1000,hot,2,1.7782794100389227e-15,19,2,126,3,127,248,950,29,1433.8709677419354,1.6879642844759612e-15
+si1000,hot,2,3.1622776601683794e-15,19,2,126,3,127,248,950,28,1413.3870967741937,1.6879642844759612e-15
+si1000,hot,2,5.6234132519034904e-15,18,2,54,3,55,104,900,28,1346.4423076923076,5.603210203512041e-15
+si1000,hot,2,1e-14,18,2,98,3,99,192,900,27,1293.1875,9.996170557968753e-15
+si1000,hot,2,1.7782794100389227e-14,18,2,126,3,127,248,900,27,1284.3387096774193,1.2792992471817812e-14
+si1000,hot,2,3.1622776601683796e-14,17,2,38,3,39,72,850,26,1228.5,3.028194978722038e-14
+si1000,hot,2,5.6234132519034906e-14,17,2,72,3,73,140,850,26,1182.6,5.590956269380902e-14
+si1000,hot,2,1e-13,17,2,126,3,127,248,850,25,1143.0,9.665816534262346e-14
+si1000,hot,2,1.7782794100389227e-13,16,2,28,3,29,52,800,24,1118.7307692307693,1.7140477071874416e-13
+si1000,hot,2,3.162277660168379e-13,16,2,52,3,53,100,800,24,1063.18,3.0740920919924977e-13
+si1000,hot,2,5.62341325190349e-13,16,2,96,3,97,188,800,23,1017.468085106383,5.573073917246879e-13
+si1000,hot,2,1e-12,16,2,126,3,127,248,800,23,1009.8548387096774,7.277791272856356e-13
+si1000,hot,2,1.7782794100389228e-12,15,2,38,3,39,72,750,22,953.3333333333334,1.7100395173959746e-12
+si1000,hot,2,3.1622776601683794e-12,15,2,72,3,73,140,750,22,917.7142857142857,3.1572458932974506e-12
+si1000,hot,2,5.6234132519034904e-12,15,2,126,3,127,248,750,21,884.9032258064516,5.458343454642266e-12
+si1000,hot,2,1e-11,14,2,28,3,29,52,700,21,870.0,9.598667160249673e-12
+si1000,hot,2,1.7782794100389227e-11,14,2,52,3,53,100,700,20,810.9,1.721491571515799e-11
+si1000,hot,2,3.1622776601683794e-11,14,2,96,3,97,188,700,20,789.4148936170212,3.1209213936582525e-11
+si1000,hot,2,5.6234132519034906e-11,14,2,126,3,127,248,700,19,768.1451612903226,4.075563112799559e-11
+si1000,hot,2,1e-10,13,2,40,3,41,76,650,19,725.0526315789474,9.956573577303635e-11
+si1000,hot,2,1.778279410038923e-10,13,2,72,3,73,140,650,18,686.2,1.7512190554823194e-10
+si1000,hot,2,3.1622776601683795e-10,13,2,126,3,127,248,650,18,673.9193548387096,3.0275611695082437e-10
+si1000,hot,2,5.623413251903491e-10,12,2,30,3,31,56,600,17,633.2857142857143,5.612881588084357e-10
+si1000,hot,2,1e-09,12,2,54,3,55,104,600,17,605.0,9.792319570596403e-10
+si1000,hot,2,1.7782794100389228e-09,12,2,98,3,99,192,600,16,576.46875,1.7469574231654403e-09
+si1000,hot,2,3.1622776601683795e-09,11,2,22,3,23,40,550,16,565.8,3.0989758670330053e-09
+si1000,hot,2,5.623413251903491e-09,11,2,40,3,41,76,550,15,517.8947368421053,5.3918675372475066e-09
+si1000,hot,2,1e-08,11,2,76,3,77,148,550,15,499.4594594594595,9.995356604859635e-09
+si1000,hot,2,1.7782794100389228e-08,11,2,126,3,127,248,550,14,479.3225806451613,1.6395408179490798e-08
+si1000,hot,2,3.162277660168379e-08,10,2,30,3,31,56,500,13,438.42857142857144,2.9935368469783234e-08
+si1000,hot,2,5.6234132519034905e-08,10,2,58,3,59,112,500,13,417.2142857142857,5.594587751797268e-08
+si1000,hot,2,1e-07,10,2,104,3,105,204,500,12,396.3235294117647,9.87567153631472e-08
+si1000,hot,2,1.7782794100389227e-07,9,2,24,3,25,44,450,12,375.0,1.7556277188387783e-07
+si1000,hot,2,3.162277660168379e-07,9,2,44,3,45,84,450,11,342.85714285714283,3.0909265790666854e-07
+si1000,hot,2,5.62341325190349e-07,9,2,80,3,81,156,450,11,332.3076923076923,5.501967210036057e-07
+si1000,hot,2,1e-06,8,2,18,3,19,32,400,10,309.9375,9.65595245361328e-07
+si1000,hot,2,1.778279410038923e-06,8,2,34,3,35,64,400,10,285.46875,1.7225742340087892e-06
+si1000,hot,2,3.162277660168379e-06,8,2,64,3,65,124,400,9,264.19354838709677,3.150201612903226e-06
+si1000,hot,2,5.623413251903491e-06,8,2,114,3,115,224,400,9,258.75,5.533014025006975e-06
+si1000,hot,2,1e-05,7,2,26,3,27,48,350,8,225.0,9.401639302571615e-06
+si1000,hot,2,1.778279410038923e-05,7,2,50,3,51,96,350,8,212.5,1.7384688059488933e-05
+si1000,hot,2,3.1622776601683795e-05,7,2,92,3,93,180,350,7,198.4,3.139071994357639e-05
+si1000,hot,2,5.623413251903491e-05,6,2,22,3,23,40,300,7,177.1,5.5389404296875e-05
+si1000,hot,2,0.0001,6,2,40,3,41,76,300,6,158.60526315789474,9.637129934210526e-05
+si1000,hot,2,0.00017782794100389227,6,2,74,3,75,144,300,6,153.125,0.0001740773518880208
+si1000,hot,2,0.00031622776601683794,5,2,18,3,19,32,250,5,128.25,0.000308990478515625
+si1000,hot,2,0.0005623413251903491,5,2,34,3,35,64,250,5,118.125,0.0005512237548828125
+si1000,hot,2,0.001,5,2,62,3,63,120,250,4,107.1,0.0009775797526041668
+uniform,cold,0,1e-18,29,1,4,1,4,4,290,29,1800.0,3.4694469519536144e-19
+uniform,cold,0,1.778279410038923e-18,28,1,4,1,4,4,280,28,1682.0,1.3877787807814458e-18
+uniform,cold,0,3.1622776601683795e-18,28,1,4,1,4,4,280,28,1682.0,1.3877787807814458e-18
+uniform,cold,0,5.623413251903491e-18,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18
+uniform,cold,0,1e-17,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18
+uniform,cold,0,1.7782794100389228e-17,27,1,4,1,4,4,270,27,1568.0,5.551115123125783e-18
+uniform,cold,0,3.1622776601683796e-17,26,1,4,1,4,4,260,26,1458.0,2.2204460492503132e-17
+uniform,cold,0,5.62341325190349e-17,26,1,4,1,4,4,260,26,1458.0,2.2204460492503132e-17
+uniform,cold,0,1e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17
+uniform,cold,0,1.7782794100389228e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17
+uniform,cold,0,3.1622776601683793e-16,25,1,4,1,4,4,250,25,1352.0,8.881784197001253e-17
+uniform,cold,0,5.623413251903491e-16,24,1,4,1,4,4,240,24,1250.0,3.552713678800501e-16
+uniform,cold,0,1e-15,24,1,4,1,4,4,240,24,1250.0,3.552713678800501e-16
+uniform,cold,0,1.7782794100389227e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15
+uniform,cold,0,3.1622776601683794e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15
+uniform,cold,0,5.6234132519034904e-15,23,1,4,1,4,4,230,23,1152.0,1.4210854715202005e-15
+uniform,cold,0,1e-14,22,1,4,1,4,4,220,22,1058.0,5.684341886080802e-15
+uniform,cold,0,1.7782794100389227e-14,22,1,4,1,4,4,220,22,1058.0,5.684341886080802e-15
+uniform,cold,0,3.1622776601683796e-14,21,1,4,1,4,4,210,21,968.0,2.2737367544323207e-14
+uniform,cold,0,5.6234132519034906e-14,21,1,4,1,4,4,210,21,968.0,2.2737367544323207e-14
+uniform,cold,0,1e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14
+uniform,cold,0,1.7782794100389227e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14
+uniform,cold,0,3.162277660168379e-13,20,1,4,1,4,4,200,20,882.0,9.094947017729283e-14
+uniform,cold,0,5.62341325190349e-13,19,1,4,1,4,4,190,19,800.0,3.637978807091713e-13
+uniform,cold,0,1e-12,19,1,4,1,4,4,190,19,800.0,3.637978807091713e-13
+uniform,cold,0,1.7782794100389228e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12
+uniform,cold,0,3.1622776601683794e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12
+uniform,cold,0,5.6234132519034904e-12,18,1,4,1,4,4,180,18,722.0,1.4551915228366853e-12
+uniform,cold,0,1e-11,17,1,4,1,4,4,170,17,648.0,5.820766091346741e-12
+uniform,cold,0,1.7782794100389227e-11,17,1,4,1,4,4,170,17,648.0,5.820766091346741e-12
+uniform,cold,0,3.1622776601683794e-11,16,1,4,1,4,4,160,16,578.0,2.3283064365386964e-11
+uniform,cold,0,5.6234132519034906e-11,16,1,4,1,4,4,160,16,578.0,2.3283064365386964e-11
+uniform,cold,0,1e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11
+uniform,cold,0,1.778279410038923e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11
+uniform,cold,0,3.1622776601683795e-10,15,1,4,1,4,4,150,15,512.0,9.313225746154786e-11
+uniform,cold,0,5.623413251903491e-10,14,1,4,1,4,4,140,14,450.0,3.7252902984619143e-10
+uniform,cold,0,1e-09,14,1,4,1,4,4,140,14,450.0,3.7252902984619143e-10
+uniform,cold,0,1.7782794100389228e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09
+uniform,cold,0,3.1622776601683795e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09
+uniform,cold,0,5.623413251903491e-09,13,1,4,1,4,4,130,13,392.0,1.4901161193847657e-09
+uniform,cold,0,1e-08,12,1,4,1,4,4,120,12,338.0,5.960464477539063e-09
+uniform,cold,0,1.7782794100389228e-08,12,1,4,1,4,4,120,12,338.0,5.960464477539063e-09
+uniform,cold,0,3.162277660168379e-08,11,1,4,1,4,4,110,11,288.0,2.384185791015625e-08
+uniform,cold,0,5.6234132519034905e-08,11,1,4,1,4,4,110,11,288.0,2.384185791015625e-08
+uniform,cold,0,1e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08
+uniform,cold,0,1.7782794100389227e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08
+uniform,cold,0,3.162277660168379e-07,10,1,4,1,4,4,100,10,242.0,9.5367431640625e-08
+uniform,cold,0,5.62341325190349e-07,9,1,4,1,4,4,90,9,200.0,3.814697265625e-07
+uniform,cold,0,1e-06,9,1,4,1,4,4,90,9,200.0,3.814697265625e-07
+uniform,cold,0,1.778279410038923e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06
+uniform,cold,0,3.162277660168379e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06
+uniform,cold,0,5.623413251903491e-06,8,1,4,1,4,4,80,8,162.0,1.52587890625e-06
+uniform,cold,0,1e-05,7,1,4,1,4,4,70,7,128.0,6.103515625e-06
+uniform,cold,0,1.778279410038923e-05,7,1,4,1,4,4,70,7,128.0,6.103515625e-06
+uniform,cold,0,3.1622776601683795e-05,6,1,4,1,4,4,60,6,98.0,2.44140625e-05
+uniform,cold,0,5.623413251903491e-05,6,1,4,1,4,4,60,6,98.0,2.44140625e-05
+uniform,cold,0,0.0001,5,1,4,1,4,4,50,5,72.0,9.765625e-05
+uniform,cold,0,0.00017782794100389227,5,1,4,1,4,4,50,5,72.0,9.765625e-05
+uniform,cold,0,0.00031622776601683794,5,1,4,1,4,4,50,5,72.0,9.765625e-05
+uniform,cold,0,0.0005623413251903491,4,1,4,1,4,4,40,4,50.0,0.000390625
+uniform,cold,0,0.001,4,1,4,1,4,4,40,4,50.0,0.000390625
+uniform,cold,2,1e-18,20,11,24,12,24,242,1800,29,1049.6528925619834,2.356363636363636e-19
+uniform,cold,2,1.778279410038923e-18,19,8,26,9,26,192,1254,28,975.0,1.76605e-18
+uniform,cold,2,3.1622776601683795e-18,19,11,24,12,24,242,1710,28,952.0661157024794,2.2385454545454543e-18
+uniform,cold,2,5.623413251903491e-18,19,11,24,12,24,242,1710,27,952.0661157024794,2.2385454545454543e-18
+uniform,cold,2,1e-17,18,6,20,7,20,108,900,27,935.925925925926,1e-17
+uniform,cold,2,1.7782794100389228e-17,18,9,24,10,24,198,1332,27,875.1515151515151,1.743709090909091e-17
+uniform,cold,2,3.1622776601683796e-17,18,11,24,12,24,242,1620,26,859.2396694214876,2.1207272727272726e-17
+uniform,cold,2,5.62341325190349e-17,18,11,24,12,24,242,1620,26,859.2396694214876,2.1207272727272726e-17
+uniform,cold,2,1e-16,17,7,18,8,18,112,986,25,833.1428571428571,9.983250000000002e-17
+uniform,cold,2,1.7782794100389228e-16,17,9,26,10,26,216,1258,25,780.0,1.7716833333333334e-16
+uniform,cold,2,3.1622776601683793e-16,17,11,24,12,24,242,1530,25,771.1735537190083,2.0029090909090908e-16
+uniform,cold,2,5.623413251903491e-16,17,11,24,12,24,242,1530,24,771.1735537190083,2.0029090909090908e-16
+uniform,cold,2,1e-15,16,6,22,7,22,120,800,24,741.7666666666667,9.68e-16
+uniform,cold,2,1.7782794100389227e-15,16,11,22,12,22,220,1440,23,693.6,1.7424e-15
+uniform,cold,2,3.1622776601683794e-15,16,11,24,12,24,242,1440,23,687.8677685950413,1.885090909090909e-15
+uniform,cold,2,5.6234132519034904e-15,16,11,24,12,24,242,1440,23,687.8677685950413,1.885090909090909e-15
+uniform,cold,2,1e-14,15,7,20,8,20,126,870,22,650.1587301587301,9.666666666666667e-15
+uniform,cold,2,1.7782794100389227e-14,15,11,24,12,24,242,1350,22,609.3223140495868,1.767272727272727e-14
+uniform,cold,2,3.1622776601683796e-14,15,11,24,12,24,242,1350,21,609.3223140495868,1.767272727272727e-14
+uniform,cold,2,5.6234132519034906e-14,15,11,24,12,24,242,1350,21,609.3223140495868,1.767272727272727e-14
+uniform,cold,2,1e-13,14,7,22,8,22,140,812,20,565.7142857142857,9.825200000000003e-14
+uniform,cold,2,1.7782794100389227e-13,14,11,24,12,24,242,1260,20,535.5371900826447,1.6494545454545455e-13
+uniform,cold,2,3.162277660168379e-13,14,11,24,12,24,242,1260,20,535.5371900826447,1.6494545454545455e-13
+uniform,cold,2,5.62341325190349e-13,13,5,18,6,18,80,546,19,529.2,5.52825e-13
+uniform,cold,2,1e-12,13,7,24,8,24,154,754,19,488.72727272727275,9.870545454545453e-13
+uniform,cold,2,1.7782794100389228e-12,13,11,24,12,24,242,1170,18,466.5123966942149,1.5316363636363636e-12
+uniform,cold,2,3.1622776601683794e-12,13,11,24,12,24,242,1170,18,466.5123966942149,1.5316363636363636e-12
+uniform,cold,2,5.6234132519034904e-12,12,6,16,7,16,84,600,18,450.6666666666667,5.485714285714286e-12
+uniform,cold,2,1e-11,12,9,20,10,20,162,888,17,417.28395061728395,9.866666666666669e-12
+uniform,cold,2,1.7782794100389227e-11,12,11,24,12,24,242,1080,17,402.24793388429754,1.4138181818181817e-11
+uniform,cold,2,3.1622776601683794e-11,12,11,24,12,24,242,1080,16,402.24793388429754,1.4138181818181817e-11
+uniform,cold,2,5.6234132519034906e-11,11,6,18,7,18,96,550,16,378.0,5.56875e-11
+uniform,cold,2,1e-10,11,9,22,10,22,180,814,15,352.0,9.849400000000002e-11
+uniform,cold,2,1.778279410038923e-10,11,11,24,12,24,242,990,15,342.74380165289256,1.2959999999999997e-10
+uniform,cold,2,3.1622776601683795e-10,11,11,24,12,24,242,990,15,342.74380165289256,1.2959999999999997e-10
+uniform,cold,2,5.623413251903491e-10,10,6,20,7,20,108,500,14,313.7037037037037,5.555555555555556e-10
+uniform,cold,2,1e-09,10,10,22,11,22,200,820,14,292.82,9.922000000000002e-10
+uniform,cold,2,1.7782794100389228e-09,10,11,24,12,24,242,900,13,288.0,1.1781818181818181e-09
+uniform,cold,2,3.1622776601683795e-09,9,5,14,6,14,60,378,13,280.0,3.0869999999999998e-09
+uniform,cold,2,5.623413251903491e-09,9,6,22,7,22,120,450,13,256.6666666666667,5.445e-09
+uniform,cold,2,1e-08,9,11,22,12,22,220,810,12,240.0,9.801000000000001e-09
+uniform,cold,2,1.7782794100389228e-08,9,11,24,12,24,242,810,12,238.01652892561984,1.0603636363636363e-08
+uniform,cold,2,3.162277660168379e-08,8,5,16,6,16,70,336,11,222.17142857142858,3.072e-08
+uniform,cold,2,5.6234132519034905e-08,8,7,22,8,22,140,464,11,203.65714285714284,5.614400000000001e-08
+uniform,cold,2,1e-07,8,11,24,12,24,242,720,10,192.79338842975207,9.425454545454546e-08
+uniform,cold,2,1.7782794100389227e-07,7,4,12,5,12,40,238,10,192.0,1.7135999999999997e-07
+uniform,cold,2,3.162277660168379e-07,7,5,18,6,18,80,294,10,172.8,2.9767499999999997e-07
+uniform,cold,2,5.62341325190349e-07,7,8,22,9,22,160,462,9,158.4,5.5902e-07
+uniform,cold,2,1e-06,7,11,24,12,24,242,630,9,152.3305785123967,8.247272727272726e-07
+uniform,cold,2,1.778279410038923e-06,6,4,14,5,14,48,204,8,142.91666666666666,1.6659999999999998e-06
+uniform,cold,2,3.162277660168379e-06,6,6,18,7,18,96,300,8,128.625,3.0374999999999993e-06
+uniform,cold,2,5.623413251903491e-06,6,8,26,9,26,192,396,8,119.4375,5.576999999999999e-06
+uniform,cold,2,1e-05,5,3,12,4,12,30,130,7,115.2,9.36e-06
+uniform,cold,2,1.778279410038923e-05,5,5,14,6,14,60,210,7,100.8,1.7150000000000004e-05
+uniform,cold,2,3.1622776601683795e-05,5,6,22,7,22,120,250,6,92.4,3.0250000000000003e-05
+uniform,cold,2,5.623413251903491e-05,5,9,28,10,28,234,370,6,86.15384615384616,5.578461538461538e-05
+uniform,cold,2,0.0001,4,4,12,5,12,40,136,5,75.0,9.792e-05
+uniform,cold,2,0.00017782794100389227,4,5,18,6,18,80,168,5,67.5,0.00017010000000000001
+uniform,cold,2,0.00031622776601683794,4,7,24,8,24,154,232,5,62.33766233766234,0.00030370909090909095
+uniform,cold,2,0.0005623413251903491,3,3,12,4,12,30,78,4,51.2,0.0005616
+uniform,cold,2,0.001,3,4,16,5,16,56,102,4,45.714285714285715,0.0009325714285714285
+uniform,cold,64,1e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,1.778279410038923e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,3.1622776601683795e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,5.623413251903491e-18,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,1e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,1.7782794100389228e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,3.1622776601683796e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,5.62341325190349e-17,12,1,256,17,17,194,4848,None,503.5154639175258,4.698682399670103e-19
+uniform,cold,64,1e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,1.7782794100389228e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,3.1622776601683793e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,5.623413251903491e-16,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,1e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,1.7782794100389227e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,3.1622776601683794e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,5.6234132519034904e-15,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,1e-14,11,1,256,17,17,194,4444,None,429.03092783505156,7.238363743010309e-17
+uniform,cold,64,1.7782794100389227e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,3.1622776601683796e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,5.6234132519034906e-14,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,1e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,1.7782794100389227e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,3.162277660168379e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,5.62341325190349e-13,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,1e-12,10,1,256,17,17,194,4040,None,360.50515463917526,1.087657962886598e-14
+uniform,cold,64,1.7782794100389228e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,3.1622776601683794e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,5.6234132519034904e-12,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,1e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,1.7782794100389227e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,3.1622776601683794e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,5.6234132519034906e-11,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,1e-10,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,1.778279410038923e-10,9,1,256,17,17,194,3636,None,297.9381443298969,1.5858053098886599e-12
+uniform,cold,64,3.1622776601683795e-10,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,5.623413251903491e-10,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,1e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,1.7782794100389228e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,3.1622776601683795e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,5.623413251903491e-09,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,1e-08,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,1.7782794100389228e-08,8,1,256,17,17,194,3232,None,241.3298969072165,2.2275235079917526e-10
+uniform,cold,64,3.162277660168379e-08,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,5.6234132519034905e-08,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,1e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,1.7782794100389227e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,3.162277660168379e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,5.62341325190349e-07,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,1e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,1.778279410038923e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,3.162277660168379e-06,7,1,256,17,17,194,2828,None,190.68041237113403,2.9845334501608254e-08
+uniform,cold,64,5.623413251903491e-06,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,1e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,1.778279410038923e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,3.1622776601683795e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,5.623413251903491e-05,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,0.0001,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,0.00017782794100389227,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,0.00031622776601683794,6,1,256,17,17,194,2424,None,145.98969072164948,3.758945919736082e-06
+uniform,cold,64,0.0005623413251903491,5,1,256,17,17,194,2020,None,107.25773195876289,0.0004350631851546392
+uniform,cold,64,0.001,5,1,256,17,17,194,2020,None,107.25773195876289,0.0004350631851546392
+uniform,hot,0,1e-18,29,2,125,3,126,250,1450,29,2721.6,3.4694469519536144e-19
+uniform,hot,0,1.778279410038923e-18,28,2,125,3,126,250,1400,28,2543.184,1.3877787807814458e-18
+uniform,hot,0,3.1622776601683795e-18,28,2,125,3,126,250,1400,28,2543.184,1.3877787807814458e-18
+uniform,hot,0,5.623413251903491e-18,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18
+uniform,hot,0,1e-17,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18
+uniform,hot,0,1.7782794100389228e-17,27,2,125,3,126,250,1350,27,2370.816,5.551115123125783e-18
+uniform,hot,0,3.1622776601683796e-17,26,2,125,3,126,250,1300,26,2204.496,2.2204460492503132e-17
+uniform,hot,0,5.62341325190349e-17,26,2,125,3,126,250,1300,26,2204.496,2.2204460492503132e-17
+uniform,hot,0,1e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17
+uniform,hot,0,1.7782794100389228e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17
+uniform,hot,0,3.1622776601683793e-16,25,2,125,3,126,250,1250,25,2044.224,8.881784197001253e-17
+uniform,hot,0,5.623413251903491e-16,24,2,125,3,126,250,1200,24,1890.0,3.552713678800501e-16
+uniform,hot,0,1e-15,24,2,125,3,126,250,1200,24,1890.0,3.552713678800501e-16
+uniform,hot,0,1.7782794100389227e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15
+uniform,hot,0,3.1622776601683794e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15
+uniform,hot,0,5.6234132519034904e-15,23,2,125,3,126,250,1150,23,1741.824,1.4210854715202005e-15
+uniform,hot,0,1e-14,22,2,125,3,126,250,1100,22,1599.696,5.684341886080802e-15
+uniform,hot,0,1.7782794100389227e-14,22,2,125,3,126,250,1100,22,1599.696,5.684341886080802e-15
+uniform,hot,0,3.1622776601683796e-14,21,2,125,3,126,250,1050,21,1463.616,2.2737367544323207e-14
+uniform,hot,0,5.6234132519034906e-14,21,2,125,3,126,250,1050,21,1463.616,2.2737367544323207e-14
+uniform,hot,0,1e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14
+uniform,hot,0,1.7782794100389227e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14
+uniform,hot,0,3.162277660168379e-13,20,2,125,3,126,250,1000,20,1333.584,9.094947017729283e-14
+uniform,hot,0,5.62341325190349e-13,19,2,125,3,126,250,950,19,1209.6,3.637978807091713e-13
+uniform,hot,0,1e-12,19,2,125,3,126,250,950,19,1209.6,3.637978807091713e-13
+uniform,hot,0,1.7782794100389228e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12
+uniform,hot,0,3.1622776601683794e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12
+uniform,hot,0,5.6234132519034904e-12,18,2,125,3,126,250,900,18,1091.664,1.4551915228366853e-12
+uniform,hot,0,1e-11,17,2,125,3,126,250,850,17,979.776,5.820766091346741e-12
+uniform,hot,0,1.7782794100389227e-11,17,2,125,3,126,250,850,17,979.776,5.820766091346741e-12
+uniform,hot,0,3.1622776601683794e-11,16,2,125,3,126,250,800,16,873.936,2.3283064365386964e-11
+uniform,hot,0,5.6234132519034906e-11,16,2,125,3,126,250,800,16,873.936,2.3283064365386964e-11
+uniform,hot,0,1e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11
+uniform,hot,0,1.778279410038923e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11
+uniform,hot,0,3.1622776601683795e-10,15,2,125,3,126,250,750,15,774.144,9.313225746154786e-11
+uniform,hot,0,5.623413251903491e-10,14,2,125,3,126,250,700,14,680.4,3.7252902984619143e-10
+uniform,hot,0,1e-09,14,2,125,3,126,250,700,14,680.4,3.7252902984619143e-10
+uniform,hot,0,1.7782794100389228e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09
+uniform,hot,0,3.1622776601683795e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09
+uniform,hot,0,5.623413251903491e-09,13,2,125,3,126,250,650,13,592.704,1.4901161193847657e-09
+uniform,hot,0,1e-08,12,2,125,3,126,250,600,12,511.056,5.960464477539063e-09
+uniform,hot,0,1.7782794100389228e-08,12,2,125,3,126,250,600,12,511.056,5.960464477539063e-09
+uniform,hot,0,3.162277660168379e-08,11,2,125,3,126,250,550,11,435.456,2.384185791015625e-08
+uniform,hot,0,5.6234132519034905e-08,11,2,125,3,126,250,550,11,435.456,2.384185791015625e-08
+uniform,hot,0,1e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08
+uniform,hot,0,1.7782794100389227e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08
+uniform,hot,0,3.162277660168379e-07,10,2,125,3,126,250,500,10,365.904,9.5367431640625e-08
+uniform,hot,0,5.62341325190349e-07,9,2,125,3,126,250,450,9,302.4,3.814697265625e-07
+uniform,hot,0,1e-06,9,2,125,3,126,250,450,9,302.4,3.814697265625e-07
+uniform,hot,0,1.778279410038923e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06
+uniform,hot,0,3.162277660168379e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06
+uniform,hot,0,5.623413251903491e-06,8,2,125,3,126,250,400,8,244.944,1.52587890625e-06
+uniform,hot,0,1e-05,7,2,125,3,126,250,350,7,193.536,6.103515625e-06
+uniform,hot,0,1.778279410038923e-05,7,2,125,3,126,250,350,7,193.536,6.103515625e-06
+uniform,hot,0,3.1622776601683795e-05,6,2,125,3,126,250,300,6,148.176,2.44140625e-05
+uniform,hot,0,5.623413251903491e-05,6,2,125,3,126,250,300,6,148.176,2.44140625e-05
+uniform,hot,0,0.0001,5,2,125,3,126,250,250,5,108.864,9.765625e-05
+uniform,hot,0,0.00017782794100389227,5,2,125,3,126,250,250,5,108.864,9.765625e-05
+uniform,hot,0,0.00031622776601683794,5,2,125,3,126,250,250,5,108.864,9.765625e-05
+uniform,hot,0,0.0005623413251903491,4,2,125,3,126,250,200,4,75.6,0.000390625
+uniform,hot,0,0.001,4,2,125,3,126,250,200,4,75.6,0.000390625
+uniform,hot,2,1e-18,20,2,126,3,127,248,1000,29,1548.5806451612902,6.401612903225806e-19
+uniform,hot,2,1.778279410038923e-18,19,2,34,3,35,64,950,28,1509.375,1.7159374999999998e-18
+uniform,hot,2,3.1622776601683795e-18,19,2,64,3,65,124,950,28,1446.774193548387,3.138064516129032e-18
+uniform,hot,2,5.623413251903491e-18,19,2,116,3,117,228,950,27,1395.7894736842106,5.606666666666666e-18
+uniform,hot,2,1e-17,19,2,126,3,127,248,950,27,1392.9032258064517,6.0815322580645154e-18
+uniform,hot,2,1.7782794100389228e-17,18,2,36,3,37,68,900,27,1364.6470588235295,1.715294117647059e-17
+uniform,hot,2,3.1622776601683796e-17,18,2,68,3,69,132,900,26,1291.1363636363637,3.152727272727273e-17
+uniform,hot,2,5.62341325190349e-17,18,2,122,3,123,240,900,26,1265.875,5.5815e-17
+uniform,hot,2,1e-16,18,2,126,3,127,248,900,25,1245.4193548387098,5.761451612903226e-17
+uniform,hot,2,1.7782794100389228e-16,17,2,38,3,39,72,850,25,1209.0,1.7047222222222224e-16
+uniform,hot,2,3.1622776601683793e-16,17,2,72,3,73,140,850,25,1163.8285714285714,3.1474285714285717e-16
+uniform,hot,2,5.623413251903491e-16,17,2,126,3,127,248,850,24,1124.5645161290322,5.441370967741936e-16
+uniform,hot,2,1e-15,17,2,126,3,127,248,850,24,1124.5645161290322,5.441370967741936e-16
+uniform,hot,2,1.7782794100389227e-15,16,2,42,3,43,80,800,23,1059.95,1.7639999999999999e-15
+uniform,hot,2,3.1622776601683794e-15,16,2,76,3,77,148,800,23,1025.972972972973,3.122162162162162e-15
+uniform,hot,2,5.6234132519034904e-15,16,2,126,3,127,248,800,23,1009.8548387096774,5.121290322580645e-15
+uniform,hot,2,1e-14,16,2,126,3,127,248,800,22,992.4435483870968,5.121290322580645e-15
+uniform,hot,2,1.7782794100389227e-14,15,2,44,3,45,84,750,22,942.8571428571429,1.728571428571429e-14
+uniform,hot,2,3.1622776601683796e-14,15,2,82,3,83,160,750,21,896.4,3.151875e-14
+uniform,hot,2,5.6234132519034906e-14,15,2,126,3,127,248,750,21,884.9032258064516,4.801209677419355e-14
+uniform,hot,2,1e-13,14,2,26,3,27,48,700,20,860.625,9.858333333333333e-14
+uniform,hot,2,1.7782794100389227e-13,14,2,48,3,49,92,700,20,814.8913043478261,1.7530434782608694e-13
+uniform,hot,2,3.162277660168379e-13,14,2,88,3,89,172,700,20,791.6860465116279,3.1516279069767445e-13
+uniform,hot,2,5.62341325190349e-13,14,2,126,3,127,248,700,19,768.1451612903226,4.4811290322580643e-13
+uniform,hot,2,1e-12,13,2,28,3,29,52,650,19,749.5384615384615,9.799999999999999e-13
+uniform,hot,2,1.7782794100389228e-12,13,2,52,3,53,100,650,18,697.48,1.7576000000000001e-12
+uniform,hot,2,3.1622776601683794e-12,13,2,94,3,95,184,650,18,679.4565217391304,3.1214130434782615e-12
+uniform,hot,2,5.6234132519034904e-12,13,2,126,3,127,248,650,18,673.9193548387096,4.161048387096774e-12
+uniform,hot,2,1e-11,12,2,30,3,31,56,600,17,633.2857142857143,9.642857142857143e-12
+uniform,hot,2,1.7782794100389227e-11,12,2,56,3,57,108,600,17,603.7777777777778,1.7422222222222223e-11
+uniform,hot,2,3.1622776601683794e-11,12,2,102,3,103,200,600,16,575.77,3.1212000000000006e-11
+uniform,hot,2,5.6234132519034906e-11,12,2,126,3,127,248,600,16,572.5241935483871,3.840967741935484e-11
+uniform,hot,2,1e-10,11,2,34,3,35,64,550,15,525.0,9.934375000000001e-11
+uniform,hot,2,1.778279410038923e-10,11,2,62,3,63,120,550,15,504.0,1.7618333333333335e-10
+uniform,hot,2,3.1622776601683795e-10,11,2,112,3,113,220,550,15,493.09090909090907,3.136e-10
+uniform,hot,2,5.623413251903491e-10,10,2,20,3,21,36,500,14,474.8333333333333,5.555555555555556e-10
+uniform,hot,2,1e-09,10,2,36,3,37,68,500,14,442.9117647058824,9.529411764705881e-10
+uniform,hot,2,1.7782794100389228e-09,10,2,68,3,69,132,500,13,414.0,1.7515151515151516e-09
+uniform,hot,2,3.1622776601683795e-09,10,2,124,3,125,244,500,13,405.73770491803276,3.1508196721311478e-09
+uniform,hot,2,5.623413251903491e-09,9,2,22,3,23,40,450,13,391.0,5.445e-09
+uniform,hot,2,1e-08,9,2,42,3,43,80,450,12,354.75,9.9225e-09
+uniform,hot,2,1.7782794100389228e-08,9,2,76,3,77,148,450,12,343.3783783783784,1.7562162162162162e-08
+uniform,hot,2,3.162277660168379e-08,9,2,126,3,127,248,450,11,327.741935483871,2.8807258064516128e-08
+uniform,hot,2,5.6234132519034905e-08,8,2,24,3,25,44,400,11,306.8181818181818,5.236363636363637e-08
+uniform,hot,2,1e-07,8,2,46,3,47,88,400,10,278.79545454545456,9.618181818181819e-08
+uniform,hot,2,1.7782794100389227e-07,8,2,86,3,87,168,400,10,270.32142857142856,1.760952380952381e-07
+uniform,hot,2,3.162277660168379e-07,8,2,126,3,127,248,400,10,267.31451612903226,2.560645161290323e-07
+uniform,hot,2,5.62341325190349e-07,7,2,28,3,29,52,350,9,232.0,5.276923076923076e-07
+uniform,hot,2,1e-06,7,2,54,3,55,104,350,9,220.0,9.813461538461538e-07
+uniform,hot,2,1.778279410038923e-06,7,2,98,3,99,192,350,8,206.25,1.7507291666666663e-06
+uniform,hot,2,3.162277660168379e-06,6,2,18,3,19,32,300,8,191.1875,3.0374999999999993e-06
+uniform,hot,2,5.623413251903491e-06,6,2,34,3,35,64,300,8,176.09375,5.418749999999999e-06
+uniform,hot,2,1e-05,6,2,64,3,65,124,300,7,161.4516129032258,9.909677419354836e-06
+uniform,hot,2,1.778279410038923e-05,6,2,116,3,117,228,300,7,158.05263157894737,1.7705263157894734e-05
+uniform,hot,2,3.1622776601683795e-05,5,2,22,3,23,40,250,6,131.1,3.0250000000000003e-05
+uniform,hot,2,5.623413251903491e-05,5,2,42,3,43,80,250,6,122.55,5.5125000000000005e-05
+uniform,hot,2,0.0001,5,2,76,3,77,148,250,5,112.37837837837837,9.756756756756757e-05
+uniform,hot,2,0.00017782794100389227,4,2,14,3,15,24,200,5,100.0,0.00016333333333333336
+uniform,hot,2,0.00031622776601683794,4,2,28,3,29,52,200,5,89.23076923076923,0.00030153846153846154
+uniform,hot,2,0.0005623413251903491,4,2,54,3,55,104,200,4,79.32692307692308,0.0005607692307692308
+uniform,hot,2,0.001,3,2,10,3,11,16,150,4,71.5,0.0009374999999999999
+uniform_refit,cold,0,1e-18,31,1,4,1,4,4,310,31,2048.0,3.4027546317804404e-19
+uniform_refit,cold,0,1.778279410038923e-18,30,1,4,1,4,4,300,30,1922.0,1.1909641211231541e-18
+uniform_refit,cold,0,3.1622776601683795e-18,30,1,4,1,4,4,300,30,1922.0,1.1909641211231541e-18
+uniform_refit,cold,0,5.623413251903491e-18,29,1,4,1,4,4,290,29,1800.0,4.168374423931039e-18
+uniform_refit,cold,0,1e-17,29,1,4,1,4,4,290,29,1800.0,4.168374423931039e-18
+uniform_refit,cold,0,1.7782794100389228e-17,28,1,4,1,4,4,280,28,1682.0,1.4589310483758634e-17
+uniform_refit,cold,0,3.1622776601683796e-17,28,1,4,1,4,4,280,28,1682.0,1.4589310483758634e-17
+uniform_refit,cold,0,5.62341325190349e-17,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17
+uniform_refit,cold,0,1e-16,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17
+uniform_refit,cold,0,1.7782794100389228e-16,27,1,4,1,4,4,270,27,1568.0,5.106258669315523e-17
+uniform_refit,cold,0,3.1622776601683793e-16,26,1,4,1,4,4,260,26,1458.0,1.7871905342604332e-16
+uniform_refit,cold,0,5.623413251903491e-16,26,1,4,1,4,4,260,26,1458.0,1.7871905342604332e-16
+uniform_refit,cold,0,1e-15,25,1,4,1,4,4,250,25,1352.0,6.255166869911515e-16
+uniform_refit,cold,0,1.7782794100389227e-15,25,1,4,1,4,4,250,25,1352.0,6.255166869911515e-16
+uniform_refit,cold,0,3.1622776601683794e-15,24,1,4,1,4,4,240,24,1250.0,2.1893084044690303e-15
+uniform_refit,cold,0,5.6234132519034904e-15,24,1,4,1,4,4,240,24,1250.0,2.1893084044690303e-15
+uniform_refit,cold,0,1e-14,23,1,4,1,4,4,230,23,1152.0,7.662579415641607e-15
+uniform_refit,cold,0,1.7782794100389227e-14,23,1,4,1,4,4,230,23,1152.0,7.662579415641607e-15
+uniform_refit,cold,0,3.1622776601683796e-14,22,1,4,1,4,4,220,22,1058.0,2.6819027954745623e-14
+uniform_refit,cold,0,5.6234132519034906e-14,22,1,4,1,4,4,220,22,1058.0,2.6819027954745623e-14
+uniform_refit,cold,0,1e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14
+uniform_refit,cold,0,1.7782794100389227e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14
+uniform_refit,cold,0,3.162277660168379e-13,21,1,4,1,4,4,210,21,968.0,9.386659784160968e-14
+uniform_refit,cold,0,5.62341325190349e-13,20,1,4,1,4,4,200,20,882.0,3.2853309244563385e-13
+uniform_refit,cold,0,1e-12,20,1,4,1,4,4,200,20,882.0,3.2853309244563385e-13
+uniform_refit,cold,0,1.7782794100389228e-12,19,1,4,1,4,4,190,19,800.0,1.1498658235597187e-12
+uniform_refit,cold,0,3.1622776601683794e-12,19,1,4,1,4,4,190,19,800.0,1.1498658235597187e-12
+uniform_refit,cold,0,5.6234132519034904e-12,18,1,4,1,4,4,180,18,722.0,4.0245303824590146e-12
+uniform_refit,cold,0,1e-11,18,1,4,1,4,4,180,18,722.0,4.0245303824590146e-12
+uniform_refit,cold,0,1.7782794100389227e-11,17,1,4,1,4,4,170,17,648.0,1.4085856338606554e-11
+uniform_refit,cold,0,3.1622776601683794e-11,17,1,4,1,4,4,170,17,648.0,1.4085856338606554e-11
+uniform_refit,cold,0,5.6234132519034906e-11,16,1,4,1,4,4,160,16,578.0,4.9300497185122934e-11
+uniform_refit,cold,0,1e-10,16,1,4,1,4,4,160,16,578.0,4.9300497185122934e-11
+uniform_refit,cold,0,1.778279410038923e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10
+uniform_refit,cold,0,3.1622776601683795e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10
+uniform_refit,cold,0,5.623413251903491e-10,15,1,4,1,4,4,150,15,512.0,1.7255174014793028e-10
+uniform_refit,cold,0,1e-09,14,1,4,1,4,4,140,14,450.0,6.039310905177559e-10
+uniform_refit,cold,0,1.7782794100389228e-09,14,1,4,1,4,4,140,14,450.0,6.039310905177559e-10
+uniform_refit,cold,0,3.1622776601683795e-09,13,1,4,1,4,4,130,13,392.0,2.1137588168121457e-09
+uniform_refit,cold,0,5.623413251903491e-09,13,1,4,1,4,4,130,13,392.0,2.1137588168121457e-09
+uniform_refit,cold,0,1e-08,12,1,4,1,4,4,120,12,338.0,7.39815585884251e-09
+uniform_refit,cold,0,1.7782794100389228e-08,12,1,4,1,4,4,120,12,338.0,7.39815585884251e-09
+uniform_refit,cold,0,3.162277660168379e-08,11,1,4,1,4,4,110,11,288.0,2.5893545505948784e-08
+uniform_refit,cold,0,5.6234132519034905e-08,11,1,4,1,4,4,110,11,288.0,2.5893545505948784e-08
+uniform_refit,cold,0,1e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08
+uniform_refit,cold,0,1.7782794100389227e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08
+uniform_refit,cold,0,3.162277660168379e-07,10,1,4,1,4,4,100,10,242.0,9.062740927082074e-08
+uniform_refit,cold,0,5.62341325190349e-07,9,1,4,1,4,4,90,9,200.0,3.171959324478726e-07
+uniform_refit,cold,0,1e-06,9,1,4,1,4,4,90,9,200.0,3.171959324478726e-07
+uniform_refit,cold,0,1.778279410038923e-06,8,1,4,1,4,4,80,8,162.0,1.1101857635675541e-06
+uniform_refit,cold,0,3.162277660168379e-06,8,1,4,1,4,4,80,8,162.0,1.1101857635675541e-06
+uniform_refit,cold,0,5.623413251903491e-06,7,1,4,1,4,4,70,7,128.0,3.885650172486439e-06
+uniform_refit,cold,0,1e-05,7,1,4,1,4,4,70,7,128.0,3.885650172486439e-06
+uniform_refit,cold,0,1.778279410038923e-05,6,1,4,1,4,4,60,6,98.0,1.359977560370254e-05
+uniform_refit,cold,0,3.1622776601683795e-05,6,1,4,1,4,4,60,6,98.0,1.359977560370254e-05
+uniform_refit,cold,0,5.623413251903491e-05,5,1,4,1,4,4,50,5,72.0,4.7599214612958884e-05
+uniform_refit,cold,0,0.0001,5,1,4,1,4,4,50,5,72.0,4.7599214612958884e-05
+uniform_refit,cold,0,0.00017782794100389227,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561
+uniform_refit,cold,0,0.00031622776601683794,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561
+uniform_refit,cold,0,0.0005623413251903491,4,1,4,1,4,4,40,4,50.0,0.0001665972511453561
+uniform_refit,cold,0,0.001,3,1,4,1,4,4,30,3,32.0,0.0005830903790087463
+uniform_refit,cold,2,1e-18,18,11,24,12,24,242,1620,31,859.2396694214876,2.8699356175858737e-19
+uniform_refit,cold,2,1.778279410038923e-18,17,6,18,7,18,96,850,30,850.5,1.746998569298693e-18
+uniform_refit,cold,2,3.1622776601683795e-18,17,10,20,11,20,180,1394,30,792.0,3.1441181384360568e-18
+uniform_refit,cold,2,5.623413251903491e-18,17,11,24,12,24,242,1530,29,771.1735537190083,4.065742124913322e-18
+uniform_refit,cold,2,1e-17,17,11,24,12,24,242,1530,29,771.1735537190083,4.065742124913322e-18
+uniform_refit,cold,2,1.7782794100389228e-17,17,11,24,12,24,242,1530,28,771.1735537190083,4.065742124913322e-18
+uniform_refit,cold,2,3.1622776601683796e-17,16,7,20,8,20,126,928,28,733.968253968254,3.1396072085387306e-17
+uniform_refit,cold,2,5.62341325190349e-17,16,9,28,10,28,234,1184,27,691.6239316239316,5.435434569944451e-17
+uniform_refit,cold,2,1e-16,16,11,24,12,24,242,1440,27,687.8677685950413,5.739871235171747e-17
+uniform_refit,cold,2,1.7782794100389228e-16,16,11,24,12,24,242,1440,27,687.8677685950413,5.739871235171747e-17
+uniform_refit,cold,2,3.1622776601683793e-16,15,6,16,7,16,84,750,26,682.6666666666666,3.131874185857601e-16
+uniform_refit,cold,2,5.623413251903491e-16,15,8,22,9,22,160,990,26,633.6,5.471188460556614e-16
+uniform_refit,cold,2,1e-15,15,11,24,12,24,242,1350,25,609.3223140495868,8.07169392446027e-16
+uniform_refit,cold,2,1.7782794100389227e-15,15,11,24,12,24,242,1350,25,609.3223140495868,8.07169392446027e-16
+uniform_refit,cold,2,3.1622776601683794e-15,15,11,24,12,24,242,1350,24,609.3223140495868,8.07169392446027e-16
+uniform_refit,cold,2,5.6234132519034904e-15,14,6,20,7,20,108,700,24,583.3333333333334,5.328535941216057e-15
+uniform_refit,cold,2,1e-14,14,9,26,10,26,216,1036,23,541.6666666666666,9.9958005721272e-15
+uniform_refit,cold,2,1.7782794100389227e-14,14,11,24,12,24,242,1260,23,535.5371900826447,1.130037149424438e-14
+uniform_refit,cold,2,3.1622776601683796e-14,14,11,24,12,24,242,1260,22,535.5371900826447,1.130037149424438e-14
+uniform_refit,cold,2,5.6234132519034906e-14,13,6,14,7,14,72,650,22,533.5555555555555,5.4550886698199384e-14
+uniform_refit,cold,2,1e-13,13,8,20,9,20,144,858,21,490.0,9.796893937635806e-14
+uniform_refit,cold,2,1.7782794100389227e-13,13,11,24,12,24,242,1170,21,466.5123966942149,1.5739803152697526e-13
+uniform_refit,cold,2,3.162277660168379e-13,13,11,24,12,24,242,1170,21,466.5123966942149,1.5739803152697526e-13
+uniform_refit,cold,2,5.62341325190349e-13,13,11,24,12,24,242,1170,20,466.5123966942149,1.5739803152697526e-13
+uniform_refit,cold,2,1e-12,12,7,16,8,16,98,696,20,441.46938775510205,9.809029950106005e-13
+uniform_refit,cold,2,1.7782794100389228e-12,12,8,26,9,26,192,792,19,411.9375,1.7193548860550842e-12
+uniform_refit,cold,2,3.1622776601683794e-12,12,11,24,12,24,242,1080,19,402.24793388429754,2.179357359604273e-12
+uniform_refit,cold,2,5.6234132519034904e-12,12,11,24,12,24,242,1080,18,402.24793388429754,2.179357359604273e-12
+uniform_refit,cold,2,1e-11,11,5,16,6,16,70,462,18,394.9714285714286,9.766749648596927e-12
+uniform_refit,cold,2,1.7782794100389227e-11,11,8,18,9,18,128,726,17,364.5,1.6996433470507543e-11
+uniform_refit,cold,2,3.1622776601683794e-11,11,11,24,12,24,242,990,17,342.74380165289256,2.9966163694558754e-11
+uniform_refit,cold,2,5.6234132519034906e-11,11,11,24,12,24,242,990,16,342.74380165289256,2.9966163694558754e-11
+uniform_refit,cold,2,1e-10,11,11,24,12,24,242,990,16,342.74380165289256,2.9966163694558754e-11
+uniform_refit,cold,2,1.778279410038923e-10,10,6,18,7,18,96,500,15,317.625,1.755829903978052e-10
+uniform_refit,cold,2,3.1622776601683795e-10,10,10,20,11,20,180,820,15,295.77777777777777,3.1600121179961653e-10
+uniform_refit,cold,2,5.623413251903491e-10,10,11,24,12,24,242,900,15,288.0,4.086295049258012e-10
+uniform_refit,cold,2,1e-09,10,11,24,12,24,242,900,14,288.0,4.086295049258012e-10
+uniform_refit,cold,2,1.7782794100389228e-09,9,4,20,5,20,72,306,14,277.77777777777777,1.7688360514149268e-09
+uniform_refit,cold,2,3.1622776601683795e-09,9,8,18,9,18,128,594,13,253.125,3.1288888888888894e-09
+uniform_refit,cold,2,5.623413251903491e-09,9,11,24,12,24,242,810,13,238.01652892561984,5.516498316498316e-09
+uniform_refit,cold,2,1e-08,9,11,24,12,24,242,810,12,238.01652892561984,5.516498316498316e-09
+uniform_refit,cold,2,1.7782794100389228e-08,8,4,14,5,14,48,272,12,236.25,1.7334593303866282e-08
+uniform_refit,cold,2,3.162277660168379e-08,8,6,18,7,18,96,400,11,212.625,3.160493827160494e-08
+uniform_refit,cold,2,5.6234132519034905e-08,8,9,22,10,22,180,592,11,198.0,5.589938119189148e-08
+uniform_refit,cold,2,1e-07,8,11,24,12,24,242,720,10,192.79338842975207,7.35533108866442e-08
+uniform_refit,cold,2,1.7782794100389227e-07,8,11,24,12,24,242,720,10,192.79338842975207,7.35533108866442e-08
+uniform_refit,cold,2,3.162277660168379e-07,7,5,16,6,16,70,294,10,175.54285714285714,3.1464471879286686e-07
+uniform_refit,cold,2,5.62341325190349e-07,7,8,18,9,18,128,462,9,162.0,5.475555555555554e-07
+uniform_refit,cold,2,1e-06,7,11,24,12,24,242,630,9,152.3305785123967,9.653872053872052e-07
+uniform_refit,cold,2,1.778279410038923e-06,7,11,24,12,24,242,630,8,152.3305785123967,9.653872053872052e-07
+uniform_refit,cold,2,3.162277660168379e-06,6,4,14,5,14,48,204,8,142.91666666666666,2.9252126200274354e-06
+uniform_refit,cold,2,5.623413251903491e-06,6,7,16,8,16,98,348,7,128.0,5.586549088771311e-06
+uniform_refit,cold,2,1e-05,6,8,26,9,26,192,396,7,119.4375,9.792263374485597e-06
+uniform_refit,cold,2,1.778279410038923e-05,6,11,24,12,24,242,540,6,116.62809917355372,1.2412121212121213e-05
+uniform_refit,cold,2,3.1622776601683795e-05,5,3,16,4,16,42,130,6,109.71428571428571,3.1303938859494416e-05
+uniform_refit,cold,2,5.623413251903491e-05,5,5,18,6,18,80,210,5,97.2,5.6e-05
+uniform_refit,cold,2,0.0001,5,7,24,8,24,154,290,5,89.76623376623377,9.998653198653199e-05
+uniform_refit,cold,2,0.00017782794100389227,5,11,24,12,24,242,450,4,85.68595041322314,0.00015515151515151513
+uniform_refit,cold,2,0.00031622776601683794,4,3,12,4,12,30,104,4,80.0,0.00029582222222222223
+uniform_refit,cold,2,0.0005623413251903491,4,5,14,6,14,60,168,4,70.0,0.0005420246913580248
+uniform_refit,cold,2,0.001,4,6,22,7,22,120,200,3,64.16666666666667,0.0009560493827160494
+uniform_refit,cold,64,1e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20
+uniform_refit,cold,64,1.778279410038923e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20
+uniform_refit,cold,64,3.1622776601683795e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20
+uniform_refit,cold,64,5.623413251903491e-18,13,1,256,17,17,194,5252,None,583.9587628865979,5.0291661166147826e-20
+uniform_refit,cold,64,1e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,1.7782794100389228e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,3.1622776601683796e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,5.62341325190349e-17,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,1e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,1.7782794100389228e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,3.1622776601683793e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,5.623413251903491e-16,12,1,256,17,17,194,4848,None,503.5154639175258,5.933363028796321e-18
+uniform_refit,cold,64,1e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,1.7782794100389227e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,3.1622776601683794e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,5.6234132519034904e-15,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,1e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,1.7782794100389227e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,3.1622776601683796e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,5.6234132519034906e-14,11,1,256,17,17,194,4444,None,429.03092783505156,6.855300513305471e-16
+uniform_refit,cold,64,1e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,1.7782794100389227e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,3.162277660168379e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,5.62341325190349e-13,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,1e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,1.7782794100389228e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,3.1622776601683794e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,5.6234132519034904e-12,10,1,256,17,17,194,4040,None,360.50515463917526,7.725733110411878e-14
+uniform_refit,cold,64,1e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,1.7782794100389227e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,3.1622776601683794e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,5.6234132519034906e-11,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,1e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,1.778279410038923e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,3.1622776601683795e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,5.623413251903491e-10,9,1,256,17,17,194,3636,None,297.9381443298969,8.448089156235387e-12
+uniform_refit,cold,64,1e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,1.7782794100389228e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,3.1622776601683795e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,5.623413251903491e-09,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,1e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,1.7782794100389228e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,3.162277660168379e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,5.6234132519034905e-08,8,1,256,17,17,194,3232,None,241.3298969072165,8.900044543194482e-10
+uniform_refit,cold,64,1e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,1.7782794100389227e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,3.162277660168379e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,5.62341325190349e-07,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,1e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,1.778279410038923e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,3.162277660168379e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,5.623413251903491e-06,7,1,256,17,17,194,2828,None,190.68041237113403,8.943501791940548e-08
+uniform_refit,cold,64,1e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,1.778279410038923e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,3.1622776601683795e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,5.623413251903491e-05,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,0.0001,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,0.00017782794100389227,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,0.00031622776601683794,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,0.0005623413251903491,6,1,256,17,17,194,2424,None,145.98969072164948,8.448089156235388e-06
+uniform_refit,cold,64,0.001,5,1,256,17,17,194,2020,None,107.25773195876289,0.0007333410725898773
+uniform_refit,hot,0,1e-18,31,2,125,3,126,250,1550,31,3096.576,3.4027546317804404e-19
+uniform_refit,hot,0,1.778279410038923e-18,30,2,125,3,126,250,1500,30,2906.064,1.1909641211231541e-18
+uniform_refit,hot,0,3.1622776601683795e-18,30,2,125,3,126,250,1500,30,2906.064,1.1909641211231541e-18
+uniform_refit,hot,0,5.623413251903491e-18,29,2,125,3,126,250,1450,29,2721.6,4.168374423931039e-18
+uniform_refit,hot,0,1e-17,29,2,125,3,126,250,1450,29,2721.6,4.168374423931039e-18
+uniform_refit,hot,0,1.7782794100389228e-17,28,2,125,3,126,250,1400,28,2543.184,1.4589310483758634e-17
+uniform_refit,hot,0,3.1622776601683796e-17,28,2,125,3,126,250,1400,28,2543.184,1.4589310483758634e-17
+uniform_refit,hot,0,5.62341325190349e-17,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17
+uniform_refit,hot,0,1e-16,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17
+uniform_refit,hot,0,1.7782794100389228e-16,27,2,125,3,126,250,1350,27,2370.816,5.106258669315523e-17
+uniform_refit,hot,0,3.1622776601683793e-16,26,2,125,3,126,250,1300,26,2204.496,1.7871905342604332e-16
+uniform_refit,hot,0,5.623413251903491e-16,26,2,125,3,126,250,1300,26,2204.496,1.7871905342604332e-16
+uniform_refit,hot,0,1e-15,25,2,125,3,126,250,1250,25,2044.224,6.255166869911515e-16
+uniform_refit,hot,0,1.7782794100389227e-15,25,2,125,3,126,250,1250,25,2044.224,6.255166869911515e-16
+uniform_refit,hot,0,3.1622776601683794e-15,24,2,125,3,126,250,1200,24,1890.0,2.1893084044690303e-15
+uniform_refit,hot,0,5.6234132519034904e-15,24,2,125,3,126,250,1200,24,1890.0,2.1893084044690303e-15
+uniform_refit,hot,0,1e-14,23,2,125,3,126,250,1150,23,1741.824,7.662579415641607e-15
+uniform_refit,hot,0,1.7782794100389227e-14,23,2,125,3,126,250,1150,23,1741.824,7.662579415641607e-15
+uniform_refit,hot,0,3.1622776601683796e-14,22,2,125,3,126,250,1100,22,1599.696,2.6819027954745623e-14
+uniform_refit,hot,0,5.6234132519034906e-14,22,2,125,3,126,250,1100,22,1599.696,2.6819027954745623e-14
+uniform_refit,hot,0,1e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14
+uniform_refit,hot,0,1.7782794100389227e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14
+uniform_refit,hot,0,3.162277660168379e-13,21,2,125,3,126,250,1050,21,1463.616,9.386659784160968e-14
+uniform_refit,hot,0,5.62341325190349e-13,20,2,125,3,126,250,1000,20,1333.584,3.2853309244563385e-13
+uniform_refit,hot,0,1e-12,20,2,125,3,126,250,1000,20,1333.584,3.2853309244563385e-13
+uniform_refit,hot,0,1.7782794100389228e-12,19,2,125,3,126,250,950,19,1209.6,1.1498658235597187e-12
+uniform_refit,hot,0,3.1622776601683794e-12,19,2,125,3,126,250,950,19,1209.6,1.1498658235597187e-12
+uniform_refit,hot,0,5.6234132519034904e-12,18,2,125,3,126,250,900,18,1091.664,4.0245303824590146e-12
+uniform_refit,hot,0,1e-11,18,2,125,3,126,250,900,18,1091.664,4.0245303824590146e-12
+uniform_refit,hot,0,1.7782794100389227e-11,17,2,125,3,126,250,850,17,979.776,1.4085856338606554e-11
+uniform_refit,hot,0,3.1622776601683794e-11,17,2,125,3,126,250,850,17,979.776,1.4085856338606554e-11
+uniform_refit,hot,0,5.6234132519034906e-11,16,2,125,3,126,250,800,16,873.936,4.9300497185122934e-11
+uniform_refit,hot,0,1e-10,16,2,125,3,126,250,800,16,873.936,4.9300497185122934e-11
+uniform_refit,hot,0,1.778279410038923e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10
+uniform_refit,hot,0,3.1622776601683795e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10
+uniform_refit,hot,0,5.623413251903491e-10,15,2,125,3,126,250,750,15,774.144,1.7255174014793028e-10
+uniform_refit,hot,0,1e-09,14,2,125,3,126,250,700,14,680.4,6.039310905177559e-10
+uniform_refit,hot,0,1.7782794100389228e-09,14,2,125,3,126,250,700,14,680.4,6.039310905177559e-10
+uniform_refit,hot,0,3.1622776601683795e-09,13,2,125,3,126,250,650,13,592.704,2.1137588168121457e-09
+uniform_refit,hot,0,5.623413251903491e-09,13,2,125,3,126,250,650,13,592.704,2.1137588168121457e-09
+uniform_refit,hot,0,1e-08,12,2,125,3,126,250,600,12,511.056,7.39815585884251e-09
+uniform_refit,hot,0,1.7782794100389228e-08,12,2,125,3,126,250,600,12,511.056,7.39815585884251e-09
+uniform_refit,hot,0,3.162277660168379e-08,11,2,125,3,126,250,550,11,435.456,2.5893545505948784e-08
+uniform_refit,hot,0,5.6234132519034905e-08,11,2,125,3,126,250,550,11,435.456,2.5893545505948784e-08
+uniform_refit,hot,0,1e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08
+uniform_refit,hot,0,1.7782794100389227e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08
+uniform_refit,hot,0,3.162277660168379e-07,10,2,125,3,126,250,500,10,365.904,9.062740927082074e-08
+uniform_refit,hot,0,5.62341325190349e-07,9,2,125,3,126,250,450,9,302.4,3.171959324478726e-07
+uniform_refit,hot,0,1e-06,9,2,125,3,126,250,450,9,302.4,3.171959324478726e-07
+uniform_refit,hot,0,1.778279410038923e-06,8,2,125,3,126,250,400,8,244.944,1.1101857635675541e-06
+uniform_refit,hot,0,3.162277660168379e-06,8,2,125,3,126,250,400,8,244.944,1.1101857635675541e-06
+uniform_refit,hot,0,5.623413251903491e-06,7,2,125,3,126,250,350,7,193.536,3.885650172486439e-06
+uniform_refit,hot,0,1e-05,7,2,125,3,126,250,350,7,193.536,3.885650172486439e-06
+uniform_refit,hot,0,1.778279410038923e-05,6,2,125,3,126,250,300,6,148.176,1.359977560370254e-05
+uniform_refit,hot,0,3.1622776601683795e-05,6,2,125,3,126,250,300,6,148.176,1.359977560370254e-05
+uniform_refit,hot,0,5.623413251903491e-05,5,2,125,3,126,250,250,5,108.864,4.7599214612958884e-05
+uniform_refit,hot,0,0.0001,5,2,125,3,126,250,250,5,108.864,4.7599214612958884e-05
+uniform_refit,hot,0,0.00017782794100389227,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561
+uniform_refit,hot,0,0.00031622776601683794,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561
+uniform_refit,hot,0,0.0005623413251903491,4,2,125,3,126,250,200,4,75.6,0.0001665972511453561
+uniform_refit,hot,0,0.001,3,2,125,3,126,250,150,3,48.384,0.0005830903790087463
+uniform_refit,hot,2,1e-18,18,2,126,3,127,248,900,31,1362.1774193548388,7.796851299792269e-19
+uniform_refit,hot,2,1.778279410038923e-18,18,2,126,3,127,248,900,30,1342.717741935484,7.796851299792269e-19
+uniform_refit,hot,2,3.1622776601683795e-18,17,2,34,3,35,64,850,30,1319.0625,3.116559176094582e-18
+uniform_refit,hot,2,5.623413251903491e-18,17,2,62,3,63,120,850,29,1247.4,5.527129629945824e-18
+uniform_refit,hot,2,1e-17,17,2,112,3,113,220,850,29,1220.4,9.838092055345813e-18
+uniform_refit,hot,2,1.7782794100389228e-17,17,2,126,3,127,248,850,28,1198.3064516129032,1.1045539341372381e-17
+uniform_refit,hot,2,3.1622776601683796e-17,17,2,126,3,127,248,850,28,1198.3064516129032,1.1045539341372381e-17
+uniform_refit,hot,2,5.62341325190349e-17,16,2,44,3,45,84,800,27,1129.2857142857142,5.614174466500292e-17
+uniform_refit,hot,2,1e-16,16,2,80,3,81,156,800,27,1094.5384615384614,9.993444695613996e-17
+uniform_refit,hot,2,1.7782794100389228e-16,16,2,126,3,127,248,800,27,1079.5,1.5593702599584538e-16
+uniform_refit,hot,2,3.1622776601683793e-16,16,2,126,3,127,248,800,26,1062.0887096774193,1.5593702599584538e-16
+uniform_refit,hot,2,5.623413251903491e-16,15,2,30,3,31,56,750,26,1045.142857142857,5.505247592327814e-16
+uniform_refit,hot,2,1e-15,15,2,56,3,57,108,750,25,979.5555555555555,9.946600423603305e-16
+uniform_refit,hot,2,1.7782794100389227e-15,15,2,100,3,101,196,750,25,956.4081632653061,1.7476976483580363e-15
+uniform_refit,hot,2,3.1622776601683794e-15,15,2,126,3,127,248,750,24,934.0645161290323,2.192864428066576e-15
+uniform_refit,hot,2,5.6234132519034904e-15,15,2,126,3,127,248,750,24,934.0645161290323,2.192864428066576e-15
+uniform_refit,hot,2,1e-14,14,2,38,3,39,72,700,23,877.5,9.618007373894983e-15
+uniform_refit,hot,2,1.7782794100389227e-14,14,2,72,3,73,140,700,23,844.7142857142857,1.7757726633812592e-14
+uniform_refit,hot,2,3.1622776601683796e-14,14,2,126,3,127,248,700,22,814.233870967742,3.070010199293206e-14
+uniform_refit,hot,2,5.6234132519034906e-14,14,2,126,3,127,248,700,22,814.233870967742,3.070010199293206e-14
+uniform_refit,hot,2,1e-13,13,2,26,3,27,48,650,21,787.5,9.407244746934382e-14
+uniform_refit,hot,2,1.7782794100389227e-13,13,2,50,3,51,96,650,21,743.75,1.7395053156313578e-13
+uniform_refit,hot,2,3.162277660168379e-13,13,2,92,3,93,180,650,21,723.3333333333334,3.1409435715208127e-13
+uniform_refit,hot,2,5.62341325190349e-13,13,2,126,3,127,248,650,20,702.5967741935484,4.276085634729822e-13
+uniform_refit,hot,2,1e-12,13,2,126,3,127,248,650,20,702.5967741935484,4.276085634729822e-13
+uniform_refit,hot,2,1.7782794100389228e-12,12,2,36,3,37,68,600,19,650.7647058823529,1.7627155114446329e-12
+uniform_refit,hot,2,3.1622776601683794e-12,12,2,66,3,67,128,600,19,626.03125,3.14748767972362e-12
+uniform_refit,hot,2,5.6234132519034904e-12,12,2,118,3,119,232,600,18,600.1293103448276,5.550884196506973e-12
+uniform_refit,hot,2,1e-11,12,2,126,3,127,248,600,18,599.1532258064516,5.920733955779755e-12
+uniform_refit,hot,2,1.7782794100389227e-11,11,2,24,3,25,44,550,17,572.7272727272727,1.6647868719199307e-11
+uniform_refit,hot,2,3.1622776601683794e-11,11,2,46,3,47,88,550,17,538.3636363636364,3.057889775158484e-11
+uniform_refit,hot,2,5.6234132519034906e-11,11,2,86,3,87,168,550,16,509.57142857142856,5.59856153901777e-11
+uniform_refit,hot,2,1e-10,11,2,126,3,127,248,550,16,503.9032258064516,8.141009189197163e-11
+uniform_refit,hot,2,1.778279410038923e-10,11,2,126,3,127,248,550,15,491.61290322580646,8.141009189197163e-11
+uniform_refit,hot,2,3.1622776601683795e-10,10,2,34,3,35,64,500,15,457.1875,3.1323138410472653e-10
+uniform_refit,hot,2,5.623413251903491e-10,10,2,62,3,63,120,500,15,438.9,5.555070083038381e-10
+uniform_refit,hot,2,1e-09,10,2,112,3,113,220,500,14,418.1,9.88782505746383e-10
+uniform_refit,hot,2,1.7782794100389228e-09,10,2,126,3,127,248,500,14,416.8467741935484,1.1101376167087038e-09
+uniform_refit,hot,2,3.1622776601683795e-09,9,2,24,3,25,44,450,13,386.3636363636364,3.0647212869435092e-09
+uniform_refit,hot,2,5.623413251903491e-09,9,2,44,3,45,84,450,13,364.2857142857143,5.395693165240491e-09
+uniform_refit,hot,2,1e-08,9,2,82,3,83,160,450,12,342.375,9.838500228623686e-09
+uniform_refit,hot,2,1.7782794100389228e-08,9,2,126,3,127,248,450,12,337.98387096774195,1.4986857825567502e-08
+uniform_refit,hot,2,3.162277660168379e-08,8,2,18,3,19,32,400,11,320.625,3.160493827160494e-08
+uniform_refit,hot,2,5.6234132519034905e-08,8,2,32,3,33,60,400,11,297.0,5.3273179901437785e-08
+uniform_refit,hot,2,1e-07,8,2,62,3,63,120,400,10,274.05,9.999126149469086e-08
+uniform_refit,hot,2,1.7782794100389227e-07,8,2,110,3,111,216,400,10,268.25,1.748604266513122e-07
+uniform_refit,hot,2,3.162277660168379e-07,8,2,126,3,127,248,400,10,267.31451612903226,1.998247710075667e-07
+uniform_refit,hot,2,5.62341325190349e-07,7,2,24,3,25,44,350,9,236.36363636363637,5.363262252151139e-07
+uniform_refit,hot,2,1e-06,7,2,46,3,47,88,350,9,222.1818181818182,9.851269900652615e-07
+uniform_refit,hot,2,1.778279410038923e-06,7,2,84,3,85,164,350,8,207.3170731707317,1.7626819231155273e-06
+uniform_refit,hot,2,3.162277660168379e-06,7,2,126,3,127,248,350,8,204.83870967741936,2.6227001194743126e-06
+uniform_refit,hot,2,5.623413251903491e-06,6,2,18,3,19,32,300,7,182.875,5.3333333333333345e-06
+uniform_refit,hot,2,1e-05,6,2,34,3,35,64,300,7,168.4375,9.51440329218107e-06
+uniform_refit,hot,2,1.778279410038923e-05,6,2,64,3,65,124,300,6,154.11290322580646,1.7399707951679278e-05
+uniform_refit,hot,2,3.1622776601683795e-05,6,2,118,3,119,232,300,6,150.80172413793105,3.161402015041862e-05
+uniform_refit,hot,2,5.623413251903491e-05,5,2,14,3,15,24,250,5,135.0,5.377229080932786e-05
+uniform_refit,hot,2,0.0001,5,2,28,3,29,52,250,5,120.46153846153847,9.927192149414372e-05
+uniform_refit,hot,2,0.00017782794100389227,5,2,50,3,51,96,250,4,108.375,0.00017146776406035667
+uniform_refit,hot,2,0.00031622776601683794,5,2,94,3,95,184,250,4,105.32608695652173,0.00031619252102343894
+uniform_refit,hot,2,0.0005623413251903491,4,2,10,3,11,16,200,4,103.125,0.0004938271604938272
+uniform_refit,hot,2,0.001,4,2,22,3,23,40,200,3,80.5,0.0009560493827160494
diff --git a/wai/wai-rs/Cargo.lock b/wai/wai-rs/Cargo.lock
index 4e874a70a..356ba4199 100644
--- a/wai/wai-rs/Cargo.lock
+++ b/wai/wai-rs/Cargo.lock
@@ -3900,7 +3900,7 @@ dependencies = [
 
 [[package]]
 name = "wai-quantum"
-version = "0.3.28"
+version = "0.3.29"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-rs/Cargo.toml b/wai/wai-rs/Cargo.toml
index 2fe108842..0e41163fa 100644
--- a/wai/wai-rs/Cargo.toml
+++ b/wai/wai-rs/Cargo.toml
@@ -357,6 +357,9 @@ quantum_tn = ["dep:wai-quantum", "wai-quantum/quantum_tn"]
 quantum_gbs = ["dep:wai-quantum", "wai-quantum/quantum_gbs"]
 # The dense state vector at any angle: fusion, threads, the same bits everywhere.
 quantum_sv = ["dep:wai-quantum", "wai-quantum/quantum_sv"]
+# Architecture-level estimation: yoked storage, cultivation, CCZ factories,
+# reaction-limited time, whole machines.
+quantum_arch = ["dep:wai-quantum", "wai-quantum/quantum_arch"]
 quantum_qir = ["quantum_toolchain", "wai-quantum/quantum_qir"]
 # Variational quantum machine learning (extensions/quantum-sim § VML,
 # `wai.quantum.vml`): the interference-based ML the thermodynamic-computing pivot
@@ -489,6 +492,7 @@ required-features = [
     "quantum_tn",
     "quantum_gbs",
     "quantum_sv",
+    "quantum_arch",
 ]
 
 [[bin]]
diff --git a/wai/wai-rs/src/bin/wai_quantum.rs b/wai/wai-rs/src/bin/wai_quantum.rs
index c436c1823..f185b9632 100644
--- a/wai/wai-rs/src/bin/wai_quantum.rs
+++ b/wai/wai-rs/src/bin/wai_quantum.rs
@@ -165,6 +165,10 @@ fn usage() -> ! {
          wai-quantum gbs --squeezing r1,r2,… [--eta E] [--seed S | --unitary U.json] [--json]\n  \
          wai-quantum gbs … --sample K                 (exact click patterns)\n  \
          wai-quantum gbs … --check SAMPLES.txt        (observed patterns vs exact marginals)\n\n\
+         ARCHITECTURE:\n  \
+         wai-quantum arch factoring [--bits 1024|1536|2048|3072|4096|6144|8192] [--json]\n  \
+         wai-quantum arch storage [--target T] [--fits refit|uniform|si1000] [--json]\n  \
+         wai-quantum arch cultivate [--p 5e-4|1e-3|2e-3] [--target T] [--json]\n\n\
          STATE VECTOR (any gate, any angle):\n  \
          wai-quantum sv --file CIRCUIT.jsonl [-n N] [--fuse W] [--top K | --sample S [--seed X] | --expect \"Z0 Z1; X3\"] [--json]\n\n\
          TENSOR NETWORKS:\n  \
@@ -957,6 +961,84 @@ fn main() {
             }
         }
 
+        // The architecture around the code: yoked storage, cultivated magic
+        // states, CCZ factories and the clock, priced; and the published
+        // factoring machine re-run region by region.
+        "arch" => {
+            use wai::quantum_arch::*;
+            let json = flag(args, "--json");
+            match algo.map(String::as_str) {
+                Some("factoring") | None => {
+                    let bits: u32 = num(args, "--bits", "", 2048);
+                    let params = FactoringParams::published(bits).unwrap_or_else(|| die("--bits: one of 1024, 1536, 2048, 3072, 4096, 6144, 8192"));
+                    let e = factoring_estimate(&params, &Machine::published()).unwrap_or_else(|e| die(&e.to_string()));
+                    let blocks: Vec<(u32, u32, u32, u64)> = e.cold.blocks.iter().map(|(b, k)| (b.rows - 1, b.distance, b.logical, *k)).collect();
+                    if json {
+                        let bs: Vec<String> = blocks.iter().map(|(w, d, l, k)| format!("{{\"count\":{k},\"distance\":{d},\"logical\":{l},\"width\":{w}}}")).collect();
+                        println!(
+                            "{{\"bits\":{bits},\"ccz_error\":{},\"ccz_rounds\":{},\"cold_blocks\":[{}],\"cold_logical\":{},\"cold_qubits\":{},\"compute_qubits\":{},\"days\":{},\"expected_shots\":{},\"hot_distance\":{},\"hot_logical\":{},\"hot_qubits\":{},\"hours_per_shot\":{},\"hours_per_shot_rounded\":{},\"physical_qubits\":{},\"shot_survival\":{},\"step_us\":{},\"t_state_d1\":{},\"t_state_volume\":{},\"toffolis_per_shot\":{}}}",
+                            e.ccz_error, e.ccz_rounds, bs.join(","), e.cold_logical, e.cold_qubits, e.compute_qubits, e.days, e.expected_shots, e.hot_distance, e.hot_logical,
+                            e.hot_qubits, e.hours_per_shot, e.hours_per_shot_rounded, e.physical_qubits(), e.shot_survival, e.timing.step_us(), e.t_state.d1, e.t_state.volume, e.toffolis_per_shot
+                        );
+                    } else {
+                        println!("{bits}-bit factoring (arXiv:2505.15917 parameters), re-run");
+                        println!("logical qubits   {} cold + {} hot", e.cold_logical, e.hot_logical);
+                        for (w, d, l, k) in &blocks {
+                            println!("cold storage     {k} × {w}×{w} grid-yoked block, d = {d}, {l} logical each");
+                        }
+                        println!("hot storage      d = {}", e.hot_distance);
+                        println!("physical qubits  {} = {} cold + {} hot + {} compute", e.physical_qubits(), e.cold_qubits, e.hot_qubits, e.compute_qubits);
+                        println!("T states         cultivated at d1 = {}, {:.0} qubit·rounds each", e.t_state.d1, e.t_state.volume);
+                        println!("CCZ states       {:.1} rounds per factory, error {:.1e}", e.ccz_rounds, e.ccz_error);
+                        println!("clock            {:.1} µs per step ({:?}-bound)", e.timing.step_us(), e.timing.bound());
+                        println!("Toffolis         {:.4e} per shot", e.toffolis_per_shot);
+                        println!("time             {:.2} h per shot ({:.2} h at the clock), {:.2} shots, {:.2} days", e.hours_per_shot_rounded, e.hours_per_shot, e.expected_shots, e.days);
+                    }
+                }
+                Some("storage") => {
+                    let target: f64 = num(args, "--target", "", 1e-15);
+                    let model = match opt(args, "--fits", "").as_deref() {
+                        None | Some("refit") => StorageModel::uniform_refit(),
+                        Some("uniform") => StorageModel::uniform(),
+                        Some("si1000") => StorageModel::si1000(),
+                        Some(_) => die("--fits: refit, uniform or si1000"),
+                    };
+                    let rows = [
+                        ("cold plain", best_block(&model, Storage::Cold, Yoke::None, target, 250)),
+                        ("cold rows", best_block(&model, Storage::Cold, Yoke::Rows, target, 250)),
+                        ("cold grid", best_block(&model, Storage::Cold, Yoke::Grid, target, 250)),
+                        ("hot plain", best_block(&model, Storage::Hot, Yoke::None, target, 250)),
+                        ("hot rows", best_block(&model, Storage::Hot, Yoke::Rows, target, 250)),
+                    ];
+                    if json {
+                        let items: Vec<String> = rows
+                            .iter()
+                            .filter_map(|(name, b)| b.map(|b| format!("{{\"distance\":{},\"logical\":{},\"name\":\"{name}\",\"qubits_per_logical\":{}}}", b.distance, b.logical, b.qubits_per_logical())))
+                            .collect();
+                        println!("{{\"layouts\":[{}],\"target\":{target}}}", items.join(","));
+                    } else {
+                        println!("storage at {target:e} per logical qubit per round");
+                        for (name, b) in rows {
+                            match b {
+                                Some(b) => println!("{name:<11} d = {:>3}  {:>4} × {:<4} patches  {:>4} logical  {:>8.2} qubits each", b.distance, b.rows, b.cols, b.logical, b.qubits_per_logical()),
+                                None => println!("{name:<11} unreachable"),
+                            }
+                        }
+                    }
+                }
+                Some("cultivate") => {
+                    let p: f64 = num(args, "--p", "", 1e-3);
+                    let target: f64 = num(args, "--target", "", 1e-7);
+                    match cultivate(p, target) {
+                        Some(t) if json => println!("{{\"d1\":{},\"error\":{},\"volume\":{}}}", t.d1, t.error, t.volume),
+                        Some(t) => println!("T state at p = {p:e}: error {:.2e}, {:.0} qubit·rounds (injection distance {})", t.error, t.volume, t.d1),
+                        None => die("no cultivation curve reaches that target at that noise (simulated: 5e-4, 1e-3, 2e-3)"),
+                    }
+                }
+                Some(other) => die(&format!("arch: unknown '{other}' (factoring, storage, cultivate)")),
+            }
+        }
+
         // The dense state vector, any gate at any angle: run a circuit file
         // (fused to --fuse qubits), then show the likeliest outcomes, draw
         // samples, or evaluate Pauli observables.
diff --git a/wai/wai-rs/src/lib.rs b/wai/wai-rs/src/lib.rs
index 960f3a554..e7243848d 100644
--- a/wai/wai-rs/src/lib.rs
+++ b/wai/wai-rs/src/lib.rs
@@ -634,6 +634,9 @@ pub use wai_quantum::quantum_gbs;
 #[cfg(feature = "quantum_sv")]
 pub use wai_quantum::quantum_sv;
 
+#[cfg(feature = "quantum_arch")]
+pub use wai_quantum::quantum_arch;
+
 #[cfg(any(feature = "quantum_tn", feature = "quantum_sv"))]
 pub use wai_quantum::gates;
 #[cfg(feature = "quantum_qir")]
diff --git a/wai/wai-web/Cargo.lock b/wai/wai-web/Cargo.lock
index 07ccb6ab6..5e4c3cb1b 100644
--- a/wai/wai-web/Cargo.lock
+++ b/wai/wai-web/Cargo.lock
@@ -734,7 +734,7 @@ dependencies = [
 
 [[package]]
 name = "wai-quantum"
-version = "0.3.28"
+version = "0.3.29"
 dependencies = [
  "blake3",
  "ed25519-dalek",