microgpt.sql

-- ============================================================================
-- microgpt.sql -- bit-exact F12 microgpt inference, implemented entirely in SQL
-- Copyright (c) 2026 Nenad Mićić
-- SPDX-License-Identifier: Apache-2.0
--
-- A single-file SQLite implementation of tokenizer/model loading, Q16.48
-- fixed-point arithmetic, transformer inference, autoregressive sampling, and
-- FNV-1a verification. No stored procedures, user-defined functions,
-- extensions, helper programs, or generated intermediate files are required.
--
-- Lineage: inspired by Andrej Karpathy's microgpt -> independent int-llm C
-- rebuild -> precision-ladder F12 spike -> this pure-SQL implementation.
--
-- Run from the repository root with:
--
--     sqlite3 :memory: < microgpt.sql
--
-- The sole external input is model/uniform-f12.mgw, captured once into the
-- in-memory database. All sample text, logits, hashes, and the final gate are
-- then computed from scratch. Output is pinned by expected_output.txt.
-- ============================================================================

-- Keep the sqlite3 shell deterministic and quiet: SQL SELECTs below are the
-- only commands intended to produce stdout.
.bail on
.echo off
.headers off
.mode list

-- ============================================================================
-- SECTION I: PROVEN Q16.48 INTEGER ARITHMETIC
-- The following block is copied byte-for-byte from sql/fp_parts.sql.
-- >>> BEGIN VERBATIM: sql/fp_parts.sql >>>
-- ================================================================
-- fp_parts.sql — Q16.48 fixed-point math in pure SQLite SQL
--
-- Ports fp_math.h (int-llm) bit-for-bit:
--   fp_mul       -> table `bus` (chained STORED generated columns)
--   fp_div(1,b)  -> view `div_view` over `divjob`   (restoring division)
--   fp_safe_exp  -> view `exp_view` over `expjob`   (dyadic squaring)
--   fp_inv_sqrt  -> view `isq_view` over `isqjob`   (Newton iterations)
--   xorshift64   -> view `rngstep` over `rngjob`
--   FNV-1a 64    -> view `fnv_view` over `fnvbytes`
--
-- SQLite has no 128-bit integers, no unsigned, no XOR operator, and
-- silently converts overflowing + / * to REAL.  Every operation below
-- therefore decomposes int64s into 32-bit limbs so no intermediate
-- ever exceeds 2^62, and rebuilds exact two's-complement results with
-- the wrapping operators << >> & |  (which never leave the integer
-- domain).  XOR(x,y) is (x|y)-(x&y), exact for all int64 pairs.
--
-- Two SQLite grammar rules shape the style throughout:
--   * << >> & | share ONE precedence level (left-associative), so
--     every composite shift/mask term is fully parenthesized;
--   * a recursive CTE may reference itself only directly in the arm's
--     FROM clause, so multi-step arithmetic inside recursion arms is
--     layered through scalar subqueries in the projection instead of
--     nested FROM subqueries.
-- ================================================================

-- ----------------------------------------------------------------
-- fp_mul as a table: INSERT (a, b), read `res` = (a*b) >> 48 with the
-- 128-bit signed product and arithmetic (floor) shift, exactly like
-- fp_w_asr(fp_w_muls(a, b), 48) in fp_math.h.
--
-- Method: P = |a|*|b| as (hi, lo) 64-bit halves via four 32x32
-- partials (the portable fp_w_umul64_), then
--   floor(P / 2^48)  =  hi*2^16 + (lo >> 48 logical)
-- and for a negative product,  asr48(-P) = -floor(P/2^48) - (P%2^48 != 0).
--
-- Contract (same as the C model's): |a*b| < 2^111 and the Q16.48
-- result fits int64 — guaranteed for all model arithmetic.
-- ----------------------------------------------------------------
CREATE TABLE bus(
  stage TEXT NOT NULL,               -- which computation this row belongs to
  g     INTEGER NOT NULL,            -- output slot (e.g. matvec row)
  s     INTEGER NOT NULL DEFAULT 0,  -- summation index (e.g. matvec column)
  a     INTEGER NOT NULL,
  b     INTEGER NOT NULL,
  neg   INTEGER AS ((a < 0) <> (b < 0)) STORED,
  ua    INTEGER AS (abs(a)) STORED,
  ub    INTEGER AS (abs(b)) STORED,
  a0    INTEGER AS (ua & 4294967295) STORED,   -- low/high 32-bit limbs
  a1    INTEGER AS (ua >> 32) STORED,
  b0    INTEGER AS (ub & 4294967295) STORED,
  b1    INTEGER AS (ub >> 32) STORED,
  -- p00 = (a0*b0) mod 2^64: a0*b0 can pass 2^63, so split b0 16/16 and
  -- add the two sub-products with 32-bit limb carries (wrapping add).
  m0    INTEGER AS ((a0 * (b0 >> 16)) << 16) STORED,
  m1    INTEGER AS (a0 * (b0 & 65535)) STORED,
  plo   INTEGER AS ((m0 & 4294967295) + (m1 & 4294967295)) STORED,
  p00   INTEGER AS ((plo & 4294967295) |
          (((((m0 >> 32) & 4294967295) + ((m1 >> 32) & 4294967295)
            + (plo >> 32)) & 4294967295) << 32)) STORED,
  -- mid = a0*b1 + (p00 >> 32)  — cannot carry (fits below 2^63)
  mid   INTEGER AS ((a0 * b1) + ((p00 >> 32) & 4294967295)) STORED,
  p10   INTEGER AS (a1 * b0) STORED,
  -- mid2 = (mid + p10) mod 2^64, carry recovered by unsigned compare
  m2lo  INTEGER AS ((mid & 4294967295) + (p10 & 4294967295)) STORED,
  mid2  INTEGER AS ((m2lo & 4294967295) |
          (((((mid >> 32) & 4294967295) + ((p10 >> 32) & 4294967295)
            + (m2lo >> 32)) & 4294967295) << 32)) STORED,
  lo    INTEGER AS ((mid2 << 32) | (p00 & 4294967295)) STORED,
  hi    INTEGER AS ((a1 * b1) + ((mid2 >> 32) & 4294967295)
          + (CASE WHEN mid2 >= 0 AND mid2 < mid THEN 4294967296 ELSE 0 END)) STORED,
  qm    INTEGER AS ((hi << 16) + ((lo >> 48) & 65535)) STORED,
  res   INTEGER AS (CASE WHEN neg = 0 THEN qm
                         WHEN (lo & 281474976710655) = 0 THEN -qm
                         ELSE -qm - 1 END) STORED
);
CREATE INDEX bus_ix ON bus(stage, g);

-- ----------------------------------------------------------------
-- fp_div(FP_ONE, b) for b > 0 — the only division inference performs
-- (softmax normalizers, exp reciprocals, temperature inverse).
--
-- C computes (2^96 / b) with a restoring-division bit loop over the
-- dividend's 97 significant bits, then truncates the quotient to its
-- low 64 bits.  Same here: 97 recursive-CTE steps; quotient bits at
-- positions >= 64 are dropped (so b=1 yields 0, exactly like C).
-- The remainder update is a wrapping 64-bit add of -b in 32-bit limbs;
-- "unsigned r >= b" is (r < 0 OR r >= b) since 0 < b < 2^63.
-- ----------------------------------------------------------------
CREATE TABLE divjob(gid INTEGER PRIMARY KEY, b INTEGER NOT NULL);

CREATE VIEW div_view AS
WITH RECURSIVE dv(gid, b, nb, i, r, q) AS (
  SELECT gid, b, 0 - b, 97, 0, 0 FROM divjob
  UNION ALL
  SELECT gid, b, nb, i - 1,
         (SELECT CASE WHEN rr < 0 OR rr >= b THEN
                   (((rr & 4294967295) + (nb & 4294967295)) & 4294967295) |
                   (((((rr >> 32) & 4294967295) + ((nb >> 32) & 4294967295)
                      + (((rr & 4294967295) + (nb & 4294967295)) >> 32)) & 4294967295) << 32)
                 ELSE rr END
          FROM (SELECT ((r << 1) | (CASE WHEN i = 97 THEN 1 ELSE 0 END)) AS rr)),
         (SELECT CASE WHEN (rr < 0 OR rr >= b) AND i - 1 < 64
                      THEN q | (1 << (i - 1)) ELSE q END
          FROM (SELECT ((r << 1) | (CASE WHEN i = 97 THEN 1 ELSE 0 END)) AS rr))
  FROM dv WHERE i > 0
)
SELECT gid, q FROM dv WHERE i = 0;

-- ----------------------------------------------------------------
-- fp_safe_exp(x): clamp to +10.0, return 0 below -10.0, else
-- exp via the dyadic limit (1 + x/2^14)^(2^14): one shifted add and
-- 14 squarings through fp_mul; negative x gets 1/exp(-x) through the
-- same restoring division as div_view.
--
-- The squaring chain operates on r >= 0 only, so its inline fp_mul
-- drops the sign handling but keeps the identical limb arithmetic
-- (a square's cross partials coincide: p01 = p10 = a0*a1).
-- ----------------------------------------------------------------
CREATE TABLE expjob(gid INTEGER PRIMARY KEY, x INTEGER NOT NULL);

CREATE VIEW exp_view AS
WITH RECURSIVE
cl AS (SELECT gid, CASE WHEN x > 2814749767106560 THEN 2814749767106560
                        ELSE x END AS xc
       FROM expjob),
dy(gid, xc, i, r) AS (
  SELECT gid, xc, 0, 281474976710656 + (abs(xc) >> 14)
  FROM cl WHERE xc >= -2814749767106560
  UNION ALL
  SELECT gid, xc, i + 1,
         (SELECT (shi << 16) + ((slo >> 48) & 65535)
          FROM (SELECT (a1 * a1) + ((mid2 >> 32) & 4294967295)
                        + (CASE WHEN mid2 >= 0 AND mid2 < mid THEN 4294967296 ELSE 0 END) AS shi,
                       ((mid2 << 32) | (p00 & 4294967295)) AS slo
                FROM (SELECT a1, p00, mid,
                             (((mid & 4294967295) + (px & 4294967295)) & 4294967295) |
                             (((((mid >> 32) & 4294967295) + ((px >> 32) & 4294967295)
                                + (((mid & 4294967295) + (px & 4294967295)) >> 32))
                               & 4294967295) << 32) AS mid2
                      FROM (SELECT a1, px, p00,
                                   (px + ((p00 >> 32) & 4294967295)) AS mid
                            FROM (SELECT a1, px,
                                         (((m0 & 4294967295) + (m1 & 4294967295)) & 4294967295) |
                                         (((((m0 >> 32) & 4294967295) + ((m1 >> 32) & 4294967295)
                                            + (((m0 & 4294967295) + (m1 & 4294967295)) >> 32))
                                           & 4294967295) << 32) AS p00
                                  FROM (SELECT a1, (a0 * a1) AS px,
                                               ((a0 * (a0 >> 16)) << 16) AS m0,
                                               (a0 * (a0 & 65535)) AS m1
                                        FROM (SELECT (r & 4294967295) AS a0,
                                                     (r >> 32) AS a1)))))))
  FROM dy WHERE i < 14
),
ps AS (SELECT gid, xc, r FROM dy WHERE i = 14),
rj(gid, b, nb, i, r, q) AS (
  SELECT gid, r, 0 - r, 97, 0, 0 FROM ps WHERE xc < 0 AND r <> 0
  UNION ALL
  SELECT gid, b, nb, i - 1,
         (SELECT CASE WHEN rr < 0 OR rr >= b THEN
                   (((rr & 4294967295) + (nb & 4294967295)) & 4294967295) |
                   (((((rr >> 32) & 4294967295) + ((nb >> 32) & 4294967295)
                      + (((rr & 4294967295) + (nb & 4294967295)) >> 32)) & 4294967295) << 32)
                 ELSE rr END
          FROM (SELECT ((r << 1) | (CASE WHEN i = 97 THEN 1 ELSE 0 END)) AS rr)),
         (SELECT CASE WHEN (rr < 0 OR rr >= b) AND i - 1 < 64
                      THEN q | (1 << (i - 1)) ELSE q END
          FROM (SELECT ((r << 1) | (CASE WHEN i = 97 THEN 1 ELSE 0 END)) AS rr))
  FROM rj WHERE i > 0
),
rq AS (SELECT gid, q FROM rj WHERE i = 0)
SELECT e.gid,
       CASE WHEN c.xc < -2814749767106560 THEN 0
            WHEN c.xc >= 0 THEN p.r
            WHEN p.r = 0 THEN 0
            ELSE (SELECT q FROM rq WHERE rq.gid = e.gid) END AS e
FROM expjob e
JOIN cl c ON c.gid = e.gid
LEFT JOIN ps p ON p.gid = e.gid;

-- ----------------------------------------------------------------
-- fp_inv_sqrt(x): 1/sqrt(x) via Newton y' = y*(3 - x*y^2)/2.
--
-- Exactly fp_math.h: normalize x = xn * 2^(2k) with xn in [2^48, 2^50)
-- (msb by table scan = CLZ), start y0 at 1.0 or 0.5 by sub-octave,
-- run 8 iterations with C's y<=0 -> y=1 early exit carried as `dead`,
-- then scale by 2^-k, saturating to INT64_MAX exactly like the C
-- 128-bit shift does.  x <= 0 returns 0.
--
-- One fp_mul per recursion, three recursions per Newton iteration:
--   phase 0: t = (y * y) >> 48
--   phase 1: t = 3.0 - ((xn * t) >> 48)          (the Newton factor)
--   phase 2: y = (y * t) >> 49, then the early-exit guard
-- The multiply is the same 32-bit-limb 128-bit product as `bus` with
-- the shift (48/49) phase-selected; ma > 0 always (y > 0 invariant,
-- xn >= 2^48), mb is signed in phase 2.  y', dead', t' each embed one
-- copy of the product chain as a layered scalar subquery.
-- ----------------------------------------------------------------
CREATE TABLE isqjob(gid INTEGER PRIMARY KEY, x INTEGER NOT NULL);

CREATE VIEW isq_view AS
WITH RECURSIVE
bt(k) AS (SELECT 0 UNION ALL SELECT k + 1 FROM bt WHERE k < 62),
prep AS (SELECT gid, x,
                (SELECT max(k) FROM bt WHERE x >= (1 << k)) AS msb
         FROM isqjob WHERE x > 0),
prep2 AS (SELECT gid, x, msb, ((msb - 48) >> 1) AS k FROM prep),
prep3 AS (SELECT gid, k,
                 CASE WHEN k >= 0 THEN x >> (2 * k) ELSE x << (-2 * k) END AS xn,
                 CASE WHEN ((msb - 48) & 1) = 0 THEN 281474976710656
                      ELSE 140737488355328 END AS y0
          FROM prep2),
nt(gid, it, phase, xn, y, dead, t) AS (
  SELECT gid, 0, 0, xn, y0, 0, 0 FROM prep3
  UNION ALL
  SELECT gid,
         it + (CASE WHEN phase = 2 THEN 1 ELSE 0 END),
         (phase + 1) % 3,
         xn,
         CASE WHEN phase < 2 OR dead THEN y ELSE
           (SELECT CASE WHEN res <= 0 THEN 1 ELSE res END
            FROM (SELECT CASE WHEN neg = 0 THEN
                           (hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))
                         WHEN (lo & ((1 << sh) - 1)) = 0 THEN
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1)))
                         ELSE
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))) - 1
                         END AS res
                  FROM (SELECT neg, sh,
                               ((mid2 << 32) | (p00 & 4294967295)) AS lo,
                               p11 + ((mid2 >> 32) & 4294967295)
                                 + (CASE WHEN mid2 >= 0 AND mid2 < mid THEN 4294967296 ELSE 0 END) AS hi
                        FROM (SELECT neg, sh, p00, p11, mid,
                                     (((mid & 4294967295) + (px10 & 4294967295)) & 4294967295) |
                                     (((((mid >> 32) & 4294967295) + ((px10 >> 32) & 4294967295)
                                        + (((mid & 4294967295) + (px10 & 4294967295)) >> 32))
                                       & 4294967295) << 32) AS mid2
                              FROM (SELECT neg, sh, p00, px10, p11,
                                           (px01 + ((p00 >> 32) & 4294967295)) AS mid
                                    FROM (SELECT neg, sh, px01, px10, p11,
                                                 (((m0 & 4294967295) + (m1 & 4294967295)) & 4294967295) |
                                                 (((((m0 >> 32) & 4294967295) + ((m1 >> 32) & 4294967295)
                                                    + (((m0 & 4294967295) + (m1 & 4294967295)) >> 32))
                                                   & 4294967295) << 32) AS p00
                                          FROM (SELECT neg, sh,
                                                       ((a0 * (b0 >> 16)) << 16) AS m0,
                                                       (a0 * (b0 & 65535)) AS m1,
                                                       (a0 * b1) AS px01,
                                                       (a1 * b0) AS px10,
                                                       (a1 * b1) AS p11
                                                FROM (SELECT ((ma < 0) <> (mb < 0)) AS neg,
                                                             (abs(ma) & 4294967295) AS a0,
                                                             (abs(ma) >> 32) AS a1,
                                                             (abs(mb) & 4294967295) AS b0,
                                                             (abs(mb) >> 32) AS b1,
                                                             CASE WHEN phase = 2 THEN 49 ELSE 48 END AS sh
                                                      FROM (SELECT CASE WHEN phase = 1 THEN xn ELSE y END AS ma,
                                                                   CASE WHEN phase = 0 THEN y ELSE t END AS mb)))))))))
         END,
         CASE WHEN dead THEN 1 WHEN phase <> 2 THEN 0 ELSE
           (SELECT CASE WHEN res <= 0 THEN 1 ELSE 0 END
            FROM (SELECT CASE WHEN neg = 0 THEN
                           (hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))
                         WHEN (lo & ((1 << sh) - 1)) = 0 THEN
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1)))
                         ELSE
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))) - 1
                         END AS res
                  FROM (SELECT neg, sh,
                               ((mid2 << 32) | (p00 & 4294967295)) AS lo,
                               p11 + ((mid2 >> 32) & 4294967295)
                                 + (CASE WHEN mid2 >= 0 AND mid2 < mid THEN 4294967296 ELSE 0 END) AS hi
                        FROM (SELECT neg, sh, p00, p11, mid,
                                     (((mid & 4294967295) + (px10 & 4294967295)) & 4294967295) |
                                     (((((mid >> 32) & 4294967295) + ((px10 >> 32) & 4294967295)
                                        + (((mid & 4294967295) + (px10 & 4294967295)) >> 32))
                                       & 4294967295) << 32) AS mid2
                              FROM (SELECT neg, sh, p00, px10, p11,
                                           (px01 + ((p00 >> 32) & 4294967295)) AS mid
                                    FROM (SELECT neg, sh, px01, px10, p11,
                                                 (((m0 & 4294967295) + (m1 & 4294967295)) & 4294967295) |
                                                 (((((m0 >> 32) & 4294967295) + ((m1 >> 32) & 4294967295)
                                                    + (((m0 & 4294967295) + (m1 & 4294967295)) >> 32))
                                                   & 4294967295) << 32) AS p00
                                          FROM (SELECT neg, sh,
                                                       ((a0 * (b0 >> 16)) << 16) AS m0,
                                                       (a0 * (b0 & 65535)) AS m1,
                                                       (a0 * b1) AS px01,
                                                       (a1 * b0) AS px10,
                                                       (a1 * b1) AS p11
                                                FROM (SELECT ((ma < 0) <> (mb < 0)) AS neg,
                                                             (abs(ma) & 4294967295) AS a0,
                                                             (abs(ma) >> 32) AS a1,
                                                             (abs(mb) & 4294967295) AS b0,
                                                             (abs(mb) >> 32) AS b1,
                                                             CASE WHEN phase = 2 THEN 49 ELSE 48 END AS sh
                                                      FROM (SELECT CASE WHEN phase = 1 THEN xn ELSE y END AS ma,
                                                                   CASE WHEN phase = 0 THEN y ELSE t END AS mb)))))))))
         END,
         CASE WHEN dead THEN 0 WHEN phase = 2 THEN 0 ELSE
           (SELECT CASE WHEN phase = 0 THEN res ELSE 844424930131968 - res END
            FROM (SELECT CASE WHEN neg = 0 THEN
                           (hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))
                         WHEN (lo & ((1 << sh) - 1)) = 0 THEN
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1)))
                         ELSE
                           -((hi << (64 - sh)) + ((lo >> sh) & ((1 << (64 - sh)) - 1))) - 1
                         END AS res
                  FROM (SELECT neg, sh,
                               ((mid2 << 32) | (p00 & 4294967295)) AS lo,
                               p11 + ((mid2 >> 32) & 4294967295)
                                 + (CASE WHEN mid2 >= 0 AND mid2 < mid THEN 4294967296 ELSE 0 END) AS hi
                        FROM (SELECT neg, sh, p00, p11, mid,
                                     (((mid & 4294967295) + (px10 & 4294967295)) & 4294967295) |
                                     (((((mid >> 32) & 4294967295) + ((px10 >> 32) & 4294967295)
                                        + (((mid & 4294967295) + (px10 & 4294967295)) >> 32))
                                       & 4294967295) << 32) AS mid2
                              FROM (SELECT neg, sh, p00, px10, p11,
                                           (px01 + ((p00 >> 32) & 4294967295)) AS mid
                                    FROM (SELECT neg, sh, px01, px10, p11,
                                                 (((m0 & 4294967295) + (m1 & 4294967295)) & 4294967295) |
                                                 (((((m0 >> 32) & 4294967295) + ((m1 >> 32) & 4294967295)
                                                    + (((m0 & 4294967295) + (m1 & 4294967295)) >> 32))
                                                   & 4294967295) << 32) AS p00
                                          FROM (SELECT neg, sh,
                                                       ((a0 * (b0 >> 16)) << 16) AS m0,
                                                       (a0 * (b0 & 65535)) AS m1,
                                                       (a0 * b1) AS px01,
                                                       (a1 * b0) AS px10,
                                                       (a1 * b1) AS p11
                                                FROM (SELECT ((ma < 0) <> (mb < 0)) AS neg,
                                                             (abs(ma) & 4294967295) AS a0,
                                                             (abs(ma) >> 32) AS a1,
                                                             (abs(mb) & 4294967295) AS b0,
                                                             (abs(mb) >> 32) AS b1,
                                                             CASE WHEN phase = 2 THEN 49 ELSE 48 END AS sh
                                                      FROM (SELECT CASE WHEN phase = 1 THEN xn ELSE y END AS ma,
                                                                   CASE WHEN phase = 0 THEN y ELSE t END AS mb)))))))))
         END
  FROM nt WHERE it < 8
),
fin AS (SELECT gid, y FROM nt WHERE it = 8)
SELECT j.gid,
       CASE WHEN j.x <= 0 THEN 0
            WHEN p2.k >= 0 THEN
              (CASE WHEN (f.y >> p2.k) < 0 THEN 0 ELSE f.y >> p2.k END)
            WHEN f.y > (9223372036854775807 >> (0 - p2.k)) THEN 9223372036854775807
            ELSE f.y << (0 - p2.k) END AS r
FROM isqjob j
LEFT JOIN prep2 p2 ON p2.gid = j.gid
LEFT JOIN fin f ON f.gid = j.gid;

-- ----------------------------------------------------------------
-- xorshift64 PRNG — fp_rng_next():
--   s ^= s << 13;  s ^= s >> 7 (logical);  s ^= s << 17
-- State lives in `rng` (one row, two's-complement int64 bit pattern).
-- Each step below is XOR(s, t) spelled (s|t)-(s&t); the logical right
-- shift masks the sign-extension bits off the arithmetic >>.
-- Uniform draw = state >> 16 logical (top 48 bits).
-- ----------------------------------------------------------------
CREATE TABLE rng(id INTEGER PRIMARY KEY CHECK (id = 1), s INTEGER NOT NULL);

-- One xorshift64 step as a view: put the current state in rngjob, read
-- the advanced state (nx) and the uniform draw (u = nx >> 16 logical).
CREATE TABLE rngjob(gid INTEGER PRIMARY KEY, s INTEGER NOT NULL);

CREATE VIEW rngstep AS
SELECT gid, s3 AS nx, (s3 >> 16) & 281474976710655 AS u
FROM (SELECT gid, ((s2 | t3) - (s2 & t3)) AS s3
      FROM (SELECT gid, s2, (s2 << 17) AS t3
            FROM (SELECT gid, ((s1 | t2) - (s1 & t2)) AS s2
                  FROM (SELECT gid, s1, ((s1 >> 7) & 144115188075855871) AS t2
                        FROM (SELECT gid, ((s | t1) - (s & t1)) AS s1
                              FROM (SELECT gid, s, (s << 13) AS t1
                                    FROM rngjob))))));

-- ----------------------------------------------------------------
-- FNV-1a 64 over a byte sequence: h = 14695981039346656037 (as int64:
-- -3750763034362895579); per byte: h = (h XOR byte) * 1099511628211
-- mod 2^64.  The prime is 2^40 + 435, so the wrapping product is
-- (h << 40) + h*435, with h*435 built from 32-bit limbs.
-- Load bytes into fnvbytes with contiguous seq starting at 1.
-- ----------------------------------------------------------------
CREATE TABLE fnvbytes(seq INTEGER PRIMARY KEY, b INTEGER NOT NULL) WITHOUT ROWID;

CREATE VIEW fnv_view AS
WITH RECURSIVE f(n, h) AS (
  SELECT 0, -3750763034362895579
  UNION ALL
  SELECT fb.seq,
         -- h' = wadd(x<<40, wadd(xl*435, (xh*435)<<32)) in 32-bit limbs
         (SELECT (((x40 & 4294967295) + (w2 & 4294967295)) & 4294967295) |
                 (((((x40 >> 32) & 4294967295) + ((w2 >> 32) & 4294967295)
                    + (((x40 & 4294967295) + (w2 & 4294967295)) >> 32)) & 4294967295) << 32)
          FROM (SELECT x40,
                       (((t1 & 4294967295) + (t2 & 4294967295)) & 4294967295) |
                       (((((t1 >> 32) & 4294967295) + ((t2 >> 32) & 4294967295)
                          + (((t1 & 4294967295) + (t2 & 4294967295)) >> 32)) & 4294967295) << 32) AS w2
                FROM (SELECT (x << 40) AS x40,
                             ((x & 4294967295) * 435) AS t1,
                             ((((x >> 32) & 4294967295) * 435) << 32) AS t2
                      FROM (SELECT ((f.h | fb.b) - (f.h & fb.b)) AS x))))
  FROM f JOIN fnvbytes fb ON fb.seq = f.n + 1
)
SELECT n, h FROM f;
-- <<< END VERBATIM: sql/fp_parts.sql <<<
-- ============================================================================

-- ============================================================================
-- SECTION II: STRICT MGW MODEL LOADER
-- The following block is copied byte-for-byte from sql/model_loader.sql.
-- >>> BEGIN VERBATIM: sql/model_loader.sql >>>
-- ================================================================
-- model_loader.sql -- strict loader for model/uniform-f12.mgw
--
-- This fragment assumes sql/fp_parts.sql has already created `rng`.
-- It loads and validates the fixed F12 microgpt model, then exposes:
--   wt(name,r,c,v)       the nine row-major weight matrices
--   uchars(i,ch)         tokenizer bytes for tokens 0..25
--   rng(id,s)            the loaded xorshift64 state (id = 1)
--   model_config         the validated architecture and BOS token
--   load_validation      one durable row per validation check
--   load_status          one durable summary row
--
-- Run from the repository root.  The model file is read once; all
-- subsequent decoding is from the in-memory image.
-- ================================================================

-- ----------------------------------------------------------------
-- 1. Capture the model in memory and expand its bytes.  Keeping a byte
-- table makes every later little-endian decode explicit and integer-only.
-- ----------------------------------------------------------------
CREATE TABLE _mgw_source(
  id    INTEGER PRIMARY KEY CHECK (id = 1),
  image BLOB
);
INSERT INTO _mgw_source(id, image)
VALUES (1, readfile('model/uniform-f12.mgw'));

CREATE TABLE _mgw_image(
  id         INTEGER PRIMARY KEY CHECK (id = 1),
  image      BLOB,
  file_bytes INTEGER NOT NULL
);
INSERT INTO _mgw_image
SELECT 1, image, coalesce(length(image), -1)
FROM _mgw_source WHERE id = 1;

CREATE TABLE _mgw_byte(
  off INTEGER PRIMARY KEY,
  v   INTEGER NOT NULL CHECK (v BETWEEN 0 AND 255)
) WITHOUT ROWID;
INSERT INTO _mgw_byte(off, v)
WITH RECURSIVE offsets(off) AS (
  SELECT 0 FROM _mgw_image WHERE file_bytes > 0
  UNION ALL
  SELECT off + 1 FROM offsets
  WHERE off + 1 < (SELECT file_bytes FROM _mgw_image WHERE id = 1)
)
SELECT off,
       16 * (instr('0123456789ABCDEF',
                   substr(hex(substr(image, off + 1, 1)), 1, 1)) - 1)
       + (instr('0123456789ABCDEF',
                substr(hex(substr(image, off + 1, 1)), 2, 1)) - 1)
FROM offsets CROSS JOIN _mgw_image;

-- ----------------------------------------------------------------
-- 2. Expected index contract for this exact inference architecture.
-- Data offsets are absolute and contiguous; every payload word is int64 LE.
-- ----------------------------------------------------------------
CREATE TABLE _mgw_expected(
  t            INTEGER PRIMARY KEY,
  name         TEXT NOT NULL UNIQUE,
  num_elements INTEGER NOT NULL,
  data_offset  INTEGER NOT NULL,
  ndims        INTEGER NOT NULL,
  rows_n       INTEGER NOT NULL,
  cols_n       INTEGER NOT NULL
);
INSERT INTO _mgw_expected VALUES
  ( 0, 'wte',                     864,   1184, 2,  27,  32),
  ( 1, 'wpe',                     256,   8096, 2,   8,  32),
  ( 2, 'lm_head',                 864,  10144, 2,  27,  32),
  ( 3, 'layers.0.attn_wq',       1024,  17056, 2,  32,  32),
  ( 4, 'layers.0.attn_wk',       1024,  25248, 2,  32,  32),
  ( 5, 'layers.0.attn_wv',       1024,  33440, 2,  32,  32),
  ( 6, 'layers.0.attn_wo',       1024,  41632, 2,  32,  32),
  ( 7, 'layers.0.mlp_fc1',       4096,  49824, 2, 128,  32),
  ( 8, 'layers.0.mlp_fc2',       4096,  82592, 2,  32, 128),
  ( 9, 'tokenizer.uchars',         26, 115360, 1,  26,   0),
  (10, 'rng.state',                 1, 115568, 1,   1,   0);

-- Decode only the u32 and int64 words used by the header/config/index.
CREATE TABLE _mgw_u32(
  off INTEGER PRIMARY KEY,
  v   INTEGER NOT NULL
) WITHOUT ROWID;
INSERT INTO _mgw_u32(off, v)
WITH
delta(d) AS (VALUES (80), (84), (88), (92)),
wanted(off) AS (
  VALUES (4), (8), (12),
         (64), (68), (72), (76), (80), (84), (88), (92)
  UNION ALL
  SELECT 128 + 96 * t + d FROM _mgw_expected CROSS JOIN delta
)
SELECT w.off,
       b0.v + (b1.v << 8) + (b2.v << 16) + (b3.v << 24)
FROM wanted w
JOIN _mgw_byte b0 ON b0.off = w.off
JOIN _mgw_byte b1 ON b1.off = w.off + 1
JOIN _mgw_byte b2 ON b2.off = w.off + 2
JOIN _mgw_byte b3 ON b3.off = w.off + 3;

CREATE TABLE _mgw_i64_meta(
  off INTEGER PRIMARY KEY,
  v   INTEGER NOT NULL
) WITHOUT ROWID;
INSERT INTO _mgw_i64_meta(off, v)
WITH
delta(d) AS (VALUES (64), (72)),
wanted(off) AS (
  VALUES (16), (24)
  UNION ALL
  SELECT 128 + 96 * t + d FROM _mgw_expected CROSS JOIN delta
)
SELECT w.off,
       (b0.v + (b1.v << 8) + (b2.v << 16) + (b3.v << 24)
        + (b4.v << 32) + (b5.v << 40) + (b6.v << 48)
        + ((b7.v & 127) << 56))
       | (CASE WHEN b7.v >= 128 THEN (1 << 63) ELSE 0 END)
FROM wanted w
JOIN _mgw_byte b0 ON b0.off = w.off
JOIN _mgw_byte b1 ON b1.off = w.off + 1
JOIN _mgw_byte b2 ON b2.off = w.off + 2
JOIN _mgw_byte b3 ON b3.off = w.off + 3
JOIN _mgw_byte b4 ON b4.off = w.off + 4
JOIN _mgw_byte b5 ON b5.off = w.off + 5
JOIN _mgw_byte b6 ON b6.off = w.off + 6
JOIN _mgw_byte b7 ON b7.off = w.off + 7;

CREATE TABLE _mgw_header(
  file_bytes   INTEGER,
  magic_hex    TEXT,
  version      INTEGER,
  endian_tag   INTEGER,
  num_tensors  INTEGER,
  index_offset INTEGER,
  data_offset  INTEGER
);
INSERT INTO _mgw_header
SELECT file_bytes, hex(substr(image, 1, 4)),
       (SELECT v FROM _mgw_u32 WHERE off = 4),
       (SELECT v FROM _mgw_u32 WHERE off = 8),
       (SELECT v FROM _mgw_u32 WHERE off = 12),
       (SELECT v FROM _mgw_i64_meta WHERE off = 16),
       (SELECT v FROM _mgw_i64_meta WHERE off = 24)
FROM _mgw_image WHERE id = 1;

CREATE TABLE _mgw_config(
  hidden_dim       INTEGER,
  num_heads        INTEGER,
  num_kv_heads     INTEGER,
  head_dim         INTEGER,
  num_layers       INTEGER,
  intermediate_dim INTEGER,
  vocab_size       INTEGER,
  max_seq_len      INTEGER
);
INSERT INTO _mgw_config
SELECT (SELECT v FROM _mgw_u32 WHERE off = 64),
       (SELECT v FROM _mgw_u32 WHERE off = 68),
       (SELECT v FROM _mgw_u32 WHERE off = 72),
       (SELECT v FROM _mgw_u32 WHERE off = 76),
       (SELECT v FROM _mgw_u32 WHERE off = 80),
       (SELECT v FROM _mgw_u32 WHERE off = 84),
       (SELECT v FROM _mgw_u32 WHERE off = 88),
       (SELECT v FROM _mgw_u32 WHERE off = 92);

-- Reconstruct each NUL-terminated ASCII index name in index order.
CREATE TABLE _mgw_name(
  t            INTEGER PRIMARY KEY,
  name         TEXT,
  first_nul    INTEGER,
  padding_zero INTEGER NOT NULL
);
INSERT INTO _mgw_name(t, name, first_nul, padding_zero)
WITH
name_bytes AS (
  SELECT e.t, b.off - (128 + 96 * e.t) AS j, b.v
  FROM _mgw_expected e
  LEFT JOIN _mgw_byte b
    ON b.off BETWEEN 128 + 96 * e.t AND 128 + 96 * e.t + 63
),
tagged AS (
  SELECT t, j, v,
         min(CASE WHEN v = 0 THEN j END) OVER (PARTITION BY t) AS z
  FROM name_bytes
)
SELECT t,
       group_concat(char(v), '' ORDER BY j)
         FILTER (WHERE z IS NOT NULL AND j < z),
       min(z),
       CASE WHEN min(z) IS NOT NULL
                  AND sum(CASE WHEN j >= z AND v <> 0 THEN 1 ELSE 0 END) = 0
            THEN 1 ELSE 0 END
FROM tagged
GROUP BY t;

CREATE TABLE _mgw_index(
  t            INTEGER PRIMARY KEY,
  name         TEXT,
  first_nul    INTEGER,
  padding_zero INTEGER,
  num_elements INTEGER,
  data_offset  INTEGER,
  ndims        INTEGER,
  rows_n       INTEGER,
  cols_n       INTEGER,
  reserved     INTEGER
);
INSERT INTO _mgw_index
SELECT e.t, n.name, n.first_nul, n.padding_zero,
       ne.v, doff.v, nd.v, r.v, c.v, z.v
FROM _mgw_expected e
LEFT JOIN _mgw_name n ON n.t = e.t
LEFT JOIN _mgw_i64_meta ne
  ON ne.off = 128 + 96 * e.t + 64
LEFT JOIN _mgw_i64_meta doff
  ON doff.off = 128 + 96 * e.t + 72
LEFT JOIN _mgw_u32 nd
  ON nd.off = 128 + 96 * e.t + 80
LEFT JOIN _mgw_u32 r
  ON r.off = 128 + 96 * e.t + 84
LEFT JOIN _mgw_u32 c
  ON c.off = 128 + 96 * e.t + 88
LEFT JOIN _mgw_u32 z
  ON z.off = 128 + 96 * e.t + 92;

-- ----------------------------------------------------------------
-- 3. Durable structural validation.  Payload decoding is gated on every
-- row below passing, so malformed metadata cannot route arbitrary bytes.
-- ----------------------------------------------------------------
CREATE TABLE load_validation(
  check_name TEXT PRIMARY KEY,
  ok         INTEGER NOT NULL CHECK (ok IN (0, 1)),
  detail     TEXT NOT NULL
) WITHOUT ROWID;

INSERT INTO load_validation VALUES
  ('source.present',
   coalesce((SELECT file_bytes >= 0 FROM _mgw_header), 0),
   'file_bytes=' || coalesce((SELECT file_bytes FROM _mgw_header), 'NULL')),
  ('header.magic',
   coalesce((SELECT magic_hex = '4D475700' FROM _mgw_header), 0),
   'expected=4D475700 got=' || coalesce((SELECT magic_hex FROM _mgw_header), 'NULL')),
  ('header.version',
   coalesce((SELECT version = 1 FROM _mgw_header), 0),
   'expected=1 got=' || coalesce((SELECT version FROM _mgw_header), 'NULL')),
  ('header.endian_tag',
   coalesce((SELECT endian_tag = 16909060 FROM _mgw_header), 0),
   'expected=16909060 got=' || coalesce((SELECT endian_tag FROM _mgw_header), 'NULL')),
  ('header.num_tensors',
   coalesce((SELECT num_tensors = 11 FROM _mgw_header), 0),
   'expected=11 got=' || coalesce((SELECT num_tensors FROM _mgw_header), 'NULL')),
  ('header.index_offset',
   coalesce((SELECT index_offset = 128 FROM _mgw_header), 0),
   'expected=128 got=' || coalesce((SELECT index_offset FROM _mgw_header), 'NULL')),
  ('header.data_offset',
   coalesce((SELECT data_offset = 1184 FROM _mgw_header), 0),
   'expected=1184 got=' || coalesce((SELECT data_offset FROM _mgw_header), 'NULL')),
  ('config.hidden_dim',
   coalesce((SELECT hidden_dim = 32 FROM _mgw_config), 0),
   'expected=32 got=' || coalesce((SELECT hidden_dim FROM _mgw_config), 'NULL')),
  ('config.num_heads',
   coalesce((SELECT num_heads = 4 FROM _mgw_config), 0),
   'expected=4 got=' || coalesce((SELECT num_heads FROM _mgw_config), 'NULL')),
  ('config.num_kv_heads',
   coalesce((SELECT num_kv_heads = 4 FROM _mgw_config), 0),
   'expected=4 got=' || coalesce((SELECT num_kv_heads FROM _mgw_config), 'NULL')),
  ('config.head_dim',
   coalesce((SELECT head_dim = 8 FROM _mgw_config), 0),
   'expected=8 got=' || coalesce((SELECT head_dim FROM _mgw_config), 'NULL')),
  ('config.num_layers',
   coalesce((SELECT num_layers = 1 FROM _mgw_config), 0),
   'expected=1 got=' || coalesce((SELECT num_layers FROM _mgw_config), 'NULL')),
  ('config.intermediate_dim',
   coalesce((SELECT intermediate_dim = 128 FROM _mgw_config), 0),
   'expected=128 got=' || coalesce((SELECT intermediate_dim FROM _mgw_config), 'NULL')),
  ('config.vocab_size',
   coalesce((SELECT vocab_size = 27 FROM _mgw_config), 0),
   'expected=27 got=' || coalesce((SELECT vocab_size FROM _mgw_config), 'NULL')),
  ('config.max_seq_len',
   coalesce((SELECT max_seq_len = 8 FROM _mgw_config), 0),
   'expected=8 got=' || coalesce((SELECT max_seq_len FROM _mgw_config), 'NULL')),
  ('index.names',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN i.name = e.name THEN 1 ELSE 0 END) = 11
             FROM _mgw_index i JOIN _mgw_expected e USING (t)), 0),
   'expected=11 exact ordered names'),
  ('index.name_encoding',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN first_nul BETWEEN 1 AND 63
                                      AND padding_zero = 1
                                 THEN 1 ELSE 0 END) = 11
             FROM _mgw_index), 0),
   'expected=NUL-terminated ASCII names with zero padding'),
  ('index.num_elements',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN i.num_elements = e.num_elements
                                 THEN 1 ELSE 0 END) = 11
             FROM _mgw_index i JOIN _mgw_expected e USING (t)), 0),
   'expected=all 11 tensor element counts'),
  ('index.data_offsets',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN i.data_offset = e.data_offset
                                 THEN 1 ELSE 0 END) = 11
             FROM _mgw_index i JOIN _mgw_expected e USING (t)), 0),
   'expected=contiguous absolute payload offsets'),
  ('index.dimensions',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN i.ndims = e.ndims
                                      AND i.rows_n = e.rows_n
                                      AND i.cols_n = e.cols_n
                                 THEN 1 ELSE 0 END) = 11
             FROM _mgw_index i JOIN _mgw_expected e USING (t)), 0),
   'expected=all ndims and shape[2] values'),
  ('index.reserved',
   coalesce((SELECT count(*) = 11
                    AND sum(CASE WHEN reserved = 0 THEN 1 ELSE 0 END) = 11
             FROM _mgw_index), 0),
   'expected=all 11 reserved fields zero'),
  ('layout.file_size',
   coalesce((SELECT file_bytes = 115576 FROM _mgw_header), 0),
   'expected=115576 got=' || coalesce((SELECT file_bytes FROM _mgw_header), 'NULL'));

-- ----------------------------------------------------------------
-- 4. Decode all 14,299 payload words only after structural validation.
-- The low 63 bits are composed without overflow; OR sets bit 63 exactly.
-- ----------------------------------------------------------------
CREATE TABLE _mgw_value(
  t    INTEGER NOT NULL,
  flat INTEGER NOT NULL,
  v    INTEGER NOT NULL,
  PRIMARY KEY (t, flat)
) WITHOUT ROWID;
INSERT INTO _mgw_value(t, flat, v)
WITH RECURSIVE nums(n) AS (
  VALUES (0)
  UNION ALL
  SELECT n + 1 FROM nums WHERE n < 4095
)
SELECT i.t, nums.n,
       (b0.v + (b1.v << 8) + (b2.v << 16) + (b3.v << 24)
        + (b4.v << 32) + (b5.v << 40) + (b6.v << 48)
        + ((b7.v & 127) << 56))
       | (CASE WHEN b7.v >= 128 THEN (1 << 63) ELSE 0 END)
FROM _mgw_index i
JOIN nums ON nums.n < i.num_elements
JOIN _mgw_byte b0 ON b0.off = i.data_offset + nums.n * 8
JOIN _mgw_byte b1 ON b1.off = i.data_offset + nums.n * 8 + 1
JOIN _mgw_byte b2 ON b2.off = i.data_offset + nums.n * 8 + 2
JOIN _mgw_byte b3 ON b3.off = i.data_offset + nums.n * 8 + 3
JOIN _mgw_byte b4 ON b4.off = i.data_offset + nums.n * 8 + 4
JOIN _mgw_byte b5 ON b5.off = i.data_offset + nums.n * 8 + 5
JOIN _mgw_byte b6 ON b6.off = i.data_offset + nums.n * 8 + 6
JOIN _mgw_byte b7 ON b7.off = i.data_offset + nums.n * 8 + 7
WHERE (SELECT min(ok) FROM load_validation) = 1;

CREATE TABLE wt(
  name TEXT NOT NULL,
  r    INTEGER NOT NULL,
  c    INTEGER NOT NULL,
  v    INTEGER NOT NULL,
  PRIMARY KEY (name, r, c)
) WITHOUT ROWID;
INSERT INTO wt(name, r, c, v)
SELECT i.name, v.flat / i.cols_n, v.flat % i.cols_n, v.v
FROM _mgw_value v JOIN _mgw_index i USING (t)
WHERE i.ndims = 2;

CREATE TABLE uchars(
  i  INTEGER PRIMARY KEY,
  ch INTEGER NOT NULL CHECK (ch BETWEEN 0 AND 255)
) WITHOUT ROWID;
INSERT INTO uchars(i, ch)
SELECT v.flat, v.v
FROM _mgw_value v JOIN _mgw_index i USING (t)
WHERE i.name = 'tokenizer.uchars';

INSERT OR REPLACE INTO rng(id, s)
SELECT 1, v.v
FROM _mgw_value v JOIN _mgw_index i USING (t)
WHERE i.name = 'rng.state' AND v.flat = 0;

CREATE TABLE model_config(
  id               INTEGER PRIMARY KEY CHECK (id = 1),
  hidden_dim       INTEGER NOT NULL,
  num_heads        INTEGER NOT NULL,
  num_kv_heads     INTEGER NOT NULL,
  head_dim         INTEGER NOT NULL,
  num_layers       INTEGER NOT NULL,
  intermediate_dim INTEGER NOT NULL,
  vocab_size       INTEGER NOT NULL,
  max_seq_len      INTEGER NOT NULL,
  bos              INTEGER NOT NULL
);
INSERT INTO model_config
SELECT 1, hidden_dim, num_heads, num_kv_heads, head_dim, num_layers,
       intermediate_dim, vocab_size, max_seq_len, vocab_size - 1
FROM _mgw_config
WHERE (SELECT min(ok) FROM load_validation) = 1;

-- Payload checks are recorded beside the structural checks.
INSERT INTO load_validation VALUES
  ('payload.all_words',
   coalesce((SELECT count(*) = 14299
                    AND sum(CASE WHEN typeof(v) = 'integer' THEN 1 ELSE 0 END)
                        = 14299
             FROM _mgw_value), 0),
   'expected=14299 integer words got=' || (SELECT count(*) FROM _mgw_value)),
  ('payload.weights',
   coalesce((SELECT count(*) = 14272
                    AND sum(CASE WHEN typeof(v) = 'integer' THEN 1 ELSE 0 END)
                        = 14272
             FROM wt), 0),
   'expected=14272 rows got=' || (SELECT count(*) FROM wt)),
  ('payload.uchars',
   coalesce((SELECT count(*) = 26
                    AND sum(CASE WHEN i BETWEEN 0 AND 25
                                      AND ch = i + 97
                                      AND typeof(ch) = 'integer'
                                 THEN 1 ELSE 0 END) = 26
             FROM uchars), 0),
   'expected=26 lowercase ASCII entries got=' || (SELECT count(*) FROM uchars)),
  ('payload.rng',
   coalesce((SELECT count(*) = 1
                    AND sum(CASE WHEN id = 1 AND typeof(s) = 'integer'
                                 THEN 1 ELSE 0 END) = 1
             FROM rng), 0),
   'expected=one signed-int64 RNG state got=' || (SELECT count(*) FROM rng)),
  ('payload.config',
   coalesce((SELECT count(*) = 1
                    AND sum(CASE WHEN hidden_dim = 32 AND num_heads = 4
                                      AND num_kv_heads = 4 AND head_dim = 8
                                      AND num_layers = 1
                                      AND intermediate_dim = 128
                                      AND vocab_size = 27
                                      AND max_seq_len = 8 AND bos = 26
                                 THEN 1 ELSE 0 END) = 1
             FROM model_config), 0),
   'expected=one validated config row');

CREATE TABLE load_status(
  status        TEXT NOT NULL CHECK (status IN ('PASS', 'FAIL')),
  checks        INTEGER NOT NULL,
  failed_checks INTEGER NOT NULL,
  weight_rows   INTEGER NOT NULL,
  uchar_rows    INTEGER NOT NULL,
  rng_rows      INTEGER NOT NULL
);
INSERT INTO load_status
SELECT CASE WHEN min(ok) = 1 THEN 'PASS' ELSE 'FAIL' END,
       count(*), sum(CASE WHEN ok = 0 THEN 1 ELSE 0 END),
       (SELECT count(*) FROM wt),
       (SELECT count(*) FROM uchars),
       (SELECT count(*) FROM rng)
FROM load_validation;

-- Release the 115 KiB image and parsing expansion before inference starts.
DROP TABLE _mgw_value;
DROP TABLE _mgw_index;
DROP TABLE _mgw_name;
DROP TABLE _mgw_config;
DROP TABLE _mgw_header;
DROP TABLE _mgw_i64_meta;
DROP TABLE _mgw_u32;
DROP TABLE _mgw_expected;
DROP TABLE _mgw_byte;
DROP TABLE _mgw_image;
DROP TABLE _mgw_source;

-- The final statement makes a failed load loud while preserving the durable
-- validation rows for callers that execute without the shell's bail mode.
CREATE TABLE _mgw_load_guard(
  ok INTEGER NOT NULL CHECK (ok = 1)
);
INSERT INTO _mgw_load_guard
SELECT status = 'PASS' FROM load_status;
-- <<< END VERBATIM: sql/model_loader.sql <<<
-- ============================================================================

-- ============================================================================
-- SECTION III: TRANSFORMER INFERENCE, SAMPLING, HASHING, AND EXIT GATE
-- The following block is copied byte-for-byte from sql/inference.sql.
-- >>> BEGIN VERBATIM: sql/inference.sql >>>
-- ================================================================
-- inference.sql -- bit-exact microgpt generation pipeline
--
-- Loader contract (created and populated before this fragment):
--   wt(name, r, c, v)  -- Q16.48 model weights
--   uchars(i, ch)      -- token id to byte value
--   rng(id, s)         -- id=1, signed xorshift64 state
--
-- The fixed-point objects from fp_parts.sql must also exist.  This file
-- deliberately contains no model values and no generated names.  It runs
-- the complete 20-sample generation, retains raw logits, hashes both
-- streams through fnv_view, and prints the project exit gate.
-- ================================================================

-- Runtime constants are derived through the same integer primitives as C.
CREATE TABLE inf_const(name TEXT PRIMARY KEY, v INTEGER NOT NULL) WITHOUT ROWID;
DELETE FROM isqjob;
INSERT INTO isqjob(gid, x) VALUES(1, 8 * 281474976710656);
INSERT INTO inf_const SELECT 'attn_scale', r FROM isq_view WHERE gid = 1;
DELETE FROM isqjob;
DELETE FROM divjob;
INSERT INTO divjob(gid, b) VALUES(1, 140737488355328);
INSERT INTO inf_const SELECT 'inv_t', q FROM div_view WHERE gid = 1;
DELETE FROM divjob;

-- Long-lived generation state and observable outputs.
CREATE TABLE inf_cur(
  id INTEGER PRIMARY KEY CHECK(id = 1),
  si INTEGER NOT NULL,
  p INTEGER NOT NULL,
  token INTEGER NOT NULL,
  active INTEGER NOT NULL
);
INSERT INTO inf_cur VALUES(1, 0, 0, 26, 1);

CREATE TABLE inf_counter(id INTEGER PRIMARY KEY CHECK(id = 1), steps INTEGER NOT NULL);
INSERT INTO inf_counter VALUES(1, 0);

CREATE TABLE inf_tick(n INTEGER PRIMARY KEY);
CREATE TABLE inf_kv(
  si INTEGER NOT NULL,
  p INTEGER NOT NULL,
  i INTEGER NOT NULL,
  kval INTEGER NOT NULL,
  vval INTEGER NOT NULL,
  PRIMARY KEY(si, p, i)
) WITHOUT ROWID;
CREATE TABLE logit_log(
  step INTEGER NOT NULL,
  t INTEGER NOT NULL,
  v INTEGER NOT NULL,
  PRIMARY KEY(step, t)
) WITHOUT ROWID;
CREATE TABLE sample_chars(
  si INTEGER NOT NULL,
  ord INTEGER NOT NULL,
  b INTEGER NOT NULL,
  PRIMARY KEY(si, ord)
) WITHOUT ROWID;
CREATE TABLE sample_log(
  step INTEGER PRIMARY KEY,
  si INTEGER NOT NULL,
  p INTEGER NOT NULL,
  in_tok INTEGER NOT NULL,
  out_tok INTEGER NOT NULL,
  total INTEGER NOT NULL,
  u INTEGER NOT NULL,
  r INTEGER NOT NULL,
  rng_after INTEGER NOT NULL
);

-- This compact trace has the same stage names and coordinates as trace.txt.
-- It is intentionally retained: it turns any future bit mismatch into a
-- direct relational diff without changing the inference path.
CREATE TABLE inf_trace(
  si INTEGER NOT NULL,
  p INTEGER NOT NULL,
  stage TEXT NOT NULL,
  i INTEGER NOT NULL,
  j INTEGER NOT NULL,
  v INTEGER NOT NULL
);
CREATE INDEX inf_trace_ix ON inf_trace(si, p, stage, i, j);

-- Per-forward scratch tables.  All arithmetic values remain INTEGER.
CREATE TABLE inf_x(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_xr(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_xn(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_q(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_k(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_v(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_ao(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_xnm(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_h1(i INTEGER PRIMARY KEY, pre INTEGER NOT NULL, v INTEGER NOT NULL);
CREATE TABLE inf_lg(t INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_pb(t INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_vec(i INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_scale(slot TEXT PRIMARY KEY, v INTEGER NOT NULL) WITHOUT ROWID;
CREATE TABLE inf_exp(g INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_div(g INTEGER PRIMARY KEY, v INTEGER NOT NULL);
CREATE TABLE inf_rngnext(s INTEGER NOT NULL, u INTEGER NOT NULL);
CREATE TABLE inf_att(
  h INTEGER NOT NULL,
  s INTEGER NOT NULL,
  dot INTEGER NOT NULL,
  al INTEGER NOT NULL DEFAULT 0,
  e INTEGER NOT NULL DEFAULT 0,
  w INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY(h, s)
) WITHOUT ROWID;
CREATE TABLE inf_ameta(
  h INTEGER PRIMARY KEY,
  mx INTEGER NOT NULL,
  sm INTEGER NOT NULL DEFAULT 0,
  inv INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE inf_sample(
  total INTEGER NOT NULL,
  u INTEGER NOT NULL DEFAULT 0,
  r INTEGER NOT NULL DEFAULT 0,
  choice INTEGER NOT NULL DEFAULT 0
);

CREATE TRIGGER inf_run_one AFTER INSERT ON inf_tick BEGIN
  -- A tick's coordinates are fixed by n.  Position zero starts a new sample;
  -- the token/active fields otherwise carry the previous sampling decision.
  UPDATE inf_cur
     SET si = (NEW.n - 1) / 8,
         p = (NEW.n - 1) % 8,
         token = CASE WHEN (NEW.n - 1) % 8 = 0 THEN 26 ELSE token END,
         active = CASE WHEN (NEW.n - 1) % 8 = 0 THEN 1 ELSE active END
   WHERE id = 1;

  DELETE FROM bus;
  DELETE FROM divjob;
  DELETE FROM expjob;
  DELETE FROM isqjob;
  DELETE FROM rngjob;
  DELETE FROM inf_x;
  DELETE FROM inf_xr;
  DELETE FROM inf_xn;
  DELETE FROM inf_q;
  DELETE FROM inf_k;
  DELETE FROM inf_v;
  DELETE FROM inf_ao;
  DELETE FROM inf_xnm;
  DELETE FROM inf_h1;
  DELETE FROM inf_lg;
  DELETE FROM inf_pb;
  DELETE FROM inf_vec;
  DELETE FROM inf_scale;
  DELETE FROM inf_exp;
  DELETE FROM inf_div;
  DELETE FROM inf_rngnext;
  DELETE FROM inf_att;
  DELETE FROM inf_ameta;
  DELETE FROM inf_sample;

  -- Raw token + position embedding (x0pre).
  INSERT INTO inf_x(i, v)
  SELECT te.c, te.v + pe.v
    FROM wt AS te
    JOIN wt AS pe ON pe.name = 'wpe' AND pe.r = (SELECT p FROM inf_cur) AND pe.c = te.c
   WHERE te.name = 'wte'
     AND te.r = (SELECT token FROM inf_cur)
     AND (SELECT active FROM inf_cur) = 1
   ORDER BY te.c;
  INSERT INTO inf_trace
  SELECT c.si, c.p, 'x0pre', x.i, -1, x.v FROM inf_x x CROSS JOIN inf_cur c;

  -- Initial RMSNorm mutates x in the C implementation (x0).
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'r0sq', i, 0, v, v FROM inf_x ORDER BY i;
  INSERT INTO isqjob(gid, x)
  SELECT 1, SUM(res) / 32 + 2814749767 FROM bus WHERE stage = 'r0sq'
  HAVING COUNT(*) > 0;
  INSERT INTO inf_scale SELECT 'r0', r FROM isq_view WHERE gid = 1;
  DELETE FROM bus;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'r0', i, 0, v, (SELECT v FROM inf_scale WHERE slot = 'r0')
    FROM inf_x ORDER BY i;
  UPDATE inf_x SET v = (SELECT res FROM bus WHERE stage = 'r0' AND g = inf_x.i);
  INSERT INTO inf_trace
  SELECT c.si, c.p, 'x0', x.i, -1, x.v FROM inf_x x CROSS JOIN inf_cur c;

  -- Layer residual is normalized once more before Q/K/V (xn).
  INSERT INTO inf_xr SELECT * FROM inf_x ORDER BY i;
  DELETE FROM bus;
  DELETE FROM isqjob;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'r1sq', i, 0, v, v FROM inf_x ORDER BY i;
  INSERT INTO isqjob(gid, x)
  SELECT 1, SUM(res) / 32 + 2814749767 FROM bus WHERE stage = 'r1sq'
  HAVING COUNT(*) > 0;
  INSERT INTO inf_scale SELECT 'r1', r FROM isq_view WHERE gid = 1;
  DELETE FROM bus;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'r1', i, 0, v, (SELECT v FROM inf_scale WHERE slot = 'r1')
    FROM inf_x ORDER BY i;
  INSERT INTO inf_xn
  SELECT g, res FROM bus WHERE stage = 'r1' ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si, c.p, 'xn', x.i, -1, x.v FROM inf_xn x CROSS JOIN inf_cur c;

  -- Three 32x32 matvecs.
  DELETE FROM bus;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT CASE w.name
           WHEN 'layers.0.attn_wq' THEN 'q'
           WHEN 'layers.0.attn_wk' THEN 'k'
           ELSE 'v'
         END,
         w.r, w.c, w.v, x.v
    FROM wt w JOIN inf_xn x ON x.i = w.c
   WHERE w.name IN ('layers.0.attn_wq', 'layers.0.attn_wk', 'layers.0.attn_wv')
   ORDER BY w.name, w.r, w.c;
  INSERT INTO inf_q SELECT g, SUM(res) FROM bus WHERE stage = 'q' GROUP BY g ORDER BY g;
  INSERT INTO inf_k SELECT g, SUM(res) FROM bus WHERE stage = 'k' GROUP BY g ORDER BY g;
  INSERT INTO inf_v SELECT g, SUM(res) FROM bus WHERE stage = 'v' GROUP BY g ORDER BY g;
  INSERT INTO inf_trace SELECT c.si,c.p,'q',z.i,-1,z.v FROM inf_q z CROSS JOIN inf_cur c;
  INSERT INTO inf_trace SELECT c.si,c.p,'k',z.i,-1,z.v FROM inf_k z CROSS JOIN inf_cur c;
  INSERT INTO inf_trace SELECT c.si,c.p,'v',z.i,-1,z.v FROM inf_v z CROSS JOIN inf_cur c;
  INSERT INTO inf_kv(si, p, i, kval, vval)
  SELECT c.si, c.p, k.i, k.v, v.v
    FROM inf_k k JOIN inf_v v USING(i) CROSS JOIN inf_cur c
   ORDER BY k.i;

  -- Causal multi-head attention.
  DELETE FROM bus;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'dot', (q.i / 8) * 8 + z.p, q.i % 8, q.v, z.kval
    FROM inf_q q
    JOIN inf_cur c
    JOIN inf_kv z ON z.si = c.si AND z.p <= c.p AND z.i = q.i
   ORDER BY q.i / 8, z.p, q.i % 8;
  INSERT INTO inf_att(h, s, dot)
  SELECT g / 8, g % 8, SUM(res) FROM bus WHERE stage = 'dot' GROUP BY g ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'dot',a.h,a.s,a.dot FROM inf_att a CROSS JOIN inf_cur c;
  DELETE FROM bus;
  INSERT INTO bus(stage, g, s, a, b)
  SELECT 'al', h * 8 + s, 0, dot,
         (SELECT v FROM inf_const WHERE name = 'attn_scale')
    FROM inf_att ORDER BY h,s;
  UPDATE inf_att SET al = (SELECT res FROM bus WHERE stage='al' AND g=inf_att.h*8+inf_att.s);
  INSERT INTO inf_trace
  SELECT c.si,c.p,'al',a.h,a.s,a.al FROM inf_att a CROSS JOIN inf_cur c;
  INSERT INTO inf_ameta(h, mx)
  SELECT h, MAX(al) FROM inf_att GROUP BY h ORDER BY h;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'amx',m.h,-1,m.mx FROM inf_ameta m CROSS JOIN inf_cur c;
  DELETE FROM expjob;
  INSERT INTO expjob(gid, x)
  SELECT a.h * 8 + a.s, a.al - m.mx
    FROM inf_att a JOIN inf_ameta m USING(h) ORDER BY a.h,a.s;
  INSERT INTO inf_exp SELECT gid, e FROM exp_view ORDER BY gid;
  UPDATE inf_att SET e=(SELECT v FROM inf_exp WHERE g=inf_att.h*8+inf_att.s);
  INSERT INTO inf_trace
  SELECT c.si,c.p,'aexp',a.h,a.s,a.e FROM inf_att a CROSS JOIN inf_cur c;
  UPDATE inf_ameta SET sm = COALESCE((SELECT SUM(e) FROM inf_att WHERE h=inf_ameta.h),1);
  UPDATE inf_ameta SET sm = 1 WHERE sm = 0;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'asm',m.h,-1,m.sm FROM inf_ameta m CROSS JOIN inf_cur c;
  DELETE FROM divjob;
  INSERT INTO divjob(gid,b) SELECT h,sm FROM inf_ameta ORDER BY h;
  INSERT INTO inf_div SELECT gid,q FROM div_view ORDER BY gid;
  UPDATE inf_ameta SET inv=(SELECT v FROM inf_div WHERE g=inf_ameta.h);
  INSERT INTO inf_trace
  SELECT c.si,c.p,'ainv',m.h,-1,m.inv FROM inf_ameta m CROSS JOIN inf_cur c;
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'aw', a.h*8+a.s, 0, a.e, m.inv
    FROM inf_att a JOIN inf_ameta m USING(h) ORDER BY a.h,a.s;
  UPDATE inf_att SET w=(SELECT res FROM bus WHERE stage='aw' AND g=inf_att.h*8+inf_att.s);
  INSERT INTO inf_trace
  SELECT c.si,c.p,'aw',a.h,a.s,a.w FROM inf_att a CROSS JOIN inf_cur c;
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'ao', z.i, a.s, a.w, z.vval
    FROM inf_att a
    JOIN inf_cur c
    JOIN inf_kv z ON z.si=c.si AND z.p=a.s AND z.i/8=a.h
   ORDER BY z.i,a.s;
  INSERT INTO inf_ao SELECT g,SUM(res) FROM bus WHERE stage='ao' GROUP BY g ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'ao',z.i,-1,z.v FROM inf_ao z CROSS JOIN inf_cur c;

  -- Attention output projection plus residual (xmid).
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'wo',w.r,w.c,w.v,a.v
    FROM wt w JOIN inf_ao a ON a.i=w.c
   WHERE w.name='layers.0.attn_wo'
   ORDER BY w.r,w.c;
  INSERT INTO inf_vec
  SELECT b.g,SUM(b.res)+r.v
    FROM bus b JOIN inf_xr r ON r.i=b.g
   WHERE b.stage='wo' GROUP BY b.g ORDER BY b.g;
  DELETE FROM inf_x;
  INSERT INTO inf_x SELECT * FROM inf_vec ORDER BY i;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'xmid',z.i,-1,z.v FROM inf_x z CROSS JOIN inf_cur c;

  -- MLP RMSNorm (xnm).
  DELETE FROM inf_xr;
  INSERT INTO inf_xr SELECT * FROM inf_x ORDER BY i;
  DELETE FROM bus;
  DELETE FROM isqjob;
  INSERT INTO bus(stage,g,s,a,b) SELECT 'r2sq',i,0,v,v FROM inf_x ORDER BY i;
  INSERT INTO isqjob(gid,x)
  SELECT 1,SUM(res)/32+2814749767 FROM bus WHERE stage='r2sq' HAVING COUNT(*)>0;
  INSERT INTO inf_scale SELECT 'r2',r FROM isq_view WHERE gid=1;
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'r2',i,0,v,(SELECT v FROM inf_scale WHERE slot='r2') FROM inf_x ORDER BY i;
  INSERT INTO inf_xnm SELECT g,res FROM bus WHERE stage='r2' ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'xnm',z.i,-1,z.v FROM inf_xnm z CROSS JOIN inf_cur c;

  -- 32 -> 128 -> 32 MLP and residual (xout).
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'fc1',w.r,w.c,w.v,x.v
    FROM wt w JOIN inf_xnm x ON x.i=w.c
   WHERE w.name='layers.0.mlp_fc1'
   ORDER BY w.r,w.c;
  INSERT INTO inf_h1
  SELECT g,SUM(res),CASE WHEN SUM(res)>0 THEN SUM(res) ELSE 0 END
    FROM bus WHERE stage='fc1' GROUP BY g ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'h1pre',z.i,-1,z.pre FROM inf_h1 z CROSS JOIN inf_cur c;
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'fc2',w.r,w.c,w.v,h.v
    FROM wt w JOIN inf_h1 h ON h.i=w.c
   WHERE w.name='layers.0.mlp_fc2'
   ORDER BY w.r,w.c;
  DELETE FROM inf_vec;
  INSERT INTO inf_vec
  SELECT b.g,SUM(b.res)+r.v
    FROM bus b JOIN inf_xr r ON r.i=b.g
   WHERE b.stage='fc2' GROUP BY b.g ORDER BY b.g;
  DELETE FROM inf_x;
  INSERT INTO inf_x SELECT * FROM inf_vec ORDER BY i;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'xout',z.i,-1,z.v FROM inf_x z CROSS JOIN inf_cur c;

  -- Raw logits are observed before temperature scaling.
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'logit',w.r,w.c,w.v,x.v
    FROM wt w JOIN inf_x x ON x.i=w.c
   WHERE w.name='lm_head'
   ORDER BY w.r,w.c;
  INSERT INTO inf_lg SELECT g,SUM(res) FROM bus WHERE stage='logit' GROUP BY g ORDER BY g;
  UPDATE inf_counter SET steps=steps+1 WHERE (SELECT active FROM inf_cur)=1;
  INSERT INTO logit_log
  SELECT n.steps,l.t,l.v FROM inf_lg l CROSS JOIN inf_counter n ORDER BY l.t;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'L',z.t,-1,z.v FROM inf_lg z CROSS JOIN inf_cur c;

  -- Temperature 0.5 and vocabulary softmax.
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'temp',t,0,v,(SELECT v FROM inf_const WHERE name='inv_t')
    FROM inf_lg ORDER BY t;
  UPDATE inf_lg SET v=(SELECT res FROM bus WHERE stage='temp' AND g=inf_lg.t);
  INSERT INTO inf_scale SELECT 'lmax',MAX(v) FROM inf_lg HAVING COUNT(*)>0;
  DELETE FROM expjob;
  DELETE FROM inf_exp;
  INSERT INTO expjob(gid,x)
  SELECT t,v-(SELECT v FROM inf_scale WHERE slot='lmax') FROM inf_lg ORDER BY t;
  INSERT INTO inf_exp SELECT gid,e FROM exp_view ORDER BY gid;
  INSERT INTO inf_scale
  SELECT 'lsm',CASE WHEN SUM(v)=0 THEN 1 ELSE SUM(v) END FROM inf_exp HAVING COUNT(*)>0;
  DELETE FROM divjob;
  DELETE FROM inf_div;
  INSERT INTO divjob(gid,b) SELECT 100,v FROM inf_scale WHERE slot='lsm';
  INSERT INTO inf_div SELECT gid,q FROM div_view;
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'prob',e.g,0,e.v,(SELECT v FROM inf_div WHERE g=100)
    FROM inf_exp e ORDER BY e.g;
  INSERT INTO inf_pb SELECT g,res FROM bus WHERE stage='prob' ORDER BY g;
  INSERT INTO inf_trace
  SELECT c.si,c.p,'P',z.t,-1,z.v FROM inf_pb z CROSS JOIN inf_cur c;

  -- weighted_choice(): no RNG draw for an all-zero distribution.
  INSERT INTO inf_sample(total)
  SELECT SUM(v) FROM inf_pb HAVING COUNT(*)>0;
  DELETE FROM rngjob;
  INSERT INTO rngjob(gid,s)
  SELECT 1,r.s FROM rng r CROSS JOIN inf_sample z WHERE z.total<>0;
  INSERT INTO inf_rngnext SELECT nx,u FROM rngstep;
  UPDATE inf_sample SET u=COALESCE((SELECT u FROM inf_rngnext),0);
  UPDATE rng SET s=(SELECT s FROM inf_rngnext) WHERE EXISTS(SELECT 1 FROM inf_rngnext);
  DELETE FROM bus;
  INSERT INTO bus(stage,g,s,a,b)
  SELECT 'pick',0,0,u,total FROM inf_sample WHERE total<>0;
  UPDATE inf_sample SET r=COALESCE((SELECT res FROM bus WHERE stage='pick'),0);
  UPDATE inf_sample
     SET choice=CASE WHEN total=0 THEN 0 ELSE COALESCE(
       (SELECT MIN(t) FROM
          (SELECT t,SUM(v) OVER (
             ORDER BY t ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
           ) AS cum FROM inf_pb)
        WHERE inf_sample.r<cum),26) END;

  INSERT INTO sample_log(step,si,p,in_tok,out_tok,total,u,r,rng_after)
  SELECT n.steps,c.si,c.p,c.token,z.choice,z.total,z.u,z.r,rng.s
    FROM inf_counter n CROSS JOIN inf_cur c CROSS JOIN inf_sample z CROSS JOIN rng;
  INSERT INTO sample_chars(si,ord,b)
  SELECT c.si,c.p,u.ch
    FROM inf_cur c CROSS JOIN inf_sample z JOIN uchars u ON u.i=z.choice
   WHERE z.choice<>26;
  UPDATE inf_cur
     SET token=(SELECT choice FROM inf_sample),
         active=CASE WHEN (SELECT choice FROM inf_sample)=26 THEN 0 ELSE 1 END
   WHERE EXISTS(SELECT 1 FROM inf_sample);
END;

-- 160 delivered ticks contain 122 active forward passes in the golden run.
WITH RECURSIVE ticks(n) AS (
  SELECT 1 UNION ALL SELECT n+1 FROM ticks WHERE n<160
)
INSERT INTO inf_tick SELECT n FROM ticks ORDER BY n;

-- Hash the actual generated sample byte stream, with one newline per sample.
CREATE TABLE inf_result(
  id INTEGER PRIMARY KEY CHECK(id=1),
  sample_hash INTEGER,
  logits_hash INTEGER,
  steps INTEGER NOT NULL
);
INSERT INTO inf_result(id,steps) SELECT 1,steps FROM inf_counter;
DELETE FROM fnvbytes;
WITH RECURSIVE samples(si) AS (
  SELECT 0 UNION ALL SELECT si+1 FROM samples WHERE si<19
), bytes AS (
  SELECT si,0 AS tail,ord,b FROM sample_chars
  UNION ALL
  SELECT si,1 AS tail,8 AS ord,10 AS b FROM samples
)
INSERT INTO fnvbytes(seq,b)
SELECT ROW_NUMBER() OVER (ORDER BY si,tail,ord),b FROM bytes ORDER BY si,tail,ord;
UPDATE inf_result SET sample_hash=(SELECT h FROM fnv_view ORDER BY n DESC LIMIT 1);

-- Hash every raw logit word as eight little-endian bytes.
DELETE FROM fnvbytes;
WITH RECURSIVE octet(k) AS (
  SELECT 0 UNION ALL SELECT k+1 FROM octet WHERE k<7
), bytes AS (
  SELECT l.step,l.t,o.k,(l.v >> (8*o.k)) & 255 AS b
    FROM logit_log l CROSS JOIN octet o
)
INSERT INTO fnvbytes(seq,b)
SELECT ROW_NUMBER() OVER (ORDER BY step,t,k),b FROM bytes ORDER BY step,t,k;
UPDATE inf_result SET logits_hash=(SELECT h FROM fnv_view ORDER BY n DESC LIMIT 1);

SELECT printf('LANE sql sample_hash=%016x logits_hash=%016x steps=%d',
              sample_hash,logits_hash,steps)
  FROM inf_result;
WITH RECURSIVE samples(si) AS (
  SELECT 0 UNION ALL SELECT si+1 FROM samples WHERE si<19
)
SELECT printf('SAMPLE %02d %s',si+1,COALESCE((
         SELECT group_concat(char(b),'' ORDER BY ord)
           FROM sample_chars c WHERE c.si=samples.si
       ),''))
  FROM samples ORDER BY si;
SELECT CASE
  WHEN printf('%016x',sample_hash)='0f6b22da7c9b715b'
   AND printf('%016x',logits_hash)='0610f72f01c199cb'
   AND steps=122
  THEN 'SQL_GATE=PASS'
  ELSE printf('SQL_GATE=FAIL sample_hash=%016x logits_hash=%016x steps=%d',
              sample_hash,logits_hash,steps) END
FROM inf_result;
-- <<< END VERBATIM: sql/inference.sql <<<
-- ============================================================================