LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pushstring
void js_pushstring(js_State *J, const char *v)
{
	size_t n = strlen(v);
	if (n > JS_STRLIMIT)
		js_rangeerror(J, "invalid string length");
	CHECKSTACK(1);
	if (n <= soffsetof(js_Value, t.type)) {
		char *s = STACK[TOP].u.shrstr;
		while (n--) *s++ = *v++;
		*s = 0;
		STACK[TOP].t.type = JS_TSHRSTR;
	} else {
		STACK[TOP].t.type = JS_TMEMSTR;
		STACK[TOP].u.memstr = jsV_newmemstring(J, v, n);
	}
	++TOP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3200
cmpq $0x10000001, %rax       # imm = 0x10000001
jae 0xe8a4
movslq 0x140(%rbx), %rdx
cmpq $0xfff, %rdx            # imm = 0xFFF
jge 0xe8b5
movq 0x148(%rbx), %rcx
shlq $0x4, %rdx
cmpq $0xf, %rax
ja 0xe851
addq %rdx, %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0xe87b
movb (%r14,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0xe83f
movb $0x6, 0xf(%rcx,%rdx)
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xf6e9
movq 0x148(%rbx), %rcx
movslq 0x140(%rbx), %rdx
shlq $0x4, %rdx
movq %rax, (%rcx,%rdx)
jmp 0xe896
xorl %eax, %eax
movb %al, (%rcx,%rdx)
movq 0x148(%rbx), %rcx
movslq 0x140(%rbx), %rdx
shlq $0x4, %rdx
movb %al, 0xf(%rcx,%rdx)
incl 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x19e97(%rip), %rsi     # 0x28742
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9778
movq %rbx, %rdi
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsstring.c
// Function: js_utfptrtoidx
int js_utfptrtoidx(const char *s, const char *p)
{
	Rune rune;
	int i = 0;
	while (s < p) {
		if (*(unsigned char *)s < Runeself)
			++s;
		else
			s += chartorune(&rune, s);
		if (rune >= 0x10000)
			i += 2;
		else
			i += 1;
	}
	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x4(%rsp), %r12
cmpq %rbx, %r15
jae 0xe909
cmpb $0x0, (%r15)
js 0xe8e3
incq %r15
jmp 0xe8f7
movq %r12, %rdi
movq %r15, %rsi
callq 0x1241b
movl %eax, %eax
addq %rax, %r15
movl 0x4(%rsp), %eax
xorl %ecx, %ecx
cmpl $0x10000, %eax          # imm = 0x10000
setge %cl
addl %ecx, %r14d
incl %r14d
jmp 0xe8d3
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pushlstring
void js_pushlstring(js_State *J, const char *v, int n)
{
	if (n > JS_STRLIMIT)
		js_rangeerror(J, "invalid string length");
	CHECKSTACK(1);
	if (n <= soffsetof(js_Value, t.type)) {
		char *s = STACK[TOP].u.shrstr;
		while (n--) *s++ = *v++;
		*s = 0;
		STACK[TOP].t.type = JS_TSHRSTR;
	} else {
		STACK[TOP].t.type = JS_TMEMSTR;
		STACK[TOP].u.memstr = jsV_newmemstring(J, v, n);
	}
	++TOP;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10000001, %edx       # imm = 0x10000001
jge 0xe9ac
movslq 0x140(%rbx), %rcx
cmpq $0xfff, %rcx            # imm = 0xFFF
jge 0xe9bd
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
cmpl $0xf, %edx
jg 0xe964
addq %rcx, %rax
movl %edx, %edx
xorl %ecx, %ecx
cmpl %ecx, %edx
je 0xe989
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
jmp 0xe953
movb $0x6, 0xf(%rax,%rcx)
movq %rbx, %rdi
callq 0xf6e9
movq 0x148(%rbx), %rcx
movslq 0x140(%rbx), %rdx
shlq $0x4, %rdx
movq %rax, (%rcx,%rdx)
jmp 0xe9a4
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb %dl, 0xf(%rax,%rcx)
incl 0x140(%rbx)
popq %rbx
retq
leaq 0x19d8f(%rip), %rsi     # 0x28742
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9778
movq %rbx, %rdi
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsregexp.c
// Function: Rp_toString
static void Rp_toString(js_State *J)
{
	js_Regexp *re;
	char * volatile out = NULL;

	re = js_toregexp(J, 0);

	if (js_try(J)) {
		js_free(J, out);
		js_throw(J);
	}

	out = js_malloc(J, strlen(re->source) + 6); /* extra space for //gim */
	strcpy(out, "/");
	strcat(out, re->source);
	strcat(out, "/");
	if (re->flags & JS_REGEXP_G) strcat(out, "g");
	if (re->flags & JS_REGEXP_I) strcat(out, "i");
	if (re->flags & JS_REGEXP_M) strcat(out, "m");

	js_pop(J, 0);
	js_pushstring(J, out);
	js_endtry(J);
	js_free(J, out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
xorl %esi, %esi
callq 0xfee4
movq %rax, %r14
movq %rbx, %rdi
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0xeb15
movq %r14, %r15
movq 0x8(%r14), %rdi
callq 0x3200
leal 0x6(%rax), %esi
movq %rbx, %rdi
callq 0xa9e8
movq %rax, (%rsp)
movq (%rsp), %rax
movw $0x2f, %bp
movw %bp, (%rax)
movq (%rsp), %rdi
movq 0x8(%r14), %rsi
callq 0x3270
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw %bp, (%r14,%rax)
movzwl 0x10(%r15), %eax
movl %eax, %ecx
testb $0x1, %cl
je 0xeaa8
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x67, (%r14,%rax)
movzwl 0x10(%r15), %eax
movl %eax, %ecx
testb $0x2, %cl
je 0xeac7
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x69, (%r14,%rax)
movzwl 0x10(%r15), %eax
testb $0x4, %al
je 0xeade
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x6d, (%r14,%rax)
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3f3d
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq (%rsp), %rsi
movq (%rbx), %rdi
movl %ebp, %edx
callq *0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsregexp.c
// Function: Rp_test
static void Rp_test(js_State *J)
{
	js_Regexp *re;
	const char *text;
	int result;
	int opts;
	Resub m;

	re = js_toregexp(J, 0);
	text = js_tostring(J, 1);

	opts = 0;
	if (re->flags & JS_REGEXP_G) {
		if (re->last > strlen(text)) {
			re->last = 0;
			js_pushboolean(J, 0);
			return;
		}
		if (re->last > 0) {
			text += re->last;
			opts |= REG_NOTBOL;
		}
	}

	result = js_regexec(re->prog, text, &m, opts);
	if (result < 0)
		js_error(J, "regexec failed");
	if (result == 0) {
		if (re->flags & JS_REGEXP_G)
			re->last = re->last + (m.sub[0].ep - text);
		js_pushboolean(J, 1);
		return;
	}

	if (re->flags & JS_REGEXP_G)
		re->last = 0;

	js_pushboolean(J, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0xfee4
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r15
testb $0x1, 0x10(%r14)
je 0xeb9c
movzwl 0x12(%r14), %r12d
movq %r15, %rdi
callq 0x3200
cmpq %r12, %rax
jae 0xeb8d
andw $0x0, 0x12(%r14)
movq %rbx, %rdi
xorl %esi, %esi
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf7ba
xorl %ebp, %ebp
testq %r12, %r12
setne %bpl
addq %r12, %r15
shll $0x2, %ebp
movq (%r14), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movl %ebp, %ecx
callq 0xe782
testl %eax, %eax
js 0xebf5
movzwl 0x10(%r14), %eax
je 0xebca
testb $0x1, %al
je 0xebc3
andw $0x0, 0x12(%r14)
movq %rbx, %rdi
xorl %esi, %esi
jmp 0xebe0
testb $0x1, %al
je 0xebda
movl 0x18(%rsp), %eax
subl %r15d, %eax
addw %ax, 0x12(%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf7ba
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19ade(%rip), %rsi     # 0x286da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsregexp.c
// Function: jsB_new_RegExp
static void jsB_new_RegExp(js_State *J)
{
	js_Regexp *old;
	const char *pattern;
	int flags;
	int is_clone = 0;

	if (js_isregexp(J, 1)) {
		if (js_isdefined(J, 2))
			js_typeerror(J, "cannot supply flags when creating one RegExp from another");
		old = js_toregexp(J, 1);
		pattern = old->source;
		flags = old->flags;
		is_clone = 1;
	} else if (js_isundefined(J, 1)) {
		pattern = "(?:)";
		flags = 0;
	} else {
		pattern = js_tostring(J, 1);
		flags = 0;
	}

	if (strlen(pattern) == 0)
		pattern = "(?:)";

	if (js_isdefined(J, 2)) {
		const char *s = js_tostring(J, 2);
		int g = 0, i = 0, m = 0;
		while (*s) {
			if (*s == 'g') ++g;
			else if (*s == 'i') ++i;
			else if (*s == 'm') ++m;
			else js_syntaxerror(J, "invalid regular expression flag: '%c'", *s);
			++s;
		}
		if (g > 1) js_syntaxerror(J, "invalid regular expression flag: 'g'");
		if (i > 1) js_syntaxerror(J, "invalid regular expression flag: 'i'");
		if (m > 1) js_syntaxerror(J, "invalid regular expression flag: 'm'");
		if (g) flags |= JS_REGEXP_G;
		if (i) flags |= JS_REGEXP_I;
		if (m) flags |= JS_REGEXP_M;
	}

	js_newregexpx(J, pattern, flags, is_clone);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xf99d
testl %eax, %eax
je 0xec90
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
jne 0xed7c
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfee4
movq 0x8(%rax), %r15
movzwl 0x10(%rax), %r14d
jmp 0xecbb
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8bb
xorl %r14d, %r14d
testl %eax, %eax
je 0xecab
leaq 0x18f79(%rip), %r15     # 0x27c22
jmp 0xecb9
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r15
xorl %ebp, %ebp
movb (%r15), %r12b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0xed41
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf64d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movzbl (%rax), %edi
cmpl $0x67, %edi
je 0xecf8
cmpl $0x69, %edi
je 0xecf4
cmpl $0x6d, %edi
jne 0xecff
incl %ecx
jmp 0xecfa
incl %edx
jmp 0xecfa
incl %esi
incq %rax
jmp 0xecde
testl %edi, %edi
jne 0xed67
cmpl $0x2, %esi
jge 0xed8d
cmpl $0x2, %edx
jge 0xed96
cmpl $0x2, %ecx
jge 0xed9f
xorl %eax, %eax
testl %esi, %esi
setne %al
orl %eax, %r14d
movl %r14d, %eax
orl $0x2, %eax
testl %edx, %edx
cmovel %r14d, %eax
movl %eax, %r14d
orl $0x4, %r14d
testl %ecx, %ecx
cmovel %eax, %r14d
testb %r12b, %r12b
leaq 0x18ed7(%rip), %rax     # 0x27c22
cmoveq %rax, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe518
movsbl %dil, %edx
leaq 0x1b106(%rip), %rsi     # 0x29e78
movq %rbx, %rdi
xorl %eax, %eax
callq 0x98e8
leaq 0x1b0bb(%rip), %rsi     # 0x29e3e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
leaq 0x1b10a(%rip), %rsi     # 0x29e9e
jmp 0xeda6
leaq 0x1b126(%rip), %rsi     # 0x29ec3
jmp 0xeda6
leaq 0x1b142(%rip), %rsi     # 0x29ee8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x98e8
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrepr.c
// Function: js_repr
void js_repr(js_State *J, int idx)
{
	js_Buffer *sb = NULL;
	int savebot;

	if (js_try(J)) {
		js_free(J, sb);
		js_throw(J);
	}

	js_copy(J, idx);

	savebot = J->bot;
	J->bot = J->top - 1;
	reprvalue(J, &sb);
	J->bot = savebot;

	js_pop(J, 1);

	js_putc(J, &sb, 0);
	js_pushstring(J, sb ? sb->s : "undefined");

	js_endtry(J);
	js_free(J, sb);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0xee5f
movq %rbx, %rdi
movl %ebp, %esi
callq 0xeee2
movl 0x140(%rbx), %eax
movl 0x144(%rbx), %ebp
decl %eax
movl %eax, 0x144(%rbx)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef29
movl %ebp, 0x144(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa986
movq (%r14), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
leaq 0x1b411(%rip), %rsi     # 0x2a248
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq (%r14), %rsi
movq (%rbx), %rdi
movl %ebp, %edx
callq *0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_savetry
void *js_savetry(js_State *J)
{
	if (J->trytop == JS_TRYLIMIT)
		js_trystackoverflow(J);
	J->trybuf[J->trytop].E = J->E;
	J->trybuf[J->trytop].envtop = J->envtop;
	J->trybuf[J->trytop].tracetop = J->tracetop;
	J->trybuf[J->trytop].top = J->top;
	J->trybuf[J->trytop].bot = J->bot;
	J->trybuf[J->trytop].strict = J->strict;
	J->trybuf[J->trytop].pc = NULL;
	return J->trybuf[J->trytop++].buf;
}

// Assembly:
movslq 0x8198(%rdi), %rcx
cmpq $0x40, %rcx
je 0xeedc
movq 0x130(%rdi), %rdx
imulq $0xf0, %rcx, %rax
addq %rdi, %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq %rdx, 0xc8(%rax)
movl 0x188(%rdi), %edx
movl %edx, 0xd0(%rax)
movl 0x2190(%rdi), %edx
movl %edx, 0xd4(%rax)
movq 0x140(%rdi), %rdx
movq %rdx, 0xd8(%rax)
movl 0x34(%rdi), %edx
movl %edx, 0xe0(%rax)
andq $0x0, 0xe8(%rax)
incl %ecx
movl %ecx, 0x8198(%rdi)
retq
pushq %rax
callq 0x118b0
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_replace
void js_replace(js_State* J, int idx)
{
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < BOT || idx >= TOP)
		js_error(J, "stack error!");
	STACK[idx] = STACK[--TOP];
}

// Assembly:
movslq %esi, %rcx
notl %esi
shrl $0x1f, %esi
movslq 0x140(%rdi,%rsi,4), %rax
addq %rcx, %rax
cmpl 0x144(%rdi), %eax
jl 0xf63e
movslq 0x140(%rdi), %rcx
cmpl %ecx, %eax
jge 0xf63e
movq 0x148(%rdi), %rdx
shlq $0x4, %rax
decq %rcx
movl %ecx, 0x140(%rdi)
shlq $0x4, %rcx
movups (%rdx,%rcx), %xmm0
movups %xmm0, (%rdx,%rax)
retq
pushq %rax
leaq 0x19139(%rip), %rsi     # 0x2877f
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrepr.c
// Function: js_tryrepr
const char *js_tryrepr(js_State *J, int idx, const char *error)
{
	const char *s;
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	s = js_torepr(J, idx);
	js_endtry(J);
	return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0xf68c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
jmp 0xf6a1
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf5c9
movq %rax, %r14
movq %rbx, %rdi
callq 0xf5a7
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_outofmemory
static void js_outofmemory(js_State *J)
{
	STACK[TOP].t.type = JS_TLITSTR;
	STACK[TOP].u.litstr = "out of memory";
	++TOP;
	js_throw(J);
}

// Assembly:
pushq %rax
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x10ab6(%rip), %rdx     # 0x20190
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_stackoverflow
static void js_stackoverflow(js_State *J)
{
	STACK[TOP].t.type = JS_TLITSTR;
	STACK[TOP].u.litstr = "stack overflow";
	++TOP;
	js_throw(J);
}

// Assembly:
pushq %rax
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x1a906(%rip), %rdx     # 0x2a0b1
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pushboolean
void js_pushboolean(js_State *J, int v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TBOOLEAN;
	STACK[TOP].u.boolean = !!v;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0xf7fc
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
movb $0x3, 0xf(%rcx,%rax)
xorl %eax, %eax
testl %esi, %esi
setne %al
movq 0x148(%rdi), %rcx
movslq 0x140(%rdi), %rdx
shlq $0x4, %rdx
movl %eax, (%rcx,%rdx)
incl 0x140(%rdi)
retq
pushq %rax
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_currentfunction
void js_currentfunction(js_State *J)
{
	CHECKSTACK(1);
	if (BOT > 0)
		STACK[TOP] = STACK[BOT-1];
	else
		STACK[TOP].t.type = JS_TUNDEFINED;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0xf84f
movslq 0x144(%rdi), %rdx
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
testq %rdx, %rdx
jle 0xf843
shlq $0x4, %rdx
movups -0x10(%rcx,%rdx), %xmm0
movups %xmm0, (%rcx,%rax)
jmp 0xf848
movb $0x1, 0xf(%rcx,%rax)
incl 0x140(%rdi)
retq
pushq %rax
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: stackidx
static js_Value *stackidx(js_State *J, int idx)
{
	static js_Value undefined = { { {0}, JS_TUNDEFINED } };
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < 0 || idx >= TOP)
		return &undefined;
	return STACK + idx;
}

// Assembly:
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x27b68(%rip), %rax     # 0x373f8
js 0xf8a7
cmpl 0x140(%rdi), %esi
jge 0xf8a7
movl %esi, %eax
shlq $0x4, %rax
addq 0x148(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_iscallable
int js_iscallable(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT)
		return v->u.object->type == JS_CFUNCTION ||
			v->u.object->type == JS_CSCRIPT ||
			v->u.object->type == JS_CCFUNCTION;
	return 0;
}

// Assembly:
pushq %rax
callq 0xf87b
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x7, 0xf(%rcx)
jne 0xf97d
movq (%rcx), %rax
movl (%rax), %ecx
movl %ecx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0xf975
pushq $0x1
popq %rax
jmp 0xf97d
xorl %eax, %eax
cmpl $0x4, %ecx
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_typeof
const char *js_typeof(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return "string";
	case JS_TUNDEFINED: return "undefined";
	case JS_TNULL: return "object";
	case JS_TBOOLEAN: return "boolean";
	case JS_TNUMBER: return "number";
	case JS_TLITSTR: return "string";
	case JS_TMEMSTR: return "string";
	case JS_TOBJECT:
		if (v->u.object->type == JS_CFUNCTION || v->u.object->type == JS_CCFUNCTION)
			return "function";
		return "object";
	}
}

// Assembly:
pushq %rax
callq 0xf87b
movq %rax, %rcx
movzbl 0xf(%rax), %edx
leaq 0x1a7ff(%rip), %rax     # 0x2a21f
decl %edx
cmpl $0x6, %edx
ja 0xfa7a
leaq 0x10d4a(%rip), %rsi     # 0x20778
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x1a80a(%rip), %rax     # 0x2a248
jmp 0xfa7a
leaq 0x1927d(%rip), %rax     # 0x28cc4
jmp 0xfa7a
leaq 0x1a69e(%rip), %rax     # 0x2a0ee
jmp 0xfa7a
leaq 0x19f9a(%rip), %rax     # 0x299f3
jmp 0xfa7a
movq (%rcx), %rax
movl (%rax), %eax
addl $-0x2, %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
leaq 0x1981e(%rip), %rcx     # 0x2928d
leaq 0x1a678(%rip), %rax     # 0x2a0ee
cmoveq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_type
int js_type(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return JS_ISSTRING;
	case JS_TUNDEFINED: return JS_ISUNDEFINED;
	case JS_TNULL: return JS_ISNULL;
	case JS_TBOOLEAN: return JS_ISBOOLEAN;
	case JS_TNUMBER: return JS_ISNUMBER;
	case JS_TLITSTR: return JS_ISSTRING;
	case JS_TMEMSTR: return JS_ISSTRING;
	case JS_TOBJECT:
		if (v->u.object->type == JS_CFUNCTION || v->u.object->type == JS_CCFUNCTION)
			return JS_ISFUNCTION;
		return JS_ISOBJECT;
	}
}

// Assembly:
pushq %rax
callq 0xf87b
movq %rax, %rcx
movzbl 0xf(%rax), %edx
pushq $0x4
popq %rax
decl %edx
cmpl $0x6, %edx
ja 0xfac8
leaq 0x10cfa(%rip), %rsi     # 0x20794
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
xorl %eax, %eax
jmp 0xfac8
pushq $0x2
jmp 0xfab1
pushq $0x1
jmp 0xfab1
pushq $0x3
popq %rax
jmp 0xfac8
movq (%rcx), %rax
movl (%rax), %eax
addl $-0x2, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
pushq $0x6
popq %rax
sbbl $0x0, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_toboolean
int jsV_toboolean(js_State *J, js_Value *v)
{
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return v->u.shrstr[0] != 0;
	case JS_TUNDEFINED: return 0;
	case JS_TNULL: return 0;
	case JS_TBOOLEAN: return v->u.boolean;
	case JS_TNUMBER: return v->u.number != 0 && !isnan(v->u.number);
	case JS_TLITSTR: return v->u.litstr[0] != 0;
	case JS_TMEMSTR: return v->u.memstr->p[0] != 0;
	case JS_TOBJECT: return 1;
	}
}

// Assembly:
movzbl 0xf(%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0xfb03
leaq 0x10cc5(%rip), %rcx     # 0x207b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
retq
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd (%rsi), %xmm0
jmp 0xfb24
xorl %eax, %eax
cmpb $0x0, (%rsi)
jmp 0xfb24
movl (%rsi), %eax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, 0x9(%rcx)
jmp 0xfb24
pushq $0x1
popq %rax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_tonumber
double jsV_tonumber(js_State *J, js_Value *v)
{
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return jsV_stringtonumber(J, v->u.shrstr);
	case JS_TUNDEFINED: return NAN;
	case JS_TNULL: return 0;
	case JS_TBOOLEAN: return v->u.boolean;
	case JS_TNUMBER: return v->u.number;
	case JS_TLITSTR: return jsV_stringtonumber(J, v->u.litstr);
	case JS_TMEMSTR: return jsV_stringtonumber(J, v->u.memstr->p);
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HNUMBER);
		return jsV_tonumber(J, v);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10c7b(%rip), %r15     # 0x207cc
pushq $0x1
popq %rbp
movzbl 0xf(%rbx), %eax
decl %eax
cmpl $0x6, %eax
ja 0xfbaa
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xfe35
jmp 0xfb54
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0xfbad
movq (%rbx), %rsi
jmp 0xfbad
movsd 0x1088b(%rip), %xmm0    # 0x20418
jmp 0xfb9f
cvtsi2sdl (%rbx), %xmm0
jmp 0xfb9f
xorpd %xmm0, %xmm0
jmp 0xfb9f
movsd (%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe258
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_numbertoint32
int jsV_numbertoint32(double n)
{
	double two32 = 4294967296.0;
	double two31 = 2147483648.0;

	if (!isfinite(n) || n == 0)
		return 0;

	n = fmod(n, two32);
	n = n >= 0 ? floor(n) : ceil(n) + two32;
	if (n >= two31)
		return n - two32;
	else
		return n;
}

// Assembly:
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setg %cl
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
xorl %eax, %eax
orb %cl, %sil
jne 0xfc4a
pushq %rax
movsd 0x10903(%rip), %xmm1    # 0x20510
callq 0x31b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0xfc2b
callq 0x3090
addsd 0x108e7(%rip), %xmm0    # 0x20510
jmp 0xfc30
callq 0x3370
ucomisd 0x108e0(%rip), %xmm0    # 0x20518
jb 0xfc42
addsd 0x108de(%rip), %xmm0    # 0x20520
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_tostring
const char *jsV_tostring(js_State *J, js_Value *v)
{
	char buf[32];
	const char *p;
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return v->u.shrstr;
	case JS_TUNDEFINED: return "undefined";
	case JS_TNULL: return "null";
	case JS_TBOOLEAN: return v->u.boolean ? "true" : "false";
	case JS_TLITSTR: return v->u.litstr;
	case JS_TMEMSTR: return v->u.memstr->p;
	case JS_TNUMBER:
		p = jsV_numbertostring(J, buf, v->u.number);
		if (p == buf) {
			int n = strlen(p);
			if (n <= soffsetof(js_Value, t.type)) {
				char *s = v->u.shrstr;
				while (n--) *s++ = *p++;
				*s = 0;
				v->t.type = JS_TSHRSTR;
				return v->u.shrstr;
			} else {
				v->u.memstr = jsV_newmemstring(J, p, n);
				v->t.type = JS_TMEMSTR;
				return v->u.memstr->p;
			}
		}
		return p;
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HSTRING);
		return jsV_tostring(J, v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl 0xf(%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0xfd2d
movq %rdi, %r14
leaq 0x10b15(%rip), %rcx     # 0x207e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1a565(%rip), %rbx     # 0x2a248
jmp 0xfd2d
movq (%rbx), %rbx
jmp 0xfd2d
cmpl $0x0, (%rbx)
leaq 0x18daa(%rip), %rax     # 0x28a9e
leaq 0x18d9e(%rip), %rbx     # 0x28a99
cmoveq %rax, %rbx
jmp 0xfd2d
movsd (%rbx), %xmm0
movq %rsp, %r12
movq %r12, %rsi
callq 0xe36d
movq %rax, %r15
cmpq %r12, %rax
je 0xfd60
movq %r15, %rbx
jmp 0xfd2d
leaq 0x19e62(%rip), %rbx     # 0x29b86
jmp 0xfd2d
movq (%rbx), %rbx
addq $0x9, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfe35
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfcb0
movq %r15, %rdi
callq 0x3200
cmpl $0xf, %eax
jg 0xfd7f
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0xfd9c
movb (%r15,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
jmp 0xfd6f
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0xf6e9
movq %rax, (%rbx)
movb $0x6, 0xf(%rbx)
addq $0x9, %rax
movq %rax, %rbx
jmp 0xfd2d
xorl %eax, %eax
movb %al, (%rbx,%rcx)
movb %al, 0xf(%rbx)
jmp 0xfd2d
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_toobject
js_Object *jsV_toobject(js_State *J, js_Value *v)
{
	js_Object *o;
	switch (v->t.type) {
	default:
	case JS_TUNDEFINED: js_typeerror(J, "cannot convert undefined to object");
	case JS_TNULL: js_typeerror(J, "cannot convert null to object");
	case JS_TOBJECT: return v->u.object;
	case JS_TSHRSTR: o = jsV_newstring(J, v->u.shrstr); break;
	case JS_TLITSTR: o = jsV_newstring(J, v->u.litstr); break;
	case JS_TMEMSTR: o = jsV_newstring(J, v->u.memstr->p); break;
	case JS_TBOOLEAN: o = jsV_newboolean(J, v->u.boolean); break;
	case JS_TNUMBER: o = jsV_newnumber(J, v->u.number); break;
	}
	v->t.type = JS_TOBJECT;
	v->u.object = o;
	return o;
}

// Assembly:
pushq %rbx
movzbl 0xf(%rsi), %eax
cmpq $0x7, %rax
ja 0xfe05
movq %rsi, %rbx
leaq 0x10a49(%rip), %rcx     # 0x20804
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
jmp 0xfdee
movl (%rbx), %esi
callq 0x1378b
jmp 0xfdf3
movsd (%rbx), %xmm0
callq 0x137a2
jmp 0xfdf3
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0xfdee
movq (%rbx), %rax
jmp 0xfdfa
movq (%rbx), %rsi
callq 0x13721
movb $0x7, 0xf(%rbx)
movq %rax, (%rbx)
popq %rbx
retq
leaq 0x18cc4(%rip), %rsi     # 0x28ac7
jmp 0xfe0c
leaq 0x18c98(%rip), %rsi     # 0x28aa4
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_toprimitive
void jsV_toprimitive(js_State *J, js_Value *v, int preferred)
{
	js_Object *obj;

	if (v->t.type != JS_TOBJECT)
		return;

	obj = v->u.object;

	if (preferred == JS_HNONE)
		preferred = obj->type == JS_CDATE ? JS_HSTRING : JS_HNUMBER;

	if (preferred == JS_HSTRING) {
		if (jsV_toString(J, obj) || jsV_valueOf(J, obj)) {
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	} else {
		if (jsV_valueOf(J, obj) || jsV_toString(J, obj)) {
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	}

	if (J->strict)
		js_typeerror(J, "cannot convert object to primitive");

	v->t.type = JS_TLITSTR;
	v->u.litstr = "[object]";
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x7, 0xf(%rsi)
jne 0xfecd
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
cmpl $0x2, %edx
je 0xfe5c
testl %edx, %edx
jne 0xfe78
cmpl $0xa, (%r15)
jne 0xfe78
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1353b
testl %eax, %eax
jne 0xfe96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x135a6
jmp 0xfe92
movq %rbx, %rdi
movq %r15, %rsi
callq 0x135a6
testl %eax, %eax
jne 0xfe96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1353b
testl %eax, %eax
je 0xfeb8
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf87b
movups (%rax), %xmm0
movups %xmm0, (%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3f3d
cmpl $0x0, 0x34(%rbx)
jne 0xfed3
movb $0x5, 0xf(%r14)
leaq 0x18bb2(%rip), %rax     # 0x28a7c
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18b7f(%rip), %rsi     # 0x28a59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_toregexp
js_Regexp *js_toregexp(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT && v->u.object->type == JS_CREGEXP)
		return &v->u.object->u.r;
	js_typeerror(J, "not a regexp");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf87b
cmpb $0x7, 0xf(%rax)
jne 0xff01
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0xff01
addq $0x20, %rax
popq %rbx
retq
leaq 0x18850(%rip), %rsi     # 0x28758
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_touserdata
void *js_touserdata(js_State *J, int idx, const char *tag)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT && v->u.object->type == JS_CUSERDATA)
		if (!strcmp(tag, v->u.object->u.user.tag))
			return v->u.object->u.user.data;
	js_typeerror(J, "not a %s", tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0xf87b
cmpb $0x7, 0xf(%rax)
jne 0xff4b
movq (%rax), %r15
cmpl $0xf, (%r15)
jne 0xff4b
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
jne 0xff4b
movq 0x28(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18813(%rip), %rsi     # 0x28765
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_remove
void js_remove(js_State *J, int idx)
{
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < BOT || idx >= TOP)
		js_error(J, "stack error!");
	for (;idx < TOP - 1; ++idx)
		STACK[idx] = STACK[idx+1];
	--TOP;
}

// Assembly:
pushq %rax
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
movslq 0x140(%rdi,%rax,4), %rax
leal (%rax,%rsi), %edx
cmpl 0x144(%rdi), %edx
jl 0xffd6
movl 0x140(%rdi), %ecx
cmpl %ecx, %edx
jge 0xffd6
movslq %esi, %rdx
addq %rdx, %rax
movq %rax, %rdx
shlq $0x4, %rdx
leaq 0x10(%rdx), %rsi
decl %ecx
movslq %ecx, %r8
cmpq %r8, %rax
jge 0xffce
movq 0x148(%rdi), %rcx
incq %rax
movups (%rcx,%rsi), %xmm0
movups %xmm0, (%rcx,%rdx)
movl 0x140(%rdi), %ecx
addq $0x10, %rdx
addq $0x10, %rsi
jmp 0xffa2
movl %ecx, 0x140(%rdi)
popq %rax
retq
leaq 0x187a2(%rip), %rsi     # 0x2877f
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_dup2
void js_dup2(js_State *J)
{
	CHECKSTACK(2);
	STACK[TOP] = STACK[TOP-2];
	STACK[TOP+1] = STACK[TOP-1];
	TOP += 2;
}

// Assembly:
movslq 0x140(%rdi), %rax
cmpq $0xffe, %rax            # imm = 0xFFE
jge 0x1006a
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
movups -0x20(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
addl $0x2, 0x140(%rdi)
retq
pushq %rax
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_rot
void js_rot(js_State *J, int n)
{
	int i;
	js_Value tmp = STACK[TOP-1];
	for (i = 1; i < n; ++i)
		STACK[TOP-i] = STACK[TOP-i-1];
	STACK[TOP-i] = tmp;
}

// Assembly:
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, -0x18(%rsp)
movl $0x1, %eax
movabsq $-0x1, %rcx
movslq 0x140(%rdi), %rdx
addq %rcx, %rdx
shlq $0x4, %rdx
addq 0x148(%rdi), %rdx
cmpl %esi, %eax
jge 0x10226
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rdx)
incl %eax
decq %rcx
jmp 0x101ff
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_isarrayindex
int js_isarrayindex(js_State *J, const char *p, int *idx)
{
	int n = 0;

	/* check for empty string */
	if (p[0] == 0)
		return 0;

	/* check for '0' and integers with leading zero */
	if (p[0] == '0')
		return (p[1] == 0) ? *idx = 0, 1 : 0;

	while (*p) {
		int c = *p++;
		if (c >= '0' && c <= '9') {
			if (n >= INT_MAX / 10)
				return 0;
			n = n * 10 + (c - '0');
		} else {
			return 0;
		}
	}
	return *idx = n, 1;
}

// Assembly:
movzbl (%rsi), %eax
testl %eax, %eax
je 0x10248
cmpl $0x30, %eax
jne 0x10249
xorl %ecx, %ecx
cmpb $0x0, 0x1(%rsi)
movl $0x0, %eax
je 0x1027a
retq
incq %rsi
xorl %ecx, %ecx
movl %eax, %edi
testb %dil, %dil
je 0x1027a
addb $-0x30, %dil
xorl %eax, %eax
cmpb $0x9, %dil
ja 0x10248
cmpl $0xccccccc, %ecx        # imm = 0xCCCCCCC
jge 0x10248
imull $0xa, %ecx, %eax
movzbl %dil, %ecx
addl %eax, %ecx
movb (%rsi), %dil
incq %rsi
jmp 0x10250
movl %ecx, (%rdx)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_unflattenarray
void jsR_unflattenarray(js_State *J, js_Object *obj) {
	if (obj->type == JS_CARRAY && obj->u.a.simple) {
		js_Property *ref;
		int i;
		char name[32];
		if (js_try(J)) {
			obj->properties = NULL;
			js_throw(J);
		}
		for (i = 0; i < obj->u.a.flat_length; ++i) {
			js_itoa(name, i);
			ref = jsV_setproperty(J, obj, name);
			ref->value = obj->u.a.array[i];
		}
		js_free(J, obj->u.a.array);
		obj->u.a.simple = 0;
		obj->u.a.flat_length = 0;
		obj->u.a.flat_capacity = 0;
		obj->u.a.array = NULL;
		js_endtry(J);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rsi)
jne 0x1031c
movq %rsi, %r14
cmpl $0x0, 0x24(%rsi)
je 0x1031c
movq %rdi, %rbx
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1032b
leaq 0x24(%r14), %r12
xorl %eax, %eax
movl %eax, %r13d
movq %rsp, %r15
movq %r13, %rbp
movslq 0x28(%r14), %rax
cmpq %rax, %rbp
jge 0x102fa
movl %ebp, %esi
movq %r15, %rdi
callq 0xe0ad
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdcd0
movq 0x30(%r14), %rcx
movups (%rcx,%r13), %xmm0
movups %xmm0, 0x18(%rax)
incq %rbp
addq $0x10, %r13
jmp 0x102c3
movq 0x30(%r14), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andl $0x0, 0x10(%r12)
movq %rbx, %rdi
callq 0xf5a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_ref
const char *js_ref(js_State *J)
{
	js_Value *v = stackidx(J, -1);
	const char *s;
	char buf[32];
	switch (v->t.type) {
	case JS_TUNDEFINED: s = "_Undefined"; break;
	case JS_TNULL: s = "_Null"; break;
	case JS_TBOOLEAN:
		s = v->u.boolean ? "_True" : "_False";
		break;
	case JS_TOBJECT:
		sprintf(buf, "%p", (void*)v->u.object);
		s = js_intern(J, buf);
		break;
	default:
		sprintf(buf, "%d", J->nextref++);
		s = js_intern(J, buf);
		break;
	}
	js_setregistry(J, s);
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $-0x1
popq %rsi
callq 0xf87b
movzbl 0xf(%rax), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x103a7
leaq 0x104c8(%rip), %rdx     # 0x20824
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x18434(%rip), %r14     # 0x287a0
jmp 0x103d8
cmpl $0x0, (%rax)
leaq 0x1843f(%rip), %rax     # 0x287b7
leaq 0x18432(%rip), %r14     # 0x287b1
cmoveq %rax, %r14
jmp 0x103d8
leaq 0x1841f(%rip), %r14     # 0x287ab
jmp 0x103d8
movq (%rax), %rdx
leaq 0x18426(%rip), %rsi     # 0x287be
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3220
jmp 0x103ca
movl 0x118(%rbx), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x118(%rbx)
leaq 0x18f43(%rip), %rsi     # 0x29300
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3220
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab8e
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x103ee
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_delproperty
static int jsR_delproperty(js_State *J, js_Object *obj, const char *name)
{
	js_Property *ref;
	int k;

	if (obj->type == JS_CARRAY) {
		if (!strcmp(name, "length"))
			goto dontconf;
		if (obj->u.a.simple)
			jsR_unflattenarray(J, obj);
	}

	else if (obj->type == JS_CSTRING) {
		if (!strcmp(name, "length"))
			goto dontconf;
		if (js_isarrayindex(J, name, &k))
			if (k >= 0 && k < obj->u.s.length)
				goto dontconf;
	}

	else if (obj->type == JS_CREGEXP) {
		if (!strcmp(name, "source")) goto dontconf;
		if (!strcmp(name, "global")) goto dontconf;
		if (!strcmp(name, "ignoreCase")) goto dontconf;
		if (!strcmp(name, "multiline")) goto dontconf;
		if (!strcmp(name, "lastIndex")) goto dontconf;
	}

	else if (obj->type == JS_CUSERDATA) {
		if (obj->u.user.delete && obj->u.user.delete(J, obj->u.user.data, name))
			return 1;
	}

	ref = jsV_getownproperty(J, obj, name);
	if (ref) {
		if (ref->atts & JS_DONTCONF)
			goto dontconf;
		jsV_delproperty(J, obj, name);
	}
	return 1;

dontconf:
	if (J->strict)
		js_typeerror(J, "'%s' is non-configurable", name);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %eax
pushq $0x1
popq %rbp
cmpl $0xf, %eax
je 0x108c4
cmpl $0x8, %eax
je 0x10810
cmpl $0x9, %eax
je 0x1085f
cmpl $0x1, %eax
jne 0x108dd
leaq 0x17f6c(%rip), %rsi     # 0x28751
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
cmpl $0x0, 0x24(%r15)
je 0x108dd
movq %r14, %rdi
movq %r15, %rsi
callq 0x10280
jmp 0x108dd
leaq 0x17f3a(%rip), %rsi     # 0x28751
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
leaq 0xc(%rsp), %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1022f
testl %eax, %eax
setne %cl
movl (%r12), %eax
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x108dd
cmpl 0x20(%r15), %eax
jge 0x108dd
jmp 0x10904
leaq 0x192e2(%rip), %rsi     # 0x29b48
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
leaq 0x192d2(%rip), %rsi     # 0x29b4f
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
leaq 0x192c6(%rip), %rsi     # 0x29b56
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
leaq 0x192be(%rip), %rsi     # 0x29b61
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10904
leaq 0x192b5(%rip), %rsi     # 0x29b6b
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x108dd
jmp 0x10904
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x108dd
movq 0x28(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *%rax
testl %eax, %eax
jne 0x1090d
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0xdc30
testq %rax, %rax
je 0x1090d
testb $0x4, 0x14(%rax)
jne 0x10904
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xde25
jmp 0x1090d
xorl %ebp, %ebp
cmpl $0x0, 0x34(%r14)
jne 0x1091c
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1974a(%rip), %rsi     # 0x2a06d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_tofunction
static js_Object *jsR_tofunction(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TUNDEFINED || v->t.type == JS_TNULL)
		return NULL;
	if (v->t.type == JS_TOBJECT)
		if (v->u.object->type == JS_CFUNCTION || v->u.object->type == JS_CCFUNCTION)
			return v->u.object;
	js_typeerror(J, "not a function");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf87b
movzbl 0xf(%rax), %ecx
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jae 0x10bf0
xorl %eax, %eax
popq %rbx
retq
cmpl $0x7, %ecx
jne 0x10c04
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x10bee
cmpl $0x4, %ecx
je 0x10bee
leaq 0x1867c(%rip), %rsi     # 0x29287
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_hasindex
static int jsR_hasindex(js_State *J, js_Object *obj, int k)
{
	char buf[32];
	if (obj->type == JS_CARRAY && obj->u.a.simple) {
		if (k >= 0 && k < obj->u.a.flat_length) {
			js_pushvalue(J, obj->u.a.array[k]);
			return 1;
		}
		return 0;
	}
	return jsR_hasproperty(J, obj, js_itoa(buf, k));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x10f33
cmpl $0x0, 0x24(%r14)
je 0x10f33
xorl %eax, %eax
testl %edx, %edx
js 0x10f4e
cmpl %edx, 0x28(%r14)
jle 0x10f4e
movq 0x30(%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0xf74a
pushq $0x1
popq %rax
jmp 0x10f4e
movq %rsp, %r15
movq %r15, %rdi
movl %edx, %esi
callq 0xe0ad
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10c36
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_setindex
static void jsR_setindex(js_State *J, js_Object *obj, int k, int transient)
{
	char buf[32];
	if (obj->type == JS_CARRAY && obj->u.a.simple && k >= 0 && k <= obj->u.a.flat_length) {
		jsR_setarrayindex(J, obj, k, stackidx(J, -1));
	} else {
		jsR_setproperty(J, obj, js_itoa(buf, k), transient);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, (%rsi)
jne 0x10f83
testl %ebp, %ebp
js 0x10f83
cmpl $0x0, 0x24(%rbx)
je 0x10f83
cmpl %ebp, 0x28(%rbx)
jge 0x10fae
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0xe0ad
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x10447
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xf87b
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %rax, %rcx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1cadd
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_newenvironment
js_Environment *jsR_newenvironment(js_State *J, js_Object *vars, js_Environment *outer)
{
	js_Environment *E = js_malloc(J, sizeof *E);
	E->gcmark = 0;
	E->gcnext = J->gcenv;
	J->gcenv = E;
	++J->gccounter;

	E->outer = outer;
	E->variables = vars;
	return E;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x20
popq %rsi
callq 0xa9e8
andl $0x0, 0x18(%rax)
movq 0x160(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x160(%r15)
incl 0x154(%r15)
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_pushtrace
static void jsR_pushtrace(js_State *J, const char *name, const char *file, int line)
{
	if (J->tracetop + 1 == JS_ENVLIMIT)
		js_error(J, "call stack overflow");
	++J->tracetop;
	J->trace[J->tracetop].name = name;
	J->trace[J->tracetop].file = file;
	J->trace[J->tracetop].line = line;
}

// Assembly:
movslq 0x2190(%rdi), %rax
incq %rax
cmpl $0x400, %eax            # imm = 0x400
je 0x114af
movl %eax, 0x2190(%rdi)
imulq $0x18, %rax, %rax
movq %rsi, 0x2198(%rdi,%rax)
movq %rdx, 0x21a0(%rdi,%rax)
movl %ecx, 0x21a8(%rdi,%rax)
retq
pushq %rax
leaq 0x18bf5(%rip), %rsi     # 0x2a0ac
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_callcfunction
static void jsR_callcfunction(js_State *J, int n, int min, js_CFunction F)
{
	int save_top;
	int i;
	js_Value v;

	for (i = n; i < min; ++i)
		js_pushundefined(J);

	save_top = TOP;
	F(J);
	if (TOP > save_top) {
		v = *stackidx(J, -1);
		TOP = --BOT; /* clear stack */
		js_pushvalue(J, v);
	} else {
		TOP = --BOT; /* clear stack */
		js_pushundefined(J);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
cmpl %ebp, %r15d
jge 0x114e2
movq %rbx, %rdi
callq 0x7336
incl %r15d
jmp 0x114d0
movl 0x140(%rbx), %ebp
movq %rbx, %rdi
callq *%r14
cmpl %ebp, 0x140(%rbx)
jle 0x1152e
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf87b
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf74a
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_eval
void js_eval(js_State *J)
{
	if (!js_isstring(J, -1))
		return;
	js_loadeval(J, "(eval)", js_tostring(J, -1));
	js_rot2pop1(J);
	js_copy(J, 0); /* copy 'this' */
	js_call(J, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %rsi
callq 0xf907
testl %eax, %eax
je 0x11750
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
leaq 0x170f4(%rip), %rsi     # 0x28802
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11752
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeee2
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x110b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pconstruct
int js_pconstruct(js_State *J, int n)
{
	int savetop = TOP - n - 2;
	if (js_try(J)) {
		/* clean up the stack to only hold the error object */
		STACK[savetop] = STACK[TOP-1];
		TOP = savetop + 1;
		return 1;
	}
	js_construct(J, n);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x140(%rdi), %r14
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x117b4
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movq 0x148(%rbx), %rdx
shlq $0x4, %rax
movslq 0x140(%rbx), %rsi
shlq $0x4, %rsi
movups -0x10(%rdx,%rsi), %xmm0
movups %xmm0, -0x20(%rdx,%rax)
movl %r14d, %eax
decl %eax
movl %eax, 0x140(%rbx)
pushq $0x1
popq %rax
jmp 0x117c8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11554
movq %rbx, %rdi
callq 0xf5a7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pcall
int js_pcall(js_State *J, int n)
{
	int savetop = TOP - n - 2;
	if (js_try(J)) {
		/* clean up the stack to only hold the error object */
		STACK[savetop] = STACK[TOP-1];
		TOP = savetop + 1;
		return 1;
	}
	js_call(J, n);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x140(%rdi), %r14
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x11827
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movq 0x148(%rbx), %rdx
shlq $0x4, %rax
movslq 0x140(%rbx), %rsi
shlq $0x4, %rsi
movups -0x10(%rdx,%rsi), %xmm0
movups %xmm0, -0x20(%rdx,%rax)
movl %r14d, %eax
decl %eax
movl %eax, 0x140(%rbx)
pushq $0x1
popq %rax
jmp 0x1183b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x110b0
movq %rbx, %rdi
callq 0xf5a7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_savetrypc
void *js_savetrypc(js_State *J, js_Instruction *pc)
{
	if (J->trytop == JS_TRYLIMIT)
		js_trystackoverflow(J);
	J->trybuf[J->trytop].E = J->E;
	J->trybuf[J->trytop].envtop = J->envtop;
	J->trybuf[J->trytop].tracetop = J->tracetop;
	J->trybuf[J->trytop].top = J->top;
	J->trybuf[J->trytop].bot = J->bot;
	J->trybuf[J->trytop].strict = J->strict;
	J->trybuf[J->trytop].pc = pc;
	return J->trybuf[J->trytop++].buf;
}

// Assembly:
movslq 0x8198(%rdi), %rcx
cmpq $0x40, %rcx
je 0x118aa
movq 0x130(%rdi), %rdx
imulq $0xf0, %rcx, %rax
addq %rdi, %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq %rdx, 0xc8(%rax)
movl 0x188(%rdi), %edx
movl %edx, 0xd0(%rax)
movl 0x2190(%rdi), %edx
movl %edx, 0xd4(%rax)
movq 0x140(%rdi), %rdx
movq %rdx, 0xd8(%rax)
movl 0x34(%rdi), %edx
movl %edx, 0xe0(%rax)
movq %rsi, 0xe8(%rax)
incl %ecx
movl %ecx, 0x8198(%rdi)
retq
pushq %rax
callq 0x118b0
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_trystackoverflow
static void js_trystackoverflow(js_State *J)
{
	STACK[TOP].t.type = JS_TLITSTR;
	STACK[TOP].u.litstr = "exception stack overflow";
	++TOP;
	js_throw(J);
}

// Assembly:
pushq %rax
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x16f4a(%rip), %rdx     # 0x2882b
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x7714