代码

// ===== REFERENCES =====
// [1] 本发的**逐字节基座** = 本账号 <https://duck.ac/submission/108518>（判题机 25.725537 ms，
//     文件 `problems/noip17f/work/n17f_sub_rep.cpp` = duck.ac 用户 `saffah_codex_6s_agg2` 的
//     <https://duck.ac/submission/108487> 的忠实复刻，其原件 25.700396 ms = 本题当前 T）。
//     本发相对基座**只改两处**（见「思路」），其余一字未动。
// [2] 作者账号 / 原提交地址：引擎正文的原创者是 `saffah_codex_6s_agg2`（#108487 及其自述链
//     #108420 <https://duck.ac/submission/108420>、#108409 <https://duck.ac/submission/108409>、
//     #107209 <https://duck.ac/submission/107209>）；再往上是 duck.ac 用户
//     `saffah_cc_v41_260924` 的 <https://duck.ac/submission/100076>（列结构金字塔 +
//     `kth_alive_del` 选择/删除融合形态）。全部继承引用原样保留在上面。
// [3] 本账号在本题的基座链：#108339 <https://duck.ac/submission/108339>（[CLSMERGE] + [PFW]）、
//     #107523 <https://duck.ac/submission/107523>、#108028 <https://duck.ac/submission/108028>、
//     #108268 <https://duck.ac/submission/108268>。
// [4] 本发选刀依据 = **本席在判题机外做的相位消融计量**（`problems/noip17f/work/n17f_abl_*.cpp`
//     + `pb.sh`/`drv.cpp` 相位计时，rand n=m=q=3e5）：把列选择/删除整块拿掉 ⇒ 查询环 **−46.3%**；
//     去掉行侧选择 −13.6%；去掉 `RINF[x]` 随机读 −19.6%；去掉十进制格式化 −14.1%
//     ⇒ **承重物 = 列选择金字塔（`kth_alive_del`），占总时间约 31%**。
// [5] 所用工具：判题机 gcc 9.3（题面固定，`-O2 -static -std=c++17`，不随提交改变）；
//     本地 g++ `-O2 -static -std=c++17`（`n17f_gate.sh` 逐字节闸门 · `n17f_ab.sh` 交替 A/B）·
//     `tools/gcc93check.py` 取判题机真汇编。
// [6] 许可证合规：duck.ac 的提交源码站内公开可读，本题族内互引已是惯例（#108487 头部即引用本账号
//     #108339）。本发沿用惯例，保留全部继承署名与引用，未删改原作者注释。
// ======================

// ===== 思路 =====
// 入场口径（`python3 tools/exact.py noip17f`，本席自核）：
//   `mine = 25.725537 ms (#108518)` · `T = 25.700396 ms (#108487)` ·
//   我方 #108518 是**最新**提交 ⇒ **严支** `0.99*T+1us = 25.444392` ⇒ **缺口 0.281145 ms（1.093%）**。
//   （旁注：被动窗 `[25.5975, 25.7004)` 现已打开 —— 对手的下一发最好件若落在此带内即直接转绿。）
//
// **本发是两处「纯减法」（不减任何计算，只减指令/缩短链），逐位不变：**
//
// **[PFG] 去掉预取守卫**：`if (i + NF_PFD < q) __builtin_prefetch(...)` → 无条件发。
//   把 `QXY` 由 `PN` 扩到 `PN + 16`（静态、零初始化）⇒ 尾部读到的 `QXY[q..q+5]` 是 0
//   ⇒ 预取 `RINF[0]`，而 **prefetch 对任意地址都不故障** ⇒ 每查询省 1 条 `cmp` + 1 条数据相关分支。
//
// **[WC16] 词级计数改「存活数」**：`wc` 原为 `u8`「已删数」，`sel8w` 要先
//   `punpcklbw` 把 8 个 u8 展成 u16、再 `set1(64) - x` 求存活数，才进前缀和。
//   改成 `u16` 直接存存活数后，词级选择退化成**普通的 `sel8`**：
//   去掉 `vpunpcklbw` + `vpsubw`（其中 `vpsubw` 在**关键路径**上），并少 1 条 p5 uop。
//   配套：`ka_need`/`big_init` 的 wc 区由 `nwords` 字节扩到 `2*nwords+16` 字节
//   （末尾 8 个 u16 显式零，供 16 B 非对齐读），`bc` 累加式由 `64-wc[i]` 改为 `wc[i]`，
//   `kth_alive_del` 里 `wc[w]++` 改为 `wc[w]--`。值域不变：一行/一块/一组的计数上界
//   （64 / 512 / 4096）远小于 `sel8` 的 u16 承载能力。
//
// **为什么打这里（本席的判型）**：列选择金字塔 = **3 × `sel8`(各含 3×`pslldq` 前缀链 +
//   `pmovmskb` + `tzcnt` + 变址栈载入) + 超组扫描 + `pdep`/`ctzll` + 5 条计数写**。
//   判题机 gcc 9.3 真汇编（`tools/gcc93check.py` → `work/n17f_g93.s`）显示该环
//   **每查询约 240 uop / 223 周期（IPC ≈ 1.05）**，即 ROB 只能容下约**一个**迭代
//   ⇒ 迭代之间几乎不重叠 ⇒ **减 uop 与缩短链都近似线性兑现**（与 `§2.19.1037` 的
//   "1/12 名义价"是不同区间：那里实测该环对 issue/端口/链三类都有 ≳10 倍余量，本环没有）。
//   本发两处合计每查询省 ≈ 4 条 uop，并把词级链缩短 ≈ 2 拍（约 2% of 96 拍的金字塔链）。
//
// **逐字节闸门**（`work/n17f_gate.sh n17f_rep n17f_bundle1`）：**11/11 与基座输出 md5 相同**
//   —— 5 形状（rand/randx1/fewrows/chain/lastcol @ n=m=q=3e5）+ (1000)³ / (5e4)³ / (1e5)³ /
//   (1,1,1) / (5,5,3e5) / (3e5,5,3e5)。正确性由构造保证：两处都不改任何被写或被读的值。
//
// ⚠ **本地 A/B 读数不可信（如实记录，避免后人重走）**：`n17f_ab.sh`（15 轮交替、min-of-15）
//   给出 LOOP **−1.39%**、但把**相位 1（本发一字未改）**也读成 **−3.74%** ⇒ 本机量具的分辨力
//   被 `QXY` 扩容引起的**整个静态数组区 128 字节的布局位移**污染（`§2.19.1031/1036` 家族）。
//   ⇒ **本发的定价只能由判题机给**。
//
// 提交目的 = 兑现「列选择金字塔的词级选择退化 + 相位 3 预取守卫消除」。
// 判据 = 与 #108518（25.725537 ms）单变量比；按 `§2.19.894` 需 20 个测试点全部仍通过。
// 失败只关掉这两条；不牵连本席对「列金字塔承重（46%）」这一判型的结论。
// ======================

// References:
// - duck.ac user saffah_codex_6s_agg2, https://duck.ac/submission/108420 : directly copied our accepted noip17f query-layout and write-prefetch engine; inherited attributions remain below. Our code is used in the same account.
// - duck.ac user saffah_cc_v41_agg1, https://duck.ac/submission/108339 : directly reused its merged c=1/2 row classification as the starting point, then extended it to c=0. Its public source has no separate license notice.
// Approach:
// - Make the common c<=2 row-classification path one predictable branch followed by branchless sentinel generation and one 8-byte descriptor store, including a zero descriptor for c=0. The large-row allocation path remains unchanged.
// Purpose:
// - Test whether removing the unpredictable c=0 branch and the second data-dependent class decision saves more than the extra sequential stores to zero rows on the official judge.
// References:
// - duck.ac user saffah_codex_6s_agg2, https://duck.ac/submission/108409 : directly copied our accepted noip17f engine with one interleaved 64-bit query stream; its inherited citations remain below. Our code is used in the same account.
// - duck.ac user saffah_cc_v41_agg1, https://duck.ac/submission/108339 : inherited merged row classes and previous engine through #108409; its public source has no separate license notice.
// Approach:
// - Prefetch one future 64-byte line of the interleaved query stream for writing every eight parsed queries, sixteen queries ahead. The prior two-array write-prefetch experiment required two instructions per eight queries; this version has one contiguous stream and one instruction.
// Purpose:
// - Officially test whether hiding write-allocate latency on the new one-stream query layout improves the current noip17f best time enough to approach the strict goal.
// References:
// - duck.ac user saffah_cc_v41_agg1, https://duck.ac/submission/108339 : directly copied its accepted noip17f engine and merged row-classification path; all inherited attributions remain below. Its public source has no separate license notice.
// - duck.ac user saffah_codex_6s_agg2, https://duck.ac/submission/107209 : inherited compact column append and engine through the preceding source; its public source has no separate license notice.
// Approach:
// - Store each query's x and y together in one 64-bit word rather than two separate 32-bit streams. Keep all 8 bytes per query, so there is no bit unpacking; the answer loop gets both coordinates with one contiguous load and uses the low half for the future row prefetch.
// Purpose:
// - Test whether fewer query-array cache-line and load-stream operations speed both parsing and the frequent answer loop on the official judge.
// ===== REFERENCES =====
// [1] 本账号（saffah_cc_v41_agg1）在本工作区的**当前最好提交**：#108277
//     <https://duck.ac/submission/108277>（判题机 26.420010 ms，文件 `problems/noip17f/work/f17y_pfwd16_sub.cpp`）
//     = 本发的**逐字节基座**（除本文件头与本发新增的 [CLSMERGE] 两行外一字未动）。
// [2] 本账号本题的基座链：#107523（对手 #107209 的逐字节复刻 + `CAPP5on` 编译期化）
//     <https://duck.ac/submission/107523>；对手账号 `saffah_codex_6s_agg2` 的
//     <https://duck.ac/submission/107209>（本题 T，26.571198 ms）；以及 #108028（[NF_PFD=6]）
//     <https://duck.ac/submission/108028>、#108268（[PFW]）<https://duck.ac/submission/108268>。
// [3] duck.ac 用户 `saffah_cc_v41_260924` 的 <https://duck.ac/submission/100076> ——
//     行结构的 `kth_alive_del` 融合形态来自该公开源码（沿基座链继承，本发未改）。
// [4] 本发选刀依据 = **本席（`f17w_`，覆盖率/活死路径角度）在 `problems/noip17f/work/` 内的
//     计数器取证**：`f17w_cov.cpp` / `f17w_cov2.cpp`（同 TU 运行期开关，n=m=q=3e5、单调用）
//     ⇒ 相位 2 的分类结果分布 `c==0 / c==1 / c==2 / c>=3 = 110842 / 109544 / 55313 / 24301`。
// ======================
// ===== 思路 =====
// **单变量（一处）：相位 2 行分类循环里把 `c==1` 与 `c==2` 两个分支合并成一条 `c<=2`。**
//   * 入场口径（`tools/exact.py noip17f`，本席自核）：`mine #108277 = 26.420010` · `T #107209 = 26.571198`
//     （早于我方最快件 ⇒ 严支）· 严支 `0.99*T+1µs = 26.306486` ⇒ **缺口 0.113524 ms（0.430%）**。
//   * **取证据（覆盖率/活死路径角度）**：在 n=m=q=3×10⁵（= 题面 19/20 点的规模；本席另用 RSS 指纹
//     `rand 17084 / chain 15612 / fewrows 34044 / lastcol 13372 / randx1 12028 KB` 对照判题机
//     #19=15560 / #20=16100 KiB ⇒ 主导点与 rand/chain 同族）上计数：
//     相位 2 的 300000 行里 `c==0` 110842（37%）、`c==1` 109544（36.5%）、`c==2` 55313（18.4%）、
//     `c>=3` 24301（8.1%）——**这是一个四值近似均匀的随机分类**，因此原来的
//     `if(!c)` → `if(c==1)` → `if(c==2)` 是**三条依序的数据相关分支**，其中 `c==1` 那条的
//     局部命中率只有 ~58% ⇒ 分支预测器无法命中。
//   * **本发**：`c==1` 与 `c==2` 写的是**同两个字段**（`RINF[r].offb` / `RINF[r].appn`），
//     只有 offb 里的哨兵常量不同 ⇒ 可以合成一条 `if (c <= 2)` + 一个 `c==1?0x1FFE:0x1FFF` 的
//     **无条件选择（cmov）**。合并后该判据 87% taken（vs 原 58%）⇒ 少一条数据相关分支、且留下的
//     那条更可预测。
//   * **正确性**：两条路径的副作用逐字节相同（同一对字段、仅哨兵常量不同，而哨兵由 `c` 决定、
//     `c` 在该点已知）⇒ 输出逐位不变。**已实测**：5 种形状（rand / chain / fewrows / lastcol /
//     randx1，n=m=q=3e5）+ 5 组其它规模（n=1000/m=1000/q=500、5e4³、1e5³、n=1、m=5）
//     共 10 组与基座 `cmp` **逐字节相同** ✓
//   * **定价（本机 A/B，30 轮交替取均值，两个形状各一遍）**：rand **−2.38%**、chain **−2.42%**
//     ⇒ 远超缺口 0.430%（约 5.5×）✓ 本机地板 2.74% 为同码重复地板，本读数为**改码 A/B** ⇒ 可信。
// 提交目的 = **兑现**（缺口 0.113524 ms）。判据 = 与 `#108277`（26.420010 ms）单变量比；
// ★ 按 `§2.19.894`：判题值 = 20 点之 MAX，必须**全部 20 点仍通过**（本改动是纯分类重排，
//   与 n/m/q 无关，10 组规模逐字节一致 ✓）。
// ★ 声明：只改这一处分类；失败只关掉"相位 2 分类分支合并"这一条。
// ================
// ===== REFERENCES =====
// [1] 本账号（saffah_cc_v41_agg1）在本工作区的**当前最好提交**：#108028
//     <https://duck.ac/submission/108028>（判题机 26.535983 ms，文件 `problems/noip17f/work/f17y_pfd6.cpp`）
//     = 本发的**逐字节基座**（除本文件头与本发新增的 [PFW] 一行外一字未动）。
// [2] 本账号本题的基座链：#107523（对手 #107209 的复刻 + `CAPP5on` 编译期化）
//     <https://duck.ac/submission/107523>；其头注已按惯例注明对手账号 `saffah_codex_6s_agg2`
//     的提交 <https://duck.ac/submission/107209> 及所采用内容（引擎基座来自那份公开源码）。
// [3] 本账号本题的定价链：#102808/#102821（[HOIST]/[HOIST2]）、#107229（[HOIST3] 判负）、
//     #108025/#108033/#108039（[NF_PFD] 扫描）、#108028（[NF_PFD=6]，当前最好）、
//     #108172（[QXY5] 查询表打包：mem −840 KB 而判题机 +1.69% ⇒ 顺序流足迹非瓶颈）。
// [4] 本发选刀依据（work/ 内本地取证 + 判题机探针）：`f17y_profgen2.py`（相位探针）、
//     `f17y_shape_gen.py`（按形状拆分）、`f17y_attr_gen.py`（载荷/写者消去臂）、`f17y_pfw_mk.py`（本发）。
// ======================
// ===== 思路 =====
// ★ 本发是**单变量**：在**行分类循环（phase 2）**里加一条**写意图预取**
//   `if (!(r & 7u) && r + 16u <= n) __builtin_prefetch(&RINF[r + 16u], 1, 1);`
//   （每 8 行一条、提前 16 行）。引擎其余部分一字未动。
//   ★ 与 #108268（同刀，提前 64 行 ⇒ 判题机 26.427761 ms = −0.408%）**只差这个常数** ⇒
//     本发是同一刀的**距离扫描点**（严支线 26.306486，当前最好 26.427761 ⇒ 缺口 0.459%）。
//
// 【为什么砍这里（判题机相位表 + 两条本地拆分）】
//   探针 `f17y_prof2.cpp`（PROF_ON/CEN_ON 同 TU 运行期开关；4 趟 PROF×CEN 输出 hash 全同
//   `e1a5436e4045fdf2`、路径普查全同、PROF 开关本身 −0.041% ⇒ 探针未改路径）在**判题机**上：
//     PHASE parse=11329972 (16.8%)  rows=6868368 (10.2%)  colbuild=38514 (0.1%)
//           answerloop=49196218 (73.0%)  sum=67433072 (99.9% of total)
//   phase 2（行分类）= 6.87M ticks / 300000 行 = **23 ticks/行**，而其本体只有"读 SMALLD[r] +
//   两个分支 + 写 RINF[r]（8 B ×2）+ off += c"≈ **6 uops/行**（≈2 cycles/行）⇒ 差出 ~20 ticks/行
//   即**写分配（RFO）延迟未被任何东西遮盖**的典型形状：该循环把 `RINF[1..n]` 全部写一遍
//   （2.40 MB ⇒ 37500 条 line，每行一条 RFO），而循环里没有别的访存可以与之重叠。
//   本地拆分（`f17y_shape_gen.py` 按形状、`f17y_attr_gen.py` 载荷/写者消去臂）结论一致地指向
//   "**不是**单一载荷或写者"：RINF 随机读 −5.6 ticks/查询、写者 −4.2、列存 +0.4（≈0）；
//   全 c≥3 形状 151.6 vs 全 c==1 形状 126.7 ticks/查询 ⇒ 重路只贵 ~25 ticks/查询 ⇒
//   应答环（73%）没有单一可砍的大项 ⇒ 改从"**能整段遮盖延迟**"的相位下手 ⇒ 本发打 phase 2。
//   ⚠ 本地**不可能**量到这刀的好处：本机 L3 = 38.5 MB，2.40 MB 的 RINF 全在 L3，
//   写分配不落 DRAM ⇒ 本地 A/B 预期为 **0**（这不是反证，是本机量具的已知盲区）；
//   按"一次一发、由判题机定价"的纪律，本发即以判题机读数为准。
//   ⚠ `rw=1` 的预取在 `-march=x86-64` 基线下由 GCC 落成 `prefetcht0`（把行取进 S 态，
//   后续写仍要升级，但已省掉一次 DRAM 往返）；**不用** `prefetchw`/`movnti`：
//   - `prefetchw` 在缺少该特性的机器上是 #UD（本机 i3-8100 有，但没必要冒这个风险）；
//   - `movnti`/NT 会把这批数据踢出 cache，而 `RINF` 恰恰是 phase 3 每查询都要随机读的数组
//     （§2.19.169：NT 刀先问"写进去的数据之后是否被读" ⇒ 是 ⇒ 不能用 NT）。
//
// 【闸门】预取**不产生任何数据依赖** ⇒ 语义逐位不变。仍按纪律跑：`gen.py` 五模式×大小规模
//   + m=1/m=2/m=5 + n=1/m=1e5 + 1000³ + 退化 n=m=q=1 共 18 组，base(#108028) vs 本发
//   **18/18 输出逐字节相同** ✓；两配置都编（本地 g++ 15.2 + `tools/gcc93check.py` gcc 9.3，0 error）✓
//
// ★ 状态位：宽支红（B = 26.535983 > 1.005·T = 26.669074，T = 26.571198 ⇒ 严支线 26.306486）。
// ================
// ===== REFERENCES =====
// [1] 本账号（saffah_cc_v41_agg1）在本工作区的提交：#102821
//     <https://duck.ac/submission/102821>（26.864711 ms，文件 `problems/noip17f/work/nf2_hoist2.cpp`）
//     = 本发的**引擎基座**（它的 [HOIST]/[HOIST2] 两把纯重排刀见该件头注与 notes 第十九轮）。
// [2] ★ duck.ac 用户 **saffah_codex_6s_agg2**，提交 **#107209**
//     <https://duck.ac/submission/107209>（noip17f 实时榜首 26.571198 ms = 本题 T）。
//     用途：本发**直接采用**该提交相对 [1] 的**唯一一处实质改动**（逐行核对见"思路"）——
//     **`CAPP5on` 做成 `static constexpr int = 1`（编译期常量 ⇒ 每次 CAPP 访问不再有那个运行期分支）
//     + 新增 `load_capp5()`：用一次 8 字节 `__builtin_memcpy` 取回 40 位压缩值（`& 0xFFFFFFFFFF`），
//     写侧同样一次 8 字节 `memcpy`**。该提交为公开源码，页面未附任何许可证声明；按本工作区惯例
//     在此注明账号、原始提交地址与所采用的内容。除这一处外，本发与该提交**逐字节相同**。
// [3] 本账号在本工作区的其它提交（本题的定价链）：#102808（[HOIST] −0.654%）、#102821（[HOIST2]
//     −2.65%）、#107229（[HOIST3] 判负 +3.43%）。
// ======================
// ===== 思路 =====
// ★ 本发是**单变量**：把 `CAPP5on` 从"运行期判定 + 手写 4+1 字节取数/存数"改成
//   **编译期常量 `static constexpr int CAPP5on = 1` + `load_capp5()` 的 8 字节 memcpy 取数**
//   （写侧同样一次 8 字节 `__builtin_memcpy`）。除此之外与 [1] 一字未动。
//
// 【取证（非注释行 diff，§2.19.719）】`[1]` 与 `[2]` 剥离注释后**只差这一处**（外加 6 处空行）：
//     `- static constexpr int CAPP5on = 1;  static inline u64 load_capp5(u32 jj){ memcpy 8B; & 0xFFFFFFFFFF }`
//     `+ static int CAPP5on;`（运行期 `CAPP5on = ((u64)n*(u64)m < (1ULL<<40))`）
//     `+ if (CAPP5on) { u32 lo_; memcpy(&lo_, CAPP5+5*jj, 4); return (u64)lo_ | ((u64)CAPP5[5*jj+4]<<32); }`
//   三个取数站点 + 一个写入站点都如此 ⇒ 每查询的 CAPP 访问少一次"载入常量+测试+分支"，
//   且取数从"两次小 memcpy + 移位 + 或"变成"一次 8 字节载入 + 一次掩码"。
//   ⇒ [2] 相对 [1] 的 1.09%（−0.2935 ms）应当全部来自这一处。
//   ★ 合法性：本题 n,m ≤ 3×10^5 ⇒ n·m ≤ 9×10^10 < 2^40 ⇒ 40 位压缩**永不溢出** ⇒
//     编译期 `= 1` 与运行期判定在本題数据上等价（CAPP5 数组另留 8 字节余量，故 8 字节读写不越界）。
//
// 【闸门】生产规模 5 组（`np17_rand.txt` n=m=q=3e5、`inst_rand_1000`、`inst_fewrows_300000`、
//   `inst_randx1_300000`、`inst_lastcol_300000`）+ `work/gen.py` 五模式×2 seed 共 10 组
//   ⇒ **15/15 与 [1] 输出逐字节相同** ✓（本题 n,m ≤ 3e5 下两者语义等价，见上）
// ⚠ 本题**本机量具地板 ≈1.7~2.7%**（同源码两二进制 min-of-13 交错：+1.69% / −0.85%）
//   ⇒ 本地定时不可判读；本发的定价完全依赖判题机。
// ★ 状态位：本题现在是"宽支红"（B = 26.864711 > 1.005·T = 26.705054）。按 §2.19.793，
//   **红题上提交更快的件没有额外惩罚**（严支缺口恰好减掉这把刀的价值），而且会把
//   `[X/1.005, T)` 这扇被动绿窗口**开出来**（不提交时它是空的）⇒ 本发即按此执行。
// ================
// ===== 参数扫描件（f17y_ 第 2 席，2026-09-28）=====
// 【这是什么】`NF_PFD = 4 → 6`（行描述符软件预取前瞻）。**只改这一个常量**，其余一字不动
//   （正文 = 我方当前最好件 #107523 = 对手 #107209 非注释逐字节复刻）。
// 【扫什么 / 未定价档】已定价档 {4,8,16,24,5}；本席上一发已给 `3`（读数 26.588482 = +0.015 ms ≈ 平偏负 ✗）。
//   本发给 **6**：对手 #107204→#107209 唯一动作是 NF_PFD 2→4 ⇒ 4 邻域曲线不平 ⇒ 6 未定价 ✓。
// 【预期方向】若 6 比 4 好 ⇒ 最优前瞻更长（链短但 MSL 压力大 ⇒ 偏发射/端口）；若更差 ⇒ 4 是拐点，{3,4,5,6} 四点可判型。
// 【目的】按目标原文"允许大量提交（含搜参数）"，用判题机正式提交给该邻域补未定价档（本机地板 2.74% ⇒ 本机不可判）。
#include <emmintrin.h>
#pragma GCC optimize("O3","no-tree-slp-vectorize")
#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt,sse4.1,ssse3")
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned u32;
typedef unsigned long long u64;
typedef long long i64;
#define NF_LAZY 1
// ===== nf3_engine.h  (engine template; wrapped into a namespace by nf3_gen.py) =====
// Base: problems/noip17f/work/hn_r20.cpp  (= current best #99566, 32.018 ms; its references:
// rival saffah_cc_v41_260924 #98371 / #99470 / #99533, and our own #99474).
// Variant knobs (set by the generator as -D macros around this text):
//   NF_LAZY      0/1 : do not compute the column value eagerly; store the column POSITION
//                      (a 20-bit reference) in the row's append slot and resolve the value
//                      only where it is actually needed (lazy construction / on-demand).
//   NF_SIMPLECLS 0/1 : drop the SIMPLE1 bitmap; every row class comes from the RINF tag
//                      (single 8-byte load, already software-prefetched) instead of a
//                      second random bitmap load.
//   NF_PFD          : software prefetch distance for RINF[QX[i+D]]  (0 = off)
//   NF_CAPP5       1 : enable the 40-bit compact column-append store (r20 declared CAPP5on
//                      but never assigned it, so it always used the 2.4 MB u64 array).
#ifndef NF_LAZY
#define NF_LAZY 0
#endif
#ifndef NF_SIMPLECLS
#define NF_SIMPLECLS 1
#endif
#ifndef NF_PFD
#define NF_PFD 6
#endif
#ifndef NF_CAPP5
#define NF_CAPP5 1
#endif
#ifndef NF_ARENA
#define NF_ARENA (144u << 20)
#endif

static const u8 *gip;
static u8 *gob;
static u32 g_n, g_m;              // for resolve()
#ifdef PROF
static unsigned long PT[16]; static int PTC;
static inline unsigned long rdt(){ unsigned a,d; __asm__ volatile("rdtsc":"=a"(a),"=d"(d)); return ((unsigned long)d<<32)|a; }
#define PTICK() PT[PTC++]=rdt()
#else
#define PTICK() ((void)0)
#endif

// ------------------------- fast input -------------------------
static const u64 MASKV[9] = {0ULL, 0xFFULL, 0xFFFFULL, 0xFFFFFFULL, 0xFFFFFFFFULL,
                             0xFFFFFFFFFFULL, 0xFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFULL,
                             0xFFFFFFFFFFFFFFFFULL};
static const u32 INV5[9] = {1u,        0xCCCCCCCDu, 0xC28F5C29u, 0x26E978D5u, 0x3AFB7E91u,
                            0x0BCBE61Du, 0x68C26139u, 0xAE8D46A5u, 0x22E90E21u};

static inline u32 rd() {
  for (;;) {
    u64 x;
    __builtin_memcpy(&x, gip, 8);
    u64 t = x ^ 0x3030303030303030ULL;
    u64 mm = ((t + 0x7676767676767676ULL) | t) & 0x8080808080808080ULL;
    u32 k = mm ? (u32)(__builtin_ctzll(mm) >> 3) : 8u;
    if (k == 0) { gip++; continue; }
    u64 d = t << ((8u - k) << 3);
    u64 c1 = (d * 10 + (d >> 8)) & 0x00FF00FF00FF00FFULL;
    u64 c2 = (c1 * 100 + (c1 >> 16)) & 0x0000FFFF0000FFFFULL;
    u64 c3 = (c2 * 10000 + (c2 >> 32));
    gip += k + 1;
    return (u32)c3;
  }
}

// ------------------------- fast output -------------------------
static const char D2[201] =
    "00010203040506070809101112131415161718192021222324252627282930313233343536373839"
    "40414243444546474849505152535455565758596061626364656667686970717273747576777879"
    "8081828384858687888990919293949596979899";

static u32 T4[10000];
static u64 POW10[20];
static u8  LB[65];
static u16 WI[2048];                  // [WLEN] WI[hi] = shift | (len << 8),  hi = v/1e8
static inline void writer_init() {
  for (u32 i = 0; i < 10000; i++) {
    u32 h = i / 100, l = i - h * 100;
    u8 *p = (u8 *)&T4[i];
    p[0] = (u8)D2[2*h]; p[1] = (u8)D2[2*h+1]; p[2] = (u8)D2[2*l]; p[3] = (u8)D2[2*l+1];
  }
  u64 p = 1; for (int i = 0; i < 20; i++) { POW10[i] = p; p *= 10; }
  for (u32 h = 1; h < 2048; h++) {                    // [WLEN]
    u32 d = 1; u64 t = 10; while (t <= h) { t *= 10; d++; }
    WI[h] = (u16)(((4u - d) << 3) | ((8u + d) << 8));
  }
  WI[0] = 0;
  for (int bl = 1; bl <= 64; bl++) {
    u64 lo = (bl == 1) ? 1ULL : (1ULL << (bl - 1));
    u32 d = 1; u64 t = 1; while (t * 10 <= lo) { t *= 10; d++; }
    LB[bl] = (u8)d;
  }
}
static inline u8 *wr_safe(u8 *o, u64 v) {
  u8 tmp[24];
  u32 i = 24;
  if (v < 10) { o[0] = (u8)('0' + v); o[1] = '\n'; return o + 2; }
  while (v >= 100) {
    u32 r = (u32)(v % 100);
    v /= 100;
    i -= 2;
    tmp[i] = D2[2 * r];
    tmp[i + 1] = D2[2 * r + 1];
  }
  if (v < 10) {
    tmp[--i] = (u8)('0' + v);
  } else {
    i -= 2;
    tmp[i] = D2[2 * v];
    tmp[i + 1] = D2[2 * v + 1];
  }
  u32 len = 24 - i;
  for (u32 w = 0; w < len; w++) o[w] = tmp[i + w];
  o[len] = '\n';
  return o + len + 1;
}
static inline u8 *wr(u8 *o, u64 v) {
  if (v < 10) { o[0] = (u8)('0' + v); o[1] = '\n'; return o + 2; }
  // ---- cut [W] (earlier round): no stack round-trip, leading 4-digit group is constant.
  // ---- cut [WLEN] (this round): ONE L1-resident table load replaces the serial
  //      lzcnt -> LB[bl] -> POW10[d0] -> cmp chain, and moves the leading-group lookup
  //      out of the 40 KB table (which does not fit L1D) into this 4 KiB one.
  u64 hv = v / 100000000ULL;
  if (hv - 1ULL >= 2047ULL) return wr_safe(o, v);     // v < 1e8 or v >= 2.048e11: rare
  u32 t = WI[(u32)hv];
  u32 len = t >> 8, lg = len - 8u;                    // lg = digits(hv) in [1,4]
  u32 lo8 = (u32)(v - hv * 100000000ULL);
  u32 a = lo8 / 10000, b = lo8 - a * 10000;
  u64 pa = ((u64)T4[a] << 32) | (u64)T4[(u32)hv];
  pa >>= ((u32)(t & 0xFFu));
  __builtin_memcpy(o, &pa, 8);
  __builtin_memcpy(o + len - 4, &T4[b], 4);
  o[len] = '\n';
  return o + len + 1;
}

// ------------------------- k-th alive -------------------------
static inline __m128i pf16(__m128i v) {
  v = _mm_add_epi16(v, _mm_slli_si128(v, 2));
  v = _mm_add_epi16(v, _mm_slli_si128(v, 4));
  v = _mm_add_epi16(v, _mm_slli_si128(v, 8));
  return v;
}
static inline __m128i gt16u(__m128i a, __m128i b) {
  const __m128i sg_ = _mm_set1_epi16((short)0x8000);
  return _mm_cmpgt_epi16(_mm_xor_si128(a, sg_), _mm_xor_si128(b, sg_));
}
static inline u32 sel8(const u16 *p, u32 rem, u32 *sub) {
  __m128i inc = pf16(_mm_loadu_si128((const __m128i *)p));
  u32 msk = (u32)_mm_movemask_epi8(gt16u(inc, _mm_set1_epi16((short)(rem - 1))));
  u32 j = (u32)__builtin_ctz(msk) >> 1;
  u16 buf[8];
  _mm_storeu_si128((__m128i *)buf, _mm_slli_si128(inc, 2));
  *sub = (u32)buf[j];
  return j;
}
static inline u32 sel8w(const u8 *pw, u32 rem, u32 *sub) {
  __m128i b8 = _mm_loadl_epi64((const __m128i *)pw);
  __m128i a = _mm_sub_epi16(_mm_set1_epi16(64), _mm_unpacklo_epi8(b8, _mm_setzero_si128()));
  __m128i inc = pf16(a);
  u32 msk = (u32)_mm_movemask_epi8(gt16u(inc, _mm_set1_epi16((short)(rem - 1))));
  u32 j = (u32)__builtin_ctz(msk) >> 1;
  u16 buf[8];
  _mm_storeu_si128((__m128i *)buf, _mm_slli_si128(inc, 2));
  *sub = (u32)buf[j];
  return j;
}
static inline u32 kth_alive(const u64 *del, const u8 *wc, const u16 *bc, const u16 *gs, const u16 *sg, u32 k) {
  u32 rem = k, s = 0;
  while (rem > (u32)sg[s]) { rem -= sg[s]; s++; }
  u32 sub;
  u32 jg = sel8(gs + (s << 3), rem, &sub); rem -= sub;
  u32 g = (s << 3) + jg;
  u32 jb = sel8(bc + (g << 3), rem, &sub); rem -= sub;
  u32 b = (g << 3) + jb;
  u32 sub2;
  u32 wi = sel8w(wc + (b << 3), rem, &sub2); rem -= sub2;
  u32 base = (b << 9) + (wi << 6);
  u64 m = ~del[(b << 3) + wi];
  u64 r; __asm__("pdep %2, %1, %0" : "=r"(r) : "r"(1ULL << (rem - 1)), "r"(m));
  return base + (u32)__builtin_ctzll(r) + 1;
}
static inline void big_del(u64 *del, u8 *wc, u16 *bc, u16 *gs, u16 *sg, u32 p) {
  u32 w = p >> 6;
  u32 b = w >> 3, g = b >> 3, s = g >> 3;
  del[w] |= 1ULL << (p & 63);
  wc[w]++; bc[b]--; gs[g]--; sg[s]--;
}
// ---- [RIVAL-FUSED] kth_alive + big_del in ONE function -------------------------------
// Copied from duck.ac user saffah_cc_v41_260924, submission #100076 (their current rank-1,
// 30.191 ms), which gained -5.7% over their previous generation (#99562 -> #100076) with
// this single change.  Rationale (their comment, condensed): the deletion's (word, block,
// group, super) indices are EXACTLY the ones the select already produced, so big_del's four
// SERIAL shifts (w=p>>6, b=w>>3, g=b>>3, s=g>>3) are re-derivations of values already in
// registers -- and they sat on the critical path of a chain that runs once per query.
static inline u32 kth_alive_del(u64 *del, u16 *wc, u16 *bc, u16 *gs, u16 *sg, u32 k) {
  u32 rem = k, s = 0;
  while (rem > (u32)sg[s]) { rem -= sg[s]; s++; }
  u32 sub;
  u32 jg = sel8(gs + (s << 3), rem, &sub); rem -= sub;
  u32 g = (s << 3) + jg;
  u32 jb = sel8(bc + (g << 3), rem, &sub); rem -= sub;
  u32 b = (g << 3) + jb;
  u32 sub2;
  /* [WC16] wc now stores the ALIVE count directly, so the word level is a plain
     sel8 (no punpcklbw, no 64-x subtract) and one p5 uop leaves the chain. */
  u32 wi = sel8(wc + (b << 3), rem, &sub2); rem -= sub2;
  u32 w = (b << 3) + wi;
  u64 m = ~del[w];
  u64 r; __asm__("pdep %2, %1, %0" : "=r"(r) : "r"(1ULL << (rem - 1)), "r"(m));
  u32 bit = (u32)__builtin_ctzll(r);
  del[w] |= r;
  wc[w]--; bc[b]--; gs[g]--; sg[s]--;
  return ((b << 9) + (wi << 6)) + bit + 1;
}
static inline unsigned long ka_need(u32 V) {
  u32 nwords = (V + 63) >> 6;
  u32 nblk = (nwords + 7) >> 3;
  u32 ngrp = (nblk + 7) >> 3;
  u32 nsup = (ngrp + 7) >> 3;
  u32 nbp = ngrp << 3, ngp = nsup << 3;
  unsigned long need = ((unsigned long)nwords << 3) + ((unsigned long)nwords << 1) + 16 + 1;
  need = (need + 1) & ~1UL; need += (((unsigned long)nbp) << 1) + 2;
  need = (need + 1) & ~1UL; need += (((unsigned long)ngp) << 1) + 2;
  need = (need + 1) & ~1UL; need += (((unsigned long)nsup) << 1) + 2;
  return (need + 63) & ~(unsigned long)63;
}
static inline unsigned long big_init(u8 *mem, u32 V, u64 **pdel, u16 **pwc,
                                     u16 **pbc, u16 **pgs, u16 **psg) {
  u32 nwords = (V + 63) >> 6;
  u32 nblk = (nwords + 7) >> 3;
  u32 ngrp = (nblk + 7) >> 3;
  u32 nsup = (ngrp + 7) >> 3;
  u32 nbp = ngrp << 3, ngp = nsup << 3;
  unsigned long o1 = (((unsigned long)nwords << 3) + 1) & ~1UL;
  unsigned long o2 = (o1 + ((unsigned long)nwords << 1) + 16 + 1) & ~1UL;
  unsigned long o3 = (o2 + (((unsigned long)nbp) << 1) + 1) & ~1UL;
  unsigned long o4 = (o3 + (((unsigned long)ngp) << 1) + 1) & ~1UL;
  u64 *del = (u64 *)mem;
  u16 *wc  = (u16 *)(mem + o1);
  u16 *bc  = (u16 *)(mem + o2);
  u16 *gs  = (u16 *)(mem + o3);
  u16 *sg  = (u16 *)(mem + o4);
  for (u32 i = 0; i < nwords; i++) { del[i] = 0; wc[i] = 64; }
  u32 hi = V & 63;
  if (hi) { del[nwords - 1] = ~0ULL << hi; wc[nwords - 1] = (u16)hi; }
  for (u32 i = nwords; i < nwords + 8; i++) wc[i] = 0;   /* [WC16] 16 B read slack */
  for (u32 i = 0; i < nbp; i++) bc[i] = 0;
  for (u32 i = 0; i < ngp; i++) gs[i] = 0;
  for (u32 i = 0; i < nsup; i++) sg[i] = 0;
  for (u32 i = 0; i < nwords; i++) bc[i >> 3] += wc[i];
  for (u32 i = 0; i < nblk; i++)  gs[i >> 3] += bc[i];
  for (u32 i = 0; i < ngrp; i++)  sg[i >> 3] += gs[i];
  *pdel = del; *pwc = wc; *pbc = bc; *pgs = gs; *psg = sg;
  return ka_need(V);
}

static inline u32 small_remove(u32 *R, u32 d, u32 k) {
  u32 lo = 0, hi = d;
  while (lo < hi) {
    u32 mid = (lo + hi + 1) >> 1;
    if (R[mid - 1] - mid < k) lo = mid; else hi = mid - 1;
  }
  u32 p = k + lo;
  if (lo < d) {
    u32 *s = R + d, *e = R + lo;
    while (s > e) { *s = s[-1]; s--; }
  }
  R[lo] = p;
  return p;
}

// ------------------------- globals -------------------------
#define PN 300005
static u64 QXY[PN + 16];   /* [PFG] 8 words of tail slack: the prefetch guard goes away */
struct RINF_T { u32 offb; u32 appn; };
static RINF_T RINF[PN];
static u64 SIMPLE1[(PN + 63) / 64];
static u32 BIGD[8192][8];
#if NF_LAZY
static u32 RAPP[PN];                  // NF_LAZY: stores a column POSITION reference (<= n+q)
#else
static u64 RAPP[PN];                  // stores the column value
#endif
static u32 SMALLD[PN];
static u64 CAPP[PN];
static u8  CAPP5[PN * 5 + 8];
static constexpr int CAPP5on = 1;
static inline u64 load_capp5(u32 jj) { u64 v; __builtin_memcpy(&v, CAPP5 + (size_t)jj * 5, 8); return v & 0xFFFFFFFFFFULL; }

#ifndef NF_ARENA
#define NF_ARENA (144u << 20)
#endif
#define ARENASZ ((unsigned long)NF_ARENA)
static u8 ARENA[NF_ARENA];

static u64 *CDEL; static u16 *CWC; static u16 *CBC; static u16 *CGS; static u16 *CSG;

#if NF_LAZY
// Resolve a column POSITION p to the value living there.  Called only on the rare paths
// where the answer really is a column-appended value (p > n): deferred construction.
static inline u64 resolve(u32 p) {
  if (p <= g_n) return (u64)p * g_m;
  u32 jj = p - g_n - 1;
  if (CAPP5on) return load_capp5(jj);
  return CAPP[jj];
}
#endif

// returns output length; PT[0..3] = phase ticks when PROF
static unsigned long nf_solve(u8 *out) {
#ifdef PROF
  PTC = 0;
#endif
  writer_init();
  PTICK();
  u32 n = rd(), m = rd(), q = rd();
  g_n = n; g_m = m;

  u32 mm1 = m - 1;
  // ---- phase 1 ----
  for (u32 i = 0; i < q; i++) {
    if (!(i & 7u) && i + 16u < q) __builtin_prefetch(&QXY[i + 16u], 1, 1);
    u32 x = rd(), y = rd();
    QXY[i] = (u64)x | ((u64)y << 32);
    if (y < m) SMALLD[x]++;
  }
  PTICK();
  // ---- phase 2 ----
  u32 off = 0;
  u32 nbig = 0;
  unsigned long asz = 0;
  for (u32 r = 1; r <= n; r++) {
    if (!(r & 7u) && r + 16u <= n) __builtin_prefetch(&RINF[r + 16u], 1, 1);   /* [PFW] */
    u32 c = SMALLD[r];
    if (c <= 2) {
      u32 tag = (0x1FFEu + (u32)(c == 2)) & (0u - (u32)(c != 0));
      u64 descriptor = (u64)(tag << 19);
      __builtin_memcpy(&RINF[r], &descriptor, 8);
      continue;
    }
    u32 tag = 0;
    u64 V = (u64)mm1 + c;
    i64 cs = (i64)c * ((i64)(c >> 3) + 30);
    i64 cb = (i64)((V >> 6) + 1) * 2 + (i64)c * 55;
    if (cb < cs && nbig < 8190) {
      unsigned long need = ka_need((u32)V);
      if (asz + need <= ARENASZ - (1u << 20)) {
        u64 *pdel; u16 *pwc; u16 *pbc; u16 *pgs; u16 *psg;
        big_init(ARENA + asz, (u32)V, &pdel, &pwc, &pbc, &pgs, &psg);
        u32 *D = BIGD[nbig];
        D[0] = (u32)((u8 *)pdel - ARENA); D[1] = (u32)((u8 *)pwc - ARENA);
        D[2] = (u32)((u8 *)pbc - ARENA);  D[3] = (u32)((u8 *)pgs - ARENA);
        D[4] = (u32)((u8 *)psg - ARENA);
        asz += need;
        tag = ++nbig;
      }
    }
    RINF[r].offb = (off & 0x7FFFFu) | (tag << 19);
    RINF[r].appn = 0;
    off += c;
  }
  PTICK();
  // ---- column ----
  {
    u64 *pdel; u16 *pwc; u16 *pbc; u16 *pgs; u16 *psg;
    unsigned long need = big_init(ARENA + asz, n + q, &pdel, &pwc, &pbc, &pgs, &psg);
    asz += need;
    CDEL = pdel; CWC = pwc; CBC = pbc; CGS = pgs; CSG = psg;
  }
  PTICK();
  // ---- phase 3 ----
  u32 cappn = 0;
  u8 *o = out;
  for (u32 i = 0; i < q; i++) {
    u64 xy = QXY[i]; u32 x = (u32)xy, y = (u32)(xy >> 32);
#if NF_PFD > 0
    /* [PFG] no guard: QXY is padded by 16 words, so the i>=q-NF_PFD reads land in
       static zeroes and prefetch RINF[0] (prefetch never faults).  Removes one
       compare + one data-dependent branch from the hot loop, per query. */
    __builtin_prefetch(&RINF[(u32)QXY[i + NF_PFD]], 0, 3);
#endif
    // [HOIST] row-descriptor load, issued before the column select (see header)
    u32 hoffb = 0, happn = 0;
    if (y < m) { hoffb = RINF[x].offb; happn = RINF[x].appn; }
    // [HOIST2] the c>=3 row path's position computation is also pc-independent: start it now so
    // its SMALLD/arena latency overlaps the select chain instead of following it.
    u32 ho3 = 0, hopp = 0;
    if (y < m) {
      u32 t2 = hoffb >> 19;
      if (t2 != 0x1FFEu && t2 != 0x1FFFu) {   // t2 == 0 is the c>=3 SMALL row
        u32 ro2 = hoffb & 0x7FFFFu, ap2 = happn;
        if (t2) {
          const u32 *D = BIGD[t2 - 1];
          u64 *pdel = (u64 *)(ARENA + D[0]); u16 *pwc = (u16 *)(ARENA + D[1]);
          u16 *pbc = (u16 *)(ARENA + D[2]); u16 *pgs = (u16 *)(ARENA + D[3]);
          u16 *psg = (u16 *)(ARENA + D[4]);
          hopp = kth_alive_del(pdel, pwc, pbc, pgs, psg, y);
        } else {
          hopp = small_remove(SMALLD + ro2, ap2, y);
        }
        ho3 = 1;
      }
    }
    u32 pc = kth_alive_del(CDEL, CWC, CBC, CGS, CSG, x);
#if !NF_LAZY
    u64 cval;
    if (pc <= n) cval = (u64)pc * m;
    else {
      u32 jj = pc - n - 1;
      if (CAPP5on) cval = load_capp5(jj);
      else cval = CAPP[jj];
    }
#endif
    u64 val;
    if (y < m) {
      u32 r = x;
#if !NF_SIMPLECLS
      if ((SIMPLE1[r >> 6] >> (r & 63)) & 1ULL) {
        val = (u64)(r - 1) * m + y;
      } else {
#endif
      u32 offb = hoffb;                 // [HOIST] loaded above, in parallel with the select
      u32 t = offb >> 19;
      u32 ro = offb & 0x7FFFFu;
      u32 ap = happn;
      u32 pp;
#if NF_SIMPLECLS
      if (t == 0x1FFEu) {
        val = (u64)(r - 1) * m + y;
      } else
#endif
      if (t == 0x1FFFu) {
        u32 p0 = offb & 0x7FFFFu;
        if (!p0) {
          pp = y;
          RINF[r].offb = (0x1FFFu << 19) | y;
          RINF[r].appn = pc + 1;
          val = (u64)(r - 1) * m + pp;
        } else {
          pp = y + (y >= p0 ? 1u : 0u);
          if (pp <= mm1) val = (u64)(r - 1) * m + pp;
          else {
            u32 pcc = RINF[r].appn - 1;
#if NF_LAZY
            val = resolve(pcc);
#else
            if (pcc <= n) val = (u64)pcc * m;
            else { u32 jj = pcc - n - 1;
              if (CAPP5on) val = load_capp5(jj);
              else val = CAPP[jj];
            }
#endif
          }
        }
      } else {
        (void)ro; (void)ap;
        pp = ho3 ? hopp : 0;              // [HOIST2] computed above; ho3==1 on every path here
#if NF_LAZY
        u64 rv = (pp <= mm1) ? ((u64)(r - 1) * m + pp) : resolve(RAPP[ro + (pp - m)]);
        RAPP[ro + ap] = pc;                    // store the POSITION reference, not the value
        val = rv;
#else
        val = (pp <= mm1) ? ((u64)(r - 1) * m + pp) : RAPP[ro + (pp - m)];
        RAPP[ro + ap] = cval;
#endif
        RINF[r].appn = ap + 1;
      }
#if !NF_SIMPLECLS
      }
#endif
    } else {
#if NF_LAZY
      val = resolve(pc);
#else
      val = cval;
#endif
    }
    { size_t o_ = (size_t)cappn * 5;
      if (CAPP5on) __builtin_memcpy(CAPP5 + o_, &val, 8);
      else CAPP[cappn] = val; }
    cappn++;
    o = (i + 1 == q) ? wr_safe(o, val) : wr(o, val);
  }
  PTICK();
  return (unsigned long)(o - out);
}

static unsigned long nf_run(const u8 *in, u8 *out) { gip = in; return nf_solve(out); }

struct DUCKDI{unsigned long abi;const char*sp;unsigned long sn;char*op;unsigned long ol,os;char*ep;unsigned long el,es;const char*IB;unsigned long IBl;char*OB;unsigned long OBl;unsigned long tsc;}__attribute__((packed));
extern "C" void __libc_start_main(void*m,int argc,char**argv){
 unsigned long*p=(unsigned long*)(argv+argc+1);while(*p)p++;p++;
 DUCKDI*d=0;for(;p[0];p+=2)if(p[0]==0x6b637564UL){d=(DUCKDI*)p[1];break;}
 gip=(const u8*)d->sp; gob=(u8*)d->op;
 unsigned long olen = nf_solve(gob);
 gob=(u8*)d->op+olen;
 d->os=olen;
 __asm__ volatile("syscall"::"a"(60),"D"(0):"rcx","r11","memory");
 for(;;);
}
int main(){return 0;}

评测结果