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

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

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

这是不是意味着今天的 JavaScript 混淆 —— 那种用来防止 Web 应用被逆向、防止抄袭的技术 —— 已经走到尽头了？我们来一探究竟。

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

准备工作

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

我把混淆后的文件交给 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 在动手之前先返回了一份六步计划。它一遍就把 bundle 的结构看穿了 —— 顶部一个打乱字符串数组的 IIFE，中间约 1,500 行的 VM 解释器，底部一段 base64+RC4 加密的字节码 blob，再加一个调用 VM 的小入口点。

Claude 写出的完整 6 步计划

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 密钥解密字节码 blob、重新实现那个自定义二进制反序列化器（这是 javascript-obfuscator 之外没人见过的部分）、反汇编、产出等价的 JavaScript。

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

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

万能大文件 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 输出后再打日志；把调度循环也包了一层，记录每条 opcode、每个操作数、每一次栈变化；然后把打了补丁的文件跑一遍，所有信息都从 stdout 抓了下来。

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

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

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

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

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

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

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

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

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

还原出的源码 —— 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」演示 —— 一段他们用来推广默认保护方案的背景 sprite-atlas 模块 —— 给 Claude Code 配了同样形态的提示词。换了混淆器，换了技术，是付费产品。

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

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

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

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

JScrambler 的输出 24,620 字节。源码五行。耗时约 20 分钟，Opus 4.7 把 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. 逆操作必须留在 bundle 里。**这一族的每一种防御都自带还原 —— 加密字符串的解码器、opcode 表的打乱密钥、环境指纹的源值 —— 因为如果逆操作不在 bundle 里，程序根本跑不起来。这就意味着整个家族原则上都是可还原的。剩下的真问题只是成本。

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

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

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

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

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

真正被波及的是什么

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

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

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

老实说的局限

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

这件事把我们带到了哪里

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

如果你今天还在发混淆后的 JavaScript，这是你在公开之前需要自己跑一遍的实验，先弄清楚自己到底发出去了什么。是的 —— 我在 AfterPack 上正在打造一个现代版本。订阅就能第一时间试用！