"""Exact reciprocal repair, over GF(2). Python 3.10+, standard library only.

Square matrices use one Python integer per row. Reported work is a specified
word-RAM model, NOT FLOPs or a claimed hardware-neutral speedup. n <= 64.
Every matrix traversal, word xor, set-bit scan, comparison, RNG draw and
search bookkeeping has a deterministic charge; elapsed time is also reported.
"""
from __future__ import annotations

from collections import Counter
from dataclasses import dataclass, field
import random

Mat = tuple[int, ...]


class BudgetExhausted(RuntimeError):
    pass


@dataclass
class Meter:
    limit: int | None = None
    used: int = 0
    counts: Counter = field(default_factory=Counter)

    def use(self, amount: int, kind: str = "misc") -> None:
        if self.limit is not None and self.used + amount > self.limit:
            remaining = self.limit - self.used
            self.counts[kind] += remaining
            self.used = self.limit
            raise BudgetExhausted
        self.used += amount
        self.counts[kind] += amount


@dataclass(frozen=True)
class Problem:
    d: Mat
    Q: Mat
    P: Mat
    h0: Mat
    grades: tuple[int, ...]

    @property
    def n(self) -> int:
        return len(self.d)


def zero(n: int) -> Mat:
    return (0,) * n


def eye(n: int) -> Mat:
    return tuple(1 << i for i in range(n))


def add(A: Mat, B: Mat, m: Meter) -> Mat:
    m.use(2 * len(A), "xor")
    return tuple(a ^ b for a, b in zip(A, B))


def mul(A: Mat, B: Mat, m: Meter) -> Mat:
    out = []
    for row in A:
        m.use(2, "multiply")
        value = 0
        while row:
            m.use(6, "multiply")
            low = row & -row
            value ^= B[low.bit_length() - 1]
            row ^= low
        out.append(value)
    return tuple(out)


def nnz(A: Mat, m: Meter) -> int:
    m.use(2 * len(A), "score")
    return sum(row.bit_count() for row in A)


def equal(A: Mat, B: Mat, m: Meter) -> bool:
    m.use(len(A), "compare")
    return A == B


def differential(p: Problem, f: Mat, m: Meter) -> Mat:
    # Signs coincide in characteristic two, for every degree.
    return add(mul(p.d, f, m), mul(f, p.d, m), m)


def K(p: Problem, h: Mat, f: Mat, m: Meter, cross: bool = True) -> Mat:
    hf = mul(h, f, m)
    if not cross:
        return hf
    return add(hf, mul(mul(p.Q, f, m), h, m), m)


def valid(p: Problem, h: Mat, m: Meter) -> bool:
    z = zero(p.n)
    # Check all identities; do not short-circuit invalid candidates.
    checks = [equal(differential(p, h, m), p.P, m),
              equal(mul(h, h, m), z, m),
              equal(mul(p.Q, h, m), z, m),
              equal(mul(h, p.Q, m), z, m)]
    m.use(p.n * p.n, "degree_check")
    graded = all(not (row >> j & 1) or p.grades[i] == p.grades[j] - 1
                 for i, row in enumerate(h) for j in range(p.n))
    return all(checks) and graded


def normalize(p: Problem, g: Mat, m: Meter) -> Mat:
    return mul(mul(g, p.d, m), g, m)


def repaired_candidate(p: Problem, current: Mat, generator: Mat,
                       a: Mat, m: Meter, protect: bool = False) -> Mat:
    # z = P (a - K_generator(partial a)) P; minus = plus over GF(2).
    z = add(a, K(p, generator, differential(p, a, m), m), m)
    if protect:
        z = mul(mul(p.P, z, m), p.P, m)
    return normalize(p, add(current, z, m), m)


def boundary_candidate(p: Problem, current: Mat, B: Mat, m: Meter) -> Mat:
    # Strong simple reduction: any fixed-Q closed variation is partial B.
    z = differential(p, B, m)
    # gdg automatically removes Q mixing; explicit P sandwiches are redundant.
    return normalize(p, add(current, z, m), m)


def positions(p: Problem, degree: int, m: Meter) -> tuple[tuple[int, int], ...]:
    m.use(p.n * p.n, "setup")
    return tuple((i, j) for i in range(p.n) for j in range(p.n)
                 if p.grades[i] == p.grades[j] + degree)


def proposal(p: Problem, available: tuple[tuple[int, int], ...],
             rng: random.Random, m: Meter, width: int = 1) -> Mat:
    m.use(p.n + 7 * width, "proposal")
    rows = [0] * p.n
    for _ in range(width):
        i, j = available[rng.randrange(len(available))]
        rows[i] ^= 1 << j
    return tuple(rows)


def kernel_work(p: Problem, h: Mat, tasks: list[Mat],
                charge: Meter | None = None) -> int:
    """Execute, rather than estimate, the kernel on fresh repair problems."""
    local = Meter()
    for task in tasks:
        K(p, h, task, local)
    if charge is not None:
        charge.use(local.used, "kernel_evaluation")
    return local.used


def semantic_certificate(p: Problem, h: Mat, f: Mat, m: Meter,
                         cross: bool = True) -> bool:
    """Check partial K + K partial = f - Q f Q for an arbitrary End task."""
    lhs = add(differential(p, K(p, h, f, m, cross), m),
              K(p, h, differential(p, f, m), m, cross), m)
    rhs = add(f, mul(mul(p.Q, f, m), p.Q, m), m)
    return equal(lhs, rhs, m)