Я взяв два JavaScript-обфускатори — популярний open-source (javascript-obfuscator, у його найсильнішому режимі «VM-обфускації») та комерційний enterprise-рівня (JScrambler) — і передав Claude Code флагманські демо кожного вендора з промптом на чотири абзаци.
Десять хвилин на перший, двадцять на другий. Обидва повернулися чистим вихідним кодом! 💣
Це означає, що сьогоднішня JavaScript-обфускація — та, що захищає веб-застосунки від реверс-інжинірингу та копіювальників — добігла кінця? Розберімося.
Обидві мішені — власні демо вендорів — програми на 5-13 рядків, роздуті обфускацією у 150-200× до 24-68 КБ. Це співвідношення, якого ви не отримаєте в реальних кодових базах. І перш ніж залунає заперечення «але продакшен більший»: для Claude продакшен простіший, не складніший. Застосунок на 1 МБ або розмазує ту саму силу обфускації по всьому бандлу (кожна функція не складніша за ці демо), або — частіше — лише критичні функції захищають жорстко, а решта відвантажується читабельною, даючи Claude семантичний контекст про те, що ймовірно робить захищена функція. Іграшка від вендора — найгірший випадок для атакуючого, не легкий.
Налаштування
Вхід — це 13-рядкова функція calculatePrice(quantity, unitPrice), яку javascript-obfuscator публікує на своїй посадковій сторінці як демонстрацію VM-режиму. Їхнє демо, їхня функція, та, яку вони самі обрали показати. Прогони її через їхній інструмент із найсильнішим режимом — і отримаєш назад 1 587 рядків, 68 КБ на диску, ~194× оригінального розміру. Усередині цього виводу: дев'ять компонованих захисних шарів, що обгортають кастомний інтерпретатор стекової VM на ~1 500 рядків (повна розбивка нижче у таблиці).
Я передав обфускований файл Claude Opus 4.6 усередині Claude Code разом із промптом на чотири абзаци. Я не сказав, з якого обфускатора файл, нічого не препроцесив, нічого не готував наперед.
Повний промпт, який я надіслав (4 абзаци)
| 1 | Hi! I have a complex task for you. |
| 2 | |
| 3 | This is the obfuscated js code file, and I want you to iterate |
| 4 | multiple times and help me to find the closest possible original |
| 5 | code used before obfuscation and place it to source.js, |
| 6 | basically deobfuscate this file. |
| 7 | |
| 8 | This obfuscation is using new "VM obfuscation" of javascript-obfuscator — |
| 9 | and you'd need to iterate multiple times to simplify it, understand |
| 10 | semantics, methods used etc — to properly deobfuscate. Work for as |
| 11 | long as you need to find the closest to original code possible, use |
| 12 | different methodics, multiple planning stages as you need them, |
| 13 | write temp files to this directory as many times as you |
| 14 | need etc — it's yours to reverse. |
| 15 | |
| 16 | This is used to benchmark whether javascript-obfuscator deobfuscation claim |
| 17 | is real — and to estimate whether their VM approach is solid. |
| 18 | |
| 19 | I expect 2 outputs: |
| 20 | - the closest deobfuscated file closest to source code as much as |
| 21 | possible |
| 22 | - learnings on what obfuscation techniques are used and how strong |
| 23 | they are |
| 24 | |
| 25 | If you need to be in execution mode, please proceed in execution mode. |
Обфускований вхід — повний файл (~80 КБ)
| 1 | ((N, A) => { |
| 2 | const J = N(); |
| 3 | while (!![]) { |
| 4 | try { |
| 5 | const L = |
| 6 | (Number.parseInt(U(0x9, "9HM@")) / 0x1) * |
| 7 | (Number.parseInt(U(0xa, "waD0")) / 0x2) + |
| 8 | (Number.parseInt(U("0xb", "w1ba")) / 0x3) * |
| 9 | (Number.parseInt(U(0x3, "NCda")) / 0x4) + |
| 10 | Number.parseInt(U("0xc", "z4r4")) / 0x5 + |
| 11 | Number.parseInt(U("0xd", "9fK8")) / 0x6 + |
| 12 | Number.parseInt(U("0xe", "9sbv")) / 0x7 + |
| 13 | -Number.parseInt(U(0xf, "hHjw")) / 0x8 + |
| 14 | -Number.parseInt(U("0x10", "mJvw")) / 0x9; |
| 15 | if (L === A) break; |
| 16 | else J["push"](J["shift"]()); |
| 17 | } catch (V) { |
| 18 | J["push"](J["shift"]()); |
| 19 | } |
| 20 | } |
| 21 | })(b, 0xd0dfd); |
| 22 | const E = |
| 23 | (typeof globalThis !== "undefined" |
| 24 | ? globalThis |
| 25 | : typeof window !== "undefined" |
| 26 | ? window |
| 27 | : global)["w_399e2f"] || |
| 28 | ((typeof globalThis !== "undefined" |
| 29 | ? globalThis |
| 30 | : typeof window !== "undefined" |
| 31 | ? window |
| 32 | : global)["w_399e2f"] = {}), |
| 33 | P = E; |
| 34 | const p = (() => { |
| 35 | const N = [ |
| 36 | "nrrCpFydblS8R3E+BJ820M1GRMXrsrA6oM7nhnhCvdzfJDluZAoJxSuNXGMrIOP0/mdNa4ZJn6JHnVVdCl24ubOpZkyzsN9Gx3SsUYGtibsKpuXHLScoXE4DoUW8M9myZng84n+eKQyKteUvcdS4qUBItKVMNYirUJ2mXEZK+CoUAixSXtiUOVrUiGj1pw+aEZXGodaRd7ubHh3n2jKe4NdwQkdgPnta5GcKVJJBeKB4ydcr5SVYDHOjh3o=", |
| 37 | ]; |
| 38 | var A = { |
| 39 | i: "jR", |
| 40 | c: "Yl", |
| 41 | p: "PM", |
| 42 | l: "TW", |
| 43 | j: "wL", |
| 44 | x: "JB", |
| 45 | a: "lk", |
| 46 | s: "mV", |
| 47 | g: "CZ", |
| 48 | ni: "My", |
| 49 | os: "hq", |
| 50 | o: "nP", |
| 51 | jk: "JZ", |
| 52 | bk: "sP", |
| 53 | smSeed: "TE", |
| 54 | smState: "Il", |
| 55 | seKey: "mH", |
| 56 | }; |
| 57 | const J = 0x0, |
| 58 | L = 0x1, |
| 59 | V = 0x2, |
| 60 | n = 0x3, |
| 61 | I = 0x4, |
| 62 | s = 0x5, |
| 63 | C = 0x6, |
| 64 | G = 0x7, |
| 65 | j = 0x8, |
| 66 | i = 0x9, |
| 67 | k = 0xa, |
| 68 | F = 0x1, |
| 69 | q = 0x2, |
| 70 | u = 0x4, |
| 71 | r = 0x8, |
| 72 | m = 0x10, |
| 73 | y = 0x20, |
| 74 | a = 0x40, |
| 75 | Y = 0x80, |
| 76 | d = 0x100, |
| 77 | W = 0x200, |
| 78 | T = 0x400, |
| 79 | M = 0x800, |
| 80 | Q = 0x1000; |
| 81 | |
| 82 | function S(bk) { |
| 83 | ((this[U("0x11", "$M$P")] = bk), |
| 84 | (this[U("0x12", "@TcF")] = new DataView( |
| 85 | bk[U("0x13", "Gx#q")], |
| 86 | bk[U("0x14", "hHjw")], |
| 87 | bk[U("0x15", "$M$P")], |
| 88 | )), |
| 89 | (this[U(0x16, "7C2)")] = 0x0)); |
| 90 | } |
| 91 | |
| 92 | ((S[U("0x17", "^u[%")]["u8"] = function () { |
| 93 | return this[U(0x18, "m]hN")][this[U("0x19", "f(J&")]++]; |
| 94 | }), |
| 95 | (S[U("0x1a", "IAcC")][U(0x1b, "mj6Y")] = function () { |
| 96 | const bk = this[U(0x1c, "f(J&")][U("0x1d", "lw7j")]( |
| 97 | this[U(0x1e, "SAmI")], |
| 98 | !![], |
| 99 | ); |
| 100 | return ((this[U("0x1f", "tO6Y")] += 0x2), bk); |
| 101 | }), |
| 102 | (S[U(0x20, "!a8Q")][U("0x21", "SAmI")] = function () { |
| 103 | const bk = this[U("0x22", "C$TP")][U("0x23", "(sPS")]( |
| 104 | this[U(0x24, "lw7j")], |
| 105 | !![], |
| 106 | ); |
| 107 | return ((this[U(0x1f, "tO6Y")] += 0x4), bk); |
| 108 | }), |
| 109 | (S[U(0x25, "Ax7%")][U("0x26", "9sbv")] = function () { |
| 110 | const bk = this[U("0x27", "SAmI")][U(0x28, "BeXe")]( |
| 111 | this[U(0x29, "(sPS")], |
| 112 | !![], |
| 113 | ); |
| 114 | return ((this[U("0x2a", "9HM@")] += 0x4), bk); |
| 115 | }), |
| 116 | (S[U(0x25, "Ax7%")][U(0x2b, "W3hW")] = function () { |
| 117 | const bk = this[U("0x2c", "c(K]")][U("0x2d", "!a8Q")]( |
| 118 | this[U(0x24, "lw7j")], |
| 119 | !![], |
| 120 | ); |
| 121 | return ((this[U(0x2e, "$M$P")] += 0x8), bk); |
| 122 | }), |
| 123 | (S[U(0x2f, "Gx#q")][U("0x30", "@TcF")] = function () { |
| 124 | let bk = 0x0, |
| 125 | bF = 0x0, |
| 126 | bq; |
| 127 | do { |
| 128 | ((bq = this["u8"]()), (bk |= (bq & 0x7f) << bF), (bF += 0x7)); |
| 129 | } while (bq >= 0x80); |
| 130 | return (bk >>> 0x1) ^ -(bk & 0x1); |
| 131 | }), |
| 132 | (S[U("0x20", "!a8Q")][U(0x31, "CJ!h")] = function () { |
| 133 | const bk = this[U("0x32", "W3hW")](), |
| 134 | bF = this[U("0x33", "67gO")][U("0x34", "@TcF")]( |
| 135 | this[U("0x35", "BeXe")], |
| 136 | this[U(0x36, "w1ba")] + bk, |
| 137 | ); |
| 138 | return ( |
| 139 | (this[U(0x1e, "SAmI")] += bk), |
| 140 | new TextDecoder()[U("0x37", "(sPS")](bF) |
| 141 | ); |
| 142 | })); |
| 143 | |
| 144 | function v(bk) { |
| 145 | const bF = atob(bk), |
| 146 | bq = new Uint8Array(bF[U("0x38", "^HLG")]); |
| 147 | for (let bu = 0x0; bu < bF[U("0x39", "9sbv")]; bu++) { |
| 148 | bq[bu] = bF[U(0x3a, "w1ba")](bu); |
| 149 | } |
| 150 | return bq; |
| 151 | } |
| 152 | |
| 153 | function f(bk) { |
| 154 | const bF = bk["u8"](); |
| 155 | switch (bF) { |
| 156 | case J: |
| 157 | return null; |
| 158 | case L: |
| 159 | return undefined; |
| 160 | case V: |
| 161 | return ![]; |
| 162 | case n: |
| 163 | return !![]; |
| 164 | case I: { |
| 165 | const bq = bk["u8"](); |
| 166 | return bq > 0x7f ? bq - 0x100 : bq; |
| 167 | } |
| 168 | case s: { |
| 169 | const bu = bk[U(0x3b, "r]n&")](); |
| 170 | return bu > 0x7fff ? bu - 0x10000 : bu; |
| 171 | } |
| 172 | case C: |
| 173 | return bk[U("0x3c", "CJ!h")](); |
| 174 | case G: |
| 175 | return bk[U(0x3d, "7C2)")](); |
| 176 | case j: |
| 177 | return bk[U("0x3e", "Fu38")](); |
| 178 | case i: |
| 179 | return BigInt(bk[U(0x3f, "tO6Y")]()); |
| 180 | case k: { |
| 181 | const br = bk[U("0x40", "oqaM")](), |
| 182 | bm = bk[U(0x41, "JGtS")](); |
| 183 | return new RegExp(br, bm); |
| 184 | } |
| 185 | default: |
| 186 | return null; |
| 187 | } |
| 188 | } |
| 189 | |
| 190 | function B(bk, bF) { |
| 191 | const bq = v(bk), |
| 192 | bu = new S(bq), |
| 193 | br = bu["u8"](), |
| 194 | bm = bu[U("0x42", "@vun")](), |
| 195 | by = bu[U(0x43, "f#37")](), |
| 196 | ba = bu[U(0x44, "!a8Q")](), |
| 197 | bY = bF ? bF["i"] : "i", |
| 198 | bd = bF ? bF["c"] : "c", |
| 199 | bW = bF ? bF["p"] : "p", |
| 200 | bT = bF ? bF["l"] : "l", |
| 201 | bM = bF ? bF["j"] : "j", |
| 202 | bQ = bF ? bF["x"] : "x", |
| 203 | bS = bF ? bF["a"] : "a", |
| 204 | bv = bF ? bF["s"] : "s", |
| 205 | bf = bF ? bF["g"] : "g", |
| 206 | bB = bF ? bF["ni"] : "ni", |
| 207 | bh = bF ? bF["os"] : "os", |
| 208 | bl = bF ? bF["o"] : "o", |
| 209 | bx = bF ? bF["jk"] : "jk", |
| 210 | U0 = bF ? bF["bk"] : "bk", |
| 211 | U1 = bF ? bF[U("0x45", "mJvw")] : "smSeed", |
| 212 | U2 = bF ? bF[U("0x46", "SAmI")] : "smState", |
| 213 | U3 = bF ? bF[U(0x47, "JGtS")] : "seKey", |
| 214 | U4 = {}; |
| 215 | ((U4[bW] = by), (U4[bT] = ba)); |
| 216 | if (bm & r) U4[bB] = bu[U("0x48", "m]hN")](); |
| 217 | if (bm & m) U4[bh] = bu[U("0x49", "f#37")](); |
| 218 | if (bm & y) { |
| 219 | const U9 = bu[U("0x4a", "NCda")](), |
| 220 | Ub = {}; |
| 221 | for (let UU = 0x0; UU < U9; UU++) { |
| 222 | const UZ = bu[U("0x4b", "oqaM")](), |
| 223 | UO = bu[U(0x4c, "SI&j")](); |
| 224 | Ub[UZ] = UO; |
| 225 | } |
| 226 | U4[bl] = Ub; |
| 227 | } |
| 228 | if (bm & a) U4[bx] = bu[U(0x4d, "$M$P")](); |
| 229 | if (bm & Y) U4[U0] = bu[U(0x4e, "d3%f")](); |
| 230 | if (bm & d) U4[U1] = bu[U("0x4f", "f(J&")](); |
| 231 | if (bm & W) U4[U2] = bu[U("0x50", "QmhY")](); |
| 232 | if (bm & T) U4[U3] = bu[U(0x51, "QeOg")](); |
| 233 | if (bm & F) U4[bS] = 0x1; |
| 234 | if (bm & q) U4[bv] = 0x1; |
| 235 | if (bm & u) U4[bf] = 0x1; |
| 236 | const U5 = bu[U(0x52, "CJ!h")](), |
| 237 | U6 = []; |
| 238 | for (let Uc = 0x0; Uc < U5; Uc++) { |
| 239 | U6[U("0x53", "@vun")](f(bu)); |
| 240 | } |
| 241 | U4[bd] = U6; |
| 242 | const U7 = bu[U("0x43", "f#37")](), |
| 243 | U8 = []; |
| 244 | for (let Ug = 0x0; Ug < U7; Ug++) { |
| 245 | let UD = bu[U("0x54", "Ows7")](), |
| 246 | UR = bu["u8"](), |
| 247 | Ut; |
| 248 | switch (UR) { |
| 249 | case J: |
| 250 | Ut = null; |
| 251 | break; |
| 252 | case I: { |
| 253 | const Ue = bu["u8"](); |
| 254 | Ut = Ue > 0x7f ? Ue - 0x100 : Ue; |
| 255 | break; |
| 256 | } |
| 257 | case s: { |
| 258 | const UX = bu[U("0x55", "d3%f")](); |
| 259 | Ut = UX > 0x7fff ? UX - 0x10000 : UX; |
| 260 | break; |
| 261 | } |
| 262 | case C: |
| 263 | Ut = bu[U("0x56", "C$TP")](); |
| 264 | break; |
| 265 | case G: |
| 266 | Ut = bu[U("0x57", "BeXe")](); |
| 267 | break; |
| 268 | case j: |
| 269 | Ut = bu[U(0x58, "Gx#q")](); |
| 270 | break; |
| 271 | default: |
| 272 | Ut = null; |
| 273 | } |
| 274 | (U8[U("0x59", "Ax7%")](UD), U8[U("0x5a", "F!70")](Ut)); |
| 275 | } |
| 276 | U4[bY] = U8; |
| 277 | if (bm & M) { |
| 278 | const UH = bu[U("0x30", "@TcF")](), |
| 279 | Uw = {}; |
| 280 | for (let Uz = 0x0; Uz < UH; Uz++) { |
| 281 | const UK = bu[U(0x5b, "waD0")](), |
| 282 | UE = bu[U(0x5c, "67gO")](); |
| 283 | Uw[UK] = UE; |
| 284 | } |
| 285 | U4[bM] = Uw; |
| 286 | } |
| 287 | if (bm & Q) { |
| 288 | const UP = bu[U(0x5d, "9fK8")](), |
| 289 | Up = {}; |
| 290 | for (let Uo = 0x0; Uo < UP; Uo++) { |
| 291 | const UN = bu[U(0x5e, "9HM@")](), |
| 292 | UA = bu[U("0x5d", "9fK8")]() - 0x1, |
| 293 | UJ = bu[U("0x43", "f#37")]() - 0x1, |
| 294 | UL = bu[U(0x5f, "f(J&")]() - 0x1; |
| 295 | Up[UN] = [UA, UJ, UL]; |
| 296 | } |
| 297 | U4[bQ] = Up; |
| 298 | } |
| 299 | return U4; |
| 300 | } |
| 301 | |
| 302 | function h() { |
| 303 | var bk = 0x5f3759df; |
| 304 | return ( |
| 305 | (bk ^= |
| 306 | Array[U(0x25, "Ax7%")][U("0x60", "mJvw")][U(0x61, "d3%f")] << 0x18), |
| 307 | (bk ^= |
| 308 | String[U(0x2f, "Gx#q")][U(0x62, "f#37")][U("0x63", "m]hN")] << 0x14), |
| 309 | (bk ^= Math[U("0x64", "NCda")][U("0x65", "w1ba")] << 0x10), |
| 310 | (bk ^= Object[U(0x66, "hHjw")][U("0x67", "Fu38")] << 0xc), |
| 311 | (bk ^= |
| 312 | Array[U("0x68", "CJ!h")][U("0x69", "ID[x")][U(0x6a, "BeXe")] << 0x8), |
| 313 | (bk ^= String[U("0x6b", "oqaM")][U("0x6c", "Fu38")][U(0x6d, "Ax7%")]), |
| 314 | (bk ^= bk >>> 0x10), |
| 315 | (bk = Math[U("0x6e", "Fu38")](bk, 0x85ebca6b) >>> 0x0), |
| 316 | (bk ^= bk >>> 0xd), |
| 317 | (bk = Math[U(0x6f, "@TcF")](bk, 0xc2b2ae35) >>> 0x0), |
| 318 | (bk ^= bk >>> 0x10), |
| 319 | bk >>> 0x0 |
| 320 | ); |
| 321 | } |
| 322 | |
| 323 | function l(bk, bF) { |
| 324 | var bq = [], |
| 325 | bu = 0x0, |
| 326 | br, |
| 327 | bm = ""; |
| 328 | for (var by = 0x0; by < 0x100; by++) bq[by] = by; |
| 329 | for (var by = 0x0; by < 0x100; by++) { |
| 330 | ((bu = |
| 331 | (bu + bq[by] + bF[U(0x70, "W3hW")](by % bF[U(0x71, "SAmI")])) % 0x100), |
| 332 | (br = bq[by]), |
| 333 | (bq[by] = bq[bu]), |
| 334 | (bq[bu] = br)); |
| 335 | } |
| 336 | var by = 0x0; |
| 337 | bu = 0x0; |
| 338 | for (var ba = 0x0; ba < bk[U(0x72, "Wtwi")]; ba++) { |
| 339 | ((by = (by + 0x1) % 0x100), |
| 340 | (bu = (bu + bq[by]) % 0x100), |
| 341 | (br = bq[by]), |
| 342 | (bq[by] = bq[bu]), |
| 343 | (bq[bu] = br), |
| 344 | (bm += String[U("0x73", "@vun")]( |
| 345 | bk[U(0x74, "9HM@")](ba) ^ bq[(bq[by] + bq[bu]) % 0x100], |
| 346 | ))); |
| 347 | } |
| 348 | return bm; |
| 349 | } |
| 350 | |
| 351 | function x(bk) { |
| 352 | return atob(bk); |
| 353 | } |
| 354 | |
| 355 | var b0 = h()[U(0x75, "Ax7%")](0x10), |
| 356 | b1 = {}; |
| 357 | |
| 358 | function b2(bk) { |
| 359 | if (b1[bk]) return b1[bk]; |
| 360 | var bF = N[bk]; |
| 361 | if (typeof bF === "string") { |
| 362 | var bq = l(x(bF), b0); |
| 363 | b1[bk] = B(bq, A); |
| 364 | } else b1[bk] = bF; |
| 365 | return b1[bk]; |
| 366 | } |
| 367 | |
| 368 | const b3 = { |
| 369 | 0: 0x46, |
| 370 | 1: 0x19d, |
| 371 | 2: 0x8e, |
| 372 | 3: 0xea, |
| 373 | 4: 0x90, |
| 374 | 5: 0x4a, |
| 375 | 6: 0x81, |
| 376 | 7: 0x4b, |
| 377 | 8: 0xfd, |
| 378 | 9: 0x64, |
| 379 | 10: 0x14f, |
| 380 | 11: 0x1c2, |
| 381 | 12: 0x79, |
| 382 | 13: 0x9c, |
| 383 | 14: 0xb6, |
| 384 | 15: 0x78, |
| 385 | 16: 0x1ec, |
| 386 | 17: 0xe, |
| 387 | 18: 0x82, |
| 388 | 19: 0x112, |
| 389 | 20: 0x1e2, |
| 390 | 21: 0x20, |
| 391 | 22: 0xbc, |
| 392 | 23: 0x7b, |
| 393 | 24: 0x1d0, |
| 394 | 25: 0xdb, |
| 395 | 26: 0x1ee, |
| 396 | 32: 0xa7, |
| 397 | 40: 0x3e, |
| 398 | 41: 0x6a, |
| 399 | 42: 0x140, |
| 400 | 43: 0x1b8, |
| 401 | 44: 0x15d, |
| 402 | 45: 0x12c, |
| 403 | 46: 0x1d9, |
| 404 | 47: 0x184, |
| 405 | 50: 0x15, |
| 406 | 51: 0x137, |
| 407 | 52: 0x155, |
| 408 | 53: 0x9d, |
| 409 | 54: 0x66, |
| 410 | 55: 0x12b, |
| 411 | 56: 0x1c5, |
| 412 | 57: 0x58, |
| 413 | 58: 0x8c, |
| 414 | 59: 0x1d5, |
| 415 | 60: 0x6f, |
| 416 | 61: 0x19b, |
| 417 | 62: 0x126, |
| 418 | 63: 0x1e3, |
| 419 | 64: 0xff, |
| 420 | 65: 0x6c, |
| 421 | 70: 0x34, |
| 422 | 71: 0x159, |
| 423 | 72: 0x157, |
| 424 | 73: 0x1bd, |
| 425 | 74: 0x13f, |
| 426 | 75: 0x44, |
| 427 | 76: 0x1b7, |
| 428 | 77: 0x13, |
| 429 | 78: 0x68, |
| 430 | 79: 0x23, |
| 431 | 80: 0x19c, |
| 432 | 81: 0x99, |
| 433 | 82: 0x1f3, |
| 434 | 90: 0x1b2, |
| 435 | 91: 0x146, |
| 436 | 92: 0x33, |
| 437 | 93: 0x115, |
| 438 | 94: 0x8a, |
| 439 | 100: 0x149, |
| 440 | 101: 0xd9, |
| 441 | 102: 0x10f, |
| 442 | 103: 0xbf, |
| 443 | 104: 0xdf, |
| 444 | 105: 0x108, |
| 445 | 106: 0xa, |
| 446 | 110: 0x16, |
| 447 | 111: 0x5c, |
| 448 | 112: 0x106, |
| 449 | 120: 0x199, |
| 450 | 121: 0x39, |
| 451 | 122: 0x1ed, |
| 452 | 123: 0x1b0, |
| 453 | 124: 0x12e, |
| 454 | 125: 0x61, |
| 455 | 126: 0x148, |
| 456 | 127: 0x15c, |
| 457 | 128: 0xc2, |
| 458 | 140: 0x57, |
| 459 | 141: 0x69, |
| 460 | 142: 0x13a, |
| 461 | 144: 0x9a, |
| 462 | 145: 0x13c, |
| 463 | 146: 0x42, |
| 464 | 147: 0x100, |
| 465 | 148: 0xe5, |
| 466 | 149: 0xe0, |
| 467 | 160: 0x147, |
| 468 | 161: 0x22, |
| 469 | 162: 0x17a, |
| 470 | 163: 0x1db, |
| 471 | 164: 0x98, |
| 472 | 166: 0x180, |
| 473 | 167: 0xa9, |
| 474 | 168: 0xa2, |
| 475 | 169: 0x1b5, |
| 476 | 170: 0x189, |
| 477 | 171: 0x1dd, |
| 478 | 172: 0x92, |
| 479 | 173: 0x11f, |
| 480 | 174: 0x62, |
| 481 | 175: 0x1d7, |
| 482 | 200: 0x1f8, |
| 483 | 201: 0x169, |
| 484 | 202: 0x43, |
| 485 | 210: 0x4f, |
| 486 | 211: 0x104, |
| 487 | 212: 0x173, |
| 488 | 213: 0x133, |
| 489 | 214: 0x1e1, |
| 490 | 215: 0x41, |
| 491 | 216: 0x75, |
| 492 | 217: 0x1f, |
| 493 | 218: 0x30, |
| 494 | 250: 0x1d, |
| 495 | 251: 0xb1, |
| 496 | 252: 0xaa, |
| 497 | 253: 0x37, |
| 498 | 254: 0x1e0, |
| 499 | 255: 0x1f7, |
| 500 | 256: 0x118, |
| 501 | 257: 0x1be, |
| 502 | 258: 0x151, |
| 503 | 259: 0xbe, |
| 504 | 260: 0xd1, |
| 505 | 261: 0x9e, |
| 506 | }; |
| 507 | |
| 508 | function b4(bk, bF) { |
| 509 | const bq = []; |
| 510 | for (let bu = 0x0; bu < bF; bu++) { |
| 511 | const br = bk[U("0x76", "@vun")](); |
| 512 | if (br && typeof br === "object" && br[U("0x77", "@TcF")] === !![]) { |
| 513 | const bm = br[U("0x78", "Ax7%")]; |
| 514 | if (Array[U("0x79", "CJ!h")](bm)) |
| 515 | for (let by = bm[U("0x7a", "waD0")] - 0x1; by >= 0x0; by--) { |
| 516 | bq[U("0x7b", "T[d%")](bm[by]); |
| 517 | } |
| 518 | } else bq[U(0x7c, "4$Y3")](br); |
| 519 | } |
| 520 | return (bq[U(0x7d, "Wtwi")](), bq); |
| 521 | } |
| 522 | |
| 523 | let b5 = !![], |
| 524 | b6 = 0x0, |
| 525 | b7 = 0x0, |
| 526 | b8 = ![], |
| 527 | b9 = 0x1388, |
| 528 | bb = 0x3; |
| 529 | |
| 530 | function bU() { |
| 531 | if (!b5 || b8) return; |
| 532 | const bk = Date[U("0x7e", "Ax7%")](); |
| 533 | if (b6 === 0x0) { |
| 534 | b6 = bk; |
| 535 | return; |
| 536 | } |
| 537 | const bF = bk - b6; |
| 538 | b6 = bk; |
| 539 | if (bF > b9) { |
| 540 | b7++; |
| 541 | if (b7 >= bb) { |
| 542 | b8 = !![]; |
| 543 | for (const bq in b3) { |
| 544 | b3[bq] = (b3[bq] + 0x1) & 0x1ff; |
| 545 | } |
| 546 | } |
| 547 | } else b7 = 0x0; |
| 548 | } |
| 549 | |
| 550 | const bZ = 0x85ebca6b, |
| 551 | bO = 0xc2b2ae35, |
| 552 | bc = 0x10, |
| 553 | bg = 0xd, |
| 554 | bD = 0x10, |
| 555 | bR = 0x9e3779b9, |
| 556 | bt = 0x200; |
| 557 | |
| 558 | function be(bk) { |
| 559 | return ( |
| 560 | (bk = bk >>> 0x0), |
| 561 | (bk ^= bk >>> bc), |
| 562 | (bk = Math[U(0x7f, "NCda")](bk, bZ) >>> 0x0), |
| 563 | (bk ^= bk >>> bg), |
| 564 | (bk = Math[U("0x80", "(sPS")](bk, bO) >>> 0x0), |
| 565 | (bk ^= bk >>> bD), |
| 566 | bk >>> 0x0 |
| 567 | ); |
| 568 | } |
| 569 | |
| 570 | function bX(bk, bF) { |
| 571 | let bq = (bk ^ (bF * bR)) >>> 0x0; |
| 572 | return ( |
| 573 | (bq = (bq ^ (bq >>> 0xb)) >>> 0x0), |
| 574 | (bq = Math[U(0x81, "QeOg")](bq, 0x1b873593) >>> 0x0), |
| 575 | (bq = (bq ^ (bq >>> 0xf)) >>> 0x0), |
| 576 | be(bq) |
| 577 | ); |
| 578 | } |
| 579 | |
| 580 | function bH(bk, bF, bq) { |
| 581 | let bu = bk ^ ((bF * bR) >>> 0x0); |
| 582 | ((bu = (bu ^ ((bq * 0x27d4eb2d) >>> 0x0)) >>> 0x0), (bu = be(bu))); |
| 583 | const br = []; |
| 584 | for (let by = 0x0; by < bt; by++) { |
| 585 | br[by] = by; |
| 586 | } |
| 587 | for (let ba = bt - 0x1; ba > 0x0; ba--) { |
| 588 | const bY = bX(bu, ba), |
| 589 | bd = bY % (ba + 0x1), |
| 590 | bW = br[ba]; |
| 591 | ((br[ba] = br[bd]), (br[bd] = bW)); |
| 592 | } |
| 593 | const bm = {}; |
| 594 | for (let bT = 0x0; bT < bt; bT++) { |
| 595 | bm[bT] = br[bT]; |
| 596 | } |
| 597 | return bm; |
| 598 | } |
| 599 | |
| 600 | const bw = {}; |
| 601 | |
| 602 | function bz(bk, bF, bq) { |
| 603 | const bu = bk + "_" + bF + "_" + bq; |
| 604 | return (!bw[bu] && (bw[bu] = bH(bk, bF, bq)), bw[bu]); |
| 605 | } |
| 606 | |
| 607 | const bK = 0x8, |
| 608 | bE = 0x9e3779b9, |
| 609 | bP = 0x85ebca6b, |
| 610 | bp = 0xc2b2ae35, |
| 611 | bo = 0x200; |
| 612 | |
| 613 | function bN(bk) { |
| 614 | return ( |
| 615 | (bk = bk >>> 0x0), |
| 616 | (bk ^= bk >>> 0x10), |
| 617 | (bk = Math[U("0x82", "n[N$")](bk, bP) >>> 0x0), |
| 618 | (bk ^= bk >>> 0xd), |
| 619 | (bk = Math[U("0x83", "BeXe")](bk, bp) >>> 0x0), |
| 620 | (bk ^= bk >>> 0x10), |
| 621 | bk >>> 0x0 |
| 622 | ); |
| 623 | } |
| 624 | |
| 625 | function bA(bk, bF) { |
| 626 | const bq = bk ^ ((bF * bE) >>> 0x0); |
| 627 | return bN(bq) % bK; |
| 628 | } |
| 629 | |
| 630 | function bJ(bk, bF, bq, bu) { |
| 631 | let br = bk ^ ((bF * bE) >>> 0x0); |
| 632 | return ( |
| 633 | (br = (br ^ ((bq * bP) >>> 0x0)) >>> 0x0), |
| 634 | (br = (br ^ ((bu * bp) >>> 0x0)) >>> 0x0), |
| 635 | bN(br) |
| 636 | ); |
| 637 | } |
| 638 | |
| 639 | function bL(bk, bF) { |
| 640 | const bq = []; |
| 641 | for (let br = 0x0; br < bF; br++) { |
| 642 | bq[br] = br; |
| 643 | } |
| 644 | let bu = bk; |
| 645 | for (let bm = bF - 0x1; bm > 0x0; bm--) { |
| 646 | bu = bN(bu ^ bm); |
| 647 | const by = bu % (bm + 0x1), |
| 648 | ba = bq[bm]; |
| 649 | ((bq[bm] = bq[by]), (bq[by] = ba)); |
| 650 | } |
| 651 | return bq; |
| 652 | } |
| 653 | |
| 654 | const bV = {}; |
| 655 | |
| 656 | function bn(bk) { |
| 657 | if (bV[bk]) return bV[bk]; |
| 658 | const bF = []; |
| 659 | for (let bq = 0x0; bq < bK; bq++) { |
| 660 | const bu = bN(bk ^ (bq * bE)), |
| 661 | br = bL(bu, bo), |
| 662 | bm = {}; |
| 663 | for (let by = 0x0; by < bo; by++) { |
| 664 | bm[br[by]] = by; |
| 665 | } |
| 666 | bF[U("0x84", "mJvw")](bm); |
| 667 | } |
| 668 | return ((bV[bk] = bF), bF); |
| 669 | } |
| 670 | |
| 671 | function bI(bk, bF) { |
| 672 | if ( |
| 673 | typeof bk === "number" && |
| 674 | Number[U("0x85", "c(K]")](bk) && |
| 675 | Number[U(0x86, "r]n&")](bk) |
| 676 | ) { |
| 677 | if (bk >= -0x80000000 && bk <= 0x7fffffff) return (bk ^ bF) | 0x0; |
| 678 | } |
| 679 | return bk; |
| 680 | } |
| 681 | |
| 682 | function bs(bk, bF) { |
| 683 | if ( |
| 684 | typeof bk === "number" && |
| 685 | Number[U("0x87", "mJvw")](bk) && |
| 686 | Number[U(0x88, "(sPS")](bk) |
| 687 | ) { |
| 688 | if (bk >= -0x80000000 && bk <= 0x7fffffff) return (bk ^ bF) | 0x0; |
| 689 | } |
| 690 | return bk; |
| 691 | } |
| 692 | |
| 693 | function* bC(bk, bF, bq, bu, br, bm) { |
| 694 | let by = [], |
| 695 | ba = new Array((bk[A["p"]] || 0x0) + (bk[A["l"]] || 0x0)), |
| 696 | bY = 0x0, |
| 697 | bd = bk[A["c"]], |
| 698 | bW = bk[A["i"]], |
| 699 | bT = bk[A["j"]] || {}, |
| 700 | bM = bk[A["x"]] || {}, |
| 701 | bQ = bW[U("0x89", "Gx#q")] >> 0x1, |
| 702 | bS = [], |
| 703 | bv = null, |
| 704 | bf = { hasReturn: ![], value: undefined }, |
| 705 | bB = { hasBreak: ![], target: 0x0 }, |
| 706 | bh = { hasContinue: ![], target: 0x0 }, |
| 707 | bl = bk[A["o"]] || b3; |
| 708 | if (bk["os"] !== undefined) { |
| 709 | const Ut = bW[U(0x8a, "9fK8")] >> 0x1, |
| 710 | Ue = bd ? bd[U(0x8b, "oqaM")] : 0x0; |
| 711 | bl = bz(bk["os"], Ut, Ue); |
| 712 | } |
| 713 | const bx = bk[A[U("0x8c", "4$Y3")]] || 0x0, |
| 714 | U0 = bx ? bn(bx) : null; |
| 715 | if (bk[A[U(0x8d, "Gx#q")]] !== undefined) { |
| 716 | const UX = bk[A[U(0x8e, "Fu38")]], |
| 717 | UH = by[U(0x8f, "$M$P")][U(0x90, "SI&j")](by), |
| 718 | Uw = by[U("0x91", "m]hN")][U(0x92, "@vun")](by); |
| 719 | ((by[U(0x69, "ID[x")] = (Uz) => { |
| 720 | if ( |
| 721 | typeof Uz === "number" && |
| 722 | Number[U(0x93, "SI&j")](Uz) && |
| 723 | Number[U(0x94, "9HM@")](Uz) && |
| 724 | Uz >= -0x80000000 && |
| 725 | Uz <= 0x7fffffff |
| 726 | ) |
| 727 | return UH((Uz ^ UX) | 0x0); |
| 728 | return UH(Uz); |
| 729 | }), |
| 730 | (by[U(0x95, "waD0")] = () => { |
| 731 | const Uz = Uw(); |
| 732 | if ( |
| 733 | typeof Uz === "number" && |
| 734 | Number[U("0x96", "ID[x")](Uz) && |
| 735 | Number[U(0x88, "(sPS")](Uz) && |
| 736 | Uz >= -0x80000000 && |
| 737 | Uz <= 0x7fffffff |
| 738 | ) |
| 739 | return (Uz ^ UX) | 0x0; |
| 740 | return Uz; |
| 741 | })); |
| 742 | } |
| 743 | let U1 = bk[A["jk"]] || 0x0, |
| 744 | U2 = bk[A["bk"]] || 0x0, |
| 745 | U3 = (Uz) => (U1 ? Uz ^ U1 : Uz), |
| 746 | U4 = (Uz) => (U2 ? Uz ^ U2 : Uz), |
| 747 | U5 = { parent: bq, vars: {} }; |
| 748 | if (bF) |
| 749 | for ( |
| 750 | let Uz = 0x0; |
| 751 | Uz < Math[U(0x97, "9sbv")](bF[U("0x98", "NCda")], bk[A["p"]] || 0x0); |
| 752 | Uz++ |
| 753 | ) { |
| 754 | ba[Uz] = bF[Uz]; |
| 755 | } |
| 756 | if (bk[A["ni"]] !== undefined && bu) { |
| 757 | const UK = bk[A["c"]][bk[A["ni"]]]; |
| 758 | U5[U(0x99, "f(J&")][UK] = bu; |
| 759 | if (!U5[U(0x9a, "9fK8")]) U5[U(0x9b, "c(K]")] = {}; |
| 760 | U5[U("0x9c", "7C2)")][UK] = !![]; |
| 761 | try { |
| 762 | Object[U("0x9d", "C$TP")](bu, "name", { |
| 763 | value: UK, |
| 764 | writable: ![], |
| 765 | enumerable: ![], |
| 766 | configurable: !![], |
| 767 | }); |
| 768 | } catch (UE) {} |
| 769 | } |
| 770 | let U6 = 0x0; |
| 771 | while (bY < bQ) { |
| 772 | try { |
| 773 | while (bY < bQ) { |
| 774 | ++U6 > 0x64 && ((U6 = 0x0), bU()); |
| 775 | let UP = bY << 0x1, |
| 776 | Up = U4(bW[UP]), |
| 777 | Uo = Up; |
| 778 | if (U0) { |
| 779 | const UL = bA(bx, bY), |
| 780 | UV = U0[UL]; |
| 781 | UV && (Uo = UV[Up]); |
| 782 | } |
| 783 | const UN = bl[Uo], |
| 784 | UA = bW[UP + 0x1], |
| 785 | UJ = UA === null ? undefined : typeof UA === "number" ? U4(UA) : UA; |
| 786 | if (Uo === 0x7a) { |
| 787 | const Un = by[U(0x9e, "Ows7")](), |
| 788 | UI = yield { t: 0x1, v: Un }; |
| 789 | (by[U("0x9f", "Fu38")](UI), bY++); |
| 790 | continue; |
| 791 | } |
| 792 | if (Uo === 0x78) { |
| 793 | const Us = by[U("0xa0", "ID[x")](), |
| 794 | UC = yield { t: 0x2, v: Us }; |
| 795 | (by[U("0xa1", "CJ!h")](UC), bY++); |
| 796 | continue; |
| 797 | } |
| 798 | if (Uo === 0x79) { |
| 799 | const UG = by[U(0xa2, "y22^")](), |
| 800 | Uj = yield { t: 0x3, v: UG }; |
| 801 | (by[U(0x7c, "4$Y3")](Uj), bY++); |
| 802 | continue; |
| 803 | } |
| 804 | if (typeof U9 === "undefined") { |
| 805 | var U7 = ![], |
| 806 | U8, |
| 807 | U9 = [], |
| 808 | Ub = {}, |
| 809 | UU = []; |
| 810 | for (var UZ in bl) { |
| 811 | if (bl[U(0xa3, "67gO")](UZ)) |
| 812 | UU[U(0xa4, "d3%f")](Number.parseInt(UZ)); |
| 813 | } |
| 814 | var UO = UU[U("0xa5", "Ows7")](); |
| 815 | for (var Uc = UO[U("0xa6", "tO6Y")] - 0x1; Uc > 0x0; Uc--) { |
| 816 | var Ug = Math[U(0xa7, "Wtwi")]( |
| 817 | Math[U(0xa8, "BeXe")]() * (Uc + 0x1), |
| 818 | ), |
| 819 | UD = UO[Uc]; |
| 820 | ((UO[Uc] = UO[Ug]), (UO[Ug] = UD)); |
| 821 | } |
| 822 | for (var Uc = 0x0; Uc < UU[U(0xa9, "y22^")]; Uc++) { |
| 823 | Ub[bl[UU[Uc]]] = UO[Uc]; |
| 824 | } |
| 825 | var UR = (Ui, Uk) => { |
| 826 | var UF = Uk; |
| 827 | switch (Ui) { |
| 828 | case bl[0x0]: { |
| 829 | (by[U("0xaa", "mj6Y")](bd[UF]), bY++); |
| 830 | break; |
| 831 | } |
| 832 | case bl[0x1]: { |
| 833 | (by[U(0xab, "7C2)")](undefined), bY++); |
| 834 | break; |
| 835 | } |
| 836 | case bl[0x2]: { |
| 837 | (by[U("0xac", "oqaM")](null), bY++); |
| 838 | break; |
| 839 | } |
| 840 | case bl[0x3]: { |
| 841 | (by[U(0xad, "Wtwi")](), bY++); |
| 842 | break; |
| 843 | } |
| 844 | case bl[0x4]: { |
| 845 | const Uq = by[U(0xae, "SAmI")](); |
| 846 | (by[U(0xaa, "mj6Y")](Uq), by[U("0xaf", "C$TP")](Uq), bY++); |
| 847 | break; |
| 848 | } |
| 849 | case bl[0x5]: { |
| 850 | const Uu = by[U(0x38, "^HLG")], |
| 851 | Ur = by[Uu - 0x1]; |
| 852 | ((by[Uu - 0x1] = by[Uu - 0x2]), (by[Uu - 0x2] = Ur), bY++); |
| 853 | break; |
| 854 | } |
| 855 | case bl[0x6]: { |
| 856 | (by[U(0xb0, "9HM@")](ba[UF]), bY++); |
| 857 | break; |
| 858 | } |
| 859 | case bl[0x7]: { |
| 860 | ((ba[UF] = by[U(0xb1, "9sbv")]()), bY++); |
| 861 | break; |
| 862 | } |
| 863 | case bl[0x8]: { |
| 864 | (by[U(0xb2, "n[N$")](bF[UF]), bY++); |
| 865 | break; |
| 866 | } |
| 867 | case bl[0x9]: { |
| 868 | ((bF[UF] = by[U(0xb3, "QmhY")]()), bY++); |
| 869 | break; |
| 870 | } |
| 871 | case bl[0xa]: { |
| 872 | const Um = by[U(0xb4, "9HM@")](), |
| 873 | Uy = by[U("0x91", "m]hN")](); |
| 874 | (by[U("0xb5", "SI&j")](Uy + Um), bY++); |
| 875 | break; |
| 876 | } |
| 877 | case bl[0xb]: { |
| 878 | const Ua = by[U("0x95", "waD0")](), |
| 879 | UY = by[U(0xb6, "Fu38")](); |
| 880 | (by[U(0xb7, "tO6Y")](UY - Ua), bY++); |
| 881 | break; |
| 882 | } |
| 883 | case bl[0xc]: { |
| 884 | const Ud = by[U(0xb8, "(sPS")](), |
| 885 | UW = by[U("0xa0", "ID[x")](); |
| 886 | (by[U("0x59", "Ax7%")](UW * Ud), bY++); |
| 887 | break; |
| 888 | } |
| 889 | case bl[0xd]: { |
| 890 | const UT = by[U("0xb9", "lw7j")](), |
| 891 | UM = by[U("0xba", "W3hW")](); |
| 892 | (by[U(0xbb, "@TcF")](UM / UT), bY++); |
| 893 | break; |
| 894 | } |
| 895 | case bl[0xe]: { |
| 896 | const UQ = by[U(0xae, "SAmI")](), |
| 897 | US = by[U(0xbc, "mj6Y")](); |
| 898 | (by[U(0xbd, "Gx#q")](US % UQ), bY++); |
| 899 | break; |
| 900 | } |
| 901 | case bl[0xf]: |
| 902 | (by[U(0xbe, "hHjw")](-by[U(0xbf, "F!70")]()), bY++); |
| 903 | break; |
| 904 | case bl[0x13]: |
| 905 | (by[U("0xc0", "(sPS")](+by[U("0xc1", "w1ba")]()), bY++); |
| 906 | break; |
| 907 | case bl[0x12]: { |
| 908 | const Uv = by[U(0xb6, "Fu38")](), |
| 909 | Uf = by[U(0xba, "W3hW")](); |
| 910 | (by[U("0xc2", "r]n&")](Math[U("0xc3", "W3hW")](Uf, Uv)), |
| 911 | bY++); |
| 912 | break; |
| 913 | } |
| 914 | case bl[0x14]: { |
| 915 | const UB = by[U(0xb6, "Fu38")](), |
| 916 | Uh = by[U("0xb8", "(sPS")](); |
| 917 | (by[U("0xc4", "SAmI")](Uh & UB), bY++); |
| 918 | break; |
| 919 | } |
| 920 | case bl[0x15]: { |
| 921 | const Ul = by[U("0xb6", "Fu38")](), |
| 922 | Ux = by[U(0xc5, "NCda")](); |
| 923 | (by[U(0xc6, "waD0")](Ux | Ul), bY++); |
| 924 | break; |
| 925 | } |
| 926 | case bl[0x16]: { |
| 927 | const Z0 = by[U(0xc7, "f#37")](), |
| 928 | Z1 = by[U("0xc8", "7C2)")](); |
| 929 | (by[U(0xc9, "w1ba")](Z1 ^ Z0), bY++); |
| 930 | break; |
| 931 | } |
| 932 | case bl[0x17]: |
| 933 | (by[U("0x59", "Ax7%")](~by[U(0x9e, "Ows7")]()), bY++); |
| 934 | break; |
| 935 | case bl[0x18]: { |
| 936 | const Z2 = by[U("0xca", "c(K]")](), |
| 937 | Z3 = by[U("0x95", "waD0")](); |
| 938 | (by[U("0xb5", "SI&j")](Z3 << Z2), bY++); |
| 939 | break; |
| 940 | } |
| 941 | case bl[0x19]: { |
| 942 | const Z4 = by[U("0x9e", "Ows7")](), |
| 943 | Z5 = by[U("0xcb", "n[N$")](); |
| 944 | (by[U("0xcc", "NCda")](Z5 >> Z4), bY++); |
| 945 | break; |
| 946 | } |
| 947 | case bl[0x1a]: { |
| 948 | const Z6 = by[U("0xcd", "SI&j")](), |
| 949 | Z7 = by[U(0xce, "mJvw")](); |
| 950 | (by[U("0x9f", "Fu38")](Z7 >>> Z6), bY++); |
| 951 | break; |
| 952 | } |
| 953 | case bl[0x20]: |
| 954 | (by[U("0xcf", "Ows7")](!by[U("0xd0", "^u[%")]()), bY++); |
| 955 | break; |
| 956 | case bl[0x28]: { |
| 957 | const Z8 = by[U("0xca", "c(K]")](), |
| 958 | Z9 = by[U("0xd1", "C$TP")](); |
| 959 | (by[U("0xd2", "c(K]")](Z9 == Z8), bY++); |
| 960 | break; |
| 961 | } |
| 962 | case bl[0x29]: { |
| 963 | const Zb = by[U(0x9e, "Ows7")](), |
| 964 | ZU = by[U(0xd3, "IAcC")](); |
| 965 | (by[U("0x8f", "$M$P")](ZU != Zb), bY++); |
| 966 | break; |
| 967 | } |
| 968 | case bl[0x2a]: { |
| 969 | const ZZ = by[U("0xb4", "9HM@")](), |
| 970 | ZO = by[U(0xd4, "67gO")](); |
| 971 | (by[U(0xc0, "(sPS")](ZO === ZZ), bY++); |
| 972 | break; |
| 973 | } |
| 974 | case bl[0x2b]: { |
| 975 | const Zc = by[U(0x76, "@vun")](), |
| 976 | Zg = by[U(0xd5, "@TcF")](); |
| 977 | (by[U("0xcf", "Ows7")](Zg !== Zc), bY++); |
| 978 | break; |
| 979 | } |
| 980 | case bl[0x2c]: { |
| 981 | const ZD = by[U(0xcb, "n[N$")](), |
| 982 | ZR = by[U(0xd6, "CJ!h")](); |
| 983 | (by[U("0x9f", "Fu38")](ZR < ZD), bY++); |
| 984 | break; |
| 985 | } |
| 986 | case bl[0x2d]: { |
| 987 | const Zt = by[U("0xad", "Wtwi")](), |
| 988 | Ze = by[U("0xd7", "5zWX")](); |
| 989 | (by[U(0xc2, "r]n&")](Ze <= Zt), bY++); |
| 990 | break; |
| 991 | } |
| 992 | case bl[0x2e]: { |
| 993 | const ZX = by[U("0xca", "c(K]")](), |
| 994 | ZH = by[U("0xd8", "oqaM")](); |
| 995 | (by[U("0xd9", "f(J&")](ZH > ZX), bY++); |
| 996 | break; |
| 997 | } |
| 998 | case bl[0x2f]: { |
| 999 | const Zw = by[U("0xb8", "(sPS")](), |
| 1000 | Zz = by[U("0xda", "hHjw")](); |
| 1001 | (by[U(0xdb, "JGtS")](Zz >= Zw), bY++); |
| 1002 | break; |
| 1003 | } |
| 1004 | case bl[0x32]: { |
| 1005 | bY = U3(bT[bY]); |
| 1006 | break; |
| 1007 | } |
| 1008 | case bl[0x33]: { |
| 1009 | by[U(0xd6, "CJ!h")]() ? (bY = U3(bT[bY])) : bY++; |
| 1010 | break; |
| 1011 | } |
| 1012 | case bl[0x34]: { |
| 1013 | !by[U("0xdc", "z4r4")]() ? (bY = U3(bT[bY])) : bY++; |
| 1014 | break; |
| 1015 | } |
| 1016 | case bl[0x35]: { |
| 1017 | const ZK = by[U("0xad", "Wtwi")](); |
| 1018 | ZK !== null && ZK !== undefined ? (bY = U3(bT[bY])) : bY++; |
| 1019 | break; |
| 1020 | } |
| 1021 | case bl[0x36]: { |
| 1022 | const ZE = by[U("0xdd", "!a8Q")](), |
| 1023 | ZP = by[U("0xcd", "SI&j")](); |
| 1024 | (by[U("0xb2", "n[N$")]( |
| 1025 | ZP[U(0xde, "z4r4")](undefined, b4(by, ZE)), |
| 1026 | ), |
| 1027 | bY++); |
| 1028 | break; |
| 1029 | } |
| 1030 | case bl[0x37]: { |
| 1031 | const Zp = by[U("0xb6", "Fu38")](), |
| 1032 | Zo = by[U("0xae", "SAmI")](), |
| 1033 | ZN = by[U("0x91", "m]hN")](); |
| 1034 | if (typeof Zo !== "function") |
| 1035 | throw new TypeError(Zo + " is not a function"); |
| 1036 | (by[U(0xbe, "hHjw")](Zo[U(0xdf, "C$TP")](ZN, b4(by, Zp))), |
| 1037 | bY++); |
| 1038 | break; |
| 1039 | } |
| 1040 | case bl[0x38]: { |
| 1041 | if (bS[U(0xe0, "IAcC")] > 0x0) { |
| 1042 | const ZA = bS[bS[U("0x8b", "oqaM")] - 0x1]; |
| 1043 | if (ZA[U(0xe1, "@vun")] !== undefined) { |
| 1044 | ((bf[U("0xe2", "n[N$")] = !![]), |
| 1045 | (bf[U(0xe3, "Wtwi")] = by[U("0xb8", "(sPS")]()), |
| 1046 | (bY = ZA[U(0xe4, "(sPS")])); |
| 1047 | break; |
| 1048 | } |
| 1049 | } |
| 1050 | bf[U("0xe5", "waD0")] && |
| 1051 | ((bf[U("0xe6", "9fK8")] = ![]), |
| 1052 | (bf[U("0xe7", "QmhY")] = undefined)); |
| 1053 | ((U7 = !![]), (U8 = by[U(0xb1, "9sbv")]())); |
| 1054 | return; |
| 1055 | } |
| 1056 | case bl[0x39]: { |
| 1057 | throw by[U(0xdd, "!a8Q")](); |
| 1058 | } |
| 1059 | case bl[0x3f]: { |
| 1060 | if (bS[U(0xe0, "IAcC")] > 0x0) { |
| 1061 | const ZJ = bS[bS[U("0xe8", "r]n&")] - 0x1]; |
| 1062 | if (ZJ[U(0xe9, "JGtS")] !== undefined) { |
| 1063 | ((bB[U("0xea", "hHjw")] = !![]), |
| 1064 | (bB[U(0xeb, "Ows7")] = U3(bT[bY])), |
| 1065 | (bY = ZJ[U(0xec, "W3hW")])); |
| 1066 | break; |
| 1067 | } |
| 1068 | } |
| 1069 | bY = U3(bT[bY]); |
| 1070 | break; |
| 1071 | } |
| 1072 | case bl[0x40]: { |
| 1073 | if (bS[U(0xe8, "r]n&")] > 0x0) { |
| 1074 | const ZL = bS[bS[U(0xed, "lw7j")] - 0x1]; |
| 1075 | if (ZL[U("0xee", "NCda")] !== undefined) { |
| 1076 | ((bh[U("0xef", "Gx#q")] = !![]), |
| 1077 | (bh[U(0xf0, "waD0")] = U3(bT[bY])), |
| 1078 | (bY = ZL[U(0xf1, "f#37")])); |
| 1079 | break; |
| 1080 | } |
| 1081 | } |
| 1082 | bY = U3(bT[bY]); |
| 1083 | break; |
| 1084 | } |
| 1085 | case bl[0x3a]: { |
| 1086 | const ZV = bM[bY]; |
| 1087 | (bS[U("0xf2", "IAcC")]({ |
| 1088 | catchIndex: ZV[0x0] >= 0x0 ? U3(ZV[0x0]) : undefined, |
| 1089 | finallyIndex: ZV[0x1] >= 0x0 ? U3(ZV[0x1]) : undefined, |
| 1090 | endIndex: ZV[0x2] >= 0x0 ? U3(ZV[0x2]) : undefined, |
| 1091 | stackSize: by[U("0x6a", "BeXe")], |
| 1092 | }), |
| 1093 | bY++); |
| 1094 | break; |
| 1095 | } |
| 1096 | case bl[0x3b]: { |
| 1097 | (bS[U(0xdd, "!a8Q")](), bY++); |
| 1098 | break; |
| 1099 | } |
| 1100 | case bl[0x3c]: { |
| 1101 | const Zn = by[U("0xd7", "5zWX")](); |
| 1102 | if (UF >= 0x0) { |
| 1103 | const ZI = bd[UF]; |
| 1104 | U5[U("0xf3", "9sbv")][ZI] = Zn; |
| 1105 | } |
| 1106 | bY++; |
| 1107 | break; |
| 1108 | } |
| 1109 | case bl[0x3d]: { |
| 1110 | if (bS[U(0xf4, "W3hW")] > 0x0) { |
| 1111 | const Zs = bS[bS[U("0x61", "d3%f")] - 0x1]; |
| 1112 | Zs[U("0xf5", "T[d%")] === bY && |
| 1113 | (Zs[U(0xf6, "f(J&")] !== undefined && |
| 1114 | (bv = Zs[U("0xf7", "4$Y3")]), |
| 1115 | bS[U("0x91", "m]hN")]()); |
| 1116 | } |
| 1117 | bY++; |
| 1118 | break; |
| 1119 | } |
| 1120 | case bl[0x3e]: { |
| 1121 | if (bf[U(0xf8, "@vun")]) { |
| 1122 | const ZC = bf[U(0xf9, "Gx#q")]; |
| 1123 | ((bf[U("0xfa", "ID[x")] = ![]), |
| 1124 | (bf[U(0xfb, "SI&j")] = undefined), |
| 1125 | (U7 = !![]), |
| 1126 | (U8 = ZC)); |
| 1127 | return; |
| 1128 | } |
| 1129 | if (bB[U(0xfc, "r]n&")]) { |
| 1130 | const ZG = bB[U("0xeb", "Ows7")]; |
| 1131 | ((bB[U(0xfd, "T[d%")] = ![]), |
| 1132 | (bB[U("0xfe", "NCda")] = 0x0), |
| 1133 | (bY = ZG)); |
| 1134 | break; |
| 1135 | } |
| 1136 | if (bh[U("0xff", "z4r4")]) { |
| 1137 | const Zj = bh[U(0xeb, "Ows7")]; |
| 1138 | ((bh[U(0x100, "(sPS")] = ![]), |
| 1139 | (bh[U("0x101", "SI&j")] = 0x0), |
| 1140 | (bY = Zj)); |
| 1141 | break; |
| 1142 | } |
| 1143 | if (bv !== null) { |
| 1144 | const Zi = bv; |
| 1145 | bv = null; |
| 1146 | throw Zi; |
| 1147 | } |
| 1148 | bY++; |
| 1149 | break; |
| 1150 | } |
| 1151 | case bl[0x46]: { |
| 1152 | const Zk = by[U(0xbf, "F!70")](), |
| 1153 | ZF = bd[UF]; |
| 1154 | if (Zk === null || Zk === undefined) |
| 1155 | throw new TypeError( |
| 1156 | "Cannot read property '" + ZF + "' of " + Zk, |
| 1157 | ); |
| 1158 | (by[U(0xb5, "SI&j")](Zk[ZF]), bY++); |
| 1159 | break; |
| 1160 | } |
| 1161 | case bl[0x47]: { |
| 1162 | const Zq = by[U("0xbf", "F!70")](), |
| 1163 | Zu = by[U("0xc5", "NCda")](), |
| 1164 | Zr = bd[UF]; |
| 1165 | if (Zu === null || Zu === undefined) |
| 1166 | throw new TypeError( |
| 1167 | "Cannot set property '" + Zr + "' of " + Zu, |
| 1168 | ); |
| 1169 | ((Zu[Zr] = Zq), by[U("0xc9", "w1ba")](Zq), bY++); |
| 1170 | break; |
| 1171 | } |
| 1172 | case bl[0x48]: { |
| 1173 | const Zm = by[U("0xdd", "!a8Q")](), |
| 1174 | Zy = by[U("0xb9", "lw7j")](); |
| 1175 | if (Zy === null || Zy === undefined) |
| 1176 | throw new TypeError( |
| 1177 | "Cannot read property '" + Zm + "' of " + Zy, |
| 1178 | ); |
| 1179 | (by[U("0x5a", "F!70")](Zy[Zm]), bY++); |
| 1180 | break; |
| 1181 | } |
| 1182 | case bl[0x49]: { |
| 1183 | const Za = by[U("0xb8", "(sPS")](), |
| 1184 | ZY = by[U(0xba, "W3hW")](), |
| 1185 | Zd = by[U(0xb9, "lw7j")](); |
| 1186 | if (Zd === null || Zd === undefined) |
| 1187 | throw new TypeError( |
| 1188 | "Cannot set property '" + ZY + "' of " + Zd, |
| 1189 | ); |
| 1190 | ((Zd[ZY] = Za), by[U(0x102, "Wtwi")](Za), bY++); |
| 1191 | break; |
| 1192 | } |
| 1193 | case bl[0x4a]: { |
| 1194 | let ZW, ZT; |
| 1195 | UF !== undefined |
| 1196 | ? ((ZT = by[U(0xbf, "F!70")]()), (ZW = bd[UF])) |
| 1197 | : ((ZW = by[U(0xb1, "9sbv")]()), |
| 1198 | (ZT = by[U("0x103", "BeXe")]())); |
| 1199 | const ZM = delete ZT[ZW]; |
| 1200 | (by[U(0x53, "@vun")](ZM), bY++); |
| 1201 | break; |
| 1202 | } |
| 1203 | case bl[0x4b]: { |
| 1204 | let ZQ = bd[UF], |
| 1205 | ZS, |
| 1206 | Zv = |
| 1207 | typeof globalThis !== "undefined" |
| 1208 | ? globalThis |
| 1209 | : typeof window !== "undefined" |
| 1210 | ? window |
| 1211 | : global; |
| 1212 | if (ZQ in E) ZS = E[ZQ]; |
| 1213 | else { |
| 1214 | if (P && ZQ in P) ZS = P[ZQ]; |
| 1215 | else { |
| 1216 | if (ZQ in Zv) ZS = Zv[ZQ]; |
| 1217 | else throw new ReferenceError(ZQ + " is not defined"); |
| 1218 | } |
| 1219 | } |
| 1220 | (by[U("0x104", "^HLG")](ZS), bY++); |
| 1221 | break; |
| 1222 | } |
| 1223 | case bl[0x4c]: { |
| 1224 | const Zf = by[U(0x105, "4$Y3")](), |
| 1225 | ZB = bd[UF]; |
| 1226 | P && ZB in P ? (P[ZB] = Zf) : (E[ZB] = Zf); |
| 1227 | (by[U(0xac, "oqaM")](Zf), bY++); |
| 1228 | break; |
| 1229 | } |
| 1230 | case bl[0x4d]: { |
| 1231 | (by[U(0x106, "!a8Q")]({}), bY++); |
| 1232 | break; |
| 1233 | } |
| 1234 | case bl[0x4e]: { |
| 1235 | const Zh = by[U(0x91, "m]hN")](), |
| 1236 | Zl = bd[UF]; |
| 1237 | Zh === null || Zh === undefined |
| 1238 | ? by[U(0x107, "y22^")](undefined) |
| 1239 | : by[U("0x104", "^HLG")](Zh[Zl]); |
| 1240 | bY++; |
| 1241 | break; |
| 1242 | } |
| 1243 | case bl[0x4f]: { |
| 1244 | const Zx = by[U("0xad", "Wtwi")](), |
| 1245 | O0 = by[U(0xb6, "Fu38")](); |
| 1246 | (by[U("0xac", "oqaM")](O0 in Zx), bY++); |
| 1247 | break; |
| 1248 | } |
| 1249 | case bl[0x51]: { |
| 1250 | const O1 = by[U(0xca, "c(K]")](), |
| 1251 | O2 = by[by[U("0x65", "w1ba")] - 0x1]; |
| 1252 | O1 !== null && |
| 1253 | O1 !== undefined && |
| 1254 | Object[U(0x108, "9HM@")](O2, O1); |
| 1255 | bY++; |
| 1256 | break; |
| 1257 | } |
| 1258 | case bl[0x52]: { |
| 1259 | const O3 = by[U("0x109", "9fK8")](), |
| 1260 | O4 = by[U("0x105", "4$Y3")](); |
| 1261 | O4 === null || O4 === undefined |
| 1262 | ? by[U(0xc2, "r]n&")](undefined) |
| 1263 | : by[U(0x10a, "^u[%")](O4[O3]); |
| 1264 | bY++; |
| 1265 | break; |
| 1266 | } |
| 1267 | case bl[0x91]: { |
| 1268 | const O5 = by[U("0xba", "W3hW")](), |
| 1269 | O6 = by[by[U("0x10b", "F!70")] - 0x1], |
| 1270 | O7 = bd[UF], |
| 1271 | O8 = |
| 1272 | typeof O6 === "function" && O6[U(0x10c, "f#37")] |
| 1273 | ? O6[U("0x10d", "Wtwi")] |
| 1274 | : O6; |
| 1275 | (Object[U("0x10e", "QeOg")](O8, O7, { |
| 1276 | get: O5, |
| 1277 | enumerable: O8 === O6, |
| 1278 | configurable: !![], |
| 1279 | }), |
| 1280 | bY++); |
| 1281 | break; |
| 1282 | } |
| 1283 | case bl[0x92]: { |
| 1284 | const O9 = by[U("0x9e", "Ows7")](), |
| 1285 | Ob = by[by[U(0x10f, "5zWX")] - 0x1], |
| 1286 | OU = bd[UF], |
| 1287 | OZ = |
| 1288 | typeof Ob === "function" && Ob[U("0x110", "NCda")] |
| 1289 | ? Ob[U("0x111", "ID[x")] |
| 1290 | : Ob; |
| 1291 | (Object[U(0x112, "T[d%")](OZ, OU, { |
| 1292 | set: O9, |
| 1293 | enumerable: OZ === Ob, |
| 1294 | configurable: !![], |
| 1295 | }), |
| 1296 | bY++); |
| 1297 | break; |
| 1298 | } |
| 1299 | case bl[0x8c]: { |
| 1300 | const OO = by[U("0xb3", "QmhY")](), |
| 1301 | Oc = by[U(0xce, "mJvw")](), |
| 1302 | Og = UF, |
| 1303 | OD = ((OR, Ot, Oe) => { |
| 1304 | let OX; |
| 1305 | return ( |
| 1306 | Oe |
| 1307 | ? (OX = function () { |
| 1308 | if (Ot) { |
| 1309 | E["__$$constructor$$__"] = OX; |
| 1310 | const OH = "__$$newTarget$$__" in E; |
| 1311 | !OH && (E["__$$newTarget$$__"] = new.target); |
| 1312 | try { |
| 1313 | const Ow = []; |
| 1314 | for ( |
| 1315 | let Oz = 0x0; |
| 1316 | Oz < arguments[U(0x113, "^u[%")]; |
| 1317 | Oz++ |
| 1318 | ) { |
| 1319 | Ow[U(0xd2, "c(K]")](arguments[Oz]); |
| 1320 | } |
| 1321 | return Ot[U(0x114, "y22^")](this, Ow); |
| 1322 | } finally { |
| 1323 | (delete E["__$$constructor$$__"], |
| 1324 | !OH && delete E["__$$newTarget$$__"]); |
| 1325 | } |
| 1326 | } |
| 1327 | }) |
| 1328 | : (OX = function () { |
| 1329 | if (Ot) { |
| 1330 | const OH = "__$$newTarget$$__" in E; |
| 1331 | !OH && (E["__$$newTarget$$__"] = new.target); |
| 1332 | try { |
| 1333 | const Ow = []; |
| 1334 | for ( |
| 1335 | let Oz = 0x0; |
| 1336 | Oz < arguments[U("0x115", "T[d%")]; |
| 1337 | Oz++ |
| 1338 | ) { |
| 1339 | Ow[U(0x59, "Ax7%")](arguments[Oz]); |
| 1340 | } |
| 1341 | return Ot[U("0x116", "QeOg")](this, Ow); |
| 1342 | } finally { |
| 1343 | !OH && delete E["__$$newTarget$$__"]; |
| 1344 | } |
| 1345 | } |
| 1346 | }), |
| 1347 | OX |
| 1348 | ); |
| 1349 | })(OO, Oc, Og); |
| 1350 | OO && |
| 1351 | Object[U(0x117, "SAmI")](OD, "name", { |
| 1352 | value: OO, |
| 1353 | configurable: !![], |
| 1354 | }); |
| 1355 | (by[U(0x69, "ID[x")](OD), bY++); |
| 1356 | break; |
| 1357 | } |
| 1358 | case bl[0x8d]: { |
| 1359 | const OR = by[U("0xae", "SAmI")](), |
| 1360 | Ot = by[by[U(0x65, "w1ba")] - 0x1]; |
| 1361 | (Object[U("0x118", "mJvw")]( |
| 1362 | Ot[U("0x119", "QmhY")], |
| 1363 | OR[U(0x11a, "d3%f")], |
| 1364 | ), |
| 1365 | Object[U(0x11b, "4$Y3")](Ot, OR), |
| 1366 | (Ot[U("0x11c", "T[d%")] = OR), |
| 1367 | bY++); |
| 1368 | break; |
| 1369 | } |
| 1370 | case bl[0x8e]: { |
| 1371 | let Oe = by[U(0xb1, "9sbv")](), |
| 1372 | OX = by[U("0xc7", "f#37")](), |
| 1373 | OH = Object[U(0x11d, "Ax7%")]( |
| 1374 | Object[U("0x11e", "y22^")](OX), |
| 1375 | ), |
| 1376 | Ow = Object[U(0x11f, "SI&j")](OH, Oe), |
| 1377 | Oz; |
| 1378 | Ow && Ow[U("0x120", "m]hN")] |
| 1379 | ? ((Oz = Ow[U("0x121", "Fu38")][U("0x122", "ID[x")](OX)), |
| 1380 | by[U("0xcf", "Ows7")](Oz)) |
| 1381 | : ((Oz = OH[Oe]), |
| 1382 | typeof Oz === "function" |
| 1383 | ? by[U(0x53, "@vun")](Oz[U(0x123, "W3hW")](OX)) |
| 1384 | : by[U("0xb2", "n[N$")](Oz)); |
| 1385 | bY++; |
| 1386 | break; |
| 1387 | } |
| 1388 | case bl[0x8f]: { |
| 1389 | const OK = by[U(0x124, "r]n&")](), |
| 1390 | OE = by[U(0xc7, "f#37")](), |
| 1391 | OP = by[U(0xc5, "NCda")](), |
| 1392 | Op = Object[U("0x125", "5zWX")]( |
| 1393 | Object[U("0x11d", "Ax7%")](OP), |
| 1394 | ); |
| 1395 | ((Op[OE] = OK), by[U(0xbe, "hHjw")](OK), bY++); |
| 1396 | break; |
| 1397 | } |
| 1398 | case bl[0x90]: { |
| 1399 | const Oo = by[U(0x109, "9fK8")](), |
| 1400 | ON = by[by[U(0x65, "w1ba")] - 0x1], |
| 1401 | OA = bd[UF]; |
| 1402 | (Object[U("0x126", "lw7j")](ON[U("0x127", "5zWX")], OA, { |
| 1403 | value: Oo, |
| 1404 | writable: !![], |
| 1405 | enumerable: ![], |
| 1406 | configurable: !![], |
| 1407 | }), |
| 1408 | bY++); |
| 1409 | break; |
| 1410 | } |
| 1411 | case bl[0x93]: { |
| 1412 | const OJ = by[U(0xd1, "C$TP")](), |
| 1413 | OL = by[by[U(0x128, "mJvw")] - 0x1], |
| 1414 | OV = bd[UF]; |
| 1415 | (Object[U(0x129, "9sbv")](OL, OV, { |
| 1416 | value: OJ, |
| 1417 | writable: !![], |
| 1418 | enumerable: ![], |
| 1419 | configurable: !![], |
| 1420 | }), |
| 1421 | bY++); |
| 1422 | break; |
| 1423 | } |
| 1424 | case bl[0x94]: { |
| 1425 | const On = by[U(0xca, "c(K]")](), |
| 1426 | OI = by[by[U("0x12a", "7C2)")] - 0x1], |
| 1427 | Os = bd[UF]; |
| 1428 | (Object[U(0x12b, "BeXe")](OI, Os, { |
| 1429 | get: On, |
| 1430 | enumerable: ![], |
| 1431 | configurable: !![], |
| 1432 | }), |
| 1433 | bY++); |
| 1434 | break; |
| 1435 | } |
| 1436 | case bl[0x95]: { |
| 1437 | const OC = by[U("0xd1", "C$TP")](), |
| 1438 | OG = by[by[U(0x12c, "C$TP")] - 0x1], |
| 1439 | Oj = bd[UF]; |
| 1440 | (Object[U(0x12d, "tO6Y")](OG, Oj, { |
| 1441 | set: OC, |
| 1442 | enumerable: ![], |
| 1443 | configurable: !![], |
| 1444 | }), |
| 1445 | bY++); |
| 1446 | break; |
| 1447 | } |
| 1448 | case bl[0xaa]: { |
| 1449 | const Oi = by[U("0xc7", "f#37")](), |
| 1450 | Ok = by[U("0x12e", "tO6Y")](), |
| 1451 | OF = by[by[U("0xe0", "IAcC")] - 0x1]; |
| 1452 | (Object[U("0x12f", "c(K]")](OF[U(0x110, "NCda")], Ok, { |
| 1453 | value: Oi, |
| 1454 | writable: !![], |
| 1455 | enumerable: ![], |
| 1456 | configurable: !![], |
| 1457 | }), |
| 1458 | bY++); |
| 1459 | break; |
| 1460 | } |
| 1461 | case bl[0xab]: { |
| 1462 | const Oq = by[U("0xd8", "oqaM")](), |
| 1463 | Ou = by[U(0xb9, "lw7j")](), |
| 1464 | Or = by[by[U(0x63, "m]hN")] - 0x1]; |
| 1465 | (Object[U(0x130, "SI&j")](Or, Ou, { |
| 1466 | value: Oq, |
| 1467 | writable: !![], |
| 1468 | enumerable: ![], |
| 1469 | configurable: !![], |
| 1470 | }), |
| 1471 | bY++); |
| 1472 | break; |
| 1473 | } |
| 1474 | case bl[0xac]: { |
| 1475 | const Om = by[U(0xb8, "(sPS")](), |
| 1476 | Oy = by[U(0xd4, "67gO")](), |
| 1477 | Oa = by[by[U("0x128", "mJvw")] - 0x1], |
| 1478 | OY = |
| 1479 | typeof Oa === "function" && Oa[U(0x131, "(sPS")] |
| 1480 | ? Oa[U("0x110", "NCda")] |
| 1481 | : Oa; |
| 1482 | (Object[U(0x132, "Fu38")](OY, Oy, { |
| 1483 | get: Om, |
| 1484 | enumerable: OY === Oa, |
| 1485 | configurable: !![], |
| 1486 | }), |
| 1487 | bY++); |
| 1488 | break; |
| 1489 | } |
| 1490 | case bl[0xad]: { |
| 1491 | const Od = by[U(0xb6, "Fu38")](), |
| 1492 | OW = by[U("0x133", "^HLG")](), |
| 1493 | OT = by[by[U("0x8a", "9fK8")] - 0x1], |
| 1494 | OM = |
| 1495 | typeof OT === "function" && OT[U(0x134, "mj6Y")] |
| 1496 | ? OT[U("0x119", "QmhY")] |
| 1497 | : OT; |
| 1498 | (Object[U("0x129", "9sbv")](OM, OW, { |
| 1499 | set: Od, |
| 1500 | enumerable: OM === OT, |
| 1501 | configurable: !![], |
| 1502 | }), |
| 1503 | bY++); |
| 1504 | break; |
| 1505 | } |
| 1506 | case bl[0xae]: { |
| 1507 | const OQ = by[U(0x12e, "tO6Y")](), |
| 1508 | OS = by[U("0xd6", "CJ!h")](), |
| 1509 | Ov = by[by[U("0x12a", "7C2)")] - 0x1]; |
| 1510 | (Object[U("0x135", "^u[%")](Ov, OS, { |
| 1511 | get: OQ, |
| 1512 | enumerable: ![], |
| 1513 | configurable: !![], |
| 1514 | }), |
| 1515 | bY++); |
| 1516 | break; |
| 1517 | } |
| 1518 | case bl[0xaf]: { |
| 1519 | const Of = by[U("0x76", "@vun")](), |
| 1520 | OB = by[U(0xb3, "QmhY")](), |
| 1521 | Oh = by[by[U(0x10b, "F!70")] - 0x1]; |
| 1522 | (Object[U("0x136", "NCda")](Oh, OB, { |
| 1523 | set: Of, |
| 1524 | enumerable: ![], |
| 1525 | configurable: !![], |
| 1526 | }), |
| 1527 | bY++); |
| 1528 | break; |
| 1529 | } |
| 1530 | case bl[0x69]: { |
| 1531 | const Ol = by[U(0x137, "Gx#q")](), |
| 1532 | Ox = b4(by, Ol), |
| 1533 | c0 = by[U("0x95", "waD0")](); |
| 1534 | if (UF === 0x1) { |
| 1535 | (by[U(0xb5, "SI&j")](Ox), bY++); |
| 1536 | break; |
| 1537 | } |
| 1538 | if (typeof c0 !== "function") |
| 1539 | throw new TypeError( |
| 1540 | "Super expression must be a constructor", |
| 1541 | ); |
| 1542 | E["__$$newTarget$$__"] = br; |
| 1543 | try { |
| 1544 | c0[U("0x138", "lw7j")](bm, Ox); |
| 1545 | } finally { |
| 1546 | delete E["__$$newTarget$$__"]; |
| 1547 | } |
| 1548 | bY++; |
| 1549 | break; |
| 1550 | } |
| 1551 | case bl[0x64]: { |
| 1552 | const c1 = by[U("0xae", "SAmI")](), |
| 1553 | c2 = b2(c1), |
| 1554 | c3 = c2 && c2[A["a"]], |
| 1555 | c4 = c2 && c2[A["s"]], |
| 1556 | c5 = c2 && c2[A["g"]], |
| 1557 | c6 = U5, |
| 1558 | c7 = bG, |
| 1559 | c8 = bj, |
| 1560 | c9 = bi, |
| 1561 | cb = |
| 1562 | c2 && c2[A["ni"]] !== undefined |
| 1563 | ? c2[A["c"]][c2[A["ni"]]] |
| 1564 | : undefined, |
| 1565 | cU = ((cZ, cO, cc, cg, cD, cR, ct, ce, cX) => { |
| 1566 | let cH, cw; |
| 1567 | if (cD) |
| 1568 | cw = function () { |
| 1569 | const cz = []; |
| 1570 | for ( |
| 1571 | let cK = 0x0; |
| 1572 | cK < arguments[U(0x10b, "F!70")]; |
| 1573 | cK++ |
| 1574 | ) { |
| 1575 | cz[U("0xaa", "mj6Y")](arguments[cK]); |
| 1576 | } |
| 1577 | return ce[U(0x139, "F!70")](this, cZ, cz, cO, cH); |
| 1578 | }; |
| 1579 | else |
| 1580 | cg |
| 1581 | ? (cw = async function () { |
| 1582 | const cz = []; |
| 1583 | for ( |
| 1584 | let cE = 0x0; |
| 1585 | cE < arguments[U(0x12a, "7C2)")]; |
| 1586 | cE++ |
| 1587 | ) { |
| 1588 | cz[U(0xa4, "d3%f")](arguments[cE]); |
| 1589 | } |
| 1590 | const cK = |
| 1591 | new.target !== undefined |
| 1592 | ? new.target |
| 1593 | : E["__$$newTarget$$__"]; |
| 1594 | return cc |
| 1595 | ? await ct(cZ, cz, cO, cH, undefined) |
| 1596 | : await ct[U(0x13a, "^u[%")]( |
| 1597 | this, |
| 1598 | cZ, |
| 1599 | cz, |
| 1600 | cO, |
| 1601 | cH, |
| 1602 | cK, |
| 1603 | ); |
| 1604 | }) |
| 1605 | : (cw = function () { |
| 1606 | const cz = []; |
| 1607 | for ( |
| 1608 | let cE = 0x0; |
| 1609 | cE < arguments[U("0x13b", "@vun")]; |
| 1610 | cE++ |
| 1611 | ) { |
| 1612 | cz[U(0x53, "@vun")](arguments[cE]); |
| 1613 | } |
| 1614 | const cK = |
| 1615 | new.target !== undefined |
| 1616 | ? new.target |
| 1617 | : E["__$$newTarget$$__"]; |
| 1618 | return cc |
| 1619 | ? cR(cZ, cz, cO, cH, undefined) |
| 1620 | : cR[U(0x13c, "c(K]")]( |
| 1621 | this, |
| 1622 | cZ, |
| 1623 | cz, |
| 1624 | cO, |
| 1625 | cH, |
| 1626 | cK, |
| 1627 | ); |
| 1628 | }); |
| 1629 | cH = cw; |
| 1630 | if (cX) |
| 1631 | try { |
| 1632 | Object[U(0x13d, "mJvw")](cH, "name", { |
| 1633 | value: cX, |
| 1634 | writable: ![], |
| 1635 | enumerable: ![], |
| 1636 | configurable: !![], |
| 1637 | }); |
| 1638 | } catch (cz) {} |
| 1639 | return cH; |
| 1640 | })(c1, c6, c3, c4, c5, c7, c8, c9, cb); |
| 1641 | if (!cU) |
| 1642 | throw new Error( |
| 1643 | "VM Error: Failed to create closure for bytecode ID " + |
| 1644 | c1, |
| 1645 | ); |
| 1646 | (by[U("0xf2", "IAcC")](cU), bY++); |
| 1647 | break; |
| 1648 | } |
| 1649 | case bl[0x68]: { |
| 1650 | const cZ = by[U(0xba, "W3hW")](), |
| 1651 | cO = b4(by, cZ), |
| 1652 | cc = by[U("0x13e", "f(J&")](); |
| 1653 | if (typeof cc !== "function") |
| 1654 | throw new TypeError(cc + " is not a constructor"); |
| 1655 | const cg = Reflect[U(0x13f, "n[N$")](cc, cO); |
| 1656 | (by[U("0x5a", "F!70")](cg), bY++); |
| 1657 | break; |
| 1658 | } |
| 1659 | case bl[0x5a]: { |
| 1660 | (by[U(0xa1, "CJ!h")]([]), bY++); |
| 1661 | break; |
| 1662 | } |
| 1663 | case bl[0x5b]: { |
| 1664 | const cD = by[U("0xa0", "ID[x")](), |
| 1665 | cR = by[by[U(0x61, "d3%f")] - 0x1]; |
| 1666 | (cR[U(0x140, "QmhY")](cD), bY++); |
| 1667 | break; |
| 1668 | } |
| 1669 | case bl[0x5d]: { |
| 1670 | const ct = by[U("0xba", "W3hW")](); |
| 1671 | (by[U(0xc9, "w1ba")]({ __spread__: !![], value: ct }), bY++); |
| 1672 | break; |
| 1673 | } |
| 1674 | case bl[0x5e]: { |
| 1675 | const ce = by[U(0x9e, "Ows7")](), |
| 1676 | cX = by[by[U(0x61, "d3%f")] - 0x1]; |
| 1677 | if (Array[U(0x141, "lw7j")](ce)) |
| 1678 | Array[U("0x142", "9sbv")][U("0x143", "QeOg")][ |
| 1679 | U("0x144", "f#37") |
| 1680 | ](cX, ce); |
| 1681 | else |
| 1682 | for (const cH of ce) { |
| 1683 | cX[U(0x145, "5zWX")](cH); |
| 1684 | } |
| 1685 | bY++; |
| 1686 | break; |
| 1687 | } |
| 1688 | case bl[0x6e]: { |
| 1689 | (by[U("0xbe", "hHjw")](typeof by[U("0x137", "Gx#q")]()), |
| 1690 | bY++); |
| 1691 | break; |
| 1692 | } |
| 1693 | case bl[0x6f]: { |
| 1694 | const cw = by[U("0xd8", "oqaM")](), |
| 1695 | cz = by[U(0x146, "T[d%")](); |
| 1696 | (by[U("0x69", "ID[x")](cz instanceof cw), bY++); |
| 1697 | break; |
| 1698 | } |
| 1699 | case bl[0x70]: { |
| 1700 | const cK = bd[UF], |
| 1701 | cE = |
| 1702 | typeof globalThis !== "undefined" |
| 1703 | ? globalThis |
| 1704 | : typeof window !== "undefined" |
| 1705 | ? window |
| 1706 | : global; |
| 1707 | if (cK in E) by[U("0xb2", "n[N$")](typeof E[cK]); |
| 1708 | else |
| 1709 | P && cK in P |
| 1710 | ? by[U(0xcc, "NCda")](typeof P[cK]) |
| 1711 | : by[U("0x8f", "$M$P")](typeof cE[cK]); |
| 1712 | bY++; |
| 1713 | break; |
| 1714 | } |
| 1715 | case bl[0xd2]: { |
| 1716 | const cP = by[U(0x76, "@vun")](), |
| 1717 | cp = { vars: {}, constVars: {}, tdzVars: {}, parent: cP }; |
| 1718 | ((U5 = cp), bY++); |
| 1719 | break; |
| 1720 | } |
| 1721 | case bl[0xd3]: { |
| 1722 | let co = bd[UF], |
| 1723 | cN = U5, |
| 1724 | cA, |
| 1725 | cJ = ![]; |
| 1726 | while (cN) { |
| 1727 | if (cN[U(0x147, "$M$P")] && co in cN[U(0x148, "ID[x")]) |
| 1728 | throw new ReferenceError( |
| 1729 | "Cannot access '" + co + "' before initialization", |
| 1730 | ); |
| 1731 | if (co in cN[U("0x149", "r]n&")]) { |
| 1732 | ((cA = cN[U(0x14a, "NCda")][co]), (cJ = !![])); |
| 1733 | break; |
| 1734 | } |
| 1735 | cN = cN[U(0x14b, "Gx#q")]; |
| 1736 | } |
| 1737 | if (!cJ) { |
| 1738 | if (co in E) cA = E[co]; |
| 1739 | else |
| 1740 | P && co in P |
| 1741 | ? (cA = P[co]) |
| 1742 | : (cA = ( |
| 1743 | typeof globalThis !== "undefined" |
| 1744 | ? globalThis |
| 1745 | : typeof window !== "undefined" |
| 1746 | ? window |
| 1747 | : global |
| 1748 | )[co]); |
| 1749 | } |
| 1750 | (by[U("0x14c", "z4r4")](cA), bY++); |
| 1751 | break; |
| 1752 | } |
| 1753 | case bl[0xd4]: { |
| 1754 | let cL = bd[UF], |
| 1755 | cV = by[U("0xad", "Wtwi")](), |
| 1756 | cn = U5, |
| 1757 | cI = ![]; |
| 1758 | while (cn) { |
| 1759 | if (cL in cn[U(0x14d, "67gO")]) { |
| 1760 | if (cn[U(0x14e, "^HLG")] && cL in cn[U("0x14f", "@TcF")]) |
| 1761 | throw new TypeError("Assignment to constant variable."); |
| 1762 | cn[U("0x150", "y22^")] && |
| 1763 | cL in cn[U("0x151", "5zWX")] && |
| 1764 | delete cn[U(0x152, "w1ba")][cL]; |
| 1765 | ((cn[U("0x153", "BeXe")][cL] = cV), (cI = !![])); |
| 1766 | break; |
| 1767 | } |
| 1768 | cn = cn[U("0x154", "IAcC")]; |
| 1769 | } |
| 1770 | !cI && |
| 1771 | (U5[U(0x155, "r]n&")] && |
| 1772 | cL in U5[U("0x148", "ID[x")] && |
| 1773 | delete U5[U("0x156", "NCda")][cL], |
| 1774 | (U5[U(0x157, "T[d%")][cL] = cV)); |
| 1775 | bY++; |
| 1776 | break; |
| 1777 | } |
| 1778 | case bl[0xd5]: { |
| 1779 | (by[U(0xbd, "Gx#q")](U5), bY++); |
| 1780 | break; |
| 1781 | } |
| 1782 | case bl[0xd6]: { |
| 1783 | U5 && U5[U("0x158", "9sbv")] && (U5 = U5[U("0x159", "CJ!h")]); |
| 1784 | bY++; |
| 1785 | break; |
| 1786 | } |
| 1787 | case bl[0xd7]: { |
| 1788 | const cs = bd[UF], |
| 1789 | cC = by[U(0xd0, "^u[%")](); |
| 1790 | if (U5[U("0x155", "r]n&")]) { |
| 1791 | cs in U5[U("0x15a", "^HLG")] && |
| 1792 | delete U5[U("0x15b", "SI&j")][cs]; |
| 1793 | const cG = cs[U("0x15c", "f#37")]("$$")[0x0]; |
| 1794 | cG !== cs && |
| 1795 | cG in U5[U(0x148, "ID[x")] && |
| 1796 | delete U5[U("0x15d", "T[d%")][cG]; |
| 1797 | } |
| 1798 | ((U5[U("0x15e", "9HM@")][cs] = cC), bY++); |
| 1799 | break; |
| 1800 | } |
| 1801 | case bl[0xd8]: { |
| 1802 | let cj = bd[UF], |
| 1803 | ci = by[U("0x15f", "$M$P")](), |
| 1804 | ck = U5, |
| 1805 | cF = ![]; |
| 1806 | while (ck) { |
| 1807 | if (cj in ck[U(0x160, "n[N$")]) { |
| 1808 | if (ck[U("0x161", "f#37")] && cj in ck[U(0x162, "^u[%")]) |
| 1809 | break; |
| 1810 | ck[U(0x14d, "67gO")][cj] = ci; |
| 1811 | !ck[U(0x163, "waD0")] && (ck[U(0x164, "C$TP")] = {}); |
| 1812 | ((ck[U("0x165", "z4r4")][cj] = !![]), (cF = !![])); |
| 1813 | break; |
| 1814 | } |
| 1815 | ck = ck[U("0x166", "y22^")]; |
| 1816 | } |
| 1817 | !cF && |
| 1818 | (U5[U("0x167", "mj6Y")] && |
| 1819 | cj in U5[U(0x168, "QeOg")] && |
| 1820 | delete U5[U(0x169, "9sbv")][cj], |
| 1821 | (U5[U(0x16a, "y22^")][cj] = ci), |
| 1822 | !U5[U("0x16b", "CJ!h")] && (U5[U("0x16c", "W3hW")] = {}), |
| 1823 | (U5[U(0x16d, "NCda")][cj] = !![])); |
| 1824 | bY++; |
| 1825 | break; |
| 1826 | } |
| 1827 | case bl[0xd9]: { |
| 1828 | const cq = bd[UF], |
| 1829 | cu = by[U(0x103, "BeXe")](); |
| 1830 | if (U5[U(0x16e, "c(K]")]) { |
| 1831 | cq in U5[U(0x169, "9sbv")] && |
| 1832 | delete U5[U(0x15b, "SI&j")][cq]; |
| 1833 | const cr = cq[U("0x16f", "waD0")]("$$")[0x0]; |
| 1834 | cr !== cq && |
| 1835 | cr in U5[U(0x170, "4$Y3")] && |
| 1836 | delete U5[U(0x171, "W3hW")][cr]; |
| 1837 | } |
| 1838 | U5[U(0x172, "@vun")][cq] = cu; |
| 1839 | !U5[U(0x173, "Ax7%")] && (U5[U("0x174", "4$Y3")] = {}); |
| 1840 | ((U5[U(0x175, "Gx#q")][cq] = !![]), bY++); |
| 1841 | break; |
| 1842 | } |
| 1843 | case bl[0xda]: { |
| 1844 | const cm = bd[UF]; |
| 1845 | !U5[U(0x168, "QeOg")] && (U5[U(0x176, "BeXe")] = {}); |
| 1846 | ((U5[U("0x148", "ID[x")][cm] = !![]), bY++); |
| 1847 | break; |
| 1848 | } |
| 1849 | case bl[0xa0]: { |
| 1850 | (by[U("0xb2", "n[N$")](bm), bY++); |
| 1851 | break; |
| 1852 | } |
| 1853 | case bl[0xa1]: { |
| 1854 | const cy = Array[U(0x142, "9sbv")][U("0x177", "f(J&")][ |
| 1855 | U(0x178, "SAmI") |
| 1856 | ](bF || []); |
| 1857 | ((cy[U(0x179, "NCda")] = bu), by[U(0xac, "oqaM")](cy), bY++); |
| 1858 | break; |
| 1859 | } |
| 1860 | case bl[0xa4]: { |
| 1861 | (by[U(0x106, "!a8Q")](br), bY++); |
| 1862 | break; |
| 1863 | } |
| 1864 | case bl[0xa2]: { |
| 1865 | const ca = UF & 0xffff, |
| 1866 | cY = UF >> 0x10, |
| 1867 | cd = bd[ca], |
| 1868 | cW = bd[cY]; |
| 1869 | (by[U("0xaf", "C$TP")](new RegExp(cd, cW)), bY++); |
| 1870 | break; |
| 1871 | } |
| 1872 | case bl[0xa3]: { |
| 1873 | (by[U("0xad", "Wtwi")](), |
| 1874 | by[U("0x104", "^HLG")](undefined), |
| 1875 | bY++); |
| 1876 | break; |
| 1877 | } |
| 1878 | case bl[0xa7]: { |
| 1879 | if (UF === -0x1) by[U(0xaa, "mj6Y")](Symbol()); |
| 1880 | else { |
| 1881 | const cT = by[U("0xbf", "F!70")](); |
| 1882 | by[U("0x7c", "4$Y3")](Symbol(cT)); |
| 1883 | } |
| 1884 | bY++; |
| 1885 | break; |
| 1886 | } |
| 1887 | case bl[0xa8]: { |
| 1888 | const cM = bd[UF]; |
| 1889 | (by[U(0xac, "oqaM")](Symbol[U(0x17a, "f#37")](cM)), bY++); |
| 1890 | break; |
| 1891 | } |
| 1892 | case bl[0xa9]: { |
| 1893 | const cQ = by[U(0x17b, "QeOg")](); |
| 1894 | (by[U("0xc9", "w1ba")](Symbol[U(0x17c, "^u[%")](cQ)), bY++); |
| 1895 | break; |
| 1896 | } |
| 1897 | case bl[0xaa]: { |
| 1898 | bY++; |
| 1899 | break; |
| 1900 | } |
| 1901 | case bl[0xc8]: { |
| 1902 | debugger; |
| 1903 | bY++; |
| 1904 | break; |
| 1905 | } |
| 1906 | case bl[0xc9]: { |
| 1907 | bY++; |
| 1908 | break; |
| 1909 | } |
| 1910 | case bl[0xca]: { |
| 1911 | ((U7 = !![]), |
| 1912 | (U8 = |
| 1913 | by[U("0x17d", "ID[x")] > 0x0 |
| 1914 | ? by[U(0xb8, "(sPS")]() |
| 1915 | : undefined)); |
| 1916 | return; |
| 1917 | } |
| 1918 | case bl[0x7f]: { |
| 1919 | const cS = by[U("0x103", "BeXe")](); |
| 1920 | if (cS == null) |
| 1921 | throw new TypeError("Cannot iterate over " + cS); |
| 1922 | const cv = cS[Symbol[U("0x17e", "Gx#q")]]; |
| 1923 | if (typeof cv !== "function") |
| 1924 | throw new TypeError("Object is not iterable"); |
| 1925 | (by[U("0x17f", "67gO")](cv[U(0x180, "hHjw")](cS)), bY++); |
| 1926 | break; |
| 1927 | } |
| 1928 | case bl[0x7b]: { |
| 1929 | const cf = by[U(0xc7, "f#37")](), |
| 1930 | cB = cf[U("0x181", "waD0")](); |
| 1931 | (by[U("0x104", "^HLG")](cB), bY++); |
| 1932 | break; |
| 1933 | } |
| 1934 | case bl[0x80]: { |
| 1935 | const ch = by[U("0xb3", "QmhY")](); |
| 1936 | (by[U(0x106, "!a8Q")](!!ch[U(0x182, "@TcF")]), bY++); |
| 1937 | break; |
| 1938 | } |
| 1939 | case bl[0xfa]: { |
| 1940 | ((ba[UF] = ba[UF] + 0x1), bY++); |
| 1941 | break; |
| 1942 | } |
| 1943 | case bl[0xfb]: { |
| 1944 | ((ba[UF] = ba[UF] - 0x1), bY++); |
| 1945 | break; |
| 1946 | } |
| 1947 | case bl[0xfc]: { |
| 1948 | const cl = UF & 0xffff, |
| 1949 | cx = UF >>> 0x10; |
| 1950 | (by[U("0x53", "@vun")](ba[cl] + bd[cx]), bY++); |
| 1951 | break; |
| 1952 | } |
| 1953 | case bl[0xfd]: { |
| 1954 | const g0 = UF & 0xffff, |
| 1955 | g1 = UF >>> 0x10; |
| 1956 | (by[U("0xc6", "waD0")](ba[g0] - bd[g1]), bY++); |
| 1957 | break; |
| 1958 | } |
| 1959 | case bl[0xfe]: { |
| 1960 | const g2 = UF & 0xffff, |
| 1961 | g3 = UF >>> 0x10; |
| 1962 | (by[U("0x107", "y22^")](ba[g2] * bd[g3]), bY++); |
| 1963 | break; |
| 1964 | } |
| 1965 | case bl[0xff]: { |
| 1966 | const g4 = UF & 0xffff, |
| 1967 | g5 = UF >>> 0x10, |
| 1968 | g6 = ba[g4], |
| 1969 | g7 = bd[g5]; |
| 1970 | (by[U("0x143", "QeOg")](g6[g7]), bY++); |
| 1971 | break; |
| 1972 | } |
| 1973 | case bl[0x100]: { |
| 1974 | const g8 = UF & 0xffff, |
| 1975 | g9 = UF >>> 0x10; |
| 1976 | (by[U(0xd9, "f(J&")](ba[g8] < bd[g9]), bY++); |
| 1977 | break; |
| 1978 | } |
| 1979 | case bl[0x101]: { |
| 1980 | const gb = UF & 0xffff, |
| 1981 | gU = UF >>> 0x10; |
| 1982 | ba[gb] < bd[gU] ? (bY = U3(bT[bY])) : bY++; |
| 1983 | break; |
| 1984 | } |
| 1985 | case bl[0x102]: { |
| 1986 | const gZ = UF & 0xffff, |
| 1987 | gO = UF >>> 0x10, |
| 1988 | gc = by[U("0x183", "JGtS")](), |
| 1989 | gg = b4(by, gc), |
| 1990 | gD = ba[gZ], |
| 1991 | gR = bd[gO], |
| 1992 | gt = gD[gR]; |
| 1993 | (by[U(0x14c, "z4r4")](gt[U(0x116, "QeOg")](gD, gg)), bY++); |
| 1994 | break; |
| 1995 | } |
| 1996 | case bl[0x103]: { |
| 1997 | ((ba[UF] = by[U("0xd3", "IAcC")]()), bY++); |
| 1998 | break; |
| 1999 | } |
| 2000 | case bl[0x104]: { |
| 2001 | const ge = ba[UF] + 0x1; |
| 2002 | ((ba[UF] = ge), by[U(0xcc, "NCda")](ge), bY++); |
| 2003 | break; |
| 2004 | } |
| 2005 | case bl[0x105]: { |
| 2006 | const gX = ba[UF] - 0x1; |
| 2007 | ((ba[UF] = gX), by[U(0x106, "!a8Q")](gX), bY++); |
| 2008 | break; |
| 2009 | } |
| 2010 | default: |
| 2011 | throw new Error( |
| 2012 | "Unknown opcode: " + UN + " (logical: " + Uo + ")", |
| 2013 | ); |
| 2014 | } |
| 2015 | }; |
| 2016 | for (var UZ in bl) { |
| 2017 | bl[U("0x184", "4$Y3")](UZ) && |
| 2018 | ((Ui) => { |
| 2019 | U9[Ub[Ui]] = (Uk) => { |
| 2020 | UR(Ui, Uk); |
| 2021 | }; |
| 2022 | })(bl[UZ]); |
| 2023 | } |
| 2024 | } |
| 2025 | U9[Ub[UN]](UJ); |
| 2026 | if (U7) return ((U7 = ![]), U8); |
| 2027 | } |
| 2028 | break; |
| 2029 | } catch (Ui) { |
| 2030 | if (bS[U(0x39, "9sbv")] > 0x0) { |
| 2031 | const Uk = bS[bS[U(0xf4, "W3hW")] - 0x1]; |
| 2032 | by[U("0x185", "hHjw")] = Uk[U("0x186", "^u[%")]; |
| 2033 | if (Uk[U("0x187", "QeOg")] !== undefined) |
| 2034 | (by[U("0xcf", "Ows7")](Ui), |
| 2035 | (bY = Uk[U("0x188", "$M$P")]), |
| 2036 | (Uk[U(0x189, "waD0")] = undefined), |
| 2037 | Uk[U(0x18a, "w1ba")] === undefined && bS[U(0xae, "SAmI")]()); |
| 2038 | else |
| 2039 | Uk[U(0x18a, "w1ba")] !== undefined |
| 2040 | ? ((bY = Uk[U(0x18b, "tO6Y")]), (Uk[U(0x18c, "ID[x")] = Ui)) |
| 2041 | : ((bY = Uk[U("0x18d", "T[d%")]), bS[U(0x95, "waD0")]()); |
| 2042 | continue; |
| 2043 | } |
| 2044 | throw Ui; |
| 2045 | } |
| 2046 | } |
| 2047 | return by[U("0x65", "w1ba")] > 0x0 ? by[U(0xd0, "^u[%")]() : undefined; |
| 2048 | } |
| 2049 | |
| 2050 | const bG = function (bk, bF, bq, bu, br) { |
| 2051 | const bm = b2(bk), |
| 2052 | by = bC(bm, bF, bq, bu, br, this), |
| 2053 | ba = by[U(0x18e, "mj6Y")](); |
| 2054 | while (!ba[U("0x18f", "d3%f")]) { |
| 2055 | throw new Error("Unexpected async/generator operation in sync context"); |
| 2056 | } |
| 2057 | return ba[U(0x190, "r]n&")]; |
| 2058 | }, |
| 2059 | bj = async function (bk, bF, bq, bu, br) { |
| 2060 | let bm = b2(bk), |
| 2061 | by = bC(bm, bF, bq, bu, br, this), |
| 2062 | ba = by[U("0x191", "w1ba")](); |
| 2063 | while (!ba[U("0x192", "w1ba")]) { |
| 2064 | if (ba[U("0x193", "5zWX")]["t"] === 0x1) |
| 2065 | try { |
| 2066 | const bY = await Promise[U(0x194, "SI&j")]( |
| 2067 | ba[U(0x195, "d3%f")]["v"], |
| 2068 | ); |
| 2069 | ba = by[U("0x196", "SAmI")](bY); |
| 2070 | } catch (bd) { |
| 2071 | ba = by[U("0x197", "QeOg")](bd); |
| 2072 | } |
| 2073 | else throw new Error("Unexpected yield in async context"); |
| 2074 | } |
| 2075 | return ba[U("0x198", "y22^")]; |
| 2076 | }, |
| 2077 | bi = function (bk, bF, bq, bu) { |
| 2078 | let br = b2(bk), |
| 2079 | bm = bC(br, bF, bq, bu, undefined, this), |
| 2080 | by = ![], |
| 2081 | ba = null; |
| 2082 | |
| 2083 | function bd(bT, bM) { |
| 2084 | if (by) return { value: undefined, done: !![] }; |
| 2085 | if (ba) { |
| 2086 | let bS; |
| 2087 | try { |
| 2088 | bS = bM |
| 2089 | ? typeof ba[U(0x199, "w1ba")] === "function" |
| 2090 | ? ba[U("0x19a", "C$TP")](bT) |
| 2091 | : ((ba = null), |
| 2092 | (() => { |
| 2093 | throw bT; |
| 2094 | })()) |
| 2095 | : ba[U("0x19b", "m]hN")](bT); |
| 2096 | } catch (bv) { |
| 2097 | ba = null; |
| 2098 | try { |
| 2099 | const bf = bm[U("0x19c", "^HLG")](bv); |
| 2100 | return bW(bf); |
| 2101 | } catch (bB) { |
| 2102 | by = !![]; |
| 2103 | throw bB; |
| 2104 | } |
| 2105 | } |
| 2106 | if (!bS[U(0x19d, "r]n&")]) |
| 2107 | return { value: bS[U(0x19e, "JGtS")], done: ![] }; |
| 2108 | ((ba = null), (bT = bS[U("0x19f", "tO6Y")]), (bM = ![])); |
| 2109 | } |
| 2110 | let bQ; |
| 2111 | try { |
| 2112 | bQ = bM ? bm[U("0x1a0", "z4r4")](bT) : bm[U("0x1a1", "@TcF")](bT); |
| 2113 | } catch (bh) { |
| 2114 | by = !![]; |
| 2115 | throw bh; |
| 2116 | } |
| 2117 | return bW(bQ); |
| 2118 | } |
| 2119 | |
| 2120 | function bW(bT) { |
| 2121 | if (bT[U(0x1a2, "4$Y3")]) |
| 2122 | return ((by = !![]), { value: bT[U("0x19f", "tO6Y")], done: !![] }); |
| 2123 | const bM = bT[U(0x195, "d3%f")]; |
| 2124 | if (bM["t"] === 0x2) return { value: bM["v"], done: ![] }; |
| 2125 | if (bM["t"] === 0x3) { |
| 2126 | let bQ = bM["v"], |
| 2127 | bS = bQ; |
| 2128 | bS && |
| 2129 | typeof bS[Symbol[U(0x1a3, "^u[%")]] === "function" && |
| 2130 | (bS = bS[Symbol[U(0x1a4, "JGtS")]]()); |
| 2131 | if (bS && typeof bS[U("0x1a5", "Ows7")] === "function") { |
| 2132 | const bv = bS[U("0x18e", "mj6Y")](); |
| 2133 | if (!bv[U("0x1a6", "QeOg")]) |
| 2134 | return ((ba = bS), { value: bv[U(0x1a7, "w1ba")], done: ![] }); |
| 2135 | return bd(bv[U(0x1a8, "lw7j")], ![]); |
| 2136 | } |
| 2137 | return bd(undefined, ![]); |
| 2138 | } |
| 2139 | throw new Error("Unexpected signal in generator"); |
| 2140 | } |
| 2141 | |
| 2142 | return { |
| 2143 | next: (bT) => bd(bT, ![]), |
| 2144 | return: (bT) => { |
| 2145 | if (by) return { value: bT, done: !![] }; |
| 2146 | by = !![]; |
| 2147 | try { |
| 2148 | bm[U("0x1a9", "^u[%")](bT); |
| 2149 | } catch (bM) {} |
| 2150 | return { value: bT, done: !![] }; |
| 2151 | }, |
| 2152 | throw: (bT) => { |
| 2153 | if (by) throw bT; |
| 2154 | return bd(bT, !![]); |
| 2155 | }, |
| 2156 | [Symbol[U("0x1aa", "mj6Y")]]: function () { |
| 2157 | return this; |
| 2158 | }, |
| 2159 | }; |
| 2160 | }; |
| 2161 | return function (bk, bF, bq, bu, br) { |
| 2162 | const bm = b2(bk); |
| 2163 | if (bm && bm[A["g"]]) return bi[U("0x139", "F!70")](this, bk, bF, bq, bu); |
| 2164 | else |
| 2165 | return bm && bm[A["s"]] |
| 2166 | ? bj[U(0x1ab, "lw7j")](this, bk, bF, bq, bu, br) |
| 2167 | : bG[U(0x1ac, "f#37")](this, bk, bF, bq, bu, br); |
| 2168 | }; |
| 2169 | })(); |
| 2170 | E[U(0x1ad, "(sPS")] = o; |
| 2171 | |
| 2172 | function o(N, A) { |
| 2173 | return p[U("0x1ae", "f(J&")]( |
| 2174 | this, |
| 2175 | 0x0, |
| 2176 | Array[U(0x1af, "Wtwi")](arguments), |
| 2177 | undefined, |
| 2178 | o, |
| 2179 | ); |
| 2180 | } |
| 2181 | |
| 2182 | function b() { |
| 2183 | const gH = [ |
| 2184 | "D3StW5VcHG", |
| 2185 | "cSkAp8k8", |
| 2186 | "WOBcOmkeW5NdSW", |
| 2187 | "W7ddLY4t", |
| 2188 | "h3L0WO7cTW", |
| 2189 | "WQZdNSkoFJS", |
| 2190 | "WP7cPCk0bMq", |
| 2191 | "BCoaW7RdQq", |
| 2192 | "W44eWRxcHW", |
| 2193 | "WOT0ASoPb8oDeJK", |
| 2194 | "agX9WONcS1FcHSoF", |
| 2195 | "jrZdTSoK", |
| 2196 | "p3awsq", |
| 2197 | "WRNcU8kVxCo/", |
| 2198 | "ctTnrrq", |
| 2199 | "WPbLE8oUfmoh", |
| 2200 | "WOhcTCkFluHoWOe3", |
| 2201 | "hdTnxa", |
| 2202 | "C8k5zH4", |
| 2203 | "WOTBeaP0FmkoWQVdGSooW5fuDCoK", |
| 2204 | "bCoUj8kj", |
| 2205 | "cJZcRay", |
| 2206 | "WOT2WOu", |
| 2207 | "Ac9khCkNygPAWOtdTSkbWQi", |
| 2208 | "x8kNW5K9W7hdI8kb", |
| 2209 | "aSo1CCoMa1VcKgvig8of", |
| 2210 | "WRvZkJ0MgNNcISkF", |
| 2211 | "W5qmAmo4W4tcHJL3xmoeywm", |
| 2212 | "W6GEu2mVW5ZcU1ddJmotchHp", |
| 2213 | "W4ZcU8kFWOzot8kyW5jsWQeBW54m", |
| 2214 | "i8oUmKhdUSkTWQznw8obumobwG", |
| 2215 | "EYnfWOpcIdlcU2xdOSoieSkauCo3", |
| 2216 | "W6OwuMePW5RdH1RdVSoHafC", |
| 2217 | "W5fuWOpdTCk5qbi", |
| 2218 | "W77dRCo6g8kTW73dQ8kUd8ouvW", |
| 2219 | "W5ldTmoZusrCW6baW5b8WOZdNW", |
| 2220 | "aSo6E8oMba3dU3PKamocW5qQ", |
| 2221 | "W61ip3XXWPrcWORdOCo4W5K8WPe", |
| 2222 | "WQFcV8k1z2JcU0HDjSklW7xcHG4", |
| 2223 | "awbogNaFiHxdJXRcIelcTSon", |
| 2224 | "WPRdVCoj", |
| 2225 | "DComW6FdQG", |
| 2226 | "WO94BCkRW7va", |
| 2227 | "W7BdSmo5mrldRX5EbSk1", |
| 2228 | "WPRdSCoBW5y3gSocW4jvWOm", |
| 2229 | "WPpdHmo3", |
| 2230 | "WPjYymoVcCoDbdVcVq", |
| 2231 | "bSkkiq", |
| 2232 | "cCoPlq", |
| 2233 | "Bmomk3xdUX1DWP3cLq", |
| 2234 | "WP3dSmom", |
| 2235 | "emoMlSks", |
| 2236 | "gd9vzrGotIVdPG", |
| 2237 | "WQlcK8kG", |
| 2238 | "WRxdMCke", |
| 2239 | "W5DHWRitnmo6s8k6EW", |
| 2240 | "WRJdHSo0", |
| 2241 | "DxOeW4m", |
| 2242 | "WO9FcdXOFSkBW6ZcLq", |
| 2243 | "edXh", |
| 2244 | "hCk+WQVdLSogW4KJpeG", |
| 2245 | "WRbipq", |
| 2246 | "WRVcNmkJyW", |
| 2247 | "W4NcTK9NmI8Cna", |
| 2248 | "WODCgG", |
| 2249 | "WRzabG", |
| 2250 | "h3GG", |
| 2251 | "W6tdQfhdRa", |
| 2252 | "W4b2WQKHn8oHu8k+kmoJ", |
| 2253 | "WPFdRSoj", |
| 2254 | "WP1/zmk5W79gDJxcHG", |
| 2255 | "DCoeW7ddTaNdGa", |
| 2256 | "owCd", |
| 2257 | "dY9MySoZzG", |
| 2258 | "W6tcK3O", |
| 2259 | "CmojW6VdVGi", |
| 2260 | "W4hcTv0", |
| 2261 | "WQdcVmkL", |
| 2262 | "WOXFhWzLDq", |
| 2263 | "WP7cRCkyW5hdSmo0", |
| 2264 | "WRuEys4WW4W", |
| 2265 | "WQZcSSkIwSozW7xdNmkhb8oO", |
| 2266 | "W6hcIxy", |
| 2267 | "iYbd", |
| 2268 | "WPRcLmkL", |
| 2269 | "txC5", |
| 2270 | "WQNdI8kq", |
| 2271 | "gSkEW4O", |
| 2272 | "gMXQ", |
| 2273 | "WPHwmq", |
| 2274 | "zSk5EbVcOCoR", |
| 2275 | "W5fYWQ8onCo6", |
| 2276 | "qZ0Psszp", |
| 2277 | "WR7cMmkvyaXzWP4", |
| 2278 | "gN1tWP7cQW", |
| 2279 | "eSkEnCkHWOCt", |
| 2280 | "zCoRoa", |
| 2281 | "W7aJBGerjq", |
| 2282 | "h8klW4OhW6BdMq", |
| 2283 | "WOVdUSoZySoZW4u", |
| 2284 | "WO3cU8kD", |
| 2285 | "W6jHeG", |
| 2286 | "e8k8Eq", |
| 2287 | "fG4uW4lcRmoh", |
| 2288 | "lIXk", |
| 2289 | "phidW5ZdLxi", |
| 2290 | "WP0sDmkD", |
| 2291 | "prJdVmo5W7JcHa", |
| 2292 | "W6jJfG", |
| 2293 | "AIbt", |
| 2294 | "W4JdPq8", |
| 2295 | "WP55Eq", |
| 2296 | "hCk5WRFdIG", |
| 2297 | "WPXalSkO", |
| 2298 | "WPf4WPddJ8kUuG", |
| 2299 | "W7dcH24oW4GG", |
| 2300 | "rCkJoSk8wKG", |
| 2301 | "WQ9heJLXWPK", |
| 2302 | "emoUoCkmWRec", |
| 2303 | "qZWttYy", |
| 2304 | "W7S3tK0PWRy", |
| 2305 | "C8kWAWdcJSoR", |
| 2306 | "cmkAkCkVWP0p", |
| 2307 | "W6SJza", |
| 2308 | "WQpcV8kTt8oUW7i", |
| 2309 | "W7/dRmo0jW", |
| 2310 | "uMyLWPBcRSoW", |
| 2311 | "oMeEW4hdLhldScldNG", |
| 2312 | "hWWaCq", |
| 2313 | "W4lcTLvjkdm", |
| 2314 | "gCkyW5CAW6FdMCkryri", |
| 2315 | "txyPWOlcRSoQW6KPBG", |
| 2316 | "aCkPWQRdHCoDW5u", |
| 2317 | "v24+WP0", |
| 2318 | "ASoiW7FdSq", |
| 2319 | "gIz1ECoEFxtdNLeX", |
| 2320 | "WQhcKmkOCXLf", |
| 2321 | "acVcRqW3WRS", |
| 2322 | "WOSvAmkyfqJcS8k+tSoRC8kt", |
| 2323 | "WRPoasjCWOldP2BdQmo0", |
| 2324 | "gCkJWPFdLSoBW5q0kW", |
| 2325 | "WP0iDW", |
| 2326 | "xmo6W7hdRrxdKqNdTSo1WR4", |
| 2327 | "g8kTWQJdL8om", |
| 2328 | "i2aWW4FdIwFdSa", |
| 2329 | "WOT8WOZdGCk0tG", |
| 2330 | "WRTDDSoN", |
| 2331 | "W5OEWQJcIG", |
| 2332 | "hIVcTq4XWQaT", |
| 2333 | "a8kJWRm", |
| 2334 | "W68VAqq", |
| 2335 | "WOfxcqu", |
| 2336 | "mNinqa", |
| 2337 | "cWFdN8oR", |
| 2338 | "W4FcVK5c", |
| 2339 | "qcujra", |
| 2340 | "W7VdSNldSMDjxCkk", |
| 2341 | "W73dIWKyW6ZcP8kTWPSb", |
| 2342 | "wsm8rs1czeC", |
| 2343 | "WOfjnqD1DCkiWRRdLq", |
| 2344 | "WOfOzCkQW6rA", |
| 2345 | "x8kNjSkYqfq", |
| 2346 | "bCkpW5yjW7ZdHq", |
| 2347 | "W5KgWOJcH0FdMG", |
| 2348 | "WP5OqmkOW6K", |
| 2349 | "twyaWPtcOW", |
| 2350 | "WOJdVCoCW5S", |
| 2351 | "WP/dSSoVBW", |
| 2352 | "fmkqnW", |
| 2353 | "WO8oACkr", |
| 2354 | "WPtdQmohySoZW5GdW5C", |
| 2355 | "WRbvkt5RWOJdPgBdMW", |
| 2356 | "WPD2WPi", |
| 2357 | "bGO1Cmk/ie7dUq", |
| 2358 | "WRqsyq", |
| 2359 | "W6ONCG8loq", |
| 2360 | "emoUoCkw", |
| 2361 | "umkTjSkMqgRcOLTY", |
| 2362 | "W7hdRLRdQh12smkDzW", |
| 2363 | "WP/dJCo/lbbcW6lcOHa", |
| 2364 | "z3yhW53cN09Lmq3dL8omW7/cJCkm", |
| 2365 | "oXBdVG", |
| 2366 | "tNy4WPK", |
| 2367 | "hXyd", |
| 2368 | "oMycW50", |
| 2369 | "fNtcKG", |
| 2370 | "W67cH28OW5e6W44qA8k8mmoCWRhcVq", |
| 2371 | "W6CNu0i", |
| 2372 | "obxdP8oZW7m", |
| 2373 | "WRBdMSkmBcPT", |
| 2374 | "cIlcRaqX", |
| 2375 | "W5ZcSLvkmZy", |
| 2376 | "cN7cJc3dRCo/", |
| 2377 | "WPJcTmkjnW", |
| 2378 | "WOZdL8oInW", |
| 2379 | "gCkFW4Sg", |
| 2380 | "hchcSW", |
| 2381 | "WR3cMSk2", |
| 2382 | "C2ysW5W", |
| 2383 | "WQLteZG", |
| 2384 | "WQKuFW", |
| 2385 | "eH/dMCoV", |
| 2386 | "eaaw", |
| 2387 | "WQLjea", |
| 2388 | "WO3dRSoYyW", |
| 2389 | "tMW7", |
| 2390 | "WQRdISkryW", |
| 2391 | "WPHvda", |
| 2392 | "dZvr", |
| 2393 | "csfK", |
| 2394 | "C8oqW7hdTq", |
| 2395 | "WPJcRSkk", |
| 2396 | "WP14EmkL", |
| 2397 | "W6tdVmo+pa", |
| 2398 | "WPXAlq", |
| 2399 | "WPHpdWe", |
| 2400 | "WR/cTCkZ", |
| 2401 | "W6tdJtmE", |
| 2402 | "csfJ", |
| 2403 | "WR3cGmk1Fa", |
| 2404 | "W7yTBa", |
| 2405 | "WPDSWPhdJG", |
| 2406 | "ymk3EG", |
| 2407 | "WOZdJCoH", |
| 2408 | "WR/cR8kWqa", |
| 2409 | "W6ldRKq", |
| 2410 | "eGxdMG", |
| 2411 | "W7y3BWa", |
| 2412 | "WO3dTmoX", |
| 2413 | "qd8k", |
| 2414 | "oWZdVCo4", |
| 2415 | "WPjVFW", |
| 2416 | "C3Wr", |
| 2417 | "W6ldTeFdSW", |
| 2418 | "Bmorna", |
| 2419 | "W7BcIwW", |
| 2420 | "C8okW7i", |
| 2421 | "oNWb", |
| 2422 | "WRFcPCkk", |
| 2423 | "gCkfW4G", |
| 2424 | "fSo6omkn", |
| 2425 | "W6tdPSo9", |
| 2426 | "gw1RWPm", |
| 2427 | "WPRcOSk2", |
| 2428 | "W5D8WQ0", |
| 2429 | "WOVcVCk2bwO", |
| 2430 | "yMmrW5JcIa", |
| 2431 | "CmoBkMBdOae", |
| 2432 | "WOSoACkuoGZcQ8kfy8oGCSko", |
| 2433 | "cGVdMCovCCopW5/dRLK", |
| 2434 | "gI/cRX4M", |
| 2435 | "WO5teGHTFmkwWPBdICo6W4zf", |
| 2436 | "WO94WPhdTmkLuG7dOCou", |
| 2437 | "w8kJo8khuuJcTLTV", |
| 2438 | "fG4kW57cPW", |
| 2439 | "W7JdNs4rW6ZcQG", |
| 2440 | "d3f2WPRcVK/cKmoKW6ddSLhdRG", |
| 2441 | "W7ZdQmo+fI/dRbLg", |
| 2442 | "pXJdVmo3W7pcHa", |
| 2443 | "hYD6ASoXFMNdSN4HWRZcQa", |
| 2444 | "eZ9pvWui", |
| 2445 | "W6aRCGKtpupcHSk2tmoRnq", |
| 2446 | "WOvSEmkoW79CEYZcJvyj", |
| 2447 | "WPn4WPddGCkLuG", |
| 2448 | "DSkXzbpcO8oZW690CmoVxmoa", |
| 2449 | "Bmoln2K", |
| 2450 | "WQ8AFtO", |
| 2451 | "fsT6BmoPEG", |
| 2452 | "WQ1bA8oUlCoTCCkVtYpdSCkY", |
| 2453 | "fSoQjCkbWRyyBgVcRSkVWQtdPSoDesCz", |
| 2454 | "W5OoWRxcHKVdKmogp1qGpwycWOeInW", |
| 2455 | "WOugDmkNmXtcP8k+yW", |
| 2456 | "WPTSz8k4W7u", |
| 2457 | "bXGas8k0pu/dRLK", |
| 2458 | "WOVdUSoTFSo4", |
| 2459 | "W7ZdMtm0W6RcP8kRWPu", |
| 2460 | "WQnjDSonm8oKACkn", |
| 2461 | "W7iJBG8Ajq", |
| 2462 | "WOlcRmk1kNWhW5b8W5PSWQe", |
| 2463 | "WObBdYPUFSkBWRBdICoRW4y", |
| 2464 | "WONdUSoZBmo4W4u", |
| 2465 | "hdVcSam", |
| 2466 | "W57cVeS", |
| 2467 | "WOlcVCkfW54", |
| 2468 | "W5OeWQS", |
| 2469 | "W5DMWQ4p", |
| 2470 | "fM7cKsi", |
| 2471 | "WRHveZL4WOm", |
| 2472 | "q8kToa", |
| 2473 | "WPj1FmoZ", |
| 2474 | "WObqm8kNWOFdMW", |
| 2475 | "ymkQzqBcOmoRW69nEW", |
| 2476 | "hdZcRb8SWQCXsCk6", |
| 2477 | "p3OErCo/mN5XWRZdP8kIWQRdP8ok", |
| 2478 | "WQVcR8kuW7ZcK8oh", |
| 2479 | "W7yWCXWqjupcV8k9", |
| 2480 | "hWSCBCk+pupdRfi", |
| 2481 | "WQ9ny8oMl8oKwmkutJFdSCk4Dvm", |
| 2482 | "WO5LyCo8eSob", |
| 2483 | "b2VcKIBdOa", |
| 2484 | "WQDnA8oOnCoP", |
| 2485 | "oM8iqmoO", |
| 2486 | "WQNcKmkGFqniWQSlsCkwW5W/FSoH", |
| 2487 | "qZuoFdfeze3dOHlcQvpcVmom", |
| 2488 | "eb0jW5/cRCohqCknkG", |
| 2489 | "W6CGt14YWQRcSCoMtG", |
| 2490 | "W5KoWQ/cSLddKCovfvG6khm5WO4", |
| 2491 | "WPr3iCkRmSo0Emkdu2pcSmkvxG", |
| 2492 | "cSkPWRddSSoBW5iUi1NdMt8gWR4D", |
| 2493 | "ax7cLHRdQ8o4w0RdNCoOW75rW6vu", |
| 2494 | "WPRdVSo1rmoQW58NW4aSW5RcP8o/WQxcOt/cUmoggePJW6NdICo1W6K", |
| 2495 | "a8kAmW", |
| 2496 | "wwy/", |
| 2497 | "dbGFDq", |
| 2498 | "gYD6BW", |
| 2499 | "W6tdLZa", |
| 2500 | "WQdcR8koW4VcLCoaW5HFWQ7dOIaKDYC", |
| 2501 | "gZ9hwr8fAMJcV8oCF8oQpmof", |
| 2502 | "WRFcUmkvW6/cImoBW5vaWR8", |
| 2503 | "xduusZDd", |
| 2504 | "WR0EAsaQW4eMWO/dVCocW7ucWRpcIq", |
| 2505 | "WPddH8o/obb8", |
| 2506 | "W4RcTL1hmJ5/DaVcOcqWo8od", |
| 2507 | "B3ypW5pcHui", |
| 2508 | "WR7dMSkeyJbGDe/cPrGrW4/cObK", |
| 2509 | "WQRdKmks", |
| 2510 | "W7BdPfldSMDfECkDE8oxyIBdSu8", |
| 2511 | "WPNdVSoNySoZW5qNW4aSW5RcP8o/WQxcOq", |
| 2512 | "WPHieX1UzmkwWQ/dGG", |
| 2513 | "wMyTWPJcTmo9W5a1zK/dHZnGxq", |
| 2514 | "WOlcP8kg", |
| 2515 | "WPJcS8kvk0zoWPC1yW", |
| 2516 | "WOzLACoYcmomltNcT8oAvG0EW5u", |
| 2517 | "W6iNEGerngRcVCk3wmoRp8kTjG", |
| 2518 | "WP1IEW", |
| 2519 | "hIPrxaG", |
| 2520 | "WO9umCkS", |
| 2521 | "WOfHy8o3", |
| 2522 | "WOecACksiGG", |
| 2523 | "W7hdOfJdTW", |
| 2524 | "vduCrs1oqfddUrVcVetcH8ot", |
| 2525 | "fSoGoW", |
| 2526 | "aqxdHmo0ymojW5/dV0m", |
| 2527 | "ebOvW4m", |
| 2528 | "fILGqGmbqW", |
| 2529 | "WQKjyd0RW5apWO3dTW", |
| 2530 | "k2Olra", |
| 2531 | "CCkOEH7cTG", |
| 2532 | "WRFcV8kjW7m", |
| 2533 | "WRThDq", |
| 2534 | "WOZdRmovW6uAdCoF", |
| 2535 | "gX0jt8kWo0K", |
| 2536 | "W6ldMtif", |
| 2537 | "W7aJBHS", |
| 2538 | "WP1SECkOW75g", |
| 2539 | "WPRcUmk1aq", |
| 2540 | "W7dcH24u", |
| 2541 | "WPhcP8kyW4xdSmokWQqnWQq", |
| 2542 | "ymokW6ZdRHpdOGNdOmoz", |
| 2543 | "eN/cMbZdUmoLxa", |
| 2544 | "WRpcRSkaW43cHSoDW58", |
| 2545 | "WRVcVSk5FSo7W6JdIW", |
| 2546 | "W5JcSKLD", |
| 2547 | "BmoFnMtdUH0", |
| 2548 | "W6ddNdOGW7NcSmk5", |
| 2549 | "W7iMzJ4Ei0K", |
| 2550 | "WR1jD8o8", |
| 2551 | "WQKAFsWQW5a", |
| 2552 | "oNidW5ddLxi", |
| 2553 | "WOBcRmkmW6ddPCoUWRy", |
| 2554 | "WONdV8o7xCo8W4me", |
| 2555 | "y8kOzHVcUW", |
| 2556 | "WR9mF8ozimoZEW", |
| 2557 | "WQ9heIm", |
| 2558 | "WOJdP8oF", |
| 2559 | "faVdMmo0", |
| 2560 | "C8k3zahcU8ojW7DpBq", |
| 2561 | "WOfVyCoOeSo/hdNcQW", |
| 2562 | "WOr2WOZdLCk0CbRdOCoj", |
| 2563 | "yhWpW4FcHxXumre", |
| 2564 | "WONcOSkOgMC/W4vNW4C", |
| 2565 | "fNRcKc/dT8oJ", |
| 2566 | "WPZcPCkacuHiWP0", |
| 2567 | "l3ScESoWjv0", |
| 2568 | "WQ0FDr8LW5yf", |
| 2569 | "ehRcKdK", |
| 2570 | "kxWFW4BdJ1ddQcddIa", |
| 2571 | "gIf6EmoPrhhdIwm", |
| 2572 | "W6uTCHSlb1VcVCkR", |
| 2573 | "W6BdPu7dJwHswG", |
| 2574 | "WPrPWO7dJ8k0", |
| 2575 | "W54pWQhcTepdJmos", |
| 2576 | "dsPUxCo8ygm", |
| 2577 | "WPSgDCkg", |
| 2578 | "dSkJWQRdKCoDW6S7pL4", |
| 2579 | "W4KeWRxcKvBdQmoacf8", |
| 2580 | "WO5IzCk+W6rKBJFcKa", |
| 2581 | "W5RcT0f4psLC", |
| 2582 | "fCoJiSkgWRO", |
| 2583 | "WQ7cLmkQEa", |
| 2584 | "W6uJCaqAna", |
| 2585 | "DSk3Ea", |
| 2586 | "k3ai", |
| 2587 | "WOLLDSoDcCoB", |
| 2588 | "aXWDFSkLiq", |
| 2589 | "WOr5BSk/W7fgydC", |
| 2590 | "W7BcK28p", |
| 2591 | "W7FdQmoHoa", |
| 2592 | "WOL8WPRdKG", |
| 2593 | "z8okW6ZdUa", |
| 2594 | "gxDO", |
| 2595 | "W4ikWQJcRvxdKmoXcemZpwqcWPe", |
| 2596 | "W7JdRmoJmYNdOq", |
| 2597 | "WPf0BSo4dCo6fdhcVq", |
| 2598 | "oh4mt8o5hKbNWRBdRW", |
| 2599 | "WPVdQCoBW5atnSocW4feWPm", |
| 2600 | "WOr4WPBdHCkOBXxdT8oFfq", |
| 2601 | "WQNcS8kTsCo2W7BdGCkRkmo4EXG", |
| 2602 | "WRZdLSkmAJjPxxtcPaWrW4u", |
| 2603 | "hXWDFCk4j13dMu9Veevzo8kLeW", |
| 2604 | "WQ5gyCogl8oLBCkE", |
| 2605 | "WOBcPmkckW", |
| 2606 | "W7m9tK8", |
| 2607 | "W6ldMsWdW70", |
| 2608 | "WQhcV8k7xa", |
| 2609 | "WQVcTCkTtq", |
| 2610 | "WRhcQ8kwW67cGG", |
| 2611 | "WO/dVSoYzmoXW4Cs", |
| 2612 | "W6eZtf84", |
| 2613 | "WQpcKmk+ya", |
| 2614 | "l3Ckq8oM", |
| 2615 | "ehRcJJ/dVa", |
| 2616 | "WRVcSSkXr8oT", |
| 2617 | ]; |
| 2618 | b = () => gH; |
| 2619 | return b(); |
| 2620 | } |
| 2621 | |
| 2622 | function U(Z, O) { |
| 2623 | Z = Z - 0x0; |
| 2624 | const c = b(); |
| 2625 | let g = c[Z]; |
| 2626 | if (U["GdGIHB"] === undefined) { |
| 2627 | var D = (H) => { |
| 2628 | const w = |
| 2629 | "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="; |
| 2630 | let z = "", |
| 2631 | K = ""; |
| 2632 | for ( |
| 2633 | let E = 0x0, P, p, o = 0x0; |
| 2634 | (p = H["charAt"](o++)); |
| 2635 | ~p && ((P = E % 0x4 ? P * 0x40 + p : p), E++ % 0x4) |
| 2636 | ? (z += String["fromCharCode"](0xff & (P >> ((-0x2 * E) & 0x6)))) |
| 2637 | : 0x0 |
| 2638 | ) { |
| 2639 | p = w["indexOf"](p); |
| 2640 | } |
| 2641 | for (let N = 0x0, A = z["length"]; N < A; N++) { |
| 2642 | K += "%" + ("00" + z["charCodeAt"](N)["toString"](0x10))["slice"](-0x2); |
| 2643 | } |
| 2644 | return decodeURIComponent(K); |
| 2645 | }; |
| 2646 | const X = (H, w) => { |
| 2647 | let z = [], |
| 2648 | K = 0x0, |
| 2649 | E, |
| 2650 | P = ""; |
| 2651 | H = D(H); |
| 2652 | let p; |
| 2653 | for (p = 0x0; p < 0x100; p++) { |
| 2654 | z[p] = p; |
| 2655 | } |
| 2656 | for (p = 0x0; p < 0x100; p++) { |
| 2657 | ((K = (K + z[p] + w["charCodeAt"](p % w["length"])) % 0x100), |
| 2658 | (E = z[p]), |
| 2659 | (z[p] = z[K]), |
| 2660 | (z[K] = E)); |
| 2661 | } |
| 2662 | ((p = 0x0), (K = 0x0)); |
| 2663 | for (let o = 0x0; o < H["length"]; o++) { |
| 2664 | ((p = (p + 0x1) % 0x100), |
| 2665 | (K = (K + z[p]) % 0x100), |
| 2666 | (E = z[p]), |
| 2667 | (z[p] = z[K]), |
| 2668 | (z[K] = E), |
| 2669 | (P += String["fromCharCode"]( |
| 2670 | H["charCodeAt"](o) ^ z[(z[p] + z[K]) % 0x100], |
| 2671 | ))); |
| 2672 | } |
| 2673 | return P; |
| 2674 | }; |
| 2675 | ((U["BemOAL"] = X), (U["kdIFLS"] = {}), (U["GdGIHB"] = !![])); |
| 2676 | } |
| 2677 | const R = c[0x0], |
| 2678 | t = Z + R, |
| 2679 | e = U["kdIFLS"][t]; |
| 2680 | return ( |
| 2681 | !e |
| 2682 | ? (U["QJsFjo"] === undefined && (U["QJsFjo"] = !![]), |
| 2683 | (g = U["BemOAL"](g, O)), |
| 2684 | (U["kdIFLS"][t] = g)) |
| 2685 | : (g = e), |
| 2686 | g |
| 2687 | ); |
| 2688 | } |
| 2689 | |
| 2690 | console[U("0x1b0", "waD0")](o(0xa, 0x14)); |
Перш ніж робити будь-що інше, агент зробив те, що зробила б людина — прочитав файл. Власне, чотири рази, пропрацьовуючи runtime VM шматками. Потім один раз запустив сам обфускований файл, аби підтвердити базовий рівень: o(10, 20) повертає 170. Той самий результат, на який треба буде потрапити після деобфускації.
План, який він написав
Claude видав шестикроковий план ще до того, як торкнувся коду. Структуру бандла він зрозумів з першого прочитання — IIFE угорі, що перетасовує масив рядків, інтерпретатор VM на ~1 500 рядків посередині, base64+RC4-зашифрований блоб байткоду внизу і невелика точка входу, що викликає VM.
Повний 6-кроковий план, як його записав Claude
| 1 | The obfuscated file is ~1,587 lines but the actual program is tiny — |
| 2 | it's encoded as bytecode executed by a custom stack-based VM |
| 3 | interpreter. |
| 4 | |
| 5 | Structure of the obfuscated code: |
| 6 | 1. String array + rotation (lines 1-11): classic javascript-obfuscator |
| 7 | string-array shuffling |
| 8 | 2. String decryption U() (lines 1549-1585): RC4-based string |
| 9 | decryption |
| 10 | 3. VM runtime p (lines 14-1534): ~1,500 lines of custom bytecode |
| 11 | interpreter |
| 12 | 4. Bytecode storage (N[0]): base64+RC4 encrypted bytecode blob |
| 13 | 5. Entry point (lines 1535-1587): function o(N,A) { return |
| 14 | p.call(this, 0x0, Array.from(arguments), undefined, o); } |
| 15 | then console.log(o(10, 20)) |
| 16 | |
| 17 | Deobfuscation approach: |
| 18 | Step 1 — Decrypt all strings: evaluate b() and U(), replace every |
| 19 | U(hex, 'key') call with its decrypted value |
| 20 | Step 2 — Clean up the VM runtime: replace obfuscated property |
| 21 | accesses with readable names; map VM internals to |
| 22 | meaningful names (stack, IP, constants, locals…) |
| 23 | Step 3 — Extract and decode bytecode: base64 → RC4 → deserialize. |
| 24 | The RC4 key comes from h() — environment fingerprinting |
| 25 | Step 4 — Disassemble bytecode to readable opcodes: map the b3 |
| 26 | shuffle table to logical operations; walk the instruction |
| 27 | stream |
| 28 | Step 5 — Reconstruct original JavaScript from the disassembly |
| 29 | Step 6 — Document the techniques used |
| 30 | |
| 31 | Verification: run both files in Node.js, both should produce the |
| 32 | same output for o(10, 20). |
Перша спроба була одним god-файлом
Claude написав один-єдиний deobfuscate.js на 883 рядки, що намагався зробити всю роботу одним проходом — обчислити декодер масиву рядків, розшифрувати кожен виклик U(idx, key), виконати відбиток середовища h(), використати його як ключ RC4 для дешифрування блобу байткоду, переписати кастомний бінарний десеріалізатор (єдину частину, якої ніхто поза javascript-obfuscator не бачив), розібрати і видати еквівалентний JavaScript.
Перша половина спрацювала. Розшифрування рядків: готово — 500 унікальних викликів U() розшифровано за один прогон. h() обчислився до очікуваного 0xa19722e9. Дешифрування байткоду: чистий буфер байтів на виході.
Друга половина — ні. Десеріалізатор використовує кастомний бінарний формат — зігзаг-кодовані varint'и, умовні поля під керуванням бітової маски прапорів, аліасовані імена властивостей. Спроба переписати його, читаючи обфускований код, видала сміття: неправильний байт версії, від'ємний параметр-каунт, нуль інструкцій. П'ять років тому пост на цьому б і закінчився. Claude знизав плечима, написав 286-рядковий instrument.js, щоб патчити саму VM на льоту, з першого разу налетів на пісочницю і миттєво змінив стратегію — «пісочниця надто обмежує, спробую простіший підхід: створити модифіковану копію, що логує зсередини».
God-файл deobfuscate.js — структура (кроки 1-3 невдалого проходу)
| 1 | #!/usr/bin/env node |
| 2 | /** |
| 3 | * Deobfuscator for javascript-obfuscator VM-obfuscated JavaScript. |
| 4 | * |
| 5 | * Strategy: |
| 6 | * 1. Evaluate the string-array + RC4 decryptor from the obfuscated file |
| 7 | * 2. Use it to decrypt every U(idx, key) call |
| 8 | * 3. Evaluate h() to get the environment fingerprint |
| 9 | * 4. Decode N[0] bytecode blob: base64 → RC4 → B() deserialize |
| 10 | * 5. Disassemble the bytecode instruction stream |
| 11 | * 6. Reconstruct the original JavaScript |
| 12 | */ |
| 13 | |
| 14 | const fs = require("fs"); |
| 15 | const path = require("path"); |
| 16 | const vm = require("vm"); |
| 17 | |
| 18 | const src = fs.readFileSync(path.join(__dirname, "obfuscated.js"), "utf8"); |
| 19 | |
| 20 | // ── Step 1: Bootstrap the string decryption ─────────────────────────────── |
| 21 | // Extract b() (string array), U() (RC4 decryptor), and the rotation IIFE |
| 22 | // from the source, then evaluate them in an isolated VM context. |
| 23 | |
| 24 | const bFuncMatch = src.match(/function b\(\)\s*\{[\s\S]*?return b\(\);\s*\}/); |
| 25 | const uFuncMatch = src.match(/function U\(Z, O\)\s*\{[\s\S]*?return.*?g;\s*\}/); |
| 26 | const rotationMatch = src.match( |
| 27 | /^\(function \(N, A\)\s*\{[\s\S]*?\(b, 0x[a-f0-9]+\)\);/m, |
| 28 | ); |
| 29 | |
| 30 | const sandbox = { U: null, b: null, parseInt, String, decodeURIComponent }; |
| 31 | vm.createContext(sandbox); |
| 32 | vm.runInContext( |
| 33 | `${bFuncMatch[0]}\n${uFuncMatch[0]}\n${rotationMatch[0]}`, |
| 34 | sandbox, |
| 35 | ); |
| 36 | const U = sandbox.U; |
| 37 | |
| 38 | // ── Step 2: Decrypt every U() call site ─────────────────────────────────── |
| 39 | const uCallPattern = /U\((?:'(0x[a-f0-9]+)'|(0x[a-f0-9]+)),\s*'([^']+)'\)/g; |
| 40 | const decryptedStrings = new Map(); |
| 41 | let match; |
| 42 | while ((match = uCallPattern.exec(src)) !== null) { |
| 43 | const idx = match[1] || match[2]; |
| 44 | const key = match[3]; |
| 45 | try { |
| 46 | decryptedStrings.set(match[0], U(idx, key)); |
| 47 | } catch (e) {} |
| 48 | } |
| 49 | |
| 50 | // ── Step 3: Compute the environment fingerprint h() ─────────────────────── |
| 51 | // h() XORs 0x5f3759df with built-in .length values from Array.prototype.push, |
| 52 | // String.prototype.padStart, Math.imul, Object.keys, Array.prototype.indexOf, |
| 53 | // String.prototype.includes — values that are identical across every JS engine. |
| 54 | function h() { |
| 55 | let bk = 0x5f3759df; |
| 56 | bk ^= Array.prototype.push.length << 0x18; // 1 |
| 57 | bk ^= String.prototype.padStart.length << 0x14; // 1 |
| 58 | bk ^= Math.imul.length << 0x10; // 2 |
| 59 | bk ^= Object.keys.length << 0xc; // 1 |
| 60 | bk ^= Array.prototype.indexOf.length << 0x8; // 1 |
| 61 | bk ^= String.prototype.includes.length; // 1 |
| 62 | return bk >>> 0; // → 0xa19722e9 |
| 63 | } |
| 64 | |
| 65 | const envKey = h(); |
| 66 | console.log(`h() = 0x${envKey.toString(16)}`); // 0xa19722e9 ✓ |
| 67 | |
| 68 | // ── Steps 4-6: bytecode decrypt → custom binary deserialize → disassemble. |
| 69 | // This is where it fell over. The B() deserializer uses zigzag varints, |
| 70 | // flag-gated conditional fields, and aliased property names. Reimplementing |
| 71 | // it from the obfuscated source produced: version byte = 0xff (expected 1), |
| 72 | // paramCount = -3, instruction count = 0. Garbage. |
Він припинив переписувати і почав інструментувати
Тоді стратегія змінилася. Claude не став стукати сильніше по десеріалізатору; він пропатчив сам обфускований файл під час виконання. Обгорнув власний B() обфускатора так, щоб той JSON.stringify-ив свій вивід у лог, обгорнув dispatch-цикл, аби логувати кожен опкод, операнд і мутацію стеку, потім запустив пропатчений файл один раз і зловив усе на stdout.
Один прогін дав повну картину: paramCount 2, localCount 3, константи [0.15, 100, 1, "calculatePrice"], block key 54, jump key 9643, ключ шифрування стеку 4168320119 і потік байткоду на 22 інструкції — плюс покрокова траса виконання кожної мутації стеку.
Дивлячись на це, я не міг позбутися думки: інструментування — це перше, що спробував би притомний реверс-інженер, а не останнє. Агент із неочевидної стартової позиції дорозумувався до очевидного ходу одним розворотом, без жодного підштовхування з мого боку.
Не переписуй те, що можеш інструментувати. Програма вже знає, як себе виконати.
Він розібрав VM, назвав кожен опкод і видав вихідний код
З байткодом у руках Claude пройшовся ним. Він XOR-ив кожен опкод із blockKey=54, аби відновити його логічний індекс, шукав індекс у таблиці перетасування b3, щоб ідентифікувати операцію, а потім давав опкодам людські імена — PUSH_CONST, STORE_LOCAL, LOAD_ARG, MUL, SUB, LOAD_LOCAL, GT, JMP_FALSE, DUP, POP, RETURN. Цільову адресу переходу він обчислив через jumpKey=9643 і пройшовся потоком з 22 інструкцій згори донизу, на ходу видаючи еквівалентний JavaScript.
Для контексту: у мене ~15 років роботи з JavaScript, я добре орієнтуюся в дебагері, і це саме та частина роботи, на якій я б згайнував більшість тижня. Прочитати 1 500 рядків коду диспетчера, відстежити, який операнд із яким ключем XOR-ується, побудувати в голові модель стекової VM, з'ясувати кожен опкод за поведінкою — це акуратна, помилкоємна, багатоденна рутина. Claude зробив це за час, який мені потрібен, аби заварити каву, з одного промпту, без жодних інструментів і без жодних знань про цей обфускатор. Те, що щойно сталося, варто проговорити вголос: агент не запропонував підхід до деобфускації, щоб я його спробував, він видав сам артефакт — файл на вхід, вихідний код на вихід, із невдалою спробою поряд із робочою у тій самій теці.
disassemble.js — скрипт, який Claude написав і який перетворив байткод на вихідний код (повний файл)
| 1 | #!/usr/bin/env node |
| 2 | /** |
| 3 | * Final disassembly of the extracted bytecode. |
| 4 | * Uses the raw bytecode data captured from the instrumented run. |
| 5 | */ |
| 6 | |
| 7 | // ── Bytecode metadata (captured from the instrumented obfuscator) ── |
| 8 | const bc = { |
| 9 | paramCount: 2, |
| 10 | localCount: 3, |
| 11 | nameIndex: 3, // constants[3] = "calculatePrice" |
| 12 | blockKey: 54, |
| 13 | jumpKey: 9643, |
| 14 | seKey: 4168320119, |
| 15 | constants: [0.15, 100, 1, "calculatePrice"], |
| 16 | instructions: [ |
| 17 | 357, |
| 18 | 54, |
| 19 | 384, |
| 20 | 52, |
| 21 | 149, |
| 22 | 55, |
| 23 | 384, |
| 24 | 53, |
| 25 | 220, |
| 26 | 54, |
| 27 | 108, |
| 28 | 55, |
| 29 | 38, |
| 30 | null, |
| 31 | 369, |
| 32 | 50, |
| 33 | 158, |
| 34 | 50, |
| 35 | 59, |
| 36 | 53, |
| 37 | 32, |
| 38 | null, |
| 39 | 333, |
| 40 | null, |
| 41 | 451, |
| 42 | 50, |
| 43 | 347, |
| 44 | 52, |
| 45 | 270, |
| 46 | 52, |
| 47 | 438, |
| 48 | null, |
| 49 | 126, |
| 50 | null, |
| 51 | 365, |
| 52 | null, |
| 53 | 217, |
| 54 | 50, |
| 55 | 245, |
| 56 | null, |
| 57 | 158, |
| 58 | 50, |
| 59 | 289, |
| 60 | null, |
| 61 | ], |
| 62 | tryCatch: { 11: 9663 }, |
| 63 | }; |
| 64 | |
| 65 | // ── Opcode mapping (recovered from the dispatch trace) ── |
| 66 | const OPCODE_NAMES = { |
| 67 | 0x0: "PUSH_CONST", |
| 68 | 0x3: "POP", |
| 69 | 0x4: "DUP", |
| 70 | 0x6: "LOAD_LOCAL", |
| 71 | 0x7: "STORE_LOCAL", |
| 72 | 0x8: "LOAD_ARG", |
| 73 | 0xb: "SUB", |
| 74 | 0xc: "MUL", |
| 75 | 0x2e: "GT", |
| 76 | 0x34: "JMP_FALSE", |
| 77 | 0x38: "RETURN", |
| 78 | }; |
| 79 | |
| 80 | // ── The decoded instruction stream ── |
| 81 | // VM applies: Up = raw_opcode XOR blockKey, then SM shuffle → Uo |
| 82 | const traced = [ |
| 83 | { |
| 84 | pc: 0, |
| 85 | op: 0x00, |
| 86 | arg: 0, |
| 87 | name: "PUSH_CONST", |
| 88 | desc: "push constants[0] = 0.15", |
| 89 | }, |
| 90 | { |
| 91 | pc: 1, |
| 92 | op: 0x07, |
| 93 | arg: 2, |
| 94 | name: "STORE_LOCAL", |
| 95 | desc: "local[2] = pop() → taxRate = 0.15", |
| 96 | }, |
| 97 | { |
| 98 | pc: 2, |
| 99 | op: 0x00, |
| 100 | arg: 1, |
| 101 | name: "PUSH_CONST", |
| 102 | desc: "push constants[1] = 100", |
| 103 | }, |
| 104 | { |
| 105 | pc: 3, |
| 106 | op: 0x07, |
| 107 | arg: 3, |
| 108 | name: "STORE_LOCAL", |
| 109 | desc: "local[3] = pop() → threshold = 100", |
| 110 | }, |
| 111 | { pc: 4, op: 0x08, arg: 0, name: "LOAD_ARG", desc: "push args[0] → price" }, |
| 112 | { |
| 113 | pc: 5, |
| 114 | op: 0x08, |
| 115 | arg: 1, |
| 116 | name: "LOAD_ARG", |
| 117 | desc: "push args[1] → quantity", |
| 118 | }, |
| 119 | { |
| 120 | pc: 6, |
| 121 | op: 0x0c, |
| 122 | arg: null, |
| 123 | name: "MUL", |
| 124 | desc: "pop 2, push product → price * quantity", |
| 125 | }, |
| 126 | { |
| 127 | pc: 7, |
| 128 | op: 0x07, |
| 129 | arg: 4, |
| 130 | name: "STORE_LOCAL", |
| 131 | desc: "local[4] = pop() → total", |
| 132 | }, |
| 133 | { |
| 134 | pc: 8, |
| 135 | op: 0x06, |
| 136 | arg: 4, |
| 137 | name: "LOAD_LOCAL", |
| 138 | desc: "push local[4] → total", |
| 139 | }, |
| 140 | { |
| 141 | pc: 9, |
| 142 | op: 0x06, |
| 143 | arg: 3, |
| 144 | name: "LOAD_LOCAL", |
| 145 | desc: "push local[3] → threshold", |
| 146 | }, |
| 147 | { |
| 148 | pc: 10, |
| 149 | op: 0x2e, |
| 150 | arg: null, |
| 151 | name: "GT", |
| 152 | desc: "pop 2, push (total > threshold)", |
| 153 | }, |
| 154 | { |
| 155 | pc: 11, |
| 156 | op: 0x34, |
| 157 | arg: null, |
| 158 | name: "JMP_FALSE", |
| 159 | desc: "if false, jump to pc=20 (9663 ^ 9643 = 20)", |
| 160 | }, |
| 161 | { |
| 162 | pc: 12, |
| 163 | op: 0x06, |
| 164 | arg: 4, |
| 165 | name: "LOAD_LOCAL", |
| 166 | desc: "push local[4] → total", |
| 167 | }, |
| 168 | { |
| 169 | pc: 13, |
| 170 | op: 0x00, |
| 171 | arg: 2, |
| 172 | name: "PUSH_CONST", |
| 173 | desc: "push constants[2] = 1", |
| 174 | }, |
| 175 | { |
| 176 | pc: 14, |
| 177 | op: 0x06, |
| 178 | arg: 2, |
| 179 | name: "LOAD_LOCAL", |
| 180 | desc: "push local[2] → taxRate (0.15)", |
| 181 | }, |
| 182 | { |
| 183 | pc: 15, |
| 184 | op: 0x0b, |
| 185 | arg: null, |
| 186 | name: "SUB", |
| 187 | desc: "pop 2, push (1 - 0.15) = 0.85", |
| 188 | }, |
| 189 | { |
| 190 | pc: 16, |
| 191 | op: 0x0c, |
| 192 | arg: null, |
| 193 | name: "MUL", |
| 194 | desc: "pop 2, push (total * 0.85)", |
| 195 | }, |
| 196 | { pc: 17, op: 0x04, arg: null, name: "DUP", desc: "duplicate TOS" }, |
| 197 | { |
| 198 | pc: 18, |
| 199 | op: 0x07, |
| 200 | arg: 4, |
| 201 | name: "STORE_LOCAL", |
| 202 | desc: "local[4] = pop() → total = discounted", |
| 203 | }, |
| 204 | { pc: 19, op: 0x03, arg: null, name: "POP", desc: "discard extra copy" }, |
| 205 | { |
| 206 | pc: 20, |
| 207 | op: 0x06, |
| 208 | arg: 4, |
| 209 | name: "LOAD_LOCAL", |
| 210 | desc: "push local[4] → total", |
| 211 | }, |
| 212 | { pc: 21, op: 0x38, arg: null, name: "RETURN", desc: "return TOS" }, |
| 213 | ]; |
| 214 | |
| 215 | // ── Reconstruct ── |
| 216 | const source = `function calculatePrice(price, quantity) { |
| 217 | const taxRate = 0.15; |
| 218 | const threshold = 100; |
| 219 | let total = price * quantity; |
| 220 | if (total > threshold) { |
| 221 | total = total * (1 - taxRate); |
| 222 | } |
| 223 | return total; |
| 224 | } |
| 225 | |
| 226 | console.log(calculatePrice(10, 20));`; |
| 227 | |
| 228 | console.log(source); |
| 229 | |
| 230 | // ── Verify behavioral equivalence ── |
| 231 | const calculatePrice = new Function( |
| 232 | "price", |
| 233 | "quantity", |
| 234 | ` |
| 235 | const taxRate = 0.15; |
| 236 | const threshold = 100; |
| 237 | let total = price * quantity; |
| 238 | if (total > threshold) { |
| 239 | total = total * (1 - taxRate); |
| 240 | } |
| 241 | return total; |
| 242 | `, |
| 243 | ); |
| 244 | |
| 245 | const tests = [ |
| 246 | [10, 20, 170], // 200 > 100 → 200 * 0.85 = 170 |
| 247 | [5, 10, 50], // 50 ≤ 100 → 50 |
| 248 | [50, 3, 127.5], // 150 > 100 → 150 * 0.85 = 127.5 |
| 249 | [100, 1, 100], // 100 ≤ 100 → 100 (boundary) |
| 250 | [101, 1, 85.85], // 101 > 100 → 101 * 0.85 = 85.85 |
| 251 | ]; |
| 252 | |
| 253 | for (const [a, b, expected] of tests) { |
| 254 | const actual = calculatePrice(a, b); |
| 255 | console.log( |
| 256 | `calculatePrice(${a}, ${b}) = ${actual} ${ |
| 257 | Math.abs(actual - expected) < 0.0001 ? "✓" : `✗ (expected ${expected})` |
| 258 | }`, |
| 259 | ); |
| 260 | } |
Що Claude насправді видав
Коли він зупинився, у Claude уже була зібрана повна робоча тека: оригінальний обфускований файл, відновлений вихідний код, опис кожної використаної техніки, провальний god-файл, покинута перша спроба інструментування, вдала друга, ним же згенерована пропатчена версія обфускованого файлу і фінальний дизасемблер. Дерево він написав сам собі.
Коли я потім запитав його, які саме файли справді робили роботу, recap прийшов без підказок і був абсолютно точним.
Відновлений вихідний код — те, що Claude реконструював
| 1 | // Recovered from 1,587 lines of VM-obfuscated code. |
| 2 | // |
| 3 | // Obfuscation layers reversed: |
| 4 | // 1. String array rotation + RC4 decryption (U() with b() array) |
| 5 | // 2. Environment fingerprinting (h() — hashes built-in .length values) |
| 6 | // 3. Bytecode encryption (base64 → RC4 with fingerprint key) |
| 7 | // 4. Bytecode serialization (custom binary format with zigzag varints) |
| 8 | // 5. Opcode shuffling (b3 table + per-function seed permutation) |
| 9 | // 6. Operand encryption (XOR with blockKey=54, jumpKey=9643) |
| 10 | // 7. Stack-value encryption (XOR with seKey=4168320119 for integers) |
| 11 | // 8. Anti-debug timing checks (corrupt opcode table on slow-step) |
| 12 | // 9. Custom stack-based VM interpreter (~1,500 lines, ~100 opcodes) |
| 13 | |
| 14 | function calculatePrice(price, quantity) { |
| 15 | const taxRate = 0.15; |
| 16 | const threshold = 100; |
| 17 | let total = price * quantity; |
| 18 | if (total > threshold) { |
| 19 | total = total * (1 - taxRate); |
| 20 | } |
| 21 | return total; |
| 22 | } |
| 23 | |
| 24 | console.log(calculatePrice(10, 20)); // → 170 |
Справжній оригінальний вихідний код — те, що клали у javascript-obfuscator
| 1 | // Simple calculator with secret discount logic |
| 2 | function calculatePrice(quantity, unitPrice) { |
| 3 | const SECRET_DISCOUNT = 0.15; |
| 4 | const SECRET_THRESHOLD = 100; |
| 5 | |
| 6 | let total = quantity * unitPrice; |
| 7 | |
| 8 | if (total > SECRET_THRESHOLD) { |
| 9 | total = total * (1 - SECRET_DISCOUNT); |
| 10 | } |
| 11 | |
| 12 | return total; |
| 13 | } |
| 14 | |
| 15 | // Try it: calculatePrice(10, 20) => 170 |
| 16 | console.log(calculatePrice(10, 20)); |
Відновлений код працює ідентично оригіналу на всіх входах, які я перевіряв, разом із межовим випадком. Чого він не повертає — то це імена: quantity, unitPrice повернулися як price, quantity, дві константи SECRET_* — як taxRate і threshold (числові значення 0.15 і 100 лишилися незмінними, бо вони мусять бути у байткоді, аби VM запустилася). Порядок аргументів і назви ідентифікаторів виведені з поведінки, а не відновлені. Обфускатор приховує те, що йому дозволено приховувати, і зберігає те, що VM треба у runtime — і виявляється, що того, що VM треба у runtime, достатньо, щоб LLM прочитала програму.
Потім я спробував його на JScrambler — платному
Той самий експеримент, інший вендор. Я взяв опубліковане JScrambler-ом демо «Javascript Racer» — модуль фонового sprite-atlas, який вони відвантажують для реклами свого дефолтного профілю захисту — і дав Claude Code промпт тієї самої форми. Інший обфускатор, інші техніки, платний продукт.
Claude прочитав файл один раз і одразу мав на руках структуру:
- Реєстр простору імен на ім'я
a20f7. - URL-кодований блоб рядків із XOR-ключем.
- 3D-таблиця індексів, що використовується як непрозорі цілочисельні теги.
- «Самозамінний декодер», який нагрівається рівно на 8 викликах, а далі вироджується у прямий look-up.
- Сам корисний навантаження, заховане під цим усім, що збирає один об'єкт на ім'я
BACKGROUND.
Нічого з цього не було у промпті. Він просто прочитав це зі сторінки.
Цікаво, що JScrambler обрав робити інакше. Тут немає байткодової VM — вони використовують сплощення потоку керування на скінченному автоматі switch-state, підручникова форма while (state !== END) { switch (state) { … } }, вкладена настільки глибоко, наскільки глибоке оригінальне дерево виразу. Без RC4 — рядки беруться з URL-кодованого блобу циклічним XOR-ключем, потім розрізаються по роздільнику. Без anti-debug таймінгів — натомість «прихована послідовність нагрівання», що вдає валідацію вмісту рядків, а насправді просто викликає функцію look-up у точному порядку, аби посунути внутрішній лічильник. Зовсім інші примітиви. Та сама форма примітивів. Той самий шестикроковий шлях із прогону javascript-obfuscator — розшифрувати рядки, прибрати runtime, витягти стан, пройти потоком керування, реконструювати, задокументувати — лягла майже один до одного. Розворот до інструментування, від якого залежав перший прогін, тут навіть не знадобився: статичний аналіз довів вхід до відкритого тексту, жодного разу не запустивши обфускований код.
24 620 байтів виводу JScrambler. П'ять рядків вихідного коду. Близько 20 хвилин, Opus 4.7 із thinking на максимумі. Довше за прогін javascript-obfuscator, але все ще впевнено у зоні «хвилини API-виклику» і дуже далеко від «днів-роботи-експерта».
Відновлений вихідний код — 24 КБ JScrambler стиснулися до 5 рядків
| 1 | var BACKGROUND = { |
| 2 | HILLS: { x: 5, y: 5, w: 1280, h: 480 }, |
| 3 | SKY: { x: 5, y: 495, w: 1280, h: 480 }, |
| 4 | TREES: { x: 5, y: 985, w: 1280, h: 480 }, |
| 5 | }; |
Чому це не втрималося
Чотири структурні причини, що працюють у обох прогонах — і передбачають, що далі спрацює, а що ні.
1. Інверсія мусить жити у бандлі. Кожен захист цієї родини везе з собою власне «скасувати» — декодер зашифрованого рядка, ключ перетасування таблиці опкодів, вихідні значення відбитку середовища — тому що якби інверсії в бандлі не було, програма б не запустилася. Це робить усю родину принципово відновлюваною. Єдине справжнє питання — ціна.
2. Послідовні перетворення розкручуються по одному. Коли шари скомпоновані як t₁ ∘ t₂ ∘ … ∘ tₙ, інверсія — це просто зворотна композиція. LLM добре розпізнають і обертають окремі сімейства перетворень — ротацію масиву рядків, RC4, base64, XOR із константою, Fisher-Yates із seed-ом (javascript-obfuscator використовує якусь комбінацію всього цього) — бо бачили їх тисячами під час тренування. Зняти n шарів займає приблизно n одиниць роботи, а не 2ⁿ, які отримаєш зі справді переплетеними перетвореннями. Дев'ять шарів стають дев'ятьма ходами моделі, тоді як обфускатор, мабуть, розраховував на дев'ять інженеро-днів.
3. VM — це єдина точка відмови. VM виглядає як крок угору, бо логічна програма тепер у кастомному байткоді, а не у JavaScript. Але річ, що перетворює байткод на поведінку — інтерпретатор — лежить прямо там, у бандлі. Інструментуй його dispatch-цикл один раз — і ти декодував кожну функцію, яка коли-небудь запуститься. Anti-debug таймінги спрацьовують лише тоді, коли людина крокує повільно з брейкпойнтом; автоматичне інструментування біжить на повній швидкості і ніколи їх не зачіпає. Відбиток середовища, побудований на стандартних значеннях .length вбудованих методів, повертає те саме число у будь-якому JS-рушії, тому runtime-прив'язка тут декоративна.
4. LLM розбили підлогу навичок. Жодне з цього не було нерозв'язним до LLM — є десятирічні роботи про ручний реверс сплощення потоку керування. Змінилося — хто це може робити і за який час. Підлога навичок упала з «експерт-реверс-інженер із інструментами» до «будь-який інженер із доступом до AI», годинник упав із днів до хвилин, а імена — те єдине, що реверс-інженерам колись треба було вигадувати з нуля — тепер повертаються із семантичного контексту безкоштовно.
Дев'ять захисних шарів і чому кожен із них розвалився
| Шар | Що робить | Чому не втримався |
|---|---|---|
| 1. Масив рядків + RC4-шифрування | Усі ~500 рядкових літералів зашифровані, декодуються у runtime через U(idx, key) | Самодостатнє. Обчисли U() один раз — і статично розшифруй кожен виклик. |
| 2. Ротація масиву рядків | Масив крутиться IIFE, поки не зійдеться контрольна сума | Ротація відбувається на старті. Дай їй відпрацювати, далі читай уже повернений масив. |
3. Відбиток середовища (h()) | XOR-ить 0x5f3759df зі значеннями .length вбудованих методів | Ці значення однакові у будь-якому стандартному JS-рушії. Жодної реальної прив'язки. |
| 4. Шифрування байткоду (RC4) | Блоб байткоду шифрується ключем, похідним від h() | Щойно h() обчислено, дешифрування — це один рядок коду. |
5. Бінарна серіалізація (B()) | Кастомний формат зі зігзаг-varint'ами і умовними полями під керуванням прапорів | Не переписуй його. Інструментуй. Хай обфускатор декодує сам себе. |
6. Перетасування опкодів (b3 + seed на функцію) | Мапує логічні опкоди у перетасовані індекси | PRNG із seed-ом. Маючи seed і алгоритм — реконструюється. |
7. XOR операндів (blockKey, jumpKey) | Кожен опкод і кожна ціль переходу XOR-яться з ключем функції | Простий XOR. Один відомий plaintext — і ключ у руках. |
8. Шифрування значень стеку (seKey) | Цілочисельні значення XOR-яться з ключем при пушу в стек VM | Застосовується лише до цілих. Float-и, рядки, об'єкти зберігаються відкрито. |
| 9. Anti-debug таймінги + інтерпретатор VM | Таймінг-перевірки псують таблицю опкодів при покроковому виконанні; кастомна VM на 1 500 рядків диспетчеризує кожен опкод | Інструментування біжить на повній швидкості. VM і є інверсія — інструментуй dispatch один раз і отримуй усе. |
Що насправді під загрозою
Випадок, до якого я постійно повертаюся, — це той, де константи і потік керування і є IP: функція перевірки ліцензії, ворота «тріал-vs-платний», валідатор токенів, що вирішує, чи отримає користувач фічу. Увесь захист тут — «зроби читання дорогим», і саме цей захист щойно зрушив. Конкурент, якому раніше потрібен був сеньйор-реверс-інженер і тиждень, тепер обходиться API-ключем і кавовою перервою. Код торгових стратегій, логіка ранжування, антифрод-евристики, рекомендаційні алгоритми — будь-що, що є функцією, відвантаженою у браузер, сидить у тій самій категорії.
Друге місце, куди це б'є боляче, — anti-cheat та anti-tamper у браузерних іграх і DRM, де вся модель загроз припускала дні роботи зловмисника на шар. Розробники чітів і ті, хто здирає DRM, тепер можуть ітеруватися проти нових релізів усередині патч-циклу, а не плентатися тижнями позаду. Чи стане це справжньою практичною проблемою — залежить від організованості атакуючих; я ще не бачив публічних доказів LLM-керованої розробки чітів, але градієнт вартості тепер хилиться у бік не на користь захисникам.
Під усім цим — те саме спостереження: купа рішень про закупівлю обфускації приймалися на основі рівняння «вартість атаки», що передбачало дні експертної роботи на шар. Ті самі захисти, що раніше купували рік запасу часу проти атакуючого, який готовий був попотіти, тепер купують пів дня проти будь-якого інженера з акаунтом Claude.
Чесні обмеження
Два продукти, два демо-файли, обидва обрані самими вендорами для реклами своїх дефолтів. Дефолтні профілі поширених JS-обфускаторів більше не піднімають вартість деобфускації настільки, щоб це мало значення проти спроможної LLM зразка 2026 року — це структурне твердження, і воно тепер підкріплене двома прогонами проти повністю різних наборів примітивів. Чого я не тестував — це платних надбудов поверх цих дефолтів: Code Locks від JScrambler (виконання, прив'язане до середовища), Self-Defending перевірки цілісності, Anti-Debugging пастки, Domain Locks — кожна додає реальну перешкоду. Інформацієзнищувальні перетворення — ті, що не залишають інверсії у бандлі — теж окремий експеримент. І те, і те варте окремого посту.
Де ми опиняємося
Цікаве питання не в тому, чи можна цю обфускацію зламати — можна, і рік тому теж можна було — і взагалі мінімізований код насправді ніколи не був схований. Питання в тому, що перестає бути захищеним, коли ціна злому падає з днів-експерта до хвилин-API-виклику. Чесна відповідь для цієї родини технік: небагато.
Якщо ви сьогодні відвантажуєте обфусковану JavaScript, ось експеримент, який варто прогнати самостійно — перш ніж дізнатися публічно, що ж саме ви відвантажуєте. І так — я будую сучасну версію на AfterPack. Підпишіться, щоб спробувати її першими!