mfsk-core 0.7.4

//! 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)
}

/// 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)
}

/// 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))
}

// ────────────────────────────────────────────────────────────────────────────
// 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)
    });

    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,
    })
}

/// 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)
}

/// Generic OSD with configurable order, parameterised over [`LdpcParams`].
///
/// `ndeep`: search depth (1..=4). `k4_limit`: upper bound (exclusive)
/// 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.
///
/// Algorithm identical to the WSJT-X reference; 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>,
) -> Option<OsdResult> {
    debug_assert_eq!(llr.len(), P::N, "llr length must equal P::N");

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

    // ── Step 1: sort bit indices by |LLR| descending ────────────────
    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)
    });

    // ── Step 2: build permuted generator matrix G'[K][N] (flat) ─────
    // G[row][col] in original space:
    //   col <  K → identity: G[row][col] = (row == col) as u8
    //   col >= K → parity:   G[row][col] = gen_parity(col - K, row)
    // Flat index: g[row * n + col].
    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)
            };
        }
    }

    // ── Step 3: GF(2) Gaussian elimination (RREF, no column swaps) ──
    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; // degenerate (shouldn't happen with a valid LDPC code)
    }

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

    // ── Step 5: encode order-0 candidate ────────────────────────────
    let mut c_perm: Vec<u8> = vec![0u8; n];
    for r in 0..k {
        if mrb[r] == 1 {
            for col in 0..n {
                c_perm[col] ^= g[r * n + col];
            }
        }
    }

    // Helper: unpermute, verify, compute weighted distance.
    // Returned tuples carry full Vec<u8>'s for both info and codeword
    // so any P::K / P::N works.
    let try_candidate = |cp: &[u8]| -> Option<(Vec<u8>, Vec<u8>, f32)> {
        let mut c = vec![0u8; n];
        for col in 0..n {
            c[perm[col]] = cp[col];
        }
        let decoded = c[..k].to_vec();
        if let Some(f) = verify
            && !f(&decoded)
        {
            return None;
        }
        let mut wd = 0.0f32;
        for col in 0..n {
            let hard = if llr[perm[col]] > 0.0 { 1u8 } else { 0u8 };
            if cp[col] != hard {
                wd += llr[perm[col]].abs();
            }
        }
        Some((decoded, c, wd))
    };

    let mut best: Option<(Vec<u8>, Vec<u8>, f32)> = None;
    let mut update_best = |decoded: Vec<u8>, cw: Vec<u8>, wd: f32| {
        let improve = best.as_ref().is_none_or(|(_, _, bd)| wd < *bd);
        if improve {
            best = Some((decoded, cw, wd));
        }
    };

    // Order-0.
    if let Some((d, cw, wd)) = try_candidate(&c_perm) {
        update_best(d, cw, wd);
    }

    // Orders 1..ndeep: flip 1, 2, …, ndeep MRB bits. Reuse buffers
    // across iterations to avoid per-candidate Vec allocs.
    let mut c1 = vec![0u8; n];
    let mut c2 = vec![0u8; n];
    let mut c3 = vec![0u8; n];
    let mut c4 = vec![0u8; n];
    for k1 in 0..k {
        c1.copy_from_slice(&c_perm);
        for col in 0..n {
            c1[col] ^= g[k1 * n + col];
        }
        if let Some((d, cw, wd)) = try_candidate(&c1) {
            update_best(d, cw, wd);
        }
        if ndeep < 2 {
            continue;
        }
        for k2 in (k1 + 1)..k {
            c2.copy_from_slice(&c1);
            for col in 0..n {
                c2[col] ^= g[k2 * n + col];
            }
            if let Some((d, cw, wd)) = try_candidate(&c2) {
                update_best(d, cw, wd);
            }
            if ndeep < 3 {
                continue;
            }
            for k3 in (k2 + 1)..k {
                c3.copy_from_slice(&c2);
                for col in 0..n {
                    c3[col] ^= g[k3 * n + col];
                }
                if let Some((d, cw, wd)) = try_candidate(&c3) {
                    update_best(d, cw, wd);
                }
                if ndeep >= 4 && k3 + 1 < k4_limit {
                    for k4 in (k3 + 1)..k4_limit.min(k) {
                        c4.copy_from_slice(&c3);
                        for col in 0..n {
                            c4[col] ^= g[k4 * n + col];
                        }
                        if let Some((d, cw, wd)) = try_candidate(&c4) {
                            update_best(d, cw, wd);
                        }
                    }
                }
            }
        }
    }

    // ── Step 6: return best ─────────────────────────────────────────
    let (decoded, codeword, _) = best?;
    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,
        codeword,
        hard_errors,
    })
}

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

    /// 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
                );
            }
        }
    }
}