मैंने दो JavaScript ओबफस्केटर्स लिए — एक लोकप्रिय ओपन-सोर्स वाला (javascript-obfuscator, उनके सबसे मज़बूत «VM ओबफस्केशन» मोड में) और एक एंटरप्राइज़ कमर्शियल (JScrambler) — और हर वेंडर का अपना फ्लैगशिप डेमो Claude Code को चार पैराग्राफ के एक प्रॉम्प्ट के साथ दे दिया।
पहले पर दस मिनट, दूसरे पर बीस। दोनों साफ़ सोर्स कोड के रूप में लौट आए! 💣
क्या इसका मतलब है कि आज की JavaScript ओबफस्केशन — वह जो वेब ऐप्स को रिवर्स-इंजीनियरिंग और नकलची लोगों से बचाती है — ख़त्म है? आइए पता लगाते हैं।
दोनों टार्गेट वेंडर्स के अपने डेमो हैं — 5-13 लाइन के प्रोग्राम जो 150-200× ओबफस्केशन ओवरहेड से फूलकर 24-68 KB बन गए, असली कोडबेस में यह अनुपात नहीं मिलता। और «लेकिन प्रोडक्शन तो बड़ा होता है» वाली आपत्ति आने से पहले: प्रोडक्शन Claude के लिए ज़्यादा आसान है, मुश्किल नहीं। 1 MB का ऐप या तो उतनी ही ओबफस्केशन ताक़त पूरे बंडल में बाँट देता है (हर फ़ंक्शन इन डेमो से कठिन नहीं), या — ज़्यादा आम — सिर्फ़ क्रिटिकल फ़ंक्शन को भारी प्रोटेक्ट किया जाता है और बाक़ी पठनीय जाता है, जिससे Claude को सेमांटिक संदर्भ मिल जाता है कि प्रोटेक्टेड फ़ंक्शन क्या कर रहा होगा। वेंडर का खिलौना नमूना हमलावर के लिए सबसे ख़राब केस है, आसान नहीं।
सेटअप
इनपुट वही 13-लाइन का calculatePrice(quantity, unitPrice) है जिसे javascript-obfuscator अपने लैंडिंग पेज पर VM मोड दिखाने के लिए छापता है — उनका डेमो, उनका फ़ंक्शन, जिसे उन्होंने ख़ुद दिखाने के लिए चुना। उसे उनके ही टूल से सबसे मज़बूत मोड में चलाओ और वापस मिलती है 1,587 लाइनें, डिस्क पर 68 KB, मूल आकार का लगभग 194 गुना। उस आउटपुट के अंदर: नौ कम्पोज़ेबल डिफ़ेन्स लेयर्स, जो लगभग 1,500 लाइन के एक कस्टम स्टैक-आधारित VM इंटरप्रेटर को लपेटे हुए हैं (पूरा ब्रेकडाउन नीचे एक टेबल में)।
मैंने ओबफस्केटेड फ़ाइल Claude Code के अंदर Claude Opus 4.6 को दी, साथ में चार पैराग्राफ का प्रॉम्प्ट। मैंने यह नहीं बताया कि फ़ाइल किस ओबफस्केटर की है, कुछ प्री-प्रोसेस नहीं किया, पहले से कोई टूलिंग नहीं बनाई।
मैंने भेजा पूरा प्रॉम्प्ट (4 पैराग्राफ)
| 1 | Hi! I have a complex task for you. |
| 2 | |
| 3 | This is the obfuscated js code file, and I want you to iterate |
| 4 | multiple times and help me to find the closest possible original |
| 5 | code used before obfuscation and place it to source.js, |
| 6 | basically deobfuscate this file. |
| 7 | |
| 8 | This obfuscation is using new "VM obfuscation" of javascript-obfuscator — |
| 9 | and you'd need to iterate multiple times to simplify it, understand |
| 10 | semantics, methods used etc — to properly deobfuscate. Work for as |
| 11 | long as you need to find the closest to original code possible, use |
| 12 | different methodics, multiple planning stages as you need them, |
| 13 | write temp files to this directory as many times as you |
| 14 | need etc — it's yours to reverse. |
| 15 | |
| 16 | This is used to benchmark whether javascript-obfuscator deobfuscation claim |
| 17 | is real — and to estimate whether their VM approach is solid. |
| 18 | |
| 19 | I expect 2 outputs: |
| 20 | - the closest deobfuscated file closest to source code as much as |
| 21 | possible |
| 22 | - learnings on what obfuscation techniques are used and how strong |
| 23 | they are |
| 24 | |
| 25 | If you need to be in execution mode, please proceed in execution mode. |
ओबफस्केटेड इनपुट — पूरी फ़ाइल (~80 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)); |
किसी और चीज़ से पहले, एजेंट ने वही किया जो कोई इंसान करता — फ़ाइल पढ़ी। दरअसल चार बार, VM रनटाइम को टुकड़ों में निकालते हुए। फिर ओबफस्केटेड फ़ाइल को एक बार चलाया सिर्फ़ बेसलाइन कन्फ़र्म करने के लिए: o(10, 20) रिटर्न करता है 170। यही वह नंबर है जिस पर डीओबफस्केशन के बाद वापस आना है।
इसने जो प्लान लिखा
Claude ने कोड छूने से पहले छह-चरण का एक प्लान लौटाया। पहली ही पढ़ाई में बंडल का स्ट्रक्चर सही पकड़ लिया — ऊपर एक IIFE जो स्ट्रिंग ऐरे को घुमा रहा है, बीच में लगभग 1,500 लाइन का VM इंटरप्रेटर, नीचे base64+RC4 से एन्क्रिप्टेड बायटकोड ब्लॉब, और एक छोटा एंट्री-पॉइंट जो VM को कॉल करता है।
पूरा 6-चरण प्लान, जैसा Claude ने लिखा
| 1 | The obfuscated file is ~1,587 lines but the actual program is tiny — |
| 2 | it's encoded as bytecode executed by a custom stack-based VM |
| 3 | interpreter. |
| 4 | |
| 5 | Structure of the obfuscated code: |
| 6 | 1. String array + rotation (lines 1-11): classic javascript-obfuscator |
| 7 | string-array shuffling |
| 8 | 2. String decryption U() (lines 1549-1585): RC4-based string |
| 9 | decryption |
| 10 | 3. VM runtime p (lines 14-1534): ~1,500 lines of custom bytecode |
| 11 | interpreter |
| 12 | 4. Bytecode storage (N[0]): base64+RC4 encrypted bytecode blob |
| 13 | 5. Entry point (lines 1535-1587): function o(N,A) { return |
| 14 | p.call(this, 0x0, Array.from(arguments), undefined, o); } |
| 15 | then console.log(o(10, 20)) |
| 16 | |
| 17 | Deobfuscation approach: |
| 18 | Step 1 — Decrypt all strings: evaluate b() and U(), replace every |
| 19 | U(hex, 'key') call with its decrypted value |
| 20 | Step 2 — Clean up the VM runtime: replace obfuscated property |
| 21 | accesses with readable names; map VM internals to |
| 22 | meaningful names (stack, IP, constants, locals…) |
| 23 | Step 3 — Extract and decode bytecode: base64 → RC4 → deserialize. |
| 24 | The RC4 key comes from h() — environment fingerprinting |
| 25 | Step 4 — Disassemble bytecode to readable opcodes: map the b3 |
| 26 | shuffle table to logical operations; walk the instruction |
| 27 | stream |
| 28 | Step 5 — Reconstruct original JavaScript from the disassembly |
| 29 | Step 6 — Document the techniques used |
| 30 | |
| 31 | Verification: run both files in Node.js, both should produce the |
| 32 | same output for o(10, 20). |
पहली कोशिश एक गॉड-फ़ाइल थी
Claude ने एक अकेली 883-लाइन की deobfuscate.js लिखी जो पूरा काम एक ही पास में निपटाना चाहती थी — स्ट्रिंग-ऐरे डिक्रिप्टर को इवैल्यूएट करना, हर U(idx, key) कॉल को डिक्रिप्ट करना, एन्वायरनमेंट फ़िंगरप्रिंट h() चलाना, उसे RC4 की कुंजी की तरह इस्तेमाल कर बायटकोड ब्लॉब डिक्रिप्ट करना, कस्टम बाइनरी डिसीरियलाइज़र को फिर से लागू करना (यह वह हिस्सा है जिसे javascript-obfuscator के बाहर किसी ने नहीं देखा), डिसैसेम्बल करना, और बराबर का JavaScript निकालना।
पहला आधा हिस्सा चल गया। स्ट्रिंग डिक्रिप्शन: हो गया — एक ही रन में 500 यूनीक U() कॉल्स डिक्रिप्ट। h() इवैल्यूएट होकर अपेक्षित 0xa19722e9 पर पहुँचा। बायटकोड डिक्रिप्शन: साफ़ बाइट बफ़र बाहर।
दूसरा आधा नहीं चला। डिसीरियलाइज़र एक कस्टम बाइनरी फ़ॉर्मैट इस्तेमाल करता है — ज़िगज़ैग-एनकोडेड वैरिंट्स, फ़्लैग-बिटमास्क से नियंत्रित कंडीशनल फ़ील्ड्स, और एलियास्ड प्रॉपर्टी नाम। ओबफस्केटेड सोर्स पढ़कर उसे फिर से लागू करने से कचरा निकला: ग़लत वर्ज़न बाइट, नेगेटिव पैरामीटर काउंट, शून्य इंस्ट्रक्शन। पाँच साल पहले पोस्ट यहीं ख़त्म होती। Claude ने कंधे उचकाए, चलते हुए VM पर पैच लगाने के लिए 286-लाइन की instrument.js लिखी, पहली ही कोशिश में सैंडबॉक्सिंग की दिक़्क़त से टकराई, और तुरंत रणनीति बदली — «सैंडबॉक्स बहुत प्रतिबंधात्मक है, मैं और सरल तरीक़ा अपनाता हूँ: एक मॉडिफ़ाइड कॉपी बनाओ जो भीतर से लॉग करे।»
गॉड-फ़ाइल deobfuscate.js — स्ट्रक्चर (फ़ेल हुए पास के स्टेप्स 1-3)
| 1 | #!/usr/bin/env node |
| 2 | /** |
| 3 | * Deobfuscator for javascript-obfuscator VM-obfuscated JavaScript. |
| 4 | * |
| 5 | * Strategy: |
| 6 | * 1. Evaluate the string-array + RC4 decryptor from the obfuscated file |
| 7 | * 2. Use it to decrypt every U(idx, key) call |
| 8 | * 3. Evaluate h() to get the environment fingerprint |
| 9 | * 4. Decode N[0] bytecode blob: base64 → RC4 → B() deserialize |
| 10 | * 5. Disassemble the bytecode instruction stream |
| 11 | * 6. Reconstruct the original JavaScript |
| 12 | */ |
| 13 | |
| 14 | const fs = require("fs"); |
| 15 | const path = require("path"); |
| 16 | const vm = require("vm"); |
| 17 | |
| 18 | const src = fs.readFileSync(path.join(__dirname, "obfuscated.js"), "utf8"); |
| 19 | |
| 20 | // ── Step 1: Bootstrap the string decryption ─────────────────────────────── |
| 21 | // Extract b() (string array), U() (RC4 decryptor), and the rotation IIFE |
| 22 | // from the source, then evaluate them in an isolated VM context. |
| 23 | |
| 24 | const bFuncMatch = src.match(/function b\(\)\s*\{[\s\S]*?return b\(\);\s*\}/); |
| 25 | const uFuncMatch = src.match(/function U\(Z, O\)\s*\{[\s\S]*?return.*?g;\s*\}/); |
| 26 | const rotationMatch = src.match( |
| 27 | /^\(function \(N, A\)\s*\{[\s\S]*?\(b, 0x[a-f0-9]+\)\);/m, |
| 28 | ); |
| 29 | |
| 30 | const sandbox = { U: null, b: null, parseInt, String, decodeURIComponent }; |
| 31 | vm.createContext(sandbox); |
| 32 | vm.runInContext( |
| 33 | `${bFuncMatch[0]}\n${uFuncMatch[0]}\n${rotationMatch[0]}`, |
| 34 | sandbox, |
| 35 | ); |
| 36 | const U = sandbox.U; |
| 37 | |
| 38 | // ── Step 2: Decrypt every U() call site ─────────────────────────────────── |
| 39 | const uCallPattern = /U\((?:'(0x[a-f0-9]+)'|(0x[a-f0-9]+)),\s*'([^']+)'\)/g; |
| 40 | const decryptedStrings = new Map(); |
| 41 | let match; |
| 42 | while ((match = uCallPattern.exec(src)) !== null) { |
| 43 | const idx = match[1] || match[2]; |
| 44 | const key = match[3]; |
| 45 | try { |
| 46 | decryptedStrings.set(match[0], U(idx, key)); |
| 47 | } catch (e) {} |
| 48 | } |
| 49 | |
| 50 | // ── Step 3: Compute the environment fingerprint h() ─────────────────────── |
| 51 | // h() XORs 0x5f3759df with built-in .length values from Array.prototype.push, |
| 52 | // String.prototype.padStart, Math.imul, Object.keys, Array.prototype.indexOf, |
| 53 | // String.prototype.includes — values that are identical across every JS engine. |
| 54 | function h() { |
| 55 | let bk = 0x5f3759df; |
| 56 | bk ^= Array.prototype.push.length << 0x18; // 1 |
| 57 | bk ^= String.prototype.padStart.length << 0x14; // 1 |
| 58 | bk ^= Math.imul.length << 0x10; // 2 |
| 59 | bk ^= Object.keys.length << 0xc; // 1 |
| 60 | bk ^= Array.prototype.indexOf.length << 0x8; // 1 |
| 61 | bk ^= String.prototype.includes.length; // 1 |
| 62 | return bk >>> 0; // → 0xa19722e9 |
| 63 | } |
| 64 | |
| 65 | const envKey = h(); |
| 66 | console.log(`h() = 0x${envKey.toString(16)}`); // 0xa19722e9 ✓ |
| 67 | |
| 68 | // ── Steps 4-6: bytecode decrypt → custom binary deserialize → disassemble. |
| 69 | // This is where it fell over. The B() deserializer uses zigzag varints, |
| 70 | // flag-gated conditional fields, and aliased property names. Reimplementing |
| 71 | // it from the obfuscated source produced: version byte = 0xff (expected 1), |
| 72 | // paramCount = -3, instruction count = 0. Garbage. |
इसने फिर से लागू करना छोड़ा और इंस्ट्रुमेंट करना शुरू किया
फिर रणनीति बदल गई। Claude डिसीरियलाइज़र पर और ज़ोर लगाने के बजाय चलते हुए ओबफस्केटेड फ़ाइल पर पैच लगाने लगा। उसने ओबफस्केटर के अपने B() डिसीरियलाइज़र को लपेटा कि वह अपना आउटपुट JSON.stringify करके लॉग करे, डिस्पैच लूप को लपेटा कि हर ओपकोड, ऑपरेंड और स्टैक म्यूटेशन लॉग करे, फिर पैच की हुई फ़ाइल एक बार चलाई और सब कुछ stdout पर पकड़ लिया।
एक ही रन ने पूरी तस्वीर दे दी: पैरामीटर काउंट 2, लोकल काउंट 3, कॉन्स्टेंट्स [0.15, 100, 1, "calculatePrice"], ब्लॉक की 54, जंप की 9643, स्टैक-एन्क्रिप्शन की 4168320119, और 22 इंस्ट्रक्शन की बायटकोड स्ट्रीम — साथ में हर स्टैक म्यूटेशन का स्टेप-बाय-स्टेप एग्ज़ीक्यूशन ट्रेस।
यह सब देखते हुए मेरे दिमाग़ में जो बात बार-बार आती रही: इंस्ट्रुमेंटेशन वह पहली चीज़ है जिसे कोई काबिल रिवर्स-इंजीनियर आज़माएगा, आख़िरी नहीं। एजेंट ने एक ग़ैर-स्पष्ट शुरुआती बिंदु से उस स्पष्ट क़दम तक तर्क लगाकर पहुँच गया, एक ही pivot में, बिना मेरे किसी इशारे के।
जिसे इंस्ट्रुमेंट किया जा सकता है, उसे फिर से लागू मत करो। प्रोग्राम पहले से जानता है कि ख़ुद को कैसे चलाना है।
इसने VM को डिसैसेम्बल किया, हर ओपकोड को नाम दिया, और सोर्स निकाला
बायटकोड हाथ में आने के बाद Claude ने उसे क़दम-दर-क़दम चलाया। हर ओपकोड को blockKey=54 से XOR करके उसका लॉजिकल इंडेक्स निकाला, इंडेक्स को b3 शफ़ल टेबल में देखा कि कौन-सी ऑपरेशन है, फिर ओपकोड को इंसानी नामों में नाम दिया — PUSH_CONST, STORE_LOCAL, LOAD_ARG, MUL, SUB, LOAD_LOCAL, GT, JMP_FALSE, DUP, POP, RETURN। jumpKey=9643 के ज़रिए जंप टार्गेट हल किया और 22-इंस्ट्रक्शन की स्ट्रीम को ऊपर से नीचे चलाते हुए साथ-साथ बराबर का JavaScript निकाला।
थोड़ा संदर्भ: मुझे JavaScript लिखते क़रीब 15 साल हो गए, डिबगर से अच्छा परिचय है, और काम का यही वह हिस्सा है जिसमें मैं हफ़्ते का ज़्यादातर हिस्सा गँवा देता। 1,500 लाइन का डिस्पैच कोड पढ़ना, याद रखना कि कौन-सा ऑपरेंड किस की से XOR हो रहा है, स्टैक-आधारित VM का मानसिक मॉडल बनाना, बर्ताव से यह पता लगाना कि कौन-सा ओपकोड क्या है — यह सावधानी और ग़लती की गुंजाइश वाला, कई दिनों का घिसने वाला काम है। Claude ने इसे एक कॉफ़ी बनाने जितने समय में कर डाला, एक प्रॉम्प्ट पर, बिना किसी टूलिंग के, इस ओबफस्केटर पर कोई पूर्व-जानकारी के बिना। जो अभी हुआ उसे साफ़ कहने लायक़ है: एजेंट ने मुझे आज़माने के लिए कोई डीओबफस्केशन तरीक़ा सुझाया नहीं, उसने आर्टिफ़ैक्ट पैदा कर दिया — फ़ाइल अंदर, सोर्स बाहर, फ़ेल हुई कोशिश ठीक उसी डायरेक्टरी में चलती कोशिश के बग़ल में।
disassemble.js — वह स्क्रिप्ट जिसे Claude ने लिखा और जिसने बायटकोड को सोर्स में बदला (पूरी फ़ाइल)
| 1 | #!/usr/bin/env node |
| 2 | /** |
| 3 | * Final disassembly of the extracted bytecode. |
| 4 | * Uses the raw bytecode data captured from the instrumented run. |
| 5 | */ |
| 6 | |
| 7 | // ── Bytecode metadata (captured from the instrumented obfuscator) ── |
| 8 | const bc = { |
| 9 | paramCount: 2, |
| 10 | localCount: 3, |
| 11 | nameIndex: 3, // constants[3] = "calculatePrice" |
| 12 | blockKey: 54, |
| 13 | jumpKey: 9643, |
| 14 | seKey: 4168320119, |
| 15 | constants: [0.15, 100, 1, "calculatePrice"], |
| 16 | instructions: [ |
| 17 | 357, |
| 18 | 54, |
| 19 | 384, |
| 20 | 52, |
| 21 | 149, |
| 22 | 55, |
| 23 | 384, |
| 24 | 53, |
| 25 | 220, |
| 26 | 54, |
| 27 | 108, |
| 28 | 55, |
| 29 | 38, |
| 30 | null, |
| 31 | 369, |
| 32 | 50, |
| 33 | 158, |
| 34 | 50, |
| 35 | 59, |
| 36 | 53, |
| 37 | 32, |
| 38 | null, |
| 39 | 333, |
| 40 | null, |
| 41 | 451, |
| 42 | 50, |
| 43 | 347, |
| 44 | 52, |
| 45 | 270, |
| 46 | 52, |
| 47 | 438, |
| 48 | null, |
| 49 | 126, |
| 50 | null, |
| 51 | 365, |
| 52 | null, |
| 53 | 217, |
| 54 | 50, |
| 55 | 245, |
| 56 | null, |
| 57 | 158, |
| 58 | 50, |
| 59 | 289, |
| 60 | null, |
| 61 | ], |
| 62 | tryCatch: { 11: 9663 }, |
| 63 | }; |
| 64 | |
| 65 | // ── Opcode mapping (recovered from the dispatch trace) ── |
| 66 | const OPCODE_NAMES = { |
| 67 | 0x0: "PUSH_CONST", |
| 68 | 0x3: "POP", |
| 69 | 0x4: "DUP", |
| 70 | 0x6: "LOAD_LOCAL", |
| 71 | 0x7: "STORE_LOCAL", |
| 72 | 0x8: "LOAD_ARG", |
| 73 | 0xb: "SUB", |
| 74 | 0xc: "MUL", |
| 75 | 0x2e: "GT", |
| 76 | 0x34: "JMP_FALSE", |
| 77 | 0x38: "RETURN", |
| 78 | }; |
| 79 | |
| 80 | // ── The decoded instruction stream ── |
| 81 | // VM applies: Up = raw_opcode XOR blockKey, then SM shuffle → Uo |
| 82 | const traced = [ |
| 83 | { |
| 84 | pc: 0, |
| 85 | op: 0x00, |
| 86 | arg: 0, |
| 87 | name: "PUSH_CONST", |
| 88 | desc: "push constants[0] = 0.15", |
| 89 | }, |
| 90 | { |
| 91 | pc: 1, |
| 92 | op: 0x07, |
| 93 | arg: 2, |
| 94 | name: "STORE_LOCAL", |
| 95 | desc: "local[2] = pop() → taxRate = 0.15", |
| 96 | }, |
| 97 | { |
| 98 | pc: 2, |
| 99 | op: 0x00, |
| 100 | arg: 1, |
| 101 | name: "PUSH_CONST", |
| 102 | desc: "push constants[1] = 100", |
| 103 | }, |
| 104 | { |
| 105 | pc: 3, |
| 106 | op: 0x07, |
| 107 | arg: 3, |
| 108 | name: "STORE_LOCAL", |
| 109 | desc: "local[3] = pop() → threshold = 100", |
| 110 | }, |
| 111 | { pc: 4, op: 0x08, arg: 0, name: "LOAD_ARG", desc: "push args[0] → price" }, |
| 112 | { |
| 113 | pc: 5, |
| 114 | op: 0x08, |
| 115 | arg: 1, |
| 116 | name: "LOAD_ARG", |
| 117 | desc: "push args[1] → quantity", |
| 118 | }, |
| 119 | { |
| 120 | pc: 6, |
| 121 | op: 0x0c, |
| 122 | arg: null, |
| 123 | name: "MUL", |
| 124 | desc: "pop 2, push product → price * quantity", |
| 125 | }, |
| 126 | { |
| 127 | pc: 7, |
| 128 | op: 0x07, |
| 129 | arg: 4, |
| 130 | name: "STORE_LOCAL", |
| 131 | desc: "local[4] = pop() → total", |
| 132 | }, |
| 133 | { |
| 134 | pc: 8, |
| 135 | op: 0x06, |
| 136 | arg: 4, |
| 137 | name: "LOAD_LOCAL", |
| 138 | desc: "push local[4] → total", |
| 139 | }, |
| 140 | { |
| 141 | pc: 9, |
| 142 | op: 0x06, |
| 143 | arg: 3, |
| 144 | name: "LOAD_LOCAL", |
| 145 | desc: "push local[3] → threshold", |
| 146 | }, |
| 147 | { |
| 148 | pc: 10, |
| 149 | op: 0x2e, |
| 150 | arg: null, |
| 151 | name: "GT", |
| 152 | desc: "pop 2, push (total > threshold)", |
| 153 | }, |
| 154 | { |
| 155 | pc: 11, |
| 156 | op: 0x34, |
| 157 | arg: null, |
| 158 | name: "JMP_FALSE", |
| 159 | desc: "if false, jump to pc=20 (9663 ^ 9643 = 20)", |
| 160 | }, |
| 161 | { |
| 162 | pc: 12, |
| 163 | op: 0x06, |
| 164 | arg: 4, |
| 165 | name: "LOAD_LOCAL", |
| 166 | desc: "push local[4] → total", |
| 167 | }, |
| 168 | { |
| 169 | pc: 13, |
| 170 | op: 0x00, |
| 171 | arg: 2, |
| 172 | name: "PUSH_CONST", |
| 173 | desc: "push constants[2] = 1", |
| 174 | }, |
| 175 | { |
| 176 | pc: 14, |
| 177 | op: 0x06, |
| 178 | arg: 2, |
| 179 | name: "LOAD_LOCAL", |
| 180 | desc: "push local[2] → taxRate (0.15)", |
| 181 | }, |
| 182 | { |
| 183 | pc: 15, |
| 184 | op: 0x0b, |
| 185 | arg: null, |
| 186 | name: "SUB", |
| 187 | desc: "pop 2, push (1 - 0.15) = 0.85", |
| 188 | }, |
| 189 | { |
| 190 | pc: 16, |
| 191 | op: 0x0c, |
| 192 | arg: null, |
| 193 | name: "MUL", |
| 194 | desc: "pop 2, push (total * 0.85)", |
| 195 | }, |
| 196 | { pc: 17, op: 0x04, arg: null, name: "DUP", desc: "duplicate TOS" }, |
| 197 | { |
| 198 | pc: 18, |
| 199 | op: 0x07, |
| 200 | arg: 4, |
| 201 | name: "STORE_LOCAL", |
| 202 | desc: "local[4] = pop() → total = discounted", |
| 203 | }, |
| 204 | { pc: 19, op: 0x03, arg: null, name: "POP", desc: "discard extra copy" }, |
| 205 | { |
| 206 | pc: 20, |
| 207 | op: 0x06, |
| 208 | arg: 4, |
| 209 | name: "LOAD_LOCAL", |
| 210 | desc: "push local[4] → total", |
| 211 | }, |
| 212 | { pc: 21, op: 0x38, arg: null, name: "RETURN", desc: "return TOS" }, |
| 213 | ]; |
| 214 | |
| 215 | // ── Reconstruct ── |
| 216 | const source = `function calculatePrice(price, quantity) { |
| 217 | const taxRate = 0.15; |
| 218 | const threshold = 100; |
| 219 | let total = price * quantity; |
| 220 | if (total > threshold) { |
| 221 | total = total * (1 - taxRate); |
| 222 | } |
| 223 | return total; |
| 224 | } |
| 225 | |
| 226 | console.log(calculatePrice(10, 20));`; |
| 227 | |
| 228 | console.log(source); |
| 229 | |
| 230 | // ── Verify behavioral equivalence ── |
| 231 | const calculatePrice = new Function( |
| 232 | "price", |
| 233 | "quantity", |
| 234 | ` |
| 235 | const taxRate = 0.15; |
| 236 | const threshold = 100; |
| 237 | let total = price * quantity; |
| 238 | if (total > threshold) { |
| 239 | total = total * (1 - taxRate); |
| 240 | } |
| 241 | return total; |
| 242 | `, |
| 243 | ); |
| 244 | |
| 245 | const tests = [ |
| 246 | [10, 20, 170], // 200 > 100 → 200 * 0.85 = 170 |
| 247 | [5, 10, 50], // 50 ≤ 100 → 50 |
| 248 | [50, 3, 127.5], // 150 > 100 → 150 * 0.85 = 127.5 |
| 249 | [100, 1, 100], // 100 ≤ 100 → 100 (boundary) |
| 250 | [101, 1, 85.85], // 101 > 100 → 101 * 0.85 = 85.85 |
| 251 | ]; |
| 252 | |
| 253 | for (const [a, b, expected] of tests) { |
| 254 | const actual = calculatePrice(a, b); |
| 255 | console.log( |
| 256 | `calculatePrice(${a}, ${b}) = ${actual} ${ |
| 257 | Math.abs(actual - expected) < 0.0001 ? "✓" : `✗ (expected ${expected})` |
| 258 | }`, |
| 259 | ); |
| 260 | } |
Claude ने असल में क्या तैयार किया
जब वह रुका, तब तक Claude ने एक पूरा वर्किंग डायरेक्टरी खड़ी कर दी थी: मूल ओबफस्केटेड फ़ाइल, रिकवर किया गया सोर्स, इस्तेमाल हुई हर तकनीक का लेख, असफल गॉड-फ़ाइल कोशिश, छोड़ी हुई पहली इंस्ट्रुमेंटेशन, सफल दूसरी, उसने ख़ुद जो पैच की हुई ओबफस्केटेड फ़ाइल बनाई, और अंतिम डिसैसेम्बलर। पूरा फ़ाइल-ट्री ख़ुद ही लिख डाला।
बाद में जब मैंने पूछा कि असल में कौन-सी फ़ाइलें काम कर रही थीं, तो बिना कहे ही एकदम सही recap मिला।
रिकवर किया गया सोर्स — जो Claude ने पुनर्निर्मित किया
| 1 | // Recovered from 1,587 lines of VM-obfuscated code. |
| 2 | // |
| 3 | // Obfuscation layers reversed: |
| 4 | // 1. String array rotation + RC4 decryption (U() with b() array) |
| 5 | // 2. Environment fingerprinting (h() — hashes built-in .length values) |
| 6 | // 3. Bytecode encryption (base64 → RC4 with fingerprint key) |
| 7 | // 4. Bytecode serialization (custom binary format with zigzag varints) |
| 8 | // 5. Opcode shuffling (b3 table + per-function seed permutation) |
| 9 | // 6. Operand encryption (XOR with blockKey=54, jumpKey=9643) |
| 10 | // 7. Stack-value encryption (XOR with seKey=4168320119 for integers) |
| 11 | // 8. Anti-debug timing checks (corrupt opcode table on slow-step) |
| 12 | // 9. Custom stack-based VM interpreter (~1,500 lines, ~100 opcodes) |
| 13 | |
| 14 | function calculatePrice(price, quantity) { |
| 15 | const taxRate = 0.15; |
| 16 | const threshold = 100; |
| 17 | let total = price * quantity; |
| 18 | if (total > threshold) { |
| 19 | total = total * (1 - taxRate); |
| 20 | } |
| 21 | return total; |
| 22 | } |
| 23 | |
| 24 | console.log(calculatePrice(10, 20)); // → 170 |
असली मूल सोर्स — javascript-obfuscator में जो डाला गया था
| 1 | // Simple calculator with secret discount logic |
| 2 | function calculatePrice(quantity, unitPrice) { |
| 3 | const SECRET_DISCOUNT = 0.15; |
| 4 | const SECRET_THRESHOLD = 100; |
| 5 | |
| 6 | let total = quantity * unitPrice; |
| 7 | |
| 8 | if (total > SECRET_THRESHOLD) { |
| 9 | total = total * (1 - SECRET_DISCOUNT); |
| 10 | } |
| 11 | |
| 12 | return total; |
| 13 | } |
| 14 | |
| 15 | // Try it: calculatePrice(10, 20) => 170 |
| 16 | console.log(calculatePrice(10, 20)); |
रिकवर किया गया कोड हर इनपुट पर, सीमा-स्थिति समेत, मूल कोड के समान चलता है। जो वह वापस नहीं लाता वे नाम हैं — quantity, unitPrice price, quantity बनकर लौटे, दोनों SECRET_* कॉन्स्टेंट taxRate और threshold बनकर लौटे (संख्यात्मक मान 0.15 और 100 वैसे ही बने रहे क्योंकि VM के चलने के लिए उन्हें बायटकोड में होना ही पड़ेगा)। आर्ग्युमेंट का क्रम और आइडेंटिफ़ायर के नाम बर्ताव से अनुमानित हैं, रिकवर नहीं किए गए। ओबफस्केटर जो छिपा सकता है उसे छिपाता है और जो VM को रनटाइम पर चाहिए उसे संरक्षित करता है — और साबित हुआ कि VM को रनटाइम पर जो चाहिए वही एक LLM के लिए प्रोग्राम पढ़ लेने को काफ़ी है।
फिर मैंने इसे JScrambler पर आज़माया — एक पेड वाला
वही प्रयोग, अलग वेंडर। मैंने JScrambler का प्रकाशित «Javascript Racer» डेमो उठाया — एक बैकग्राउंड स्प्राइट-एटलस मॉड्यूल जिसे वे अपनी डिफ़ॉल्ट प्रोटेक्शन प्रोफ़ाइल के विज्ञापन के लिए शिप करते हैं — और Claude Code को उसी आकार का प्रॉम्प्ट दिया। अलग ओबफस्केटर, अलग तकनीकें, पेड प्रोडक्ट।
Claude ने फ़ाइल एक बार पढ़ी और स्ट्रक्चर तुरंत साफ़ कर दिया:
a20f7नाम का एक नेमस्पेस रजिस्ट्री।- URL-एनकोडेड XOR-कुंजी वाला स्ट्रिंग ब्लॉब।
- एक 3D इंडेक्स टेबल जिसे अपारदर्शी इंटीजर टैग्स की तरह इस्तेमाल किया गया।
- एक «सेल्फ़-रिप्लेसिंग डीकोडर» जो ख़ुद को ठीक 8 कॉल्स के लिए तैयार करता है और फिर सीधे लुक-अप में सिमट जाता है।
- असली पेलोड, इन सब के नीचे छुपा हुआ, एक
BACKGROUNDनाम का ऑब्जेक्ट बना रहा।
इनमें से कुछ भी प्रॉम्प्ट में नहीं था। इसने सीधे फ़ाइल से पढ़ लिया।
दिलचस्प बात यह है कि JScrambler ने क्या अलग करने का चुनाव किया। यहाँ कोई बायटकोड VM नहीं है — वे स्विच-स्टेट-मशीन वाली कंट्रोल-फ़्लो फ़्लैटनिंग इस्तेमाल करते हैं, पाठ्यपुस्तक वाली while (state !== END) { switch (state) { … } } शक्ल में, मूल अभिव्यक्ति-वृक्ष जितनी गहरी नेस्टेड। कोई RC4 नहीं — स्ट्रिंग्स URL-एनकोडेड ब्लॉब से आती हैं, चक्रीय XOR कुंजी से, फिर एक डिलिमिटर पर बँटती हैं। कोई एंटी-डिबग टाइमिंग नहीं — उसकी जगह एक «छुपी हुई प्राइमिंग सीक्वेंस» है जो स्ट्रिंग सामग्री को सत्यापित करती दिखती है, असल में बस लुक-अप फ़ंक्शन को एक सटीक क्रम में कॉल करके भीतर का काउंटर आगे बढ़ाती है। प्राथमिक उपकरण पूरी तरह अलग। उपकरणों का आकार वही। javascript-obfuscator रन से आया वही छह-चरण का चाप — स्ट्रिंग्स डिक्रिप्ट, रनटाइम साफ़, स्टेट निकालो, कंट्रोल फ़्लो चलाओ, पुनर्निर्माण, दस्तावेज़ीकरण — लगभग ज्यों का त्यों लागू हो गया। जिस इंस्ट्रुमेंटेशन pivot पर पहली बार निर्भर रहना पड़ा था, वह इस बार ज़रूरी ही नहीं था: स्टैटिक एनालिसिस ने इनपुट को बिना ओबफस्केटेड कोड चलाए ही प्लेनटेक्स्ट तक पहुँचा दिया।
JScrambler के 24,620 बाइट आउटपुट। सोर्स की पाँच लाइनें। क़रीब 20 मिनट, Opus 4.7 max thinking के साथ। javascript-obfuscator रन से लंबा, फिर भी «एक API कॉल के मिनटों» के दायरे में सुरक्षित, «एक्सपर्ट के दिनों» से कोसों दूर।
रिकवर किया गया सोर्स — JScrambler के 24 KB सिमटकर 5 लाइनें
| 1 | var BACKGROUND = { |
| 2 | HILLS: { x: 5, y: 5, w: 1280, h: 480 }, |
| 3 | SKY: { x: 5, y: 495, w: 1280, h: 480 }, |
| 4 | TREES: { x: 5, y: 985, w: 1280, h: 480 }, |
| 5 | }; |
यह क्यों नहीं टिका
चार संरचनात्मक कारण जो दोनों रन पर लागू होते हैं — और यह भी बताते हैं कि आगे क्या काम करेगा, क्या नहीं।
1. इन्वर्स बंडल के अंदर रहना ही पड़ता है। इस परिवार के हर डिफ़ेंस के साथ उसका undo भी जाता है — एन्क्रिप्टेड स्ट्रिंग का डीकोडर, ओपकोड टेबल की शफ़ल कुंजी, एन्वायरनमेंट फ़िंगरप्रिंट के स्रोत मान — क्योंकि अगर इन्वर्स बंडल में न हो तो प्रोग्राम चलेगा ही नहीं। इससे यह पूरा परिवार सिद्धांत रूप में रिकवर करने योग्य बन जाता है। असली सवाल बस लागत का है।
2. क्रमिक रूपांतरण एक-एक करके खुलते हैं। जब परतें t₁ ∘ t₂ ∘ … ∘ tₙ जैसी जुड़ी हों, तो इन्वर्स सिर्फ़ उलटा संयोजन है। LLM अकेले रूपांतरण-परिवारों को पहचानने और उलटने में सहज हैं — स्ट्रिंग-ऐरे रोटेशन, RC4, base64, XOR-with-constant, सीडेड फ़िशर-येट्स (javascript-obfuscator इन सबका कोई संयोजन इस्तेमाल करता है) — क्योंकि उन्होंने प्रशिक्षण में हज़ारों ऐसे देखे हैं। n परतें तोड़ने में लगभग n यूनिट काम लगता है, उन 2ⁿ के बजाय जो असली अंतर्संबंधित रूपांतरणों पर लगते। नौ परतें नौ मॉडल-राउंड का काम बन जाती हैं, जबकि ओबफस्केटर शायद नौ इंजीनियर-दिनों की उम्मीद कर रहा था।
3. VM एक अकेला फ़ेल्योर पॉइंट है। VM ऊपर की तरफ़ का क़दम लगता है क्योंकि लॉजिकल प्रोग्राम अब कस्टम बायटकोड में है, JavaScript में नहीं। पर जो चीज़ बायटकोड को बर्ताव में बदलती है — इंटरप्रेटर — वह बंडल में ही बैठा है। उसकी डिस्पैच लूप को एक बार इंस्ट्रुमेंट कर लो और इस प्रोग्राम का हर वह फ़ंक्शन जो कभी चलेगा वह डीकोड हो जाएगा। एंटी-डिबग टाइमिंग चेक तभी ट्रिगर होते हैं जब कोई इंसान ब्रेकपॉइंट से धीरे-धीरे स्टेप कर रहा हो; ऑटोमेटेड इंस्ट्रुमेंटेशन पूरी गति से चलता है और कभी नहीं उछलता। स्टैंडर्ड बिल्ट-इन .length मानों पर आधारित एन्वायरनमेंट फ़िंगरप्रिंट हर JavaScript इंजन पर वही नंबर देता है, इसलिए रनटाइम बाइंडिंग सजावटी ही है।
4. LLM ने स्किल फ़्लोर को ज़मीन पर पटक दिया। यह कुछ भी LLM से पहले अटूट नहीं था — कंट्रोल-फ़्लो फ़्लैटनिंग को हाथ से उलटने पर एक दशक पुराने शोधपत्र मौजूद हैं। बदला यह कि अब यह कौन कर सकता है और कितने समय में। स्किल फ़्लोर «टूलिंग के साथ विशेषज्ञ रिवर्स-इंजीनियर» से गिरकर «AI एक्सेस वाला कोई भी इंजीनियर» तक आ गया, घड़ी दिनों से मिनटों में आ गई, और नाम — जो रिवर्स-इंजीनियर के पास से पहले शून्य से गढ़ने पड़ते थे — अब सेमांटिक संदर्भ से मुफ़्त में लौट आते हैं।
नौ डिफ़ेन्स परतें, और हर एक कैसे टूटी
| परत | यह क्या करता है | क्यों नहीं टिका |
|---|---|---|
| 1. स्ट्रिंग ऐरे + RC4 एन्क्रिप्शन | सभी ~500 स्ट्रिंग लिटरल एन्क्रिप्टेड, रनटाइम पर U(idx, key) के ज़रिए डीकोड | स्व-निहित। U() एक बार इवैल्यूएट करो, हर कॉल स्थैतिक रूप से डिक्रिप्ट हो जाती है। |
| 2. स्ट्रिंग ऐरे रोटेशन | ऐरे को एक IIFE तब तक घुमाता है जब तक चेकसम मेल नहीं खाता | रोटेशन स्टार्टअप पर ही चलता है। उसे चलने दो, फिर घुमाया हुआ ऐरे पढ़ लो। |
3. एन्वायरनमेंट फ़िंगरप्रिंट (h()) | 0x5f3759df को बिल्ट-इन .length मानों से XOR करता है | वे मान हर मानक JS इंजन पर एक से हैं। असली बाइंडिंग नहीं। |
| 4. बायटकोड एन्क्रिप्शन (RC4) | बायटकोड ब्लॉब h() से व्युत्पन्न कुंजी से एन्क्रिप्टेड | h() के इवैल्यूएट होते ही डिक्रिप्शन कोड की एक लाइन में। |
5. बाइनरी सीरियलाइज़ेशन (B()) | फ़्लैग-नियंत्रित कंडीशनल फ़ील्ड्स के साथ कस्टम ज़िगज़ैग-वैरिंट फ़ॉर्मैट | इसे फिर से लागू मत करो। इसे इंस्ट्रुमेंट करो। ओबफस्केटर को ख़ुद ही डीकोड कर लेने दो। |
6. ओपकोड शफ़लिंग (b3 टेबल + प्रति-फ़ंक्शन बीज) | लॉजिकल ओपकोड को शफ़ल किए इंडेक्स से जोड़ता है | सीडेड PRNG। बीज और एल्गोरिथ्म मिलते ही पुनर्निर्माण योग्य। |
7. ऑपरेंड XOR (blockKey, jumpKey) | हर ओपकोड और जंप टार्गेट प्रति-फ़ंक्शन कुंजी से XOR | साधारण XOR। एक ज्ञात-प्लेनटेक्स्ट से कुंजी निकल आती है। |
8. स्टैक मान एन्क्रिप्शन (seKey) | VM स्टैक पर पुश होते समय इंटीजर मान कुंजी से XOR | केवल इंटीजर पर लागू। फ़्लोट, स्ट्रिंग, ऑब्जेक्ट खुले में रखे हैं। |
| 9. एंटी-डिबग टाइमिंग + VM इंटरप्रेटर | स्टेप किया जाए तो टाइमिंग चेक ओपकोड टेबल बिगाड़ देते हैं; 1,500-लाइन का कस्टम VM हर ओपकोड डिस्पैच करता है | इंस्ट्रुमेंटेशन पूरी गति से चलता है। VM ही इन्वर्स है — डिस्पैच को एक बार इंस्ट्रुमेंट करो, सब कुछ हाथ में। |
असल में क्या ख़तरे में है
जिस सूरत-ए-हाल पर मैं बार-बार लौटता हूँ वह यह है जहाँ कॉन्स्टेंट और कंट्रोल फ़्लो ही IP हैं — एक लाइसेंस-चेक फ़ंक्शन, ट्रायल-बनाम-पेड गेट, ऐसा टोकन वैलिडेटर जो तय करता है कि यूज़र को फ़ीचर मिलेगा या नहीं। उस सूरत में पूरा डिफ़ेंस यही है कि «पढ़ना महँगा कर दो», और यही डिफ़ेंस अभी हिला है। जिस प्रतियोगी को सीनियर रिवर्स-इंजीनियर और एक हफ़्ता चाहिए था, अब उसे एक API कुंजी और कॉफ़ी ब्रेक चाहिए। ट्रेडिंग-स्ट्रैटेजी कोड, रैंकिंग लॉजिक, एंटी-फ़्रॉड ह्यूरिस्टिक्स, रेकमेंडेशन एल्गोरिथ्म — कुछ भी जो ब्राउज़र को भेजा गया फ़ंक्शन है, उसी कोष्ठक में बैठा है।
दूसरी जगह जहाँ यह ज़ोर से लगता है वह है ब्राउज़र गेम्स और DRM में एंटी-चीट और एंटी-टेम्पर, जहाँ पूरा थ्रेट मॉडल यह मानकर चलता है कि हर परत पर हमलावर के कई दिन लगेंगे। चीट डेवलपर और DRM-स्ट्रिपर अब नए रिलीज़ के विरुद्ध पैच साइकल के भीतर इटरेट कर सकते हैं, हफ़्तों पीछे नहीं। यह असली व्यावहारिक समस्या बनेगा या नहीं, यह इस पर निर्भर करता है कि हमलावर कितने संगठित हैं; मैंने अभी तक LLM-संचालित चीट विकास का कोई सार्वजनिक प्रमाण नहीं देखा है, लेकिन लागत का ढाल अब रक्षकों के विरुद्ध इशारा कर रहा है।
इन सबके नीचे वही एक टिप्पणी है: ओबफस्केशन ख़रीदने के बहुत-से फ़ैसले उस लागत-समीकरण पर लिए गए जो मानता था कि हर परत पर विशेषज्ञ के कई दिन लगेंगे। वही डिफ़ेंस जो उस तरह के हमलावर के विरुद्ध साल भर की राहत ख़रीदता था जिसे मेहनत करनी हो, अब Claude अकाउंट वाले किसी भी इंजीनियर के सामने एक दोपहर ख़रीदता है।
ईमानदार सीमाएँ
दो प्रोडक्ट, दो डेमो फ़ाइलें, दोनों वेंडर्स की ही चुनी हुई कि वे अपने डिफ़ॉल्ट का विज्ञापन कर सकें। मुख्यधारा JS ओबफस्केटर्स के डिफ़ॉल्ट प्रोफ़ाइल अब किसी सक्षम 2026-कालीन LLM के विरुद्ध डीओबफस्केशन की लागत इतनी ऊँची नहीं उठाते कि फ़र्क़ पड़े — यह संरचनात्मक दावा है, और अब इसे दो रनों का समर्थन है जो पूरी तरह अलग प्राथमिक उपकरण-समूहों के विरुद्ध थे। जो मैंने नहीं परखा वे हैं इन डिफ़ॉल्ट के ऊपर बैठने वाले पेड ऐड-ऑन: JScrambler के Code Locks (एन्वायरनमेंट-बँधे एग्ज़ीक्यूशन गेट्स), Self-Defending इंटीग्रिटी चेक, Anti-Debugging ट्रैप्स, Domain Locks — हर एक असली रुकावट जोड़ता है। जानकारी-नष्ट करने वाले रूपांतरण — वे जो बंडल में कहीं भी इन्वर्स नहीं रखते — भी एक अलग प्रयोग हैं। दोनों फ़ॉलो-अप पोस्ट के लायक़ हैं।
यह सब हमें कहाँ छोड़ता है
दिलचस्प सवाल यह नहीं है कि यह ओबफस्केशन तोड़ी जा सकती है या नहीं — तोड़ी जा सकती है, और साल भर पहले भी जा सकती थी — और मिनिफ़ाइ किया कोड वैसे भी कभी सच में छुपा ही नहीं था। सवाल यह है कि जब इसे तोड़ने की लागत विशेषज्ञ-के-दिनों से गिरकर API-कॉल-के-मिनटों पर आ जाए, तब क्या बचता है जिसे «बचाया जा सकता है» कहा जा सके। इस तकनीक-परिवार के लिए ईमानदार जवाब है: ज़्यादा कुछ नहीं।
अगर आप आज ओबफस्केटेड JavaScript शिप करते हैं, तो सार्वजनिक होने से पहले यह वही प्रयोग है जो आपको ख़ुद चलाना चाहिए, ताकि पता चले कि आप शिप क्या रहे हैं। और हाँ — मैं AfterPack पर एक आधुनिक संस्करण बना रहा हूँ। पहले आज़माने वालों में होने के लिए सब्सक्राइब करें!