// ===== REFERENCES (k09k_ 席, 2026-10-03) =====
// [1] 基座 = 本账号 #121663 逐字（k09i_ 席, 2026-10-02）
// 提交 URL: https://duck.ac/submission/121663 账号 saffah_cc_v41_agg1
// 所用内容: 全部引擎源码（CDQ<3,256> + LV3 C1/C2/C3+ZB 计数器 + 叶块 y 排序前移计数
// + 共用基址律 struct SmallCounters + node_fused 指针游标 等）
// [2] 叶块「lyk[] 中转趟并入 lk[] 构造趟」= k09j_ 席的刀（该刀随 #121920 提交；同件生成器
// work/k09j__tmp/mkvar2.py 的 leaffuse()）
// 所用内容: cdq_leaf256 内三处叶尺寸分支的 lk[] 构造循环改写（取消 lyk[] 写回整趟）
// ===== k09k_ 席 思路 =====
// 单发两处「零语义变化」的确定性削减，合计 −1.0% 级 Ir（callgrind, gcc9.3 -O2）：
// (a) 叶块 lk[] 构造与 lyk[] 写回趟合并（每元素少 1 次载入+1 次存储，去一整个 sn 长度趟）；
// (b) 计数器清零 memset(ZB/C1/C2/C3) 改内联 32B 零写循环 k09k_zr()：libc 走
// __memset_chk_avx2_unaligned_erms 的 ERMS rep-stosb 路径，小尺寸（C2≈96B / C3=32B）
// 启动开销远大于数据本身，且每次调用带 FORTIFY 边界检查。（★注：callgrind 把 rep stosb
// 按每字节计 1 条指令 ⇒ 该 memset 的 6.3% Ir 里大部分是量具假象，本条只取真实的那一小块。）
// 闸门：与 #121663 逐位等价 —— 6 分布 × n=1..400 = 2400 例 O(n²) 暴力 bad=0；n=1e5 三 seed
// FNV 4654105658404580465 / 12353063283700970727 / 6236218152481883361 全同。
#include <string.h>
#include <immintrin.h>
#pragma GCC push_options
#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")
#pragma GCC optimize("O2","unroll-loops","no-inline-functions-called-once","no-ipa-cp","sched-pressure","no-tree-ch","no-ipa-sra","no-tree-vrp")
typedef unsigned u32;
typedef unsigned long long u64;
typedef unsigned char u8;
typedef unsigned short u16;
static const int MAXN = 1000001;
int g_nz = 0;
#ifndef ZCTHR
#define ZCTHR 16
#endif
#define W_Y(v) ((u32)((v) >> 40))
#define W_ORIG(v) ((u32)(((v) >> 20) & 0xFFFFFu))
#define W_A(v) ((u32)((v) & 0xFFFFFu))
#define W_T(v) ((u32)((v) >> 40))
#define W_R(v) ((u32)((v) & 0xFFFFFu))
#define W_X(v) ((u32)(((v) >> 20) & 0xFFFFFu))
// +16 u64 of pad per row keeps the two buffers off a 4096-byte multiple (4K aliasing)
static u64 RC[2][2 * (MAXN + 8)] __attribute__((aligned(64)));
static u64 TIE[(MAXN + 63) / 64 + 8]; // TIE[p] bit = (x[p-1] == x[p])
// H64 and CNT are only live during the BUILD, i.e. before the CDQ ping-pong needs RC[1].
// Aliasing them onto RC[1] removes 1.2 MB of first-touch pages (measured ~0.064 us/KB).
#define H64 ((u64 *)(void *)RC[1])
#define CNT ((u32 *)(void *)(RC[1] + (MAXN + 8)))
#define NGRP ((MAXN + 1023) / 1024 + 8)
struct alignas(64) SmallCounters {
alignas(64) u8 M2TAB[NGRP * 32];
alignas(64) u8 M3TAB[NGRP * 32];
alignas(64) u64 ZB[(MAXN + 63) / 64 + 16];
alignas(64) u16 C1[(MAXN + 63) / 64 + 32];
alignas(64) u16 C2[(MAXN + 1023) / 1024 + 32];
alignas(64) u32 C3[8];
};
static SmallCounters smallct;
#define ZB (smallct.ZB)
#define C1 (smallct.C1)
#define C2 (smallct.C2)
#define C3 (smallct.C3)
#define M2TAB (smallct.M2TAB)
#define M3TAB (smallct.M3TAB)
// ---------- z counter: prefix count over rank domain [0,n) ----------
// LV<=3 COUNTER (n <= 262144, i.e. this row):
// C1[w] (u16) = # inserted ranks in [(w&~15)*64, w*64) -- cumulative in a 16-WORD group
// C2[p] (u16) = # inserted ranks in [(p&~15)*1024, p*1024) -- cumulative in a 16-BLOCK group
// C3[q] (u32) = # inserted ranks in [0, q*16384) -- global cumulative
// count(<T) = C3[T>>14] + C2[T>>10] + C1[T>>6] + popcount(ZB[T>>6] & ((1<<(T&63))-1))
// The query is then FOUR SCALAR LOADS and no vector code at all. The three suffix
// increments in zadd are one aligned 32-byte load/add/store each (windows never partially
// overlap, so store-to-load forwarding is clean).
// bit per rank
// per-word cumulative (group 16 words = 1024 ranks)
// per-1024 cumulative (group 16 blocks = 16384 ranks)
// global cumulative per 16384 ranks (LV<=3)
// LV>=4 fallback (unchanged classic counter, not used on this row)
static u8 ZW1[(MAXN + 63) / 64 + 32];
static u16 ZW2[(MAXN + 1023) / 1024 + 32];
static u16 ZW3[(MAXN + 16383) / 16384 + 32];
static u32 ZW4[(MAXN + 262143) / 262144 + 32];
static const u16 IDX16[16] __attribute__((aligned(32))) = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
static const u32 IDX8[8] __attribute__((aligned(32))) = {0,1,2,3,4,5,6,7};
// add +1 (sgn=+1) / -1 (sgn=-1) to lanes (t0, 15] of the 16-lane u16 group at p
alignas(32) static const u16 PREFIX16[16][16]={{0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},{0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1},{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1},{0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1},{0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1},{0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1},{0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1},{0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1},{0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1},{0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1},{0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1},{0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},{0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
alignas(32) static const u32 PREFIX8[8][8]={{0,1,1,1,1,1,1,1},{0,0,1,1,1,1,1,1},{0,0,0,1,1,1,1,1},{0,0,0,0,1,1,1,1},{0,0,0,0,0,1,1,1},{0,0,0,0,0,0,1,1},{0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,0}};
// ---- k09f_: mask rows indexed by the C1 GROUP offset (p*32) so that zadd needs
// no index arithmetic for the C2/C3 masks. Row p holds PREFIX16[p&15] / PREFIX8[p>>4].
// k09k_: inline zero for the counter clears (replaces libc memset, which costs ~6% Ir)
static inline void k09k_zr(void *p, size_t n) {
char *q = (char *)p;
__m256i z = _mm256_setzero_si256();
size_t i = 0;
for (; i + 128 <= n; i += 128) {
_mm256_storeu_si256((__m256i *)(void *)(q + i), z);
_mm256_storeu_si256((__m256i *)(void *)(q + i + 32), z);
_mm256_storeu_si256((__m256i *)(void *)(q + i + 64), z);
_mm256_storeu_si256((__m256i *)(void *)(q + i + 96), z);
}
for (; i < n; i += 32) _mm256_storeu_si256((__m256i *)(void *)(q + i), z);
}
#define memset0(p, n) k09k_zr((p), ((n) + 31u) & ~31u)
static void mktab(void) {
const int ng = (g_nz + 1023) / 1024 + 1;
for (int p = 0; p < ng && p < NGRP; p++) {
__m256i m = _mm256_load_si256((const __m256i *)PREFIX16[p & 15]);
_mm256_store_si256((__m256i *)(void *)(M2TAB + 32 * p), m);
__m256i n = _mm256_load_si256((const __m256i *)PREFIX8[(p >> 4) < 8 ? (p >> 4) : 7]);
_mm256_store_si256((__m256i *)(void *)(M3TAB + 32 * p), n);
}
}
static inline void grp16v(void *p, const void *m, int sgn) {
__m256i x = _mm256_load_si256((const __m256i *)p), y = _mm256_load_si256((const __m256i *)m);
_mm256_store_si256((__m256i *)p, sgn > 0 ? _mm256_add_epi16(x, y) : _mm256_sub_epi16(x, y));
}
static inline void grp8v(void *p, const void *m, int sgn) {
__m256i x = _mm256_load_si256((const __m256i *)p), y = _mm256_load_si256((const __m256i *)m);
_mm256_store_si256((__m256i *)p, sgn > 0 ? _mm256_add_epi32(x, y) : _mm256_sub_epi32(x, y));
}
static inline void grp16b(void *p,u32 t4,int sgn){
__m256i x=_mm256_load_si256((const __m256i*)p),m=_mm256_load_si256((const __m256i*)(const void*)((const char*)PREFIX16+(size_t)t4*8));
_mm256_store_si256((__m256i*)p,sgn>0?_mm256_add_epi16(x,m):_mm256_sub_epi16(x,m));
}
static inline void grp8b(void *p,u32 t4,int sgn){
__m256i x=_mm256_load_si256((const __m256i*)p),m=_mm256_load_si256((const __m256i*)(const void*)((const char*)PREFIX8+(size_t)t4*8));
_mm256_store_si256((__m256i*)p,sgn>0?_mm256_add_epi32(x,m):_mm256_sub_epi32(x,m));
}
template <int LV> static inline void zclear() {
memset0(ZB, (size_t)((g_nz + 63) / 64) * 8);
memset0(C1, (size_t)(((g_nz + 63) / 64 + 15) / 16) * 32);
memset0(C2, (size_t)(((g_nz + 1023) / 1024 + 15) / 16) * 32);
memset0(C3, 32);
if (LV >= 4) { // classic upper levels, used only by the LV>=4 fallback
memset(ZW1, 0, (size_t)((g_nz + 63) / 64));
memset(ZW2, 0, (size_t)((g_nz + 1023) / 1024) * 2);
memset(ZW3, 0, (size_t)((g_nz + 16383) / 16384) * 2);
memset(ZW4, 0, (size_t)((g_nz + 262143) / 262144) * 4);
}
}
// Upper LEVELS are tiny; clear them inline (no libc call per node).
static inline void zclear_upper() {
__m128i z = _mm_setzero_si128();
int i2 = (g_nz + 1023) / 1024, q2 = (i2 + 7) >> 3;
for (int q = 0; q < q2; q++) _mm_storeu_si128((__m128i *)(void *)(ZW2 + 8 * q), z);
int i3 = (g_nz + 16383) / 16384, q3 = (i3 + 7) >> 3;
for (int q = 0; q < q3; q++) _mm_storeu_si128((__m128i *)(void *)(ZW3 + 8 * q), z);
int i4 = (g_nz + 262143) / 262144, q4 = (i4 + 3) >> 2;
for (int q = 0; q < q4; q++) _mm_storeu_si128((__m128i *)(void *)(ZW4 + 4 * q), z);
int i1 = (g_nz + 63) / 64, q1 = (i1 + 15) >> 4;
for (int q = 0; q < q1; q++) _mm_storeu_si128((__m128i *)(void *)(ZW1 + 16 * q), z);
}
// Touched-only clear: the ZB word (and, at LV<=3, the C1/C2 GROUPS) of the ranks this node
// inserted. ⚠ At LV>=4 the classic ZW1/ZW2/ZW3 levels are live and MUST be cleared here too
// -- clearing only ZB/C1/C2 would leave them stale.
template <int LV> static inline void zclear_touched(int l, int aIns, const u64 *S) {
__m256i z = _mm256_setzero_si256();
for (int k = l; k < aIns; k++) {
u32 r = W_R(S[2 * k + 1]);
ZB[r >> 6] = 0;
if (LV <= 3) {
_mm256_store_si256((__m256i *)(void *)(C1 + ((r >> 6) & ~15u)), z);
_mm256_store_si256((__m256i *)(void *)(C2 + ((r >> 10) & ~15u)), z);
}
}
if (LV <= 3) _mm256_store_si256((__m256i *)(void *)C3, z);
else zclear_upper();
}
// ---- CHEAP CLEAR ------------------------------------------------------------------
// Two facts, both from measurement (custom_test n=1e5; 1.094M zadds over 4094 nodes):
// * C2 has only (n>>10) 16-lane groups (~7 for n=1e5) and C3 is ONE 8-lane vector, so
// one C2/C3 store per inserted rank was ~85% redundant;
// * the FULL clear memsets ZB (12.5 KB ~= 390 store-slots) however few ranks the node
// inserted; below ~400 inserts the per-rank ZB clear is the cheaper one.
// Zeroing MORE than the node dirtied is always correct -- an already-zero entry stays
// zero, and after the clear the counter reads 0 for every T either way.
#ifndef C1GRP
#define C1GRP 98
#endif
#ifndef ZBTHR
#define ZBTHR 400
#endif
static inline void zclear_C23() {
__m256i z = _mm256_setzero_si256();
int i2 = (g_nz + 1023) / 1024, q2 = (i2 + 15) >> 4;
for (int q = 0; q < q2; q++) _mm256_store_si256((__m256i *)(void *)(C2 + 16 * q), z);
_mm256_store_si256((__m256i *)(void *)C3, z);
}
template <int LV> static inline void zclear_cheap(int l, int aIns, const u64 *S) {
if (LV <= 3) {
if (aIns - l >= C1GRP) {
for (int k = l; k < aIns; k++) ZB[W_R(S[2 * k + 1]) >> 6] = 0;
memset0(C1, (size_t)(((g_nz + 63) / 64 + 15) / 16) * 32);
} else {
__m256i z = _mm256_setzero_si256();
for (int k = l; k < aIns; k++) {
u32 r = W_R(S[2 * k + 1]);
ZB[r >> 6] = 0;
_mm256_store_si256((__m256i *)(void *)(C1 + ((r >> 6) & ~15u)), z);
}
}
zclear_C23();
} else {
for (int k = l; k < aIns; k++) ZB[W_R(S[2 * k + 1]) >> 6] = 0;
zclear_upper();
}
}
static inline __m256i mkI16() { return _mm256_setr_epi16(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15); }
static inline __m128i mkI8() { return _mm_setr_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15); }
static inline __m256i mkOne16() { return _mm256_set1_epi16(1); }
template <int LV> static inline void zadd(u32 r) {
if (LV <= 3) {
const u32 g1 = (r >> 5) & ~31u; // p*32 : C1 group byte offset == table row offset
const u32 g2 = (g1 >> 4) & ~31u; // (p/16)*32 : C2 group byte offset
ZB[r >> 6] |= 1ull << (r & 63);
grp16b((char*)C1 + g1, (r >> 4) & 60u, +1);
grp16v((char*)C2 + g2, M2TAB + g1, +1);
grp8v ((char*)C3, M3TAB + g1, +1);
} else { ZB[r>>6] |= 1ull<<(r&63); ZW1[r >> 6]++; ZW2[r >> 10]++; ZW3[r >> 14]++; ZW4[r >> 18]++; }
}
template <int LV> static inline void zsub(u32 r) {
if (LV <= 3) {
const u32 g1 = (r >> 5) & ~31u;
const u32 g2 = (g1 >> 4) & ~31u;
ZB[r >> 6] &= ~(1ull << (r & 63));
grp16b((char*)C1 + g1, (r >> 4) & 60u, -1);
grp16v((char*)C2 + g2, M2TAB + g1, -1);
grp8v ((char*)C3, M3TAB + g1, -1);
} else { ZB[r>>6] &= ~(1ull<<(r&63)); ZW1[r >> 6]--; ZW2[r >> 10]--; ZW3[r >> 14]--; ZW4[r >> 18]--; }
}
static inline u32 hsum256(__m256i s) {
__m128i lo = _mm256_castsi256_si128(s), hi = _mm256_extracti128_si256(s, 1);
__m128i t = _mm_add_epi32(lo, hi);
t = _mm_add_epi32(t, _mm_shuffle_epi32(t, _MM_SHUFFLE(1, 0, 3, 2)));
t = _mm_add_epi32(t, _mm_shuffle_epi32(t, _MM_SHUFFLE(2, 3, 0, 1)));
return (u32)_mm_cvtsi128_si32(t);
}
template <int LV> static inline u32 zquery(u32 T) {
if (LV <= 3) {
// FOUR SCALAR LOADS, NO VECTOR CODE: C3[T>>14] + C2[T>>10] + C1[T>>6] + bits
u32 w = T >> 6;
u32 s = (u32)C3[T >> 14] + (u32)C2[T >> 10] + (u32)C1[w];
return s + (u32)__builtin_popcountll(_bzhi_u64(ZB[w], T & 63));
}
u32 k4 = T >> 18, k3 = (T >> 14) & 15, k2 = (T >> 10) & 15, k1 = (T >> 6) & 15, rem = T & 63;
__m256i acc = _mm256_setzero_si256();
if (LV >= 4) acc = _mm256_and_si256(_mm256_loadu_si256((const __m256i *)ZW4),
_mm256_cmpgt_epi32(_mm256_set1_epi32((int)k4), _mm256_setr_epi32(0,1,2,3,4,5,6,7)));
acc = _mm256_add_epi32(acc, _mm256_madd_epi16(_mm256_and_si256(
_mm256_loadu_si256((const __m256i *)(ZW3 + (k4 << 4))),
_mm256_cmpgt_epi16(_mm256_set1_epi16((short)k3), mkI16())), mkOne16()));
acc = _mm256_add_epi32(acc, _mm256_madd_epi16(_mm256_and_si256(
_mm256_loadu_si256((const __m256i *)(ZW2 + ((T >> 14) << 4))),
_mm256_cmpgt_epi16(_mm256_set1_epi16((short)k2), mkI16())), mkOne16()));
__m128i s8 = _mm_sad_epu8(_mm_and_si128(
_mm_loadu_si128((const __m128i *)(ZW1 + ((T >> 10) << 4))),
_mm_cmpgt_epi8(_mm_set1_epi8((char)k1), mkI8())), _mm_setzero_si128());
u32 s = hsum256(acc) + (u32)_mm_cvtsi128_si32(s8) + (u32)(_mm_extract_epi16(s8, 4) & 0xFFFF);
s += (u32)__builtin_popcountll(_bzhi_u64(ZB[T >> 6], rem));
return s;
}
#ifndef SIMD_LIM
#define SIMD_LIM 128
#endif
// count records in [l,i) whose R < T (4 records per AVX iteration)
static inline u32 count_lt(const u64 *S, int l, int i, u32 T) {
u32 c = 0;
int k = l;
const __m256i m20 = _mm256_set1_epi64x(0xFFFFF);
for (; k + 2 <= i; k += 2) { // two records = 4 u64 lanes
__m256i v = _mm256_loadu_si256((const __m256i *)(S + 2 * k)); // {w0,w1,w0,w1}
__m256i r = _mm256_and_si256(_mm256_srli_epi64(v, 20), m20);
__m256i cm = _mm256_cmpgt_epi64(_mm256_set1_epi64x((long long)T), r);
c += (u32)__builtin_popcount((u32)_mm256_movemask_pd(_mm256_castsi256_pd(cm)) & 0xAu);
}
for (; k < i; k++) if (W_R(S[2 * k + 1]) < T) c++;
return c;
}
// fused y-merge + cross count (no x-ties: every left x < every right x)
template <int LV> static void node_fused(int l, int m, int r, int src, int dst) {
u64 *S = RC[src];
u64 *D = RC[dst];
int a = l, b = m, t = l;
if (a < m && b < r) {
const u64 *pa = S + 2 * a, *pb = S + 2 * b; u64 *pd = D + 2 * l;
const u64 *const pae = S + 2 * m, *const pbe = S + 2 * r;
u64 w0a = pa[0], w1a = pa[1];
u64 w0b = pb[0], w1b = pb[1];
for (;;) {
if ((w0b >> 40) <= (w0a >> 40)) { // right first on equal y (strict)
w0b += zquery<LV>((u32)(w1b >> 40));
pd[0] = w0b; pd[1] = w1b; pd += 2; pb += 2;
if (pb >= pbe) break;
w0b = pb[0]; w1b = pb[1];
} else {
zadd<LV>(W_R(w1a));
pd[0] = w0a; pd[1] = w1a; pd += 2; pa += 2;
if (pa >= pae) break;
w0a = pa[0]; w1a = pa[1];
}
}
a = (int)((pa - S) >> 1); b = (int)((pb - S) >> 1); t = (int)((pd - D) >> 1);
}
int aIns = a;
while (b < r) {
u64 w0b = S[2 * b], w1b = S[2 * b + 1];
w0b += zquery<LV>((u32)(w1b >> 40));
D[2 * t] = w0b; D[2 * t + 1] = w1b; b++; t++;
}
while (a < m) { D[2 * t] = S[2 * a]; D[2 * t + 1] = S[2 * a + 1]; a++; t++; }
// full zclear ~= 497 vector stores + 4 memset calls; touched-clear ~= 3 stores per insert.
if (aIns - l >= ZBTHR) zclear<LV>();
else if (r - l >= ZCTHR) zclear_cheap<LV>(l, aIns, S);
else for (int k = l; k < aIns; k++) zsub<LV>(W_R(S[2 * k + 1]));
}
// plain branchless y-merge (used for single-group nodes)
static void merge_run(int l, int m, int r, int src, int dst) {
u64 *S = RC[src];
u64 *D = RC[dst];
int a = l, b = m, t = l;
{ const u64 *pa = S + 2 * a, *pb = S + 2 * b; u64 *pd = D + 2 * t;
const u64 *const pae = S + 2 * m, *const pbe = S + 2 * r;
while (pa < pae && pb < pbe) {
const u64 *ps = ((*pa >> 40) <= (*pb >> 40)) ? pa : pb;
pd[0] = ps[0]; pd[1] = ps[1]; pd += 2;
if (ps == pa) pa += 2; else pb += 2;
}
a = (int)((pa - S) >> 1); b = (int)((pb - S) >> 1); t = (int)((pd - D) >> 1);
}
while (a < m) { D[2 * t] = S[2 * a]; D[2 * t + 1] = S[2 * a + 1]; a++; t++; }
while (b < r) { D[2 * t] = S[2 * b]; D[2 * t + 1] = S[2 * b + 1]; b++; t++; }
}
// tie fallback: queries p with x==g (pass 2) / x!=g (pass 1), inserts q with x<g (pass 2)
template <int LV> static void cross_filter(int l, int m, int r, int src, u32 g, int pass) {
u64 *S = RC[src];
int i = l;
if (pass == 1) {
for (int j = m; j < r; j++) {
if (W_X(S[2 * j + 1]) == g) continue;
u32 yj = (u32)(S[2 * j] >> 40);
while (i < m && (u32)(S[2 * i] >> 40) < yj) { zadd<LV>(W_R(S[2 * i + 1])); i++; }
u32 c = zquery<LV>(W_T(S[2 * j + 1]));
if (c) S[2 * j] += c;
}
for (int k = l; k < i; k++) zsub<LV>(W_R(S[2 * k + 1]));
} else {
for (int j = m; j < r; j++) {
if (W_X(S[2 * j + 1]) != g) continue;
u32 yj = (u32)(S[2 * j] >> 40);
while (i < m && (u32)(S[2 * i] >> 40) < yj) {
if (W_X(S[2 * i + 1]) < g) zadd<LV>(W_R(S[2 * i + 1]));
i++;
}
u32 c = zquery<LV>(W_T(S[2 * j + 1]));
if (c) S[2 * j] += c;
}
for (int k = l; k < i; k++) if (W_X(S[2 * k + 1]) < g) zsub<LV>(W_R(S[2 * k + 1]));
}
}
#ifndef LEAF_N
#define LEAF_N 8
#endif
// base case: count all internal dominance pairs of a small x-group-aligned range
// directly, then insertion-sort the range by y. No counter, no recursion.
#define LSCR 512 // >= any LF; the leaf is processed entirely inside one call
struct alignas(64) LeafScratch {
alignas(32) u32 lex[LSCR + 16]; alignas(32) u32 ley[LSCR + 16]; alignas(32) u32 ler[LSCR + 16];
alignas(32) u64 lkey[LSCR + 16]; alignas(32) u64 ltmp[2 * (LSCR + 16)];
alignas(32) u32 lk[256];
alignas(32) u32 lyk[LSCR + 16]; alignas(32) u32 lxq[LSCR + 16];
alignas(32) u32 lzq[LSCR + 16]; alignas(32) u32 ltq[LSCR + 16]; alignas(32) u32 lst[LSCR + 16];
};
static LeafScratch lsc;
#define lex (lsc.lex)
#define ley (lsc.ley)
#define ler (lsc.ler)
#define lkey (lsc.lkey)
#define ltmp (lsc.ltmp)
#define lk (lsc.lk)
#define lyk (lsc.lyk)
#define lxq (lsc.lxq)
#define lzq (lsc.lzq)
#define ltq (lsc.ltq)
#define lst (lsc.lst)
// ---- generated AVX2 bitonic sort of 64 u32 keys (keys in r[0..7]) ----
static inline void bs64(__m256i *r) {
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,-1,0,0,-1,-1,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,-1,-1,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,-1,0,-1,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[0], B=r[1]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[1]=Hi; }
{ __m256i A=r[2], B=r[3]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[3]=Lo; r[2]=Hi; }
{ __m256i A=r[4], B=r[5]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[4]=Lo; r[5]=Hi; }
{ __m256i A=r[6], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[7]=Lo; r[6]=Hi; }
{ __m256i A=r[0]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[0], B=r[2]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[2]=Hi; }
{ __m256i A=r[1], B=r[3]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[1]=Lo; r[3]=Hi; }
{ __m256i A=r[4], B=r[6]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[6]=Lo; r[4]=Hi; }
{ __m256i A=r[5], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[7]=Lo; r[5]=Hi; }
{ __m256i A=r[0], B=r[1]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[1]=Hi; }
{ __m256i A=r[2], B=r[3]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[2]=Lo; r[3]=Hi; }
{ __m256i A=r[4], B=r[5]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[5]=Lo; r[4]=Hi; }
{ __m256i A=r[6], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[7]=Lo; r[6]=Hi; }
{ __m256i A=r[0]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,-1,-1,0,0,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,-1,0,0,-1,-1,0,0)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(-1,0,-1,0,-1,0,-1,0)); }
{ __m256i A=r[0], B=r[4]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[4]=Hi; }
{ __m256i A=r[1], B=r[5]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[1]=Lo; r[5]=Hi; }
{ __m256i A=r[2], B=r[6]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[2]=Lo; r[6]=Hi; }
{ __m256i A=r[3], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[3]=Lo; r[7]=Hi; }
{ __m256i A=r[0], B=r[2]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[2]=Hi; }
{ __m256i A=r[1], B=r[3]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[1]=Lo; r[3]=Hi; }
{ __m256i A=r[4], B=r[6]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[4]=Lo; r[6]=Hi; }
{ __m256i A=r[5], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[5]=Lo; r[7]=Hi; }
{ __m256i A=r[0], B=r[1]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[0]=Lo; r[1]=Hi; }
{ __m256i A=r[2], B=r[3]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[2]=Lo; r[3]=Hi; }
{ __m256i A=r[4], B=r[5]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[4]=Lo; r[5]=Hi; }
{ __m256i A=r[6], B=r[7]; __m256i Lo=_mm256_min_epu32(A,B), Hi=_mm256_max_epu32(A,B); r[6]=Lo; r[7]=Hi; }
{ __m256i A=r[0]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_permute4x64_epi64(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,0,0,-1,-1,-1,-1)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0x4E); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,0,-1,-1,0,0,-1,-1)); }
{ __m256i A=r[0]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[0]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[1]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[1]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[2]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[2]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[3]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[3]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[4]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[4]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[5]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[5]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[6]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[6]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
{ __m256i A=r[7]; __m256i T=_mm256_shuffle_epi32(A,0xB1); r[7]=_mm256_blendv_epi8(_mm256_min_epu32(A,T),_mm256_max_epu32(A,T),_mm256_setr_epi32(0,-1,0,-1,0,-1,0,-1)); }
}
// ---- 128-key BITONIC MERGE (branch-free, fixed network) ---------------------
// In: k[0..63] ascending and k[64..127] ascending. Out: k[0..127] ascending.
static inline void bm128(u32 *k) {
const __m256i BM_IDX64 = _mm256_setr_epi32(7,6,5,4,3,2,1,0);
{ // reverse the top half
__m256i t[8];
for (int q = 0; q < 8; q++) t[q] = _mm256_permutevar8x32_epi32(
_mm256_load_si256((const __m256i *)(k + 64 + 8 * (7 - q))), BM_IDX64);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(k + 64 + 8 * q), t[q]);
}
for (int d = 64; d >= 8; d >>= 1) {
for (int base = 0; base < 128; base += 2 * d)
for (int j = 0; j < d; j += 8) {
__m256i a = _mm256_load_si256((const __m256i *)(k + base + j));
__m256i b = _mm256_load_si256((const __m256i *)(k + base + j + d));
_mm256_store_si256((__m256i *)(k + base + j), _mm256_min_epu32(a, b));
_mm256_store_si256((__m256i *)(k + base + j + d), _mm256_max_epu32(a, b));
}
}
for (int d = 4; d >= 1; d >>= 1) {
__m256i idx = _mm256_setr_epi32(0^d, 1^d, 2^d, 3^d, 4^d, 5^d, 6^d, 7^d);
__m256i bsel = _mm256_setr_epi32((0&d)?-1:0, (1&d)?-1:0, (2&d)?-1:0, (3&d)?-1:0,
(4&d)?-1:0, (5&d)?-1:0, (6&d)?-1:0, (7&d)?-1:0);
for (int base = 0; base < 128; base += 8) {
__m256i a = _mm256_load_si256((const __m256i *)(k + base));
__m256i p = _mm256_permutevar8x32_epi32(a, idx);
__m256i lo = _mm256_min_epu32(a, p), hi = _mm256_max_epu32(a, p);
_mm256_store_si256((__m256i *)(k + base), _mm256_blendv_epi8(lo, hi, bsel));
}
}
}
// ---- 256-key BITONIC MERGE: in k[0..127] and k[128..255] each ascending ----
static inline void bm256(u32 *k) {
const __m256i BM_IDX64 = _mm256_setr_epi32(7,6,5,4,3,2,1,0);
{ __m256i t[16];
for (int q = 0; q < 16; q++) t[q] = _mm256_permutevar8x32_epi32(
_mm256_load_si256((const __m256i *)(k + 128 + 8 * (15 - q))), BM_IDX64);
for (int q = 0; q < 16; q++) _mm256_store_si256((__m256i *)(k + 128 + 8 * q), t[q]);
}
for (int d = 128; d >= 8; d >>= 1) {
for (int base = 0; base < 256; base += 2 * d)
for (int j = 0; j < d; j += 8) {
__m256i a = _mm256_load_si256((const __m256i *)(k + base + j));
__m256i b = _mm256_load_si256((const __m256i *)(k + base + j + d));
_mm256_store_si256((__m256i *)(k + base + j), _mm256_min_epu32(a, b));
_mm256_store_si256((__m256i *)(k + base + j + d), _mm256_max_epu32(a, b));
}
}
for (int d = 4; d >= 1; d >>= 1) {
__m256i idx = _mm256_setr_epi32(0^d, 1^d, 2^d, 3^d, 4^d, 5^d, 6^d, 7^d);
__m256i bsel = _mm256_setr_epi32((0&d)?-1:0, (1&d)?-1:0, (2&d)?-1:0, (3&d)?-1:0,
(4&d)?-1:0, (5&d)?-1:0, (6&d)?-1:0, (7&d)?-1:0);
for (int base = 0; base < 256; base += 8) {
__m256i a = _mm256_load_si256((const __m256i *)(k + base));
__m256i p = _mm256_permutevar8x32_epi32(a, idx);
__m256i lo = _mm256_min_epu32(a, p), hi = _mm256_max_epu32(a, p);
_mm256_store_si256((__m256i *)(k + base), _mm256_blendv_epi8(lo, hi, bsel));
}
}
}
static int cdq_leaf256(int l, int r, int in) {
u64 *S = RC[in];
const int sn = r - l;
if (sn <= 64) {
for (int k = 0; k < sn; k++) lk[k] = (u32)(S[2 * (l + k)] >> 40) << 8 | (u32)k;
for (int k = sn; k < 64; k++) lk[k] = 0xFFFFFFFFu;
{ __m256i r0[8];
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 8 * q), r0[q]); }
} else if (sn <= 128) {
for (int k = 0; k < sn; k++) lk[k] = (u32)(S[2 * (l + k)] >> 40) << 8 | (u32)k;
for (int k = sn; k < 128; k++) lk[k] = 0xFFFFFFFFu;
{ __m256i r0[8];
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 8 * q), r0[q]);
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 64 + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 64 + 8 * q), r0[q]); }
bm128(lk);
} else {
for (int k = 0; k < sn; k++) lk[k] = (u32)(S[2 * (l + k)] >> 40) << 8 | (u32)k;
for (int k = sn; k < 256; k++) lk[k] = 0xFFFFFFFFu;
{ __m256i r0[8];
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 8 * q), r0[q]);
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 64 + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 64 + 8 * q), r0[q]);
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 128 + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 128 + 8 * q), r0[q]);
for (int q = 0; q < 8; q++) r0[q] = _mm256_load_si256((const __m256i *)(lk + 192 + 8 * q));
bs64(r0);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 192 + 8 * q), r0[q]); }
bm128(lk); bm128(lk + 128); bm256(lk);
}
for (int q = 0; q < sn; q++) {
const int sr = (int)(lk[q] & 255u);
u64 w0 = S[2 * (l + sr)], w1 = S[2 * (l + sr) + 1];
ltmp[2 * q] = w0; ltmp[2 * q + 1] = w1;
lxq[q] = (u32)((w1 >> 20) & 0xFFFFFu);
lzq[q] = (u32)(w1 & 0xFFFFFu);
ltq[q] = (u32)(w1 >> 40);
}
int g=0,q=1;
{ // 4-wide: shared loads over the common y-prefix
const auto red=[]( __m256i v)->u32{
__m128i s=_mm_add_epi32(_mm256_castsi256_si128(v),_mm256_extracti128_si256(v,1));
s=_mm_add_epi32(s,_mm_shuffle_epi32(s,0x4e));s=_mm_add_epi32(s,_mm_shuffle_epi32(s,0xb1));return (u32)_mm_cvtsi128_si32(s); };
const auto tl=[&](const __m256i xj,const __m256i tj,int k,int n)->u32{
__m256i c=_mm256_and_si256(_mm256_cmpgt_epi32(xj,_mm256_loadu_si256((const __m256i*)(lxq+k))),_mm256_cmpgt_epi32(tj,_mm256_loadu_si256((const __m256i*)(lzq+k))));
return (u32)__builtin_popcount(_bzhi_u32((u32)_mm256_movemask_ps(_mm256_castsi256_ps(c)),(u32)n)); };
for(;q+3<sn;q+=4){
if((lk[q]>>8)!=(lk[q-1]>>8))g=q;
const int G0=g;
const int G1=((lk[q+1]>>8)!=(lk[q]>>8))?q+1:G0;
const int G2=((lk[q+2]>>8)!=(lk[q+1]>>8))?q+2:G1;
const int G3=((lk[q+3]>>8)!=(lk[q+2]>>8))?q+3:G2;
const __m256i x0=_mm256_set1_epi32((int)lxq[q ]),t0=_mm256_set1_epi32((int)ltq[q ]);
const __m256i x1=_mm256_set1_epi32((int)lxq[q+1]),t1=_mm256_set1_epi32((int)ltq[q+1]);
const __m256i x2=_mm256_set1_epi32((int)lxq[q+2]),t2=_mm256_set1_epi32((int)ltq[q+2]);
const __m256i x3=_mm256_set1_epi32((int)lxq[q+3]),t3=_mm256_set1_epi32((int)ltq[q+3]);
__m256i a0=_mm256_setzero_si256(),a1=a0,a2=a0,a3=a0; int k=0;
for(;k+8<=G0;k+=8){
const __m256i vx=_mm256_loadu_si256((const __m256i*)(lxq+k));
const __m256i vz=_mm256_loadu_si256((const __m256i*)(lzq+k));
a0=_mm256_sub_epi32(a0,_mm256_and_si256(_mm256_cmpgt_epi32(x0,vx),_mm256_cmpgt_epi32(t0,vz)));
a1=_mm256_sub_epi32(a1,_mm256_and_si256(_mm256_cmpgt_epi32(x1,vx),_mm256_cmpgt_epi32(t1,vz)));
a2=_mm256_sub_epi32(a2,_mm256_and_si256(_mm256_cmpgt_epi32(x2,vx),_mm256_cmpgt_epi32(t2,vz)));
a3=_mm256_sub_epi32(a3,_mm256_and_si256(_mm256_cmpgt_epi32(x3,vx),_mm256_cmpgt_epi32(t3,vz)));
}
u32 c0=red(a0); if(k<G0) c0+=tl(x0,t0,k,G0-k);
for(;k+8<=G1;k+=8){ const __m256i vx=_mm256_loadu_si256((const __m256i*)(lxq+k));
const __m256i vz=_mm256_loadu_si256((const __m256i*)(lzq+k));
a1=_mm256_sub_epi32(a1,_mm256_and_si256(_mm256_cmpgt_epi32(x1,vx),_mm256_cmpgt_epi32(t1,vz)));
a2=_mm256_sub_epi32(a2,_mm256_and_si256(_mm256_cmpgt_epi32(x2,vx),_mm256_cmpgt_epi32(t2,vz)));
a3=_mm256_sub_epi32(a3,_mm256_and_si256(_mm256_cmpgt_epi32(x3,vx),_mm256_cmpgt_epi32(t3,vz))); }
u32 c1=red(a1); if(k<G1) c1+=tl(x1,t1,k,G1-k);
for(;k+8<=G2;k+=8){ const __m256i vx=_mm256_loadu_si256((const __m256i*)(lxq+k));
const __m256i vz=_mm256_loadu_si256((const __m256i*)(lzq+k));
a2=_mm256_sub_epi32(a2,_mm256_and_si256(_mm256_cmpgt_epi32(x2,vx),_mm256_cmpgt_epi32(t2,vz)));
a3=_mm256_sub_epi32(a3,_mm256_and_si256(_mm256_cmpgt_epi32(x3,vx),_mm256_cmpgt_epi32(t3,vz))); }
u32 c2=red(a2); if(k<G2) c2+=tl(x2,t2,k,G2-k);
for(;k+8<=G3;k+=8){ const __m256i vx=_mm256_loadu_si256((const __m256i*)(lxq+k));
const __m256i vz=_mm256_loadu_si256((const __m256i*)(lzq+k));
a3=_mm256_sub_epi32(a3,_mm256_and_si256(_mm256_cmpgt_epi32(x3,vx),_mm256_cmpgt_epi32(t3,vz))); }
u32 c3=red(a3); if(k<G3) c3+=tl(x3,t3,k,G3-k);
ltmp[2*q]+=c0; ltmp[2*(q+1)]+=c1; ltmp[2*(q+2)]+=c2; ltmp[2*(q+3)]+=c3;
g=G3;
}
}
const auto reduce=[](__m256i v)->u32{
__m128i sum=_mm_add_epi32(_mm256_castsi256_si128(v),_mm256_extracti128_si256(v,1));
sum=_mm_add_epi32(sum,_mm_shuffle_epi32(sum,0x4e));
sum=_mm_add_epi32(sum,_mm_shuffle_epi32(sum,0xb1));return (u32)_mm_cvtsi128_si32(sum);
};
for(;q+1<sn;q+=2){
if((lk[q]>>8)!=(lk[q-1]>>8))g=q;
const int g0=g,g1=((lk[q+1]>>8)!=(lk[q]>>8))?q+1:g;
const __m256i x0=_mm256_set1_epi32(lxq[q]),t0=_mm256_set1_epi32(ltq[q]);
const __m256i x1=_mm256_set1_epi32(lxq[q+1]),t1=_mm256_set1_epi32(ltq[q+1]);
__m256i a0=_mm256_setzero_si256(),a1=a0;
int k=0;
for(;k+8<=g0;k+=8){
__m256i vx=_mm256_loadu_si256((const __m256i*)(lxq+k));
__m256i vz=_mm256_loadu_si256((const __m256i*)(lzq+k));
a0=_mm256_sub_epi32(a0,_mm256_and_si256(_mm256_cmpgt_epi32(x0,vx),_mm256_cmpgt_epi32(t0,vz)));
a1=_mm256_sub_epi32(a1,_mm256_and_si256(_mm256_cmpgt_epi32(x1,vx),_mm256_cmpgt_epi32(t1,vz)));
}
u32 c0=reduce(a0);
if(k<g0){__m256i c=_mm256_and_si256(_mm256_cmpgt_epi32(x0,_mm256_loadu_si256((const __m256i*)(lxq+k))),_mm256_cmpgt_epi32(t0,_mm256_loadu_si256((const __m256i*)(lzq+k))));c0+=(u32)__builtin_popcount(_bzhi_u32((u32)_mm256_movemask_ps(_mm256_castsi256_ps(c)),g0-k));}
for(;k+8<=g1;k+=8){__m256i c=_mm256_and_si256(_mm256_cmpgt_epi32(x1,_mm256_loadu_si256((const __m256i*)(lxq+k))),_mm256_cmpgt_epi32(t1,_mm256_loadu_si256((const __m256i*)(lzq+k))));a1=_mm256_sub_epi32(a1,c);}
u32 c1=reduce(a1);
if(k<g1){__m256i c=_mm256_and_si256(_mm256_cmpgt_epi32(x1,_mm256_loadu_si256((const __m256i*)(lxq+k))),_mm256_cmpgt_epi32(t1,_mm256_loadu_si256((const __m256i*)(lzq+k))));c1+=(u32)__builtin_popcount(_bzhi_u32((u32)_mm256_movemask_ps(_mm256_castsi256_ps(c)),g1-k));}
ltmp[2*q]+=c0;ltmp[2*(q+1)]+=c1;g=g1;
}
for (; q < sn; q++) {
if((lk[q]>>8)!=(lk[q-1]>>8))g=q;
const u32 xj = lxq[q], tj = ltq[q];
const __m256i mxj = _mm256_set1_epi32((int)xj);
const __m256i mtj = _mm256_set1_epi32((int)tj);
u32 acc = 0;
__m256i vacc=_mm256_setzero_si256();
int k = 0;
for (; k + 8 <= g; k += 8) {
__m256i c = _mm256_and_si256(_mm256_cmpgt_epi32(mxj, _mm256_loadu_si256((const __m256i *)(lxq + k))),
_mm256_cmpgt_epi32(mtj, _mm256_loadu_si256((const __m256i *)(lzq + k))));
vacc=_mm256_sub_epi32(vacc,c);
}
__m128i sum=_mm_add_epi32(_mm256_castsi256_si128(vacc),_mm256_extracti128_si256(vacc,1));
sum=_mm_add_epi32(sum,_mm_shuffle_epi32(sum,0x4e));sum=_mm_add_epi32(sum,_mm_shuffle_epi32(sum,0xb1));acc=(u32)_mm_cvtsi128_si32(sum);
if(k<g){__m256i c=_mm256_and_si256(_mm256_cmpgt_epi32(mxj,_mm256_loadu_si256((const __m256i*)(lxq+k))),_mm256_cmpgt_epi32(mtj,_mm256_loadu_si256((const __m256i*)(lzq+k))));acc+=(u32)__builtin_popcount(_bzhi_u32((u32)_mm256_movemask_ps(_mm256_castsi256_ps(c)),g-k));}
ltmp[2 * q] += acc;
}
for (int k = 0; k < sn; k++) { S[2 * (l + k)] = ltmp[2 * k]; S[2 * (l + k) + 1] = ltmp[2 * k + 1]; }
return in;
}
static int cdq_leaf(int l, int r, int in) {
u64 *S = RC[in];
const int sn = r - l;
for (int k = 0; k < sn; k++) { // compact u32 lanes in x-order (leaf is x-sorted)
u64 w0 = S[2 * (l + k)], w1 = S[2 * (l + k) + 1];
lex[k] = (u32)((w1 >> 20) & 0xFFFFFu);
ley[k] = (u32)(w0 >> 40);
ler[k] = (u32)(w1 & 0xFFFFFu);
}
for (int j = l + 1; j < r; j++) {
const int jl = j - l;
const u32 xj = W_X(S[2 * j + 1]), yj = (u32)(S[2 * j] >> 40), tj = W_T(S[2 * j + 1]);
const __m256i mxj = _mm256_set1_epi32((int)xj);
const __m256i myj = _mm256_set1_epi32((int)yj);
const __m256i mtj = _mm256_set1_epi32((int)tj);
u32 acc = 0;
int k = 0;
for (; k + 8 <= jl; k += 8) { // all values < 2^20, so signed cmps are exact
__m256i c = _mm256_and_si256(_mm256_cmpgt_epi32(mxj, _mm256_loadu_si256((const __m256i *)(lex + k))),
_mm256_and_si256(_mm256_cmpgt_epi32(myj, _mm256_loadu_si256((const __m256i *)(ley + k))),
_mm256_cmpgt_epi32(mtj, _mm256_loadu_si256((const __m256i *)(ler + k)))));
acc += (u32)__builtin_popcount((u32)_mm256_movemask_ps(_mm256_castsi256_ps(c)));
}
for (; k < jl; k++) acc += (u32)((lex[k] < xj) & (ley[k] < yj) & (ler[k] < tj));
S[2 * j] += acc;
}
{ // y-sort: AVX2 bitonic sort of packed u32 keys, then one permute
if (sn <= 64) {
for (int k = 0; k < sn; k++) lk[k] = (ley[k] << 7) | (u32)k;
for (int k = sn; k < 64; k++) lk[k] = 0xFFFFFFFFu;
{
__m256i r[8];
for (int q = 0; q < 8; q++) r[q] = _mm256_load_si256((const __m256i *)(lk + 8 * q));
bs64(r);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 8 * q), r[q]);
}
for (int k = 0; k < sn; k++) {
const int sr = (int)(lk[k] & 127u);
ltmp[2 * k] = S[2 * (l + sr)]; ltmp[2 * k + 1] = S[2 * (l + sr) + 1];
}
} else if (sn <= 128) {
// sn in (64,128]: fixed sort each 64-key half, then bitonic-merge (branch-free)
for (int k = 0; k < sn; k++) lk[k] = (ley[k] << 7) | (u32)k;
for (int k = sn; k < 128; k++) lk[k] = 0xFFFFFFFFu;
{
__m256i r[8];
for (int q = 0; q < 8; q++) r[q] = _mm256_load_si256((const __m256i *)(lk + 8 * q));
bs64(r);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 8 * q), r[q]);
for (int q = 0; q < 8; q++) r[q] = _mm256_load_si256((const __m256i *)(lk + 64 + 8 * q));
bs64(r);
for (int q = 0; q < 8; q++) _mm256_store_si256((__m256i *)(lk + 64 + 8 * q), r[q]);
}
bm128(lk);
for (int k = 0; k < sn; k++) {
const int sr = (int)(lk[k] & 127u);
ltmp[2 * k] = S[2 * (l + sr)]; ltmp[2 * k + 1] = S[2 * (l + sr) + 1];
}
} else {
for (int k = 0; k < sn; k++) lkey[k] = ((u64)ley[k] << 20) | (u64)(u32)k;
for (int i = 1; i < sn; i++) {
u64 kv = lkey[i];
int k = i;
while (k > 0 && lkey[k - 1] > kv) { lkey[k] = lkey[k - 1]; k--; }
lkey[k] = kv;
}
for (int k = 0; k < sn; k++) {
const int sr = (int)(u32)(lkey[k] & 0xFFFFFu);
ltmp[2 * k] = S[2 * (l + sr)]; ltmp[2 * k + 1] = S[2 * (l + sr) + 1];
}
}
for (int k = 0; k < sn; k++) { S[2 * (l + k)] = ltmp[2 * k]; S[2 * (l + k) + 1] = ltmp[2 * k + 1]; }
}
return in;
}
// returns the buffer holding the y-sorted range [l,r)
template <int LV, int LF> static int cdq(int l, int r, int in) {
int s = r - l;
if (s <= 1) return in;
if (s <= LF) return (LF == 256) ? cdq_leaf256(l, r, in) : cdq_leaf(l, r, in);
int m = (l + r) >> 1;
int mode = 3;
const u64 *SI = RC[in];
if (__builtin_expect(W_X(SI[2 * m - 1]) != W_X(SI[2 * m + 1]), 1)) mode = 0;
else {
u32 g = W_X(SI[2 * m + 1]);
int a = m - 1; while (a > l && W_X(SI[2 * a - 1]) == W_X(SI[2 * a + 1])) a--;
int b = m; while (b < r && W_X(SI[2 * b - 1]) == W_X(SI[2 * b + 1])) b++;
if (a == l && b == r) mode = 2;
else {
int lim = s >> 2;
int ca = -1, cb = -1;
if (a > l && a - l >= lim && r - a >= lim) ca = a;
if (b < r && b - l >= lim && r - b >= lim) cb = b;
if (ca >= 0 && (cb < 0 || m - ca <= cb - m)) { m = ca; mode = 1; }
else if (cb >= 0) { m = cb; mode = 1; }
}
}
int b1 = cdq<LV, LF>(l, m, in);
int b2 = cdq<LV, LF>(m, r, in);
if (b1 != b2) {
memcpy(RC[b1] + 2 * m, RC[b2] + 2 * m, (size_t)(r - m) * 16);
b2 = b1;
}
if (mode == 0 || mode == 1) {
int out = 1 - b1;
node_fused<LV>(l, m, r, b1, out);
return out;
}
if (mode == 2) {
int out = 1 - b1;
merge_run(l, m, r, b1, out);
return out;
}
// mode 3: x-tie spans the midpoint, no balanced group boundary: filtered passes
{
const u64 *S = RC[b1];
u32 g = 0;
for (int k = l; k < m; k++) { u32 xv = W_X(S[2 * k + 1]); if (xv > g) g = xv; }
cross_filter<LV>(l, m, r, b1, g, 1);
cross_filter<LV>(l, m, r, b1, g, 2);
}
int out = 1 - b1;
merge_run(l, m, r, b1, out);
return out;
}
void count_3d(int n, const unsigned *x, const unsigned *y, const unsigned *z, unsigned *out) {
if (n <= 1) { if (n == 1) out[0] = 0; return; }
g_nz = n;
mktab();
// ---- FUSED BUILD: histograms, then ONE scatter pass (no P0/P1 arrays) ----
memset(H64, 0, (size_t)(n + 1) * 8);
memset(CNT, 0, (size_t)(n + 1) * 4);
for (int i = 0; i < n; i++) {
H64[z[i]]++;
CNT[x[i]]++;
}
{
u32 acc = 0;
for (int v = 0; v <= n; v++) { u32 c = (u32)(H64[v] & 0xFFFFFu); H64[v] = (u64)acc << 20; acc += c; }
}
{
u32 acc = 0;
int v = 0;
for (; v + 8 <= n + 1; v += 8) {
__m256i x = _mm256_loadu_si256((const __m256i *)(CNT + v));
__m256i p = _mm256_add_epi32(x, _mm256_slli_si256(x, 4));
p = _mm256_add_epi32(p, _mm256_slli_si256(p, 8));
__m128i lo = _mm256_castsi256_si128(p);
__m128i hi = _mm256_extracti128_si256(p, 1);
hi = _mm_add_epi32(hi, _mm_shuffle_epi32(lo, 0xFF));
__m256i pi = _mm256_inserti128_si256(_mm256_castsi128_si256(lo), hi, 1);
__m256i ex = _mm256_add_epi32(_mm256_sub_epi32(pi, x), _mm256_set1_epi32((int)acc));
_mm256_storeu_si256((__m256i *)(CNT + v), ex);
acc += (u32)_mm_extract_epi32(hi, 3);
}
for (; v <= n; v++) { u32 c = CNT[v]; CNT[v] = acc; acc += c; }
}
{
u64 *D = RC[0];
for (int i = 0; i < n; i++) {
if (i + 12 < n) { __builtin_prefetch(&D[2 * CNT[x[i + 12]]]); }
u32 zv = z[i];
u64 h = H64[zv];
u32 T = (u32)(h >> 20);
u32 R = T + (u32)(h & 0xFFFFFu);
H64[zv] = h + 1;
u32 xv = x[i];
u32 t = CNT[xv]++;
__m128i _rv = _mm_set_epi64x((long long)(((u64)T << 40) | ((u64)xv << 20) | (u64)R),
(long long)(((u64)y[i] << 40) | ((u64)i << 20)));
_mm_storeu_si128((__m128i *)(void *)(D + 2 * t), _rv);
}
}
// ---- tie bits over x-order positions ----
// ---- CDQ ----
// (ENGINE, SIZE)-dependent: measured optima are LF=16 at n=1e5 and LF=24 at n=1e6.
int bb = (n <= 262144) ? cdq<3, 256>(0, n, 0) : cdq<4, 64>(0, n, 0);
{
const u64 *D = RC[bb];
for (int p = 0; p < n; p++) {
if (p + 64 < n) __builtin_prefetch(&out[W_ORIG(D[2 * (p + 64)])]);
out[W_ORIG(D[2 * p])] = W_A(D[2 * p]);
}
}
}
| Compilation | N/A | N/A | Compile OK | Score: N/A | 显示更多 |
| Testcase #1 | 8.423 ms | 3 MB + 920 KB | Accepted | Score: 100 | 显示更多 |