I prefer Q2 honestly.. but leaving IQ1 staging in for posterity

hexstate_quantize.c

@@ -5239,853 +5239,6 @@ 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;
@@ -6169,50 +5322,6 @@ 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,24 +96,6 @@ 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
@@ -278,56 +260,6 @@ 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
@@ -339,27 +271,24 @@ 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", 19: "IQ1_S", 30: "BF16",
+    13: "Q5_K", 14: "Q6_K", 15: "Q8_K", 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, 19: 256, 30: 1,
+    13: 256, 14: 256, 15: 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, 19: 50, 30: 2,
+    13: 176, 14: 210, 15: 292, 30: 2,
 }
 
 
@@ -723,9 +652,6 @@ 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
@@ -838,7 +764,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] [--q2kall] [--iq1-all]")
+              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all]")
         sys.exit(1)
 
     input_path = sys.argv[1]
@@ -846,8 +772,6 @@ 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
@@ -869,10 +793,8 @@ def main():
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  HExState GGUF Re-Quantizer                                  ║")
     print("  ║  GGUF → Q2_K GGUF with metadata passthrough                  ║")
-    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 q2all:
+        print("  ║  Mode: --q2all  ALL eligible tensors → Q2_K (test mode)      ║")
     if use_hpc and imatrix_data:
         print("  ║  Engine: HPC + iMatrix (calibrated sensitivity propagation)  ║")
     elif use_hpc:
@@ -959,21 +881,6 @@ 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
@@ -989,7 +896,7 @@ def main():
                 will_quant = 'EMBD_Q8'
                 total_embd += 1
             elif should_quantize(ti['name'], ti['n_dims'], ti['dims'], tied_embeddings):
-                if q2all or q2kall:
+                if q2all:
                     if q2k_row_compatible(ti['n_dims'], ti['dims']):
                         will_quant = True; total_quant += 1
                     elif q4_row_compatible(ti['n_dims'], ti['dims']):
@@ -998,41 +905,6 @@ 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
@@ -1049,15 +921,10 @@ def main():
                 total_keep += 1
             quant_plan.append(will_quant)
 
-        if q2all or q2kall:
-            print("  Mode: --q2all/--q2kall — Q2_K wherever block-compatible; safe Q4/keep otherwise")
+        if q2all:
+            print("  Mode: --q2all — 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}")
@@ -1091,11 +958,6 @@ 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
@@ -1129,8 +991,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, 24 means IQ1_S in llama.cpp
-                    updated_kv.append((key, vtype, struct.pack('<I', 24 if iq1all else 10)))
+                    # file_type=10 means Q2_K in llama.cpp
+                    updated_kv.append((key, vtype, struct.pack('<I', 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:
@@ -1378,74 +1240,6 @@ 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:
@@ -1559,16 +1353,16 @@ def main():
     print("  ╔════════════════════════════════════════════════════════════════╗")
     print("  ║  RE-QUANTIZATION SUMMARY                                     ║")
     print("  ╠════════════════════════════════════════════════════════════════╣")
-    print(f"  ║  Tensors quantized ({'IQ1_S' if iq1all else 'Q2_K'}): {quant_count:<33d} ║")
+    print(f"  ║  Tensors quantized (Q2_K): {quant_count:<33d} ║")
     print(f"  ║  Tensors kept as-is:       {total_keep:<33d} ║")
-    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"  ║  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 {'IQ1_S' if iq1all else 'Q2_K'} RMSE:                            {mean_rmse:>12.6e} ║")
+        print(f"  ║  Mean Q2_K RMSE:                            {mean_rmse:>12.6e} ║")
     print(f"  ║  Total time:        {elapsed:>39.1f} sec ║")
     print("  ╚════════════════════════════════════════════════════════════════╝")
     print()