// ===== 引用区 =====
// [1] 原作者账号: saffah_cc_v41_agg1
// 原提交 URL: https://duck.ac/submission/129298
// 所用内容: 直接完整复制其计算引擎正文（为满足代码长度限制删除散文注释；代码逐字节等价，
// 以同一输入在评测机路径驱动下校验输出 checksum 与未删注释版相同），跨题用于本题。
// 许可证遵守: duck.ac 公开提交均未附独立许可证声明；按项目 INSTRUCTIONS 要求在同一评测站内
// 逐项注明原作者账号与原提交 URL 后使用；本发不新增第三方代码。
// [2] 上述提交正文内继承的全链引用（原注释所列提交号，逐一列明）:
// #99663, #103830, #106438, #106447, #106692, #106695, #106709, #106733, #106738, #106752, #106772, #106869, #106997, #107033, #107283, #107464, #107502, #107540, #107572, #107596, #108400, #108433, #108480, #108494, #108526, #108562, #108571, #108598, #108623, #108682, #109829, #109875, #109975, #111489, #112098, #113180, #113478, #113527, #114180, #114211, #114343, #120231, #120385, #120513, #120561, #122477, #122518, #122643, #122761, #122788, #126043, #126050, #127682, #128346, #128613, #128708, #128725
// ===== 思路区 =====
// 本次提交的目的（校准/基线）: 逐字采用本题当前 T 件引擎正文（去散文注释，代码逐字节等价；
// 本地同输入 checksum 与未删注释版相符），以本账号提交复现读数，建立本账号在本题的官方基线，
// 供后续单变量实验对比。算法、数据、常数均未改，本次不声称算法新思路。
// ============================================================
#define MAXQ (272)
#pragma GCC optimize("O3,unroll-loops,rename-registers,no-strict-aliasing,no-split-paths,no-split-loops,live-range-shrinkage,ira-loop-pressure,no-tree-slp-vectorize,align-loops=32,align-functions=32,no-ira-share-save-slots,no-ira-share-spill-slots")
#pragma GCC optimize("tracer")
#pragma GCC optimize("no-rerun-cse-after-loop,no-omit-frame-pointer")
#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt,tune=haswell")
#undef __code_model_small__
#undef __MMX_WITH_SSE__
#define __tune_core_avx2__ 1
#define __tune_haswell__ 1
#define __code_model_small__ 1
#define __SSE3__ 1
#define __SSSE3__ 1
#define __SSE4_1__ 1
#define __SSE4_2__ 1
#define __AVX__ 1
#define __AVX2__ 1
#define __BMI__ 1
#define __BMI2__ 1
#define __LZCNT__ 1
#define __CRC32__ 1
#define __POPCNT__ 1
#define __XSAVE__ 1
#define __MMX_WITH_SSE__ 1
#include <immintrin.h>
extern "C" void *malloc(unsigned long);
typedef unsigned u32;
typedef unsigned short u16;
typedef unsigned char u8;
typedef unsigned long long u64;
#define LDU256(p) ({ __m256i _v256; __asm__("vmovdqu %1, %0" : "=x"(_v256) : "m"(*(const __m256i *)(p))); _v256; })
#ifndef MAXN
#define MAXN 100032
#endif
#define MAXK 8
#define STRIDE 16
#ifndef MF_APF
#define MF_APF 0
#endif
#ifndef MF_QCOEF
#define MF_QCOEF 70
#endif
#ifndef MF_KSPAD
#define MF_KSPAD 1
#endif
#ifndef MF_FILTAUTO
#define MF_FILTAUTO 1
#endif
#ifndef MF_NT
#define MF_NT 1
#endif
#ifndef MF_FR_NOSORT
#define MF_FR_NOSORT 0
#endif
#ifndef MF_FR_NOCAND
#define MF_FR_NOCAND 0
#endif
#ifndef MF_BUILD_NOPOOL
#define MF_BUILD_NOPOOL 0
#endif
#ifndef MF_FR_NOREAD
#define MF_FR_NOREAD 0
#endif
#ifndef MF_NOSDMP
#define MF_NOSDMP 0
#endif
#ifndef MF_FB2
#define MF_FB2 0
#endif
#ifndef MF_FB3
#define MF_FB3 1
#endif
#ifndef MF_PLEN
#define MF_PLEN 1
#endif
#ifndef MF_BUDGETMB
#define MF_BUDGETMB 1900
#endif
#ifndef MF_NOFILTB
#define MF_NOFILTB 1
#endif
#ifndef MF_PFB
#define MF_PFB 16
#ifndef MF_PFB1
#define MF_PFB1 64
#endif
#ifndef MF_PFB2
#define MF_PFB2 24
#endif
#ifndef MF_PFB3
#define MF_PFB3 8
#endif
#ifndef MF_PFB4
#define MF_PFB4 96
#endif
#endif
#ifndef MF_ASCR
#define MF_ASCR 1
#endif
#ifndef MF_WTRIM
#define MF_WTRIM 1
#endif
#define AS_WORDS 20480
#ifndef MF_PFA
#define MF_PFA 1
#endif
#ifndef MF_FR_NOMETA
#define MF_FR_NOMETA 0
#endif
#ifndef MAXQ
#define MAXQ 4096
#endif
static u32 s_ord[MAXK][MAXN];
static u32 s_gt[MAXK][MAXN];
static u32 s_pm[(size_t)MAXN * STRIDE] __attribute__((aligned(64)));
static u8 s_bd_pad[448] __attribute__((used,aligned(64)));
static u8 s_bd[(size_t)MAXN * MAXK];
static u8 s_g[MAXN];
static u32 s_qord[MAXN], s_tmp[MAXN], s_cntv[MAXN];
static u32 s_frord[MAXK][MAXN];
static u64 s_brow[2][MAXN];
static u8 s_bkt[MAXN];
static u32 s_nid[MAXN];
static u32 s_pos[MAXK][MAXN];
static u32 s_posp[(size_t)MAXK * MAXN];
static u64 s_facc[(size_t)(MAXK - 1) * (((MAXN) + 63) / 64 + 16)];
static u32 s_bnde[(size_t)MAXK * (MAXQ + 2)];
static u64 *s_fbm = 0;
static u64 s_fbuf[8192] __attribute__((aligned(64)));
static __m256i khi8v, khi8hv;
static u32 g_Qc = 32;
static u32 g_fbm_W = 0;
static int g_use_filt = 0;
static int g_lexsort = 0;
static int g_nofilt = 0;
static u32 s_fpos[(MAXK + 1) * MAXQ];
static u32 s_bval[(MAXK + 1) * MAXQ];
static u64 *s_bs = 0;
static u64 s_acc[MAXN / 64 + 256] __attribute__((aligned(64)));
static u32 *s_sdmp[MAXK];
static u64 s_ascr[AS_WORDS] __attribute__((aligned(64)));
static u32 s_maxr[(size_t)MAXK * MAXK * MAXQ];
static u8 *s_sig = 0;
alignas(64) static u64 cached_sig[MAXN];
alignas(32) static u32 packed_fold_minimum[MAXN];
static int g_sig_on = 0;
static int g_sig_merged = 0;
static u32 g_sigsh = 0;
static inline u8 sig_nz(u8 v) { return v ? v : (u8)1; }
alignas(32) static const unsigned char y8_mskb[4][32] = {
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4},
{8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8},
{12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12},
};
#ifndef MF_SPL_ALIGN
#define MF_SPL_ALIGN 110592
#endif
static size_t g_spl = 0;
static u32 s_pofs[(size_t)MAXK * MAXQ];
static u32 s_plen[(size_t)MAXK * MAXQ];
static int g_plen_on = 0;
static u32 g_W, g_Q, g_B;
static u32 g_KS;
static int g_nosort = 0;
static int g_nosdmp = 0;
static int g_skip_and = 0, g_skip_fringe = 0;
int g_npf = 1, g_npfl = 2;
#define FPOS(d,b) s_fpos[(size_t)(d) * MAXQ + (b)]
#define BVAL(d,b) s_bval[(size_t)(d) * MAXQ + (b)]
extern "C" int madvise(void *, unsigned long, int);
static void *pool_alloc(size_t bytes) {
void *raw = malloc(bytes + (2u << 20));
if (!raw) return 0;
void *p = (void *)(((size_t)raw + (2u << 20) - 1) & ~(size_t)((2u << 20) - 1));
madvise(p, (unsigned long)bytes, 14);
return p;
}
__attribute__((target("avx2,popcnt")))
static inline u32 hsum256(__m256i v) {
u64 b[4];
_mm256_storeu_si256((__m256i *)b, v);
return (u32)(b[0] + b[1] + b[2] + b[3]);
}
template<int KK>
__attribute__((target("avx2,popcnt")))
static u32 and_popcount_range(const u64 *const *bs, u32 Wr, u32 rem) {
const __m256i lm = _mm256_set1_epi8(0x0f);
const __m256i lk = _mm256_setr_epi8(0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4);
const __m256i z = _mm256_setzero_si256();
__m256i tot = z, acc0=z, acc1=z, acc2=z, acc3=z;
u32 w = 0, cnt = 0, total = 0;
for (; w + 16 <= Wr; w += 16) {
__asm__ __volatile__("nop\n\tnop\n\tnop \n\tnop\n\tnop\n\tnop\n\t" ::: "ymm15");
__m256i a0 = _mm256_load_si256((const __m256i *)(bs[0] + w + 0));
for (int d=1; d<KK; d++) a0 = _mm256_and_si256(a0, _mm256_load_si256((const __m256i *)(bs[d] + w + 0)));
__m256i lo0 = _mm256_and_si256(a0, lm);
__m256i hi0 = _mm256_and_si256(_mm256_srli_epi16(a0, 4), lm);
acc0 = _mm256_add_epi8(acc0, _mm256_add_epi8(_mm256_shuffle_epi8(lk,lo0),_mm256_shuffle_epi8(lk,hi0)));
__m256i a1 = _mm256_load_si256((const __m256i *)(bs[0] + w + 4));
for (int d=1; d<KK; d++) a1 = _mm256_and_si256(a1, _mm256_load_si256((const __m256i *)(bs[d] + w + 4)));
__m256i lo1 = _mm256_and_si256(a1, lm);
__m256i hi1 = _mm256_and_si256(_mm256_srli_epi16(a1, 4), lm);
acc1 = _mm256_add_epi8(acc1, _mm256_add_epi8(_mm256_shuffle_epi8(lk,lo1),_mm256_shuffle_epi8(lk,hi1)));
__m256i a2 = _mm256_load_si256((const __m256i *)(bs[0] + w + 8));
for (int d=1; d<KK; d++) a2 = _mm256_and_si256(a2, _mm256_load_si256((const __m256i *)(bs[d] + w + 8)));
__m256i lo2 = _mm256_and_si256(a2, lm);
__m256i hi2 = _mm256_and_si256(_mm256_srli_epi16(a2, 4), lm);
acc2 = _mm256_add_epi8(acc2, _mm256_add_epi8(_mm256_shuffle_epi8(lk,lo2),_mm256_shuffle_epi8(lk,hi2)));
__m256i a3 = _mm256_load_si256((const __m256i *)(bs[0] + w + 12));
for (int d=1; d<KK; d++) a3 = _mm256_and_si256(a3, _mm256_load_si256((const __m256i *)(bs[d] + w + 12)));
__m256i lo3 = _mm256_and_si256(a3, lm);
__m256i hi3 = _mm256_and_si256(_mm256_srli_epi16(a3, 4), lm);
acc3 = _mm256_add_epi8(acc3, _mm256_add_epi8(_mm256_shuffle_epi8(lk,lo3),_mm256_shuffle_epi8(lk,hi3)));
if (++cnt == 31) {
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc0,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc1,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc2,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc3,z));
acc0=acc1=acc2=acc3=z; cnt=0;
}
}
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc0,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc1,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc2,z));
tot = _mm256_add_epi64(tot, _mm256_sad_epu8(acc3,z));
total = hsum256(tot);
for (; w + 4 <= Wr; w += 4) {
__m256i a=LDU256(bs[0]+w);
for (int d=1;d<KK;d++) a=_mm256_and_si256(a,LDU256(bs[d]+w));
__m256i lo=_mm256_and_si256(a,lm), hi=_mm256_and_si256(_mm256_srli_epi16(a,4),lm);
__m256i pc=_mm256_add_epi8(_mm256_shuffle_epi8(lk,lo),_mm256_shuffle_epi8(lk,hi));
total += hsum256(_mm256_sad_epu8(pc,z));
}
for (; w < Wr; w++) {
u64 v = bs[0][w];
for (int d = 1; d < KK; d++) v &= bs[d][w];
total += (u32)__builtin_popcountll(v);
}
if (rem) {
u64 v = bs[0][Wr];
for (int d = 1; d < KK; d++) v &= bs[d][Wr];
total += (u32)__builtin_popcountll(v & ((1ull << rem) - 1));
}
return total;
}
__attribute__((always_inline,target("avx2")))
static inline __m256i classify_sig7(const u8 *const *planes, const __m256i *query, u32 pos) {
__m256i v0 = LDU256(planes[0] + pos);
__m256i v1 = LDU256(planes[1] + pos);
__m256i v2 = LDU256(planes[2] + pos);
__m256i v3 = LDU256(planes[3] + pos);
__m256i v4 = LDU256(planes[4] + pos);
__m256i v5 = LDU256(planes[5] + pos);
__m256i v6 = LDU256(planes[6] + pos);
v0 = _mm256_subs_epi8(v0, query[0]);
v1 = _mm256_subs_epi8(v1, query[1]);
v2 = _mm256_subs_epi8(v2, query[2]);
v3 = _mm256_subs_epi8(v3, query[3]);
v4 = _mm256_subs_epi8(v4, query[4]);
v5 = _mm256_subs_epi8(v5, query[5]);
v6 = _mm256_subs_epi8(v6, query[6]);
__m256i a = _mm256_max_epi8(v0, v1);
__m256i b = _mm256_max_epi8(v2, v3);
__m256i c = _mm256_max_epi8(v4, v5);
return _mm256_max_epi8(_mm256_max_epi8(a, b), _mm256_max_epi8(c, v6));
}
template<int KK>
__attribute__((target("avx2,popcnt")))
__attribute__((flatten)) static void query_group(u32 N, u32 *out, u32 ds, u32 q0, u32 q1, u32 Q, u32 W) {
const u32 KS_C = (KK <= 8) ? 8u : (u32)KK;
const int k = KK;
const int K1 = KK - 1;
u32 *qo = s_qord, *tmp = s_tmp;
const __m256i koff = _mm256_setr_epi32(0, MAXQ, 2 * MAXQ, 3 * MAXQ,
4 * MAXQ, 5 * MAXQ, 6 * MAXQ, 7 * MAXQ);
const __m256i klt = _mm256_setr_epi32((0 < KK) ? -1 : 0, (1 < KK) ? -1 : 0,
(2 < KK) ? -1 : 0, (3 < KK) ? -1 : 0,
(4 < KK) ? -1 : 0, (5 < KK) ? -1 : 0,
(6 < KK) ? -1 : 0, (7 < KK) ? -1 : 0);
#if !MF_ASCR
for (u32 qi = q0; qi < q1; qi++) {
u32 i = qo[qi];
const u8 *bd0 = s_bd + (size_t)i * MAXK;
__m256i vidx = _mm256_add_epi32(_mm256_cvtepu8_epi32(_mm_loadl_epi64((const __m128i *)bd0)), koff);
if (KK < 8) vidx = _mm256_and_si256(vidx, klt);
__m256i a = _mm256_i32gather_epi32((const int *)s_bval, vidx, 4);
if (KK < 8) a = _mm256_blendv_epi8(_mm256_set1_epi32(0x7FFFFFFF), a, klt);
_mm256_storeu_si256((__m256i *)(s_pm + (size_t)i * STRIDE + 8), a);
}
#endif
#if MF_ASCR
const u32 d1 = (ds == 0) ? 1u : 0u;
const u32 e1 = (d1 < ds) ? d1 : d1 - 1;
qo = s_frord[d1];
#else
const u32 d1 = 0, e1 = 0;
#endif
if (g_lexsort) {
u32 *cntv = s_cntv;
for (int dd = k - 1; dd >= 0; dd--) {
if (dd == ds) continue;
for (u32 v = 0; v <= Q; v++) cntv[v] = 0;
for (u32 qi = q0; qi < q1; qi++) cntv[s_bd[(size_t)(qo[qi] & 0xFFFFFu) * MAXK + dd] + 1]++;
{ u32 ac = q0; for (u32 v = 0; v <= Q; v++) { u32 c = cntv[v]; cntv[v] = ac; ac += c; } }
for (u32 qi = q0; qi < q1; qi++) { u32 id = (qo[qi] & 0xFFFFFu); tmp[cntv[s_bd[(size_t)id * MAXK + dd] + 1]++] = id; }
u32 *sw = qo; qo = tmp; tmp = sw;
}
}
#ifdef PF_DIST
for (u32 qi = q0; qi < q0 + PF_DIST && qi + PF_DIST < q1; qi++) {
u32 j = (qo[qi + PF_DIST] & 0xFFFFFu);
const u8 *bdn = s_bd + (size_t)j * MAXK;
for (int e = 0; e < K1; e++) {
int d = (e < ds) ? e : e + 1;
const char *pp = (const char *)(s_bs + ((size_t)e * (Q + 1) + bdn[d]) * W);
_mm_prefetch(pp, _MM_HINT_T0);
_mm_prefetch(pp + 64, _MM_HINT_T0);
_mm_prefetch(pp + 128, _MM_HINT_T0);
}
}
#endif
#if MF_ASCR
{
u32 qi = q0;
while (qi < q1) {
u32 b1 = qo[qi] >> 20;
u32 qe = qi + 1;
while (qe < q1 && (qo[qe] >> 20) == b1) qe++;
const u64 *bp1 = g_plen_on ? (s_bs + s_pofs[(size_t)e1 * MAXQ + b1])
: (s_bs + ((size_t)e1 * (Q + 1) + b1) * W);
for (u32 qq = qi; qq < qe; qq++) {
u32 i = (qo[qq] & 0xFFFFFu);
u64 brow = s_brow[d1][qq];
const u8 *bd = (const u8 *)&brow;
#if MF_PFA > 0
{
u32 qj = qq + MF_PFA;
if (qj < qe) {
u32 j = (qo[qj] & 0xFFFFFu);
_mm_prefetch((const char *)(s_gt[ds] + j), _MM_HINT_T0);
}
}
#endif
const u32 R = s_gt[ds][i];
u32 cnt = 0;
if (g_npf > 0 && qq + 1 < qe) {
u64 nb = s_brow[d1][qq + 1];
const u8 *nbd = (const u8 *)&nb;
for (int e = 0; e < K1; e++) {
if (e == (int)e1) continue;
int d = (e < ds) ? e : e + 1;
const char *pa = (const char *)(s_bs + s_pofs[(size_t)e * MAXQ + nbd[d]]);
_mm_prefetch(pa, _MM_HINT_T0);
if (g_npfl > 1) _mm_prefetch(pa + 64, _MM_HINT_T0);
}
}
if (R && !g_skip_and) {
const u64 *bp[MAXK];
for (int e = 0; e < K1; e++) {
if (e == (int)e1) bp[e] = bp1;
else { int d = (e < ds) ? e : e + 1;
bp[e] = g_plen_on ? (s_bs + s_pofs[(size_t)e * MAXQ + bd[d]])
: (s_bs + ((size_t)e * (Q + 1) + bd[d]) * W); }
}
cnt = and_popcount_range<KK - 1>(bp, R >> 6, R & 63u);
}
out[i] = cnt;
}
qi = qe;
}
}
#else
for (u32 qi = q0; qi < q1; qi++) {
u32 i = (qo[qi] & 0xFFFFFu);
const u8 *bd = s_bd + (size_t)i * MAXK;
#if MF_PFA > 0
{
u32 qj = qi + MF_PFA;
if (qj < q1) {
u32 j = (qo[qj] & 0xFFFFFu);
_mm_prefetch((const char *)(s_bd + (size_t)j * MAXK), _MM_HINT_T0);
_mm_prefetch((const char *)(s_gt[ds] + j), _MM_HINT_T0);
}
}
#endif
#ifdef PF_DIST
if (qi + PF_DIST < q1) {
u32 j = (qo[qi + PF_DIST] & 0xFFFFFu);
const u8 *bdn = s_bd + (size_t)j * MAXK;
for (int e = 0; e < K1; e++) {
int d = (e < ds) ? e : e + 1;
const char *pp = (const char *)(s_bs + ((size_t)e * (Q + 1) + bdn[d]) * W);
_mm_prefetch(pp, _MM_HINT_T0);
_mm_prefetch(pp + 64, _MM_HINT_T0);
_mm_prefetch(pp + 128, _MM_HINT_T0);
}
}
#endif
const u32 R = s_gt[ds][i];
u32 cnt = 0;
if (R && !g_skip_and) {
const u64 *bp[MAXK];
for (int e = 0; e < K1; e++) {
int d = (e < ds) ? e : e + 1;
bp[e] = g_plen_on ? (s_bs + s_pofs[(size_t)e * MAXQ + bd[d]])
: (s_bs + ((size_t)e * (Q + 1) + bd[d]) * W);
#ifdef DBG_PLEN
if (g_plen_on) {
u32 need = (R >> 6) + ((R & 63) ? 1 : 0);
if (need > s_plen[(size_t)e * MAXQ + bd[d]])
printf("DBG ds=%d e=%d d=%d b=%u R=%u need=%u len=%u\n", ds, e, d, bd[d], R, need, s_plen[(size_t)e * MAXQ + bd[d]]);
}
#endif
}
cnt = and_popcount_range<KK - 1>(bp, R >> 6, R & 63u);
}
out[i] = cnt;
}
#endif
if (g_skip_fringe) return;
for (int d = 0; d < k; d++) {
if (d == ds) continue;
const u32 *fo = s_frord[d];
u32 exmask = 0;
for (int e = 0; e < d; e++) if (e != ds) exmask |= 1u << e;
u32 hiA[8], hiAh[8];
for (int e = 0; e < 8; e++) hiA[e] = ((exmask >> e) & 1u) ? 0u : 0x7FFFFFFFu;
for (int e = 8; e < 16; e++) hiAh[e - 8] = ((exmask >> e) & 1u) ? 0u : 0x7FFFFFFFu;
const __m256i notexlo = LDU256(hiA);
const __m256i notexloh = LDU256(hiAh);
const __m256i all8 = _mm256_set1_epi32(-1);
const u32 *const odd = s_ord[d];
const u8 *sgv[16];
int nzsig = 0;
if (s_sig) {
const u8 *sgb_base = s_sig + (size_t)d * k * (g_spl);
const size_t sgv_pl = g_spl;
for (int e = 0; e < k; e++) { if (e == (int)d) continue; sgv[nzsig++] = sgb_base + (size_t)e * sgv_pl; }
}
const u32 *const sdmpd = s_sdmp[d];
for (u32 qi = q0; qi < q1; qi++) {
u32 i = fo[qi] & 0xFFFFFu;
#if MF_PFB > 0
{
u32 qj = qi + MF_PFB3;
if (qj < q1) {
u32 j = fo[qj] & 0xFFFFFu;
_mm_prefetch((const char *)(s_pm + (size_t)j * STRIDE), _MM_HINT_T0);
_mm_prefetch((const char *)(s_gt[d] + j), _MM_HINT_T0);
_mm_prefetch((const char *)(out + j), _MM_HINT_T0);
}
}
#endif
const u32 lo = FPOS(d, fo[qi] >> 20);
const u32 hi = s_gt[d][i];
if (lo >= hi) continue;
const u32 *rec = s_pm + (size_t)i * STRIDE;
__m256i qr = (KK==8) ? _mm256_load_si256((const __m256i *)rec) : _mm256_or_si256(_mm256_load_si256((const __m256i *)rec), khi8v);
__m256i Avraw = LDU256((const __m256i *)(s_pm + (size_t)i * STRIDE + 8));
__m256i Avm = _mm256_or_si256(Avraw, notexlo);
__m256i qT = _mm256_min_epi32(qr, Avm);
__m256i qTh;
if (k > 8) {
__m256i qrh = _mm256_or_si256(LDU256((rec + 8)), khi8hv);
__m256i Avmh = _mm256_set1_epi32(0x7FFFFFFF);
qTh = _mm256_min_epi32(qrh, Avmh);
} else {
qTh = all8;
}
u32 add = 0;
const u32 *c0 = sdmpd ? (sdmpd + (size_t)lo * KS_C) : 0;
if (g_use_filt) {
const u32 w0 = lo >> 6;
const u32 nw = ((hi - 1) >> 6) - w0 + 1;
u64 *fb = s_fbuf;
const u64 wcs = (u64)N / g_Qc + 1;
const u32 FW = g_fbm_W;
int first = 1;
#if MF_FR_NOREAD
first = 0;
for (u32 w = 0; w < nw; w++) fb[w] = 0;
#endif
for (int e = 0; e < k; e++) {
if (e == d) continue;
u32 c = (u32)((u64)rec[e] / wcs) + 1;
if (c > g_Qc) c = g_Qc;
const u64 *row = s_fbm + ((size_t)(d * k + e) * (g_Qc + 1) + c) * FW + w0;
if (first) { for (u32 w = 0; w < nw; w++) fb[w] = row[w]; first = 0; }
else { for (u32 w = 0; w < nw; w++) fb[w] &= row[w]; }
}
fb[0] &= ~0ull << (lo & 63);
u32 r2 = hi & 63u;
if (r2) fb[nw - 1] &= (1ull << r2) - 1;
for (u32 w = 0; w < nw; w++) {
u64 vv = fb[w];
#if MF_FR_NOCAND
vv = 0;
#endif
while (vv) {
int t = __builtin_ctzll(vv);
vv &= vv - 1;
u32 j = ((w0 + w) << 6) + (u32)t;
const u32 *cp = c0 ? (c0 + (size_t)(j - lo) * KS_C) : (s_pm + (size_t)s_ord[d][j] * STRIDE);
__m256i pv = LDU256(cp);
u32 ok = (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8);
if (k > 8) {
__m256i pvh = LDU256((cp + 8));
ok &= (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, pvh), all8);
}
add += ok;
}
}
out[i] += add;
continue;
}
if (g_sig_on && (hi - lo) >= 2) {
__m256i qsv[16];
{
const __m256i shv = _mm256_set1_epi32((int)g_sigsh);
__m256i sv0 = _mm256_xor_si256(_mm256_srlv_epi32(qT, shv),
_mm256_set1_epi8((char)0x80));
const __m256i ylo = _mm256_broadcastsi128_si256(_mm256_castsi256_si128(sv0));
const __m256i yhi = _mm256_broadcastsi128_si256(_mm256_extracti128_si256(sv0, 1));
__m256i zlo = ylo, zhi = yhi;
if (k > 8) {
__m256i sv1 = _mm256_xor_si256(_mm256_srlv_epi32(qTh, shv),
_mm256_set1_epi8((char)0x80));
zlo = _mm256_broadcastsi128_si256(_mm256_castsi256_si128(sv1));
zhi = _mm256_broadcastsi128_si256(_mm256_extracti128_si256(sv1, 1));
}
if (k == 8) {
switch (d) {
case 0:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[3] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 1:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[3] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 2:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[3] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 3:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[3] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 4:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[3] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 5:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[3] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 6:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[3] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[3]));
break;
case 7:
qsv[0] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[1] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[2] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[2]));
qsv[3] = _mm256_shuffle_epi8(ylo, _mm256_load_si256((const __m256i *)y8_mskb[3]));
qsv[4] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[0]));
qsv[5] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[1]));
qsv[6] = _mm256_shuffle_epi8(yhi, _mm256_load_si256((const __m256i *)y8_mskb[2]));
break;
}
} else {
int t = 0;
for (int e = 0; e < k; e++) {
if (e == (int)d) continue;
__m256i src = (e < 8) ? ((e < 4) ? ylo : yhi) : ((e < 12) ? zlo : zhi);
qsv[t++] = _mm256_shuffle_epi8(
src, _mm256_load_si256((const __m256i *)y8_mskb[e & 3]));
}
}
}
u32 aj = lo, aacc = 0, aexact = 0;
for (; aj + 32 <= hi; aj += 32) {
__m256i ac;
if (k == 8) ac = classify_sig7(sgv, qsv, aj);
else {
ac = _mm256_set1_epi8((char)0x80);
for (int t = 0; t < nzsig; t++) {
__m256i cv = LDU256((sgv[t] + aj));
ac = _mm256_max_epi8(ac, _mm256_subs_epi8(cv, qsv[t]));
}
}
u32 decm = (u32)_mm256_movemask_epi8(ac);
u32 amb = (u32)_mm256_movemask_epi8(_mm256_cmpeq_epi8(ac, _mm256_setzero_si256()));
aacc += (u32)__builtin_popcount(decm);
if (amb) {
while (amb) {
int t = __builtin_ctz(amb); amb &= amb - 1;
const u32 *cp = c0 ? (c0 + (size_t)(aj + (u32)t - lo) * KS_C)
: (s_pm + (size_t)odd[aj + (u32)t] * STRIDE);
__m256i pv = LDU256(cp);
u32 okl = (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8);
if (k > 8) {
__m256i pvh = LDU256((cp + 8));
okl &= (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, pvh), all8);
}
aacc += okl;
}
}
}
{
u32 r = hi - aj;
if (r) {
const u32 base = aj, lk = 0u;
u32 kmask = (1u << r) - 1u;
__m256i ac;
if (k == 8) ac = classify_sig7(sgv, qsv, base);
else {
ac = _mm256_set1_epi8((char)0x80);
for (int t = 0; t < nzsig; t++) {
__m256i cv = LDU256((sgv[t] + base));
ac = _mm256_max_epi8(ac, _mm256_subs_epi8(cv, qsv[t]));
}
}
u32 decm = ((u32)_mm256_movemask_epi8(ac)) & kmask;
u32 amb = ((u32)_mm256_movemask_epi8(_mm256_cmpeq_epi8(ac, _mm256_setzero_si256()))) & kmask;
aacc += (u32)__builtin_popcount(decm);
if (amb) {
while (amb) {
int t = __builtin_ctz(amb); amb &= amb - 1;
const u32 *cp = c0 ? (c0 + (size_t)(base + (u32)t - lo) * KS_C)
: (s_pm + (size_t)odd[base + (u32)t] * STRIDE);
__m256i pv = LDU256(cp);
u32 okl = (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8);
if (k > 8) {
__m256i pvh = LDU256((cp + 8));
okl &= (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, pvh), all8);
}
aacc += okl;
}
}
}
}
add = aacc;
} else if (c0) {
if (k <= 8) {
const u32 *c = c0;
u32 a0 = 0, a1 = 0, a2 = 0, a3 = 0;
u32 j = lo;
for (; j + 4 <= hi; j += 4) {
__m256i p0 = LDU256((c));
__m256i p1 = LDU256((c + KS_C));
__m256i p2 = LDU256((c + 2 * KS_C));
__m256i p3 = LDU256((c + 3 * KS_C));
a0 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p0), all8);
a1 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p1), all8);
a2 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p2), all8);
a3 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p3), all8);
c += 4 * KS_C;
}
for (; j < hi; j++, c += KS_C) {
__m256i pv = LDU256(c);
a0 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8);
}
add = a0 + a1 + a2 + a3;
} else {
const u32 *c = c0;
u32 a0 = 0, a1 = 0, a2 = 0, a3 = 0;
u32 j = lo;
for (; j + 4 <= hi; j += 4) {
__m256i p0 = LDU256((c));
__m256i p1 = LDU256((c + KS_C));
__m256i p2 = LDU256((c + 2 * KS_C));
__m256i p3 = LDU256((c + 3 * KS_C));
__m256i h0 = LDU256((c + 8));
__m256i h1 = LDU256((c + KS_C + 8));
__m256i h2 = LDU256((c + 2 * KS_C + 8));
__m256i h3 = LDU256((c + 3 * KS_C + 8));
a0 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p0), all8) & (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, h0), all8);
a1 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p1), all8) & (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, h1), all8);
a2 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p2), all8) & (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, h2), all8);
a3 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, p3), all8) & (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, h3), all8);
c += 4 * KS_C;
}
for (; j < hi; j++, c += KS_C) {
__m256i pv = LDU256(c);
__m256i pvh = LDU256((c + 8));
a0 += (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8) &
(u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, pvh), all8);
}
add = a0 + a1 + a2 + a3;
}
} else {
for (u32 j = lo; j < hi; j++) {
const u32 *c = s_pm + (size_t)odd[j] * STRIDE;
__m256i pv = _mm256_load_si256((const __m256i *)c);
u32 ok = (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qT, pv), all8);
if (k > 8) {
__m256i pvh = _mm256_load_si256((const __m256i *)(c + 8));
ok &= (u32)_mm256_testc_si256(_mm256_cmpgt_epi32(qTh, pvh), all8);
}
add += ok;
}
}
out[i] += add;
}
}
}
__attribute__((target("avx2")))
__attribute__((aligned(64))) static void solve_mf(u32 N, const unsigned **x, u32 *out, int k) {
const u32 W = ((N + 63) / 64 + 7u) & ~7u;
g_W = W;
#ifdef MF_SKIP_AND
g_skip_and = 1;
#endif
#ifdef MF_FILT
g_use_filt = 1;
#endif
#ifdef MF_NOFILT
g_use_filt = 0;
#endif
#ifdef MF_Q
g_Q = MF_Q; g_B = (u32)((N + (MF_Q) - 1) / (MF_Q));
#endif
#ifdef MF_FILT
g_use_filt = 1;
#endif
#ifdef MF_NOFILT
g_use_filt = 0;
#endif
#ifdef MF_SKIP_FRINGE
g_skip_fringe = 1;
#endif
if (!g_Q) {
u64 r = (u64)N, s2 = 0;
while (s2 * s2 < r) s2++;
u64 overhead = (u64)(5 * k + 21) * N * 4;
overhead += (u64)k * k * 4 * N;
overhead += (u64)k * k * ((u64)N + 64);
overhead += (u64)N * ((k <= 8) ? 8u : (u32)k) * 4 * k;
u64 budget = ((u64)MF_BUDGETMB << 20);
if (budget > overhead + ((u64)64 << 20)) budget -= overhead; else budget = (u64)64 << 20;
#if MF_PLEN
static const u32 kfill[7] = {72, 67, 62, 58, 54, 50, 46};
u64 perfill = ((u64)(k - 1) * W * 8) * kfill[k - 4] / 100;
#else
u64 perfill = (u64)(k - 1) * W * 8;
#endif
u64 Qmem = budget / (perfill ? perfill : 1);
if (Qmem < 8) Qmem = 8;
static const u32 kscale[7] = {82, 91, 100, 108, 115, 122, 129};
u32 q = (u32)((s2 * MF_QCOEF + 99) / 100);
q = (u32)(((u64)q * kscale[k - 4] + 99) / 100);
if (q >= MAXQ) q = MAXQ - 1;
if ((u64)q > Qmem) q = (u32)Qmem;
if (q > N) q = N;
g_Q = q;
g_B = (N + q - 1) / q;
}
const u32 Q = g_Q, B = g_B;
const u32 Bc = B;
u64 divM; int divS;
{ u64 t = (u64)B * (u64)N; divS = 0;
while (divS < 64 && ((u64)1 << divS) < t) divS++;
divM = ((u64)1 << divS) / B + 1; }
#if MF_PLEN
g_plen_on = 1;
#endif
#if MF_WTRIM
u32 Wpool = W;
#else
const u32 Wpool = W;
#endif
#if MF_FILTAUTO
if (!g_use_filt && B >= 400) g_use_filt = 1;
#endif
if (g_use_filt && (u64)k * k * (g_Qc + 1) * W * 8 > ((u64)700 << 20)) g_use_filt = 0;
#if !MF_FILTAUTO
g_use_filt = 0;
#endif
{
int lo8[8], hi8[8];
for (int e = 0; e < 8; e++) lo8[e] = (e < k) ? 0 : 0x7FFFFFFF;
for (int e = 0; e < 8; e++) hi8[e] = (8 + e < k) ? 0 : 0x7FFFFFFF;
khi8v = LDU256(lo8);
khi8hv = LDU256(hi8);
}
const int K1 = k - 1;
for (int d = 0; d < k; d++) {
const unsigned *xd = x[d];
u32 *od = s_ord[d];
static u8 freq8[MAXN+1] __attribute__((aligned(64)));
for(u32 i=0;i<=N;i++)freq8[i]=0;
for(u32 i=0;i<N;i++){u32 v=xd[i];freq8[v<N?v:0]++;}
u32 sum=0;
for(u32 i=0;i<=N;i++){u32 c=freq8[i];s_tmp[i]=sum;sum+=c;}
bool compact=(sum==N);
if(!compact){
for(u32 i=0;i<=N;i++)s_cntv[i]=0;
for(u32 i=0;i<N;i++){u32 v=xd[i];s_cntv[v<N?v:0]++;}
sum=0;for(u32 i=0;i<=N;i++){u32 c=s_cntv[i];s_cntv[i]=sum;s_tmp[i]=sum;sum+=c;}
}
if(compact){
u32 *gt=s_gt[d],*pp=s_pos[d];
for(u32 i=0;i<N;i++){
u32 v=xd[i];if(v>=N)v=0;
u32 w=s_tmp[v],st=w&0xfffffu,q=st+(w>>20);
s_tmp[v]=w+(1u<<20);od[q]=i;
#if MF_FB2
s_posp[(size_t)i*MAXK+d]=q;
#else
if(g_use_filt)pp[i]=q;
#endif
gt[i]=st;
u32 num=(s_tmp[v+1]&0xfffffu)-1u;
u32 bb=(u32)(((u64)num*divM)>>divS);
s_bd[(size_t)i*MAXK+d]=bb>Q-1?Q-1:bb;
}
}else{
#if MF_FB2
for (u32 i = 0; i < N; i++) {
u32 v = xd[i]; if (v >= N) v = 0; u32 q = s_tmp[v]++; od[q] = i;
s_posp[(size_t)i * MAXK + d] = q;
}
#else
if (g_use_filt) {
u32 *pp = s_pos[d];
for (u32 i = 0; i < N; i++) {
u32 v = xd[i]; if (v >= N) v = 0; u32 q = s_tmp[v]++; od[q] = i; pp[i] = q;
}
} else {
for (u32 i = 0; i < N; i++) { u32 v = xd[i]; if (v >= N) v = 0; od[s_tmp[v]++] = i; }
}
#endif
{ u32 *gt = s_gt[d];
for (u32 i = 0; i < N; i++) {
u32 v = xd[i]; if (v >= N) v = 0;
gt[i] = s_cntv[v];
u32 bb = (u32)(((u64)(s_cntv[v + 1] - 1u) * divM) >> divS);
s_bd[(size_t)i * MAXK + d] = bb > Q - 1 ? Q - 1 : bb;
} }
}
BVAL(d, 0) = 0; FPOS(d, 0) = 0;
for (u32 b = 1; b < Q; b++) {
u32 pos = b * B < N ? b * B : N - 1;
u32 v = xd[od[pos]];
BVAL(d, b) = v;
u32 gs = pos;
while (gs > 0 && xd[od[gs - 1]] == v) gs--;
FPOS(d, b) = gs;
}
BVAL(d, Q) = 0xFFFFFFFFu; FPOS(d, Q) = 0;
}
{
u32 nn0 = N - 1; u32 sh0 = 0;
while (nn0 > 255u) { nn0 >>= 1; sh0++; }
const __m256i koff = _mm256_setr_epi32(0, MAXQ, 2*MAXQ, 3*MAXQ,
4*MAXQ, 5*MAXQ, 6*MAXQ, 7*MAXQ);
const __m256i shv0 = _mm256_set1_epi32((int)sh0);
const __m256i bias = _mm256_set1_epi8((char)0x80);
for (u32 i = 0; i < N; ++i) {
u32 *p = s_pm + (size_t)i * STRIDE;
for (int d = 0; d < k; d++) p[d] = x[d][i];
for (int d = k; d < 8; d++) p[d] = 0;
const u8 *bd0 = s_bd + (size_t)i * MAXK;
__m256i vidx = _mm256_add_epi32(
_mm256_cvtepu8_epi32(_mm_loadl_epi64((const __m128i *)bd0)), koff);
__m256i a = _mm256_i32gather_epi32((const int *)s_bval, vidx, 4);
if (k < 8)
for (int e = k; e < 8; ++e) ((u32 *)(void *)&a)[e] = 0x7FFFFFFFu;
__m256i rv = LDU256((const __m256i *)p);
_mm256_storeu_si256((__m256i *)(p + 8), a);
__m256i sv = _mm256_srlv_epi32(rv, shv0);
__m256i pk = _mm256_packus_epi32(sv, sv);
__m256i pb = _mm256_xor_si256(_mm256_packus_epi16(pk, pk), bias);
__m128i cm = _mm_unpacklo_epi32(_mm256_castsi256_si128(pb), _mm256_extracti128_si256(pb, 1));
_mm_storel_epi64((__m128i *)(cached_sig + i), cm);
}
}
{ size_t s0 = (size_t)N + 64;
#if MF_SPL_ALIGN > 1
s0 = (s0 + (size_t)(MF_SPL_ALIGN) - 1) / (size_t)(MF_SPL_ALIGN) * (size_t)(MF_SPL_ALIGN);
#endif
g_spl = s0; }
{
u32 nn = N - 1; u32 sh = 0;
while (nn > 255u) { nn >>= 1; sh++; }
g_sigsh = sh;
size_t need = (size_t)k * k * (g_spl);
static u8 *sigpool = 0; static size_t sigcap = 0;
if (need > ((size_t)220 << 20)) { sigpool = 0; sigcap = 0; }
else if (need > sigcap) { sigpool = (u8 *)pool_alloc(need); sigcap = sigpool ? need : 0; }
if (sigpool) {
s_sig = sigpool;
g_sig_on = 1;
g_sig_merged = 0;
}
}
#if MF_NOFILTB
g_use_filt = 0;
#endif
#if MF_FB3
if (g_use_filt) {
u32 Qc = g_Qc;
u64 wc = (u64)N / Qc + 1;
for (int e = 0; e < k; e++) {
const unsigned *xe = x[e];
const u32 *pe = s_ord[e];
u32 ptr = 0;
u32 *bn = s_bnde + (size_t)e * (MAXQ + 2);
for (u32 c = 0; c <= Qc; c++) {
u64 v = (u64)c * wc;
if (v > 0xFFFFFFFFull) v = 0xFFFFFFFFull;
while (v && ptr < N && (u64)xe[pe[ptr]] < v) ptr++;
bn[c] = ptr;
}
}
}
#endif
if (g_use_filt) {
u32 Qc = g_Qc;
u64 wc = (u64)N / Qc + 1;
size_t need2 = (size_t)k * k * (Qc + 1) * W * sizeof(u64);
static u64 *fpool = 0; static size_t fcap = 0;
if (need2 > fcap) { fpool = (u64 *)pool_alloc(need2 + 4096); fcap = need2; }
if (fpool) {
s_fbm = fpool; g_fbm_W = W;
#if MF_FB2
for (int d = 0; d < k; d++)
for (int e = 0; e < k; e++) {
if (e == d) continue;
u64 *b0 = s_fbm + (size_t)(d * k + e) * (Qc + 1) * W;
for (u32 w = 0; w < W; w++) b0[w] = 0;
}
for (int e = 0; e < k; e++) {
const unsigned *xe = x[e];
const u32 *pe = s_ord[e];
int dmap[MAXK], km1 = 0;
for (int d = 0; d < k; d++) if (d != e) dmap[km1++] = d;
for (int i = 0; i < km1; i++) { u64 *a = s_facc + (size_t)i * W; for (u32 w = 0; w < W; w++) a[w] = 0; }
u32 ptr = 0;
for (u32 c = 1; c <= Qc; c++) {
u64 v = (u64)c * wc;
if (v > 0xFFFFFFFFull) v = 0xFFFFFFFFull;
while (ptr < N && (u64)xe[pe[ptr]] < v) {
const u32 *pv = s_posp + (size_t)pe[ptr] * MAXK;
for (int i = 0; i < km1; i++) {
u32 q = pv[dmap[i]];
s_facc[(size_t)i * W + (q >> 6)] |= 1ull << (q & 63);
}
ptr++;
}
for (int i = 0; i < km1; i++) {
int d = dmap[i];
u64 *dst = s_fbm + ((size_t)(d * k + e) * (Qc + 1) + c) * W;
const u64 *src = s_facc + (size_t)i * W;
#if MF_NT
{ u32 w = 0;
for (; w + 4 <= W; w += 4) _mm256_stream_si256((__m256i *)(dst + w), _mm256_load_si256((const __m256i *)(src + w)));
for (; w < W; w++) dst[w] = src[w]; }
#else
{ u32 w = 0;
for (; w + 4 <= W; w += 4) _mm256_storeu_si256((__m256i *)(dst + w), LDU256((const __m256i *)(src + w)));
for (; w < W; w++) dst[w] = src[w]; }
#endif
}
}
}
#else
for (int d = 0; d < k; d++) {
for (int e = 0; e < k; e++) {
if (e == d) continue;
const unsigned *xe = x[e];
const u32 *pe = s_ord[e];
const u32 *pd = s_pos[d];
u64 *base = s_fbm + (size_t)(d * k + e) * (Qc + 1) * W;
for (u32 w = 0; w < W; w++) base[w] = 0;
u64 *cur = s_acc;
for (u32 w = 0; w < W; w++) cur[w] = 0;
u32 ptr = 0;
for (u32 c = 1; c <= Qc; c++) {
#if MF_FB3
u32 pend = s_bnde[(size_t)e * (MAXQ + 2) + c];
#else
u64 v = (u64)c * wc;
if (v > 0xFFFFFFFFull) v = 0xFFFFFFFFull;
u32 pend = ptr;
{ const unsigned *xe_ = xe; const u32 *pe_ = pe;
while (pend < N && (u64)xe_[pe_[pend]] < v) pend++; }
#endif
while (ptr < pend) { u32 q = pd[pe[ptr]]; cur[q >> 6] |= 1ull << (q & 63); ptr++; }
u64 *dst = base + (size_t)c * W;
#if MF_NT
{ u32 w = 0;
for (; w + 4 <= W; w += 4) _mm256_stream_si256((__m256i *)(dst + w), _mm256_load_si256((const __m256i *)(cur + w)));
for (; w < W; w++) dst[w] = cur[w]; }
#else
for (u32 w = 0; w < W; w++) dst[w] = cur[w];
#endif
}
}
}
#endif
} else { g_use_filt = 0; }
_mm_sfence();
}
{
size_t mrn = (size_t)MAXK * MAXK * MAXQ;
for (size_t z = 0; z < mrn; z++) s_maxr[z] = 0;
}
if(k==8){
u32 i=0;
for(;i+8<=N;i+=8){
__m256i m=_mm256_slli_epi32(_mm256_loadu_si256((const __m256i*)(s_gt[0]+i)),3);
for(unsigned d=1;d<8;++d){
__m256i v=_mm256_or_si256(_mm256_slli_epi32(_mm256_loadu_si256((const __m256i*)(s_gt[d]+i)),3),_mm256_set1_epi32(d));
m=_mm256_min_epu32(m,v);
}
_mm256_store_si256((__m256i*)(packed_fold_minimum+i),m);
}
for(;i<N;++i){u32 m=s_gt[0][i]<<3;for(unsigned d=1;d<8;++d){u32 v=(s_gt[d][i]<<3)|d;if(v<m)m=v;}packed_fold_minimum[i]=m;}
}
u32 gstart[MAXK+2] = {};
for (u32 i = 0; i < N; i++) {
u32 best = 0xFFFFFFFFu; int ds = 0;
if (k == 8) {
const u32 packed=packed_fold_minimum[i];
best=packed>>3;ds=packed&7u;
} else {
for (int d = 0; d < k; d++) {
u32 g = s_gt[d][i];
if (g < best) { best = g; ds = d; }
}
}
s_g[i] = (u32)ds;
#if MF_ASCR
++gstart[ds+1];
#endif
if (g_plen_on) {
const u8 *bdv = s_bd + (size_t)i * MAXK;
u32 *mr = s_maxr + ((size_t)ds * MAXK) * MAXQ;
u32 bb = best;
for (int d = 0; d < k; d++) {
if (d == ds) continue;
u32 b = bdv[d];
u32 *slot = mr + (size_t)d * MAXQ + b;
*slot = bb > *slot ? bb : *slot;
}
}
}
#if MF_ASCR
for(unsigned d=1;d<=unsigned(k+1);++d)gstart[d]+=gstart[d-1];
#else
for (u32 i = 0; i < N; i++) s_qord[i] = i;
{
for (u32 v = 0; v <= (u32)k; v++) s_cntv[v] = 0;
for (u32 i = 0; i < N; i++) s_cntv[s_g[i] + 1]++;
{ u32 ac = 0; for (u32 v = 0; v <= (u32)k; v++) { u32 c = s_cntv[v]; s_cntv[v] = ac; ac += c; } }
for (u32 i = 0; i < N; i++) { u32 id = s_qord[i]; s_tmp[s_cntv[s_g[id] + 1]++] = id; }
for (u32 i = 0; i < N; i++) s_qord[i] = s_tmp[i];
}
{ u32 c = 0; for (int d = 0; d <= k; d++) { gstart[d] = c; while (c < N && (int)s_g[s_qord[c]] == d) c++; } gstart[k + 1] = c; }
#endif
{
u32 bmax = (N - 1) / Bc;
if (bmax > Q - 1) bmax = Q - 1;
for (int d = 0; d < k; d++) {
u32 pos[MAXK];
for (int ds = 0; ds < k; ds++) pos[ds] = gstart[ds];
const u32 *const fpd = s_fpos + (size_t)d * MAXQ;
u32 b = 0;
for (u32 r = 0; r < N; r++) {
while (b < bmax && r >= fpd[b + 1]) b++;
u32 id = s_ord[d][r];
u32 dst = pos[s_g[id]]++;
if (d < 2) s_brow[d][dst] = *(const u64 *)(s_bd + (size_t)id * MAXK);
s_frord[d][dst] = id | (b << 20);
}
}
}
#if MF_NOSDMP
g_nosdmp = 1;
#endif
if (!g_nosdmp) {
u32 KS = k;
#if MF_KSPAD
if (k <= 8) KS = 8;
#endif
size_t per = (size_t)N * KS * 4;
size_t lim = (size_t)150 << 20;
if (k >= 9) lim = (size_t)470 << 20;
const int skiprows = (k == 8);
if (per * k <= lim) {
static u32 *pool = 0; static size_t cap = 0;
if (!skiprows && per * k > cap) { pool = (u32 *)pool_alloc(per * k + 256); cap = per * k; }
if (pool || skiprows) {
g_KS = KS;
for (int d = 0; d < k; d++) {
s_sdmp[d] = skiprows ? 0 : (pool + (size_t)d * N * g_KS);
const u32 *od = s_ord[d];
u32 *dst = s_sdmp[d];
const u32 KSx = g_KS;
if (KSx == (u32)k && k == 8) {
const size_t pl = g_spl;
u8 *sb = s_sig ? (s_sig + (size_t)d * k * pl) : 0;
u8 *sbase[MAXK];
if (sb) for (int e = 0; e < k; e++) sbase[e] = sb + (size_t)e * pl;
if (sb) {
u8 stg[8][8] __attribute__((aligned(64)));
u32 j = 0;
for (; j + 8 <= N; j += 8) {
for (u32 t=0;t<8;t++) {
const u32 jj=j+t;
if (jj+64<N) _mm_prefetch((const char*)(cached_sig+od[jj+64]),_MM_HINT_T0);
*(u64*)stg[t]=cached_sig[od[jj]];
if (!skiprows) _mm256_stream_si256((__m256i*)(dst+(size_t)jj*KSx),_mm256_loadu_si256((const __m256i*)(s_pm+(size_t)od[jj]*STRIDE)));
}
{
__m128i a0 = _mm_loadl_epi64((const __m128i *)stg[0]), a1 = _mm_loadl_epi64((const __m128i *)stg[1]);
__m128i a2 = _mm_loadl_epi64((const __m128i *)stg[2]), a3 = _mm_loadl_epi64((const __m128i *)stg[3]);
__m128i a4 = _mm_loadl_epi64((const __m128i *)stg[4]), a5 = _mm_loadl_epi64((const __m128i *)stg[5]);
__m128i a6 = _mm_loadl_epi64((const __m128i *)stg[6]), a7 = _mm_loadl_epi64((const __m128i *)stg[7]);
__m128i x0 = _mm_unpacklo_epi8(a0, a1), x1 = _mm_unpacklo_epi8(a2, a3);
__m128i x2 = _mm_unpacklo_epi8(a4, a5), x3 = _mm_unpacklo_epi8(a6, a7);
__m128i y0 = _mm_unpacklo_epi16(x0, x1), y1 = _mm_unpackhi_epi16(x0, x1);
__m128i y2 = _mm_unpacklo_epi16(x2, x3), y3 = _mm_unpackhi_epi16(x2, x3);
__m128i z0 = _mm_unpacklo_epi32(y0, y2), z1 = _mm_unpackhi_epi32(y0, y2);
__m128i z2 = _mm_unpacklo_epi32(y1, y3), z3 = _mm_unpackhi_epi32(y1, y3);
_mm_storel_epi64((__m128i *)(sbase[0] + j), z0);
_mm_storel_epi64((__m128i *)(sbase[1] + j), _mm_srli_si128(z0, 8));
_mm_storel_epi64((__m128i *)(sbase[2] + j), z1);
_mm_storel_epi64((__m128i *)(sbase[3] + j), _mm_srli_si128(z1, 8));
_mm_storel_epi64((__m128i *)(sbase[4] + j), z2);
_mm_storel_epi64((__m128i *)(sbase[5] + j), _mm_srli_si128(z2, 8));
_mm_storel_epi64((__m128i *)(sbase[6] + j), z3);
_mm_storel_epi64((__m128i *)(sbase[7] + j), _mm_srli_si128(z3, 8));
}
}
for (; j < N; j++) {
const u32 *row = s_pm + (size_t)od[j] * STRIDE;
u32 *dp = dst + (size_t)j * KSx;
if (!skiprows) _mm256_stream_si256((__m256i *)dp, _mm256_loadu_si256((const __m256i *)row));
for (int e = 0; e < k; e++) sbase[e][j] = (u8)((row[e] >> g_sigsh) ^ 0x80u);
}
} else
for (u32 j = 0; j < N; j++) {
#if MF_PFB > 0
if (j + MF_PFB4 < N) _mm_prefetch((const char *)(s_pm + (size_t)od[j + MF_PFB4] * STRIDE), _MM_HINT_T0);
#endif
const u32 *row = s_pm + (size_t)od[j] * STRIDE;
u32 *dp = dst + (size_t)j * KSx;
_mm256_stream_si256((__m256i *)dp, _mm256_loadu_si256((const __m256i *)row));
}
} else
for (u32 j = 0; j < N; j++) {
#if MF_PFB > 0
if (j + MF_PFB4 < N) _mm_prefetch((const char *)(s_pm + (size_t)od[j + MF_PFB4] * STRIDE), _MM_HINT_T0);
#endif
const u32 *row = s_pm + (size_t)od[j] * STRIDE;
u32 *dp = dst + (size_t)j * KSx;
for (u32 e = 0; e < KSx; e++) dp[e] = (e < (u32)k) ? row[e] : 0u;
if (s_sig) {
u8 *sb2 = s_sig + (size_t)d * k * (g_spl);
for (int e = 0; e < k; e++) sb2[(size_t)e * (g_spl) + j] = (u8)((row[e] >> g_sigsh) ^ 0x80u);
}
}
if (s_sig) g_sig_merged = 1;
}
_mm_sfence();
}
}
}
if (s_sig && !g_sig_merged) {
for (int d = 0; d < k; d++) {
const u32 *od = s_ord[d];
u8 *base = s_sig + (size_t)d * k * (g_spl);
for (u32 j = 0; j < N; j++) {
#if MF_PFB > 0
if (j + MF_PFB4 < N) _mm_prefetch((const char *)(s_pm + (size_t)od[j + MF_PFB4] * STRIDE), _MM_HINT_T0);
#endif
const u32 *row = s_pm + (size_t)od[j] * STRIDE;
for (int e = 0; e < k; e++) base[(size_t)e * (g_spl) + j] = (u8)((row[e] >> g_sigsh) ^ 0x80u);
}
}
}
u64 poolwords = (u64)K1 * (Q + 1) * W;
#if MF_PLEN
if (g_plen_on) {
u64 best = 0;
for (int dsx = 0; dsx < k; dsx++) {
u64 tot = 0;
for (int e = 0; e < K1; e++) {
int d = (e < dsx) ? e : e + 1;
const u32 *mr = s_maxr + ((size_t)dsx * MAXK + d) * MAXQ;
for (u32 b = 0; b <= Q; b++) {
u32 RR = mr[b];
u32 len = ((RR >> 6) + 8u) & ~7u;
if (len > W) len = W;
tot += len;
}
}
if (tot > best) best = tot;
}
if (best && best < poolwords) poolwords = best;
}
#endif
size_t need = (size_t)poolwords * sizeof(u64);
static u64 *pool = 0; static size_t cap2 = 0;
if (need > cap2) { pool = (u64 *)pool_alloc(need + 4096); cap2 = need; }
s_bs = pool;
for (int ds = 0; ds < k; ds++) {
u32 q0 = gstart[ds], q1 = gstart[ds + 1];
if (q0 >= q1) continue;
#if MF_PLEN
if (g_plen_on) {
u64 tot = 0;
for (int e = 0; e < K1; e++) {
int d = (e < ds) ? e : e + 1;
const u32 *mr = s_maxr + ((size_t)ds * MAXK + d) * MAXQ;
u32 *po = s_pofs + (size_t)e * MAXQ;
u32 *pl = s_plen + (size_t)e * MAXQ;
for (u32 b = 0; b <= Q; b++) {
u32 RR = mr[b];
u32 len = ((RR >> 6) + 8u) & ~7u;
if (len > Wpool) len = Wpool;
po[b] = (u32)tot; pl[b] = len; tot += len;
}
}
if (tot > (u64)K1 * (Q + 1) * W) { g_plen_on = 0; }
}
#endif
{
const u32 *od = s_ord[ds];
for (u32 j = 0; j < N; j++) {
if (j + 32 < N) _mm_prefetch((const char *)(s_nid + od[j + 32]), _MM_HINT_T0);
s_nid[od[j]] = j; }
}
for (int e = 0; e < K1; e++) {
int d = (e < ds) ? e : e + 1;
const unsigned *xd = x[d];
const u32 *od = s_ord[d];
u64 *base = g_plen_on ? s_bs : (s_bs + (size_t)e * (Q + 1) * Wpool);
u64 *cur = s_acc;
for (u32 w = 0; w < Wpool; w++) cur[w] = 0;
if (g_plen_on) {
u64 *d0 = s_bs + s_pofs[(size_t)e * MAXQ];
u32 l0 = s_plen[(size_t)e * MAXQ];
for (u32 w = 0; w < l0; w++) d0[w] = 0;
}
u32 ptr = 0;
#if MF_BUILD_NOPOOL
while (ptr < N) ptr++;
#else
for (u32 b = 1; b <= Q; b++) {
u32 pend = (b < Q) ? FPOS(d, b) : (u32)N;
while (ptr < pend) {
if (ptr + 24 < pend) _mm_prefetch((const char *)(s_nid + od[ptr + 24]), _MM_HINT_T0);
u32 q = s_nid[od[ptr]]; cur[q >> 6] |= 1ull << (q & 63); ptr++; }
u64 *dst = g_plen_on ? (base + s_pofs[(size_t)e * MAXQ + b])
: (base + (size_t)b * Wpool);
u32 wlen = g_plen_on ? s_plen[(size_t)e * MAXQ + b] : Wpool;
#if MF_NT
{
u32 w = 0;
for (; w + 4 <= wlen; w += 4)
_mm256_stream_si256((__m256i *)(dst + w), _mm256_load_si256((const __m256i *)(cur + w)));
for (; w < wlen; w++) dst[w] = cur[w];
}
#else
{ u32 w = 0;
for (; w + 4 <= wlen; w += 4) _mm256_storeu_si256((__m256i *)(dst + w), LDU256((const __m256i *)(cur + w)));
for (; w < wlen; w++) dst[w] = cur[w]; }
#endif
}
_mm_sfence();
#endif
}
switch (k) {
case 4: query_group<4>(N, out, ds, q0, q1, Q, Wpool); break;
case 5: query_group<5>(N, out, ds, q0, q1, Q, Wpool); break;
case 6: query_group<6>(N, out, ds, q0, q1, Q, Wpool); break;
case 7: query_group<7>(N, out, ds, q0, q1, Q, Wpool); break;
case 8: query_group<8>(N, out, ds, q0, q1, Q, Wpool); break;
case 9: query_group<9>(N, out, ds, q0, q1, Q, Wpool); break;
default: query_group<10>(N, out, ds, q0, q1, Q, Wpool); break;
}
}
}
void count_4d(int n, const unsigned *x[4], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 4); }
void count_5d(int n, const unsigned *x[5], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 5); }
void count_6d(int n, const unsigned *x[6], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 6); }
void count_7d(int n, const unsigned *x[7], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 7); }
void count_8d(int n, const unsigned *x[8], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 8); }
void count_9d(int n, const unsigned *x[9], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 9); }
void count_10d(int n, const unsigned *x[10], unsigned *out) { solve_mf((u32)n, (const unsigned **)x, out, 10); }
| Compilation | N/A | N/A | Compile OK | Score: N/A | 显示更多 |
| Testcase #1 | 76.258 ms | 33 MB + 976 KB | Accepted | Score: 100 | 显示更多 |