Upload 4 files

gguf_format.h

@@ -168,6 +168,31 @@ typedef struct {
 
 /* sizeof(BlockIQ1S) = 2 + 32 + 16 = 50 bytes for 256 weights */
 
+/* IQ2_XS BLOCK (2.3125 bpw). Layout matches ggml block_iq2_xs:
+ * d(fp16) + qs[32] (per 8 weights: 9-bit codeword index | 7 sign bits << 9)
+ * + scales[8] (4-bit per 16-weight sub-block, low nibble first).
+ * Dequant: y_j = d * (ls + 0.5) * 0.25 * grid[j] * sign_j,  grid ∈ {8,25,43}. */
+typedef struct {
+    uint16_t d;
+    uint16_t qs[QK_K/8];
+    uint8_t  scales[QK_K/32];
+} BlockIQ2XS;
+
+/* sizeof(BlockIQ2XS) = 2 + 64 + 8 = 74 bytes for 256 weights */
+
+/* IQ2_S BLOCK (2.5625 bpw). Layout matches ggml block_iq2_s:
+ * qs[0..31] low 8 bits of the 1024-codeword index per 8 weights,
+ * qs[32..63] full 8 sign bits per group, qh[8] two high index bits per
+ * group (2 bits × 4 groups per byte), scales[8] as IQ2_XS. */
+typedef struct {
+    uint16_t d;
+    uint8_t  qs[QK_K/4];
+    uint8_t  qh[QK_K/32];
+    uint8_t  scales[QK_K/32];
+} BlockIQ2S;
+
+/* sizeof(BlockIQ2S) = 2 + 64 + 8 + 8 = 82 bytes for 256 weights */
+
 /* ═══════════════════════════════════════════════════════════════════════
  * FP16 ←→ FP32 CONVERSION
  *
@@ -688,6 +713,8 @@ static inline int64_t ggml_type_block_size(GGMLType type)
         case GGML_TYPE_Q4_K:  return 256;
         case GGML_TYPE_Q5_K:  return 256;
         case GGML_TYPE_Q6_K:  return 256;
+        case GGML_TYPE_IQ2_XS: return QK_K;
+        case GGML_TYPE_IQ2_S:  return QK_K;
         default: return 1;
     }
 }
@@ -702,6 +729,8 @@ static inline int64_t ggml_type_bytes_per_block(GGMLType type)
         case GGML_TYPE_Q2_K:  return sizeof(BlockQ2K);   /* 84 */
         case GGML_TYPE_Q4_0:  return 18;   /* 2 + 16 */
         case GGML_TYPE_Q4_1:  return 20;   /* 2 + 2 + 16 */
+        case GGML_TYPE_IQ2_XS: return sizeof(BlockIQ2XS); /* 74 */
+        case GGML_TYPE_IQ2_S:  return sizeof(BlockIQ2S);  /* 82 */
         default: return 4;
     }
 }

hexstate_quantize.c

@@ -5561,33 +5561,51 @@ write_fail:
 
 #include "iq2xs_grid.h"
 
-#define IQ2XS_NGRID   512
 #define IQ2XS_TOPK    8
 #define IQ2XS_NGROUP  (QK_K / 8)       /* 32 */
 #define IQ2XS_NSUB    (QK_K / 16)      /* 16 */
 
-static float g_iq2xs_gridf[IQ2XS_NGRID][8];
+/* Codebook spec. IQ2_XS: 512 codewords, 7 sign bits + parity (even number
+ * of negatives). IQ2_S: 1024 codewords, 8 free sign bits. Same alphabet
+ * {8,25,43}, same sub-block scale law, so one search serves both. */
+typedef struct {
+    int          ngrid;
+    const float (*g)[8];
+    int          parity;
+    int          block_bytes;
+    const char  *name;
+} IQ2Book;
+
+static float g_iq2xs_gridf[512][8];
+static float g_iq2s_gridf[1024][8];
 static int   g_iq2xs_grid_ready = 0;
+static const IQ2Book g_iq2_book_xs = { 512,  g_iq2xs_gridf, 1, 74, "IQ2_XS" };
+static const IQ2Book g_iq2_book_s  = { 1024, g_iq2s_gridf,  0, 82, "IQ2_S"  };
 
 static void iq2xs_prepare_grid(void)
 {
     if (g_iq2xs_grid_ready) return;
-    for (int k = 0; k < IQ2XS_NGRID; k++)
+    for (int k = 0; k < 512; k++)
         for (int j = 0; j < 8; j++)
             g_iq2xs_gridf[k][j] = (float)((iq2xs_grid[k] >> (8 * j)) & 0xFF);
+    for (int k = 0; k < 1024; k++)
+        for (int j = 0; j < 8; j++)
+            g_iq2s_gridf[k][j] = (float)((iq2s_grid[k] >> (8 * j)) & 0xFF);
     g_iq2xs_grid_ready = 1;
 }
 
+/* Internal code: grid index | signs8 << 16 (all 8 sign bits explicit). */
 typedef struct {
-    uint16_t code;      /* grid | signs7 << 9 */
+    uint32_t code;
     float    sse;       /* Σ w (x − deq)² */
     float    deq[8];
 } IQ2Cand;
 
 /* Top-K codewords for 8 weights at magnitude scale db (db > 0).
- * Sign parity is enforced by the cheapest flip *per codeword*. */
-static int iq2xs_group_candidates(const float *x, const float *w, float db,
-                                  int K, IQ2Cand *out)
+ * For parity codebooks the parity is enforced by the cheapest flip *per
+ * codeword*. */
+static int iq2xs_group_candidates(const IQ2Book *bk, const float *x, const float *w,
+                                  float db, int K, IQ2Cand *out)
 {
     float   ax[8], wa[8];
     uint8_t s = 0; int par = 0;
@@ -5596,9 +5614,10 @@ static int iq2xs_group_candidates(const float *x, const float *w, float db,
         wa[i] = w[i];
         if (x[i] < 0.0f) { s |= (uint8_t)(1u << i); par ^= 1; }
     }
+    if (!bk->parity) par = 0;
     int n = 0;
-    for (int k = 0; k < IQ2XS_NGRID; k++) {
-        const float *g = g_iq2xs_gridf[k];
+    for (int k = 0; k < bk->ngrid; k++) {
+        const float *g = bk->g[k];
         float e0 = 0.0f;
         for (int i = 0; i < 8; i++) {
             float d = ax[i] - db * g[i];
@@ -5628,7 +5647,7 @@ static int iq2xs_group_candidates(const float *x, const float *w, float db,
             while (pos > 0 && out[pos - 1].sse > e) { out[pos] = out[pos - 1]; pos--; }
             uint8_t sf = s;
             if (flips[f] >= 0) sf ^= (uint8_t)(1u << flips[f]);
-            out[pos].code = (uint16_t)(k | ((sf & 127) << 9));
+            out[pos].code = (uint32_t)k | ((uint32_t)sf << 16);
             out[pos].sse  = e;
             for (int i = 0; i < 8; i++)
                 out[pos].deq[i] = db * g[i] * ((sf >> i) & 1 ? -1.0f : 1.0f);
@@ -5638,18 +5657,18 @@ static int iq2xs_group_candidates(const float *x, const float *w, float db,
     return n;
 }
 
-/* Decode one group from its 16-bit code at scale db. */
-static inline void iq2xs_decode_group(uint16_t code, float db, float *deq)
+/* Decode one group from its internal code at scale db. */
+static inline void iq2xs_decode_group(const IQ2Book *bk, uint32_t code, float db, float *deq)
 {
-    const float *g = g_iq2xs_gridf[code & 511];
-    uint8_t signs = ksigns_iq2xs[code >> 9];
+    const float *g = bk->g[code & 0xFFFF];
+    uint8_t signs = (uint8_t)(code >> 16);
     for (int j = 0; j < 8; j++)
         deq[j] = db * g[j] * ((signs >> j) & 1 ? -1.0f : 1.0f);
 }
 
 /* Best codes for a 16-weight sub-block at fixed db; returns weighted SSE. */
-static float iq2xs_sub_pick(const float *x, const float *w, float db,
-                            uint16_t code[2], float deq[16])
+static float iq2xs_sub_pick(const IQ2Book *bk, const float *x, const float *w, float db,
+                            uint32_t code[2], float deq[16])
 {
     if (db <= 0.0f) {
         code[0] = code[1] = 0;
@@ -5660,7 +5679,7 @@ static float iq2xs_sub_pick(const float *x, const float *w, float db,
     IQ2Cand c;
     float e = 0.0f;
     for (int k = 0; k < 2; k++) {
-        iq2xs_group_candidates(x + 8 * k, w + 8 * k, db, 1, &c);
+        iq2xs_group_candidates(bk, x + 8 * k, w + 8 * k, db, 1, &c);
         code[k] = c.code;
         memcpy(deq + 8 * k, c.deq, sizeof(c.deq));
         e += c.sse;
@@ -5669,18 +5688,18 @@ static float iq2xs_sub_pick(const float *x, const float *w, float db,
 }
 
 /* Float scale search for one sub-block: candidate db grid + LS refit. */
-static float iq2xs_sub_fit(const float *x, const float *w, float *db_out)
+static float iq2xs_sub_fit(const IQ2Book *bk, const float *x, const float *w, float *db_out)
 {
     float amax = 0.0f;
     for (int i = 0; i < 16; i++) amax = fmaxf(amax, fabsf(x[i]));
     if (amax < 1e-12f) { *db_out = 0.0f; return 0.0f; }
 
     float best_e = 1e30f, best_db = amax / 43.0f;
-    uint16_t code[2]; float deq[16];
+    uint32_t code[2]; float deq[16];
     for (int is = -10; is <= 10; is++) {
         /* amax lands on grid value 43·(1+0.035·is): includes clipped maxima */
         float db = amax / (43.0f * (1.0f + 0.035f * (float)is));
-        float e  = iq2xs_sub_pick(x, w, db, code, deq);
+        float e  = iq2xs_sub_pick(bk, x, w, db, code, deq);
         /* LS refit of db with codes fixed: deq = db·ĝ */
         double num = 0.0, den = 0.0;
         for (int i = 0; i < 16; i++) {
@@ -5690,7 +5709,7 @@ static float iq2xs_sub_fit(const float *x, const float *w, float *db_out)
         }
         if (den > 0.0 && num > 0.0) {
             float db2 = (float)(num / den);
-            float e2  = iq2xs_sub_pick(x, w, db2, code, deq);
+            float e2  = iq2xs_sub_pick(bk, x, w, db2, code, deq);
             if (e2 < e) { e = e2; db = db2; }
         }
         if (e < best_e) { best_e = e; best_db = db; }
@@ -5701,32 +5720,59 @@ static float iq2xs_sub_fit(const float *x, const float *w, float *db_out)
 
 /* Whole-block encode at a given d: ls from float sub-scales, re-pick codes.
  * Returns weighted SSE. */
-static float iq2xs_block_at_d(const float *x, const float *w, float d,
+static inline float iq2xs_sub_db(float d, uint8_t ls)
+{
+    return d * ((float)ls + 0.5f) * 0.25f;
+}
+
+/* HEX_IQ2_EXACT=1: exhaustive ls ∈ 0..15 per sub-block and a dense d scan.
+ * Given d the sub-blocks separate, and given ls the two groups separate and
+ * are already solved exactly, so this is the true optimum of the format for
+ * the weighted-SSE objective — used to measure how far the fast path sits
+ * from the floor. ~40× slower. */
+static int iq2xs_exact_mode(void)
+{
+    static int mode = -1;
+    if (mode < 0) { const char *s = getenv("HEX_IQ2_EXACT"); mode = (s && atoi(s)) ? 1 : 0; }
+    return mode;
+}
+
+static float iq2xs_block_at_d(const IQ2Book *bk, const float *x, const float *w, float d,
                               const float *db_f, uint8_t ls[IQ2XS_NSUB],
-                              uint16_t code[IQ2XS_NGROUP], float deq[QK_K])
+                              uint32_t code[IQ2XS_NGROUP], float deq[QK_K])
 {
     float e = 0.0f;
+    const int exact = iq2xs_exact_mode();
     for (int ib = 0; ib < IQ2XS_NSUB; ib++) {
+        if (exact && d > 0.0f) {
+            float best = 1e30f; uint32_t ct[2]; float dq[16];
+            for (int l = 0; l < 16; l++) {
+                float el = iq2xs_sub_pick(bk, x + 16 * ib, w + 16 * ib,
+                                          iq2xs_sub_db(d, (uint8_t)l), ct, dq);
+                if (el < best) {
+                    best = el; ls[ib] = (uint8_t)l;
+                    code[2*ib] = ct[0]; code[2*ib+1] = ct[1];
+                    memcpy(deq + 16 * ib, dq, sizeof(dq));
+                }
+            }
+            e += best;
+            continue;
+        }
         int l = (d > 0.0f) ? gguf_nearest_int(db_f[ib] * 4.0f / d - 0.5f) : 0;
         if (l < 0) l = 0; if (l > 15) l = 15;
         ls[ib] = (uint8_t)l;
         float db = d * ((float)l + 0.5f) * 0.25f;
-        e += iq2xs_sub_pick(x + 16 * ib, w + 16 * ib, db, code + 2 * ib, deq + 16 * ib);
+        e += iq2xs_sub_pick(bk, x + 16 * ib, w + 16 * ib, db, code + 2 * ib, deq + 16 * ib);
     }
     return e;
 }
 
-static inline float iq2xs_sub_db(float d, uint8_t ls)
-{
-    return d * ((float)ls + 0.5f) * 0.25f;
-}
-
 /* Greedy re-selection among top-K codewords per group on
  *   SSE + (λ_dc/n)(Σe + carry)² + (λ_vw/n) Σ_p (e_p + e_{p+128})²
  * with a block SSE cap. This is the fold-through-codebook step. */
-static void iq2xs_shape_block(const float *x, const float *w, float d,
+static void iq2xs_shape_block(const IQ2Book *bk, const float *x, const float *w, float d,
                               const uint8_t ls[IQ2XS_NSUB],
-                              uint16_t code[IQ2XS_NGROUP], float dc_carry)
+                              uint32_t code[IQ2XS_NGROUP], float dc_carry)
 {
     if (HEX_DC_LAMBDA == 0.0f && HEX_VW_LAMBDA == 0.0f) return;
 
@@ -5740,7 +5786,7 @@ static void iq2xs_shape_block(const float *x, const float *w, float d,
         if (db <= 0.0f) { ncand[g] = 0; cur[g] = -1;
             for (int j = 0; j < 8; j++) { e[8*g+j] = x[8*g+j]; sse += w[8*g+j]*x[8*g+j]*x[8*g+j]; dc += e[8*g+j]; }
             continue; }
-        ncand[g] = iq2xs_group_candidates(x + 8*g, w + 8*g, db, IQ2XS_TOPK, cands[g]);
+        ncand[g] = iq2xs_group_candidates(bk, x + 8*g, w + 8*g, db, IQ2XS_TOPK, cands[g]);
         cur[g] = 0;
         for (int c = 0; c < ncand[g]; c++)
             if (cands[g][c].code == code[g]) { cur[g] = c; break; }
@@ -5795,29 +5841,70 @@ static void iq2xs_shape_block(const float *x, const float *w, float d,
     }
 }
 
-static void iq2xs_pack(BlockIQ2XS *b, float d, const uint8_t ls[IQ2XS_NSUB],
-                       const uint16_t code[IQ2XS_NGROUP])
+/* Pack / unpack to the ggml block layouts. Scales are identical in both;
+ * XS stores idx(9) | signs7(7) per uint16 with the 8th sign as parity,
+ * S stores idx low byte, a separate sign byte, and 2 high idx bits in qh. */
+static void iq2_pack(const IQ2Book *bk, void *blk, float d, const uint8_t ls[IQ2XS_NSUB],
+                     const uint32_t code[IQ2XS_NGROUP])
 {
-    b->d = gguf_fp32_to_fp16(d);
-    for (int ib = 0; ib < IQ2XS_NSUB; ib += 2)
-        b->scales[ib / 2] = (uint8_t)(ls[ib] | (ls[ib + 1] << 4));
-    memcpy(b->qs, code, sizeof(uint16_t) * IQ2XS_NGROUP);
+    if (bk->parity) {
+        BlockIQ2XS *b = (BlockIQ2XS *)blk;
+        b->d = gguf_fp32_to_fp16(d);
+        for (int ib = 0; ib < IQ2XS_NSUB; ib += 2)
+            b->scales[ib / 2] = (uint8_t)(ls[ib] | (ls[ib + 1] << 4));
+        for (int g = 0; g < IQ2XS_NGROUP; g++)
+            b->qs[g] = (uint16_t)((code[g] & 511) | (((code[g] >> 16) & 127) << 9));
+    } else {
+        BlockIQ2S *b = (BlockIQ2S *)blk;
+        b->d = gguf_fp32_to_fp16(d);
+        memset(b->qh, 0, sizeof(b->qh));
+        for (int ib = 0; ib < IQ2XS_NSUB; ib += 2)
+            b->scales[ib / 2] = (uint8_t)(ls[ib] | (ls[ib + 1] << 4));
+        for (int g = 0; g < IQ2XS_NGROUP; g++) {
+            uint32_t idx = code[g] & 1023;
+            b->qs[g]               = (uint8_t)(idx & 0xFF);
+            b->qs[IQ2XS_NGROUP + g] = (uint8_t)(code[g] >> 16);
+            b->qh[g >> 2] |= (uint8_t)(((idx >> 8) & 3) << (2 * (g & 3)));
+        }
+    }
 }
 
-static void iq2xs_dequant_block(const BlockIQ2XS *b, float *out)
+static float iq2_unpack(const IQ2Book *bk, const void *blk, uint8_t ls[IQ2XS_NSUB],
+                        uint32_t code[IQ2XS_NGROUP])
 {
-    iq2xs_prepare_grid();
-    float d = gguf_fp16_to_fp32(b->d);
-    for (int g = 0; g < IQ2XS_NGROUP; g++) {
-        uint8_t ls = (g & 2) ? (b->scales[g >> 2] >> 4) : (b->scales[g >> 2] & 0xF);
-        iq2xs_decode_group(b->qs[g], iq2xs_sub_db(d, ls), out + 8 * g);
+    if (bk->parity) {
+        const BlockIQ2XS *b = (const BlockIQ2XS *)blk;
+        for (int ib = 0; ib < IQ2XS_NSUB; ib++)
+            ls[ib] = (ib & 1) ? (b->scales[ib >> 1] >> 4) : (b->scales[ib >> 1] & 0xF);
+        for (int g = 0; g < IQ2XS_NGROUP; g++)
+            code[g] = (uint32_t)(b->qs[g] & 511) | ((uint32_t)ksigns_iq2xs[b->qs[g] >> 9] << 16);
+        return gguf_fp16_to_fp32(b->d);
+    } else {
+        const BlockIQ2S *b = (const BlockIQ2S *)blk;
+        for (int ib = 0; ib < IQ2XS_NSUB; ib++)
+            ls[ib] = (ib & 1) ? (b->scales[ib >> 1] >> 4) : (b->scales[ib >> 1] & 0xF);
+        for (int g = 0; g < IQ2XS_NGROUP; g++) {
+            uint32_t idx = (uint32_t)b->qs[g] | ((((uint32_t)b->qh[g >> 2] >> (2 * (g & 3))) & 3) << 8);
+            code[g] = idx | ((uint32_t)b->qs[IQ2XS_NGROUP + g] << 16);
+        }
+        return gguf_fp16_to_fp32(b->d);
     }
 }
 
-static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
-                                       BlockIQ2XS *output, float *out_total_error,
-                                       const float *imat_importance, int verbose,
-                                       int64_t row_width)
+static void iq2_dequant_block(const IQ2Book *bk, const void *blk, float *out)
+{
+    iq2xs_prepare_grid();
+    uint8_t ls[IQ2XS_NSUB]; uint32_t code[IQ2XS_NGROUP];
+    float d = iq2_unpack(bk, blk, ls, code);
+    for (int g = 0; g < IQ2XS_NGROUP; g++)
+        iq2xs_decode_group(bk, code[g], iq2xs_sub_db(d, ls[g >> 1]), out + 8 * g);
+}
+
+static void quantize_tensor_iq2_hpc(const IQ2Book *bk,
+                                    const float *weights, int64_t n_elements,
+                                    uint8_t *output, float *out_total_error,
+                                    const float *imat_importance, int verbose,
+                                    int64_t row_width)
 {
     if (!weights || !output || n_elements <= 0 || n_elements % QK_K != 0) {
         if (out_total_error) *out_total_error = -1.0f;
@@ -5825,6 +5912,7 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
     }
     iq2xs_prepare_grid();
     const int64_t n_blocks = n_elements / QK_K;
+    const int     BB = bk->block_bytes;
     static const float d_mult[] = { 1.0f, 0.97f, 1.03f, 0.94f, 1.06f, 0.90f, 1.10f, 0.85f, 1.15f };
     const int n_dm = (int)(sizeof(d_mult) / sizeof(d_mult[0]));
 
@@ -5853,21 +5941,24 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
         /* 1. float sub-block scales */
         float db_f[IQ2XS_NSUB], db_max = 0.0f;
         for (int ib = 0; ib < IQ2XS_NSUB; ib++) {
-            iq2xs_sub_fit(x + 16 * ib, w + 16 * ib, &db_f[ib]);
+            iq2xs_sub_fit(bk, x + 16 * ib, w + 16 * ib, &db_f[ib]);
             db_max = fmaxf(db_max, db_f[ib]);
         }
-        if (db_max <= 0.0f) { memset(&output[blk], 0, sizeof(BlockIQ2XS)); continue; }
+        if (db_max <= 0.0f) { memset(output + blk * BB, 0, (size_t)BB); continue; }
 
         /* 2. d candidate search (fp16-exact), codes re-picked at quantised db */
         float    d0 = db_max * 4.0f / 15.5f;
         float    best_e = 1e30f, best_d = d0;
         uint8_t  ls[IQ2XS_NSUB], ls_t[IQ2XS_NSUB];
-        uint16_t code[IQ2XS_NGROUP], code_t[IQ2XS_NGROUP];
+        uint32_t code[IQ2XS_NGROUP], code_t[IQ2XS_NGROUP];
         float    deq[QK_K];
-        for (int c = 0; c < n_dm; c++) {
-            float d = gguf_fp16_to_fp32(gguf_fp32_to_fp16(d0 * d_mult[c]));
+        const int exact = iq2xs_exact_mode();
+        const int n_dc  = exact ? 61 : n_dm;          /* exact: d0·[0.70..1.30] step 0.01 */
+        for (int c = 0; c < n_dc; c++) {
+            float mult = exact ? (0.70f + 0.01f * (float)c) : d_mult[c];
+            float d = gguf_fp16_to_fp32(gguf_fp32_to_fp16(d0 * mult));
             if (d <= 0.0f) continue;
-            float e = iq2xs_block_at_d(x, w, d, db_f, ls_t, code_t, deq);
+            float e = iq2xs_block_at_d(bk, x, w, d, db_f, ls_t, code_t, deq);
             if (e < best_e) { best_e = e; best_d = d;
                 memcpy(ls, ls_t, sizeof(ls)); memcpy(code, code_t, sizeof(code)); }
         }
@@ -5875,7 +5966,7 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
         /* 3. per-sub-block ls ±1 coordinate descent at fixed d */
         float sub_e[IQ2XS_NSUB];
         for (int ib = 0; ib < IQ2XS_NSUB; ib++)
-            sub_e[ib] = iq2xs_sub_pick(x + 16*ib, w + 16*ib, iq2xs_sub_db(best_d, ls[ib]),
+            sub_e[ib] = iq2xs_sub_pick(bk, x + 16*ib, w + 16*ib, iq2xs_sub_db(best_d, ls[ib]),
                                        code + 2*ib, deq + 16*ib);
         for (int it = 0; it < 3; it++) {
             int moved = 0;
@@ -5883,8 +5974,8 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
                 for (int dl = -1; dl <= 1; dl += 2) {
                     int l = (int)ls[ib] + dl;
                     if (l < 0 || l > 15) continue;
-                    uint16_t ct[2]; float dq[16];
-                    float e = iq2xs_sub_pick(x + 16*ib, w + 16*ib,
+                    uint32_t ct[2]; float dq[16];
+                    float e = iq2xs_sub_pick(bk, x + 16*ib, w + 16*ib,
                                              iq2xs_sub_db(best_d, (uint8_t)l), ct, dq);
                     if (e < sub_e[ib]) {
                         sub_e[ib] = e; ls[ib] = (uint8_t)l;
@@ -5899,24 +5990,24 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
 
         /* 4. fold/DC shaping among near-equivalent codewords (carry = 0 here;
          *    the sequential pass below applies the true residual carry). */
-        iq2xs_shape_block(x, w, best_d, ls, code, 0.0f);
+        iq2xs_shape_block(bk, x, w, best_d, ls, code, 0.0f);
 
         float d_out = best_d;
         if (inflate != 0.0f)
             d_out = gguf_fp16_to_fp32(gguf_fp32_to_fp16(best_d * (1.0f + inflate)));
-        iq2xs_pack(&output[blk], d_out, ls, code);
+        iq2_pack(bk, output + blk * BB, d_out, ls, code);
     }
 
     /* 5. sequential TRUE residual carry along each row */
     if (HEX_DC_LAMBDA > 0.0f && g_hex_dc_decay > 0.0f) {
         int64_t bpr = (row_width > 0 && row_width % QK_K == 0) ? row_width / QK_K : 0;
         float rolling = 0.0f, w[QK_K], deq[QK_K];
-        uint8_t ls[IQ2XS_NSUB]; uint16_t code[IQ2XS_NGROUP];
+        uint8_t ls[IQ2XS_NSUB]; uint32_t code[IQ2XS_NGROUP];
         for (int64_t blk = 0; blk < n_blocks; blk++) {
             if (bpr > 0 && (blk % bpr) == 0) rolling = 0.0f;
             const float *x = weights + blk * QK_K;
-            BlockIQ2XS *b = &output[blk];
-            float d = gguf_fp16_to_fp32(b->d);
+            uint8_t *b = output + blk * BB;
+            float d = iq2_unpack(bk, b, ls, code);
             if (d > 0.0f) {
                 float sigma2 = 0.0f;
                 for (int i = 0; i < QK_K; i++) sigma2 += x[i] * x[i];
@@ -5925,13 +6016,10 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
                     float base = imat_importance ? imat_importance[blk * QK_K + i] : 1.0f;
                     w[i] = (wmode == 1) ? base * sqrtf(sigma2 + x[i] * x[i]) : base;
                 }
-                for (int ib = 0; ib < IQ2XS_NSUB; ib++)
-                    ls[ib] = (ib & 1) ? (b->scales[ib >> 1] >> 4) : (b->scales[ib >> 1] & 0xF);
-                memcpy(code, b->qs, sizeof(code));
-                iq2xs_shape_block(x, w, d, ls, code, g_hex_dc_decay * rolling);
-                memcpy(b->qs, code, sizeof(code));
+                iq2xs_shape_block(bk, x, w, d, ls, code, g_hex_dc_decay * rolling);
+                iq2_pack(bk, b, d, ls, code);
             }
-            iq2xs_dequant_block(b, deq);
+            iq2_dequant_block(bk, b, deq);
             float r = 0.0f;
             for (int i = 0; i < QK_K; i++) r += x[i] - deq[i];
             rolling = r;
@@ -5943,13 +6031,13 @@ static void quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_elements,
     #pragma omp parallel for reduction(+:tot)
     for (int64_t blk = 0; blk < n_blocks; blk++) {
         float deq[QK_K];
-        iq2xs_dequant_block(&output[blk], deq);
+        iq2_dequant_block(bk, output + blk * BB, deq);
         const float *x = weights + blk * QK_K;
         for (int i = 0; i < QK_K; i++) { double e = x[i] - deq[i]; tot += e * e; }
     }
     if (out_total_error) *out_total_error = (float)tot;
     if (verbose)
-        printf("  [IQ2_XS·Sieve] blocks=%lld rmse=%.4e\n", (long long)n_blocks,
+        printf("  [%s·Sieve] blocks=%lld rmse=%.4e\n", bk->name, (long long)n_blocks,
                sqrt(tot / (double)n_elements));
 }
 
@@ -6069,15 +6157,35 @@ void hexstate_quantize_tensor_iq2_xs_hpc(const float *weights, int64_t n_element
                                          int64_t row_width)
 {
     hexstate_init();
-    quantize_tensor_iq2_xs_hpc(weights, n_elements, (BlockIQ2XS *)output,
-                               out_error, imat_importance, verbose, row_width);
+    quantize_tensor_iq2_hpc(&g_iq2_book_xs, weights, n_elements, (uint8_t *)output,
+                            out_error, imat_importance, verbose, row_width);
 }
 
 void hexstate_dequant_iq2_xs(const void *blocks, int64_t n_blocks, float *out)
 {
-    const BlockIQ2XS *b = (const BlockIQ2XS *)blocks;
+    const uint8_t *b = (const uint8_t *)blocks;
+    for (int64_t i = 0; i < n_blocks; i++)
+        iq2_dequant_block(&g_iq2_book_xs, b + i * sizeof(BlockIQ2XS), out + i * QK_K);
+}
+
+/* IQ2_S (82 bytes / 256 weights): 1024 codewords, 8 free sign bits. */
+int hexstate_iq2s_block_bytes(void) { return (int)sizeof(BlockIQ2S); }
+
+void hexstate_quantize_tensor_iq2_s_hpc(const float *weights, int64_t n_elements,
+                                        void *output, float *out_error,
+                                        const float *imat_importance, int verbose,
+                                        int64_t row_width)
+{
+    hexstate_init();
+    quantize_tensor_iq2_hpc(&g_iq2_book_s, weights, n_elements, (uint8_t *)output,
+                            out_error, imat_importance, verbose, row_width);
+}
+
+void hexstate_dequant_iq2_s(const void *blocks, int64_t n_blocks, float *out)
+{
+    const uint8_t *b = (const uint8_t *)blocks;
     for (int64_t i = 0; i < n_blocks; i++)
-        iq2xs_dequant_block(&b[i], out + i * QK_K);
+        iq2_dequant_block(&g_iq2_book_s, b + i * sizeof(BlockIQ2S), out + i * QK_K);
 }
 
 #ifndef HEXSTATE_LIBRARY

hexstate_requantize.py

@@ -118,10 +118,13 @@ def _load_hexstate_lib():
             lib.hexstate_set_sse_budget.restype = None
             lib.hexstate_set_sse_budget.argtypes = [ctypes.c_float]
 
-        # IQ2_XS (E8 codebook) quantizer + dequant
-        if hasattr(lib, 'hexstate_quantize_tensor_iq2_xs_hpc'):
-            lib.hexstate_quantize_tensor_iq2_xs_hpc.restype = None
-            lib.hexstate_quantize_tensor_iq2_xs_hpc.argtypes = [
+        # IQ2_XS / IQ2_S (E8 codebook) quantizers + dequant
+        for suffix in ('iq2_xs', 'iq2_s'):
+            qfn = f'hexstate_quantize_tensor_{suffix}_hpc'
+            if not hasattr(lib, qfn):
+                continue
+            getattr(lib, qfn).restype = None
+            getattr(lib, qfn).argtypes = [
                 ctypes.POINTER(ctypes.c_float),  # weights
                 ctypes.c_int64,                   # n_elements
                 ctypes.c_void_p,                  # output
@@ -130,9 +133,9 @@ def _load_hexstate_lib():
                 ctypes.c_int,                     # verbose
                 ctypes.c_int64,                   # row_width
             ]
-            lib.hexstate_dequant_iq2_xs.restype = None
-            lib.hexstate_dequant_iq2_xs.argtypes = [
-                ctypes.c_void_p, ctypes.c_int64, ctypes.POINTER(ctypes.c_float)]
+            dfn = getattr(lib, f'hexstate_dequant_{suffix}')
+            dfn.restype = None
+            dfn.argtypes = [ctypes.c_void_p, ctypes.c_int64, ctypes.POINTER(ctypes.c_float)]
 
         lib.hexstate_init()
         dc_l = os.environ.get('HEX_DC_LAMBDA')
@@ -148,7 +151,7 @@ def _load_hexstate_lib():
         # IQ2_XS has no per-sub-block offset, so cancelling DC means swapping
         # codewords — it needs ~2e-2 (≈ +0.2% RMSE) to be effective.
         budget = os.environ.get('HEX_SSE_BUDGET')
-        if budget is None and LOWBIT_FORMAT == 'iq2xs':
+        if budget is None and LOWBIT_FORMAT in ('iq2xs', 'iq2s', 'auto'):
             budget = '0.02'
         if budget is not None and hasattr(lib, 'hexstate_set_sse_budget'):
             lib.hexstate_set_sse_budget(ctypes.c_float(float(budget)))
@@ -349,30 +352,44 @@ GGML_TYPE_Q4_0  = 2
 GGML_TYPE_Q8_0  = 8
 GGML_TYPE_Q2_K  = 10
 GGML_TYPE_IQ2_XS = 17
+GGML_TYPE_IQ2_S  = 22
 GGML_TYPE_BF16  = 30
 
 IQ2_XS_BLOCK_BYTES = 74   # d(fp16) + 32×u16 codes + 8 scale bytes
-
-# Low-bit target for the "Q2_K plan" tensors: 'q2k' (default) or 'iq2xs'
-# (--iq2xs: E8 codebook, 2.3125 bpw, native llama.cpp decode).
+IQ2_S_BLOCK_BYTES  = 82   # d(fp16) + 32 idx + 32 sign bytes + 8 qh + 8 scales
+
+# Low-bit target for the "Q2_K plan" tensors:
+#   'q2k'   (default)  Q2_K, 2.625 bpw
+#   'iq2xs' (--iq2xs)  IQ2_XS E8 codebook, 2.3125 bpw
+#   'iq2s'  (--iq2s)   IQ2_S  E8 codebook, 2.5625 bpw
+#   'auto'  (--iq2auto) per tensor: IQ2_S where its imatrix-weighted RMSE on a
+#           row sample beats Q2_K (Gaussian-ish tensors), Q2_K where the
+#           weights are outlier-heavy and Q2_K's min/scale offset wins.
 LOWBIT_FORMAT = 'q2k'
 
+# kind -> (ggml type, block bytes, display name, LLAMA_FTYPE_MOSTLY_*)
+LOWBIT_KINDS = {
+    'q2k':   (GGML_TYPE_Q2_K,   84,                 'Q2_K',   10),
+    'iq2xs': (GGML_TYPE_IQ2_XS, IQ2_XS_BLOCK_BYTES, 'IQ2_XS', 20),
+    'iq2s':  (GGML_TYPE_IQ2_S,  IQ2_S_BLOCK_BYTES,  'IQ2_S',  28),
+}
+
 TYPE_NAME = {
     0: "F32", 1: "F16", 2: "Q4_0", 3: "Q4_1", 6: "Q5_0", 7: "Q5_1",
     8: "Q8_0", 9: "Q8_1", 10: "Q2_K", 11: "Q3_K", 12: "Q4_K",
-    13: "Q5_K", 14: "Q6_K", 15: "Q8_K", 17: "IQ2_XS", 30: "BF16",
+    13: "Q5_K", 14: "Q6_K", 15: "Q8_K", 17: "IQ2_XS", 22: "IQ2_S", 30: "BF16",
 }
 
 # Block sizes and byte sizes for each type
 TYPE_BLOCK_SIZE = {
     0: 1, 1: 1, 2: 32, 3: 32, 6: 32, 7: 32,
     8: 32, 9: 32, 10: 256, 11: 256, 12: 256,
-    13: 256, 14: 256, 15: 256, 17: 256, 30: 1,
+    13: 256, 14: 256, 15: 256, 17: 256, 22: 256, 30: 1,
 }
 TYPE_BLOCK_BYTES = {
     0: 4, 1: 2, 2: 18, 3: 20, 6: 20, 7: 22,
     8: 34, 9: 36, 10: 84, 11: 110, 12: 144,
-    13: 176, 14: 210, 15: 292, 17: IQ2_XS_BLOCK_BYTES, 30: 2,
+    13: 176, 14: 210, 15: 292, 17: IQ2_XS_BLOCK_BYTES, 22: IQ2_S_BLOCK_BYTES, 30: 2,
 }
 
 
@@ -835,25 +852,27 @@ def _copy_bytes(fin, fout, abs_offset, n_bytes):
     return written
 
 
-def quantize_tensor_iq2xs_hpc(f32_data, importance=None, row_width=0):
-    """IQ2_XS (E8 codebook, 74 B / 256 w) via the HPC C library.
+def quantize_tensor_iq2_hpc(f32_data, importance=None, row_width=0, kind='iq2xs'):
+    """IQ2_XS (74 B) or IQ2_S (82 B) per 256 weights via the HPC C library.
     Returns (bytes, n_blocks, dequant_f32)."""
+    suffix = {'iq2xs': 'iq2_xs', 'iq2s': 'iq2_s'}[kind]
+    block_bytes = LOWBIT_KINDS[kind][1]
     lib = _load_hexstate_lib()
-    if lib is None or not hasattr(lib, 'hexstate_quantize_tensor_iq2_xs_hpc'):
-        raise RuntimeError('libhexstate_q2k.so lacks IQ2_XS support — rebuild')
+    if lib is None or not hasattr(lib, f'hexstate_quantize_tensor_{suffix}_hpc'):
+        raise RuntimeError(f'libhexstate_q2k.so lacks {LOWBIT_KINDS[kind][2]} support — rebuild')
     f32 = np.ascontiguousarray(f32_data, dtype=np.float32).reshape(-1)
     n = int(f32.size)
     if n % QK_K != 0:
-        raise ValueError(f'IQ2_XS needs a multiple of {QK_K} elements, got {n}')
+        raise ValueError(f'{LOWBIT_KINDS[kind][2]} needs a multiple of {QK_K} elements, got {n}')
     n_blocks = n // QK_K
-    out = np.zeros(n_blocks * IQ2_XS_BLOCK_BYTES, dtype=np.uint8)
+    out = np.zeros(n_blocks * block_bytes, dtype=np.uint8)
     err = ctypes.c_float(0.0)
     imat_ptr = None
     if importance is not None:
         imat_c = np.ascontiguousarray(importance, dtype=np.float32).reshape(-1)
         if imat_c.size == n:
             imat_ptr = imat_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
-    lib.hexstate_quantize_tensor_iq2_xs_hpc(
+    getattr(lib, f'hexstate_quantize_tensor_{suffix}_hpc')(
         f32.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
         ctypes.c_int64(n),
         out.ctypes.data_as(ctypes.c_void_p),
@@ -863,12 +882,68 @@ def quantize_tensor_iq2xs_hpc(f32_data, importance=None, row_width=0):
         ctypes.c_int64(int(row_width)),
     )
     deq = np.zeros(n, dtype=np.float32)
-    lib.hexstate_dequant_iq2_xs(
+    getattr(lib, f'hexstate_dequant_{suffix}')(
         out.ctypes.data_as(ctypes.c_void_p), ctypes.c_int64(n_blocks),
         deq.ctypes.data_as(ctypes.POINTER(ctypes.c_float)))
     return out.tobytes(), n_blocks, deq
 
 
+def quantize_tensor_iq2xs_hpc(f32_data, importance=None, row_width=0):
+    return quantize_tensor_iq2_hpc(f32_data, importance, row_width, 'iq2xs')
+
+
+def _lowbit_dequant(kind, qbytes, n_blocks, n):
+    """Dequantize a low-bit payload of any supported kind to f32[n]."""
+    if kind == 'q2k':
+        return dequant_q2k_fast(qbytes, n_blocks)[:n]
+    lib = _load_hexstate_lib()
+    suffix = {'iq2xs': 'iq2_xs', 'iq2s': 'iq2_s'}[kind]
+    buf = np.frombuffer(qbytes, dtype=np.uint8)
+    deq = np.zeros(n_blocks * QK_K, dtype=np.float32)
+    getattr(lib, f'hexstate_dequant_{suffix}')(
+        buf.ctypes.data_as(ctypes.c_void_p), ctypes.c_int64(n_blocks),
+        deq.ctypes.data_as(ctypes.POINTER(ctypes.c_float)))
+    return deq[:n]
+
+
+def auto_select_lowbit(fin, ti, abs_offset, imatrix_data, n_sample_rows=32,
+                       margin=None):
+    """Pick 'iq2s' or 'q2k' for one tensor from a row sample.
+
+    Encodes evenly spaced rows both ways and compares imatrix-weighted RMSE
+    (the quantity that tracked PPL in the splice A/Bs). IQ2_S is 2.4%
+    smaller, so it wins ties; HEX_AUTO_MARGIN (default 0) lets it win while
+    up to that relative fraction *worse* if you want to bias toward size.
+    Returns (kind, wrmse_q2k, wrmse_iq2s).
+    """
+    if margin is None:
+        margin = float(os.environ.get('HEX_AUTO_MARGIN', '0'))
+    d0 = int(ti['dims'][0])
+    n_rows = int(ti['n_elements']) // d0
+    k = min(n_sample_rows, n_rows)
+    rows = np.unique(np.linspace(0, n_rows - 1, k).astype(np.int64))
+    parts, imps = [], []
+    for r in rows:
+        parts.append(_load_rows_f32(fin, abs_offset, ti['type'], d0, int(r), int(r) + 1))
+        imps.append(_imat_chunk(ti, imatrix_data, int(r), int(r) + 1, d0))
+    X = np.concatenate(parts).astype(np.float32)
+    W = np.concatenate(imps).astype(np.float32) if imps[0] is not None else np.ones_like(X)
+    if W.size != X.size:
+        W = np.ones_like(X)
+    n = X.size
+    qb, nb = quantize_tensor_q2k_hpc(X, opt_mode=2, importance=W if imps[0] is not None else None,
+                                     row_width=d0)
+    e_q = _lowbit_dequant('q2k', qb, nb, n) - X
+    sb, nb2, deq_s = quantize_tensor_iq2_hpc(X, importance=W if imps[0] is not None else None,
+                                             row_width=d0, kind='iq2s')
+    e_s = deq_s[:n] - X
+    den = float(np.sum(W * X * X)) or 1.0
+    wr_q = float(np.sqrt(np.sum(W * e_q * e_q) / den))
+    wr_s = float(np.sqrt(np.sum(W * e_s * e_s) / den))
+    kind = 'iq2s' if wr_s <= wr_q * (1.0 + margin) else 'q2k'
+    return kind, wr_q, wr_s
+
+
 def _stream_quantize(fin, fout, ti, abs_offset, kind, imatrix_data, use_hpc):
     """Quantize one tensor in row chunks. kind: 'q2k' | 'iq2xs' | 'q4' | 'q8'.
     Returns (n_out_bytes, rmse_or_None, sigma_or_None).
@@ -883,7 +958,7 @@ def _stream_quantize(fin, fout, ti, abs_offset, kind, imatrix_data, use_hpc):
 
     d0 = int(ti['dims'][0])
     n_rows = int(ti['n_elements']) // d0
-    align = QK_K if kind in ('q2k', 'iq2xs') else 32
+    align = QK_K if kind in ('q2k', 'iq2xs', 'iq2s') else 32
     if d0 % align != 0:
         raise ValueError(f'{ti["name"]} dim0={d0} not aligned to {align}')
 
@@ -901,9 +976,9 @@ def _stream_quantize(fin, fout, ti, abs_offset, kind, imatrix_data, use_hpc):
         total_ss += float(np.vdot(f32, f32))
         total_n += n_valid
 
-        if kind == 'iq2xs':
-            qbytes, n_blocks, deq = quantize_tensor_iq2xs_hpc(
-                f32, importance=imp, row_width=d0)
+        if kind in ('iq2xs', 'iq2s'):
+            qbytes, n_blocks, deq = quantize_tensor_iq2_hpc(
+                f32, importance=imp, row_width=d0, kind=kind)
             fout.write(qbytes)
             written += len(qbytes)
             diff = f32.reshape(-1)[:n_valid] - deq[:n_valid]
@@ -1074,13 +1149,18 @@ def should_quantize(name, n_dims, dims, tied_embeddings=False):
 def main():
     if len(sys.argv) < 3:
         print("Usage: python3 hexstate_requantize.py <input.gguf> <output.gguf>"
-              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all] [--iq2xs]")
+              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all]"
+              " [--iq2xs | --iq2s | --iq2auto]")
         print("  --iq2xs          low-bit tensors → IQ2_XS (E8 codebook, 2.3125 bpw) instead of Q2_K")
+        print("  --iq2s           low-bit tensors → IQ2_S  (E8 codebook, 2.5625 bpw) instead of Q2_K")
+        print("  --iq2auto        per tensor: IQ2_S or Q2_K, whichever has lower imatrix-weighted")
+        print("                   RMSE on a row sample (IQ2_S wins Gaussian-ish tensors, Q2_K wins")
+        print("                   outlier-heavy ones). HEX_AUTO_MARGIN biases toward IQ2_S.")
         print("  HEX_CHUNK_ELEMS  max f32 elements per tensor chunk (default 2000000)")
         print("  HEX_DC_LAMBDA    DC residual weight (default 1)")
         print("  HEX_VW_LAMBDA    vesica weight (default 1)")
         print("  HEX_DC_DECAY     rolling residual carry 0..1 (default 0.85)")
-        print("  HEX_SSE_BUDGET   relative SSE the shaper may spend (Q2_K 5e-4, IQ2_XS 2e-2)")
+        print("  HEX_SSE_BUDGET   relative SSE the shaper may spend (Q2_K 5e-4, IQ2 2e-2)")
         sys.exit(1)
 
     global LOWBIT_FORMAT
@@ -1092,11 +1172,17 @@ def main():
     keep_embd = '--keep-embd' in sys.argv   # keep tied embedding at source precision instead of Q8_0
     if '--iq2xs' in sys.argv:
         LOWBIT_FORMAT = 'iq2xs'
-    lowbit_kind = LOWBIT_FORMAT                       # 'q2k' | 'iq2xs'
-    lowbit_name = 'IQ2_XS' if lowbit_kind == 'iq2xs' else 'Q2_K'
-    lowbit_type = GGML_TYPE_IQ2_XS if lowbit_kind == 'iq2xs' else GGML_TYPE_Q2_K
-    lowbit_bytes = IQ2_XS_BLOCK_BYTES if lowbit_kind == 'iq2xs' else 84
-    lowbit_file_type = 20 if lowbit_kind == 'iq2xs' else 10   # LLAMA_FTYPE_MOSTLY_*
+    elif '--iq2s' in sys.argv:
+        LOWBIT_FORMAT = 'iq2s'
+    elif '--iq2auto' in sys.argv:
+        LOWBIT_FORMAT = 'auto'
+    lowbit_kind = LOWBIT_FORMAT                       # 'q2k' | 'iq2xs' | 'iq2s' | 'auto'
+    lowbit_auto = lowbit_kind == 'auto'
+    # For 'auto' the per-tensor kind is decided at plan time (lowbit_choice);
+    # file-level labels use IQ2_S since that is the intended majority type.
+    _label_kind = 'iq2s' if lowbit_auto else lowbit_kind
+    lowbit_name = 'IQ2_S/Q2_K' if lowbit_auto else LOWBIT_KINDS[_label_kind][2]
+    lowbit_file_type = LOWBIT_KINDS[_label_kind][3]   # LLAMA_FTYPE_MOSTLY_*
 
     # Check for imatrix
     imatrix_data = None
@@ -1112,19 +1198,25 @@ def main():
 
     # Check for HPC C library
     use_hpc = _load_hexstate_lib() is not None
-    if lowbit_kind == 'iq2xs':
+    if lowbit_kind != 'q2k':
         lib = _load_hexstate_lib()
-        if lib is None or not hasattr(lib, 'hexstate_quantize_tensor_iq2_xs_hpc'):
-            print("  ERROR: --iq2xs needs libhexstate_q2k.so with IQ2_XS support "
-                  "(make -f makefile.quantize.c)")
+        need = 'hexstate_quantize_tensor_iq2_xs_hpc' if lowbit_kind == 'iq2xs' \
+            else 'hexstate_quantize_tensor_iq2_s_hpc'
+        if lib is None or not hasattr(lib, need):
+            print(f"  ERROR: --{'iq2auto' if lowbit_auto else lowbit_kind} needs libhexstate_q2k.so "
+                  "with IQ2 support (make -f makefile.quantize.c)")
             sys.exit(1)
 
     print()
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  HExState GGUF Re-Quantizer                                  ║")
-    print(f"  ║  GGUF → {lowbit_name:6s} GGUF with metadata passthrough                ║")
+    print(f"  ║  GGUF → {lowbit_name:10s} GGUF with metadata passthrough            ║")
     if lowbit_kind == 'iq2xs':
         print("  ║  Low-bit: IQ2_XS  E8 codebook · fold/DC shaping · 2.3125 bpw ║")
+    elif lowbit_kind == 'iq2s':
+        print("  ║  Low-bit: IQ2_S   E8 codebook · fold/DC shaping · 2.5625 bpw ║")
+    elif lowbit_auto:
+        print("  ║  Low-bit: AUTO    IQ2_S vs Q2_K per tensor by weighted RMSE  ║")
     if q2all:
         print("  ║  Mode: --q2all  ALL eligible tensors → Q2_K (test mode)      ║")
     if use_hpc and imatrix_data:
@@ -1268,6 +1360,10 @@ def main():
         # ── Compute output tensor sizes and offsets ──
         out_tensor_infos = []
         out_data_offset = 0
+        lowbit_choice = {}      # tensor index -> 'q2k' | 'iq2xs' | 'iq2s'
+        auto_counts = {}
+        if lowbit_auto:
+            print("  Auto-selecting IQ2_S vs Q2_K per tensor (32-row samples)...")
 
         for i, ti in enumerate(tensor_infos):
             if quant_plan[i]:
@@ -1292,9 +1388,18 @@ def main():
                     out_size = n_blocks * 18
                     print(f"  Q4_0: {ti['name']} (dims[0]={dim0})")
                 elif quant_plan[i] is True and q2k_row_compatible(ti['n_dims'], ti['dims']):
-                    out_type = lowbit_type
+                    if lowbit_auto:
+                        kind, wr_q, wr_s = auto_select_lowbit(
+                            fin, ti, data_section_start + ti['offset'], imatrix_data)
+                        auto_counts[kind] = auto_counts.get(kind, 0) + 1
+                        print(f"  [AUTO→{LOWBIT_KINDS[kind][2]:6s}] {ti['name'][:48]:48s} "
+                              f"wRMSE Q2_K={wr_q:.4f}  IQ2_S={wr_s:.4f}")
+                    else:
+                        kind = lowbit_kind
+                    lowbit_choice[i] = kind
+                    out_type = LOWBIT_KINDS[kind][0]
                     n_blocks = ti['n_elements'] // QK_K
-                    out_size = n_blocks * lowbit_bytes
+                    out_size = n_blocks * LOWBIT_KINDS[kind][1]
                 else:
                     out_type = ti['type']
                     out_size = ti['data_size']
@@ -1482,15 +1587,17 @@ def main():
                     total_quant_bytes += nbytes
 
                 elif plan:
+                    kind = lowbit_choice.get(i, 'q2k')
+                    kname = LOWBIT_KINDS[kind][2]
                     nbytes, rmse, sigma = _stream_quantize(
-                        fin, fout, ti, abs_offset, lowbit_kind, imatrix_data, use_hpc)
+                        fin, fout, ti, abs_offset, kind, imatrix_data, use_hpc)
                     if rmse is not None:
                         q2k_rmse_sum += rmse
                         q2k_tensor_count += 1
-                        print(f"\n  [{lowbit_name}] {ti['name'][:50]}  RMSE={rmse:.6e}"
+                        print(f"\n  [{kname}] {ti['name'][:50]}  RMSE={rmse:.6e}"
                               f"  σ={sigma:.4f}  rel={rmse / max(sigma, 1e-30):.4f}")
                     else:
-                        print(f"\n  [{lowbit_name}] {ti['name'][:55]}  RMSE=n/a")
+                        print(f"\n  [{kname}] {ti['name'][:55]}  RMSE=n/a")
                     quant_count += 1
                     total_quant_bytes += nbytes
 
@@ -1516,16 +1623,18 @@ def main():
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  RE-QUANTIZATION SUMMARY                                     ║")
     print("  ╠════════════════════════════════════════════════════════════════╣")
-    print(f"  ║  Tensors quantized ({lowbit_name:6s}): {quant_count:<31d} ║")
+    print(f"  ║  Tensors quantized ({lowbit_name[:10]:10s}): {quant_count:<27d} ║")
+    if lowbit_auto:
+        print(f"  ║  Auto split:  IQ2_S {auto_counts.get('iq2s', 0):<5d} Q2_K {auto_counts.get('q2k', 0):<27d} ║")
     print(f"  ║  Tensors kept as-is:       {total_keep:<33d} ║")
-    print(f"  ║  {lowbit_name:6s} data:       {total_quant_bytes:>12,} bytes ({total_quant_bytes/1024**2:>7.1f} MB) ║")
+    print(f"  ║  {lowbit_name[:10]:10s} data:   {total_quant_bytes:>12,} bytes ({total_quant_bytes/1024**2:>7.1f} MB) ║")
     print(f"  ║  Kept data:         {total_keep_bytes:>12,} bytes ({total_keep_bytes/1024**2:>7.1f} MB) ║")
     print(f"  ║  Original size:     {file_size:>12,} bytes ({file_size/1024**3:>7.2f} GB) ║")
     print(f"  ║  Output size:       {final_size:>12,} bytes ({final_size/1024**3:>7.2f} GB) ║")
     print(f"  ║  Compression:       {compression:>42.1f}x ║")
     if q2k_tensor_count > 0:
         mean_rmse = q2k_rmse_sum / q2k_tensor_count
-        print(f"  ║  Mean {lowbit_name:6s} RMSE:                          {mean_rmse:>12.6e} ║")
+        print(f"  ║  Mean {lowbit_name[:10]:10s} RMSE:                      {mean_rmse:>12.6e} ║")
     print(f"  ║  Total time:        {elapsed:>39.1f} sec ║")
     print("  ╚════════════════════════════════════════════════════════════════╝")
     print()

iq2xs_grid.h

@@ -0,0 +1,410 @@
+/* iq2xs_grid.h — IQ2_XS codebook, copied verbatim from ggml-common.h (MIT).
+ * 512 codewords x 8 bytes; byte j = magnitude {0x08,0x19,0x2b} of weight j.
+ * ksigns_iq2xs[i] = i | (parity(i) << 7): 7 stored sign bits + parity bit. */
+#ifndef IQ2XS_GRID_H
+#define IQ2XS_GRID_H
+#include <stdint.h>
+
+static const uint8_t ksigns_iq2xs[128] = {
+      0, 129, 130,   3, 132,   5,   6, 135, 136,   9,  10, 139,  12, 141, 142,  15,
+    144,  17,  18, 147,  20, 149, 150,  23,  24, 153, 154,  27, 156,  29,  30, 159,
+    160,  33,  34, 163,  36, 165, 166,  39,  40, 169, 170,  43, 172,  45,  46, 175,
+     48, 177, 178,  51, 180,  53,  54, 183, 184,  57,  58, 187,  60, 189, 190,  63,
+    192,  65,  66, 195,  68, 197, 198,  71,  72, 201, 202,  75, 204,  77,  78, 207,
+     80, 209, 210,  83, 212,  85,  86, 215, 216,  89,  90, 219,  92, 221, 222,  95,
+     96, 225, 226,  99, 228, 101, 102, 231, 232, 105, 106, 235, 108, 237, 238, 111,
+    240, 113, 114, 243, 116, 245, 246, 119, 120, 249, 250, 123, 252, 125, 126, 255,
+};
+
+static const uint64_t iq2xs_grid[512] = {
+    0x0808080808080808, 0x080808080808082b, 0x0808080808081919, 0x0808080808082b08,
+    0x0808080808082b2b, 0x0808080808190819, 0x0808080808191908, 0x080808080819192b,
+    0x0808080808192b19, 0x08080808082b0808, 0x08080808082b082b, 0x08080808082b1919,
+    0x08080808082b2b08, 0x0808080819080819, 0x0808080819081908, 0x080808081908192b,
+    0x0808080819082b19, 0x0808080819190808, 0x080808081919082b, 0x0808080819191919,
+    0x0808080819192b08, 0x08080808192b0819, 0x08080808192b1908, 0x080808082b080808,
+    0x080808082b08082b, 0x080808082b081919, 0x080808082b082b08, 0x080808082b190819,
+    0x080808082b191908, 0x080808082b192b19, 0x080808082b2b0808, 0x0808081908080819,
+    0x0808081908081908, 0x080808190808192b, 0x0808081908082b19, 0x0808081908190808,
+    0x080808190819082b, 0x0808081908191919, 0x0808081908192b08, 0x0808081908192b2b,
+    0x08080819082b0819, 0x08080819082b1908, 0x0808081919080808, 0x080808191908082b,
+    0x0808081919081919, 0x0808081919082b08, 0x0808081919190819, 0x0808081919191908,
+    0x08080819192b0808, 0x08080819192b2b08, 0x080808192b080819, 0x080808192b081908,
+    0x080808192b190808, 0x0808082b08080808, 0x0808082b0808082b, 0x0808082b08081919,
+    0x0808082b08082b08, 0x0808082b08190819, 0x0808082b08191908, 0x0808082b082b0808,
+    0x0808082b19080819, 0x0808082b19081908, 0x0808082b19190808, 0x0808082b19191919,
+    0x0808082b2b080808, 0x0808082b2b082b2b, 0x0808190808080819, 0x0808190808081908,
+    0x080819080808192b, 0x0808190808082b19, 0x0808190808190808, 0x080819080819082b,
+    0x0808190808191919, 0x0808190808192b08, 0x08081908082b0819, 0x08081908082b1908,
+    0x0808190819080808, 0x080819081908082b, 0x0808190819081919, 0x0808190819082b08,
+    0x0808190819190819, 0x0808190819191908, 0x080819081919192b, 0x08081908192b0808,
+    0x080819082b080819, 0x080819082b081908, 0x080819082b190808, 0x0808191908080808,
+    0x080819190808082b, 0x0808191908081919, 0x0808191908082b08, 0x0808191908190819,
+    0x0808191908191908, 0x08081919082b0808, 0x0808191919080819, 0x0808191919081908,
+    0x0808191919190808, 0x08081919192b0819, 0x080819192b080808, 0x0808192b08080819,
+    0x0808192b08081908, 0x0808192b08190808, 0x0808192b082b192b, 0x0808192b19080808,
+    0x0808192b1908082b, 0x0808192b2b081908, 0x08082b0808080808, 0x08082b080808082b,
+    0x08082b0808081919, 0x08082b0808082b08, 0x08082b0808082b2b, 0x08082b0808190819,
+    0x08082b0808191908, 0x08082b08082b0808, 0x08082b08082b1919, 0x08082b0819080819,
+    0x08082b0819081908, 0x08082b0819190808, 0x08082b0819192b08, 0x08082b082b080808,
+    0x08082b082b2b0808, 0x08082b082b2b2b2b, 0x08082b1908080819, 0x08082b1908081908,
+    0x08082b1908190808, 0x08082b1919080808, 0x08082b192b080819, 0x08082b192b082b19,
+    0x08082b2b08080808, 0x08082b2b082b0808, 0x08082b2b082b2b08, 0x08082b2b2b19192b,
+    0x08082b2b2b2b0808, 0x0819080808080819, 0x0819080808081908, 0x081908080808192b,
+    0x0819080808082b19, 0x0819080808190808, 0x081908080819082b, 0x0819080808191919,
+    0x0819080808192b08, 0x08190808082b0819, 0x08190808082b1908, 0x0819080819080808,
+    0x081908081908082b, 0x0819080819081919, 0x0819080819082b08, 0x0819080819190819,
+    0x0819080819191908, 0x08190808192b0808, 0x08190808192b2b2b, 0x081908082b080819,
+    0x081908082b081908, 0x081908082b190808, 0x0819081908080808, 0x081908190808082b,
+    0x0819081908081919, 0x0819081908082b08, 0x0819081908190819, 0x0819081908191908,
+    0x08190819082b0808, 0x0819081919080819, 0x0819081919081908, 0x0819081919190808,
+    0x081908192b080808, 0x081908192b191908, 0x081908192b19192b, 0x0819082b08080819,
+    0x0819082b08081908, 0x0819082b0808192b, 0x0819082b08190808, 0x0819082b19080808,
+    0x0819082b192b0808, 0x0819190808080808, 0x081919080808082b, 0x0819190808081919,
+    0x0819190808082b08, 0x0819190808190819, 0x0819190808191908, 0x08191908082b0808,
+    0x0819190819080819, 0x0819190819081908, 0x0819190819082b19, 0x0819190819190808,
+    0x08191908192b1908, 0x081919082b080808, 0x0819191908080819, 0x0819191908081908,
+    0x0819191908190808, 0x0819191919080808, 0x0819192b08080808, 0x0819192b08191908,
+    0x0819192b19082b19, 0x08192b0808080819, 0x08192b0808081908, 0x08192b0808190808,
+    0x08192b080819082b, 0x08192b0819080808, 0x08192b0819191908, 0x08192b082b08192b,
+    0x08192b1908080808, 0x08192b1908081919, 0x08192b19192b192b, 0x08192b2b19190819,
+    0x08192b2b2b2b2b19, 0x082b080808080808, 0x082b08080808082b, 0x082b080808081919,
+    0x082b080808082b08, 0x082b080808082b2b, 0x082b080808190819, 0x082b080808191908,
+    0x082b0808082b0808, 0x082b080819080819, 0x082b080819081908, 0x082b080819190808,
+    0x082b08082b080808, 0x082b08082b2b0808, 0x082b081908080819, 0x082b081908081908,
+    0x082b081908190808, 0x082b081919080808, 0x082b081919082b08, 0x082b0819192b1919,
+    0x082b082b08080808, 0x082b082b082b082b, 0x082b082b2b080808, 0x082b082b2b2b2b08,
+    0x082b190808080819, 0x082b190808081908, 0x082b190808190808, 0x082b1908082b2b19,
+    0x082b190819080808, 0x082b191908080808, 0x082b191919080819, 0x082b19191919082b,
+    0x082b19192b192b19, 0x082b192b08080819, 0x082b192b08192b2b, 0x082b192b2b2b192b,
+    0x082b2b0808080808, 0x082b2b0808082b08, 0x082b2b0808082b2b, 0x082b2b08082b0808,
+    0x082b2b0819191919, 0x082b2b082b082b08, 0x082b2b082b2b082b, 0x082b2b19192b2b08,
+    0x082b2b192b190808, 0x082b2b2b08082b08, 0x082b2b2b082b0808, 0x082b2b2b2b08082b,
+    0x082b2b2b2b082b08, 0x082b2b2b2b082b2b, 0x1908080808080819, 0x1908080808081908,
+    0x190808080808192b, 0x1908080808082b19, 0x1908080808190808, 0x190808080819082b,
+    0x1908080808191919, 0x1908080808192b08, 0x19080808082b0819, 0x19080808082b1908,
+    0x1908080819080808, 0x190808081908082b, 0x1908080819081919, 0x1908080819082b08,
+    0x1908080819082b2b, 0x1908080819190819, 0x1908080819191908, 0x19080808192b0808,
+    0x19080808192b1919, 0x190808082b080819, 0x190808082b081908, 0x190808082b190808,
+    0x1908081908080808, 0x190808190808082b, 0x1908081908081919, 0x1908081908082b08,
+    0x1908081908190819, 0x1908081908191908, 0x19080819082b0808, 0x1908081919080819,
+    0x1908081919081908, 0x1908081919190808, 0x190808192b080808, 0x190808192b081919,
+    0x190808192b2b082b, 0x1908082b08080819, 0x1908082b08081908, 0x1908082b08190808,
+    0x1908082b0819082b, 0x1908082b082b2b19, 0x1908082b19080808, 0x1908190808080808,
+    0x190819080808082b, 0x1908190808081919, 0x1908190808082b08, 0x1908190808190819,
+    0x1908190808191908, 0x1908190808192b19, 0x19081908082b0808, 0x1908190819080819,
+    0x1908190819081908, 0x1908190819190808, 0x190819082b080808, 0x190819082b191908,
+    0x1908191908080819, 0x1908191908081908, 0x1908191908190808, 0x19081919082b1908,
+    0x1908191919080808, 0x190819192b192b2b, 0x1908192b08080808, 0x1908192b08082b2b,
+    0x1908192b19081908, 0x1908192b19190808, 0x19082b0808080819, 0x19082b0808081908,
+    0x19082b0808190808, 0x19082b0819080808, 0x19082b0819081919, 0x19082b0819191908,
+    0x19082b08192b082b, 0x19082b1908080808, 0x19082b1908190819, 0x19082b1919081908,
+    0x19082b1919190808, 0x19082b19192b2b19, 0x19082b2b08081908, 0x1919080808080808,
+    0x191908080808082b, 0x1919080808081919, 0x1919080808082b08, 0x1919080808190819,
+    0x1919080808191908, 0x19190808082b0808, 0x19190808082b2b08, 0x1919080819080819,
+    0x1919080819081908, 0x1919080819190808, 0x191908082b080808, 0x1919081908080819,
+    0x1919081908081908, 0x1919081908190808, 0x1919081908191919, 0x1919081919080808,
+    0x191908191908082b, 0x1919082b08080808, 0x1919082b19081908, 0x1919082b2b2b2b2b,
+    0x1919190808080819, 0x1919190808081908, 0x1919190808190808, 0x19191908082b0819,
+    0x1919190819080808, 0x19191908192b0808, 0x191919082b080819, 0x191919082b2b0819,
+    0x1919191908080808, 0x1919191908082b08, 0x191919192b080808, 0x191919192b082b08,
+    0x1919192b082b0819, 0x1919192b192b2b08, 0x1919192b2b2b0819, 0x19192b0808080808,
+    0x19192b0808191908, 0x19192b0819080819, 0x19192b0819190808, 0x19192b082b192b19,
+    0x19192b1908192b2b, 0x19192b1919080808, 0x19192b191908082b, 0x19192b2b2b081919,
+    0x192b080808080819, 0x192b080808081908, 0x192b080808190808, 0x192b080819080808,
+    0x192b080819191908, 0x192b0808192b082b, 0x192b08082b08192b, 0x192b08082b2b2b19,
+    0x192b081908080808, 0x192b082b082b1908, 0x192b082b19082b2b, 0x192b082b2b19082b,
+    0x192b190808080808, 0x192b19080819192b, 0x192b191908190808, 0x192b191919080808,
+    0x192b191919081919, 0x192b19192b2b1908, 0x192b2b0808080819, 0x192b2b08192b2b2b,
+    0x192b2b19082b1919, 0x192b2b2b0808192b, 0x192b2b2b19191908, 0x192b2b2b192b082b,
+    0x2b08080808080808, 0x2b0808080808082b, 0x2b08080808081919, 0x2b08080808082b08,
+    0x2b08080808190819, 0x2b08080808191908, 0x2b080808082b0808, 0x2b080808082b2b2b,
+    0x2b08080819080819, 0x2b08080819081908, 0x2b08080819190808, 0x2b0808082b080808,
+    0x2b0808082b08082b, 0x2b0808082b2b2b08, 0x2b0808082b2b2b2b, 0x2b08081908080819,
+    0x2b08081908081908, 0x2b0808190808192b, 0x2b08081908190808, 0x2b08081919080808,
+    0x2b08081919190819, 0x2b08081919192b19, 0x2b08082b08080808, 0x2b08082b082b0808,
+    0x2b08082b2b080808, 0x2b08082b2b08082b, 0x2b08082b2b2b0808, 0x2b08082b2b2b2b08,
+    0x2b08190808080819, 0x2b08190808081908, 0x2b08190808190808, 0x2b0819080819082b,
+    0x2b08190808191919, 0x2b08190819080808, 0x2b081908192b0808, 0x2b0819082b082b19,
+    0x2b08191908080808, 0x2b08191919081908, 0x2b0819192b2b1919, 0x2b08192b08192b08,
+    0x2b08192b192b2b2b, 0x2b082b0808080808, 0x2b082b0808082b08, 0x2b082b08082b1919,
+    0x2b082b0819192b2b, 0x2b082b082b080808, 0x2b082b082b08082b, 0x2b082b082b2b2b08,
+    0x2b082b190808192b, 0x2b082b2b082b082b, 0x2b082b2b2b080808, 0x2b082b2b2b082b08,
+    0x2b082b2b2b19192b, 0x2b082b2b2b2b2b08, 0x2b19080808080819, 0x2b19080808081908,
+    0x2b19080808190808, 0x2b19080819080808, 0x2b1908081919192b, 0x2b1908082b081908,
+    0x2b19081908080808, 0x2b190819082b082b, 0x2b190819192b1908, 0x2b19082b1919192b,
+    0x2b19082b2b082b19, 0x2b19190808080808, 0x2b19190808081919, 0x2b19190819081908,
+    0x2b19190819190808, 0x2b19190819192b08, 0x2b191919082b2b19, 0x2b1919192b190808,
+    0x2b1919192b19082b, 0x2b19192b19080819, 0x2b192b0819190819, 0x2b192b082b2b192b,
+    0x2b192b1919082b19, 0x2b192b2b08191919, 0x2b192b2b192b0808, 0x2b2b080808080808,
+    0x2b2b08080808082b, 0x2b2b080808082b08, 0x2b2b080808082b2b, 0x2b2b0808082b0808,
+    0x2b2b0808082b2b2b, 0x2b2b08082b2b0808, 0x2b2b081919190819, 0x2b2b081919192b19,
+    0x2b2b08192b2b192b, 0x2b2b082b08080808, 0x2b2b082b0808082b, 0x2b2b082b08082b08,
+    0x2b2b082b082b2b2b, 0x2b2b082b2b080808, 0x2b2b082b2b2b0808, 0x2b2b190819080808,
+    0x2b2b19082b191919, 0x2b2b192b192b1919, 0x2b2b192b2b192b08, 0x2b2b2b0808082b2b,
+    0x2b2b2b08082b0808, 0x2b2b2b08082b082b, 0x2b2b2b08082b2b08, 0x2b2b2b082b2b0808,
+    0x2b2b2b082b2b2b08, 0x2b2b2b1908081908, 0x2b2b2b192b081908, 0x2b2b2b192b08192b,
+    0x2b2b2b2b082b2b08, 0x2b2b2b2b082b2b2b, 0x2b2b2b2b2b190819, 0x2b2b2b2b2b2b2b2b,
+};
+
+/* IQ2_S codebook (1024 codewords, same alphabet, full 8 sign bits). */
+static const uint64_t iq2s_grid[1024] = {
+    0x0808080808080808, 0x080808080808082b, 0x0808080808081919, 0x0808080808082b08,
+    0x0808080808082b2b, 0x0808080808190819, 0x0808080808191908, 0x080808080819192b,
+    0x0808080808192b19, 0x08080808082b0808, 0x08080808082b082b, 0x08080808082b1919,
+    0x08080808082b2b08, 0x0808080819080819, 0x0808080819081908, 0x080808081908192b,
+    0x0808080819082b19, 0x0808080819190808, 0x080808081919082b, 0x0808080819191919,
+    0x0808080819192b08, 0x08080808192b0819, 0x08080808192b1908, 0x08080808192b192b,
+    0x08080808192b2b19, 0x080808082b080808, 0x080808082b08082b, 0x080808082b081919,
+    0x080808082b082b08, 0x080808082b190819, 0x080808082b191908, 0x080808082b2b0808,
+    0x080808082b2b1919, 0x080808082b2b2b2b, 0x0808081908080819, 0x0808081908081908,
+    0x080808190808192b, 0x0808081908082b19, 0x0808081908190808, 0x080808190819082b,
+    0x0808081908191919, 0x0808081908192b08, 0x08080819082b0819, 0x08080819082b1908,
+    0x0808081919080808, 0x080808191908082b, 0x0808081919081919, 0x0808081919082b08,
+    0x0808081919190819, 0x0808081919191908, 0x080808191919192b, 0x0808081919192b19,
+    0x08080819192b0808, 0x08080819192b1919, 0x08080819192b2b08, 0x080808192b080819,
+    0x080808192b081908, 0x080808192b190808, 0x080808192b19082b, 0x080808192b191919,
+    0x080808192b2b0819, 0x080808192b2b1908, 0x0808082b08080808, 0x0808082b0808082b,
+    0x0808082b08081919, 0x0808082b08082b08, 0x0808082b08190819, 0x0808082b08191908,
+    0x0808082b082b0808, 0x0808082b082b2b2b, 0x0808082b19080819, 0x0808082b19081908,
+    0x0808082b1908192b, 0x0808082b19082b19, 0x0808082b19190808, 0x0808082b19191919,
+    0x0808082b2b080808, 0x0808082b2b081919, 0x0808082b2b082b2b, 0x0808082b2b191908,
+    0x0808082b2b2b082b, 0x0808190808080819, 0x0808190808081908, 0x080819080808192b,
+    0x0808190808082b19, 0x0808190808190808, 0x080819080819082b, 0x0808190808191919,
+    0x0808190808192b08, 0x08081908082b0819, 0x08081908082b1908, 0x08081908082b192b,
+    0x08081908082b2b19, 0x0808190819080808, 0x080819081908082b, 0x0808190819081919,
+    0x0808190819082b08, 0x0808190819082b2b, 0x0808190819190819, 0x0808190819191908,
+    0x080819081919192b, 0x0808190819192b19, 0x08081908192b0808, 0x08081908192b082b,
+    0x08081908192b1919, 0x080819082b080819, 0x080819082b081908, 0x080819082b08192b,
+    0x080819082b082b19, 0x080819082b190808, 0x080819082b191919, 0x080819082b192b08,
+    0x080819082b2b0819, 0x080819082b2b1908, 0x0808191908080808, 0x080819190808082b,
+    0x0808191908081919, 0x0808191908082b08, 0x0808191908082b2b, 0x0808191908190819,
+    0x0808191908191908, 0x080819190819192b, 0x0808191908192b19, 0x08081919082b0808,
+    0x08081919082b1919, 0x08081919082b2b08, 0x0808191919080819, 0x0808191919081908,
+    0x080819191908192b, 0x0808191919082b19, 0x0808191919190808, 0x080819191919082b,
+    0x0808191919191919, 0x0808191919192b08, 0x08081919192b0819, 0x08081919192b1908,
+    0x080819192b080808, 0x080819192b08082b, 0x080819192b081919, 0x080819192b082b08,
+    0x080819192b190819, 0x080819192b191908, 0x080819192b2b0808, 0x0808192b08080819,
+    0x0808192b08081908, 0x0808192b0808192b, 0x0808192b08082b19, 0x0808192b08190808,
+    0x0808192b08191919, 0x0808192b19080808, 0x0808192b19081919, 0x0808192b19082b08,
+    0x0808192b19190819, 0x0808192b19191908, 0x0808192b192b0808, 0x0808192b2b080819,
+    0x0808192b2b081908, 0x0808192b2b190808, 0x08082b0808080808, 0x08082b080808082b,
+    0x08082b0808081919, 0x08082b0808082b08, 0x08082b0808190819, 0x08082b0808191908,
+    0x08082b080819192b, 0x08082b0808192b19, 0x08082b08082b0808, 0x08082b08082b1919,
+    0x08082b08082b2b2b, 0x08082b0819080819, 0x08082b0819081908, 0x08082b081908192b,
+    0x08082b0819082b19, 0x08082b0819190808, 0x08082b081919082b, 0x08082b0819191919,
+    0x08082b0819192b08, 0x08082b08192b0819, 0x08082b08192b1908, 0x08082b082b080808,
+    0x08082b082b081919, 0x08082b082b191908, 0x08082b082b2b2b2b, 0x08082b1908080819,
+    0x08082b1908081908, 0x08082b1908190808, 0x08082b190819082b, 0x08082b1908191919,
+    0x08082b1908192b08, 0x08082b19082b0819, 0x08082b1919080808, 0x08082b1919081919,
+    0x08082b1919082b08, 0x08082b1919190819, 0x08082b1919191908, 0x08082b19192b0808,
+    0x08082b192b080819, 0x08082b192b190808, 0x08082b2b08080808, 0x08082b2b08190819,
+    0x08082b2b08191908, 0x08082b2b082b082b, 0x08082b2b082b2b08, 0x08082b2b082b2b2b,
+    0x08082b2b19190808, 0x08082b2b2b192b19, 0x0819080808080819, 0x0819080808081908,
+    0x081908080808192b, 0x0819080808082b19, 0x0819080808190808, 0x081908080819082b,
+    0x0819080808191919, 0x0819080808192b08, 0x08190808082b0819, 0x08190808082b1908,
+    0x08190808082b192b, 0x0819080819080808, 0x081908081908082b, 0x0819080819081919,
+    0x0819080819082b08, 0x0819080819190819, 0x0819080819191908, 0x081908081919192b,
+    0x0819080819192b19, 0x08190808192b0808, 0x08190808192b082b, 0x08190808192b1919,
+    0x08190808192b2b08, 0x081908082b080819, 0x081908082b081908, 0x081908082b08192b,
+    0x081908082b190808, 0x081908082b191919, 0x081908082b192b08, 0x081908082b2b0819,
+    0x081908082b2b1908, 0x0819081908080808, 0x081908190808082b, 0x0819081908081919,
+    0x0819081908082b08, 0x0819081908082b2b, 0x0819081908190819, 0x0819081908191908,
+    0x081908190819192b, 0x0819081908192b19, 0x08190819082b0808, 0x08190819082b082b,
+    0x08190819082b1919, 0x08190819082b2b08, 0x0819081919080819, 0x0819081919081908,
+    0x081908191908192b, 0x0819081919082b19, 0x0819081919190808, 0x081908191919082b,
+    0x0819081919191919, 0x0819081919192b08, 0x08190819192b0819, 0x08190819192b1908,
+    0x081908192b080808, 0x081908192b08082b, 0x081908192b081919, 0x081908192b082b08,
+    0x081908192b190819, 0x081908192b191908, 0x0819082b08080819, 0x0819082b08081908,
+    0x0819082b08082b19, 0x0819082b08190808, 0x0819082b08191919, 0x0819082b082b0819,
+    0x0819082b082b1908, 0x0819082b19080808, 0x0819082b19081919, 0x0819082b19190819,
+    0x0819082b19191908, 0x0819082b2b080819, 0x0819082b2b081908, 0x0819082b2b190808,
+    0x0819190808080808, 0x081919080808082b, 0x0819190808081919, 0x0819190808082b08,
+    0x0819190808190819, 0x0819190808191908, 0x081919080819192b, 0x0819190808192b19,
+    0x08191908082b0808, 0x08191908082b1919, 0x08191908082b2b08, 0x0819190819080819,
+    0x0819190819081908, 0x081919081908192b, 0x0819190819082b19, 0x0819190819190808,
+    0x081919081919082b, 0x0819190819191919, 0x0819190819192b08, 0x08191908192b0819,
+    0x08191908192b1908, 0x081919082b080808, 0x081919082b08082b, 0x081919082b081919,
+    0x081919082b082b08, 0x081919082b190819, 0x081919082b191908, 0x081919082b2b0808,
+    0x0819191908080819, 0x0819191908081908, 0x081919190808192b, 0x0819191908082b19,
+    0x0819191908190808, 0x081919190819082b, 0x0819191908191919, 0x0819191908192b08,
+    0x08191919082b0819, 0x08191919082b1908, 0x0819191919080808, 0x081919191908082b,
+    0x0819191919081919, 0x0819191919082b08, 0x0819191919190819, 0x0819191919191908,
+    0x08191919192b0808, 0x081919192b080819, 0x081919192b081908, 0x081919192b190808,
+    0x0819192b08080808, 0x0819192b08081919, 0x0819192b08082b08, 0x0819192b08190819,
+    0x0819192b08191908, 0x0819192b082b0808, 0x0819192b19080819, 0x0819192b19081908,
+    0x0819192b19190808, 0x0819192b2b080808, 0x0819192b2b2b2b2b, 0x08192b0808080819,
+    0x08192b0808081908, 0x08192b080808192b, 0x08192b0808082b19, 0x08192b0808190808,
+    0x08192b0808191919, 0x08192b0808192b08, 0x08192b08082b0819, 0x08192b0819080808,
+    0x08192b081908082b, 0x08192b0819081919, 0x08192b0819082b08, 0x08192b0819190819,
+    0x08192b0819191908, 0x08192b08192b0808, 0x08192b082b080819, 0x08192b082b081908,
+    0x08192b1908080808, 0x08192b190808082b, 0x08192b1908081919, 0x08192b1908082b08,
+    0x08192b1908190819, 0x08192b1908191908, 0x08192b19082b0808, 0x08192b1919080819,
+    0x08192b1919081908, 0x08192b1919190808, 0x08192b19192b2b19, 0x08192b192b2b082b,
+    0x08192b2b08081908, 0x08192b2b08190808, 0x08192b2b19080808, 0x08192b2b1919192b,
+    0x082b080808080808, 0x082b08080808082b, 0x082b080808081919, 0x082b080808082b08,
+    0x082b080808190819, 0x082b080808191908, 0x082b08080819192b, 0x082b080808192b19,
+    0x082b0808082b0808, 0x082b0808082b1919, 0x082b0808082b2b2b, 0x082b080819080819,
+    0x082b080819081908, 0x082b080819190808, 0x082b08081919082b, 0x082b080819191919,
+    0x082b0808192b1908, 0x082b08082b080808, 0x082b08082b082b2b, 0x082b08082b191908,
+    0x082b08082b2b2b2b, 0x082b081908080819, 0x082b081908081908, 0x082b081908190808,
+    0x082b08190819082b, 0x082b081908191919, 0x082b0819082b0819, 0x082b081919080808,
+    0x082b08191908082b, 0x082b081919081919, 0x082b081919190819, 0x082b081919191908,
+    0x082b0819192b0808, 0x082b08192b080819, 0x082b08192b081908, 0x082b08192b190808,
+    0x082b082b08080808, 0x082b082b08082b2b, 0x082b082b082b082b, 0x082b082b082b2b08,
+    0x082b082b082b2b2b, 0x082b082b19081908, 0x082b082b19190808, 0x082b082b2b082b08,
+    0x082b082b2b082b2b, 0x082b082b2b2b2b08, 0x082b190808080819, 0x082b190808081908,
+    0x082b19080808192b, 0x082b190808082b19, 0x082b190808190808, 0x082b190808191919,
+    0x082b190808192b08, 0x082b1908082b0819, 0x082b1908082b1908, 0x082b190819080808,
+    0x082b19081908082b, 0x082b190819081919, 0x082b190819082b08, 0x082b190819190819,
+    0x082b190819191908, 0x082b1908192b0808, 0x082b19082b080819, 0x082b19082b081908,
+    0x082b19082b190808, 0x082b191908080808, 0x082b191908081919, 0x082b191908082b08,
+    0x082b191908190819, 0x082b191908191908, 0x082b1919082b0808, 0x082b191919080819,
+    0x082b191919081908, 0x082b191919190808, 0x082b1919192b192b, 0x082b19192b080808,
+    0x082b192b08080819, 0x082b192b08081908, 0x082b192b08190808, 0x082b192b19080808,
+    0x082b192b19192b19, 0x082b2b0808080808, 0x082b2b0808081919, 0x082b2b0808190819,
+    0x082b2b0808191908, 0x082b2b0819080819, 0x082b2b0819081908, 0x082b2b0819190808,
+    0x082b2b082b082b2b, 0x082b2b082b2b2b2b, 0x082b2b1908080819, 0x082b2b1908081908,
+    0x082b2b1908190808, 0x082b2b192b191919, 0x082b2b2b08082b2b, 0x082b2b2b082b082b,
+    0x082b2b2b192b1908, 0x082b2b2b2b082b08, 0x082b2b2b2b082b2b, 0x1908080808080819,
+    0x1908080808081908, 0x190808080808192b, 0x1908080808082b19, 0x1908080808190808,
+    0x190808080819082b, 0x1908080808191919, 0x1908080808192b08, 0x1908080808192b2b,
+    0x19080808082b0819, 0x19080808082b1908, 0x19080808082b192b, 0x1908080819080808,
+    0x190808081908082b, 0x1908080819081919, 0x1908080819082b08, 0x1908080819082b2b,
+    0x1908080819190819, 0x1908080819191908, 0x190808081919192b, 0x1908080819192b19,
+    0x19080808192b0808, 0x19080808192b082b, 0x19080808192b1919, 0x190808082b080819,
+    0x190808082b081908, 0x190808082b190808, 0x190808082b191919, 0x190808082b192b08,
+    0x190808082b2b0819, 0x190808082b2b1908, 0x1908081908080808, 0x190808190808082b,
+    0x1908081908081919, 0x1908081908082b08, 0x1908081908190819, 0x1908081908191908,
+    0x190808190819192b, 0x1908081908192b19, 0x19080819082b0808, 0x19080819082b082b,
+    0x19080819082b1919, 0x1908081919080819, 0x1908081919081908, 0x190808191908192b,
+    0x1908081919082b19, 0x1908081919190808, 0x190808191919082b, 0x1908081919191919,
+    0x1908081919192b08, 0x19080819192b0819, 0x19080819192b1908, 0x190808192b080808,
+    0x190808192b08082b, 0x190808192b081919, 0x190808192b082b08, 0x190808192b190819,
+    0x190808192b191908, 0x190808192b2b0808, 0x1908082b08080819, 0x1908082b08081908,
+    0x1908082b08190808, 0x1908082b0819082b, 0x1908082b08191919, 0x1908082b08192b08,
+    0x1908082b082b1908, 0x1908082b19080808, 0x1908082b19081919, 0x1908082b19082b08,
+    0x1908082b19190819, 0x1908082b19191908, 0x1908082b192b0808, 0x1908082b2b080819,
+    0x1908082b2b081908, 0x1908190808080808, 0x190819080808082b, 0x1908190808081919,
+    0x1908190808082b08, 0x1908190808082b2b, 0x1908190808190819, 0x1908190808191908,
+    0x190819080819192b, 0x1908190808192b19, 0x19081908082b0808, 0x19081908082b082b,
+    0x19081908082b1919, 0x19081908082b2b08, 0x1908190819080819, 0x1908190819081908,
+    0x190819081908192b, 0x1908190819082b19, 0x1908190819190808, 0x190819081919082b,
+    0x1908190819191919, 0x1908190819192b08, 0x19081908192b0819, 0x19081908192b1908,
+    0x190819082b080808, 0x190819082b08082b, 0x190819082b081919, 0x190819082b082b08,
+    0x190819082b190819, 0x190819082b191908, 0x190819082b2b0808, 0x1908191908080819,
+    0x1908191908081908, 0x190819190808192b, 0x1908191908082b19, 0x1908191908190808,
+    0x190819190819082b, 0x1908191908191919, 0x1908191908192b08, 0x19081919082b0819,
+    0x19081919082b1908, 0x1908191919080808, 0x190819191908082b, 0x1908191919081919,
+    0x1908191919082b08, 0x1908191919190819, 0x1908191919191908, 0x19081919192b0808,
+    0x19081919192b2b2b, 0x190819192b080819, 0x190819192b081908, 0x190819192b190808,
+    0x1908192b08080808, 0x1908192b0808082b, 0x1908192b08081919, 0x1908192b08082b08,
+    0x1908192b08190819, 0x1908192b08191908, 0x1908192b082b0808, 0x1908192b19080819,
+    0x1908192b19081908, 0x1908192b19190808, 0x1908192b2b080808, 0x1908192b2b2b1919,
+    0x19082b0808080819, 0x19082b0808081908, 0x19082b0808082b19, 0x19082b0808190808,
+    0x19082b080819082b, 0x19082b0808191919, 0x19082b0808192b08, 0x19082b08082b0819,
+    0x19082b08082b1908, 0x19082b0819080808, 0x19082b081908082b, 0x19082b0819081919,
+    0x19082b0819082b08, 0x19082b0819190819, 0x19082b0819191908, 0x19082b08192b0808,
+    0x19082b082b081908, 0x19082b082b190808, 0x19082b1908080808, 0x19082b190808082b,
+    0x19082b1908081919, 0x19082b1908082b08, 0x19082b1908190819, 0x19082b1908191908,
+    0x19082b19082b0808, 0x19082b1919080819, 0x19082b1919081908, 0x19082b1919190808,
+    0x19082b192b080808, 0x19082b192b19192b, 0x19082b2b08080819, 0x19082b2b08081908,
+    0x19082b2b08190808, 0x19082b2b19080808, 0x1919080808080808, 0x191908080808082b,
+    0x1919080808081919, 0x1919080808082b08, 0x1919080808190819, 0x1919080808191908,
+    0x191908080819192b, 0x1919080808192b19, 0x19190808082b0808, 0x19190808082b082b,
+    0x19190808082b1919, 0x19190808082b2b08, 0x1919080819080819, 0x1919080819081908,
+    0x191908081908192b, 0x1919080819082b19, 0x1919080819190808, 0x191908081919082b,
+    0x1919080819191919, 0x1919080819192b08, 0x19190808192b0819, 0x19190808192b1908,
+    0x191908082b080808, 0x191908082b08082b, 0x191908082b081919, 0x191908082b082b08,
+    0x191908082b190819, 0x191908082b191908, 0x1919081908080819, 0x1919081908081908,
+    0x191908190808192b, 0x1919081908082b19, 0x1919081908190808, 0x191908190819082b,
+    0x1919081908191919, 0x1919081908192b08, 0x19190819082b0819, 0x19190819082b1908,
+    0x1919081919080808, 0x191908191908082b, 0x1919081919081919, 0x1919081919082b08,
+    0x1919081919190819, 0x1919081919191908, 0x19190819192b0808, 0x191908192b080819,
+    0x191908192b081908, 0x191908192b190808, 0x1919082b08080808, 0x1919082b08081919,
+    0x1919082b08082b08, 0x1919082b08190819, 0x1919082b08191908, 0x1919082b082b0808,
+    0x1919082b19080819, 0x1919082b19081908, 0x1919082b19190808, 0x1919082b192b2b19,
+    0x1919082b2b080808, 0x1919190808080819, 0x1919190808081908, 0x191919080808192b,
+    0x1919190808082b19, 0x1919190808190808, 0x191919080819082b, 0x1919190808191919,
+    0x1919190808192b08, 0x19191908082b0819, 0x19191908082b1908, 0x1919190819080808,
+    0x191919081908082b, 0x1919190819081919, 0x1919190819082b08, 0x1919190819190819,
+    0x1919190819191908, 0x19191908192b0808, 0x191919082b080819, 0x191919082b081908,
+    0x191919082b190808, 0x1919191908080808, 0x191919190808082b, 0x1919191908081919,
+    0x1919191908082b08, 0x1919191908190819, 0x1919191908191908, 0x19191919082b0808,
+    0x1919191919080819, 0x1919191919081908, 0x1919191919190808, 0x191919192b080808,
+    0x1919192b08080819, 0x1919192b08081908, 0x1919192b08190808, 0x1919192b082b192b,
+    0x1919192b19080808, 0x19192b0808080808, 0x19192b080808082b, 0x19192b0808081919,
+    0x19192b0808082b08, 0x19192b0808190819, 0x19192b0808191908, 0x19192b08082b0808,
+    0x19192b0819080819, 0x19192b0819081908, 0x19192b0819190808, 0x19192b0819192b2b,
+    0x19192b082b080808, 0x19192b1908080819, 0x19192b1908081908, 0x19192b1908190808,
+    0x19192b1919080808, 0x19192b2b08080808, 0x19192b2b08192b19, 0x19192b2b2b081919,
+    0x19192b2b2b2b2b08, 0x192b080808080819, 0x192b080808081908, 0x192b08080808192b,
+    0x192b080808190808, 0x192b08080819082b, 0x192b080808191919, 0x192b080808192b08,
+    0x192b0808082b0819, 0x192b0808082b1908, 0x192b080819080808, 0x192b080819081919,
+    0x192b080819082b08, 0x192b080819190819, 0x192b080819191908, 0x192b0808192b0808,
+    0x192b08082b081908, 0x192b08082b190808, 0x192b081908080808, 0x192b08190808082b,
+    0x192b081908081919, 0x192b081908082b08, 0x192b081908190819, 0x192b081908191908,
+    0x192b0819082b0808, 0x192b081919080819, 0x192b081919081908, 0x192b081919190808,
+    0x192b08192b080808, 0x192b08192b192b19, 0x192b082b08081908, 0x192b082b08190808,
+    0x192b082b19080808, 0x192b082b1919192b, 0x192b082b2b2b0819, 0x192b190808080808,
+    0x192b190808081919, 0x192b190808082b08, 0x192b190808190819, 0x192b190808191908,
+    0x192b1908082b0808, 0x192b190819080819, 0x192b190819081908, 0x192b190819190808,
+    0x192b19082b080808, 0x192b191908080819, 0x192b191908081908, 0x192b191908190808,
+    0x192b191919080808, 0x192b191919082b2b, 0x192b1919192b2b08, 0x192b19192b19082b,
+    0x192b192b08080808, 0x192b192b2b191908, 0x192b2b0808080819, 0x192b2b0808081908,
+    0x192b2b0808190808, 0x192b2b08192b1919, 0x192b2b082b192b08, 0x192b2b1908080808,
+    0x192b2b19082b2b2b, 0x192b2b2b1908082b, 0x192b2b2b2b2b0819, 0x2b08080808080808,
+    0x2b0808080808082b, 0x2b08080808081919, 0x2b08080808082b08, 0x2b08080808190819,
+    0x2b08080808191908, 0x2b08080808192b19, 0x2b080808082b0808, 0x2b080808082b1919,
+    0x2b08080819080819, 0x2b08080819081908, 0x2b08080819190808, 0x2b0808081919082b,
+    0x2b08080819191919, 0x2b08080819192b08, 0x2b080808192b0819, 0x2b0808082b080808,
+    0x2b0808082b081919, 0x2b0808082b190819, 0x2b0808082b191908, 0x2b08081908080819,
+    0x2b08081908081908, 0x2b08081908082b19, 0x2b08081908190808, 0x2b0808190819082b,
+    0x2b08081908191919, 0x2b08081908192b08, 0x2b080819082b0819, 0x2b080819082b1908,
+    0x2b08081919080808, 0x2b0808191908082b, 0x2b08081919081919, 0x2b08081919082b08,
+    0x2b08081919190819, 0x2b08081919191908, 0x2b0808192b080819, 0x2b0808192b081908,
+    0x2b0808192b190808, 0x2b0808192b2b2b19, 0x2b08082b08080808, 0x2b08082b08081919,
+    0x2b08082b08082b2b, 0x2b08082b08190819, 0x2b08082b08191908, 0x2b08082b19080819,
+    0x2b08082b19081908, 0x2b08082b19190808, 0x2b08190808080819, 0x2b08190808081908,
+    0x2b0819080808192b, 0x2b08190808082b19, 0x2b08190808190808, 0x2b0819080819082b,
+    0x2b08190808191919, 0x2b08190808192b08, 0x2b081908082b0819, 0x2b08190819080808,
+    0x2b0819081908082b, 0x2b08190819081919, 0x2b08190819082b08, 0x2b08190819190819,
+    0x2b08190819191908, 0x2b081908192b0808, 0x2b0819082b080819, 0x2b0819082b081908,
+    0x2b0819082b190808, 0x2b08191908080808, 0x2b0819190808082b, 0x2b08191908081919,
+    0x2b08191908082b08, 0x2b08191908190819, 0x2b08191908191908, 0x2b081919082b0808,
+    0x2b08191919080819, 0x2b08191919081908, 0x2b08191919190808, 0x2b0819192b080808,
+    0x2b0819192b082b2b, 0x2b08192b08080819, 0x2b08192b08081908, 0x2b08192b08190808,
+    0x2b08192b082b2b19, 0x2b08192b19080808, 0x2b082b0808080808, 0x2b082b0808081919,
+    0x2b082b0808190819, 0x2b082b0808191908, 0x2b082b0819080819, 0x2b082b0819081908,
+    0x2b082b0819190808, 0x2b082b082b2b082b, 0x2b082b1908080819, 0x2b082b1908081908,
+    0x2b082b1919080808, 0x2b082b19192b1919, 0x2b082b2b082b082b, 0x2b082b2b19192b08,
+    0x2b082b2b19192b2b, 0x2b082b2b2b08082b, 0x2b082b2b2b2b082b, 0x2b19080808080819,
+    0x2b19080808081908, 0x2b19080808082b19, 0x2b19080808190808, 0x2b1908080819082b,
+    0x2b19080808191919, 0x2b19080808192b08, 0x2b190808082b1908, 0x2b19080819080808,
+    0x2b1908081908082b, 0x2b19080819081919, 0x2b19080819082b08, 0x2b19080819190819,
+    0x2b19080819191908, 0x2b190808192b0808, 0x2b1908082b080819, 0x2b1908082b081908,
+    0x2b1908082b190808, 0x2b19081908080808, 0x2b19081908081919, 0x2b19081908190819,
+    0x2b19081908191908, 0x2b19081919080819, 0x2b19081919081908, 0x2b19081919190808,
+    0x2b19081919192b2b, 0x2b19082b08080819, 0x2b19082b08081908, 0x2b19082b08190808,
+    0x2b19082b19080808, 0x2b19082b2b2b192b, 0x2b19190808080808, 0x2b1919080808082b,
+    0x2b19190808081919, 0x2b19190808082b08, 0x2b19190808190819, 0x2b19190808191908,
+    0x2b191908082b0808, 0x2b19190819080819, 0x2b19190819081908, 0x2b19190819190808,
+    0x2b1919082b080808, 0x2b1919082b19192b, 0x2b19191908080819, 0x2b19191908081908,
+    0x2b19191908190808, 0x2b19191919080808, 0x2b1919192b192b08, 0x2b1919192b2b0819,
+    0x2b19192b08080808, 0x2b19192b1908192b, 0x2b19192b192b1908, 0x2b192b0808080819,
+    0x2b192b0808081908, 0x2b192b0808190808, 0x2b192b08082b192b, 0x2b192b0819080808,
+    0x2b192b082b2b2b19, 0x2b192b1908080808, 0x2b192b1919082b19, 0x2b192b191919082b,
+    0x2b192b2b2b190808, 0x2b2b080808080808, 0x2b2b080808081919, 0x2b2b080808082b2b,
+    0x2b2b080808191908, 0x2b2b0808082b082b, 0x2b2b0808082b2b2b, 0x2b2b080819080819,
+    0x2b2b080819081908, 0x2b2b080819190808, 0x2b2b08082b2b082b, 0x2b2b08082b2b2b2b,
+    0x2b2b081919080808, 0x2b2b0819192b1919, 0x2b2b082b0808082b, 0x2b2b082b08082b2b,
+    0x2b2b082b082b082b, 0x2b2b082b082b2b08, 0x2b2b082b082b2b2b, 0x2b2b082b2b08082b,
+    0x2b2b082b2b082b08, 0x2b2b082b2b082b2b, 0x2b2b082b2b2b2b08, 0x2b2b190808080819,
+    0x2b2b190808081908, 0x2b2b190808190808, 0x2b2b190819080808, 0x2b2b19082b082b19,
+    0x2b2b19082b2b1908, 0x2b2b191908080808, 0x2b2b191908192b19, 0x2b2b192b19190819,
+    0x2b2b2b0808082b2b, 0x2b2b2b08082b2b08, 0x2b2b2b082b2b082b, 0x2b2b2b1919191908,
+    0x2b2b2b192b08192b, 0x2b2b2b2b08082b08, 0x2b2b2b2b08082b2b, 0x2b2b2b2b082b0808,
+    0x2b2b2b2b082b082b, 0x2b2b2b2b082b2b08, 0x2b2b2b2b2b082b08, 0x2b2b2b2b2b2b2b2b,
+};
+
+#endif /* IQ2XS_GRID_H */