mfsk-core 0.10.0

//! Ordered Statistics Decoding (OSD), generic over [`LdpcParams`].
//!
//! Originally ported from WSJT-X `osd174_91.f90`. Phase 0c-B
//! generalised the algorithm so [`super::Ldpc174_91`] and
//! [`Ldpc240_101`](crate::fec::Ldpc240_101) share a single
//! implementation; the matrix shape comes from `P` at compile time. The non-generic
//! [`osd_decode`] / [`osd_decode_deep`] / [`osd_decode_deep4`]
//! entry points pin `P = Ldpc174_91Params` for FT8's bespoke decode
//! path which calls them directly via `super::ft8::ldpc`'s re-export
//! façade.

use alloc::vec;
use alloc::vec::Vec;

use super::bp::check_crc14;
use super::params::{Ldpc174_91Params, LdpcParams};
use super::{LDPC_K, LDPC_N};

// ────────────────────────────────────────────────────────────────────────────
// Generator parity sub-matrix

/// Parity generator sub-matrix P[83][91].
/// Parsed from WSJT-X ldpc_174_91_c_generator.f90.
/// Full systematic generator G[row][col]:
///   col <  91 → G[row][col] = (row == col) as u8   (identity block)
///   col >= 91 → G[row][col] = GEN_PARITY[col-91][row]
///
/// Visible to the sibling [`super::params`] module so the generic
/// [`super::params::LdpcParams::gen_parity`] accessor can return
/// these bytes without copying.
pub(super) const GEN_PARITY: [[u8; 91]; 83] = [
    [
        1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0,
        0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,
        0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0,
    ],
    [
        0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1,
        1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1,
        0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0,
        1,
    ],
    [
        1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
        1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,
        0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,
        0,
    ],
    [
        0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0,
        0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,
        0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0,
        1,
    ],
    [
        0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1,
        1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1,
        1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0,
        1,
    ],
    [
        0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0,
        0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,
        1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0,
        1,
    ],
    [
        0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1,
        1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,
        0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0,
        1,
    ],
    [
        0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,
        0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1,
        0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,
        1,
    ],
    [
        1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,
        0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0,
        0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0,
        0,
    ],
    [
        0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0,
        0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,
        1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0,
        0,
    ],
    [
        1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
        1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
        0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1,
        0,
    ],
    [
        0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0,
        1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1,
        1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
        1,
    ],
    [
        0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1,
        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0,
        0,
    ],
    [
        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0,
        0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
        1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,
        1,
    ],
    [
        0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1,
        0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0,
        0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0,
        0,
    ],
    [
        1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0,
        0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0,
        0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0,
        0,
    ],
    [
        0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1,
        0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1,
        0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0,
        0,
    ],
    [
        0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1,
        1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1,
        1,
    ],
    [
        0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
        0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1,
        1,
    ],
    [
        0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,
        1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0,
        0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1,
        0,
    ],
    [
        1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0,
        0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1,
        1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0,
        0,
    ],
    [
        0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0,
        0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0,
        0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0,
        0,
    ],
    [
        0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1,
        1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0,
        1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,
        0,
    ],
    [
        0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,
        1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,
        0,
    ],
    [
        1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1,
        1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1,
        1,
    ],
    [
        1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1,
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1,
        0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,
        1,
    ],
    [
        0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0,
        1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0,
        1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0,
        0,
    ],
    [
        1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0,
        1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1,
        0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0,
        0,
    ],
    [
        1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0,
        1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1,
        1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1,
        0,
    ],
    [
        0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1,
        1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0,
        1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1,
        1,
    ],
    [
        0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0,
        0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
        0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0,
        0,
    ],
    [
        0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0,
        0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,
        0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0,
        1,
    ],
    [
        1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0,
        0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1,
        1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1,
        0,
    ],
    [
        1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1,
        0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,
        1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1,
        0,
    ],
    [
        0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1,
        0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0,
        0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0,
        0,
    ],
    [
        0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0,
        0,
    ],
    [
        0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1,
        0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
        1,
    ],
    [
        1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
        1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1,
        1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,
        1,
    ],
    [
        1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0,
        1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1,
        1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
        1,
    ],
    [
        1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
        1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0,
        1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1,
        0,
    ],
    [
        0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0,
        0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,
        0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
        1,
    ],
    [
        0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,
        0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,
        0,
    ],
    [
        1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1,
        1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1,
        1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0,
        0,
    ],
    [
        0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1,
        0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
        1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0,
        0,
    ],
    [
        0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0,
        1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,
        1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,
        1,
    ],
    [
        0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
        0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,
        1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,
        0,
    ],
    [
        0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1,
        0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0,
        1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1,
    ],
    [
        0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
        1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1,
        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0,
        0,
    ],
    [
        0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0,
        0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0,
        0,
    ],
    [
        0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0,
        0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1,
        0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1,
        1,
    ],
    [
        1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1,
        0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1,
        0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1,
        0,
    ],
    [
        0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,
        1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0,
        1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,
        0,
    ],
    [
        1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0,
        0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
        0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,
        0,
    ],
    [
        0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1,
        0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1,
        0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0,
    ],
    [
        0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0,
        1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0,
        1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1,
        1,
    ],
    [
        1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
        0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
        0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
        1,
    ],
    [
        0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0,
        0,
    ],
    [
        1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,
        1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,
        0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1,
        1,
    ],
    [
        1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0,
        1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1,
        1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0,
        1,
    ],
    [
        1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0,
        1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1,
        1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,
        0,
    ],
    [
        1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0,
        1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,
        1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1,
        1,
    ],
    [
        1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1,
        0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0,
        1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1,
        0,
    ],
    [
        1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1,
        1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
        0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
        1,
    ],
    [
        0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
        1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,
        1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
        1,
    ],
    [
        1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
        1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0,
        0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
        1,
    ],
    [
        0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1,
        0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0,
        0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0,
        0,
    ],
    [
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0,
        0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
        0,
    ],
    [
        0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,
        0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1,
        0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0,
        1,
    ],
    [
        0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1,
        0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0,
        0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1,
        1,
    ],
    [
        1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0,
        0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1,
        1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0,
        1,
    ],
    [
        1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1,
        0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0,
        1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1,
        0,
    ],
    [
        1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
        0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0,
        1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1,
        1,
    ],
    [
        0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1,
        0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
        0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0,
        0,
    ],
    [
        1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1,
        0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1,
        1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1,
    ],
    [
        0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0,
        1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0,
        1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0,
        0,
    ],
    [
        1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0,
        0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0,
        1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
        1,
    ],
    [
        0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1,
        0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1,
        1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0,
        1,
    ],
    [
        1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1,
        1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1,
        0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1,
        0,
    ],
    [
        1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
        0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1,
        1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1,
        0,
    ],
    [
        1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1,
        1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,
        0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0,
        0,
    ],
    [
        0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,
        1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0,
        0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0,
        1,
    ],
    [
        0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1,
        0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0,
        0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1,
        0,
    ],
    [
        0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
        1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,
        0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        0,
    ],
];

// ────────────────────────────────────────────────────────────────────────────
// Systematic encoder

/// Generic systematic encode. `info.len() == P::K`, `cw.len() == P::N`.
/// `cw[..K] = info`; `cw[K..N]` filled from [`LdpcParams::gen_parity`].
pub fn ldpc_encode_generic<P: LdpcParams>(info: &[u8], cw: &mut [u8]) {
    debug_assert_eq!(info.len(), P::K, "info length must equal P::K");
    debug_assert_eq!(cw.len(), P::N, "cw length must equal P::N");
    cw[..P::K].copy_from_slice(info);
    for j in 0..P::M {
        let mut p = 0u8;
        for k in 0..P::K {
            p ^= P::gen_parity(j, k) & info[k];
        }
        cw[P::K + j] = p;
    }
}

/// Encode 91 information bits into a 174-bit LDPC(174,91) codeword.
///
/// Systematic: `codeword[0..91] = info`, parity bits `codeword[91..174]`
/// from `GEN_PARITY`. Backward-compat wrapper around
/// [`ldpc_encode_generic`] pinned to [`Ldpc174_91Params`].
pub fn ldpc_encode(info: &[u8; LDPC_K]) -> [u8; LDPC_N] {
    let mut cw = [0u8; LDPC_N];
    ldpc_encode_generic::<Ldpc174_91Params>(info.as_slice(), cw.as_mut_slice());
    cw
}

// ────────────────────────────────────────────────────────────────────────────
// Public API

/// Output of a successful OSD decode.
///
/// `info` and `codeword` are heap-allocated so the struct can serve
/// any [`LdpcParams`]'s K / N. `message77` exposes the leading 77
/// bits as a fixed-size array for legacy Wsjt77-family callers.
pub struct OsdResult {
    /// Leading 77 info bits (Wsjt77 message field). Same content as
    /// `info[..77]` — duplicated for callers that take fixed-size
    /// references.
    pub message77: [u8; 77],
    /// Full systematic info (length `P::K`).
    pub info: Vec<u8>,
    /// Full codeword (length `P::N`, original bit ordering).
    pub codeword: Vec<u8>,
    /// Number of hard errors (bits where hard decision disagrees with LLR sign).
    pub hard_errors: u32,
}

/// OSD with configurable order — pinned to LDPC(174, 91).
///
/// - ndeep=1: order-0 + order-1 (92 candidates)
/// - ndeep=2: + order-2 (4,187 total)
/// - ndeep=3: + order-3 (121,667 total)
///
/// Higher order recovers weaker signals at the cost of runtime.
pub fn osd_decode_deep(
    llr: &[f32; LDPC_N],
    ndeep: u8,
    verify: Option<fn(&[u8]) -> bool>,
) -> Option<OsdResult> {
    osd_decode_generic::<Ldpc174_91Params>(llr.as_slice(), ndeep, LDPC_K, verify, false)
}

/// OSD order-4 decode with Top-K LLR pruning — pinned to LDPC(174, 91).
///
/// Runs the standard order-3 search (all 91 MRB bits) plus an order-4
/// extension limited to the `k4_limit` *least* reliable MRB bits.
/// Because errors concentrate in low-|LLR| bits, restricting k4 to the
/// tail (e.g. k4_limit=30) gives C(30,4)=27,405 extra candidates —
/// comparable cost to order-3 — while catching the 4-bit-error cases
/// that order-3 misses.
///
/// Recommended k4_limit: 30 (empirically chosen).
pub fn osd_decode_deep4(
    llr: &[f32; LDPC_N],
    k4_limit: usize,
    verify: Option<fn(&[u8]) -> bool>,
) -> Option<OsdResult> {
    osd_decode_generic::<Ldpc174_91Params>(llr.as_slice(), 4, k4_limit, verify, false)
}

/// OSD order-2 decode (default) — pinned to LDPC(174, 91) with the
/// legacy implicit `check_crc14` verifier.
///
/// Sorts bits by |LLR| reliability, builds the permuted systematic generator,
/// performs GF(2) Gaussian elimination to isolate the 91 most reliable basis
/// (MRB) bits, then tests the order-0 hard-decision candidate plus all 91
/// single-bit flips and all C(91,2) = 4,095 two-bit flips.
/// Returns the minimum-weighted CRC-passing codeword, or `None` if none passes.
pub fn osd_decode(llr: &[f32; LDPC_N]) -> Option<OsdResult> {
    osd_decode_generic::<Ldpc174_91Params>(llr.as_slice(), 2, LDPC_K, Some(check_crc14), false)
}

// ────────────────────────────────────────────────────────────────────────────
// WSJT-X-faithful OSD (issue #63) — shared scaffolding for ndeep=2 (npre1)
// and ndeep=3 (npre1 + npre2).

/// Sliding window of trailing-parity bits the `npre1` gate inspects.
/// Mirrors WSJT-X `osd174_91.f90:147` `nt = 40`. Same value for ndeep=2
/// and ndeep=3 dispatch.
const NPRE1_PARITY_WINDOW: usize = 40;

/// Maximum tolerated partial parity-error count for the `npre1` gate
/// at WSJT-X ndeep=2 dispatch. Mirrors `osd174_91.f90:148`
/// `ntheta = 10`. Candidates whose parity-error count in the first
/// `NPRE1_PARITY_WINDOW` parity bits — plus the info-bit-flip count
/// of the test pattern — exceed this are rejected without the
/// expensive full encode + CRC check.
const NPRE1_GATE_NDEEP2: u32 = 10;

/// Same as [`NPRE1_GATE_NDEEP2`] but for WSJT-X ndeep=3 dispatch
/// (`osd174_91.f90:154`). ndeep=3 loosens the gate to 12 because it
/// composes with the `npre2` second-stage pass that mops up patterns
/// the looser gate lets through.
const NPRE1_GATE_NDEEP3: u32 = 12;

/// Hash-key width for the `npre2` second-stage pre-processing rule.
/// Mirrors WSJT-X `osd174_91.f90:155` `ntau = 14` for FT8 ndeep=3.
/// 2^14 = 16,384 hash buckets; 4,095 (i1, i2) entries spread across
/// them.
const NPRE2_NTAU: usize = 14;

/// Shared OSD scaffolding extracted from `osd_decode_npre1` so the
/// ndeep=3 entry `osd_decode_npre1_npre2` can reuse it. Holds the
/// permutation + RREF generator + hard-decision projections + the
/// order-0 codeword that every WSJT-X-faithful OSD pass needs.
struct OsdSetup {
    perm: Vec<usize>,
    /// Flat `LDPC_K × LDPC_N` RREF permuted generator
    /// (`g[row * LDPC_N + col]`).
    g: Vec<u8>,
    /// Hard decisions in permuted space (= `hdec(indices)` in WSJT-X).
    hdec_perm: Vec<u8>,
    /// `|LLR|` in permuted space (= `absrx(indices)` in WSJT-X).
    absrx_perm: Vec<f32>,
    /// Order-0 codeword (= `c0 = encode(m0)`) in permuted space.
    c_perm: Vec<u8>,
}

/// Best-so-far accumulator. Tracked separately from the closure
/// pattern to avoid the borrow tangle that bit the first npre1 impl.
struct OsdBest {
    /// `(info, full codeword)` of the best candidate so far, or `None`
    /// if no CRC-valid candidate has been found.
    state: Option<(Vec<u8>, Vec<u8>)>,
    /// Weighted distance of the best candidate, or `+infinity` when
    /// `state` is `None`.
    dd: f32,
}

impl OsdBest {
    fn new() -> Self {
        Self {
            state: None,
            dd: f32::INFINITY,
        }
    }

    fn maybe_update(&mut self, decoded: Vec<u8>, cw: Vec<u8>, dd: f32) {
        if dd < self.dd {
            self.dd = dd;
            self.state = Some((decoded, cw));
        }
    }
}

/// LDPC(174, 91) setup: permute bits by `|LLR|` descending, build the
/// permuted RREF generator, project the hard decisions into permuted
/// space, and encode the order-0 candidate. Returns `None` if the
/// Gaussian elimination is degenerate (shouldn't happen for valid
/// LDPC codes).
fn osd_setup_ldpc174_91(llr: &[f32; LDPC_N]) -> Option<OsdSetup> {
    let n = LDPC_N;
    let k = LDPC_K;

    let mut perm: Vec<usize> = (0..n).collect();
    perm.sort_unstable_by(|&a, &b| {
        llr[b]
            .abs()
            .partial_cmp(&llr[a].abs())
            .unwrap_or(core::cmp::Ordering::Equal)
    });

    // Bit-packed Gaussian elimination (issue #182 perf follow-up).
    // Profiling found this setup (sort + elimination) is ~86% of a
    // single `osd_decode_npre1`/`_npre2` call's cost (~113µs of
    // ~132µs, synthetic-LLR microbenchmark), paid fresh on every one
    // of the 8 zsave-seeded dispatches per candidate in
    // `osd_strategy.rs::try_fallback` (each has a different LLR
    // reliability ordering, so results can't be cached across them).
    // `osd174_91.f90`'s own `genmrb` is `integer*1` (byte-per-bit)
    // too — this isn't a WSJT-X-fidelity fix, it's a legitimate
    // algorithmic improvement beyond what WSJT-X itself does. `g`'s
    // *final* representation (`Vec<u8>`, unpacked below) and every
    // downstream consumer (`osd_npre1_pass`, `osd_npre2_pass`,
    // `build_npre2_table`, `try_candidate_ldpc174_91`) are unchanged —
    // only the elimination's internal representation differs.
    const WORDS: usize = LDPC_N.div_ceil(64); // 3 for LDPC_N=174
    type PackedRow = [u64; WORDS];
    let mut g_packed: Vec<PackedRow> = vec![[0u64; WORDS]; k];
    for row in 0..k {
        for col in 0..n {
            let j = perm[col];
            let bit = if j < k {
                (row == j) as u64
            } else {
                <Ldpc174_91Params as LdpcParams>::gen_parity(j - k, row) as u64
            };
            g_packed[row][col / 64] |= bit << (col % 64);
        }
    }

    let mut pivot_col: Vec<usize> = vec![0; k];
    let mut pivot_row = 0usize;
    for col in 0..n {
        if pivot_row >= k {
            break;
        }
        let word = col / 64;
        let bit = col % 64;
        let mut found: Option<usize> = None;
        for r in pivot_row..k {
            if (g_packed[r][word] >> bit) & 1 != 0 {
                found = Some(r);
                break;
            }
        }
        if let Some(r) = found {
            if r != pivot_row {
                g_packed.swap(r, pivot_row);
            }
            let pivot = g_packed[pivot_row];
            for r2 in 0..k {
                if r2 != pivot_row && (g_packed[r2][word] >> bit) & 1 != 0 {
                    for c in 0..WORDS {
                        g_packed[r2][c] ^= pivot[c];
                    }
                }
            }
            pivot_col[pivot_row] = col;
            pivot_row += 1;
        }
    }
    if pivot_row < k {
        return None;
    }

    // Unpack to the byte-per-bit format every downstream consumer
    // expects — one linear O(k*n) pass, negligible next to the O(k²*n)
    // elimination it replaces.
    let mut g: Vec<u8> = vec![0u8; k * n];
    for row in 0..k {
        for col in 0..n {
            g[row * n + col] = ((g_packed[row][col / 64] >> (col % 64)) & 1) as u8;
        }
    }

    let mut m0: Vec<u8> = vec![0u8; k];
    for r in 0..k {
        let orig = perm[pivot_col[r]];
        m0[r] = if llr[orig] > 0.0 { 1 } else { 0 };
    }

    let mut hdec_perm: Vec<u8> = vec![0u8; n];
    let mut absrx_perm: Vec<f32> = vec![0.0f32; n];
    for col in 0..n {
        hdec_perm[col] = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
        absrx_perm[col] = llr[perm[col]].abs();
    }

    let mut c_perm: Vec<u8> = vec![0u8; n];
    for r in 0..k {
        if m0[r] == 1 {
            for col in 0..n {
                c_perm[col] ^= g[r * n + col];
            }
        }
    }

    Some(OsdSetup {
        perm,
        g,
        hdec_perm,
        absrx_perm,
        c_perm,
    })
}

/// Diagnostic variant of [`osd_setup_ldpc174_91`] (issue #182) — builds
/// the systematic generator with `osd174_91.f90:86-107`'s *exact*
/// bounded-window column-swap pivot search instead of
/// [`osd_setup_ldpc174_91`]'s unbounded full-column-range row
/// reduction.
///
/// The two are **not** the same algorithm. WSJT-X's real Gaussian
/// elimination processes diagonal indices `id=1..k` and, for each,
/// searches only columns `id..k+20` (`do icol=id,k+20` — "The 20 is ad
/// hoc - beware", per the source comment itself) for a usable pivot,
/// swapping that column into position `id` when found. Any column
/// beyond `k+20` in reliability order is never eligible to become an
/// MRB (most-reliable-basis) position, no matter how the elimination
/// unfolds. [`osd_setup_ldpc174_91`] instead scans the *entire* N=174
/// column range for each pivot row — a more complete elimination that
/// never leaves a row un-pivoted, but which can select a genuinely
/// *different* set of k physical bit positions as the systematic basis
/// whenever the top `k+20` reliable columns don't happen to be the
/// ones WSJT-X's row-major search would have chosen.
///
/// Since `osd_npre1_pass` only explores single- and paired-bit flips
/// *within* whichever k positions got selected as the MRB, a different
/// basis changes which candidate codewords are reachable at all —
/// independent of `ntheta`/`nt` gate values, which already matched
/// exactly.
///
/// **Disproven.** This was the leading hypothesis for
/// `osd_decode_npre1`'s `K1BZM DK8NE -10` gap, tested directly
/// (`issue_182_dk8ne_osd_fortran_pivot_probe`): the bounded-window
/// basis genuinely differs from [`osd_setup_ldpc174_91`]'s (87-90/91
/// position overlap across the 4 LLR variants), but `osd_decode_npre1`
/// built on *either* basis still fails on this candidate — even a full
/// unrestricted order-2 exhaustive search (no `ntheta` gate at all)
/// never reaches it. The real gap was upstream of basis construction
/// entirely: see [`super::bp::bp_llr_zsum`]'s doc comment and
/// `osd_strategy.rs`'s `try_fallback` for the actual fix (WSJT-X's
/// `decode174_91.f90` never feeds `osd174_91` the raw channel LLR when
/// `maxosd>0`, which FT8's blind dispatch always is). Kept as a
/// diagnostic — `#[cfg(test)]` only, not part of the production
/// dispatch — documenting a plausible-but-wrong hypothesis so it isn't
/// re-investigated from scratch later.
#[cfg(test)]
fn osd_setup_ldpc174_91_fortran_pivot(llr: &[f32; LDPC_N]) -> Option<OsdSetup> {
    let n = LDPC_N;
    let k = LDPC_K;

    let mut perm: Vec<usize> = (0..n).collect();
    perm.sort_unstable_by(|&a, &b| {
        llr[b]
            .abs()
            .partial_cmp(&llr[a].abs())
            .unwrap_or(core::cmp::Ordering::Equal)
    });

    let mut g: Vec<u8> = vec![0u8; k * n];
    for row in 0..k {
        for col in 0..n {
            let j = perm[col];
            g[row * n + col] = if j < k {
                (row == j) as u8
            } else {
                <Ldpc174_91Params as LdpcParams>::gen_parity(j - k, row)
            };
        }
    }

    // `osd174_91.f90:86-107`: for each diagonal row `id`, search only
    // columns `id..k+20` (ad hoc 20-column slack) for a usable pivot,
    // swapping it into position `id` and eliminating it from every
    // other row. Unlike `osd_setup_ldpc174_91`, a row that finds no
    // pivot within this bounded window is silently left un-eliminated
    // (matching WSJT-X's own behaviour, "beware" and all — not treated
    // as an error here either).
    const PIVOT_WINDOW_SLACK: usize = 20;
    for id in 0..k {
        let upper = (k + PIVOT_WINDOW_SLACK).min(n);
        let mut found: Option<usize> = None;
        for icol in id..upper {
            if g[id * n + icol] == 1 {
                found = Some(icol);
                break;
            }
        }
        let Some(icol) = found else { continue };
        if icol != id {
            for r in 0..k {
                g.swap(r * n + id, r * n + icol);
            }
            perm.swap(id, icol);
        }
        for ii in 0..k {
            if ii != id && g[ii * n + id] == 1 {
                for c in 0..n {
                    g[ii * n + c] ^= g[id * n + c];
                }
            }
        }
    }

    let mut m0: Vec<u8> = vec![0u8; k];
    for r in 0..k {
        m0[r] = if llr[perm[r]] > 0.0 { 1 } else { 0 };
    }

    let mut hdec_perm: Vec<u8> = vec![0u8; n];
    let mut absrx_perm: Vec<f32> = vec![0.0f32; n];
    for col in 0..n {
        hdec_perm[col] = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
        absrx_perm[col] = llr[perm[col]].abs();
    }

    let mut c_perm: Vec<u8> = vec![0u8; n];
    for r in 0..k {
        if m0[r] == 1 {
            for col in 0..n {
                c_perm[col] ^= g[r * n + col];
            }
        }
    }

    Some(OsdSetup {
        perm,
        g,
        hdec_perm,
        absrx_perm,
        c_perm,
    })
}

/// Diagnostic (issue #182, disproven hypothesis — see
/// [`osd_setup_ldpc174_91_fortran_pivot`]'s doc comment):
/// [`osd_decode_npre1`] built on
/// [`osd_setup_ldpc174_91_fortran_pivot`] instead of
/// [`osd_setup_ldpc174_91`] — same `npre1` search, different MRB basis
/// construction.
#[cfg(test)]
pub(crate) fn osd_decode_npre1_fortran_pivot(llr: &[f32; LDPC_N]) -> Option<OsdResult> {
    let setup = osd_setup_ldpc174_91_fortran_pivot(llr)?;
    let mut best = OsdBest::new();
    osd_npre1_pass(&setup, &mut best, NPRE1_GATE_NDEEP2);
    osd_result_from_best(llr, best)
}

/// Diagnostic (issue #182, disproven hypothesis): the MRB basis
/// (`perm[0..LDPC_K]`, as a set of physical bit indices) each setup
/// variant selects, for direct comparison. `(current, fortran_pivot)`.
#[cfg(test)]
pub(crate) fn osd_debug_basis_sets(llr: &[f32; LDPC_N]) -> (Vec<usize>, Vec<usize>) {
    let current = osd_setup_ldpc174_91(llr)
        .map(|s| s.perm[..LDPC_K].to_vec())
        .unwrap_or_default();
    let fortran_pivot = osd_setup_ldpc174_91_fortran_pivot(llr)
        .map(|s| s.perm[..LDPC_K].to_vec())
        .unwrap_or_default();
    (current, fortran_pivot)
}

/// Un-permute a candidate codeword into the caller-provided
/// `c_unperm` scratch buffer and CRC-verify it. Returns the
/// unpermuted full codeword + its first-`K` info slice as fresh
/// `Vec`s on CRC pass, or `None` if CRC fails (no allocation on
/// the fail path).
///
/// Caller provides the scratch buffer so it can be reused across
/// the ~4186 invocations a single OSD candidate triggers — heap
/// churn on each call was the dominant per-candidate cost before
/// this refactor (Gemini PR #86 review).
fn try_candidate_ldpc174_91(
    perm: &[usize],
    cp: &[u8],
    c_unperm: &mut [u8; LDPC_N],
) -> Option<(Vec<u8>, Vec<u8>)> {
    for col in 0..LDPC_N {
        c_unperm[perm[col]] = cp[col];
    }
    if !check_crc14(&c_unperm[..LDPC_K]) {
        return None;
    }
    Some((c_unperm[..LDPC_K].to_vec(), c_unperm.to_vec()))
}

/// Run the WSJT-X `nord=1 + npre1=1` pass against the given
/// [`OsdSetup`], updating [`OsdBest`] with any improvement.
///
/// `ntheta` selects which dispatch's gate threshold to apply
/// (10 for ndeep=2, 12 for ndeep=3 — see [`NPRE1_GATE_NDEEP2`] /
/// [`NPRE1_GATE_NDEEP3`]).
///
/// Mirrors `osd174_91.f90:179-228`. Also handles the order-0
/// baseline so callers don't need a separate "try order-0 first"
/// step — re-trying order-0 inside a multi-pass driver is harmless
/// (idempotent).
fn osd_npre1_pass(setup: &OsdSetup, best: &mut OsdBest, ntheta: u32) {
    let n = LDPC_N;
    let k = LDPC_K;
    let nt = NPRE1_PARITY_WINDOW.min(n - k);

    // Fixed-size scratch buffers: hoist allocations out of the per-
    // candidate hot loop (Gemini PR #87 review). `LDPC_N` / `LDPC_K`
    // are `const`, so `[T; N]` lives on the stack with no allocator
    // round-trip.
    let mut ce_iflag = [0u8; LDPC_N];
    let mut e2sub = [0u8; LDPC_N - LDPC_K];
    let mut e2 = [0u8; LDPC_N - LDPC_K];
    let mut ce_pair = [0u8; LDPC_N];
    // Caller-provided buffer for try_candidate_ldpc174_91 — shared
    // across every CRC try in this pass (Gemini PR #86 review,
    // ~4186 calls/candidate previously each allocating their own Vec).
    let mut c_unperm = [0u8; LDPC_N];

    // Order-0 baseline.
    {
        let mut wd = 0.0f32;
        for col in k..n {
            if setup.c_perm[col] != setup.hdec_perm[col] {
                wd += setup.absrx_perm[col];
            }
        }
        if wd < best.dd
            && let Some((d, cw)) =
                try_candidate_ldpc174_91(&setup.perm, &setup.c_perm, &mut c_unperm)
        {
            best.maybe_update(d, cw, wd);
        }
    }

    for iflag in (0..k).rev() {
        ce_iflag.copy_from_slice(&setup.c_perm);
        for col in 0..n {
            ce_iflag[col] ^= setup.g[iflag * n + col];
        }
        for j in 0..(n - k) {
            e2sub[j] = ce_iflag[k + j] ^ setup.hdec_perm[k + j];
        }
        let mut parity_err: u32 = 0;
        for j in 0..nt {
            parity_err += e2sub[j] as u32;
        }
        let d1 = setup.absrx_perm[iflag];

        // n1 = iflag baseline. WSJT-X gate is `parity_err + 1 <= ntheta`
        // (the +1 accounts for the iflag info-bit flip); written as
        // `parity_err < ntheta` to silence clippy::int_plus_one.
        if parity_err < ntheta {
            let mut parity_wd = 0.0f32;
            for j in 0..(n - k) {
                if e2sub[j] == 1 {
                    parity_wd += setup.absrx_perm[k + j];
                }
            }
            let dd = d1 + parity_wd;
            if dd < best.dd
                && let Some((d, cw)) =
                    try_candidate_ldpc174_91(&setup.perm, &ce_iflag, &mut c_unperm)
            {
                best.maybe_update(d, cw, dd);
            }
        }

        // n1 < iflag pair-anchor. e2 derived incrementally as
        // `e2sub XOR g[n1, k..n]` — WSJT-X `osd174_91:203`.
        for n1 in (0..iflag).rev() {
            for j in 0..(n - k) {
                e2[j] = e2sub[j] ^ setup.g[n1 * n + (k + j)];
            }
            let mut parity_err_pair: u32 = 0;
            for j in 0..nt {
                parity_err_pair += e2[j] as u32;
            }
            // +2 for the two info-bit flips (iflag + n1).
            if parity_err_pair + 2 > ntheta {
                continue;
            }
            ce_pair.copy_from_slice(&ce_iflag);
            for col in 0..n {
                ce_pair[col] ^= setup.g[n1 * n + col];
            }
            let mut parity_wd_pair = 0.0f32;
            for j in 0..(n - k) {
                if e2[j] == 1 {
                    parity_wd_pair += setup.absrx_perm[k + j];
                }
            }
            let dd = d1 + setup.absrx_perm[n1] + parity_wd_pair;
            if dd < best.dd
                && let Some((d, cw)) =
                    try_candidate_ldpc174_91(&setup.perm, &ce_pair, &mut c_unperm)
            {
                best.maybe_update(d, cw, dd);
            }
        }
    }
}

/// Hash table for the `npre2` pass. Maps an `ntau`-bit key
/// (XOR of two G columns, restricted to the first ntau parity rows)
/// to the chain of `(i1, i2)` MRB index pairs whose generator
/// difference yields that key.
///
/// Backed by three flat vecs (`fp` head-per-bucket, `pairs`/`next`
/// chained list). Mirrors WSJT-X `boxit91` (`osd174_91.f90:336-370`).
struct OsdNpre2Table {
    /// Per-hash-bucket head index into `pairs` (or `-1` = empty).
    fp: Vec<i32>,
    /// Chained `(i1, i2)` entries; `next[idx]` is the chained next or
    /// `-1` to terminate the bucket's chain.
    pairs: Vec<(u8, u8)>,
    next: Vec<i32>,
}

impl OsdNpre2Table {
    fn new(ntau: usize) -> Self {
        let buckets = 1usize << ntau;
        Self {
            fp: vec![-1; buckets],
            pairs: Vec::new(),
            next: Vec::new(),
        }
    }

    /// Head insertion: O(1) per insert. The previous implementation
    /// traversed the chain to find the tail (O(L) per insert), which
    /// dominated `build_npre2_table` for keys with long chains. To
    /// keep WSJT-X iteration order under `iter_pairs`, the build loop
    /// in [`build_npre2_table`] inserts entries in **reverse** of the
    /// original tail-insert order — head-insert then naturally yields
    /// the same traversal sequence. (Gemini PR #87 review.)
    fn insert(&mut self, key: usize, i1: u8, i2: u8) {
        let idx = self.pairs.len() as i32;
        self.pairs.push((i1, i2));
        self.next.push(self.fp[key]);
        self.fp[key] = idx;
    }

    /// Iterate over `(i1, i2)` pairs registered at `key`, in
    /// insertion order. Mirrors WSJT-X `fetchit91` chain traversal.
    fn iter_pairs(&self, key: usize) -> impl Iterator<Item = (u8, u8)> + '_ {
        let mut cur = self.fp[key];
        core::iter::from_fn(move || {
            if cur < 0 {
                None
            } else {
                let entry = self.pairs[cur as usize];
                cur = self.next[cur as usize];
                Some(entry)
            }
        })
    }
}

/// Build the [`OsdNpre2Table`] for `ntau`-bit XOR of all C(K, 2)
/// MRB column pairs.
///
/// Two perf optimisations vs the WSJT-X-faithful tail-insert / reverse-
/// loop reference (Gemini PR #87 review):
///
/// 1. **row_keys pre-compute.** Each row's `ntau`-bit parity key is
///    independent of the pairing inner loop. Hoist the per-row bit
///    pack into a `LDPC_K`-length scratch (~1.4 KB on the stack for
///    ntau=14 → `u16`), reducing the inner-loop work from O(K² · ntau)
///    to O(K · ntau + K²). `ntau <= 14` per WSJT-X constraints — fits
///    in `u16` with one bit to spare.
///
/// 2. **Forward loops paired with head-insert in
///    [`OsdNpre2Table::insert`].** The original reverse outer/inner +
///    tail-insert yielded a specific iteration order under
///    [`OsdNpre2Table::iter_pairs`]. Forward outer/inner + head-insert
///    yields the *same* order (head-insert reverses, forward loop
///    reverses again — net no change), so candidates surface in the
///    same sequence WSJT-X explores them. Preserves any tie-break
///    parity with the reference implementation.
fn build_npre2_table(setup: &OsdSetup, ntau: usize) -> OsdNpre2Table {
    let n = LDPC_N;
    let k = LDPC_K;
    let mut table = OsdNpre2Table::new(ntau);

    let mut row_keys = [0u16; LDPC_K];
    for i in 0..k {
        let mut rk: u16 = 0;
        // Hoist `i * n + k` out of the j loop — Gemini PR #96 minor
        // perf nit. `g` is row-major LDPC_K × LDPC_N, row i parity
        // section starts at `row_base + k`.
        let row_base = i * n;
        for j in 0..ntau {
            if setup.g[row_base + k + j] != 0 {
                rk |= 1u16 << (ntau - 1 - j);
            }
        }
        row_keys[i] = rk;
    }

    for i1 in 0..k {
        for i2 in 0..i1 {
            let key = (row_keys[i1] ^ row_keys[i2]) as usize;
            table.insert(key, i1 as u8, i2 as u8);
        }
    }
    table
}

/// Run the WSJT-X `npre2 = 1` pass (`osd174_91.f90:230-289`) against
/// the given [`OsdSetup`], updating [`OsdBest`] with any improvement.
///
/// For each MRB outer pattern (nord=1, so each `iflag` flip) and
/// each near-by perturbation `r2pat = e2sub XOR single-bit[i2]`
/// (`i2 = 0..=ntau`), look up which MRB pairs `(in1, in2)` produce a
/// G-column XOR matching `r2pat` in the precomputed table. Each match
/// yields a weight-3 candidate `me = m0 XOR misub XOR bit[in1] XOR
/// bit[in2]`; encode, weighted-distance, CRC-verify, update best.
///
/// The `sum(mi) < nord+npre1+npre2 = 3` guard skips matches whose
/// `in1` / `in2` overlap with `iflag` (would degenerate the
/// "weight-3 pattern" requirement).
fn osd_npre2_pass(setup: &OsdSetup, best: &mut OsdBest, ntau: usize) {
    let n = LDPC_N;
    let k = LDPC_K;
    let table = build_npre2_table(setup, ntau);

    // Same fixed-size scratch + caller-provided unperm buffer pattern
    // as `osd_npre1_pass` — see that function's hoist for rationale
    // (Gemini PR #86 / #87 review).
    let mut ce_misub = [0u8; LDPC_N];
    let mut e2sub = [0u8; LDPC_N - LDPC_K];
    let mut ce_test = [0u8; LDPC_N];
    let mut c_unperm = [0u8; LDPC_N];

    for iflag in (0..k).rev() {
        ce_misub.copy_from_slice(&setup.c_perm);
        for col in 0..n {
            ce_misub[col] ^= setup.g[iflag * n + col];
        }
        for j in 0..(n - k) {
            e2sub[j] = ce_misub[k + j] ^ setup.hdec_perm[k + j];
        }

        // Pack first `ntau` bits of e2sub into a base key.
        let mut base_key: usize = 0;
        for j in 0..ntau {
            if e2sub[j] != 0 {
                base_key |= 1 << (ntau - 1 - j);
            }
        }

        // i2 = 0 → r2pat = e2sub (no perturbation); i2 = 1..=ntau →
        // flip parity bit (i2-1).
        for i2 in 0..=ntau {
            let key = if i2 == 0 {
                base_key
            } else {
                base_key ^ (1 << (ntau - i2))
            };

            for (in1, in2) in table.iter_pairs(key) {
                let in1_u = in1 as usize;
                let in2_u = in2 as usize;
                // Threshold: sum(mi) >= nord + npre1 + npre2 = 3.
                // mi has bits at iflag, in1, in2; skip if any pair
                // overlaps (degenerates to weight-1 or weight-2).
                if iflag == in1_u || iflag == in2_u || in1_u == in2_u {
                    continue;
                }

                ce_test.copy_from_slice(&ce_misub);
                for col in 0..n {
                    ce_test[col] ^= setup.g[in1_u * n + col] ^ setup.g[in2_u * n + col];
                }

                let mut dd = 0.0f32;
                for col in 0..n {
                    if ce_test[col] != setup.hdec_perm[col] {
                        dd += setup.absrx_perm[col];
                    }
                }
                if dd < best.dd
                    && let Some((d, cw)) =
                        try_candidate_ldpc174_91(&setup.perm, &ce_test, &mut c_unperm)
                {
                    best.maybe_update(d, cw, dd);
                }
            }
        }
    }
}

/// Build an [`OsdResult`] from a populated [`OsdBest`] and the raw
/// (un-permuted) `llr`. Used by both `osd_decode_npre1` and
/// `osd_decode_npre1_npre2` to factor out the message77 / hard_errors
/// computation.
fn osd_result_from_best(llr: &[f32; LDPC_N], best: OsdBest) -> Option<OsdResult> {
    let (decoded, codeword) = best.state?;
    let mut hard_errors = 0u32;
    for i in 0..LDPC_N {
        if (codeword[i] == 1) != (llr[i] > 0.0) {
            hard_errors += 1;
        }
    }
    let mut message77 = [0u8; 77];
    message77.copy_from_slice(&decoded[..77]);
    Some(OsdResult {
        message77,
        info: decoded,
        codeword,
        hard_errors,
    })
}

/// WSJT-X-faithful `nord=1 + npre1=1` OSD decode (issue #63).
///
/// Mirrors `osd174_91.f90` with ndeep=2 — the FT8 default that
/// `ft8b.f90:405` dispatches to. Enumerates the same 4,186 weight-2
/// anchored-pair patterns our [`osd_decode`] does (order-1 baseline +
/// npre1 pair-anchor), but applies WSJT-X's `ntheta=10` early-reject
/// gate on partial parity-error count so only ~165 algebraically
/// plausible patterns reach the full encode + CRC verify.
///
/// **False-positive filter.** Pure brute-force `osd_decode` (ndeep=2)
/// occasionally returns CRC-luck codewords at high `nharderrors` — on
/// `qso3_busy.wav` it surfaces two confirmed phantoms (`N1API F2VX 73`
/// at 30 hard errors / -24 dB and `CQ EA2BFM IN83` at 31 / -24 dB).
/// These have parity errors spread broadly across all 83 parity bits,
/// so they trip the `ntheta=10` gate before reaching CRC and never
/// surface from this variant. Real low-SNR signals preserve the
/// algebraic structure of their parity bits and pass the gate.
///
/// The pattern enumeration matches WSJT-X line-for-line:
///   - Outer `iflag` walks from K-1 down to 0 (the 91 single-bit-flip
///     baseline patterns).
///   - Inner `n1` walks from `iflag` down to 0; when `n1 < iflag` the
///     pattern flips two MRB bits (`iflag`, `n1`) — the npre1
///     pair-anchor extension.
///   - The parity-error vector for the `n1 < iflag` case is computed
///     incrementally as `e2 = e2sub XOR g[n1, k..n]`, mirroring
///     `osd174_91:203`.
///
/// Returns `None` if no CRC-passing candidate is found.
pub fn osd_decode_npre1(llr: &[f32; LDPC_N]) -> Option<OsdResult> {
    let setup = osd_setup_ldpc174_91(llr)?;
    let mut best = OsdBest::new();
    osd_npre1_pass(&setup, &mut best, NPRE1_GATE_NDEEP2);
    osd_result_from_best(llr, best)
}

/// WSJT-X-faithful `nord=1 + npre1=1 + npre2=1` OSD decode
/// (= ndeep=3 dispatch).
///
/// Strictly extends [`osd_decode_npre1`]: runs the same npre1 pass
/// with a slightly looser `ntheta=12` gate (vs ndeep=2's 10), then
/// follows with the `npre2` second-stage pre-processing rule
/// (`osd174_91.f90:230-289`). npre2 explores weight-3 patterns that
/// the nord=1 search misses by looking up MRB-pair G-column XORs in a
/// `ntau=14` hash table, then anchoring on each (in1, in2) pair whose
/// generator difference cancels the parity-error vector of the test
/// pattern.
///
/// Pattern count vs other entries:
///
/// | entry | ndeep | raw patterns | post-gate (~) |
/// |---|---:|---:|---:|
/// | [`osd_decode`] | 2 | 4,186 | 4,186 (no gate) |
/// | [`osd_decode_deep`] | 3 | 121,667 | 121,667 (no gate) |
/// | [`osd_decode_npre1`] | 2 | 4,186 | ~165 |
/// | this | 3 | ~127,000 | ~165 + ~few-thousand npre2 |
///
/// Caller dispatch typically routes higher-`q` (cleaner) candidates
/// to ndeep=3 since the npre2 pass costs a 64 KB hash-table build
/// up-front; not worth it on every candidate.
pub fn osd_decode_npre1_npre2(llr: &[f32; LDPC_N]) -> Option<OsdResult> {
    let setup = osd_setup_ldpc174_91(llr)?;
    let mut best = OsdBest::new();
    // ndeep=3 uses ntheta=12 (vs ndeep=2's 10) — looser gate because
    // the npre2 pass below picks up patterns this would have rejected.
    osd_npre1_pass(&setup, &mut best, NPRE1_GATE_NDEEP3);
    osd_npre2_pass(&setup, &mut best, NPRE2_NTAU);
    osd_result_from_best(llr, best)
}

/// Packed-elimination setup for [`osd_decode_generic`], generic over
/// [`LdpcParams`] — the same technique `osd_setup_ldpc174_91` applies
/// to FT8's specific LDPC(174,91), made reusable across every code
/// that shares the generic path (MSK144's LDPC(128,90), uvpacket's
/// LDPC(240,101), FST4).
///
/// Returns `(perm, g, pivot_col)` — identical shape and identical
/// values to what `osd_decode_generic` used to compute inline (steps
/// 1-3): `perm` the reliability-descending column order, `g` the
/// row-reduced generator in byte-per-bit form (every downstream
/// consumer — order-0 encode, `try_candidate`, the `k1..k4` search —
/// is unchanged and still reads `g` this way), `pivot_col[r]` the
/// permuted-space column that row `r` pivoted on.
///
/// **Row-swap elimination, not column-swap** — this is the one place
/// this function's packing differs in *shape* from `osd_setup_
/// ldpc174_91`'s, because the algorithm it is packing differs: this
/// crate's generic path scans columns left-to-right and swaps *rows*
/// into place (`g.swap(r, pivot_row)` below), where FT8's own
/// `osd_setup_ldpc174_91` fixes each row in turn and swaps *columns*.
/// Both reach a valid RREF; they are not required to (and in general
/// won't) select the same pivot positions, so this function does not
/// try to reproduce FT8's specific choice — it packs *this* function's
/// existing algorithm, unchanged, which is what
/// `osd_generic_setup_matches_reference` (this module's test suite)
/// verifies against the pre-packing implementation kept there as a
/// reference.
///
/// Row-swap turns out to be the easier case to pack: swapping two
/// entire packed rows is one `Vec::swap` call, versus the per-bit
/// extract-and-set a column swap needs (see `osd_decode_packed` in
/// `wspr::osd` for that harder case, packing WSPR's column-swap
/// elimination). The row XOR during elimination — this function's
/// hottest inner loop, up to `k·(k−1)` times — is the same class of
/// win either way: `n.div_ceil(64)` word-XORs instead of `n` per-byte
/// ones.
fn osd_setup_generic_packed<P: LdpcParams>(
    llr: &[f32],
) -> Option<(Vec<usize>, Vec<u8>, Vec<usize>)> {
    let n = P::N;
    let k = P::K;
    let words = n.div_ceil(64);

    let mut perm: Vec<usize> = (0..n).collect();
    perm.sort_unstable_by(|&a, &b| {
        llr[b]
            .abs()
            .partial_cmp(&llr[a].abs())
            .unwrap_or(core::cmp::Ordering::Equal)
    });

    let mut g_packed: Vec<Vec<u64>> = vec![vec![0u64; words]; k];
    for row in 0..k {
        for col in 0..n {
            let j = perm[col];
            let bit = if j < k {
                (row == j) as u64
            } else {
                P::gen_parity(j - k, row) as u64
            };
            if bit == 1 {
                g_packed[row][col / 64] |= 1 << (col % 64);
            }
        }
    }

    let mut pivot_col: Vec<usize> = vec![0; k];
    let mut pivot_row = 0usize;
    for col in 0..n {
        if pivot_row >= k {
            break;
        }
        let word = col / 64;
        let bit = col % 64;
        let mut found: Option<usize> = None;
        for r in pivot_row..k {
            if (g_packed[r][word] >> bit) & 1 != 0 {
                found = Some(r);
                break;
            }
        }
        let Some(r) = found else { continue };
        if r != pivot_row {
            g_packed.swap(r, pivot_row);
        }
        let pivot = g_packed[pivot_row].clone();
        for r2 in 0..k {
            if r2 != pivot_row && (g_packed[r2][word] >> bit) & 1 != 0 {
                for c in 0..words {
                    g_packed[r2][c] ^= pivot[c];
                }
            }
        }
        pivot_col[pivot_row] = col;
        pivot_row += 1;
    }

    if pivot_row < k {
        return None; // degenerate (shouldn't happen with a valid LDPC code)
    }

    // Unpack to the byte-per-bit format every downstream consumer
    // expects — one linear O(k*n) pass, negligible next to the O(k²*n)
    // elimination it replaces.
    let mut g: Vec<u8> = vec![0u8; k * n];
    for row in 0..k {
        for col in 0..n {
            g[row * n + col] = ((g_packed[row][col / 64] >> (col % 64)) & 1) as u8;
        }
    }

    Some((perm, g, pivot_col))
}

/// Counts how many patterns WSJT-X's actual `npre1` pre-screening
/// mechanism (`osd240_101.f90`/`osd174_91.f90`'s `nord=1, npre1=1`
/// loop, `nt=40`/`ntheta=12` partial-parity gate) would attempt and
/// pass for a given LLR array — without doing the expensive full
/// codeword construction for gate-passing patterns, only counting
/// them. Issue #306 follow-up (VK3NV): "a cheap indication of the
/// ceiling" — how much smaller is WSJT-X's actual pruned search than
/// `osd_decode_generic`'s unpruned order-3 combinatorial one — before
/// committing to the full genericised port of `npre1`/`npre2`.
///
/// Mirrors `osd240_101.f90` lines 177-203 exactly: for each single-bit
/// "anchor" position `p` (0-based, `0..k`, matching WSJT-X's `iflag`
/// 1-based `1..k`), the "pure" single flip (`n1 == p`, one call
/// equivalent to a real `mrbencode101` — counted here, not performed)
/// plus every second flip `n1 < p` computed incrementally by XORing
/// the single-flip base's parity mismatch against row `n1`'s own
/// parity portion — the same linearity `osd240_101.f90` exploits
/// (`e2 = e2sub XOR g2(k+1:N, n1)`), so no re-encoding is needed per
/// `n1`. Reuses this module's own [`osd_setup_generic_packed`] for the
/// permutation/RREF/order-0 setup — the same code
/// `osd_decode_generic`'s combinatorial search already uses, so the
/// two counts are on equal footing (same reliability ranking, same
/// order-0 baseline).
///
/// Returns `(ntotal, npostgate)`: `ntotal` is the total pattern count
/// attempted (compare against `osd_decode_generic`'s unpruned
/// `C(k,3)` for the equivalent order — this function only replicates
/// the `nord=1` pass, i.e., the ndeep=2/3 count, not `npre2`'s
/// additional weight-3 hash-table pass); `npostgate` is how many of
/// those actually clear the `ntheta` gate and would reach the
/// expensive step in the real algorithm.
#[cfg(feature = "internal-testing")]
pub fn npre1_pattern_counts<P: LdpcParams>(llr: &[f32]) -> Option<(u32, u32)> {
    const NT: usize = 40; // osd240_101.f90/osd174_91.f90 shared constant
    const NTHETA: u32 = 12; // FST4's ndeep=2 and ndeep=3 both use 12

    let n = P::N;
    let k = P::K;
    let (perm, g, pivot_col) = osd_setup_generic_packed::<P>(llr)?;

    let mut hdec = alloc::vec![0u8; n];
    for (col, h) in hdec.iter_mut().enumerate() {
        *h = if llr[perm[col]] > 0.0 { 1 } else { 0 };
    }
    let mut mrb = alloc::vec![0u8; k];
    for (r, m) in mrb.iter_mut().enumerate() {
        let orig = perm[pivot_col[r]];
        *m = if llr[orig] > 0.0 { 1 } else { 0 };
    }
    let mut c0 = alloc::vec![0u8; n];
    for (r, &mr) in mrb.iter().enumerate() {
        if mr == 1 {
            for (col, c) in c0.iter_mut().enumerate() {
                *c ^= g[r * n + col];
            }
        }
    }

    let window = NT.min(n - k);
    let mut ntotal = 0u32;
    let mut npostgate = 0u32;
    let mut e2sub = alloc::vec![0u8; n - k];

    for p in 0..k {
        // n1 == p: the "pure" single-bit flip.
        for i in 0..(n - k) {
            e2sub[i] = (c0[k + i] ^ g[p * n + k + i]) ^ hdec[k + i];
        }
        let mismatches: u32 = e2sub[..window].iter().map(|&b| b as u32).sum();
        ntotal += 1;
        if mismatches < NTHETA {
            npostgate += 1;
        }

        // n1 < p: incremental second flip, matching osd240_101.f90's
        // `e2 = ieor(e2sub, g2(k+1:N,n1))` -- always against the
        // single-flip base `e2sub`, not chained across `n1`.
        for n1 in (0..p).rev() {
            let mismatches: u32 = (0..window)
                .map(|i| (e2sub[i] ^ g[n1 * n + k + i]) as u32)
                .sum();
            ntotal += 1;
            if mismatches + 2 <= NTHETA {
                npostgate += 1;
            }
        }
    }

    Some((ntotal, npostgate))
}

/// Generic OSD with configurable order, parameterised over [`LdpcParams`].
///
/// `ndeep`: search depth (1..=4). `k4_limit`: bound on bit indices used
/// in the order-4 extension; ignored when `ndeep < 4`. `verify`:
/// parity-converged candidate filter; pass `Some(check_crc)` for codecs
/// whose info bits include an inline integrity field, `None` to accept
/// any parity-valid candidate.
///
/// `k4_tail`: which end of the MRB reliability ordering `k4_limit`
/// bounds. Row index in `0..k` runs from the *most* reliable MRB bit
/// (row 0) to the *least* reliable (row `k-1`) — confirmed empirically
/// (issue #306 follow-up), not just asserted: a synthetic strictly-
/// monotonic LLR fed through this function's own setup showed
/// `|llr|` decreasing monotonically from row 0 to row `k-1`. `false`
/// (existing behaviour, every current caller): `k4` ranges over
/// `0..k4_limit` — the *most* reliable end — and the extension only
/// fires when `k1`/`k2`/`k3` are themselves within that same range
/// (transitively, via `k1<k2<k3`). `true`: `k4` ranges over
/// `(k-k4_limit)..k` instead — the *least* reliable end, matching this
/// function's own existing `osd_decode_deep4` doc comment's stated
/// intent ("restricting k4 to the tail... because errors concentrate
/// in low-|LLR| bits") — which the `false` behaviour does not actually
/// implement, despite the doc comment describing it. Added to test
/// that discrepancy directly (issue #306 follow-up, prompted while
/// investigating FST4 OSD costs) rather than assume either direction;
/// `false` for every caller until that AWGN sweep decides one way.
///
/// Algorithm identical to the WSJT-X reference otherwise; only the
/// working buffer shapes are runtime-sized to accommodate either LDPC
/// code.
pub fn osd_decode_generic<P: LdpcParams>(
    llr: &[f32],
    ndeep: u8,
    k4_limit: usize,
    verify: Option<fn(&[u8]) -> bool>,
    k4_tail: bool,
) -> Option<OsdResult> {
    debug_assert_eq!(llr.len(), P::N, "llr length must equal P::N");

    let n = P::N;
    let k = P::K;

    // Steps 1-3 (sort, build, GF(2) eliminate) live in
    // `osd_setup_generic_packed` — see its doc comment for why this
    // is a packed *representation* of exactly the same row-swap
    // elimination this function used to run inline, not a different
    // algorithm. Everything from here on (order-0 encode, the k1..k4
    // search, `try_candidate`) used to consume `g` as plain
    // byte-per-bit throughout; see the `g_packed` repacking below for
    // why that's no longer true of the row-XOR construction specifically.
    let Some((perm, g, pivot_col)) = osd_setup_generic_packed::<P>(llr) else {
        return None; // degenerate (shouldn't happen with a valid LDPC code)
    };

    // Fixed-size scratch, sized with headroom for the largest
    // `LdpcParams` this function serves today (FST4's `N=240`) —
    // avoids a heap alloc/dealloc round-trip on every one of
    // `try_and_update`'s ~166 650 calls for an order-3 FST4 search
    // (issue #306 follow-up: measured 6.28 s/candidate for OSD on
    // real embedded hardware, most of that spent on candidates that
    // fail CRC immediately). `[u8; P::N]` isn't expressible here —
    // `P::N` is a trait-associated const, and stable Rust can't use a
    // generic parameter's associated const as an array length
    // (`generic_const_exprs` remains nightly-only) — so this uses the
    // same "fixed max bound + runtime-length prefix slice" idiom
    // `engine::llr`'s `MAX_NSYM`/`MAX_IBMAX_PLUS_1` already established
    // for the identical problem.
    const OSD_MAX_N: usize = 256; // ≥ 240 (FST4), 174 (FT8), 128 (MSK144)
    const OSD_WORDS: usize = OSD_MAX_N.div_ceil(64); // 4

    // ── Step 4: hard decisions on MRB bits ──────────────────────────
    let mut mrb = [0u8; OSD_MAX_N];
    let mrb = &mut mrb[..k];
    for r in 0..k {
        let orig = perm[pivot_col[r]];
        mrb[r] = if llr[orig] > 0.0 { 1 } else { 0 };
    }

    // Pack `g` (byte-per-bit, from `osd_setup_generic_packed` above)
    // into `OSD_WORDS`-word rows, once, up front — O(k*n), negligible
    // next to what it feeds. `osd_setup_generic_packed` itself already
    // builds and Gaussian-eliminates a packed representation
    // internally, then unpacks it to byte-per-bit before returning
    // (its own doc comment explains why: `packed_setup_differential`'s
    // tests check it against a byte-per-bit reference, and no other
    // caller needs the packed form — until now). Re-packing here,
    // rather than changing what `osd_setup_generic_packed` returns,
    // keeps that function's tested contract untouched and confines
    // this change to the one consumer that actually has a hot loop
    // over `g`: every one of the ~166 650 combinatorial candidates
    // XORs one full `g` row into a running codeword (`c1[col] ^=
    // g[k1*n+col]` for `col in 0..n`, and again for `c2`/`c3`/`c4`) —
    // unlike `try_and_update`'s scatter (moved behind the `verify`
    // gate above), this construction *is* the candidate, so it can't
    // be deferred, only made cheaper per call. No permutation is
    // involved here (both `c*` and `g`'s rows are already in the same
    // permuted-column order), so — same reasoning as
    // `osd_setup_generic_packed`'s own row-XOR during elimination —
    // it packs directly into `n.div_ceil(64)` word-XORs instead of `n`
    // per-byte ones, with no gather/scatter complication.
    let mut g_packed = [[0u64; OSD_WORDS]; OSD_MAX_N];
    let g_packed = &mut g_packed[..k];
    for (row, row_words) in g_packed.iter_mut().enumerate() {
        for col in 0..n {
            if g[row * n + col] != 0 {
                row_words[col / 64] |= 1 << (col % 64);
            }
        }
    }

    // ── Step 5: encode order-0 candidate (packed) ───────────────────
    let mut c_perm_packed = [0u64; OSD_WORDS];
    for r in 0..k {
        if mrb[r] == 1 {
            for w in 0..OSD_WORDS {
                c_perm_packed[w] ^= g_packed[r][w];
            }
        }
    }

    // Permuted hard-decisions and |LLR| — depend only on `perm`/`llr`,
    // both fixed for the rest of this call, so precomputing them once
    // here (O(n)) instead of inside `try_and_update` removes a branch,
    // an `.abs()` call and a double indirection (`llr[perm[col]]`)
    // from the ~166,650-call weighted-distance loop below (issue #306
    // follow-up: the previous per-call heap-alloc fix left this
    // redundant recomputation in place — same closure, different
    // waste). Bit-identical: `try_and_update` used to compute exactly
    // these two values fresh on every call from the same unchanging
    // `perm`/`llr`.
    let mut hdec_perm = [0u8; OSD_MAX_N];
    let hdec_perm = &mut hdec_perm[..n];
    let mut absrx_perm = [0.0f32; OSD_MAX_N];
    let absrx_perm = &mut absrx_perm[..n];
    for col in 0..n {
        hdec_perm[col] = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
        absrx_perm[col] = llr[perm[col]].abs();
    }

    // Inverse permutation: `inv_perm[i]` is the permuted-space column
    // holding unpermuted (systematic) position `i`. `decoded[i]` for
    // `i < k` only ever needs `cp[inv_perm[i]]` — this lets
    // `try_and_update` gather just the `k` bits `verify` needs instead
    // of scattering the full `n`-length codeword (and copying its
    // first `k`) on every call before even checking whether `verify`
    // will reject the candidate a moment later. `verify` (`check_crc14`
    // and its FST4/MSK144 equivalents) is a strong filter — a
    // 14..24-bit CRC rejects essentially every one of the ~166,650
    // wrong FST4 candidates — so this turns the previously
    // always-executed `O(n)` scatter into an `O(k)` gather for the
    // overwhelming majority of calls, deferring the `O(n)` codeword
    // build to the rare (effectively: only the true candidate) path
    // that actually needs it.
    let mut inv_perm = [0usize; OSD_MAX_N];
    let inv_perm = &mut inv_perm[..n];
    for (col, &p) in perm.iter().enumerate() {
        inv_perm[p] = col;
    }

    // Best-so-far, plus the scratch `try_and_update` writes each
    // candidate into before deciding whether it's an improvement.
    // Single closure (not a `try_candidate` + separate `update_best`
    // pair) so there's exactly one `FnMut` capturing all of these by
    // mutable reference, rather than two closures each needing to
    // borrow the other's captures — simpler for the borrow checker,
    // same logic as the previous two-closure version.
    let mut best_wd: Option<f32> = None;
    let mut best_codeword = [0u8; OSD_MAX_N];
    let mut best_decoded = [0u8; OSD_MAX_N];
    let mut scratch_c = [0u8; OSD_MAX_N];
    let mut scratch_decoded = [0u8; OSD_MAX_N];
    // `cp` is now `OSD_WORDS`-word packed (bit `col` lives at
    // `cp[col/64]` bit `col%64`) rather than one byte per bit — the
    // caller (the k1..k4 construction below) builds it via
    // `g_packed`'s word-XORs instead of `g`'s byte-XORs. The gather
    // step (`decoded[i] = bit(cp, inv_perm[i])`) stays `O(k)` either
    // way, just trading a byte load for a shift+mask; the scatter and
    // weighted-distance loops (still `O(n)`, still gated behind
    // `verify` exactly as before) are now one combined pass instead of
    // two, since both need the same per-column bit.
    let mut try_and_update = |cp: &[u64]| {
        let decoded = &mut scratch_decoded[..k];
        for (i, d) in decoded.iter_mut().enumerate() {
            let idx = inv_perm[i];
            *d = ((cp[idx / 64] >> (idx % 64)) & 1) as u8;
        }
        if let Some(f) = verify
            && !f(decoded)
        {
            return;
        }
        let c = &mut scratch_c[..n];
        let mut wd = 0.0f32;
        for col in 0..n {
            let bit = ((cp[col / 64] >> (col % 64)) & 1) as u8;
            c[perm[col]] = bit;
            if bit != hdec_perm[col] {
                wd += absrx_perm[col];
            }
        }
        if best_wd.is_none_or(|bd| wd < bd) {
            best_wd = Some(wd);
            best_codeword[..n].copy_from_slice(&scratch_c[..n]);
            best_decoded[..k].copy_from_slice(&scratch_decoded[..k]);
        }
    };

    // Order-0.
    try_and_update(&c_perm_packed);

    // Orders 1..ndeep: flip 1, 2, …, ndeep MRB bits. `c1`/`c2`/`c3`/`c4`
    // are packed now too — each is computed directly as a word-XOR of
    // its parent and one `g_packed` row (`OSD_WORDS`=4 XORs) instead
    // of a byte copy plus an `n`-element (up to 240) byte-XOR loop,
    // for every one of the ~166 650 order-3 combinations this search
    // makes for FST4.
    let mut c1_packed = [0u64; OSD_WORDS];
    let mut c2_packed = [0u64; OSD_WORDS];
    let mut c3_packed = [0u64; OSD_WORDS];
    let mut c4_packed = [0u64; OSD_WORDS];
    for k1 in 0..k {
        for w in 0..OSD_WORDS {
            c1_packed[w] = c_perm_packed[w] ^ g_packed[k1][w];
        }
        try_and_update(&c1_packed);
        if ndeep < 2 {
            continue;
        }
        for k2 in (k1 + 1)..k {
            for w in 0..OSD_WORDS {
                c2_packed[w] = c1_packed[w] ^ g_packed[k2][w];
            }
            try_and_update(&c2_packed);
            if ndeep < 3 {
                continue;
            }
            for k3 in (k2 + 1)..k {
                for w in 0..OSD_WORDS {
                    c3_packed[w] = c2_packed[w] ^ g_packed[k3][w];
                }
                try_and_update(&c3_packed);
                if ndeep >= 4 {
                    // See `k4_tail`'s doc comment above for which end
                    // of the reliability ordering each branch searches.
                    // `false` branch unchanged from before `k4_tail`
                    // existed — same gate, same range.
                    let (gate, k4_start, k4_end) = if k4_tail {
                        (k1 >= k.saturating_sub(k4_limit), k3 + 1, k)
                    } else {
                        (k3 + 1 < k4_limit, k3 + 1, k4_limit.min(k))
                    };
                    if gate {
                        for k4 in k4_start..k4_end {
                            for w in 0..OSD_WORDS {
                                c4_packed[w] = c3_packed[w] ^ g_packed[k4][w];
                            }
                            try_and_update(&c4_packed);
                        }
                    }
                }
            }
        }
    }

    // ── Step 6: return best ─────────────────────────────────────────
    best_wd?;
    let codeword = &best_codeword[..n];
    let decoded = &best_decoded[..k];
    let mut hard_errors = 0u32;
    for i in 0..n {
        if (codeword[i] == 1) != (llr[i] > 0.0) {
            hard_errors += 1;
        }
    }
    let mut message77 = [0u8; 77];
    message77.copy_from_slice(&decoded[..77]);
    Some(OsdResult {
        message77,
        info: decoded.to_vec(),
        codeword: codeword.to_vec(),
        hard_errors,
    })
}

// ────────────────────────────────────────────────────────────────────────────
// Generic WSJT-X-faithful npre1 / npre1+npre2 OSD (issue #306, VK3NV)
//
// `osd_decode_npre1`/`osd_decode_npre1_npre2` above (issue #63) proved
// out the pruned-search architecture for FT8's `Ldpc174_91Params`, pinned
// throughout to `LDPC_N`/`LDPC_K` for the fixed-array scratch. Issue #198
// found WSJT-X uses this *same* npre1/npre2/ntheta/ntau architecture for
// FST4 (`osd240_101.f90`) and MSK144 (`osd128_90.f90`) too — only the
// tuning constants differ — making FST4/MSK144's `osd_decode_generic`
// dispatch (unpruned k1/k2/k3 combinatorial search) a real WSJT-X-fidelity
// gap, not just an equally-valid alternative implementation.
//
// `npre1_pattern_counts` (above) measured the actual scale of that gap on
// real FST4-60 data before committing to this port: `ntotal=5151`
// (matches `k(k+1)/2` for K=101, and FT8's own `osd_decode_npre1` ndeep=2
// precedent of ~4,186 for K=91 — `cd50179`'s commit message), with a mean
// `npostgate=11` (0.2%) actually reaching the expensive full-codeword
// step — a ~32× reduction in combinatorial scale vs `osd_decode_generic`'s
// unpruned `C(101,3)≈166,650`.
//
// [`osd_decode_npre_generic`] below is that port: the same npre1/npre2
// pass logic as `osd_npre1_pass`/`osd_npre2_pass`, generalised over any
// [`LdpcParams`] via [`osd_setup_generic_packed`] and the same
// "fixed `OSD_MAX_N` bound + runtime-length slice" idiom
// `osd_decode_generic` established (`P::N`/`P::K` can't size a `[T; P::N]`
// array on stable Rust). `ntheta`/`ntau` are runtime parameters rather
// than trait constants — WSJT-X tunes them per-protocol *and* per-ndeep
// (FT8 ndeep=2 uses `ntheta=10`, FST4 ndeep=2/3 both use `ntheta=12`),
// so baking them into `LdpcParams` would need a second axis the trait
// doesn't otherwise have.
//
// Deliberately **not** shared with `osd_decode_generic`'s own setup
// section despite the overlap — that function is the tested, currently-
// shipping search for FT8 order-≤2 dispatch, MSK144, and (until this is
// wired in) FST4; refactoring it to share scaffolding with a brand-new,
// not-yet-bit-verified-against-AWGN search path is a correctness risk
// this port doesn't need to take on. The duplication is confined to
// plain setup arithmetic (no closures, no control flow) — the same
// tolerance this file already extends to
// `osd_setup_ldpc174_91_fortran_pivot` existing alongside
// `osd_setup_ldpc174_91`.

/// Fixed upper bound on `P::N` this generic OSD scratch is sized for.
/// Shared between [`osd_decode_generic`]'s local `OSD_MAX_N` and this
/// port so both stay in sync if a fourth, larger `LdpcParams` is ever
/// added — see `osd_decode_generic`'s own doc comment for why `P::N`
/// can't size the array directly on stable Rust.
const OSD_NPRE_MAX_N: usize = 256; // ≥ 240 (FST4), 174 (FT8), 128 (MSK144)
const OSD_NPRE_WORDS: usize = OSD_NPRE_MAX_N.div_ceil(64); // 4

/// WSJT-X-faithful `npre1` (and, when `run_npre2` is set, `npre1+npre2`)
/// OSD search, generic over any [`LdpcParams`] — the FST4/MSK144-capable
/// counterpart to [`osd_decode_npre1`]/[`osd_decode_npre1_npre2`]'s
/// FT8-pinned originals.
///
/// - `ntheta`: partial-parity gate threshold over the first
///   `min(40, P::N-P::K)` parity bits (WSJT-X `nt`/`ntheta`,
///   `osd174_91.f90`/`osd240_101.f90`). A candidate whose mismatch count
///   in that window, plus its info-bit-flip count, exceeds `ntheta` is
///   rejected without the expensive full encode + `verify` check.
/// - `ntau`: hash-key width for the `npre2` pair-table second stage
///   (`osd174_91.f90`/`osd240_101.f90`'s `ntau`). Ignored when
///   `run_npre2` is `false`.
/// - `run_npre2`: `false` runs only the `npre1` pass (WSJT-X `ndeep=2`
///   equivalent); `true` adds the `npre2` hash-table pass (`ndeep=3`
///   equivalent).
///
/// Algorithm identical to `osd_npre1_pass`/`osd_npre2_pass` (both
/// crate-private, hence unlinked here)
/// otherwise; only the working-buffer shapes are runtime-sized
/// (`OSD_NPRE_MAX_N`-bounded) to accommodate any `LdpcParams` instead of
/// being pinned to `LDPC_N`/`LDPC_K`.
pub fn osd_decode_npre_generic<P: LdpcParams>(
    llr: &[f32],
    ntheta: u32,
    ntau: usize,
    run_npre2: bool,
    verify: Option<fn(&[u8]) -> bool>,
) -> Option<OsdResult> {
    debug_assert_eq!(llr.len(), P::N, "llr length must equal P::N");

    let n = P::N;
    let k = P::K;

    let Some((perm, g, pivot_col)) = osd_setup_generic_packed::<P>(llr) else {
        return None; // degenerate (shouldn't happen with a valid LDPC code)
    };

    let mut mrb = [0u8; OSD_NPRE_MAX_N];
    let mrb = &mut mrb[..k];
    for r in 0..k {
        let orig = perm[pivot_col[r]];
        mrb[r] = if llr[orig] > 0.0 { 1 } else { 0 };
    }

    let mut g_packed = [[0u64; OSD_NPRE_WORDS]; OSD_NPRE_MAX_N];
    let g_packed = &mut g_packed[..k];
    for (row, row_words) in g_packed.iter_mut().enumerate() {
        for col in 0..n {
            if g[row * n + col] != 0 {
                row_words[col / 64] |= 1 << (col % 64);
            }
        }
    }

    let mut c_perm_packed = [0u64; OSD_NPRE_WORDS];
    for r in 0..k {
        if mrb[r] == 1 {
            for w in 0..OSD_NPRE_WORDS {
                c_perm_packed[w] ^= g_packed[r][w];
            }
        }
    }

    let mut hdec_perm = [0u8; OSD_NPRE_MAX_N];
    let hdec_perm = &mut hdec_perm[..n];
    let mut absrx_perm = [0.0f32; OSD_NPRE_MAX_N];
    let absrx_perm = &mut absrx_perm[..n];
    for col in 0..n {
        hdec_perm[col] = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
        absrx_perm[col] = llr[perm[col]].abs();
    }

    let mut inv_perm = [0usize; OSD_NPRE_MAX_N];
    let inv_perm = &mut inv_perm[..n];
    for (col, &p) in perm.iter().enumerate() {
        inv_perm[p] = col;
    }

    // Same verify-gate-first, deferred-scatter `try_and_update` as
    // `osd_decode_generic` — see that function's doc comment for the
    // rationale. Here the `ntheta`/`ntau` gates upstream already prune
    // to a handful of calls (measured mean 11/5151 for FST4-60), so
    // there's no need for `osd_npre1_pass`'s original
    // `dd < best.dd`-before-CRC micro-optimisation on top of that.
    let mut best_wd: Option<f32> = None;
    let mut best_codeword = [0u8; OSD_NPRE_MAX_N];
    let mut best_decoded = [0u8; OSD_NPRE_MAX_N];
    let mut scratch_c = [0u8; OSD_NPRE_MAX_N];
    let mut scratch_decoded = [0u8; OSD_NPRE_MAX_N];
    let mut try_and_update = |cp: &[u64]| {
        let decoded = &mut scratch_decoded[..k];
        for (i, d) in decoded.iter_mut().enumerate() {
            let idx = inv_perm[i];
            *d = ((cp[idx / 64] >> (idx % 64)) & 1) as u8;
        }
        if let Some(f) = verify
            && !f(decoded)
        {
            return;
        }
        let c = &mut scratch_c[..n];
        let mut wd = 0.0f32;
        for col in 0..n {
            let bit = ((cp[col / 64] >> (col % 64)) & 1) as u8;
            c[perm[col]] = bit;
            if bit != hdec_perm[col] {
                wd += absrx_perm[col];
            }
        }
        if best_wd.is_none_or(|bd| wd < bd) {
            best_wd = Some(wd);
            best_codeword[..n].copy_from_slice(&scratch_c[..n]);
            best_decoded[..k].copy_from_slice(&scratch_decoded[..k]);
        }
    };

    // Order-0 baseline.
    try_and_update(&c_perm_packed);

    // ── npre1 pass (mirrors `osd_npre1_pass`) ───────────────────────
    let nt = NPRE1_PARITY_WINDOW.min(n - k);
    let mut e2sub = [0u8; OSD_NPRE_MAX_N];
    let e2sub = &mut e2sub[..(n - k)];
    let mut e2 = [0u8; OSD_NPRE_MAX_N];
    let e2 = &mut e2[..(n - k)];
    let mut ce_iflag_packed = [0u64; OSD_NPRE_WORDS];
    let mut ce_pair_packed = [0u64; OSD_NPRE_WORDS];

    for iflag in (0..k).rev() {
        for w in 0..OSD_NPRE_WORDS {
            ce_iflag_packed[w] = c_perm_packed[w] ^ g_packed[iflag][w];
        }
        for (j, e) in e2sub.iter_mut().enumerate() {
            let col = k + j;
            let bit = ((ce_iflag_packed[col / 64] >> (col % 64)) & 1) as u8;
            *e = bit ^ hdec_perm[col];
        }
        let parity_err: u32 = e2sub[..nt].iter().map(|&b| b as u32).sum();
        // WSJT-X gate is `parity_err + 1 <= ntheta` (the +1 accounts
        // for the iflag info-bit flip); written as `parity_err <
        // ntheta` to silence clippy::int_plus_one, same as
        // `osd_npre1_pass`.
        if parity_err < ntheta {
            try_and_update(&ce_iflag_packed);
        }

        for n1 in (0..iflag).rev() {
            for j in 0..(n - k) {
                let col = k + j;
                let g_bit = ((g_packed[n1][col / 64] >> (col % 64)) & 1) as u8;
                e2[j] = e2sub[j] ^ g_bit;
            }
            let parity_err_pair: u32 = e2[..nt].iter().map(|&b| b as u32).sum();
            // +2 for the two info-bit flips (iflag + n1).
            if parity_err_pair + 2 > ntheta {
                continue;
            }
            for w in 0..OSD_NPRE_WORDS {
                ce_pair_packed[w] = ce_iflag_packed[w] ^ g_packed[n1][w];
            }
            try_and_update(&ce_pair_packed);
        }
    }

    // ── npre2 pass (mirrors `build_npre2_table`/`osd_npre2_pass`) ──
    if run_npre2 {
        let mut table = OsdNpre2Table::new(ntau);
        let mut row_keys = [0u16; OSD_NPRE_MAX_N];
        let row_keys = &mut row_keys[..k];
        for (i, rk) in row_keys.iter_mut().enumerate() {
            let mut key: u16 = 0;
            for j in 0..ntau {
                let col = k + j;
                let bit = ((g_packed[i][col / 64] >> (col % 64)) & 1) as u8;
                if bit != 0 {
                    key |= 1u16 << (ntau - 1 - j);
                }
            }
            *rk = key;
        }
        for i1 in 0..k {
            for i2 in 0..i1 {
                let key = (row_keys[i1] ^ row_keys[i2]) as usize;
                table.insert(key, i1 as u8, i2 as u8);
            }
        }

        let mut ce_misub_packed = [0u64; OSD_NPRE_WORDS];
        let mut ce_test_packed = [0u64; OSD_NPRE_WORDS];
        for iflag in (0..k).rev() {
            for w in 0..OSD_NPRE_WORDS {
                ce_misub_packed[w] = c_perm_packed[w] ^ g_packed[iflag][w];
            }
            for (j, e) in e2sub.iter_mut().enumerate() {
                let col = k + j;
                let bit = ((ce_misub_packed[col / 64] >> (col % 64)) & 1) as u8;
                *e = bit ^ hdec_perm[col];
            }

            let mut base_key: usize = 0;
            for j in 0..ntau {
                if e2sub[j] != 0 {
                    base_key |= 1 << (ntau - 1 - j);
                }
            }

            for i2 in 0..=ntau {
                let key = if i2 == 0 {
                    base_key
                } else {
                    base_key ^ (1 << (ntau - i2))
                };
                for (in1, in2) in table.iter_pairs(key) {
                    let in1_u = in1 as usize;
                    let in2_u = in2 as usize;
                    if iflag == in1_u || iflag == in2_u || in1_u == in2_u {
                        continue;
                    }
                    for w in 0..OSD_NPRE_WORDS {
                        ce_test_packed[w] =
                            ce_misub_packed[w] ^ g_packed[in1_u][w] ^ g_packed[in2_u][w];
                    }
                    try_and_update(&ce_test_packed);
                }
            }
        }
    }

    best_wd?;
    let codeword = &best_codeword[..n];
    let decoded = &best_decoded[..k];
    let mut hard_errors = 0u32;
    for i in 0..n {
        if (codeword[i] == 1) != (llr[i] > 0.0) {
            hard_errors += 1;
        }
    }
    let mut message77 = [0u8; 77];
    message77.copy_from_slice(&decoded[..77]);
    Some(OsdResult {
        message77,
        info: decoded.to_vec(),
        codeword: codeword.to_vec(),
        hard_errors,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Byte-per-bit reference copy of `osd_setup_ldpc174_91` as it
    /// existed before the bit-packed Gaussian elimination rewrite
    /// (issue #182 perf follow-up). Exists solely so
    /// `packed_elimination_matches_byte_reference` can differentially
    /// verify the packed rewrite is a pure implementation-detail
    /// change, not a behavior change — do not "fix" this to match any
    /// future change to the real function; it's intentionally frozen.
    fn osd_setup_ldpc174_91_byte_reference(llr: &[f32; LDPC_N]) -> Option<OsdSetup> {
        let n = LDPC_N;
        let k = LDPC_K;

        let mut perm: Vec<usize> = (0..n).collect();
        perm.sort_unstable_by(|&a, &b| {
            llr[b]
                .abs()
                .partial_cmp(&llr[a].abs())
                .unwrap_or(core::cmp::Ordering::Equal)
        });

        let mut g: Vec<u8> = vec![0u8; k * n];
        for row in 0..k {
            for col in 0..n {
                let j = perm[col];
                g[row * n + col] = if j < k {
                    (row == j) as u8
                } else {
                    <Ldpc174_91Params as LdpcParams>::gen_parity(j - k, row)
                };
            }
        }

        let mut pivot_col: Vec<usize> = vec![0; k];
        let mut pivot_row = 0usize;
        for col in 0..n {
            if pivot_row >= k {
                break;
            }
            let mut found: Option<usize> = None;
            for r in pivot_row..k {
                if g[r * n + col] != 0 {
                    found = Some(r);
                    break;
                }
            }
            if let Some(r) = found {
                if r != pivot_row {
                    for c in 0..n {
                        g.swap(r * n + c, pivot_row * n + c);
                    }
                }
                for r2 in 0..k {
                    if r2 != pivot_row && g[r2 * n + col] != 0 {
                        for c in 0..n {
                            g[r2 * n + c] ^= g[pivot_row * n + c];
                        }
                    }
                }
                pivot_col[pivot_row] = col;
                pivot_row += 1;
            }
        }
        if pivot_row < k {
            return None;
        }

        let mut m0: Vec<u8> = vec![0u8; k];
        for r in 0..k {
            let orig = perm[pivot_col[r]];
            m0[r] = if llr[orig] > 0.0 { 1 } else { 0 };
        }

        let mut hdec_perm: Vec<u8> = vec![0u8; n];
        let mut absrx_perm: Vec<f32> = vec![0.0f32; n];
        for col in 0..n {
            hdec_perm[col] = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
            absrx_perm[col] = llr[perm[col]].abs();
        }

        let mut c_perm: Vec<u8> = vec![0u8; n];
        for r in 0..k {
            if m0[r] == 1 {
                for col in 0..n {
                    c_perm[col] ^= g[r * n + col];
                }
            }
        }

        Some(OsdSetup {
            perm,
            g,
            hdec_perm,
            absrx_perm,
            c_perm,
        })
    }

    /// Differential test (issue #182 perf follow-up): the bit-packed
    /// `osd_setup_ldpc174_91` must produce byte-for-byte identical
    /// output to the frozen byte-per-bit reference above, across many
    /// LLR inputs — not just "does the regression suite still pass"
    /// (which only exercises a handful of real-world candidates), but
    /// exhaustive equivalence including edge cases the reference WAVs
    /// may not hit (e.g. exact-tie |LLR| magnitudes).
    #[test]
    fn packed_elimination_matches_byte_reference() {
        fn synth_llr(seed: u32) -> [f32; LDPC_N] {
            let mut llr = [0f32; LDPC_N];
            let mut s = seed;
            for x in llr.iter_mut() {
                s = s.wrapping_mul(1_103_515_245).wrapping_add(12345);
                let u = (s >> 8) as f32 / (1u32 << 24) as f32; // [0,1)
                *x = (u - 0.5) * 6.0;
            }
            llr
        }

        for seed in [0x1234_5678u32, 1, 42, 0xdead_beef, 0xc0ffee] {
            let llr = synth_llr(seed);
            let expected = osd_setup_ldpc174_91_byte_reference(&llr);
            let actual = osd_setup_ldpc174_91(&llr);
            match (expected, actual) {
                (Some(e), Some(a)) => {
                    assert_eq!(e.perm, a.perm, "seed={seed}: perm mismatch");
                    assert_eq!(e.g, a.g, "seed={seed}: g mismatch");
                    assert_eq!(e.hdec_perm, a.hdec_perm, "seed={seed}: hdec_perm mismatch");
                    assert_eq!(
                        e.absrx_perm, a.absrx_perm,
                        "seed={seed}: absrx_perm mismatch"
                    );
                    assert_eq!(e.c_perm, a.c_perm, "seed={seed}: c_perm mismatch");
                }
                (None, None) => {}
                _ => panic!("seed={seed}: Some/None mismatch between reference and packed"),
            }
        }

        // Degenerate/edge cases: all-zero (many exact ties), all-same-
        // sign, and an exact-tie-heavy pattern.
        let all_zero = [0f32; LDPC_N];
        let mut alternating = [0f32; LDPC_N];
        for (i, x) in alternating.iter_mut().enumerate() {
            *x = if i % 2 == 0 { 1.0 } else { -1.0 };
        }
        for (label, llr) in [("all_zero", all_zero), ("alternating", alternating)] {
            let expected = osd_setup_ldpc174_91_byte_reference(&llr);
            let actual = osd_setup_ldpc174_91(&llr);
            match (expected, actual) {
                (Some(e), Some(a)) => {
                    assert_eq!(e.perm, a.perm, "{label}: perm mismatch");
                    assert_eq!(e.g, a.g, "{label}: g mismatch");
                    assert_eq!(e.hdec_perm, a.hdec_perm, "{label}: hdec_perm mismatch");
                    assert_eq!(e.absrx_perm, a.absrx_perm, "{label}: absrx_perm mismatch");
                    assert_eq!(e.c_perm, a.c_perm, "{label}: c_perm mismatch");
                }
                (None, None) => {}
                _ => panic!("{label}: Some/None mismatch between reference and packed"),
            }
        }
    }

    /// Throwaway probe (issue #182 cost investigation) — NOT for
    /// commit. `osd_setup_ldpc174_91` (basis construction: sort +
    /// Gaussian elimination) reruns from scratch on every one of the 8
    /// zsave-seeded dispatches per candidate in `try_fallback` — splits
    /// out how much of a single `osd_decode_npre1` call's cost is setup
    /// vs the actual `npre1` pattern search.
    #[test]
    #[ignore = "manual diagnostic — issue #182 setup-vs-search cost split"]
    fn issue_182_setup_vs_search_cost() {
        // Synthetic but realistic-shaped LLR: random-ish magnitudes so
        // the Gaussian elimination and npre1 gate behave like a real
        // noisy candidate, not a degenerate all-same-value case.
        let mut llr = [0f32; LDPC_N];
        let mut seed = 0x1234_5678u32;
        for x in llr.iter_mut() {
            seed = seed.wrapping_mul(1_103_515_245).wrapping_add(12345);
            let u = (seed >> 8) as f32 / (1u32 << 24) as f32; // [0,1)
            *x = (u - 0.5) * 6.0; // roughly [-3,3), plausible LLR range
        }

        const REPS: usize = 2000;
        let t0 = std::time::Instant::now();
        for _ in 0..REPS {
            let _ = osd_setup_ldpc174_91(&llr);
        }
        let setup_only = t0.elapsed();

        let t1 = std::time::Instant::now();
        for _ in 0..REPS {
            if let Some(setup) = osd_setup_ldpc174_91(&llr) {
                let mut best = OsdBest::new();
                osd_npre1_pass(&setup, &mut best, NPRE1_GATE_NDEEP2);
            }
        }
        let setup_plus_search = t1.elapsed();

        println!(
            "setup_only: {:?}/call ({:?} total for {REPS} reps)",
            setup_only / REPS as u32,
            setup_only
        );
        println!(
            "setup+npre1_pass: {:?}/call ({:?} total for {REPS} reps)",
            setup_plus_search / REPS as u32,
            setup_plus_search
        );
        println!(
            "npre1_pass alone (by subtraction): {:?}/call",
            (setup_plus_search.saturating_sub(setup_only)) / REPS as u32
        );
    }

    /// All-zero LLR should not produce a spurious decode (CRC check guards it).
    #[test]
    fn zero_llr_no_spurious_decode() {
        let llr = [0.0f32; LDPC_N];
        // The all-zero codeword may or may not pass CRC; just check no panic.
        let _ = osd_decode(&llr);
    }

    /// Smoke: `osd_decode_npre1` on all-zero LLR returns `None` or a
    /// codeword without panicking — same minimum-viable contract as
    /// `osd_decode`.
    #[test]
    fn npre1_zero_llr_no_panic() {
        let llr = [0.0f32; LDPC_N];
        let _ = osd_decode_npre1(&llr);
    }

    /// Smoke: `osd_decode_npre1_npre2` on all-zero LLR. Same contract
    /// as the npre1 entry — also exercises the 64 KB hash-table build
    /// path without panic.
    #[test]
    fn npre1_npre2_zero_llr_no_panic() {
        let llr = [0.0f32; LDPC_N];
        let _ = osd_decode_npre1_npre2(&llr);
    }

    /// Clean-LLR round-trip via the ndeep=3 entry. Order-0 (= encode
    /// of MRB hard decisions) is exactly the input codeword, so this
    /// also serves as a sanity check that the npre1 → npre2 pass
    /// sequence doesn't accidentally overwrite the order-0 best with
    /// a worse-distance candidate.
    #[test]
    fn npre1_npre2_decodes_clean_codeword() {
        use super::super::bp::crc14;
        let mut info_with_crc = [0u8; LDPC_K];
        for i in 0..77 {
            info_with_crc[i] = ((i * 13 + 7) & 1) as u8;
        }
        let mut bytes = [0u8; 12];
        for (i, &bit) in info_with_crc[..77].iter().enumerate() {
            bytes[i / 8] |= (bit & 1) << (7 - (i % 8));
        }
        let crc = crc14(&bytes);
        for j in 0..14 {
            info_with_crc[77 + j] = ((crc >> (13 - j)) & 1) as u8;
        }
        let cw = ldpc_encode(&info_with_crc);
        let mut llr = [0.0f32; LDPC_N];
        for i in 0..LDPC_N {
            llr[i] = if cw[i] == 1 { 4.0 } else { -4.0 };
        }
        let osd = osd_decode_npre1_npre2(&llr).expect("clean LLR must decode");
        assert_eq!(&osd.info[..91], &info_with_crc[..]);
        assert_eq!(osd.hard_errors, 0);
    }

    /// Round-trip: a well-conditioned LLR derived from a known
    /// CRC-valid info word should decode back to the same info via
    /// `osd_decode_npre1`. The order-0 candidate (encode of hard
    /// decisions) is exactly the input codeword on this clean LLR, so
    /// the algorithm only needs to validate CRC and return — exercises
    /// permutation + RREF + try_candidate without touching the
    /// npre1 enumeration path.
    #[test]
    fn npre1_decodes_clean_codeword() {
        use super::super::bp::crc14;
        // Build a CRC-valid 91-bit info: a fixed 77-bit payload + its
        // CRC-14 in bits 77..91. `check_crc14` packs the 77-bit field
        // into 12 bytes (big-endian, MSB-first) — replicate the same
        // packing here to compute the expected CRC.
        let mut info_with_crc = [0u8; LDPC_K];
        for i in 0..77 {
            info_with_crc[i] = ((i * 13 + 7) & 1) as u8;
        }
        let mut bytes = [0u8; 12];
        for (i, &bit) in info_with_crc[..77].iter().enumerate() {
            bytes[i / 8] |= (bit & 1) << (7 - (i % 8));
        }
        let crc = crc14(&bytes);
        for j in 0..14 {
            info_with_crc[77 + j] = ((crc >> (13 - j)) & 1) as u8;
        }
        // Sanity: `check_crc14` accepts our hand-rolled info.
        assert!(
            check_crc14(&info_with_crc),
            "test CRC packing must round-trip"
        );
        let cw = ldpc_encode(&info_with_crc);
        // Make a strong-confidence LLR: positive for cw=1 bits, negative
        // for cw=0 — magnitude well above any noise floor.
        let mut llr = [0.0f32; LDPC_N];
        for i in 0..LDPC_N {
            llr[i] = if cw[i] == 1 { 4.0 } else { -4.0 };
        }
        let osd = osd_decode_npre1(&llr).expect("clean LLR must decode");
        assert_eq!(
            &osd.info[..91],
            &info_with_crc[..],
            "decoded info bits must match the encoded input"
        );
        assert_eq!(osd.hard_errors, 0, "clean LLR has zero hard errors");
    }

    /// Verify that ldpc_encode produces codewords that satisfy ALL 83 parity
    /// check equations stored in the NM/NRW tables.
    ///
    /// If this test fails, GEN_PARITY is inconsistent with the check matrix —
    /// confirmed encoder bug.
    #[test]
    fn verify_ldpc_encode_parity() {
        use super::super::LDPC_M;
        use super::super::tables::{NM, NRW};

        // Test with several different info vectors to catch row-specific bugs.
        let test_infos: &[[u8; LDPC_K]] = &[
            [1u8; LDPC_K], // all ones
            {
                let mut v = [0u8; LDPC_K];
                for i in (0..LDPC_K).step_by(2) {
                    v[i] = 1;
                }
                v
            }, // alternating
            {
                let mut v = [0u8; LDPC_K];
                // first 77 bits = 1 (message), last 14 = 0 (CRC placeholder)
                for i in 0..77 {
                    v[i] = 1;
                }
                v
            },
        ];

        for (t, info) in test_infos.iter().enumerate() {
            let cw = ldpc_encode(info);
            for j in 0..LDPC_M {
                let n = NRW[j] as usize;
                let check: u8 = NM[j][..n]
                    .iter()
                    .map(|&i| cw[i as usize])
                    .fold(0u8, |acc, b| acc ^ b);
                assert_eq!(
                    check, 0,
                    "GEN_PARITY inconsistency: parity check row {} failed for test info #{} — encoder bug confirmed",
                    j, t
                );
            }
        }
    }
}

#[cfg(test)]
mod packed_setup_differential {
    use super::*;
    use crate::fec::ldpc::params::{Ldpc128_90Params, Ldpc240_101Params};

    /// The setup `osd_decode_generic` used before packing, preserved
    /// here verbatim as the reference `osd_setup_generic_packed` is
    /// checked against — the same "keep the old implementation as the
    /// diff target" pattern `wspr::osd::osd_decode` is kept for.
    pub(super) fn osd_setup_generic_reference<P: LdpcParams>(
        llr: &[f32],
    ) -> Option<(Vec<usize>, Vec<u8>, Vec<usize>)> {
        let n = P::N;
        let k = P::K;

        let mut perm: Vec<usize> = (0..n).collect();
        perm.sort_unstable_by(|&a, &b| {
            llr[b]
                .abs()
                .partial_cmp(&llr[a].abs())
                .unwrap_or(core::cmp::Ordering::Equal)
        });

        let mut g: Vec<u8> = vec![0u8; k * n];
        for row in 0..k {
            for col in 0..n {
                let j = perm[col];
                g[row * n + col] = if j < k {
                    (row == j) as u8
                } else {
                    P::gen_parity(j - k, row)
                };
            }
        }

        let mut pivot_col: Vec<usize> = vec![0; k];
        let mut pivot_row = 0usize;
        for col in 0..n {
            if pivot_row >= k {
                break;
            }
            let mut found: Option<usize> = None;
            for r in pivot_row..k {
                if g[r * n + col] != 0 {
                    found = Some(r);
                    break;
                }
            }
            if let Some(r) = found {
                if r != pivot_row {
                    for c in 0..n {
                        g.swap(r * n + c, pivot_row * n + c);
                    }
                }
                for r2 in 0..k {
                    if r2 != pivot_row && g[r2 * n + col] != 0 {
                        for c in 0..n {
                            g[r2 * n + c] ^= g[pivot_row * n + c];
                        }
                    }
                }
                pivot_col[pivot_row] = col;
                pivot_row += 1;
            }
        }

        if pivot_row < k {
            return None;
        }
        Some((perm, g, pivot_col))
    }

    /// Deterministic xorshift32 — no external RNG dependency, and
    /// reproducible across runs so a failure is re-diagnosable.
    struct Xorshift32(u32);
    impl Xorshift32 {
        fn next_f32(&mut self) -> f32 {
            self.0 ^= self.0 << 13;
            self.0 ^= self.0 >> 17;
            self.0 ^= self.0 << 5;
            (self.0 % 4000) as f32 / 100.0 - 20.0 // spread over [-20, 20)
        }
    }

    /// Real codewords (valid, so elimination never degenerates by
    /// construction) plus synthetic LLR noise, covering both concrete
    /// `LdpcParams` the generic path serves. Not a hand-picked case:
    /// `REPS` distinct random info vectors × independent noise draws
    /// per protocol.
    fn check_matches<P: LdpcParams>(seed: u32) {
        const REPS: usize = 200;
        let mut rng = Xorshift32(seed);
        let mut mismatches = 0usize;
        for t in 0..REPS {
            let mut info = alloc::vec![0u8; P::K];
            for b in info.iter_mut() {
                rng.0 ^= rng.0 << 13;
                rng.0 ^= rng.0 >> 17;
                rng.0 ^= rng.0 << 5;
                *b = (rng.0 & 1) as u8;
            }
            let mut cw = alloc::vec![0u8; P::N];
            ldpc_encode_generic::<P>(&info, &mut cw);

            let llr: alloc::vec::Vec<f32> = cw
                .iter()
                .map(|&b| {
                    let noise = rng.next_f32();
                    // Sign convention matches `mrb`'s: bit=1 -> llr>0
                    // (`mrb[r] = if llr[orig] > 0.0 { 1 } else { 0 }`).
                    (if b == 1 { 10.0 } else { -10.0 }) + noise
                })
                .collect();

            let reference = osd_setup_generic_reference::<P>(&llr);
            let packed = osd_setup_generic_packed::<P>(&llr);
            if reference != packed {
                mismatches += 1;
                eprintln!("trial {t}: reference={reference:?}\npacked={packed:?}");
            }
        }
        assert_eq!(mismatches, 0, "{mismatches}/{REPS} trials diverged");
    }

    #[test]
    fn matches_reference_ldpc128_90() {
        check_matches::<Ldpc128_90Params>(0xC0FF_EE01);
    }

    #[test]
    fn matches_reference_ldpc240_101() {
        check_matches::<Ldpc240_101Params>(0xC0FF_EE02);
    }

    #[test]
    fn matches_reference_ldpc174_91() {
        check_matches::<Ldpc174_91Params>(0xC0FF_EE03);
    }

    /// End-to-end, not just the setup: `osd_decode_generic` itself
    /// (packed setup + unchanged encode/search/verify) must recover
    /// the exact transmitted info bits from a clean (noise-free)
    /// codeword — the property the setup differential can't see on
    /// its own, since a setup bug that happens to still produce *some*
    /// valid RREF wouldn't necessarily show up as a `(perm, g,
    /// pivot_col)` mismatch against a differently-parameterised
    /// reference call.
    #[test]
    fn osd_decode_generic_recovers_clean_codeword() {
        let info: alloc::vec::Vec<u8> = (0..Ldpc128_90Params::K)
            .map(|i| (i % 3 == 0) as u8)
            .collect();
        let mut cw = alloc::vec![0u8; Ldpc128_90Params::N];
        ldpc_encode_generic::<Ldpc128_90Params>(&info, &mut cw);
        let llr: alloc::vec::Vec<f32> = cw
            .iter()
            .map(|&b| if b == 1 { 10.0 } else { -10.0 })
            .collect();
        let result =
            osd_decode_generic::<Ldpc128_90Params>(&llr, 2, Ldpc128_90Params::K, None, false)
                .expect("clean codeword must decode");
        assert_eq!(result.info, info);
    }
}

#[cfg(test)]
mod packed_setup_timing {
    use super::packed_setup_differential::*;
    use super::*;
    use crate::fec::ldpc::params::Ldpc128_90Params;
    use std::time::Instant;

    /// Host per-call cost of the setup step alone (sort + build +
    /// eliminate), reference vs packed, for MSK144's LDPC(128,90).
    /// `#[ignore]`d: prints, asserts nothing — a speed number, not a
    /// correctness gate (that's `packed_setup_differential`).
    #[test]
    #[ignore = "manual diagnostic — osd setup host timing, reference vs packed"]
    fn setup_timing_ldpc128_90() {
        let llr: alloc::vec::Vec<f32> = (0..Ldpc128_90Params::N)
            .map(|i| ((i as f32 * 37.0) % 41.0) - 20.0)
            .collect();

        let _ = osd_setup_generic_reference::<Ldpc128_90Params>(&llr);
        const REPS: usize = 5000;
        let t0 = Instant::now();
        for _ in 0..REPS {
            let _ = std::hint::black_box(osd_setup_generic_reference::<Ldpc128_90Params>(
                std::hint::black_box(&llr),
            ));
        }
        let reference = t0.elapsed();

        let _ = osd_setup_generic_packed::<Ldpc128_90Params>(&llr);
        let t0 = Instant::now();
        for _ in 0..REPS {
            let _ = std::hint::black_box(osd_setup_generic_packed::<Ldpc128_90Params>(
                std::hint::black_box(&llr),
            ));
        }
        let packed = t0.elapsed();

        eprintln!(
            "reference: {:.2} us/call | packed: {:.2} us/call | {:.2}x",
            reference.as_secs_f64() * 1e6 / REPS as f64,
            packed.as_secs_f64() * 1e6 / REPS as f64,
            reference.as_secs_f64() / packed.as_secs_f64(),
        );
    }
}