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 = 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)>, +} + +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) -> Vec { + 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 { + 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], cols: usize) -> Vec> { + // 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 = 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> { + (0..self.half()).map(|i| self.x_neighbours(i).to_vec()).collect() + } + /// Z checks as lists of data qubits. + pub fn hz(&self) -> Vec> { + (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>| { + 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> { + 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; 7] = [None, Some(1), Some(4), Some(3), Some(5), Some(0), Some(2)]; +const SZ: [Option; 7] = [Some(3), Some(5), Some(0), Some(1), Some(2), Some(4), None]; + +fn line(out: &mut String, name: &str, arg: Option, 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 = (0..h).collect(); + let data: Vec = (h..3 * h).collect(); + let zc: Vec = (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> = 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 = 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 = 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 = (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 = (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, + row_var: Vec, + /// Edges by variable: indices into the check-ordered edge list, CSR. + col_start: Vec, + col_edge: Vec, + prior: Vec, + /// `ln(1/p)`, the OSD cost of each fault. + cost: Vec, + observables: Vec, + 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![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 = Vec::new(); + for r in &by_row { + row_var.extend(r); + row_start.push(row_var.len()); + } + let mut by_col: Vec> = 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 = Vec::new(); + for c in &by_col { + col_edge.extend(c); + col_start.push(col_edge.len()); + } + let prior: Vec = mechs.iter().map(|m| ln((1.0 - m.probability) / m.probability)).collect(); + let cost: Vec = 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 { + let mut order: Vec = (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 = 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 = (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> = 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 { + 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); + let mut sections: Vec<(char, Vec)> = 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 = 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, 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 = 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::(); + let either_cycle = 1.0 - (1.0 - either).powf(1.0 / f64::from(cycles)); + if flag(args, "--json") { + let items: Vec = 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",