# AI 智能体 10 分钟攻破混淆后的 JavaScript

我把两款 JavaScript 混淆器 —— javascript-obfuscator 和 JScrambler —— 各自的旗舰演示文件丢给 Claude Code，每个只配一段提示词。两家厂商的成品都被还原成干净源码，分别用了 10 分钟和 20 分钟。提示词、脚本和还原后的代码全部内嵌。

Source: https://www.afterpack.dev/zh/blog/ai-deobfuscates-javascript

Published: 2026-05-13 · Author: Nikita Savchenko · Tags: security, analysis, AI

我拿来两款 JavaScript 混淆器 —— 一款流行的开源工具（**javascript-obfuscator**，开启它最强的「VM 混淆」模式），一款商业企业级工具（**JScrambler**），把厂商各自挂在首页的旗舰演示丢给 [Claude Code](https://claude.com/claude-code)，配的提示词只有四段。

第一个用了十分钟，第二个二十分钟。两个都被还原成干净源码！💣

这是不是意味着今天的 JavaScript 混淆 —— 那种用来防止 Web 应用被[逆向](https://en.wikipedia.org/wiki/Reverse_engineering)、防止抄袭的技术 —— 已经走到尽头了？我们来一探究竟。

> 两个目标都是厂商**自己**的演示文件 —— 5 到 13 行的小程序被 150-200× 的混淆膨胀塞成 24-68 KB，**这种比例在真实代码库里见不到**。在「但生产代码更大」的反驳出现之前先说一句：对 Claude 来说生产代码**更容易**，不是更难。一个 1 MB 的应用要么把同样强度的混淆均摊到整个 bundle 上（每个函数都不比这些演示更难），要么 —— 更常见 —— 只对关键函数下重手保护，其它部分照样发可读代码出去，反而给 Claude 提供了被保护函数大致在做什么的语义上下文。厂商的玩具样本对攻击者来说是**最差的**情况，不是最简单的。

## 准备工作

输入是 javascript-obfuscator 挂在自家首页上演示 VM 模式的那段 13 行的 `calculatePrice(quantity, unitPrice)` —— 他们自己的演示、他们自己的函数，他们亲手挑出来展示的。用他们自己的工具开到最强模式跑一遍，输出 1,587 行、磁盘上 68 KB、原大小的约 194 倍。这堆输出里面：九层可组合的防御外壳，包裹着一个约 1,500 行的自定义[基于栈的虚拟机](https://en.wikipedia.org/wiki/Stack_machine)解释器（详细拆解在下文表格里）。

我把混淆后的文件交给 Claude Code 里的 Claude Opus 4.6，连同四段提示词。我没告诉它文件来自哪个混淆器，没有预处理任何东西，也没有预先准备任何工具。

**我发出的完整提示词（4 段）**

```
Hi! I have a complex task for you.

This is the obfuscated js code file, and I want you to iterate
multiple times and help me to find the closest possible original
code used before obfuscation and place it to source.js,
basically deobfuscate this file.

This obfuscation is using new "VM obfuscation" of javascript-obfuscator —
and you'd need to iterate multiple times to simplify it, understand
semantics, methods used etc — to properly deobfuscate. Work for as
long as you need to find the closest to original code possible, use
different methodics, multiple planning stages as you need them,
write temp files to this directory as many times as you
need etc — it's yours to reverse.

This is used to benchmark whether javascript-obfuscator deobfuscation claim
is real — and to estimate whether their VM approach is solid.

I expect 2 outputs:
- the closest deobfuscated file closest to source code as much as
  possible
- learnings on what obfuscation techniques are used and how strong
  they are

If you need to be in execution mode, please proceed in execution mode.
```

**混淆后的输入 —— 完整文件（约 80 KB）**

```js
((N, A) => {
  const J = N();
  while (!![]) {
    try {
      const L =
        (Number.parseInt(U(0x9, "9HM@")) / 0x1) *
          (Number.parseInt(U(0xa, "waD0")) / 0x2) +
        (Number.parseInt(U("0xb", "w1ba")) / 0x3) *
          (Number.parseInt(U(0x3, "NCda")) / 0x4) +
        Number.parseInt(U("0xc", "z4r4")) / 0x5 +
        Number.parseInt(U("0xd", "9fK8")) / 0x6 +
        Number.parseInt(U("0xe", "9sbv")) / 0x7 +
        -Number.parseInt(U(0xf, "hHjw")) / 0x8 +
        -Number.parseInt(U("0x10", "mJvw")) / 0x9;
      if (L === A) break;
      else J["push"](J["shift"]());
    } catch (V) {
      J["push"](J["shift"]());
    }
  }
})(b, 0xd0dfd);
const E =
    (typeof globalThis !== "undefined"
      ? globalThis
      : typeof window !== "undefined"
        ? window
        : global)["w_399e2f"] ||
    ((typeof globalThis !== "undefined"
      ? globalThis
      : typeof window !== "undefined"
        ? window
        : global)["w_399e2f"] = {}),
  P = E;
const p = (() => {
  const N = [
    "nrrCpFydblS8R3E+BJ820M1GRMXrsrA6oM7nhnhCvdzfJDluZAoJxSuNXGMrIOP0/mdNa4ZJn6JHnVVdCl24ubOpZkyzsN9Gx3SsUYGtibsKpuXHLScoXE4DoUW8M9myZng84n+eKQyKteUvcdS4qUBItKVMNYirUJ2mXEZK+CoUAixSXtiUOVrUiGj1pw+aEZXGodaRd7ubHh3n2jKe4NdwQkdgPnta5GcKVJJBeKB4ydcr5SVYDHOjh3o=",
  ];
  var A = {
    i: "jR",
    c: "Yl",
    p: "PM",
    l: "TW",
    j: "wL",
    x: "JB",
    a: "lk",
    s: "mV",
    g: "CZ",
    ni: "My",
    os: "hq",
    o: "nP",
    jk: "JZ",
    bk: "sP",
    smSeed: "TE",
    smState: "Il",
    seKey: "mH",
  };
  const J = 0x0,
    L = 0x1,
    V = 0x2,
    n = 0x3,
    I = 0x4,
    s = 0x5,
    C = 0x6,
    G = 0x7,
    j = 0x8,
    i = 0x9,
    k = 0xa,
    F = 0x1,
    q = 0x2,
    u = 0x4,
    r = 0x8,
    m = 0x10,
    y = 0x20,
    a = 0x40,
    Y = 0x80,
    d = 0x100,
    W = 0x200,
    T = 0x400,
    M = 0x800,
    Q = 0x1000;

  function S(bk) {
    ((this[U("0x11", "$M$P")] = bk),
      (this[U("0x12", "@TcF")] = new DataView(
        bk[U("0x13", "Gx#q")],
        bk[U("0x14", "hHjw")],
        bk[U("0x15", "$M$P")],
      )),
      (this[U(0x16, "7C2)")] = 0x0));
  }

  ((S[U("0x17", "^u[%")]["u8"] = function () {
    return this[U(0x18, "m]hN")][this[U("0x19", "f(J&")]++];
  }),
    (S[U("0x1a", "IAcC")][U(0x1b, "mj6Y")] = function () {
      const bk = this[U(0x1c, "f(J&")][U("0x1d", "lw7j")](
        this[U(0x1e, "SAmI")],
        !![],
      );
      return ((this[U("0x1f", "tO6Y")] += 0x2), bk);
    }),
    (S[U(0x20, "!a8Q")][U("0x21", "SAmI")] = function () {
      const bk = this[U("0x22", "C$TP")][U("0x23", "(sPS")](
        this[U(0x24, "lw7j")],
        !![],
      );
      return ((this[U(0x1f, "tO6Y")] += 0x4), bk);
    }),
    (S[U(0x25, "Ax7%")][U("0x26", "9sbv")] = function () {
      const bk = this[U("0x27", "SAmI")][U(0x28, "BeXe")](
        this[U(0x29, "(sPS")],
        !![],
      );
      return ((this[U("0x2a", "9HM@")] += 0x4), bk);
    }),
    (S[U(0x25, "Ax7%")][U(0x2b, "W3hW")] = function () {
      const bk = this[U("0x2c", "c(K]")][U("0x2d", "!a8Q")](
        this[U(0x24, "lw7j")],
        !![],
      );
      return ((this[U(0x2e, "$M$P")] += 0x8), bk);
    }),
    (S[U(0x2f, "Gx#q")][U("0x30", "@TcF")] = function () {
      let bk = 0x0,
        bF = 0x0,
        bq;
      do {
        ((bq = this["u8"]()), (bk |= (bq & 0x7f) << bF), (bF += 0x7));
      } while (bq >= 0x80);
      return (bk >>> 0x1) ^ -(bk & 0x1);
    }),
    (S[U("0x20", "!a8Q")][U(0x31, "CJ!h")] = function () {
      const bk = this[U("0x32", "W3hW")](),
        bF = this[U("0x33", "67gO")][U("0x34", "@TcF")](
          this[U("0x35", "BeXe")],
          this[U(0x36, "w1ba")] + bk,
        );
      return (
        (this[U(0x1e, "SAmI")] += bk),
        new TextDecoder()[U("0x37", "(sPS")](bF)
      );
    }));

  function v(bk) {
    const bF = atob(bk),
      bq = new Uint8Array(bF[U("0x38", "^HLG")]);
    for (let bu = 0x0; bu < bF[U("0x39", "9sbv")]; bu++) {
      bq[bu] = bF[U(0x3a, "w1ba")](bu);
    }
    return bq;
  }

  function f(bk) {
    const bF = bk["u8"]();
    switch (bF) {
      case J:
        return null;
      case L:
        return undefined;
      case V:
        return ![];
      case n:
        return !![];
      case I: {
        const bq = bk["u8"]();
        return bq > 0x7f ? bq - 0x100 : bq;
      }
      case s: {
        const bu = bk[U(0x3b, "r]n&")]();
        return bu > 0x7fff ? bu - 0x10000 : bu;
      }
      case C:
        return bk[U("0x3c", "CJ!h")]();
      case G:
        return bk[U(0x3d, "7C2)")]();
      case j:
        return bk[U("0x3e", "Fu38")]();
      case i:
        return BigInt(bk[U(0x3f, "tO6Y")]());
      case k: {
        const br = bk[U("0x40", "oqaM")](),
          bm = bk[U(0x41, "JGtS")]();
        return new RegExp(br, bm);
      }
      default:
        return null;
    }
  }

  function B(bk, bF) {
    const bq = v(bk),
      bu = new S(bq),
      br = bu["u8"](),
      bm = bu[U("0x42", "@vun")](),
      by = bu[U(0x43, "f#37")](),
      ba = bu[U(0x44, "!a8Q")](),
      bY = bF ? bF["i"] : "i",
      bd = bF ? bF["c"] : "c",
      bW = bF ? bF["p"] : "p",
      bT = bF ? bF["l"] : "l",
      bM = bF ? bF["j"] : "j",
      bQ = bF ? bF["x"] : "x",
      bS = bF ? bF["a"] : "a",
      bv = bF ? bF["s"] : "s",
      bf = bF ? bF["g"] : "g",
      bB = bF ? bF["ni"] : "ni",
      bh = bF ? bF["os"] : "os",
      bl = bF ? bF["o"] : "o",
      bx = bF ? bF["jk"] : "jk",
      U0 = bF ? bF["bk"] : "bk",
      U1 = bF ? bF[U("0x45", "mJvw")] : "smSeed",
      U2 = bF ? bF[U("0x46", "SAmI")] : "smState",
      U3 = bF ? bF[U(0x47, "JGtS")] : "seKey",
      U4 = {};
    ((U4[bW] = by), (U4[bT] = ba));
    if (bm & r) U4[bB] = bu[U("0x48", "m]hN")]();
    if (bm & m) U4[bh] = bu[U("0x49", "f#37")]();
    if (bm & y) {
      const U9 = bu[U("0x4a", "NCda")](),
        Ub = {};
      for (let UU = 0x0; UU < U9; UU++) {
        const UZ = bu[U("0x4b", "oqaM")](),
          UO = bu[U(0x4c, "SI&j")]();
        Ub[UZ] = UO;
      }
      U4[bl] = Ub;
    }
    if (bm & a) U4[bx] = bu[U(0x4d, "$M$P")]();
    if (bm & Y) U4[U0] = bu[U(0x4e, "d3%f")]();
    if (bm & d) U4[U1] = bu[U("0x4f", "f(J&")]();
    if (bm & W) U4[U2] = bu[U("0x50", "QmhY")]();
    if (bm & T) U4[U3] = bu[U(0x51, "QeOg")]();
    if (bm & F) U4[bS] = 0x1;
    if (bm & q) U4[bv] = 0x1;
    if (bm & u) U4[bf] = 0x1;
    const U5 = bu[U(0x52, "CJ!h")](),
      U6 = [];
    for (let Uc = 0x0; Uc < U5; Uc++) {
      U6[U("0x53", "@vun")](f(bu));
    }
    U4[bd] = U6;
    const U7 = bu[U("0x43", "f#37")](),
      U8 = [];
    for (let Ug = 0x0; Ug < U7; Ug++) {
      let UD = bu[U("0x54", "Ows7")](),
        UR = bu["u8"](),
        Ut;
      switch (UR) {
        case J:
          Ut = null;
          break;
        case I: {
          const Ue = bu["u8"]();
          Ut = Ue > 0x7f ? Ue - 0x100 : Ue;
          break;
        }
        case s: {
          const UX = bu[U("0x55", "d3%f")]();
          Ut = UX > 0x7fff ? UX - 0x10000 : UX;
          break;
        }
        case C:
          Ut = bu[U("0x56", "C$TP")]();
          break;
        case G:
          Ut = bu[U("0x57", "BeXe")]();
          break;
        case j:
          Ut = bu[U(0x58, "Gx#q")]();
          break;
        default:
          Ut = null;
      }
      (U8[U("0x59", "Ax7%")](UD), U8[U("0x5a", "F!70")](Ut));
    }
    U4[bY] = U8;
    if (bm & M) {
      const UH = bu[U("0x30", "@TcF")](),
        Uw = {};
      for (let Uz = 0x0; Uz < UH; Uz++) {
        const UK = bu[U(0x5b, "waD0")](),
          UE = bu[U(0x5c, "67gO")]();
        Uw[UK] = UE;
      }
      U4[bM] = Uw;
    }
    if (bm & Q) {
      const UP = bu[U(0x5d, "9fK8")](),
        Up = {};
      for (let Uo = 0x0; Uo < UP; Uo++) {
        const UN = bu[U(0x5e, "9HM@")](),
          UA = bu[U("0x5d", "9fK8")]() - 0x1,
          UJ = bu[U("0x43", "f#37")]() - 0x1,
          UL = bu[U(0x5f, "f(J&")]() - 0x1;
        Up[UN] = [UA, UJ, UL];
      }
      U4[bQ] = Up;
    }
    return U4;
  }

  function h() {
    var bk = 0x5f3759df;
    return (
      (bk ^=
        Array[U(0x25, "Ax7%")][U("0x60", "mJvw")][U(0x61, "d3%f")] << 0x18),
      (bk ^=
        String[U(0x2f, "Gx#q")][U(0x62, "f#37")][U("0x63", "m]hN")] << 0x14),
      (bk ^= Math[U("0x64", "NCda")][U("0x65", "w1ba")] << 0x10),
      (bk ^= Object[U(0x66, "hHjw")][U("0x67", "Fu38")] << 0xc),
      (bk ^=
        Array[U("0x68", "CJ!h")][U("0x69", "ID[x")][U(0x6a, "BeXe")] << 0x8),
      (bk ^= String[U("0x6b", "oqaM")][U("0x6c", "Fu38")][U(0x6d, "Ax7%")]),
      (bk ^= bk >>> 0x10),
      (bk = Math[U("0x6e", "Fu38")](bk, 0x85ebca6b) >>> 0x0),
      (bk ^= bk >>> 0xd),
      (bk = Math[U(0x6f, "@TcF")](bk, 0xc2b2ae35) >>> 0x0),
      (bk ^= bk >>> 0x10),
      bk >>> 0x0
    );
  }

  function l(bk, bF) {
    var bq = [],
      bu = 0x0,
      br,
      bm = "";
    for (var by = 0x0; by < 0x100; by++) bq[by] = by;
    for (var by = 0x0; by < 0x100; by++) {
      ((bu =
        (bu + bq[by] + bF[U(0x70, "W3hW")](by % bF[U(0x71, "SAmI")])) % 0x100),
        (br = bq[by]),
        (bq[by] = bq[bu]),
        (bq[bu] = br));
    }
    var by = 0x0;
    bu = 0x0;
    for (var ba = 0x0; ba < bk[U(0x72, "Wtwi")]; ba++) {
      ((by = (by + 0x1) % 0x100),
        (bu = (bu + bq[by]) % 0x100),
        (br = bq[by]),
        (bq[by] = bq[bu]),
        (bq[bu] = br),
        (bm += String[U("0x73", "@vun")](
          bk[U(0x74, "9HM@")](ba) ^ bq[(bq[by] + bq[bu]) % 0x100],
        )));
    }
    return bm;
  }

  function x(bk) {
    return atob(bk);
  }

  var b0 = h()[U(0x75, "Ax7%")](0x10),
    b1 = {};

  function b2(bk) {
    if (b1[bk]) return b1[bk];
    var bF = N[bk];
    if (typeof bF === "string") {
      var bq = l(x(bF), b0);
      b1[bk] = B(bq, A);
    } else b1[bk] = bF;
    return b1[bk];
  }

  const b3 = {
    0: 0x46,
    1: 0x19d,
    2: 0x8e,
    3: 0xea,
    4: 0x90,
    5: 0x4a,
    6: 0x81,
    7: 0x4b,
    8: 0xfd,
    9: 0x64,
    10: 0x14f,
    11: 0x1c2,
    12: 0x79,
    13: 0x9c,
    14: 0xb6,
    15: 0x78,
    16: 0x1ec,
    17: 0xe,
    18: 0x82,
    19: 0x112,
    20: 0x1e2,
    21: 0x20,
    22: 0xbc,
    23: 0x7b,
    24: 0x1d0,
    25: 0xdb,
    26: 0x1ee,
    32: 0xa7,
    40: 0x3e,
    41: 0x6a,
    42: 0x140,
    43: 0x1b8,
    44: 0x15d,
    45: 0x12c,
    46: 0x1d9,
    47: 0x184,
    50: 0x15,
    51: 0x137,
    52: 0x155,
    53: 0x9d,
    54: 0x66,
    55: 0x12b,
    56: 0x1c5,
    57: 0x58,
    58: 0x8c,
    59: 0x1d5,
    60: 0x6f,
    61: 0x19b,
    62: 0x126,
    63: 0x1e3,
    64: 0xff,
    65: 0x6c,
    70: 0x34,
    71: 0x159,
    72: 0x157,
    73: 0x1bd,
    74: 0x13f,
    75: 0x44,
    76: 0x1b7,
    77: 0x13,
    78: 0x68,
    79: 0x23,
    80: 0x19c,
    81: 0x99,
    82: 0x1f3,
    90: 0x1b2,
    91: 0x146,
    92: 0x33,
    93: 0x115,
    94: 0x8a,
    100: 0x149,
    101: 0xd9,
    102: 0x10f,
    103: 0xbf,
    104: 0xdf,
    105: 0x108,
    106: 0xa,
    110: 0x16,
    111: 0x5c,
    112: 0x106,
    120: 0x199,
    121: 0x39,
    122: 0x1ed,
    123: 0x1b0,
    124: 0x12e,
    125: 0x61,
    126: 0x148,
    127: 0x15c,
    128: 0xc2,
    140: 0x57,
    141: 0x69,
    142: 0x13a,
    144: 0x9a,
    145: 0x13c,
    146: 0x42,
    147: 0x100,
    148: 0xe5,
    149: 0xe0,
    160: 0x147,
    161: 0x22,
    162: 0x17a,
    163: 0x1db,
    164: 0x98,
    166: 0x180,
    167: 0xa9,
    168: 0xa2,
    169: 0x1b5,
    170: 0x189,
    171: 0x1dd,
    172: 0x92,
    173: 0x11f,
    174: 0x62,
    175: 0x1d7,
    200: 0x1f8,
    201: 0x169,
    202: 0x43,
    210: 0x4f,
    211: 0x104,
    212: 0x173,
    213: 0x133,
    214: 0x1e1,
    215: 0x41,
    216: 0x75,
    217: 0x1f,
    218: 0x30,
    250: 0x1d,
    251: 0xb1,
    252: 0xaa,
    253: 0x37,
    254: 0x1e0,
    255: 0x1f7,
    256: 0x118,
    257: 0x1be,
    258: 0x151,
    259: 0xbe,
    260: 0xd1,
    261: 0x9e,
  };

  function b4(bk, bF) {
    const bq = [];
    for (let bu = 0x0; bu < bF; bu++) {
      const br = bk[U("0x76", "@vun")]();
      if (br && typeof br === "object" && br[U("0x77", "@TcF")] === !![]) {
        const bm = br[U("0x78", "Ax7%")];
        if (Array[U("0x79", "CJ!h")](bm))
          for (let by = bm[U("0x7a", "waD0")] - 0x1; by >= 0x0; by--) {
            bq[U("0x7b", "T[d%")](bm[by]);
          }
      } else bq[U(0x7c, "4$Y3")](br);
    }
    return (bq[U(0x7d, "Wtwi")](), bq);
  }

  let b5 = !![],
    b6 = 0x0,
    b7 = 0x0,
    b8 = ![],
    b9 = 0x1388,
    bb = 0x3;

  function bU() {
    if (!b5 || b8) return;
    const bk = Date[U("0x7e", "Ax7%")]();
    if (b6 === 0x0) {
      b6 = bk;
      return;
    }
    const bF = bk - b6;
    b6 = bk;
    if (bF > b9) {
      b7++;
      if (b7 >= bb) {
        b8 = !![];
        for (const bq in b3) {
          b3[bq] = (b3[bq] + 0x1) & 0x1ff;
        }
      }
    } else b7 = 0x0;
  }

  const bZ = 0x85ebca6b,
    bO = 0xc2b2ae35,
    bc = 0x10,
    bg = 0xd,
    bD = 0x10,
    bR = 0x9e3779b9,
    bt = 0x200;

  function be(bk) {
    return (
      (bk = bk >>> 0x0),
      (bk ^= bk >>> bc),
      (bk = Math[U(0x7f, "NCda")](bk, bZ) >>> 0x0),
      (bk ^= bk >>> bg),
      (bk = Math[U("0x80", "(sPS")](bk, bO) >>> 0x0),
      (bk ^= bk >>> bD),
      bk >>> 0x0
    );
  }

  function bX(bk, bF) {
    let bq = (bk ^ (bF * bR)) >>> 0x0;
    return (
      (bq = (bq ^ (bq >>> 0xb)) >>> 0x0),
      (bq = Math[U(0x81, "QeOg")](bq, 0x1b873593) >>> 0x0),
      (bq = (bq ^ (bq >>> 0xf)) >>> 0x0),
      be(bq)
    );
  }

  function bH(bk, bF, bq) {
    let bu = bk ^ ((bF * bR) >>> 0x0);
    ((bu = (bu ^ ((bq * 0x27d4eb2d) >>> 0x0)) >>> 0x0), (bu = be(bu)));
    const br = [];
    for (let by = 0x0; by < bt; by++) {
      br[by] = by;
    }
    for (let ba = bt - 0x1; ba > 0x0; ba--) {
      const bY = bX(bu, ba),
        bd = bY % (ba + 0x1),
        bW = br[ba];
      ((br[ba] = br[bd]), (br[bd] = bW));
    }
    const bm = {};
    for (let bT = 0x0; bT < bt; bT++) {
      bm[bT] = br[bT];
    }
    return bm;
  }

  const bw = {};

  function bz(bk, bF, bq) {
    const bu = bk + "_" + bF + "_" + bq;
    return (!bw[bu] && (bw[bu] = bH(bk, bF, bq)), bw[bu]);
  }

  const bK = 0x8,
    bE = 0x9e3779b9,
    bP = 0x85ebca6b,
    bp = 0xc2b2ae35,
    bo = 0x200;

  function bN(bk) {
    return (
      (bk = bk >>> 0x0),
      (bk ^= bk >>> 0x10),
      (bk = Math[U("0x82", "n[N$")](bk, bP) >>> 0x0),
      (bk ^= bk >>> 0xd),
      (bk = Math[U("0x83", "BeXe")](bk, bp) >>> 0x0),
      (bk ^= bk >>> 0x10),
      bk >>> 0x0
    );
  }

  function bA(bk, bF) {
    const bq = bk ^ ((bF * bE) >>> 0x0);
    return bN(bq) % bK;
  }

  function bJ(bk, bF, bq, bu) {
    let br = bk ^ ((bF * bE) >>> 0x0);
    return (
      (br = (br ^ ((bq * bP) >>> 0x0)) >>> 0x0),
      (br = (br ^ ((bu * bp) >>> 0x0)) >>> 0x0),
      bN(br)
    );
  }

  function bL(bk, bF) {
    const bq = [];
    for (let br = 0x0; br < bF; br++) {
      bq[br] = br;
    }
    let bu = bk;
    for (let bm = bF - 0x1; bm > 0x0; bm--) {
      bu = bN(bu ^ bm);
      const by = bu % (bm + 0x1),
        ba = bq[bm];
      ((bq[bm] = bq[by]), (bq[by] = ba));
    }
    return bq;
  }

  const bV = {};

  function bn(bk) {
    if (bV[bk]) return bV[bk];
    const bF = [];
    for (let bq = 0x0; bq < bK; bq++) {
      const bu = bN(bk ^ (bq * bE)),
        br = bL(bu, bo),
        bm = {};
      for (let by = 0x0; by < bo; by++) {
        bm[br[by]] = by;
      }
      bF[U("0x84", "mJvw")](bm);
    }
    return ((bV[bk] = bF), bF);
  }

  function bI(bk, bF) {
    if (
      typeof bk === "number" &&
      Number[U("0x85", "c(K]")](bk) &&
      Number[U(0x86, "r]n&")](bk)
    ) {
      if (bk >= -0x80000000 && bk <= 0x7fffffff) return (bk ^ bF) | 0x0;
    }
    return bk;
  }

  function bs(bk, bF) {
    if (
      typeof bk === "number" &&
      Number[U("0x87", "mJvw")](bk) &&
      Number[U(0x88, "(sPS")](bk)
    ) {
      if (bk >= -0x80000000 && bk <= 0x7fffffff) return (bk ^ bF) | 0x0;
    }
    return bk;
  }

  function* bC(bk, bF, bq, bu, br, bm) {
    let by = [],
      ba = new Array((bk[A["p"]] || 0x0) + (bk[A["l"]] || 0x0)),
      bY = 0x0,
      bd = bk[A["c"]],
      bW = bk[A["i"]],
      bT = bk[A["j"]] || {},
      bM = bk[A["x"]] || {},
      bQ = bW[U("0x89", "Gx#q")] >> 0x1,
      bS = [],
      bv = null,
      bf = { hasReturn: ![], value: undefined },
      bB = { hasBreak: ![], target: 0x0 },
      bh = { hasContinue: ![], target: 0x0 },
      bl = bk[A["o"]] || b3;
    if (bk["os"] !== undefined) {
      const Ut = bW[U(0x8a, "9fK8")] >> 0x1,
        Ue = bd ? bd[U(0x8b, "oqaM")] : 0x0;
      bl = bz(bk["os"], Ut, Ue);
    }
    const bx = bk[A[U("0x8c", "4$Y3")]] || 0x0,
      U0 = bx ? bn(bx) : null;
    if (bk[A[U(0x8d, "Gx#q")]] !== undefined) {
      const UX = bk[A[U(0x8e, "Fu38")]],
        UH = by[U(0x8f, "$M$P")][U(0x90, "SI&j")](by),
        Uw = by[U("0x91", "m]hN")][U(0x92, "@vun")](by);
      ((by[U(0x69, "ID[x")] = (Uz) => {
        if (
          typeof Uz === "number" &&
          Number[U(0x93, "SI&j")](Uz) &&
          Number[U(0x94, "9HM@")](Uz) &&
          Uz >= -0x80000000 &&
          Uz <= 0x7fffffff
        )
          return UH((Uz ^ UX) | 0x0);
        return UH(Uz);
      }),
        (by[U(0x95, "waD0")] = () => {
          const Uz = Uw();
          if (
            typeof Uz === "number" &&
            Number[U("0x96", "ID[x")](Uz) &&
            Number[U(0x88, "(sPS")](Uz) &&
            Uz >= -0x80000000 &&
            Uz <= 0x7fffffff
          )
            return (Uz ^ UX) | 0x0;
          return Uz;
        }));
    }
    let U1 = bk[A["jk"]] || 0x0,
      U2 = bk[A["bk"]] || 0x0,
      U3 = (Uz) => (U1 ? Uz ^ U1 : Uz),
      U4 = (Uz) => (U2 ? Uz ^ U2 : Uz),
      U5 = { parent: bq, vars: {} };
    if (bF)
      for (
        let Uz = 0x0;
        Uz < Math[U(0x97, "9sbv")](bF[U("0x98", "NCda")], bk[A["p"]] || 0x0);
        Uz++
      ) {
        ba[Uz] = bF[Uz];
      }
    if (bk[A["ni"]] !== undefined && bu) {
      const UK = bk[A["c"]][bk[A["ni"]]];
      U5[U(0x99, "f(J&")][UK] = bu;
      if (!U5[U(0x9a, "9fK8")]) U5[U(0x9b, "c(K]")] = {};
      U5[U("0x9c", "7C2)")][UK] = !![];
      try {
        Object[U("0x9d", "C$TP")](bu, "name", {
          value: UK,
          writable: ![],
          enumerable: ![],
          configurable: !![],
        });
      } catch (UE) {}
    }
    let U6 = 0x0;
    while (bY < bQ) {
      try {
        while (bY < bQ) {
          ++U6 > 0x64 && ((U6 = 0x0), bU());
          let UP = bY << 0x1,
            Up = U4(bW[UP]),
            Uo = Up;
          if (U0) {
            const UL = bA(bx, bY),
              UV = U0[UL];
            UV && (Uo = UV[Up]);
          }
          const UN = bl[Uo],
            UA = bW[UP + 0x1],
            UJ = UA === null ? undefined : typeof UA === "number" ? U4(UA) : UA;
          if (Uo === 0x7a) {
            const Un = by[U(0x9e, "Ows7")](),
              UI = yield { t: 0x1, v: Un };
            (by[U("0x9f", "Fu38")](UI), bY++);
            continue;
          }
          if (Uo === 0x78) {
            const Us = by[U("0xa0", "ID[x")](),
              UC = yield { t: 0x2, v: Us };
            (by[U("0xa1", "CJ!h")](UC), bY++);
            continue;
          }
          if (Uo === 0x79) {
            const UG = by[U(0xa2, "y22^")](),
              Uj = yield { t: 0x3, v: UG };
            (by[U(0x7c, "4$Y3")](Uj), bY++);
            continue;
          }
          if (typeof U9 === "undefined") {
            var U7 = ![],
              U8,
              U9 = [],
              Ub = {},
              UU = [];
            for (var UZ in bl) {
              if (bl[U(0xa3, "67gO")](UZ))
                UU[U(0xa4, "d3%f")](Number.parseInt(UZ));
            }
            var UO = UU[U("0xa5", "Ows7")]();
            for (var Uc = UO[U("0xa6", "tO6Y")] - 0x1; Uc > 0x0; Uc--) {
              var Ug = Math[U(0xa7, "Wtwi")](
                  Math[U(0xa8, "BeXe")]() * (Uc + 0x1),
                ),
                UD = UO[Uc];
              ((UO[Uc] = UO[Ug]), (UO[Ug] = UD));
            }
            for (var Uc = 0x0; Uc < UU[U(0xa9, "y22^")]; Uc++) {
              Ub[bl[UU[Uc]]] = UO[Uc];
            }
            var UR = (Ui, Uk) => {
              var UF = Uk;
              switch (Ui) {
                case bl[0x0]: {
                  (by[U("0xaa", "mj6Y")](bd[UF]), bY++);
                  break;
                }
                case bl[0x1]: {
                  (by[U(0xab, "7C2)")](undefined), bY++);
                  break;
                }
                case bl[0x2]: {
                  (by[U("0xac", "oqaM")](null), bY++);
                  break;
                }
                case bl[0x3]: {
                  (by[U(0xad, "Wtwi")](), bY++);
                  break;
                }
                case bl[0x4]: {
                  const Uq = by[U(0xae, "SAmI")]();
                  (by[U(0xaa, "mj6Y")](Uq), by[U("0xaf", "C$TP")](Uq), bY++);
                  break;
                }
                case bl[0x5]: {
                  const Uu = by[U(0x38, "^HLG")],
                    Ur = by[Uu - 0x1];
                  ((by[Uu - 0x1] = by[Uu - 0x2]), (by[Uu - 0x2] = Ur), bY++);
                  break;
                }
                case bl[0x6]: {
                  (by[U(0xb0, "9HM@")](ba[UF]), bY++);
                  break;
                }
                case bl[0x7]: {
                  ((ba[UF] = by[U(0xb1, "9sbv")]()), bY++);
                  break;
                }
                case bl[0x8]: {
                  (by[U(0xb2, "n[N$")](bF[UF]), bY++);
                  break;
                }
                case bl[0x9]: {
                  ((bF[UF] = by[U(0xb3, "QmhY")]()), bY++);
                  break;
                }
                case bl[0xa]: {
                  const Um = by[U(0xb4, "9HM@")](),
                    Uy = by[U("0x91", "m]hN")]();
                  (by[U("0xb5", "SI&j")](Uy + Um), bY++);
                  break;
                }
                case bl[0xb]: {
                  const Ua = by[U("0x95", "waD0")](),
                    UY = by[U(0xb6, "Fu38")]();
                  (by[U(0xb7, "tO6Y")](UY - Ua), bY++);
                  break;
                }
                case bl[0xc]: {
                  const Ud = by[U(0xb8, "(sPS")](),
                    UW = by[U("0xa0", "ID[x")]();
                  (by[U("0x59", "Ax7%")](UW * Ud), bY++);
                  break;
                }
                case bl[0xd]: {
                  const UT = by[U("0xb9", "lw7j")](),
                    UM = by[U("0xba", "W3hW")]();
                  (by[U(0xbb, "@TcF")](UM / UT), bY++);
                  break;
                }
                case bl[0xe]: {
                  const UQ = by[U(0xae, "SAmI")](),
                    US = by[U(0xbc, "mj6Y")]();
                  (by[U(0xbd, "Gx#q")](US % UQ), bY++);
                  break;
                }
                case bl[0xf]:
                  (by[U(0xbe, "hHjw")](-by[U(0xbf, "F!70")]()), bY++);
                  break;
                case bl[0x13]:
                  (by[U("0xc0", "(sPS")](+by[U("0xc1", "w1ba")]()), bY++);
                  break;
                case bl[0x12]: {
                  const Uv = by[U(0xb6, "Fu38")](),
                    Uf = by[U(0xba, "W3hW")]();
                  (by[U("0xc2", "r]n&")](Math[U("0xc3", "W3hW")](Uf, Uv)),
                    bY++);
                  break;
                }
                case bl[0x14]: {
                  const UB = by[U(0xb6, "Fu38")](),
                    Uh = by[U("0xb8", "(sPS")]();
                  (by[U("0xc4", "SAmI")](Uh & UB), bY++);
                  break;
                }
                case bl[0x15]: {
                  const Ul = by[U("0xb6", "Fu38")](),
                    Ux = by[U(0xc5, "NCda")]();
                  (by[U(0xc6, "waD0")](Ux | Ul), bY++);
                  break;
                }
                case bl[0x16]: {
                  const Z0 = by[U(0xc7, "f#37")](),
                    Z1 = by[U("0xc8", "7C2)")]();
                  (by[U(0xc9, "w1ba")](Z1 ^ Z0), bY++);
                  break;
                }
                case bl[0x17]:
                  (by[U("0x59", "Ax7%")](~by[U(0x9e, "Ows7")]()), bY++);
                  break;
                case bl[0x18]: {
                  const Z2 = by[U("0xca", "c(K]")](),
                    Z3 = by[U("0x95", "waD0")]();
                  (by[U("0xb5", "SI&j")](Z3 << Z2), bY++);
                  break;
                }
                case bl[0x19]: {
                  const Z4 = by[U("0x9e", "Ows7")](),
                    Z5 = by[U("0xcb", "n[N$")]();
                  (by[U("0xcc", "NCda")](Z5 >> Z4), bY++);
                  break;
                }
                case bl[0x1a]: {
                  const Z6 = by[U("0xcd", "SI&j")](),
                    Z7 = by[U(0xce, "mJvw")]();
                  (by[U("0x9f", "Fu38")](Z7 >>> Z6), bY++);
                  break;
                }
                case bl[0x20]:
                  (by[U("0xcf", "Ows7")](!by[U("0xd0", "^u[%")]()), bY++);
                  break;
                case bl[0x28]: {
                  const Z8 = by[U("0xca", "c(K]")](),
                    Z9 = by[U("0xd1", "C$TP")]();
                  (by[U("0xd2", "c(K]")](Z9 == Z8), bY++);
                  break;
                }
                case bl[0x29]: {
                  const Zb = by[U(0x9e, "Ows7")](),
                    ZU = by[U(0xd3, "IAcC")]();
                  (by[U("0x8f", "$M$P")](ZU != Zb), bY++);
                  break;
                }
                case bl[0x2a]: {
                  const ZZ = by[U("0xb4", "9HM@")](),
                    ZO = by[U(0xd4, "67gO")]();
                  (by[U(0xc0, "(sPS")](ZO === ZZ), bY++);
                  break;
                }
                case bl[0x2b]: {
                  const Zc = by[U(0x76, "@vun")](),
                    Zg = by[U(0xd5, "@TcF")]();
                  (by[U("0xcf", "Ows7")](Zg !== Zc), bY++);
                  break;
                }
                case bl[0x2c]: {
                  const ZD = by[U(0xcb, "n[N$")](),
                    ZR = by[U(0xd6, "CJ!h")]();
                  (by[U("0x9f", "Fu38")](ZR < ZD), bY++);
                  break;
                }
                case bl[0x2d]: {
                  const Zt = by[U("0xad", "Wtwi")](),
                    Ze = by[U("0xd7", "5zWX")]();
                  (by[U(0xc2, "r]n&")](Ze <= Zt), bY++);
                  break;
                }
                case bl[0x2e]: {
                  const ZX = by[U("0xca", "c(K]")](),
                    ZH = by[U("0xd8", "oqaM")]();
                  (by[U("0xd9", "f(J&")](ZH > ZX), bY++);
                  break;
                }
                case bl[0x2f]: {
                  const Zw = by[U("0xb8", "(sPS")](),
                    Zz = by[U("0xda", "hHjw")]();
                  (by[U(0xdb, "JGtS")](Zz >= Zw), bY++);
                  break;
                }
                case bl[0x32]: {
                  bY = U3(bT[bY]);
                  break;
                }
                case bl[0x33]: {
                  by[U(0xd6, "CJ!h")]() ? (bY = U3(bT[bY])) : bY++;
                  break;
                }
                case bl[0x34]: {
                  !by[U("0xdc", "z4r4")]() ? (bY = U3(bT[bY])) : bY++;
                  break;
                }
                case bl[0x35]: {
                  const ZK = by[U("0xad", "Wtwi")]();
                  ZK !== null && ZK !== undefined ? (bY = U3(bT[bY])) : bY++;
                  break;
                }
                case bl[0x36]: {
                  const ZE = by[U("0xdd", "!a8Q")](),
                    ZP = by[U("0xcd", "SI&j")]();
                  (by[U("0xb2", "n[N$")](
                    ZP[U(0xde, "z4r4")](undefined, b4(by, ZE)),
                  ),
                    bY++);
                  break;
                }
                case bl[0x37]: {
                  const Zp = by[U("0xb6", "Fu38")](),
                    Zo = by[U("0xae", "SAmI")](),
                    ZN = by[U("0x91", "m]hN")]();
                  if (typeof Zo !== "function")
                    throw new TypeError(Zo + " is not a function");
                  (by[U(0xbe, "hHjw")](Zo[U(0xdf, "C$TP")](ZN, b4(by, Zp))),
                    bY++);
                  break;
                }
                case bl[0x38]: {
                  if (bS[U(0xe0, "IAcC")] > 0x0) {
                    const ZA = bS[bS[U("0x8b", "oqaM")] - 0x1];
                    if (ZA[U(0xe1, "@vun")] !== undefined) {
                      ((bf[U("0xe2", "n[N$")] = !![]),
                        (bf[U(0xe3, "Wtwi")] = by[U("0xb8", "(sPS")]()),
                        (bY = ZA[U(0xe4, "(sPS")]));
                      break;
                    }
                  }
                  bf[U("0xe5", "waD0")] &&
                    ((bf[U("0xe6", "9fK8")] = ![]),
                    (bf[U("0xe7", "QmhY")] = undefined));
                  ((U7 = !![]), (U8 = by[U(0xb1, "9sbv")]()));
                  return;
                }
                case bl[0x39]: {
                  throw by[U(0xdd, "!a8Q")]();
                }
                case bl[0x3f]: {
                  if (bS[U(0xe0, "IAcC")] > 0x0) {
                    const ZJ = bS[bS[U("0xe8", "r]n&")] - 0x1];
                    if (ZJ[U(0xe9, "JGtS")] !== undefined) {
                      ((bB[U("0xea", "hHjw")] = !![]),
                        (bB[U(0xeb, "Ows7")] = U3(bT[bY])),
                        (bY = ZJ[U(0xec, "W3hW")]));
                      break;
                    }
                  }
                  bY = U3(bT[bY]);
                  break;
                }
                case bl[0x40]: {
                  if (bS[U(0xe8, "r]n&")] > 0x0) {
                    const ZL = bS[bS[U(0xed, "lw7j")] - 0x1];
                    if (ZL[U("0xee", "NCda")] !== undefined) {
                      ((bh[U("0xef", "Gx#q")] = !![]),
                        (bh[U(0xf0, "waD0")] = U3(bT[bY])),
                        (bY = ZL[U(0xf1, "f#37")]));
                      break;
                    }
                  }
                  bY = U3(bT[bY]);
                  break;
                }
                case bl[0x3a]: {
                  const ZV = bM[bY];
                  (bS[U("0xf2", "IAcC")]({
                    catchIndex: ZV[0x0] >= 0x0 ? U3(ZV[0x0]) : undefined,
                    finallyIndex: ZV[0x1] >= 0x0 ? U3(ZV[0x1]) : undefined,
                    endIndex: ZV[0x2] >= 0x0 ? U3(ZV[0x2]) : undefined,
                    stackSize: by[U("0x6a", "BeXe")],
                  }),
                    bY++);
                  break;
                }
                case bl[0x3b]: {
                  (bS[U(0xdd, "!a8Q")](), bY++);
                  break;
                }
                case bl[0x3c]: {
                  const Zn = by[U("0xd7", "5zWX")]();
                  if (UF >= 0x0) {
                    const ZI = bd[UF];
                    U5[U("0xf3", "9sbv")][ZI] = Zn;
                  }
                  bY++;
                  break;
                }
                case bl[0x3d]: {
                  if (bS[U(0xf4, "W3hW")] > 0x0) {
                    const Zs = bS[bS[U("0x61", "d3%f")] - 0x1];
                    Zs[U("0xf5", "T[d%")] === bY &&
                      (Zs[U(0xf6, "f(J&")] !== undefined &&
                        (bv = Zs[U("0xf7", "4$Y3")]),
                      bS[U("0x91", "m]hN")]());
                  }
                  bY++;
                  break;
                }
                case bl[0x3e]: {
                  if (bf[U(0xf8, "@vun")]) {
                    const ZC = bf[U(0xf9, "Gx#q")];
                    ((bf[U("0xfa", "ID[x")] = ![]),
                      (bf[U(0xfb, "SI&j")] = undefined),
                      (U7 = !![]),
                      (U8 = ZC));
                    return;
                  }
                  if (bB[U(0xfc, "r]n&")]) {
                    const ZG = bB[U("0xeb", "Ows7")];
                    ((bB[U(0xfd, "T[d%")] = ![]),
                      (bB[U("0xfe", "NCda")] = 0x0),
                      (bY = ZG));
                    break;
                  }
                  if (bh[U("0xff", "z4r4")]) {
                    const Zj = bh[U(0xeb, "Ows7")];
                    ((bh[U(0x100, "(sPS")] = ![]),
                      (bh[U("0x101", "SI&j")] = 0x0),
                      (bY = Zj));
                    break;
                  }
                  if (bv !== null) {
                    const Zi = bv;
                    bv = null;
                    throw Zi;
                  }
                  bY++;
                  break;
                }
                case bl[0x46]: {
                  const Zk = by[U(0xbf, "F!70")](),
                    ZF = bd[UF];
                  if (Zk === null || Zk === undefined)
                    throw new TypeError(
                      "Cannot read property '" + ZF + "' of " + Zk,
                    );
                  (by[U(0xb5, "SI&j")](Zk[ZF]), bY++);
                  break;
                }
                case bl[0x47]: {
                  const Zq = by[U("0xbf", "F!70")](),
                    Zu = by[U("0xc5", "NCda")](),
                    Zr = bd[UF];
                  if (Zu === null || Zu === undefined)
                    throw new TypeError(
                      "Cannot set property '" + Zr + "' of " + Zu,
                    );
                  ((Zu[Zr] = Zq), by[U("0xc9", "w1ba")](Zq), bY++);
                  break;
                }
                case bl[0x48]: {
                  const Zm = by[U("0xdd", "!a8Q")](),
                    Zy = by[U("0xb9", "lw7j")]();
                  if (Zy === null || Zy === undefined)
                    throw new TypeError(
                      "Cannot read property '" + Zm + "' of " + Zy,
                    );
                  (by[U("0x5a", "F!70")](Zy[Zm]), bY++);
                  break;
                }
                case bl[0x49]: {
                  const Za = by[U("0xb8", "(sPS")](),
                    ZY = by[U(0xba, "W3hW")](),
                    Zd = by[U(0xb9, "lw7j")]();
                  if (Zd === null || Zd === undefined)
                    throw new TypeError(
                      "Cannot set property '" + ZY + "' of " + Zd,
                    );
                  ((Zd[ZY] = Za), by[U(0x102, "Wtwi")](Za), bY++);
                  break;
                }
                case bl[0x4a]: {
                  let ZW, ZT;
                  UF !== undefined
                    ? ((ZT = by[U(0xbf, "F!70")]()), (ZW = bd[UF]))
                    : ((ZW = by[U(0xb1, "9sbv")]()),
                      (ZT = by[U("0x103", "BeXe")]()));
                  const ZM = delete ZT[ZW];
                  (by[U(0x53, "@vun")](ZM), bY++);
                  break;
                }
                case bl[0x4b]: {
                  let ZQ = bd[UF],
                    ZS,
                    Zv =
                      typeof globalThis !== "undefined"
                        ? globalThis
                        : typeof window !== "undefined"
                          ? window
                          : global;
                  if (ZQ in E) ZS = E[ZQ];
                  else {
                    if (P && ZQ in P) ZS = P[ZQ];
                    else {
                      if (ZQ in Zv) ZS = Zv[ZQ];
                      else throw new ReferenceError(ZQ + " is not defined");
                    }
                  }
                  (by[U("0x104", "^HLG")](ZS), bY++);
                  break;
                }
                case bl[0x4c]: {
                  const Zf = by[U(0x105, "4$Y3")](),
                    ZB = bd[UF];
                  P && ZB in P ? (P[ZB] = Zf) : (E[ZB] = Zf);
                  (by[U(0xac, "oqaM")](Zf), bY++);
                  break;
                }
                case bl[0x4d]: {
                  (by[U(0x106, "!a8Q")]({}), bY++);
                  break;
                }
                case bl[0x4e]: {
                  const Zh = by[U(0x91, "m]hN")](),
                    Zl = bd[UF];
                  Zh === null || Zh === undefined
                    ? by[U(0x107, "y22^")](undefined)
                    : by[U("0x104", "^HLG")](Zh[Zl]);
                  bY++;
                  break;
                }
                case bl[0x4f]: {
                  const Zx = by[U("0xad", "Wtwi")](),
                    O0 = by[U(0xb6, "Fu38")]();
                  (by[U("0xac", "oqaM")](O0 in Zx), bY++);
                  break;
                }
                case bl[0x51]: {
                  const O1 = by[U(0xca, "c(K]")](),
                    O2 = by[by[U("0x65", "w1ba")] - 0x1];
                  O1 !== null &&
                    O1 !== undefined &&
                    Object[U(0x108, "9HM@")](O2, O1);
                  bY++;
                  break;
                }
                case bl[0x52]: {
                  const O3 = by[U("0x109", "9fK8")](),
                    O4 = by[U("0x105", "4$Y3")]();
                  O4 === null || O4 === undefined
                    ? by[U(0xc2, "r]n&")](undefined)
                    : by[U(0x10a, "^u[%")](O4[O3]);
                  bY++;
                  break;
                }
                case bl[0x91]: {
                  const O5 = by[U("0xba", "W3hW")](),
                    O6 = by[by[U("0x10b", "F!70")] - 0x1],
                    O7 = bd[UF],
                    O8 =
                      typeof O6 === "function" && O6[U(0x10c, "f#37")]
                        ? O6[U("0x10d", "Wtwi")]
                        : O6;
                  (Object[U("0x10e", "QeOg")](O8, O7, {
                    get: O5,
                    enumerable: O8 === O6,
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x92]: {
                  const O9 = by[U("0x9e", "Ows7")](),
                    Ob = by[by[U(0x10f, "5zWX")] - 0x1],
                    OU = bd[UF],
                    OZ =
                      typeof Ob === "function" && Ob[U("0x110", "NCda")]
                        ? Ob[U("0x111", "ID[x")]
                        : Ob;
                  (Object[U(0x112, "T[d%")](OZ, OU, {
                    set: O9,
                    enumerable: OZ === Ob,
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x8c]: {
                  const OO = by[U("0xb3", "QmhY")](),
                    Oc = by[U(0xce, "mJvw")](),
                    Og = UF,
                    OD = ((OR, Ot, Oe) => {
                      let OX;
                      return (
                        Oe
                          ? (OX = function () {
                              if (Ot) {
                                E["__$$constructor$$__"] = OX;
                                const OH = "__$$newTarget$$__" in E;
                                !OH && (E["__$$newTarget$$__"] = new.target);
                                try {
                                  const Ow = [];
                                  for (
                                    let Oz = 0x0;
                                    Oz < arguments[U(0x113, "^u[%")];
                                    Oz++
                                  ) {
                                    Ow[U(0xd2, "c(K]")](arguments[Oz]);
                                  }
                                  return Ot[U(0x114, "y22^")](this, Ow);
                                } finally {
                                  (delete E["__$$constructor$$__"],
                                    !OH && delete E["__$$newTarget$$__"]);
                                }
                              }
                            })
                          : (OX = function () {
                              if (Ot) {
                                const OH = "__$$newTarget$$__" in E;
                                !OH && (E["__$$newTarget$$__"] = new.target);
                                try {
                                  const Ow = [];
                                  for (
                                    let Oz = 0x0;
                                    Oz < arguments[U("0x115", "T[d%")];
                                    Oz++
                                  ) {
                                    Ow[U(0x59, "Ax7%")](arguments[Oz]);
                                  }
                                  return Ot[U("0x116", "QeOg")](this, Ow);
                                } finally {
                                  !OH && delete E["__$$newTarget$$__"];
                                }
                              }
                            }),
                        OX
                      );
                    })(OO, Oc, Og);
                  OO &&
                    Object[U(0x117, "SAmI")](OD, "name", {
                      value: OO,
                      configurable: !![],
                    });
                  (by[U(0x69, "ID[x")](OD), bY++);
                  break;
                }
                case bl[0x8d]: {
                  const OR = by[U("0xae", "SAmI")](),
                    Ot = by[by[U(0x65, "w1ba")] - 0x1];
                  (Object[U("0x118", "mJvw")](
                    Ot[U("0x119", "QmhY")],
                    OR[U(0x11a, "d3%f")],
                  ),
                    Object[U(0x11b, "4$Y3")](Ot, OR),
                    (Ot[U("0x11c", "T[d%")] = OR),
                    bY++);
                  break;
                }
                case bl[0x8e]: {
                  let Oe = by[U(0xb1, "9sbv")](),
                    OX = by[U("0xc7", "f#37")](),
                    OH = Object[U(0x11d, "Ax7%")](
                      Object[U("0x11e", "y22^")](OX),
                    ),
                    Ow = Object[U(0x11f, "SI&j")](OH, Oe),
                    Oz;
                  Ow && Ow[U("0x120", "m]hN")]
                    ? ((Oz = Ow[U("0x121", "Fu38")][U("0x122", "ID[x")](OX)),
                      by[U("0xcf", "Ows7")](Oz))
                    : ((Oz = OH[Oe]),
                      typeof Oz === "function"
                        ? by[U(0x53, "@vun")](Oz[U(0x123, "W3hW")](OX))
                        : by[U("0xb2", "n[N$")](Oz));
                  bY++;
                  break;
                }
                case bl[0x8f]: {
                  const OK = by[U(0x124, "r]n&")](),
                    OE = by[U(0xc7, "f#37")](),
                    OP = by[U(0xc5, "NCda")](),
                    Op = Object[U("0x125", "5zWX")](
                      Object[U("0x11d", "Ax7%")](OP),
                    );
                  ((Op[OE] = OK), by[U(0xbe, "hHjw")](OK), bY++);
                  break;
                }
                case bl[0x90]: {
                  const Oo = by[U(0x109, "9fK8")](),
                    ON = by[by[U(0x65, "w1ba")] - 0x1],
                    OA = bd[UF];
                  (Object[U("0x126", "lw7j")](ON[U("0x127", "5zWX")], OA, {
                    value: Oo,
                    writable: !![],
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x93]: {
                  const OJ = by[U(0xd1, "C$TP")](),
                    OL = by[by[U(0x128, "mJvw")] - 0x1],
                    OV = bd[UF];
                  (Object[U(0x129, "9sbv")](OL, OV, {
                    value: OJ,
                    writable: !![],
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x94]: {
                  const On = by[U(0xca, "c(K]")](),
                    OI = by[by[U("0x12a", "7C2)")] - 0x1],
                    Os = bd[UF];
                  (Object[U(0x12b, "BeXe")](OI, Os, {
                    get: On,
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x95]: {
                  const OC = by[U("0xd1", "C$TP")](),
                    OG = by[by[U(0x12c, "C$TP")] - 0x1],
                    Oj = bd[UF];
                  (Object[U(0x12d, "tO6Y")](OG, Oj, {
                    set: OC,
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xaa]: {
                  const Oi = by[U("0xc7", "f#37")](),
                    Ok = by[U("0x12e", "tO6Y")](),
                    OF = by[by[U("0xe0", "IAcC")] - 0x1];
                  (Object[U("0x12f", "c(K]")](OF[U(0x110, "NCda")], Ok, {
                    value: Oi,
                    writable: !![],
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xab]: {
                  const Oq = by[U("0xd8", "oqaM")](),
                    Ou = by[U(0xb9, "lw7j")](),
                    Or = by[by[U(0x63, "m]hN")] - 0x1];
                  (Object[U(0x130, "SI&j")](Or, Ou, {
                    value: Oq,
                    writable: !![],
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xac]: {
                  const Om = by[U(0xb8, "(sPS")](),
                    Oy = by[U(0xd4, "67gO")](),
                    Oa = by[by[U("0x128", "mJvw")] - 0x1],
                    OY =
                      typeof Oa === "function" && Oa[U(0x131, "(sPS")]
                        ? Oa[U("0x110", "NCda")]
                        : Oa;
                  (Object[U(0x132, "Fu38")](OY, Oy, {
                    get: Om,
                    enumerable: OY === Oa,
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xad]: {
                  const Od = by[U(0xb6, "Fu38")](),
                    OW = by[U("0x133", "^HLG")](),
                    OT = by[by[U("0x8a", "9fK8")] - 0x1],
                    OM =
                      typeof OT === "function" && OT[U(0x134, "mj6Y")]
                        ? OT[U("0x119", "QmhY")]
                        : OT;
                  (Object[U("0x129", "9sbv")](OM, OW, {
                    set: Od,
                    enumerable: OM === OT,
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xae]: {
                  const OQ = by[U(0x12e, "tO6Y")](),
                    OS = by[U("0xd6", "CJ!h")](),
                    Ov = by[by[U("0x12a", "7C2)")] - 0x1];
                  (Object[U("0x135", "^u[%")](Ov, OS, {
                    get: OQ,
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0xaf]: {
                  const Of = by[U("0x76", "@vun")](),
                    OB = by[U(0xb3, "QmhY")](),
                    Oh = by[by[U(0x10b, "F!70")] - 0x1];
                  (Object[U("0x136", "NCda")](Oh, OB, {
                    set: Of,
                    enumerable: ![],
                    configurable: !![],
                  }),
                    bY++);
                  break;
                }
                case bl[0x69]: {
                  const Ol = by[U(0x137, "Gx#q")](),
                    Ox = b4(by, Ol),
                    c0 = by[U("0x95", "waD0")]();
                  if (UF === 0x1) {
                    (by[U(0xb5, "SI&j")](Ox), bY++);
                    break;
                  }
                  if (typeof c0 !== "function")
                    throw new TypeError(
                      "Super expression must be a constructor",
                    );
                  E["__$$newTarget$$__"] = br;
                  try {
                    c0[U("0x138", "lw7j")](bm, Ox);
                  } finally {
                    delete E["__$$newTarget$$__"];
                  }
                  bY++;
                  break;
                }
                case bl[0x64]: {
                  const c1 = by[U("0xae", "SAmI")](),
                    c2 = b2(c1),
                    c3 = c2 && c2[A["a"]],
                    c4 = c2 && c2[A["s"]],
                    c5 = c2 && c2[A["g"]],
                    c6 = U5,
                    c7 = bG,
                    c8 = bj,
                    c9 = bi,
                    cb =
                      c2 && c2[A["ni"]] !== undefined
                        ? c2[A["c"]][c2[A["ni"]]]
                        : undefined,
                    cU = ((cZ, cO, cc, cg, cD, cR, ct, ce, cX) => {
                      let cH, cw;
                      if (cD)
                        cw = function () {
                          const cz = [];
                          for (
                            let cK = 0x0;
                            cK < arguments[U(0x10b, "F!70")];
                            cK++
                          ) {
                            cz[U("0xaa", "mj6Y")](arguments[cK]);
                          }
                          return ce[U(0x139, "F!70")](this, cZ, cz, cO, cH);
                        };
                      else
                        cg
                          ? (cw = async function () {
                              const cz = [];
                              for (
                                let cE = 0x0;
                                cE < arguments[U(0x12a, "7C2)")];
                                cE++
                              ) {
                                cz[U(0xa4, "d3%f")](arguments[cE]);
                              }
                              const cK =
                                new.target !== undefined
                                  ? new.target
                                  : E["__$$newTarget$$__"];
                              return cc
                                ? await ct(cZ, cz, cO, cH, undefined)
                                : await ct[U(0x13a, "^u[%")](
                                    this,
                                    cZ,
                                    cz,
                                    cO,
                                    cH,
                                    cK,
                                  );
                            })
                          : (cw = function () {
                              const cz = [];
                              for (
                                let cE = 0x0;
                                cE < arguments[U("0x13b", "@vun")];
                                cE++
                              ) {
                                cz[U(0x53, "@vun")](arguments[cE]);
                              }
                              const cK =
                                new.target !== undefined
                                  ? new.target
                                  : E["__$$newTarget$$__"];
                              return cc
                                ? cR(cZ, cz, cO, cH, undefined)
                                : cR[U(0x13c, "c(K]")](
                                    this,
                                    cZ,
                                    cz,
                                    cO,
                                    cH,
                                    cK,
                                  );
                            });
                      cH = cw;
                      if (cX)
                        try {
                          Object[U(0x13d, "mJvw")](cH, "name", {
                            value: cX,
                            writable: ![],
                            enumerable: ![],
                            configurable: !![],
                          });
                        } catch (cz) {}
                      return cH;
                    })(c1, c6, c3, c4, c5, c7, c8, c9, cb);
                  if (!cU)
                    throw new Error(
                      "VM Error: Failed to create closure for bytecode ID " +
                        c1,
                    );
                  (by[U("0xf2", "IAcC")](cU), bY++);
                  break;
                }
                case bl[0x68]: {
                  const cZ = by[U(0xba, "W3hW")](),
                    cO = b4(by, cZ),
                    cc = by[U("0x13e", "f(J&")]();
                  if (typeof cc !== "function")
                    throw new TypeError(cc + " is not a constructor");
                  const cg = Reflect[U(0x13f, "n[N$")](cc, cO);
                  (by[U("0x5a", "F!70")](cg), bY++);
                  break;
                }
                case bl[0x5a]: {
                  (by[U(0xa1, "CJ!h")]([]), bY++);
                  break;
                }
                case bl[0x5b]: {
                  const cD = by[U("0xa0", "ID[x")](),
                    cR = by[by[U(0x61, "d3%f")] - 0x1];
                  (cR[U(0x140, "QmhY")](cD), bY++);
                  break;
                }
                case bl[0x5d]: {
                  const ct = by[U("0xba", "W3hW")]();
                  (by[U(0xc9, "w1ba")]({ __spread__: !![], value: ct }), bY++);
                  break;
                }
                case bl[0x5e]: {
                  const ce = by[U(0x9e, "Ows7")](),
                    cX = by[by[U(0x61, "d3%f")] - 0x1];
                  if (Array[U(0x141, "lw7j")](ce))
                    Array[U("0x142", "9sbv")][U("0x143", "QeOg")][
                      U("0x144", "f#37")
                    ](cX, ce);
                  else
                    for (const cH of ce) {
                      cX[U(0x145, "5zWX")](cH);
                    }
                  bY++;
                  break;
                }
                case bl[0x6e]: {
                  (by[U("0xbe", "hHjw")](typeof by[U("0x137", "Gx#q")]()),
                    bY++);
                  break;
                }
                case bl[0x6f]: {
                  const cw = by[U("0xd8", "oqaM")](),
                    cz = by[U(0x146, "T[d%")]();
                  (by[U("0x69", "ID[x")](cz instanceof cw), bY++);
                  break;
                }
                case bl[0x70]: {
                  const cK = bd[UF],
                    cE =
                      typeof globalThis !== "undefined"
                        ? globalThis
                        : typeof window !== "undefined"
                          ? window
                          : global;
                  if (cK in E) by[U("0xb2", "n[N$")](typeof E[cK]);
                  else
                    P && cK in P
                      ? by[U(0xcc, "NCda")](typeof P[cK])
                      : by[U("0x8f", "$M$P")](typeof cE[cK]);
                  bY++;
                  break;
                }
                case bl[0xd2]: {
                  const cP = by[U(0x76, "@vun")](),
                    cp = { vars: {}, constVars: {}, tdzVars: {}, parent: cP };
                  ((U5 = cp), bY++);
                  break;
                }
                case bl[0xd3]: {
                  let co = bd[UF],
                    cN = U5,
                    cA,
                    cJ = ![];
                  while (cN) {
                    if (cN[U(0x147, "$M$P")] && co in cN[U(0x148, "ID[x")])
                      throw new ReferenceError(
                        "Cannot access '" + co + "' before initialization",
                      );
                    if (co in cN[U("0x149", "r]n&")]) {
                      ((cA = cN[U(0x14a, "NCda")][co]), (cJ = !![]));
                      break;
                    }
                    cN = cN[U(0x14b, "Gx#q")];
                  }
                  if (!cJ) {
                    if (co in E) cA = E[co];
                    else
                      P && co in P
                        ? (cA = P[co])
                        : (cA = (
                            typeof globalThis !== "undefined"
                              ? globalThis
                              : typeof window !== "undefined"
                                ? window
                                : global
                          )[co]);
                  }
                  (by[U("0x14c", "z4r4")](cA), bY++);
                  break;
                }
                case bl[0xd4]: {
                  let cL = bd[UF],
                    cV = by[U("0xad", "Wtwi")](),
                    cn = U5,
                    cI = ![];
                  while (cn) {
                    if (cL in cn[U(0x14d, "67gO")]) {
                      if (cn[U(0x14e, "^HLG")] && cL in cn[U("0x14f", "@TcF")])
                        throw new TypeError("Assignment to constant variable.");
                      cn[U("0x150", "y22^")] &&
                        cL in cn[U("0x151", "5zWX")] &&
                        delete cn[U(0x152, "w1ba")][cL];
                      ((cn[U("0x153", "BeXe")][cL] = cV), (cI = !![]));
                      break;
                    }
                    cn = cn[U("0x154", "IAcC")];
                  }
                  !cI &&
                    (U5[U(0x155, "r]n&")] &&
                      cL in U5[U("0x148", "ID[x")] &&
                      delete U5[U("0x156", "NCda")][cL],
                    (U5[U(0x157, "T[d%")][cL] = cV));
                  bY++;
                  break;
                }
                case bl[0xd5]: {
                  (by[U(0xbd, "Gx#q")](U5), bY++);
                  break;
                }
                case bl[0xd6]: {
                  U5 && U5[U("0x158", "9sbv")] && (U5 = U5[U("0x159", "CJ!h")]);
                  bY++;
                  break;
                }
                case bl[0xd7]: {
                  const cs = bd[UF],
                    cC = by[U(0xd0, "^u[%")]();
                  if (U5[U("0x155", "r]n&")]) {
                    cs in U5[U("0x15a", "^HLG")] &&
                      delete U5[U("0x15b", "SI&j")][cs];
                    const cG = cs[U("0x15c", "f#37")]("$$")[0x0];
                    cG !== cs &&
                      cG in U5[U(0x148, "ID[x")] &&
                      delete U5[U("0x15d", "T[d%")][cG];
                  }
                  ((U5[U("0x15e", "9HM@")][cs] = cC), bY++);
                  break;
                }
                case bl[0xd8]: {
                  let cj = bd[UF],
                    ci = by[U("0x15f", "$M$P")](),
                    ck = U5,
                    cF = ![];
                  while (ck) {
                    if (cj in ck[U(0x160, "n[N$")]) {
                      if (ck[U("0x161", "f#37")] && cj in ck[U(0x162, "^u[%")])
                        break;
                      ck[U(0x14d, "67gO")][cj] = ci;
                      !ck[U(0x163, "waD0")] && (ck[U(0x164, "C$TP")] = {});
                      ((ck[U("0x165", "z4r4")][cj] = !![]), (cF = !![]));
                      break;
                    }
                    ck = ck[U("0x166", "y22^")];
                  }
                  !cF &&
                    (U5[U("0x167", "mj6Y")] &&
                      cj in U5[U(0x168, "QeOg")] &&
                      delete U5[U(0x169, "9sbv")][cj],
                    (U5[U(0x16a, "y22^")][cj] = ci),
                    !U5[U("0x16b", "CJ!h")] && (U5[U("0x16c", "W3hW")] = {}),
                    (U5[U(0x16d, "NCda")][cj] = !![]));
                  bY++;
                  break;
                }
                case bl[0xd9]: {
                  const cq = bd[UF],
                    cu = by[U(0x103, "BeXe")]();
                  if (U5[U(0x16e, "c(K]")]) {
                    cq in U5[U(0x169, "9sbv")] &&
                      delete U5[U(0x15b, "SI&j")][cq];
                    const cr = cq[U("0x16f", "waD0")]("$$")[0x0];
                    cr !== cq &&
                      cr in U5[U(0x170, "4$Y3")] &&
                      delete U5[U(0x171, "W3hW")][cr];
                  }
                  U5[U(0x172, "@vun")][cq] = cu;
                  !U5[U(0x173, "Ax7%")] && (U5[U("0x174", "4$Y3")] = {});
                  ((U5[U(0x175, "Gx#q")][cq] = !![]), bY++);
                  break;
                }
                case bl[0xda]: {
                  const cm = bd[UF];
                  !U5[U(0x168, "QeOg")] && (U5[U(0x176, "BeXe")] = {});
                  ((U5[U("0x148", "ID[x")][cm] = !![]), bY++);
                  break;
                }
                case bl[0xa0]: {
                  (by[U("0xb2", "n[N$")](bm), bY++);
                  break;
                }
                case bl[0xa1]: {
                  const cy = Array[U(0x142, "9sbv")][U("0x177", "f(J&")][
                    U(0x178, "SAmI")
                  ](bF || []);
                  ((cy[U(0x179, "NCda")] = bu), by[U(0xac, "oqaM")](cy), bY++);
                  break;
                }
                case bl[0xa4]: {
                  (by[U(0x106, "!a8Q")](br), bY++);
                  break;
                }
                case bl[0xa2]: {
                  const ca = UF & 0xffff,
                    cY = UF >> 0x10,
                    cd = bd[ca],
                    cW = bd[cY];
                  (by[U("0xaf", "C$TP")](new RegExp(cd, cW)), bY++);
                  break;
                }
                case bl[0xa3]: {
                  (by[U("0xad", "Wtwi")](),
                    by[U("0x104", "^HLG")](undefined),
                    bY++);
                  break;
                }
                case bl[0xa7]: {
                  if (UF === -0x1) by[U(0xaa, "mj6Y")](Symbol());
                  else {
                    const cT = by[U("0xbf", "F!70")]();
                    by[U("0x7c", "4$Y3")](Symbol(cT));
                  }
                  bY++;
                  break;
                }
                case bl[0xa8]: {
                  const cM = bd[UF];
                  (by[U(0xac, "oqaM")](Symbol[U(0x17a, "f#37")](cM)), bY++);
                  break;
                }
                case bl[0xa9]: {
                  const cQ = by[U(0x17b, "QeOg")]();
                  (by[U("0xc9", "w1ba")](Symbol[U(0x17c, "^u[%")](cQ)), bY++);
                  break;
                }
                case bl[0xaa]: {
                  bY++;
                  break;
                }
                case bl[0xc8]: {
                  debugger;
                  bY++;
                  break;
                }
                case bl[0xc9]: {
                  bY++;
                  break;
                }
                case bl[0xca]: {
                  ((U7 = !![]),
                    (U8 =
                      by[U("0x17d", "ID[x")] > 0x0
                        ? by[U(0xb8, "(sPS")]()
                        : undefined));
                  return;
                }
                case bl[0x7f]: {
                  const cS = by[U("0x103", "BeXe")]();
                  if (cS == null)
                    throw new TypeError("Cannot iterate over " + cS);
                  const cv = cS[Symbol[U("0x17e", "Gx#q")]];
                  if (typeof cv !== "function")
                    throw new TypeError("Object is not iterable");
                  (by[U("0x17f", "67gO")](cv[U(0x180, "hHjw")](cS)), bY++);
                  break;
                }
                case bl[0x7b]: {
                  const cf = by[U(0xc7, "f#37")](),
                    cB = cf[U("0x181", "waD0")]();
                  (by[U("0x104", "^HLG")](cB), bY++);
                  break;
                }
                case bl[0x80]: {
                  const ch = by[U("0xb3", "QmhY")]();
                  (by[U(0x106, "!a8Q")](!!ch[U(0x182, "@TcF")]), bY++);
                  break;
                }
                case bl[0xfa]: {
                  ((ba[UF] = ba[UF] + 0x1), bY++);
                  break;
                }
                case bl[0xfb]: {
                  ((ba[UF] = ba[UF] - 0x1), bY++);
                  break;
                }
                case bl[0xfc]: {
                  const cl = UF & 0xffff,
                    cx = UF >>> 0x10;
                  (by[U("0x53", "@vun")](ba[cl] + bd[cx]), bY++);
                  break;
                }
                case bl[0xfd]: {
                  const g0 = UF & 0xffff,
                    g1 = UF >>> 0x10;
                  (by[U("0xc6", "waD0")](ba[g0] - bd[g1]), bY++);
                  break;
                }
                case bl[0xfe]: {
                  const g2 = UF & 0xffff,
                    g3 = UF >>> 0x10;
                  (by[U("0x107", "y22^")](ba[g2] * bd[g3]), bY++);
                  break;
                }
                case bl[0xff]: {
                  const g4 = UF & 0xffff,
                    g5 = UF >>> 0x10,
                    g6 = ba[g4],
                    g7 = bd[g5];
                  (by[U("0x143", "QeOg")](g6[g7]), bY++);
                  break;
                }
                case bl[0x100]: {
                  const g8 = UF & 0xffff,
                    g9 = UF >>> 0x10;
                  (by[U(0xd9, "f(J&")](ba[g8] < bd[g9]), bY++);
                  break;
                }
                case bl[0x101]: {
                  const gb = UF & 0xffff,
                    gU = UF >>> 0x10;
                  ba[gb] < bd[gU] ? (bY = U3(bT[bY])) : bY++;
                  break;
                }
                case bl[0x102]: {
                  const gZ = UF & 0xffff,
                    gO = UF >>> 0x10,
                    gc = by[U("0x183", "JGtS")](),
                    gg = b4(by, gc),
                    gD = ba[gZ],
                    gR = bd[gO],
                    gt = gD[gR];
                  (by[U(0x14c, "z4r4")](gt[U(0x116, "QeOg")](gD, gg)), bY++);
                  break;
                }
                case bl[0x103]: {
                  ((ba[UF] = by[U("0xd3", "IAcC")]()), bY++);
                  break;
                }
                case bl[0x104]: {
                  const ge = ba[UF] + 0x1;
                  ((ba[UF] = ge), by[U(0xcc, "NCda")](ge), bY++);
                  break;
                }
                case bl[0x105]: {
                  const gX = ba[UF] - 0x1;
                  ((ba[UF] = gX), by[U(0x106, "!a8Q")](gX), bY++);
                  break;
                }
                default:
                  throw new Error(
                    "Unknown opcode: " + UN + " (logical: " + Uo + ")",
                  );
              }
            };
            for (var UZ in bl) {
              bl[U("0x184", "4$Y3")](UZ) &&
                ((Ui) => {
                  U9[Ub[Ui]] = (Uk) => {
                    UR(Ui, Uk);
                  };
                })(bl[UZ]);
            }
          }
          U9[Ub[UN]](UJ);
          if (U7) return ((U7 = ![]), U8);
        }
        break;
      } catch (Ui) {
        if (bS[U(0x39, "9sbv")] > 0x0) {
          const Uk = bS[bS[U(0xf4, "W3hW")] - 0x1];
          by[U("0x185", "hHjw")] = Uk[U("0x186", "^u[%")];
          if (Uk[U("0x187", "QeOg")] !== undefined)
            (by[U("0xcf", "Ows7")](Ui),
              (bY = Uk[U("0x188", "$M$P")]),
              (Uk[U(0x189, "waD0")] = undefined),
              Uk[U(0x18a, "w1ba")] === undefined && bS[U(0xae, "SAmI")]());
          else
            Uk[U(0x18a, "w1ba")] !== undefined
              ? ((bY = Uk[U(0x18b, "tO6Y")]), (Uk[U(0x18c, "ID[x")] = Ui))
              : ((bY = Uk[U("0x18d", "T[d%")]), bS[U(0x95, "waD0")]());
          continue;
        }
        throw Ui;
      }
    }
    return by[U("0x65", "w1ba")] > 0x0 ? by[U(0xd0, "^u[%")]() : undefined;
  }

  const bG = function (bk, bF, bq, bu, br) {
      const bm = b2(bk),
        by = bC(bm, bF, bq, bu, br, this),
        ba = by[U(0x18e, "mj6Y")]();
      while (!ba[U("0x18f", "d3%f")]) {
        throw new Error("Unexpected async/generator operation in sync context");
      }
      return ba[U(0x190, "r]n&")];
    },
    bj = async function (bk, bF, bq, bu, br) {
      let bm = b2(bk),
        by = bC(bm, bF, bq, bu, br, this),
        ba = by[U("0x191", "w1ba")]();
      while (!ba[U("0x192", "w1ba")]) {
        if (ba[U("0x193", "5zWX")]["t"] === 0x1)
          try {
            const bY = await Promise[U(0x194, "SI&j")](
              ba[U(0x195, "d3%f")]["v"],
            );
            ba = by[U("0x196", "SAmI")](bY);
          } catch (bd) {
            ba = by[U("0x197", "QeOg")](bd);
          }
        else throw new Error("Unexpected yield in async context");
      }
      return ba[U("0x198", "y22^")];
    },
    bi = function (bk, bF, bq, bu) {
      let br = b2(bk),
        bm = bC(br, bF, bq, bu, undefined, this),
        by = ![],
        ba = null;

      function bd(bT, bM) {
        if (by) return { value: undefined, done: !![] };
        if (ba) {
          let bS;
          try {
            bS = bM
              ? typeof ba[U(0x199, "w1ba")] === "function"
                ? ba[U("0x19a", "C$TP")](bT)
                : ((ba = null),
                  (() => {
                    throw bT;
                  })())
              : ba[U("0x19b", "m]hN")](bT);
          } catch (bv) {
            ba = null;
            try {
              const bf = bm[U("0x19c", "^HLG")](bv);
              return bW(bf);
            } catch (bB) {
              by = !![];
              throw bB;
            }
          }
          if (!bS[U(0x19d, "r]n&")])
            return { value: bS[U(0x19e, "JGtS")], done: ![] };
          ((ba = null), (bT = bS[U("0x19f", "tO6Y")]), (bM = ![]));
        }
        let bQ;
        try {
          bQ = bM ? bm[U("0x1a0", "z4r4")](bT) : bm[U("0x1a1", "@TcF")](bT);
        } catch (bh) {
          by = !![];
          throw bh;
        }
        return bW(bQ);
      }

      function bW(bT) {
        if (bT[U(0x1a2, "4$Y3")])
          return ((by = !![]), { value: bT[U("0x19f", "tO6Y")], done: !![] });
        const bM = bT[U(0x195, "d3%f")];
        if (bM["t"] === 0x2) return { value: bM["v"], done: ![] };
        if (bM["t"] === 0x3) {
          let bQ = bM["v"],
            bS = bQ;
          bS &&
            typeof bS[Symbol[U(0x1a3, "^u[%")]] === "function" &&
            (bS = bS[Symbol[U(0x1a4, "JGtS")]]());
          if (bS && typeof bS[U("0x1a5", "Ows7")] === "function") {
            const bv = bS[U("0x18e", "mj6Y")]();
            if (!bv[U("0x1a6", "QeOg")])
              return ((ba = bS), { value: bv[U(0x1a7, "w1ba")], done: ![] });
            return bd(bv[U(0x1a8, "lw7j")], ![]);
          }
          return bd(undefined, ![]);
        }
        throw new Error("Unexpected signal in generator");
      }

      return {
        next: (bT) => bd(bT, ![]),
        return: (bT) => {
          if (by) return { value: bT, done: !![] };
          by = !![];
          try {
            bm[U("0x1a9", "^u[%")](bT);
          } catch (bM) {}
          return { value: bT, done: !![] };
        },
        throw: (bT) => {
          if (by) throw bT;
          return bd(bT, !![]);
        },
        [Symbol[U("0x1aa", "mj6Y")]]: function () {
          return this;
        },
      };
    };
  return function (bk, bF, bq, bu, br) {
    const bm = b2(bk);
    if (bm && bm[A["g"]]) return bi[U("0x139", "F!70")](this, bk, bF, bq, bu);
    else
      return bm && bm[A["s"]]
        ? bj[U(0x1ab, "lw7j")](this, bk, bF, bq, bu, br)
        : bG[U(0x1ac, "f#37")](this, bk, bF, bq, bu, br);
  };
})();
E[U(0x1ad, "(sPS")] = o;

function o(N, A) {
  return p[U("0x1ae", "f(J&")](
    this,
    0x0,
    Array[U(0x1af, "Wtwi")](arguments),
    undefined,
    o,
  );
}

function b() {
  const gH = [
    "D3StW5VcHG",
    "cSkAp8k8",
    "WOBcOmkeW5NdSW",
    "W7ddLY4t",
    "h3L0WO7cTW",
    "WQZdNSkoFJS",
    "WP7cPCk0bMq",
    "BCoaW7RdQq",
    "W44eWRxcHW",
    "WOT0ASoPb8oDeJK",
    "agX9WONcS1FcHSoF",
    "jrZdTSoK",
    "p3awsq",
    "WRNcU8kVxCo/",
    "ctTnrrq",
    "WPbLE8oUfmoh",
    "WOhcTCkFluHoWOe3",
    "hdTnxa",
    "C8k5zH4",
    "WOTBeaP0FmkoWQVdGSooW5fuDCoK",
    "bCoUj8kj",
    "cJZcRay",
    "WOT2WOu",
    "Ac9khCkNygPAWOtdTSkbWQi",
    "x8kNW5K9W7hdI8kb",
    "aSo1CCoMa1VcKgvig8of",
    "WRvZkJ0MgNNcISkF",
    "W5qmAmo4W4tcHJL3xmoeywm",
    "W6GEu2mVW5ZcU1ddJmotchHp",
    "W4ZcU8kFWOzot8kyW5jsWQeBW54m",
    "i8oUmKhdUSkTWQznw8obumobwG",
    "EYnfWOpcIdlcU2xdOSoieSkauCo3",
    "W6OwuMePW5RdH1RdVSoHafC",
    "W5fuWOpdTCk5qbi",
    "W77dRCo6g8kTW73dQ8kUd8ouvW",
    "W5ldTmoZusrCW6baW5b8WOZdNW",
    "aSo6E8oMba3dU3PKamocW5qQ",
    "W61ip3XXWPrcWORdOCo4W5K8WPe",
    "WQFcV8k1z2JcU0HDjSklW7xcHG4",
    "awbogNaFiHxdJXRcIelcTSon",
    "WPRdVCoj",
    "DComW6FdQG",
    "WO94BCkRW7va",
    "W7BdSmo5mrldRX5EbSk1",
    "WPRdSCoBW5y3gSocW4jvWOm",
    "WPpdHmo3",
    "WPjYymoVcCoDbdVcVq",
    "bSkkiq",
    "cCoPlq",
    "Bmomk3xdUX1DWP3cLq",
    "WP3dSmom",
    "emoMlSks",
    "gd9vzrGotIVdPG",
    "WQlcK8kG",
    "WRxdMCke",
    "W5DHWRitnmo6s8k6EW",
    "WRJdHSo0",
    "DxOeW4m",
    "WO9FcdXOFSkBW6ZcLq",
    "edXh",
    "hCk+WQVdLSogW4KJpeG",
    "WRbipq",
    "WRVcNmkJyW",
    "W4NcTK9NmI8Cna",
    "WODCgG",
    "WRzabG",
    "h3GG",
    "W6tdQfhdRa",
    "W4b2WQKHn8oHu8k+kmoJ",
    "WPFdRSoj",
    "WP1/zmk5W79gDJxcHG",
    "DCoeW7ddTaNdGa",
    "owCd",
    "dY9MySoZzG",
    "W6tcK3O",
    "CmojW6VdVGi",
    "W4hcTv0",
    "WQdcVmkL",
    "WOXFhWzLDq",
    "WP7cRCkyW5hdSmo0",
    "WRuEys4WW4W",
    "WQZcSSkIwSozW7xdNmkhb8oO",
    "W6hcIxy",
    "iYbd",
    "WPRcLmkL",
    "txC5",
    "WQNdI8kq",
    "gSkEW4O",
    "gMXQ",
    "WPHwmq",
    "zSk5EbVcOCoR",
    "W5fYWQ8onCo6",
    "qZ0Psszp",
    "WR7cMmkvyaXzWP4",
    "gN1tWP7cQW",
    "eSkEnCkHWOCt",
    "zCoRoa",
    "W7aJBGerjq",
    "h8klW4OhW6BdMq",
    "WOVdUSoZySoZW4u",
    "WO3cU8kD",
    "W6jHeG",
    "e8k8Eq",
    "fG4uW4lcRmoh",
    "lIXk",
    "phidW5ZdLxi",
    "WP0sDmkD",
    "prJdVmo5W7JcHa",
    "W6jJfG",
    "AIbt",
    "W4JdPq8",
    "WP55Eq",
    "hCk5WRFdIG",
    "WPXalSkO",
    "WPf4WPddJ8kUuG",
    "W7dcH24oW4GG",
    "rCkJoSk8wKG",
    "WQ9heJLXWPK",
    "emoUoCkmWRec",
    "qZWttYy",
    "W7S3tK0PWRy",
    "C8kWAWdcJSoR",
    "cmkAkCkVWP0p",
    "W6SJza",
    "WQpcV8kTt8oUW7i",
    "W7/dRmo0jW",
    "uMyLWPBcRSoW",
    "oMeEW4hdLhldScldNG",
    "hWWaCq",
    "W4lcTLvjkdm",
    "gCkyW5CAW6FdMCkryri",
    "txyPWOlcRSoQW6KPBG",
    "aCkPWQRdHCoDW5u",
    "v24+WP0",
    "ASoiW7FdSq",
    "gIz1ECoEFxtdNLeX",
    "WQhcKmkOCXLf",
    "acVcRqW3WRS",
    "WOSvAmkyfqJcS8k+tSoRC8kt",
    "WRPoasjCWOldP2BdQmo0",
    "gCkJWPFdLSoBW5q0kW",
    "WP0iDW",
    "xmo6W7hdRrxdKqNdTSo1WR4",
    "g8kTWQJdL8om",
    "i2aWW4FdIwFdSa",
    "WOT8WOZdGCk0tG",
    "WRTDDSoN",
    "W5OEWQJcIG",
    "hIVcTq4XWQaT",
    "a8kJWRm",
    "W68VAqq",
    "WOfxcqu",
    "mNinqa",
    "cWFdN8oR",
    "W4FcVK5c",
    "qcujra",
    "W7VdSNldSMDjxCkk",
    "W73dIWKyW6ZcP8kTWPSb",
    "wsm8rs1czeC",
    "WOfjnqD1DCkiWRRdLq",
    "WOfOzCkQW6rA",
    "x8kNjSkYqfq",
    "bCkpW5yjW7ZdHq",
    "W5KgWOJcH0FdMG",
    "WP5OqmkOW6K",
    "twyaWPtcOW",
    "WOJdVCoCW5S",
    "WP/dSSoVBW",
    "fmkqnW",
    "WO8oACkr",
    "WPtdQmohySoZW5GdW5C",
    "WRbvkt5RWOJdPgBdMW",
    "WPD2WPi",
    "bGO1Cmk/ie7dUq",
    "WRqsyq",
    "W6ONCG8loq",
    "emoUoCkw",
    "umkTjSkMqgRcOLTY",
    "W7hdRLRdQh12smkDzW",
    "WP/dJCo/lbbcW6lcOHa",
    "z3yhW53cN09Lmq3dL8omW7/cJCkm",
    "oXBdVG",
    "tNy4WPK",
    "hXyd",
    "oMycW50",
    "fNtcKG",
    "W67cH28OW5e6W44qA8k8mmoCWRhcVq",
    "W6CNu0i",
    "obxdP8oZW7m",
    "WRBdMSkmBcPT",
    "cIlcRaqX",
    "W5ZcSLvkmZy",
    "cN7cJc3dRCo/",
    "WPJcTmkjnW",
    "WOZdL8oInW",
    "gCkFW4Sg",
    "hchcSW",
    "WR3cMSk2",
    "C2ysW5W",
    "WQLteZG",
    "WQKuFW",
    "eH/dMCoV",
    "eaaw",
    "WQLjea",
    "WO3dRSoYyW",
    "tMW7",
    "WQRdISkryW",
    "WPHvda",
    "dZvr",
    "csfK",
    "C8oqW7hdTq",
    "WPJcRSkk",
    "WP14EmkL",
    "W6tdVmo+pa",
    "WPXAlq",
    "WPHpdWe",
    "WR/cTCkZ",
    "W6tdJtmE",
    "csfJ",
    "WR3cGmk1Fa",
    "W7yTBa",
    "WPDSWPhdJG",
    "ymk3EG",
    "WOZdJCoH",
    "WR/cR8kWqa",
    "W6ldRKq",
    "eGxdMG",
    "W7y3BWa",
    "WO3dTmoX",
    "qd8k",
    "oWZdVCo4",
    "WPjVFW",
    "C3Wr",
    "W6ldTeFdSW",
    "Bmorna",
    "W7BcIwW",
    "C8okW7i",
    "oNWb",
    "WRFcPCkk",
    "gCkfW4G",
    "fSo6omkn",
    "W6tdPSo9",
    "gw1RWPm",
    "WPRcOSk2",
    "W5D8WQ0",
    "WOVcVCk2bwO",
    "yMmrW5JcIa",
    "CmoBkMBdOae",
    "WOSoACkuoGZcQ8kfy8oGCSko",
    "cGVdMCovCCopW5/dRLK",
    "gI/cRX4M",
    "WO5teGHTFmkwWPBdICo6W4zf",
    "WO94WPhdTmkLuG7dOCou",
    "w8kJo8khuuJcTLTV",
    "fG4kW57cPW",
    "W7JdNs4rW6ZcQG",
    "d3f2WPRcVK/cKmoKW6ddSLhdRG",
    "W7ZdQmo+fI/dRbLg",
    "pXJdVmo3W7pcHa",
    "hYD6ASoXFMNdSN4HWRZcQa",
    "eZ9pvWui",
    "W6aRCGKtpupcHSk2tmoRnq",
    "WOvSEmkoW79CEYZcJvyj",
    "WPn4WPddGCkLuG",
    "DSkXzbpcO8oZW690CmoVxmoa",
    "Bmoln2K",
    "WQ8AFtO",
    "fsT6BmoPEG",
    "WQ1bA8oUlCoTCCkVtYpdSCkY",
    "fSoQjCkbWRyyBgVcRSkVWQtdPSoDesCz",
    "W5OoWRxcHKVdKmogp1qGpwycWOeInW",
    "WOugDmkNmXtcP8k+yW",
    "WPTSz8k4W7u",
    "bXGas8k0pu/dRLK",
    "WOVdUSoTFSo4",
    "W7ZdMtm0W6RcP8kRWPu",
    "WQnjDSonm8oKACkn",
    "W7iJBG8Ajq",
    "WOlcRmk1kNWhW5b8W5PSWQe",
    "WObBdYPUFSkBWRBdICoRW4y",
    "WONdUSoZBmo4W4u",
    "hdVcSam",
    "W57cVeS",
    "WOlcVCkfW54",
    "W5OeWQS",
    "W5DMWQ4p",
    "fM7cKsi",
    "WRHveZL4WOm",
    "q8kToa",
    "WPj1FmoZ",
    "WObqm8kNWOFdMW",
    "ymkQzqBcOmoRW69nEW",
    "hdZcRb8SWQCXsCk6",
    "p3OErCo/mN5XWRZdP8kIWQRdP8ok",
    "WQVcR8kuW7ZcK8oh",
    "W7yWCXWqjupcV8k9",
    "hWSCBCk+pupdRfi",
    "WQ9ny8oMl8oKwmkutJFdSCk4Dvm",
    "WO5LyCo8eSob",
    "b2VcKIBdOa",
    "WQDnA8oOnCoP",
    "oM8iqmoO",
    "WQNcKmkGFqniWQSlsCkwW5W/FSoH",
    "qZuoFdfeze3dOHlcQvpcVmom",
    "eb0jW5/cRCohqCknkG",
    "W6CGt14YWQRcSCoMtG",
    "W5KoWQ/cSLddKCovfvG6khm5WO4",
    "WPr3iCkRmSo0Emkdu2pcSmkvxG",
    "cSkPWRddSSoBW5iUi1NdMt8gWR4D",
    "ax7cLHRdQ8o4w0RdNCoOW75rW6vu",
    "WPRdVSo1rmoQW58NW4aSW5RcP8o/WQxcOt/cUmoggePJW6NdICo1W6K",
    "a8kAmW",
    "wwy/",
    "dbGFDq",
    "gYD6BW",
    "W6tdLZa",
    "WQdcR8koW4VcLCoaW5HFWQ7dOIaKDYC",
    "gZ9hwr8fAMJcV8oCF8oQpmof",
    "WRFcUmkvW6/cImoBW5vaWR8",
    "xduusZDd",
    "WR0EAsaQW4eMWO/dVCocW7ucWRpcIq",
    "WPddH8o/obb8",
    "W4RcTL1hmJ5/DaVcOcqWo8od",
    "B3ypW5pcHui",
    "WR7dMSkeyJbGDe/cPrGrW4/cObK",
    "WQRdKmks",
    "W7BdPfldSMDfECkDE8oxyIBdSu8",
    "WPNdVSoNySoZW5qNW4aSW5RcP8o/WQxcOq",
    "WPHieX1UzmkwWQ/dGG",
    "wMyTWPJcTmo9W5a1zK/dHZnGxq",
    "WOlcP8kg",
    "WPJcS8kvk0zoWPC1yW",
    "WOzLACoYcmomltNcT8oAvG0EW5u",
    "W6iNEGerngRcVCk3wmoRp8kTjG",
    "WP1IEW",
    "hIPrxaG",
    "WO9umCkS",
    "WOfHy8o3",
    "WOecACksiGG",
    "W7hdOfJdTW",
    "vduCrs1oqfddUrVcVetcH8ot",
    "fSoGoW",
    "aqxdHmo0ymojW5/dV0m",
    "ebOvW4m",
    "fILGqGmbqW",
    "WQKjyd0RW5apWO3dTW",
    "k2Olra",
    "CCkOEH7cTG",
    "WRFcV8kjW7m",
    "WRThDq",
    "WOZdRmovW6uAdCoF",
    "gX0jt8kWo0K",
    "W6ldMtif",
    "W7aJBHS",
    "WP1SECkOW75g",
    "WPRcUmk1aq",
    "W7dcH24u",
    "WPhcP8kyW4xdSmokWQqnWQq",
    "ymokW6ZdRHpdOGNdOmoz",
    "eN/cMbZdUmoLxa",
    "WRpcRSkaW43cHSoDW58",
    "WRVcVSk5FSo7W6JdIW",
    "W5JcSKLD",
    "BmoFnMtdUH0",
    "W6ddNdOGW7NcSmk5",
    "W7iMzJ4Ei0K",
    "WR1jD8o8",
    "WQKAFsWQW5a",
    "oNidW5ddLxi",
    "WOBcRmkmW6ddPCoUWRy",
    "WONdV8o7xCo8W4me",
    "y8kOzHVcUW",
    "WR9mF8ozimoZEW",
    "WQ9heIm",
    "WOJdP8oF",
    "faVdMmo0",
    "C8k3zahcU8ojW7DpBq",
    "WOfVyCoOeSo/hdNcQW",
    "WOr2WOZdLCk0CbRdOCoj",
    "yhWpW4FcHxXumre",
    "WONcOSkOgMC/W4vNW4C",
    "fNRcKc/dT8oJ",
    "WPZcPCkacuHiWP0",
    "l3ScESoWjv0",
    "WQ0FDr8LW5yf",
    "ehRcKdK",
    "kxWFW4BdJ1ddQcddIa",
    "gIf6EmoPrhhdIwm",
    "W6uTCHSlb1VcVCkR",
    "W6BdPu7dJwHswG",
    "WPrPWO7dJ8k0",
    "W54pWQhcTepdJmos",
    "dsPUxCo8ygm",
    "WPSgDCkg",
    "dSkJWQRdKCoDW6S7pL4",
    "W4KeWRxcKvBdQmoacf8",
    "WO5IzCk+W6rKBJFcKa",
    "W5RcT0f4psLC",
    "fCoJiSkgWRO",
    "WQ7cLmkQEa",
    "W6uJCaqAna",
    "DSk3Ea",
    "k3ai",
    "WOLLDSoDcCoB",
    "aXWDFSkLiq",
    "WOr5BSk/W7fgydC",
    "W7BcK28p",
    "W7FdQmoHoa",
    "WOL8WPRdKG",
    "z8okW6ZdUa",
    "gxDO",
    "W4ikWQJcRvxdKmoXcemZpwqcWPe",
    "W7JdRmoJmYNdOq",
    "WPf0BSo4dCo6fdhcVq",
    "oh4mt8o5hKbNWRBdRW",
    "WPVdQCoBW5atnSocW4feWPm",
    "WOr4WPBdHCkOBXxdT8oFfq",
    "WQNcS8kTsCo2W7BdGCkRkmo4EXG",
    "WRZdLSkmAJjPxxtcPaWrW4u",
    "hXWDFCk4j13dMu9Veevzo8kLeW",
    "WQ5gyCogl8oLBCkE",
    "WOBcPmkckW",
    "W7m9tK8",
    "W6ldMsWdW70",
    "WQhcV8k7xa",
    "WQVcTCkTtq",
    "WRhcQ8kwW67cGG",
    "WO/dVSoYzmoXW4Cs",
    "W6eZtf84",
    "WQpcKmk+ya",
    "l3Ckq8oM",
    "ehRcJJ/dVa",
    "WRVcSSkXr8oT",
  ];
  b = () => gH;
  return b();
}

function U(Z, O) {
  Z = Z - 0x0;
  const c = b();
  let g = c[Z];
  if (U["GdGIHB"] === undefined) {
    var D = (H) => {
      const w =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=";
      let z = "",
        K = "";
      for (
        let E = 0x0, P, p, o = 0x0;
        (p = H["charAt"](o++));
        ~p && ((P = E % 0x4 ? P * 0x40 + p : p), E++ % 0x4)
          ? (z += String["fromCharCode"](0xff & (P >> ((-0x2 * E) & 0x6))))
          : 0x0
      ) {
        p = w["indexOf"](p);
      }
      for (let N = 0x0, A = z["length"]; N < A; N++) {
        K += "%" + ("00" + z["charCodeAt"](N)["toString"](0x10))["slice"](-0x2);
      }
      return decodeURIComponent(K);
    };
    const X = (H, w) => {
      let z = [],
        K = 0x0,
        E,
        P = "";
      H = D(H);
      let p;
      for (p = 0x0; p < 0x100; p++) {
        z[p] = p;
      }
      for (p = 0x0; p < 0x100; p++) {
        ((K = (K + z[p] + w["charCodeAt"](p % w["length"])) % 0x100),
          (E = z[p]),
          (z[p] = z[K]),
          (z[K] = E));
      }
      ((p = 0x0), (K = 0x0));
      for (let o = 0x0; o < H["length"]; o++) {
        ((p = (p + 0x1) % 0x100),
          (K = (K + z[p]) % 0x100),
          (E = z[p]),
          (z[p] = z[K]),
          (z[K] = E),
          (P += String["fromCharCode"](
            H["charCodeAt"](o) ^ z[(z[p] + z[K]) % 0x100],
          )));
      }
      return P;
    };
    ((U["BemOAL"] = X), (U["kdIFLS"] = {}), (U["GdGIHB"] = !![]));
  }
  const R = c[0x0],
    t = Z + R,
    e = U["kdIFLS"][t];
  return (
    !e
      ? (U["QJsFjo"] === undefined && (U["QJsFjo"] = !![]),
        (g = U["BemOAL"](g, O)),
        (U["kdIFLS"][t] = g))
      : (g = e),
    g
  );
}

console[U("0x1b0", "waD0")](o(0xa, 0x14));
```

在做任何其它事之前，这个智能体做了一件人类会做的事 —— 读文件。读了四遍，分段啃完那段 VM 运行时。然后把混淆文件原样跑了一次，只是为了确认基线：`o(10, 20)` 返回 `170`。这是反混淆之后需要落回的那个数。

![Claude Code 会话：探查 VM 混淆器文件（10 次工具调用，56.2k tokens，26 秒），把混淆后的源码读了四遍，运行 node obfuscated.js 确认基线输出为 170，然后宣布要开始动手写反混淆脚本。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/exploration.png)

## 它写出的方案

Claude 在动手之前先返回了一份六步计划。它一遍就把 bundle 的结构看穿了 —— 顶部一个打乱字符串数组的 IIFE，中间约 1,500 行的 VM 解释器，底部一段 [base64](https://en.wikipedia.org/wiki/Base64)+[RC4](https://en.wikipedia.org/wiki/RC4) 加密的字节码 blob，再加一个调用 VM 的小入口点。

![Claude 的六步反混淆计划：拆解混淆代码的结构（字符串数组+轮转、RC4 字符串解密、VM 运行时、加密字节码、入口点），以及三步反混淆动作（解密字符串、清理 VM 运行时、提取并解码字节码）。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/02-plan.png)

**Claude 写出的完整 6 步计划**

```
The obfuscated file is ~1,587 lines but the actual program is tiny —
it's encoded as bytecode executed by a custom stack-based VM
interpreter.

Structure of the obfuscated code:
  1. String array + rotation (lines 1-11): classic javascript-obfuscator
     string-array shuffling
  2. String decryption U() (lines 1549-1585): RC4-based string
     decryption
  3. VM runtime p (lines 14-1534): ~1,500 lines of custom bytecode
     interpreter
  4. Bytecode storage (N[0]): base64+RC4 encrypted bytecode blob
  5. Entry point (lines 1535-1587): function o(N,A) { return
     p.call(this, 0x0, Array.from(arguments), undefined, o); }
     then console.log(o(10, 20))

Deobfuscation approach:
  Step 1 — Decrypt all strings: evaluate b() and U(), replace every
           U(hex, 'key') call with its decrypted value
  Step 2 — Clean up the VM runtime: replace obfuscated property
           accesses with readable names; map VM internals to
           meaningful names (stack, IP, constants, locals…)
  Step 3 — Extract and decode bytecode: base64 → RC4 → deserialize.
           The RC4 key comes from h() — environment fingerprinting
  Step 4 — Disassemble bytecode to readable opcodes: map the b3
           shuffle table to logical operations; walk the instruction
           stream
  Step 5 — Reconstruct original JavaScript from the disassembly
  Step 6 — Document the techniques used

Verification: run both files in Node.js, both should produce the
same output for o(10, 20).
```

## 第一次尝试是一个万能大文件

Claude 写了一个 883 行的 `deobfuscate.js`，想一次性搞定整件事 —— 求值字符串数组解密器、解密每一处 `U(idx, key)` 调用、跑环境指纹 `h()`、拿结果当 RC4 密钥解密字节码 blob、重新实现那个自定义二进制反序列化器（这是 javascript-obfuscator 之外没人见过的部分）、反汇编、产出等价的 JavaScript。

前半部分跑通了。字符串解密：搞定 —— 一次运行解密了 500 个唯一的 `U()` 调用。`h()` 算出了预期的 `0xa19722e9`。字节码解密：干净的字节缓冲区出来了。

后半部分跑不通。反序列化器用的是一种自定义二进制格式 —— [zigzag 编码 varint](https://protobuf.dev/programming-guides/encoding/)、由标志位掩码控制的条件字段、起了别名的属性名。靠读混淆源码重新实现它，产出的是垃圾：版本字节错的、参数数量是负的、指令数为零。换作五年前，文章到这里就该结束了。Claude 耸耸肩，写了一个 286 行的 `instrument.js` 改去打补丁直接 patch 运行中的 VM，第一次尝试撞上沙箱限制，立刻又换策略 —— *「沙箱限制太严，让我换个更简单的方法：复制一份改过的文件，从里面打日志。」*

![Claude Code 会话：写出 883 行的 deobfuscate.js，运行后（解密了 500 个 U() 调用，但字节码反序列化失败）、写出一个 286 行的 instrument.js（被沙箱限制报错）、再写一个更小的 48 行 instrument2.js（复制一份改过的混淆文件运行）—— 最终拿到环境指纹 __H__:a19722e9 并捕获了字节码。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/failure-and-pivot.png)

**万能大文件 deobfuscate.js —— 失败那一轮的步骤 1-3 结构**

```js
#!/usr/bin/env node
/**
 * Deobfuscator for javascript-obfuscator VM-obfuscated JavaScript.
 *
 * Strategy:
 *   1. Evaluate the string-array + RC4 decryptor from the obfuscated file
 *   2. Use it to decrypt every U(idx, key) call
 *   3. Evaluate h() to get the environment fingerprint
 *   4. Decode N[0] bytecode blob: base64 → RC4 → B() deserialize
 *   5. Disassemble the bytecode instruction stream
 *   6. Reconstruct the original JavaScript
 */

const fs = require("fs");
const path = require("path");
const vm = require("vm");

const src = fs.readFileSync(path.join(__dirname, "obfuscated.js"), "utf8");

// ── Step 1: Bootstrap the string decryption ───────────────────────────────
// Extract b() (string array), U() (RC4 decryptor), and the rotation IIFE
// from the source, then evaluate them in an isolated VM context.

const bFuncMatch = src.match(/function b\(\)\s*\{[\s\S]*?return b\(\);\s*\}/);
const uFuncMatch = src.match(/function U\(Z, O\)\s*\{[\s\S]*?return.*?g;\s*\}/);
const rotationMatch = src.match(
  /^\(function \(N, A\)\s*\{[\s\S]*?\(b, 0x[a-f0-9]+\)\);/m,
);

const sandbox = { U: null, b: null, parseInt, String, decodeURIComponent };
vm.createContext(sandbox);
vm.runInContext(
  `${bFuncMatch[0]}\n${uFuncMatch[0]}\n${rotationMatch[0]}`,
  sandbox,
);
const U = sandbox.U;

// ── Step 2: Decrypt every U() call site ───────────────────────────────────
const uCallPattern = /U\((?:'(0x[a-f0-9]+)'|(0x[a-f0-9]+)),\s*'([^']+)'\)/g;
const decryptedStrings = new Map();
let match;
while ((match = uCallPattern.exec(src)) !== null) {
  const idx = match[1] || match[2];
  const key = match[3];
  try {
    decryptedStrings.set(match[0], U(idx, key));
  } catch (e) {}
}

// ── Step 3: Compute the environment fingerprint h() ───────────────────────
// h() XORs 0x5f3759df with built-in .length values from Array.prototype.push,
// String.prototype.padStart, Math.imul, Object.keys, Array.prototype.indexOf,
// String.prototype.includes — values that are identical across every JS engine.
function h() {
  let bk = 0x5f3759df;
  bk ^= Array.prototype.push.length << 0x18; // 1
  bk ^= String.prototype.padStart.length << 0x14; // 1
  bk ^= Math.imul.length << 0x10; // 2
  bk ^= Object.keys.length << 0xc; // 1
  bk ^= Array.prototype.indexOf.length << 0x8; // 1
  bk ^= String.prototype.includes.length; // 1
  return bk >>> 0; // → 0xa19722e9
}

const envKey = h();
console.log(`h() = 0x${envKey.toString(16)}`); // 0xa19722e9 ✓

// ── Steps 4-6: bytecode decrypt → custom binary deserialize → disassemble.
// This is where it fell over. The B() deserializer uses zigzag varints,
// flag-gated conditional fields, and aliased property names. Reimplementing
// it from the obfuscated source produced: version byte = 0xff (expected 1),
// paramCount = -3, instruction count = 0. Garbage.
```

## 它停止重新实现，开始进行插桩

然后策略变了。Claude 不再硬刚反序列化器，而是给运行中的混淆文件打补丁。它把混淆器自己的 `B()` 反序列化器包了一层，让它 `JSON.stringify` 输出后再打日志；把调度循环也包了一层，记录每条 opcode、每个操作数、每一次栈变化；然后把打了补丁的文件跑一遍，所有信息都从 stdout 抓了下来。

一次运行就拿到完整画面：参数数 `2`、局部变量数 `3`、常量 `[0.15, 100, 1, "calculatePrice"]`、block key `54`、jump key `9643`、栈加密 key `4168320119`，以及那 22 条指令的字节码流 —— 加上每一次栈变化的逐步执行轨迹。

看着这一幕，我反复想到的一点是：插桩本应是一个合格逆向工程师**最先**会试的招，而不是最后才想起。智能体从一个非显然的起点，一次转向，零提示，就推理到了那个显然的动作。

> *能插桩就别重新实现。程序自己已经知道怎么跑了。*

![Claude Code 会话：写出 48 行的 instrument2.js，给混淆后的 VM 打补丁记录解码后的字节码和调度轨迹，用 node instrument2.js && node _patched.js 跑起来，直接从运行中的程序里恢复出函数名、参数、局部变量、常量、blockKey、jumpKey 和 seKey。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/05-pivot.png)

## 它反汇编了这个 VM，给每条 opcode 起了名字，并产出了源码

拿到字节码以后，Claude 开始逐条走。它把每条 opcode 与 `blockKey=54` 做 XOR 恢复其逻辑索引，再去 `b3` 打乱表里查到对应操作，然后把 opcode 翻译成人类能读的名字 —— `PUSH_CONST`、`STORE_LOCAL`、`LOAD_ARG`、`MUL`、`SUB`、`LOAD_LOCAL`、`GT`、`JMP_FALSE`、`DUP`、`POP`、`RETURN`。它通过 `jumpKey=9643` 解出跳转目标，从头到尾走完 22 条指令流，一边走一边产出等价的 JavaScript。

顺便说一句：我写 JavaScript 大概 15 年了，调试器用得很熟，而这正是那种我会花掉一周里大部分时间的工作。读 1,500 行的 dispatch 代码、跟踪哪个操作数跟哪个 key 做 XOR、给基于栈的 VM 在脑子里建模、用行为追踪推断每条 opcode 对应什么操作 —— 这是一场细致、易错、要几天才磨得出结果的活。Claude 用我冲一杯咖啡的时间就做完了，靠一段提示词，没有工具加持，也没有针对这个混淆器的先验。**刚刚发生的事值得说清楚：智能体不是建议了一种反混淆思路让我去尝试，它产出了成品 —— 文件进去，源码出来，失败的尝试和能跑的版本就并排躺在同一个目录里。**

**disassemble.js —— Claude 把字节码变回源码的脚本（完整文件）**

```js
#!/usr/bin/env node
/**
 * Final disassembly of the extracted bytecode.
 * Uses the raw bytecode data captured from the instrumented run.
 */

// ── Bytecode metadata (captured from the instrumented obfuscator) ──
const bc = {
  paramCount: 2,
  localCount: 3,
  nameIndex: 3, // constants[3] = "calculatePrice"
  blockKey: 54,
  jumpKey: 9643,
  seKey: 4168320119,
  constants: [0.15, 100, 1, "calculatePrice"],
  instructions: [
    357,
    54,
    384,
    52,
    149,
    55,
    384,
    53,
    220,
    54,
    108,
    55,
    38,
    null,
    369,
    50,
    158,
    50,
    59,
    53,
    32,
    null,
    333,
    null,
    451,
    50,
    347,
    52,
    270,
    52,
    438,
    null,
    126,
    null,
    365,
    null,
    217,
    50,
    245,
    null,
    158,
    50,
    289,
    null,
  ],
  tryCatch: { 11: 9663 },
};

// ── Opcode mapping (recovered from the dispatch trace) ──
const OPCODE_NAMES = {
  0x0: "PUSH_CONST",
  0x3: "POP",
  0x4: "DUP",
  0x6: "LOAD_LOCAL",
  0x7: "STORE_LOCAL",
  0x8: "LOAD_ARG",
  0xb: "SUB",
  0xc: "MUL",
  0x2e: "GT",
  0x34: "JMP_FALSE",
  0x38: "RETURN",
};

// ── The decoded instruction stream ──
// VM applies: Up = raw_opcode XOR blockKey, then SM shuffle → Uo
const traced = [
  {
    pc: 0,
    op: 0x00,
    arg: 0,
    name: "PUSH_CONST",
    desc: "push constants[0] = 0.15",
  },
  {
    pc: 1,
    op: 0x07,
    arg: 2,
    name: "STORE_LOCAL",
    desc: "local[2] = pop() → taxRate = 0.15",
  },
  {
    pc: 2,
    op: 0x00,
    arg: 1,
    name: "PUSH_CONST",
    desc: "push constants[1] = 100",
  },
  {
    pc: 3,
    op: 0x07,
    arg: 3,
    name: "STORE_LOCAL",
    desc: "local[3] = pop() → threshold = 100",
  },
  { pc: 4, op: 0x08, arg: 0, name: "LOAD_ARG", desc: "push args[0] → price" },
  {
    pc: 5,
    op: 0x08,
    arg: 1,
    name: "LOAD_ARG",
    desc: "push args[1] → quantity",
  },
  {
    pc: 6,
    op: 0x0c,
    arg: null,
    name: "MUL",
    desc: "pop 2, push product → price * quantity",
  },
  {
    pc: 7,
    op: 0x07,
    arg: 4,
    name: "STORE_LOCAL",
    desc: "local[4] = pop() → total",
  },
  {
    pc: 8,
    op: 0x06,
    arg: 4,
    name: "LOAD_LOCAL",
    desc: "push local[4] → total",
  },
  {
    pc: 9,
    op: 0x06,
    arg: 3,
    name: "LOAD_LOCAL",
    desc: "push local[3] → threshold",
  },
  {
    pc: 10,
    op: 0x2e,
    arg: null,
    name: "GT",
    desc: "pop 2, push (total > threshold)",
  },
  {
    pc: 11,
    op: 0x34,
    arg: null,
    name: "JMP_FALSE",
    desc: "if false, jump to pc=20 (9663 ^ 9643 = 20)",
  },
  {
    pc: 12,
    op: 0x06,
    arg: 4,
    name: "LOAD_LOCAL",
    desc: "push local[4] → total",
  },
  {
    pc: 13,
    op: 0x00,
    arg: 2,
    name: "PUSH_CONST",
    desc: "push constants[2] = 1",
  },
  {
    pc: 14,
    op: 0x06,
    arg: 2,
    name: "LOAD_LOCAL",
    desc: "push local[2] → taxRate (0.15)",
  },
  {
    pc: 15,
    op: 0x0b,
    arg: null,
    name: "SUB",
    desc: "pop 2, push (1 - 0.15) = 0.85",
  },
  {
    pc: 16,
    op: 0x0c,
    arg: null,
    name: "MUL",
    desc: "pop 2, push (total * 0.85)",
  },
  { pc: 17, op: 0x04, arg: null, name: "DUP", desc: "duplicate TOS" },
  {
    pc: 18,
    op: 0x07,
    arg: 4,
    name: "STORE_LOCAL",
    desc: "local[4] = pop() → total = discounted",
  },
  { pc: 19, op: 0x03, arg: null, name: "POP", desc: "discard extra copy" },
  {
    pc: 20,
    op: 0x06,
    arg: 4,
    name: "LOAD_LOCAL",
    desc: "push local[4] → total",
  },
  { pc: 21, op: 0x38, arg: null, name: "RETURN", desc: "return TOS" },
];

// ── Reconstruct ──
const source = `function calculatePrice(price, quantity) {
  const taxRate = 0.15;
  const threshold = 100;
  let total = price * quantity;
  if (total > threshold) {
    total = total * (1 - taxRate);
  }
  return total;
}

console.log(calculatePrice(10, 20));`;

console.log(source);

// ── Verify behavioral equivalence ──
const calculatePrice = new Function(
  "price",
  "quantity",
  `
  const taxRate = 0.15;
  const threshold = 100;
  let total = price * quantity;
  if (total > threshold) {
    total = total * (1 - taxRate);
  }
  return total;
`,
);

const tests = [
  [10, 20, 170], // 200 > 100  → 200 * 0.85 = 170
  [5, 10, 50], // 50 ≤ 100   → 50
  [50, 3, 127.5], // 150 > 100  → 150 * 0.85 = 127.5
  [100, 1, 100], // 100 ≤ 100  → 100  (boundary)
  [101, 1, 85.85], // 101 > 100  → 101 * 0.85 = 85.85
];

for (const [a, b, expected] of tests) {
  const actual = calculatePrice(a, b);
  console.log(
    `calculatePrice(${a}, ${b}) = ${actual} ${
      Math.abs(actual - expected) < 0.0001 ? "✓" : `✗ (expected ${expected})`
    }`,
  );
}
```

## Claude 实际产出了什么

等它停下来的时候，Claude 已经搭起了一整个工作目录：原始混淆文件、还原后的源码、用过的全部技术写成的说明、失败的万能大文件、被放弃的第一次插桩、成功的第二次插桩、它生成的那份打了补丁的混淆文件，以及最终的反汇编脚本。整个文件树是它自己搭出来的。

![Claude 在工作目录里搭出的文件树：_patched.js、deobfuscate.js、disassemble.js、instrument.js、instrument2.js、obfuscated.js、source.js。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/file-tree.png)

事后我问它哪些文件真正起了作用，它不用提示就给出了一份精确的复盘。

![Claude 自己复盘整条流水线：deobfuscate.js 部分成功（解密了字符串和 h() 指纹，在字节码反序列化处失败），instrument2.js 是关键突破（给混淆代码打补丁让它记录自身内部，生成了带解码字节码和执行轨迹的 _patched.js），disassemble.js 拿到这些捕获数据后做出了最终还原并附带验证。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/pipeline-recap.png)

**还原出的源码 —— Claude 重建的版本**

```js
// Recovered from 1,587 lines of VM-obfuscated code.
//
// Obfuscation layers reversed:
//   1. String array rotation + RC4 decryption (U() with b() array)
//   2. Environment fingerprinting (h() — hashes built-in .length values)
//   3. Bytecode encryption (base64 → RC4 with fingerprint key)
//   4. Bytecode serialization (custom binary format with zigzag varints)
//   5. Opcode shuffling (b3 table + per-function seed permutation)
//   6. Operand encryption (XOR with blockKey=54, jumpKey=9643)
//   7. Stack-value encryption (XOR with seKey=4168320119 for integers)
//   8. Anti-debug timing checks (corrupt opcode table on slow-step)
//   9. Custom stack-based VM interpreter (~1,500 lines, ~100 opcodes)

function calculatePrice(price, quantity) {
  const taxRate = 0.15;
  const threshold = 100;
  let total = price * quantity;
  if (total > threshold) {
    total = total * (1 - taxRate);
  }
  return total;
}

console.log(calculatePrice(10, 20)); // → 170
```

**真实的原始源码 —— 当初喂进 javascript-obfuscator 的东西**

```js
// Simple calculator with secret discount logic
function calculatePrice(quantity, unitPrice) {
  const SECRET_DISCOUNT = 0.15;
  const SECRET_THRESHOLD = 100;

  let total = quantity * unitPrice;

  if (total > SECRET_THRESHOLD) {
    total = total * (1 - SECRET_DISCOUNT);
  }

  return total;
}

// Try it: calculatePrice(10, 20) => 170
console.log(calculatePrice(10, 20));
```

还原出的代码在我试过的所有输入上、包括边界情形，跑出来都和原版完全一致。它没能恢复的是那些*名字* —— `quantity, unitPrice` 变成了 `price, quantity`，两个 `SECRET_*` 常量变成了 `taxRate` 和 `threshold`（数值 `0.15` 和 `100` 原样保留，因为 VM 要跑就必须把它们留在字节码里）。参数顺序和标识符名是从行为推断的，不是恢复的。混淆器藏掉了它**能**藏的东西，保留了 VM 在运行时**必须**要的东西 —— 而事实证明，VM 运行时必须要的那部分，已经足够 LLM 把整个程序看懂了。

## 然后我拿 JScrambler 试了一遍 —— 一款付费产品

同样的实验，换个厂商。我抓了 JScrambler 公开的「Javascript Racer」演示 —— 一段他们用来推广默认保护方案的背景 sprite-atlas 模块 —— 给 Claude Code 配了同样形态的提示词。换了混淆器，换了技术，是付费产品。

Claude 把文件读了一遍，结构当场就摊开了：

- 一个叫 `a20f7` 的命名空间登记表。
- 一段 URL 编码、用 XOR 加密的字符串 blob。
- 一张被当成不透明整数 tag 用的三维索引表。
- 一个「自替换的解码器」—— 它正好为 8 次调用做预热，之后退化为直接查表。
- 真正的载荷藏在下面，构建一个叫 `BACKGROUND` 的对象。

这些东西没一个出现在提示词里。它就这么从文件里读出来了。

![Claude 第一次读 JScrambler 混淆文件后的诊断清单：命名空间登记表、URL 编码的 XOR 字符串 blob、当成不透明整数 tag 用的三维索引表、自替换的字符串解码器，以及组装 BACKGROUND 对象的载荷状态机 —— 都是一遍读下来发现的。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/jscrambler-triage.png)

有意思的是 JScrambler 选了不一样的做法。这里没有字节码 VM —— 他们用的是 switch 状态机式的[控制流扁平化](<https://en.wikipedia.org/wiki/Obfuscation_(software)>)，那种教科书式的 `while (state !== END) { switch (state) { … } }` 结构，按原始表达式树的深度层层嵌套。没有 RC4 —— 字符串来自一个 URL 编码 blob，用循环 XOR key 解码后按分隔符切开。没有反调试计时检查 —— 取而代之的是一段「伪装成校验的预热序列」，看上去在验证字符串内容，实际上只是按精确顺序调用查表函数推进一个内部计数器。完全不同的基础构件，完全相同的*结构形态*。从 javascript-obfuscator 那一轮带来的六步弧线 —— 解密字符串、清理运行时、提取状态、走控制流、还原源码、文档化 —— 几乎可以一比一搬过来。第一轮依赖的那次插桩转向这回根本没用上：静态分析没运行过被混淆代码就把输入变回了明文。

JScrambler 的输出 24,620 字节。源码五行。耗时约 20 分钟，Opus 4.7 把 thinking 拉满。比 javascript-obfuscator 那轮长一些，仍然稳稳处于「一次 API 调用的分钟级」区间，离「专家干上几天」差着一个量级。

![Claude 写出还原后的 source.js：5 行内容，var BACKGROUND = { HILLS, SKY, TREES } 的 sprite-atlas 几何，确认过静态分析和打补丁的动态运行产出一致后写下。](https://www.afterpack.dev/blog/ai-deobfuscates-javascript/jscrambler-result.png)

**还原出的源码 —— JScrambler 的 24 KB 收缩成 5 行**

```js
var BACKGROUND = {
  HILLS: { x: 5, y: 5, w: 1280, h: 480 },
  SKY: { x: 5, y: 495, w: 1280, h: 480 },
  TREES: { x: 5, y: 985, w: 1280, h: 480 },
};
```

## 为什么这层防线没扛住

在两轮实验上都成立的四个结构性原因 —— 它们也预测了下一步哪些招还管用、哪些不管用。

**1. 逆操作必须留在 bundle 里。**这一族的每一种防御都自带还原 —— 加密字符串的解码器、opcode 表的打乱密钥、环境指纹的源值 —— 因为如果逆操作不在 bundle 里，程序根本跑不起来。这就意味着整个家族原则上都是可还原的。剩下的真问题只是成本。

**2. 串行变换是逐层拆开的。**当多层组合成 `t₁ ∘ t₂ ∘ … ∘ tₙ` 时，逆操作就是反着叠回去。LLM 对识别和反演单个变换族非常熟练 —— 字符串数组轮转、RC4、base64、[XOR-with-constant](https://en.wikipedia.org/wiki/XOR_cipher)、带种子的 [Fisher-Yates](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle)（javascript-obfuscator 用的是这些的某种组合）—— 因为它们在训练里见过成千上万。打掉 `n` 层大约要 `n` 个单位的工作量，而不是真正交织变换才会有的 `2ⁿ`。九层防御变成九次模型轮次，而混淆器原本可能指望它能撑九个工程师日。

**3. VM 是单点故障。**VM 看起来像是升了一档防御，因为逻辑程序此刻变成了自定义字节码，不再是 JavaScript。可问题在于：把字节码翻成行为的那个东西 —— 解释器 —— 就在 bundle 里坐着。把它的 dispatch 循环插桩一次，就把这个程序将要跑的每个函数都解码了。反调试计时检查只有在人类用断点慢慢单步时才会触发；自动化插桩满速跑，永远不会踩中。基于标准内置 `.length` 值的环境指纹在任何 JavaScript 引擎里都是同一个数，所以那个所谓的运行时绑定纯属装饰。

**4. LLM 把技能门槛拍到了地板上。**这一切在 LLM 之前也不是不可破 —— 手工反演控制流扁平化的论文都已经有十多年了。变了的是谁能做、用多久做。技能门槛从「带工具的资深逆向工程师」掉到「任何有 AI 账号的工程师」，时钟从天降到分钟，而那些名字 —— 一直是逆向工程师必须从零拼凑的唯一东西 —— 现在从语义上下文里白送回来。

**九层防御，以及它们各自如何被拆掉**

| 防御层                                                | 做了什么                                                                                           | 为什么没扛住                                                                                      |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------- |
| 1. 字符串数组 + RC4 加密                     | 全部约 500 个字符串字面量加密，运行时通过 `U(idx, key)` 解码                               | 自包含。把 `U()` 求值一次，就能静态解密每一处调用。                                     |
| 2. 字符串数组轮转                             | 数组由一个 IIFE 轮转直到校验和匹配                                               | 轮转在启动时跑完。让它跑完，再读轮转后的数组就行。                                 |
| 3. 环境指纹（`h()`）                | 把 `0x5f3759df` 与内置的 `.length` 值做 XOR                                                       | 这些值在任何标准 JS 引擎上都一样。没有真正的绑定。                              |
| 4. 字节码加密（RC4）                         | 字节码 blob 用一个由 `h()` 派生的 key 加密                                                  | 一旦 `h()` 算出来，解密就只剩一行代码。                                                |
| 5. 二进制序列化（`B()`）                      | 自定义 zigzag-varint 格式，带标志位控制的条件字段                                         | 不要重新实现它。插桩它。让混淆器自己把自己解码完。                                  |
| 6. opcode 打乱（`b3` 表 + 每函数种子） | 把逻辑 opcode 映射到打乱后的索引                                                               | 带种子的 PRNG。拿到种子和算法就能复原。                                      |
| 7. 操作数 XOR（`blockKey`、`jumpKey`）               | 每一条 opcode 和跳转目标都用一个每函数的 key 做 XOR                                             | 简单 XOR。一个已知明文就能恢复出 key。                                                       |
| 8. 栈值加密（`seKey`）                  | 入栈整数值与一个 key 做 XOR                                            | 只作用于整数。浮点、字符串、对象都明文存。                                 |
| 9. 反调试计时 + VM 解释器                | 单步时计时检查会破坏 opcode 表；1,500 行自定义 VM 负责每条 opcode 的 dispatch | 插桩满速运行。VM**自己**就是逆操作 —— 把 dispatch 插桩一次，全都到手。 |

## 真正被波及的是什么

我反复回到的场景，是常量和控制流**本身**就是 IP 的那种 —— license 校验函数、试用/付费版的开关、决定用户能不能解锁功能的 token 校验器。这种场景下的整套防御就是「让它读起来很贵」，而这层防御刚刚松动了。原本需要一位资深逆向工程师加一周的竞争对手，现在只需要一个 API key 加一杯咖啡的时间。交易策略代码、排序逻辑、反欺诈启发式、推荐算法 —— 任何作为**函数**发到浏览器的东西，都坐在同一个等级里。

另一处会被砸结实的，是浏览器游戏和 [DRM](https://en.wikipedia.org/wiki/Digital_rights_management) 里的反作弊与反篡改，那里整套威胁模型假设的就是每一层要花攻击者好几天。作弊开发者和 DRM 破解者现在可以在补丁周期内对新版本迭代，而不是落后几周。这是否会演变成实际中的麻烦，要看攻击者组织得有多严密；我还没看到公开证据显示有 LLM 驱动的作弊开发，但成本梯度已经在朝着防御方不利的方向倾斜。

在这一切底下，是同一个观察：很多购买混淆服务的决策建立在「每一层都得专家干上几天」的成本假设上。原本能买来一年喘息窗口、对抗那种愿意花力气的攻击者的同一套防御，现在面对任何一个有 Claude 账号的工程师，只能买来一个下午。

## 老实说的局限

两款产品，两份演示文件，都是厂商自己挑出来宣传默认配置的。主流 JS 混淆器的默认方案在面对一个有能力的 2026 年 LLM 时，已经没法把反混淆成本抬到足以挡住攻击者的高度 —— 这是结构性的结论，现在已经被两轮分别针对完全不同基础构件的实验背书。我**没有**测的是叠在这些默认方案之上的付费附加模块：JScrambler 的 Code Locks（环境绑定的执行门）、Self-Defending 完整性检查、反调试陷阱、Domain Locks —— 每一项都会带来真正的额外阻力。还有信息破坏型的变换 —— 那种 bundle 里**不**保留逆操作的 —— 是另一个值得单独做的实验。两者都值得后续文章。

## 这件事把我们带到了哪里

有趣的问题不是这种混淆能不能被破 —— 能，一年前也能 —— 而且[压缩后的代码本来就从来没有真正隐藏过](https://www.afterpack.dev/blog/claude-code-source-leak)。问题是：当攻击成本从「专家干上几天」掉到「一次 API 调用的几分钟」时，还有哪些东西能算是可防御的。对这一族技术来说，老实的答案是：没剩多少。

如果你今天还在发混淆后的 JavaScript，这是你在公开之前需要自己跑一遍的实验，先弄清楚自己到底发出去了什么。是的 —— 我在 [AfterPack](https://www.afterpack.dev/) 上正在打造一个现代版本。它现已上线：从[快速入门](https://www.afterpack.dev/docs/quickstart)开始。