From c403edbbdcb1ebc375ea3f1914b5e1be94a1a634 Mon Sep 17 00:00:00 2001
From: Transaction Science <hello@transaction.science>
Date: Sun, 4 Oct 2026 21:30:40 -0400
Subject: [PATCH] wai-quantum 0.3.30: qLDPC memory at circuit level, re-derived
 from the circuit up

quantum_ldpc re-derives the logical failure rates of bivariate-bicycle
memories (arXiv:2308.07915) from scratch:

- Codes from their two polynomials: check matrices, k by GF(2) rank, a basis
  of logical operators. Presets [[72,12,6]], [[90,8,10]], [[108,8,10]],
  [[144,12,12]] and [[288,12,18]] all come out with their published k.
- The depth-8 syndrome cycle as circuit text: the published CNOT order, X and
  Z checks interleaved, circuit-level depolarizing noise on every CNOT, idle,
  preparation and measurement, two noiseless closing cycles, observables from
  the logical basis. quantum_frame samples it and derives its error model.
- BP-OSD: min-sum belief propagation in the log domain with adaptive scaling
  1 - 2^-t, then ordered statistics on non-convergence (information set in
  posterior order, combination sweep of order 7, cost sum ln(1/p)), in f64
  with in-crate logarithms.
- Memory experiments in fixed 64-shot chunks across threads (one on wasm32);
  the tally does not depend on the thread count.

Checked against the source's own Apache-2.0 simulation software:
- the error model for [[72,12,6]] (six cycles, p = 0.003) has its columns
  exactly, 2,268 X-fault and 2,232 Z-fault; half the probabilities agree to
  1e-13, the largest gap is 0.94% (merged faults: sums vs independent);
- on identical syndromes and error model, its decoder makes the same
  decision as BpOsd on 1,500 of 1,500 shots;
- failure rates per run on [[72,12,6]]: 0.028/0.090/0.230 here vs
  0.034/0.086/0.209 at p = 0.003/0.004/0.005 (halves combined as
  independent; the source's halves fail together 2.9% vs 1.3%);
- half by half at p = 0.005 the Z-type agrees (0.122 vs 0.118); the X-type is
  0.121 here (20,000 shots) vs 0.111 (9,000 runs), 2.3 sigma. Priors make no
  difference (476 vs 478 of 4,000) and both samplers match the exact detector
  rates, so the residual is in sampling and is documented as open;
- [[144,12,12]] per run 0.034 / 0.180 vs 0.039 / 0.193 at p = 0.004 / 0.005;
  per cycle on the published fit (2.90e-3 vs 3.15e-3, 1.64e-2 vs 1.54e-2).

CLI: wai-quantum ldpc [--code --p --cycles --shots --basis --max-iter
--osd-order --threads --seed --json] and ldpc --circuit. Example:
ldpc_memory. Pinned bit for bit natively and under wasm32-wasip2 (15 pins);
CLI output byte-identical across the two, including threaded vs not.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 wai/wai-quantum-serve/Cargo.lock            |    2 +-
 wai/wai-quantum/Cargo.lock                  |    2 +-
 wai/wai-quantum/Cargo.toml                  |   11 +-
 wai/wai-quantum/README.md                   |   25 +
 wai/wai-quantum/examples/ldpc_memory.rs     |   45 +
 wai/wai-quantum/src/lib.rs                  |    3 +
 wai/wai-quantum/src/quantum_ldpc.rs         |  978 ++++
 wai/wai-quantum/tests/bit_identity.rs       |   27 +-
 wai/wai-quantum/tests/data/bb72_p003_c6.dem | 4504 +++++++++++++++++++
 wai/wai-rs/Cargo.lock                       |    2 +-
 wai/wai-rs/Cargo.toml                       |    3 +
 wai/wai-rs/src/bin/wai_quantum.rs           |   64 +
 wai/wai-rs/src/lib.rs                       |    3 +
 wai/wai-web/Cargo.lock                      |    2 +-
 14 files changed, 5664 insertions(+), 7 deletions(-)
 create mode 100644 wai/wai-quantum/examples/ldpc_memory.rs
 create mode 100644 wai/wai-quantum/src/quantum_ldpc.rs
 create mode 100644 wai/wai-quantum/tests/data/bb72_p003_c6.dem

diff --git a/wai/wai-quantum-serve/Cargo.lock b/wai/wai-quantum-serve/Cargo.lock
index 8ce676bc5..ad69b461e 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.29"
+version = "0.3.30"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-quantum/Cargo.lock b/wai/wai-quantum/Cargo.lock
index 22101dd04..5ebca3ae9 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.29"
+version = "0.3.30"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-quantum/Cargo.toml b/wai/wai-quantum/Cargo.toml
index 2b032b640..e41d71ae7 100644
--- a/wai/wai-quantum/Cargo.toml
+++ b/wai/wai-quantum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "wai-quantum"
-version = "0.3.29"
+version = "0.3.30"
 edition = "2024"
 rust-version = "1.97"
 license = "Apache-2.0"
@@ -68,6 +68,9 @@ quantum_sv = []
 # Architecture-level estimation: yoked storage, magic-state cultivation, CCZ
 # factories and reaction-limited time, assembled into whole-machine estimates.
 quantum_arch = []
+# qLDPC memory at circuit level: bivariate-bicycle codes, their depth-8 syndrome
+# cycle, and BP-OSD decoding of the circuit's error model.
+quantum_ldpc = ["quantum_frame"]
 # 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"]
@@ -107,13 +110,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_arch", "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_ldpc", "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 = "ldpc_memory"
+required-features = ["quantum_ldpc"]
+
 [[example]]
 name = "arch_factoring"
 required-features = ["quantum_arch"]
diff --git a/wai/wai-quantum/README.md b/wai/wai-quantum/README.md
index 4b984f261..47fbb445a 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_ldpc` | **qLDPC memory at circuit level**: bivariate-bicycle codes from their two polynomials (`k` by rank, logical bases), the depth-8 syndrome cycle with circuit-level noise, its detector error model, and BP-OSD decoding (min-sum with adaptive scaling, ordered statistics with a combination sweep). The error model has the same columns as the source's own decoding matrices, and on identical syndromes the decoder makes the source's decisions shot for shot |
 | `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 |
@@ -153,6 +154,30 @@ 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.
 
+## qLDPC memory
+
+```sh
+wai-quantum ldpc --code 144 --p 0.004 --cycles 12 --shots 1000   # failures per cycle, both halves
+wai-quantum ldpc --circuit --code 72 --cycles 6 --p 0.003        # the circuit itself
+```
+
+High-rate codes are where most of the projected qubit savings in fault
+tolerance come from, and their headline numbers are logical failure rates per
+syndrome cycle under circuit noise. `quantum_ldpc` re-derives them for the
+bivariate-bicycle family (arXiv:2308.07915):
+- the codes are built from their polynomials;
+- the depth-8 syndrome cycle is written out gate by gate;
+- the circuit is sampled with the Pauli-frame simulator;
+- its error model is decoded with belief propagation plus ordered statistics.
+
+The source published its simulation software, and running it gives the
+oracle. On the 72-qubit code the derived error model has the source's columns,
+detector for detector, and on identical syndromes the decoder makes the
+source's decision shot for shot. Logical failure rates track the source's;
+the one open residual, 2.3σ on one half at the highest noise, is documented
+in the module. On the 144-qubit code the rates land on the source's published
+curve.
+
 ## Architecture
 
 ```sh
diff --git a/wai/wai-quantum/examples/ldpc_memory.rs b/wai/wai-quantum/examples/ldpc_memory.rs
new file mode 100644
index 000000000..25f72c0f8
--- /dev/null
+++ b/wai/wai-quantum/examples/ldpc_memory.rs
@@ -0,0 +1,45 @@
+//! Run a bivariate-bicycle memory experiment at circuit level and decode it
+//! with BP-OSD: logical failures per shot and per syndrome cycle.
+//!
+//! ```text
+//! cargo run --release --example ldpc_memory --features quantum_ldpc -- CODE P CYCLES SHOTS [THREADS] [MAX_ITER]
+//! ```
+//! CODE is 72, 90, 108, 144 or 288.
+use wai_quantum::quantum_frame::Basis;
+use wai_quantum::quantum_ldpc::{memory_experiment, BbCode, BpOsdConfig};
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    let code = match a[1].as_str() {
+        "72" => BbCode::bb72(),
+        "90" => BbCode::bb90(),
+        "108" => BbCode::bb108(),
+        "144" => BbCode::bb144(),
+        "288" => BbCode::bb288(),
+        other => panic!("unknown code {other}"),
+    };
+    let p: f64 = a[2].parse().unwrap();
+    let cycles: u32 = a[3].parse().unwrap();
+    let shots: usize = a[4].parse().unwrap();
+    let threads: usize = a.get(5).map_or(8, |x| x.parse().unwrap());
+    let max_iter: u32 = a.get(6).map_or(10_000, |x| x.parse().unwrap());
+    let cfg = BpOsdConfig { max_iter, ..BpOsdConfig::default() };
+    let mut both_ok = 1.0;
+    for (name, basis, seed) in [("Z", Basis::Z, 1u64 << 32), ("X", Basis::X, 2u64 << 32)] {
+        let t0 = std::time::Instant::now();
+        let r = memory_experiment(&code, cycles, p, basis, shots, seed, cfg, threads).unwrap();
+        let dt = t0.elapsed().as_secs_f64();
+        both_ok *= 1.0 - r.per_shot();
+        println!(
+            "{name}-basis  shots {}  failures {}  per shot {:.5}  per cycle {:.3e}  bp-converged {:.3}  {:.1} ms/shot",
+            r.shots,
+            r.failures,
+            r.per_shot(),
+            r.per_cycle(),
+            r.converged as f64 / r.shots as f64,
+            1e3 * dt * threads as f64 / shots as f64
+        );
+    }
+    let p_shot = 1.0 - both_ok;
+    println!("either     per shot {:.5}  per cycle {:.3e}", p_shot, 1.0 - (1.0 - p_shot).powf(1.0 / f64::from(cycles)));
+}
diff --git a/wai/wai-quantum/src/lib.rs b/wai/wai-quantum/src/lib.rs
index 772ac7e41..da1ff3b1a 100644
--- a/wai/wai-quantum/src/lib.rs
+++ b/wai/wai-quantum/src/lib.rs
@@ -106,6 +106,9 @@ pub mod quantum_arch;
 #[cfg(feature = "quantum_frame")]
 pub mod quantum_frame;
 
+#[cfg(feature = "quantum_ldpc")]
+pub mod quantum_ldpc;
+
 #[cfg(feature = "quantum_frame")]
 pub mod quantum_match;
 
diff --git a/wai/wai-quantum/src/quantum_ldpc.rs b/wai/wai-quantum/src/quantum_ldpc.rs
new file mode 100644
index 000000000..d631350a8
--- /dev/null
+++ b/wai/wai-quantum/src/quantum_ldpc.rs
@@ -0,0 +1,978 @@
+//! qLDPC MEMORY at circuit level — `wai.quantum.ldpc`.
+//!
+//! High-rate quantum LDPC codes promise many logical qubits per physical
+//! qubit. The bivariate-bicycle family (arXiv:2308.07915) is the
+//! best-documented case: 12 logical qubits in 144 data and 144 check qubits at
+//! distance 12. The claim that matters is how often such a memory fails per
+//! syndrome cycle when every gate, idle, preparation and measurement is noisy.
+//! That number comes from a circuit simulation and a decoder.
+//!
+//! This module builds both, so the claim can be re-derived rather than quoted:
+//!
+//! - **The codes.** [`BbCode`] builds the check matrices from the two
+//!   polynomials and counts the logical qubits by rank. It also finds a basis
+//!   of logical operators. Five codes from the source are presets.
+//! - **The circuit.** [`memory_circuit`] writes the source's depth-8 syndrome
+//!   cycle in the ecosystem's circuit text:
+//!   - each check qubit is coupled to its six neighbours in the published
+//!     order;
+//!   - X checks are measured in the X basis and Z checks in the Z basis, all
+//!     interleaved;
+//!   - circuit-level depolarizing noise of strength `p` follows every CNOT,
+//!     idle, preparation and measurement;
+//!   - two noiseless cycles at the end read the final syndrome.
+//!
+//!   `quantum_frame` samples it and derives its detector error model.
+//! - **The decoder.** [`BpOsd`] is belief propagation with ordered-statistics
+//!   post-processing:
+//!   - min-sum belief propagation in the log domain, with the adaptive
+//!     scaling `α = 1 − 2^(−t)`;
+//!   - when it fails to converge, ordered statistics: columns are ranked by
+//!     the posterior, an information set is taken in that order, and the
+//!     combination sweep is scored by `Σ ln(1/p)`.
+//!
+//!   It runs in `f64` with in-crate logarithms, so a decode is the same bits on
+//!   every machine.
+//! - **The experiment.** [`memory_experiment`] runs Z-basis or X-basis memory,
+//!   sampled in fixed chunks across threads, and counts logical failures.
+//!   [`LdpcPoint::per_cycle`] turns them into a rate per syndrome cycle.
+//!
+//! # Checked against the source's own software
+//!
+//! The source's simulation software is Apache-2.0. Running it gives the
+//! oracle:
+//! - **The error model.** Its decoding matrices for `[[72,12,6]]` over six
+//!   cycles at `p = 0.003` have the same columns as the ones derived here
+//!   from the circuit, detector for detector: 2,268 for X faults and 2,232
+//!   for Z faults. Half the probabilities agree to `10⁻¹³`. The largest gap
+//!   is 0.94%, on columns where several faults merge: the source adds their
+//!   probabilities, while this crate combines them as independent events.
+//! - **Logical failure rates.** These agree with the source's decoder on the
+//!   same codes and noise. On `[[72,12,6]]` over six cycles, the failure
+//!   rates per shot are:
+//!
+//!   | `p`   | here (8,000 shots) | source's software (2,000 trials) |
+//!   |-------|--------------------|----------------------------------|
+//!   | 0.003 | 0.028              | 0.034                            |
+//!   | 0.004 | 0.090              | 0.086                            |
+//!   | 0.005 | 0.230              | 0.209                            |
+//!
+//!   "Here" combines the two halves as independent. The source decodes both
+//!   halves of each run, and a Y fault can fail both together: in its software
+//!   at `p = 0.005` both fail in 2.9% of runs, against 1.3% if they were
+//!   independent. That accounts for most of the gap in the last row.
+//!
+//!   Taken half by half at `p = 0.005`, the source's software (9,000 runs for
+//!   the X-type half, 3,000 for the Z-type) gives 0.111 and 0.118. This
+//!   crate gives 0.121 (20,000 shots) and 0.122 (4,000). The Z-type half
+//!   agrees. The X-type half sits 2.3σ above.
+//!
+//!   Each piece of the chain was checked separately:
+//!   - the error models match column for column;
+//!   - the source's decoder, given this crate's syndromes and error model,
+//!     makes the same decision as [`BpOsd`] on every one of 1,500 shots;
+//!   - decoding with the source's priors instead of these moves 476
+//!     failures out of 4,000 to 478;
+//!   - both samplers' detector rates match the exact expectation of the
+//!     error model.
+//!
+//!   The residual lies in sampling, at a level not yet resolved.
+//! - **The 144-qubit code.** On `[[144,12,12]]` over twelve cycles, the
+//!   failure rate per run is 0.034 at `p = 0.004` and 0.180 at `p = 0.005`
+//!   (8,000 and 2,000 shots). The source's software gives 0.039 (1,522 runs)
+//!   and 0.193 (519 runs). Per cycle, the rates land on the source's
+//!   published curve: 2.90·10⁻³ at `p = 0.004` (fit 3.15·10⁻³) and
+//!   1.64·10⁻² at `p = 0.005` (fit 1.54·10⁻²).
+//!
+//! # Honest boundaries
+//!
+//! - **Memory only.** Logical gates on these codes (automorphisms, the
+//!   ZX-duality, measurements through an ancilla system) are not simulated.
+//! - **Two experiments, not one.** A Z-basis memory sees X-type failures and an
+//!   X-basis memory sees Z-type failures. Their rates are combined as
+//!   independent. The source decodes both halves of one noisy run instead,
+//!   which differs at second order.
+//! - **The decoder is the source's.** It is not the best decoder known for
+//!   these codes. A better one would make the code look better. The point here
+//!   is to reproduce the claim on its own terms.
+
+use crate::quantum_frame::{error_model, parse, sample, Basis, ErrorModel, FrameError};
+use crate::repro::ln;
+
+// ---------------------------------------------------------------------------
+// GF(2)
+// ---------------------------------------------------------------------------
+
+/// A set of GF(2) rows over `cols` columns, kept in reduced echelon form as
+/// they arrive, so membership and rank are cheap.
+#[derive(Clone, Debug)]
+struct Span {
+    /// Reduced rows with the column of their leading one.
+    rows: Vec<(usize, Vec<u64>)>,
+}
+
+impl Span {
+    fn new(cols: usize) -> Span {
+        let _ = cols;
+        Span { rows: Vec::new() }
+    }
+    fn reduce(&self, v: &mut [u64]) {
+        for (lead, r) in &self.rows {
+            if (v[lead / 64] >> (lead % 64)) & 1 == 1 {
+                for (a, b) in v.iter_mut().zip(r) {
+                    *a ^= b;
+                }
+            }
+        }
+    }
+    /// Add `v` unless it is already in the span; whether it was new.
+    fn insert(&mut self, v: &[u64]) -> bool {
+        let mut v = v.to_vec();
+        self.reduce(&mut v);
+        let Some(w) = v.iter().position(|&x| x != 0) else { return false };
+        let lead = w * 64 + v[w].trailing_zeros() as usize;
+        // Keep every row reduced at the new leading column.
+        for (_, r) in self.rows.iter_mut() {
+            if (r[lead / 64] >> (lead % 64)) & 1 == 1 {
+                for (a, b) in r.iter_mut().zip(&v) {
+                    *a ^= b;
+                }
+            }
+        }
+        self.rows.push((lead, v));
+        true
+    }
+    fn rank(&self) -> usize {
+        self.rows.len()
+    }
+}
+
+fn bits(cols: usize, ones: impl IntoIterator<Item = usize>) -> Vec<u64> {
+    let mut v = vec![0u64; cols.div_ceil(64)];
+    for c in ones {
+        v[c / 64] ^= 1 << (c % 64);
+    }
+    v
+}
+
+fn ones(v: &[u64]) -> Vec<usize> {
+    let mut out = Vec::new();
+    for (w, &x) in v.iter().enumerate() {
+        let mut x = x;
+        while x != 0 {
+            out.push(w * 64 + x.trailing_zeros() as usize);
+            x &= x - 1;
+        }
+    }
+    out
+}
+
+/// A basis of the null space of `rows` (each a list of columns) over `cols`
+/// columns.
+fn kernel(rows: &[Vec<usize>], cols: usize) -> Vec<Vec<u64>> {
+    // Row-reduce, then read the kernel off the free columns.
+    let mut span = Span::new(cols);
+    for r in rows {
+        span.insert(&bits(cols, r.iter().copied()));
+    }
+    let leads: Vec<usize> = span.rows.iter().map(|(l, _)| *l).collect();
+    let mut is_lead = vec![false; cols];
+    for &l in &leads {
+        is_lead[l] = true;
+    }
+    let mut out = Vec::new();
+    for free in (0..cols).filter(|&c| !is_lead[c]) {
+        let mut v = bits(cols, [free]);
+        for (lead, r) in &span.rows {
+            if (r[free / 64] >> (free % 64)) & 1 == 1 {
+                v[lead / 64] ^= 1 << (lead % 64);
+            }
+        }
+        out.push(v);
+    }
+    out
+}
+
+// ---------------------------------------------------------------------------
+// Bivariate-bicycle codes
+// ---------------------------------------------------------------------------
+
+/// A bivariate-bicycle code: `A = x^a₁ + y^a₂ + y^a₃` and
+/// `B = y^b₁ + x^b₂ + x^b₃` over `x^ℓ = y^m = 1`, with `H_X = [A | B]` and
+/// `H_Z = [Bᵀ | Aᵀ]`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct BbCode {
+    pub l: u32,
+    pub m: u32,
+    pub a: [u32; 3],
+    pub b: [u32; 3],
+}
+
+/// Which monomial of `A` or `B` a check's neighbour comes from.
+#[derive(Clone, Copy)]
+enum Mono {
+    X(u32),
+    Y(u32),
+}
+
+impl BbCode {
+    /// `[[72,12,6]]`.
+    pub fn bb72() -> BbCode {
+        BbCode { l: 6, m: 6, a: [3, 1, 2], b: [3, 1, 2] }
+    }
+    /// `[[90,8,10]]`.
+    pub fn bb90() -> BbCode {
+        BbCode { l: 15, m: 3, a: [9, 1, 2], b: [0, 2, 7] }
+    }
+    /// `[[108,8,10]]`.
+    pub fn bb108() -> BbCode {
+        BbCode { l: 9, m: 6, a: [3, 1, 2], b: [3, 1, 2] }
+    }
+    /// `[[144,12,12]]`.
+    pub fn bb144() -> BbCode {
+        BbCode { l: 12, m: 6, a: [3, 1, 2], b: [3, 1, 2] }
+    }
+    /// `[[288,12,18]]`.
+    pub fn bb288() -> BbCode {
+        BbCode { l: 12, m: 12, a: [3, 2, 7], b: [3, 1, 2] }
+    }
+
+    /// Checks of each type, `ℓm`.
+    pub fn half(&self) -> usize {
+        (self.l * self.m) as usize
+    }
+    /// Data qubits, `2ℓm`.
+    pub fn n(&self) -> usize {
+        2 * self.half()
+    }
+
+    fn apply(&self, mono: Mono, i: usize) -> usize {
+        let (l, m) = (self.l as usize, self.m as usize);
+        let (r, c) = (i / m, i % m);
+        match mono {
+            Mono::X(s) => ((r + s as usize) % l) * m + c,
+            Mono::Y(s) => r * m + (c + s as usize) % m,
+        }
+    }
+    fn apply_t(&self, mono: Mono, i: usize) -> usize {
+        let (l, m) = (self.l as usize, self.m as usize);
+        let (r, c) = (i / m, i % m);
+        match mono {
+            Mono::X(s) => ((r + l - s as usize % l) % l) * m + c,
+            Mono::Y(s) => r * m + (c + m - s as usize % m) % m,
+        }
+    }
+    fn a_mono(&self) -> [Mono; 3] {
+        [Mono::X(self.a[0]), Mono::Y(self.a[1]), Mono::Y(self.a[2])]
+    }
+    fn b_mono(&self) -> [Mono; 3] {
+        [Mono::Y(self.b[0]), Mono::X(self.b[1]), Mono::X(self.b[2])]
+    }
+
+    /// The six data qubits of X check `i`, by direction 0 to 5: `A₁(i), A₂(i),
+    /// A₃(i)` on the left half, then `B₁(i), B₂(i), B₃(i)` on the right.
+    pub fn x_neighbours(&self, i: usize) -> [usize; 6] {
+        let (a, b, h) = (self.a_mono(), self.b_mono(), self.half());
+        [self.apply(a[0], i), self.apply(a[1], i), self.apply(a[2], i), h + self.apply(b[0], i), h + self.apply(b[1], i), h + self.apply(b[2], i)]
+    }
+    /// The six data qubits of Z check `i`: `B₁ᵀ(i), B₂ᵀ(i), B₃ᵀ(i)` on the
+    /// left, then `A₁ᵀ(i), A₂ᵀ(i), A₃ᵀ(i)` on the right.
+    pub fn z_neighbours(&self, i: usize) -> [usize; 6] {
+        let (a, b, h) = (self.a_mono(), self.b_mono(), self.half());
+        [self.apply_t(b[0], i), self.apply_t(b[1], i), self.apply_t(b[2], i), h + self.apply_t(a[0], i), h + self.apply_t(a[1], i), h + self.apply_t(a[2], i)]
+    }
+
+    /// X checks as lists of data qubits.
+    pub fn hx(&self) -> Vec<Vec<usize>> {
+        (0..self.half()).map(|i| self.x_neighbours(i).to_vec()).collect()
+    }
+    /// Z checks as lists of data qubits.
+    pub fn hz(&self) -> Vec<Vec<usize>> {
+        (0..self.half()).map(|i| self.z_neighbours(i).to_vec()).collect()
+    }
+
+    /// Logical qubits, `n − rank H_X − rank H_Z`.
+    pub fn k(&self) -> usize {
+        let rank = |rows: Vec<Vec<usize>>| {
+            let mut s = Span::new(self.n());
+            for r in rows {
+                s.insert(&bits(self.n(), r));
+            }
+            s.rank()
+        };
+        self.n() - rank(self.hx()) - rank(self.hz())
+    }
+
+    /// Whether every X check commutes with every Z check.
+    pub fn is_valid(&self) -> bool {
+        let hz = self.hz();
+        self.hx().iter().all(|x| hz.iter().all(|z| x.iter().filter(|q| z.contains(q)).count() % 2 == 0))
+    }
+
+    /// A basis of `k` logical operators of one type. `Basis::Z` gives Z-type
+    /// operators, which commute with the X checks and are not products of Z
+    /// checks; `Basis::X` gives the reverse. Each is a list of data qubits.
+    pub fn logicals(&self, basis: Basis) -> Vec<Vec<usize>> {
+        let (commute, stabilizers) = match basis {
+            Basis::Z => (self.hx(), self.hz()),
+            Basis::X => (self.hz(), self.hx()),
+        };
+        let n = self.n();
+        let mut span = Span::new(n);
+        for s in stabilizers {
+            span.insert(&bits(n, s));
+        }
+        let mut out = Vec::new();
+        for v in kernel(&commute, n) {
+            if span.insert(&v) {
+                out.push(ones(&v));
+            }
+        }
+        out
+    }
+}
+
+// ---------------------------------------------------------------------------
+// The syndrome-measurement circuit
+// ---------------------------------------------------------------------------
+
+/// The order in which X checks (`SX`) and Z checks (`SZ`) visit their six
+/// neighbours over the seven CNOT rounds of a cycle (arXiv:2308.07915, its
+/// table of the depth-8 cycle). `None` is a round without a CNOT.
+const SX: [Option<usize>; 7] = [None, Some(1), Some(4), Some(3), Some(5), Some(0), Some(2)];
+const SZ: [Option<usize>; 7] = [Some(3), Some(5), Some(0), Some(1), Some(2), Some(4), None];
+
+fn line(out: &mut String, name: &str, arg: Option<f64>, targets: &[usize]) {
+    if targets.is_empty() {
+        return;
+    }
+    out.push_str(name);
+    if let Some(a) = arg {
+        out.push_str(&format!("({a})"));
+    }
+    for t in targets {
+        out.push_str(&format!(" {t}"));
+    }
+    out.push('\n');
+}
+
+/// Text of a bivariate-bicycle memory experiment in `basis`.
+///
+/// - **Layout.** Qubits are X checks `0..ℓm`, data `ℓm..3ℓm` (left half, then
+///   right) and Z checks `3ℓm..4ℓm`.
+/// - **Start.** Data and Z checks start in `basis`, noiselessly.
+/// - **Cycles.** `cycles` noisy syndrome cycles at strength `p`, then two
+///   noiseless ones.
+/// - **Detectors.** Each check of `basis`, cycle by cycle: its first outcome,
+///   then each change.
+/// - **Observables.** The logical operators of [`BbCode::logicals`], read from
+///   a final noiseless measurement of the data.
+///
+/// Noise:
+/// - two-qubit depolarizing noise after each CNOT;
+/// - one-qubit depolarizing noise on idle data;
+/// - a flip after each preparation;
+/// - a flipped result on each measurement.
+pub fn memory_circuit(code: &BbCode, cycles: u32, p: f64, basis: Basis) -> String {
+    let h = code.half();
+    let xc: Vec<usize> = (0..h).collect();
+    let data: Vec<usize> = (h..3 * h).collect();
+    let zc: Vec<usize> = (3 * h..4 * h).collect();
+    let xn: Vec<[usize; 6]> = (0..h).map(|i| code.x_neighbours(i).map(|q| q + h)).collect();
+    let zn: Vec<[usize; 6]> = (0..h).map(|i| code.z_neighbours(i).map(|q| q + h)).collect();
+    let mut out = String::new();
+    match basis {
+        Basis::Z => line(&mut out, "R", None, &data),
+        Basis::X => line(&mut out, "RX", None, &data),
+    }
+    line(&mut out, "R", None, &zc);
+    let mut measured = 0usize;
+    // Absolute record of each check's outcome in the previous cycle.
+    let mut previous: Option<Vec<usize>> = None;
+    for cycle in 0..cycles + 2 {
+        let noise = if cycle < cycles { Some(p) } else { None };
+        let idle_cnots = |out: &mut String, t: usize, x_rounds: bool, z_rounds: bool| {
+            let mut pairs: Vec<usize> = Vec::new();
+            let mut busy = vec![false; 4 * h];
+            if let (true, Some(dir)) = (z_rounds, SZ[t]) {
+                for i in 0..h {
+                    pairs.extend([zn[i][dir], zc[i]]);
+                    busy[zn[i][dir]] = true;
+                }
+            }
+            if let (true, Some(dir)) = (x_rounds, SX[t]) {
+                for i in 0..h {
+                    pairs.extend([xc[i], xn[i][dir]]);
+                    busy[xn[i][dir]] = true;
+                }
+            }
+            line(out, "CX", None, &pairs);
+            if let Some(p) = noise {
+                line(out, "DEPOLARIZE2", Some(p), &pairs);
+                let idle: Vec<usize> = data.iter().copied().filter(|&q| !busy[q]).collect();
+                line(out, "DEPOLARIZE1", Some(p), &idle);
+            }
+        };
+        // Round 1: prepare the X checks; the Z checks take their first CNOT.
+        line(&mut out, "RX", None, &xc);
+        if let Some(p) = noise {
+            line(&mut out, "Z_ERROR", Some(p), &xc);
+        }
+        idle_cnots(&mut out, 0, false, true);
+        out.push_str("TICK\n");
+        // Rounds 2 to 6: both kinds of check.
+        for t in 1..6 {
+            idle_cnots(&mut out, t, true, true);
+            out.push_str("TICK\n");
+        }
+        // Round 7: measure the Z checks; the X checks take their last CNOT.
+        line(&mut out, "M", noise, &zc);
+        let z_records: Vec<usize> = (measured..measured + h).collect();
+        measured += h;
+        idle_cnots(&mut out, 6, true, false);
+        out.push_str("TICK\n");
+        // Round 8: data idle; measure the X checks; prepare the Z checks.
+        if let Some(p) = noise {
+            line(&mut out, "DEPOLARIZE1", Some(p), &data);
+        }
+        line(&mut out, "MX", noise, &xc);
+        let x_records: Vec<usize> = (measured..measured + h).collect();
+        measured += h;
+        line(&mut out, "R", None, &zc);
+        if let Some(p) = noise {
+            line(&mut out, "X_ERROR", Some(p), &zc);
+        }
+        out.push_str("TICK\n");
+        let current = match basis {
+            Basis::Z => z_records,
+            Basis::X => x_records,
+        };
+        for (i, &r) in current.iter().enumerate() {
+            match &previous {
+                None => out.push_str(&format!("DETECTOR rec[-{}]\n", measured - r)),
+                Some(prev) => out.push_str(&format!("DETECTOR rec[-{}] rec[-{}]\n", measured - r, measured - prev[i])),
+            }
+        }
+        previous = Some(current);
+    }
+    match basis {
+        Basis::Z => line(&mut out, "M", None, &data),
+        Basis::X => line(&mut out, "MX", None, &data),
+    }
+    let first = measured;
+    measured += data.len();
+    for (k, op) in code.logicals(basis).iter().enumerate() {
+        out.push_str(&format!("OBSERVABLE_INCLUDE({k})"));
+        for &q in op {
+            out.push_str(&format!(" rec[-{}]", measured - (first + q)));
+        }
+        out.push('\n');
+    }
+    out
+}
+
+// ---------------------------------------------------------------------------
+// BP-OSD
+// ---------------------------------------------------------------------------
+
+/// How belief propagation scales its min-sum messages.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Scaling {
+    /// `α = 1 − 2^(−t)` at iteration `t`.
+    Adaptive,
+    Fixed(f64),
+}
+
+/// Decoder settings. The default is the source's: min-sum, adaptive scaling,
+/// up to 10,000 iterations, combination sweep of order 7.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BpOsdConfig {
+    pub max_iter: u32,
+    pub scaling: Scaling,
+    /// Order of the combination sweep; 0 is OSD-0 alone.
+    pub osd_order: u32,
+}
+
+impl Default for BpOsdConfig {
+    fn default() -> BpOsdConfig {
+        BpOsdConfig { max_iter: 10_000, scaling: Scaling::Adaptive, osd_order: 7 }
+    }
+}
+
+/// A decode: the observables the correction flips, and how it was found.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Decoded {
+    pub observables: u64,
+    /// Whether belief propagation alone explained the syndrome.
+    pub converged: bool,
+    pub iterations: u32,
+}
+
+/// Belief propagation with ordered-statistics post-processing over a
+/// detector error model.
+#[derive(Clone, Debug)]
+pub struct BpOsd {
+    cfg: BpOsdConfig,
+    checks: usize,
+    vars: usize,
+    /// Edges by check: `(var)`, CSR.
+    row_start: Vec<usize>,
+    row_var: Vec<usize>,
+    /// Edges by variable: indices into the check-ordered edge list, CSR.
+    col_start: Vec<usize>,
+    col_edge: Vec<usize>,
+    prior: Vec<f64>,
+    /// `ln(1/p)`, the OSD cost of each fault.
+    cost: Vec<f64>,
+    observables: Vec<u64>,
+    rank: usize,
+}
+
+impl BpOsd {
+    /// Build the decoder for `model`. Faults with probability 0 are dropped.
+    pub fn new(model: &ErrorModel, cfg: BpOsdConfig) -> BpOsd {
+        let mechs: Vec<_> = model.mechanisms.iter().filter(|m| m.probability > 0.0 && !m.detectors.is_empty()).collect();
+        let checks = model.detectors as usize;
+        let vars = mechs.len();
+        let mut by_row: Vec<Vec<usize>> = vec![Vec::new(); checks];
+        for (j, m) in mechs.iter().enumerate() {
+            for &d in &m.detectors {
+                by_row[d as usize].push(j);
+            }
+        }
+        let mut row_start = vec![0];
+        let mut row_var: Vec<usize> = Vec::new();
+        for r in &by_row {
+            row_var.extend(r);
+            row_start.push(row_var.len());
+        }
+        let mut by_col: Vec<Vec<usize>> = vec![Vec::new(); vars];
+        for (e, &j) in row_var.iter().enumerate() {
+            by_col[j].push(e);
+        }
+        let mut col_start = vec![0];
+        let mut col_edge: Vec<usize> = Vec::new();
+        for c in &by_col {
+            col_edge.extend(c);
+            col_start.push(col_edge.len());
+        }
+        let prior: Vec<f64> = mechs.iter().map(|m| ln((1.0 - m.probability) / m.probability)).collect();
+        let cost: Vec<f64> = mechs.iter().map(|m| ln(1.0 / m.probability)).collect();
+        let observables = mechs.iter().map(|m| m.observables).collect();
+        let mut span = Span::new(vars);
+        // Rank of H: row-reduce the checks over the faults.
+        for r in &by_row {
+            span.insert(&bits(vars, r.iter().copied()));
+        }
+        let rank = span.rank();
+        BpOsd { cfg, checks, vars, row_start, row_var, col_start, col_edge, prior, cost, observables, rank }
+    }
+
+    /// Faults (columns) in the model the decoder uses.
+    pub fn faults(&self) -> usize {
+        self.vars
+    }
+
+    /// Decode the detectors that fired.
+    pub fn decode(&self, fired: &[u32]) -> Decoded {
+        let mut synd = vec![false; self.checks];
+        for &d in fired {
+            synd[d as usize] = true;
+        }
+        let edges = self.row_var.len();
+        let mut v2c = vec![0.0f64; edges];
+        let mut c2v = vec![0.0f64; edges];
+        let mut sgn = vec![0u32; edges];
+        let mut post = vec![0.0f64; self.vars];
+        let mut hard = vec![false; self.vars];
+        for j in 0..self.vars {
+            for &e in &self.col_edge[self.col_start[j]..self.col_start[j + 1]] {
+                v2c[e] = self.prior[j];
+            }
+        }
+        let mut iterations = 0;
+        for t in 1..=self.cfg.max_iter {
+            iterations = t;
+            let alpha = match self.cfg.scaling {
+                Scaling::Adaptive => 1.0 - pow2_neg(t),
+                Scaling::Fixed(a) => a,
+            };
+            // Check to variable: the smallest other magnitude, the parity of
+            // the other signs and the syndrome; zero counts as negative.
+            for (i, &fired) in synd.iter().enumerate() {
+                let (s, e_end) = (self.row_start[i], self.row_start[i + 1]);
+                let mut min = 1e308f64;
+                let mut negatives = u32::from(fired);
+                for e in s..e_end {
+                    c2v[e] = min;
+                    sgn[e] = negatives;
+                    if v2c[e].abs() < min {
+                        min = v2c[e].abs();
+                    }
+                    if v2c[e] <= 0.0 {
+                        negatives += 1;
+                    }
+                }
+                let (mut min, mut negatives) = (1e308f64, 0u32);
+                for e in (s..e_end).rev() {
+                    if min < c2v[e] {
+                        c2v[e] = min;
+                    }
+                    sgn[e] += negatives;
+                    c2v[e] *= if sgn[e] % 2 == 1 { -alpha } else { alpha };
+                    if v2c[e].abs() < min {
+                        min = v2c[e].abs();
+                    }
+                    if v2c[e] <= 0.0 {
+                        negatives += 1;
+                    }
+                }
+            }
+            // Variable to check: the prior plus every other incoming message,
+            // summed forward then backward.
+            for j in 0..self.vars {
+                let col = &self.col_edge[self.col_start[j]..self.col_start[j + 1]];
+                let mut acc = self.prior[j];
+                for &e in col {
+                    v2c[e] = acc;
+                    acc += c2v[e];
+                }
+                post[j] = acc;
+                hard[j] = acc <= 0.0;
+                let mut acc = 0.0;
+                for &e in col.iter().rev() {
+                    v2c[e] += acc;
+                    acc += c2v[e];
+                }
+            }
+            if self.explains(&hard, &synd) {
+                return Decoded { observables: self.flips(&hard), converged: true, iterations };
+            }
+        }
+        let x = self.osd(&post, &synd);
+        Decoded { observables: self.flips(&x), converged: false, iterations }
+    }
+
+    fn explains(&self, x: &[bool], synd: &[bool]) -> bool {
+        (0..self.checks).all(|i| {
+            let parity = self.row_var[self.row_start[i]..self.row_start[i + 1]].iter().filter(|&&j| x[j]).count() % 2 == 1;
+            parity == synd[i]
+        })
+    }
+
+    fn flips(&self, x: &[bool]) -> u64 {
+        x.iter().zip(&self.observables).filter(|(b, _)| **b).fold(0, |m, (_, o)| m ^ o)
+    }
+
+    /// Ordered-statistics decoding: rank faults by posterior (likeliest
+    /// first), take the first independent columns as the information set, and
+    /// solve; then sweep single flips of every other column and pairs among
+    /// the first `osd_order`, keeping the cheapest solution.
+    fn osd(&self, post: &[f64], synd: &[bool]) -> Vec<bool> {
+        let mut order: Vec<usize> = (0..self.vars).collect();
+        order.sort_by(|&a, &b| post[a].total_cmp(&post[b]).then(a.cmp(&b)));
+        // Row-major matrix over the sorted columns, the syndrome appended.
+        let cols = self.vars + 1;
+        let words = cols.div_ceil(64);
+        let mut m = vec![0u64; self.checks * words];
+        let mut position = vec![0usize; self.vars];
+        for (p, &j) in order.iter().enumerate() {
+            position[j] = p;
+        }
+        for i in 0..self.checks {
+            for &j in &self.row_var[self.row_start[i]..self.row_start[i + 1]] {
+                let p = position[j];
+                m[i * words + p / 64] ^= 1 << (p % 64);
+            }
+            if synd[i] {
+                let p = self.vars;
+                m[i * words + p / 64] ^= 1 << (p % 64);
+            }
+        }
+        // Reduced echelon form, pivots in sorted order.
+        let mut pivots: Vec<usize> = Vec::with_capacity(self.rank);
+        let mut row = 0;
+        for p in 0..self.vars {
+            if row == self.checks || pivots.len() == self.rank {
+                break;
+            }
+            let (w, b) = (p / 64, p % 64);
+            let Some(r) = (row..self.checks).find(|&r| (m[r * words + w] >> b) & 1 == 1) else { continue };
+            if r != row {
+                for k in 0..words {
+                    m.swap(r * words + k, row * words + k);
+                }
+            }
+            let (head, tail) = m.split_at_mut(row * words);
+            let (pivot, rest) = tail.split_at_mut(words);
+            for other in head.chunks_exact_mut(words).chain(rest.chunks_exact_mut(words)) {
+                // Whole rows: the free columns before `p` are read later.
+                if (other[w] >> b) & 1 == 1 {
+                    for (a, c) in other.iter_mut().zip(pivot.iter()) {
+                        *a ^= c;
+                    }
+                }
+            }
+            pivots.push(p);
+            row += 1;
+        }
+        let bit = |r: usize, p: usize| (m[r * words + p / 64] >> (p % 64)) & 1 == 1;
+        let s = self.vars;
+        // OSD-0: the pivots take the reduced syndrome; everything else is 0.
+        let mut base = vec![false; self.vars];
+        for (r, &p) in pivots.iter().enumerate() {
+            base[p] = bit(r, s);
+        }
+        let cost_at = |p: usize| self.cost[order[p]];
+        let base_cost: f64 = (0..self.vars).filter(|&p| base[p]).map(cost_at).sum();
+        let mut best = (base_cost, Vec::new());
+        if self.cfg.osd_order > 0 {
+            let mut is_pivot = vec![false; self.vars];
+            for &p in &pivots {
+                is_pivot[p] = true;
+            }
+            let free: Vec<usize> = (0..self.vars).filter(|&p| !is_pivot[p]).collect();
+            // The change in cost from flipping a set of free columns.
+            let delta = |set: &[usize]| {
+                let mut d: f64 = set.iter().map(|&p| cost_at(p)).sum();
+                for (r, &pv) in pivots.iter().enumerate() {
+                    let flip = set.iter().fold(false, |a, &p| a ^ bit(r, p));
+                    if flip {
+                        d += if base[pv] { -cost_at(pv) } else { cost_at(pv) };
+                    }
+                }
+                d
+            };
+            let order_k = (self.cfg.osd_order as usize).min(free.len());
+            let mut candidates: Vec<Vec<usize>> = free.iter().map(|&p| vec![p]).collect();
+            for i in 0..order_k {
+                for j in i + 1..order_k {
+                    candidates.push(vec![free[i], free[j]]);
+                }
+            }
+            for set in candidates {
+                let c = base_cost + delta(&set);
+                if c < best.0 {
+                    best = (c, set);
+                }
+            }
+        }
+        let mut x = base;
+        for &p in &best.1 {
+            x[p] = true;
+            for (r, &pv) in pivots.iter().enumerate() {
+                if bit(r, p) {
+                    x[pv] = !x[pv];
+                }
+            }
+        }
+        let mut out = vec![false; self.vars];
+        for (p, &j) in order.iter().enumerate() {
+            out[j] = x[p];
+        }
+        out
+    }
+}
+
+fn pow2_neg(t: u32) -> f64 {
+    if t >= 1075 {
+        return 0.0;
+    }
+    let mut x = 1.0;
+    for _ in 0..t {
+        x /= 2.0;
+    }
+    x
+}
+
+// ---------------------------------------------------------------------------
+// Memory experiments
+// ---------------------------------------------------------------------------
+
+/// A memory experiment's tally.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LdpcPoint {
+    pub p: f64,
+    pub cycles: u32,
+    pub shots: u64,
+    /// Shots whose decoded observables were wrong (any logical flipped).
+    pub failures: u64,
+    /// Shots belief propagation alone decoded.
+    pub converged: u64,
+}
+
+impl LdpcPoint {
+    /// Failure rate per shot.
+    pub fn per_shot(&self) -> f64 {
+        self.failures as f64 / self.shots as f64
+    }
+    /// Failure rate per syndrome cycle, `1 − (1 − P)^(1/N)`.
+    pub fn per_cycle(&self) -> f64 {
+        1.0 - crate::repro::exp(ln(1.0 - self.per_shot()) / f64::from(self.cycles))
+    }
+}
+
+/// Shots per independently seeded chunk: results do not depend on how many
+/// threads ran them.
+const CHUNK: usize = 64;
+
+/// Run `shots` shots of the memory experiment in `basis` and decode each.
+/// Chunk `c` is sampled with seed `seed + c`. The tally is the same at any
+/// `threads` (one on wasm32, which has none).
+#[allow(clippy::too_many_arguments)]
+pub fn memory_experiment(code: &BbCode, cycles: u32, p: f64, basis: Basis, shots: usize, seed: u64, cfg: BpOsdConfig, threads: usize) -> Result<LdpcPoint, FrameError> {
+    let circuit = parse(&memory_circuit(code, cycles, p, basis))?;
+    let model = error_model(&circuit)?;
+    let decoder = BpOsd::new(&model, cfg);
+    let chunks = shots.div_ceil(CHUNK);
+    let run = |c: usize| {
+        let n = CHUNK.min(shots - c * CHUNK);
+        let det = sample(&circuit, n, seed.wrapping_add(c as u64));
+        let (mut fail, mut conv) = (0u64, 0u64);
+        for s in 0..n {
+            let d = decoder.decode(&det.fired(s));
+            fail += u64::from(d.observables != det.flips(s));
+            conv += u64::from(d.converged);
+        }
+        (fail, conv)
+    };
+    // wasm32 has no threads; the tally is the same either way.
+    let threads = if cfg!(target_arch = "wasm32") { 1 } else { threads.max(1).min(chunks.max(1)) };
+    let mut tallies = vec![(0u64, 0u64); chunks];
+    if threads == 1 {
+        for (c, t) in tallies.iter_mut().enumerate() {
+            *t = run(c);
+        }
+    } else {
+        let next = std::sync::atomic::AtomicUsize::new(0);
+        let results = std::sync::Mutex::new(&mut tallies);
+        std::thread::scope(|scope| {
+            for _ in 0..threads {
+                scope.spawn(|| loop {
+                    let c = next.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    if c >= chunks {
+                        break;
+                    }
+                    let r = run(c);
+                    results.lock().unwrap()[c] = r;
+                });
+            }
+        });
+    }
+    let (failures, converged) = tallies.iter().fold((0, 0), |(f, c), t| (f + t.0, c + t.1));
+    Ok(LdpcPoint { p, cycles, shots: shots as u64, failures, converged })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_presets_have_their_published_parameters() {
+        for (code, n, k) in [(BbCode::bb72(), 72, 12), (BbCode::bb90(), 90, 8), (BbCode::bb108(), 108, 8), (BbCode::bb144(), 144, 12), (BbCode::bb288(), 288, 12)] {
+            assert!(code.is_valid());
+            assert_eq!((code.n(), code.k()), (n, k));
+            for basis in [Basis::X, Basis::Z] {
+                assert_eq!(code.logicals(basis).len(), k);
+            }
+        }
+    }
+
+    #[test]
+    fn logical_operators_commute_with_checks_and_pair_up() {
+        let code = BbCode::bb72();
+        let (lx, lz) = (code.logicals(Basis::X), code.logicals(Basis::Z));
+        let overlap = |a: &[usize], b: &[usize]| a.iter().filter(|q| b.contains(q)).count() % 2;
+        for z in &lz {
+            assert!(code.hx().iter().all(|c| overlap(c, z) == 0));
+        }
+        for x in &lx {
+            assert!(code.hz().iter().all(|c| overlap(c, x) == 0));
+        }
+        // The pairing matrix between the two bases is invertible.
+        let mut span = Span::new(lz.len());
+        for x in &lx {
+            span.insert(&bits(lz.len(), lz.iter().enumerate().filter(|(_, z)| overlap(x, z) == 1).map(|(i, _)| i)));
+        }
+        assert_eq!(span.rank(), lz.len());
+    }
+
+    #[test]
+    fn the_noiseless_cycle_is_deterministic_and_silent() {
+        for basis in [Basis::Z, Basis::X] {
+            let c = parse(&memory_circuit(&BbCode::bb72(), 3, 0.0, basis)).unwrap();
+            let model = error_model(&c).unwrap();
+            assert!(model.mechanisms.iter().all(|m| m.probability == 0.0) || model.mechanisms.is_empty());
+            let det = sample(&c, 64, 1);
+            assert!((0..64).all(|s| det.fired(s).is_empty() && det.flips(s) == 0));
+        }
+    }
+
+    #[test]
+    fn the_error_model_has_the_reference_columns() {
+        // The source's decoding matrices for [[72,12,6]], six cycles, p = 0.003.
+        let reference = include_str!("../tests/data/bb72_p003_c6.dem");
+        type Column = (f64, Vec<u32>);
+        let mut sections: Vec<(char, Vec<Column>)> = Vec::new();
+        for l in reference.lines() {
+            if let Some(h) = l.strip_prefix("# ") {
+                sections.push((h.chars().next().unwrap(), Vec::new()));
+                continue;
+            }
+            let mut f = l.split_whitespace();
+            let p: f64 = f.next().unwrap().parse().unwrap();
+            let rows: Vec<u32> = f.map(|x| x.parse().unwrap()).collect();
+            // Its matrix drops the logical rows, so columns that differ only
+            // there repeat; their faults add.
+            let cols = &mut sections.last_mut().unwrap().1;
+            match cols.iter_mut().find(|(_, r)| *r == rows) {
+                Some((q, _)) => *q += p,
+                None => cols.push((p, rows)),
+            }
+        }
+        for (kind, columns) in sections {
+            // X faults are seen by Z checks: the Z-basis memory.
+            let basis = if kind == 'X' { Basis::Z } else { Basis::X };
+            let c = parse(&memory_circuit(&BbCode::bb72(), 6, 0.003, basis)).unwrap();
+            let model = error_model(&c).unwrap();
+            let mut ours: Vec<(Vec<u32>, f64)> = Vec::new();
+            for m in model.mechanisms.iter().filter(|m| !m.detectors.is_empty()) {
+                match ours.iter_mut().find(|(d, _)| *d == m.detectors) {
+                    // The same detectors with different observables: the
+                    // source keeps logical rows out of its decoding matrix.
+                    Some((_, q)) => *q = *q + m.probability - 2.0 * *q * m.probability,
+                    None => ours.push((m.detectors.clone(), m.probability)),
+                }
+            }
+            // The source keeps one column of faults that light nothing (its
+            // probabilities summed); here they leave the model. None of them
+            // flips a logical.
+            let columns: Vec<_> = columns.into_iter().filter(|(_, rows)| !rows.is_empty()).collect();
+            assert!(model.mechanisms.iter().all(|m| !m.detectors.is_empty() || m.observables == 0));
+            assert_eq!(ours.len(), columns.len(), "{kind}");
+            for (p, rows) in &columns {
+                let (_, q) = ours.iter().find(|(d, _)| d == rows).unwrap_or_else(|| panic!("{kind}: no column {rows:?}"));
+                assert!((q / p - 1.0).abs() < 0.01, "{kind} {rows:?}: {q} vs {p}");
+            }
+        }
+    }
+
+    #[test]
+    fn bp_osd_corrects_every_single_fault() {
+        let c = parse(&memory_circuit(&BbCode::bb72(), 2, 0.003, Basis::Z)).unwrap();
+        let model = error_model(&c).unwrap();
+        let dec = BpOsd::new(&model, BpOsdConfig::default());
+        for m in model.mechanisms.iter().filter(|m| !m.detectors.is_empty()) {
+            assert_eq!(dec.decode(&m.detectors).observables, m.observables, "{:?}", m.detectors);
+        }
+    }
+
+    #[test]
+    fn the_tally_does_not_depend_on_threads() {
+        let cfg = BpOsdConfig { max_iter: 50, ..BpOsdConfig::default() };
+        let a = memory_experiment(&BbCode::bb72(), 2, 0.004, Basis::Z, 600, 9, cfg, 1).unwrap();
+        let b = memory_experiment(&BbCode::bb72(), 2, 0.004, Basis::Z, 600, 9, cfg, 3).unwrap();
+        assert_eq!(a, b);
+        assert!(a.failures > 0 && a.converged > 0);
+    }
+}
diff --git a/wai/wai-quantum/tests/bit_identity.rs b/wai/wai-quantum/tests/bit_identity.rs
index 5f2f4064a..3bac232a3 100644
--- a/wai/wai-quantum/tests/bit_identity.rs
+++ b/wai/wai-quantum/tests/bit_identity.rs
@@ -20,7 +20,8 @@
     feature = "quantum_tn",
     feature = "quantum_gbs",
     feature = "quantum_sv",
-    feature = "quantum_arch"
+    feature = "quantum_arch",
+    feature = "quantum_ldpc"
 ))]
 
 use wai_quantum::*;
@@ -339,3 +340,27 @@ fn architecture_estimates() {
     }
     assert_eq!(digest(&v), 0xd166_b4c6_c731_7a52);
 }
+
+/// A bivariate-bicycle memory: the circuit's error model (probabilities from
+/// the independent-channel conversion), BP over it with in-crate logarithms,
+/// and OSD on the shots BP leaves unexplained.
+#[test]
+fn qldpc_memory_decoding() {
+    use quantum_frame::{error_model, parse, sample, Basis};
+    use quantum_ldpc::*;
+    let c = parse(&memory_circuit(&BbCode::bb72(), 3, 0.005, Basis::Z)).unwrap();
+    let model = error_model(&c).unwrap();
+    let dec = BpOsd::new(&model, BpOsdConfig { max_iter: 40, ..BpOsdConfig::default() });
+    let det = sample(&c, 192, 11);
+    let mut v: Vec<f64> = model.mechanisms.iter().step_by(37).map(|m| m.probability).collect();
+    let mut osd = 0;
+    for s in 0..192 {
+        let d = dec.decode(&det.fired(s));
+        osd += u32::from(!d.converged);
+        v.push(d.observables as f64);
+        v.push(f64::from(d.iterations));
+        v.push(det.flips(s) as f64);
+    }
+    assert!(osd > 0, "the sample must exercise OSD");
+    assert_eq!(digest(&v), 0x5479_ebe5_f648_b739);
+}
diff --git a/wai/wai-quantum/tests/data/bb72_p003_c6.dem b/wai/wai-quantum/tests/data/bb72_p003_c6.dem
new file mode 100644
index 000000000..872f655f9
--- /dev/null
+++ b/wai/wai-quantum/tests/data/bb72_p003_c6.dem
@@ -0,0 +1,4504 @@
+# X 288 2269
+0.0016 19 20 36
+0.0078000000000000005 0 36
+0.0008 0 19 20
+0.0016 20 21 37
+0.0078000000000000005 1 37
+0.0008 1 20 21
+0.0016 21 22 38
+0.0078000000000000005 2 38
+0.0008 2 21 22
+0.0016 22 23 39
+0.0078000000000000005 3 39
+0.0008 3 22 23
+0.0016 18 23 40
+0.0078000000000000005 4 40
+0.0008 4 18 23
+0.0016 18 19 41
+0.0078000000000000005 5 41
+0.0008 5 18 19
+0.0016 25 26 42
+0.0078000000000000005 6 42
+0.0008 6 25 26
+0.0016 26 27 43
+0.0078000000000000005 7 43
+0.0008 7 26 27
+0.0016 27 28 44
+0.0078000000000000005 8 44
+0.0008 8 27 28
+0.0016 28 29 45
+0.0078000000000000005 9 45
+0.0008 9 28 29
+0.0016 24 29 46
+0.0078000000000000005 10 46
+0.0008 10 24 29
+0.0016 24 25 47
+0.0078000000000000005 11 47
+0.0008 11 24 25
+0.0016 31 32 48
+0.0078000000000000005 12 48
+0.0008 12 31 32
+0.0016 32 33 49
+0.0078000000000000005 13 49
+0.0008 13 32 33
+0.0016 33 34 50
+0.0078000000000000005 14 50
+0.0008 14 33 34
+0.0016 34 35 51
+0.0078000000000000005 15 51
+0.0008 15 34 35
+0.0016 30 35 52
+0.0078000000000000005 16 52
+0.0008 16 30 35
+0.0016 30 31 53
+0.0078000000000000005 17 53
+0.0008 17 30 31
+0.0016 1 2 54
+0.0078000000000000005 18 54
+0.0008 1 2 18
+0.0016 2 3 55
+0.0078000000000000005 19 55
+0.0008 2 3 19
+0.0016 3 4 56
+0.0078000000000000005 20 56
+0.0008 3 4 20
+0.0016 4 5 57
+0.0078000000000000005 21 57
+0.0008 4 5 21
+0.0016 0 5 58
+0.0078000000000000005 22 58
+0.0008 0 5 22
+0.0016 0 1 59
+0.0078000000000000005 23 59
+0.0008 0 1 23
+0.0016 7 8 60
+0.0078000000000000005 24 60
+0.0008 7 8 24
+0.0016 8 9 61
+0.0078000000000000005 25 61
+0.0008 8 9 25
+0.0016 9 10 62
+0.0078000000000000005 26 62
+0.0008 9 10 26
+0.0016 10 11 63
+0.0078000000000000005 27 63
+0.0008 10 11 27
+0.0016 6 11 64
+0.0078000000000000005 28 64
+0.0008 6 11 28
+0.0016 6 7 65
+0.0078000000000000005 29 65
+0.0008 6 7 29
+0.0016 13 14 66
+0.0078000000000000005 30 66
+0.0008 13 14 30
+0.0016 14 15 67
+0.0078000000000000005 31 67
+0.0008 14 15 31
+0.0016 15 16 68
+0.0078000000000000005 32 68
+0.0008 15 16 32
+0.0016 16 17 69
+0.0078000000000000005 33 69
+0.0008 16 17 33
+0.0016 12 17 70
+0.0078000000000000005 34 70
+0.0008 12 17 34
+0.0016 12 13 71
+0.0078000000000000005 35 71
+0.0008 12 13 35
+0.005200000000000001 3 6 12
+0.005200000000000001 4 7 13
+0.005200000000000001 5 8 14
+0.005200000000000001 0 9 15
+0.005200000000000001 1 10 16
+0.005200000000000001 2 11 17
+0.005200000000000001 9 12 18
+0.005200000000000001 10 13 19
+0.005200000000000001 11 14 20
+0.005200000000000001 6 15 21
+0.005200000000000001 7 16 22
+0.005200000000000001 8 17 23
+0.005200000000000001 15 18 24
+0.005200000000000001 16 19 25
+0.005200000000000001 17 20 26
+0.005200000000000001 12 21 27
+0.005200000000000001 13 22 28
+0.005200000000000001 14 23 29
+0.005200000000000001 21 24 30
+0.005200000000000001 22 25 31
+0.005200000000000001 23 26 32
+0.005200000000000001 18 27 33
+0.005200000000000001 19 28 34
+0.005200000000000001 20 29 35
+0.005200000000000001 0 27 30
+0.005200000000000001 1 28 31
+0.005200000000000001 2 29 32
+0.005200000000000001 3 24 33
+0.005200000000000001 4 25 34
+0.005200000000000001 5 26 35
+0.005200000000000001 0 6 33
+0.005200000000000001 1 7 34
+0.005200000000000001 2 8 35
+0.005200000000000001 3 9 30
+0.005200000000000001 4 10 31
+0.005200000000000001 5 11 32
+0.34560000000000013 
+0.004 5 36 58
+0.004 0 37 59
+0.004 1 38 54
+0.004 2 39 55
+0.004 3 40 56
+0.004 4 41 57
+0.004 11 42 64
+0.004 6 43 65
+0.004 7 44 60
+0.004 8 45 61
+0.004 9 46 62
+0.004 10 47 63
+0.004 17 48 70
+0.004 12 49 71
+0.004 13 50 66
+0.004 14 51 67
+0.004 15 52 68
+0.004 16 53 69
+0.004 23 40 54
+0.004 18 41 55
+0.004 19 36 56
+0.004 20 37 57
+0.004 21 38 58
+0.004 22 39 59
+0.004 29 46 60
+0.004 24 47 61
+0.004 25 42 62
+0.004 26 43 63
+0.004 27 44 64
+0.004 28 45 65
+0.004 35 52 66
+0.004 30 53 67
+0.004 31 48 68
+0.004 32 49 69
+0.004 33 50 70
+0.004 34 51 71
+0.0016 4 13 44 60
+0.0016 5 14 45 61
+0.0016 0 15 46 62
+0.0016 1 16 47 63
+0.0016 2 17 42 64
+0.0016 3 12 43 65
+0.0016 10 19 50 66
+0.0016 11 20 51 67
+0.0016 6 21 52 68
+0.0016 7 22 53 69
+0.0016 8 23 48 70
+0.0016 9 18 49 71
+0.0016 16 25 36 56
+0.0016 17 26 37 57
+0.0016 12 27 38 58
+0.0016 13 28 39 59
+0.0016 14 29 40 54
+0.0016 15 24 41 55
+0.0016 22 31 42 62
+0.0016 23 32 43 63
+0.0016 18 33 44 64
+0.0016 19 34 45 65
+0.0016 20 35 46 60
+0.0016 21 30 47 61
+0.0016 1 28 48 68
+0.0016 2 29 49 69
+0.0016 3 24 50 70
+0.0016 4 25 51 71
+0.0016 5 26 52 66
+0.0016 0 27 53 67
+0.0016 7 34 38 54
+0.0016 8 35 39 55
+0.0016 9 30 40 56
+0.0016 10 31 41 57
+0.0016 11 32 36 58
+0.0016 6 33 37 59
+0.0016 9 15 36
+0.0016 10 16 37
+0.0016 11 17 38
+0.0016 6 12 39
+0.0016 7 13 40
+0.0016 8 14 41
+0.0016 15 21 42
+0.0016 16 22 43
+0.0016 17 23 44
+0.0016 12 18 45
+0.0016 13 19 46
+0.0016 14 20 47
+0.0016 21 27 48
+0.0016 22 28 49
+0.0016 23 29 50
+0.0016 18 24 51
+0.0016 19 25 52
+0.0016 20 26 53
+0.0016 27 33 54
+0.0016 28 34 55
+0.0016 29 35 56
+0.0016 24 30 57
+0.0016 25 31 58
+0.0016 26 32 59
+0.0016 3 33 60
+0.0016 4 34 61
+0.0016 5 35 62
+0.0016 0 30 63
+0.0016 1 31 64
+0.0016 2 32 65
+0.0016 3 9 66
+0.0016 4 10 67
+0.0016 5 11 68
+0.0016 0 6 69
+0.0016 1 7 70
+0.0016 2 8 71
+0.0016 13 41 44 57 60
+0.0016 14 36 45 58 61
+0.0016 15 37 46 59 62
+0.0016 16 38 47 54 63
+0.0016 17 39 42 55 64
+0.0016 12 40 43 56 65
+0.0016 19 47 50 63 66
+0.0016 20 42 51 64 67
+0.0016 21 43 52 65 68
+0.0016 22 44 53 60 69
+0.0016 23 45 48 61 70
+0.0016 18 46 49 62 71
+0.0016 25 36 53 56 69
+0.0016 26 37 48 57 70
+0.0016 27 38 49 58 71
+0.0016 28 39 50 59 66
+0.0016 29 40 51 54 67
+0.0016 24 41 52 55 68
+0.0016 31 39 42 59 62
+0.0016 32 40 43 54 63
+0.0016 33 41 44 55 64
+0.0016 34 36 45 56 65
+0.0016 35 37 46 57 60
+0.0016 30 38 47 58 61
+0.0016 1 45 48 65 68
+0.0016 2 46 49 60 69
+0.0016 3 47 50 61 70
+0.0016 4 42 51 62 71
+0.0016 5 43 52 63 66
+0.0016 0 44 53 64 67
+0.0016 7 38 51 54 71
+0.0016 8 39 52 55 66
+0.0016 9 40 53 56 67
+0.0016 10 41 48 57 68
+0.0016 11 36 49 58 69
+0.0016 6 37 50 59 70
+0.0016 6 36 69
+0.0016 7 37 70
+0.0016 8 38 71
+0.0016 9 39 66
+0.0016 10 40 67
+0.0016 11 41 68
+0.0016 12 39 42
+0.0016 13 40 43
+0.0016 14 41 44
+0.0016 15 36 45
+0.0016 16 37 46
+0.0016 17 38 47
+0.0016 18 45 48
+0.0016 19 46 49
+0.0016 20 47 50
+0.0016 21 42 51
+0.0016 22 43 52
+0.0016 23 44 53
+0.0016 24 51 54
+0.0016 25 52 55
+0.0016 26 53 56
+0.0016 27 48 57
+0.0016 28 49 58
+0.0016 29 50 59
+0.0016 30 57 60
+0.0016 31 58 61
+0.0016 32 59 62
+0.0016 33 54 63
+0.0016 34 55 64
+0.0016 35 56 65
+0.0016 0 63 66
+0.0016 1 64 67
+0.0016 2 65 68
+0.0016 3 60 69
+0.0016 4 61 70
+0.0016 5 62 71
+0.0016 41 44 50 57 60 66
+0.0016 36 45 51 58 61 67
+0.0016 37 46 52 59 62 68
+0.0016 38 47 53 54 63 69
+0.0016 39 42 48 55 64 70
+0.0016 40 43 49 56 65 71
+0.0016 36 47 50 56 63 66
+0.0016 37 42 51 57 64 67
+0.0016 38 43 52 58 65 68
+0.0016 39 44 53 59 60 69
+0.0016 40 45 48 54 61 70
+0.0016 41 46 49 55 62 71
+0.0016 36 42 53 56 62 69
+0.0016 37 43 48 57 63 70
+0.0016 38 44 49 58 64 71
+0.0016 39 45 50 59 65 66
+0.0016 40 46 51 54 60 67
+0.0016 41 47 52 55 61 68
+0.0016 39 42 48 59 62 68
+0.0016 40 43 49 54 63 69
+0.0016 41 44 50 55 64 70
+0.0016 36 45 51 56 65 71
+0.0016 37 46 52 57 60 66
+0.0016 38 47 53 58 61 67
+0.0016 38 45 48 54 65 68
+0.0016 39 46 49 55 60 69
+0.0016 40 47 50 56 61 70
+0.0016 41 42 51 57 62 71
+0.0016 36 43 52 58 63 66
+0.0016 37 44 53 59 64 67
+0.0016 38 44 51 54 60 71
+0.0016 39 45 52 55 61 66
+0.0016 40 46 53 56 62 67
+0.0016 41 47 48 57 63 68
+0.0016 36 42 49 58 64 69
+0.0016 37 43 50 59 65 70
+0.011200000000000002 36 63 66
+0.011200000000000002 37 64 67
+0.011200000000000002 38 65 68
+0.011200000000000002 39 60 69
+0.011200000000000002 40 61 70
+0.011200000000000002 41 62 71
+0.011200000000000002 36 42 69
+0.011200000000000002 37 43 70
+0.011200000000000002 38 44 71
+0.011200000000000002 39 45 66
+0.011200000000000002 40 46 67
+0.011200000000000002 41 47 68
+0.011200000000000002 39 42 48
+0.011200000000000002 40 43 49
+0.011200000000000002 41 44 50
+0.011200000000000002 36 45 51
+0.011200000000000002 37 46 52
+0.011200000000000002 38 47 53
+0.011200000000000002 45 48 54
+0.011200000000000002 46 49 55
+0.011200000000000002 47 50 56
+0.011200000000000002 42 51 57
+0.011200000000000002 43 52 58
+0.011200000000000002 44 53 59
+0.011200000000000002 51 54 60
+0.011200000000000002 52 55 61
+0.011200000000000002 53 56 62
+0.011200000000000002 48 57 63
+0.011200000000000002 49 58 64
+0.011200000000000002 50 59 65
+0.011200000000000002 57 60 66
+0.011200000000000002 58 61 67
+0.011200000000000002 59 62 68
+0.011200000000000002 54 63 69
+0.011200000000000002 55 64 70
+0.011200000000000002 56 65 71
+0.005600000000000001 36 37 59
+0.005600000000000001 37 38 54
+0.005600000000000001 38 39 55
+0.005600000000000001 39 40 56
+0.005600000000000001 40 41 57
+0.005600000000000001 36 41 58
+0.005600000000000001 42 43 65
+0.005600000000000001 43 44 60
+0.005600000000000001 44 45 61
+0.005600000000000001 45 46 62
+0.005600000000000001 46 47 63
+0.005600000000000001 42 47 64
+0.005600000000000001 48 49 71
+0.005600000000000001 49 50 66
+0.005600000000000001 50 51 67
+0.005600000000000001 51 52 68
+0.005600000000000001 52 53 69
+0.005600000000000001 48 53 70
+0.005600000000000001 41 54 55
+0.005600000000000001 36 55 56
+0.005600000000000001 37 56 57
+0.005600000000000001 38 57 58
+0.005600000000000001 39 58 59
+0.005600000000000001 40 54 59
+0.005600000000000001 47 60 61
+0.005600000000000001 42 61 62
+0.005600000000000001 43 62 63
+0.005600000000000001 44 63 64
+0.005600000000000001 45 64 65
+0.005600000000000001 46 60 65
+0.005600000000000001 53 66 67
+0.005600000000000001 48 67 68
+0.005600000000000001 49 68 69
+0.005600000000000001 50 69 70
+0.005600000000000001 51 70 71
+0.005600000000000001 52 66 71
+0.0108 36 72
+0.0108 37 73
+0.0108 38 74
+0.0108 39 75
+0.0108 40 76
+0.0108 41 77
+0.0108 42 78
+0.0108 43 79
+0.0108 44 80
+0.0108 45 81
+0.0108 46 82
+0.0108 47 83
+0.0108 48 84
+0.0108 49 85
+0.0108 50 86
+0.0108 51 87
+0.0108 52 88
+0.0108 53 89
+0.0108 54 90
+0.0108 55 91
+0.0108 56 92
+0.0108 57 93
+0.0108 58 94
+0.0108 59 95
+0.0108 60 96
+0.0108 61 97
+0.0108 62 98
+0.0108 63 99
+0.0108 64 100
+0.0108 65 101
+0.0108 66 102
+0.0108 67 103
+0.0108 68 104
+0.0108 69 105
+0.0108 70 106
+0.0108 71 107
+0.0016 55 56 72
+0.0016 56 57 73
+0.0016 57 58 74
+0.0016 58 59 75
+0.0016 54 59 76
+0.0016 54 55 77
+0.0016 61 62 78
+0.0016 62 63 79
+0.0016 63 64 80
+0.0016 64 65 81
+0.0016 60 65 82
+0.0016 60 61 83
+0.0016 67 68 84
+0.0016 68 69 85
+0.0016 69 70 86
+0.0016 70 71 87
+0.0016 66 71 88
+0.0016 66 67 89
+0.0016 37 38 90
+0.0016 38 39 91
+0.0016 39 40 92
+0.0016 40 41 93
+0.0016 36 41 94
+0.0016 36 37 95
+0.0016 43 44 96
+0.0016 44 45 97
+0.0016 45 46 98
+0.0016 46 47 99
+0.0016 42 47 100
+0.0016 42 43 101
+0.0016 49 50 102
+0.0016 50 51 103
+0.0016 51 52 104
+0.0016 52 53 105
+0.0016 48 53 106
+0.0016 48 49 107
+0.004 41 72 94
+0.004 36 73 95
+0.004 37 74 90
+0.004 38 75 91
+0.004 39 76 92
+0.004 40 77 93
+0.004 47 78 100
+0.004 42 79 101
+0.004 43 80 96
+0.004 44 81 97
+0.004 45 82 98
+0.004 46 83 99
+0.004 53 84 106
+0.004 48 85 107
+0.004 49 86 102
+0.004 50 87 103
+0.004 51 88 104
+0.004 52 89 105
+0.004 59 76 90
+0.004 54 77 91
+0.004 55 72 92
+0.004 56 73 93
+0.004 57 74 94
+0.004 58 75 95
+0.004 65 82 96
+0.004 60 83 97
+0.004 61 78 98
+0.004 62 79 99
+0.004 63 80 100
+0.004 64 81 101
+0.004 71 88 102
+0.004 66 89 103
+0.004 67 84 104
+0.004 68 85 105
+0.004 69 86 106
+0.004 70 87 107
+0.0016 40 49 80 96
+0.0016 41 50 81 97
+0.0016 36 51 82 98
+0.0016 37 52 83 99
+0.0016 38 53 78 100
+0.0016 39 48 79 101
+0.0016 46 55 86 102
+0.0016 47 56 87 103
+0.0016 42 57 88 104
+0.0016 43 58 89 105
+0.0016 44 59 84 106
+0.0016 45 54 85 107
+0.0016 52 61 72 92
+0.0016 53 62 73 93
+0.0016 48 63 74 94
+0.0016 49 64 75 95
+0.0016 50 65 76 90
+0.0016 51 60 77 91
+0.0016 58 67 78 98
+0.0016 59 68 79 99
+0.0016 54 69 80 100
+0.0016 55 70 81 101
+0.0016 56 71 82 96
+0.0016 57 66 83 97
+0.0016 37 64 84 104
+0.0016 38 65 85 105
+0.0016 39 60 86 106
+0.0016 40 61 87 107
+0.0016 41 62 88 102
+0.0016 36 63 89 103
+0.0016 43 70 74 90
+0.0016 44 71 75 91
+0.0016 45 66 76 92
+0.0016 46 67 77 93
+0.0016 47 68 72 94
+0.0016 42 69 73 95
+0.0016 45 51 72
+0.0016 46 52 73
+0.0016 47 53 74
+0.0016 42 48 75
+0.0016 43 49 76
+0.0016 44 50 77
+0.0016 51 57 78
+0.0016 52 58 79
+0.0016 53 59 80
+0.0016 48 54 81
+0.0016 49 55 82
+0.0016 50 56 83
+0.0016 57 63 84
+0.0016 58 64 85
+0.0016 59 65 86
+0.0016 54 60 87
+0.0016 55 61 88
+0.0016 56 62 89
+0.0016 63 69 90
+0.0016 64 70 91
+0.0016 65 71 92
+0.0016 60 66 93
+0.0016 61 67 94
+0.0016 62 68 95
+0.0016 39 69 96
+0.0016 40 70 97
+0.0016 41 71 98
+0.0016 36 66 99
+0.0016 37 67 100
+0.0016 38 68 101
+0.0016 39 45 102
+0.0016 40 46 103
+0.0016 41 47 104
+0.0016 36 42 105
+0.0016 37 43 106
+0.0016 38 44 107
+0.0016 49 77 80 93 96
+0.0016 50 72 81 94 97
+0.0016 51 73 82 95 98
+0.0016 52 74 83 90 99
+0.0016 53 75 78 91 100
+0.0016 48 76 79 92 101
+0.0016 55 83 86 99 102
+0.0016 56 78 87 100 103
+0.0016 57 79 88 101 104
+0.0016 58 80 89 96 105
+0.0016 59 81 84 97 106
+0.0016 54 82 85 98 107
+0.0016 61 72 89 92 105
+0.0016 62 73 84 93 106
+0.0016 63 74 85 94 107
+0.0016 64 75 86 95 102
+0.0016 65 76 87 90 103
+0.0016 60 77 88 91 104
+0.0016 67 75 78 95 98
+0.0016 68 76 79 90 99
+0.0016 69 77 80 91 100
+0.0016 70 72 81 92 101
+0.0016 71 73 82 93 96
+0.0016 66 74 83 94 97
+0.0016 37 81 84 101 104
+0.0016 38 82 85 96 105
+0.0016 39 83 86 97 106
+0.0016 40 78 87 98 107
+0.0016 41 79 88 99 102
+0.0016 36 80 89 100 103
+0.0016 43 74 87 90 107
+0.0016 44 75 88 91 102
+0.0016 45 76 89 92 103
+0.0016 46 77 84 93 104
+0.0016 47 72 85 94 105
+0.0016 42 73 86 95 106
+0.0016 42 72 105
+0.0016 43 73 106
+0.0016 44 74 107
+0.0016 45 75 102
+0.0016 46 76 103
+0.0016 47 77 104
+0.0016 48 75 78
+0.0016 49 76 79
+0.0016 50 77 80
+0.0016 51 72 81
+0.0016 52 73 82
+0.0016 53 74 83
+0.0016 54 81 84
+0.0016 55 82 85
+0.0016 56 83 86
+0.0016 57 78 87
+0.0016 58 79 88
+0.0016 59 80 89
+0.0016 60 87 90
+0.0016 61 88 91
+0.0016 62 89 92
+0.0016 63 84 93
+0.0016 64 85 94
+0.0016 65 86 95
+0.0016 66 93 96
+0.0016 67 94 97
+0.0016 68 95 98
+0.0016 69 90 99
+0.0016 70 91 100
+0.0016 71 92 101
+0.0016 36 99 102
+0.0016 37 100 103
+0.0016 38 101 104
+0.0016 39 96 105
+0.0016 40 97 106
+0.0016 41 98 107
+0.0016 77 80 86 93 96 102
+0.0016 72 81 87 94 97 103
+0.0016 73 82 88 95 98 104
+0.0016 74 83 89 90 99 105
+0.0016 75 78 84 91 100 106
+0.0016 76 79 85 92 101 107
+0.0016 72 83 86 92 99 102
+0.0016 73 78 87 93 100 103
+0.0016 74 79 88 94 101 104
+0.0016 75 80 89 95 96 105
+0.0016 76 81 84 90 97 106
+0.0016 77 82 85 91 98 107
+0.0016 72 78 89 92 98 105
+0.0016 73 79 84 93 99 106
+0.0016 74 80 85 94 100 107
+0.0016 75 81 86 95 101 102
+0.0016 76 82 87 90 96 103
+0.0016 77 83 88 91 97 104
+0.0016 75 78 84 95 98 104
+0.0016 76 79 85 90 99 105
+0.0016 77 80 86 91 100 106
+0.0016 72 81 87 92 101 107
+0.0016 73 82 88 93 96 102
+0.0016 74 83 89 94 97 103
+0.0016 74 81 84 90 101 104
+0.0016 75 82 85 91 96 105
+0.0016 76 83 86 92 97 106
+0.0016 77 78 87 93 98 107
+0.0016 72 79 88 94 99 102
+0.0016 73 80 89 95 100 103
+0.0016 74 80 87 90 96 107
+0.0016 75 81 88 91 97 102
+0.0016 76 82 89 92 98 103
+0.0016 77 83 84 93 99 104
+0.0016 72 78 85 94 100 105
+0.0016 73 79 86 95 101 106
+0.011200000000000002 72 99 102
+0.011200000000000002 73 100 103
+0.011200000000000002 74 101 104
+0.011200000000000002 75 96 105
+0.011200000000000002 76 97 106
+0.011200000000000002 77 98 107
+0.011200000000000002 72 78 105
+0.011200000000000002 73 79 106
+0.011200000000000002 74 80 107
+0.011200000000000002 75 81 102
+0.011200000000000002 76 82 103
+0.011200000000000002 77 83 104
+0.011200000000000002 75 78 84
+0.011200000000000002 76 79 85
+0.011200000000000002 77 80 86
+0.011200000000000002 72 81 87
+0.011200000000000002 73 82 88
+0.011200000000000002 74 83 89
+0.011200000000000002 81 84 90
+0.011200000000000002 82 85 91
+0.011200000000000002 83 86 92
+0.011200000000000002 78 87 93
+0.011200000000000002 79 88 94
+0.011200000000000002 80 89 95
+0.011200000000000002 87 90 96
+0.011200000000000002 88 91 97
+0.011200000000000002 89 92 98
+0.011200000000000002 84 93 99
+0.011200000000000002 85 94 100
+0.011200000000000002 86 95 101
+0.011200000000000002 93 96 102
+0.011200000000000002 94 97 103
+0.011200000000000002 95 98 104
+0.011200000000000002 90 99 105
+0.011200000000000002 91 100 106
+0.011200000000000002 92 101 107
+0.005600000000000001 72 73 95
+0.005600000000000001 73 74 90
+0.005600000000000001 74 75 91
+0.005600000000000001 75 76 92
+0.005600000000000001 76 77 93
+0.005600000000000001 72 77 94
+0.005600000000000001 78 79 101
+0.005600000000000001 79 80 96
+0.005600000000000001 80 81 97
+0.005600000000000001 81 82 98
+0.005600000000000001 82 83 99
+0.005600000000000001 78 83 100
+0.005600000000000001 84 85 107
+0.005600000000000001 85 86 102
+0.005600000000000001 86 87 103
+0.005600000000000001 87 88 104
+0.005600000000000001 88 89 105
+0.005600000000000001 84 89 106
+0.005600000000000001 77 90 91
+0.005600000000000001 72 91 92
+0.005600000000000001 73 92 93
+0.005600000000000001 74 93 94
+0.005600000000000001 75 94 95
+0.005600000000000001 76 90 95
+0.005600000000000001 83 96 97
+0.005600000000000001 78 97 98
+0.005600000000000001 79 98 99
+0.005600000000000001 80 99 100
+0.005600000000000001 81 100 101
+0.005600000000000001 82 96 101
+0.005600000000000001 89 102 103
+0.005600000000000001 84 103 104
+0.005600000000000001 85 104 105
+0.005600000000000001 86 105 106
+0.005600000000000001 87 106 107
+0.005600000000000001 88 102 107
+0.0108 72 108
+0.0108 73 109
+0.0108 74 110
+0.0108 75 111
+0.0108 76 112
+0.0108 77 113
+0.0108 78 114
+0.0108 79 115
+0.0108 80 116
+0.0108 81 117
+0.0108 82 118
+0.0108 83 119
+0.0108 84 120
+0.0108 85 121
+0.0108 86 122
+0.0108 87 123
+0.0108 88 124
+0.0108 89 125
+0.0108 90 126
+0.0108 91 127
+0.0108 92 128
+0.0108 93 129
+0.0108 94 130
+0.0108 95 131
+0.0108 96 132
+0.0108 97 133
+0.0108 98 134
+0.0108 99 135
+0.0108 100 136
+0.0108 101 137
+0.0108 102 138
+0.0108 103 139
+0.0108 104 140
+0.0108 105 141
+0.0108 106 142
+0.0108 107 143
+0.0016 91 92 108
+0.0016 92 93 109
+0.0016 93 94 110
+0.0016 94 95 111
+0.0016 90 95 112
+0.0016 90 91 113
+0.0016 97 98 114
+0.0016 98 99 115
+0.0016 99 100 116
+0.0016 100 101 117
+0.0016 96 101 118
+0.0016 96 97 119
+0.0016 103 104 120
+0.0016 104 105 121
+0.0016 105 106 122
+0.0016 106 107 123
+0.0016 102 107 124
+0.0016 102 103 125
+0.0016 73 74 126
+0.0016 74 75 127
+0.0016 75 76 128
+0.0016 76 77 129
+0.0016 72 77 130
+0.0016 72 73 131
+0.0016 79 80 132
+0.0016 80 81 133
+0.0016 81 82 134
+0.0016 82 83 135
+0.0016 78 83 136
+0.0016 78 79 137
+0.0016 85 86 138
+0.0016 86 87 139
+0.0016 87 88 140
+0.0016 88 89 141
+0.0016 84 89 142
+0.0016 84 85 143
+0.004 77 108 130
+0.004 72 109 131
+0.004 73 110 126
+0.004 74 111 127
+0.004 75 112 128
+0.004 76 113 129
+0.004 83 114 136
+0.004 78 115 137
+0.004 79 116 132
+0.004 80 117 133
+0.004 81 118 134
+0.004 82 119 135
+0.004 89 120 142
+0.004 84 121 143
+0.004 85 122 138
+0.004 86 123 139
+0.004 87 124 140
+0.004 88 125 141
+0.004 95 112 126
+0.004 90 113 127
+0.004 91 108 128
+0.004 92 109 129
+0.004 93 110 130
+0.004 94 111 131
+0.004 101 118 132
+0.004 96 119 133
+0.004 97 114 134
+0.004 98 115 135
+0.004 99 116 136
+0.004 100 117 137
+0.004 107 124 138
+0.004 102 125 139
+0.004 103 120 140
+0.004 104 121 141
+0.004 105 122 142
+0.004 106 123 143
+0.0016 76 85 116 132
+0.0016 77 86 117 133
+0.0016 72 87 118 134
+0.0016 73 88 119 135
+0.0016 74 89 114 136
+0.0016 75 84 115 137
+0.0016 82 91 122 138
+0.0016 83 92 123 139
+0.0016 78 93 124 140
+0.0016 79 94 125 141
+0.0016 80 95 120 142
+0.0016 81 90 121 143
+0.0016 88 97 108 128
+0.0016 89 98 109 129
+0.0016 84 99 110 130
+0.0016 85 100 111 131
+0.0016 86 101 112 126
+0.0016 87 96 113 127
+0.0016 94 103 114 134
+0.0016 95 104 115 135
+0.0016 90 105 116 136
+0.0016 91 106 117 137
+0.0016 92 107 118 132
+0.0016 93 102 119 133
+0.0016 73 100 120 140
+0.0016 74 101 121 141
+0.0016 75 96 122 142
+0.0016 76 97 123 143
+0.0016 77 98 124 138
+0.0016 72 99 125 139
+0.0016 79 106 110 126
+0.0016 80 107 111 127
+0.0016 81 102 112 128
+0.0016 82 103 113 129
+0.0016 83 104 108 130
+0.0016 78 105 109 131
+0.0016 81 87 108
+0.0016 82 88 109
+0.0016 83 89 110
+0.0016 78 84 111
+0.0016 79 85 112
+0.0016 80 86 113
+0.0016 87 93 114
+0.0016 88 94 115
+0.0016 89 95 116
+0.0016 84 90 117
+0.0016 85 91 118
+0.0016 86 92 119
+0.0016 93 99 120
+0.0016 94 100 121
+0.0016 95 101 122
+0.0016 90 96 123
+0.0016 91 97 124
+0.0016 92 98 125
+0.0016 99 105 126
+0.0016 100 106 127
+0.0016 101 107 128
+0.0016 96 102 129
+0.0016 97 103 130
+0.0016 98 104 131
+0.0016 75 105 132
+0.0016 76 106 133
+0.0016 77 107 134
+0.0016 72 102 135
+0.0016 73 103 136
+0.0016 74 104 137
+0.0016 75 81 138
+0.0016 76 82 139
+0.0016 77 83 140
+0.0016 72 78 141
+0.0016 73 79 142
+0.0016 74 80 143
+0.0016 85 113 116 129 132
+0.0016 86 108 117 130 133
+0.0016 87 109 118 131 134
+0.0016 88 110 119 126 135
+0.0016 89 111 114 127 136
+0.0016 84 112 115 128 137
+0.0016 91 119 122 135 138
+0.0016 92 114 123 136 139
+0.0016 93 115 124 137 140
+0.0016 94 116 125 132 141
+0.0016 95 117 120 133 142
+0.0016 90 118 121 134 143
+0.0016 97 108 125 128 141
+0.0016 98 109 120 129 142
+0.0016 99 110 121 130 143
+0.0016 100 111 122 131 138
+0.0016 101 112 123 126 139
+0.0016 96 113 124 127 140
+0.0016 103 111 114 131 134
+0.0016 104 112 115 126 135
+0.0016 105 113 116 127 136
+0.0016 106 108 117 128 137
+0.0016 107 109 118 129 132
+0.0016 102 110 119 130 133
+0.0016 73 117 120 137 140
+0.0016 74 118 121 132 141
+0.0016 75 119 122 133 142
+0.0016 76 114 123 134 143
+0.0016 77 115 124 135 138
+0.0016 72 116 125 136 139
+0.0016 79 110 123 126 143
+0.0016 80 111 124 127 138
+0.0016 81 112 125 128 139
+0.0016 82 113 120 129 140
+0.0016 83 108 121 130 141
+0.0016 78 109 122 131 142
+0.0016 78 108 141
+0.0016 79 109 142
+0.0016 80 110 143
+0.0016 81 111 138
+0.0016 82 112 139
+0.0016 83 113 140
+0.0016 84 111 114
+0.0016 85 112 115
+0.0016 86 113 116
+0.0016 87 108 117
+0.0016 88 109 118
+0.0016 89 110 119
+0.0016 90 117 120
+0.0016 91 118 121
+0.0016 92 119 122
+0.0016 93 114 123
+0.0016 94 115 124
+0.0016 95 116 125
+0.0016 96 123 126
+0.0016 97 124 127
+0.0016 98 125 128
+0.0016 99 120 129
+0.0016 100 121 130
+0.0016 101 122 131
+0.0016 102 129 132
+0.0016 103 130 133
+0.0016 104 131 134
+0.0016 105 126 135
+0.0016 106 127 136
+0.0016 107 128 137
+0.0016 72 135 138
+0.0016 73 136 139
+0.0016 74 137 140
+0.0016 75 132 141
+0.0016 76 133 142
+0.0016 77 134 143
+0.0016 113 116 122 129 132 138
+0.0016 108 117 123 130 133 139
+0.0016 109 118 124 131 134 140
+0.0016 110 119 125 126 135 141
+0.0016 111 114 120 127 136 142
+0.0016 112 115 121 128 137 143
+0.0016 108 119 122 128 135 138
+0.0016 109 114 123 129 136 139
+0.0016 110 115 124 130 137 140
+0.0016 111 116 125 131 132 141
+0.0016 112 117 120 126 133 142
+0.0016 113 118 121 127 134 143
+0.0016 108 114 125 128 134 141
+0.0016 109 115 120 129 135 142
+0.0016 110 116 121 130 136 143
+0.0016 111 117 122 131 137 138
+0.0016 112 118 123 126 132 139
+0.0016 113 119 124 127 133 140
+0.0016 111 114 120 131 134 140
+0.0016 112 115 121 126 135 141
+0.0016 113 116 122 127 136 142
+0.0016 108 117 123 128 137 143
+0.0016 109 118 124 129 132 138
+0.0016 110 119 125 130 133 139
+0.0016 110 117 120 126 137 140
+0.0016 111 118 121 127 132 141
+0.0016 112 119 122 128 133 142
+0.0016 113 114 123 129 134 143
+0.0016 108 115 124 130 135 138
+0.0016 109 116 125 131 136 139
+0.0016 110 116 123 126 132 143
+0.0016 111 117 124 127 133 138
+0.0016 112 118 125 128 134 139
+0.0016 113 119 120 129 135 140
+0.0016 108 114 121 130 136 141
+0.0016 109 115 122 131 137 142
+0.011200000000000002 108 135 138
+0.011200000000000002 109 136 139
+0.011200000000000002 110 137 140
+0.011200000000000002 111 132 141
+0.011200000000000002 112 133 142
+0.011200000000000002 113 134 143
+0.011200000000000002 108 114 141
+0.011200000000000002 109 115 142
+0.011200000000000002 110 116 143
+0.011200000000000002 111 117 138
+0.011200000000000002 112 118 139
+0.011200000000000002 113 119 140
+0.011200000000000002 111 114 120
+0.011200000000000002 112 115 121
+0.011200000000000002 113 116 122
+0.011200000000000002 108 117 123
+0.011200000000000002 109 118 124
+0.011200000000000002 110 119 125
+0.011200000000000002 117 120 126
+0.011200000000000002 118 121 127
+0.011200000000000002 119 122 128
+0.011200000000000002 114 123 129
+0.011200000000000002 115 124 130
+0.011200000000000002 116 125 131
+0.011200000000000002 123 126 132
+0.011200000000000002 124 127 133
+0.011200000000000002 125 128 134
+0.011200000000000002 120 129 135
+0.011200000000000002 121 130 136
+0.011200000000000002 122 131 137
+0.011200000000000002 129 132 138
+0.011200000000000002 130 133 139
+0.011200000000000002 131 134 140
+0.011200000000000002 126 135 141
+0.011200000000000002 127 136 142
+0.011200000000000002 128 137 143
+0.005600000000000001 108 109 131
+0.005600000000000001 109 110 126
+0.005600000000000001 110 111 127
+0.005600000000000001 111 112 128
+0.005600000000000001 112 113 129
+0.005600000000000001 108 113 130
+0.005600000000000001 114 115 137
+0.005600000000000001 115 116 132
+0.005600000000000001 116 117 133
+0.005600000000000001 117 118 134
+0.005600000000000001 118 119 135
+0.005600000000000001 114 119 136
+0.005600000000000001 120 121 143
+0.005600000000000001 121 122 138
+0.005600000000000001 122 123 139
+0.005600000000000001 123 124 140
+0.005600000000000001 124 125 141
+0.005600000000000001 120 125 142
+0.005600000000000001 113 126 127
+0.005600000000000001 108 127 128
+0.005600000000000001 109 128 129
+0.005600000000000001 110 129 130
+0.005600000000000001 111 130 131
+0.005600000000000001 112 126 131
+0.005600000000000001 119 132 133
+0.005600000000000001 114 133 134
+0.005600000000000001 115 134 135
+0.005600000000000001 116 135 136
+0.005600000000000001 117 136 137
+0.005600000000000001 118 132 137
+0.005600000000000001 125 138 139
+0.005600000000000001 120 139 140
+0.005600000000000001 121 140 141
+0.005600000000000001 122 141 142
+0.005600000000000001 123 142 143
+0.005600000000000001 124 138 143
+0.0108 108 144
+0.0108 109 145
+0.0108 110 146
+0.0108 111 147
+0.0108 112 148
+0.0108 113 149
+0.0108 114 150
+0.0108 115 151
+0.0108 116 152
+0.0108 117 153
+0.0108 118 154
+0.0108 119 155
+0.0108 120 156
+0.0108 121 157
+0.0108 122 158
+0.0108 123 159
+0.0108 124 160
+0.0108 125 161
+0.0108 126 162
+0.0108 127 163
+0.0108 128 164
+0.0108 129 165
+0.0108 130 166
+0.0108 131 167
+0.0108 132 168
+0.0108 133 169
+0.0108 134 170
+0.0108 135 171
+0.0108 136 172
+0.0108 137 173
+0.0108 138 174
+0.0108 139 175
+0.0108 140 176
+0.0108 141 177
+0.0108 142 178
+0.0108 143 179
+0.0016 127 128 144
+0.0016 128 129 145
+0.0016 129 130 146
+0.0016 130 131 147
+0.0016 126 131 148
+0.0016 126 127 149
+0.0016 133 134 150
+0.0016 134 135 151
+0.0016 135 136 152
+0.0016 136 137 153
+0.0016 132 137 154
+0.0016 132 133 155
+0.0016 139 140 156
+0.0016 140 141 157
+0.0016 141 142 158
+0.0016 142 143 159
+0.0016 138 143 160
+0.0016 138 139 161
+0.0016 109 110 162
+0.0016 110 111 163
+0.0016 111 112 164
+0.0016 112 113 165
+0.0016 108 113 166
+0.0016 108 109 167
+0.0016 115 116 168
+0.0016 116 117 169
+0.0016 117 118 170
+0.0016 118 119 171
+0.0016 114 119 172
+0.0016 114 115 173
+0.0016 121 122 174
+0.0016 122 123 175
+0.0016 123 124 176
+0.0016 124 125 177
+0.0016 120 125 178
+0.0016 120 121 179
+0.004 113 144 166
+0.004 108 145 167
+0.004 109 146 162
+0.004 110 147 163
+0.004 111 148 164
+0.004 112 149 165
+0.004 119 150 172
+0.004 114 151 173
+0.004 115 152 168
+0.004 116 153 169
+0.004 117 154 170
+0.004 118 155 171
+0.004 125 156 178
+0.004 120 157 179
+0.004 121 158 174
+0.004 122 159 175
+0.004 123 160 176
+0.004 124 161 177
+0.004 131 148 162
+0.004 126 149 163
+0.004 127 144 164
+0.004 128 145 165
+0.004 129 146 166
+0.004 130 147 167
+0.004 137 154 168
+0.004 132 155 169
+0.004 133 150 170
+0.004 134 151 171
+0.004 135 152 172
+0.004 136 153 173
+0.004 143 160 174
+0.004 138 161 175
+0.004 139 156 176
+0.004 140 157 177
+0.004 141 158 178
+0.004 142 159 179
+0.0016 112 121 152 168
+0.0016 113 122 153 169
+0.0016 108 123 154 170
+0.0016 109 124 155 171
+0.0016 110 125 150 172
+0.0016 111 120 151 173
+0.0016 118 127 158 174
+0.0016 119 128 159 175
+0.0016 114 129 160 176
+0.0016 115 130 161 177
+0.0016 116 131 156 178
+0.0016 117 126 157 179
+0.0016 124 133 144 164
+0.0016 125 134 145 165
+0.0016 120 135 146 166
+0.0016 121 136 147 167
+0.0016 122 137 148 162
+0.0016 123 132 149 163
+0.0016 130 139 150 170
+0.0016 131 140 151 171
+0.0016 126 141 152 172
+0.0016 127 142 153 173
+0.0016 128 143 154 168
+0.0016 129 138 155 169
+0.0016 109 136 156 176
+0.0016 110 137 157 177
+0.0016 111 132 158 178
+0.0016 112 133 159 179
+0.0016 113 134 160 174
+0.0016 108 135 161 175
+0.0016 115 142 146 162
+0.0016 116 143 147 163
+0.0016 117 138 148 164
+0.0016 118 139 149 165
+0.0016 119 140 144 166
+0.0016 114 141 145 167
+0.0016 117 123 144
+0.0016 118 124 145
+0.0016 119 125 146
+0.0016 114 120 147
+0.0016 115 121 148
+0.0016 116 122 149
+0.0016 123 129 150
+0.0016 124 130 151
+0.0016 125 131 152
+0.0016 120 126 153
+0.0016 121 127 154
+0.0016 122 128 155
+0.0016 129 135 156
+0.0016 130 136 157
+0.0016 131 137 158
+0.0016 126 132 159
+0.0016 127 133 160
+0.0016 128 134 161
+0.0016 135 141 162
+0.0016 136 142 163
+0.0016 137 143 164
+0.0016 132 138 165
+0.0016 133 139 166
+0.0016 134 140 167
+0.0016 111 141 168
+0.0016 112 142 169
+0.0016 113 143 170
+0.0016 108 138 171
+0.0016 109 139 172
+0.0016 110 140 173
+0.0016 111 117 174
+0.0016 112 118 175
+0.0016 113 119 176
+0.0016 108 114 177
+0.0016 109 115 178
+0.0016 110 116 179
+0.0016 121 149 152 165 168
+0.0016 122 144 153 166 169
+0.0016 123 145 154 167 170
+0.0016 124 146 155 162 171
+0.0016 125 147 150 163 172
+0.0016 120 148 151 164 173
+0.0016 127 155 158 171 174
+0.0016 128 150 159 172 175
+0.0016 129 151 160 173 176
+0.0016 130 152 161 168 177
+0.0016 131 153 156 169 178
+0.0016 126 154 157 170 179
+0.0016 133 144 161 164 177
+0.0016 134 145 156 165 178
+0.0016 135 146 157 166 179
+0.0016 136 147 158 167 174
+0.0016 137 148 159 162 175
+0.0016 132 149 160 163 176
+0.0016 139 147 150 167 170
+0.0016 140 148 151 162 171
+0.0016 141 149 152 163 172
+0.0016 142 144 153 164 173
+0.0016 143 145 154 165 168
+0.0016 138 146 155 166 169
+0.0016 109 153 156 173 176
+0.0016 110 154 157 168 177
+0.0016 111 155 158 169 178
+0.0016 112 150 159 170 179
+0.0016 113 151 160 171 174
+0.0016 108 152 161 172 175
+0.0016 115 146 159 162 179
+0.0016 116 147 160 163 174
+0.0016 117 148 161 164 175
+0.0016 118 149 156 165 176
+0.0016 119 144 157 166 177
+0.0016 114 145 158 167 178
+0.0016 114 144 177
+0.0016 115 145 178
+0.0016 116 146 179
+0.0016 117 147 174
+0.0016 118 148 175
+0.0016 119 149 176
+0.0016 120 147 150
+0.0016 121 148 151
+0.0016 122 149 152
+0.0016 123 144 153
+0.0016 124 145 154
+0.0016 125 146 155
+0.0016 126 153 156
+0.0016 127 154 157
+0.0016 128 155 158
+0.0016 129 150 159
+0.0016 130 151 160
+0.0016 131 152 161
+0.0016 132 159 162
+0.0016 133 160 163
+0.0016 134 161 164
+0.0016 135 156 165
+0.0016 136 157 166
+0.0016 137 158 167
+0.0016 138 165 168
+0.0016 139 166 169
+0.0016 140 167 170
+0.0016 141 162 171
+0.0016 142 163 172
+0.0016 143 164 173
+0.0016 108 171 174
+0.0016 109 172 175
+0.0016 110 173 176
+0.0016 111 168 177
+0.0016 112 169 178
+0.0016 113 170 179
+0.0016 149 152 158 165 168 174
+0.0016 144 153 159 166 169 175
+0.0016 145 154 160 167 170 176
+0.0016 146 155 161 162 171 177
+0.0016 147 150 156 163 172 178
+0.0016 148 151 157 164 173 179
+0.0016 144 155 158 164 171 174
+0.0016 145 150 159 165 172 175
+0.0016 146 151 160 166 173 176
+0.0016 147 152 161 167 168 177
+0.0016 148 153 156 162 169 178
+0.0016 149 154 157 163 170 179
+0.0016 144 150 161 164 170 177
+0.0016 145 151 156 165 171 178
+0.0016 146 152 157 166 172 179
+0.0016 147 153 158 167 173 174
+0.0016 148 154 159 162 168 175
+0.0016 149 155 160 163 169 176
+0.0016 147 150 156 167 170 176
+0.0016 148 151 157 162 171 177
+0.0016 149 152 158 163 172 178
+0.0016 144 153 159 164 173 179
+0.0016 145 154 160 165 168 174
+0.0016 146 155 161 166 169 175
+0.0016 146 153 156 162 173 176
+0.0016 147 154 157 163 168 177
+0.0016 148 155 158 164 169 178
+0.0016 149 150 159 165 170 179
+0.0016 144 151 160 166 171 174
+0.0016 145 152 161 167 172 175
+0.0016 146 152 159 162 168 179
+0.0016 147 153 160 163 169 174
+0.0016 148 154 161 164 170 175
+0.0016 149 155 156 165 171 176
+0.0016 144 150 157 166 172 177
+0.0016 145 151 158 167 173 178
+0.011200000000000002 144 171 174
+0.011200000000000002 145 172 175
+0.011200000000000002 146 173 176
+0.011200000000000002 147 168 177
+0.011200000000000002 148 169 178
+0.011200000000000002 149 170 179
+0.011200000000000002 144 150 177
+0.011200000000000002 145 151 178
+0.011200000000000002 146 152 179
+0.011200000000000002 147 153 174
+0.011200000000000002 148 154 175
+0.011200000000000002 149 155 176
+0.011200000000000002 147 150 156
+0.011200000000000002 148 151 157
+0.011200000000000002 149 152 158
+0.011200000000000002 144 153 159
+0.011200000000000002 145 154 160
+0.011200000000000002 146 155 161
+0.011200000000000002 153 156 162
+0.011200000000000002 154 157 163
+0.011200000000000002 155 158 164
+0.011200000000000002 150 159 165
+0.011200000000000002 151 160 166
+0.011200000000000002 152 161 167
+0.011200000000000002 159 162 168
+0.011200000000000002 160 163 169
+0.011200000000000002 161 164 170
+0.011200000000000002 156 165 171
+0.011200000000000002 157 166 172
+0.011200000000000002 158 167 173
+0.011200000000000002 165 168 174
+0.011200000000000002 166 169 175
+0.011200000000000002 167 170 176
+0.011200000000000002 162 171 177
+0.011200000000000002 163 172 178
+0.011200000000000002 164 173 179
+0.005600000000000001 144 145 167
+0.005600000000000001 145 146 162
+0.005600000000000001 146 147 163
+0.005600000000000001 147 148 164
+0.005600000000000001 148 149 165
+0.005600000000000001 144 149 166
+0.005600000000000001 150 151 173
+0.005600000000000001 151 152 168
+0.005600000000000001 152 153 169
+0.005600000000000001 153 154 170
+0.005600000000000001 154 155 171
+0.005600000000000001 150 155 172
+0.005600000000000001 156 157 179
+0.005600000000000001 157 158 174
+0.005600000000000001 158 159 175
+0.005600000000000001 159 160 176
+0.005600000000000001 160 161 177
+0.005600000000000001 156 161 178
+0.005600000000000001 149 162 163
+0.005600000000000001 144 163 164
+0.005600000000000001 145 164 165
+0.005600000000000001 146 165 166
+0.005600000000000001 147 166 167
+0.005600000000000001 148 162 167
+0.005600000000000001 155 168 169
+0.005600000000000001 150 169 170
+0.005600000000000001 151 170 171
+0.005600000000000001 152 171 172
+0.005600000000000001 153 172 173
+0.005600000000000001 154 168 173
+0.005600000000000001 161 174 175
+0.005600000000000001 156 175 176
+0.005600000000000001 157 176 177
+0.005600000000000001 158 177 178
+0.005600000000000001 159 178 179
+0.005600000000000001 160 174 179
+0.0108 144 180
+0.0108 145 181
+0.0108 146 182
+0.0108 147 183
+0.0108 148 184
+0.0108 149 185
+0.0108 150 186
+0.0108 151 187
+0.0108 152 188
+0.0108 153 189
+0.0108 154 190
+0.0108 155 191
+0.0108 156 192
+0.0108 157 193
+0.0108 158 194
+0.0108 159 195
+0.0108 160 196
+0.0108 161 197
+0.0108 162 198
+0.0108 163 199
+0.0108 164 200
+0.0108 165 201
+0.0108 166 202
+0.0108 167 203
+0.0108 168 204
+0.0108 169 205
+0.0108 170 206
+0.0108 171 207
+0.0108 172 208
+0.0108 173 209
+0.0108 174 210
+0.0108 175 211
+0.0108 176 212
+0.0108 177 213
+0.0108 178 214
+0.0108 179 215
+0.0016 163 164 180
+0.0016 164 165 181
+0.0016 165 166 182
+0.0016 166 167 183
+0.0016 162 167 184
+0.0016 162 163 185
+0.0016 169 170 186
+0.0016 170 171 187
+0.0016 171 172 188
+0.0016 172 173 189
+0.0016 168 173 190
+0.0016 168 169 191
+0.0016 175 176 192
+0.0016 176 177 193
+0.0016 177 178 194
+0.0016 178 179 195
+0.0016 174 179 196
+0.0016 174 175 197
+0.0016 145 146 198
+0.0016 146 147 199
+0.0016 147 148 200
+0.0016 148 149 201
+0.0016 144 149 202
+0.0016 144 145 203
+0.0016 151 152 204
+0.0016 152 153 205
+0.0016 153 154 206
+0.0016 154 155 207
+0.0016 150 155 208
+0.0016 150 151 209
+0.0016 157 158 210
+0.0016 158 159 211
+0.0016 159 160 212
+0.0016 160 161 213
+0.0016 156 161 214
+0.0016 156 157 215
+0.004 149 180 202
+0.004 144 181 203
+0.004 145 182 198
+0.004 146 183 199
+0.004 147 184 200
+0.004 148 185 201
+0.004 155 186 208
+0.004 150 187 209
+0.004 151 188 204
+0.004 152 189 205
+0.004 153 190 206
+0.004 154 191 207
+0.004 161 192 214
+0.004 156 193 215
+0.004 157 194 210
+0.004 158 195 211
+0.004 159 196 212
+0.004 160 197 213
+0.004 167 184 198
+0.004 162 185 199
+0.004 163 180 200
+0.004 164 181 201
+0.004 165 182 202
+0.004 166 183 203
+0.004 173 190 204
+0.004 168 191 205
+0.004 169 186 206
+0.004 170 187 207
+0.004 171 188 208
+0.004 172 189 209
+0.004 179 196 210
+0.004 174 197 211
+0.004 175 192 212
+0.004 176 193 213
+0.004 177 194 214
+0.004 178 195 215
+0.0016 148 157 188 204
+0.0016 149 158 189 205
+0.0016 144 159 190 206
+0.0016 145 160 191 207
+0.0016 146 161 186 208
+0.0016 147 156 187 209
+0.0016 154 163 194 210
+0.0016 155 164 195 211
+0.0016 150 165 196 212
+0.0016 151 166 197 213
+0.0016 152 167 192 214
+0.0016 153 162 193 215
+0.0016 160 169 180 200
+0.0016 161 170 181 201
+0.0016 156 171 182 202
+0.0016 157 172 183 203
+0.0016 158 173 184 198
+0.0016 159 168 185 199
+0.0016 166 175 186 206
+0.0016 167 176 187 207
+0.0016 162 177 188 208
+0.0016 163 178 189 209
+0.0016 164 179 190 204
+0.0016 165 174 191 205
+0.0016 145 172 192 212
+0.0016 146 173 193 213
+0.0016 147 168 194 214
+0.0016 148 169 195 215
+0.0016 149 170 196 210
+0.0016 144 171 197 211
+0.0016 151 178 182 198
+0.0016 152 179 183 199
+0.0016 153 174 184 200
+0.0016 154 175 185 201
+0.0016 155 176 180 202
+0.0016 150 177 181 203
+0.0016 153 159 180
+0.0016 154 160 181
+0.0016 155 161 182
+0.0016 150 156 183
+0.0016 151 157 184
+0.0016 152 158 185
+0.0016 159 165 186
+0.0016 160 166 187
+0.0016 161 167 188
+0.0016 156 162 189
+0.0016 157 163 190
+0.0016 158 164 191
+0.0016 165 171 192
+0.0016 166 172 193
+0.0016 167 173 194
+0.0016 162 168 195
+0.0016 163 169 196
+0.0016 164 170 197
+0.0016 171 177 198
+0.0016 172 178 199
+0.0016 173 179 200
+0.0016 168 174 201
+0.0016 169 175 202
+0.0016 170 176 203
+0.0016 147 177 204
+0.0016 148 178 205
+0.0016 149 179 206
+0.0016 144 174 207
+0.0016 145 175 208
+0.0016 146 176 209
+0.0016 147 153 210
+0.0016 148 154 211
+0.0016 149 155 212
+0.0016 144 150 213
+0.0016 145 151 214
+0.0016 146 152 215
+0.0016 157 185 188 201 204
+0.0016 158 180 189 202 205
+0.0016 159 181 190 203 206
+0.0016 160 182 191 198 207
+0.0016 161 183 186 199 208
+0.0016 156 184 187 200 209
+0.0016 163 191 194 207 210
+0.0016 164 186 195 208 211
+0.0016 165 187 196 209 212
+0.0016 166 188 197 204 213
+0.0016 167 189 192 205 214
+0.0016 162 190 193 206 215
+0.0016 169 180 197 200 213
+0.0016 170 181 192 201 214
+0.0016 171 182 193 202 215
+0.0016 172 183 194 203 210
+0.0016 173 184 195 198 211
+0.0016 168 185 196 199 212
+0.0016 175 183 186 203 206
+0.0016 176 184 187 198 207
+0.0016 177 185 188 199 208
+0.0016 178 180 189 200 209
+0.0016 179 181 190 201 204
+0.0016 174 182 191 202 205
+0.0016 145 189 192 209 212
+0.0016 146 190 193 204 213
+0.0016 147 191 194 205 214
+0.0016 148 186 195 206 215
+0.0016 149 187 196 207 210
+0.0016 144 188 197 208 211
+0.0016 151 182 195 198 215
+0.0016 152 183 196 199 210
+0.0016 153 184 197 200 211
+0.0016 154 185 192 201 212
+0.0016 155 180 193 202 213
+0.0016 150 181 194 203 214
+0.0016 150 180 213
+0.0016 151 181 214
+0.0016 152 182 215
+0.0016 153 183 210
+0.0016 154 184 211
+0.0016 155 185 212
+0.0016 156 183 186
+0.0016 157 184 187
+0.0016 158 185 188
+0.0016 159 180 189
+0.0016 160 181 190
+0.0016 161 182 191
+0.0016 162 189 192
+0.0016 163 190 193
+0.0016 164 191 194
+0.0016 165 186 195
+0.0016 166 187 196
+0.0016 167 188 197
+0.0016 168 195 198
+0.0016 169 196 199
+0.0016 170 197 200
+0.0016 171 192 201
+0.0016 172 193 202
+0.0016 173 194 203
+0.0016 174 201 204
+0.0016 175 202 205
+0.0016 176 203 206
+0.0016 177 198 207
+0.0016 178 199 208
+0.0016 179 200 209
+0.0016 144 207 210
+0.0016 145 208 211
+0.0016 146 209 212
+0.0016 147 204 213
+0.0016 148 205 214
+0.0016 149 206 215
+0.0016 185 188 194 201 204 210
+0.0016 180 189 195 202 205 211
+0.0016 181 190 196 203 206 212
+0.0016 182 191 197 198 207 213
+0.0016 183 186 192 199 208 214
+0.0016 184 187 193 200 209 215
+0.0016 180 191 194 200 207 210
+0.0016 181 186 195 201 208 211
+0.0016 182 187 196 202 209 212
+0.0016 183 188 197 203 204 213
+0.0016 184 189 192 198 205 214
+0.0016 185 190 193 199 206 215
+0.0016 180 186 197 200 206 213
+0.0016 181 187 192 201 207 214
+0.0016 182 188 193 202 208 215
+0.0016 183 189 194 203 209 210
+0.0016 184 190 195 198 204 211
+0.0016 185 191 196 199 205 212
+0.0016 183 186 192 203 206 212
+0.0016 184 187 193 198 207 213
+0.0016 185 188 194 199 208 214
+0.0016 180 189 195 200 209 215
+0.0016 181 190 196 201 204 210
+0.0016 182 191 197 202 205 211
+0.0016 182 189 192 198 209 212
+0.0016 183 190 193 199 204 213
+0.0016 184 191 194 200 205 214
+0.0016 185 186 195 201 206 215
+0.0016 180 187 196 202 207 210
+0.0016 181 188 197 203 208 211
+0.0016 182 188 195 198 204 215
+0.0016 183 189 196 199 205 210
+0.0016 184 190 197 200 206 211
+0.0016 185 191 192 201 207 212
+0.0016 180 186 193 202 208 213
+0.0016 181 187 194 203 209 214
+0.011200000000000002 180 207 210
+0.011200000000000002 181 208 211
+0.011200000000000002 182 209 212
+0.011200000000000002 183 204 213
+0.011200000000000002 184 205 214
+0.011200000000000002 185 206 215
+0.011200000000000002 180 186 213
+0.011200000000000002 181 187 214
+0.011200000000000002 182 188 215
+0.011200000000000002 183 189 210
+0.011200000000000002 184 190 211
+0.011200000000000002 185 191 212
+0.011200000000000002 183 186 192
+0.011200000000000002 184 187 193
+0.011200000000000002 185 188 194
+0.011200000000000002 180 189 195
+0.011200000000000002 181 190 196
+0.011200000000000002 182 191 197
+0.011200000000000002 189 192 198
+0.011200000000000002 190 193 199
+0.011200000000000002 191 194 200
+0.011200000000000002 186 195 201
+0.011200000000000002 187 196 202
+0.011200000000000002 188 197 203
+0.011200000000000002 195 198 204
+0.011200000000000002 196 199 205
+0.011200000000000002 197 200 206
+0.011200000000000002 192 201 207
+0.011200000000000002 193 202 208
+0.011200000000000002 194 203 209
+0.011200000000000002 201 204 210
+0.011200000000000002 202 205 211
+0.011200000000000002 203 206 212
+0.011200000000000002 198 207 213
+0.011200000000000002 199 208 214
+0.011200000000000002 200 209 215
+0.005600000000000001 180 181 203
+0.005600000000000001 181 182 198
+0.005600000000000001 182 183 199
+0.005600000000000001 183 184 200
+0.005600000000000001 184 185 201
+0.005600000000000001 180 185 202
+0.005600000000000001 186 187 209
+0.005600000000000001 187 188 204
+0.005600000000000001 188 189 205
+0.005600000000000001 189 190 206
+0.005600000000000001 190 191 207
+0.005600000000000001 186 191 208
+0.005600000000000001 192 193 215
+0.005600000000000001 193 194 210
+0.005600000000000001 194 195 211
+0.005600000000000001 195 196 212
+0.005600000000000001 196 197 213
+0.005600000000000001 192 197 214
+0.005600000000000001 185 198 199
+0.005600000000000001 180 199 200
+0.005600000000000001 181 200 201
+0.005600000000000001 182 201 202
+0.005600000000000001 183 202 203
+0.005600000000000001 184 198 203
+0.005600000000000001 191 204 205
+0.005600000000000001 186 205 206
+0.005600000000000001 187 206 207
+0.005600000000000001 188 207 208
+0.005600000000000001 189 208 209
+0.005600000000000001 190 204 209
+0.005600000000000001 197 210 211
+0.005600000000000001 192 211 212
+0.005600000000000001 193 212 213
+0.005600000000000001 194 213 214
+0.005600000000000001 195 214 215
+0.005600000000000001 196 210 215
+0.0108 180 216
+0.0108 181 217
+0.0108 182 218
+0.0108 183 219
+0.0108 184 220
+0.0108 185 221
+0.0108 186 222
+0.0108 187 223
+0.0108 188 224
+0.0108 189 225
+0.0108 190 226
+0.0108 191 227
+0.0108 192 228
+0.0108 193 229
+0.0108 194 230
+0.0108 195 231
+0.0108 196 232
+0.0108 197 233
+0.0108 198 234
+0.0108 199 235
+0.0108 200 236
+0.0108 201 237
+0.0108 202 238
+0.0108 203 239
+0.0108 204 240
+0.0108 205 241
+0.0108 206 242
+0.0108 207 243
+0.0108 208 244
+0.0108 209 245
+0.0108 210 246
+0.0108 211 247
+0.0108 212 248
+0.0108 213 249
+0.0108 214 250
+0.0108 215 251
+0.0016 199 200 216
+0.0016 200 201 217
+0.0016 201 202 218
+0.0016 202 203 219
+0.0016 198 203 220
+0.0016 198 199 221
+0.0016 205 206 222
+0.0016 206 207 223
+0.0016 207 208 224
+0.0016 208 209 225
+0.0016 204 209 226
+0.0016 204 205 227
+0.0016 211 212 228
+0.0016 212 213 229
+0.0016 213 214 230
+0.0016 214 215 231
+0.0016 210 215 232
+0.0016 210 211 233
+0.0016 181 182 234
+0.0016 182 183 235
+0.0016 183 184 236
+0.0016 184 185 237
+0.0016 180 185 238
+0.0016 180 181 239
+0.0016 187 188 240
+0.0016 188 189 241
+0.0016 189 190 242
+0.0016 190 191 243
+0.0016 186 191 244
+0.0016 186 187 245
+0.0016 193 194 246
+0.0016 194 195 247
+0.0016 195 196 248
+0.0016 196 197 249
+0.0016 192 197 250
+0.0016 192 193 251
+0.004 185 216 238
+0.004 180 217 239
+0.004 181 218 234
+0.004 182 219 235
+0.004 183 220 236
+0.004 184 221 237
+0.004 191 222 244
+0.004 186 223 245
+0.004 187 224 240
+0.004 188 225 241
+0.004 189 226 242
+0.004 190 227 243
+0.004 197 228 250
+0.004 192 229 251
+0.004 193 230 246
+0.004 194 231 247
+0.004 195 232 248
+0.004 196 233 249
+0.004 203 220 234
+0.004 198 221 235
+0.004 199 216 236
+0.004 200 217 237
+0.004 201 218 238
+0.004 202 219 239
+0.004 209 226 240
+0.004 204 227 241
+0.004 205 222 242
+0.004 206 223 243
+0.004 207 224 244
+0.004 208 225 245
+0.004 215 232 246
+0.004 210 233 247
+0.004 211 228 248
+0.004 212 229 249
+0.004 213 230 250
+0.004 214 231 251
+0.0016 184 193 224 240
+0.0016 185 194 225 241
+0.0016 180 195 226 242
+0.0016 181 196 227 243
+0.0016 182 197 222 244
+0.0016 183 192 223 245
+0.0016 190 199 230 246
+0.0016 191 200 231 247
+0.0016 186 201 232 248
+0.0016 187 202 233 249
+0.0016 188 203 228 250
+0.0016 189 198 229 251
+0.0016 196 205 216 236
+0.0016 197 206 217 237
+0.0016 192 207 218 238
+0.0016 193 208 219 239
+0.0016 194 209 220 234
+0.0016 195 204 221 235
+0.0016 202 211 222 242
+0.0016 203 212 223 243
+0.0016 198 213 224 244
+0.0016 199 214 225 245
+0.0016 200 215 226 240
+0.0016 201 210 227 241
+0.0016 181 208 228 248
+0.0016 182 209 229 249
+0.0016 183 204 230 250
+0.0016 184 205 231 251
+0.0016 185 206 232 246
+0.0016 180 207 233 247
+0.0016 187 214 218 234
+0.0016 188 215 219 235
+0.0016 189 210 220 236
+0.0016 190 211 221 237
+0.0016 191 212 216 238
+0.0016 186 213 217 239
+0.0016 189 195 216
+0.0016 190 196 217
+0.0016 191 197 218
+0.0016 186 192 219
+0.0016 187 193 220
+0.0016 188 194 221
+0.0016 195 201 222
+0.0016 196 202 223
+0.0016 197 203 224
+0.0016 192 198 225
+0.0016 193 199 226
+0.0016 194 200 227
+0.0016 201 207 228
+0.0016 202 208 229
+0.0016 203 209 230
+0.0016 198 204 231
+0.0016 199 205 232
+0.0016 200 206 233
+0.0016 207 213 234
+0.0016 208 214 235
+0.0016 209 215 236
+0.0016 204 210 237
+0.0016 205 211 238
+0.0016 206 212 239
+0.0016 183 213 240
+0.0016 184 214 241
+0.0016 185 215 242
+0.0016 180 210 243
+0.0016 181 211 244
+0.0016 182 212 245
+0.0016 183 189 246
+0.0016 184 190 247
+0.0016 185 191 248
+0.0016 180 186 249
+0.0016 181 187 250
+0.0016 182 188 251
+0.0016 193 221 224 237 240
+0.0016 194 216 225 238 241
+0.0016 195 217 226 239 242
+0.0016 196 218 227 234 243
+0.0016 197 219 222 235 244
+0.0016 192 220 223 236 245
+0.0016 199 227 230 243 246
+0.0016 200 222 231 244 247
+0.0016 201 223 232 245 248
+0.0016 202 224 233 240 249
+0.0016 203 225 228 241 250
+0.0016 198 226 229 242 251
+0.0016 205 216 233 236 249
+0.0016 206 217 228 237 250
+0.0016 207 218 229 238 251
+0.0016 208 219 230 239 246
+0.0016 209 220 231 234 247
+0.0016 204 221 232 235 248
+0.0016 211 219 222 239 242
+0.0016 212 220 223 234 243
+0.0016 213 221 224 235 244
+0.0016 214 216 225 236 245
+0.0016 215 217 226 237 240
+0.0016 210 218 227 238 241
+0.0016 181 225 228 245 248
+0.0016 182 226 229 240 249
+0.0016 183 227 230 241 250
+0.0016 184 222 231 242 251
+0.0016 185 223 232 243 246
+0.0016 180 224 233 244 247
+0.0016 187 218 231 234 251
+0.0016 188 219 232 235 246
+0.0016 189 220 233 236 247
+0.0016 190 221 228 237 248
+0.0016 191 216 229 238 249
+0.0016 186 217 230 239 250
+0.0016 186 216 249
+0.0016 187 217 250
+0.0016 188 218 251
+0.0016 189 219 246
+0.0016 190 220 247
+0.0016 191 221 248
+0.0016 192 219 222
+0.0016 193 220 223
+0.0016 194 221 224
+0.0016 195 216 225
+0.0016 196 217 226
+0.0016 197 218 227
+0.0016 198 225 228
+0.0016 199 226 229
+0.0016 200 227 230
+0.0016 201 222 231
+0.0016 202 223 232
+0.0016 203 224 233
+0.0016 204 231 234
+0.0016 205 232 235
+0.0016 206 233 236
+0.0016 207 228 237
+0.0016 208 229 238
+0.0016 209 230 239
+0.0016 210 237 240
+0.0016 211 238 241
+0.0016 212 239 242
+0.0016 213 234 243
+0.0016 214 235 244
+0.0016 215 236 245
+0.0016 180 243 246
+0.0016 181 244 247
+0.0016 182 245 248
+0.0016 183 240 249
+0.0016 184 241 250
+0.0016 185 242 251
+0.0016 221 224 230 237 240 246
+0.0016 216 225 231 238 241 247
+0.0016 217 226 232 239 242 248
+0.0016 218 227 233 234 243 249
+0.0016 219 222 228 235 244 250
+0.0016 220 223 229 236 245 251
+0.0016 216 227 230 236 243 246
+0.0016 217 222 231 237 244 247
+0.0016 218 223 232 238 245 248
+0.0016 219 224 233 239 240 249
+0.0016 220 225 228 234 241 250
+0.0016 221 226 229 235 242 251
+0.0016 216 222 233 236 242 249
+0.0016 217 223 228 237 243 250
+0.0016 218 224 229 238 244 251
+0.0016 219 225 230 239 245 246
+0.0016 220 226 231 234 240 247
+0.0016 221 227 232 235 241 248
+0.0016 219 222 228 239 242 248
+0.0016 220 223 229 234 243 249
+0.0016 221 224 230 235 244 250
+0.0016 216 225 231 236 245 251
+0.0016 217 226 232 237 240 246
+0.0016 218 227 233 238 241 247
+0.0016 218 225 228 234 245 248
+0.0016 219 226 229 235 240 249
+0.0016 220 227 230 236 241 250
+0.0016 221 222 231 237 242 251
+0.0016 216 223 232 238 243 246
+0.0016 217 224 233 239 244 247
+0.0016 218 224 231 234 240 251
+0.0016 219 225 232 235 241 246
+0.0016 220 226 233 236 242 247
+0.0016 221 227 228 237 243 248
+0.0016 216 222 229 238 244 249
+0.0016 217 223 230 239 245 250
+0.006 216 243 246
+0.006 217 244 247
+0.006 218 245 248
+0.006 219 240 249
+0.006 220 241 250
+0.006 221 242 251
+0.006 216 222 249
+0.006 217 223 250
+0.006 218 224 251
+0.006 219 225 246
+0.006 220 226 247
+0.006 221 227 248
+0.006 219 222 228
+0.006 220 223 229
+0.006 221 224 230
+0.006 216 225 231
+0.006 217 226 232
+0.006 218 227 233
+0.006 225 228 234
+0.006 226 229 235
+0.006 227 230 236
+0.006 222 231 237
+0.006 223 232 238
+0.006 224 233 239
+0.006 231 234 240
+0.006 232 235 241
+0.006 233 236 242
+0.006 228 237 243
+0.006 229 238 244
+0.006 230 239 245
+0.006 237 240 246
+0.006 238 241 247
+0.006 239 242 248
+0.006 234 243 249
+0.006 235 244 250
+0.006 236 245 251
+0.0048000000000000004 216 217 239
+0.0048000000000000004 217 218 234
+0.0048000000000000004 218 219 235
+0.0048000000000000004 219 220 236
+0.0048000000000000004 220 221 237
+0.0048000000000000004 216 221 238
+0.0048000000000000004 222 223 245
+0.0048000000000000004 223 224 240
+0.0048000000000000004 224 225 241
+0.0048000000000000004 225 226 242
+0.0048000000000000004 226 227 243
+0.0048000000000000004 222 227 244
+0.0048000000000000004 228 229 251
+0.0048000000000000004 229 230 246
+0.0048000000000000004 230 231 247
+0.0048000000000000004 231 232 248
+0.0048000000000000004 232 233 249
+0.0048000000000000004 228 233 250
+0.0048000000000000004 221 234 235
+0.0048000000000000004 216 235 236
+0.0048000000000000004 217 236 237
+0.0048000000000000004 218 237 238
+0.0048000000000000004 219 238 239
+0.0048000000000000004 220 234 239
+0.0048000000000000004 227 240 241
+0.0048000000000000004 222 241 242
+0.0048000000000000004 223 242 243
+0.0048000000000000004 224 243 244
+0.0048000000000000004 225 244 245
+0.0048000000000000004 226 240 245
+0.0048000000000000004 233 246 247
+0.0048000000000000004 228 247 248
+0.0048000000000000004 229 248 249
+0.0048000000000000004 230 249 250
+0.0048000000000000004 231 250 251
+0.0048000000000000004 232 246 251
+0.003 216 252
+0.003 217 253
+0.003 218 254
+0.003 219 255
+0.003 220 256
+0.003 221 257
+0.003 222 258
+0.003 223 259
+0.003 224 260
+0.003 225 261
+0.003 226 262
+0.003 227 263
+0.003 228 264
+0.003 229 265
+0.003 230 266
+0.003 231 267
+0.003 232 268
+0.003 233 269
+0.003 234 270
+0.003 235 271
+0.003 236 272
+0.003 237 273
+0.003 238 274
+0.003 239 275
+0.003 240 276
+0.003 241 277
+0.003 242 278
+0.003 243 279
+0.003 244 280
+0.003 245 281
+0.003 246 282
+0.003 247 283
+0.003 248 284
+0.003 249 285
+0.003 250 286
+0.003 251 287
+# Z 288 2233
+0.0108 0 36
+0.0108 1 37
+0.0108 2 38
+0.0108 3 39
+0.0108 4 40
+0.0108 5 41
+0.0108 6 42
+0.0108 7 43
+0.0108 8 44
+0.0108 9 45
+0.0108 10 46
+0.0108 11 47
+0.0108 12 48
+0.0108 13 49
+0.0108 14 50
+0.0108 15 51
+0.0108 16 52
+0.0108 17 53
+0.0108 18 54
+0.0108 19 55
+0.0108 20 56
+0.0108 21 57
+0.0108 22 58
+0.0108 23 59
+0.0108 24 60
+0.0108 25 61
+0.0108 26 62
+0.0108 27 63
+0.0108 28 64
+0.0108 29 65
+0.0108 30 66
+0.0108 31 67
+0.0108 32 68
+0.0108 33 69
+0.0108 34 70
+0.0108 35 71
+0.004 6 12 21
+0.34560000000000013 
+0.004 7 13 22
+0.004 8 14 23
+0.004 9 15 18
+0.004 10 16 19
+0.004 11 17 20
+0.004 12 18 27
+0.004 13 19 28
+0.004 14 20 29
+0.004 15 21 24
+0.004 16 22 25
+0.004 17 23 26
+0.004 18 24 33
+0.004 19 25 34
+0.004 20 26 35
+0.004 21 27 30
+0.004 22 28 31
+0.004 23 29 32
+0.004 3 24 30
+0.004 4 25 31
+0.004 5 26 32
+0.004 0 27 33
+0.004 1 28 34
+0.004 2 29 35
+0.004 0 9 30
+0.004 1 10 31
+0.004 2 11 32
+0.004 3 6 33
+0.004 4 7 34
+0.004 5 8 35
+0.004 0 6 15
+0.004 1 7 16
+0.004 2 8 17
+0.004 3 9 12
+0.004 4 10 13
+0.004 5 11 14
+0.0028 4 5 18
+0.0028 0 5 19
+0.0028 0 1 20
+0.0028 1 2 21
+0.0028 2 3 22
+0.0028 3 4 23
+0.0028 10 11 24
+0.0028 6 11 25
+0.0028 6 7 26
+0.0028 7 8 27
+0.0028 8 9 28
+0.0028 9 10 29
+0.0028 16 17 30
+0.0028 12 17 31
+0.0028 12 13 32
+0.0028 13 14 33
+0.0028 14 15 34
+0.0028 15 16 35
+0.0028 0 22 23
+0.0028 1 18 23
+0.0028 2 18 19
+0.0028 3 19 20
+0.0028 4 20 21
+0.0028 5 21 22
+0.0028 6 28 29
+0.0028 7 24 29
+0.0028 8 24 25
+0.0028 9 25 26
+0.0028 10 26 27
+0.0028 11 27 28
+0.0028 12 34 35
+0.0028 13 30 35
+0.0028 14 30 31
+0.0028 15 31 32
+0.0028 16 32 33
+0.0028 17 33 34
+0.004 5 19 36
+0.004 0 20 37
+0.004 1 21 38
+0.004 2 22 39
+0.004 3 23 40
+0.004 4 18 41
+0.004 11 25 42
+0.004 6 26 43
+0.004 7 27 44
+0.004 8 28 45
+0.004 9 29 46
+0.004 10 24 47
+0.004 17 31 48
+0.004 12 32 49
+0.004 13 33 50
+0.004 14 34 51
+0.004 15 35 52
+0.004 16 30 53
+0.004 1 23 54
+0.004 2 18 55
+0.004 3 19 56
+0.004 4 20 57
+0.004 5 21 58
+0.004 0 22 59
+0.004 7 29 60
+0.004 8 24 61
+0.004 9 25 62
+0.004 10 26 63
+0.004 11 27 64
+0.004 6 28 65
+0.004 13 35 66
+0.004 14 30 67
+0.004 15 31 68
+0.004 16 32 69
+0.004 17 33 70
+0.004 12 34 71
+0.0016 1 6 12 21 28 34
+0.0016 2 7 13 22 29 35
+0.0016 3 8 14 23 24 30
+0.0016 4 9 15 18 25 31
+0.0016 5 10 16 19 26 32
+0.0016 0 11 17 20 27 33
+0.0016 4 7 12 18 27 34
+0.0016 5 8 13 19 28 35
+0.0016 0 9 14 20 29 30
+0.0016 1 10 15 21 24 31
+0.0016 2 11 16 22 25 32
+0.0016 3 6 17 23 26 33
+0.0016 4 10 13 18 24 33
+0.0016 5 11 14 19 25 34
+0.0016 0 6 15 20 26 35
+0.0016 1 7 16 21 27 30
+0.0016 2 8 17 22 28 31
+0.0016 3 9 12 23 29 32
+0.0016 3 10 16 19 24 30
+0.0016 4 11 17 20 25 31
+0.0016 5 6 12 21 26 32
+0.0016 0 7 13 22 27 33
+0.0016 1 8 14 23 28 34
+0.0016 2 9 15 18 29 35
+0.0016 0 9 16 22 25 30
+0.0016 1 10 17 23 26 31
+0.0016 2 11 12 18 27 32
+0.0016 3 6 13 19 28 33
+0.0016 4 7 14 20 29 34
+0.0016 5 8 15 21 24 35
+0.0016 0 6 15 22 28 31
+0.0016 1 7 16 23 29 32
+0.0016 2 8 17 18 24 33
+0.0016 3 9 12 19 25 34
+0.0016 4 10 13 20 26 35
+0.0016 5 11 14 21 27 30
+0.0016 9 30 36
+0.0016 10 31 37
+0.0016 11 32 38
+0.0016 6 33 39
+0.0016 7 34 40
+0.0016 8 35 41
+0.0016 0 15 42
+0.0016 1 16 43
+0.0016 2 17 44
+0.0016 3 12 45
+0.0016 4 13 46
+0.0016 5 14 47
+0.0016 6 21 48
+0.0016 7 22 49
+0.0016 8 23 50
+0.0016 9 18 51
+0.0016 10 19 52
+0.0016 11 20 53
+0.0016 12 27 54
+0.0016 13 28 55
+0.0016 14 29 56
+0.0016 15 24 57
+0.0016 16 25 58
+0.0016 17 26 59
+0.0016 18 33 60
+0.0016 19 34 61
+0.0016 20 35 62
+0.0016 21 30 63
+0.0016 22 31 64
+0.0016 23 32 65
+0.0016 3 24 66
+0.0016 4 25 67
+0.0016 5 26 68
+0.0016 0 27 69
+0.0016 1 28 70
+0.0016 2 29 71
+0.0016 6 12 28 34 38
+0.0016 7 13 29 35 39
+0.0016 8 14 24 30 40
+0.0016 9 15 25 31 41
+0.0016 10 16 26 32 36
+0.0016 11 17 27 33 37
+0.0016 4 12 18 34 44
+0.0016 5 13 19 35 45
+0.0016 0 14 20 30 46
+0.0016 1 15 21 31 47
+0.0016 2 16 22 32 42
+0.0016 3 17 23 33 43
+0.0016 4 10 18 24 50
+0.0016 5 11 19 25 51
+0.0016 0 6 20 26 52
+0.0016 1 7 21 27 53
+0.0016 2 8 22 28 48
+0.0016 3 9 23 29 49
+0.0016 10 16 24 30 56
+0.0016 11 17 25 31 57
+0.0016 6 12 26 32 58
+0.0016 7 13 27 33 59
+0.0016 8 14 28 34 54
+0.0016 9 15 29 35 55
+0.0016 0 16 22 30 62
+0.0016 1 17 23 31 63
+0.0016 2 12 18 32 64
+0.0016 3 13 19 33 65
+0.0016 4 14 20 34 60
+0.0016 5 15 21 35 61
+0.0016 0 6 22 28 68
+0.0016 1 7 23 29 69
+0.0016 2 8 18 24 70
+0.0016 3 9 19 25 71
+0.0016 4 10 20 26 66
+0.0016 5 11 21 27 67
+0.0016 27 36 69
+0.0016 28 37 70
+0.0016 29 38 71
+0.0016 24 39 66
+0.0016 25 40 67
+0.0016 26 41 68
+0.0016 33 39 42
+0.0016 34 40 43
+0.0016 35 41 44
+0.0016 30 36 45
+0.0016 31 37 46
+0.0016 32 38 47
+0.0016 3 45 48
+0.0016 4 46 49
+0.0016 5 47 50
+0.0016 0 42 51
+0.0016 1 43 52
+0.0016 2 44 53
+0.0016 9 51 54
+0.0016 10 52 55
+0.0016 11 53 56
+0.0016 6 48 57
+0.0016 7 49 58
+0.0016 8 50 59
+0.0016 15 57 60
+0.0016 16 58 61
+0.0016 17 59 62
+0.0016 12 54 63
+0.0016 13 55 64
+0.0016 14 56 65
+0.0016 21 63 66
+0.0016 22 64 67
+0.0016 23 65 68
+0.0016 18 60 69
+0.0016 19 61 70
+0.0016 20 62 71
+0.0016 6 28 38 71
+0.0016 7 29 39 66
+0.0016 8 24 40 67
+0.0016 9 25 41 68
+0.0016 10 26 36 69
+0.0016 11 27 37 70
+0.0016 12 34 41 44
+0.0016 13 35 36 45
+0.0016 14 30 37 46
+0.0016 15 31 38 47
+0.0016 16 32 39 42
+0.0016 17 33 40 43
+0.0016 4 18 47 50
+0.0016 5 19 42 51
+0.0016 0 20 43 52
+0.0016 1 21 44 53
+0.0016 2 22 45 48
+0.0016 3 23 46 49
+0.0016 10 24 53 56
+0.0016 11 25 48 57
+0.0016 6 26 49 58
+0.0016 7 27 50 59
+0.0016 8 28 51 54
+0.0016 9 29 52 55
+0.0016 16 30 59 62
+0.0016 17 31 54 63
+0.0016 12 32 55 64
+0.0016 13 33 56 65
+0.0016 14 34 57 60
+0.0016 15 35 58 61
+0.0016 0 22 65 68
+0.0016 1 23 60 69
+0.0016 2 18 61 70
+0.0016 3 19 62 71
+0.0016 4 20 63 66
+0.0016 5 21 64 67
+0.011200000000000002 36 42 51
+0.011200000000000002 37 43 52
+0.011200000000000002 38 44 53
+0.011200000000000002 39 45 48
+0.011200000000000002 40 46 49
+0.011200000000000002 41 47 50
+0.011200000000000002 42 48 57
+0.011200000000000002 43 49 58
+0.011200000000000002 44 50 59
+0.011200000000000002 45 51 54
+0.011200000000000002 46 52 55
+0.011200000000000002 47 53 56
+0.011200000000000002 48 54 63
+0.011200000000000002 49 55 64
+0.011200000000000002 50 56 65
+0.011200000000000002 51 57 60
+0.011200000000000002 52 58 61
+0.011200000000000002 53 59 62
+0.011200000000000002 54 60 69
+0.011200000000000002 55 61 70
+0.011200000000000002 56 62 71
+0.011200000000000002 57 63 66
+0.011200000000000002 58 64 67
+0.011200000000000002 59 65 68
+0.011200000000000002 39 60 66
+0.011200000000000002 40 61 67
+0.011200000000000002 41 62 68
+0.011200000000000002 36 63 69
+0.011200000000000002 37 64 70
+0.011200000000000002 38 65 71
+0.011200000000000002 36 45 66
+0.011200000000000002 37 46 67
+0.011200000000000002 38 47 68
+0.011200000000000002 39 42 69
+0.011200000000000002 40 43 70
+0.011200000000000002 41 44 71
+0.0016 22 36 59
+0.0016 23 37 54
+0.0016 18 38 55
+0.0016 19 39 56
+0.0016 20 40 57
+0.0016 21 41 58
+0.0016 28 42 65
+0.0016 29 43 60
+0.0016 24 44 61
+0.0016 25 45 62
+0.0016 26 46 63
+0.0016 27 47 64
+0.0016 34 48 71
+0.0016 35 49 66
+0.0016 30 50 67
+0.0016 31 51 68
+0.0016 32 52 69
+0.0016 33 53 70
+0.0016 4 41 54
+0.0016 5 36 55
+0.0016 0 37 56
+0.0016 1 38 57
+0.0016 2 39 58
+0.0016 3 40 59
+0.0016 10 47 60
+0.0016 11 42 61
+0.0016 6 43 62
+0.0016 7 44 63
+0.0016 8 45 64
+0.0016 9 46 65
+0.0016 16 53 66
+0.0016 17 48 67
+0.0016 12 49 68
+0.0016 13 50 69
+0.0016 14 51 70
+0.0016 15 52 71
+0.005600000000000001 36 37 56
+0.005600000000000001 37 38 57
+0.005600000000000001 38 39 58
+0.005600000000000001 39 40 59
+0.005600000000000001 40 41 54
+0.005600000000000001 36 41 55
+0.005600000000000001 42 43 62
+0.005600000000000001 43 44 63
+0.005600000000000001 44 45 64
+0.005600000000000001 45 46 65
+0.005600000000000001 46 47 60
+0.005600000000000001 42 47 61
+0.005600000000000001 48 49 68
+0.005600000000000001 49 50 69
+0.005600000000000001 50 51 70
+0.005600000000000001 51 52 71
+0.005600000000000001 52 53 66
+0.005600000000000001 48 53 67
+0.005600000000000001 38 54 55
+0.005600000000000001 39 55 56
+0.005600000000000001 40 56 57
+0.005600000000000001 41 57 58
+0.005600000000000001 36 58 59
+0.005600000000000001 37 54 59
+0.005600000000000001 44 60 61
+0.005600000000000001 45 61 62
+0.005600000000000001 46 62 63
+0.005600000000000001 47 63 64
+0.005600000000000001 42 64 65
+0.005600000000000001 43 60 65
+0.005600000000000001 50 66 67
+0.005600000000000001 51 67 68
+0.005600000000000001 52 68 69
+0.005600000000000001 53 69 70
+0.005600000000000001 48 70 71
+0.005600000000000001 49 66 71
+0.0108 36 72
+0.0108 37 73
+0.0108 38 74
+0.0108 39 75
+0.0108 40 76
+0.0108 41 77
+0.0108 42 78
+0.0108 43 79
+0.0108 44 80
+0.0108 45 81
+0.0108 46 82
+0.0108 47 83
+0.0108 48 84
+0.0108 49 85
+0.0108 50 86
+0.0108 51 87
+0.0108 52 88
+0.0108 53 89
+0.0108 54 90
+0.0108 55 91
+0.0108 56 92
+0.0108 57 93
+0.0108 58 94
+0.0108 59 95
+0.0108 60 96
+0.0108 61 97
+0.0108 62 98
+0.0108 63 99
+0.0108 64 100
+0.0108 65 101
+0.0108 66 102
+0.0108 67 103
+0.0108 68 104
+0.0108 69 105
+0.0108 70 106
+0.0108 71 107
+0.004 41 55 72
+0.004 36 56 73
+0.004 37 57 74
+0.004 38 58 75
+0.004 39 59 76
+0.004 40 54 77
+0.004 47 61 78
+0.004 42 62 79
+0.004 43 63 80
+0.004 44 64 81
+0.004 45 65 82
+0.004 46 60 83
+0.004 53 67 84
+0.004 48 68 85
+0.004 49 69 86
+0.004 50 70 87
+0.004 51 71 88
+0.004 52 66 89
+0.004 37 59 90
+0.004 38 54 91
+0.004 39 55 92
+0.004 40 56 93
+0.004 41 57 94
+0.004 36 58 95
+0.004 43 65 96
+0.004 44 60 97
+0.004 45 61 98
+0.004 46 62 99
+0.004 47 63 100
+0.004 42 64 101
+0.004 49 71 102
+0.004 50 66 103
+0.004 51 67 104
+0.004 52 68 105
+0.004 53 69 106
+0.004 48 70 107
+0.0016 37 42 48 57 64 70
+0.0016 38 43 49 58 65 71
+0.0016 39 44 50 59 60 66
+0.0016 40 45 51 54 61 67
+0.0016 41 46 52 55 62 68
+0.0016 36 47 53 56 63 69
+0.0016 40 43 48 54 63 70
+0.0016 41 44 49 55 64 71
+0.0016 36 45 50 56 65 66
+0.0016 37 46 51 57 60 67
+0.0016 38 47 52 58 61 68
+0.0016 39 42 53 59 62 69
+0.0016 40 46 49 54 60 69
+0.0016 41 47 50 55 61 70
+0.0016 36 42 51 56 62 71
+0.0016 37 43 52 57 63 66
+0.0016 38 44 53 58 64 67
+0.0016 39 45 48 59 65 68
+0.0016 39 46 52 55 60 66
+0.0016 40 47 53 56 61 67
+0.0016 41 42 48 57 62 68
+0.0016 36 43 49 58 63 69
+0.0016 37 44 50 59 64 70
+0.0016 38 45 51 54 65 71
+0.0016 36 45 52 58 61 66
+0.0016 37 46 53 59 62 67
+0.0016 38 47 48 54 63 68
+0.0016 39 42 49 55 64 69
+0.0016 40 43 50 56 65 70
+0.0016 41 44 51 57 60 71
+0.0016 36 42 51 58 64 67
+0.0016 37 43 52 59 65 68
+0.0016 38 44 53 54 60 69
+0.0016 39 45 48 55 61 70
+0.0016 40 46 49 56 62 71
+0.0016 41 47 50 57 63 66
+0.0016 45 66 72
+0.0016 46 67 73
+0.0016 47 68 74
+0.0016 42 69 75
+0.0016 43 70 76
+0.0016 44 71 77
+0.0016 36 51 78
+0.0016 37 52 79
+0.0016 38 53 80
+0.0016 39 48 81
+0.0016 40 49 82
+0.0016 41 50 83
+0.0016 42 57 84
+0.0016 43 58 85
+0.0016 44 59 86
+0.0016 45 54 87
+0.0016 46 55 88
+0.0016 47 56 89
+0.0016 48 63 90
+0.0016 49 64 91
+0.0016 50 65 92
+0.0016 51 60 93
+0.0016 52 61 94
+0.0016 53 62 95
+0.0016 54 69 96
+0.0016 55 70 97
+0.0016 56 71 98
+0.0016 57 66 99
+0.0016 58 67 100
+0.0016 59 68 101
+0.0016 39 60 102
+0.0016 40 61 103
+0.0016 41 62 104
+0.0016 36 63 105
+0.0016 37 64 106
+0.0016 38 65 107
+0.0016 42 48 64 70 74
+0.0016 43 49 65 71 75
+0.0016 44 50 60 66 76
+0.0016 45 51 61 67 77
+0.0016 46 52 62 68 72
+0.0016 47 53 63 69 73
+0.0016 40 48 54 70 80
+0.0016 41 49 55 71 81
+0.0016 36 50 56 66 82
+0.0016 37 51 57 67 83
+0.0016 38 52 58 68 78
+0.0016 39 53 59 69 79
+0.0016 40 46 54 60 86
+0.0016 41 47 55 61 87
+0.0016 36 42 56 62 88
+0.0016 37 43 57 63 89
+0.0016 38 44 58 64 84
+0.0016 39 45 59 65 85
+0.0016 46 52 60 66 92
+0.0016 47 53 61 67 93
+0.0016 42 48 62 68 94
+0.0016 43 49 63 69 95
+0.0016 44 50 64 70 90
+0.0016 45 51 65 71 91
+0.0016 36 52 58 66 98
+0.0016 37 53 59 67 99
+0.0016 38 48 54 68 100
+0.0016 39 49 55 69 101
+0.0016 40 50 56 70 96
+0.0016 41 51 57 71 97
+0.0016 36 42 58 64 104
+0.0016 37 43 59 65 105
+0.0016 38 44 54 60 106
+0.0016 39 45 55 61 107
+0.0016 40 46 56 62 102
+0.0016 41 47 57 63 103
+0.0016 63 72 105
+0.0016 64 73 106
+0.0016 65 74 107
+0.0016 60 75 102
+0.0016 61 76 103
+0.0016 62 77 104
+0.0016 69 75 78
+0.0016 70 76 79
+0.0016 71 77 80
+0.0016 66 72 81
+0.0016 67 73 82
+0.0016 68 74 83
+0.0016 39 81 84
+0.0016 40 82 85
+0.0016 41 83 86
+0.0016 36 78 87
+0.0016 37 79 88
+0.0016 38 80 89
+0.0016 45 87 90
+0.0016 46 88 91
+0.0016 47 89 92
+0.0016 42 84 93
+0.0016 43 85 94
+0.0016 44 86 95
+0.0016 51 93 96
+0.0016 52 94 97
+0.0016 53 95 98
+0.0016 48 90 99
+0.0016 49 91 100
+0.0016 50 92 101
+0.0016 57 99 102
+0.0016 58 100 103
+0.0016 59 101 104
+0.0016 54 96 105
+0.0016 55 97 106
+0.0016 56 98 107
+0.0016 42 64 74 107
+0.0016 43 65 75 102
+0.0016 44 60 76 103
+0.0016 45 61 77 104
+0.0016 46 62 72 105
+0.0016 47 63 73 106
+0.0016 48 70 77 80
+0.0016 49 71 72 81
+0.0016 50 66 73 82
+0.0016 51 67 74 83
+0.0016 52 68 75 78
+0.0016 53 69 76 79
+0.0016 40 54 83 86
+0.0016 41 55 78 87
+0.0016 36 56 79 88
+0.0016 37 57 80 89
+0.0016 38 58 81 84
+0.0016 39 59 82 85
+0.0016 46 60 89 92
+0.0016 47 61 84 93
+0.0016 42 62 85 94
+0.0016 43 63 86 95
+0.0016 44 64 87 90
+0.0016 45 65 88 91
+0.0016 52 66 95 98
+0.0016 53 67 90 99
+0.0016 48 68 91 100
+0.0016 49 69 92 101
+0.0016 50 70 93 96
+0.0016 51 71 94 97
+0.0016 36 58 101 104
+0.0016 37 59 96 105
+0.0016 38 54 97 106
+0.0016 39 55 98 107
+0.0016 40 56 99 102
+0.0016 41 57 100 103
+0.011200000000000002 72 78 87
+0.011200000000000002 73 79 88
+0.011200000000000002 74 80 89
+0.011200000000000002 75 81 84
+0.011200000000000002 76 82 85
+0.011200000000000002 77 83 86
+0.011200000000000002 78 84 93
+0.011200000000000002 79 85 94
+0.011200000000000002 80 86 95
+0.011200000000000002 81 87 90
+0.011200000000000002 82 88 91
+0.011200000000000002 83 89 92
+0.011200000000000002 84 90 99
+0.011200000000000002 85 91 100
+0.011200000000000002 86 92 101
+0.011200000000000002 87 93 96
+0.011200000000000002 88 94 97
+0.011200000000000002 89 95 98
+0.011200000000000002 90 96 105
+0.011200000000000002 91 97 106
+0.011200000000000002 92 98 107
+0.011200000000000002 93 99 102
+0.011200000000000002 94 100 103
+0.011200000000000002 95 101 104
+0.011200000000000002 75 96 102
+0.011200000000000002 76 97 103
+0.011200000000000002 77 98 104
+0.011200000000000002 72 99 105
+0.011200000000000002 73 100 106
+0.011200000000000002 74 101 107
+0.011200000000000002 72 81 102
+0.011200000000000002 73 82 103
+0.011200000000000002 74 83 104
+0.011200000000000002 75 78 105
+0.011200000000000002 76 79 106
+0.011200000000000002 77 80 107
+0.0016 58 72 95
+0.0016 59 73 90
+0.0016 54 74 91
+0.0016 55 75 92
+0.0016 56 76 93
+0.0016 57 77 94
+0.0016 64 78 101
+0.0016 65 79 96
+0.0016 60 80 97
+0.0016 61 81 98
+0.0016 62 82 99
+0.0016 63 83 100
+0.0016 70 84 107
+0.0016 71 85 102
+0.0016 66 86 103
+0.0016 67 87 104
+0.0016 68 88 105
+0.0016 69 89 106
+0.0016 40 77 90
+0.0016 41 72 91
+0.0016 36 73 92
+0.0016 37 74 93
+0.0016 38 75 94
+0.0016 39 76 95
+0.0016 46 83 96
+0.0016 47 78 97
+0.0016 42 79 98
+0.0016 43 80 99
+0.0016 44 81 100
+0.0016 45 82 101
+0.0016 52 89 102
+0.0016 53 84 103
+0.0016 48 85 104
+0.0016 49 86 105
+0.0016 50 87 106
+0.0016 51 88 107
+0.005600000000000001 72 73 92
+0.005600000000000001 73 74 93
+0.005600000000000001 74 75 94
+0.005600000000000001 75 76 95
+0.005600000000000001 76 77 90
+0.005600000000000001 72 77 91
+0.005600000000000001 78 79 98
+0.005600000000000001 79 80 99
+0.005600000000000001 80 81 100
+0.005600000000000001 81 82 101
+0.005600000000000001 82 83 96
+0.005600000000000001 78 83 97
+0.005600000000000001 84 85 104
+0.005600000000000001 85 86 105
+0.005600000000000001 86 87 106
+0.005600000000000001 87 88 107
+0.005600000000000001 88 89 102
+0.005600000000000001 84 89 103
+0.005600000000000001 74 90 91
+0.005600000000000001 75 91 92
+0.005600000000000001 76 92 93
+0.005600000000000001 77 93 94
+0.005600000000000001 72 94 95
+0.005600000000000001 73 90 95
+0.005600000000000001 80 96 97
+0.005600000000000001 81 97 98
+0.005600000000000001 82 98 99
+0.005600000000000001 83 99 100
+0.005600000000000001 78 100 101
+0.005600000000000001 79 96 101
+0.005600000000000001 86 102 103
+0.005600000000000001 87 103 104
+0.005600000000000001 88 104 105
+0.005600000000000001 89 105 106
+0.005600000000000001 84 106 107
+0.005600000000000001 85 102 107
+0.0108 72 108
+0.0108 73 109
+0.0108 74 110
+0.0108 75 111
+0.0108 76 112
+0.0108 77 113
+0.0108 78 114
+0.0108 79 115
+0.0108 80 116
+0.0108 81 117
+0.0108 82 118
+0.0108 83 119
+0.0108 84 120
+0.0108 85 121
+0.0108 86 122
+0.0108 87 123
+0.0108 88 124
+0.0108 89 125
+0.0108 90 126
+0.0108 91 127
+0.0108 92 128
+0.0108 93 129
+0.0108 94 130
+0.0108 95 131
+0.0108 96 132
+0.0108 97 133
+0.0108 98 134
+0.0108 99 135
+0.0108 100 136
+0.0108 101 137
+0.0108 102 138
+0.0108 103 139
+0.0108 104 140
+0.0108 105 141
+0.0108 106 142
+0.0108 107 143
+0.004 77 91 108
+0.004 72 92 109
+0.004 73 93 110
+0.004 74 94 111
+0.004 75 95 112
+0.004 76 90 113
+0.004 83 97 114
+0.004 78 98 115
+0.004 79 99 116
+0.004 80 100 117
+0.004 81 101 118
+0.004 82 96 119
+0.004 89 103 120
+0.004 84 104 121
+0.004 85 105 122
+0.004 86 106 123
+0.004 87 107 124
+0.004 88 102 125
+0.004 73 95 126
+0.004 74 90 127
+0.004 75 91 128
+0.004 76 92 129
+0.004 77 93 130
+0.004 72 94 131
+0.004 79 101 132
+0.004 80 96 133
+0.004 81 97 134
+0.004 82 98 135
+0.004 83 99 136
+0.004 78 100 137
+0.004 85 107 138
+0.004 86 102 139
+0.004 87 103 140
+0.004 88 104 141
+0.004 89 105 142
+0.004 84 106 143
+0.0016 73 78 84 93 100 106
+0.0016 74 79 85 94 101 107
+0.0016 75 80 86 95 96 102
+0.0016 76 81 87 90 97 103
+0.0016 77 82 88 91 98 104
+0.0016 72 83 89 92 99 105
+0.0016 76 79 84 90 99 106
+0.0016 77 80 85 91 100 107
+0.0016 72 81 86 92 101 102
+0.0016 73 82 87 93 96 103
+0.0016 74 83 88 94 97 104
+0.0016 75 78 89 95 98 105
+0.0016 76 82 85 90 96 105
+0.0016 77 83 86 91 97 106
+0.0016 72 78 87 92 98 107
+0.0016 73 79 88 93 99 102
+0.0016 74 80 89 94 100 103
+0.0016 75 81 84 95 101 104
+0.0016 75 82 88 91 96 102
+0.0016 76 83 89 92 97 103
+0.0016 77 78 84 93 98 104
+0.0016 72 79 85 94 99 105
+0.0016 73 80 86 95 100 106
+0.0016 74 81 87 90 101 107
+0.0016 72 81 88 94 97 102
+0.0016 73 82 89 95 98 103
+0.0016 74 83 84 90 99 104
+0.0016 75 78 85 91 100 105
+0.0016 76 79 86 92 101 106
+0.0016 77 80 87 93 96 107
+0.0016 72 78 87 94 100 103
+0.0016 73 79 88 95 101 104
+0.0016 74 80 89 90 96 105
+0.0016 75 81 84 91 97 106
+0.0016 76 82 85 92 98 107
+0.0016 77 83 86 93 99 102
+0.0016 81 102 108
+0.0016 82 103 109
+0.0016 83 104 110
+0.0016 78 105 111
+0.0016 79 106 112
+0.0016 80 107 113
+0.0016 72 87 114
+0.0016 73 88 115
+0.0016 74 89 116
+0.0016 75 84 117
+0.0016 76 85 118
+0.0016 77 86 119
+0.0016 78 93 120
+0.0016 79 94 121
+0.0016 80 95 122
+0.0016 81 90 123
+0.0016 82 91 124
+0.0016 83 92 125
+0.0016 84 99 126
+0.0016 85 100 127
+0.0016 86 101 128
+0.0016 87 96 129
+0.0016 88 97 130
+0.0016 89 98 131
+0.0016 90 105 132
+0.0016 91 106 133
+0.0016 92 107 134
+0.0016 93 102 135
+0.0016 94 103 136
+0.0016 95 104 137
+0.0016 75 96 138
+0.0016 76 97 139
+0.0016 77 98 140
+0.0016 72 99 141
+0.0016 73 100 142
+0.0016 74 101 143
+0.0016 78 84 100 106 110
+0.0016 79 85 101 107 111
+0.0016 80 86 96 102 112
+0.0016 81 87 97 103 113
+0.0016 82 88 98 104 108
+0.0016 83 89 99 105 109
+0.0016 76 84 90 106 116
+0.0016 77 85 91 107 117
+0.0016 72 86 92 102 118
+0.0016 73 87 93 103 119
+0.0016 74 88 94 104 114
+0.0016 75 89 95 105 115
+0.0016 76 82 90 96 122
+0.0016 77 83 91 97 123
+0.0016 72 78 92 98 124
+0.0016 73 79 93 99 125
+0.0016 74 80 94 100 120
+0.0016 75 81 95 101 121
+0.0016 82 88 96 102 128
+0.0016 83 89 97 103 129
+0.0016 78 84 98 104 130
+0.0016 79 85 99 105 131
+0.0016 80 86 100 106 126
+0.0016 81 87 101 107 127
+0.0016 72 88 94 102 134
+0.0016 73 89 95 103 135
+0.0016 74 84 90 104 136
+0.0016 75 85 91 105 137
+0.0016 76 86 92 106 132
+0.0016 77 87 93 107 133
+0.0016 72 78 94 100 140
+0.0016 73 79 95 101 141
+0.0016 74 80 90 96 142
+0.0016 75 81 91 97 143
+0.0016 76 82 92 98 138
+0.0016 77 83 93 99 139
+0.0016 99 108 141
+0.0016 100 109 142
+0.0016 101 110 143
+0.0016 96 111 138
+0.0016 97 112 139
+0.0016 98 113 140
+0.0016 105 111 114
+0.0016 106 112 115
+0.0016 107 113 116
+0.0016 102 108 117
+0.0016 103 109 118
+0.0016 104 110 119
+0.0016 75 117 120
+0.0016 76 118 121
+0.0016 77 119 122
+0.0016 72 114 123
+0.0016 73 115 124
+0.0016 74 116 125
+0.0016 81 123 126
+0.0016 82 124 127
+0.0016 83 125 128
+0.0016 78 120 129
+0.0016 79 121 130
+0.0016 80 122 131
+0.0016 87 129 132
+0.0016 88 130 133
+0.0016 89 131 134
+0.0016 84 126 135
+0.0016 85 127 136
+0.0016 86 128 137
+0.0016 93 135 138
+0.0016 94 136 139
+0.0016 95 137 140
+0.0016 90 132 141
+0.0016 91 133 142
+0.0016 92 134 143
+0.0016 78 100 110 143
+0.0016 79 101 111 138
+0.0016 80 96 112 139
+0.0016 81 97 113 140
+0.0016 82 98 108 141
+0.0016 83 99 109 142
+0.0016 84 106 113 116
+0.0016 85 107 108 117
+0.0016 86 102 109 118
+0.0016 87 103 110 119
+0.0016 88 104 111 114
+0.0016 89 105 112 115
+0.0016 76 90 119 122
+0.0016 77 91 114 123
+0.0016 72 92 115 124
+0.0016 73 93 116 125
+0.0016 74 94 117 120
+0.0016 75 95 118 121
+0.0016 82 96 125 128
+0.0016 83 97 120 129
+0.0016 78 98 121 130
+0.0016 79 99 122 131
+0.0016 80 100 123 126
+0.0016 81 101 124 127
+0.0016 88 102 131 134
+0.0016 89 103 126 135
+0.0016 84 104 127 136
+0.0016 85 105 128 137
+0.0016 86 106 129 132
+0.0016 87 107 130 133
+0.0016 72 94 137 140
+0.0016 73 95 132 141
+0.0016 74 90 133 142
+0.0016 75 91 134 143
+0.0016 76 92 135 138
+0.0016 77 93 136 139
+0.011200000000000002 108 114 123
+0.011200000000000002 109 115 124
+0.011200000000000002 110 116 125
+0.011200000000000002 111 117 120
+0.011200000000000002 112 118 121
+0.011200000000000002 113 119 122
+0.011200000000000002 114 120 129
+0.011200000000000002 115 121 130
+0.011200000000000002 116 122 131
+0.011200000000000002 117 123 126
+0.011200000000000002 118 124 127
+0.011200000000000002 119 125 128
+0.011200000000000002 120 126 135
+0.011200000000000002 121 127 136
+0.011200000000000002 122 128 137
+0.011200000000000002 123 129 132
+0.011200000000000002 124 130 133
+0.011200000000000002 125 131 134
+0.011200000000000002 126 132 141
+0.011200000000000002 127 133 142
+0.011200000000000002 128 134 143
+0.011200000000000002 129 135 138
+0.011200000000000002 130 136 139
+0.011200000000000002 131 137 140
+0.011200000000000002 111 132 138
+0.011200000000000002 112 133 139
+0.011200000000000002 113 134 140
+0.011200000000000002 108 135 141
+0.011200000000000002 109 136 142
+0.011200000000000002 110 137 143
+0.011200000000000002 108 117 138
+0.011200000000000002 109 118 139
+0.011200000000000002 110 119 140
+0.011200000000000002 111 114 141
+0.011200000000000002 112 115 142
+0.011200000000000002 113 116 143
+0.0016 94 108 131
+0.0016 95 109 126
+0.0016 90 110 127
+0.0016 91 111 128
+0.0016 92 112 129
+0.0016 93 113 130
+0.0016 100 114 137
+0.0016 101 115 132
+0.0016 96 116 133
+0.0016 97 117 134
+0.0016 98 118 135
+0.0016 99 119 136
+0.0016 106 120 143
+0.0016 107 121 138
+0.0016 102 122 139
+0.0016 103 123 140
+0.0016 104 124 141
+0.0016 105 125 142
+0.0016 76 113 126
+0.0016 77 108 127
+0.0016 72 109 128
+0.0016 73 110 129
+0.0016 74 111 130
+0.0016 75 112 131
+0.0016 82 119 132
+0.0016 83 114 133
+0.0016 78 115 134
+0.0016 79 116 135
+0.0016 80 117 136
+0.0016 81 118 137
+0.0016 88 125 138
+0.0016 89 120 139
+0.0016 84 121 140
+0.0016 85 122 141
+0.0016 86 123 142
+0.0016 87 124 143
+0.005600000000000001 108 109 128
+0.005600000000000001 109 110 129
+0.005600000000000001 110 111 130
+0.005600000000000001 111 112 131
+0.005600000000000001 112 113 126
+0.005600000000000001 108 113 127
+0.005600000000000001 114 115 134
+0.005600000000000001 115 116 135
+0.005600000000000001 116 117 136
+0.005600000000000001 117 118 137
+0.005600000000000001 118 119 132
+0.005600000000000001 114 119 133
+0.005600000000000001 120 121 140
+0.005600000000000001 121 122 141
+0.005600000000000001 122 123 142
+0.005600000000000001 123 124 143
+0.005600000000000001 124 125 138
+0.005600000000000001 120 125 139
+0.005600000000000001 110 126 127
+0.005600000000000001 111 127 128
+0.005600000000000001 112 128 129
+0.005600000000000001 113 129 130
+0.005600000000000001 108 130 131
+0.005600000000000001 109 126 131
+0.005600000000000001 116 132 133
+0.005600000000000001 117 133 134
+0.005600000000000001 118 134 135
+0.005600000000000001 119 135 136
+0.005600000000000001 114 136 137
+0.005600000000000001 115 132 137
+0.005600000000000001 122 138 139
+0.005600000000000001 123 139 140
+0.005600000000000001 124 140 141
+0.005600000000000001 125 141 142
+0.005600000000000001 120 142 143
+0.005600000000000001 121 138 143
+0.0108 108 144
+0.0108 109 145
+0.0108 110 146
+0.0108 111 147
+0.0108 112 148
+0.0108 113 149
+0.0108 114 150
+0.0108 115 151
+0.0108 116 152
+0.0108 117 153
+0.0108 118 154
+0.0108 119 155
+0.0108 120 156
+0.0108 121 157
+0.0108 122 158
+0.0108 123 159
+0.0108 124 160
+0.0108 125 161
+0.0108 126 162
+0.0108 127 163
+0.0108 128 164
+0.0108 129 165
+0.0108 130 166
+0.0108 131 167
+0.0108 132 168
+0.0108 133 169
+0.0108 134 170
+0.0108 135 171
+0.0108 136 172
+0.0108 137 173
+0.0108 138 174
+0.0108 139 175
+0.0108 140 176
+0.0108 141 177
+0.0108 142 178
+0.0108 143 179
+0.004 113 127 144
+0.004 108 128 145
+0.004 109 129 146
+0.004 110 130 147
+0.004 111 131 148
+0.004 112 126 149
+0.004 119 133 150
+0.004 114 134 151
+0.004 115 135 152
+0.004 116 136 153
+0.004 117 137 154
+0.004 118 132 155
+0.004 125 139 156
+0.004 120 140 157
+0.004 121 141 158
+0.004 122 142 159
+0.004 123 143 160
+0.004 124 138 161
+0.004 109 131 162
+0.004 110 126 163
+0.004 111 127 164
+0.004 112 128 165
+0.004 113 129 166
+0.004 108 130 167
+0.004 115 137 168
+0.004 116 132 169
+0.004 117 133 170
+0.004 118 134 171
+0.004 119 135 172
+0.004 114 136 173
+0.004 121 143 174
+0.004 122 138 175
+0.004 123 139 176
+0.004 124 140 177
+0.004 125 141 178
+0.004 120 142 179
+0.0016 109 114 120 129 136 142
+0.0016 110 115 121 130 137 143
+0.0016 111 116 122 131 132 138
+0.0016 112 117 123 126 133 139
+0.0016 113 118 124 127 134 140
+0.0016 108 119 125 128 135 141
+0.0016 112 115 120 126 135 142
+0.0016 113 116 121 127 136 143
+0.0016 108 117 122 128 137 138
+0.0016 109 118 123 129 132 139
+0.0016 110 119 124 130 133 140
+0.0016 111 114 125 131 134 141
+0.0016 112 118 121 126 132 141
+0.0016 113 119 122 127 133 142
+0.0016 108 114 123 128 134 143
+0.0016 109 115 124 129 135 138
+0.0016 110 116 125 130 136 139
+0.0016 111 117 120 131 137 140
+0.0016 111 118 124 127 132 138
+0.0016 112 119 125 128 133 139
+0.0016 113 114 120 129 134 140
+0.0016 108 115 121 130 135 141
+0.0016 109 116 122 131 136 142
+0.0016 110 117 123 126 137 143
+0.0016 108 117 124 130 133 138
+0.0016 109 118 125 131 134 139
+0.0016 110 119 120 126 135 140
+0.0016 111 114 121 127 136 141
+0.0016 112 115 122 128 137 142
+0.0016 113 116 123 129 132 143
+0.0016 108 114 123 130 136 139
+0.0016 109 115 124 131 137 140
+0.0016 110 116 125 126 132 141
+0.0016 111 117 120 127 133 142
+0.0016 112 118 121 128 134 143
+0.0016 113 119 122 129 135 138
+0.0016 117 138 144
+0.0016 118 139 145
+0.0016 119 140 146
+0.0016 114 141 147
+0.0016 115 142 148
+0.0016 116 143 149
+0.0016 108 123 150
+0.0016 109 124 151
+0.0016 110 125 152
+0.0016 111 120 153
+0.0016 112 121 154
+0.0016 113 122 155
+0.0016 114 129 156
+0.0016 115 130 157
+0.0016 116 131 158
+0.0016 117 126 159
+0.0016 118 127 160
+0.0016 119 128 161
+0.0016 120 135 162
+0.0016 121 136 163
+0.0016 122 137 164
+0.0016 123 132 165
+0.0016 124 133 166
+0.0016 125 134 167
+0.0016 126 141 168
+0.0016 127 142 169
+0.0016 128 143 170
+0.0016 129 138 171
+0.0016 130 139 172
+0.0016 131 140 173
+0.0016 111 132 174
+0.0016 112 133 175
+0.0016 113 134 176
+0.0016 108 135 177
+0.0016 109 136 178
+0.0016 110 137 179
+0.0016 114 120 136 142 146
+0.0016 115 121 137 143 147
+0.0016 116 122 132 138 148
+0.0016 117 123 133 139 149
+0.0016 118 124 134 140 144
+0.0016 119 125 135 141 145
+0.0016 112 120 126 142 152
+0.0016 113 121 127 143 153
+0.0016 108 122 128 138 154
+0.0016 109 123 129 139 155
+0.0016 110 124 130 140 150
+0.0016 111 125 131 141 151
+0.0016 112 118 126 132 158
+0.0016 113 119 127 133 159
+0.0016 108 114 128 134 160
+0.0016 109 115 129 135 161
+0.0016 110 116 130 136 156
+0.0016 111 117 131 137 157
+0.0016 118 124 132 138 164
+0.0016 119 125 133 139 165
+0.0016 114 120 134 140 166
+0.0016 115 121 135 141 167
+0.0016 116 122 136 142 162
+0.0016 117 123 137 143 163
+0.0016 108 124 130 138 170
+0.0016 109 125 131 139 171
+0.0016 110 120 126 140 172
+0.0016 111 121 127 141 173
+0.0016 112 122 128 142 168
+0.0016 113 123 129 143 169
+0.0016 108 114 130 136 176
+0.0016 109 115 131 137 177
+0.0016 110 116 126 132 178
+0.0016 111 117 127 133 179
+0.0016 112 118 128 134 174
+0.0016 113 119 129 135 175
+0.0016 135 144 177
+0.0016 136 145 178
+0.0016 137 146 179
+0.0016 132 147 174
+0.0016 133 148 175
+0.0016 134 149 176
+0.0016 141 147 150
+0.0016 142 148 151
+0.0016 143 149 152
+0.0016 138 144 153
+0.0016 139 145 154
+0.0016 140 146 155
+0.0016 111 153 156
+0.0016 112 154 157
+0.0016 113 155 158
+0.0016 108 150 159
+0.0016 109 151 160
+0.0016 110 152 161
+0.0016 117 159 162
+0.0016 118 160 163
+0.0016 119 161 164
+0.0016 114 156 165
+0.0016 115 157 166
+0.0016 116 158 167
+0.0016 123 165 168
+0.0016 124 166 169
+0.0016 125 167 170
+0.0016 120 162 171
+0.0016 121 163 172
+0.0016 122 164 173
+0.0016 129 171 174
+0.0016 130 172 175
+0.0016 131 173 176
+0.0016 126 168 177
+0.0016 127 169 178
+0.0016 128 170 179
+0.0016 114 136 146 179
+0.0016 115 137 147 174
+0.0016 116 132 148 175
+0.0016 117 133 149 176
+0.0016 118 134 144 177
+0.0016 119 135 145 178
+0.0016 120 142 149 152
+0.0016 121 143 144 153
+0.0016 122 138 145 154
+0.0016 123 139 146 155
+0.0016 124 140 147 150
+0.0016 125 141 148 151
+0.0016 112 126 155 158
+0.0016 113 127 150 159
+0.0016 108 128 151 160
+0.0016 109 129 152 161
+0.0016 110 130 153 156
+0.0016 111 131 154 157
+0.0016 118 132 161 164
+0.0016 119 133 156 165
+0.0016 114 134 157 166
+0.0016 115 135 158 167
+0.0016 116 136 159 162
+0.0016 117 137 160 163
+0.0016 124 138 167 170
+0.0016 125 139 162 171
+0.0016 120 140 163 172
+0.0016 121 141 164 173
+0.0016 122 142 165 168
+0.0016 123 143 166 169
+0.0016 108 130 173 176
+0.0016 109 131 168 177
+0.0016 110 126 169 178
+0.0016 111 127 170 179
+0.0016 112 128 171 174
+0.0016 113 129 172 175
+0.011200000000000002 144 150 159
+0.011200000000000002 145 151 160
+0.011200000000000002 146 152 161
+0.011200000000000002 147 153 156
+0.011200000000000002 148 154 157
+0.011200000000000002 149 155 158
+0.011200000000000002 150 156 165
+0.011200000000000002 151 157 166
+0.011200000000000002 152 158 167
+0.011200000000000002 153 159 162
+0.011200000000000002 154 160 163
+0.011200000000000002 155 161 164
+0.011200000000000002 156 162 171
+0.011200000000000002 157 163 172
+0.011200000000000002 158 164 173
+0.011200000000000002 159 165 168
+0.011200000000000002 160 166 169
+0.011200000000000002 161 167 170
+0.011200000000000002 162 168 177
+0.011200000000000002 163 169 178
+0.011200000000000002 164 170 179
+0.011200000000000002 165 171 174
+0.011200000000000002 166 172 175
+0.011200000000000002 167 173 176
+0.011200000000000002 147 168 174
+0.011200000000000002 148 169 175
+0.011200000000000002 149 170 176
+0.011200000000000002 144 171 177
+0.011200000000000002 145 172 178
+0.011200000000000002 146 173 179
+0.011200000000000002 144 153 174
+0.011200000000000002 145 154 175
+0.011200000000000002 146 155 176
+0.011200000000000002 147 150 177
+0.011200000000000002 148 151 178
+0.011200000000000002 149 152 179
+0.0016 130 144 167
+0.0016 131 145 162
+0.0016 126 146 163
+0.0016 127 147 164
+0.0016 128 148 165
+0.0016 129 149 166
+0.0016 136 150 173
+0.0016 137 151 168
+0.0016 132 152 169
+0.0016 133 153 170
+0.0016 134 154 171
+0.0016 135 155 172
+0.0016 142 156 179
+0.0016 143 157 174
+0.0016 138 158 175
+0.0016 139 159 176
+0.0016 140 160 177
+0.0016 141 161 178
+0.0016 112 149 162
+0.0016 113 144 163
+0.0016 108 145 164
+0.0016 109 146 165
+0.0016 110 147 166
+0.0016 111 148 167
+0.0016 118 155 168
+0.0016 119 150 169
+0.0016 114 151 170
+0.0016 115 152 171
+0.0016 116 153 172
+0.0016 117 154 173
+0.0016 124 161 174
+0.0016 125 156 175
+0.0016 120 157 176
+0.0016 121 158 177
+0.0016 122 159 178
+0.0016 123 160 179
+0.005600000000000001 144 145 164
+0.005600000000000001 145 146 165
+0.005600000000000001 146 147 166
+0.005600000000000001 147 148 167
+0.005600000000000001 148 149 162
+0.005600000000000001 144 149 163
+0.005600000000000001 150 151 170
+0.005600000000000001 151 152 171
+0.005600000000000001 152 153 172
+0.005600000000000001 153 154 173
+0.005600000000000001 154 155 168
+0.005600000000000001 150 155 169
+0.005600000000000001 156 157 176
+0.005600000000000001 157 158 177
+0.005600000000000001 158 159 178
+0.005600000000000001 159 160 179
+0.005600000000000001 160 161 174
+0.005600000000000001 156 161 175
+0.005600000000000001 146 162 163
+0.005600000000000001 147 163 164
+0.005600000000000001 148 164 165
+0.005600000000000001 149 165 166
+0.005600000000000001 144 166 167
+0.005600000000000001 145 162 167
+0.005600000000000001 152 168 169
+0.005600000000000001 153 169 170
+0.005600000000000001 154 170 171
+0.005600000000000001 155 171 172
+0.005600000000000001 150 172 173
+0.005600000000000001 151 168 173
+0.005600000000000001 158 174 175
+0.005600000000000001 159 175 176
+0.005600000000000001 160 176 177
+0.005600000000000001 161 177 178
+0.005600000000000001 156 178 179
+0.005600000000000001 157 174 179
+0.0108 144 180
+0.0108 145 181
+0.0108 146 182
+0.0108 147 183
+0.0108 148 184
+0.0108 149 185
+0.0108 150 186
+0.0108 151 187
+0.0108 152 188
+0.0108 153 189
+0.0108 154 190
+0.0108 155 191
+0.0108 156 192
+0.0108 157 193
+0.0108 158 194
+0.0108 159 195
+0.0108 160 196
+0.0108 161 197
+0.0108 162 198
+0.0108 163 199
+0.0108 164 200
+0.0108 165 201
+0.0108 166 202
+0.0108 167 203
+0.0108 168 204
+0.0108 169 205
+0.0108 170 206
+0.0108 171 207
+0.0108 172 208
+0.0108 173 209
+0.0108 174 210
+0.0108 175 211
+0.0108 176 212
+0.0108 177 213
+0.0108 178 214
+0.0108 179 215
+0.004 149 163 180
+0.004 144 164 181
+0.004 145 165 182
+0.004 146 166 183
+0.004 147 167 184
+0.004 148 162 185
+0.004 155 169 186
+0.004 150 170 187
+0.004 151 171 188
+0.004 152 172 189
+0.004 153 173 190
+0.004 154 168 191
+0.004 161 175 192
+0.004 156 176 193
+0.004 157 177 194
+0.004 158 178 195
+0.004 159 179 196
+0.004 160 174 197
+0.004 145 167 198
+0.004 146 162 199
+0.004 147 163 200
+0.004 148 164 201
+0.004 149 165 202
+0.004 144 166 203
+0.004 151 173 204
+0.004 152 168 205
+0.004 153 169 206
+0.004 154 170 207
+0.004 155 171 208
+0.004 150 172 209
+0.004 157 179 210
+0.004 158 174 211
+0.004 159 175 212
+0.004 160 176 213
+0.004 161 177 214
+0.004 156 178 215
+0.0016 145 150 156 165 172 178
+0.0016 146 151 157 166 173 179
+0.0016 147 152 158 167 168 174
+0.0016 148 153 159 162 169 175
+0.0016 149 154 160 163 170 176
+0.0016 144 155 161 164 171 177
+0.0016 148 151 156 162 171 178
+0.0016 149 152 157 163 172 179
+0.0016 144 153 158 164 173 174
+0.0016 145 154 159 165 168 175
+0.0016 146 155 160 166 169 176
+0.0016 147 150 161 167 170 177
+0.0016 148 154 157 162 168 177
+0.0016 149 155 158 163 169 178
+0.0016 144 150 159 164 170 179
+0.0016 145 151 160 165 171 174
+0.0016 146 152 161 166 172 175
+0.0016 147 153 156 167 173 176
+0.0016 147 154 160 163 168 174
+0.0016 148 155 161 164 169 175
+0.0016 149 150 156 165 170 176
+0.0016 144 151 157 166 171 177
+0.0016 145 152 158 167 172 178
+0.0016 146 153 159 162 173 179
+0.0016 144 153 160 166 169 174
+0.0016 145 154 161 167 170 175
+0.0016 146 155 156 162 171 176
+0.0016 147 150 157 163 172 177
+0.0016 148 151 158 164 173 178
+0.0016 149 152 159 165 168 179
+0.0016 144 150 159 166 172 175
+0.0016 145 151 160 167 173 176
+0.0016 146 152 161 162 168 177
+0.0016 147 153 156 163 169 178
+0.0016 148 154 157 164 170 179
+0.0016 149 155 158 165 171 174
+0.0016 153 174 180
+0.0016 154 175 181
+0.0016 155 176 182
+0.0016 150 177 183
+0.0016 151 178 184
+0.0016 152 179 185
+0.0016 144 159 186
+0.0016 145 160 187
+0.0016 146 161 188
+0.0016 147 156 189
+0.0016 148 157 190
+0.0016 149 158 191
+0.0016 150 165 192
+0.0016 151 166 193
+0.0016 152 167 194
+0.0016 153 162 195
+0.0016 154 163 196
+0.0016 155 164 197
+0.0016 156 171 198
+0.0016 157 172 199
+0.0016 158 173 200
+0.0016 159 168 201
+0.0016 160 169 202
+0.0016 161 170 203
+0.0016 162 177 204
+0.0016 163 178 205
+0.0016 164 179 206
+0.0016 165 174 207
+0.0016 166 175 208
+0.0016 167 176 209
+0.0016 147 168 210
+0.0016 148 169 211
+0.0016 149 170 212
+0.0016 144 171 213
+0.0016 145 172 214
+0.0016 146 173 215
+0.0016 150 156 172 178 182
+0.0016 151 157 173 179 183
+0.0016 152 158 168 174 184
+0.0016 153 159 169 175 185
+0.0016 154 160 170 176 180
+0.0016 155 161 171 177 181
+0.0016 148 156 162 178 188
+0.0016 149 157 163 179 189
+0.0016 144 158 164 174 190
+0.0016 145 159 165 175 191
+0.0016 146 160 166 176 186
+0.0016 147 161 167 177 187
+0.0016 148 154 162 168 194
+0.0016 149 155 163 169 195
+0.0016 144 150 164 170 196
+0.0016 145 151 165 171 197
+0.0016 146 152 166 172 192
+0.0016 147 153 167 173 193
+0.0016 154 160 168 174 200
+0.0016 155 161 169 175 201
+0.0016 150 156 170 176 202
+0.0016 151 157 171 177 203
+0.0016 152 158 172 178 198
+0.0016 153 159 173 179 199
+0.0016 144 160 166 174 206
+0.0016 145 161 167 175 207
+0.0016 146 156 162 176 208
+0.0016 147 157 163 177 209
+0.0016 148 158 164 178 204
+0.0016 149 159 165 179 205
+0.0016 144 150 166 172 212
+0.0016 145 151 167 173 213
+0.0016 146 152 162 168 214
+0.0016 147 153 163 169 215
+0.0016 148 154 164 170 210
+0.0016 149 155 165 171 211
+0.0016 171 180 213
+0.0016 172 181 214
+0.0016 173 182 215
+0.0016 168 183 210
+0.0016 169 184 211
+0.0016 170 185 212
+0.0016 177 183 186
+0.0016 178 184 187
+0.0016 179 185 188
+0.0016 174 180 189
+0.0016 175 181 190
+0.0016 176 182 191
+0.0016 147 189 192
+0.0016 148 190 193
+0.0016 149 191 194
+0.0016 144 186 195
+0.0016 145 187 196
+0.0016 146 188 197
+0.0016 153 195 198
+0.0016 154 196 199
+0.0016 155 197 200
+0.0016 150 192 201
+0.0016 151 193 202
+0.0016 152 194 203
+0.0016 159 201 204
+0.0016 160 202 205
+0.0016 161 203 206
+0.0016 156 198 207
+0.0016 157 199 208
+0.0016 158 200 209
+0.0016 165 207 210
+0.0016 166 208 211
+0.0016 167 209 212
+0.0016 162 204 213
+0.0016 163 205 214
+0.0016 164 206 215
+0.0016 150 172 182 215
+0.0016 151 173 183 210
+0.0016 152 168 184 211
+0.0016 153 169 185 212
+0.0016 154 170 180 213
+0.0016 155 171 181 214
+0.0016 156 178 185 188
+0.0016 157 179 180 189
+0.0016 158 174 181 190
+0.0016 159 175 182 191
+0.0016 160 176 183 186
+0.0016 161 177 184 187
+0.0016 148 162 191 194
+0.0016 149 163 186 195
+0.0016 144 164 187 196
+0.0016 145 165 188 197
+0.0016 146 166 189 192
+0.0016 147 167 190 193
+0.0016 154 168 197 200
+0.0016 155 169 192 201
+0.0016 150 170 193 202
+0.0016 151 171 194 203
+0.0016 152 172 195 198
+0.0016 153 173 196 199
+0.0016 160 174 203 206
+0.0016 161 175 198 207
+0.0016 156 176 199 208
+0.0016 157 177 200 209
+0.0016 158 178 201 204
+0.0016 159 179 202 205
+0.0016 144 166 209 212
+0.0016 145 167 204 213
+0.0016 146 162 205 214
+0.0016 147 163 206 215
+0.0016 148 164 207 210
+0.0016 149 165 208 211
+0.011200000000000002 180 186 195
+0.011200000000000002 181 187 196
+0.011200000000000002 182 188 197
+0.011200000000000002 183 189 192
+0.011200000000000002 184 190 193
+0.011200000000000002 185 191 194
+0.011200000000000002 186 192 201
+0.011200000000000002 187 193 202
+0.011200000000000002 188 194 203
+0.011200000000000002 189 195 198
+0.011200000000000002 190 196 199
+0.011200000000000002 191 197 200
+0.011200000000000002 192 198 207
+0.011200000000000002 193 199 208
+0.011200000000000002 194 200 209
+0.011200000000000002 195 201 204
+0.011200000000000002 196 202 205
+0.011200000000000002 197 203 206
+0.011200000000000002 198 204 213
+0.011200000000000002 199 205 214
+0.011200000000000002 200 206 215
+0.011200000000000002 201 207 210
+0.011200000000000002 202 208 211
+0.011200000000000002 203 209 212
+0.011200000000000002 183 204 210
+0.011200000000000002 184 205 211
+0.011200000000000002 185 206 212
+0.011200000000000002 180 207 213
+0.011200000000000002 181 208 214
+0.011200000000000002 182 209 215
+0.011200000000000002 180 189 210
+0.011200000000000002 181 190 211
+0.011200000000000002 182 191 212
+0.011200000000000002 183 186 213
+0.011200000000000002 184 187 214
+0.011200000000000002 185 188 215
+0.0016 166 180 203
+0.0016 167 181 198
+0.0016 162 182 199
+0.0016 163 183 200
+0.0016 164 184 201
+0.0016 165 185 202
+0.0016 172 186 209
+0.0016 173 187 204
+0.0016 168 188 205
+0.0016 169 189 206
+0.0016 170 190 207
+0.0016 171 191 208
+0.0016 178 192 215
+0.0016 179 193 210
+0.0016 174 194 211
+0.0016 175 195 212
+0.0016 176 196 213
+0.0016 177 197 214
+0.0016 148 185 198
+0.0016 149 180 199
+0.0016 144 181 200
+0.0016 145 182 201
+0.0016 146 183 202
+0.0016 147 184 203
+0.0016 154 191 204
+0.0016 155 186 205
+0.0016 150 187 206
+0.0016 151 188 207
+0.0016 152 189 208
+0.0016 153 190 209
+0.0016 160 197 210
+0.0016 161 192 211
+0.0016 156 193 212
+0.0016 157 194 213
+0.0016 158 195 214
+0.0016 159 196 215
+0.005600000000000001 180 181 200
+0.005600000000000001 181 182 201
+0.005600000000000001 182 183 202
+0.005600000000000001 183 184 203
+0.005600000000000001 184 185 198
+0.005600000000000001 180 185 199
+0.005600000000000001 186 187 206
+0.005600000000000001 187 188 207
+0.005600000000000001 188 189 208
+0.005600000000000001 189 190 209
+0.005600000000000001 190 191 204
+0.005600000000000001 186 191 205
+0.005600000000000001 192 193 212
+0.005600000000000001 193 194 213
+0.005600000000000001 194 195 214
+0.005600000000000001 195 196 215
+0.005600000000000001 196 197 210
+0.005600000000000001 192 197 211
+0.005600000000000001 182 198 199
+0.005600000000000001 183 199 200
+0.005600000000000001 184 200 201
+0.005600000000000001 185 201 202
+0.005600000000000001 180 202 203
+0.005600000000000001 181 198 203
+0.005600000000000001 188 204 205
+0.005600000000000001 189 205 206
+0.005600000000000001 190 206 207
+0.005600000000000001 191 207 208
+0.005600000000000001 186 208 209
+0.005600000000000001 187 204 209
+0.005600000000000001 194 210 211
+0.005600000000000001 195 211 212
+0.005600000000000001 196 212 213
+0.005600000000000001 197 213 214
+0.005600000000000001 192 214 215
+0.005600000000000001 193 210 215
+0.0108 180 216
+0.0108 181 217
+0.0108 182 218
+0.0108 183 219
+0.0108 184 220
+0.0108 185 221
+0.0108 186 222
+0.0108 187 223
+0.0108 188 224
+0.0108 189 225
+0.0108 190 226
+0.0108 191 227
+0.0108 192 228
+0.0108 193 229
+0.0108 194 230
+0.0108 195 231
+0.0108 196 232
+0.0108 197 233
+0.0108 198 234
+0.0108 199 235
+0.0108 200 236
+0.0108 201 237
+0.0108 202 238
+0.0108 203 239
+0.0108 204 240
+0.0108 205 241
+0.0108 206 242
+0.0108 207 243
+0.0108 208 244
+0.0108 209 245
+0.0108 210 246
+0.0108 211 247
+0.0108 212 248
+0.0108 213 249
+0.0108 214 250
+0.0108 215 251
+0.004 185 199 216
+0.004 180 200 217
+0.004 181 201 218
+0.004 182 202 219
+0.004 183 203 220
+0.004 184 198 221
+0.004 191 205 222
+0.004 186 206 223
+0.004 187 207 224
+0.004 188 208 225
+0.004 189 209 226
+0.004 190 204 227
+0.004 197 211 228
+0.004 192 212 229
+0.004 193 213 230
+0.004 194 214 231
+0.004 195 215 232
+0.004 196 210 233
+0.004 181 203 234
+0.004 182 198 235
+0.004 183 199 236
+0.004 184 200 237
+0.004 185 201 238
+0.004 180 202 239
+0.004 187 209 240
+0.004 188 204 241
+0.004 189 205 242
+0.004 190 206 243
+0.004 191 207 244
+0.004 186 208 245
+0.004 193 215 246
+0.004 194 210 247
+0.004 195 211 248
+0.004 196 212 249
+0.004 197 213 250
+0.004 192 214 251
+0.0016 181 186 192 201 208 214
+0.0016 182 187 193 202 209 215
+0.0016 183 188 194 203 204 210
+0.0016 184 189 195 198 205 211
+0.0016 185 190 196 199 206 212
+0.0016 180 191 197 200 207 213
+0.0016 184 187 192 198 207 214
+0.0016 185 188 193 199 208 215
+0.0016 180 189 194 200 209 210
+0.0016 181 190 195 201 204 211
+0.0016 182 191 196 202 205 212
+0.0016 183 186 197 203 206 213
+0.0016 184 190 193 198 204 213
+0.0016 185 191 194 199 205 214
+0.0016 180 186 195 200 206 215
+0.0016 181 187 196 201 207 210
+0.0016 182 188 197 202 208 211
+0.0016 183 189 192 203 209 212
+0.0016 183 190 196 199 204 210
+0.0016 184 191 197 200 205 211
+0.0016 185 186 192 201 206 212
+0.0016 180 187 193 202 207 213
+0.0016 181 188 194 203 208 214
+0.0016 182 189 195 198 209 215
+0.0016 180 189 196 202 205 210
+0.0016 181 190 197 203 206 211
+0.0016 182 191 192 198 207 212
+0.0016 183 186 193 199 208 213
+0.0016 184 187 194 200 209 214
+0.0016 185 188 195 201 204 215
+0.0016 180 186 195 202 208 211
+0.0016 181 187 196 203 209 212
+0.0016 182 188 197 198 204 213
+0.0016 183 189 192 199 205 214
+0.0016 184 190 193 200 206 215
+0.0016 185 191 194 201 207 210
+0.0016 189 210 216
+0.0016 190 211 217
+0.0016 191 212 218
+0.0016 186 213 219
+0.0016 187 214 220
+0.0016 188 215 221
+0.0016 180 195 222
+0.0016 181 196 223
+0.0016 182 197 224
+0.0016 183 192 225
+0.0016 184 193 226
+0.0016 185 194 227
+0.0016 186 201 228
+0.0016 187 202 229
+0.0016 188 203 230
+0.0016 189 198 231
+0.0016 190 199 232
+0.0016 191 200 233
+0.0016 192 207 234
+0.0016 193 208 235
+0.0016 194 209 236
+0.0016 195 204 237
+0.0016 196 205 238
+0.0016 197 206 239
+0.0016 198 213 240
+0.0016 199 214 241
+0.0016 200 215 242
+0.0016 201 210 243
+0.0016 202 211 244
+0.0016 203 212 245
+0.0016 183 204 246
+0.0016 184 205 247
+0.0016 185 206 248
+0.0016 180 207 249
+0.0016 181 208 250
+0.0016 182 209 251
+0.0016 186 192 208 214 218
+0.0016 187 193 209 215 219
+0.0016 188 194 204 210 220
+0.0016 189 195 205 211 221
+0.0016 190 196 206 212 216
+0.0016 191 197 207 213 217
+0.0016 184 192 198 214 224
+0.0016 185 193 199 215 225
+0.0016 180 194 200 210 226
+0.0016 181 195 201 211 227
+0.0016 182 196 202 212 222
+0.0016 183 197 203 213 223
+0.0016 184 190 198 204 230
+0.0016 185 191 199 205 231
+0.0016 180 186 200 206 232
+0.0016 181 187 201 207 233
+0.0016 182 188 202 208 228
+0.0016 183 189 203 209 229
+0.0016 190 196 204 210 236
+0.0016 191 197 205 211 237
+0.0016 186 192 206 212 238
+0.0016 187 193 207 213 239
+0.0016 188 194 208 214 234
+0.0016 189 195 209 215 235
+0.0016 180 196 202 210 242
+0.0016 181 197 203 211 243
+0.0016 182 192 198 212 244
+0.0016 183 193 199 213 245
+0.0016 184 194 200 214 240
+0.0016 185 195 201 215 241
+0.0016 180 186 202 208 248
+0.0016 181 187 203 209 249
+0.0016 182 188 198 204 250
+0.0016 183 189 199 205 251
+0.0016 184 190 200 206 246
+0.0016 185 191 201 207 247
+0.0016 207 216 249
+0.0016 208 217 250
+0.0016 209 218 251
+0.0016 204 219 246
+0.0016 205 220 247
+0.0016 206 221 248
+0.0016 213 219 222
+0.0016 214 220 223
+0.0016 215 221 224
+0.0016 210 216 225
+0.0016 211 217 226
+0.0016 212 218 227
+0.0016 183 225 228
+0.0016 184 226 229
+0.0016 185 227 230
+0.0016 180 222 231
+0.0016 181 223 232
+0.0016 182 224 233
+0.0016 189 231 234
+0.0016 190 232 235
+0.0016 191 233 236
+0.0016 186 228 237
+0.0016 187 229 238
+0.0016 188 230 239
+0.0016 195 237 240
+0.0016 196 238 241
+0.0016 197 239 242
+0.0016 192 234 243
+0.0016 193 235 244
+0.0016 194 236 245
+0.0016 201 243 246
+0.0016 202 244 247
+0.0016 203 245 248
+0.0016 198 240 249
+0.0016 199 241 250
+0.0016 200 242 251
+0.0016 186 208 218 251
+0.0016 187 209 219 246
+0.0016 188 204 220 247
+0.0016 189 205 221 248
+0.0016 190 206 216 249
+0.0016 191 207 217 250
+0.0016 192 214 221 224
+0.0016 193 215 216 225
+0.0016 194 210 217 226
+0.0016 195 211 218 227
+0.0016 196 212 219 222
+0.0016 197 213 220 223
+0.0016 184 198 227 230
+0.0016 185 199 222 231
+0.0016 180 200 223 232
+0.0016 181 201 224 233
+0.0016 182 202 225 228
+0.0016 183 203 226 229
+0.0016 190 204 233 236
+0.0016 191 205 228 237
+0.0016 186 206 229 238
+0.0016 187 207 230 239
+0.0016 188 208 231 234
+0.0016 189 209 232 235
+0.0016 196 210 239 242
+0.0016 197 211 234 243
+0.0016 192 212 235 244
+0.0016 193 213 236 245
+0.0016 194 214 237 240
+0.0016 195 215 238 241
+0.0016 180 202 245 248
+0.0016 181 203 240 249
+0.0016 182 198 241 250
+0.0016 183 199 242 251
+0.0016 184 200 243 246
+0.0016 185 201 244 247
+0.0072 216 222 231
+0.0072 217 223 232
+0.0072 218 224 233
+0.0072 219 225 228
+0.0072 220 226 229
+0.0072 221 227 230
+0.0072 222 228 237
+0.0072 223 229 238
+0.0072 224 230 239
+0.0072 225 231 234
+0.0072 226 232 235
+0.0072 227 233 236
+0.0072 228 234 243
+0.0072 229 235 244
+0.0072 230 236 245
+0.0072 231 237 240
+0.0072 232 238 241
+0.0072 233 239 242
+0.0072 234 240 249
+0.0072 235 241 250
+0.0072 236 242 251
+0.0072 237 243 246
+0.0072 238 244 247
+0.0072 239 245 248
+0.0072 219 240 246
+0.0072 220 241 247
+0.0072 221 242 248
+0.0072 216 243 249
+0.0072 217 244 250
+0.0072 218 245 251
+0.0072 216 225 246
+0.0072 217 226 247
+0.0072 218 227 248
+0.0072 219 222 249
+0.0072 220 223 250
+0.0072 221 224 251
+0.0016 202 216 239
+0.0016 203 217 234
+0.0016 198 218 235
+0.0016 199 219 236
+0.0016 200 220 237
+0.0016 201 221 238
+0.0016 208 222 245
+0.0016 209 223 240
+0.0016 204 224 241
+0.0016 205 225 242
+0.0016 206 226 243
+0.0016 207 227 244
+0.0016 214 228 251
+0.0016 215 229 246
+0.0016 210 230 247
+0.0016 211 231 248
+0.0016 212 232 249
+0.0016 213 233 250
+0.0016 184 221 234
+0.0016 185 216 235
+0.0016 180 217 236
+0.0016 181 218 237
+0.0016 182 219 238
+0.0016 183 220 239
+0.0016 190 227 240
+0.0016 191 222 241
+0.0016 186 223 242
+0.0016 187 224 243
+0.0016 188 225 244
+0.0016 189 226 245
+0.0016 196 233 246
+0.0016 197 228 247
+0.0016 192 229 248
+0.0016 193 230 249
+0.0016 194 231 250
+0.0016 195 232 251
+0.0028 216 217 236
+0.0028 217 218 237
+0.0028 218 219 238
+0.0028 219 220 239
+0.0028 220 221 234
+0.0028 216 221 235
+0.0028 222 223 242
+0.0028 223 224 243
+0.0028 224 225 244
+0.0028 225 226 245
+0.0028 226 227 240
+0.0028 222 227 241
+0.0028 228 229 248
+0.0028 229 230 249
+0.0028 230 231 250
+0.0028 231 232 251
+0.0028 232 233 246
+0.0028 228 233 247
+0.0028 218 234 235
+0.0028 219 235 236
+0.0028 220 236 237
+0.0028 221 237 238
+0.0028 216 238 239
+0.0028 217 234 239
+0.0028 224 240 241
+0.0028 225 241 242
+0.0028 226 242 243
+0.0028 227 243 244
+0.0028 222 244 245
+0.0028 223 240 245
+0.0028 230 246 247
+0.0028 231 247 248
+0.0028 232 248 249
+0.0028 233 249 250
+0.0028 228 250 251
+0.0028 229 246 251
diff --git a/wai/wai-rs/Cargo.lock b/wai/wai-rs/Cargo.lock
index 356ba4199..4a2966ae1 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.29"
+version = "0.3.30"
 dependencies = [
  "blake3",
  "ed25519-dalek",
diff --git a/wai/wai-rs/Cargo.toml b/wai/wai-rs/Cargo.toml
index 0e41163fa..97f6d9a97 100644
--- a/wai/wai-rs/Cargo.toml
+++ b/wai/wai-rs/Cargo.toml
@@ -360,6 +360,8 @@ 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"]
+# qLDPC memory at circuit level: bivariate-bicycle codes, BP-OSD.
+quantum_ldpc = ["quantum_frame", "wai-quantum/quantum_ldpc"]
 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
@@ -493,6 +495,7 @@ required-features = [
     "quantum_gbs",
     "quantum_sv",
     "quantum_arch",
+    "quantum_ldpc",
 ]
 
 [[bin]]
diff --git a/wai/wai-rs/src/bin/wai_quantum.rs b/wai/wai-rs/src/bin/wai_quantum.rs
index f185b9632..95e02cbf4 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\
+         QLDPC MEMORY (circuit level, BP-OSD):\n  \
+         wai-quantum ldpc [--code 72|90|108|144|288] [--p P] [--cycles N] [--shots S] [--basis z|x|both]\n    \
+         [--max-iter I] [--osd-order K] [--threads T] [--seed S] [--json]\n  \
+         wai-quantum ldpc --circuit [--code …] [--p P] [--cycles N] [--basis z|x]   (the circuit text)\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  \
@@ -961,6 +965,66 @@ fn main() {
             }
         }
 
+        // qLDPC memory: a bivariate-bicycle code's depth-8 syndrome cycle,
+        // sampled with circuit-level noise and decoded by BP-OSD.
+        "ldpc" => {
+            use wai::quantum_frame::Basis;
+            use wai::quantum_ldpc::{memory_circuit, memory_experiment, BbCode, BpOsdConfig};
+            let code = match opt(args, "--code", "").as_deref().unwrap_or("72") {
+                "72" => BbCode::bb72(),
+                "90" => BbCode::bb90(),
+                "108" => BbCode::bb108(),
+                "144" => BbCode::bb144(),
+                "288" => BbCode::bb288(),
+                _ => die("--code: 72, 90, 108, 144 or 288"),
+            };
+            let p: f64 = num(args, "--p", "", 0.003);
+            let cycles: u32 = num(args, "--cycles", "", 6);
+            let bases: Vec<(&str, Basis)> = match opt(args, "--basis", "").as_deref().unwrap_or("both") {
+                "z" | "Z" => vec![("z", Basis::Z)],
+                "x" | "X" => vec![("x", Basis::X)],
+                "both" => vec![("z", Basis::Z), ("x", Basis::X)],
+                _ => die("--basis: z, x or both"),
+            };
+            if flag(args, "--circuit") {
+                print!("{}", memory_circuit(&code, cycles, p, bases[0].1));
+                return;
+            }
+            let shots: usize = num(args, "--shots", "", 1000);
+            let seed: u64 = num(args, "--seed", "", 0);
+            let threads: usize = num(args, "--threads", "", std::thread::available_parallelism().map_or(1, |n| n.get()));
+            let cfg = BpOsdConfig { max_iter: num(args, "--max-iter", "", 10_000), osd_order: num(args, "--osd-order", "", 7), ..BpOsdConfig::default() };
+            let mut rows = Vec::new();
+            for (i, (name, basis)) in bases.iter().enumerate() {
+                let r = memory_experiment(&code, cycles, p, *basis, shots, seed ^ ((i as u64 + 1) << 32), cfg, threads).unwrap_or_else(|e| die(&e.to_string()));
+                rows.push((*name, r));
+            }
+            let either = 1.0 - rows.iter().map(|(_, r)| 1.0 - r.per_shot()).product::<f64>();
+            let either_cycle = 1.0 - (1.0 - either).powf(1.0 / f64::from(cycles));
+            if flag(args, "--json") {
+                let items: Vec<String> = rows
+                    .iter()
+                    .map(|(b, r)| format!("{{\"basis\":\"{b}\",\"bp_converged\":{},\"failures\":{},\"per_cycle\":{},\"per_shot\":{},\"shots\":{}}}", r.converged, r.failures, r.per_cycle(), r.per_shot(), r.shots))
+                    .collect();
+                println!("{{\"code\":[{},{}],\"cycles\":{cycles},\"either_per_cycle\":{either_cycle},\"either_per_shot\":{either},\"p\":{p},\"runs\":[{}]}}", code.n(), code.k(), items.join(","));
+            } else {
+                println!("[[{},{}]] bivariate-bicycle memory, p = {p}, {cycles} noisy cycles", code.n(), code.k());
+                for (b, r) in &rows {
+                    println!(
+                        "{b}-basis   {} failures in {} shots   {:.3e} per shot   {:.3e} per cycle   BP alone {:.1}%",
+                        r.failures,
+                        r.shots,
+                        r.per_shot(),
+                        r.per_cycle(),
+                        100.0 * r.converged as f64 / r.shots as f64
+                    );
+                }
+                if rows.len() == 2 {
+                    println!("either    {either:.3e} per shot   {either_cycle:.3e} per cycle (the two halves as independent)");
+                }
+            }
+        }
+
         // 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.
diff --git a/wai/wai-rs/src/lib.rs b/wai/wai-rs/src/lib.rs
index e7243848d..8e47e9850 100644
--- a/wai/wai-rs/src/lib.rs
+++ b/wai/wai-rs/src/lib.rs
@@ -637,6 +637,9 @@ pub use wai_quantum::quantum_sv;
 #[cfg(feature = "quantum_arch")]
 pub use wai_quantum::quantum_arch;
 
+#[cfg(feature = "quantum_ldpc")]
+pub use wai_quantum::quantum_ldpc;
+
 #[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 5e4c3cb1b..4116b39ae 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.29"
+version = "0.3.30"
 dependencies = [
  "blake3",
  "ed25519-dalek",
-- 
2.54.0 (Apple Git-157)