AI Agents defeat obfuscated JavaScript in 10 minutes

I took two JavaScript obfuscators — a popular open-source one (javascript-obfuscator, in their strongest "VM obfuscation" mode) and an enterprise commercial one (JScrambler) — and gave each vendor's own flagship demo to Claude Code with a four-paragraph prompt.

Ten minutes for the first, twenty for the second. Both came back as clean source! 💣

Does this mean the JavaScript obfuscation today, the kind protecting web apps from reverse-engineering and copycats, is over? Let's find out.

Both targets are the vendors' own demos — 5-13 line programs blown up to 24-68 KB by 150-200× obfuscation overhead, a ratio you don't get in real codebases. And before the "but production is bigger" objection: production is easier for Claude, not harder. A 1 MB app either gets the same obfuscation strength amortized across the whole bundle (each function no harder than these demos), or — more commonly — only critical functions get heavily protected and the rest ships readable, giving Claude semantic context for what the protected function probably does. The vendor toy is the worst case for the attacker, not the easy one.

The setup

The input is the 13-line calculatePrice(quantity, unitPrice) function that javascript-obfuscator publishes on its landing page to demonstrate VM mode — their demo, their function, the one they picked to show off. Run it through their tool with the strongest mode enabled and you get back 1,587 lines, 68 KB on disk, ~194× the original size. Inside that output: nine composable defense layers wrapping a ~1,500-line custom stack-based VM interpreter (full breakdown in a table further down).

I gave the obfuscated file to Claude Opus 4.6 inside Claude Code, alongside a four-paragraph prompt. I didn't tell it which obfuscator the file came from, didn't pre-process anything, didn't pre-build any tooling.

The full prompt I sent (4 paragraphs)

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.

The obfuscated input — full file (~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));

Before doing anything else, the agent did what a human would do — it read the file. Four times, actually, working through the VM runtime in chunks. Then it ran the obfuscated file once just to confirm the baseline: o(10, 20) returns 170. Same number it would need to land back at after deobfuscation.

The plan it wrote

Claude returned a six-step plan before touching code. It got the bundle structure right on the first read — an IIFE shuffling a string array at the top, a ~1,500-line VM interpreter in the middle, a base64+RC4 encrypted bytecode blob at the bottom, a small entry point that calls into the VM.

The full 6-step plan, as Claude wrote it

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).

The first attempt was one god-file

Claude wrote a single 883-line deobfuscate.js that tried to do the whole job in one pass — evaluate the string-array decryptor, decrypt every U(idx, key) call, run the environment fingerprint h(), use that as an RC4 key to decrypt the bytecode blob, reimplement the custom binary deserializer (the one part nobody outside javascript-obfuscator has seen before), disassemble, emit equivalent JavaScript.

The first half worked. String decryption: done — 500 unique U() calls decrypted in one run. h() evaluated to the expected 0xa19722e9. Bytecode decryption: clean byte buffer out.

The second half did not. The deserializer uses a custom binary format — zigzag-encoded varints, conditional fields gated by a flag bitmask, aliased property names. Reimplementing it by reading the obfuscated source produced garbage: wrong version byte, negative parameter count, zero instructions. Five years ago that's where the post would have ended. Claude shrugged, wrote a 286-line instrument.js to patch the running VM instead, hit a sandboxing problem on the first try, and immediately swapped strategies again — "the sandbox is too restrictive, let me use a simpler approach: create a modified copy that logs from inside."

The god-file deobfuscate.js — structure (steps 1-3 of the failed pass)

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.

It stopped reimplementing and started instrumenting

Then the strategy changed. Claude didn't bang harder on the deserializer; it patched the running obfuscated file. It wrapped the obfuscator's own B() deserializer to JSON.stringify its output and log it, wrapped the dispatch loop to log every opcode, operand, and stack mutation, then ran the patched file once and caught everything on stdout.

One run produced the full picture: param count 2, local count 3, constants [0.15, 100, 1, "calculatePrice"], block key 54, jump key 9643, stack-encryption key 4168320119, and the 22-instruction bytecode stream — plus a step-by-step execution trace of every stack mutation.

Watching this happen, the part I kept thinking was: instrumentation is the first thing a working reverse-engineer would have tried, not the last. The agent reasoned its way to the obvious move from a non-obvious starting point, in one pivot, with no prompting from me.

Don't reimplement what you can instrument. The program already knows how to run itself.

It disassembled the VM, named every opcode, and emitted source

With the bytecode in hand, Claude walked it. It XORed each opcode against blockKey=54 to recover its logical index, looked the index up in the b3 shuffle table to identify the operation, then named the opcodes in human terms — PUSH_CONST, STORE_LOCAL, LOAD_ARG, MUL, SUB, LOAD_LOCAL, GT, JMP_FALSE, DUP, POP, RETURN. It resolved the jump target via jumpKey=9643 and walked the 22-instruction stream top to bottom, emitting equivalent JavaScript as it went.

For context: I have ~15 years writing JavaScript, I know my way around a debugger, and this is the part of the work where I would have lost most of a week. Reading 1,500 lines of dispatch code, tracking which operand is XOR'd with which key, building a mental model of the stack-based VM, working out which opcode is which by tracing behavior — that's a careful, error-prone, multi-day grind. Claude did it in the time it takes me to make coffee, off a single prompt, with no tooling and no priors on this obfuscator. What just happened is worth being explicit about: the agent didn't suggest a deobfuscation approach for me to try, it produced the artifact — file in, source out, with the failed attempt sitting next to the working one in the same directory.

disassemble.js — the script Claude wrote that turned bytecode into source (full file)

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	}

What Claude actually produced

By the time it stopped, Claude had built a complete working directory: the original obfuscated file, the recovered source, a writeup of every technique used, the failed god-file attempt, the abandoned first instrumentation attempt, the successful second one, the patched obfuscated file it generated, and the final disassembler. It self-authored the tree.

When I asked it afterwards which files actually did the work, the recap was unprompted and exactly right.

The recovered source — what Claude reconstructed

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

The actual original source — what was put into 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));

The recovered code runs identically to the original on every input I tried, including the boundary case. What it doesn't recover are the names — quantity, unitPrice came back as price, quantity, the two SECRET_* constants came back as taxRate and threshold (the numeric values 0.15 and 100 were preserved unchanged because they have to be in the bytecode for the VM to run). Argument order and identifier names are inferred from behavior, not recovered. The obfuscator hides what it's allowed to hide and preserves what the VM needs at runtime — and as it turns out, what the VM needs at runtime is enough for an LLM to read the program.

Then I tried it on JScrambler — a paid one

Same experiment, different vendor. I grabbed JScrambler's published "Javascript Racer" demo — a background sprite-atlas module they ship to advertise their default protection profile — and gave Claude Code the same shape of prompt. Different obfuscator, different techniques, paid product.

Claude read the file once and immediately had the structure mapped out:

• A namespace registry called a20f7.
• A URL-encoded XOR-keyed string blob.
• A 3D index table used as opaque integer tags.
• A "self-replacing decoder" that primes itself for exactly 8 calls and then degrades into a direct lookup.
• The actual payload, hiding under all of it, building one object called BACKGROUND.

None of this was in the prompt. It just read it off the page.

What's interesting is what JScrambler chose to do differently. No bytecode VM here — they use switch-state-machine control-flow flattening instead, the textbook while (state !== END) { switch (state) { … } } shape, nested as deep as the original expression tree. No RC4 — strings come from a URL-encoded blob with a cyclic XOR key, then split on a delimiter. No anti-debug timing — instead, a "disguised priming sequence" that pretends to validate string contents but is really just calling the lookup function in a precise order to advance an internal counter. Entirely different primitives. Same primitive shape. The same six-step arc from the javascript-obfuscator run — decrypt strings, clean runtime, extract state, walk the control flow, reconstruct, document — translated almost directly. The instrumentation pivot the first run depended on wasn't even needed: static analysis took the input to cleartext without ever executing the obfuscated code.

24,620 bytes of JScrambler output. Five lines of source. About 20 minutes, Opus 4.7 with max thinking turned up. Longer than the javascript-obfuscator run, still well inside "minutes-of-an-API-call" territory, still nowhere near "days-of-an-expert".

The recovered source — JScrambler's 24 KB collapsed to 5 lines

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	};

Why this didn't hold up

Four structural reasons that apply across both runs — and predict what does and doesn't work next.

1. The inverse has to live in the bundle. Every defense in this family ships its own undo — the decoder for the encrypted string, the shuffle key for the opcode table, the source values for the environment fingerprint — because if the inverse weren't in the bundle, the program wouldn't run. That makes the whole family recoverable in principle. The only real question is cost.

2. Sequential transforms unroll one at a time. When layers are composed as t₁ ∘ t₂ ∘ … ∘ tₙ, the inverse is just the reverse composition. LLMs are fluent at recognizing and inverting individual transform families — string-array rotation, RC4, base64, XOR-with-constant, seeded Fisher-Yates (javascript-obfuscator uses some combination of all of these) — because they've seen thousands of each in training. Defeating n layers takes roughly n units of work rather than the 2ⁿ you'd get from genuinely interleaved transforms. Nine layers becomes nine model-turns of work, when the obfuscator was probably hoping for nine engineer-days.

3. A VM is a single point of failure. The VM looks like a step up because the logical program is now in custom bytecode, not JavaScript. But the thing that turns bytecode into behavior — the interpreter — sits right there in the bundle. Instrument its dispatch loop once and you've decoded every function that will ever run. Anti-debug timing checks only fire when a human is stepping slowly with a breakpoint; automated instrumentation runs at full speed and never trips them. Environment fingerprinting using standard built-in .length values gives the same number on every JavaScript engine, so the runtime binding is cosmetic.

4. LLMs collapsed the skill floor. None of this was unbreakable before LLMs — there are decade-old papers on reversing control-flow flattening by hand. What changed is who can do it and how long it takes. The skill floor dropped from "expert reverse-engineer with tooling" to "any engineer with AI access", the clock dropped from days to minutes, and the names — which used to be the one thing reverse-engineers had to fake from scratch — now come back from semantic context for free.

The nine defense layers, and why each came apart

Layer	What it does	Why it didn't hold
1. String array + RC4 encryption	All ~500 string literals encrypted, decoded at runtime via U(idx, key)	Self-contained. Evaluate U() once, statically decrypt every call.
2. String array rotation	The array is rotated by an IIFE until a checksum matches	Rotation runs on startup. Just let it run, then read the rotated array.
3. Environment fingerprinting (h())	XORs 0x5f3759df with built-in .length values	Those values are identical on every standard JS engine. No actual binding.
4. Bytecode encryption (RC4)	Bytecode blob encrypted with a key derived from h()	Once h() is evaluated, decryption is one line of code.
5. Binary serialization (B())	Custom zigzag-varint format with flag-gated conditional fields	Don't reimplement it. Instrument it. Let the obfuscator decode itself.
6. Opcode shuffling (b3 table + per-function seed)	Maps logical opcodes to shuffled indices	Seeded PRNG. Reconstructible once you have the seed and algorithm.
7. Operand XOR (blockKey, jumpKey)	Every opcode and jump target XORed with a per-function key	Simple XOR. One known-plaintext recovers the key.
8. Stack value encryption (seKey)	Integer values XORed with a key when pushed to the VM stack	Applied only to integers. Floats, strings, objects stored in plaintext.
9. Anti-debug timing + VM interpreter	Timing checks corrupt the opcode table if stepped through; 1,500-line custom VM dispatches each opcode	Instrumentation runs at full speed. The VM is the inverse — instrument dispatch once, get everything.

What's actually at risk

The case I keep coming back to is the one where the constants and the control flow are the IP — a license-check function, a trial-vs-paid gate, a token validator that decides whether the user gets the feature. The whole defense in that case is "make it expensive to read", and that defense is what just shifted. A competitor who needed a senior reverse-engineer and a week now needs an API key and a coffee break. Trading-strategy code, ranking logic, anti-fraud heuristics, recommendation algorithms — anything that's a function shipped to the browser sits in the same bracket.

The other place this lands hard is anti-cheat and anti-tamper in browser games and DRM, where the entire threat model assumed days of attacker work per layer. Cheat developers and DRM-strippers can now iterate against new releases inside the patch cycle rather than weeks behind it. Whether that becomes an actual practical problem depends on how organized the attackers are; I haven't seen public evidence of LLM-driven cheat development yet, but the cost gradient is now pointing the wrong way for the defenders.

Underneath all of that is the same observation: a lot of obfuscation purchase decisions were made on a cost-of-attack equation that assumed days of expert work per layer. The same defenses that used to buy a year of headroom against the kind of attacker who could be bothered now buy an afternoon against any engineer with a Claude account.

Honest limits

Two products, two demo files, both picked by the vendors to advertise their defaults. Default profiles of mainstream JS obfuscators no longer raise deobfuscation cost enough to matter against a capable 2026-era LLM — that's the structural claim, and it's now backed by two runs against entirely different primitive sets. What I haven't tested is the paid add-ons sitting on top of those defaults: JScrambler's Code Locks (env-bound execution gates), Self-Defending integrity checks, Anti-Debugging traps, Domain Locks — each adds a real obstacle. Information-destroying transforms — the kind that don't preserve an inverse anywhere in the bundle — are also a separate experiment. Both are worth a follow-up post.

Where this leaves things

The interesting question isn't whether this obfuscation can be broken — it can, and it could a year ago too — and minified code was never really hidden to begin with. The question is what stops being defensible when the cost of breaking it drops from days-of-an-expert to minutes-of-an-API-call. The honest answer for this technique family is: not much.

If you ship obfuscated JavaScript today, this is the experiment to run yourself before you know what you ship, publicly. And yes — I'm building a modern one at AfterPack. Subscribe to be the first to try it!