# Snapshot: verilog/clean7c/rtl/array/att/lutgemm_lane_w2.sv

Copied 2026-11-17T17:32:37Z from the clean7c tree (verilog repo commit 5998a7f1, md5 fa1aa8c446adb4a1ba537603d0f50d0d). Read-only copy for review; the live file is in the RTL repo.

```systemverilog
// =====================================================================================================================
// lutgemm_lane_w2   (clean7c rtl/array/att, WP3)
// =====================================================================================================================
// Imported from the shipped packaged copy ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv md5 6edf40360b7da7f7c05ea673828548eb (ATT 0xE4B713BE).
// Code = the shipped code; only this header, the items under 'clean7c edits' and the role include differ.
// Regenerate / verify: tools/wp3_import.py [--check]. Architecture + diagrams: docs/ARRAY.md.
//
// Purpose  : one output column of the ATT body GEMV: W2 x A8 multiply-free LUT-GEMM lane with a per-lane GPTQ-v2 zero.
//            Per 16-element chunk c of group g: sum_i a_i*(code_i - z) = sum_planes(2*T[hi] + T[lo]) - z*S_c, with
//            T = {0, a0, a1, a0+a1} over activation pairs (the cluster's shared pair tables tbl_e/tbl_o) and z*S_c a 4:1
//            select of {0, S, 2S, 3S} (S, 3S shared by the cluster). Two chunks per cycle (even + odd, URAM ports A/B);
//            per-group INT sum, one scale multiply per group (FOLD_FABRIC 1: the 48-b fold add kept in fabric), result_q
//            48 b. TILE_PIPE with TP_SLIM 1: one accumulator bank, cleared by the column's last pair output.
// Users    : u_array/g_grp[*].g_lane[*].g_dual.g_lutg.u_lane (512, SEQ_CHK 1) and the A8Q lead lane u_array/g_a8q.u_lead
//            (datapath inputs tied 0, SEQ_CHK 0: only its chunk-index lookahead is used).
// Latency  : chunk c's codes / scale / zero at cycle t (registered RAM reads addressed by *_next_out at t-1); WLAT is built in:
//            qw/scale/zero are re-registered once (qw_d ...) to meet the cluster's activation register at t+1; CSA_LAT 3
//            (csa_tree16_w); done one cycle after the column's last pair leaves the tree.
// Reset    : synchronous active-low. KNOWN HAZARD (docs/ARRAY.md §7): the issue registers qw_d/qwb_d/sc_d/qz_d/ec_d are pure
//            datapath but share the reset block with the valid/tag bits (same idiom as the MLPV lane's g_wlat1, whose qw_d
//            bits place_design inverted on M1364 lane 84). Not changed here (lever L-RST-DP).
// Invariant: err_short (sticky) = wrong pair sequence (S_DRAIN timeout count or SEQ_CHK); report-only.
// Instances in the image: 513 (resolved parameters: rtl/array/SHIPPED_PARAMS.tsv, rows 'att lutgemm_lane_w2').
// Ports (generated from the port list; widths as declared, resolved values are in SHIPPED_PARAMS.tsv):
//   input  clk                   1
//   input  rst_n                 1
//   input  start                 1
//   input  a_chunk               signed [K_PAR*A_WIDTH-1:0]
//   input  a_chunk_b             signed [K_PAR*A_WIDTH-1:0]
//   input  tbl_e                 [TBW-1:0]
//   input  tbl_o                 [TBW-1:0]
//   input  qw_word               [31:0]
//   input  qw_word_b             [31:0]
//   input  scale_q               signed [SCALE_WIDTH-1:0]
//   input  qz                    [1:0]
//   input  s_e                   signed [ZW-1:0]
//   input  s3_e                  signed [ZW-1:0]
//   input  s_o                   signed [ZW-1:0]
//   input  s3_o                  signed [ZW-1:0]
//   input  n_chunks_run          [CW-1:0]
//   output chunk_idx_out         [CW-1:0]
//   output chunk_idx_b_out       [CW-1:0]
//   output chunk_idx_valid       1
//   output chunk_idx_next_out    [CW-1:0]
//   output chunk_idx_b_next_out  [CW-1:0]
//   output group_idx_out         [GW-1:0]
//   output group_idx_next_out    [GW-1:0]
//   output acc_out               signed [31:0]
//   output result_q              signed [RES_WIDTH-1:0]
//   output done                  1
//   output start_dropped         1
//   output err_short             1
// clean7c edits:
//   - dead branch `g_csa20` (CSA_NARROW 0) removed -> stub (shipped :303-314)
//   - dead branch `g_banks2` (TP_SLIM 0) removed -> stub (shipped :415-440)
//   - dead branch `g_fold_dsp` (FOLD_FABRIC 0) removed -> stub (shipped :447-449)
//   - default K 10240 -> 8192 (every lutgemm_lane_w2 instance of the image resolves 8192)
//   - default CSA_NARROW 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
//   - default TP_SLIM 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
//   - default FOLD_FABRIC 1'b0 -> 1'b1 (every lutgemm_lane_w2 instance of the image resolves 1'b1)
// =====================================================================================================================
`timescale 1ns/1ps
`default_nettype none

(* keep_hierarchy = "yes" *)
module lutgemm_lane_w2 #(
    parameter int K           = 8192,    // max reduction length (runtime n_chunks_run <= K/16)
    parameter int A_WIDTH     = 8,
    parameter int GROUP       = 128,
    parameter int SCALE_WIDTH = 16,
    parameter int RES_WIDTH   = 48,
    parameter bit TILE_PIPE   = 1'b1,
    parameter bit CSA_NARROW  = 1'b1,     // H2: tree at the minimum exact width
    parameter int CSA_OW      = A_WIDTH + 6,  // narrowed tree width (RED R4 overrides)
    parameter bit RED_PLANE   = 1'b0,
    parameter bit RED_GRP     = 1'b0,
    parameter bit TP_SLIM     = 1'b1,     // E2: single-bank TILE_PIPE
    parameter bit SEQ_CHK     = 1'b1,     // pair-sequence check feeding err_short
    parameter bit FOLD_FABRIC = 1'b1,     // E3: TP_SLIM 48-b fold add kept out of the DSP
    parameter bit RED_DROPV   = 1'b0,
    parameter bit RED_SLIMCLR = 1'b0,
    // ----- derived -----
    parameter int K_PAR       = 16,
    parameter int TE_W        = A_WIDTH + 1,                     // table entry a0+a1
    parameter int TBW         = 8 * TE_W,
    parameter int ZW          = A_WIDTH + 6,                     // |3*S| < 2^(A+5)
    parameter int N_CHUNKS    = K / K_PAR,
    parameter int CW          = (N_CHUNKS <= 1) ? 1 : $clog2(N_CHUNKS + 2),
    parameter int CPG         = GROUP / K_PAR,
    parameter int N_GROUPS    = (K + GROUP - 1) / GROUP,
    parameter int GW          = (N_GROUPS <= 1) ? 1 : $clog2(N_GROUPS + 1),
    parameter int N_PAIRS     = (N_CHUNKS + 1) / 2,
    parameter int PW          = (N_PAIRS <= 1) ? 1 : $clog2(N_PAIRS + 2)
) (
    input  wire                            clk,
    input  wire                            rst_n,
    input  wire                            start,

    input  wire signed [K_PAR*A_WIDTH-1:0] a_chunk,      // even chunk (issue cycle)
    input  wire signed [K_PAR*A_WIDTH-1:0] a_chunk_b,    // odd  chunk (issue cycle)
    input  wire        [TBW-1:0]           tbl_e,        // shared pair sums (issue cycle)
    input  wire        [TBW-1:0]           tbl_o,
    input  wire        [31:0]              qw_word,      // 16 codes, even chunk (cycle t)
    input  wire        [31:0]              qw_word_b,    // 16 codes, odd  chunk (cycle t)
    input  wire signed [SCALE_WIDTH-1:0]   scale_q,      // this lane's scale, cycle t
    input  wire        [1:0]               qz,           // this lane's zero,  cycle t
    input  wire signed [ZW-1:0]            s_e,          // shared S, 3S (issue+CSA_LAT-1)
    input  wire signed [ZW-1:0]            s3_e,
    input  wire signed [ZW-1:0]            s_o,
    input  wire signed [ZW-1:0]            s3_o,

    input  wire        [CW-1:0]            n_chunks_run,

    output wire        [CW-1:0]            chunk_idx_out,
    output wire        [CW-1:0]            chunk_idx_b_out,
    output wire                            chunk_idx_valid,
    output wire        [CW-1:0]            chunk_idx_next_out,
    output wire        [CW-1:0]            chunk_idx_b_next_out,
    output wire        [GW-1:0]            group_idx_out,
    output wire        [GW-1:0]            group_idx_next_out,

    output reg  signed [31:0]              acc_out,
    output reg  signed [RES_WIDTH-1:0]     result_q,
    output reg                             done,
    output reg                             start_dropped,
    output reg                             err_short
);
    localparam int CSA_LAT  = 3;
    localparam int CPG_BITS = (CPG <= 1) ? 1 : $clog2(CPG);
    // term / tree / partial-sum widths
    localparam int TW     = CSA_NARROW ? (A_WIDTH + 2) : 20;
    localparam int SW     = CSA_NARROW ? CSA_OW        : 26;
    localparam int PSUM_W = CSA_NARROW ? (A_WIDTH + 8) : 28;
    localparam int GACC_W = CSA_NARROW ? (A_WIDTH + 10) : 32;

`ifndef SYNTHESIS
    initial if (CPG[0] != 1'b0)
        $error("lutgemm_lane_w2: CPG (GROUP/K_PAR=%0d) must be EVEN for the pair/group alignment.", CPG);
    initial if (TILE_PIPE && (N_PAIRS <= CSA_LAT + 2))
        $error("lutgemm_lane_w2: TILE_PIPE=1 needs N_PAIRS > CSA_LAT+2 (got %0d).", N_PAIRS);
`endif

    wire signed [PSUM_W-1:0] csa_sum_e, csa_sum_o;
    wire                     csa_out_valid;
    wire signed [PSUM_W:0]   csa_pair_sum;

    // ----------------------------------------------------------------
    // FSM - pair walk (verbatim from the golden dual lane)
    // ----------------------------------------------------------------
    typedef enum logic [1:0] { S_IDLE, S_RUN, S_DRAIN, S_DONE } state_t;
    state_t state, state_n;
    wire state_is_idle = (state == S_IDLE);

    logic [CW-1:0] nc_run_q;
    wire  [CW-1:0] nc_eff = (nc_run_q == '0) ? CW'(N_CHUNKS) : nc_run_q;
    wire  [PW-1:0] np_eff = PW'((nc_eff + CW'(1)) >> 1);

    logic [PW-1:0] pair_idx,    pair_idx_n;
    logic [CW-1:0] drain_count, drain_count_n;
    logic [PW-1:0] outs_recvd,  outs_recvd_n;

    wire at_terminal_pair = (state == S_RUN) && (pair_idx == np_eff - 1'b1);
    wire col_accept = (state_is_idle && start)
                   || (TILE_PIPE && at_terminal_pair && start);
    always_ff @(posedge clk) begin
        if (!rst_n)          nc_run_q <= '0;
        else if (col_accept) nc_run_q <= n_chunks_run;
    end
    always_ff @(posedge clk) begin
        if (!rst_n)                                         start_dropped <= 1'b0;
        else if (start && !col_accept && (state != S_IDLE)) start_dropped <= 1'b1;
    end

    always_ff @(posedge clk) begin
        if (!rst_n) begin
            state <= S_IDLE; pair_idx <= '0; drain_count <= '0; outs_recvd <= '0;
        end else begin
            state <= state_n; pair_idx <= pair_idx_n;
            drain_count <= drain_count_n; outs_recvd <= outs_recvd_n;
        end
    end

    always_comb begin
        state_n = state; pair_idx_n = pair_idx;
        drain_count_n = drain_count; outs_recvd_n = outs_recvd;
        case (state)
            S_IDLE: if (start) begin
                state_n = S_RUN; pair_idx_n = '0;
                drain_count_n = '0; outs_recvd_n = '0;
            end
            S_RUN: begin
                if (pair_idx == np_eff - 1'b1) begin
                    if (TILE_PIPE && start) begin
                        state_n = S_RUN; pair_idx_n = '0;
                        drain_count_n = '0; outs_recvd_n = '0;
                    end else begin
                        state_n = S_DRAIN; drain_count_n = '0;
                    end
                end else pair_idx_n = pair_idx + 1'b1;
                if (csa_out_valid) outs_recvd_n = outs_recvd + 1'b1;
            end
            S_DRAIN: begin
                if (csa_out_valid) outs_recvd_n = outs_recvd + 1'b1;
                if (outs_recvd == np_eff) state_n = S_DONE;
                else if (drain_count >= CSA_LAT + 2) state_n = S_DONE;
                drain_count_n = drain_count + 1'b1;
            end
            S_DONE: state_n = S_IDLE;
            default: state_n = S_IDLE;
        endcase
    end

    wire [CW-1:0] even_cur  = CW'(pair_idx)   << 1;
    wire [CW-1:0] even_next = CW'(pair_idx_n) << 1;
    assign chunk_idx_out        = even_cur;
    assign chunk_idx_b_out      = even_cur  + CW'(1);
    assign chunk_idx_next_out   = even_next;
    assign chunk_idx_b_next_out = even_next + CW'(1);
    assign chunk_idx_valid      = (state == S_RUN);

    wire [CW-1:0] grp_cur_full  = (CPG <= 1) ? even_cur  : (even_cur  >> CPG_BITS);
    wire [CW-1:0] grp_next_full = (CPG <= 1) ? even_next : (even_next >> CPG_BITS);
    assign group_idx_out      = grp_cur_full[GW-1:0];
    assign group_idx_next_out = RED_GRP ? (grp_next_full[GW-1:0] + GW'(1))   // RED R3
                                        :  grp_next_full[GW-1:0];

    // ----------------------------------------------------------------
    // WLAT=1 issue registers (qw, scale, AND the per-lane zero)
    // ----------------------------------------------------------------
    reg [31:0]                   qw_d, qwb_d;
    reg                          civ_d;
    reg [CW-1:0]                 ec_d;
    reg signed [SCALE_WIDTH-1:0] sc_d;
    reg [1:0]                    qz_d;
    reg                          tp_tag_d, tp_lcol_d;
    reg  col_tag;
    always_ff @(posedge clk) begin
        if (!rst_n)                       col_tag <= 1'b0;
        else if (TILE_PIPE && col_accept) col_tag <= ~col_tag;
    end
    wire lastcol_pre = (pair_idx == np_eff - 1'b1);
    always_ff @(posedge clk) begin
        if (!rst_n) begin
            qw_d <= '0; qwb_d <= '0; civ_d <= 1'b0; ec_d <= '0; sc_d <= '0; qz_d <= '0;
            tp_tag_d <= 1'b0; tp_lcol_d <= 1'b0;
        end else begin
            qw_d  <= qw_word;  qwb_d <= qw_word_b; civ_d <= chunk_idx_valid;
            ec_d  <= even_cur; sc_d  <= scale_q;   qz_d  <= qz;
            tp_tag_d <= col_tag; tp_lcol_d <= lastcol_pre;
        end
    end
    wire                          mac_in_valid  = civ_d;
    wire [CW-1:0]                 even_issue    = ec_d;
    wire signed [SCALE_WIDTH-1:0] scale_q_eff   = sc_d;
    wire                          tag_issue     = tp_tag_d;
    wire                          lastcol_issue = tp_lcol_d;

    wire odd_valid_issue = ((even_issue + CW'(1)) < nc_eff);
    // tree-issue valid (RED_DROPV drops pair 0 of every column)
    wire mac_v = mac_in_valid && !(RED_DROPV && (even_issue == '0));

    // ----------------------------------------------------------------
    // LUT-GEMM lookups (no multiply). Odd codes forced to 0 past nc.
    // ----------------------------------------------------------------
    wire [31:0] qw_e_codes = qw_d;
    wire [31:0] qw_o_codes = odd_valid_issue ? qwb_d : 32'd0;

    function automatic signed [TW-1:0] lk2(input [1:0] m,
                                           input signed [A_WIDTH-1:0] a0,
                                           input signed [A_WIDTH-1:0] a1,
                                           input signed [TE_W-1:0]    s);
        case (m)
            2'd0:    lk2 = '0;
            2'd1:    lk2 = TW'(a0);
            2'd2:    lk2 = TW'(a1);
            default: lk2 = TW'(s);
        endcase
    endfunction

    logic signed [TW-1:0] terms_e [0:15];
    logic signed [TW-1:0] terms_o [0:15];
    always_comb begin
        for (int j = 0; j < 8; j++) begin
            logic [1:0] r0e, r1e, r0o, r1o;      // codes of elements 2j, 2j+1
            logic [1:0] lo_e, hi_e, lo_o, hi_o;  // bit-plane masks over the pair
            logic signed [A_WIDTH-1:0] ae0, ae1, ao0, ao1;
            r0e = qw_e_codes[(2*j)*2 +: 2];   r1e = qw_e_codes[(2*j+1)*2 +: 2];
            r0o = qw_o_codes[(2*j)*2 +: 2];   r1o = qw_o_codes[(2*j+1)*2 +: 2];
            lo_e = {r1e[0], r0e[0]};  hi_e = {r1e[1], r0e[1]};
            lo_o = {r1o[0], r0o[0]};  hi_o = {r1o[1], r0o[1]};
            if (RED_PLANE) begin                  // RED R2: planes swapped
                {lo_e, hi_e} = {hi_e, lo_e};
                {lo_o, hi_o} = {hi_o, lo_o};
            end
            ae0 = a_chunk  [(2*j)*A_WIDTH +: A_WIDTH];  ae1 = a_chunk  [(2*j+1)*A_WIDTH +: A_WIDTH];
            ao0 = a_chunk_b[(2*j)*A_WIDTH +: A_WIDTH];  ao1 = a_chunk_b[(2*j+1)*A_WIDTH +: A_WIDTH];
            terms_e[2*j]   = lk2(lo_e, ae0, ae1, tbl_e[j*TE_W +: TE_W]);
            terms_e[2*j+1] = lk2(hi_e, ae0, ae1, tbl_e[j*TE_W +: TE_W]) <<< 1;
            terms_o[2*j]   = lk2(lo_o, ao0, ao1, tbl_o[j*TE_W +: TE_W]);
            terms_o[2*j+1] = lk2(hi_o, ao0, ao1, tbl_o[j*TE_W +: TE_W]) <<< 1;
        end
    end

    wire signed [SW-1:0] tsum_e, tsum_o;
    wire                 tval_e, tval_o;
    generate
    if (!CSA_NARROW) begin : g_csa20
        // clean7c WP3: branch `g_csa20` (CSA_NARROW 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
        // (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:303-314). Selecting it is an elaboration
        // error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
        C7_REMOVED_BRANCH__lutgemm_lane_w2__g_csa20 u_c7_removed ();
    end else begin : g_csaw
        csa_tree16_w #(.IN_W(TW), .OUT_W(SW)) u_csa_e (.clk(clk), .rst_n(rst_n),
            .in_valid(mac_v), .prods(terms_e), .sum_out(tsum_e), .out_valid(tval_e));
        csa_tree16_w #(.IN_W(TW), .OUT_W(SW)) u_csa_o (.clk(clk), .rst_n(rst_n),
            .in_valid(mac_v), .prods(terms_o), .sum_out(tsum_o), .out_valid(tval_o));
    end
    endgenerate

    // ----------------------------------------------------------------
    // PER-LANE Z = zero * S  (4:1 select of {0, S, 2S, 3S}, then one register)
    // zero is delayed issue -> issue+CSA_LAT-1 to meet the cluster's S/3S.
    // ----------------------------------------------------------------
    logic [1:0] qz_sr [0:CSA_LAT-2];
    always_ff @(posedge clk) begin
        if (!rst_n) for (int q = 0; q < CSA_LAT-1; q++) qz_sr[q] <= '0;
        else begin
            qz_sr[0] <= qz_d;
            for (int q = 1; q < CSA_LAT-1; q++) qz_sr[q] <= qz_sr[q-1];
        end
    end
    wire [1:0] zq = qz_sr[CSA_LAT-2];
    function automatic signed [ZW-1:0] zsel(input [1:0] z, input signed [ZW-1:0] s,
                                            input signed [ZW-1:0] s3);
        case (z)
            2'd0:    zsel = '0;
            2'd1:    zsel = s;
            2'd2:    zsel = s <<< 1;
            default: zsel = s3;
        endcase
    endfunction
    reg signed [ZW-1:0] z_e, z_o;
    always_ff @(posedge clk) begin
        if (!rst_n) begin z_e <= '0; z_o <= '0; end
        else begin z_e <= zsel(zq, s_e, s3_e); z_o <= zsel(zq, s_o, s3_o); end
    end

    logic ov_sr [0:CSA_LAT-1];
    always_ff @(posedge clk) begin
        if (!rst_n) for (int q = 0; q < CSA_LAT; q++) ov_sr[q] <= 1'b0;
        else begin
            ov_sr[0] <= odd_valid_issue;
            for (int q = 1; q < CSA_LAT; q++) ov_sr[q] <= ov_sr[q-1];
        end
    end
    wire signed [ZW-1:0] z_o_eff = ov_sr[CSA_LAT-1] ? z_o : '0;
    assign csa_sum_e     = PSUM_W'($signed(tsum_e) - $signed(z_e));
    assign csa_sum_o     = PSUM_W'($signed(tsum_o) - $signed(z_o_eff));
    assign csa_out_valid = tval_e;
    assign csa_pair_sum  = $signed(csa_sum_e) + $signed(csa_sum_o);

    // ----------------------------------------------------------------
    // From here down = the golden dual lane (TILE_PIPE banks, fold, scale).
    // ----------------------------------------------------------------
    logic tag_sr  [0:CSA_LAT-1];
    logic lcol_sr [0:CSA_LAT-1];
    always_ff @(posedge clk) begin
        if (!rst_n) begin
            for (int t = 0; t < CSA_LAT; t++) begin tag_sr[t] <= 1'b0; lcol_sr[t] <= 1'b0; end
        end else begin
            tag_sr[0]  <= tag_issue;
            lcol_sr[0] <= lastcol_issue && mac_v;
            for (int t = 1; t < CSA_LAT; t++) begin
                tag_sr[t] <= tag_sr[t-1]; lcol_sr[t] <= lcol_sr[t-1];
            end
        end
    end
    wire tag_now  = tag_sr[CSA_LAT-1];
    wire lcol_now = lcol_sr[CSA_LAT-1];
    wire new_tag  = TILE_PIPE ? ~col_tag : 1'b0;

    wire [CW-1:0] grp_issue_full = (CPG <= 1) ? even_issue : (even_issue >> CPG_BITS);
    wire [CW-1:0] grp_end_full   = ((grp_issue_full + CW'(1)) << CPG_BITS) - CW'(1);
    wire [CW-1:0] grp_last       = (grp_end_full < (nc_eff - CW'(1)))
                                   ? grp_end_full : (nc_eff - CW'(1));
    wire last_in_grp_issue = odd_valid_issue ? ((even_issue + CW'(1)) == grp_last)
                                             : (even_issue == grp_last);

    logic                          last_sr [0:CSA_LAT-1];
    logic signed [SCALE_WIDTH-1:0] sc_sr   [0:CSA_LAT-1];
    always_ff @(posedge clk) begin
        if (!rst_n) begin
            for (int s = 0; s < CSA_LAT; s++) begin last_sr[s] <= 1'b0; sc_sr[s] <= '0; end
        end else begin
            last_sr[0] <= last_in_grp_issue;
            sc_sr[0]   <= scale_q_eff;
            for (int s = 1; s < CSA_LAT; s++) begin
                last_sr[s] <= last_sr[s-1]; sc_sr[s] <= sc_sr[s-1];
            end
        end
    end
    wire                          last_now  = last_sr[CSA_LAT-1];
    wire signed [SCALE_WIDTH-1:0] scale_now = sc_sr[CSA_LAT-1];

    wire signed [31:0]          acc_next;
    wire signed [GACC_W-1:0]    g_total_w;
    wire signed [RES_WIDTH-1:0] scaled_next_w;
    wire                        cap_ev;
    wire signed [31:0]          acc_cap;
    wire signed [RES_WIDTH-1:0] res_cap;
    genvar ab;
    generate
    if (!TP_SLIM) begin : g_banks2
        // clean7c WP3: branch `g_banks2` (TP_SLIM 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
        // (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:415-440). Selecting it is an elaboration
        // error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
        C7_REMOVED_BRANCH__lutgemm_lane_w2__g_banks2 u_c7_removed ();
    end else begin : g_bank1
        // ---- TP_SLIM: one bank, cleared by the column's last pair output ----
        logic signed [31:0]          acc_s;
        logic signed [GACC_W-1:0]    gacc_s;
        logic signed [RES_WIDTH-1:0] sacc_s;
        assign acc_next      = acc_s  + $signed(csa_pair_sum);
        assign g_total_w     = gacc_s + $signed(csa_pair_sum);
        if (!FOLD_FABRIC) begin : g_fold_dsp
            // clean7c WP3: branch `g_fold_dsp` (FOLD_FABRIC 0) is elaborated by NO instance of ATT 0xE4B713BE and was removed
            // (shipped text: ref/att_13be/packaged_ip/src/lutgemm_lane_w2.sv:447-449). Selecting it is an elaboration
            // error, never silently different hardware; restoring it is a lever (PLAN.md §6), not a cleanup.
            C7_REMOVED_BRANCH__lutgemm_lane_w2__g_fold_dsp u_c7_removed ();
        end else begin : g_fold_fab
            // product in the DSP, 48-b accumulate in fabric (E3: avoid the 2nd DSP)
            (* keep = "true" *)    wire signed [RES_WIDTH-1:0] fold_prod = $signed(g_total_w) * $signed(scale_now);
            (* use_dsp = "no" *)   wire signed [RES_WIDTH-1:0] fold_sum  = sacc_s + fold_prod;
            assign scaled_next_w = last_now ? fold_sum : sacc_s;
        end
        wire col_end = csa_out_valid && lcol_now;
        always_ff @(posedge clk) begin
            if (!rst_n) begin
                acc_s <= '0; gacc_s <= '0; sacc_s <= '0;
            end else if (csa_out_valid) begin
                gacc_s <= last_now ? '0 : g_total_w;          // lcol pair is always last-in-group
                if (col_end && !RED_SLIMCLR) begin acc_s <= '0; sacc_s <= '0; end
                else begin acc_s <= acc_next; sacc_s <= scaled_next_w; end
            end
        end
        assign cap_ev  = col_end;
        assign acc_cap = acc_next;
        assign res_cap = scaled_next_w;
    end
    endgenerate

    always_ff @(posedge clk) begin
        if (!rst_n) begin
            acc_out <= '0; result_q <= '0; done <= 1'b0;
        end else begin
            done <= cap_ev;
            if (cap_ev) begin acc_out <= acc_cap; result_q <= res_cap; end
        end
    end

    // ----------------------------------------------------------------
    // err_short: (a) S_DRAIN timeout exit with a short count; (b) SEQ_CHK pair
    // sequence: each output's issue pair index must equal the per-column count.
    // ----------------------------------------------------------------
    // outs_recvd is exact only for a column accepted from IDLE: a chained (TILE_PIPE)
    // accept resets it while the previous column's outputs are still in flight.
    reg chained_q;
    always_ff @(posedge clk) begin
        if (!rst_n)          chained_q <= 1'b0;
        else if (col_accept) chained_q <= !state_is_idle;
    end
    wire drain_short = (state == S_DRAIN) && !chained_q && (outs_recvd != np_eff)
                    && (drain_count >= CSA_LAT + 2);
    wire seq_bad;
    generate
    if (SEQ_CHK) begin : g_seq
        logic [PW-1:0] pidx_sr [0:CSA_LAT-1];
        logic [PW-1:0] seq_cnt;
        always_ff @(posedge clk) begin
            if (!rst_n) begin
                for (int t = 0; t < CSA_LAT; t++) pidx_sr[t] <= '0;
                seq_cnt <= '0;
            end else begin
                pidx_sr[0] <= PW'(even_issue >> 1);
                for (int t = 1; t < CSA_LAT; t++) pidx_sr[t] <= pidx_sr[t-1];
                if (csa_out_valid) seq_cnt <= lcol_now ? '0 : (seq_cnt + 1'b1);
            end
        end
        assign seq_bad = csa_out_valid && (pidx_sr[CSA_LAT-1] != seq_cnt);
    end else begin : g_noseq
        assign seq_bad = 1'b0;
    end
    endgenerate
    always_ff @(posedge clk) begin
        if (!rst_n)                        err_short <= 1'b0;
        else if (drain_short || seq_bad)   err_short <= 1'b1;
    end

endmodule
`default_nettype wire
```
