Tomé dos ofuscadores de JavaScript — uno popular de código abierto (javascript-obfuscator, en su modo más fuerte de «ofuscación VM») y uno comercial de gama empresarial (JScrambler) — y le di a Claude Code la demo insignia que cada proveedor publica, acompañada de una instrucción de cuatro párrafos.
Diez minutos para el primero, veinte para el segundo. Los dos volvieron como código fuente limpio. 💣
¿Significa esto que la ofuscación de JavaScript que hoy protege a las aplicaciones web de la ingeniería inversa y los clones está acabada? Vamos a averiguarlo.
Los dos objetivos son las demos propias de los proveedores — programas de 5 a 13 líneas inflados a 24-68 KB por una sobrecarga de ofuscación de 150-200×, una proporción que no se da en bases de código reales. Y antes de la objeción «pero producción es más grande»: producción es más fácil para Claude, no más difícil. Una app de 1 MB o reparte la misma fuerza de ofuscación amortizada sobre todo el bundle (cada función no más dura que estas demos) o — lo más habitual — sólo las funciones críticas reciben protección fuerte y el resto se envía legible, dándole a Claude el contexto semántico de lo que la función protegida probablemente hace. La pieza de demostración del proveedor es el peor caso para el atacante, no el fácil.
El montaje
La entrada es la función calculatePrice(quantity, unitPrice) de 13 líneas que javascript-obfuscator publica en su landing para presumir del modo VM — su demo, su función, la que ellos eligieron como escaparate. Pásala por su herramienta con el modo más fuerte activado y devuelve 1.587 líneas, 68 KB en disco, unas 194× el tamaño original. Dentro de esa salida: nueve capas defensivas componibles envolviendo un intérprete de VM basada en pila hecho a medida de unas 1.500 líneas (desglose completo en una tabla más abajo).
Le di el archivo ofuscado a Claude Opus 4.6 dentro de Claude Code junto con una instrucción de cuatro párrafos. No le dije de qué ofuscador venía el archivo, no preprocesé nada, no preparé ninguna herramienta.
La instrucción completa que envié (4 párrafos)
| 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. |
La entrada ofuscada — archivo completo (~80 KB)
| 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)); |
Antes que cualquier otra cosa, el agente hizo lo que haría una persona — leer el archivo. Cuatro veces, de hecho, recorriendo el runtime de la VM por tramos. Después corrió el archivo ofuscado una vez sólo para confirmar la línea base: o(10, 20) devuelve 170. El mismo número al que tendría que aterrizar tras la desofuscación.
El plan que escribió
Claude devolvió un plan de seis pasos antes de tocar código. Acertó con la estructura del bundle a la primera lectura — un IIFE arriba barajando un array de strings, un intérprete de VM de unas 1.500 líneas en el medio, un blob de bytecode cifrado con base64+RC4 abajo, y un pequeño punto de entrada que llama a la VM.
El plan completo de 6 pasos, tal como lo escribió 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). |
El primer intento fue un archivo dios
Claude escribió un único deobfuscate.js de 883 líneas que trataba de hacer todo el trabajo de una sola pasada — evaluar el descifrador del array de strings, descifrar cada llamada U(idx, key), ejecutar la huella de entorno h(), usarla como clave RC4 para descifrar el blob de bytecode, reimplementar el deserializador binario custom (la única pieza que nadie fuera de javascript-obfuscator ha visto), desensamblar, emitir JavaScript equivalente.
La primera mitad funcionó. Descifrado de strings: hecho — 500 llamadas únicas a U() descifradas en una pasada. h() evaluó al 0xa19722e9 esperado. Descifrado del bytecode: buffer de bytes limpio en la salida.
La segunda mitad no. El deserializador usa un formato binario custom — varints codificados en zigzag, campos condicionales gobernados por una máscara de flags, nombres de propiedad con alias. Reimplementarlo leyendo el código ofuscado produjo basura: byte de versión equivocado, número de parámetros negativo, cero instrucciones. Hace cinco años el artículo habría terminado ahí. Claude se encogió de hombros, escribió un instrument.js de 286 líneas para parchear la VM en ejecución, chocó con un problema de sandbox al primer intento, y cambió de estrategia al instante — «el sandbox es demasiado restrictivo, voy a usar un enfoque más simple: crear una copia modificada que registre desde dentro».
El archivo dios deobfuscate.js — estructura (pasos 1-3 de la pasada fallida)
| 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. |
Dejó de reimplementar y empezó a instrumentar
Entonces cambió la estrategia. Claude no golpeó más fuerte contra el deserializador; parcheó el archivo ofuscado en ejecución. Envolvió el propio B() del ofuscador para que JSON.stringify registrara su salida, envolvió el bucle de despacho para registrar cada opcode, operando y mutación de pila, y luego ejecutó el archivo parcheado una vez capturando todo por stdout.
Una sola ejecución produjo la imagen completa: paramCount 2, localCount 3, constantes [0.15, 100, 1, "calculatePrice"], block key 54, jump key 9643, clave de cifrado de pila 4168320119, y el flujo de bytecode de 22 instrucciones — además de una traza paso a paso de cada mutación de pila.
Mirando esto en directo, lo que no paraba de pensar era: la instrumentación es la primera cosa que habría probado un buen ingeniero inverso, no la última. El agente razonó hasta llegar al movimiento obvio desde un punto de partida nada obvio, en un solo pivote, sin que yo le sugiriera nada.
No reimplementes lo que puedes instrumentar. El programa ya sabe cómo ejecutarse.
Desensambló la VM, nombró cada opcode y emitió código fuente
Con el bytecode en la mano, Claude lo recorrió. Hizo XOR de cada opcode contra blockKey=54 para recuperar su índice lógico, buscó el índice en la tabla de barajado b3 para identificar la operación, y luego nombró los opcodes en términos humanos — PUSH_CONST, STORE_LOCAL, LOAD_ARG, MUL, SUB, LOAD_LOCAL, GT, JMP_FALSE, DUP, POP, RETURN. Resolvió el destino del salto vía jumpKey=9643 y recorrió las 22 instrucciones de arriba abajo, emitiendo JavaScript equivalente a medida.
Para que se entienda: tengo unos 15 años escribiendo JavaScript, me manejo con un depurador, y ésta es la parte del trabajo en la que yo habría perdido la mayor parte de una semana. Leer 1.500 líneas de código de despacho, seguir qué operando se XOR-ea con qué clave, construir un modelo mental de la VM basada en pila, identificar cada opcode trazando su comportamiento — eso es una rutina cuidadosa, propensa a errores y de varios días. Claude lo hizo en lo que tardo en preparar un café, con una sola instrucción, sin herramientas y sin antecedentes sobre este ofuscador. Lo que acaba de pasar merece decirse explícitamente: el agente no sugirió un enfoque de desofuscación para que yo lo probara, produjo el artefacto — archivo entra, código sale, con el intento fallido al lado del que funciona en el mismo directorio.
disassemble.js — el script que Claude escribió para convertir el bytecode en código fuente (archivo completo)
| 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 | } |
Lo que Claude produjo en realidad
Cuando paró, Claude había montado un directorio de trabajo completo: el archivo ofuscado original, el código recuperado, una nota con cada técnica usada, el intento fallido del archivo dios, la primera instrumentación abandonada, la segunda que sí funcionó, el archivo ofuscado parcheado que generó, y el desensamblador final. Se autoescribió el árbol.
Cuando le pregunté después qué archivos hicieron realmente el trabajo, el resumen vino sin pedirlo y exactamente correcto.
El código fuente recuperado — lo que Claude reconstruyó
| 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 |
El código fuente real original — lo que se metió en 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)); |
El código recuperado se ejecuta idénticamente al original en todas las entradas que probé, incluido el caso límite. Lo que no recupera son los nombres — quantity, unitPrice volvió como price, quantity, las dos constantes SECRET_* volvieron como taxRate y threshold (los valores numéricos 0.15 y 100 se preservaron sin cambios porque tienen que estar en el bytecode para que la VM corra). El orden de argumentos y los nombres de identificador se infieren del comportamiento, no se recuperan. El ofuscador esconde lo que se le permite esconder y preserva lo que la VM necesita en runtime — y resulta que lo que la VM necesita en runtime ya basta para que un LLM lea el programa.
Después lo intenté con JScrambler — uno de pago
Mismo experimento, otro proveedor. Cogí la demo «Javascript Racer» que publica JScrambler — un módulo de sprite-atlas de fondo que usan para anunciar su perfil de protección por defecto — y le di a Claude Code una instrucción de la misma forma. Otro ofuscador, otras técnicas, producto de pago.
Claude leyó el archivo una vez y al instante tenía la estructura desplegada:
- Un registro de namespace llamado
a20f7. - Un blob de strings codificado en URL con clave XOR.
- Una tabla de índices 3D usada como etiquetas enteras opacas.
- Un «decodificador autorreemplazante» que se ceba para exactamente 8 llamadas y luego degenera en un look-up directo.
- La carga útil real, escondida debajo de todo eso, construyendo un objeto llamado
BACKGROUND.
Nada de esto estaba en la instrucción. Lo leyó del propio archivo.
Lo interesante es lo que JScrambler eligió hacer distinto. Aquí no hay VM de bytecode — usan aplanamiento de flujo de control con máquina de estados tipo switch, la forma de manual while (state !== END) { switch (state) { … } }, anidada tan profundo como el árbol de expresiones original. Sin RC4 — los strings vienen de un blob codificado en URL con una clave XOR cíclica y luego se parten por un delimitador. Sin chequeos anti-debug por tiempos — en su lugar, una «secuencia de cebado disfrazada» que aparenta validar el contenido de strings cuando en realidad sólo llama a la función de look-up en un orden preciso para avanzar un contador interno. Primitivas completamente distintas. La misma forma de primitivas. El mismo arco de seis pasos de la pasada con javascript-obfuscator — descifrar strings, limpiar el runtime, extraer estado, recorrer el control de flujo, reconstruir, documentar — se trasladó casi sin cambios. El pivote a instrumentación del que dependía la primera corrida ni siquiera hizo falta: el análisis estático llevó la entrada a texto claro sin ejecutar nunca el código ofuscado.
24.620 bytes de salida de JScrambler. Cinco líneas de código fuente. Unos 20 minutos, Opus 4.7 con el thinking al máximo. Más largo que la pasada de javascript-obfuscator, todavía bien dentro del territorio «minutos de una llamada a la API», muy lejos de «días de un experto».
El código fuente recuperado — los 24 KB de JScrambler colapsados a 5 líneas
| 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 | }; |
Por qué esto no aguantó
Cuatro razones estructurales que aplican a las dos pasadas — y predicen qué funciona y qué no funcionará a continuación.
1. El inverso tiene que vivir en el bundle. Cada defensa de esta familia envía su propio deshacer — el decodificador del string cifrado, la clave de barajado de la tabla de opcodes, los valores fuente de la huella de entorno — porque si el inverso no estuviera en el bundle, el programa no correría. Eso vuelve a toda la familia recuperable en principio. La única pregunta real es el coste.
2. Las transformaciones secuenciales se desenrollan una a una. Cuando las capas se componen como t₁ ∘ t₂ ∘ … ∘ tₙ, el inverso es simplemente la composición al revés. Los LLM son fluidos reconociendo e invirtiendo familias individuales de transformaciones — rotación de array de strings, RC4, base64, XOR-with-constant, Fisher-Yates con semilla (javascript-obfuscator usa alguna combinación de todas ellas) — porque han visto miles de cada una en el entrenamiento. Derrotar n capas cuesta del orden de n unidades de trabajo en lugar de las 2ⁿ que tendrías con transformaciones realmente entrelazadas. Nueve capas se vuelven nueve turnos de modelo, cuando el ofuscador probablemente esperaba nueve días-ingeniero.
3. Una VM es un único punto de fallo. La VM parece un salto adelante porque el programa lógico ahora está en bytecode custom, no en JavaScript. Pero la cosa que convierte ese bytecode en comportamiento — el intérprete — está ahí mismo en el bundle. Instrumenta su bucle de despacho una vez y has decodificado cada función que se ejecutará. Los chequeos anti-debug por tiempos sólo se disparan cuando un humano avanza despacio con un breakpoint; la instrumentación automática corre a velocidad plena y nunca los toca. La huella de entorno basada en valores estándar .length de built-ins da el mismo número en cualquier motor JavaScript, así que el vínculo de runtime es cosmético.
4. Los LLM aplastaron el suelo de habilidad. Nada de esto era irrompible antes de los LLM — hay papers de hace una década sobre revertir aplanamiento de flujo de control a mano. Lo que cambió es quién lo puede hacer y cuánto tarda. El suelo de habilidad cayó de «ingeniero inverso experto con herramientas» a «cualquier ingeniero con acceso a una IA», el reloj cayó de días a minutos, y los nombres — que solían ser la única cosa que los ingenieros inversos tenían que fabricar de cero — ahora vuelven gratis desde el contexto semántico.
Las nueve capas defensivas, y por qué cada una cayó
| Capa | Qué hace | Por qué no aguantó |
|---|---|---|
| 1. Array de strings + cifrado RC4 | Los ~500 literales de string cifrados, decodificados en runtime vía U(idx, key) | Autocontenida. Evalúas U() una vez y descifras estáticamente cada llamada. |
| 2. Rotación del array de strings | El array lo rota un IIFE hasta que cuadra un checksum | La rotación corre al arranque. Déjala correr y luego lees el array rotado. |
3. Huella de entorno (h()) | XOR-ea 0x5f3759df con valores .length de built-ins | Esos valores son idénticos en todo motor JS estándar. No hay vínculo real. |
| 4. Cifrado de bytecode (RC4) | Blob de bytecode cifrado con una clave derivada de h() | En cuanto h() está evaluado, descifrar es una línea de código. |
5. Serialización binaria (B()) | Formato custom de varints zigzag con campos condicionales por flag | No lo reimplementes. Instruméntalo. Deja que el ofuscador se decodifique solo. |
6. Barajado de opcodes (tabla b3 + semilla por función) | Mapea opcodes lógicos a índices barajados | PRNG con semilla. Reconstruible una vez tienes semilla y algoritmo. |
7. XOR de operandos (blockKey, jumpKey) | Cada opcode y destino de salto XOR-eado con una clave por función | XOR simple. Un plaintext conocido recupera la clave. |
8. Cifrado de valores de pila (seKey) | Valores enteros XOR-eados con una clave al empujarse a la pila VM | Sólo aplicado a enteros. Floats, strings y objetos se guardan en claro. |
| 9. Anti-debug por tiempos + intérprete VM | Los chequeos de tiempos corrompen la tabla de opcodes si se hace single-step; VM custom de 1.500 líneas despacha cada opcode | La instrumentación corre a velocidad plena. La VM es el inverso — instrumenta el despacho una vez y lo tienes todo. |
Qué está realmente en riesgo
El caso al que vuelvo una y otra vez es aquel en el que las constantes y el control de flujo son el IP — una función de verificación de licencia, una puerta entre prueba y pago, un validador de token que decide si el usuario obtiene la función. La defensa entera en ese caso es «que sea caro de leer», y esa defensa es lo que acaba de moverse. Un competidor que necesitaba un ingeniero inverso senior y una semana ahora necesita una clave de API y una pausa para café. Código de estrategia de trading, lógica de ranking, heurísticas anti-fraude, algoritmos de recomendación — cualquier cosa que sea una función enviada al navegador cae en el mismo cajón.
El otro sitio donde esto golpea fuerte es el anti-cheat y el anti-manipulación en juegos de navegador y DRM, donde todo el modelo de amenaza asumía días de trabajo del atacante por capa. Los desarrolladores de cheats y los que despojan DRM ahora pueden iterar contra nuevos lanzamientos dentro del ciclo de parche en lugar de ir semanas por detrás. Si esto se convierte en un problema práctico real depende de lo organizados que estén los atacantes; aún no he visto evidencia pública de desarrollo de cheats impulsado por LLM, pero el gradiente de coste apunta ahora en la dirección equivocada para los defensores.
Debajo de todo eso está la misma observación: muchas decisiones de compra de ofuscación se tomaron sobre una ecuación de coste de ataque que asumía días de trabajo experto por capa. Las mismas defensas que solían comprar un año de margen contra el tipo de atacante que se molestaba en intentarlo ahora compran una tarde contra cualquier ingeniero con cuenta de Claude.
Límites honestos
Dos productos, dos archivos de demo, ambos elegidos por los proveedores para anunciar sus configuraciones por defecto. Los perfiles por defecto de los ofuscadores JS dominantes ya no elevan el coste de desofuscación lo suficiente como para importar frente a un LLM capaz de la era 2026 — esa es la afirmación estructural, y ahora está respaldada por dos pasadas contra conjuntos de primitivas completamente distintos. Lo que no he probado son los complementos de pago que se sientan encima de esos perfiles: los Code Locks de JScrambler (puertas de ejecución atadas al entorno), las comprobaciones de integridad Self-Defending, las trampas Anti-Debugging, los Domain Locks — cada uno añade un obstáculo real. Las transformaciones que destruyen información — las que no preservan un inverso en ninguna parte del bundle — son también un experimento aparte. Ambos merecen un post de seguimiento.
Dónde nos deja esto
La pregunta interesante no es si esta ofuscación puede romperse — sí puede, y ya podía hace un año — y además el código minificado nunca estuvo realmente escondido para empezar. La pregunta es qué deja de ser defendible cuando el coste de romperlo cae de días-de-experto a minutos-de-llamada-API. La respuesta honesta para esta familia de técnicas es: no mucho.
Si hoy envías JavaScript ofuscado, éste es el experimento que toca hacer tú mismo antes de saber, públicamente, qué estás enviando. Y sí — estoy construyendo uno moderno en AfterPack. ¡Suscríbete para ser de los primeros en probarlo!