LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsregexp.c
// Function: js_RegExp_prototype_exec
void js_RegExp_prototype_exec(js_State *J, js_Regexp *re, const char *text)
{
	const char *haystack;
	int result;
	int i;
	int opts;
	Resub m;

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

	result = js_regexec(re->prog, haystack, &m, opts);
	if (result < 0)
		js_error(J, "regexec failed");
	if (result == 0) {
		js_newarray(J);
		js_pushstring(J, text);
		js_setproperty(J, -2, "input");
		js_pushnumber(J, js_utfptrtoidx(text, m.sub[0].sp));
		js_setproperty(J, -2, "index");
		for (i = 0; i < m.nsub; ++i) {
			js_pushlstring(J, m.sub[i].sp, m.sub[i].ep - m.sub[i].sp);
			js_setindex(J, -2, i);
		}
		if (re->flags & JS_REGEXP_G)
			re->last = m.sub[0].ep - text;
		return;
	}

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

	js_pushnull(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
testb $0x1, 0x10(%rsi)
movq %rdx, %r12
je 0x133fa
movzwl 0x12(%rbx), %r12d
movq %r15, %rdi
callq 0x3200
cmpq %r12, %rax
jb 0x13440
xorl %ebp, %ebp
testq %r12, %r12
setne %bpl
addq %r15, %r12
shll $0x2, %ebp
movq (%rbx), %r13
movl 0x1c(%r13), %eax
leaq 0x8(%rsp), %rdi
movl %eax, -0x8(%rdi)
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x3060
movq (%r13), %rdi
orl 0x18(%r13), %ebp
movq %rsp, %r8
movq %r12, %rsi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x1c171
testl %eax, %eax
js 0x13514
je 0x1345f
testb $0x1, 0x10(%rbx)
je 0x13446
movw $0x0, 0x12(%rbx)
movq %r14, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13525
movq %r14, %rdi
callq 0x135de
movq %r14, %rdi
movq %r15, %rsi
callq 0x13665
leaq 0x20270(%rip), %rdx     # 0x336e9
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41f3
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x137a2
cvtsi2sd %eax, %xmm0
movq %r14, %rdi
callq 0x4184
leaq 0x20249(%rip), %rdx     # 0x336ef
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41f3
movslq (%rsp), %r13
testq %r13, %r13
jle 0x134f1
leaq 0x10(%rsp), %rbp
xorl %r12d, %r12d
movq -0x8(%rbp), %rsi
movl (%rbp), %edx
subl %esi, %edx
movq %r14, %rdi
callq 0x13802
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r12d, %edx
callq 0x1393c
incq %r12
addq $0x10, %rbp
cmpq %r12, %r13
jne 0x134c4
testb $0x1, 0x10(%rbx)
je 0x13502
movl 0x10(%rsp), %eax
subl %r15d, %eax
movw %ax, 0x12(%rbx)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x201bf(%rip), %rsi     # 0x336da
movq %r14, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./regexp.c
// Function: js_regexec
int regexec(Reprog *prog, const char *sp, Resub *sub, int eflags)
{
	Resub scratch;
	int i;

	if (!sub)
		sub = &scratch;

	sub->nsub = prog->nsub;
	for (i = 0; i < REG_MAXSUB; ++i)
		sub->sub[i].sp = sub->sub[i].ep = NULL;

	return match(prog->start, sp, sp, prog->flags | eflags, sub, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %ecx, %ebx
movq %rsi, %r14
testq %rdx, %rdx
movq %rsp, %r15
cmovneq %rdx, %r15
movq %rdi, %r12
movl 0x1c(%rdi), %eax
movl %eax, (%r15)
leaq 0x8(%r15), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x3060
movq (%r12), %rdi
orl 0x18(%r12), %ebx
movq %r14, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x1c171
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3200
cmpq $0x10000001, %rax       # imm = 0x10000001
jae 0x13756
movslq 0x140(%rbx), %rcx
cmpq $0xfff, %rcx            # imm = 0xFFF
jge 0x13767
movq %rax, %r15
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
cmpq $0xf, %r15
ja 0x136e7
addq %rcx, %rax
testq %r15, %r15
je 0x136cb
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x136b9
addq %rcx, %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rdx
shlq $0x4, %rdx
movb %cl, 0xf(%rax,%rdx)
jmp 0x13744
movb $0x6, 0xf(%rax,%rcx)
leal 0xa(%r15), %esi
movq %rbx, %rdi
callq 0xe119
movq %rax, %r12
leaq 0x9(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33d0
xorl %eax, %eax
movb %al, 0x9(%r12,%r15)
movb %al, 0x8(%r12)
movq 0x178(%rbx), %rax
movq %rax, (%r12)
movq %r12, 0x178(%rbx)
incl 0x154(%rbx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movq %r12, (%rax,%rcx)
incl 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1ffe5(%rip), %rsi     # 0x33742
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcab5
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x21916(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq %rbx, %rdi
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
xorl %r14d, %r14d
cmpq %rsi, %rdi
jae 0x137f3
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x4(%rsp), %r12
movl $0x1, %eax
cmpb $0x0, (%r15)
jns 0x137d8
movq %r12, %rdi
movq %r15, %rsi
callq 0x18750
movl %eax, %eax
addq %rax, %r15
xorl %eax, %eax
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
setge %al
addl %eax, %r14d
incl %r14d
cmpq %rbx, %r15
jb 0x137c0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x10000001, %edx       # imm = 0x10000001
jge 0x138f0
movslq 0x140(%rbx), %rcx
cmpq $0xfff, %rcx            # imm = 0xFFF
jge 0x13901
movl %edx, %r15d
movq %rsi, %r14
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
cmpl $0xf, %edx
jg 0x1387e
addq %rcx, %rax
testl %r15d, %r15d
je 0x13862
movl %r15d, %edx
xorl %ecx, %ecx
movb (%r14,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
cmpl %ecx, %edx
jne 0x13850
addq %rcx, %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rdx
shlq $0x4, %rdx
movb %cl, 0xf(%rax,%rdx)
jmp 0x138de
movb $0x6, 0xf(%rax,%rcx)
leal 0xa(%r15), %esi
movq %rbx, %rdi
callq 0xe119
movq %rax, %r12
leaq 0x9(%rax), %rdi
movl %r15d, %r15d
movq %r14, %rsi
movq %r15, %rdx
callq 0x33d0
xorl %eax, %eax
movb %al, 0x9(%r12,%r15)
movb %al, 0x8(%r12)
movq 0x178(%rbx), %rax
movq %rax, (%r12)
movq %r12, 0x178(%rbx)
incl 0x154(%rbx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movq %r12, (%rax,%rcx)
incl 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1fe4b(%rip), %rsi     # 0x33742
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcab5
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x2177c(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq %rbx, %rdi
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x15720
movq %rax, %r14
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x13ad1
movq %r14, %r15
movq 0x8(%r14), %rdi
callq 0x3200
leal 0x6(%rax), %esi
movq %rbx, %rdi
callq 0xe119
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)
testb $0x1, 0x10(%r15)
je 0x13a5a
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x67, (%r14,%rax)
testb $0x2, 0x10(%r15)
je 0x13a74
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x69, (%r14,%rax)
testb $0x4, 0x10(%r15)
je 0x13a8e
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3200
movw $0x6d, (%r14,%rax)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jl 0x13ae5
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x13665
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x13af4
decl %eax
movl %eax, 0x8198(%rbx)
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %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 0x8ec6
movl %eax, 0x140(%rbx)
leaq 0x1fc7c(%rip), %rsi     # 0x3376e
jmp 0x13afb
leaq 0x1fd0e(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x15720
movq %rax, %r14
movl 0x144(%rbx), %eax
leaq 0x2c8c8(%rip), %rsi     # 0x403f8
cmpl $-0x1, %eax
jl 0x13b4c
incl %eax
cmpl 0x140(%rbx), %eax
jge 0x13b4c
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r15
testb $0x1, 0x10(%r14)
je 0x13b8a
movzwl 0x12(%r14), %r12d
movq %r15, %rdi
callq 0x3200
cmpq %r12, %rax
jae 0x13b7b
movw $0x0, 0x12(%r14)
xorl %esi, %esi
jmp 0x13bf3
xorl %ebp, %ebp
testq %r12, %r12
setne %bpl
addq %r12, %r15
shll $0x2, %ebp
movq (%r14), %r12
movl 0x1c(%r12), %eax
leaq 0x10(%rsp), %rdi
movl %eax, -0x8(%rdi)
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x3060
movq (%r12), %rdi
orl 0x18(%r12), %ebp
leaq 0x8(%rsp), %r8
movq %r15, %rsi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
callq 0x1c171
testl %eax, %eax
js 0x13c0a
movzwl 0x10(%r14), %eax
je 0x13bde
xorl %esi, %esi
testb $0x1, %al
je 0x13bf3
movw $0x0, 0x12(%r14)
jmp 0x13bf3
movl $0x1, %esi
testb $0x1, %al
je 0x13bf3
movl 0x18(%rsp), %eax
subl %r15d, %eax
addw %ax, 0x12(%r14)
movq %rbx, %rdi
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14ad9
leaq 0x1fac9(%rip), %rsi     # 0x336da
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movq $0x0, 0x8(%rsp)
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x13f89
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14073
movl 0x140(%rbx), %eax
movl 0x144(%rbx), %ebp
decl %eax
movl %eax, 0x144(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14101
movl %ebp, 0x144(%rbx)
movl 0x140(%rbx), %eax
movl %eax, %ecx
decl %ecx
movl %ecx, 0x140(%rbx)
cmpl %ebp, %eax
jle 0x13f9b
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe0bc
movq (%r14), %r14
leaq 0x8(%r14), %rax
testq %r14, %r14
leaq 0x212e6(%rip), %rsi     # 0x3523d
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x13665
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x13faa
decl %eax
movl %eax, 0x8198(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %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 0x8ec6
movl %ebp, 0x140(%rbx)
leaq 0x1f7c6(%rip), %rsi     # 0x3376e
jmp 0x13fb1
leaq 0x1f858(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x14033
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)
movl 0x140(%rdi), %edx
movl %edx, 0xd8(%rax)
movl 0x144(%rdi), %edx
movl %edx, 0xdc(%rax)
movl 0x34(%rdi), %edx
movl %edx, 0xe0(%rax)
movq $0x0, 0xe8(%rax)
incl %ecx
movl %ecx, 0x8198(%rdi)
retq
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 0x1f7c7(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x14954
movslq 0x140(%rdi), %rcx
cmpl %ecx, %eax
jge 0x14954
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 0x1ee23(%rip), %rsi     # 0x3377f
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x149e4
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x14a03
movl %eax, 0x140(%rbx)
leaq 0x1ed8c(%rip), %rsi     # 0x3376e
jmp 0x14a12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x148df
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x14a0b
movq %rax, %r14
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1edf7(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: jsV_newmemstring
js_String *jsV_newmemstring(js_State *J, const char *s, int n)
{
	js_String *v = js_malloc(J, soffsetof(js_String, p) + n + 1);
	memcpy(v->p, s, n);
	v->p[n] = 0;
	v->gcmark = 0;
	v->gcnext = J->gcstr;
	J->gcstr = v;
	++J->gccounter;
	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal 0xa(%rbx), %esi
callq 0xe119
movq %rax, %r12
leaq 0x9(%rax), %rdi
movslq %ebx, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33d0
xorl %eax, %eax
movb %al, 0x9(%r12,%rbx)
movb %al, 0x8(%r12)
movq 0x178(%r15), %rax
movq %rax, (%r12)
movq %r12, 0x178(%r15)
incl 0x154(%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x14b1b
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
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x20568(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x14b9a
movslq 0x144(%rdi), %rdx
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
testq %rdx, %rdx
jle 0x14b8e
shlq $0x4, %rdx
movups -0x10(%rcx,%rdx), %xmm0
movups %xmm0, (%rcx,%rax)
jmp 0x14b93
movb $0x1, 0xf(%rcx,%rax)
incl 0x140(%rdi)
retq
pushq %rax
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x204e2(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x150ea
leaq 0x166ee(%rip), %rcx     # 0x2b7c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
retq
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd (%rsi), %xmm0
jmp 0x1510d
xorl %eax, %eax
cmpb $0x0, (%rsi)
jmp 0x1510d
movl (%rsi), %eax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, 0x9(%rcx)
jmp 0x1510d
movl $0x1, %eax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0xf(%rbx), %eax
cmpl $0x7, %eax
jne 0x15171
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x15634
jmp 0x15156
decl %eax
cmpl $0x5, %eax
ja 0x151b8
leaq 0x1665d(%rip), %rcx     # 0x2b7dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x162c0(%rip), %xmm0    # 0x2b450
jmp 0x151a7
movq (%rbx), %rsi
jmp 0x151bb
cvtsi2sdl (%rbx), %xmm0
jmp 0x151a7
movsd (%rbx), %xmm0
jmp 0x151a7
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0x151bb
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12f0d
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x15275
pushq %rax
movsd 0x16338(%rip), %xmm1    # 0x2b570
callq 0x31b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x15256
callq 0x3090
addsd 0x1631c(%rip), %xmm0    # 0x2b570
jmp 0x1525b
callq 0x3370
ucomisd 0x16315(%rip), %xmm0    # 0x2b578
jb 0x1526d
addsd 0x16313(%rip), %xmm0    # 0x2b580
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl 0xf(%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x153bb
movq %rdi, %r14
leaq 0x16493(%rip), %rcx     # 0x2b7f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1fecc(%rip), %rbx     # 0x3523d
jmp 0x153bb
movq (%rbx), %rbx
jmp 0x153bb
cmpl $0x0, (%rbx)
leaq 0x1e71c(%rip), %rax     # 0x33a9e
leaq 0x1e710(%rip), %rbx     # 0x33a99
cmoveq %rax, %rbx
jmp 0x153bb
movsd (%rbx), %xmm0
movq %rsp, %r12
movq %r12, %rsi
callq 0x1303a
movq %rax, %r15
cmpq %r12, %rax
je 0x153f6
movq %r15, %rbx
jmp 0x153bb
leaq 0x1f7c9(%rip), %rbx     # 0x34b7b
jmp 0x153bb
movq (%rbx), %rbx
addq $0x9, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x15634
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1533b
movq %r15, %rdi
callq 0x3200
movq %rax, %r12
cmpl $0xf, %r12d
jg 0x1542c
movq %rbx, %rax
testl %r12d, %r12d
je 0x15423
xorl %eax, %eax
movb (%r15,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpl %eax, %r12d
jne 0x15411
addq %rbx, %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0xf(%rbx)
jmp 0x153bb
movl %r12d, %esi
addl $0xa, %esi
movq %r14, %rdi
callq 0xe119
movq %rax, %r13
leaq 0x9(%rax), %rbp
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33d0
xorl %eax, %eax
movb %al, 0x9(%r13,%r12)
movb %al, 0x8(%r13)
movq 0x178(%r14), %rax
movq %rax, (%r13)
movq %r13, 0x178(%r14)
incl 0x154(%r14)
movq %r13, (%rbx)
movb $0x6, 0xf(%rbx)
movq %rbp, %rbx
jmp 0x153bb
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movzbl 0xf(%rsi), %eax
cmpq $0x7, %rax
ja 0x155e8
movq %rsi, %rbx
leaq 0x16365(%rip), %rcx     # 0x2b810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x155c8
movl (%rbx), %ebp
movq 0xa8(%r14), %r15
movq %r14, %rdi
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%r14)
incl 0x154(%r14)
movabsq $0x100000006, %rcx      # imm = 0x100000006
movq %rcx, (%rax)
leaq 0x2ae94(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r15, 0x18(%rax)
movl %ebp, 0x20(%rax)
jmp 0x155cd
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0xb0(%r14), %r15
movq %r14, %rdi
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%r14)
incl 0x154(%r14)
movabsq $0x100000007, %rcx      # imm = 0x100000007
movq %rcx, (%rax)
leaq 0x2ae18(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r15, 0x18(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0x155cd
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0x155c5
movq (%rbx), %rax
jmp 0x155d4
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1a241
movb $0x7, 0xf(%rbx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e4e1(%rip), %rsi     # 0x33ac7
jmp 0x155ef
leaq 0x1e4b5(%rip), %rsi     # 0x33aa4
movq %r14, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x156db
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testl %edx, %edx
jne 0x1565b
xorl %edx, %edx
cmpl $0xa, (%r15)
sete %dl
incl %edx
movq %rbx, %rdi
movq %r15, %rsi
cmpl $0x2, %edx
jne 0x1567c
callq 0x19e2b
testl %eax, %eax
jne 0x15694
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19f29
jmp 0x15690
callq 0x19f29
testl %eax, %eax
jne 0x15694
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19e2b
testl %eax, %eax
je 0x156e1
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x156b4
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x156bb
leaq 0x2ad3d(%rip), %rax     # 0x403f8
movups (%rax), %xmm0
movups %xmm0, (%r14)
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x156f8
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x34(%rbx)
jne 0x1570f
movb $0x5, 0xf(%r14)
leaq 0x1e389(%rip), %rax     # 0x33a7c
movq %rax, (%r14)
jmp 0x156db
movl %eax, 0x140(%rbx)
leaq 0x1e069(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x1e343(%rip), %rsi     # 0x33a59
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x2ac6a(%rip), %rax     # 0x403f8
js 0x157a6
cmpl 0x140(%r14), %esi
jge 0x157a6
movl %esi, %eax
shlq $0x4, %rax
addq 0x148(%r14), %rax
cmpb $0x7, 0xf(%rax)
jne 0x157cf
movq (%rax), %r15
cmpl $0xf, (%r15)
jne 0x157cf
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x157cf
movq 0x28(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1df8f(%rip), %rsi     # 0x33765
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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), %ecx
cmpl 0x144(%rdi), %ecx
jl 0x15865
cmpl 0x140(%rdi), %ecx
jge 0x15865
movl 0x140(%rdi), %r8d
decl %r8d
cmpl %r8d, %ecx
jge 0x1585c
movslq %esi, %rcx
addq %rcx, %rax
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x10(%rcx), %rdx
movq 0x148(%rdi), %rsi
incq %rax
movups (%rsi,%rdx), %xmm0
movups %xmm0, (%rsi,%rcx)
movslq 0x140(%rdi), %r8
decq %r8
addq $0x10, %rcx
addq $0x10, %rdx
cmpq %r8, %rax
jl 0x15833
movl %r8d, 0x140(%rdi)
popq %rax
retq
leaq 0x1df13(%rip), %rsi     # 0x3377f
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movq 0x148(%rdi), %rcx
cmpq $0xffe, %rax            # imm = 0xFFE
jge 0x15925
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
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x1f75e(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_rot3
void js_rot3(js_State *J)
{
	/* A B C -> C A B */
	js_Value tmp = STACK[TOP-1];	/* A B C (C) */
	STACK[TOP-1] = STACK[TOP-2];	/* A B B */
	STACK[TOP-2] = STACK[TOP-3];	/* A A B */
	STACK[TOP-3] = tmp;		/* C A B */
}

// Assembly:
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, -0x18(%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x30(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movaps -0x18(%rsp), %xmm0
movups %xmm0, -0x30(%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_rot4
void js_rot4(js_State *J)
{
	/* A B C D -> D A B C */
	js_Value tmp = STACK[TOP-1];	/* A B C D (D) */
	STACK[TOP-1] = STACK[TOP-2];	/* A B C C */
	STACK[TOP-2] = STACK[TOP-3];	/* A B B C */
	STACK[TOP-3] = STACK[TOP-4];	/* A A B C */
	STACK[TOP-4] = tmp;		/* D A B C */
}

// Assembly:
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, -0x18(%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x30(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x40(%rax,%rcx), %xmm0
movups %xmm0, -0x30(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movaps -0x18(%rsp), %xmm0
movups %xmm0, -0x40(%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
cmpl $0x2, %esi
jl 0x15b14
leal -0x1(%rsi), %eax
movq $-0x1, %rcx
movq 0x148(%rdi), %rdx
movslq 0x140(%rdi), %r8
addq %rcx, %r8
shlq $0x4, %r8
movups -0x10(%rdx,%r8), %xmm0
movups %xmm0, (%rdx,%r8)
decq %rcx
decl %eax
jne 0x15aeb
movl %esi, %eax
movq 0x148(%rdi), %rcx
movslq 0x140(%rdi), %rdx
cltq
subq %rax, %rdx
shlq $0x4, %rdx
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rcx,%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x15b49
cmpl $0x30, %eax
jne 0x15b4a
xorl %eax, %eax
cmpb $0x0, 0x1(%rsi)
je 0x15b80
retq
xorl %eax, %eax
movb (%rsi), %cl
testb %cl, %cl
je 0x15b80
incq %rsi
addb $-0x30, %cl
cmpb $0xa, %cl
setb %dil
cmpl $0xccccccc, %eax        # imm = 0xCCCCCCC
setl %r8b
leal (%rax,%rax,4), %r9d
movzbl %cl, %ecx
leal (%rcx,%r9,2), %ecx
testb %r8b, %dil
cmovel %eax, %ecx
movl %ecx, %eax
jne 0x15b4c
xorl %eax, %eax
retq
movl %eax, (%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x15c47
movq %rsi, %r14
cmpl $0x0, 0x24(%rsi)
je 0x15c47
movq %rdi, %rbx
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x15c56
leaq 0x24(%r14), %r12
cmpl $0x0, 0x28(%r14)
jle 0x15c18
xorl %eax, %eax
movq %rsp, %r15
movq %rax, %rcx
movq %rcx, %r13
movq %rax, %rbp
movl %r13d, %esi
movq %r15, %rdi
callq 0x12cc2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x127de
movq 0x30(%r14), %rcx
movups (%rcx,%rbp), %xmm0
movups %xmm0, 0x18(%rax)
incq %r13
movslq 0x28(%r14), %rdx
addq $0x10, %rbp
movq %rbp, %rax
movq %r13, %rcx
cmpq %rdx, %r13
jl 0x15bd7
movq 0x30(%r14), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x0, 0x10(%r12)
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x15c66
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x8ec6
leaq 0x1db9c(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movslq 0x140(%rdi), %rax
testq %rax, %rax
jle 0x15ca1
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x15ca8
leaq 0x2a750(%rip), %rax     # 0x403f8
movzbl 0xf(%rax), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x15d05
leaq 0x15b76(%rip), %rdx     # 0x2b830
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1dad6(%rip), %r14     # 0x337a0
jmp 0x15d36
cmpl $0x0, (%rax)
leaq 0x1dae1(%rip), %rax     # 0x337b7
leaq 0x1dad4(%rip), %r14     # 0x337b1
cmoveq %rax, %r14
jmp 0x15d36
leaq 0x1dac1(%rip), %r14     # 0x337ab
jmp 0x15d36
movq (%rax), %rdx
leaq 0x1dac8(%rip), %rsi     # 0x337be
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3220
jmp 0x15d28
movl 0x118(%rbx), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x118(%rbx)
leaq 0x1e5da(%rip), %rsi     # 0x342f5
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3220
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe33c
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d4c
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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:
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x29ceb(%rip), %rax     # 0x403f8
js 0x16724
cmpl 0x140(%rdi), %esi
jge 0x16724
movl %esi, %eax
shlq $0x4, %rax
addq 0x148(%rdi), %rax
movzbl 0xf(%rax), %ecx
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jae 0x16733
xorl %eax, %eax
retq
cmpl $0x7, %ecx
jne 0x16748
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x16747
cmpl $0x4, %ecx
jne 0x16748
retq
pushq %rax
leaq 0x1db37(%rip), %rsi     # 0x34287
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x16a96
cmpl $0x0, 0x24(%r14)
je 0x16a96
xorl %eax, %eax
testl %edx, %edx
js 0x16ab1
cmpl %edx, 0x28(%r14)
jle 0x16ab1
movq 0x30(%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x14a7d
movl $0x1, %eax
jmp 0x16ab1
movq %rsp, %r15
movq %r15, %rdi
movl %edx, %esi
callq 0x12cc2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x16778
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, (%rsi)
jne 0x16ae1
testl %edx, %edx
js 0x16ae1
cmpl $0x0, 0x24(%rbx)
je 0x16ae1
cmpl %edx, 0x28(%rbx)
jge 0x16b09
movq %rsp, %r15
movq %r15, %rdi
movl %edx, %esi
callq 0x12cc2
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x15dd3
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x140(%r14), %rax
testq %rax, %rax
jle 0x16b29
movq 0x148(%r14), %rcx
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
jmp 0x16b30
leaq 0x298c8(%rip), %rcx     # 0x403f8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27345
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movl $0x20, %esi
callq 0xe119
movl $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_O1/ccxvii[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 0x17195
movl %eax, 0x2190(%rdi)
leaq (%rax,%rax,2), %rax
movq %rsi, 0x2198(%rdi,%rax,8)
movq %rdx, 0x21a0(%rdi,%rax,8)
movl %ecx, 0x21a8(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1df04(%rip), %rsi     # 0x350a1
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
subl %esi, %ebp
jle 0x171c0
movq %rbx, %rdi
callq 0x89b6
decl %ebp
jne 0x171b4
movl 0x140(%rbx), %ebp
movq %rbx, %rdi
callq *%r14
movl 0x140(%rbx), %eax
cmpl %ebp, %eax
jle 0x171ee
testl %eax, %eax
jle 0x1720e
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x17215
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x89b6
leaq 0x291e3(%rip), %rax     # 0x403f8
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x14a7d
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movl 0x140(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, %esi
testl %eax, %eax
jle 0x174d0
movq %rsi, %rcx
shlq $0x4, %rcx
addq 0x148(%rbx), %rcx
jmp 0x174d7
leaq 0x28f21(%rip), %rcx     # 0x403f8
movzbl 0xf(%rcx), %ecx
cmpl $0x6, %ecx
ja 0x17558
movl $0x61, %edx
btl %ecx, %edx
jae 0x17558
testl %eax, %eax
jle 0x174fb
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0x17502
leaq 0x28ef6(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x1533b
leaq 0x1c2f1(%rip), %rsi     # 0x33802
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x180dd
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 0x14073
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x16c25
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x175bf
leaq 0x140(%rbx), %rdx
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movl %r14d, %ecx
movq 0x148(%rbx), %rsi
shlq $0x4, %rax
movslq 0x140(%rbx), %rdi
shlq $0x4, %rdi
movups -0x10(%rsi,%rdi), %xmm0
movups %xmm0, -0x20(%rsi,%rax)
movl $0x1, %eax
jmp 0x175df
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1723c
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x175e8
addq $0x8198, %rbx           # imm = 0x8198
xorl %eax, %eax
movq %rbx, %rdx
decl %ecx
movl %ecx, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c21a(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17654
leaq 0x140(%rbx), %rdx
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movl %r14d, %ecx
movq 0x148(%rbx), %rsi
shlq $0x4, %rax
movslq 0x140(%rbx), %rdi
shlq $0x4, %rdi
movups -0x10(%rsi,%rdi), %xmm0
movups %xmm0, -0x20(%rsi,%rax)
movl $0x1, %eax
jmp 0x17674
movq %rbx, %rdi
movl %ebp, %esi
callq 0x16c25
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x1767d
addq $0x8198, %rbx           # imm = 0x8198
xorl %eax, %eax
movq %rbx, %rdx
decl %ecx
movl %ecx, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c185(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939