IQ1

gguf_format.h

@@ -157,6 +157,17 @@ typedef struct {
 
 /* sizeof(BlockQ2K) = 2 + 2 + 16 + 64 = 84 bytes for 256 weights */
 
+/* IQ1_S BLOCK (1-bit, imatrix-weighted). Layout matches ggml block_iq1_s:
+ * d(fp16) + qs[32] (grid-index low 8 bits, 4 per sub-block) + qh[8]
+ * (grid-index high 3 bits per group + scale + sign). 50 bytes/block. */
+typedef struct {
+    uint16_t d;
+    uint8_t  qs[QK_K/8];
+    uint16_t qh[QK_K/32];
+} BlockIQ1S;
+
+/* sizeof(BlockIQ1S) = 2 + 32 + 16 = 50 bytes for 256 weights */
+
 /* ═══════════════════════════════════════════════════════════════════════
  * FP16 ←→ FP32 CONVERSION
  *

hexstate_quantize.c

@@ -5239,6 +5239,853 @@ write_fail:
  * ═══════════════════════════════════════════════════════════════════════════ */
 
 /* Initialize HExState subsystems (must be called once before quantization) */
+
+/* =====================================================================
+ * IQ1_S HPC QUANTIZATION (1-bit, imatrix-weighted)
+ *
+ * Same HPC front-end as the Q2_K path (hexstate_init with triality/s6,
+ * kurtosis-driven outlier clamp, OpenMP, imatrix importance, MSE error),
+ * with IQ1_S geometry: 256-element superblocks of 8x32 sub-blocks, each
+ * sub-block split by exhaustive 2-boundary 3-level search (the SIEVE
+ * sequential selector adapted to 1-bit), packed ggml-compatibly via the
+ * 1-bit grid (kgrid_1bit_2048 + kmap + neighbours, built once at init).
+ * Output layout matches ggml block_iq1_s: d(fp16) + qs[32] + qh[8].
+ * ===================================================================== */
+
+#define HEX_IQ1S_BLOCK_SIZE 32
+#define HEX_NGRID_IQ1S 2048
+#define HEX_KMAP_IQ1S_SIZE 43692
+#define HEX_GROUP_MAX_EPS_IQ1_S 1e-12f
+#define HEX_IQ1S_DELTA 0.125f
+
+static const uint16_t hex_kgrid_1bit_2048[2048] = {
+            0,     2,     5,     8,    10,    17,    21,    32,    34,    40,    42,    69,    81,    84,    86,   101,
+          128,   130,   136,   138,   149,   160,   162,   168,   170,   260,   261,   273,   276,   278,   281,   282,
+          293,   321,   326,   329,   338,   341,   346,   353,   356,   358,   360,   389,   401,   404,   406,   421,
+          512,   514,   520,   522,   533,   544,   546,   552,   554,   581,   593,   601,   612,   617,   640,   642,
+          648,   650,   657,   661,   665,   672,   674,   680,   682,  1041,  1044,  1046,  1061,  1089,  1097,  1109,
+         1114,  1124,  1125,  1169,  1177,  1189,  1281,  1284,  1285,  1286,  1301,  1304,  1306,  1321,  1344,  1349,
+         1354,  1360,  1361,  1364,  1365,  1366,  1369,  1376,  1378,  1381,  1384,  1386,  1409,  1425,  1429,  1432,
+         1434,  1441,  1444,  1445,  1446,  1449,  1556,  1561,  1601,  1604,  1616,  1618,  1621,  1624,  1632,  1633,
+         1638,  1641,  1669,  1681,  1684,  1689,  2048,  2050,  2056,  2058,  2069,  2080,  2082,  2088,  2090,  2117,
+         2129,  2134,  2149,  2176,  2178,  2184,  2186,  2197,  2208,  2210,  2216,  2218,  2309,  2321,  2324,  2329,
+         2340,  2341,  2369,  2384,  2385,  2389,  2401,  2404,  2409,  2449,  2452,  2454,  2457,  2469,  2560,  2562,
+         2568,  2570,  2581,  2592,  2594,  2600,  2602,  2629,  2641,  2649,  2657,  2661,  2688,  2690,  2693,  2696,
+         2698,  2709,  2720,  2722,  2728,  2730,  4112,  4113,  4116,  4121,  4132,  4133,  4161,  4164,  4176,  4181,
+         4184,  4193,  4196,  4197,  4201,  4241,  4244,  4246,  4257,  4261,  4353,  4356,  4358,  4361,  4368,  4370,
+         4373,  4376,  4385,  4388,  4393,  4421,  4426,  4432,  4433,  4434,  4436,  4437,  4438,  4441,  4448,  4453,
+         4484,  4498,  4501,  4513,  4516,  4625,  4628,  4630,  4645,  4672,  4678,  4681,  4690,  4693,  4696,  4698,
+         4708,  4710,  4741,  4753,  4756,  4758,  4773,  5121,  5126,  5129,  5140,  5141,  5144,  5145,  5153,  5158,
+         5185,  5189,  5190,  5192,  5194,  5201,  5204,  5205,  5206,  5209,  5218,  5221,  5224,  5252,  5257,  5264,
+         5268,  5269,  5272,  5273,  5274,  5281,  5284,  5285,  5289,  5378,  5381,  5386,  5393,  5396,  5397,  5398,
+         5401,  5408,  5410,  5413,  5416,  5418,  5441,  5444,  5445,  5446,  5457,  5458,  5460,  5461,  5462,  5465,
+         5466,  5473,  5476,  5477,  5478,  5481,  5504,  5506,  5508,  5509,  5512,  5514,  5520,  5521,  5524,  5525,
+         5526,  5529,  5530,  5536,  5538,  5541,  5633,  5636,  5637,  5638,  5653,  5654,  5656,  5658,  5665,  5670,
+         5696,  5698,  5700,  5701,  5704,  5706,  5713,  5717,  5718,  5720,  5721,  5729,  5732,  5733,  5736,  5737,
+         5738,  5766,  5770,  5778,  5781,  5796,  5801,  6161,  6166,  6181,  6209,  6212,  6214,  6217,  6224,  6229,
+         6232,  6234,  6240,  6241,  6244,  6246,  6249,  6277,  6289,  6292,  6309,  6416,  6418,  6421,  6426,  6433,
+         6437,  6466,  6468,  6469,  6472,  6481,  6484,  6485,  6486,  6489,  6490,  6496,  6501,  6506,  6537,  6545,
+         6546,  6549,  6552,  6561,  6566,  6569,  6665,  6678,  6692,  6694,  6724,  6726,  6729,  6736,  6738,  6741,
+         6744,  6753,  6758,  6761,  6789,  6801,  6806,  6810,  8192,  8194,  8200,  8202,  8213,  8224,  8226,  8229,
+         8232,  8234,  8261,  8273,  8281,  8289,  8293,  8320,  8322,  8328,  8330,  8341,  8352,  8354,  8357,  8360,
+         8362,  8453,  8465,  8468,  8473,  8485,  8514,  8516,  8521,  8533,  8536,  8538,  8545,  8548,  8549,  8550,
+         8581,  8592,  8598,  8601,  8613,  8705,  8712,  8714,  8721,  8725,  8736,  8738,  8744,  8746,  8773,  8785,
+         8790,  8793,  8805,  8833,  8840,  8842,  8849,  8853,  8864,  8866,  8872,  8874,  9221,  9236,  9238,  9241,
+         9253,  9284,  9285,  9286,  9289,  9298,  9301,  9304,  9306,  9318,  9349,  9361,  9364,  9369,  9377,  9381,
+         9481,  9493,  9505,  9513,  9536,  9541,  9544,  9553,  9556,  9557,  9561,  9570,  9573,  9576,  9609,  9616,
+         9620,  9621,  9624,  9626,  9633,  9636,  9638,  9641,  9733,  9744,  9746,  9753,  9765,  9793,  9801,  9813,
+         9824,  9825,  9833,  9860,  9862,  9872,  9882, 10240, 10242, 10248, 10250, 10261, 10272, 10274, 10280, 10282,
+        10309, 10321, 10324, 10341, 10368, 10370, 10376, 10378, 10400, 10402, 10408, 10410, 10505, 10513, 10516, 10521,
+        10533, 10566, 10569, 10578, 10581, 10593, 10596, 10598, 10601, 10629, 10640, 10646, 10649, 10660, 10661, 10752,
+        10754, 10760, 10762, 10784, 10786, 10792, 10794, 10821, 10833, 10838, 10841, 10853, 10880, 10882, 10888, 10890,
+        10901, 10912, 10914, 10920, 10922, 16389, 16401, 16406, 16421, 16457, 16466, 16469, 16472, 16474, 16481, 16484,
+        16486, 16532, 16537, 16545, 16550, 16640, 16641, 16644, 16646, 16649, 16658, 16661, 16662, 16664, 16666, 16673,
+        16678, 16681, 16709, 16712, 16714, 16721, 16724, 16725, 16726, 16729, 16730, 16741, 16744, 16746, 16769, 16772,
+        16774, 16784, 16786, 16789, 16800, 16801, 16802, 16901, 16913, 16916, 16918, 16933, 16961, 16978, 16981, 16986,
+        16996, 17001, 17033, 17044, 17061, 17409, 17429, 17433, 17449, 17477, 17480, 17482, 17489, 17492, 17493, 17494,
+        17505, 17506, 17509, 17512, 17514, 17537, 17542, 17545, 17552, 17554, 17557, 17568, 17569, 17577, 17665, 17666,
+        17669, 17674, 17681, 17684, 17685, 17686, 17689, 17696, 17701, 17706, 17729, 17732, 17733, 17734, 17737, 17744,
+        17745, 17748, 17749, 17750, 17752, 17753, 17761, 17764, 17765, 17766, 17769, 17794, 17796, 17797, 17800, 17809,
+        17812, 17813, 17814, 17817, 17818, 17829, 17832, 17834, 17921, 17925, 17929, 17940, 17941, 17944, 17946, 17953,
+        17956, 17961, 17984, 17986, 17989, 17992, 18000, 18001, 18002, 18005, 18006, 18009, 18018, 18021, 18024, 18049,
+        18053, 18058, 18068, 18069, 18081, 18084, 18086, 18437, 18449, 18453, 18458, 18469, 18498, 18505, 18512, 18517,
+        18520, 18529, 18532, 18534, 18537, 18565, 18577, 18580, 18582, 18585, 18597, 18689, 18693, 18694, 18698, 18704,
+        18708, 18709, 18712, 18721, 18724, 18726, 18752, 18757, 18762, 18769, 18770, 18772, 18773, 18774, 18777, 18784,
+        18786, 18789, 18790, 18794, 18822, 18825, 18834, 18837, 18838, 18840, 18849, 18852, 18854, 18857, 18966, 19012,
+        19014, 19017, 19029, 19032, 19034, 19044, 19049, 19092, 19109, 20481, 20484, 20485, 20486, 20489, 20498, 20501,
+        20506, 20513, 20516, 20521, 20544, 20549, 20552, 20561, 20564, 20565, 20566, 20569, 20581, 20584, 20614, 20617,
+        20629, 20632, 20640, 20641, 20646, 20649, 20741, 20744, 20745, 20746, 20753, 20756, 20757, 20758, 20760, 20761,
+        20768, 20773, 20774, 20776, 20778, 20801, 20804, 20805, 20806, 20809, 20816, 20817, 20818, 20820, 20821, 20822,
+        20824, 20825, 20826, 20833, 20836, 20837, 20838, 20841, 20866, 20869, 20881, 20884, 20885, 20886, 20889, 20896,
+        20901, 20906, 20993, 20998, 21010, 21013, 21018, 21025, 21028, 21058, 21061, 21066, 21073, 21076, 21077, 21078,
+        21081, 21090, 21093, 21125, 21136, 21138, 21141, 21145, 21146, 21156, 21508, 21509, 21521, 21524, 21525, 21526,
+        21528, 21529, 21537, 21541, 21544, 21546, 21569, 21572, 21573, 21574, 21577, 21578, 21584, 21585, 21588, 21589,
+        21590, 21592, 21593, 21594, 21601, 21602, 21604, 21605, 21606, 21609, 21632, 21640, 21642, 21649, 21652, 21653,
+        21654, 21657, 21665, 21668, 21669, 21674, 21761, 21762, 21764, 21765, 21766, 21769, 21776, 21777, 21778, 21780,
+        21781, 21782, 21785, 21786, 21793, 21796, 21797, 21798, 21801, 21824, 21825, 21826, 21828, 21829, 21830, 21832,
+        21833, 21840, 21841, 21842, 21844, 21845, 21846, 21848, 21849, 21850, 21856, 21857, 21860, 21861, 21862, 21864,
+        21865, 21866, 21889, 21892, 21893, 21897, 21898, 21904, 21905, 21908, 21909, 21910, 21912, 21913, 21921, 21924,
+        21925, 21926, 21929, 22016, 22017, 22018, 22020, 22022, 22024, 22025, 22033, 22036, 22037, 22040, 22041, 22048,
+        22049, 22050, 22052, 22053, 22054, 22056, 22057, 22081, 22085, 22086, 22088, 22089, 22090, 22096, 22097, 22098,
+        22100, 22101, 22102, 22104, 22105, 22106, 22113, 22116, 22117, 22121, 22146, 22149, 22150, 22152, 22153, 22154,
+        22161, 22165, 22170, 22178, 22181, 22182, 22184, 22185, 22532, 22533, 22534, 22537, 22544, 22549, 22552, 22561,
+        22570, 22597, 22600, 22602, 22609, 22612, 22613, 22614, 22616, 22617, 22624, 22626, 22628, 22629, 22658, 22665,
+        22672, 22674, 22677, 22680, 22689, 22697, 22785, 22786, 22789, 22794, 22801, 22804, 22805, 22806, 22809, 22821,
+        22849, 22852, 22853, 22854, 22857, 22864, 22865, 22866, 22868, 22869, 22870, 22872, 22873, 22874, 22881, 22884,
+        22885, 22886, 22889, 22913, 22917, 22921, 22929, 22932, 22933, 22934, 22936, 22937, 22949, 23044, 23048, 23061,
+        23066, 23072, 23077, 23078, 23081, 23109, 23112, 23113, 23121, 23125, 23126, 23128, 23129, 23138, 23141, 23144,
+        23146, 23169, 23178, 23186, 23189, 23190, 23192, 23194, 23201, 24581, 24596, 24598, 24601, 24613, 24644, 24656,
+        24661, 24662, 24664, 24666, 24673, 24676, 24678, 24681, 24705, 24726, 24741, 24833, 24836, 24838, 24841, 24850,
+        24853, 24865, 24866, 24870, 24873, 24901, 24905, 24913, 24917, 24918, 24921, 24933, 24934, 24938, 24964, 24970,
+        24978, 24981, 24993, 24998, 25001, 25105, 25110, 25113, 25152, 25153, 25158, 25173, 25174, 25176, 25184, 25221,
+        25233, 25238, 25253, 25617, 25618, 25621, 25622, 25626, 25633, 25638, 25641, 25664, 25666, 25669, 25672, 25674,
+        25681, 25684, 25685, 25686, 25689, 25690, 25696, 25698, 25701, 25732, 25733, 25737, 25744, 25746, 25748, 25749,
+        25750, 25752, 25754, 25761, 25764, 25769, 25861, 25864, 25866, 25873, 25877, 25878, 25881, 25924, 25925, 25926,
+        25929, 25936, 25937, 25940, 25941, 25942, 25945, 25953, 25956, 25957, 25958, 25961, 25990, 25993, 25994, 26001,
+        26005, 26006, 26009, 26010, 26018, 26021, 26022, 26024, 26114, 26121, 26133, 26144, 26150, 26152, 26153, 26176,
+        26181, 26184, 26186, 26193, 26196, 26197, 26198, 26200, 26202, 26208, 26213, 26216, 26240, 26242, 26245, 26250,
+        26260, 26262, 26264, 26265, 26272, 26276, 26278, 26282, 26646, 26649, 26661, 26689, 26706, 26709, 26714, 26721,
+        26729, 26757, 26769, 26776, 26790, 26881, 26884, 26896, 26901, 26913, 26916, 26918, 26921, 26944, 26945, 26949,
+        26950, 26952, 26961, 26964, 26965, 26966, 26969, 26976, 26981, 26986, 27010, 27012, 27018, 27029, 27041, 27044,
+        27045, 27049, 27153, 27158, 27160, 27201, 27204, 27209, 27216, 27221, 27224, 27226, 27236, 27237, 27241, 27270,
+        27284, 27288, 27290, 27302, 32768, 32770, 32776, 32778, 32800, 32802, 32808, 32810, 32837, 32848, 32849, 32852,
+        32854, 32857, 32869, 32896, 32898, 32904, 32906, 32917, 32928, 32930, 32936, 32938, 33029, 33041, 33044, 33046,
+        33049, 33061, 33089, 33092, 33097, 33104, 33106, 33109, 33110, 33112, 33113, 33124, 33126, 33129, 33157, 33161,
+        33172, 33174, 33177, 33189, 33280, 33282, 33288, 33290, 33301, 33312, 33314, 33320, 33322, 33361, 33364, 33369,
+        33381, 33408, 33410, 33416, 33418, 33429, 33440, 33442, 33448, 33450, 33812, 33817, 33857, 33860, 33873, 33877,
+        33882, 33889, 33892, 33897, 33940, 33945, 34049, 34057, 34066, 34069, 34074, 34086, 34089, 34112, 34113, 34117,
+        34120, 34129, 34132, 34133, 34134, 34137, 34138, 34149, 34150, 34152, 34154, 34177, 34180, 34182, 34185, 34192,
+        34194, 34197, 34200, 34214, 34321, 34326, 34329, 34341, 34369, 34372, 34377, 34378, 34384, 34389, 34393, 34394,
+        34401, 34406, 34410, 34437, 34449, 34458, 34468, 34816, 34818, 34824, 34826, 34837, 34848, 34850, 34856, 34858,
+        34881, 34885, 34897, 34900, 34905, 34917, 34921, 34944, 34946, 34952, 34954, 34965, 34976, 34978, 34984, 34986,
+        35077, 35078, 35089, 35092, 35094, 35109, 35137, 35140, 35142, 35145, 35152, 35154, 35157, 35162, 35169, 35172,
+        35205, 35222, 35225, 35237, 35328, 35330, 35336, 35338, 35349, 35360, 35362, 35368, 35370, 35397, 35409, 35412,
+        35414, 35456, 35458, 35464, 35466, 35477, 35488, 35490, 35496, 35498, 36869, 36881, 36886, 36888, 36889, 36901,
+        36929, 36934, 36937, 36949, 36952, 36954, 36969, 36970, 36997, 37009, 37012, 37014, 37017, 37029, 37121, 37124,
+        37126, 37129, 37136, 37141, 37144, 37146, 37153, 37156, 37158, 37161, 37184, 37189, 37200, 37201, 37204, 37205,
+        37206, 37209, 37218, 37221, 37252, 37254, 37266, 37269, 37272, 37281, 37284, 37286, 37289, 37381, 37393, 37396,
+        37401, 37413, 37444, 37446, 37449, 37456, 37458, 37461, 37464, 37478, 37481, 37509, 37524, 37526, 37545, 37889,
+        37892, 37894, 37904, 37909, 37912, 37926, 37952, 37962, 37969, 37972, 37973, 37974, 37976, 37977, 37984, 37985,
+        37986, 37989, 38020, 38022, 38034, 38036, 38037, 38040, 38049, 38057, 38144, 38149, 38152, 38154, 38160, 38161,
+        38164, 38165, 38166, 38169, 38177, 38181, 38185, 38186, 38209, 38212, 38213, 38214, 38217, 38224, 38225, 38226,
+        38228, 38229, 38230, 38232, 38233, 38234, 38241, 38244, 38245, 38246, 38249, 38273, 38277, 38280, 38289, 38290,
+        38292, 38293, 38294, 38297, 38298, 38304, 38306, 38309, 38312, 38314, 38401, 38404, 38416, 38421, 38425, 38432,
+        38438, 38441, 38469, 38472, 38473, 38481, 38482, 38485, 38486, 38489, 38501, 38504, 38530, 38532, 38537, 38538,
+        38546, 38548, 38549, 38564, 38566, 38569, 38917, 38934, 38937, 38949, 38977, 38982, 38992, 38994, 38997, 38998,
+        39002, 39012, 39013, 39045, 39057, 39062, 39065, 39077, 39172, 39174, 39177, 39184, 39186, 39189, 39192, 39194,
+        39200, 39201, 39204, 39206, 39232, 39234, 39237, 39240, 39242, 39249, 39252, 39253, 39254, 39257, 39266, 39269,
+        39270, 39274, 39297, 39300, 39312, 39314, 39317, 39322, 39329, 39334, 39429, 39445, 39461, 39492, 39494, 39497,
+        39504, 39509, 39512, 39521, 39557, 39569, 39572, 39573, 39574, 40960, 40962, 40968, 40970, 40981, 40992, 40994,
+        41000, 41002, 41029, 41041, 41044, 41046, 41049, 41088, 41090, 41096, 41098, 41109, 41120, 41122, 41128, 41130,
+        41221, 41225, 41233, 41236, 41238, 41241, 41242, 41286, 41289, 41297, 41301, 41304, 41306, 41313, 41316, 41349,
+        41360, 41362, 41366, 41369, 41474, 41480, 41482, 41488, 41497, 41506, 41512, 41514, 41541, 41553, 41558, 41561,
+        41573, 41600, 41602, 41608, 41610, 41621, 41632, 41634, 41640, 41642, 42009, 42021, 42049, 42052, 42064, 42068,
+        42069, 42072, 42074, 42081, 42085, 42086, 42088, 42089, 42117, 42246, 42249, 42256, 42258, 42261, 42264, 42278,
+        42281, 42306, 42309, 42321, 42324, 42325, 42326, 42329, 42341, 42346, 42369, 42372, 42373, 42374, 42377, 42386,
+        42389, 42392, 42501, 42513, 42518, 42522, 42529, 42533, 42564, 42566, 42570, 42578, 42581, 42582, 42584, 42592,
+        42594, 42630, 42640, 42645, 42646, 42649, 42657, 42660, 42662, 43008, 43010, 43016, 43018, 43040, 43042, 43048,
+        43050, 43089, 43092, 43094, 43097, 43136, 43138, 43144, 43146, 43157, 43168, 43170, 43176, 43178, 43269, 43284,
+        43289, 43297, 43301, 43329, 43344, 43349, 43354, 43361, 43366, 43369, 43408, 43414, 43520, 43522, 43528, 43530,
+        43552, 43554, 43560, 43562, 43601, 43604, 43606, 43648, 43650, 43656, 43658, 43669, 43680, 43682, 43688, 43690,
+};
+
+static uint64_t *hex_iq1s_grid = NULL;
+static int *hex_iq1s_map = NULL;
+static uint16_t *hex_iq1s_neighbours = NULL;
+static uint64_t *hex_iq1s_dgrid = NULL;  /* dequant grid: bytes in {-1,0,+1} */
+static int hex_iq1s_ready = 0;
+
+static int hex_iq1s_cmp(const void *left, const void *right) {
+    const int *l = (const int *)left;
+    const int *r = (const int *)right;
+    if (l[0] != r[0]) return l[0] < r[0] ? -1 : 1;
+    if (l[1] != r[1]) return l[1] < r[1] ? -1 : 1;
+    return 0;
+}
+
+typedef struct { float v; int i; } hex_sort_pair;
+static int hex_iq1s_sort_helper(const void *left, const void *right) {
+    const hex_sort_pair *l = (const hex_sort_pair *)left;
+    const hex_sort_pair *r = (const hex_sort_pair *)right;
+    if (l->v < r->v) return -1;
+    if (l->v > r->v) return 1;
+    return 0;
+}
+
+static int hex_iq1s_best_neighbour(const uint16_t *neighbours, const uint64_t *grid,
+        const float *xval, const float *weight, float scale, const float *xg,
+        int8_t *L, int ngrid) {
+    int num_neighbors = neighbours[0];
+    float best_score = 1e30f;
+    int grid_index = -1;
+    int j, i;
+    if (num_neighbors > 0) {
+        for (j = 1; j <= num_neighbors; ++j) {
+            const int8_t *pg = (const int8_t *)(grid + neighbours[j]);
+            float d2 = 0;
+            for (i = 0; i < 8; ++i) {
+                float q = xg[(pg[i] - 1)/2];
+                float diff = scale*q - xval[i];
+                d2 += weight[i]*diff*diff;
+            }
+            if (d2 < best_score) { best_score = d2; grid_index = neighbours[j]; }
+        }
+    }
+    if (grid_index < 0) {
+        for (i = 0; i < ngrid; ++i) {
+            const int8_t *gi = (const int8_t *)(grid + i);
+            float d2 = 0;
+            for (j = 0; j < 8; ++j) {
+                float q = xg[(gi[j] - 1)/2];
+                float diff = scale*q - xval[j];
+                d2 += weight[j]*diff*diff;
+            }
+            if (d2 < best_score) { best_score = d2; grid_index = i; }
+        }
+    }
+    if (grid_index < 0) return -1;
+    {
+        const int8_t *pg = (const int8_t *)(grid + grid_index);
+        for (i = 0; i < 8; ++i) L[i] = (pg[i] - 1)/2;
+    }
+    return grid_index;
+}
+
+/* One-time build of grid + kmap + neighbours (ggml iq2xs_init_impl, IQ1_S branch). */
+static void hex_iq1s_init(void) {
+    int k, i, j;
+    if (hex_iq1s_ready) return;
+    hex_iq1s_ready = 1;
+
+    uint64_t *the_grid = (uint64_t *)malloc(HEX_NGRID_IQ1S*sizeof(uint64_t));
+    if (!the_grid) return;
+    for (k = 0; k < HEX_NGRID_IQ1S; ++k) {
+        int8_t *pos = (int8_t *)(the_grid + k);
+        for (i = 0; i < 8; ++i) {
+            int l = (hex_kgrid_1bit_2048[k] >> 2*i) & 0x3;
+            pos[i] = (int8_t)(2*l + 1);
+        }
+    }
+    hex_iq1s_grid = the_grid;
+
+    /* Dequant grid: same patterns mapped to {-1,0,+1} (matches ggml iq1s_grid). */
+    {
+        uint64_t *dg = (uint64_t *)malloc(HEX_NGRID_IQ1S*sizeof(uint64_t));
+        if (dg) {
+            for (k = 0; k < HEX_NGRID_IQ1S; ++k) {
+                int8_t *pos = (int8_t *)(dg + k);
+                for (i = 0; i < 8; ++i) {
+                    int l = (hex_kgrid_1bit_2048[k] >> 2*i) & 0x3;
+                    pos[i] = (int8_t)(l - 1);
+                }
+            }
+            hex_iq1s_dgrid = dg;
+        }
+    }
+
+    int *kmap = (int *)malloc(HEX_KMAP_IQ1S_SIZE*sizeof(int));
+    if (!kmap) return;
+    for (i = 0; i < HEX_KMAP_IQ1S_SIZE; ++i) kmap[i] = -1;
+    {
+        uint64_t aux64;
+        uint8_t *aux8 = (uint8_t *)&aux64;
+        for (i = 0; i < HEX_NGRID_IQ1S; ++i) {
+            aux64 = the_grid[i];
+            uint16_t index = 0;
+            for (k = 0; k < 8; ++k) {
+                uint16_t q = (uint16_t)((aux8[k] - 1)/2);
+                index |= (uint16_t)(q << 2*k);
+            }
+            kmap[index] = i;
+        }
+    }
+    hex_iq1s_map = kmap;
+
+    {
+        int *n_per_i = (int *)malloc(HEX_KMAP_IQ1S_SIZE*sizeof(int));
+        int *offsets = NULL;
+        uint16_t *neighbours = NULL;
+        int num_neighbors = 0, num_not_in_map = 0;
+        int counter = 0;
+        if (!n_per_i) return;
+        #pragma omp parallel reduction(+:num_neighbors,num_not_in_map)
+        {
+            int *dist2 = (int *)malloc(2*HEX_NGRID_IQ1S*sizeof(int));
+            int8_t pos[8];
+            int ii;
+            if (dist2) {
+                #pragma omp for schedule(dynamic, 64)
+                for (ii = 0; ii < HEX_KMAP_IQ1S_SIZE; ++ii) {
+                    int a, b;
+                    if (kmap[ii] >= 0) { n_per_i[ii] = 0; continue; }
+                    ++num_not_in_map;
+                    for (k = 0; k < 8; ++k) pos[k] = (int8_t)(2*((ii >> 2*k) & 0x3) + 1);
+                    for (j = 0; j < HEX_NGRID_IQ1S; ++j) {
+                        const int8_t *pg = (const int8_t *)(the_grid + j);
+                        int d2 = 0;
+                        for (k = 0; k < 8; ++k) d2 += (pg[k] - pos[k])*(pg[k] - pos[k]);
+                        dist2[2*j+0] = d2; dist2[2*j+1] = j;
+                    }
+                    qsort(dist2, HEX_NGRID_IQ1S, 2*sizeof(int), hex_iq1s_cmp);
+                    {
+                        int n = 0, d2 = dist2[0], nhave = 1;
+                        for (a = 0; a < HEX_NGRID_IQ1S; ++a) {
+                            if (dist2[2*a] > d2) {
+                                if (nhave == 3) break;
+                                d2 = dist2[2*a]; ++nhave;
+                            }
+                            ++n;
+                        }
+                        n_per_i[ii] = n;
+                        num_neighbors += n;
+                    }
+                }
+                free(dist2);
+            }
+        }
+        neighbours = (uint16_t *)malloc((num_neighbors + num_not_in_map)*sizeof(uint16_t));
+        offsets = (int *)malloc(HEX_KMAP_IQ1S_SIZE*sizeof(int));
+        if (!neighbours || !offsets) { free(neighbours); free(offsets); free(n_per_i); return; }
+        for (i = 0; i < HEX_KMAP_IQ1S_SIZE; ++i) {
+            if (kmap[i] >= 0) { offsets[i] = -1; continue; }
+            offsets[i] = counter;
+            counter += 1 + n_per_i[i];
+        }
+        #pragma omp parallel
+        {
+            int *dist2 = (int *)malloc(2*HEX_NGRID_IQ1S*sizeof(int));
+            int8_t pos[8];
+            int ii;
+            if (dist2) {
+                #pragma omp for schedule(dynamic, 64)
+                for (ii = 0; ii < HEX_KMAP_IQ1S_SIZE; ++ii) {
+                    int a;
+                    uint16_t *start;
+                    int local_counter, d2, n = 0, nhave = 1;
+                    if (kmap[ii] >= 0) continue;
+                    for (k = 0; k < 8; ++k) pos[k] = (int8_t)(2*((ii >> 2*k) & 0x3) + 1);
+                    for (j = 0; j < HEX_NGRID_IQ1S; ++j) {
+                        const int8_t *pg = (const int8_t *)(the_grid + j);
+                        int dd = 0;
+                        for (k = 0; k < 8; ++k) dd += (pg[k] - pos[k])*(pg[k] - pos[k]);
+                        dist2[2*j+0] = dd; dist2[2*j+1] = j;
+                    }
+                    qsort(dist2, HEX_NGRID_IQ1S, 2*sizeof(int), hex_iq1s_cmp);
+                    local_counter = offsets[ii];
+                    kmap[ii] = -(local_counter + 1);
+                    d2 = dist2[0];
+                    start = &neighbours[local_counter++];
+                    for (a = 0; a < HEX_NGRID_IQ1S; ++a) {
+                        if (dist2[2*a] > d2) {
+                            if (nhave == 3) break;
+                            d2 = dist2[2*a]; ++nhave;
+                        }
+                        neighbours[local_counter++] = (uint16_t)dist2[2*a+1];
+                        ++n;
+                    }
+                    *start = (uint16_t)n;
+                }
+                free(dist2);
+            }
+        }
+        free(offsets);
+        free(n_per_i);
+        hex_iq1s_neighbours = neighbours;
+    }
+}
+
+static int hex_nearest_int(float fval) {
+    float v = fval;
+    if (!(v > -4194303.f && v < 4194303.f)) v = v < 0 ? -4194303.f : 4194303.f;
+    {
+        float val = v + 12582912.f;
+        int i;
+        memcpy(&i, &val, sizeof(int));
+        return (i & 0x007fffff) - 0x00400000;
+    }
+}
+
+static void hex_iq1s_dequant_block(const BlockIQ1S *b, float *out) {
+    float d = gguf_fp16_to_fp32(b->d);
+    int ib, l, j;
+    const uint8_t *qs = b->qs;
+    for (ib = 0; ib < QK_K/32; ++ib) {
+        uint16_t h = b->qh[ib];
+        float dl = d * (2*((h >> 12) & 7) + 1);
+        float delta = (h & 0x8000) ? -HEX_IQ1S_DELTA : HEX_IQ1S_DELTA;
+        for (l = 0; l < 4; ++l) {
+            unsigned gi = (unsigned)qs[l] | (unsigned)(((h >> (3*l)) & 7) << 8);
+            const int8_t *grid = (const int8_t *)(hex_iq1s_dgrid + gi);
+            for (j = 0; j < 8; ++j) out[j] = dl * (grid[j] + delta);
+            out += 8;
+        }
+        qs += 4;
+    }
+}
+
+/* HPC IQ1_S tensor quantizer: mirrors quantize_tensor_q2k_hpc front-end
+ * (kurtosis-driven clamp, OpenMP, imatrix, MSE) with IQ1_S geometry. */
+
+/* ---- IQ1_S sieve/triality/vesica selection stage ----
+ * Geometry stays ggml-compatible (packing untouched); the SELECTION of
+ * per-sub-block configuration runs the same machinery as Q2_K/Q4_0/Q8_0:
+ * Boltzmann-encoded candidate errors -> triality mask -> CZ chain ->
+ * sieve_measure_graph -> in-bin selection with greedy override, then
+ * ULP polish accepted under the vesica/DC extended metric. */
+#define HEX_IQ1S_NCAND 6
+#define HEX_IQ1S_GROUP_BLKS 64
+static const int HEX_IQ1S_CAND_TO_QUHIT[6] = {0, 1, 2, 3, 4, 5};
+
+/* Evaluate one (boundaries, shift) candidate: L codes, WLS scale,
+ * grid indices, extended error (wSSE + spectral). */
+static float hex_iq1s_eval_cand(const float *xb, const float *weight,
+        const int *order, int i1, int i2, int shift,
+        const float *xxp, const float *xxm,
+        int8_t *Lout, uint16_t *idxout, float *scaleout)
+{
+    const float *xx = shift == 1 ? xxp : xxm;
+    int L[32];
+    float sumqx = 0.0f, sumq2 = 0.0f;
+    float scale;
+    float e[32];
+    int r, j, k;
+    if (i1 < 0) i1 = 0; if (i1 > 32) i1 = 32;
+    if (i2 < 0) i2 = 0; if (i2 > 32) i2 = 32;
+    if (i1 > i2) { int t = i1; i1 = i2; i2 = t; }
+    for (r = 0; r < i1; ++r) L[order[r]] = 0;
+    for (r = i1; r < i2; ++r) L[order[r]] = 1;
+    for (r = i2; r < 32; ++r) L[order[r]] = 2;
+    for (j = 0; j < 32; ++j) {
+        float q = xx[L[j]];
+        sumqx += weight[j]*q*xb[j];
+        sumq2 += weight[j]*q*q;
+    }
+    if (!(sumq2 > 0.0f)) return 1e30f;
+    scale = sumqx/sumq2;
+    if (scale < 0.0f) {
+        for (j = 0; j < 32; ++j) L[j] = 2 - L[j];
+        scale = -scale;
+    }
+    for (k = 0; k < 4; ++k) {
+        uint16_t u = 0;
+        for (j = 0; j < 8; ++j) u |= (uint16_t)(L[8*k+j] << 2*j);
+        {
+            int gi = hex_iq1s_map[u];
+            if (gi < 0) {
+                const uint16_t *neighbours = hex_iq1s_neighbours - hex_iq1s_map[u] - 1;
+                gi = hex_iq1s_best_neighbour(neighbours, hex_iq1s_grid,
+                        xb + 8*k, weight + 8*k, scale, xx, (int8_t *)(L + 8*k), HEX_NGRID_IQ1S);
+                if (gi < 0) return 1e30f;
+            }
+            idxout[k] = (uint16_t)gi;
+        }
+    }
+    /* reconstruct with final codes for scoring */
+    {
+        float wsum = 0.0f;
+        for (j = 0; j < 32; ++j) {
+            int grp = j / 8, pos = j % 8;
+            const int8_t *pg = (const int8_t *)(hex_iq1s_grid + idxout[grp]);
+            int code = (pg[pos] - 1)/2;
+            if (code < 0) code = 0; if (code > 2) code = 2;
+            e[j] = xb[j] - scale*xx[code];
+            wsum += weight[j]*e[j]*e[j];
+        }
+        wsum += hex_spectral_penalty(e, 32);
+        for (j = 0; j < 32; ++j) Lout[j] = (int8_t)L[j];
+        *scaleout = scale;
+        return wsum;
+    }
+}
+
+/* Extended block metric for ULP accept: wSSE + spectral + vesica/DC. */
+static float hex_iq1s_block_metric(const float *xb, const float *deq, const float *w)
+{
+    float e[256];
+    float sse = 0.0f, ves = 0.0f, dc = 0.0f;
+    int j;
+    for (j = 0; j < 256; ++j) {
+        e[j] = xb[j] - deq[j];
+        sse += (w ? w[j] : 1.0f)*e[j]*e[j];
+        dc += e[j];
+    }
+    for (j = 0; j < 128; ++j) {
+        float v = e[j] + e[j+128];
+        ves += v*v;
+    }
+    return sse + hex_spectral_penalty(e, 256) + (4.0f*ves + dc*dc)/256.0f;
+}
+static void quantize_tensor_iq1_s_hpc(const float *weights, int64_t n_elements,
+                                      BlockIQ1S *output, float *out_total_error,
+                                      const float *imat_importance,
+                                      int verbose)
+
+{
+    int64_t n_blocks;
+    float total_err = 0.0f;
+    double t_sum_sq = 0.0, t_sum_4 = 0.0;
+    double t_var, t_kurt;
+    float w_sigma, clamp_sigma, clamp_val;
+    int64_t i, gbase;
+    int SMAX = HEX_IQ1S_GROUP_BLKS*8;
+    int NC = HEX_IQ1S_NCAND;
+    int plain = 0; /* HEX_IQ1S_PLAIN=1: ggml-exact, no sieve/ULP (A/B reference) */
+    float *g_err = NULL;
+    int8_t *g_i1 = NULL, *g_i2 = NULL, *g_sh = NULL;
+    float *g_sc = NULL;
+    uint16_t *g_gi = NULL;
+    int *g_sel = NULL;
+
+    if (!weights || !output || n_elements <= 0 || n_elements % QK_K != 0) {
+        if (out_total_error) *out_total_error = -1.0f;
+        return;
+    }
+    hex_iq1s_init();
+    if (!hex_iq1s_grid || !hex_iq1s_map || !hex_iq1s_neighbours || !hex_iq1s_dgrid) {
+        if (out_total_error) *out_total_error = -1.0f;
+        return;
+    }
+    n_blocks = n_elements / QK_K;
+    {
+        const char *penv = getenv("HEX_IQ1S_PLAIN");
+        if (penv && penv[0] == '1') plain = 1;
+    }
+
+    for (i = 0; i < n_elements; i++) {
+        double w2 = (double)weights[i] * (double)weights[i];
+        t_sum_sq += w2;
+        t_sum_4  += w2 * w2;
+    }
+    w_sigma = sqrtf((float)(t_sum_sq / (double)n_elements));
+    t_var  = t_sum_sq / (double)n_elements;
+    t_kurt = (t_var > 1e-30) ? (t_sum_4 / (double)n_elements) / (t_var * t_var) : 3.0;
+    if      (t_kurt <= 6.0)  clamp_sigma = 1.0e9f;
+    else if (t_kurt <= 20.0) clamp_sigma = 6.0f;
+    else                     clamp_sigma = 4.0f;
+    clamp_val = w_sigma * clamp_sigma;
+    if (verbose) {
+        char kl[128];
+        sprintf(kl, "    [iq1_s-hpc] kurt=%.2f clamp=%.3g sigma=%.6g sieve=on", t_kurt, (double)clamp_val, (double)w_sigma);
+        puts(kl);
+    }
+
+    g_err = (float *)malloc((size_t)SMAX*NC*sizeof(float));
+    g_i1 = (int8_t *)malloc((size_t)SMAX*NC);
+    g_i2 = (int8_t *)malloc((size_t)SMAX*NC);
+    g_sh = (int8_t *)malloc((size_t)SMAX*NC);
+    g_sc = (float *)malloc((size_t)SMAX*NC*sizeof(float));
+    g_gi = (uint16_t *)malloc((size_t)SMAX*NC*4*sizeof(uint16_t));
+    g_sel = (int *)malloc((size_t)SMAX*sizeof(int));
+    if (!g_err || !g_i1 || !g_i2 || !g_sh || !g_sc || !g_gi || !g_sel) {
+        free(g_err); free(g_i1); free(g_i2); free(g_sh); free(g_sc); free(g_gi); free(g_sel);
+        if (out_total_error) *out_total_error = -1.0f;
+        return;
+    }
+
+    for (gbase = 0; gbase < n_blocks; gbase += HEX_IQ1S_GROUP_BLKS) {
+        int64_t gb = n_blocks - gbase;
+        int ns, u, s, c;
+        HPCGraph *graph = NULL;
+        double (*marg)[6] = NULL;
+        int *measured = NULL;
+        int shor_ran = 0;
+        float temperature = 0.5f;
+        if (gb > HEX_IQ1S_GROUP_BLKS) gb = HEX_IQ1S_GROUP_BLKS;
+        ns = (int)(gb*8);
+
+        /* Phase 1+2: greedy seeds + sieve candidates (parallel over sub-blocks) */
+        #pragma omp parallel for schedule(dynamic, 8)
+        for (u = 0; u < ns; ++u) {
+            int64_t blk = gbase + u/8;
+            int ib = u%8;
+            const float *xbl = weights + blk*QK_K;
+            const float *qwb = imat_importance ? imat_importance + blk*QK_K : NULL;
+            const float *xb = xbl + 32*ib;
+            float qw[32], weight[32], xc[32];
+            hex_sort_pair pairs[32];
+            int order[32];
+            float sumx[33], sumw[33];
+            float xp[3], xm[3];
+            float best_scale, maxv;
+            int besti1, besti2, best_shift;
+            int i1, i2, j;
+            int ci1[6], ci2[6], csh[6];
+            float qwo[32];
+            if (!qwb) {
+                for (j = 0; j < 32; ++j) qwo[j] = 1.0f;
+                qwb = qwo;
+            }
+            for (j = 0; j < 32; ++j) {
+                qw[j] = qwb[j];
+                weight[j] = qw[j] * sqrtf(1.0f + xb[j]*xb[j]);
+            }
+            maxv = fabsf(xb[0]);
+            for (j = 1; j < 32; ++j) { float a = fabsf(xb[j]); if (a > maxv) maxv = a; }
+            if (!(maxv >= HEX_GROUP_MAX_EPS_IQ1_S)) {
+                for (c = 0; c < NC; ++c) {
+                    g_err[u*NC+c] = 1e30f;
+                    g_i1[u*NC+c] = 0; g_i2[u*NC+c] = 0; g_sh[u*NC+c] = 1;
+                    g_sc[u*NC+c] = 0.0f;
+                    g_gi[(u*NC+c)*4+0] = 0; g_gi[(u*NC+c)*4+1] = 0;
+                    g_gi[(u*NC+c)*4+2] = 0; g_gi[(u*NC+c)*4+3] = 0;
+                }
+                continue;
+            }
+            {
+                float sumx2 = 0.0f;
+                for (j = 0; j < QK_K; ++j) sumx2 += xbl[j]*xbl[j];
+                {
+                    float s2 = 2*sumx2/QK_K;
+                    for (j = 0; j < 32; ++j) weight[j] = qw[j] * sqrtf(s2 + xb[j]*xb[j]);
+                }
+            }
+            for (j = 0; j < 32; ++j) {
+                float v = xb[j];
+                if (v > clamp_val) v = clamp_val;
+                if (v < -clamp_val) v = -clamp_val;
+                xc[j] = v;
+                pairs[j].v = v; pairs[j].i = j;
+            }
+            qsort(pairs, 32, sizeof(hex_sort_pair), hex_iq1s_sort_helper);
+            for (j = 0; j < 32; ++j) order[j] = pairs[j].i;
+            sumx[0] = sumw[0] = 0.0f;
+            for (j = 0; j < 32; ++j) {
+                int gi2 = order[j];
+                sumx[j+1] = sumx[j] + weight[gi2]*xc[gi2];
+                sumw[j+1] = sumw[j] + weight[gi2];
+            }
+            xp[0] = -1 + HEX_IQ1S_DELTA; xp[1] = HEX_IQ1S_DELTA; xp[2] = 1 + HEX_IQ1S_DELTA;
+            xm[0] = -1 - HEX_IQ1S_DELTA; xm[1] = -HEX_IQ1S_DELTA; xm[2] = 1 - HEX_IQ1S_DELTA;
+            {
+                float bsc = -1e30f;
+                best_scale = maxv; besti1 = 0; besti2 = 0; best_shift = 1;
+                for (i1 = 0; i1 <= 32; ++i1) {
+                    for (i2 = i1; i2 <= 32; ++i2) {
+                        float sumqx = (sumx[i1]-sumx[0])*xp[0] + (sumx[i2]-sumx[i1])*xp[1] + (sumx[32]-sumx[i2])*xp[2];
+                        float sumq2 = (sumw[i1]-sumw[0])*xp[0]*xp[0] + (sumw[i2]-sumw[i1])*xp[1]*xp[1] + (sumw[32]-sumw[i2])*xp[2]*xp[2];
+                        if (sumq2 > 0 && sumqx*sumqx > bsc*sumq2) {
+                            best_scale = sumqx/sumq2; bsc = best_scale*sumqx;
+                            besti1 = i1; besti2 = i2; best_shift = 1;
+                        }
+                        sumqx = (sumx[i1]-sumx[0])*xm[0] + (sumx[i2]-sumx[i1])*xm[1] + (sumx[32]-sumx[i2])*xm[2];
+                        sumq2 = (sumw[i1]-sumw[0])*xm[0]*xm[0] + (sumw[i2]-sumw[i1])*xm[1]*xm[1] + (sumw[32]-sumw[i2])*xm[2]*xm[2];
+                        if (sumq2 > 0 && sumqx*sumqx > bsc*sumq2) {
+                            best_scale = sumqx/sumq2; bsc = best_scale*sumqx;
+                            besti1 = i1; besti2 = i2; best_shift = -1;
+                        }
+                    }
+                }
+            }
+            ci1[0] = besti1; ci2[0] = besti2; csh[0] = best_shift;
+            ci1[1] = besti1-1; ci2[1] = besti2; csh[1] = best_shift;
+            ci1[2] = besti1+1; ci2[2] = besti2; csh[2] = best_shift;
+            ci1[3] = besti1; ci2[3] = besti2-1; csh[3] = best_shift;
+            ci1[4] = besti1; ci2[4] = besti2+1; csh[4] = best_shift;
+            ci1[5] = besti1; ci2[5] = besti2; csh[5] = -best_shift;
+            for (c = 0; c < NC; ++c) {
+                int8_t Lc[32];
+                uint16_t ix[4];
+                float sc = 0.0f;
+                float e = hex_iq1s_eval_cand(xb, weight, order, ci1[c], ci2[c], csh[c],
+                                             xp, xm, Lc, ix, &sc);
+                g_err[u*NC+c] = e;
+                g_i1[u*NC+c] = (int8_t)(ci1[c] < 0 ? 0 : ci1[c] > 32 ? 32 : ci1[c]);
+                g_i2[u*NC+c] = (int8_t)(ci2[c] < 0 ? 0 : ci2[c] > 32 ? 32 : ci2[c]);
+                g_sh[u*NC+c] = (int8_t)csh[c];
+                g_sc[u*NC+c] = sc;
+                g_gi[(u*NC+c)*4+0] = ix[0]; g_gi[(u*NC+c)*4+1] = ix[1];
+                g_gi[(u*NC+c)*4+2] = ix[2]; g_gi[(u*NC+c)*4+3] = ix[3];
+            }
+        }
+
+        /* Phase 3: triality encode + CZ chain + sieve measurement (mirrors Q4) */
+        graph = hpc_create((uint64_t)ns);
+        if (graph) {
+            {
+                double eacc = 0.0;
+                int ecount = 0;
+                for (s = 0; s < ns && s < 100; ++s) {
+                    float mx = 0.0f;
+                    for (c = 0; c < NC; ++c)
+                        if (g_err[s*NC+c] > mx) mx = g_err[s*NC+c];
+                    eacc += (double)mx; ecount++;
+                }
+                if (ecount > 0) {
+                    temperature = (float)(eacc / ecount) * 0.1f;
+                    if (temperature < 1e-10f) temperature = 1e-10f;
+                }
+            }
+            for (s = 0; s < ns; ++s) triality_dft(&graph->locals[s]);
+            for (s = 0; s < ns; ++s) {
+                float mn = 1e30f;
+                double amp_re[6], amp_norm = 0.0;
+                int v;
+                for (c = 0; c < NC; ++c)
+                    if (g_err[s*NC+c] < mn) mn = g_err[s*NC+c];
+                for (v = 0; v < 6; ++v) amp_re[v] = 0.0;
+                for (c = 0; c < NC; ++c) {
+                    int qi = HEX_IQ1S_CAND_TO_QUHIT[c];
+                    amp_re[qi] += exp(-(double)(g_err[s*NC+c] - mn) / (2.0*(double)temperature));
+                }
+                for (v = 0; v < 6; ++v) amp_norm += amp_re[v]*amp_re[v];
+                if (amp_norm > 1e-30) {
+                    double inv = 1.0/sqrt(amp_norm);
+                    for (v = 0; v < 6; ++v) amp_re[v] *= inv;
+                }
+                for (v = 0; v < 6; ++v) {
+                    graph->locals[s].edge_re[v] = amp_re[v];
+                    graph->locals[s].edge_im[v] = 0.0;
+                }
+                graph->locals[s].primary = VIEW_EDGE;
+                graph->locals[s].dirty = DIRTY_VERTEX | DIRTY_DIAGONAL | DIRTY_FOLDED;
+                graph->locals[s].delta_valid = 0;
+                triality_update_mask(&graph->locals[s]);
+            }
+            for (s = 0; s < ns - 1; ++s) hpc_cz(graph, (uint64_t)s, (uint64_t)(s+1));
+            marg = (double (*)[6])calloc((size_t)ns, sizeof(double[6]));
+            measured = (int *)calloc((size_t)ns, sizeof(int));
+            if (marg && measured) {
+                sieve_measure_graph(graph, (int64_t)ns, marg, measured, 1);
+                for (s = 0; s < ns; ++s) {
+                    int bin = measured[s];
+                    int bb = 0, gb2 = 0;
+                    float be = 1e30f, ge = 1e30f;
+                    int bc = -1, gc = 0;
+                    if (bin < 0 || bin > 5) {
+                        double bm = -1.0;
+                        bin = 0;
+                        for (int v = 0; v < 6; ++v)
+                            if (marg[s][v] > bm) { bm = marg[s][v]; bin = v; }
+                    }
+                    for (c = 0; c < NC; ++c) {
+                        float e = g_err[s*NC+c];
+                        if (e < ge) { ge = e; gc = c; }
+                        if (HEX_IQ1S_CAND_TO_QUHIT[c] == bin && e < be) { be = e; bc = c; }
+                    }
+                    {
+                        int sel = (bc >= 0) ? bc : gc;
+                        if (ge < g_err[s*NC+sel] * HEX_GREEDY_OVERRIDE_RATIO) sel = gc;
+                        g_sel[s] = sel;
+                    }
+                    (void)bb; (void)gb2;
+                }
+                shor_ran = 1;
+            }
+            free(marg); free(measured);
+            hpc_destroy(graph);
+        }
+        if (!shor_ran) {
+            for (s = 0; s < ns; ++s) {
+                float gb2 = g_err[s*NC+0];
+                int gc = 0;
+                for (c = 1; c < NC; ++c)
+                    if (g_err[s*NC+c] < gb2) { gb2 = g_err[s*NC+c]; gc = c; }
+                g_sel[s] = gc;
+            }
+        }
+        if (plain) {
+            /* ggml-exact reference: exhaustive optimum only, no sieve. */
+            for (s = 0; s < ns; ++s) g_sel[s] = 0;
+        }
+
+        /* Phase 4: pack winners + ULP polish under vesica guard + MSE */
+        #pragma omp parallel for schedule(dynamic, 8) reduction(+:total_err)
+        for (int64_t b = 0; b < gb; ++b) {
+            int64_t blk = gbase + b;
+            const float *xbl = weights + blk*QK_K;
+            const float *qwb = imat_importance ? imat_importance + blk*QK_K : NULL;
+            BlockIQ1S *yb = &output[blk];
+            float scales[8];
+            int8_t shifts[8];
+            float max_scale = 0.0f;
+            uint16_t qh_base[8];
+            float d, id;
+            uint16_t d16;
+            BlockIQ1S tmp;
+            float deq[256];
+            float best_metric;
+            int ib, ii, k, du;
+            float qw1[256];
+            const float *ww = qwb;
+            yb->d = 0;
+            memset(yb->qs, 0, QK_K/8);
+            memset(yb->qh, 0, QK_K/16);
+            if (!ww) {
+                for (ii = 0; ii < 256; ++ii) qw1[ii] = 1.0f;
+                ww = qw1;
+            }
+            for (ib = 0; ib < 8; ++ib) {
+                int sel = g_sel[b*8+ib];
+                scales[ib] = g_sc[(b*8+ib)*NC+sel];
+                shifts[ib] = g_sh[(b*8+ib)*NC+sel];
+                if (scales[ib] > max_scale) max_scale = scales[ib];
+                {
+                    uint16_t h = 0;
+                    for (k = 0; k < 4; ++k) {
+                        uint16_t gx = g_gi[((b*8+ib)*NC+sel)*4+k];
+                        yb->qs[4*ib+k] = (uint8_t)(gx & 255);
+                        h |= (uint16_t)((gx >> 8) << 3*k);
+                    }
+                    qh_base[ib] = h;
+                    yb->qh[ib] = h;
+                }
+            }
+            if (!(max_scale > 0.0f)) continue;
+            d = max_scale/15.0f;
+            d16 = gguf_fp32_to_fp16(d*1.125f);
+            yb->d = d16;
+            id = 1.0f/d;
+            for (ib = 0; ib < 8; ++ib) {
+                int l = hex_nearest_int(0.5f*(id*scales[ib]-1.0f));
+                if (l < 0) l = 0; if (l > 7) l = 7;
+                if (shifts[ib] == -1) l |= 8;
+                yb->qh[ib] |= (uint16_t)(l << 12);
+            }
+            memcpy(&tmp, yb, sizeof(BlockIQ1S));
+            hex_iq1s_dequant_block(&tmp, deq);
+            best_metric = hex_iq1s_block_metric(xbl, deq, ww);
+            if (!plain) {
+            for (du = -8; du <= 8; ++du) {
+                int c16;
+                float td;
+                float tid;
+                float tdeq[256];
+                float m;
+                if (du == 0) continue;
+                c16 = (int)d16 + du;
+                if (c16 <= 0 || c16 > 0x7BFF) continue;
+                td = gguf_fp16_to_fp32((uint16_t)c16);
+                if (!(td > 0.0f)) continue;
+                memcpy(&tmp, yb, sizeof(BlockIQ1S));
+                tmp.d = (uint16_t)c16;
+                tid = 1.0f/(td/1.125f);
+                for (ib = 0; ib < 8; ++ib) {
+                    int l = hex_nearest_int(0.5f*(tid*scales[ib]-1.0f));
+                    if (l < 0) l = 0; if (l > 7) l = 7;
+                    if (shifts[ib] == -1) l |= 8;
+                    tmp.qh[ib] = (uint16_t)(qh_base[ib] | (l << 12));
+                }
+                hex_iq1s_dequant_block(&tmp, tdeq);
+                m = hex_iq1s_block_metric(xbl, tdeq, ww);
+                if (m < best_metric) {
+                    best_metric = m;
+                    memcpy(yb, &tmp, sizeof(BlockIQ1S));
+                    memcpy(deq, tdeq, sizeof(deq));
+                }
+            }
+            } /* end ULP polish (skipped in plain mode) */
+            for (ii = 0; ii < 256; ++ii) {
+                float e = xbl[ii] - deq[ii];
+                total_err += e*e;
+            }
+        }
+    }
+
+    free(g_err); free(g_i1); free(g_i2); free(g_sh); free(g_sc); free(g_gi); free(g_sel);
+    if (out_total_error) *out_total_error = total_err;
+}
+
+
 void hexstate_init(void)
 {
     static int initialized = 0;
@@ -5322,6 +6169,50 @@ void hexstate_quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
                              imat_importance, verbose);
 }
 
+/* IQ1_S via the HPC pipeline (same machinery as Q2_K, IQ1_S geometry).
+ * n_elements must be a multiple of 256; output needs n/256*50 bytes. */
+void hexstate_quantize_tensor_iq1_s(const float *weights, int64_t n_elements,
+                                    void *output, float *out_error,
+                                    int verbose)
+{
+    hexstate_init();
+    if (!weights || !output || n_elements <= 0 || n_elements % QK_K != 0) {
+        if (out_error) *out_error = -1.0f;
+        return;
+    }
+    {
+        /* uniform importance: weight = sqrt(sigma2 + x^2) */
+        float *wbuf = (float *)malloc((size_t)n_elements * sizeof(float));
+        int64_t i;
+        if (!wbuf) { if (out_error) *out_error = -1.0f; return; }
+        for (i = 0; i < n_elements; ++i) wbuf[i] = 1.0f;
+        quantize_tensor_iq1_s_hpc(weights, n_elements,
+                                  (BlockIQ1S *)output, out_error,
+                                  wbuf, verbose);
+        free(wbuf);
+    }
+}
+
+void hexstate_quantize_tensor_iq1_s_imat(const float *weights, int64_t n_elements,
+                                         void *output, float *out_error,
+                                         const float *imat_importance,
+                                         int verbose)
+{
+    hexstate_init();
+    quantize_tensor_iq1_s_hpc(weights, n_elements,
+                              (BlockIQ1S *)output, out_error,
+                              imat_importance, verbose);
+}
+
+int hexstate_iq1s_block_bytes(void)    { return (int)sizeof(BlockIQ1S); }
+int hexstate_iq1s_block_elements(void) { return QK_K; }
+
+/* Debug/test: dequantize one block. */
+void hexstate_iq1s_dequant_dbg(const void *block, float *out) {
+    hex_iq1s_init();
+    hex_iq1s_dequant_block((const BlockIQ1S *)block, out);
+}
+
 #ifndef HEXSTATE_LIBRARY
 /* ═══════════════════════════════════════════════════════════════════════════
  * MAIN

hexstate_requantize.py

@@ -96,6 +96,24 @@ def _load_hexstate_lib():
                 ctypes.c_int,                     # verbose
             ]
 
+        # IQ1_S HPC quantizer (same HPC machinery as Q2_K, IQ1_S geometry)
+        if hasattr(lib, 'hexstate_quantize_tensor_iq1_s_imat'):
+            lib.hexstate_quantize_tensor_iq1_s_imat.restype = None
+            lib.hexstate_quantize_tensor_iq1_s_imat.argtypes = [
+                ctypes.POINTER(ctypes.c_float),  # weights
+                ctypes.c_int64,                   # n_elements
+                ctypes.c_void_p,                  # output
+                ctypes.POINTER(ctypes.c_float),   # out_error
+                ctypes.POINTER(ctypes.c_float),   # imat_importance (can be NULL)
+                ctypes.c_int,                     # verbose
+            ]
+
+        if hasattr(lib, 'hexstate_iq1s_block_bytes'):
+            lib.hexstate_iq1s_block_bytes.restype = ctypes.c_int
+            lib.hexstate_iq1s_block_bytes.argtypes = []
+            lib.hexstate_iq1s_block_elements.restype = ctypes.c_int
+            lib.hexstate_iq1s_block_elements.argtypes = []
+
         lib.hexstate_init()
         _HEXSTATE_LIB = lib
         return lib
@@ -260,6 +278,56 @@ def quantize_tensor_q2k_hpc(f32_data, opt_mode=2, importance=None):
     return output.tobytes(), n_blocks
 
 
+def quantize_tensor_iq1_s_hpc(f32_data, importance=None):
+    """Quantize tensor to IQ1_S using the HexState HPC C implementation.
+
+    Verbatim counterpart of quantize_tensor_q2k_hpc: same padding,
+    same buffer handling, same imatrix plumbing; only the C entry
+    point and block geometry (50 B / 256 el) differ.
+    importance: optional per-element importance weights (from imatrix)
+    Returns: (bytes, n_blocks, rmse)
+    """
+    lib = _load_hexstate_lib()
+    if lib is None:
+        raise RuntimeError("HexState library not available")
+
+    n_elements = len(f32_data)
+    if n_elements % QK_K != 0:
+        pad_len = QK_K - (n_elements % QK_K)
+        f32_data = np.concatenate([f32_data, np.zeros(pad_len, dtype=np.float32)])
+        if importance is not None:
+            importance = np.concatenate([importance, np.ones(pad_len, dtype=np.float32)])
+        n_elements = len(f32_data)
+
+    n_blocks = n_elements // QK_K
+    block_bytes = lib.hexstate_iq1s_block_bytes()  # 50
+
+    # Allocate output buffer
+    output = np.zeros(n_blocks * block_bytes, dtype=np.uint8)
+    error = ctypes.c_float(0.0)
+
+    # Call C quantizer with or without importance weights
+    f32_contiguous = np.ascontiguousarray(f32_data, dtype=np.float32)
+
+    if importance is not None:
+        imat_contiguous = np.ascontiguousarray(importance, dtype=np.float32)
+        imat_ptr = imat_contiguous.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+    else:
+        imat_ptr = None
+
+    lib.hexstate_quantize_tensor_iq1_s_imat(
+        f32_contiguous.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+        ctypes.c_int64(n_elements),
+        output.ctypes.data_as(ctypes.c_void_p),
+        ctypes.byref(error),
+        imat_ptr,
+        ctypes.c_int(1),  # verbose
+    )
+
+    rmse = float(np.sqrt(max(error.value, 0.0) / max(n_elements, 1)))
+    return output.tobytes(), n_blocks, rmse
+
+
 # ─── Constants ──────────────────────────────────────────────────────────────
 GGUF_MAGIC = 0x46554747
 GGUF_VERSION = 3
@@ -271,24 +339,27 @@ GGML_TYPE_F16   = 1
 GGML_TYPE_Q4_0  = 2
 GGML_TYPE_Q8_0  = 8
 GGML_TYPE_Q2_K  = 10
+GGML_TYPE_IQ1_S = 19
 GGML_TYPE_BF16  = 30
 
+IQ1S_TYPE_SIZE = 50  # bytes per 256-element IQ1_S block
+
 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", 30: "BF16",
+    13: "Q5_K", 14: "Q6_K", 15: "Q8_K", 19: "IQ1_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, 30: 1,
+    13: 256, 14: 256, 15: 256, 19: 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, 30: 2,
+    13: 176, 14: 210, 15: 292, 19: 50, 30: 2,
 }
 
 
@@ -652,6 +723,9 @@ def is_q4_tensor(name):
     Attention/FFN are NOT matched here — they keep their Q2_K plan.
     NOTE: 'output.weight' is exact-matched so 'attn_output.weight'
     never matches.
+    NOTE 2: ssm_beta is deliberately NOT matched here — the default Q2_K
+    pipeline ships it at Q2_K (proven good). Only the --iq1-all branch
+    promotes it (see main()), because 1-bit recurrent dynamics diverge.
     """
     if name == 'output.weight' or name.endswith('.output.weight'):
         return True
@@ -764,7 +838,7 @@ 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]")
+              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all] [--q2kall] [--iq1-all]")
         sys.exit(1)
 
     input_path = sys.argv[1]
@@ -772,6 +846,8 @@ def main():
     keep_metadata = '--keep-metadata' in sys.argv
     quantize_none = '--quantize-none' in sys.argv
     q2all = '--q2all' in sys.argv
+    q2kall = '--q2kall' in sys.argv          # verbatim duplicate of --q2all
+    iq1all = '--iq1-all' in sys.argv         # verbatim duplicate of --q2all, IQ1_S target
     keep_embd = '--keep-embd' in sys.argv   # keep tied embedding at source precision instead of Q8_0
 
     # Check for imatrix
@@ -793,8 +869,10 @@ def main():
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  HExState GGUF Re-Quantizer                                  ║")
     print("  ║  GGUF → Q2_K GGUF with metadata passthrough                  ║")
-    if q2all:
-        print("  ║  Mode: --q2all  ALL eligible tensors → Q2_K (test mode)      ║")
+    if q2all or q2kall:
+        print("  ║  Mode: --q2all/--q2kall  ALL eligible tensors → Q2_K (test mode) ║")
+    if iq1all:
+        print("  ║  Mode: --iq1-all  ALL eligible tensors → IQ1_S (test mode)  ║")
     if use_hpc and imatrix_data:
         print("  ║  Engine: HPC + iMatrix (calibrated sensitivity propagation)  ║")
     elif use_hpc:
@@ -881,6 +959,21 @@ def main():
         total_attn = 0
         total_keep = 0
         total_embd = 0
+        # For --iq1-all: replicate llama.cpp's MOSTLY_IQ1_S preset mix with
+        # the types this pipeline supports (Q2_K/Q4_0-HPC/IQ1_S):
+        #   attn_v (separate) -> Q4  (preset: Q4_K; V carries content)
+        #   attn/ssm output   -> Q4  (preset: IQ2_XXS for attn_o)
+        #   token_embd        -> Q2_K (preset: Q2_K)
+        #   ffn_down first 1/8 layers -> Q2_K (preset: Q2_K)
+        #   rest (attn_q/k incl. fused qkv, ffn_up/gate, ffn_down) -> IQ1_S
+        # Pure-1-bit attention (esp. V) severs contextual linkage while
+        # leaving local fluency intact — the observed failure mode.
+        def _ti_bid(name):
+            for part in name.split('.'):
+                if part.isdecimal():
+                    return int(part)
+            return None
+        n_ffn_down = sum(1 for ti in tensor_infos if '.ffn_down.weight' in ti['name'])
         for ti in tensor_infos:
             if quantize_none:
                 will_quant = False
@@ -896,7 +989,7 @@ def main():
                 will_quant = 'EMBD_Q8'
                 total_embd += 1
             elif should_quantize(ti['name'], ti['n_dims'], ti['dims'], tied_embeddings):
-                if q2all:
+                if q2all or q2kall:
                     if q2k_row_compatible(ti['n_dims'], ti['dims']):
                         will_quant = True; total_quant += 1
                     elif q4_row_compatible(ti['n_dims'], ti['dims']):
@@ -905,6 +998,41 @@ def main():
                     else:
                         will_quant = False; total_keep += 1
                         print(f"  Q2ALL→KEEP (row width not block-aligned): {ti['name']}")
+                elif iq1all:
+                    nm = ti['name']
+                    is_sep_v = ('.attn_v.weight' in nm or 'v_proj.weight' in nm) \
+                        and 'qkv' not in nm
+                    is_out = ('.attn_output.weight' in nm or 'o_proj.weight' in nm
+                              or 'ssm_out.weight' in nm)
+                    is_embd = (nm == 'token_embd.weight' or '.token_embd.weight' in nm)
+                    bid = _ti_bid(nm)
+                    is_early_ffn = ('.ffn_down.weight' in nm and bid is not None
+                                    and n_ffn_down > 0 and bid < (n_ffn_down + 7) // 8)
+                    if ((is_q4_tensor(nm) and not is_embd) or 'ssm_beta.weight' in nm) \
+                            and q4_row_compatible(ti['n_dims'], ti['dims']):
+                        # Q4-class tensors (output/ssm_alpha) stay Q4_0-HPC.
+                        # ssm_beta joins them ONLY here: it is the recurrent
+                        # partner of ssm_alpha and 1-bit dynamics diverge.
+                        # Default mode still ships ssm_beta at Q2_K (proven).
+                        will_quant = 'Q4_HPC'; total_attn += 1
+                    elif (is_sep_v or is_out) \
+                            and q4_row_compatible(ti['n_dims'], ti['dims']):
+                        # Preset keeps V at Q4_K and O at IQ2_XXS; closest
+                        # available is Q4_0-HPC. (Fused qkv can't split and
+                        # stays IQ1_S like the preset's Q/K.)
+                        will_quant = 'Q4_HPC'; total_attn += 1
+                    elif (is_embd or is_early_ffn) \
+                            and q2k_row_compatible(ti['n_dims'], ti['dims']):
+                        # Preset: embeddings and first-1/8 FFN-down at Q2_K.
+                        will_quant = True; total_quant += 1
+                    elif q2k_row_compatible(ti['n_dims'], ti['dims']):
+                        will_quant = 'IQ1_S'; total_quant += 1
+                    elif q4_row_compatible(ti['n_dims'], ti['dims']):
+                        will_quant = 'Q4_0'; total_quant += 1
+                        print(f"  IQ1ALL→Q4_0 (row width not 256-aligned): {ti['name']}")
+                    else:
+                        will_quant = False; total_keep += 1
+                        print(f"  IQ1ALL→KEEP (row width not block-aligned): {ti['name']}")
                 elif is_q4_tensor(ti['name']) and q4_row_compatible(ti['n_dims'], ti['dims']):
                     # Q4_0 path (HPC sieve). dim0 — not just total n — must be
                     # block-aligned: GGUF quants tile along rows and llama.cpp
@@ -921,10 +1049,15 @@ def main():
                 total_keep += 1
             quant_plan.append(will_quant)
 
-        if q2all:
-            print("  Mode: --q2all — Q2_K wherever block-compatible; safe Q4/keep otherwise")
+        if q2all or q2kall:
+            print("  Mode: --q2all/--q2kall — Q2_K wherever block-compatible; safe Q4/keep otherwise")
             print(f"  Tensors to quantize (Q2_K):     {total_quant}")
             print(f"  Tensors to keep as-is:          {total_keep}")
+        elif iq1all:
+            print("  Mode: --iq1-all — IQ1_S wherever block-compatible; safe Q4/keep otherwise")
+            print(f"  Tensors to quantize (IQ1_S):    {total_quant}")
+            print(f"  Tensors to promote (Q4_0·HPC):  {total_attn}")
+            print(f"  Tensors to keep as-is:          {total_keep}")
         else:
             print(f"  Tensors to quantize (Q2_K):     {total_quant}")
             print(f"  Tensors to promote (Q4_0·HPC):  {total_attn}")
@@ -958,6 +1091,11 @@ def main():
                     n_blocks = ti['n_elements'] // 32
                     out_size = n_blocks * 18
                     print(f"  Q4_0: {ti['name']} (dims[0]={dim0})")
+                elif quant_plan[i] == 'IQ1_S':
+                    out_type = GGML_TYPE_IQ1_S
+                    n_blocks = ti['n_elements'] // QK_K
+                    out_size = n_blocks * IQ1S_TYPE_SIZE
+                    print(f"  [IQ1_S·HPC] {ti['name']} ({ti['n_elements']:,} elements)")
                 elif quant_plan[i] is True and q2k_row_compatible(ti['n_dims'], ti['dims']):
                     out_type = GGML_TYPE_Q2_K
                     n_blocks = ti['n_elements'] // QK_K
@@ -991,8 +1129,8 @@ def main():
         else:
             for key, vtype, raw_value in kv_pairs:
                 if key == 'general.file_type' and vtype == 4:  # UINT32
-                    # file_type=10 means Q2_K in llama.cpp
-                    updated_kv.append((key, vtype, struct.pack('<I', 10)))
+                    # file_type=10 means Q2_K, 24 means IQ1_S in llama.cpp
+                    updated_kv.append((key, vtype, struct.pack('<I', 24 if iq1all else 10)))
                 elif key == 'general.quantization_version' and vtype == 4:
                     updated_kv.append((key, vtype, struct.pack('<I', 2)))
                 elif key == 'tokenizer.ggml.token_type' and vtype == 9:
@@ -1240,6 +1378,74 @@ def main():
                     quant_count += 1
                     total_quant_bytes += n_blocks_q4 * 18
 
+                elif quant_plan[i] == 'IQ1_S':
+                    # Convert to F32 for quantization
+                    if ti['type'] == GGML_TYPE_BF16:
+                        f32 = bf16_to_f32(raw_data, ti['n_elements'])
+                    elif ti['type'] == GGML_TYPE_F16:
+                        f32 = f16_to_f32(raw_data, ti['n_elements'])
+                    elif ti['type'] == GGML_TYPE_F32:
+                        f32 = np.frombuffer(raw_data, dtype=np.float32).copy()
+                    else:
+                        # Can't re-quantize from quantized format — keep as-is
+                        fout.write(raw_data)
+                        pad = align_offset(fout.tell()) - fout.tell()
+                        if pad > 0:
+                            fout.write(b'\x00' * pad)
+                        continue
+
+                    # Quantize to IQ1_S — always use HPC with chunked processing
+                    # Each chunk gets full HPC treatment (no size threshold)
+                    row_width = int(ti['dims'][0])
+                    HPC_CHUNK = max(row_width, (50_000_000 // row_width) * row_width)
+
+                    # Look up imatrix importance for this tensor
+                    imat_full = _expand_imatrix(ti, imatrix_data)
+
+                    n_el = ti['n_elements']
+                    if use_hpc and n_el <= HPC_CHUNK:
+                        # Small tensor — single HPC pass
+                        iq1_data, n_blocks, tensor_rmse = quantize_tensor_iq1_s_hpc(f32, importance=imat_full)
+                    elif use_hpc:
+                        # Large tensor — chunked HPC (each chunk gets BP)
+                        chunks = []
+                        processed = 0
+                        se_sum = 0.0
+                        while processed < n_el:
+                            end = min(processed + HPC_CHUNK, n_el)
+                            chunk_f32 = f32[processed:end]
+                            if len(chunk_f32) % QK_K != 0:
+                                pad_len = QK_K - (len(chunk_f32) % QK_K)
+                                chunk_f32 = np.concatenate([chunk_f32, np.zeros(pad_len, dtype=np.float32)])
+                            chunk_imp = imat_full[processed:end] if imat_full is not None else None
+                            if chunk_imp is not None and len(chunk_imp) < len(chunk_f32):
+                                chunk_imp = np.concatenate([chunk_imp, np.ones(len(chunk_f32) - len(chunk_imp), dtype=np.float32)])
+                            chunk_data, _, chunk_rmse = quantize_tensor_iq1_s_hpc(chunk_f32, importance=chunk_imp)
+                            actual_blocks = (end - processed + QK_K - 1) // QK_K
+                            chunks.append(chunk_data[:actual_blocks * IQ1S_TYPE_SIZE])
+                            se_sum += (chunk_rmse ** 2) * (end - processed)
+                            processed = end
+                            pct = 100.0 * processed / n_el
+                            print(f"\r    → {processed/1e6:.0f}M/{n_el/1e6:.0f}M ({pct:.0f}%)", end='', flush=True)
+                        print()
+                        iq1_data = b''.join(chunks)
+                        n_blocks = n_el // QK_K
+                        tensor_rmse = float(np.sqrt(se_sum / max(n_el, 1)))
+                    else:
+                        # No HPC available — IQ1_S needs the C library; keep as-is
+                        fout.write(raw_data)
+                        pad = align_offset(fout.tell()) - fout.tell()
+                        if pad > 0:
+                            fout.write(b'\x00' * pad)
+                        print(f"  [IQ1_S] {ti['name'][:55]}  skipped (no HPC library)")
+                        continue
+                    fout.write(iq1_data)
+                    print(f"  [IQ1_S·HPC] {ti['name'][:55]}  RMSE={tensor_rmse:.6e}")
+                    q2k_rmse_sum += tensor_rmse
+                    q2k_tensor_count += 1
+
+                    quant_count += 1
+                    total_quant_bytes += len(iq1_data)
                 elif quant_plan[i]:
                     # Convert to F32 for quantization
                     if ti['type'] == GGML_TYPE_BF16:
@@ -1353,16 +1559,16 @@ def main():
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  RE-QUANTIZATION SUMMARY                                     ║")
     print("  ╠════════════════════════════════════════════════════════════════╣")
-    print(f"  ║  Tensors quantized (Q2_K): {quant_count:<33d} ║")
+    print(f"  ║  Tensors quantized ({'IQ1_S' if iq1all else 'Q2_K'}): {quant_count:<33d} ║")
     print(f"  ║  Tensors kept as-is:       {total_keep:<33d} ║")
-    print(f"  ║  Q2_K data:         {total_quant_bytes:>12,} bytes ({total_quant_bytes/1024**2:>7.1f} MB) ║")
+    print(f"  ║  {'IQ1_S' if iq1all else 'Q2_K'} 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 Q2_K RMSE:                            {mean_rmse:>12.6e} ║")
+        print(f"  ║  Mean {'IQ1_S' if iq1all else 'Q2_K'} RMSE:                            {mean_rmse:>12.6e} ║")
     print(f"  ║  Total time:        {elapsed:>39.1f} sec ║")
     print("  ╚════════════════════════════════════════════════════════════════╝")
     print()