#!/usr/bin/env python3
"""
Emoji V8.13 - 全栈VM字节码执行 (零明文load) + TFORLOOP 蹦床控制流混淆 + 双层字符串保护 + 反拦截器 + 真机引擎兼容 (LuaJ/GG 自动兼容档 + 逐检测器诊断码 + D3 真机熔断) + 循环回边安全 + 三向停机判别

架构升级:
1. Lua 源码 -> 编译器 -> VM 字节码 (51 指令栈式VM)
2. 字节码加密 -> Emoji 外层壳
3. 运行时: 解密字节码 -> VM 解释执行 -> 完全不调用 load()
4. 支持: 函数调用、表操作、GG API 桥接、循环、条件分支
5. V8-Scatter: 解密逻辑碎片化分散 — 轮函数/密钥调度/AES白盒拆成独立碎片,
   以随机拓扑序散布全文件, 轮函数随机槽位存储 + XOR编码调度序列
6. TFORLOOP 蹦床控制流混淆 (V8.5):
   VM 中 TFORLOOP 语义与 Lua 5.1 一致: "若 R[A+1] 非空(≠nil) 则 R[A]=R[A+1]
   并跳转 sBx"。混淆器用 NOT/TEST 指令链维护 R245-R248 四个布尔状态寄存器,
   将真实控制流改写为条件蹦床链; 基本块乱序布局 + 多级蹦床 + 诱饵蹦床,
   线性阅读反汇编完全不可读, 必须按蹦床链重建执行序。
   主要函数另叠加等价指令替换 (EQ+TFORLOOP 替代 JMP) 与常量乱序。
7. 双层字符串保护 (V8.6 新增):
   外层: 常量池全局名/消息/字符串全部采用链式流式 XOR (密钥字节依赖前密文字节);
   内层: 字符映射表 (256字节双射置换) 由引导器以 5 字节分块逐块重建,
         字符串常量以映射后索引存储, 运行时经映射表还原。
   另含: 针对debug库的反篡改自检 + 防load探针 (load/loadstring 完整性验证)。
8. API 调用名保护 (V8.6 新增):
   所有 API 调用名 (gg.searchNumber/gg.setValues/...) 在常量表中以 XOR 密文
   存储 (14 字节循环密钥, 逐字节异或); 运行时经元表 __index 逐字节还原后
   查表转发。外壳源码中的 API 明文名全部消除 (密文表动态构建转发项)。
9. 多态垃圾填充 (V8.6 新增):
   每个函数头部植入固定模式 (TFORLOOP, TFORLOOP, EQ_SKIP, 垃圾指令, NOT...),
   垃圾指令总被前一条 EQ_SKIP 的条件跳过语义跳过, 永不执行;
   垃圾内容每次加密随机生成 (多态), 对抗函数头签名定位。
10. 反拦截器防护 (V8.7 新增):
   对抗夕颜/Only类 GG 拦截器 (全函数钩挂/环境伪造/加载器包裹):
   _G污染扫描 + debug.getinfo活性金丝雀 + 帧深度走查(防load) + 行为金丝雀
   + string.dump原生态探针 + gg错误前缀指纹(基线自校准) + 拦截器残留产物扫描
   + debug.gethook/getinfo自检 + loadstring功能探针; 全部只读零弹窗, 敏感字串
   随机掩码XOR存储 (外壳零明文特征); 命中即 error() 静默处决 — 拦截器以
   xpcall(目标,catch) 运行本脚本, isDebug=false 时错误被静默吞掉, 拦截者
   只看到脚本"无声无息退出", 无任何排查线索; gg 桥接首次访问时 _icheck 惰性复检。
11. 真机引擎兼容 (V8.8 新增, V8.9 强化):
   针对 GG (LuaJ 系引擎) 实测差异修复自检误报:
   a) D1 _G 扫描白名单补引擎差异全局 (rawlen/luajava), 未知计数阈值 2→4;
      _icheck 复检改仅精确泄漏名扫描 (_lscan) — 用户脚本运行期合法全局不计入
   b) D3 帧走查过滤 source=nil 的伪帧 (LuaJ getinfo 对栈外层号返回幽灵帧)
   c) D9 getinfo(函数) 容忍 nil/报错 (LuaJ 变体不支持函数参数形式)
   d) D5/_icheck string.dump 探针增加校准门控 (dump(内置) 成功则自动停用)
   V8.9 新增: 自动兼容档 — 真机 GG (gg 全局存在) 自动跳过三项无法在真实引擎上
   标定的检测器 (未知全局计数/gethook/残留产物扫描), 其余检测器全保留;
   --guard-strict 强制全量; 处决文案改为逐检测器诊断码 (0x11..0x1F, 真机报错
   可精确归因到检测器), --guard-decoy 恢复随机诱饵文案池
   V8.10 新增: D3 帧走查幽灵帧甄别 — 真机 GG 实测误报 0x16 (诊断码归因):
   GG 的 LuaJ 在主 chunk 之上 (Java 边界外) 返回的伪帧携带非空 source 且
   what 为 main/Lua, V8.9 的 source=nil 单条件过滤不足。现处决需同时满足
   四条件: what∈{main,Lua} + source 为字符串 + 归一化 source≠自身 chunk
   + currentline≥1 (真实调用点行号); 引擎伪帧 (钳位帧/残影帧) 必有短板
   自动放行, 真实外部包装帧 (拦截器/加载器) 全部条件成立照常处决
   V8.11 新增: D3 真机熔断 — V8.10 四条件甄别真机复测仍误报 0x16: 实测证实
   GG 的伪帧可同时满足全部四条件 (外来 source + 真实行号), 帧内容上与真实
   包装帧不可区分, 无法在不误杀的前提下远程标定 → D3 在 gg 环境 (真机) 停用,
   --guard-strict 或非 GG 引擎保留 (K3/T9/T5 验证); 真机反拦截由 _lscan 泄漏
   名/dump 探针/行为金丝雀/gg前缀指纹/_icheck 惰性复检承担 (拦截器必然钩挂
   Lua 函数+泄漏全局, 与帧走查无关)
   V8.12 修复: 循环回边头部陷阱 — 加密产物在真机 GG "执行完功能返回菜单后
   脚本无声关闭" (无任何报错)。根因: V8.6 引入的函数头多态垃圾
   (TFORLOOP,TFORLOOP,EQ_SKIP,垃圾,NOT...) 原地前缀进块 0 节点, 其双
   TFORLOOP 的 "入口状态寄存器必为 nil 永不触发" 前提仅在函数真实入口成立;
   当 while/repeat/for 循环头位于函数偏移 0 时 (如 mainMenu/menuVehicle 类
   "local function f() while true do ... end end"), 循环回边 TFORLOOP 目标
   即头垃圾起点; 第二圈进入时蹦床已把 R[244..248] 写为 true/false (非 nil)
   → 头部 TFORLOOP 误触发 end 哨兵 → VM 静默停机。修复: 头垃圾独立成节点
   (仅 VM 隐式入口可达), ('blk',0) 引用一律解析到真实块体节点, 头尾经专属
   蹦床重写状态寄存器后进入块体; 另加物化后自检 (任何显式边目标 raw==0 或
   越界 → 整函数回退未混淆字节码, 零语义风险)
   V8.13 修复: ①真机 "使用功能后返回菜单退出" 残留 — 三路并进:
   (a) 物化自检升级: 显式边目标落在头垃圾区间 [0,head_len) 内 (含中段)
       一律整函数回退, 堵住 raw==0 单点检查的变体逃逸;
   (b) _icheck dump 探针按文档语义修复: 以 _dseen 按函数值去重计 "不同
       成员" (旧版按调用次数, 同一成员 setup+首次访问计 2 次, 2 个可 dump
       成员即误杀); _rscan 弱指示名计数仅在非 GG 引擎参与 (真机额外全局
       不可枚举, 强指示名单名判罚保留);
   (c) 引导层三向判别: _bvm_run pcall 包裹, 错误原样上抛 (诊断码弹窗不变),
       VM 正常返回 (常驻菜单脚本=异常静默停机) 打 gg.toast("V8:END") —
       真机一次运行即可判别: 弹 0xNN=守卫处决 / 弹 V8:END=VM 静默停机 /
       无标记即死=os.exit 路径
   新增验证: scripts/test_vm_flow.py 真机交互状态机 harness (返回键 nil/
   可见性轮询/再点开/长空闲 3 万轮/状态机 fuzz 60 轮), luajit21+lua51+
   LuaJ(GgProbe5) 三引擎全绿
   V8.14 防护收敛 + 统一惩罚:
   (a) 删除旧 guard 中依赖 string.dump / io.popen / debug.gethook / 帧走查
       的可反制探针, 仅保留 _G 泄漏名扫描 (强/弱指示名) + 未知全局计数;
   (b) 新增 adets 碎片 — 移植用户提供的反 hook 段: 内建函数在载入期以 rawget
       快照为 local (消除 _ENV 读写 / 自改名 loadfile / os/io 依赖等 hook 点);
       关键内建与 _G 全局若被替换为来自其它 @文件 的 Lua 闭包即判罚,
       另含 type/tostring/tonumber/string.rep/pcall/traceback/loadstring 行为金丝雀;
   (c) 所有反 hook/反篡改触发点 (guard/_icheck/ad1~ad3/VM 内 A-H/d/t) 统一改走
       _PEN(): setVisible 闪烁循环 (20000 轮) + os.exit, 不再使用 error() 静默处决;
       完整性校验和/AES/VM 运行错误仍保留原 error 行为

VM指令集 (52条):
  栈操作:    NOP PUSH_NIL PUSH_TRUE PUSH_FALSE PUSH_CONST PUSH_NUM POP DUP SWAP
  算术:      ADD SUB MUL DIV MOD POW UNM
  位运算:    BAND BOR BXOR BNOT LSHIFT RSHIFT
  比较:      EQ NE LT LE GT GE
  条件跳过:  EQ_SKIP A B C N (寄存器机: R[A]==R[B] 与 C 比对, 匹配则跳过紧随 N 字节垃圾)
  逻辑:      LAND LOR LNOT
  字符串:    CONCAT LEN
  跳转:      JMP JMP_TRUE JMP_FALSE
  蹦床寄存器: TFORLOOP (若R[A+1]非空则R[A]=R[A+1]并跳转sBx)
              TEST (真值匹配则跳过紧随TFORLOOP)  NOT (R[A]=not R[B])
  变量:      GET_GLOBAL SET_GLOBAL GET_LOCAL SET_LOCAL (R245-R248=local槽245..248)
  表:        NEW_TABLE GET_TABLE SET_TABLE
  函数:      CALL CALL_NATIVE RETURN HALT
"""

import os, random, struct, re, sys

EMOJI_BASE = 0x1F300

# ============================================================
# AES 白盒加密系统 (替代 V5 查表 XOR)
# ============================================================
# 简化 AES-128 (6轮) + 白盒 T-box 实现
# 密钥完全嵌入查找表，解密时无原始密钥暴露

# AES S-box
_AES_SBOX = [
    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
]

# AES 逆 S-box
_AES_INV_SBOX = [0]*256
for i in range(256):
    _AES_INV_SBOX[_AES_SBOX[i]] = i

# GF(2^8) 乘法
def _gmul(a, b):
    p = 0
    for _ in range(8):
        if b & 1: p ^= a
        hi = a & 0x80
        a = (a << 1) & 0xFF
        if hi: a ^= 0x1b
        b >>= 1
    return p

# MixColumns 矩阵
# | 2 3 1 1 |
# | 1 2 3 1 |
# | 1 1 2 3 |
# | 3 1 1 2 |

def _mix_column(col):
    """正向 MixColumns (4字节列)"""
    r = [
        _gmul(col[0],2) ^ _gmul(col[1],3) ^ col[2] ^ col[3],
        col[0] ^ _gmul(col[1],2) ^ _gmul(col[2],3) ^ col[3],
        col[0] ^ col[1] ^ _gmul(col[2],2) ^ _gmul(col[3],3),
        _gmul(col[0],3) ^ col[1] ^ col[2] ^ _gmul(col[3],2),
    ]
    return r

def _inv_mix_column(col):
    """逆向 MixColumns (4字节列)"""
    r = [
        _gmul(col[0],0x0e) ^ _gmul(col[1],0x0b) ^ _gmul(col[2],0x0d) ^ _gmul(col[3],0x09),
        _gmul(col[0],0x09) ^ _gmul(col[1],0x0e) ^ _gmul(col[2],0x0b) ^ _gmul(col[3],0x0d),
        _gmul(col[0],0x0d) ^ _gmul(col[1],0x09) ^ _gmul(col[2],0x0e) ^ _gmul(col[3],0x0b),
        _gmul(col[0],0x0b) ^ _gmul(col[1],0x0d) ^ _gmul(col[2],0x09) ^ _gmul(col[3],0x0e),
    ]
    return r

# Rcon
_AES_RCON = [0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36]

def _key_expansion_10r(key_bytes):
    """10轮 AES 的密钥扩展 (11个 16字节轮密钥)
    key_bytes: 16字节密钥
    返回: list of 11 round keys, 每个 16字节
    """
    assert len(key_bytes) == 16
    rk = [list(key_bytes)]
    for i in range(10):
        prev = rk[-1]
        # RotWord + SubWord + Rcon
        w3 = prev[12:16]
        w3_rot = [w3[1], w3[2], w3[3], w3[0]]
        w3_sub = [_AES_SBOX[b] for b in w3_rot]
        w3_sub[0] ^= _AES_RCON[i]

        new_rk = [0]*16
        # w4 = w0 ^ w3'
        for j in range(4):
            new_rk[j] = prev[j] ^ w3_sub[j]
        # w5 = w4 ^ w1
        for j in range(4):
            new_rk[4+j] = new_rk[j] ^ prev[4+j]
        # w6 = w5 ^ w2
        for j in range(4):
            new_rk[8+j] = new_rk[4+j] ^ prev[8+j]
        # w7 = w6 ^ w3
        for j in range(4):
            new_rk[12+j] = new_rk[8+j] ^ prev[12+j]
        rk.append(new_rk)
    return rk

def _shift_rows(state):
    """正向 ShiftRows (4x4 状态，列优先: state[col*4+row])"""
    # 行1: 左移1
    s = state[:]
    # state 布局: col0(r0,r1,r2,r3), col1(r0,r1,r2,r3), ...
    # 行0: s0 s4 s8 s12 (不变)
    # 行1: s1 s5 s9 s13 -> s5 s9 s13 s1 (左移1)
    # 行2: s2 s6 s10 s14 -> s10 s14 s2 s6 (左移2)
    # 行3: s3 s7 s11 s15 -> s15 s3 s7 s11 (左移3)
    r = s[:]
    # 行1
    r[1]=s[5]; r[5]=s[9]; r[9]=s[13]; r[13]=s[1]
    # 行2
    r[2]=s[10]; r[6]=s[14]; r[10]=s[2]; r[14]=s[6]
    # 行3
    r[3]=s[15]; r[7]=s[3]; r[11]=s[7]; r[15]=s[11]
    return r

def _inv_shift_rows(state):
    """逆向 ShiftRows"""
    s = state[:]
    r = s[:]
    # 行1: 右移1 = 左移3
    r[1]=s[13]; r[5]=s[1]; r[9]=s[5]; r[13]=s[9]
    # 行2: 右移2 = 左移2
    r[2]=s[10]; r[6]=s[14]; r[10]=s[2]; r[14]=s[6]
    # 行3: 右移3 = 左移1
    r[3]=s[7]; r[7]=s[11]; r[11]=s[15]; r[15]=s[3]
    return r

def aes_encrypt_block(block, key_bytes):
    """10轮 AES 加密 (16字节块)"""
    rk = _key_expansion_10r(key_bytes)
    state = list(block)

    # AddRoundKey (初始)
    for i in range(16):
        state[i] ^= rk[0][i]

    # 轮 1-9: SubBytes -> ShiftRows -> MixColumns -> AddRoundKey
    for r in range(1, 10):
        for i in range(16):
            state[i] = _AES_SBOX[state[i]]
        state = _shift_rows(state)
        for c in range(4):
            col = state[c*4:(c+1)*4]
            new_col = _mix_column(col)
            for i in range(4):
                state[c*4+i] = new_col[i]
        for i in range(16):
            state[i] ^= rk[r][i]

    # 最后一轮 (第10轮): SubBytes -> ShiftRows -> AddRoundKey
    for i in range(16):
        state[i] = _AES_SBOX[state[i]]
    state = _shift_rows(state)
    for i in range(16):
        state[i] ^= rk[10][i]

    return bytes(state)

def aes_decrypt_block(block, key_bytes):
    """10轮 AES 解密 (16字节块) - 用于验证"""
    rk = _key_expansion_10r(key_bytes)
    state = list(block)

    # 最后一轮逆: AddRoundKey -> InvShiftRows -> InvSubBytes
    for i in range(16):
        state[i] ^= rk[10][i]
    state = _inv_shift_rows(state)
    for i in range(16):
        state[i] = _AES_INV_SBOX[state[i]]

    # 轮 9-1: AddRoundKey -> InvMixColumns -> InvShiftRows -> InvSubBytes
    for r in range(9, 0, -1):
        for i in range(16):
            state[i] ^= rk[r][i]
        for c in range(4):
            col = state[c*4:(c+1)*4]
            new_col = _inv_mix_column(col)
            for i in range(4):
                state[c*4+i] = new_col[i]
        state = _inv_shift_rows(state)
        for i in range(16):
            state[i] = _AES_INV_SBOX[state[i]]

    # 初始 AddRoundKey
    for i in range(16):
        state[i] ^= rk[0][i]

    return bytes(state)

def aes_whitebox_build(key_bytes, seed=12345):
    """构建 AES-10 白盒解密表 (10轮完整版, 去除逆置换表防密钥恢复)
    返回字典包含所有查表数据
    关键改进: 不存储 inv_kperm, 轮密钥直接以 XOR 掩码形式存储
    """
    import random
    rk = _key_expansion_10r(key_bytes)
    
    rng = random.Random(seed)
    
    # 1. 最后一轮表: 16个表 x 256字节
    #    last_tbl[pos][x] = InvSbox[x ^ rk10[pos]]
    last_tbl = []
    for pos in range(16):
        tbl = [0]*256
        k = rk[10][pos]
        for x in range(256):
            tbl[x] = _AES_INV_SBOX[x ^ k]
        last_tbl.append(tbl)
    
    # 2. InvMixColumn T-box (4个，每个256x4字节)
    imc_t = []
    for row in range(4):
        tbl = []
        for x in range(256):
            col = [0, 0, 0, 0]
            col[row] = x
            result = _inv_mix_column(col)
            tbl.append(bytes(result))
        imc_t.append(tbl)
    
    # 3. 轮密钥直接存储 (9轮: rk[9]..rk[1])
    #    改进: 用 per-byte 随机掩码 XOR, 掩码分散存储
    #    运行时 XOR 还原, 攻击者无法直接读取
    rk_masks = []  # 每轮16字节的掩码
    round_rks_masked = []  # 掩码后的轮密钥
    for r in range(9, 0, -1):
        mask = [rng.randint(0, 255) for _ in range(16)]
        masked = [rk[r][i] ^ mask[i] for i in range(16)]
        rk_masks.append(mask)
        round_rks_masked.append(masked)
    
    # 4. 最终密钥 (rk[0]) 同样掩码存储
    final_mask = [rng.randint(0, 255) for _ in range(16)]
    final_rk_masked = [rk[0][i] ^ final_mask[i] for i in range(16)]
    
    # 5. 掩码分散到白盒密钥表中 (不再单独存储 inv_kperm)
    #    掩码本身也被 XOR 分片保护
    return {
        'last_tbl': last_tbl,
        'imc_t': imc_t,
        'round_rks_masked': round_rks_masked,
        'rk_masks': rk_masks,
        'final_rk_masked': final_rk_masked,
        'final_mask': final_mask,
        'inv_sbox': _AES_INV_SBOX,
    }

def aes_whitebox_decrypt(data, wb):
    """AES 白盒解密 (CBC模式, PKCS7填充) - 10轮版
    data: bytes 加密数据 (前16字节为IV)
    wb: 白盒表字典
    返回: bytes 明文数据
    """
    n = len(data)
    assert n % 16 == 0 and n >= 32, f"data length {n} not valid for CBC"

    last_tbl = wb['last_tbl']
    imc_t = wb['imc_t']
    round_rks_masked = wb['round_rks_masked']
    rk_masks = wb['rk_masks']
    final_rk_masked = wb['final_rk_masked']
    final_mask = wb['final_mask']
    inv_sbox = wb['inv_sbox']

    # 解码轮密钥 (XOR 还原掩码)
    round_rks = []
    for i, masked in enumerate(round_rks_masked):
        round_rks.append([masked[j] ^ rk_masks[i][j] for j in range(16)])
    final_rk = [final_rk_masked[i] ^ final_mask[i] for i in range(16)]

    iv = list(data[:16])
    result = bytearray()
    prev_block = iv

    for bi in range(16, n, 16):
        state = list(data[bi:bi+16])

        # 第一步: ARK(rk10) + ISR + ISB (通过 last_tbl)
        new_state = [0]*16
        for c in range(4):
            for r in range(4):
                out_pos = c*4 + r
                in_col = (c - r) % 4
                in_pos = in_col*4 + r
                new_state[out_pos] = last_tbl[in_pos][state[in_pos]]
        state = new_state

        # 中间9轮
        for rn in range(9):
            rk_in = round_rks[rn]

            # ARK
            for i in range(16):
                state[i] ^= rk_in[i]

            # InvMixColumns (T-box)
            ns = [0]*16
            for c in range(4):
                s0 = state[c*4+0]
                s1 = state[c*4+1]
                s2 = state[c*4+2]
                s3 = state[c*4+3]
                t0 = imc_t[0][s0]
                t1 = imc_t[1][s1]
                t2 = imc_t[2][s2]
                t3 = imc_t[3][s3]
                for i in range(4):
                    ns[c*4+i] = t0[i] ^ t1[i] ^ t2[i] ^ t3[i]
            state = ns

            # InvShiftRows
            state = _inv_shift_rows(state)

            # InvSubBytes
            for i in range(16):
                state[i] = inv_sbox[state[i]]

        # 最终 ARK
        for i in range(16):
            state[i] ^= final_rk[i]

        # CBC: XOR with previous ciphertext block (or IV)
        for i in range(16):
            state[i] ^= prev_block[i]

        result.extend(state)
        prev_block = list(data[bi:bi+16])

    # PKCS7 去填充
    pad_len = result[-1]
    if 1 <= pad_len <= 16 and all(b == pad_len for b in result[-pad_len:]):
        result = result[:-pad_len]

    return bytes(result)

def aes_encrypt_cbc(data, key_bytes):
    """AES-10 加密 (CBC + PKCS7 填充 + 随机IV)
    输出格式: IV(16) + ciphertext
    CBC模式: 每块明文先与前一块密文异或再加密"""
    iv = os.urandom(16)
    pad_len = 16 - (len(data) % 16)
    padded = data + bytes([pad_len]*pad_len)
    result = bytearray(iv)
    prev = iv
    for i in range(0, len(padded), 16):
        block = bytes(a ^ b for a, b in zip(padded[i:i+16], prev))
        enc = aes_encrypt_block(block, key_bytes)
        result.extend(enc)
        prev = enc
    return bytes(result)

# ============================================================
# V5加密原语 (沿用)
# ============================================================

VM_BC_PRNG = [
    5,0,17, 3,0,31, 7,0,256,
    5,1,23, 3,1,17, 7,1,256,
    5,2,29, 3,2,43, 7,2,256,
    2,3,0, 8,3,1, 8,3,2,
    0,0,0
]
VM_BC_KDF = [
    5,0,17, 1,2,31, 6,2,1, 4,0,2, 7,0,256,
    2,2,0, 5,2,23, 3,2,11, 7,2,256,
    8,0,2, 5,0,29, 3,0,7, 7,0,256,
    0,0,0
]

def vm_execute_v5(bc, regs=None):
    reg = list(regs or [0]*8)
    pc = 0
    while pc <= len(bc) - 3:
        op, dst, arg = bc[pc], bc[pc+1], bc[pc+2]
        if op == 0: break
        elif op == 1: reg[dst] = arg
        elif op == 2: reg[dst] = reg[arg]
        elif op == 3: reg[dst] += arg
        elif op == 4: reg[dst] += reg[arg]
        elif op == 5: reg[dst] *= arg
        elif op == 6: reg[dst] *= reg[arg]
        elif op == 7: reg[dst] %= arg
        elif op == 8: reg[dst] = reg[dst] ^ reg[arg]
        elif op == 9: reg[dst] = reg[dst] ^ arg
        pc += 3
    return reg

# 改进: VM_BC_PRNG/VM_BC_KDF 是固定程序, 其语义可精确展开为纯算术。
# 热路径直接用内联算术替代逐指令 VM 解释 (构建提速 ~50x, 且为 Lua 端
# 同样的内联提供一致实现)。参考实现保留为 *_ref 函数用于回归验证。
def vm_prng_step_ref(s1, s2, s3):
    regs = vm_execute_v5(VM_BC_PRNG, [s1, s2, s3, 0, 0, 0, 0, 0])
    return regs[0], regs[1], regs[2], regs[3]

def vm_derive_key_ref(seed, idx):
    regs = vm_execute_v5(VM_BC_KDF, [seed, idx, 0, 0, 0, 0, 0, 0])
    return regs[0]

def vm_prng_step(s1, s2, s3):
    # VM_BC_PRNG 展开: s1=s1*17+31; s2=s2*23+17; s3=s3*29+43 (mod 256); r=s1^s2^s3
    s1 = (s1 * 17 + 31) % 256
    s2 = (s2 * 23 + 17) % 256
    s3 = (s3 * 29 + 43) % 256
    return s1, s2, s3, (s1 ^ s2 ^ s3)

def vm_derive_key(seed, idx):
    # VM_BC_KDF 展开: r0=(seed*17+31*idx)%256; r2=(r0*23+11)%256; r0^=r2; k=(r0*29+7)%256
    r0 = (seed * 17 + 31 * idx) % 256
    r2 = (r0 * 23 + 11) % 256
    r0 = (r0 ^ r2) & 0xFF
    return (r0 * 29 + 7) % 256

def key_schedule_v5(seed):
    return [vm_derive_key(seed, i) for i in range(1, 6)]

def prng_v5(seed, n):
    s1 = seed; s2 = (seed * 7 + 13) % 256; s3 = (seed * 13 + 7) % 256
    stream = []
    for _ in range(n):
        s1, s2, s3, r = vm_prng_step(s1, s2, s3)
        stream.append(r & 0xFF)
    return stream

def make_sbox_v5(seed):
    sbox = list(range(256)); state = seed
    for i in range(255, 0, -1):
        state = (state * 17 + 31) % 256; j = state % (i + 1)
        sbox[i], sbox[j] = sbox[j], sbox[i]
    return sbox

# ===== 改进: 32位种子 V5 加密 (2^32 密钥空间) =====
def key_schedule_v5_32(seed32):
    """32位种子 → 5个密钥, 从4个独立1字节种子XOR组合"""
    seeds = [(seed32 >> (i * 8)) & 0xFF for i in range(4)]
    keys = [0] * 5
    for s in seeds:
        ks = key_schedule_v5(s)
        for i in range(5):
            keys[i] ^= ks[i]
    return keys

def prng_v5_32(sk3, n):
    """用3个独立密钥作为PRNG初始状态 (2^24状态空间, 而非2^8)"""
    s1, s2, s3 = sk3[0], sk3[1], sk3[2]
    stream = []
    for _ in range(n):
        s1, s2, s3, r = vm_prng_step(s1, s2, s3)
        stream.append(r & 0xFF)
    return stream

def make_sbox_v5_32(seeds):
    """多种子S盒: 依次应用多个独立洗牌"""
    sbox = list(range(256))
    for seed in seeds:
        state = seed
        for i in range(255, 0, -1):
            state = (state * 17 + 31) % 256
            j = state % (i + 1)
            sbox[i], sbox[j] = sbox[j], sbox[i]
    return sbox

def checksum1(data, key=0):
    """改进: HMAC式校验和1 (密钥混合, 防篡改)
    内层: key^ipad 混合数据哈希; 外层: key^opad 混合内层哈希"""
    inner = [(key * 0x36 + i * 0x36) % 256 for i in range(4)]
    for i, b in enumerate(data): inner[i % 4] = (inner[i % 4] * 31 + b) % 251
    outer = [(key * 0x5C + i * 0x5C) % 256 for i in range(4)]
    for i in range(4): outer[i] = (outer[i] * 17 + inner[i]) % 251
    return bytes(outer)

def checksum2(data, key=0):
    """改进: HMAC式校验和2 (密钥混合, 防篡改)"""
    inner = [(key * 0x5C + i * 0x36) % 256 for i in range(4)]
    for i, b in enumerate(data): inner[i % 4] = (inner[i % 4] * 17 + b * ((i + key + 1) % 251)) % 251
    outer = [(key * 0x36 + i * 0x5C) % 256 for i in range(4)]
    for i in range(4): outer[i] = (outer[i] * 31 + inner[i]) % 251
    return bytes(outer)

def bc_checksum(bc):
    s = 0
    for v in bc: s = (s * 31 + v) % 65521
    return s

def encrypt_v5(raw, seed):
    n = len(raw); sk = key_schedule_v5(seed)
    ks1 = prng_v5(sk[0], n); ks2 = prng_v5(sk[3], n)
    sb1 = make_sbox_v5(sk[1]); sb2 = make_sbox_v5(sk[4])
    iv1 = sk[2]; iv2 = sk[2] * 7 % 256
    d = bytearray(raw)
    for i in range(n): d[i] ^= ks1[i]
    for i in range(n): d[i] = sb1[d[i]]
    d[0] ^= iv1
    for i in range(1, n): d[i] ^= d[i-1]
    for i in range(n): d[i] ^= ks2[i]
    for i in range(n): d[i] = sb2[d[i]]
    d[0] ^= iv2
    for i in range(1, n): d[i] ^= d[i-1]
    return checksum1(raw, seed & 0xFF) + checksum2(raw, seed & 0xFF) + bytes(d)

def encrypt_v5_32(raw, seed32):
    """改进: 32位种子V5加密, 密钥空间 2^32"""
    n = len(raw)
    sk = key_schedule_v5_32(seed32)
    ks1 = prng_v5_32([sk[0], sk[1], sk[2]], n)
    ks2 = prng_v5_32([sk[3], sk[4], sk[0]], n)
    sb1 = make_sbox_v5_32([sk[1], sk[3]])
    sb2 = make_sbox_v5_32([sk[2], sk[4]])
    iv1 = sk[0] ^ sk[2]
    iv2 = (sk[1] ^ sk[4]) * 7 % 256
    d = bytearray(raw)
    for i in range(n): d[i] ^= ks1[i]
    for i in range(n): d[i] = sb1[d[i]]
    d[0] ^= iv1
    for i in range(1, n): d[i] ^= d[i-1]
    for i in range(n): d[i] ^= ks2[i]
    for i in range(n): d[i] = sb2[d[i]]
    d[0] ^= iv2
    for i in range(1, n): d[i] ^= d[i-1]
    return checksum1(raw, seed32 & 0xFF) + checksum2(raw, (seed32 >> 8) & 0xFF) + bytes(d)

def encode_emoji(data):
    chars = []
    for i, b in enumerate(data):
        chars.append(chr(EMOJI_BASE + b))
        if (i + 1) % 56 == 0: chars.append("\n")
    return "".join(chars)

def encrypt_string(s, key):
    # 改进: 从单字节密钥派生16字节密钥, 多字节XOR (防频率分析)
    kb = [(key * 31 + i * 17 + 0xA3) % 256 for i in range(16)]
    data = s.encode('utf-8')
    encrypted = bytes([b ^ kb[i % 16] for i, b in enumerate(data)])
    return ''.join(f'\\{b:03d}' for b in encrypted)

def encrypt_bytecode(bc, key):
    # 改进: 从单字节密钥派生16字节密钥, 多字节XOR
    kb = [(key * 31 + i * 17 + 0xA3) % 256 for i in range(16)]
    return [x ^ kb[i % 16] for i, x in enumerate(bc)]

# ============================================================
# V8: Lua -> VM 字节码 编译器
# ============================================================

# VM 操作码定义
OP = {
    'NOP': 0,
    'HALT': 1,
    'PUSH_NIL': 2,
    'PUSH_TRUE': 3,
    'PUSH_FALSE': 4,
    'PUSH_CONST': 5,    # +1 byte: const index
    'PUSH_NUM': 6,      # +1 byte: small int (0-255)
    'POP': 7,
    'DUP': 8,
    'SWAP': 9,
    'ADD': 10,
    'SUB': 11,
    'MUL': 12,
    'DIV': 13,
    'MOD': 14,
    'POW': 15,
    'UNM': 16,
    'BAND': 17,
    'BOR': 18,
    'BXOR': 19,
    'BNOT': 20,
    'LSHIFT': 21,
    'RSHIFT': 22,
    'EQ': 23,
    'NE': 24,
    'LT': 25,
    'LE': 26,
    'GT': 27,
    'GE': 28,
    'LAND': 29,
    'LOR': 30,
    'LNOT': 31,
    'CONCAT': 32,
    'LEN': 33,
    'JMP': 34,          # +2 bytes: address (little-endian)
    'JMP_TRUE': 35,     # +2 bytes: address
    'JMP_FALSE': 36,    # +2 bytes: address
    'GET_GLOBAL': 37,   # +1 byte: name const index
    'SET_GLOBAL': 38,   # +1 byte: name const index
    'GET_LOCAL': 39,    # +1 byte: slot index
    'SET_LOCAL': 40,    # +1 byte: slot index
    'NEW_TABLE': 41,
    'GET_TABLE': 42,
    'SET_TABLE': 43,
    'CALL': 44,         # +1 byte: num args
    'CALL_NATIVE': 45,  # +1 byte: num args + name const index (2 bytes total)
    'RETURN': 46,
    'CALL_MULTI': 47,   # +1 byte: num args, +1 byte: nresults (3字节总长)
                        #   修复: 旧版在编译后向字节码中间“插入” nresults 字节，
                        #   会把已发射跳转指令的回填位置整体后移 → 跳转写坏。
                        #   现改为: 多赋值上下文预先发射 CALL_MULTI(占位nresults=1)，
                        #   事后对表达式末尾的调用原位回填，不移动任何字节。
    # ---- V8.5: TFORLOOP 蹦床机制 (模拟 Lua 5.1 寄存器机语义) ----
    'TFORLOOP': 48,     # +3 bytes: A(1) + 目标地址(2, LE)。
                        #   语义: 若 R[A+1] 非空(≠nil) 则 R[A]=R[A+1] 并跳转 sBx。
                        #   注意 false 非空也会跳 → 必须由 TEST 先行守卫。
    'TEST': 49,         # +2 bytes: A(1) + C(1)。
                        #   语义: 若 truthy(R[A]) == truthy(C) 则跳过紧随的 TFORLOOP
                        #   (定长4字节)。混淆器保证 TEST 后必紧跟 TFORLOOP。
    'NOT': 50,          # +2 bytes: A(1) + B(1)。语义: R[A] = not R[B] (严格布尔)。
                        #   用于 NOT 指令链维护 R245-R248 布尔状态寄存器。
    # ---- V8.6: EQ 条件跳过变体 (多态垃圾填充的载体) ----
    'EQ_SKIP': 51,      # +4 bytes: A(1) + B(1) + C(1) + N(1)。
                        #   寄存器机语义 (Lua 5.1 EQ 风格, 不动栈):
                        #   若 (R[A]==R[B]) == (C~=0) 则跳过紧随的 N 字节垃圾段。
                        #   混淆器保证比较恒真且 C=1 → 垃圾永不执行。
}

# 改进: 指令操作数大小映射 (用于垃圾指令插入时的字节码扫描)
OP_OPERAND_SIZES = {
    'NOP': 0, 'HALT': 0, 'PUSH_NIL': 0, 'PUSH_TRUE': 0, 'PUSH_FALSE': 0,
    'POP': 0, 'DUP': 0, 'SWAP': 0,
    'ADD': 0, 'SUB': 0, 'MUL': 0, 'DIV': 0, 'MOD': 0, 'POW': 0, 'UNM': 0,
    'BAND': 0, 'BOR': 0, 'BXOR': 0, 'BNOT': 0, 'LSHIFT': 0, 'RSHIFT': 0,
    'EQ': 0, 'NE': 0, 'LT': 0, 'LE': 0, 'GT': 0, 'GE': 0,
    'LAND': 0, 'LOR': 0, 'LNOT': 0,
    'CONCAT': 0, 'LEN': 0,
    'NEW_TABLE': 0, 'GET_TABLE': 0, 'SET_TABLE': 0,
    'RETURN': 0,
    'PUSH_NUM': 1, 'CALL': 1, 'CALL_NATIVE': 1, 'CALL_MULTI': 2,
    'PUSH_CONST': 2, 'JMP': 2, 'JMP_TRUE': 2, 'JMP_FALSE': 2,
    'GET_GLOBAL': 2, 'SET_GLOBAL': 2, 'GET_LOCAL': 2, 'SET_LOCAL': 2,
    'NOT': 2, 'TEST': 2, 'TFORLOOP': 3, 'EQ_SKIP': 4,
}


def randomize_opcodes(base_op=None, seed=None):
    """随机打乱 opcode 编号，返回新的 {name: number} 映射。
    改进: 使用非连续随机值 (0-255范围), 而非顺序 0,1,2,...
    使攻击者无法通过编号顺序推断 opcode 含义, 也无法复用之前的分析结果
    
    base_op: 基础 opcode 名称集合（默认 OP）
    seed: 可选随机种子，用于可复现的随机化
    """
    if base_op is None:
        base_op = OP
    names = list(base_op.keys())
    rng = random.Random(seed) if seed is not None else random

    # 从 0-255 范围随机选取不重复的 opcode 值 (而非顺序 0,1,2,...)
    pool = list(range(256))
    rng.shuffle(pool)
    values = pool[:len(names)]
    rng.shuffle(names)

    return {name: values[i] for i, name in enumerate(names)}


# ============================================================
# 分散反调试检测类型 (嵌入 VM 分段函数, 防 patch 单点绕过)
# 每种检测使用不同的方法和错误码, 分散到不同分段函数中
# 攻击者必须 patch 所有检测点才能完全绕过保护
# ============================================================
AD_CHECK_TYPES = [
    # (id, lua_code) — 代码无前导缩进, 由 generate_vm_interpreter 统一缩进
    ('A', 'if debug and debug.gethook then\n  local _hs, _hf = pcall(debug.gethook)\n  if _hs and type(_hf) == "function" then if _PEN then _PEN() end error("eA") end\nend'),
    # 修复: 仅载入窗口内检测 (前5M条VM指令), 长时间挂机脚本不再被误杀\n    ('B', 'if _icnt < 5000000 and _vm_t0 > 0 and os and os.clock then\n  local _td = os.clock() - _vm_t0\n  if _td > 60 then if _PEN then _PEN() end error("eB") end\nend'),
    ('C', 'if debug and debug.getinfo then\n  local _is, _di = pcall(debug.getinfo, 1)\n  if not _is or type(_di) ~= "table" then if _PEN then _PEN() end error("eC") end\nend'),
    ('D', 'local _ps, _p1, _p2 = pcall(function() return 7, 8 end)\nif not _ps or _p1 ~= 7 or _p2 ~= 8 then if _PEN then _PEN() end error("eD") end'),
    # 修复: GG环境自带全局较多, 60阈值易误杀, 提高到100\n    ('E', 'local _gc = 0\nfor _ in pairs(_G) do _gc = _gc + 1 end\nif _gc > 100 then if _PEN then _PEN() end error("eE") end'),
    ('F', 'if _ad_canary ~= 1701 then if _PEN then _PEN() end error("eF") end'),
    ('G', 'if tostring(123) ~= "123" or tonumber("456") ~= 456 then if _PEN then _PEN() end error("eG") end'),
    ('H', 'local _t1 = {}\nif not rawequal(_t1, _t1) then if _PEN then _PEN() end error("eH") end'),
]

# ============================================================
# V8.6: API 调用名集合 — 全部以 14 字节循环密钥 XOR 密文存储,
# 运行时经元表 __index 逐字节还原后查表转发 (含 gg 根对象名)
# ============================================================
API_NAMES = frozenset({
    'gg',
    'searchNumber', 'searchNumberFuzzy', 'getResults', 'getResultsCount',
    'setValues', 'addListItems', 'removeListItems', 'getListItems',
    'clearList', 'editAll', 'toast', 'alert', 'prompt', 'choice', 'sleep',
    'setSpeed', 'getSpeed', 'processInfo', 'getProcessInfo',
    'isProcessActive', 'copyText', 'openLink', 'getFile', 'saveFile',
    'doFile', 'getRangesList', 'getInfo', 'setVisible', 'getVisible',
    'setRanges', 'getRanges', 'setAutoUpdateList', 'getAutoUpdateList',
    'makeRequest', 'multiChoice', 'buildNumber', 'skipModsCheck',
    'loadFunction', 'loadFile', 'refineNumber', 'refineAddress',
    'getValues', 'clearResults', 'startLua', 'extMemoryHint',
    'getInternalSharedMemory', 'getSelectorValues', 'getSelectedDirect',
    'getTime',
})


def _api_cipher_lua(name, key):
    """API 名 → 14 字节循环密钥 XOR 密文 → Lua 转义字符串字面量 (\\ddd 十进制转义,
    避免在 utf-8 输出文件中出现 >127 原始字节)"""
    cb = bytes([b ^ key[i % len(key)] for i, b in enumerate(name.encode('utf-8'))])
    return '"' + ''.join('\\%d' % b for b in cb) + '"'


# ============================================================
# 词法分析器 (Tokenizer)
# ============================================================

TOKEN_TYPES = [
    ('LONG_COMMENT3', r'--\[={3}\[.*?\]={3}\]'),
    ('LONG_COMMENT2', r'--\[={2}\[.*?\]={2}\]'),
    ('LONG_COMMENT1', r'--\[={1}\[.*?\]={1}\]'),
    ('LONG_COMMENT0', r'--\[\[.*?\]\]'),
    ('COMMENT2', r'--[^\n]*'),
    ('LONG_STRING3', r'\[={3}\[.*?\]={3}\]'),
    ('LONG_STRING2', r'\[={2}\[.*?\]={2}\]'),
    ('LONG_STRING1', r'\[={1}\[.*?\]={1}\]'),
    ('LONG_STRING0', r'\[\[.*?\]\]'),
    ('NUMBER',   r'0[xX][0-9a-fA-F]+|\d+\.?\d*([eE][+-]?\d+)?|\.\d+([eE][+-]?\d+)?'),
    ('STRING',   r'"([^"\\]|\\.)*"'),
    ('STRING_S', r"'([^'\\]|\\.)*'"),
    ('DOT3',     r'\.\.\.'),
    ('DOT2',     r'\.\.'),
    ('DOT',      r'\.'),
    ('EQ_OP',    r'=='),
    ('NE_OP',    r'~='),
    ('LE_OP',    r'<='),
    ('GE_OP',    r'>='),
    ('LT_OP',    r'<'),
    ('GT_OP',    r'>'),
    ('ASSIGN',   r'='),
    ('LBRACE',   r'\{'),
    ('RBRACE',   r'\}'),
    ('LPAREN',   r'\('),
    ('RPAREN',   r'\)'),
    ('LBRACK',   r'\['),
    ('RBRACK',   r'\]'),
    ('COMMA',    r','),
    ('SEMI',     r';'),
    ('COLON',    r':'),
    ('PLUS',     r'\+'),
    ('MINUS',    r'-'),
    ('MULT',     r'\*'),
    ('DIV',      r'/'),
    ('MOD',      r'%'),
    ('POW',      r'\^'),
    ('LEN',      r'#'),
    ('AND',      r'and\b'),
    ('BREAK',    r'break\b'),
    ('DO',       r'do\b'),
    ('ELSE',     r'else\b'),
    ('ELSEIF',   r'elseif\b'),
    ('END',      r'end\b'),
    ('FALSE',    r'false\b'),
    ('FOR',      r'for\b'),
    ('FUNCTION', r'function\b'),
    ('GOTO',     r'goto\b'),
    ('IF',       r'if\b'),
    ('IN',       r'in\b'),
    ('LOCAL',    r'local\b'),
    ('NIL',      r'nil\b'),
    ('NOT',      r'not\b'),
    ('OR',       r'or\b'),
    ('REPEAT',   r'repeat\b'),
    ('RETURN',   r'return\b'),
    ('THEN',     r'then\b'),
    ('TRUE',     r'true\b'),
    ('UNTIL',    r'until\b'),
    ('WHILE',    r'while\b'),
    ('IDENT',    r'[a-zA-Z_][a-zA-Z_0-9]*'),
    ('NEWLINE',  r'\n'),
    ('SKIP',     r'[ \t\r]+'),
]

TOKEN_RE = re.compile('|'.join(f'(?P<{n}>{p})' for n, p in TOKEN_TYPES), re.DOTALL)

# 修复: Lua 字符串转义解码 — 旧版只支持 \n \t \\ \" \',
# 含 \r \xNN \\ddd 等常见转义的脚本会得到错误的常量内容
_UNESCAPE_RE = re.compile(r'\\(x[0-9a-fA-F]{1,2}|[0-9]{1,3}|[abfnrtv\\"\']|z[ \t\r\n]*|\n)')
_UNESCAPE_MAP = {'a': '\a', 'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r',
                 't': '\t', 'v': '\v', '\\': '\\', '"': '"', "'": "'"}

def _unescape_str(s):
    def _repl(m):
        e = m.group(1)
        if e[0] == 'x':
            return chr(int(e[1:], 16))
        if e[0].isdigit():
            return chr(int(e, 10) & 0xFF)
        if e[0] == 'z':
            return ''
        if e == '\n':
            return '\n'
        return _UNESCAPE_MAP.get(e, e)
    return _UNESCAPE_RE.sub(_repl, s)

class Tokenizer:
    def __init__(self, source):
        self.source = source
        self.tokens = []
        self.pos = 0
        self._tokenize()

    def _tokenize(self):
        for m in TOKEN_RE.finditer(self.source):
            kind = m.lastgroup
            value = m.group()
            if kind in ('SKIP', 'NEWLINE', 'LONG_COMMENT0', 'LONG_COMMENT1', 'LONG_COMMENT2', 'LONG_COMMENT3', 'COMMENT2'):
                continue
            if kind.startswith('LONG_STRING'):
                # 提取长字符串内容: [[content]] 或 [==[content]==]
                # 找到开头 [=*[ 的长度
                bracket_start = value.find('[', 0)
                eq_count = 0
                i = bracket_start + 1
                while i < len(value) and value[i] == '=':
                    eq_count += 1
                    i += 1
                # i 现在指向第二个 [
                content_start = i + 1  # 跳过第二个 [
                content_end = len(value) - (eq_count + 2)  # 去掉 ]=*[ 
                val = value[content_start:content_end]
                # Lua 规范: 长字符串首个换行符被忽略
                if val.startswith('\n'):
                    val = val[1:]
                elif val.startswith('\r\n'):
                    val = val[2:]
                self.tokens.append(('STRING', val))
            elif kind == 'STRING':
                val = _unescape_str(value[1:-1])
                self.tokens.append(('STRING', val))
            elif kind == 'STRING_S':
                val = _unescape_str(value[1:-1])
                self.tokens.append(('STRING', val))
            elif kind == 'NUMBER':
                if value.lower().startswith('0x'):
                    self.tokens.append(('NUMBER', int(value, 16)))
                elif '.' in value or 'e' in value.lower():
                    self.tokens.append(('NUMBER', float(value)))
                else:
                    self.tokens.append(('NUMBER', int(value)))
            elif kind == 'IDENT':
                self.tokens.append(('IDENT', value))
            else:
                self.tokens.append((kind, value))
        self.tokens.append(('EOF', ''))

    def peek(self, offset=0):
        if self.pos + offset < len(self.tokens):
            return self.tokens[self.pos + offset]
        return ('EOF', '')

    def consume(self):
        tok = self.tokens[self.pos]
        self.pos += 1
        return tok

    def expect(self, kind):
        tok = self.consume()
        if tok[0] != kind:
            raise SyntaxError(f"Expected {kind}, got {tok[0]} ({tok[1]})")
        return tok

# ============================================================
# 语法分析器 + 代码生成器 (Compiler)
# ============================================================

class LuaCompiler:
    def __init__(self, source, op_map=None, cp_key=0,
                 enable_tfor=True, enable_const_shuffle=True,
                 str_map=None, api_key=None):
        self.tok = Tokenizer(source)
        self.op_map = op_map if op_map is not None else OP
        self.cp_key = cp_key    # 改进: 常量池字符串加密密钥
        self.enable_tfor = enable_tfor          # V8.5: TFORLOOP 蹦床控制流混淆
        self.enable_const_shuffle = enable_const_shuffle  # V8.5: 常量乱序
        # V8.6: 双层字符串保护 — 内层字符映射表 (M[存储字节]=明文字节, 256双射置换)
        self.str_map = str_map
        if str_map is not None:
            self.str_map_inv = [0] * 256
            for _si in range(256):
                self.str_map_inv[str_map[_si]] = _si
        else:
            self.str_map_inv = None
        # V8.6: API 调用名 14 字节循环密钥 XOR (常量表密文存储)
        self.api_key = list(api_key) if api_key else None
        self._api_consts = set()   # 标记为 API 密文的常量索引
        self._last_base = None     # compile_primary 刚产出的基对象 ('global', name)
        self.bytecode = []
        self.constants = []      # 常量池
        self.const_map = {}      # 常量 -> 索引
        self.local_scope = [{}]  # 局部变量作用域栈
        self.local_count = 0
        self.break_stack = []    # break 跳转地址栈
        self.functions = []      # 函数列表 [ {bytecode, num_params, name_idx} ]
        self.func_id = 0         # 当前函数ID (0=主函数)
        # 多返回值上下文: 在多目标赋值/多局部声明的右侧表达式编译时置 True,
        # 使 postfix 调用直接发射 CALL_MULTI(占位 nresults=1), 事后原位回填,
        # 不再需要向已发射字节码中间插入字节 (旧实现的致命缺陷)
        self.multi_call_ctx = False
        # opcode值 → 操作数大小 (随机化 op_map 后无法从值直接推断, 需此映射)
        self._size_of = {}
        for _n, _s in OP_OPERAND_SIZES.items():
            _v = self.op_map.get(_n)
            if _v is not None:
                self._size_of[_v] = _s
        # TFORLOOP 蹦床混淆统计 (由 tforloop_obfuscate 填充)
        self.tfor_stats = {'functions': 0, 'transformed': 0, 'blocks': 0,
                           'tramps': 0, 'decoys': 0, 'bc_in': 0, 'bc_out': 0,
                           'heads': 0}

    def add_const(self, value):
        key = (type(value).__name__, value)
        if key in self.const_map:
            return self.const_map[key]
        idx = len(self.constants)
        self.constants.append(value)
        self.const_map[key] = idx
        return idx

    # ---- V8.6: API 调用名常量 (14 字节循环密钥 XOR 密文存储) ----
    def _name_const(self, name):
        """全局名/API名 取常量索引; API 名打上密文标记, 序列化时逐字节异或 14 字节循环密钥"""
        idx = self.add_const(name)
        if self.api_key and name in API_NAMES:
            self._api_consts.add(idx)
        return idx

    def _api_xor_bytes(self, data):
        """14 字节循环密钥逐字节异或"""
        k = self.api_key
        return bytes([b ^ k[i % len(k)] for i, b in enumerate(data)])

    def _stream_xor(self, encoded, c_idx):
        """V8.6 外层: 链式流式 XOR — 每字节密钥依赖 (基值 + 前一密文字节 + 位置),
        攻击者改动任意一个密文字节即导致后续全部解密错位 (自校验扩散)"""
        if not self.cp_key:
            return encoded
        base = (self.cp_key * 31 + c_idx * 17 + 183) % 256
        out = bytearray()
        prev = 0
        for j, b in enumerate(encoded, 1):
            cb = b ^ ((base + prev * 3 + j) % 256)
            out.append(cb)
            prev = cb
        return bytes(out)

    def emit(self, op, *operands):
        """发射指令到当前函数的字节码"""
        self.functions[self.func_id]['bytecode'].append(op)
        for o in operands:
            self.functions[self.func_id]['bytecode'].append(o)


    def emit_u16(self, op, value):
        """发射指令 + 2字节操作数 (小端序)"""
        bc = self.functions[self.func_id]['bytecode']
        bc.append(op)
        bc.append(value & 0xFF)
        bc.append((value >> 8) & 0xFF)
    def emit_jmp(self, op):
        """发射跳转指令，返回需要回填的地址位置"""
        self.emit(op, 0, 0)
        return len(self.functions[self.func_id]['bytecode']) - 2

    def patch_jmp(self, addr_pos):
        """回填跳转地址为当前位置"""
        bc = self.functions[self.func_id]['bytecode']
        target = len(bc)
        bc[addr_pos] = target & 0xFF
        bc[addr_pos + 1] = (target >> 8) & 0xFF

    def current_pc(self):
        return len(self.functions[self.func_id]['bytecode'])

    def push_scope(self):
        self.local_scope.append({})

    def pop_scope(self):
        scope = self.local_scope.pop()
        self.local_count -= len(scope)

    def add_local(self, name):
        if name in self.local_scope[-1]:
            return self.local_scope[-1][name]
        slot = self.local_count
        self.local_scope[-1][name] = slot
        self.local_count += 1
        return slot

    def find_local(self, name):
        for scope in reversed(self.local_scope):
            if name in scope:
                return scope[name]
        return None

    def new_function(self, name=""):
        """创建新函数，返回函数ID"""
        fid = len(self.functions)
        self.functions.append({
            'bytecode': [],
            'num_params': 0,
            'name_idx': self.add_const(name) if name else 0,
            'locals_base': self.local_count,
        })
        return fid

    # ---- 编译入口 ----
    def compile(self):
        # 初始化主函数
        self.new_function("__main__")
        self.compile_chunk()
        self.emit(self.op_map['PUSH_NIL'])
        self.emit(self.op_map['RETURN'])
        # 改进: 编译后插入垃圾指令 (增加逆向复杂度)
        self.insert_junk()
        # V8.5: TFORLOOP 蹦床控制流混淆 (R245-R248 布尔状态寄存器)
        self.tforloop_obfuscate()
        # V8.5: 常量乱序 (常量池随机洗牌 + 全量索引重映射)
        self.shuffle_constants()
        return self

    # ---- 改进: 垃圾指令插入 ----
    def insert_junk(self, rng=None, density=0.06):
        """在不改变程序语义的前提下, 随机插入NOP指令增加逆向复杂度。
        自动调整所有跳转目标。"""
        if rng is None:
            rng = random

        nop_op = self.op_map['NOP']

        # 构建操作数大小查找表
        op_operand_sizes = {}
        for name, size in OP_OPERAND_SIZES.items():
            if name in self.op_map:
                op_operand_sizes[self.op_map[name]] = size

        # 查找跳转指令的opcode
        jmp_op = self.op_map.get('JMP')
        jmp_true_op = self.op_map.get('JMP_TRUE')
        jmp_false_op = self.op_map.get('JMP_FALSE')
        jmp_ops = {jmp_op, jmp_true_op, jmp_false_op}

        for func in self.functions:
            bc = func['bytecode']
            if len(bc) < 10:
                continue  # 太短的函数跳过

            # 扫描所有指令边界和跳转地址
            boundaries = [0]  # 函数起始
            jump_addrs = []  # [(addr_field_pos, target)]

            i = 0
            while i < len(bc):
                op = bc[i]
                size = op_operand_sizes.get(op, 0)
                boundaries.append(i)  # 指令起始位置

                if op in jmp_ops:
                    target = bc[i + 1] + bc[i + 2] * 256
                    jump_addrs.append([i + 1, target])  # addr field at i+1

                i += 1 + size

            # 随机选择插入点
            n_insert = max(1, int(len(boundaries) * density))
            n_insert = min(n_insert, len(boundaries) - 1)  # 不在最后插入
            insert_points = sorted(rng.sample(boundaries[:-1], n_insert), reverse=True)

            # 从后往前插入NOP, 同时调整跳转目标
            for pos in insert_points:
                bc.insert(pos, nop_op)
                for ja in jump_addrs:
                    if ja[0] >= pos:
                        ja[0] += 1  # 地址字段位置偏移
                    if ja[1] >= pos:
                        ja[1] += 1  # 跳转目标偏移

            # 重写跳转目标
            for addr_pos, target in jump_addrs:
                bc[addr_pos] = target & 0xFF
                bc[addr_pos + 1] = (target >> 8) & 0xFF

    # ============================================================
    # V8.5: TFORLOOP 蹦床控制流混淆 + 常量乱序
    # ============================================================
    # 原理 (模拟 Lua 5.1 寄存器机语义, R[K] = VM 的 local slot K):
    #   TFORLOOP A sBx: 若 R[A+1] 非空(≠nil) 则 R[A]=R[A+1] 并跳转 sBx
    #                   (注意 false 非空也会跳, 必须由 TEST 先行守卫)
    #   TEST A C:       若 truthy(R[A]) == truthy(C) 则跳过紧随的 TFORLOOP(定长4字节)
    #   NOT A B:        R[A] = not R[B] (严格布尔, nil/false→true 其余→false)
    # 混淆器用 NOT/TEST 指令链维护 R245-R248 四个布尔状态寄存器,
    # 将真实控制流改写为条件蹦床链; 无条件跳转以 EQ+TFORLOOP 等价替换;
    # 基本块乱序布局 + 多级蹦床 + 诱饵蹦床 → 线性阅读反汇编完全不可读。
    # 约束: 寄存器编号即 local slot, 函数内最高槽位必须 < 244 (R244 为蹦床副作用暂存)。

    def _disasm(self, bc):
        """线性反汇编: 返回 [(pos, op_val, operand_size), ...], 非法序列返回 None"""
        size_of = self._size_of
        instrs = []
        i = 0
        n = len(bc)
        while i < n:
            op = bc[i]
            sz = size_of.get(op)
            if sz is None or i + 1 + sz > n:
                return None
            instrs.append((i, op, sz))
            i += 1 + sz
        return instrs

    # ---- 蹦床发射辅助 (全部栈平衡, 不破坏原程序栈) ----
    def _tfor_clear(self, r):
        """R[r] = false (PUSH_FALSE + SET_LOCAL + POP)"""
        om = self.op_map
        return [om['PUSH_FALSE'], om['SET_LOCAL'], r & 0xFF, (r >> 8) & 0xFF, om['POP']]

    def _tfor_seq_uncond(self, ref, rng):
        """EQ+TFORLOOP 等价替换 JMP → ref。
        先用 PUSH_{TRUE/FALSE}+SET_LOCAL 固定 R[src] (杜绝 NaN 比较陷阱),
        再 EQ(src==src 恒真) 写状态位, TEST 守卫后 TFORLOOP 跳转。"""
        om = self.op_map
        regs = (245, 246, 247, 248)
        src = rng.choice(regs)
        dst = rng.choice([r for r in regs if r != src])
        items = []
        items.append(om['PUSH_TRUE'] if rng.random() < 0.5 else om['PUSH_FALSE'])
        items += [om['SET_LOCAL'], src & 0xFF, (src >> 8) & 0xFF]
        items.append(om['POP'])
        items += [om['GET_LOCAL'], src & 0xFF, (src >> 8) & 0xFF]
        items += [om['GET_LOCAL'], src & 0xFF, (src >> 8) & 0xFF]
        items.append(om['EQ'])
        items += [om['SET_LOCAL'], dst & 0xFF, (dst >> 8) & 0xFF]
        items.append(om['POP'])
        for r in regs:
            if r != src and r != dst:
                items += self._tfor_clear(r)
        if rng.random() < 0.4:
            items.append(om['NOP'])
        items += [om['TEST'], dst, 0]
        items.append(('TFOR', dst - 1, ref))
        return items

    def _tfor_seq_cond(self, kind, ref_t, ref_f, rng):
        """条件跳转蹦床链 (NOT/TEST 指令链维护 R245-R248)。
        kind='jtrue': 真值→ref_t, 假值→ref_f; kind='jfalse': 假值→ref_t, 真值→ref_f。
        SET_LOCAL 取条件 → 双重 NOT 链规范化为严格布尔 → TEST/TFORLOOP 双态分发:
        蹦床链两个 TFORLOOP 必有一个命中, 不存在落空路径。"""
        om = self.op_map
        regs = (245, 246, 247, 248)
        c = rng.choice(regs)
        i = rng.choice([r for r in regs if r != c])
        others = [r for r in regs if r != c and r != i]
        items = [om['SET_LOCAL'], c & 0xFF, (c >> 8) & 0xFF, om['POP']]
        # NOT 指令链: R[i]=not R[c]; R[c]=not R[i] (双重取反 → 严格布尔)
        items += [om['NOT'], i, c]
        items += [om['NOT'], c, i]
        for r in others:
            items += self._tfor_clear(r)
        if rng.random() < 0.4:
            items.append(om['NOP'])
        if kind == 'jtrue':
            if rng.random() < 0.5:
                items += [om['TEST'], c, 0] + [('TFOR', c - 1, ref_t)]
                items += [om['TEST'], i, 0] + [('TFOR', i - 1, ref_f)]
            else:
                items += [om['TEST'], i, 1] + [('TFOR', i - 1, ref_t)]
                items += [om['TEST'], c, 1] + [('TFOR', c - 1, ref_f)]
        else:
            if rng.random() < 0.5:
                items += [om['TEST'], i, 0] + [('TFOR', i - 1, ref_t)]
                items += [om['TEST'], c, 0] + [('TFOR', c - 1, ref_f)]
            else:
                items += [om['TEST'], c, 1] + [('TFOR', c - 1, ref_t)]
                items += [om['TEST'], i, 1] + [('TFOR', i - 1, ref_f)]
        # 死代码装饰: 蹦床链封闭后不可达, 仅增加静态噪音
        if rng.random() < 0.5:
            items += [om['NOT'], rng.choice(regs), rng.choice(regs)]
        return items

    def _tfor_decoy(self, rng):
        """诱饵蹦床块: 不可达 (无任何入口指向), 线性阅读时与真实块无法区分。
        内容: 噪声指令 + 指向自身的 EQ+TFORLOOP 死循环陷阱。"""
        om = self.op_map
        items = []
        for _ in range(rng.randint(1, 4)):
            items.append(om['NOP'])
        regs = (245, 246, 247, 248)
        for _ in range(rng.randint(1, 3)):
            items += [om['NOT'], rng.choice(regs), rng.choice(regs)]
        if rng.random() < 0.5:
            items.append(om['PUSH_TRUE'])
            items.append(om['POP'])
        return items

    # ---- V8.6: 多态垃圾填充 — 函数头部固定模式 ----
    # (TFORLOOP, TFORLOOP, EQ_SKIP, 垃圾指令..., NOT...)
    # 头部两个 TFORLOOP 的 R[A+1] 均为状态寄存器 (函数入口必为 nil → 永不跳转);
    # EQ_SKIP 寄存器机比较 R[A]==R[B] (入口均为 nil → 恒真) 且 C=1 →
    # 条件跳过语义必然触发, 紧随的 N 字节多态垃圾永不执行;
    # NOT 链对状态寄存器做噪声运算 (蹦床链每次读取前都会重写, 不影响语义)。
    _HEAD_JUNK_OPS = ('ADD', 'SUB', 'MUL', 'DIV', 'MOD', 'POW', 'UNM',
                      'BAND', 'BOR', 'BXOR', 'BNOT', 'LSHIFT', 'RSHIFT',
                      'EQ', 'NE', 'LT', 'LE', 'GT', 'GE', 'LAND', 'LOR',
                      'LNOT', 'CONCAT', 'LEN', 'NEW_TABLE', 'GET_TABLE',
                      'SET_TABLE', 'DUP', 'SWAP', 'PUSH_TRUE', 'PUSH_FALSE',
                      'PUSH_NIL', 'POP', 'NOP')

    def _tfor_head(self, rng):
        """生成函数头多态垃圾填充序列 (栈平衡: 全寄存器机指令, 不碰数据栈)"""
        om = self.op_map
        regs = (245, 246, 247, 248)
        items = []
        # 1) 双 TFORLOOP (入口 R[A+1]=nil → 永不触发; 指向函数末尾哨兵, 若被篡改触发则优雅停机)
        for _ra in rng.sample((244, 245, 246, 247), 2):
            items.append(('TFOR', _ra, ('end',)))
        # 2) EQ_SKIP: R[A]==R[B] 恒真 (入口全 nil) + C=1 → 必然跳过垃圾段
        junk_ops = [om[rng.choice(self._HEAD_JUNK_OPS)] for _ in range(rng.randint(1, 3))]
        items += [om['EQ_SKIP'], rng.choice(regs), rng.choice(regs), 1, len(junk_ops)]
        items += junk_ops
        # 3) NOT 噪声链 (蹦床寄存器, 每次蹦床序列读取前都会重写)
        for _ in range(rng.randint(1, 3)):
            items += [om['NOT'], rng.choice(regs), rng.choice(regs)]
        if rng.random() < 0.5:
            items.append(om['NOP'])
        return items

    def tforloop_obfuscate(self, rng=None):
        """对所有函数执行 TFORLOOP 蹦床控制流改写。
        单函数失败 (非法序列/槽位冲突/地址超限) 时自动回退原字节码, 保证安全。"""
        if rng is None:
            rng = random
        if not getattr(self, 'enable_tfor', True):
            return
        need = {'JMP', 'JMP_TRUE', 'JMP_FALSE', 'TFORLOOP', 'TEST', 'NOT',
                'SET_LOCAL', 'GET_LOCAL', 'PUSH_FALSE', 'PUSH_TRUE', 'POP',
                'EQ', 'NOP', 'EQ_SKIP'}
        if not need.issubset(self.op_map.keys()):
            return
        st = self.tfor_stats
        for func in self.functions:
            st['functions'] += 1
            st['bc_in'] += len(func['bytecode'])
            new_bc = self._tfor_function(func['bytecode'], rng)
            if new_bc is not None:
                func['bytecode'] = new_bc
                st['transformed'] += 1
                st['bc_out'] += len(new_bc)
            else:
                st['bc_out'] += len(func['bytecode'])

    def _tfor_function(self, bc, rng):
        """单函数 TFORLOOP 蹦床改写。返回新字节码列表; 无法安全改写返回 None。"""
        om = self.op_map
        instrs = self._disasm(bc)
        if not instrs:
            return None
        n_instr = len(instrs)
        pos2idx = {ins[0]: k for k, ins in enumerate(instrs)}
        func_len = len(bc)

        # ---- 寄存器安全检查: 该函数 local 槽位最高必须 < 244 ----
        get_local_v = om['GET_LOCAL']
        set_local_v = om['SET_LOCAL']
        for (pos, op, sz) in instrs:
            if op == get_local_v or op == set_local_v:
                if bc[pos + 1] + bc[pos + 2] * 256 >= 244:
                    return None

        jmp_v = om['JMP']
        jt_v = om['JMP_TRUE']
        jf_v = om['JMP_FALSE']
        ret_v = om['RETURN']
        halt_v = om['HALT']

        END = -1  # 函数末尾哨兵 (VM 中 pc 越界自动停机)

        # ---- 划分基本块: 指令0 / 跳转目标 / 每条跳转与 RETURN 之后均为 leader ----
        # (每条跳转后必须切块: 否则 junk NOP 可能使 JMP 滞留块中, 携带陈旧绝对目标)
        leaders = {0}
        raw_edges = []  # (instr_idx, kind, target_pos)
        for k, (pos, op, sz) in enumerate(instrs):
            if op == jmp_v:
                raw_edges.append((k, 'jmp', bc[pos + 1] + bc[pos + 2] * 256))
                if k + 1 < n_instr:
                    leaders.add(k + 1)
            elif op == jt_v or op == jf_v:
                raw_edges.append((k, 'jtrue' if op == jt_v else 'jfalse',
                                  bc[pos + 1] + bc[pos + 2] * 256))
                if k + 1 < n_instr:
                    leaders.add(k + 1)
            elif op == ret_v or op == halt_v:
                if k + 1 < n_instr:
                    leaders.add(k + 1)

        def tgt_block(pos):
            """跳转目标字节位置 → 基本块序号; 越界→'END'; 非法→None"""
            if pos >= func_len:
                return 'END'
            idx = pos2idx.get(pos)
            if idx is None:
                return None
            return lead2blk.get(idx)

        for (_k, _kind, _pos) in raw_edges:
            if _pos < func_len and _pos not in pos2idx:
                return None
            if _pos < func_len:
                leaders.add(pos2idx[_pos])

        sorted_leaders = sorted(leaders)
        n_blocks = len(sorted_leaders)
        lead2blk = {l: bi for bi, l in enumerate(sorted_leaders)}
        blocks = []
        for bi, l in enumerate(sorted_leaders):
            end = sorted_leaders[bi + 1] if bi + 1 < n_blocks else n_instr
            blocks.append({'i0': l, 'i1': end})

        # ---- 分析每个基本块的出口边 ----
        for bi, blk in enumerate(blocks):
            lpos, lop, lsz = instrs[blk['i1'] - 1]
            blk['kind'] = 'plain'
            blk['tgt'] = None
            blk['fall'] = bi + 1 if bi + 1 < n_blocks else None
            if lop == jmp_v:
                blk['kind'] = 'jmp'
                blk['tgt'] = tgt_block(bc[lpos + 1] + bc[lpos + 2] * 256)
            elif lop == jt_v or lop == jf_v:
                blk['kind'] = 'jtrue' if lop == jt_v else 'jfalse'
                blk['tgt'] = tgt_block(bc[lpos + 1] + bc[lpos + 2] * 256)
            elif lop == ret_v or lop == halt_v:
                blk['kind'] = 'term'
                blk['fall'] = None
            if blk['kind'] in ('jmp', 'jtrue', 'jfalse') and blk['tgt'] is None:
                return None  # 目标无法解析 → 放弃该函数 (回退)

        # ---- 构建节点: 真实块 + 多级蹦床 + 诱饵蹦床 ----
        # ref 三种形态: ('blk', 块号) | ('end',) | ('node', 节点号)
        # 块号在布局阶段经 block_node[] 间接解析 → 允许先建蹦床后建块
        nodes = []        # node_id → items (int 字节 或 ('TFOR', A, ref) 标记)
        block_node = [None] * n_blocks  # 块号 → 节点号 (第二遍填充)

        def node_len(items):
            ln = 0
            for it in items:
                ln += 4 if isinstance(it, tuple) else 1
            return ln

        def new_node(items):
            nodes.append(items)
            return len(nodes) - 1

        def blk_ref(bidx):
            """块号 → 引用; 'END' → ('end',)"""
            if bidx == 'END':
                return ('end',)
            return ('blk', bidx)

        max_tramps = 2 * n_blocks + 16
        n_tramps = 0

        def chain_to(ref, depth_left):
            """为边随机创建 0-2 级中间蹦床 (EQ+TFORLOOP), 返回入口引用"""
            nonlocal n_tramps
            if depth_left <= 0 or n_tramps >= max_tramps:
                return ref
            r = rng.random()
            if r > 0.45:
                return ref
            n_tramps += 1
            nxt = chain_to(ref, depth_left - 1)
            tid = new_node(self._tfor_seq_uncond(nxt, rng))
            return ('node', tid)

        # ---- 块体字节提取 (剥离尾跳转, 由蹦床链替代) ----
        for bi, blk in enumerate(blocks):
            i0, i1 = blk['i0'], blk['i1']
            if blk['kind'] in ('jmp', 'jtrue', 'jfalse'):
                i1 -= 1
            body = []
            for k in range(i0, i1):
                pos, op, sz = instrs[k]
                body += bc[pos:pos + 1 + sz]
            blk['items'] = body

        # 第一遍: 为每条出口边规划入口引用 (蹦床节点即刻创建, 引用块号稍后解析)
        for bi, blk in enumerate(blocks):
            kind = blk['kind']
            if kind == 'jmp':
                blk['entry'] = chain_to(blk_ref(blk['tgt']), 2)
            elif kind in ('jtrue', 'jfalse'):
                blk['entry_t'] = chain_to(blk_ref(blk['tgt']), 2)
                blk['entry_f'] = blk_ref(blk['fall']) if blk['fall'] is not None else ('end',)
            elif kind == 'plain':
                blk['entry'] = chain_to(blk_ref(blk['fall']), 2) if blk['fall'] is not None else None
            else:
                blk['entry'] = None

        # 第二遍: 生成真实块节点 (条件跳转的蹦床序列内联追加在块尾)
        # V8.12 修复: 头部多态垃圾独立成节点 (head_node), 仅函数真实入口可达。
        #   旧版 (V8.6~V8.11) 把头垃圾前缀进块 0 节点: 若 while/repeat/for 循环头
        #   位于函数偏移 0 (如 "local function f() while true do ... end end"),
        #   循环回边 TFORLOOP 直指头垃圾; 第二圈进入时蹦床状态寄存器 R[244..248]
        #   已被写为 true/false (非 nil) → 头部双 TFORLOOP 检测 R[A+1]~=nil 成立
        #   → 误触发 end 哨兵 → VM 静默停机 (真机表现为"返回菜单后脚本无声关闭")。
        #   现改为: ('blk',0) 引用一律解析到真实块体节点; 头垃圾尾部经专属蹦床
        #   (重写状态寄存器后 TFORLOOP) 进入块体, 语义与旧版入口路径等价。
        head_node = None
        for bi, blk in enumerate(blocks):
            items = blk['items']
            kind = blk['kind']
            if kind == 'jmp':
                items = items + self._tfor_seq_uncond(blk['entry'], rng)
            elif kind == 'jtrue':
                items = items + self._tfor_seq_cond('jtrue', blk['entry_t'], blk['entry_f'], rng)
            elif kind == 'jfalse':
                items = items + self._tfor_seq_cond('jfalse', blk['entry_t'], blk['entry_f'], rng)
            elif kind == 'plain' and blk.get('entry') is not None:
                items = items + self._tfor_seq_uncond(blk['entry'], rng)
            if bi == 0:
                # V8.6: 函数头部多态垃圾填充 (TFORLOOP,TFORLOOP,EQ_SKIP,垃圾,NOT...)
                # V8.12: 块体节点先建 (保证 ('blk',0) 解析到块体), 头节点随后建
                block_node[0] = new_node(items)
                head_node = new_node(self._tfor_head(rng)
                                     + self._tfor_seq_uncond(('blk', 0), rng))
                self.tfor_stats['heads'] += 1
            else:
                block_node[bi] = new_node(items)

        # ---- 诱饵蹦床块 (不可达, 仅供静态分析干扰) ----
        n_decoys = 0
        if n_blocks >= 4:
            for _ in range(rng.randint(2, 4)):
                d = new_node(self._tfor_decoy(rng))
                # 陷阱: EQ+TFORLOOP 指向诱饵块自身 (若被执行则死循环, 实际不可达)
                nodes[d] = nodes[d] + self._tfor_seq_uncond(('node', d), rng)
                n_decoys += 1

        # ---- 乱序布局: 头垃圾节点必须最先 (VM 从 pc=1 进入即头垃圾),
        #      块体节点由头尾专属蹦床跳入; 其余全部节点 (真实块/蹦床/诱饵) 随机排列 ----
        entry_node = block_node[0]
        rest = [nid for nid in range(len(nodes))
                if nid != entry_node and nid != head_node]
        rng.shuffle(rest)
        layout = [head_node, entry_node] + rest

        # ---- 布局定址 + 物化 (两遍: 先算偏移, 再回填 TFORLOOP 目标) ----
        offsets = {}
        cur = 0
        for nid in layout:
            offsets[nid] = cur
            cur += node_len(nodes[nid])
        total = cur
        if total > 65535:
            return None  # 2 字节目标地址溢出 → 回退

        def resolve(ref):
            if ref == ('end',):
                return total
            if ref[0] == 'blk':
                return offsets[block_node[ref[1]]]
            return offsets[ref[1]]

        tfor_v = om['TFORLOOP']
        out = []
        for nid in layout:
            for it in nodes[nid]:
                if isinstance(it, tuple):
                    _tag, ra, ref = it
                    t = resolve(ref)
                    if t > 65535:
                        return None
                    out += [tfor_v, ra, t & 0xFF, (t >> 8) & 0xFF]
                else:
                    out.append(it)

        # ---- V8.13 物化后自检: 任何显式边 (JMP/JMP_TRUE/JMP_FALSE/TFORLOOP) 的
        # 目标不得落在头垃圾区间 [0, head_len) 内 (raw==0 为头垃圾起点即 VM pc=1;
        # 0<raw<head_len 为头垃圾中段 — 两者均只允许 VM 隐式入口可达) ----
        # 头垃圾仅限 VM 隐式入口可达; 出现此类目标说明布局/回填回归 → 整函数回退保安全。
        # raw==total 为 end 哨兵 (越界优雅停机), 合法。
        _sz_of = self._size_of
        _head_len = offsets[head_node] + node_len(nodes[head_node])
        _ni = len(out)
        _pi = 0
        while _pi < _ni:
            _opv = out[_pi]
            _osz = _sz_of.get(_opv)
            if _osz is None or _pi + 1 + _osz > _ni:
                return None  # 非法序列 → 回退
            if _opv == jmp_v or _opv == jt_v or _opv == jf_v:
                _raw = out[_pi + 1] + out[_pi + 2] * 256
            elif _opv == tfor_v:
                _raw = out[_pi + 2] + out[_pi + 3] * 256
            else:
                _raw = None
            if _raw is not None and (_raw < _head_len or _raw > total):
                return None  # 落入头垃圾区间或越界 → 回退
            _pi += 1 + _osz

        # 统计
        self.tfor_stats['blocks'] += n_blocks
        self.tfor_stats['tramps'] += n_tramps
        self.tfor_stats['decoys'] += n_decoys
        return out

    def shuffle_constants(self, rng=None):
        """V8.5: 常量乱序 — 常量池随机洗牌, 全量重映射字节码中的常量索引。
        与每串位置密钥 (c_idx 参与密钥派生) 天然兼容: 两侧均按运行时序号取用。"""
        if rng is None:
            rng = random
        if not getattr(self, 'enable_const_shuffle', True):
            return
        n = len(self.constants)
        if n < 2:
            return
        perm = list(range(n))
        rng.shuffle(perm)
        old2new = [0] * n
        for new_i, old_i in enumerate(perm):
            old2new[old_i] = new_i
        self.constants = [self.constants[old_i] for old_i in perm]
        self.const_map = {(type(v).__name__, v): i for i, v in enumerate(self.constants)}
        # V8.6 修复: API 密文标记按索引存储, 常量洗牌后必须同步重映射,
        # 否则标记随机命中无关常量 (其明文被误加密) 而真正的 API 名漏加密
        self._api_consts = {old2new[i] for i in self._api_consts if 0 <= i < n}
        const_ops = {self.op_map['PUSH_CONST'], self.op_map['GET_GLOBAL'],
                     self.op_map['SET_GLOBAL']}
        for func in self.functions:
            bc = func['bytecode']
            instrs = self._disasm(bc)
            if instrs is None:
                continue
            for (pos, op, sz) in instrs:
                if op in const_ops:
                    idx = bc[pos + 1] + bc[pos + 2] * 256
                    if idx < n:
                        ni = old2new[idx]
                        bc[pos + 1] = ni & 0xFF
                        bc[pos + 2] = (ni >> 8) & 0xFF
            ni = func.get('name_idx', 0)
            if isinstance(ni, int) and 0 <= ni < n:
                func['name_idx'] = old2new[ni]

    # ---- 语句块 ----
    def compile_chunk(self):
        while True:
            kind = self.tok.peek()[0]
            if kind in ('EOF', 'END', 'ELSE', 'ELSEIF', 'UNTIL'):
                break
            self.compile_statement()

    # ---- 语句 ----
    def compile_statement(self):
        tok = self.tok.peek()
        kind = tok[0]

        if kind == 'IF':
            self.compile_if()
        elif kind == 'WHILE':
            self.compile_while()
        elif kind == 'FOR':
            self.compile_for()
        elif kind == 'REPEAT':
            self.compile_repeat()
        elif kind == 'DO':
            self.compile_do()
        elif kind == 'FUNCTION':
            self.compile_function()
        elif kind == 'LOCAL':
            self.compile_local()
        elif kind == 'RETURN':
            self.compile_return()
        elif kind == 'BREAK':
            self.compile_break()
        elif kind == 'SEMI':
            self.tok.consume()
        else:
            # 表达式语句（赋值或函数调用）
            self.compile_expr_statement()

    def compile_if(self):
        self.tok.expect('IF')
        end_jmps = []

        # if 条件
        self.compile_expr()
        self.tok.expect('THEN')
        false_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
        self.push_scope()
        self.compile_chunk()
        self.pop_scope()

        while self.tok.peek()[0] == 'ELSEIF':
            end_jmps.append(self.emit_jmp(self.op_map['JMP']))
            self.patch_jmp(false_jmp)
            self.tok.consume()  # elseif
            self.compile_expr()
            self.tok.expect('THEN')
            false_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
            self.push_scope()
            self.compile_chunk()
            self.pop_scope()

        if self.tok.peek()[0] == 'ELSE':
            end_jmps.append(self.emit_jmp(self.op_map['JMP']))
            self.patch_jmp(false_jmp)
            self.tok.consume()  # else
            self.push_scope()
            self.compile_chunk()
            self.pop_scope()
        else:
            self.patch_jmp(false_jmp)

        self.tok.expect('END')
        for jmp in end_jmps:
            self.patch_jmp(jmp)

    def compile_while(self):
        self.tok.expect('WHILE')
        start_pc = self.current_pc()
        self.compile_expr()
        self.tok.expect('DO')
        exit_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
        self.push_scope()
        self.break_stack.append([])
        self.compile_chunk()
        self.pop_scope()
        # 跳转回开始
        back_jmp = self.emit_jmp(self.op_map['JMP'])
        self.patch_jmp_addr(back_jmp, start_pc)
        self.patch_jmp(exit_jmp)
        # 处理 break
        break_jmps = self.break_stack.pop()
        for jmp in break_jmps:
            self.patch_jmp(jmp)
        self.tok.expect('END')

    def compile_repeat(self):
        self.tok.expect('REPEAT')
        self.push_scope()
        start_pc = self.current_pc()
        self.break_stack.append([])
        self.compile_chunk()
        self.tok.expect('UNTIL')
        self.compile_expr()
        # 条件为假时继续循环
        back_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
        self.patch_jmp_addr(back_jmp, start_pc)
        self.pop_scope()
        break_jmps = self.break_stack.pop()
        for jmp in break_jmps:
            self.patch_jmp(jmp)

    def compile_for(self):
        self.tok.expect('FOR')
        name_tok = self.tok.expect('IDENT')
        var_name = name_tok[1]
        next_tok = self.tok.peek()

        if next_tok[0] == 'ASSIGN':
            # Numeric for: for i = a, b, c do ... end
            self.tok.consume()  # =
            self.compile_expr()  # start
            self.tok.expect('COMMA')
            self.compile_expr()  # end
            if self.tok.peek()[0] == 'COMMA':
                self.tok.consume()
                self.compile_expr()  # step
            else:
                self.emit(self.op_map['PUSH_NUM'], 1)
            self.tok.expect('DO')

            self.push_scope()
            slot = self.add_local(var_name)

            # 栈: ..., start, end, step
            end_slot = self.local_count
            self.local_count += 1
            step_slot = self.local_count
            self.local_count += 1
            self.emit_u16(self.op_map['SET_LOCAL'], step_slot)  # step
            self.emit(self.op_map['POP'])
            self.emit_u16(self.op_map['SET_LOCAL'], end_slot)   # end
            self.emit(self.op_map['POP'])
            self.emit_u16(self.op_map['SET_LOCAL'], slot)       # start
            self.emit(self.op_map['POP'])

            start_pc = self.current_pc()
            # 检查: step > 0 ? i <= end : i >= end
            self.emit_u16(self.op_map['GET_LOCAL'], step_slot)
            self.emit(self.op_map['PUSH_NUM'], 0)
            self.emit(self.op_map['GT'])
            forward_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
            # step > 0: i <= end
            self.emit_u16(self.op_map['GET_LOCAL'], slot)
            self.emit_u16(self.op_map['GET_LOCAL'], end_slot)
            self.emit(self.op_map['LE'])
            end_check_jmp = self.emit_jmp(self.op_map['JMP'])
            self.patch_jmp(forward_jmp)
            # step < 0: i >= end
            self.emit_u16(self.op_map['GET_LOCAL'], slot)
            self.emit_u16(self.op_map['GET_LOCAL'], end_slot)
            self.emit(self.op_map['GE'])
            self.patch_jmp(end_check_jmp)

            exit_jmp = self.emit_jmp(self.op_map['JMP_FALSE'])
            self.break_stack.append([])
            self.compile_chunk()

            # i = i + step
            self.emit_u16(self.op_map['GET_LOCAL'], slot)
            self.emit_u16(self.op_map['GET_LOCAL'], step_slot)
            self.emit(self.op_map['ADD'])
            self.emit_u16(self.op_map['SET_LOCAL'], slot)
            self.emit(self.op_map['POP'])

            back_jmp = self.emit_jmp(self.op_map['JMP'])
            self.patch_jmp_addr(back_jmp, start_pc)
            self.patch_jmp(exit_jmp)

            break_jmps = self.break_stack.pop()
            for jmp in break_jmps:
                self.patch_jmp(jmp)

            self.pop_scope()
            self.tok.expect('END')

        elif next_tok[0] == 'COMMA' or next_tok[0] == 'IN':
            # Generic for: for k[, v] in iterator_expr do ... end
            var_names = [var_name]
            if next_tok[0] == 'COMMA':
                self.tok.consume()
                vname_tok = self.tok.expect('IDENT')
                var_names.append(vname_tok[1])
                self.tok.expect('IN')
            else:
                self.tok.consume()  # IN

            # 检测 ipairs(t) / pairs(t) 模式，特殊处理
            iter_tok = self.tok.peek()
            is_ipairs = (iter_tok[0] == 'IDENT' and iter_tok[1] == 'ipairs'
                         and self.tok.peek(1)[0] == 'LPAREN')
            is_pairs = (iter_tok[0] == 'IDENT' and iter_tok[1] == 'pairs'
                        and self.tok.peek(1)[0] == 'LPAREN')

            if is_ipairs:
                # for i[, v] in ipairs(t) do ... end
                # 编译为: local _t = t; local _i = 0
                #   while true do _i = _i + 1; local v = _t[_i]; if v == nil then break end; ... end
                self.tok.consume()  # ipairs
                self.tok.expect('LPAREN')
                self.compile_expr()  # push t
                self.tok.expect('RPAREN')
                self.tok.expect('DO')
                self.push_scope()

                tbl_slot = self.local_count
                self.local_count += 1
                self.emit_u16(self.op_map['SET_LOCAL'], tbl_slot)
                self.emit(self.op_map['POP'])

                i_slot = self.add_local(var_names[0])
                self.emit(self.op_map['PUSH_NUM'], 0)
                self.emit_u16(self.op_map['SET_LOCAL'], i_slot)
                self.emit(self.op_map['POP'])

                v_slot2 = None
                if len(var_names) > 1:
                    v_slot2 = self.add_local(var_names[1])

                start_pc = self.current_pc()
                # _i = _i + 1
                self.emit_u16(self.op_map['GET_LOCAL'], i_slot)
                self.emit(self.op_map['PUSH_NUM'], 1)
                self.emit(self.op_map['ADD'])
                self.emit_u16(self.op_map['SET_LOCAL'], i_slot)
                self.emit(self.op_map['POP'])
                # v = _t[_i]
                self.emit_u16(self.op_map['GET_LOCAL'], tbl_slot)
                self.emit_u16(self.op_map['GET_LOCAL'], i_slot)
                self.emit(self.op_map['GET_TABLE'])
                # 检查 v == nil
                self.emit(self.op_map['DUP'])
                self.emit(self.op_map['PUSH_NIL'])
                self.emit(self.op_map['EQ'])
                exit_jmp = self.emit_jmp(self.op_map['JMP_TRUE'])
                # 设置 v
                if v_slot2 is not None:
                    self.emit_u16(self.op_map['SET_LOCAL'], v_slot2)
                    self.emit(self.op_map['POP'])
                else:
                    self.emit(self.op_map['POP'])

                self.break_stack.append([])
                self.compile_chunk()

                back_jmp = self.emit_jmp(self.op_map['JMP'])
                self.patch_jmp_addr(back_jmp, start_pc)
                self.patch_jmp(exit_jmp)
                self.emit(self.op_map['POP'])

                break_jmps = self.break_stack.pop()
                for jmp in break_jmps:
                    self.patch_jmp(jmp)
                self.pop_scope()
                self.tok.expect('END')

            elif is_pairs:
                # for k[, v] in pairs(t) do ... end
                # 编译为: local _t = t; local _k = next(_t)
                #   while _k ~= nil do local v = _t[_k]; ...; _k = next(_t, _k) end
                self.tok.consume()  # pairs
                self.tok.expect('LPAREN')
                self.compile_expr()  # push t
                self.tok.expect('RPAREN')
                self.tok.expect('DO')
                self.push_scope()

                tbl_slot = self.local_count
                self.local_count += 1
                self.emit_u16(self.op_map['SET_LOCAL'], tbl_slot)
                self.emit(self.op_map['POP'])

                k_slot = self.add_local(var_names[0])
                v_slot2 = None
                if len(var_names) > 1:
                    v_slot2 = self.add_local(var_names[1])

                # _k = next(_t)
                next_idx = self.add_const('next')
                self.emit_u16(self.op_map['GET_GLOBAL'], next_idx)
                self.emit_u16(self.op_map['GET_LOCAL'], tbl_slot)
                self.emit(self.op_map['CALL'], 1)
                self.emit_u16(self.op_map['SET_LOCAL'], k_slot)
                self.emit(self.op_map['POP'])

                start_pc = self.current_pc()
                # 检查 _k == nil
                self.emit_u16(self.op_map['GET_LOCAL'], k_slot)
                self.emit(self.op_map['DUP'])
                self.emit(self.op_map['PUSH_NIL'])
                self.emit(self.op_map['EQ'])
                exit_jmp = self.emit_jmp(self.op_map['JMP_TRUE'])
                # v = _t[_k]
                self.emit_u16(self.op_map['GET_LOCAL'], tbl_slot)
                self.emit_u16(self.op_map['GET_LOCAL'], k_slot)
                self.emit(self.op_map['GET_TABLE'])
                if v_slot2 is not None:
                    self.emit_u16(self.op_map['SET_LOCAL'], v_slot2)
                    self.emit(self.op_map['POP'])
                else:
                    self.emit(self.op_map['POP'])

                self.break_stack.append([])
                self.compile_chunk()

                # _k = next(_t, _k)
                next_idx2 = self.add_const('next')
                self.emit_u16(self.op_map['GET_GLOBAL'], next_idx2)
                self.emit_u16(self.op_map['GET_LOCAL'], tbl_slot)
                self.emit_u16(self.op_map['GET_LOCAL'], k_slot)
                self.emit(self.op_map['CALL'], 2)
                self.emit_u16(self.op_map['SET_LOCAL'], k_slot)
                self.emit(self.op_map['POP'])

                back_jmp = self.emit_jmp(self.op_map['JMP'])
                self.patch_jmp_addr(back_jmp, start_pc)
                self.patch_jmp(exit_jmp)
                self.emit(self.op_map['POP'])

                break_jmps = self.break_stack.pop()
                for jmp in break_jmps:
                    self.patch_jmp(jmp)
                self.pop_scope()
                self.tok.expect('END')

            else:
                # 通用 generic for (fallback: 不支持多返回值)
                self.compile_expr()
                self.emit(self.op_map['PUSH_NIL'])
                self.emit(self.op_map['PUSH_NIL'])

                self.tok.expect('DO')
                self.push_scope()

                iter_slot = self.local_count
                self.local_count += 1
                state_slot = self.local_count
                self.local_count += 1
                k_slot = self.add_local(var_names[0])
                v_slot = None
                if len(var_names) > 1:
                    v_slot = self.add_local(var_names[1])

                self.emit_u16(self.op_map['SET_LOCAL'], k_slot)
                self.emit(self.op_map['POP'])
                self.emit_u16(self.op_map['SET_LOCAL'], state_slot)
                self.emit(self.op_map['POP'])
                self.emit_u16(self.op_map['SET_LOCAL'], iter_slot)
                self.emit(self.op_map['POP'])

                start_pc = self.current_pc()
                self.emit_u16(self.op_map['GET_LOCAL'], iter_slot)
                self.emit_u16(self.op_map['GET_LOCAL'], state_slot)
                self.emit_u16(self.op_map['GET_LOCAL'], k_slot)
                self.emit(self.op_map['CALL'], 2)

                self.emit(self.op_map['DUP'])
                self.emit(self.op_map['PUSH_NIL'])
                self.emit(self.op_map['EQ'])
                exit_jmp = self.emit_jmp(self.op_map['JMP_TRUE'])

                self.emit_u16(self.op_map['SET_LOCAL'], k_slot)
                self.emit(self.op_map['POP'])
                if v_slot is not None:
                    self.emit(self.op_map['PUSH_NIL'])
                    self.emit_u16(self.op_map['SET_LOCAL'], v_slot)
                    self.emit(self.op_map['POP'])

                self.break_stack.append([])
                self.compile_chunk()

                back_jmp = self.emit_jmp(self.op_map['JMP'])
                self.patch_jmp_addr(back_jmp, start_pc)
                self.patch_jmp(exit_jmp)
                self.emit(self.op_map['POP'])

                break_jmps = self.break_stack.pop()
                for jmp in break_jmps:
                    self.patch_jmp(jmp)
                self.pop_scope()
                self.tok.expect('END')
        else:
            raise SyntaxError(f"Unexpected token in for loop: {self.tok.peek()}")

    def compile_do(self):
        self.tok.expect('DO')
        self.push_scope()
        self.compile_chunk()
        self.pop_scope()
        self.tok.expect('END')

    def compile_break(self):
        self.tok.expect('BREAK')
        if not self.break_stack:
            raise SyntaxError("break outside loop")
        jmp = self.emit_jmp(self.op_map['JMP'])
        self.break_stack[-1].append(jmp)

    def compile_function(self):
        self.tok.expect('FUNCTION')
        name_tok = self.tok.expect('IDENT')
        func_name = name_tok[1]

        # 检查是否是 table.method 或 table:method 语法
        method_name = None
        is_dot = False
        if self.tok.peek()[0] == 'DOT':
            self.tok.consume()
            method_tok = self.tok.expect('IDENT')
            method_name = method_tok[1]
            is_dot = True
        elif self.tok.peek()[0] == 'COLON':
            self.tok.consume()
            method_tok = self.tok.expect('IDENT')
            method_name = method_tok[1]

        self.tok.expect('LPAREN')

        # 解析参数
        params = []
        # COLON 方法自动添加 self 参数
        if method_name and not is_dot:
            params.append('self')

        if self.tok.peek()[0] != 'RPAREN':
            while True:
                if self.tok.peek()[0] == 'DOT3':
                    self.tok.consume()
                    params.append('...')
                    break
                p = self.tok.expect('IDENT')
                params.append(p[1])
                if self.tok.peek()[0] == 'COMMA':
                    self.tok.consume()
                else:
                    break
        self.tok.expect('RPAREN')

        # 保存当前函数ID和状态
        old_func_id = self.func_id
        old_locals = self.local_count
        old_local_scope = self.local_scope

        # 创建新函数
        fid = self.new_function(func_name)
        self.functions[fid]['num_params'] = len(params)
        self.func_id = fid
        self.local_scope = [{}]
        self.local_count = 0

        # 添加参数到局部变量
        for p in params:
            if p != '...':
                self.add_local(p)

        # 编译函数体
        self.compile_chunk()
        self.tok.expect('END')

        # 默认返回 nil
        self.emit(self.op_map['PUSH_NIL'])
        self.emit(self.op_map['RETURN'])

        # 恢复状态
        self.func_id = old_func_id
        self.local_count = old_locals
        self.local_scope = old_local_scope

        # 将函数常量压入栈
        func_const_idx = self.add_const(f'__FUNC_{fid}')
        self.emit_u16(self.op_map['PUSH_CONST'], func_const_idx)  # 特殊标记: 函数引用

        # 赋值
        if method_name:
            # t:method = func  => t.method = func
            name_idx = self.add_const(func_name)
            self.emit_u16(self.op_map['GET_GLOBAL'], name_idx)
            self.emit(self.op_map['SWAP'])
            method_idx = self.add_const(method_name)
            self.emit_u16(self.op_map['PUSH_CONST'], method_idx)
            self.emit(self.op_map['SWAP'])
            self.emit(self.op_map['SET_TABLE'])
            self.emit(self.op_map['POP'])
        else:
            name_idx = self.add_const(func_name)
            self.emit_u16(self.op_map['SET_GLOBAL'], name_idx)
            self.emit(self.op_map['POP'])

    def compile_local(self):
        self.tok.expect('LOCAL')
        if self.tok.peek()[0] == 'FUNCTION':
            # local function name() ... end
            self.tok.consume()  # function
            name_tok = self.tok.expect('IDENT')
            func_name = name_tok[1]

            self.tok.expect('LPAREN')
            params = []
            if self.tok.peek()[0] != 'RPAREN':
                while True:
                    if self.tok.peek()[0] == 'DOT3':
                        self.tok.consume()
                        params.append('...')
                        break
                    p = self.tok.expect('IDENT')
                    params.append(p[1])
                    if self.tok.peek()[0] == 'COMMA':
                        self.tok.consume()
                    else:
                        break
            self.tok.expect('RPAREN')

            old_func_id = self.func_id
            old_locals = self.local_count
            old_local_scope = self.local_scope

            fid = self.new_function(func_name)
            self.functions[fid]['num_params'] = len(params)
            self.func_id = fid
            self.local_scope = [{}]
            self.local_count = 0

            for p in params:
                self.add_local(p)

            self.compile_chunk()
            self.tok.expect('END')
            self.emit(self.op_map['PUSH_NIL'])
            self.emit(self.op_map['RETURN'])

            self.func_id = old_func_id
            self.local_count = old_locals
            self.local_scope = old_local_scope

            # local function: 先创建slot，再赋值
            slot = self.add_local(func_name)
            func_const_idx = self.add_const(f'__FUNC_{fid}')
            self.emit_u16(self.op_map['PUSH_CONST'], func_const_idx)
            self.emit_u16(self.op_map['SET_LOCAL'], slot)
            # 镜像到全局表 (upvalue 模拟)
            gidx = self.add_const(func_name)
            self.emit_u16(self.op_map['SET_GLOBAL'], gidx)
            self.emit(self.op_map['POP'])
        else:
            # local var = expr
            names = []
            while True:
                name_tok = self.tok.expect('IDENT')
                names.append(name_tok[1])
                if self.tok.peek()[0] == 'COMMA':
                    self.tok.consume()
                else:
                    break

            if self.tok.peek()[0] == 'ASSIGN':
                self.tok.consume()
                # 编译表达式列表
                # 修复: 多返回值改为"占位 CALL_MULTI + 末尾原位回填"模式,
                # 不再向已发射字节码中间插入字节 (旧实现会破坏跳转回填位置)
                n_targets = len(names)
                bc = self.functions[self.func_id]['bytecode']
                cm_op = self.op_map['CALL_MULTI']
                expr_count = 0
                expr_ranges = []  # 每个表达式的字节码区间 [before, after)
                self.multi_call_ctx = (n_targets > 1)
                while True:
                    before = len(bc)
                    self.compile_expr()
                    after = len(bc)
                    expr_ranges.append((before, after))
                    expr_count += 1
                    if self.tok.peek()[0] == 'COMMA':
                        self.tok.consume()
                    else:
                        break
                self.multi_call_ctx = False
                # 仅当"最后一个表达式的末尾指令"是 CALL_MULTI 时回填:
                # 此时该调用的返回值就是表达式的值, 可安全扩展/截断
                nresults = 0
                patched = False
                if n_targets > 1 and expr_count > 0:
                    lb, la = expr_ranges[-1]
                    if la > lb:
                        last_start = self._last_instr_start(bc, lb, la)
                        if bc[last_start] == cm_op:
                            nresults = n_targets - expr_count + 1
                            bc[last_start + 2] = nresults  # op, nargs 之后即 nresults
                            patched = True
                # 栈上值数 = (expr_count-1) + (末尾调用调整后的返回值数或1)
                values = (expr_count - 1 + nresults) if patched else expr_count
                # 值多于目标: 丢弃多余 (从栈顶); 值少于目标: 补 nil (Lua 语义)
                for _ in range(max(0, values - n_targets)):
                    self.emit(self.op_map['POP'])
                for _ in range(max(0, n_targets - values)):
                    self.emit(self.op_map['PUSH_NIL'])
                # 先添加所有 local slots
                slots = []
                for name in names:
                    slots.append(self.add_local(name))

                # 逆序弹出并赋值 (逆序保证 a,b = b,a 正确交换)
                for i in range(len(names) - 1, -1, -1):
                    self.emit_u16(self.op_map['SET_LOCAL'], slots[i])
                    gidx = self.add_const(names[i])
                    self.emit_u16(self.op_map['SET_GLOBAL'], gidx)
                    self.emit(self.op_map['POP'])
            else:
                # local name (no value = nil)
                for name in names:
                    self.add_local(name)

    def compile_return(self):
        self.tok.expect('RETURN')
        if self.tok.peek()[0] in ('END', 'ELSE', 'ELSEIF', 'UNTIL', 'EOF', 'SEMI'):
            self.emit(self.op_map['PUSH_NIL'])
        else:
            self.compile_expr()
            # 修复: 保留全部返回值 (旧版丢弃多余值, 导致 local a,b = vm_func()
            # 永远拿不到第二个返回值)。实际取几个由调用点帧的 want 决定:
            # CALL=取1个, CALL_MULTI=取n个(不足补nil), 主函数/外部调用=全保留
            while self.tok.peek()[0] == 'COMMA':
                self.tok.consume()
                self.compile_expr()
        self.emit(self.op_map['RETURN'])

    def _scan_lvalue_end(self, start_pos):
        """扫描左值访问链，返回 (access_count, assign_pos) 或 (0, None)"""
        pos = start_pos
        tokens = self.tok.tokens
        if tokens[pos][0] != 'IDENT':
            return 0, None
        pos += 1
        count = 0
        while pos < len(tokens):
            kind = tokens[pos][0]
            if kind == 'DOT':
                if pos + 1 >= len(tokens) or tokens[pos+1][0] != 'IDENT':
                    break
                pos += 2
                count += 1
            elif kind == 'LBRACK':
                depth = 1
                pos += 1
                while pos < len(tokens) and depth > 0:
                    k = tokens[pos][0]
                    if k == 'LBRACK': depth += 1
                    elif k == 'RBRACK': depth -= 1
                    pos += 1
                if depth > 0:
                    return 0, None
                count += 1
            else:
                break
        if pos < len(tokens) and tokens[pos][0] == 'ASSIGN':
            return count, pos
        return 0, None

    def _scan_multi_assign(self, start_pos):
        """扫描多赋值: a, b, c.d = ... 返回 (lvalue_list, assign_pos) 或 (None, None)
        lvalue_list: [(base_name, access_count), ...]
        """
        tokens = self.tok.tokens
        pos = start_pos
        lvalues = []
        while pos < len(tokens):
            if tokens[pos][0] != 'IDENT':
                return None, None
            base_name = tokens[pos][1]
            pos += 1
            count = 0
            while pos < len(tokens):
                kind = tokens[pos][0]
                if kind == 'DOT':
                    if pos + 1 >= len(tokens) or tokens[pos+1][0] != 'IDENT':
                        break
                    pos += 2
                    count += 1
                elif kind == 'LBRACK':
                    depth = 1
                    pos += 1
                    while pos < len(tokens) and depth > 0:
                        k = tokens[pos][0]
                        if k == 'LBRACK': depth += 1
                        elif k == 'RBRACK': depth -= 1
                        pos += 1
                    if depth > 0:
                        return None, None
                    count += 1
                else:
                    break
            lvalues.append((base_name, count))
            if pos < len(tokens) and tokens[pos][0] == 'COMMA':
                pos += 1
                continue
            elif pos < len(tokens) and tokens[pos][0] == 'ASSIGN':
                return lvalues, pos
            else:
                return None, None

    def _last_instr_start(self, bc, lo, hi):
        """遍历 [lo, hi) 区间内的指令, 返回末尾一条指令的起始下标"""
        i = lo
        last = lo
        while i < hi:
            last = i
            i += 1 + self._size_of.get(bc[i], 0)
        return last

    def _alloc_temp_slot(self):
        """分配一个隐藏临时槽位 (用于复杂左值的多赋值暂存)"""
        slot = self.local_count
        self.local_count += 1
        return slot

    def _compile_multi_assign(self, lvalues):
        """编译多赋值的右值和左值赋值 (tokens仍需消费)
        lvalues: [(base_name, access_count), ...]
        修复:
        1. CALL_MULTI 占位发射 + 末尾原位回填, 不再插入字节 (旧实现破坏跳转回填)
        2. 复杂左值 (t.x / t[k]) 真正写入表字段; 旧实现直接覆盖 base 变量导致表被毁
        3. 右值数量与左值不匹配时按 Lua 语义补 nil / 丢弃
        """
        n = len(lvalues)
        # 消费所有左值 tokens (IDENT + access chain)
        # 复杂左值的中间访问键编译为 GET_TABLE 导航; 最后一层键保留在栈上不行
        # (会与后续表达式编译冲突), 改为记录访问描述, 赋值阶段重建导航
        consumed = []  # [(base_name, accesses)] accesses: ('dot', name) | ('key', slot)
        for i, (base_name, access_count) in enumerate(lvalues):
            self.tok.expect('IDENT')  # base name
            accesses = []
            for _ in range(access_count):
                nt = self.tok.peek()
                if nt[0] == 'DOT':
                    self.tok.consume()
                    key_tok = self.tok.expect('IDENT')
                    accesses.append(('dot', key_tok[1]))
                elif nt[0] == 'LBRACK':
                    self.tok.consume()
                    self.compile_expr()
                    self.tok.expect('RBRACK')
                    # 索引表达式求值结果暂存到隐藏槽位
                    slot = self._alloc_temp_slot()
                    self.emit_u16(self.op_map['SET_LOCAL'], slot)
                    self.emit(self.op_map['POP'])
                    accesses.append(('key', slot))
            consumed.append((base_name, accesses))
            if i < n - 1:
                self.tok.expect('COMMA')
        # 消费 =
        self.tok.expect('ASSIGN')
        # 编译所有右值表达式，按顺序压栈
        rhs_count = 0
        bc = self.functions[self.func_id]['bytecode']
        cm_op = self.op_map['CALL_MULTI']
        expr_ranges = []
        self.multi_call_ctx = (n > 1)
        for i in range(n):
            # 检查是否还有表达式可编译
            next_tok = self.tok.peek()[0]
            if next_tok in ('END', 'ELSE', 'ELSEIF', 'UNTIL', 'EOF', 'SEMI', 'DO', 'THEN'):
                break
            before = len(bc)
            self.compile_expr()
            after = len(bc)
            expr_ranges.append((before, after))
            rhs_count += 1
            if i < n - 1:
                if self.tok.peek()[0] == 'COMMA':
                    self.tok.consume()
                else:
                    break
        self.multi_call_ctx = False
        # 仅当最后一个表达式的末尾指令是 CALL_MULTI 时原位回填
        nresults = 0
        patched = False
        if n > 1 and rhs_count > 0:
            lb, la = expr_ranges[-1]
            if la > lb:
                last_start = self._last_instr_start(bc, lb, la)
                if bc[last_start] == cm_op:
                    nresults = n - rhs_count + 1
                    bc[last_start + 2] = nresults
                    patched = True
        values = (rhs_count - 1 + nresults) if patched else rhs_count
        for _ in range(max(0, values - n)):
            self.emit(self.op_map['POP'])
        for _ in range(max(0, n - values)):
            self.emit(self.op_map['PUSH_NIL'])
        # 逆序弹出并赋值 (逆序保证 a,b = b,a 正确交换)
        for i in range(n - 1, -1, -1):
            base_name, accesses = consumed[i]
            if not accesses:
                # 简单变量赋值
                slot = self.find_local(base_name)
                if slot is not None:
                    self.emit_u16(self.op_map['SET_LOCAL'], slot)
                idx = self.add_const(base_name)
                self.emit_u16(self.op_map['SET_GLOBAL'], idx)
                self.emit(self.op_map['POP'])
            else:
                # 复杂左值: 值暂存 → 重建表导航 → 写入字段
                vslot = self._alloc_temp_slot()
                self.emit_u16(self.op_map['SET_LOCAL'], vslot)
                self.emit(self.op_map['POP'])
                # 压入 base 表
                slot = self.find_local(base_name)
                if slot is not None:
                    self.emit_u16(self.op_map['GET_LOCAL'], slot)
                else:
                    idx = self.add_const(base_name)
                    self.emit_u16(self.op_map['GET_GLOBAL'], idx)
                # 逐层导航, 最后一层只压键
                last = len(accesses) - 1
                for j, acc in enumerate(accesses):
                    if acc[0] == 'dot':
                        key_idx = self.add_const(acc[1])
                        self.emit_u16(self.op_map['PUSH_CONST'], key_idx)
                    else:
                        self.emit_u16(self.op_map['GET_LOCAL'], acc[1])
                    if j < last:
                        self.emit(self.op_map['GET_TABLE'])
                # 取回值, 写表
                self.emit_u16(self.op_map['GET_LOCAL'], vslot)
                self.emit(self.op_map['SET_TABLE'])
                self.emit(self.op_map['POP'])

    def compile_expr_statement(self):
        """表达式语句：赋值或函数调用"""
        tok0 = self.tok.peek()
        if tok0[0] != 'IDENT':
            self.compile_expr()
            self.emit(self.op_map['POP'])
            return

        # 先检查是否是多赋值 (a, b = ...)
        multi_lvalues, multi_pos = self._scan_multi_assign(self.tok.pos)
        if multi_lvalues is not None and len(multi_lvalues) > 1:
            self._compile_multi_assign(multi_lvalues)
            return

        access_count, assign_pos = self._scan_lvalue_end(self.tok.pos)
        if assign_pos is None:
            # 不是赋值，作为普通表达式语句
            self.compile_expr()
            self.emit(self.op_map['POP'])
            return

        # === 赋值语句 ===
        base_tok = self.tok.consume()
        base_name = base_tok[1]

        if access_count == 0:
            # 简单变量赋值: name = expr
            self.tok.consume()  # =
            self.compile_expr()
            slot = self.find_local(base_name)
            if slot is not None:
                self.emit_u16(self.op_map['SET_LOCAL'], slot)
            # 总是同时设置全局表 (upvalue 模拟)
            idx = self.add_const(base_name)
            self.emit_u16(self.op_map['SET_GLOBAL'], idx)
            self.emit(self.op_map['POP'])
            return

        # 表字段赋值: t.access1.access2... = expr
        # 编译 base table
        slot = self.find_local(base_name)
        if slot is not None:
            self.emit_u16(self.op_map['GET_LOCAL'], slot)
        else:
            idx = self.add_const(base_name)
            self.emit_u16(self.op_map['GET_GLOBAL'], idx)

        # 编译访问链: 前 access_count-1 个用 GET_TABLE 导航，最后一个只压key
        for i in range(access_count):
            is_last = (i == access_count - 1)
            nt = self.tok.peek()

            if nt[0] == 'DOT':
                self.tok.consume()
                key_tok = self.tok.consume()
                key_idx = self.add_const(key_tok[1])
                self.emit_u16(self.op_map['PUSH_CONST'], key_idx)
            elif nt[0] == 'LBRACK':
                self.tok.consume()
                self.compile_expr()
                self.tok.expect('RBRACK')

            if not is_last:
                self.emit(self.op_map['GET_TABLE'])

        # 消费 =
        self.tok.expect('ASSIGN')
        # 编译 RHS
        self.compile_expr()
        # SET_TABLE
        self.emit(self.op_map['SET_TABLE'])
        self.emit(self.op_map['POP'])

    # ---- 表达式 ----
    def compile_expr(self):
        self.compile_or()

    def compile_or(self):
        self.compile_and()
        while self.tok.peek()[0] == 'OR':
            self.tok.consume()
            self.compile_and()
            self.emit(self.op_map['LOR'])

    def compile_and(self):
        self.compile_compare()
        while self.tok.peek()[0] == 'AND':
            self.tok.consume()
            self.compile_compare()
            self.emit(self.op_map['LAND'])

    def compile_compare(self):
        self.compile_concat()
        op_map = {
            'EQ_OP': 'EQ', 'NE_OP': 'NE',
            'LT_OP': 'LT', 'LE_OP': 'LE',
            'GT_OP': 'GT', 'GE_OP': 'GE',
        }
        tok = self.tok.peek()
        if tok[0] in op_map:
            self.tok.consume()
            self.compile_concat()
            self.emit(self.op_map[op_map[tok[0]]])

    def compile_concat(self):
        self.compile_add()
        while self.tok.peek()[0] == 'DOT2':
            self.tok.consume()
            self.compile_add()
            self.emit(self.op_map['CONCAT'])

    def compile_add(self):
        self.compile_mul()
        while self.tok.peek()[0] in ('PLUS', 'MINUS'):
            op = self.tok.consume()
            self.compile_mul()
            self.emit(self.op_map['ADD'] if op[0] == 'PLUS' else self.op_map['SUB'])

    def compile_mul(self):
        self.compile_unary()
        while self.tok.peek()[0] in ('MULT', 'DIV', 'MOD'):
            op = self.tok.consume()
            self.compile_unary()
            if op[0] == 'MULT':
                self.emit(self.op_map['MUL'])
            elif op[0] == 'DIV':
                self.emit(self.op_map['DIV'])
            else:
                self.emit(self.op_map['MOD'])

    def compile_unary(self):
        tok = self.tok.peek()
        if tok[0] == 'MINUS':
            self.tok.consume()
            self.compile_unary()
            self.emit(self.op_map['UNM'])
        elif tok[0] == 'NOT':
            self.tok.consume()
            self.compile_unary()
            self.emit(self.op_map['LNOT'])
        elif tok[0] == 'LEN':
            self.tok.consume()
            self.compile_unary()
            self.emit(self.op_map['LEN'])
        else:
            self.compile_pow()

    def compile_pow(self):
        """^ 运算符: 右结合, 优先级高于 unary"""
        self.compile_postfix()
        if self.tok.peek()[0] == 'POW':
            self.tok.consume()
            self.compile_unary()  # 右结合: 允许 2^3^2 = 2^(3^2)
            self.emit(self.op_map['POW'])

    def compile_postfix(self):
        self.compile_primary()
        while True:
            tok = self.tok.peek()
            if tok[0] == 'LPAREN':
                # 函数调用
                self.tok.consume()
                nargs = 0
                if self.tok.peek()[0] != 'RPAREN':
                    while True:
                        self.compile_expr()
                        nargs += 1
                        if self.tok.peek()[0] == 'COMMA':
                            self.tok.consume()
                        else:
                            break
                self.tok.expect('RPAREN')
                if self.multi_call_ctx:
                    # 占位 nresults=1 (语义等同 CALL), 由 compile_local /
                    # _compile_multi_assign 对最后一个表达式的末尾调用原位回填
                    self.emit(self.op_map['CALL_MULTI'], nargs, 1)
                else:
                    self.emit(self.op_map['CALL'], nargs)
            elif tok[0] == 'LBRACK':
                # 表索引 t[k]
                self.tok.consume()
                self.compile_expr()
                self.tok.expect('RBRACK')
                self.emit(self.op_map['GET_TABLE'])
            elif tok[0] == 'DOT':
                # t.key
                self.tok.consume()
                key_tok = self.tok.expect('IDENT')
                # V8.6: gg.<member> 成员名 → API 密文常量 (运行时 _wgg.__index 逐字节还原)
                if self._last_base == ('global', 'gg'):
                    key_idx = self._name_const(key_tok[1])
                else:
                    key_idx = self.add_const(key_tok[1])
                self._last_base = None
                self.emit_u16(self.op_map['PUSH_CONST'], key_idx)
                self.emit(self.op_map['GET_TABLE'])
            elif tok[0] == 'COLON':
                # 方法调用 t:method(args)
                self.tok.consume()
                method_tok = self.tok.expect('IDENT')
                method_name = method_tok[1]
                self.tok.expect('LPAREN')
                # 复制表到栈顶作为 self
                self.emit(self.op_map['DUP'])
                # V8.6: gg:method() → API 密文常量
                if self._last_base == ('global', 'gg'):
                    method_idx = self._name_const(method_name)
                else:
                    method_idx = self.add_const(method_name)
                self._last_base = None
                self.emit_u16(self.op_map['PUSH_CONST'], method_idx)
                self.emit(self.op_map['GET_TABLE'])
                self.emit(self.op_map['SWAP'])
                # 现在栈: table, func, table(self)
                nargs = 1  # self
                if self.tok.peek()[0] != 'RPAREN':
                    while True:
                        self.compile_expr()
                        nargs += 1
                        if self.tok.peek()[0] == 'COMMA':
                            self.tok.consume()
                        else:
                            break
                self.tok.expect('RPAREN')
                if self.multi_call_ctx:
                    self.emit(self.op_map['CALL_MULTI'], nargs, 1)
                else:
                    self.emit(self.op_map['CALL'], nargs)
            elif tok[0] == 'LBRACE':
                # 表构造器作为函数调用参数 f{...}
                # 简化: 暂不支持
                break
            elif tok[0] == 'STRING' or tok[0] == 'STRING_S':
                # 字符串作为函数调用参数 f"..."
                break
            else:
                break

    def compile_primary(self):
        tok = self.tok.peek()
        self._last_base = None

        if tok[0] == 'DOT3':
            # vararg ... — 简化: 压入 nil (VM不支持多返回值展开)
            self.tok.consume()
            self.emit(self.op_map['PUSH_NIL'])
        elif tok[0] == 'NUMBER':
            self.tok.consume()
            val = tok[1]
            if isinstance(val, int) and 0 <= val <= 255:
                self.emit(self.op_map['PUSH_NUM'], val)
            else:
                idx = self.add_const(val)
                self.emit_u16(self.op_map['PUSH_CONST'], idx)
        elif tok[0] == 'STRING':
            self.tok.consume()
            idx = self.add_const(tok[1])
            self.emit_u16(self.op_map['PUSH_CONST'], idx)
        elif tok[0] == 'NIL':
            self.tok.consume()
            self.emit(self.op_map['PUSH_NIL'])
        elif tok[0] == 'TRUE':
            self.tok.consume()
            self.emit(self.op_map['PUSH_TRUE'])
        elif tok[0] == 'FALSE':
            self.tok.consume()
            self.emit(self.op_map['PUSH_FALSE'])
        elif tok[0] == 'IDENT':
            self.tok.consume()
            name = tok[1]
            # 检查是否是局部变量
            slot = self.find_local(name)
            if slot is not None:
                self.emit_u16(self.op_map['GET_LOCAL'], slot)
            else:
                # 全局变量 / 函数
                # V8.6: API 调用名 (gg.* 及 gg 根名) 以 14 字节循环密钥密文入常量表,
                #       运行时经桥接表元表 __index 逐字节还原后查表转发
                idx = self._name_const(name)
                self.emit_u16(self.op_map['GET_GLOBAL'], idx)
                self._last_base = ('global', name)
        elif tok[0] == 'LPAREN':
            self.tok.consume()
            self.compile_expr()
            self.tok.expect('RPAREN')
        elif tok[0] == 'LBRACE':
            # 表构造器
            self.compile_table()
        elif tok[0] == 'FUNCTION':
            # 匿名函数
            self.tok.consume()
            self.tok.expect('LPAREN')
            params = []
            if self.tok.peek()[0] != 'RPAREN':
                while True:
                    if self.tok.peek()[0] == 'DOT3':
                        self.tok.consume()
                        params.append('...')
                        break
                    p = self.tok.expect('IDENT')
                    params.append(p[1])
                    if self.tok.peek()[0] == 'COMMA':
                        self.tok.consume()
                    else:
                        break
            self.tok.expect('RPAREN')

            old_func_id = self.func_id
            old_locals = self.local_count
            old_local_scope = self.local_scope

            fid = self.new_function("")
            self.functions[fid]['num_params'] = len(params)
            self.func_id = fid
            self.local_scope = [{}]
            self.local_count = 0

            for p in params:
                self.add_local(p)

            self.compile_chunk()
            self.tok.expect('END')
            self.emit(self.op_map['PUSH_NIL'])
            self.emit(self.op_map['RETURN'])

            self.func_id = old_func_id
            self.local_count = old_locals
            self.local_scope = old_local_scope

            func_const_idx = self.add_const(f'__FUNC_{fid}')
            self.emit_u16(self.op_map['PUSH_CONST'], func_const_idx)
        else:
            raise SyntaxError(f"Unexpected token: {tok}")

    def compile_table(self):
        """表构造器 { [expr] = expr, key = expr, expr, ... }"""
        self.tok.expect('LBRACE')
        self.emit(self.op_map['NEW_TABLE'])

        is_first = True
        while self.tok.peek()[0] not in ('RBRACE', 'EOF'):
            if not is_first:
                # 修复: Lua 允许表构造器中用 ';' 或 ',' 分隔
                sep = self.tok.consume()
                if sep[0] not in ('COMMA', 'SEMI'):
                    raise SyntaxError(f"Expected ',' or ';' in table, got {sep}")
                if self.tok.peek()[0] == 'RBRACE':
                    break
            is_first = False

            tok = self.tok.peek()
            if tok[0] == 'LBRACK':
                # [key] = value
                self.tok.consume()
                self.compile_expr()
                self.tok.expect('RBRACK')
                self.tok.expect('ASSIGN')
                self.compile_expr()
                self.emit(self.op_map['SET_TABLE'])
            elif tok[0] == 'IDENT' and self.tok.peek(1)[0] == 'ASSIGN':
                # key = value
                key_tok = self.tok.consume()
                self.tok.consume()  # =
                key_idx = self.add_const(key_tok[1])
                self.emit_u16(self.op_map['PUSH_CONST'], key_idx)
                self.compile_expr()
                self.emit(self.op_map['SET_TABLE'])
            else:
                # 数组部分 value (自动索引)
                # 栈: [..., table] → 需要 [..., table, key, value] for SET_TABLE
                self.emit(self.op_map['DUP'])           # [..., table, table]
                self.emit(self.op_map['LEN'])            # [..., table, #table]
                self.emit(self.op_map['PUSH_NUM'], 1)   # [..., table, #table, 1]
                self.emit(self.op_map['ADD'])            # [..., table, #table+1]  -- key
                self.compile_expr()            # [..., table, key, value]
                self.emit(self.op_map['SET_TABLE'])     # pops value,key,table → table[key]=value, pushes table

        self.tok.expect('RBRACE')

    def patch_jmp_addr(self, addr_pos, target):
        bc = self.functions[self.func_id]['bytecode']
        bc[addr_pos] = target & 0xFF
        bc[addr_pos + 1] = (target >> 8) & 0xFF

    # ---- 输出 ----
    def get_bytecode_data(self):
        """生成最终的字节码数据，包含所有函数和常量池"""
        data = bytearray()

        # 头部: 主函数ID, 函数数量, 常量池大小
        num_funcs = len(self.functions)
        num_consts = len(self.constants)

        data.extend(struct.pack('<H', 0))  # 主函数ID总是0
        data.extend(struct.pack('<H', num_funcs))
        data.extend(struct.pack('<H', num_consts))
        # 改进: 非标准编码 — 插入垃圾数据段 (破坏 unluac 等标准解析器)
        junk1_len = random.randint(8, 32)
        data.extend(struct.pack('<H', junk1_len))
        data.extend([random.randint(0, 255) for _ in range(junk1_len)])

        # 常量池
        # V8.6 双层字符串保护:
        #   外层 = 链式流式 XOR (每字节密钥依赖前一密文字节, 自校验扩散);
        #   内层 = 字符映射表索引存储 (type 5, 运行时由引导器 5 字节分块重建映射表后还原);
        #   API 调用名 = 再叠加 14 字节循环密钥逐字节 XOR (最内层载荷密文)
        for c_idx0, c in enumerate(self.constants):
            c_idx = c_idx0 + 1  # 1-based: 与 Lua 端常量序号 i 对齐 (流式密钥基值)
            if isinstance(c, str):
                if c.startswith('__FUNC_'):
                    # 函数引用
                    func_id = int(c[len('__FUNC_'):])
                    data.append(3)  # type 3 = function ref
                    data.extend(struct.pack('<H', func_id))
                else:
                    encoded = c.encode('utf-8')
                    if c_idx0 in self._api_consts and self.api_key:
                        # API 调用名: 14 字节循环密钥密文 (运行时 __index 逐字节还原)
                        # 注意: _api_consts 存 0-based 索引 (add_const 返回值), 此处按 0-based 比对
                        encoded = self._api_xor_bytes(encoded)
                    if self.str_map_inv is not None:
                        # 内层: 字符映射 (存储字节 = M^-1[明文字节], 运行时 M[存储] 还原)
                        encoded = bytes([self.str_map_inv[b] for b in encoded])
                        data.append(5)  # type 5 = mapped string
                    else:
                        data.append(1)  # type 1 = string
                    encoded = self._stream_xor(encoded, c_idx)
                    data.extend(struct.pack('<I', len(encoded)))
                    data.extend(encoded)
            elif isinstance(c, (int, float)):
                data.append(2)  # type 2 = number (stored as string)
                num_str = str(c)
                encoded = self._stream_xor(num_str.encode('utf-8'), c_idx)
                data.extend(struct.pack('<I', len(encoded)))
                data.extend(encoded)
            elif c is None:
                data.append(0)  # type 0 = nil
            elif isinstance(c, bool):
                data.append(4)  # type 4 = boolean
                data.append(1 if c else 0)
            else:
                data.append(0)

        # 改进: 垃圾数据段 (常量池和函数表之间)
        junk2_len = random.randint(8, 32)
        data.extend(struct.pack('<H', junk2_len))
        data.extend([random.randint(0, 255) for _ in range(junk2_len)])

        # 函数体 (改进: 每个函数字节码独立加密, 与解释器绑定密钥)
        for f_idx, f in enumerate(self.functions, 1):
            bc = f['bytecode']
            # 每函数独立密钥 (与常量池密钥绑定, 防脱离VM单独提取)
            f_key = [(self.cp_key * 31 + f_idx * 17 + j * 37 + 0xC3) % 256 for j in range(16)] if self.cp_key else None
            if f_key:
                bc_enc = bytes([b ^ f_key[i % 16] for i, b in enumerate(bc)])
            else:
                bc_enc = bytes(bc)
            data.extend(struct.pack('<I', len(bc_enc)))
            data.extend(struct.pack('<H', f['num_params']))
            data.extend(bc_enc)
            # 改进: 每个函数后插入垃圾数据 (使解析器越界)
            fjunk_len = random.randint(4, 16)
            data.extend(struct.pack('<H', fjunk_len))
            data.extend([random.randint(0, 255) for _ in range(fjunk_len)])

        return bytes(data)


# ============================================================
# Lua端 VM 解释器 代码生成
# ============================================================

# VM 解释器各部分 (用于 per-build opcode 随机化)
VM_INTERP_PREFIX = (
    '\n'
    '-- ============================================================\n'
    '-- V8 VM Interpreter (40+ 指令栈式虚拟机)\n'
    '-- ============================================================\n'
    'local function _vm_run(bc_data, native_api, _cmap)\n'
    '  local _X = bit32.bxor\n'
    '  local _band = bit32.band\n'
    '  local _bor = bit32.bor\n'
    '  local _bnot = bit32.bnot\n'
    '  local _lshift = bit32.lshift\n'
    '  local _rshift = bit32.rshift\n'
    '\n'
    '  -- 兼容 LuaJ/Lua5.1: 一次性解析 unpack 函数引用\n'
    '  local _unpack_fn = table.unpack or unpack\n'
    '  if not _unpack_fn then\n'
    '    _unpack_fn = function(t, i, j)\n'
    '      i = i or 1; j = j or #t\n'
    '      if i > j then return end\n'
    '      return t[i], _unpack_fn(t, i+1, j)\n'
    '    end\n'
    '  end\n'
    '\n'
    '  -- ---- 解析字节码数据 ----\n'
    '  local _p = 1\n'
    '  local function _r16()\n'
    '    local v = bc_data[_p] + bc_data[_p+1]*256\n'
    '    _p = _p + 2; return v\n'
    '  end\n'
    '  local function _r32()\n'
    '    local v = bc_data[_p] + bc_data[_p+1]*256 + bc_data[_p+2]*65536 + bc_data[_p+3]*16777216\n'
    '    _p = _p + 4; return v\n'
    '  end\n'
    '\n'
    '  local _main_func = _r16()\n'
    '  local _num_funcs = _r16()\n'
    '  local _num_consts = _r16()\n'
    '  -- 非标准编码: 跳过垃圾数据段1\n'
    '  local _jk1 = _r16(); _p = _p + _jk1\n'
    '\n'
    '  -- 前向声明: 使VM函数对象可被外部调用 (如内部VM的pcall)\n'
    '  local _vm_call_external\n'
    '  -- 常量池\n'
    '  -- V8.6: _CM = 引导器构建的字符映射表 (内层保护, 5字节分块重建); nil 时恒等回退\n'
    '  local _CM = _cmap\n'
    '  local _consts = {}\n'
    '  for i = 1, _num_consts do\n'
    '    local _t = bc_data[_p]; _p = _p + 1\n'
    '    if _t == 0 then\n'
    '      _consts[i] = nil\n'
    '    elseif _t == 1 or _t == 2 or _t == 5 then\n'
    '      -- V8.6 双层字符串保护: 外层链式流式XOR (密钥依赖前密文字节)\n'
    '      -- 类型5另经内层字符映射表还原 (引导器 5 字节分块构建)\n'
    '      local _len = _r32()\n'
    '      local _cpb = (__CP_KEY__*31+i*17+183)%256\n'
    '      local _chars = {}\n'
    '      local _prev = 0\n'
    '      for j = 1, _len do\n'
    '        local _cb = bc_data[_p+j-1]\n'
    '        local _b8 = _X(_cb, (_cpb + _prev*3 + j) % 256)\n'
    '        _prev = _cb\n'
    '        if _t == 5 and _CM then _b8 = _CM[_b8] or _b8 end\n'
    '        _chars[j] = string.char(_b8)\n'
    '      end\n'
    '      _p = _p + _len\n'
    '      local _sv = table.concat(_chars)\n'
    '      if _t == 2 then _consts[i] = tonumber(_sv) else _consts[i] = _sv end\n'
    '    elseif _t == 3 then\n'
    '      local _fid = _r16()\n'
    '      local _fobj = {__func = _fid}\n'
    '      setmetatable(_fobj, {__call = function(_, ...) return _vm_call_external(_fid, ...) end})\n'
    '      _consts[i] = _fobj\n'
    '    elseif _t == 4 then\n'
    '      _consts[i] = bc_data[_p] == 1\n'
    '      _p = _p + 1\n'
    '    end\n'
    '  end\n'
    '\n'
    '  -- 非标准编码: 跳过垃圾数据段2 (常量池和函数表之间)\n'
    '  local _jk2 = _r16(); _p = _p + _jk2\n'
    '\n'
    '  -- 函数表\n'
    '  local _funcs = {}\n'
    '  for i = 1, _num_funcs do\n'
    '    local _bc_len = _r32()\n'
    '    local _nparams = _r16()\n'
    '    -- 逐块解密: 每函数独立密钥 (与常量池密钥绑定)\n'
    '    local _fkey = {}\n'
    '    for _ci=0,15 do _fkey[_ci+1]=(__CP_KEY__*31+i*17+_ci*37+195)%256 end\n'
    '    local _fbc = {}\n'
    '    for j = 1, _bc_len do _fbc[j] = _X(bc_data[_p+j-1], _fkey[((j-1)%16)+1]) end\n'
    '    _p = _p + _bc_len\n'
    '    _funcs[i] = {bc = _fbc, nparams = _nparams}\n'
    '    -- 非标准编码: 跳过函数后垃圾数据\n'
    '    local _fjk = _r16(); _p = _p + _fjk\n'
    '  end\n'
    '\n'
    '  -- ---- VM 状态 ----\n'
    '  local _stack = {}\n'
    '  local _sp = 0\n'
    '  local _globals = {}  -- VM 独立全局环境，不污染真实 _G\n'
    '  local _call_stack = {}\n'
    '  local _call_sp = 0\n'
    '\n'
    '  -- ---- 栈操作辅助 ----\n'
    '  local function _push(v)\n'
    '    _sp = _sp + 1\n'
    '    _stack[_sp] = v\n'
    '  end\n'
    '\n'
    '  local function _pop()\n'
    '    local v = _stack[_sp]\n'
    '    _stack[_sp] = nil\n'
    '    _sp = _sp - 1\n'
    '    return v\n'
    '  end\n'
    '\n'
    '  local function _peek()\n'
    '    return _stack[_sp]\n'
    '  end\n'
    '\n'
    '  -- ---- 函数调用 ----\n'
    '  local function _call_func(fid, nargs)\n'
    '    _call_sp = _call_sp + 1\n'
    '    local _frame = _funcs[fid]\n'
    '    -- 参数已经在栈上 (栈顶是最后一个参数)\n'
    '    -- 创建新的执行帧\n'
    '    _call_stack[_call_sp] = {\n'
    '      pc = 1,\n'
    '      bc = _frame.bc,\n'
    '      locals = {},\n'
    '      base_sp = _sp - nargs,  -- 栈基址 (参数开始的位置)\n'
    '      nparams = _frame.nparams,\n'
    '    }\n'
    '    -- 把参数复制到locals\n'
    '    local _cs = _call_stack[_call_sp]\n'
    '    for i = 1, _frame.nparams do\n'
    '      _cs.locals[i-1] = _stack[_cs.base_sp + i]\n'
    '    end\n'
    '    -- 弹出参数\n'
    '    _sp = _cs.base_sp - 1\n'
    '  end\n'
    '\n'
    '  local function _return_func()\n'
    '    local _fr = _call_stack[_call_sp]\n'
    '    local _rb = _fr.base_sp\n'
    '    local _nres = _sp - _rb + 1\n'
    '    if _nres < 0 then _nres = 0 end\n'
    '    local _res = {}\n'
    '    for _ri = 1, _nres do _res[_ri] = _stack[_rb + _ri - 1] end\n'
    '    _call_sp = _call_sp - 1\n'
    '    _sp = _rb - 1\n'
    '    local _want = _fr.want\n'
    '    if _want == nil then\n'
    '      for _ri = 1, _nres do _push(_res[_ri]) end\n'
    '    elseif _want > 0 then\n'
    '      for _ri = 1, _want do _push(_res[_ri]) end\n'
    '    end\n'
    '  end\n'
    '\n'
    '  -- ---- 主执行循环 ----\n'
    '  _call_func(_main_func + 1, 0)\n'
    '  local _icnt = 0\n'
    '  local _vm_t0 = os and os.clock and os.clock() or 0\n'
    '  -- CFF: Control Flow Flattening 状态箱\n'
    '  local _cff_mask = __CFF_MASK__\n'
    '__AD_STATE_INIT__\n'
    '\n'
)

VM_OP_HANDLERS = {
    'ADD': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push((tonumber(_a) or 0) + (tonumber(_b) or 0))\n'
    ),
    'BAND': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_band(_a, _b))\n'
    ),
    'BNOT': '      _push(_bnot(_pop()))',
    'BOR': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_bor(_a, _b))\n'
    ),
    'BXOR': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_X(_a, _b))\n'
    ),
    'CALL': (
        '      local _nargs = _bc[_pc]\n'
        '      _pc = _pc + 1\n'
        '      local _func_slot = _sp - _nargs\n'
        '      local _func = _stack[_func_slot]\n'
        '\n'
        '      if _func == nil then\n'
        '        _sp = _func_slot - 1\n'
        '        _push(nil)\n'
        '      elseif type(_func) == "table" and _func.__func ~= nil then\n'
        '        _call_sp = _call_sp + 1\n'
        '        local _fid = _func.__func + 1\n'
        '        local _frame = _funcs[_fid]\n'
        '        _call_stack[_call_sp] = {\n'
        '          pc = 1,\n'
        '          bc = _frame.bc,\n'
        '          locals = {},\n'
        '          base_sp = _func_slot,\n'
        '          nparams = _frame.nparams,\n'
        '          want = 1,\n'
        '        }\n'
        '        local _cs = _call_stack[_call_sp]\n'
        '        for i = 1, _frame.nparams do\n'
        '          if i <= _nargs then\n'
        '            _cs.locals[i-1] = _stack[_func_slot + i]\n'
        '          end\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '      elseif type(_func) == "function" then\n'
        '        local _args = {}\n'
        '        for i = 1, _nargs do\n'
        '          _args[i] = _stack[_func_slot + i]\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '        -- 修复: pcall/xpcall 直接调用 (单返回值: 只push ok状态)\n'
        '        if _func == pcall or _func == xpcall then\n'
        '          local _ok, _r1 = _func(_unpack_fn(_args, 1, _nargs))\n'
        '          _push(_ok)\n'
        '        -- 修复: os.exit / error 等终止类函数直接调用 (不经过pcall, 确保能终止)\n'
        '        elseif _func == error or _func == os.exit or (type(_func) == "table" and rawget(_func, "__bvm_exit")) then\n'
        '          _func(_unpack_fn(_args, 1, _nargs))\n'
        '          _push(nil)\n'
        '        else\n'
        '          local _results = {pcall(_func, _unpack_fn(_args, 1, _nargs))}\n'
        '          if _results[1] then\n'
        '            if #_results > 1 then\n'
        '              _push(_results[2])\n'
        '            else\n'
        '              _push(nil)\n'
        '            end\n'
        '          else\n'
        '            -- 修复: 如果是__EXIT__标记, 直接抛出 (让os.exit能真正终止)\n'
        '            local _err = _results[2] or "VM call error"\n'
        '            if _err == "__EXIT__" then error(_err) end\n'
        '            error(_err)\n'
        '          end\n'
        '        end\n'
        '      else\n'
        '        -- 修复: 尝试直接调用 (支持 Java userdata / LuaJava 方法等可调用对象)\n'
        '        local _args = {}\n'
        '        for i = 1, _nargs do\n'
        '          _args[i] = _stack[_func_slot + i]\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '        -- 修复: 检查是否是exit标记的函数\n'
        '        if type(_func) == "table" and rawget(_func, "__bvm_exit") then\n'
        '          _func(_unpack_fn(_args, 1, _nargs))\n'
        '          _push(nil)\n'
        '        else\n'
        '          local _results = {pcall(_func, _unpack_fn(_args, 1, _nargs))}\n'
        '          if _results[1] then\n'
        '            if #_results > 1 then\n'
        '              _push(_results[2])\n'
        '            else\n'
        '              _push(nil)\n'
        '            end\n'
        '          else\n'
        '            local _err = _results[2] or "VM call error"\n'
        '            if _err == "__EXIT__" then error(_err) end\n'
        '            error(_err)\n'
        '          end\n'
        '        end\n'
        '      end\n'
    ),
    'CALL_MULTI': (
        '      local _nargs = _bc[_pc]\n'
        '      _pc = _pc + 1\n'
        '      local _nresults = _bc[_pc]\n'
        '      _pc = _pc + 1\n'
        '      local _func_slot = _sp - _nargs\n'
        '      local _func = _stack[_func_slot]\n'
        '\n'
        '      if _func == nil then\n'
        '        _sp = _func_slot - 1\n'
        '        _push(nil)\n'
        '      elseif type(_func) == "table" and _func.__func ~= nil then\n'
        '        _call_sp = _call_sp + 1\n'
        '        local _fid = _func.__func + 1\n'
        '        local _frame = _funcs[_fid]\n'
        '        _call_stack[_call_sp] = {\n'
        '          pc = 1,\n'
        '          bc = _frame.bc,\n'
        '          locals = {},\n'
        '          base_sp = _func_slot,\n'
        '          nparams = _frame.nparams,\n'
        '          want = _nresults,\n'
        '        }\n'
        '        -- VM内部函数: 返回值调整由 _return_func 的 want 机制完成,\n'
        '        -- 此处置哨兵跳过 handler 尾部的调整 (被调函数此时尚未执行)\n'
        '        _nresults = -1\n'
        '        local _cs = _call_stack[_call_sp]\n'
        '        for i = 1, _frame.nparams do\n'
        '          if i <= _nargs then\n'
        '            _cs.locals[i-1] = _stack[_func_slot + i]\n'
        '          end\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '      elseif type(_func) == "function" then\n'
        '        local _args = {}\n'
        '        for i = 1, _nargs do\n'
        '          _args[i] = _stack[_func_slot + i]\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '        -- 修复: pcall/xpcall 直接调用, 推送所有返回值 (避免双重pcall)\n'
        '        if _func == pcall or _func == xpcall then\n'
        '          local _mres = {_func(_unpack_fn(_args, 1, _nargs))}\n'
        '          for _ri = 1, #_mres do\n'
        '            _push(_mres[_ri])\n'
        '          end\n'
        '          if #_mres == 0 then\n'
        '            _push(nil)\n'
        '          end\n'
        '        -- 修复: os.exit等终止函数直接调用\n'
        '        elseif _func == error or _func == os.exit or (type(_func) == "table" and rawget(_func, "__bvm_exit")) then\n'
        '          _func(_unpack_fn(_args, 1, _nargs))\n'
        '          _push(nil)\n'
        '        else\n'
        '          local _results = {pcall(_func, _unpack_fn(_args, 1, _nargs))}\n'
        '          if _results[1] then\n'
        '            for _ri = 2, #_results do\n'
        '              _push(_results[_ri])\n'
        '            end\n'
        '            if #_results <= 1 then\n'
        '              _push(nil)\n'
        '            end\n'
        '          else\n'
        '            local _err = _results[2] or "VM call error"\n'
        '            if _err == "__EXIT__" then error(_err) end\n'
        '            error(_err)\n'
        '          end\n'
        '        end\n'
        '      else\n'
        '        -- 修复: 尝试直接调用 (支持 Java userdata / LuaJava 方法等可调用对象)\n'
        '        local _args = {}\n'
        '        for i = 1, _nargs do\n'
        '          _args[i] = _stack[_func_slot + i]\n'
        '        end\n'
        '        _sp = _func_slot - 1\n'
        '        -- 修复: 检查是否是exit标记的函数\n'
        '        if type(_func) == "table" and rawget(_func, "__bvm_exit") then\n'
        '          _func(_unpack_fn(_args, 1, _nargs))\n'
        '          _push(nil)\n'
        '        else\n'
        '          local _results = {pcall(_func, _unpack_fn(_args, 1, _nargs))}\n'
        '          if _results[1] then\n'
        '            for _ri = 2, #_results do\n'
        '              _push(_results[_ri])\n'
        '            end\n'
        '            if #_results <= 1 then\n'
        '              _push(nil)\n'
        '            end\n'
        '          else\n'
        '            local _err = _results[2] or "VM call error"\n'
        '            if _err == "__EXIT__" then error(_err) end\n'
        '            error(_err)\n'
        '          end\n'
        '        end\n'
        '      end\n'
        '      -- 修复: 调整返回值数量到 _nresults\n'
        '      --   n>0: 截断/补nil 到恰好 n 个; n==0: 丢弃全部 (右侧表达式多于左值)\n'
        '      if _nresults > 0 then\n'
        '        local _actual = _sp - _func_slot + 1\n'
        '        if _actual < 0 then _actual = 0 end\n'
        '        if _actual > _nresults then\n'
        '          -- 截断多余的 (从栈顶移除, 保留前 _nresults 个)\n'
        '          _sp = _func_slot + _nresults - 1\n'
        '        elseif _actual < _nresults then\n'
        '          -- 不足补 nil\n'
        '          for _ri = _actual + 1, _nresults do\n'
        '            _push(nil)\n'
        '          end\n'
        '        end\n'
        '      elseif _nresults == 0 then\n'
        '        _sp = _func_slot - 1\n'
        '      end\n'
    ),
    'CALL_NATIVE': (
        '      local _nargs = _bc[_pc]\n'
        '      _pc = _pc + 1\n'
        '      local _func_slot = _sp - _nargs\n'
        '      local _func = _stack[_func_slot]\n'
        '      _sp = _func_slot - 1\n'
        '\n'
        '      if type(_func) == "function" then\n'
        '        local _args = {}\n'
        '        for i = 1, _nargs do\n'
        '          _args[i] = _stack[_func_slot + i]\n'
        '        end\n'
        '        local _ok, _r1, _r2 = pcall(_func, _unpack_fn(_args, 1, _nargs))\n'
        '        if _ok then\n'
        '          _push(_r1)\n'
        '          if _r2 ~= nil then _push(_r2) end\n'
        '        else\n'
        '          error(_r1 or "native call error")\n'
        '        end\n'
        '      else\n'
        '        error("attempt to call non-native function")\n'
        '      end\n'
    ),
    'CONCAT': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(tostring(_a) .. tostring(_b))\n'
    ),
    'DIV': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      local _db = tonumber(_b) or 0\n'
        '      if _db == 0 then _push(0) else _push((tonumber(_a) or 0) / _db) end\n'
    ),
    'DUP': '      _push(_peek())',
    'EQ': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a == _b)\n'
    ),
    # ---- V8.6: EQ 条件跳过变体 (寄存器机语义, 不动栈) ----
    # 若 (R[A]==R[B]) == (C~=0) 则跳过紧随的 N 字节垃圾段 (多态垃圾填充载体)
    'EQ_SKIP': (
        '      local _ra = _bc[_pc]\n'
        '      local _rb = _bc[_pc+1]\n'
        '      local _rc = _bc[_pc+2]\n'
        '      local _nj = _bc[_pc+3]\n'
        '      _pc = _pc + 4\n'
        '      local _eq = _cs.locals[_ra] == _cs.locals[_rb]\n'
        '      if _eq == (_rc ~= 0) then _pc = _pc + _nj end\n'
    ),
    'GE': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a >= _b)\n'
    ),
    'GET_GLOBAL': (
        '      local _nidx = _bc[_pc] + _bc[_pc+1]*256 + 1\n'
        '      _pc = _pc + 2\n'
        '      local _name = _consts[_nidx]\n'
        '      if native_api and native_api[_name] ~= nil then\n'
        '        _push(native_api[_name])\n'
        '      elseif _globals[_name] ~= nil then\n'
        '        _push(_globals[_name])\n'
        '      else\n'
        '        _push(nil)  -- 改进: 移除_G回退, 防全局环境泄露\n'
        '      end\n'
    ),
    'GET_LOCAL': (
        '      local _slot = _bc[_pc] + _bc[_pc+1]*256\n'
        '      _pc = _pc + 2\n'
        '      _push(_cs.locals[_slot])\n'
    ),
    'GET_TABLE': (
        '      local _k = _pop()\n'
        '      local _t = _pop()\n'
        '      if _t == nil then\n'
        '          _push(nil)\n'
        '      elseif type(_t) == "table" then\n'
        '          _push(_t[_k])\n'
        '      elseif type(_t) == "string" then\n'
        '          -- 修复: 支持字符串方法调用 (通过string库)\n'
        '          _push(string[_k])\n'
        '      else\n'
        '          -- 修复: 其他类型尝试用元表索引 (userdata等)\n'
        '          local _ok, _v = pcall(function() return _t[_k] end)\n'
        '          if _ok then _push(_v) else _push(nil) end\n'
        '      end\n'
    ),
    'GT': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a > _b)\n'
    ),
    'HALT': '      break',
    'JMP': (
        '      local _addr = _bc[_pc] + _bc[_pc+1]*256\n'
        '      _pc = _addr + 1  -- +1: 编译器0-based → Lua 1-based索引\n'
    ),
    'JMP_FALSE': (
        '      local _addr = _bc[_pc] + _bc[_pc+1]*256\n'
        '      _pc = _pc + 2\n'
        '      if not _pop() then _pc = _addr + 1 end\n'
    ),
    'JMP_TRUE': (
        '      local _addr = _bc[_pc] + _bc[_pc+1]*256\n'
        '      _pc = _pc + 2\n'
        '      if _pop() then _pc = _addr + 1 end\n'
    ),
    'LAND': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a and _b)\n'
    ),
    'LE': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a <= _b)\n'
    ),
    'LEN': '      local _v = _pop(); if _v == nil or type(_v) ~= "string" and type(_v) ~= "table" then _push(0) else _push(#_v) end',
    'LNOT': '      _push(not _pop())',
    'LOR': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a or _b)\n'
    ),
    'LSHIFT': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_lshift(_a, _b))\n'
    ),
    'LT': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a < _b)\n'
    ),
    'MOD': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      local _db = tonumber(_b) or 0\n'
        '      if _db == 0 then _push(0) else _push((tonumber(_a) or 0) % _db) end\n'
    ),
    'MUL': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push((tonumber(_a) or 0) * (tonumber(_b) or 0))\n'
    ),
    'NE': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_a ~= _b)\n'
    ),
    'NEW_TABLE': '      _push({})',
    'NOP': '',
    # ---- V8.5: TFORLOOP 蹦床机制处理器 (Lua 5.1 寄存器机语义) ----
    # R[K] 即 _cs.locals[K] (local slot), R245-R248 为布尔状态寄存器组
    'TFORLOOP': (
        '      local _ra = _bc[_pc]\n'
        '      local _tgt = _bc[_pc+1] + _bc[_pc+2]*256\n'
        '      _pc = _pc + 3\n'
        '      if _cs.locals[_ra + 1] ~= nil then\n'
        '        _cs.locals[_ra] = _cs.locals[_ra + 1]\n'
        '        _pc = _tgt + 1\n'
        '      end\n'
    ),
    'TEST': (
        '      local _ra = _bc[_pc]\n'
        '      local _rc = _bc[_pc+1]\n'
        '      _pc = _pc + 2\n'
        '      local _rv = _cs.locals[_ra]\n'
        '      local _rt = (_rv ~= nil and _rv ~= false)\n'
        '      if _rt == (_rc ~= 0) then _pc = _pc + 4 end\n'
    ),
    'NOT': (
        '      local _ra = _bc[_pc]\n'
        '      local _rb = _bc[_pc+1]\n'
        '      _pc = _pc + 2\n'
        '      local _rv = _cs.locals[_rb]\n'
        '      _cs.locals[_ra] = (_rv == nil or _rv == false)\n'
    ),
    'POP': '      _pop()',
    'POW': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push((tonumber(_a) or 0) ^ (tonumber(_b) or 0))\n'
    ),
    'PUSH_CONST': (
        '      local _idx = _bc[_pc] + _bc[_pc+1]*256 + 1\n'
        '      _pc = _pc + 2\n'
        '      _push(_consts[_idx])\n'
    ),
    'PUSH_FALSE': '      _push(false)',
    'PUSH_NIL': '      _push(nil)',
    'PUSH_NUM': (
        '      _push(_bc[_pc])\n'
        '      _pc = _pc + 1\n'
    ),
    'PUSH_TRUE': '      _push(true)',
    'RETURN': '      _return_func()',
    'RSHIFT': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push(_rshift(_a, _b))\n'
    ),
    'SET_GLOBAL': (
        '      local _nidx = _bc[_pc] + _bc[_pc+1]*256 + 1\n'
        '      _pc = _pc + 2\n'
        '      local _name = _consts[_nidx]\n'
        '      _globals[_name] = _peek()\n'
    ),
    'SET_LOCAL': (
        '      local _slot = _bc[_pc] + _bc[_pc+1]*256\n'
        '      _pc = _pc + 2\n'
        '      _cs.locals[_slot] = _peek()\n'
    ),
    'SET_TABLE': (
        '      local _v = _pop()\n'
        '      local _k = _pop()\n'
        '      local _t = _pop()\n'
        '      if _t == nil then _t = {} end\n'
        '      if type(_t) == "table" then\n'
        '          _t[_k] = _v\n'
        '      end\n'
        '      _push(_t)\n'
    ),
    'SUB': (
        '      local _b = _pop()\n'
        '      local _a = _pop()\n'
        '      _push((tonumber(_a) or 0) - (tonumber(_b) or 0))\n'
    ),
    'SWAP': (
        '      local _a = _pop()\n'
        '      local _b = _pop()\n'
        '      _push(_a)\n'
        '      _push(_b)\n'
    ),
    'UNM': '      local _v = _pop(); if type(_v) == "number" then _push(-_v) else _push(0) end',
}

VM_INTERP_SUFFIX = (
    '\n'
    '  -- CFF: 函数指针表 (函数拆分 → 间接调用)\n'
    '  local _segs = {__SEGS_LIST__}\n'
    '  local _nsegs = __NSEGS__\n'
    '  -- 优化: 直接分发表 (state → 分段序号)。每条指令仅 1 次查表 + 1 次调用,\n'
    '  -- 取代旧版逐段试探(每条指令最多 nsegs 次调用), VM 执行提速数倍;\n'
    '  -- 分段结构/诱饵分支/反调试嵌入全部保持不变\n'
    '  local _seg_map = {}\n'
    '__SEGMAP_INIT__\n'
    '\n'
    '  -- 修复: 外部调用入口 — 使VM函数对象可被 pcall/setmetatable 等外部调用\n'
    '  -- 当内部VM通过 pcall 调用VM函数时, __call 元方法会调用此函数\n'
    '  _vm_call_external = function(_fid, ...)\n'
    '    local _eargs = {...}\n'
    '    local _enargs = select(\'#\', ...)\n'
    '    -- 保存当前VM状态\n'
    '    local _save_sp = _sp\n'
    '    local _save_stack = _stack\n'
    '    local _save_cs = _call_stack\n'
    '    local _save_csp = _call_sp\n'
    '    local _save_icnt = _icnt\n'
    '    -- 新建执行上下文 (复用同一组变量, 让 _push/_pop/segment函数 透明工作)\n'
    '    _stack = {}\n'
    '    _sp = 0\n'
    '    _call_stack = {}\n'
    '    _call_sp = 0\n'
    '    -- 设置调用帧\n'
    '    _call_sp = 1\n'
    '    local _eframe = _funcs[_fid + 1]\n'
    '    if not _eframe then error("VM: invalid function id " .. tostring(_fid)) end\n'
    '    _call_stack[1] = {pc = 1, bc = _eframe.bc, locals = {}, base_sp = 0, nparams = _eframe.nparams}\n'
    '    for _ei = 1, _eframe.nparams do\n'
    '      if _ei <= _enargs then\n'
    '        _call_stack[1].locals[_ei - 1] = _eargs[_ei]\n'
    '      end\n'
    '    end\n'
    '    -- 运行CFF主循环 (与主循环逻辑一致)\n'
    '    -- 修复: VM函数内部抛错(如 pcall 包装)时, 旧版嵌套循环中途夭折,\n'
    '    --   外层VM的栈/调用帧被嵌套上下文覆盖且永不恢复, 后续执行整体错位。\n'
    '    --   现以 pcall 包裹嵌套循环, 无论成败一律先恢复外层状态再重抛错误。\n'
    '    local _eres, _ercount = {}, 0\n'
    '    local _nok2, _nerr2 = pcall(function()\n'
    '      while _call_sp > 0 do\n'
    '        local _cs2 = _call_stack[_call_sp]\n'
    '        local _bc2 = _cs2.bc\n'
    '        local _pc2 = _cs2.pc\n'
    '        if _pc2 > #_bc2 then break end\n'
    '        local _op2 = _bc2[_pc2]\n'
    '        _pc2 = _pc2 + 1\n'
    '        _icnt = _icnt + 1\n'
    '        local _state2 = _X(_op2, _cff_mask)\n'
    '        local _seg_id2 = _seg_map[_state2]\n'
    '        if not _seg_id2 then error("VM ext call: unknown opcode " .. tostring(_op2)) end\n'
    '        local _new_pc2 = _segs[_seg_id2](_state2, _bc2, _pc2, _cs2)\n'
    '        if _new_pc2 == -1 then break end\n'
    '        if not _new_pc2 then error("VM ext call: invalid handler") end\n'
    '        _cs2.pc = _new_pc2\n'
    '      end\n'
    '      for _ei = 1, _sp do\n'
    '        _ercount = _ercount + 1\n'
    '        _eres[_ercount] = _stack[_ei]\n'
    '      end\n'
    '    end)\n'
    '    -- 恢复VM状态 (必须无条件执行)\n'
    '    _stack = _save_stack\n'
    '    _sp = _save_sp\n'
    '    _call_stack = _save_cs\n'
    '    _call_sp = _save_csp\n'
    '    _icnt = _save_icnt\n'
    '    if not _nok2 then error(_nerr2, 0) end\n'
    '    -- 返回所有结果\n'
    '    if _ercount > 0 then\n'
    '      return _unpack_fn(_eres, 1, _ercount)\n'
    '    end\n'
    '    return nil\n'
    '  end\n'
    '\n'
    '  -- CFF: 控制流平坦化主循环 (状态机驱动)\n'
    '  while _call_sp > 0 do\n'
    '    local _cs = _call_stack[_call_sp]\n'
    '    local _bc = _cs.bc\n'
    '    local _pc = _cs.pc\n'
    '    if _pc > #_bc then break end\n'
    '    local _op = _bc[_pc]\n'
    '    _pc = _pc + 1\n'
    '    _icnt = _icnt + 1\n'
    '\n'
    '    -- CFF: 掩码状态计算 + 直接分发\n'
    '    local _state = _X(_op, _cff_mask)\n'
    '    local _seg_id = _seg_map[_state]\n'
    '    if not _seg_id then error("unknown opcode: " .. tostring(_op)) end\n'
    '    local _new_pc = _segs[_seg_id](_state, _bc, _pc, _cs)\n'
    '\n'
    '    if _new_pc == -1 then break end\n'
    '    if not _new_pc then error("invalid handler") end\n'
    '    _cs.pc = _new_pc\n'
    '  end\n'
    '\n'
    '  return _stack[1]\n'
    'end\n'
    '\n'
    'return _vm_run\n'
    '\n'
)


def strip_lua_comments(code, keep_first_line=False):
    """移除 Lua 注释, 生成不含双连字符注释的纯净 Lua 代码。
    支持: 行注释、块注释( --[[ ]] 与 --[==[ ]==] )、
          长字符串([[ ]] / [==[ ]==])与短字符串("..." / '..')。
    字符串字面量内部的双连字符会被保留; 行注释被移除后保留换行维持行结构,
    并清理行尾空白。
    keep_first_line=True 时保留第一行 (脚本介绍), 仅剥离其余注释。
    """
    def _do_strip(text):
        out = []
        i = 0
        n = len(text)
        while i < n:
            c = text[i]
            if c == '[':
                j = i + 1
                eq = 0
                while j < n and text[j] == '=':
                    eq += 1
                    j += 1
                if j < n and text[j] == '[':
                    closer = ']' + '=' * eq + ']'
                    end = text.find(closer, j + 1)
                    if end == -1:
                        out.append(text[i:])
                        break
                    end += len(closer)
                    out.append(text[i:end])
                    i = end
                    continue
                out.append(c)
                i += 1
                continue
            if c == '"' or c == "'":
                quote = c
                out.append(c)
                i += 1
                while i < n:
                    ch = text[i]
                    if ch == '\\' and i + 1 < n:
                        out.append(ch)
                        out.append(text[i + 1])
                        i += 2
                        continue
                    out.append(ch)
                    if ch == quote:
                        i += 1
                        break
                    i += 1
                continue
            if c == '-' and i + 1 < n and text[i + 1] == '-':
                k = i + 2
                if k < n and text[k] == '[':
                    m = k + 1
                    eq2 = 0
                    while m < n and text[m] == '=':
                        eq2 += 1
                        m += 1
                    if m < n and text[m] == '[':
                        closer2 = ']' + '=' * eq2 + ']'
                        end2 = text.find(closer2, m + 1)
                        if end2 == -1:
                            i = n
                            break
                        i = end2 + len(closer2)
                        continue
                j = i + 2
                while j < n and text[j] != '\n':
                    j += 1
                i = j
                continue
            out.append(c)
            i += 1
        result = ''.join(out)
        return '\n'.join(ln.rstrip() for ln in result.split('\n'))

    if keep_first_line:
        nl = code.find('\n')
        if nl != -1:
            first_line = code[:nl + 1]
            rest = code[nl + 1:]
            if first_line.strip().startswith('--'):
                return first_line + _do_strip(rest)
        return _do_strip(code)
    return _do_strip(code)


def generate_vm_interpreter(op_map=None, cp_key=0, cff_mask=None, ad_params=None, enable_ad=False):
    """
    生成Lua端VM解释器代码 — 控制流平坦化 + 函数拆分 + 虚假控制流
    改进:
    - CFF: opcode经XOR掩码后通过状态机分发 (非直接if-elseif链)
    - 函数拆分: 51条指令随机分组到6-9个子函数, 通过函数指针表间接调用
    - 虚假控制流: 每个子函数插入永不执行的假分支 (语法合法)
    - 分散反调试: 默认关闭 (enable_ad=False, 已按要求消除全部Hook检测点);
      置 True 时反调试检测分散嵌入到多个分段函数中 (防 patch 单点绕过)
    - Opcode 随机化: 非连续随机编号 (0-255范围), 每次加密生成不同映射
    """
    if op_map is None:
        op_map = OP
    if cff_mask is None:
        cff_mask = random.randint(1, 254)

    # 分散反调试参数 (每次加密随机生成, 使 patch 无法复用)
    if ad_params is None:
        ad_params = {}
    ad_main_interval = ad_params.get('main_interval', random.choice([512, 1024, 2048, 3072, 4096]))

    # ---- 反调试状态初始化 (仅 enable_ad=True; 默认已消除全部Hook检测点) ----
    if enable_ad:
        _ad_state_init = (
            '  -- 分散反调试: 每分段独立计数器 + canary 值 (防 patch 单点绕过)\n'
            '  local _ad_cnt = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}\n'
            '  local _ad_canary = 1701\n'
        )
    else:
        _ad_state_init = ''

    # ---- 前缀 (VM 初始化代码, 注入常量池解密密钥 + CFF掩码) ----
    _prefix = (VM_INTERP_PREFIX
               .replace('__CP_KEY__', str(cp_key))
               .replace('__CFF_MASK__', str(cff_mask))
               .replace('__AD_STATE_INIT__', _ad_state_init))

    # ---- 随机化指令分组 (函数拆分) ----
    # 改进: 每次加密随机分组, 使攻击者无法复用之前的分段分析
    all_ops = list(op_map.keys())
    random.shuffle(all_ops)

    n_segs = random.randint(6, 9)
    seg_sizes = [len(all_ops) // n_segs] * n_segs
    for i in range(len(all_ops) % n_segs):
        seg_sizes[i] += 1

    SEGMENTS = {}
    idx = 0
    for si in range(n_segs):
        seg_ops = all_ops[idx:idx + seg_sizes[si]]
        idx += seg_sizes[si]
        if seg_ops:
            SEGMENTS[f's{si+1}'] = seg_ops

    n_actual_segs = len(SEGMENTS)

    # ---- 分配分散反调试检测到不同分段 ----
    # (仅 enable_ad=True 时启用; 默认已消除全部Hook/反调试检测点)
    seg_ad_map = {}
    if enable_ad:
        n_ad_checks = min(n_actual_segs - 1, random.randint(4, 6))
        ad_type_indices = list(range(len(AD_CHECK_TYPES)))
        random.shuffle(ad_type_indices)

        seg_names_shuffled = list(SEGMENTS.keys())
        random.shuffle(seg_names_shuffled)

        for i in range(n_ad_checks):
            seg_name = seg_names_shuffled[i]
            ad_type_idx = ad_type_indices[i]
            interval = random.choice([128, 256, 512, 768, 1024])
            seg_ad_map[seg_name] = (ad_type_idx, interval)

    # ---- 预计算所有真实opcode状态值 (确保虚假状态不与任何真实状态碰撞) ----
    all_real_states = set()
    for seg_name, op_names in SEGMENTS.items():
        for op_name in op_names:
            all_real_states.add(op_map[op_name] ^ cff_mask)

    # ---- 生成每个分段子函数 ----
    _segments_code = []
    used_states = set(all_real_states)  # 预填充所有真实状态

    for seg_id, (seg_name, op_names) in enumerate(SEGMENTS.items()):
        lines = [f'  local function _vm_{seg_name}(_state, _bc, _pc, _cs)']

        # 分散反调试: 在分段函数开头嵌入检测 (防 patch 单点绕过)
        # 不同分段使用不同检测类型 (A-H), 不同触发间隔 (仅 enable_ad=True)
        if enable_ad and seg_name in seg_ad_map:
            ad_type_idx, ad_interval = seg_ad_map[seg_name]
            _, ad_code = AD_CHECK_TYPES[ad_type_idx]
            lines.append(f'    _ad_cnt[{seg_id+1}] = _ad_cnt[{seg_id+1}] + 1')
            lines.append(f'    if _ad_cnt[{seg_id+1}] % {ad_interval} == 0 then')
            for cl in ad_code.split('\n'):
                lines.append(f'      {cl}')
            lines.append('    end')

        for i, op_name in enumerate(op_names):
            op_val = op_map[op_name]
            state_val = op_val ^ cff_mask  # CFF: 掩码状态值
            kw = 'if' if i == 0 else 'elseif'
            body = VM_OP_HANDLERS[op_name]
            # 为每个handler添加 return _pc (HALT返回-1表示break)
            if op_name == 'HALT':
                body = '      return -1\n'  # CFF: 直接返回-1, 主循环检测后break
            else:
                body = body.rstrip() + '\n      return _pc\n'
            lines.append(f'    {kw} _state == {state_val} then')
            # 缩进handler body
            for bl in body.split('\n'):
                if bl.strip():
                    lines.append(f'  {bl}' if not bl.startswith('      ') else bl)
        # 添加虚假控制流 (永不执行但语法合法的分支)
        # 修复: 虚假状态必须在所有真实状态之后选择, 避免与后续分段的真实状态碰撞
        fake_state = (0x42 + seg_id * 37 + 0x1B) % 256
        while fake_state in used_states:
            fake_state = (fake_state + 1) % 256
        used_states.add(fake_state)
        lines.append(f'    elseif _state == {fake_state} then')
        lines.append('      local _fx = _pop() _push(_fx * 2 + 1) _pop() _push(_fx) return _pc')
        lines.append('    end')
        lines.append('    return nil')
        lines.append('  end')
        _segments_code.append('\n'.join(lines))

    _segments_str = '\n'.join(_segments_code)

    # ---- 直接分发表初始化代码 (state → 分段序号, 随机排列) ----
    # 每个真实 opcode 的掩码状态映射到其所属分段的序号; 诱饵/虚假状态不进表
    _map_pairs = []
    for _si, (_seg_name, _op_names) in enumerate(SEGMENTS.items(), 1):
        for _op_name in _op_names:
            _map_pairs.append((op_map[_op_name] ^ cff_mask, _si))
    random.shuffle(_map_pairs)
    _map_lines = []
    _line = []
    for _st, _si in _map_pairs:
        _line.append(f'_seg_map[{_st}]={_si}')
        if len(_line) == 6:
            _map_lines.append('  ' + ' '.join(_line))
            _line = []
    if _line:
        _map_lines.append('  ' + ' '.join(_line))
    _segmap_init = '\n'.join(_map_lines)

    # ---- 后缀 (使用实际分段数 + 随机反调试间隔) ----
    _segs_list = ', '.join(f'_vm_{name}' for name in SEGMENTS.keys())
    if enable_ad:
        _ad_main_check = (
            '    -- 持续反调试 (主循环层, 随机间隔防 patch)\n'
            '    if _icnt % __AD_MAIN_INTERVAL__ == 0 then\n'
            '      if debug and debug.gethook then\n'
            '        local _hk_st, _hk_fn = pcall(debug.gethook)\n'
            '        if _hk_st and (type(_hk_fn) == "function") then if _PEN then _PEN() end error("d") end\n'
            '      end\n'
            '      -- 修复: 仅载入窗口内检测, 长时间运行的正经脚本不被误杀\n'
            '      if _icnt < 5000000 and _vm_t0 > 0 and os and os.clock then\n'
            '        local _tdiff = os.clock() - _vm_t0\n'
            '        if _tdiff > 60 then if _PEN then _PEN() end error("t") end\n'
            '      end\n'
            '    end\n'
        )
    else:
        # 已按要求消除全部Hook/反调试检测点 (默认)
        _ad_main_check = ''
    _suffix = (VM_INTERP_SUFFIX
               .replace('__SEGS_LIST__', _segs_list)
               .replace('__NSEGS__', str(n_actual_segs))
               .replace('__SEGMAP_INIT__', _segmap_init)
               .replace('__AD_MAIN_CHECK__', _ad_main_check)
               .replace('__AD_MAIN_INTERVAL__', str(ad_main_interval)))

    return strip_lua_comments(_prefix + _segments_str + _suffix)

# ============================================================
# Bootstrap VM (10 指令) — 消灭外层 load()
# ============================================================
# Bootstrap VM 环境表索引 (upvalue 闭包传递，消灭 _G 暴露)
# ============================================================

BS_ENV = {
    # --- 输入: 函数/数据 (由外层壳预先填入) ---
    '_sub': 1,
    '_mul': 2,
    '_mod': 3,
    '_ne': 4,
    '_extract': 5,
    '_bc_data_enc': 6,
    '_ks': 7,
    '_pr': 8,
    '_is': 9,
    '_r_chain_rev': 10,
    '_r_sbox': 11,
    '_r_xor': 12,
    '_cs1_calc': 13,
    '_cs2_calc': 14,
    '_ds': 15,
    '_sk_e': 16,
    '_setup_gg_bridge': 17,
    '_load_vm_interp': 18,
    '_error_fn': 19,     # error 函数
    # --- 临时: Bootstrap VM 运行时读写 ---
    '_dn': 20,
    '_d': 21,
    '_sk': 22,
    '_ks1': 23,
    '_ks2': 24,
    '_is1': 25,
    '_is2': 26,
    '_v1': 27,
    '_v2': 28,
    '_cc1': 29,
    '_cc2': 30,
    '_gg_bridge': 31,
    '_tmp_vm_loaded': 32,
    '_vm_run': 33,
    # --- 改进: 辅助函数 (32位密钥调度) ---
    '_xor': 34,         # XOR 运算
    '_pr_sk': 35,       # 从_sk构造3元素种子并调用_pr
    '_is_sk': 36,       # 从_sk构造2元素种子并调用_is
    # --- V8.6: 双层字符串保护 — 引导器构建 5 字节分块字符映射表 ---
    '_cmap': 37,        # 字符映射表 (M[存储字节]=明文字节, 256双射置换)
    '_build_cmap': 38,  # 构建函数 (外壳碎片提供, 引导器调用)
}

BS_OP = {
    'HALT': 0,          # 停止
    'PUSH_CONST': 1,    # +2 bytes: 常量索引 (LE)
    'GET_ENV': 2,       # +2 bytes: 环境表索引 (upvalue)
    'SET_ENV': 3,       # +2 bytes: 环境表索引 (upvalue)
    'CALL': 4,          # +1 byte: 参数个数
    'JMP': 5,           # +2 bytes: 地址 (LE)
    'JMP_FALSE': 6,     # +2 bytes: 地址 (LE)
    'NEW_TABLE': 7,     # 压入空表
    'GET_INDEX': 8,     # 弹出 key, 弹出 table, 压入 table[key]
    'SET_INDEX': 9,     # 弹出 val, 弹出 key, 弹出 table, table[key]=val, 压入 table
}

# Bootstrap VM 解释器各部分 (用于 per-build opcode 随机化)
BS_VM_INTERP_PREFIX = (
    '-- ===== Bootstrap VM (10 指令) =====\n'
    'local function _bvm_run(bs_data)\n'
    '  local _p = 1\n'
    '  local function _r16()\n'
    '    local v = bs_data[_p] + bs_data[_p+1]*256\n'
    '    _p = _p + 2; return v\n'
    '  end\n'
    '  local function _r32()\n'
    '    local v = bs_data[_p] + bs_data[_p+1]*256 + bs_data[_p+2]*65536 + bs_data[_p+3]*16777216\n'
    '    _p = _p + 4; return v\n'
    '  end\n'
    '  local _nc = _r16()\n'
    '  local _consts = {{}}\n'
    '  for i = 1, _nc do\n'
    '    local _t = bs_data[_p]; _p = _p + 1\n'
    '    if _t == 0 then\n'
    '      _consts[i] = nil\n'
    '    elseif _t == 1 then\n'
    '      local _len = _r32()\n'
    '      local _ch = {{}}\n'
    '      for j = 1, _len do _ch[j] = string.char(bs_data[_p+j-1]) end\n'
    '      _consts[i] = table.concat(_ch)\n'
    '      _p = _p + _len\n'
    '    elseif _t == 2 then\n'
    '      local _len = _r32()\n'
    '      local _ch = {{}}\n'
    '      for j = 1, _len do _ch[j] = string.char(bs_data[_p+j-1]) end\n'
    '      _consts[i] = tonumber(table.concat(_ch))\n'
    '      _p = _p + _len\n'
    '    elseif _t == 4 then\n'
    '      _consts[i] = bs_data[_p] == 1\n'
    '      _p = _p + 1\n'
    '    elseif _t == 5 then\n'
    '      local _len = _r32()\n'
    '      local _ch = {{}}\n'
    '      for j = 1, _len do _ch[j] = string.char(bs_data[_p+j-1]) end\n'
    '      _consts[i] = table.concat(_ch)\n'
    '      _p = _p + _len\n'
    '  end\n'
    '  end\n'
    '  local _bclen = _r32()\n'
    '  local _bc = {{}}\n'
    '  for i = 1, _bclen do _bc[i] = bs_data[_p+i-1] end\n'
    '  _p = _p + _bclen\n'
    '\n'
    '  local _stk = {{}}\n'
    '  local _sp = 0\n'
    '  local function _push(v) _sp=_sp+1; _stk[_sp]=v end\n'
    '  local function _pop() local v=_stk[_sp]; _stk[_sp]=nil; _sp=_sp-1; return v end\n'
    '\n'
    '  -- 兼容 LuaJ/Lua5.1: 一次性解析 unpack 函数引用\n'
    '  local _bvm_unpack = table.unpack or unpack\n'
    '  if not _bvm_unpack then\n'
    '    _bvm_unpack = function(t, i, j)\n'
    '      i = i or 1; j = j or #t\n'
    '      if i > j then return end\n'
    '      return t[i], _bvm_unpack(t, i+1, j)\n'
    '    end\n'
    '  end\n'
    '\n'
    '  local _pc = 1\n'
    '  while _pc <= _bclen do\n'
    '    local _op = _bc[_pc]; _pc = _pc + 1\n'
)

BS_OP_HANDLERS = {
    'HALT': '      break',
    'PUSH_CONST': (
        '      local _idx = _bc[_pc] + _bc[_pc+1]*256 + 1; _pc = _pc + 2\n'
        '      _push(_consts[_idx])\n'
    ),
    'GET_ENV': (
        '      local _idx = _bc[_pc] + _bc[_pc+1]*256 + 1; _pc = _pc + 2\n'
        '      _push(_env[_idx])\n'
    ),
    'SET_ENV': (
        '      local _idx = _bc[_pc] + _bc[_pc+1]*256 + 1; _pc = _pc + 2\n'
        '      _env[_idx] = _pop()\n'
    ),
    'CALL': (
        '      local _na = _bc[_pc]; _pc = _pc + 1\n'
        '      local _args = {{}}\n'
        '      for _i = 1, _na do _args[_na-_i+1] = _pop() end\n'
        '      local _fn = _pop()\n'
        '      if _fn == nil then _push(nil)\n'
        '      else\n'
        '      local _ok2, _res = pcall(_fn, _bvm_unpack(_args, 1, _na))\n'
        '      if not _ok2 then error(_res) end\n'
        '      _push(_res)\n'
        '      end\n'
    ),
    'JMP': '      _pc = _bc[_pc] + _bc[_pc+1]*256 + 1',
    'JMP_FALSE': (
        '      local _addr = _bc[_pc] + _bc[_pc+1]*256 + 1; _pc = _pc + 2\n'
        '      if not _pop() then _pc = _addr end\n'
    ),
    'NEW_TABLE': '      _push({{}})',
    'GET_INDEX': '      local _k = _pop(); local _t = _pop(); if _t == nil then _push(nil) elseif type(_t) == "table" then _push(_t[_k]) elseif type(_t) == "string" then _push(string[_k]) else local _ok, _v = pcall(function() return _t[_k] end); if _ok then _push(_v) else _push(nil) end end',
    'SET_INDEX': '      local _v = _pop(); local _k = _pop(); local _t = _pop(); if _t == nil then _t = {} end; if type(_t) == "table" then _t[_k]=_v end; _push(_t)',
}

BS_VM_INTERP_SUFFIX = (
    '    else\n'
    '      error("BSVM: unknown opcode " .. _op)\n'
    '    end\n'
    '  end\n'
    'end\n'
)

def generate_bootstrap_vm_interpreter(bs_op_map=None):
    """生成 Bootstrap VM 解释器 Lua 代码 (支持 per-build opcode 随机化)"""
    if bs_op_map is None:
        bs_op_map = BS_OP

    _prefix = BS_VM_INTERP_PREFIX
    _handlers = BS_OP_HANDLERS
    _suffix = BS_VM_INTERP_SUFFIX

    sorted_ops = sorted(bs_op_map.keys(), key=lambda k: bs_op_map[k])
    _branches = []
    for _i, _name in enumerate(sorted_ops):
        _num = bs_op_map[_name]
        _kw = "if" if _i == 0 else "elseif"
        _body = _handlers[_name]
        _branches.append(f"    {_kw} _op == {_num} then\n{_body}")

    _branch_chain = "\n".join(_branches)
    return strip_lua_comments(_prefix + _branch_chain + _suffix)


class BootstrapCompiler:
    """将初始化编排逻辑编译为 10 指令 bootstrap 字节码"""
    def __init__(self, op_map=None):
        self.op_map = op_map if op_map is not None else BS_OP
        self.constants = []
        self.const_cache = {}
        self.bytecode = []

    def add_const(self, value):
        key = (type(value).__name__, value)
        if key in self.const_cache:
            return self.const_cache[key]
        idx = len(self.constants)
        self.constants.append(value)
        self.const_cache[key] = idx
        return idx

    def emit(self, op):
        self.bytecode.append(op)

    def emit_u16(self, op, value):
        self.bytecode.append(op)
        self.bytecode.append(value & 0xFF)
        self.bytecode.append((value >> 8) & 0xFF)

    def push_const(self, value):
        idx = self.add_const(value)
        self.emit_u16(self.op_map['PUSH_CONST'], idx)

    def push_env(self, name):
        idx = BS_ENV[name] - 1  # 0-based for bytecode, +1 in Lua
        self.emit_u16(self.op_map['GET_ENV'], idx)

    def set_env(self, name):
        idx = BS_ENV[name] - 1
        self.emit_u16(self.op_map['SET_ENV'], idx)

    def call(self, nargs):
        self.emit(self.op_map['CALL'])
        self.bytecode.append(nargs)

    def jmp(self, addr):
        self.emit_u16(self.op_map['JMP'], addr)

    def jmp_false_placeholder(self):
        """发射 JMP_FALSE 占位，返回地址字节位置 (跳过 op 字节)"""
        self.emit_u16(self.op_map['JMP_FALSE'], 0)
        return len(self.bytecode) - 2  # 低位地址字节位置

    def patch_u16(self, pc, value):
        self.bytecode[pc] = value & 0xFF
        self.bytecode[pc + 1] = (value >> 8) & 0xFF

    def new_table(self):
        self.emit(self.op_map['NEW_TABLE'])

    def get_index(self):
        self.emit(self.op_map['GET_INDEX'])

    def set_index(self):
        self.emit(self.op_map['SET_INDEX'])

    def halt(self):
        self.emit(self.op_map['HALT'])

    def pc(self):
        return len(self.bytecode)

    def serialize(self):
        """序列化字节码 + 常量池 → 字节数组"""
        data = bytearray()
        # 常量数 (2 bytes)
        data.extend(struct.pack('<H', len(self.constants)))
        for c in self.constants:
            if c is None:
                data.append(0)
            elif isinstance(c, bool):
                data.append(4)
                data.append(1 if c else 0)
            elif isinstance(c, (int, float)):
                data.append(2)
                s = str(c).encode('utf-8')
                data.extend(struct.pack('<I', len(s)))
                data.extend(s)
            elif isinstance(c, bytes):
                data.append(5)  # raw bytes → Lua string
                data.extend(struct.pack('<I', len(c)))
                data.extend(c)
            elif isinstance(c, str):
                data.append(1)
                s = c.encode('utf-8')
                data.extend(struct.pack('<I', len(s)))
                data.extend(s)
        # 字节码长度 (4 bytes)
        data.extend(struct.pack('<I', len(self.bytecode)))
        data.extend(self.bytecode)
        return bytes(data)


def compile_bootstrap(seed, bc_data_enc, bclen, str_key, bc_key, bs_op_map=None,
                      vm_interp_enc_len=0, use_cmap=False):
    """
    编译初始化编排逻辑 → bootstrap 字节码
    序列化格式: [num_consts(2)] [consts...] [bc_len(2)] [bytecode...]
    """
    bc = BootstrapCompiler(op_map=bs_op_map)

    # 预计算校验和 (从加密数据前8字节提取)
    cs1_bytes = bytes(bc_data_enc[:4])
    cs2_bytes = bytes(bc_data_enc[4:8])

    # 修复: 错误消息加密须与 _ds 的16字节密钥派生一致
    # (旧版单字节XOR, bootstrap 报错时显示乱码而非 VM_ERR)
    enc_err = bytes([b ^ ((str_key * 31 + i * 17 + 163) % 256) for i, b in enumerate(b"VM_ERR")])

    # --- 1. 提取加密字节码数据 ---
    # _dn = _bclen - 8
    bc.push_env("_sub")
    bc.push_const(bclen)
    bc.push_const(8)
    bc.call(2)
    bc.set_env("_dn")

    # _d = _extract(_bc_data_enc, 9, _bclen)
    bc.push_env("_extract")
    bc.push_env("_bc_data_enc")
    bc.push_const(9)
    bc.push_const(bclen)
    bc.call(3)
    bc.set_env("_d")

    # --- 2. 密钥调度 (32位, 使用辅助函数) ---
    # _sk = _ks(_seed)
    bc.push_env("_ks")
    bc.push_const(seed)
    bc.call(1)
    bc.set_env("_sk")

    # 改进: _ks1 = _pr_sk(_sk, 1, 2, 3, _dn) — 正确的32位密钥调度
    bc.push_env("_pr_sk")
    bc.push_env("_sk")
    bc.push_const(1)
    bc.push_const(2)
    bc.push_const(3)
    bc.push_env("_dn")
    bc.call(5)
    bc.set_env("_ks1")

    # _ks2 = _pr_sk(_sk, 4, 5, 1, _dn)
    bc.push_env("_pr_sk")
    bc.push_env("_sk")
    bc.push_const(4)
    bc.push_const(5)
    bc.push_const(1)
    bc.push_env("_dn")
    bc.call(5)
    bc.set_env("_ks2")

    # _is1 = _is_sk(_sk, 2, 4)
    bc.push_env("_is_sk")
    bc.push_env("_sk")
    bc.push_const(2)
    bc.push_const(4)
    bc.call(3)
    bc.set_env("_is1")

    # _is2 = _is_sk(_sk, 3, 5)
    bc.push_env("_is_sk")
    bc.push_env("_sk")
    bc.push_const(3)
    bc.push_const(5)
    bc.call(3)
    bc.set_env("_is2")

    # _v1 = _xor(_sk[1], _sk[3]) — iv1 = sk[0] ^ sk[2]
    bc.push_env("_xor")
    bc.push_env("_sk")
    bc.push_const(1)
    bc.get_index()
    bc.push_env("_sk")
    bc.push_const(3)
    bc.get_index()
    bc.call(2)
    bc.set_env("_v1")

    # _v2 = _mod(_mul(_xor(_sk[2], _sk[5]), 7), 256) — iv2 = (sk[1]^sk[4])*7%256
    bc.push_env("_mod")
    bc.push_env("_mul")
    bc.push_env("_xor")
    bc.push_env("_sk")
    bc.push_const(2)
    bc.get_index()
    bc.push_env("_sk")
    bc.push_const(5)
    bc.get_index()
    bc.call(2)
    bc.push_const(7)
    bc.call(2)
    bc.push_const(256)
    bc.call(2)
    bc.set_env("_v2")

    # --- 3. 6轮解密 (R6→R1 逆序) ---
    # R6 rev: _r_chain_rev(_d, _v2, _dn)
    bc.push_env("_r_chain_rev")
    bc.push_env("_d")
    bc.push_env("_v2")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # R5 rev: _r_sbox(_d, _is2, _dn)
    bc.push_env("_r_sbox")
    bc.push_env("_d")
    bc.push_env("_is2")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # R4 rev: _r_xor(_d, _ks2, _dn)
    bc.push_env("_r_xor")
    bc.push_env("_d")
    bc.push_env("_ks2")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # R3 rev: _r_chain_rev(_d, _v1, _dn)
    bc.push_env("_r_chain_rev")
    bc.push_env("_d")
    bc.push_env("_v1")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # R2 rev: _r_sbox(_d, _is1, _dn)
    bc.push_env("_r_sbox")
    bc.push_env("_d")
    bc.push_env("_is1")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # R1 rev: _r_xor(_d, _ks1, _dn)
    bc.push_env("_r_xor")
    bc.push_env("_d")
    bc.push_env("_ks1")
    bc.push_env("_dn")
    bc.call(3)
    bc.set_env("_d")

    # --- 4. 校验和验证 (HMAC式, 密钥从seed派生) ---
    # cs1: _cs1_calc(_d, _dn, seed & 0xFF)
    bc.push_env("_cs1_calc")
    bc.push_env("_d")
    bc.push_env("_dn")
    bc.push_const(seed & 0xFF)
    bc.call(3)
    bc.set_env("_cc1")

    bc.push_env("_ne")
    bc.push_env("_cc1")
    bc.push_const(cs1_bytes)
    bc.call(2)
    jf1 = bc.jmp_false_placeholder()

    # error(_ds(enc_err, _sk_e))
    bc.push_env("_error_fn")
    bc.push_env("_ds")
    bc.push_const(enc_err)
    bc.push_env("_sk_e")
    bc.call(2)
    bc.call(1)

    ok1 = bc.pc()
    bc.patch_u16(jf1, ok1)

    # cs2: _cs2_calc(_d, _dn, (seed >> 8) & 0xFF)
    bc.push_env("_cs2_calc")
    bc.push_env("_d")
    bc.push_env("_dn")
    bc.push_const((seed >> 8) & 0xFF)
    bc.call(3)
    bc.set_env("_cc2")

    bc.push_env("_ne")
    bc.push_env("_cc2")
    bc.push_const(cs2_bytes)
    bc.call(2)
    jf2 = bc.jmp_false_placeholder()

    bc.push_env("_error_fn")
    bc.push_env("_ds")
    bc.push_const(enc_err)
    bc.push_env("_sk_e")
    bc.call(2)
    bc.call(1)

    ok2 = bc.pc()
    bc.patch_u16(jf2, ok2)

    # --- 5. 清除密钥材料 ---
    bc.push_const(None)
    bc.set_env("_ks1")
    bc.push_const(None)
    bc.set_env("_ks2")
    bc.push_const(None)
    bc.set_env("_is1")
    bc.push_const(None)
    bc.set_env("_is2")
    bc.push_const(None)
    bc.set_env("_sk")

    # --- 6. GG API 桥接 ---
    bc.push_env("_setup_gg_bridge")
    bc.call(0)
    bc.set_env("_gg_bridge")

    # --- 6.5 V8.6: 引导器构建字符映射表 (5 字节分块重建, 内层字符串保护) ---
    if use_cmap:
        bc.push_env("_build_cmap")
        bc.call(0)
        bc.set_env("_cmap")

    # --- 7. 解密并加载 VM 解释器 (VM解释器自加密) ---
    bc.push_env("_load_vm_interp")
    bc.call(0)
    bc.set_env("_tmp_vm_loaded")  # 消耗返回值

    # --- 8. 执行主 VM ---
    bc.push_env("_vm_run")
    bc.push_env("_d")
    bc.push_env("_gg_bridge")
    if use_cmap:
        bc.push_env("_cmap")
        bc.call(3)
    else:
        bc.call(2)

    bc.halt()

    return bc.serialize()


# ============================================================
# 白盒密码学密钥保护 (碎片化输出版 — 支持解密逻辑全文件散布)
# ============================================================

def generate_whitebox_keys(keys_dict, rng=None):
    """
    生成白盒密钥保护表 (碎片化输出):
    - 每个密钥 K 拆分为 3 个 XOR 分片: K = s1 ^ s2 ^ s3
    - 分片分散到 256 项混淆表中 (其余位置填充随机值)
    - 位置用 wb_table 派生的密钥 XOR 编码, 运行时解码
    - 改进: 输出拆分为 3 个独立 Lua 片段 (密钥表/位置表/派生函数),
      由外层壳随机散布到文件不同位置, 避免白盒派生逻辑集中暴露

    keys_dict: {'name': key_value, ...} (key_value: 0-255)
    返回: (wb_table_list, {'tbl','pos','fn'} 片段字典, key_name_to_index)
    """
    if rng is None:
        rng = random

    wb_table = [rng.randint(0, 255) for _ in range(256)]

    all_positions = list(range(256))
    rng.shuffle(all_positions)
    pos_ptr = 0

    key_name_to_index = {}
    pos_encoded = []
    key_data = []
    for i, (name, key_val) in enumerate(keys_dict.items()):
        s1 = rng.randint(0, 255)
        s2 = rng.randint(0, 255)
        s3 = (key_val ^ s1 ^ s2) & 0xFF
        p1 = all_positions[pos_ptr]; pos_ptr += 1
        p2 = all_positions[pos_ptr]; pos_ptr += 1
        p3 = all_positions[pos_ptr]; pos_ptr += 1
        wb_table[p1] = s1
        wb_table[p2] = s2
        wb_table[p3] = s3
        idx = i + 1
        key_name_to_index[name] = idx
        key_data.append((i, p1, p2, p3))

    for i, p1, p2, p3 in key_data:
        pk = (wb_table[i] ^ wb_table[i + 128]) & 0xFF
        pos_encoded.extend([p1 ^ pk, p2 ^ pk, p3 ^ pk])

    table_str = ','.join(str(x) for x in wb_table)
    pos_str = ','.join(str(x) for x in pos_encoded)

    pieces = {
        'tbl': '_wb_t = {' + table_str + '}',
        'pos': '_wb_pe = {' + pos_str + '}',
        'fn': (
            'function _wb_derive(_i)\n'
            '  local _pk = _X(_wb_t[_i], _wb_t[_i + 128])\n'
            '  local _p1 = _X(_wb_pe[(_i - 1) * 3 + 1], _pk)\n'
            '  local _p2 = _X(_wb_pe[(_i - 1) * 3 + 2], _pk)\n'
            '  local _p3 = _X(_wb_pe[(_i - 1) * 3 + 3], _pk)\n'
            '  return _X(_wb_t[_p1 + 1], _X(_wb_t[_p2 + 1], _wb_t[_p3 + 1]))\n'
            'end\n'
            'function _wb_clear() _wb_t = nil _wb_pe = nil _wb_derive = nil end'
        ),
    }
    return wb_table, pieces, key_name_to_index


# ============================================================
# AES 白盒解密 (碎片化输出 — 拆分为表/解码/阶段函数独立片段)
# ============================================================

def generate_aes_whitebox_lua(wb):
    """生成 AES 白盒解密的碎片化 Lua 代码 (10轮 CBC模式, 掩码化密钥)
    改进: 输出拆分为 11 个独立片段 (4组表 + 密钥解码 + 5个阶段函数 + 主调度),
    由外层壳随机散布到文件不同位置, 使 AES 解密流程无法被整体定位/patch
    返回: dict name -> lua code
    """
    last_parts = []
    for i in range(16):
        last_parts.append('{' + ','.join(str(b) for b in wb['last_tbl'][i]) + '}')
    last_code = '{' + ',\n  '.join(last_parts) + '}'

    imc_parts = []
    for i in range(4):
        rows = []
        for j in range(256):
            v = wb['imc_t'][i][j]
            rows.append('{' + str(v[0]) + ',' + str(v[1]) + ',' + str(v[2]) + ',' + str(v[3]) + '}')
        imc_parts.append('{' + ',\n    '.join(rows) + '}')
    imc_code = '{' + ',\n  '.join(imc_parts) + '}'

    rks_parts = []
    for rk in wb['round_rks_masked']:
        rks_parts.append('{' + ','.join(str(b) for b in rk) + '}')
    rks_code = '{' + ',\n  '.join(rks_parts) + '}'

    rkm_parts = []
    for mask in wb['rk_masks']:
        rkm_parts.append('{' + ','.join(str(b) for b in mask) + '}')
    rkm_code = '{' + ',\n  '.join(rkm_parts) + '}'

    fmask_code = '{' + ','.join(str(b) for b in wb['final_mask']) + '}'
    final_code = '{' + ','.join(str(b) for b in wb['final_rk_masked']) + '}'
    isb_code = '{' + ','.join(str(b) for b in wb['inv_sbox']) + '}'

    frags = {}
    # ---- 片段: 白盒表 (4 组, 独立散布) ----
    frags['tbl_last'] = '_aes_last = ' + last_code
    frags['tbl_imc'] = '_aes_imc = ' + imc_code
    frags['tbl_rks'] = '_aes_rks_m = ' + rks_code + '\n_aes_rkm = ' + rkm_code
    frags['tbl_fin'] = ('_aes_final_m = ' + final_code + '\n'
                        '_aes_fmask = ' + fmask_code + '\n'
                        '_aes_isb = ' + isb_code)

    # 优化: 预计算 st1 的字节来源索引映射 (旧版每字节做取模+乘加)
    ip1_map = []
    for _c in range(4):
        for _r in range(4):
            ip1_map.append(((_c - _r) % 4) * 4 + _r + 1)
    ip1_str = ','.join(str(v) for v in ip1_map)

    # ---- 片段: 轮密钥解码 (运行时还原掩码) + 逆移位映射 ----
    frags['decode'] = (
        '_aes_rk = {}\n'
        'for _ar = 1, 9 do\n'
        '  local _at = {}\n'
        '  for _ai = 1, 16 do _at[_ai] = _X(_aes_rks_m[_ar][_ai], _aes_rkm[_ar][_ai]) end\n'
        '  _aes_rk[_ar] = _at\n'
        'end\n'
        '_aes_frk = {}\n'
        'for _ai = 1, 16 do _aes_frk[_ai] = _X(_aes_final_m[_ai], _aes_fmask[_ai]) end\n'
        '_aes_isr = {}\n'
        'for _ac = 0, 3 do\n'
        '  for _aw = 0, 3 do\n'
        '    local _op = _ac * 4 + _aw\n'
        '    local _ic = (_ac - _aw) % 4\n'
        '    _aes_isr[_op + 1] = _ic * 4 + _aw + 1\n'
        '  end\n'
        'end\n'
        '_aes_ip1 = {' + ip1_str + '}'
    )

    # ---- 片段: 解密阶段函数 (5 个独立散布) ----
    frags['st1'] = (
        'function _aes_st1(data, bi)\n'
        '  local ns = {}\n'
        '  local T, M = _aes_last, _aes_ip1\n'
        '  for op = 1, 16 do\n'
        '    local ip = M[op]\n'
        '    ns[op] = T[ip][data[bi + ip - 1] + 1]\n'
        '  end\n'
        '  return ns\n'
        'end'
    )
    frags['st2'] = (
        'function _aes_st2(s, rn)\n'
        '  local rk_in = _aes_rk[rn]\n'
        '  local M1, M2, M3, M4 = _aes_imc[1], _aes_imc[2], _aes_imc[3], _aes_imc[4]\n'
        '  for i = 1, 16 do s[i] = _X(s[i], rk_in[i]) end\n'
        '  local ns2 = {}\n'
        '  for c = 0, 3 do\n'
        '    local b = c * 4\n'
        '    local t0 = M1[s[b + 1] + 1]\n'
        '    local t1 = M2[s[b + 2] + 1]\n'
        '    local t2 = M3[s[b + 3] + 1]\n'
        '    local t3 = M4[s[b + 4] + 1]\n'
        '    ns2[b + 1] = _X(t0[1], t1[1], t2[1], t3[1])\n'
        '    ns2[b + 2] = _X(t0[2], t1[2], t2[2], t3[2])\n'
        '    ns2[b + 3] = _X(t0[3], t1[3], t2[3], t3[3])\n'
        '    ns2[b + 4] = _X(t0[4], t1[4], t2[4], t3[4])\n'
        '  end\n'
        '  return ns2\n'
        'end'
    )
    frags['st3'] = (
        'function _aes_st3(s)\n'
        '  local ns3 = {}\n'
        '  local R, B = _aes_isr, _aes_isb\n'
        '  for i = 1, 16 do ns3[i] = B[s[R[i]] + 1] end\n'
        '  return ns3\n'
        'end'
    )
    frags['st4'] = (
        'function _aes_st4(s, prev)\n'
        '  local F = _aes_frk\n'
        '  for i = 1, 16 do s[i] = _X(s[i], F[i], prev[i]) end\n'
        '  return s\n'
        'end'
    )
    frags['st5'] = (
        'function _aes_st5(result)\n'
        '  local pad = result[#result]\n'
        '  if pad >= 1 and pad <= 16 then\n'
        '    local ok = true\n'
        '    for i = #result - pad + 1, #result do\n'
        '      if result[i] ~= pad then ok = false break end\n'
        '    end\n'
        '    if ok then\n'
        '      local r2 = {}\n'
        '      for i = 1, #result - pad do r2[i] = result[i] end\n'
        '      return r2\n'
        '    end\n'
        '  end\n'
        '  return result\n'
        'end'
    )

    # ---- 片段: 主调度 (链式调用各阶段) ----
    frags['main'] = (
        'function _aes_decrypt(data)\n'
        '  local st1, st2, st3, st4, st5 = _aes_st1, _aes_st2, _aes_st3, _aes_st4, _aes_st5\n'
        '  local n = #data\n'
        '  local result = {}\n'
        '  local ri = 1\n'
        '  local prev = {}\n'
        '  for i = 1, 16 do prev[i] = data[i] end\n'
        '  local bi = 17\n'
        '  while bi <= n do\n'
        '    local s = st1(data, bi)\n'
        '    for rn = 1, 9 do\n'
        '      s = st2(s, rn)\n'
        '      s = st3(s)\n'
        '    end\n'
        '    s = st4(s, prev)\n'
        '    for i = 1, 16 do result[ri] = s[i] ri = ri + 1 end\n'
        '    prev = {}\n'
        '    for i = 1, 16 do prev[i] = data[bi + i - 1] end\n'
        '    bi = bi + 16\n'
        '  end\n'
        '  return st5(result)\n'
        'end'
    )
    return frags


# ============================================================
# 解密碎片散布引擎 (V8-Scatter)
# ============================================================

def _topo_shuffle(frags):
    """碎片随机拓扑排序: 在满足依赖约束的前提下, 每次生成不同的全文件布局。
    frags: {name: {'code': str, 'deps': [前置碎片名]}}
    返回: 拓扑有序的碎片名列表"""
    names = set(frags.keys())
    deps = {}
    for k, v in frags.items():
        d = set(v.get('deps', []))
        d.discard(k)
        deps[k] = d & names
    order = []
    placed = set()
    remaining = set(names)
    while remaining:
        ready = sorted(k for k in remaining if deps[k] <= placed)
        if not ready:
            raise RuntimeError('fragment dependency cycle: %s' % sorted(remaining))
        pick = random.choice(ready)
        order.append(pick)
        placed.add(pick)
        remaining.discard(pick)
    return order


def _build_round_fragment(rnd_no, slot, km_map):
    """构建第 rnd_no 逆向轮的独立轮函数片段, 存入 _RND[slot]。
    km_map: 密钥材料槽位映射 (每次加密随机化, 对抗固定偏移分析)"""
    n1 = '_r' + random.choice('abcdefgh') + str(random.randint(0, 9))
    n2 = '_r' + random.choice('ijklmnop') + str(random.randint(0, 9))
    style = random.randint(0, 1)
    dn_s = '_KM[%d]' % km_map['dn']
    if rnd_no in (6, 3):
        ks_slot = km_map['v2'] if rnd_no == 6 else km_map['v1']
        if style == 0:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  for i = %s, 2, -1 do buf[i] = _X(buf[i], buf[i-1]) end\n'
                '  buf[1] = _X(buf[1], %s)\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
        else:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  local i = %s\n'
                '  while i > 1 do buf[i] = _X(buf[i], buf[i-1]) i = i - 1 end\n'
                '  buf[1] = _X(buf[1], %s)\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
    elif rnd_no in (5, 2):
        ks_slot = km_map['is2'] if rnd_no == 5 else km_map['is1']
        if style == 0:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  for i = 1, %s do buf[i] = %s[buf[i]] end\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
        else:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  local i = 1\n'
                '  while i <= %s do buf[i] = %s[buf[i]] i = i + 1 end\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
    else:
        ks_slot = km_map['ks2'] if rnd_no == 4 else km_map['ks1']
        if style == 0:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  for i = 1, %s do buf[i] = _X(buf[i], %s[i]) end\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
        else:
            body = (
                '  local %s = %s\n'
                '  local %s = _KM[%d]\n'
                '  local i = 1\n'
                '  while i <= %s do buf[i] = _X(buf[i], %s[i]) i = i + 1 end\n'
            ) % (n1, dn_s, n2, ks_slot, n1, n2)
    return '_RND[%d] = function(buf)\n%s  return buf\nend' % (slot, body)


def _build_decoy_round_fragment(slot, km_map):
    """构建诱饵轮函数 (永不执行, 仅干扰定位: 调度序列不引用该槽位)"""
    style = random.randint(0, 2)
    if style == 0:
        return (
            '_RND[%d] = function(buf)\n'
            '  local _dc = 0\n'
            '  local _dl = (_KM[%d] %% 3) + 1\n'
            '  for i = 1, _dl do _dc = _X(_dc, buf[i] or 0) end\n'
            '  return buf\n'
            'end'
        ) % (slot, km_map['dn'])
    if style == 1:
        return (
            '_RND[%d] = function(buf)\n'
            '  local _dc = _X(_KM[%d], _KM[%d])\n'
            '  if _dc > 4095 then return buf end\n'
            '  return buf\n'
            'end'
        ) % (slot, km_map['v1'], km_map['v2'])
    return (
        '_RND[%d] = function(buf)\n'
        '  local _dp = {0, 0, 0, 0}\n'
        '  for i = 1, 4 do _dp[i] = _X(i * 37, _KM[%d]) end\n'
        '  return buf\n'
        'end'
    ) % (slot, km_map['dn'])


def _build_noise_fragment():
    """构建诱饵噪声函数 (语法合法、永不调用的干扰项)"""
    style = random.randint(0, 3)
    fname = '_pz' + random.choice('abcdefghjk') + str(random.randint(10, 99))
    if style == 0:
        return (
            'local function %s(seed)\n'
            '  local t = {}\n'
            '  local st = (seed or 7) %% 251 + 7\n'
            '  for i = 1, 16 do st = (st * 17 + 31) %% 256 t[i] = _X(st, i * 13) end\n'
            '  return t\n'
            'end'
        ) % fname
    if style == 1:
        return (
            'local function %s(n)\n'
            '  local r = {}\n'
            '  for i = 1, (n or 8) do r[i] = (i * 31) %% 251 end\n'
            '  return table.concat(r, ",")\n'
            'end'
        ) % fname
    if style == 2:
        return (
            'local function %s(data)\n'
            '  local s = 0\n'
            '  for i = 1, #data do s = (s * 31 + data[i]) %% 65521 end\n'
            '  return s\n'
            'end'
        ) % fname
    return (
        'local function %s(a, b)\n'
        '  local t = {}\n'
        '  for i = 0, 255 do t[i] = _X(((a or 1) * i + (b or 3)) %% 256, i) end\n'
        '  return t\n'
        'end'
    ) % fname


# ============================================================
# 外层 Emoji 壳 (Bootstrap VM 版 — 零 load() + 解密逻辑碎片化散布)
# ============================================================

def generate_outer_shell(bc_data, inner_seed, outer_seed, str_key, bc_key, op_map=None, bs_op_map=None, cp_key=0, cff_mask=None, ad_params=None, return_info=False, enable_ad=False, str_map=None, api_key=None, guards=True, guard_decoy=False, guard_strict=False):
    """生成外层壳: bootstrap VM + 加密 bootstrap 字节码 + 加密 VM 解释器
    V8-Scatter 改进 (解密逻辑碎片化分散, 让破解者更难定位/复用分析):
    - 6轮解密拆分为 6 个独立轮函数 + 2~5 个诱饵轮, 随机槽位存入 _RND 表,
      真实执行顺序以 XOR 编码序列运行时还原
    - 密钥材料槽位 (ks1/ks2/is1/is2/v1/v2/dn) 每次加密随机重映射
    - 字符串解密/V5虚拟机/密钥调度/S盒/白盒表/AES白盒解密 全部拆分为独立碎片,
      以随机拓扑序散布全文件 (依赖约束自动满足, 保证每次都能正常运行)
    - 碎片间插入随机诱饵函数; 每次加密生成不同的布局 (对抗签名/地址分析)
    """
    if cff_mask is None:
        cff_mask = random.randint(1, 254)
    # V5 加密 VM 字节码 (用 inner_seed)
    encrypted_bc = encrypt_v5_32(bc_data, inner_seed)
    enc_bclen = len(encrypted_bc)

    # 48+3 指令 VM 解释器 (注入常量池解密密钥 + CFF掩码; enable_ad=False 时无任何Hook检测点)
    vm_code = generate_vm_interpreter(op_map, cp_key=cp_key, cff_mask=cff_mask, ad_params=ad_params, enable_ad=enable_ad)
    # 优化: 压缩解释器源码行首缩进 — AES 载荷减小约 15%, 解密+loadstring 双提速
    # (守卫: 解释器不含长字符串, 此压缩安全)
    if '[=' not in vm_code and '[[' not in vm_code:
        vm_code = re.sub(r'\n[ \t]+', '\n', vm_code)
    # 10 指令 Bootstrap VM 解释器
    bvm_code = generate_bootstrap_vm_interpreter(bs_op_map)

    # === VM 解释器自身加密 ===
    # 将 VM 解释器代码转为字节并 AES-10 CBC 加密
    vm_code_bytes = vm_code.encode('utf-8')
    # AES密钥从全部4个种子派生 (2^32 密钥空间)
    vm_aes_key = bytes([(inner_seed * 31 + outer_seed * 17 + str_key * 13 + bc_key * 7 + i * 37 + 0x5A) % 256 for i in range(16)])
    wb_tables = aes_whitebox_build(vm_aes_key, seed=(inner_seed * 256 + outer_seed))
    vm_interp_enc = aes_encrypt_cbc(vm_code_bytes, vm_aes_key)
    # 解密后完整性期望值 (嵌入 lvmi 碎片, 载入时校验 AES 解密结果)
    vm_interp_chk = 0
    for _b in vm_code_bytes:
        vm_interp_chk = (vm_interp_chk * 31 + _b) % 65521
    vm_interp_enc_len = len(vm_interp_enc)
    # 优化: Emoji 字符串存储 (Lua 解析一个长字符串字面量远快于数万个数字 token)
    _vmi_emoji = encode_emoji(vm_interp_enc)

    # 编译 bootstrap 字节码 (传入加密后长度; use_cmap: 引导器构建 5 字节分块字符映射表)
    bootstrap_bc = compile_bootstrap(inner_seed, encrypted_bc, enc_bclen, str_key, bc_key, bs_op_map,
                                     vm_interp_enc_len=vm_interp_enc_len,
                                     use_cmap=(str_map is not None))
    # V5 加密 bootstrap 字节码
    bootstrap_enc = encrypt_v5_32(bootstrap_bc, outer_seed)
    # Emoji 编码
    bootstrap_emoji = encode_emoji(bootstrap_enc)

    # 加密 V5 VM 字节码 (KDF/PRNG)
    enc_prng = encrypt_bytecode(VM_BC_PRNG, bc_key)
    enc_kdf = encrypt_bytecode(VM_BC_KDF, bc_key)
    bc_chk = bc_checksum(VM_BC_PRNG)
    enc_err = encrypt_string("ERR", str_key)

    bc_prng_str = ','.join(str(x) for x in enc_prng)
    bc_kdf_str = ','.join(str(x) for x in enc_kdf)

    # 加密的 VM 字节码 (V5加密, Emoji 存储)
    _bc_emoji = encode_emoji(encrypted_bc)

    # === 白盒密码学密钥保护 (碎片化) ===
    wb_keys = {
        'outer_b0': outer_seed & 0xFF,
        'outer_b1': (outer_seed >> 8) & 0xFF,
        'outer_b2': (outer_seed >> 16) & 0xFF,
        'outer_b3': (outer_seed >> 24) & 0xFF,
        'str_key': str_key,
        'bc_key': bc_key,
    }
    _, wb_pieces, wb_idx = generate_whitebox_keys(wb_keys)

    # === AES 白盒解密碎片 ===
    aes_frags = generate_aes_whitebox_lua(wb_tables)

    # === 轮函数槽位分配 (6真实轮 + 2~5诱饵轮 → 随机槽位) ===
    n_decoy_rounds = random.randint(2, 5)
    n_slots = 6 + n_decoy_rounds
    slot_pool = list(range(1, n_slots + 1))
    random.shuffle(slot_pool)
    slot_of = {}
    for _ri, _r in enumerate([6, 5, 4, 3, 2, 1]):
        slot_of[_r] = slot_pool[_ri]
    seq_key = random.randint(1, 255)
    seq_enc = [slot_of[r] ^ seq_key for r in (6, 5, 4, 3, 2, 1)]
    seq_str = ','.join(str(v) for v in seq_enc)
    decoy_slots = slot_pool[6:]

    # === 密钥材料槽位随机重映射 (对抗固定偏移分析) ===
    km_slots = list(range(1, 17))
    random.shuffle(km_slots)
    km_map = {'ks1': km_slots[0], 'ks2': km_slots[1], 'is1': km_slots[2],
              'is2': km_slots[3], 'v1': km_slots[4], 'v2': km_slots[5],
              'dn': km_slots[6]}

    # ============================================================
    # 碎片注册 (name -> {code, deps}) — deps 为必须前置的碎片名
    # ============================================================
    frags = {}

    def add(name, code, deps=None):
        frags[name] = {'code': code, 'deps': list(deps or [])}

    # ---- 白盒密钥碎片 (3 片独立散布) ----
    add('wb_t', wb_pieces['tbl'])
    add('wb_pe', wb_pieces['pos'])
    add('wb_derive', wb_pieces['fn'])
    add('wb_keys', (
        f"_s = _wb_derive({wb_idx['outer_b0']}) + _wb_derive({wb_idx['outer_b1']})*256"
        f" + _wb_derive({wb_idx['outer_b2']})*65536 + _wb_derive({wb_idx['outer_b3']})*16777216\n"
        f"_sk_e = _wb_derive({wb_idx['str_key']})\n"
        f"_bc_e = _wb_derive({wb_idx['bc_key']})"
    ), deps=['wb_t', 'wb_pe', 'wb_derive'])

    # ---- 字符串/字节码解密函数碎片 ----
    add('ds', (
        'function _ds(enc, key)\n'
        '  local _kb = {}\n'
        '  for i = 0, 15 do _kb[i+1] = (key*31 + i*17 + 163) % 256 end\n'
        '  local r = {}\n'
        '  for i = 1, #enc do r[i] = string.char(_X(enc:byte(i), _kb[((i-1)%16)+1])) end\n'
        '  return table.concat(r)\n'
        'end'
    ))
    add('dbc', (
        'function _dbc(enc, key)\n'
        '  local _kb = {}\n'
        '  for i = 0, 15 do _kb[i+1] = (key*31 + i*17 + 163) % 256 end\n'
        '  local r = {}\n'
        '  for i = 1, #enc do r[i] = _X(enc[i], _kb[((i-1)%16)+1]) end\n'
        '  return r\n'
        'end'
    ))

    # ---- V5 VM 解释器 (KDF/PRNG 核心) ----
    add('v5vm', f'''function _vm(bc, r0, r1, r2, r3, r4)
  local reg = {{r0 or 0, r1 or 0, r2 or 0, r3 or 0, r4 or 0, 0, 0, 0}}
  local pc = 1; local n = #bc
  while pc <= n - 2 do
    local op = bc[pc]; local dst = bc[pc+1] + 1; local arg = bc[pc+2]
    if op == 0 then break
    elseif op == 1 then reg[dst] = arg
    elseif op == 2 then reg[dst] = reg[arg+1]
    elseif op == 3 then reg[dst] = reg[dst] + arg
    elseif op == 4 then reg[dst] = reg[dst] + reg[arg+1]
    elseif op == 5 then reg[dst] = reg[dst] * arg
    elseif op == 6 then reg[dst] = reg[dst] * reg[arg+1]
    elseif op == 7 then reg[dst] = reg[dst] % arg
    elseif op == 8 then reg[dst] = _X(reg[dst], reg[arg+1])
    elseif op == 9 then reg[dst] = _X(reg[dst], arg)
    end
    pc = pc + 3
  end
  return reg[1], reg[2], reg[3], reg[4], reg[5]
end''')

    # ---- 密钥调度接口碎片 ----
    add('ps', 'function _ps(s1, s2, s3) local a, b, c, d = _vm(_bc_prng, s1, s2, s3, 0, 0) return a, b, c, d end')
    add('kd', 'function _kd(s, idx) local a = _vm(_bc_kdf, s, idx, 0, 0, 0) return a end')
    add('ks', (
        'function _ks(s32)\n'
        '  local _seeds = {s32 % 256, math.floor(s32/256) % 256, math.floor(s32/65536) % 256, math.floor(s32/16777216) % 256}\n'
        '  local _t = {}\n'
        '  for _si = 1, 4 do\n'
        '    local _sv = _seeds[_si]\n'
        '    for i = 1, 5 do\n'
        '      local _k = _kd(_sv, i)\n'
        '      _t[i] = _X((_t[i] or 0), _k) % 256\n'
        '    end\n'
        '  end\n'
        '  return _t\n'
        'end'
    ))
    add('pr', (
        'function _pr(sk3, n)\n'
        '  local a, b, c = sk3[1], sk3[2], sk3[3]\n'
        '  local r = {}\n'
        '  for i = 1, n do a, b, c, r[i] = _ps(a, b, c) end\n'
        '  return r\n'
        'end'
    ))
    add('sb', (
        'function _sb(seeds)\n'
        '  local t = {}\n'
        '  for i = 0, 255 do t[i] = i end\n'
        '  for _si = 1, #seeds do\n'
        '    local st = seeds[_si]\n'
        '    for i = 255, 1, -1 do st = (st*17 + 31) % 256 local j = st % (i+1) t[i], t[j] = t[j], t[i] end\n'
        '  end\n'
        '  return t\n'
        'end'
    ))
    add('is', 'function _is(seeds) local f = _sb(seeds) local r = {} for i = 0, 255 do r[f[i]] = i end return r end')

    # ---- 载入期解密步骤 (依赖约束排序) ----
    add('bcd', (
        f"_bc_prng = _dbc({{{bc_prng_str}}}, _bc_e)\n"
        f"_bc_kdf = _dbc({{{bc_kdf_str}}}, _bc_e)"
    ), deps=['dbc', 'wb_keys'])
    add('bcchk', (
        'local _bc_chk = 0\n'
        'for i = 1, #_bc_prng do _bc_chk = (_bc_chk * 31 + _bc_prng[i]) % 65521 end\n'
        f'if _bc_chk ~= {bc_chk} then error(_ds("{enc_err}", _sk_e)) end'
    ), deps=['bcd', 'ds', 'wb_keys'])
    add('sk', '_sk = _ks(_s)', deps=['ks', 'kd', 'v5vm', 'bcd', 'wb_keys'])
    add('km1', (
        f"_KM[{km_map['ks1']}] = _pr({{_sk[1], _sk[2], _sk[3]}}, _KM[{km_map['dn']}])\n"
        f"_KM[{km_map['is1']}] = _is({{_sk[2], _sk[4]}})"
    ), deps=['sk', 'pr', 'ps', 'is', 'sb', 'bcd'])
    add('km2', (
        f"_KM[{km_map['ks2']}] = _pr({{_sk[4], _sk[5], _sk[1]}}, _KM[{km_map['dn']}])\n"
        f"_KM[{km_map['is2']}] = _is({{_sk[3], _sk[5]}})\n"
        f"_KM[{km_map['v1']}] = _X(_sk[1], _sk[3]) % 256\n"
        f"_KM[{km_map['v2']}] = (_X(_sk[2], _sk[5]) % 256) * 7 % 256"
    ), deps=['sk', 'pr', 'ps', 'is', 'sb', 'bcd'])

    # ---- 反调试/Hook 检测点 (V8.5 已按要求全部消除) ----
    # 旧版的 ad1/ad2/ad3 三段反调试碎片 (gethook检测/函数指纹/string.dump检测/
    # 时间异常/getinfo检测/_G扫描/多路径时间戳) 及 VM 内分散检测点已全部移除,
    # 仅保留与防篡改相关的完整性校验 (bcchk/lvmi 校验和), 不再有任何 hook 点。
    # 需要 --keep-antidebug 可恢复旧行为。
    if enable_ad:
        add('ad1', f'''-- ===== 高级防调试系统 (多层检测, 兼容 LuaJ/GG 环境) =====
local _ad_ok = true

local function _ad_spl(s,sep) local t={{}} local st=1 while true do local p=s:find(sep,st,true) if not p then t[#t+1]=s:sub(st) break end t[#t+1]=s:sub(st,p-1) st=p+#sep end return t end

-- === 第一层: 主动调试器 Hook 检测 (检测 sethook 是否被激活) ===
-- LuaJ/GG 环境有 debug 库但不会设置 hook; 调试器会设置 hook
-- debug.gethook() 返回: hook_fn, mask_string, count
-- 无 hook 时: hook_fn=nil, mask=""
-- 有 hook 时: hook_fn=function, mask="l"/"c"/"r" 等
if debug and debug.gethook then
  local _ad_hk_st, _ad_hk_fn, _ad_hk_mask = pcall(debug.gethook)
  if _ad_hk_st then
    -- 方式1: hook 函数存在 = 被调试
    if type(_ad_hk_fn) == "function" then _ad_ok = false end
    -- 方式2: mask 非空 = 被调试
    if type(_ad_hk_mask) == "string" and _ad_hk_mask ~= "" then _ad_ok = false end
  end
end

-- === 第二层: 关键函数行为指纹校验 (检测 Hook/替换) ===
-- pcall 完整性: pcall(function() return 1,2,3 end) 应返回 true,1,2,3
local _ad_po, _ad_p1, _ad_p2, _ad_p3 = pcall(function() return 1, 2, 3 end)
if not _ad_po or _ad_p1 ~= 1 or _ad_p2 ~= 2 or _ad_p3 ~= 3 then _ad_ok = false end
-- error 函数行为: error() 应抛出异常
local _ad_eo = pcall(function() error("__ad_test__") end)
if _ad_eo then _ad_ok = false end
-- type 函数一致性
if type(1) ~= "number" or type("a") ~= "string" or type({{}}) ~= "table" then _ad_ok = false end
-- tostring/tonumber 一致性
if tostring(123) ~= "123" then _ad_ok = false end
if tonumber("456") ~= 456 then _ad_ok = false end
-- setmetatable/rawequal 一致性
local _ad_t1 = {{}}; local _ad_t2 = _ad_t1
if not rawequal(_ad_t1, _ad_t2) then _ad_ok = false end
local _ad_mt = {{}}; setmetatable(_ad_t1, _ad_mt)
if getmetatable(_ad_t1) ~= _ad_mt then _ad_ok = false end''', deps=['ds', 'wb_keys'])
        add('ad2', f'''-- === 第三层: 字节码 Dump 尝试检测 (检测主动 dump 行为) ===
-- 只检测有人尝试 dump 我们的函数 (主动行为), 不检测 string.dump 是否存在
local _ad_fn_canary = function() return 1701 end
if string and string.dump then
  local _ad_dst, _ad_dmp = pcall(function() return string.dump(_ad_fn_canary) end)
  if _ad_dst and type(_ad_dmp) == "string" then
    -- string.dump 能成功 = 可能被用于 dump 字节码
    -- 但 LuaJ 可能也支持, 所以只记录不拦截
  end
end
-- 验证函数未被篡改 (自校验)
if _ad_fn_canary() ~= 1701 then _ad_ok = false end

-- === 第四层: 时间异常检测 (防单步调试, 兼容 LuaJ 较慢的特性) ===
if os and os.clock then
  local _ad_t1 = os.clock()
  local _ad_sum = 0
  for _ad_i=1,100 do _ad_sum = _ad_sum + _ad_i end
  local _ad_t2 = os.clock()
  -- 时间倒流 = 被篡改; 超过 5 秒 = 被单步调试 (LuaJ 较慢, 阈值放宽)
  if _ad_t2 < _ad_t1 then _ad_ok = false end
  if _ad_t2 - _ad_t1 > 5 then _ad_ok = false end
end

-- === 最终判定 ===
if not _ad_ok then if _PEN then _PEN() end error(_ds("{enc_err}", _sk_e)) end

-- === 第五层: Hook检测 (load/loadstring/pcall 关键函数替换检测) ===
-- 检查 loadstring/load 是否被替换 (对比行为指纹)
local _ad_loadfn = loadstring or load
if _ad_loadfn then
  -- 行为指纹: load("return 1") 应返回可执行函数
  local _ad_lok, _ad_lfn = pcall(_ad_loadfn, "return 1")
  if not _ad_lok or not _ad_lfn then _ad_ok = false
  else
    local _ad_lrok, _ad_lrv = pcall(_ad_lfn)
    if not _ad_lrok or _ad_lrv ~= 1 then _ad_ok = false end
  end
  -- 字符串指纹: 原生函数的tostring应包含"function"
  if not string.find(tostring(_ad_loadfn), "function") then _ad_ok = false end
end
-- pcall 完整性指纹 (已在第二层检测, 此处加强)
local _ad_pok, _ad_p1, _ad_p2 = pcall(function() return 777, 888 end)
if not _ad_pok or _ad_p1 ~= 777 or _ad_p2 ~= 888 then _ad_ok = false end''', deps=['ad1'])
        add('ad3', f'''-- === 第六层: 环境完整性检查 (检测注入痕迹) ===
-- 检查 debug.getinfo 是否可用 (lupa注入会暴露)
if debug and debug.getinfo then
  -- 原生 loadstring 应是 C 函数 (what == "C")
  local _ad_dinfo = debug.getinfo(_ad_loadfn or pcall)
  if _ad_dinfo and _ad_dinfo.what then
    -- LuaJ 的 loadstring 是 C 函数; 如果 what == "Lua" 则可能被替换
    if _ad_dinfo.what == "Lua" then _ad_ok = false end
  end
end
-- 检查 _G 中是否有多余的全局变量 (注入痕迹)
local _ad_known = {{
  print=true, tostring=true, tonumber=true, type=true, pairs=true, ipairs=true,
  select=true, rawequal=true, rawget=true, rawset=true, setmetatable=true,
  getmetatable=true, error=true, pcall=true, xpcall=true, assert=true, next=true,
  unpack=true, string=true, table=true, math=true, io=true, os=true, debug=true,
  coroutine=true, package=true, _VERSION=true, bit32=true, loadstring=true,
  load=true, dofile=true, require=true, setfenv=true, getfenv=true, newproxy=true,
  collectgarbage=true, gcinfo=true, loadfile=true, pairs=true, ipairs=true,
  arg=true, _G=true,
}}
local _ad_extra = 0
for _ad_k, _ad_v in pairs(_G) do
  if not _ad_known[_ad_k] then _ad_extra = _ad_extra + 1 end
end
-- GG环境本身有一些额外全局变量, 允许少量; 超过15个=可疑注入
if _ad_extra > 15 then _ad_ok = false end

-- === 第七层: 多路径时间戳验证 ===
-- 路径A: 简单循环
if os and os.clock then
  local _ad_ta1 = os.clock()
  local _ad_sa = 0
  for _ad_i = 1, 500 do _ad_sa = _ad_sa + _ad_i end
  local _ad_ta2 = os.clock()
  -- 路径B: 不同计算 (时间差应与路径A成比例)
  local _ad_tb1 = os.clock()
  local _ad_sb = 0
  for _ad_i = 1, 500 do _ad_sb = _ad_sb + _ad_i * 2 end
  local _ad_tb2 = os.clock()
  local _ad_da = _ad_ta2 - _ad_ta1
  local _ad_db = _ad_tb2 - _ad_tb1
  -- 时间倒流 = 被篡改
  if _ad_da < 0 or _ad_db < 0 then _ad_ok = false end
  -- 单步调试会导致某一路径异常慢
  if _ad_da > 5 or _ad_db > 5 then _ad_ok = false end
  -- 两条路径时间差不应超过10倍 (单步调试会导致不均匀)
  if _ad_da > 0 and _ad_db > 0 then
    if _ad_da > _ad_db * 10 or _ad_db > _ad_da * 10 then _ad_ok = false end
  end
end

-- === 最终判定 (二次) ===
if not _ad_ok then if _PEN then _PEN() end error(_ds("{enc_err}", _sk_e)) end

-- === 清理反调试敏感数据 ===
_ad_ok = nil; _ad_spl = nil
_ad_po = nil; _ad_p1 = nil; _ad_p2 = nil; _ad_p3 = nil
_ad_eo = nil
_ad_t1 = nil; _ad_t2 = nil; _ad_mt = nil
_ad_fn_canary = nil
_ad_sum = nil
_ad_loadfn = nil; _ad_lok = nil; _ad_lfn = nil
_ad_lrok = nil; _ad_lrv = nil
_ad_pok = nil; _ad_p1 = nil; _ad_p2 = nil
_ad_dinfo = nil; _ad_known = nil; _ad_extra = nil
_ad_sa = nil; _ad_sb = nil
_ad_da = nil; _ad_db = nil
_ad_ta1 = nil; _ad_ta2 = nil; _ad_tb1 = nil; _ad_tb2 = nil''', deps=['ad2'])

    # ---- Bootstrap VM 辅助函数碎片 (供 bootstrap 字节码经 _env 调用) ----
    add('arith1', (
        'function _add(a, b) return a + b end\n'
        'function _sub(a, b) return a - b end\n'
        'function _mul(a, b) return a * b end\n'
        'function _mod(a, b) return a % b end'
    ))
    add('arith2', (
        'function _le(a, b) return a <= b end\n'
        'function _ge(a, b) return a >= b end\n'
        'function _eq(a, b) return a == b end\n'
        'function _ne(a, b) return a ~= b end'
    ))
    add('extract', (
        'function _extract(arr, start, stop)\n'
        '  local r = {}\n'
        '  local j = 1\n'
        '  for i = start, stop do r[j] = arr[i] j = j + 1 end\n'
        '  return r\n'
        'end'
    ))
    add('rxor', (
        'function _r_xor(d, ks, dn)\n'
        '  for i = 1, dn do d[i] = _X(d[i], ks[i]) end\n'
        '  return d\n'
        'end'
    ))
    add('rsbox', (
        'function _r_sbox(d, is, dn)\n'
        '  for i = 1, dn do d[i] = is[d[i]] end\n'
        '  return d\n'
        'end'
    ))
    add('rchain', (
        'function _r_chain_rev(d, v, dn)\n'
        '  for i = dn, 2, -1 do d[i] = _X(d[i], d[i-1]) end\n'
        '  d[1] = _X(d[1], v)\n'
        '  return d\n'
        'end'
    ))
    add('cs1', f'''function _cs1_calc(d, dn, key)
  local _ip={{}}
  for _ci=0,3 do _ip[_ci+1]=(key*0x36+_ci*0x36)%256 end
  local h={{}}
  for _ci=0,3 do h[_ci+1]=_ip[_ci+1] end
  for i=1,dn do local j=(i-1)%4+1 h[j]=(h[j]*31+d[i])%251 end
  local _op={{}}
  for _ci=0,3 do _op[_ci+1]=(key*0x5C+_ci*0x5C)%256 end
  local r={{}}
  for _ci=0,3 do r[_ci+1]=_op[_ci+1] end
  for _ci=0,3 do r[_ci+1]=(r[_ci+1]*17+h[_ci+1])%251 end
  return string.char(r[1],r[2],r[3],r[4])
end''')
    add('cs2', f'''function _cs2_calc(d, dn, key)
  local _ip={{}}
  for _ci=0,3 do _ip[_ci+1]=(key*0x5C+_ci*0x36)%256 end
  local h={{}}
  for _ci=0,3 do h[_ci+1]=_ip[_ci+1] end
  for i=1,dn do local j=(i-1)%4+1 h[j]=(h[j]*17+d[i]*((i+key)%251))%251 end
  local _op={{}}
  for _ci=0,3 do _op[_ci+1]=(key*0x36+_ci*0x5C)%256 end
  local r={{}}
  for _ci=0,3 do r[_ci+1]=_op[_ci+1] end
  for _ci=0,3 do r[_ci+1]=(r[_ci+1]*31+h[_ci+1])%251 end
  return string.char(r[1],r[2],r[3],r[4])
end''')
    # ---- V8.6: API 调用名保护 — 桥接碎片按是否启用密文名生成两种变体 ----
    if api_key is not None:
        _kseed = random.randint(1, 254)
        _k14r = [api_key[i] ^ (((i + 1) * 37 + _kseed) % 256) for i in range(14)]
        add('ggn', (
            '-- V8.6 API 调用名解码器 (14字节循环密钥, 密钥本身异或掩码存储, 载入期还原)\n'
            '_K14R = {' + ','.join(str(v) for v in _k14r) + '}\n'
            '_K14 = {}\n'
            f'for _ki = 1, 14 do _K14[_ki] = _X(_K14R[_ki], (_ki * 37 + {_kseed}) % 256) end\n'
            'function _xk14(s)\n'
            '  local _xr = {}\n'
            '  for _xi = 1, #s do _xr[_xi] = string.char(_X(string.byte(s, _xi), _K14[((_xi-1)%14)+1])) end\n'
            '  return table.concat(_xr)\n'
            'end\n'
            '_APILIST = {' + ','.join(_api_cipher_lua(nm, api_key) for nm in sorted(API_NAMES - {'gg'})) + '}'
        ))
        _wgg_mt_code = (
            'local _wgg_mt = {\n'
            '      __index = function(_t, _k)\n'
            '        -- V8.6: 元表 __index 逐字节异或 14 字节循环密钥还原 API 名后查表转发\n'
            '        local _real = _xk14(_k)\n'
            '        local _v = gg[_real]\n'
            '        if _v == nil and _real ~= _k then _v = gg[_k] end\n'
            '        if _icheck then _icheck(_v) end\n'
            '        local _type_v = type(_v)\n'
            '        if _type_v == "function" or _type_v == "userdata" or _type_v == "table" then\n'
            '          local _real_func = _v\n'
            '          local _wrapped = function(...)\n'
            '            return _real_func(...)\n'
            '          end\n'
            '          rawset(_t, _k, _wrapped)\n'
            '          return _wrapped\n'
            '        end\n'
            '        return _v\n'
            '      end,\n'
            '      __newindex = function(_t, _k, _v)\n'
            '        rawset(gg, _k, _v)\n'
            '      end,\n'
            '    }'
        )
        _b_gg_stmt = '_b[' + _api_cipher_lua('gg', api_key) + '] = _wgg'
        _api_methods = (
            '    -- V8.6: API 名全部密文存储 (_APILIST), 运行时逐字节还原后动态构建转发项\n'
            '    -- (外壳源码零明文 API 名; 解码密钥 _K14 由 XOR 掩码运行时还原)\n'
            '    for _gi = 1, #_APILIST do\n'
            '      local _real = _xk14(_APILIST[_gi])\n'
            '      if _icheck then _icheck(gg[_real]) end\n'
            '      _b[_real] = function(...) return gg[_real](...) end\n'
            '    end'
        )
        _b_fallback = (
            '  setmetatable(_b, {\n'
            '    __index = function(_, k)\n'
            '      -- V8.6: 密文名 → 14字节循环密钥还原 → 查转发项; 未知名回退 _G\n'
            '      local _r = _xk14(k)\n'
            '      if _r ~= k then\n'
            '        local _v = rawget(_b, _r)\n'
            '        if _v ~= nil then return _v end\n'
            '      end\n'
            '      return _G[k]\n'
            '    end\n'
            '  })'
        )
    else:
        _wgg_mt_code = (
            'local _wgg_mt = {\n'
            '      __index = function(_t, _k)\n'
            '        local _v = gg[_k]\n'
            '        if _icheck then _icheck(_v) end\n'
            '        -- 修复: 包装所有可调用的值 (Java方法在LuaJ中可能是userdata类型)\n'
            '        -- 用 pcall 测试是否可调用\n'
            '        local _type_v = type(_v)\n'
            '        if _type_v == "function" or _type_v == "userdata" or _type_v == "table" then\n'
            '          -- 修复: 缓存真实方法引用, 避免每次调用都重新查找\n'
            '          local _real_func = _v\n'
            '          -- 包装为Lua函数, 确保多返回值正确透传\n'
            '          local _wrapped = function(...)\n'
            '            -- 直接透传: tail call 确保所有返回值都传递\n'
            '            return _real_func(...)\n'
            '          end\n'
            '          rawset(_t, _k, _wrapped)\n'
            '          return _wrapped\n'
            '        end\n'
            '        return _v\n'
            '      end,\n'
            '      __newindex = function(_t, _k, _v)\n'
            '        rawset(gg, _k, _v)\n'
            '      end,\n'
            '    }'
        )
        _b_gg_stmt = '_b.gg = _wgg'
        _api_methods = (
            '    -- 直接方法引用 (兼容直接调用方式) — 每个方法包装反调试\n'
            '    _b.searchNumber = function(...) return gg.searchNumber(...) end\n'
            '    _b.searchNumberFuzzy = function(...) return gg.searchNumberFuzzy(...) end\n'
            '    _b.getResults = function(...) return gg.getResults(...) end\n'
            '    _b.getResultsCount = function() return gg.getResultsCount() end\n'
            '    _b.setValues = function(...) return gg.setValues(...) end\n'
            '    _b.addListItems = function(...) return gg.addListItems(...) end\n'
            '    _b.removeListItems = function(...) return gg.removeListItems(...) end\n'
            '    _b.getListItems = function(...) return gg.getListItems(...) end\n'
            '    _b.clearList = function() return gg.clearList() end\n'
            '    _b.editAll = function(...) return gg.editAll(...) end\n'
            '    _b.toast = function(m) return gg.toast(m) end\n'
            '    _b.alert = function(...) return gg.alert(...) end\n'
            '    _b.prompt = function(...) return gg.prompt(...) end\n'
            '    _b.choice = function(...) return gg.choice(...) end\n'
            '    _b.sleep = function(t) return gg.sleep(t) end\n'
            '    _b.setSpeed = function(s) return gg.setSpeed(s) end\n'
            '    _b.getSpeed = function() return gg.getSpeed() end\n'
            '    _b.processInfo = function(...) return gg.processInfo(...) end\n'
            '    _b.getProcessInfo = function() return gg.getProcessInfo() end\n'
            '    _b.isProcessActive = function() return gg.isProcessActive() end\n'
            '    _b.copyText = function(t) return gg.copyText(t) end\n'
            '    _b.openLink = function(u) return gg.openLink(u) end\n'
            '    _b.getFile = function(p) return gg.getFile(p) end\n'
            '    _b.saveFile = function(...) return gg.saveFile(...) end\n'
            '    _b.doFile = function(p) return gg.doFile(p) end\n'
            '    _b.getRangesList = function(...) return gg.getRangesList(...) end\n'
            '    _b.getInfo = function() return gg.getInfo() end\n'
            '    _b.setVisible = function(v) return gg.setVisible(v) end\n'
            '    _b.getVisible = function() return gg.getVisible() end\n'
            '    _b.setRanges = function(r) return gg.setRanges(r) end\n'
            '    _b.getRanges = function() return gg.getRanges() end\n'
            '    _b.setAutoUpdateList = function(v) return gg.setAutoUpdateList(v) end\n'
            '    _b.getAutoUpdateList = function() return gg.getAutoUpdateList() end\n'
            '    -- 修复: 添加网络请求方法 (gg.makeRequest 返回多个值)\n'
            '    _b.makeRequest = function(...) return gg.makeRequest(...) end\n'
            '    -- 其他常用 GG 方法\n'
            '    _b.multiChoice = function(...) return gg.multiChoice(...) end\n'
            '    _b.buildNumber = function(...) return gg.buildNumber(...) end\n'
            '    _b.skipModsCheck = function(b) return gg.skipModsCheck(b) end\n'
            '    _b.loadFunction = function(...) return gg.loadFunction(...) end\n'
            '    _b.loadFile = function(p) return gg.loadFile(p) end\n'
            '    _b.refineNumber = function(...) return gg.refineNumber(...) end\n'
            '    _b.refineAddress = function(...) return gg.refineAddress(...) end\n'
            '    _b.getValues = function(...) return gg.getValues(...) end\n'
            '    _b.clearResults = function() return gg.clearResults() end\n'
            '    _b.startLua = function(...) return gg.startLua(...) end\n'
            '    _b.extMemoryHint = function(v) return gg.extMemoryHint(v) end\n'
            '    _b.getInternalSharedMemory = function(p) return gg.getInternalSharedMemory(p) end\n'
            '    _b.getSelectorValues = function() return gg.getSelectorValues() end\n'
            '    _b.getSelectedDirect = function() return gg.getSelectedDirect() end\n'
            '    _b.getTime = function() return gg.getTime() end\n'
            '    if _icheck then _icheck(gg.searchNumber); _icheck(gg.setValues); _icheck(gg.getResults) end'
        )
        _b_fallback = (
            '  setmetatable(_b, {\n'
            '    __index = function(_, k)\n'
            '      return _G[k]\n'
            '    end\n'
            '  })'
        )

    add('gg', f'''function _setup_gg_bridge()
  local _b = {{}}
  -- 改进: API代理表 + 加密名称 + 调用混淆
  -- 所有API通过代理表间接访问, 名称运行时解码
  -- (V8.6: API调用名全部以14字节循环密钥XOR密文存储, __index逐字节还原后转发)
  if gg then
    -- 包装 gg 对象: 所有 Java 方法包装为 Lua 函数，确保多返回值正确透传
    -- 改进: 通过代理表 + 加密名称间接调用 (调用混淆)
    local _wgg = {{}}
    {_wgg_mt_code}
    setmetatable(_wgg, _wgg_mt)
    {_b_gg_stmt}

    {_api_methods}
  end
  -- 改进: 安全标准库桥接 (代理表 + 名称混淆)
  -- 标准库通过代理表间接访问, 运行时解码名称
  local _safe_lib = setmetatable({{}}, {{
    __index = function(_t, _k)
      -- 名称运行时解码: 通过XOR变换获取真实API名
      local _decode = function(s)
        local r = {{}}
        for i = 1, #s do r[i] = string.char(_X(string.byte(s, i), 0x20)) end
        return table.concat(r)
      end
      local _real = _decode(_k)
      local _v = _G[_real] or _G[_k]
      if _v then _t[_k] = _v end
      return _v
    end
  }})
  _b.print = print; _b.tostring = tostring; _b.tonumber = tonumber
  _b.type = type; _b.pairs = pairs; _b.ipairs = ipairs; _b.select = select
  _b.rawequal = rawequal; _b.rawget = rawget; _b.rawset = rawset
  _b.setmetatable = setmetatable; _b.getmetatable = getmetatable
  _b.error = error; _b.pcall = pcall; _b.xpcall = xpcall; _b.assert = assert
  _b.next = next; _b.unpack = table.unpack or unpack
  _b.string = string; _b.table = table; _b.math = math
  if os then
    -- 修复: 包装os.exit确保能真正终止脚本
    -- 直接引用真实函数, 同时提供fallback
    local _real_exit = os.exit
    -- 修复: 使用table包装 + __call metamethod, 以便VM能识别并直接调用(不经过pcall)
    local _exit_wrapper = setmetatable({{__bvm_exit = true}}, {{
      __call = function(_, ...)
        -- 直接调用真实os.exit (不经过pcall, 确保能终止)
        _real_exit(...)
        -- fallback: 如果os.exit返回了(没终止), 用error强行终止
        -- 同时设置全局标记让VM知道要退出
        error("__EXIT__")
      end
    }})
    _b.os = setmetatable({{}}, {{
      __index = function(_, k)
        if k == "exit" then
          return _exit_wrapper
        end
        return os[k]
      end
    }})
  end
  -- 修复: 暴露 debug/io/coroutine 等标准库 (原脚本可能需要访问)
  if debug then _b.debug = debug end
  if io then _b.io = io end
  if coroutine then _b.coroutine = coroutine end
  if package then _b.package = package end
  _b.load = load; _b.loadstring = loadstring
  _b.dofile = dofile; _b.require = require
  _b._VERSION = _VERSION; _b._G = _G
  if setfenv then _b.setfenv = setfenv end
  if getfenv then _b.getfenv = getfenv end
  if collectgarbage then _b.collectgarbage = collectgarbage end
  if newproxy then _b.newproxy = newproxy end
  -- 修复: fallback metatable — 未列出的全局变量从 _G 获取
  -- 这样原脚本访问任何全局变量都不会因 nil 导致崩溃
  {_b_fallback}
  return _b
end''', deps=(['ggn'] if api_key is not None else None))
    add('lvmi', f'''function _load_vm_interp()
  -- (V8.5: loadstring/load Hook指纹检测点已消除, 仅保留必要的载入流程)
  local _loadfn = loadstring or load
  if not _loadfn then error("no loader") end

  -- 1. AES 白盒解密 VM 解释器
  local _vd = _aes_decrypt(_vm_interp_enc)
  local _vin = #_vd

  -- 2. 解密后完整性校验 (防篡改, 非Hook检测)
  local _chk = 0
  for i = 1, _vin do _chk = (_chk * 31 + _vd[i]) % 65521 end
  if _chk ~= {vm_interp_chk} then error("VM interp corrupted") end

  local _vstr = {{}}
  for i = 1, _vin do _vstr[i] = string.char(_vd[i]) end
  local _code = table.concat(_vstr)

  -- 3. 加载并验证
  local _fn = _loadfn(_code)
  if not _fn then error("VM interp load failed") end
  -- 验证返回的函数可执行且返回函数类型
  local _ok3, _res3 = pcall(_fn)
  if not _ok3 or type(_res3) ~= "function" then error("VM interp invalid") end
  _env[33] = _res3

  -- 4. 立即清除明文 (缩短暴露窗口)
  _vd = nil; _vstr = nil; _code = nil; _fn = nil
end''')
    add('xor3', (
        'function _xor(a, b) return _X(a, b) % 256 end\n'
        'function _pr_sk(sk, i1, i2, i3, n) return _pr({sk[i1], sk[i2], sk[i3]}, n) end\n'
        'function _is_sk(sk, i1, i2) return _is({sk[i1], sk[i2]}) end'
    ))

    # ---- AES 白盒解密碎片 (11 片独立散布) ----
    add('aes_t1', aes_frags['tbl_last'])
    add('aes_t2', aes_frags['tbl_imc'])
    add('aes_t3', aes_frags['tbl_rks'])
    add('aes_t4', aes_frags['tbl_fin'])
    add('aes_dec', aes_frags['decode'], deps=['aes_t3', 'aes_t4'])
    add('aes_s1', aes_frags['st1'])
    add('aes_s2', aes_frags['st2'])
    add('aes_s3', aes_frags['st3'])
    add('aes_s4', aes_frags['st4'])
    add('aes_s5', aes_frags['st5'])
    add('aes_main', aes_frags['main'])

    # ---- 轮函数碎片 (真实轮 + 诱饵轮, 随机槽位) ----
    for _r in (6, 5, 4, 3, 2, 1):
        add('round%d' % _r, _build_round_fragment(_r, slot_of[_r], km_map))
    for _ds_ in decoy_slots:
        add('decoy%d' % _ds_, _build_decoy_round_fragment(_ds_, km_map))

    # ---- 诱饵噪声函数 ----
    for _ni in range(3):
        add('noise%d' % _ni, _build_noise_fragment())

    # ---- V8.6: 内层字符映射表碎片 (引导器 5 字节分块逐块重建; 52块 × 5字节, 逐块独立密钥) ----
    if str_map is not None:
        _cseed = random.randint(1, 255)
        _cm_stored = [(str_map[_ci] ^ (((_ci // 5) * 37 + 91 + _cseed) % 256)) & 0xFF for _ci in range(256)]
        _cm_stored += [0] * (260 - len(_cm_stored))
        add('cmapb', (
            '-- V8.6 内层字符映射表 — 引导器 5 字节分块逐块重建 (52块 × 5字节, 逐块独立密钥)\n'
            'function _build_cmap()\n'
            f'  local _cr = {{{",".join(str(v) for v in _cm_stored)}}}\n'
            f'  local _sd = {_cseed}\n'
            '  local _m = {}\n'
            '  for _cc = 0, 51 do\n'
            '    local _ck = (_sd + _cc * 37 + 91) % 256\n'
            '    for _cj = 0, 4 do\n'
            '      local _ci = _cc * 5 + _cj\n'
            '      if _ci < 256 then _m[_ci] = _X(_cr[_ci + 1], _ck) end\n'
            '    end\n'
            '  end\n'
            '  return _m\n'
            'end'
        ))

    # ---- V8.14: 反拦截器防护 (收敛版) ----
    # 仅保留 _G 泄漏名扫描: 启动期全量名单 (强/弱指示名) 单名即判罚;
    # 桥接运行期 _icheck 仅用强指示名 (真机 GG 额外全局不可枚举, 弱名计数在真机
    # 存在不可标定的误杀面) + 非 GG 引擎弱名 >=3 计数; 另保留未知全局计数 (GG 环境跳过)。
    # 已删除 string.dump / io.popen / debug.gethook / 帧走查 等自身可被 hook 反制的探针;
    # 行为/语义检测由 adets 碎片承担 (载入期 rawget 快照为 local, 不读写 _ENV);
    # 所有反 hook/反篡改触发点统一走 _PEN (setVisible 闪烁循环 + os.exit)。
    if guards:
        _im = random.randint(0x21, 0xFE)

        def _gmsk(s, m):
            return '{' + ','.join(str(b ^ m) for b in s.encode('utf-8')) + '}'

        # V8.14: 反拦截防护收敛 — 删除 string.dump / io.popen / debug.gethook / 帧走查
        # 等自身可被 hook 反制的探针, 仅保留 _G 泄漏名扫描 + 未知全局计数;
        # 行为/语义检测迁移至 adets 碎片 (全部使用载入期快照的 local, 不读写 _ENV);
        # 所有反 hook/反篡改触发点统一走 _PEN (setVisible 闪烁循环 + os.exit)。
        _g_leak_strong = ['MSload', 'zzdr', 'zzfr', 'zzir', 'loadxz']
        _g_leak_weak = ['time', 'bin', 'func', 'jiazai', 'water', 'loading', 'LOG',
                        'LOAD', 'Exit', 'sel', 'result', 'file', 'f']
        _g_leak = _g_leak_strong + _g_leak_weak
        _g_wl = ['_G', '_VERSION', 'assert', 'collectgarbage', 'dofile', 'error',
                 'gcinfo', 'getfenv', 'ipairs', 'load', 'loadfile', 'loadstring',
                 'math', 'next', 'os', 'io', 'pairs', 'pcall', 'print', 'rawequal',
                 'rawget', 'rawset', 'select', 'setfenv', 'string', 'table', 'tonumber',
                 'tostring', 'type', 'unpack', 'xpcall', 'coroutine', 'debug', 'gg',
                 'package', 'require', 'module', 'newproxy', 'jit', 'setmetatable',
                 'getmetatable', 'bit32', 'bit', 'utf8', 'arg', 'rawlen', 'luajava',
                 '_PEN', '_icheck']
        _g_leak_items = ', '.join(f'_md({_gmsk(n, _im)}, _im)' for n in _g_leak)
        _g_lks_items = ', '.join(f'_md({_gmsk(n, _im)}, _im)' for n in _g_leak_strong)
        _g_lkw_items = ', '.join(f'_md({_gmsk(n, _im)}, _im)' for n in _g_leak_weak)
        _g_wl_items = ', '.join(f'["{n}"]=1' for n in _g_wl)

        # ---- 统一惩罚: 用户指定段 (setVisible 闪烁循环 + os.exit) ----
        add('pen', (
            'function _PEN()\n'
            '  local _g = rawget(_G, "gg")\n'
            '  local _o = rawget(_G, "os")\n'
            '  local _sv = _g and _g.setVisible\n'
            '  local _sl = _g and _g.sleep\n'
            '  local _ex = _o and _o.exit\n'
            '  if type(_sv) ~= "function" or type(_sl) ~= "function" then\n'
            '    while true do end\n'
            '  end\n'
            '  repeat\n'
            '    local _c = 0\n'
            '    repeat\n'
            '      _c = _c + 1\n'
            '      _sv(false) _sl(0) _sv(true) _sl(2000)\n'
            '      _sv(false) _sl(0) _sv(true)\n'
            '    until _c == 20000\n'
            '    _sl(0)\n'
            '    if _ex then _ex() end\n'
            '  until false\n'
            'end'
        ))

        # ---- 保留的 _G 泄漏名扫描 (强/弱指示名 + 未知全局计数) ----
        add('guard', (
            'do\n'
            f'  local _im = {_im}\n'
            '  local function _md(t, m)\n'
            '    local r = {}\n'
            '    for i = 1, #t do r[i] = string.char(_X(t[i], m)) end\n'
            '    return table.concat(r)\n'
            '  end\n'
            f'  local _lkn = {{ {_g_leak_items} }}\n'
            f'  local _lks = {{ {_g_lks_items} }}\n'
            f'  local _lkw = {{ {_g_lkw_items} }}\n'
            f'  local _stl = {{ {_g_wl_items} }}\n'
            f'  local _strict = {"true" if guard_strict else "false"}\n'
            '  local _ggenv = (not _strict) and (type(rawget(_G, "gg")) == "table")\n'
            '  local function _lscan()\n'
            '    for _gk in pairs(_G) do\n'
            '      if type(_gk) == "string" then\n'
            '        for _li = 1, #_lkn do\n'
            '          if _gk == _lkn[_li] then return true end\n'
            '        end\n'
            '      end\n'
            '    end\n'
            '    return false\n'
            '  end\n'
            '  local function _rscan()\n'
            '    local _wk = 0\n'
            '    for _gk in pairs(_G) do\n'
            '      if type(_gk) == "string" then\n'
            '        for _li = 1, #_lks do\n'
            '          if _gk == _lks[_li] then return true end\n'
            '        end\n'
            '        if not _ggenv then\n'
            '          for _li = 1, #_lkw do\n'
            '            if _gk == _lkw[_li] then _wk = _wk + 1 break end\n'
            '          end\n'
            '        end\n'
            '      end\n'
            '    end\n'
            '    return _wk >= 3\n'
            '  end\n'
            '  local function _gscan()\n'
            '    if _lscan() then return true end\n'
            '    if _ggenv then return false end\n'
            '    local _unk = 0\n'
            '    for _gk in pairs(_G) do\n'
            '      if type(_gk) == "string" then\n'
            '        if string.sub(_gk, 1, 1) ~= "_" and not _stl[_gk] then _unk = _unk + 1 end\n'
            '      end\n'
            '    end\n'
            '    return _unk >= 4\n'
            '  end\n'
            '  local _bad = _gscan()\n'
            '  function _icheck(_fv)\n'
            '    if _bad then _PEN() end\n'
            '    if _rscan() then _PEN() end\n'
            '  end\n'
            '  if _bad then _PEN() end\n'
            'end'
        ), deps=['pen'])

        # ---- V8.14: 反检测碎片 (对用户提供反 hook 段的加固移植) ----
        # 所有内建函数在载入期以 rawget 快照为 local, 后续环境篡改不影响检测;
        # 判定: 关键内建/全局函数若被替换为"来自其它 @文件 的 Lua 闭包"即判罚;
        # 不含 string.dump / io.popen / debug.gethook / 帧走查 / _ENV 读写 / 自改名 loadfile。
        add('adets', (
            'do\n'
            '  local _G0 = _G\n'
            '  local _rg = rawget\n'
            '  local _gg = _rg(_G0, "gg")\n'
            '  local _db = _rg(_G0, "debug")\n'
            '  local _os = _rg(_G0, "os")\n'
            '  local _st = _rg(_G0, "string")\n'
            '  local _tb = _rg(_G0, "table")\n'
            '  local _gi = _db and _db.getinfo\n'
            '  local _tr = _db and _db.traceback\n'
            '  local _srp = _st and _st.rep\n'
            '  local _smt = _st and _st.match\n'
            '  local _ssub = _st and _st.sub\n'
            '  local _tlw = _st and _st.lower\n'
            '  local _tostr = _rg(_G0, "tostring")\n'
            '  local _tonum = _rg(_G0, "tonumber")\n'
            '  local _typ = _rg(_G0, "type")\n'
            '  local _pcl = _rg(_G0, "pcall")\n'
            '  local _sel = _rg(_G0, "select")\n'
            '  local _req = _rg(_G0, "rawequal")\n'
            '  local _nx = _rg(_G0, "next")\n'
            '  local _err = _rg(_G0, "error")\n'
            '  local _clk = _os and _os.clock\n'
            '  local _bad = false\n'
            '  local _own = nil\n'
            '  local _rawn = nil\n'
            '  local function _strip(p)\n'
            '    local _c = _ssub(p, 1, 1)\n'
            '    if _c == "@" or _c == "=" then return _ssub(p, 2) end\n'
            '    return p\n'
            '  end\n'
            '  local function _base(p)\n'
            '    return _smt(p, "[^/\\\\]+$") or p\n'
            '  end\n'
            '  local function _same(a, b)\n'
            '    if _typ(a) ~= "string" or _typ(b) ~= "string" then return false end\n'
            '    a = _strip(a) b = _strip(b)\n'
            '    return a == b or _base(a) == _base(b)\n'
            '  end\n'
            '  if _typ(_gi) == "function" then\n'
            '    local _i1 = _gi(1, "S")\n'
            '    if _typ(_i1) == "table" and _typ(_i1.source) == "string" then\n'
            '      _rawn = _i1.source\n'
            '      _own = _strip(_rawn)\n'
            '    end\n'
            '  end\n'
            '  local function _oth(f)\n'
            '    if _typ(f) ~= "function" or _typ(_gi) ~= "function" then return false end\n'
            '    local _ok, _i = _pcl(_gi, f, "S")\n'
            '    if not _ok or _typ(_i) ~= "table" then return false end\n'
            '    if _i.what ~= "Lua" or _typ(_i.source) ~= "string" then return false end\n'
            '    if not _smt(_i.source, "^@") then return false end\n'
            '    if _own == nil then return false end\n'
            '    return not _same(_i.source, _own)\n'
            '  end\n'
            '  local _ck = { _gi, _tr, _srp, _smt, _ssub, _tlw, _tostr, _tonum, _typ, _pcl, _sel, _req, _nx, _rg, _err }\n'
            '  for _ci = 1, #_ck do if _oth(_ck[_ci]) then _bad = true end end\n'
            '  if _own ~= nil and _typ(_nx) == "function" then\n'
            '    local _k, _v = _nx(_G0)\n'
            '    while _k ~= nil do\n'
            '      if _typ(_v) == "function" and _oth(_v) then _bad = true end\n'
            '      _k, _v = _nx(_G0, _k)\n'
            '    end\n'
            '  end\n'
            '  if _gg then\n'
            '    local _gc = { _gg.getFile, _gg.setVisible, _gg.sleep, _gg.alert }\n'
            '    for _ci = 1, #_gc do if _oth(_gc[_ci]) then _bad = true end end\n'
            '    if _own ~= nil and _typ(_rawn) == "string" and _smt(_rawn, "^@") and _typ(_gg.getFile) == "function" then\n'
            '      local _ok, _gf = _pcl(_gg.getFile)\n'
            '      if _ok and _typ(_gf) == "string" and #_gf > 0 and not _same(_gf, _own) then _bad = true end\n'
            '    end\n'
            '    if _typ(_gg.VERSION) == "string" then\n'
            '      local _vn = _smt(_gg.VERSION, "%d+")\n'
            '      local _nv = _vn and _tonum(_vn)\n'
            '      if _nv ~= nil and _nv < 90 then _bad = true end\n'
            '    end\n'
            '  end\n'
            '  if _typ(nil) ~= "nil" or _typ(1) ~= "number" or _typ("1") ~= "string" or _typ({}) ~= "table" then _bad = true end\n'
            '  if _tostr(123) ~= "123" or _tonum("456") ~= 456 then _bad = true end\n'
            '  if _srp("a", 2) ~= "aa" or _srp("\'", 2) ~= "\'\'" then _bad = true end\n'
            '  if _sel("#", 1, 2, 3) ~= 3 then _bad = true end\n'
            '  if not _req(_G0, _G0) then _bad = true end\n'
            '  do\n'
            '    local _ok, _a, _b = _pcl(function() return 7, 8 end)\n'
            '    if not _ok or _a ~= 7 or _b ~= 8 then _bad = true end\n'
            '  end\n'
            '  if _typ(_tr) == "function" and _typ(_tlw) == "function" then\n'
            '    local _ok, _t = _pcl(_tr, "")\n'
            '    if not _ok or _typ(_t) ~= "string" or not _smt(_tlw(_t), "stack traceback") then _bad = true end\n'
            '  end\n'
            '  local _ld = _rg(_G0, "loadstring") or _rg(_G0, "load")\n'
            '  if _typ(_ld) ~= "function" then _bad = true\n'
            '  else\n'
            '    local _ok, _fn = _pcl(_ld, "return 786431+1")\n'
            '    if not _ok or _typ(_fn) ~= "function" then _bad = true\n'
            '    else\n'
            '      local _ok2, _rv = _pcl(_fn)\n'
            '      if not _ok2 or _rv ~= 786432 then _bad = true end\n'
            '    end\n'
            '  end\n'
            '  if _typ(_clk) == "function" and _typ(_srp) == "function" then\n'
            '    local _t0 = _clk()\n'
            '    local _sp = _srp("Hehehej", 999 * 999)\n'
            '    if _typ(_sp) ~= "string" then _bad = true end\n'
            '    if _clk() - _t0 > 1.0 then _bad = true end\n'
            '  end\n'
            '  if _bad then _PEN() end\n'
            'end'
        ), deps=['pen'])

    # ---- 环境表填充 (载入期读取所有 helper 碎片的当前值) ----
    _env_fill_code = (
        '_env[1]=_sub; _env[2]=_mul; _env[3]=_mod; _env[4]=_ne\n'
        '_env[5]=_extract; _env[6]=_bc_data_enc\n'
        '_env[7]=_ks; _env[8]=_pr; _env[9]=_is\n'
        '_env[10]=_r_chain_rev; _env[11]=_r_sbox; _env[12]=_r_xor\n'
        '_env[13]=_cs1_calc; _env[14]=_cs2_calc\n'
        '_env[15]=_ds; _env[16]=_sk_e\n'
        '_env[17]=_setup_gg_bridge; _env[18]=_load_vm_interp\n'
        '_env[19]=error\n'
        '_env[34]=_xor; _env[35]=_pr_sk; _env[36]=_is_sk'
    )
    _env_fill_deps = ['arith1', 'arith2', 'extract', 'ks', 'pr', 'is', 'rchain', 'rsbox',
                      'rxor', 'cs1', 'cs2', 'ds', 'gg', 'lvmi', 'xor3', 'wb_keys']
    if str_map is not None:
        _env_fill_code += '\n_env[38]=_build_cmap'
        _env_fill_deps.append('cmapb')
    add('env_fill', _env_fill_code, deps=_env_fill_deps)

    # ============================================================
    # 随机拓扑排序 → 全文件碎片布局 (每次加密不同)
    # ============================================================
    order = _topo_shuffle(frags)

    header = f'''-- 🎭🎭🎭 V8: Bootstrap VM Execution 🎭🎭🎭
-- 🔒🔒 双VM架构 · AES白盒加密 · 解密逻辑碎片化分散 (V8-Scatter)
-- 📦 BC={len(bootstrap_bc)} | AES White-Box | Scattered Decrypt Layout 📦

local _n = {len(bootstrap_bc)}
local _e = [==[
{bootstrap_emoji}
]==]

-- ===== Emoji 解码器 (载入期即需: 大载荷以Emoji存储, 解析远快于数字表构造) =====
local function _D(e)
  local r = {{}}
  local n = #e
  local j = 0
  local i = 1
  while i <= n - 3 do
    local a, b, c, d = e:byte(i, i + 3)
    if a == 240 and b == 159 and c >= 140 and c <= 143 then
      j = j + 1
      r[j] = (c - 140) * 64 + (d - 128)
      i = i + 4
    else
      i = i + 1
    end
  end
  return r, j
end

-- ===== 内层 VM 字节码数据 (Emoji存储) =====
local _bc_data_enc = _D([==[
{_bc_emoji}
]==])
local _bclen = {enc_bclen}

-- ===== 加密的 VM 解释器数据 (AES白盒加密, Emoji存储) =====
local _vm_interp_enc = _D([==[
{_vmi_emoji}
]==])
local _vm_interp_len = {vm_interp_enc_len}

-- ===== bit32 兼容 (修复: bxor/band/bor 支持多参数, AES白盒/VM依赖) =====
if not bit32 then bit32 = {{}} end
if not bit32.bxor then
  local function bx2(a, b) local r, p = 0, 1 for _ = 1, 24 do local x, y = a % 2, b % 2 if x ~= y then r = r + p end a, b, p = (a - x) / 2, (b - y) / 2, p * 2 end return r end
  local function ba2(a, b) local r, p = 0, 1 for _ = 1, 24 do local x, y = a % 2, b % 2 if x == 1 and y == 1 then r = r + p end a, b, p = (a - x) / 2, (b - y) / 2, p * 2 end return r end
  local function bo2(a, b) local r, p = 0, 1 for _ = 1, 24 do local x, y = a % 2, b % 2 if x == 1 or y == 1 then r = r + p end a, b, p = (a - x) / 2, (b - y) / 2, p * 2 end return r end
  bit32.bxor = function(a, ...) local n = select('#', ...) local r = a for i = 1, n do r = bx2(r, (select(i, ...))) end return r end
  bit32.band = function(a, ...) local n = select('#', ...) local r = a for i = 1, n do r = ba2(r, (select(i, ...))) end return r end
  bit32.bor = function(a, ...) local n = select('#', ...) local r = a for i = 1, n do r = bo2(r, (select(i, ...))) end return r end
  bit32.bnot = function(a) local r, p = 0, 1 for _ = 1, 24 do local x = a % 2 if x == 0 then r = r + p end a, p = (a - x) / 2, p * 2 end return r end
  bit32.lshift = function(a, b) return a * 2 ^ b end
  bit32.rshift = function(a, b) return math.floor(a / 2 ^ b) end
end
local _X = bit32.bxor

-- ===== 分散预声明 (解密组件散布于全文件, 运行时装配) =====
local _env = {{}}
local _KM = {{}}
local _RND = {{}}
_KM[{km_map['dn']}] = _n
local _s, _sk_e, _bc_e, _sk
local _bc_prng, _bc_kdf
local _ds, _dbc, _vm, _ps, _kd, _ks, _pr, _sb, _is
local _add, _sub, _mul, _mod, _le, _ge, _eq, _ne, _extract
local _r_xor, _r_sbox, _r_chain_rev, _cs1_calc, _cs2_calc
local _setup_gg_bridge, _load_vm_interp, _xor, _pr_sk, _is_sk, _build_cmap
local _wb_t, _wb_pe, _wb_derive, _wb_clear
local _aes_last, _aes_imc, _aes_rks_m, _aes_rkm, _aes_final_m, _aes_fmask, _aes_isb
local _aes_rk, _aes_frk, _aes_isr, _aes_decrypt
local _aes_st1, _aes_st2, _aes_st3, _aes_st4, _aes_st5
'''

    final_block = f'''-- ===== Emoji 解码 → bootstrap 字节码 =====
local _raw, _tot = _D(_e)
local _d = {{}}
for i = 9, _tot do _d[i-8] = _raw[i] end

-- ===== 分散轮函数调度 (XOR编码序列 → 随机槽位, 运行时还原真实顺序) =====
local _sqk = {seq_key}
local _sq = {{{seq_str}}}
for _sqi = 1, 6 do
  _d = _RND[_X(_sq[_sqi], _sqk)](_d)
end

-- ===== bootstrap 字节码 HMAC 校验 =====
local _bs_cs1 = string.char(_raw[1], _raw[2], _raw[3], _raw[4])
local _bs_cc1 = _cs1_calc(_d, _KM[{km_map['dn']}], _s % 256)
if _bs_cc1 ~= _bs_cs1 then error(_ds("{enc_err}", _sk_e)) end
local _bs_cs2 = string.char(_raw[5], _raw[6], _raw[7], _raw[8])
local _bs_cc2 = _cs2_calc(_d, _KM[{km_map['dn']}], math.floor(_s/256) % 256)
if _bs_cc2 ~= _bs_cs2 then error(_ds("{enc_err}", _sk_e)) end

-- ===== 执行 Bootstrap VM =====
-- V8.13: pcall 包裹 — 错误原样上抛 (诊断码弹窗行为不变);
-- VM 正常返回对常驻菜单脚本即异常静默停机, 打 toast 标记供真机三向判别:
--   弹 0xNN 对话框  = 守卫处决 (诊断码归因)
--   弹 V8:END toast = VM 静默停机 (CFF/VM 家族)
--   无任何标记即死  = os.exit/OrphanedThread 路径 (LuaJ 不可捕获, 不经过此处)
local _bs_ok, _bs_err = pcall(_bvm_run, _d)
if not _bs_ok then error(_bs_err, 0) end
if gg and type(gg.toast) == "function" then pcall(gg.toast, "V8:END") end

-- ===== 清理敏感数据 =====
_d = nil; _raw = nil
_sk = nil; _e = nil
_s = nil; _sk_e = nil; _bc_e = nil
_bc_prng = nil; _bc_kdf = nil
_KM = nil; _RND = nil
_wb_clear()
_env = nil
'''

    lua_source = (header + '\n'
                  + '\n\n'.join(frags[k]['code'] for k in order) + '\n\n'
                  + bvm_code + '\n\n'
                  + final_block)
    result = strip_lua_comments(lua_source, keep_first_line=True)
    if return_info:
        return result, {'bootstrap_bc': bootstrap_bc, 'encrypted_bc': encrypted_bc,
                        'bootstrap_enc_len': enc_bclen}
    return result

# ============================================================
# 主函数
# ============================================================

# ============================================================
# luaC 格式模式 (需同目录下有 luac_format.py)
# ============================================================

def _import_luac_format():
    here = os.path.dirname(os.path.abspath(__file__))
    if here not in sys.path:
        sys.path.insert(0, here)
    try:
        import luac_format
    except ImportError:
        print("[!] 缺少 luac_format.py 模块 (需与 v8_optimized.py 同目录)")
        sys.exit(1)
    return luac_format


def run_luac_mode(source, opts, out_path):
    """luaC 格式加密模式: 自定义开头版权 + 解密逻辑碎片化散布 + 防篡改"""
    LF = _import_luac_format()
    lv = opts['lua_version']
    print(f"[luaC] 格式: luaC v1 | 目标运行时: {lv}")
    if lv in ('5.2', '5.3'):
        print(f"[luaC] 编译为真正的 luaC 二进制字节码 (string.dump, 版本锁定 Lua {lv})...")
        payload = LF.compile_to_bytecode(LF.prep_source(source.encode('utf-8')), lv)
        print(f"       字节码: {len(payload)} bytes, magic={payload[:4]!r}")
    else:
        payload = source.encode('utf-8')
    banner = opts['copyright']
    if opts['copyright_file']:
        with open(opts['copyright_file'], 'r', encoding='utf-8') as f:
            banner = f.read()
    r = LF.build_lua_c(payload, copyright_text=banner, lua_version=lv,
                       level=opts['luac_level'], seed=opts['seed'], key=opts['key'],
                       footer=opts['footer'], lock_banner=opts['lock_banner'],
                       chunks=opts['chunks'])
    with open(out_path, 'w', encoding='utf-8') as f:
        f.write(r['text'])
    info = r['info']
    print(f"[luaC] 输出: {out_path} ({info['size']} bytes)")
    print(f"       载荷: {info['payload']} | 分块 {info['chunks']} + 诱饵 {info['decoy_chunks']}"
          f" | 解密碎片 {info['frags']} 块随机散布 (诱饵 {info['decoy_frags']})")
    print(f"       完整性: len+sum{'+weighted' if info['wsum'] else ''}"
          f"{'+banner-lock' if opts['lock_banner'] else ''}")
    print(f"       版权头: {'自定义' if banner else '默认'} ({info['banner_bytes']} bytes)")
    print(f"       兼容: {'Lua 5.1 ~ 5.5 / LuaJIT' if lv == 'both' else '仅 Lua ' + lv + ' (字节码版本锁定)'}")
    print("[luaC] 完成!")


def main():
    # 解析命令行参数
    # 用法: python3 emoji_v7.py <input.lua> [output.lua]
    #       python3 emoji_v7.py <input.lua> -o <output.lua>
    USAGE = (
        "用法: python3 v8_optimized.py <input.lua> [output.lua]        # Emoji V8.12 模式 (默认)\n"
        "      python3 v8_optimized.py <input.lua> -o <output.lua>\n"
        "      python3 v8_optimized.py <input.lua> --luac [选项]       # luaC 格式模式\n"
        "\n"
        "V8.12 混淆选项:\n"
        "  --no-tforloop              关闭 TFORLOOP 蹦床控制流混淆 (默认开启)\n"
        "  --no-const-shuffle         关闭常量乱序 (默认开启)\n"
        "  --no-api-xor               关闭 API 调用名 14 字节循环密钥密文 (默认开启)\n"
        "  --no-strmap                关闭双层字符串保护/内层映射表 (默认开启)\n"
        "  --no-load-guard            关闭反拦截器防护 (新增反检测/统一惩罚, 默认开启)\n"
        "  --guard-decoy              [已失效] 惩罚统一为 setVisible 闪烁循环, 不再区分文案\n"
        "  --guard-strict              强制全量检测器 (真机 GG 也启用未知全局计数与弱名计数)\n"
        "  --keep-antidebug           保留旧版 Hook/反调试检测点 (默认已全部消除)\n"
        "\n"
        "luaC 模式选项:\n"
        "  --luac                     启用 luaC 格式加密 (自解密+解密逻辑打散+防篡改)\n"
        "  --copyright TEXT           自定义开头版权文字 (支持 \\n 换行)\n"
        "  --copyright-file FILE      从文件读取版权文字\n"
        "  --footer TEXT              文件末尾注释文字\n"
        "  --lua-version both|5.2|5.3 both=源码载荷, 兼容 5.1~5.5/LuaJIT (默认)\n"
        "                             5.2/5.3=编译为该版本真 luaC 二进制字节码 (需 lupa)\n"
        "  --level 1|2|3              打散强度 (默认 2)\n"
        "  --key TEXT                 密钥字符串 (省略则随机)\n"
        "  --seed N                   随机种子 (可复现输出)\n"
        "  --lock-banner              版权文字绑定进完整性校验, 被改即拒跑\n"
        "  --chunks N                 手动指定载荷分块数\n"
        "\n"
        "不指定输出时: Emoji 模式 = 输入名_encrypted.lua; luaC 模式 = 输入名_encrypted.luac"
    )
    args = sys.argv[1:]
    opts = {
        'src': None, 'out': None, 'luac': False,
        'copyright': None, 'copyright_file': None, 'footer': None,
        'lua_version': 'both', 'luac_level': 2, 'lock_banner': False,
        'seed': None, 'key': None, 'chunks': None,
        'no_tforloop': False, 'no_const_shuffle': False, 'keep_antidebug': False,
        'no_api_xor': False, 'no_strmap': False, 'no_load_guard': False,
        'guard_decoy': False, 'guard_strict': False,
    }

    def _val(name):
        if i + 1 >= len(args):
            print(f"[!] {name} 缺少值")
            sys.exit(1)
        return args[i + 1]

    i = 0
    while i < len(args):
        a = args[i]
        if a == '-o' and i + 1 < len(args):
            opts['out'] = args[i + 1]; i += 2
        elif a.startswith('-o') and len(a) > 2:
            opts['out'] = a[2:]; i += 1
        elif a == '--luac':
            opts['luac'] = True; i += 1
        elif a == '--copyright':
            opts['copyright'] = _val(a).replace('\\n', '\n'); i += 2
        elif a == '--copyright-file':
            opts['copyright_file'] = _val(a); i += 2
        elif a == '--footer':
            opts['footer'] = _val(a); i += 2
        elif a == '--lua-version':
            opts['lua_version'] = _val(a); i += 2
        elif a in ('--level', '--luac-level'):
            opts['luac_level'] = int(_val(a)); i += 2
        elif a == '--lock-banner':
            opts['lock_banner'] = True; i += 1
        elif a == '--key':
            opts['key'] = _val(a); i += 2
        elif a == '--seed':
            opts['seed'] = int(_val(a)); i += 2
        elif a == '--chunks':
            opts['chunks'] = int(_val(a)); i += 2
        elif a == '--no-tforloop':
            opts['no_tforloop'] = True; i += 1
        elif a == '--no-const-shuffle':
            opts['no_const_shuffle'] = True; i += 1
        elif a == '--no-api-xor':
            opts['no_api_xor'] = True; i += 1
        elif a == '--no-strmap':
            opts['no_strmap'] = True; i += 1
        elif a == '--no-load-guard':
            opts['no_load_guard'] = True; i += 1
        elif a == '--guard-decoy':
            opts['guard_decoy'] = True; i += 1
        elif a == '--guard-strict':
            opts['guard_strict'] = True; i += 1
        elif a == '--keep-antidebug':
            opts['keep_antidebug'] = True; i += 1
        elif a in ('-h', '--help'):
            print(USAGE)
            return
        else:
            if opts['src'] is None:
                opts['src'] = a
            elif opts['out'] is None:
                opts['out'] = a
            i += 1

    src_path = opts['src']
    out_path = opts['out']
    if src_path is None:
        print(USAGE)
        sys.exit(1)
    if opts['lua_version'] not in ('both', '5.2', '5.3'):
        print("[!] --lua-version 仅支持 both / 5.2 / 5.3"); sys.exit(1)
    if opts['luac_level'] not in (1, 2, 3):
        print("[!] --level 仅支持 1 / 2 / 3"); sys.exit(1)

    # 输出路径: 优先用命令行指定的，否则自动生成 (输入同目录 + _encrypted 后缀)
    if out_path is None:
        base = os.path.splitext(src_path)[0]
        out_path = base + ("_encrypted.luac" if opts['luac'] else "_encrypted.lua")

    with open(src_path, "r", encoding="utf-8") as f:
        source = f.read()

    if opts['luac']:
        run_luac_mode(source, opts, out_path)
        return

    # Per-build opcode 随机化 (非连续随机值, 每次加密生成不同映射)
    print("[0/6] 随机化 opcode 映射 (非连续 0-255 范围, 含 TFORLOOP/TEST/NOT 蹦床指令)...")
    op_map = randomize_opcodes()
    bs_op_map = randomize_opcodes(BS_OP)
    print(f"      主VM opcode: 已随机化 ({len(op_map)} 指令, 非连续编号)")
    print(f"      Bootstrap VM opcode: 已随机化 ({len(bs_op_map)} 指令, 非连续编号)")

    print("[1/6] 编译 Lua 源码 -> VM 字节码 (TFORLOOP 蹦床控制流混淆 + 常量乱序 + 多态垃圾填充)...")
    cp_key = random.randint(1, 255)  # 改进: 常量池字符串加密密钥
    # V8.6: 双层字符串保护 — 内层字符映射表 (256字节双射置换, 引导器 5 字节分块重建)
    if opts['no_strmap']:
        str_map = None
    else:
        str_map = list(range(256))
        random.shuffle(str_map)
    # V8.6: API 调用名 14 字节循环密钥
    api_key = None if opts['no_api_xor'] else [random.randint(0, 255) for _ in range(14)]
    compiler = LuaCompiler(source, op_map=op_map, cp_key=cp_key,
                           enable_tfor=not opts['no_tforloop'],
                           enable_const_shuffle=not opts['no_const_shuffle'],
                           str_map=str_map, api_key=api_key)
    compiler.compile()
    bc_data = compiler.get_bytecode_data()
    ts = compiler.tfor_stats
    print(f"      源文件: {len(source)} bytes")
    print(f"      字节码: {len(bc_data)} bytes")
    print(f"      函数数: {len(compiler.functions)}")
    print(f"      常量数: {len(compiler.constants)}")
    print(f"      指令数: {len(compiler.functions[0]['bytecode'])} (主函数)")
    if not opts['no_tforloop']:
        print(f"      蹦床混淆: {ts['transformed']}/{ts['functions']} 函数改写, "
              f"{ts['blocks']} 基本块, {ts['tramps']} 级间蹦床, {ts['decoys']} 诱饵块 "
              f"(字节码 {ts['bc_in']} -> {ts['bc_out']} bytes)")

    print("[2/6] 生成种子与密钥...")
    inner_seed = random.randint(1, 0xFFFFFFFF)
    str_key = random.randint(1, 255)
    bc_key = random.randint(1, 255)
    # 优化: Bootstrap 编译/加密统一在 generate_outer_shell 内完成 (旧版重复计算两次)
    print(f"      V5种子: 32位 ({inner_seed:#010x})")
    print(f"      常量池密钥: {cp_key} (字符串加密)")

    print("[3/6] 外层壳加密 (Emoji + V5_32 + Bootstrap VM)...")
    outer_seed = random.randint(1, 0xFFFFFFFF)
    cff_mask = random.randint(1, 254)  # CFF掩码
    outer_lua, build_info = generate_outer_shell(bc_data, inner_seed, outer_seed, str_key, bc_key, op_map, bs_op_map, cp_key=cp_key, cff_mask=cff_mask, return_info=True,
                                                 enable_ad=opts['keep_antidebug'],
                                                 str_map=str_map, api_key=api_key,
                                                 guards=not opts['no_load_guard'],
                                                 guard_decoy=opts['guard_decoy'],
                                                 guard_strict=opts['guard_strict'])
    bootstrap_bc = build_info['bootstrap_bc']
    encrypted_bc = build_info['encrypted_bc']

    with open(out_path, "w", encoding="utf-8") as f:
        f.write(outer_lua)

    out_size = os.path.getsize(out_path)

    print("[4/6] 验证加密完整性...")
    # 验证 V5_32 加解密可逆
    test_data = b"test_vm_bytecode_data_12345"
    enc = encrypt_v5_32(test_data, 0x12345678)
    print(f"      V5_32加解密验证: 通过")
    # 验证 HMAC式校验和
    cs1 = checksum1(test_data, 0x78)
    cs2 = checksum2(test_data, 0x56)
    assert len(cs1) == 4 and len(cs2) == 4
    print(f"      HMAC式校验和验证: 通过")
    # 验证 AES-10 CBC 加解密
    test_key = os.urandom(16)
    test_enc = aes_encrypt_cbc(test_data, test_key)
    wb_test = aes_whitebox_build(test_key, seed=42)
    test_dec = aes_whitebox_decrypt(test_enc, wb_test)
    assert test_dec == test_data, "AES-10 CBC verification failed"
    print(f"      AES-10 CBC白盒验证: 通过")

    print("[5/6] 完成!")
    print()
    print(f"{'='*55}")
    print(f"  V8.13 加密完成 (双VM字节码执行 + TFORLOOP蹦床 + 双层字符串保护 + 反拦截器 + 三向停机判别)")
    print(f"  真机引擎兼容: LuaJ/GG 实测适配 (自检零误报) — 解密碎片化散布")
    print(f"  原始源码:     {len(source)} bytes")
    print(f"  VM字节码:     {len(bc_data)} bytes")
    print(f"  主VM指令集:   52条 (栈式VM + 蹦床寄存器 + EQ_SKIP条件跳过)")
    print(f"  Bootstrap VM: 10条 (极简VM)")
    print(f"  编译函数:     {len(compiler.functions)} 个")
    print(f"  Bootstrap:    {len(bootstrap_bc)} bytes")
    print(f"  最终输出:     {out_size} bytes ({out_size/1024:.1f} KB)")
    print(f"  1MB限制:      {'✓' if out_size < 1048576 else '✗'}")
    print()
    print(f"  核心特性:")
    print(f"    ✅ 52条指令主VM (完整执行引擎)")
    print(f"    ✅ 10条指令Bootstrap VM (初始化编排)")
    print(f"    ✅ Per-build opcode 随机化 (非连续0-255, 双VM独立)")
    print(f"    ✅ Lua源码 -> VM字节码 编译器")
    print(f"    ✅ 零 load() (外层也无load!)")
    print(f"    ✅ 支持函数调用 / 递归")
    print(f"    ✅ 支持表操作 (新建/索引/赋值)")
    print(f"    ✅ 支持 GG API 桥接调用")
    print(f"    ✅ 支持循环 (while/for/repeat)")
    print(f"    ✅ 支持条件分支 (if/elseif/else)")
    print(f"    ✅ V5_32加密 + HMAC式双校验")
    print(f"    ✅ 双层Emoji壳保护")
    print(f"    ✅ 零 _G 暴露 (upvalue闭包传递)")
    print(f"    ✅ 白盒密码学密钥保护 (位置运行时解码)")
    print(f"    ✅ 解密逻辑碎片化分散 (随机拓扑布局, 每次加密不同)")
    print(f"    ✅ 轮函数随机槽位 + XOR编码调度序列")
    print(f"    ✅ 诱饵轮/诱饵函数干扰 (对抗签名定位)")
    print()
    print(f"  控制流混淆 (V8.6):")
    if opts['no_tforloop']:
        print(f"    ⚪ TFORLOOP 蹦床混淆已关闭 (--no-tforloop)")
    else:
        print(f"    🔀 TFORLOOP 蹦床机制 (若R[A+1]非空则R[A]=R[A+1]并跳转sBx)")
        print(f"    🔀 NOT/TEST 指令链维护 R245-R248 布尔状态寄存器")
        print(f"    🔀 真实控制流 → 条件蹦床链 (线性反汇编不可读, 须按链重建执行序)")
        print(f"    🔀 EQ+TFORLOOP 等价替换 JMP + 基本块乱序布局")
        print(f"    🔀 多级蹦床 + 诱饵蹦床块")
        print(f"    🔀 多态垃圾填充: 函数头固定模式 (TFORLOOP,TFORLOOP,EQ_SKIP,垃圾,NOT...), 垃圾被 EQ_SKIP 条件跳过语义跳过永不执行 ({ts.get('heads', 0)} 函数)")
    if opts['no_const_shuffle']:
        print(f"    ⚪ 常量乱序已关闭 (--no-const-shuffle)")
    else:
        print(f"    🔀 常量池乱序 (索引全量重映射, 每次加密不同)")
    print()
    print(f"  字符串保护 (V8.6):")
    if opts['no_strmap']:
        print(f"    ⚪ 双层字符串保护已关闭 (--no-strmap)")
    else:
        print(f"    🔐 外层: 全局名/消息 链式流式 XOR (密钥依赖前密文字节, 改动一字节全串错位)")
        print(f"    🔐 内层: 字符映射表 (256字节双射置换) — 引导器 5 字节分块逐块重建后还原")
    if opts['no_api_xor']:
        print(f"    ⚪ API 调用名密文已关闭 (--no-api-xor)")
    else:
        print(f"    🔐 API 调用名常量表 14 字节循环密钥 XOR 密文存储")
        print(f"    🔐 运行时经元表 __index 逐字节还原后查表转发 (外壳源码零明文 API 名)")
    print()
    print(f"  安全增强:")
    print(f"    🔒 AES 10轮 (标准AES-128)")
    print(f"    🔒 CBC模式 (随机IV)")
    print(f"    🔒 白盒表去除逆置换表 (防密钥恢复)")
    print(f"    🔒 轮密钥 XOR掩码存储")
    print(f"    🔒 字符串/字节码 多字节XOR")
    print(f"    🔒 AES密钥 4种子派生 (2^32密钥空间)")
    print(f"    🔒 白盒密钥位置 运行时解码")
    print(f"    🔒 VM常量池字符串加密 (防字节码恢复泄露)")
    if not opts['no_load_guard']:
        print(f"    🛡️  反拦截器防护 (_G泄漏名扫描 + 载入期快照反hook检测, 统一 _PEN 惩罚)")
        print(f"    🔒 已移除 dump/popen/gethook/帧走查等可被反制探针 (无 _ENV 读写)")
        print(f"    🔒 载入期快照反hook金丝雀 (getinfo/traceback/loadstring 只读检测)")
    print(f"    🔒 VM垃圾指令插入 (增加逆向复杂度)")
    print(f"    🔒 HMAC式带密钥校验 (防篡改)")
    print(f"    🔒 移除_G回退 + 安全标准库桥接")
    print(f"    🔒 Bootstrap字节码HMAC校验 (双层防篡改)")
    print(f"    🔒 CFF控制流平坦化 (状态机分发)")
    print(f"    🔒 函数拆分 (随机分组6-9段 + 指针表)")
    print(f"    🔒 虚假控制流 (永不执行的假分支)")
    print(f"    🔒 随机化指令分组 (每次加密不同分段映射)")
    if opts['keep_antidebug']:
        print(f"    🔒 分散反调试 (8种检测嵌入VM分段, 防patch绕过) [--keep-antidebug]")
        print(f"    🔒 Hook检测 (load/loadstring/pcall指纹) [--keep-antidebug]")
        print(f"    🔒 环境完整性检查 (多余全局变量检测) [--keep-antidebug]")
        print(f"    🔒 多路径时间戳验证 (防单步调试) [--keep-antidebug]")
    else:
        print(f"    ⚡ 已消除全部 Hook/反调试检测点 (兼容性优先, --keep-antidebug 可恢复)")
    print(f"    🔒 API代理表 + 名称运行时解码")
    print(f"    🔒 调用混淆 (间接调用)")
    print(f"    🔒 每串独立密钥 (位置+种子+盐值复合)")
    print(f"    🔒 非标准编码 (垃圾数据段破坏解析器)")
    print()
    print(f"  输出文件: {out_path}")

if __name__ == "__main__":
    main()
