LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_setUTCDate
static void Dp_setUTCDate(js_State *J)
{
	double t = js_todate(J, 0);
	double y = YearFromTime(t);
	double m = MonthFromTime(t);
	double d = js_tonumber(J, 1);
	js_setdate(J, 0, MakeDate(MakeDay(y, m, d), TimeWithinDay(t)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x203f2
movl 0x144(%rbx), %eax
leaq 0x35471(%rip), %r14     # 0x403f8
cmpl $-0x1, %eax
jl 0xafa4
incl %eax
cmpl 0x140(%rbx), %eax
jge 0xafa4
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
movsd %xmm0, 0x8(%rsp)
callq 0x20936
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2080c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1514c
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x20caa
movsd %xmm0, (%rsp)
movsd 0x204c1(%rip), %xmm1    # 0x2b4c0
movsd 0x8(%rsp), %xmm0
callq 0x31b0
movapd %xmm0, %xmm1
movsd 0x204aa(%rip), %xmm4    # 0x2b4c0
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x20bcf
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_setMonth
static void Dp_setMonth(js_State *J)
{
	double t = LocalTime(js_todate(J, 0));
	double y = YearFromTime(t);
	double m = js_tonumber(J, 1);
	double d = js_optnumber(J, 2, DateFromTime(t));
	js_setdate(J, 0, UTC(MakeDate(MakeDay(y, m, d), TimeWithinDay(t))));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x203f2
movsd %xmm0, 0x8(%rsp)
callq 0x204c6
movl 0x144(%rbx), %eax
leaq 0x35382(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $-0x1, %eax
jl 0xb098
incl %eax
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0xb098
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, (%rsp)
movl 0x144(%rbx), %ecx
leal 0x2(%rcx), %eax
cmpl $-0x2, %ecx
jl 0xb0d9
cmpl 0x140(%rbx), %eax
jge 0xb0d9
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
movsd 0x8(%rsp), %xmm0
addsd 0x203e9(%rip), %xmm0    # 0x2b4d0
cmpb $0x1, 0xf(%r14)
movsd %xmm0, 0x8(%rsp)
jne 0xb102
callq 0x20a2e
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0xb12b
leaq 0x352ef(%rip), %rsi     # 0x403f8
cmpl $-0x2, %ecx
jl 0xb123
cmpl 0x140(%rbx), %eax
jge 0xb123
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2080c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x20caa
movsd %xmm0, (%rsp)
movsd 0x20360(%rip), %xmm1    # 0x2b4c0
movsd 0x8(%rsp), %xmm0
callq 0x31b0
movapd %xmm0, %xmm1
movsd 0x20349(%rip), %xmm4    # 0x2b4c0
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, (%rsp)
callq 0x204c6
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x204c6
movq %rbx, %rdi
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x20bcf
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_setUTCMonth
static void Dp_setUTCMonth(js_State *J)
{
	double t = js_todate(J, 0);
	double y = YearFromTime(t);
	double m = js_tonumber(J, 1);
	double d = js_optnumber(J, 2, DateFromTime(t));
	js_setdate(J, 0, MakeDate(MakeDay(y, m, d), TimeWithinDay(t)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x203f2
movsd %xmm0, 0x8(%rsp)
movl 0x144(%rbx), %eax
leaq 0x35204(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $-0x1, %eax
jl 0xb216
incl %eax
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0xb216
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, (%rsp)
movl 0x144(%rbx), %ecx
leal 0x2(%rcx), %eax
cmpl $-0x2, %ecx
jl 0xb247
cmpl 0x140(%rbx), %eax
jge 0xb247
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
cmpb $0x1, 0xf(%r14)
movsd 0x8(%rsp), %xmm0
jne 0xb262
callq 0x20a2e
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0xb28b
leaq 0x3518f(%rip), %rsi     # 0x403f8
cmpl $-0x2, %ecx
jl 0xb283
cmpl 0x140(%rbx), %eax
jge 0xb283
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2080c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x20caa
movsd %xmm0, (%rsp)
movsd 0x20200(%rip), %xmm1    # 0x2b4c0
movsd 0x8(%rsp), %xmm0
callq 0x31b0
movapd %xmm0, %xmm1
movsd 0x201e9(%rip), %xmm4    # 0x2b4c0
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x20bcf
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_setFullYear
static void Dp_setFullYear(js_State *J)
{
	double t = LocalTime(js_todate(J, 0));
	double y = js_tonumber(J, 1);
	double m = js_optnumber(J, 2, MonthFromTime(t));
	double d = js_optnumber(J, 3, DateFromTime(t));
	js_setdate(J, 0, UTC(MakeDate(MakeDay(y, m, d), TimeWithinDay(t))));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x203f2
movsd %xmm0, 0x8(%rsp)
callq 0x204c6
movl 0x144(%rbx), %eax
leaq 0x350c1(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $-0x1, %eax
jl 0xb359
incl %eax
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0xb359
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, (%rsp)
movl 0x144(%rbx), %ecx
leal 0x2(%rcx), %eax
cmpl $-0x2, %ecx
jl 0xb39a
cmpl 0x140(%rbx), %eax
jge 0xb39a
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
movsd 0x8(%rsp), %xmm0
addsd 0x20128(%rip), %xmm0    # 0x2b4d0
cmpb $0x1, 0xf(%r14)
movsd %xmm0, 0x8(%rsp)
jne 0xb3c3
callq 0x20936
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0xb3ec
leaq 0x3502e(%rip), %rsi     # 0x403f8
cmpl $-0x2, %ecx
jl 0xb3e4
cmpl 0x140(%rbx), %eax
jge 0xb3e4
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x10(%rsp)
movl 0x144(%rbx), %ecx
leal 0x3(%rcx), %eax
leaq 0x34ff6(%rip), %rdx     # 0x403f8
cmpl $-0x3, %ecx
jge 0xb40f
movsd 0x8(%rsp), %xmm0
jmp 0xb42a
cmpl 0x140(%rbx), %eax
movsd 0x8(%rsp), %xmm0
jge 0xb42a
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x1, 0xf(%rdx)
jne 0xb43b
callq 0x20a2e
cvtsi2sd %eax, %xmm2
jmp 0xb468
leaq 0x34fb6(%rip), %rsi     # 0x403f8
cmpl $-0x3, %ecx
jl 0xb45c
cmpl 0x140(%rbx), %eax
jge 0xb45c
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movapd %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x20caa
movsd %xmm0, (%rsp)
movsd 0x2003b(%rip), %xmm1    # 0x2b4c0
movsd 0x8(%rsp), %xmm0
callq 0x31b0
movapd %xmm0, %xmm1
movsd 0x20024(%rip), %xmm4    # 0x2b4c0
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, (%rsp)
callq 0x204c6
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x204c6
movq %rbx, %rdi
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x20bcf
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_setUTCFullYear
static void Dp_setUTCFullYear(js_State *J)
{
	double t = js_todate(J, 0);
	double y = js_tonumber(J, 1);
	double m = js_optnumber(J, 2, MonthFromTime(t));
	double d = js_optnumber(J, 3, DateFromTime(t));
	js_setdate(J, 0, MakeDate(MakeDay(y, m, d), TimeWithinDay(t)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x203f2
movsd %xmm0, (%rsp)
movl 0x144(%rbx), %eax
leaq 0x34ee0(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $-0x1, %eax
jl 0xb53a
incl %eax
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0xb53a
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x8(%rsp)
movl 0x144(%rbx), %ecx
leal 0x2(%rcx), %eax
cmpl $-0x2, %ecx
jl 0xb56c
cmpl 0x140(%rbx), %eax
jge 0xb56c
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
cmpb $0x1, 0xf(%r14)
movsd (%rsp), %xmm0
jne 0xb586
callq 0x20936
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0xb5af
leaq 0x34e6b(%rip), %rsi     # 0x403f8
cmpl $-0x2, %ecx
jl 0xb5a7
cmpl 0x140(%rbx), %eax
jge 0xb5a7
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x10(%rsp)
movl 0x144(%rbx), %ecx
leal 0x3(%rcx), %eax
leaq 0x34e33(%rip), %rdx     # 0x403f8
cmpl $-0x3, %ecx
jge 0xb5d1
movsd (%rsp), %xmm0
jmp 0xb5eb
cmpl 0x140(%rbx), %eax
movsd (%rsp), %xmm0
jge 0xb5eb
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x1, 0xf(%rdx)
jne 0xb5fc
callq 0x20a2e
cvtsi2sd %eax, %xmm2
jmp 0xb629
leaq 0x34df5(%rip), %rsi     # 0x403f8
cmpl $-0x3, %ecx
jl 0xb61d
cmpl 0x140(%rbx), %eax
jge 0xb61d
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x20caa
movsd %xmm0, 0x8(%rsp)
movsd 0x1fe78(%rip), %xmm1    # 0x2b4c0
movsd (%rsp), %xmm0
callq 0x31b0
movapd %xmm0, %xmm1
movsd 0x1fe62(%rip), %xmm4    # 0x2b4c0
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd 0x8(%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x20bcf
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_toISOString
static void Dp_toISOString(js_State *J)
{
	char buf[64];
	double t = js_todate(J, 0);
	if (!isfinite(t))
		js_rangeerror(J, "invalid date");
	js_pushstring(J, fmtdatetime(buf, t, 0));
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x203f2
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0xb6da
movq %rsp, %rdi
xorps %xmm1, %xmm1
callq 0x20444
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13665
addq $0x40, %rsp
popq %rbx
retq
leaq 0x28b85(%rip), %rsi     # 0x34266
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcab5
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdate.c
// Function: Dp_toJSON
static void Dp_toJSON(js_State *J)
{
	js_copy(J, 0);
	js_toprimitive(J, -1, JS_HNUMBER);
	if (js_isnumber(J, -1) && !isfinite(js_tonumber(J, -1))) {
		js_pushnull(J);
		return;
	}
	js_pop(J, 1);

	js_getproperty(J, 0, "toISOString");
	if (!js_iscallable(J, -1))
		js_typeerror(J, "this.toISOString is not a function");
	js_copy(J, 0);
	js_call(J, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x14073
movslq 0x140(%rbx), %rax
leaq 0x34cf1(%rip), %r14     # 0x403f8
movq %r14, %rsi
testq %rax, %rax
jle 0xb722
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x15634
movl 0x140(%rbx), %ecx
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jle 0xb74a
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
cmpb $0x4, 0xf(%r14)
jne 0xb79b
testl %ecx, %ecx
jle 0xb764
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0xb76b
leaq 0x34c8d(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x1514c
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xb79b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13525
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0xb7f1
leaq 0x27940(%rip), %rdx     # 0x330fb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4032
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14e17
testl %eax, %eax
je 0xb808
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16c25
movl %eax, 0x140(%rbx)
leaq 0x27f70(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x28a64(%rip), %rsi     # 0x34273
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsdtoa.c
// Function: js_fmtexp
void
js_fmtexp(char *p, int e)
{
	char se[9];
	int i;

	*p++ = 'e';
	if(e < 0) {
		*p++ = '-';
		e = -e;
	} else
		*p++ = '+';
	i = 0;
	while(e) {
		se[i++] = e % 10 + '0';
		e /= 10;
	}
	while(i < 1)
		se[i++] = '0';
	while(i > 0)
		*p++ = se[--i];
	*p++ = '\0';
}

// Assembly:
movb $0x65, (%rdi)
testl %esi, %esi
js 0xc284
movb $0x2b, 0x1(%rdi)
jmp 0xc28a
movb $0x2d, 0x1(%rdi)
negl %esi
xorl %eax, %eax
testl %esi, %esi
je 0xc2c0
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %esi, %edx
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %r8d
leal (%r8,%r8,4), %r8d
movl %esi, %r9d
subl %r8d, %r9d
orb $0x30, %r9b
movb %r9b, -0x9(%rsp,%rax)
incq %rax
cmpl $0xa, %esi
movl %edx, %esi
jae 0xc295
movl %eax, %ecx
testl %eax, %eax
jne 0xc2d2
movl %eax, %ecx
movb $0x30, -0x9(%rsp,%rcx)
movl $0x1, %ecx
addq $0x2, %rdi
testl %ecx, %ecx
jle 0xc2f5
cmpl $0x1, %eax
adcl $0x0, %eax
incq %rax
movb -0xb(%rsp,%rax), %cl
movb %cl, (%rdi)
incq %rdi
decq %rax
cmpq $0x1, %rax
jg 0xc2e3
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jserror.c
// Function: js_newerrorx
static void js_newerrorx(js_State *J, const char *message, js_Object *prototype)
{
	js_pushobject(J, jsV_newobject(J, JS_CERROR, prototype));
	js_pushstring(J, message);
	js_setproperty(J, -2, "message");
	if (jsB_stacktrace(J, 0))
		js_setproperty(J, -2, "stack");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
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(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000005, %rcx      # imm = 0x100000005
movq %rcx, (%rax)
leaq 0x33ade(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x44e7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13665
leaq 0x279d0(%rip), %rdx     # 0x342cf
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41f3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2129b
testl %eax, %eax
je 0xc933
leaq 0x279b6(%rip), %rdx     # 0x342d7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %r15
jmp 0x41f3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jserror.c
// Function: Ep_toString
static void Ep_toString(js_State *J)
{
	const char *name = "Error";
	const char *message = "";

	if (!js_isobject(J, -1))
		js_typeerror(J, "not an object");

	if (js_hasproperty(J, 0, "name"))
		name = js_tostring(J, -1);
	if (js_hasproperty(J, 0, "message"))
		message = js_tostring(J, -1);

	if (name[0] == 0)
		js_pushstring(J, message);
	else if (message[0] == 0)
		js_pushstring(J, name);
	else {
		js_pushstring(J, name);
		js_pushstring(J, ": ");
		js_concat(J);
		js_pushstring(J, message);
		js_concat(J);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x140(%rdi), %rax
testq %rax, %rax
jle 0xce80
movq 0x148(%rbx), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $-0x10, %rcx
jmp 0xce87
leaq 0x33571(%rip), %rcx     # 0x403f8
cmpb $0x7, 0xf(%rcx)
jne 0xd003
movl 0x144(%rbx), %esi
testl %esi, %esi
sets %cl
cmpl %eax, %esi
setge %al
orb %cl, %al
jne 0xceb2
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0xceb9
leaq 0x3353f(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x15489
leaq 0x26272(%rip), %rdx     # 0x3313a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16778
testl %eax, %eax
je 0xcef8
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0xcf01
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
jmp 0xcf08
leaq 0x26296(%rip), %r14     # 0x33195
jmp 0xcf13
leaq 0x334f0(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r14
movslq 0x144(%rbx), %rax
leaq 0x334d7(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0xcf3c
cmpl 0x140(%rbx), %eax
jge 0xcf3c
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
leaq 0x27384(%rip), %rdx     # 0x342cf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16778
testl %eax, %eax
je 0xcf7b
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0xcf84
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
jmp 0xcf8b
leaq 0x27404(%rip), %r15     # 0x34386
jmp 0xcf96
leaq 0x3346d(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r15
cmpb $0x0, (%r14)
je 0xcfe3
movb (%r15), %bpl
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13665
testb %bpl, %bpl
je 0xcff8
leaq 0x25cd3(%rip), %rsi     # 0x32c89
movq %rbx, %rdi
callq 0x13665
movq %rbx, %rdi
callq 0x1ac43
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13665
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ac43
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13665
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x280d2(%rip), %rsi     # 0x350dc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_apply
static void Fp_apply(js_State *J)
{
	int i, n;

	if (!js_iscallable(J, 0))
		js_typeerror(J, "not a function");

	js_copy(J, 0);
	js_copy(J, 1);

	if (js_isnull(J, 2) || js_isundefined(J, 2)) {
		n = 0;
	} else {
		n = js_getlength(J, 2);
		if (n < 0)
			n = 0;
		for (i = 0; i < n; ++i)
			js_getindex(J, 2, i);
	}

	js_call(J, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x14e17
testl %eax, %eax
je 0xd427
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
movl 0x144(%rbx), %ecx
leal 0x2(%rcx), %eax
leaq 0x33063(%rip), %rdx     # 0x403f8
cmpl $-0x2, %ecx
jl 0xd3af
cmpl 0x140(%rbx), %eax
jge 0xd3af
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x2, 0xf(%rdx)
je 0xd413
leaq 0x3303c(%rip), %rdx     # 0x403f8
cmpl $-0x2, %ecx
jl 0xd3d6
cmpl 0x140(%rbx), %eax
jge 0xd3d6
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x1, 0xf(%rdx)
je 0xd413
movq %rbx, %rdi
movl $0x2, %esi
callq 0x3fcc
xorl %r15d, %r15d
movl $0x0, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
jle 0xd413
movl %eax, %r14d
movq %rbx, %rdi
movl $0x2, %esi
movl %r15d, %edx
callq 0x169fb
incl %r15d
cmpl %r15d, %r14d
jne 0xd3fb
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16c25
leaq 0x26e59(%rip), %rsi     # 0x34287
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_call
static void Fp_call(js_State *J)
{
	int i, top = js_gettop(J);

	if (!js_iscallable(J, 0))
		js_typeerror(J, "not a function");

	for (i = 0; i < top; ++i)
		js_copy(J, i);

	js_call(J, top - 2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %ebp
subl 0x144(%rdi), %ebp
xorl %esi, %esi
callq 0x14e17
testl %eax, %eax
je 0xd481
testl %ebp, %ebp
jle 0xd470
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14073
incl %r14d
cmpl %r14d, %ebp
jne 0xd45d
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x16c25
leaq 0x26dff(%rip), %rsi     # 0x34287
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_bind
static void Fp_bind(js_State *J)
{
	int i, top = js_gettop(J);
	int n;

	if (!js_iscallable(J, 0))
		js_typeerror(J, "not a function");

	n = js_getlength(J, 0);
	if (n > top - 2)
		n -= top - 2;
	else
		n = 0;

	/* Reuse target function's prototype for HasInstance check. */
	js_getproperty(J, 0, "prototype");
	js_newcconstructor(J, callbound, constructbound, "[bind]", n);

	/* target function */
	js_copy(J, 0);
	js_defproperty(J, -2, "__TargetFunction__", JS_READONLY | JS_DONTENUM | JS_DONTCONF);

	/* bound this */
	js_copy(J, 1);
	js_defproperty(J, -2, "__BoundThis__", JS_READONLY | JS_DONTENUM | JS_DONTCONF);

	/* bound arguments */
	js_newarray(J);
	for (i = 2; i < top; ++i) {
		js_copy(J, i);
		js_setindex(J, -2, i - 2);
	}
	js_defproperty(J, -2, "__BoundArguments__", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r15d
subl 0x144(%rdi), %r15d
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x14e17
testl %eax, %eax
je 0xd5a7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
movl %eax, %ebp
leal -0x2(%r15), %eax
subl %eax, %ebp
cmovlel %r14d, %ebp
leaq 0x25ccb(%rip), %rdx     # 0x331a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4032
leaq 0x13fcd(%rip), %rsi     # 0x214b7
leaq 0x14099(%rip), %rdx     # 0x2158a
leaq 0x26e4e(%rip), %rcx     # 0x34346
movq %rbx, %rdi
movl %ebp, %r8d
callq 0x6211
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
leaq 0x26e39(%rip), %rdx     # 0x3434d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x7, %ecx
callq 0x66df
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
leaq 0x26e26(%rip), %rdx     # 0x34360
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x7, %ecx
callq 0x66df
movq %rbx, %rdi
callq 0x135de
cmpl $0x3, %r15d
jl 0xd584
movl $0x2, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14073
leal -0x2(%r14), %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1393c
incl %r14d
cmpl %r15d, %r14d
jne 0xd560
leaq 0x26de3(%rip), %rdx     # 0x3436e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x7, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x66df
leaq 0x26cd9(%rip), %rsi     # 0x34287
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsgc.c
// Function: jsG_freefunction
static void jsG_freefunction(js_State *J, js_Function *fun)
{
	js_free(J, fun->funtab);
	js_free(J, fun->vartab);
	js_free(J, fun->code);
	js_free(J, fun);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rsi
movq (%rdi), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq 0x40(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq 0x20(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq (%r14), %rdi
movq 0x10(%r14), %rax
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsgc.c
// Function: jsG_freeobject
static void jsG_freeobject(js_State *J, js_Object *obj)
{
	if (obj->properties->level)
		jsG_freeproperty(J, obj->properties);
	if (obj->type == JS_CREGEXP) {
		js_free(J, obj->u.r.source);
		js_regfreex(J->alloc, J->actx, obj->u.r.prog);
	}
	if (obj->type == JS_CSTRING) {
		if (obj->u.s.string != obj->u.s.shrstr)
			js_free(J, obj->u.s.string);
	}
	if (obj->type == JS_CARRAY && obj->u.a.simple)
		js_free(J, obj->u.a.array);
	if (obj->type == JS_CITERATOR)
		jsG_freeiterator(J, obj->u.iter.head);
	if (obj->type == JS_CUSERDATA && obj->u.user.finalize)
		obj->u.user.finalize(J, obj->u.user.data);
	if (obj->type == JS_CCFUNCTION && obj->u.c.finalize)
		obj->u.c.finalize(J, obj->u.c.data);
	js_free(J, obj);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpl $0x0, 0x10(%rsi)
je 0xdebc
movq %r14, %rdi
callq 0x2173f
cmpl $0x9, (%rbx)
jne 0xdf05
movq 0x28(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0xdf05
movq (%r14), %r12
movq 0x10(%r14), %r13
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0xdeef
movq %r12, %rdi
xorl %edx, %edx
callq *%r13
movq (%r15), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq *%r13
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *%r13
cmpl $0x8, (%rbx)
jne 0xdf20
movq 0x28(%rbx), %rsi
leaq 0x30(%rbx), %rax
cmpq %rax, %rsi
je 0xdf20
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
cmpl $0x1, (%rbx)
jne 0xdf38
cmpl $0x0, 0x24(%rbx)
je 0xdf38
movq 0x30(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
cmpl $0xe, (%rbx)
jne 0xdf5a
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0xdf5a
movq (%rsi), %r15
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq %r15, %rsi
testq %r15, %r15
jne 0xdf46
cmpl $0xf, (%rbx)
jne 0xdf71
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xdf71
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq *%rax
cmpl $0x4, (%rbx)
jne 0xdf88
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xdf88
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq *%rax
movq (%r14), %rdi
movq 0x10(%r14), %rax
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsgc.c
// Function: js_freestate
void js_freestate(js_State *J)
{
	js_Function *fun, *nextfun;
	js_Object *obj, *nextobj;
	js_Environment *env, *nextenv;
	js_String *str, *nextstr;

	if (!J)
		return;

	for (env = J->gcenv; env; env = nextenv)
		nextenv = env->gcnext, jsG_freeenvironment(J, env);
	for (fun = J->gcfun; fun; fun = nextfun)
		nextfun = fun->gcnext, jsG_freefunction(J, fun);
	for (obj = J->gcobj; obj; obj = nextobj)
		nextobj = obj->gcnext, jsG_freeobject(J, obj);
	for (str = J->gcstr; str; str = nextstr)
		nextstr = str->gcnext, js_free(J, str);

	jsS_freestrings(J);

	js_free(J, J->lexbuf.text);
	J->alloc(J->actx, J->stack, 0);
	J->alloc(J->actx, J, 0);
}

// Assembly:
testq %rdi, %rdi
je 0xe09b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x160(%rdi), %rsi
testq %rsi, %rsi
je 0xdfe9
movq 0x10(%rsi), %r14
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r14, %rsi
testq %r14, %r14
jne 0xdfd5
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0xe009
movq 0x60(%rsi), %r14
movq %rbx, %rdi
callq 0xde55
movq %r14, %rsi
testq %r14, %r14
jne 0xdff5
movq 0x170(%rbx), %rsi
testq %rsi, %rsi
je 0xe029
movq 0x50(%rsi), %r14
movq %rbx, %rdi
callq 0xde9b
movq %r14, %rsi
testq %r14, %r14
jne 0xe015
movq 0x178(%rbx), %rsi
testq %rsi, %rsi
je 0xe048
movq (%rsi), %r14
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r14, %rsi
testq %r14, %r14
jne 0xe035
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
sete %al
leaq 0x321c7(%rip), %rcx     # 0x40220
cmpq %rcx, %rsi
sete %cl
orb %al, %cl
jne 0xe06b
movq %rbx, %rdi
callq 0xe2f6
movq (%rbx), %rdi
movq 0x50(%rbx), %rsi
xorl %edx, %edx
callq *0x10(%rbx)
movq (%rbx), %rdi
movq 0x148(%rbx), %rsi
xorl %edx, %edx
callq *0x10(%rbx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsintern.c
// Function: js_putc
void js_putc(js_State *J, js_Buffer **sbp, int c)
{
	js_Buffer *sb = *sbp;
	if (!sb) {
		sb = js_malloc(J, sizeof *sb);
		sb->n = 0;
		sb->m = sizeof sb->s;
		*sbp = sb;
	} else if (sb->n == sb->m) {
		sb = js_realloc(J, sb, (sb->m *= 2) + soffsetof(js_Buffer, s));
		*sbp = sb;
	}
	sb->s[sb->n++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0xe0eb
movl 0x4(%rax), %ecx
cmpl %ecx, (%rax)
jne 0xe105
leal (%rcx,%rcx), %edx
movl %edx, 0x4(%rax)
leal 0x8(,%rcx,2), %edx
movq %rax, %rsi
callq 0xe170
jmp 0xe102
movl $0x48, %esi
callq 0xe119
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, (%rax)
movq %rax, (%r14)
movslq (%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movb %bl, 0x8(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_malloc
void *js_malloc(js_State *J, int size)
{
	void *ptr = J->alloc(J->actx, NULL, size);
	if (!ptr)
		js_outofmemory(J);
	return ptr;
}

// Assembly:
pushq %rbx
movl %esi, %edx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
callq *0x10(%rbx)
testq %rax, %rax
je 0xe12e
popq %rbx
retq
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1d032(%rip), %rdx     # 0x2b190
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq %rbx, %rdi
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_realloc
void *js_realloc(js_State *J, void *ptr, int size)
{
	ptr = J->alloc(J->actx, ptr, size);
	if (!ptr)
		js_outofmemory(J);
	return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x10(%rbx)
testq %rax, %rax
je 0xe181
popq %rbx
retq
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1cfdf(%rip), %rdx     # 0x2b190
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq %rbx, %rdi
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsintern.c
// Function: jsS_dumpstrings
void jsS_dumpstrings(js_State *J)
{
	js_StringNode *root = J->strings;
	printf("interned strings {\n");
	if (root && root != &jsS_sentinel)
		dumpstringnode(root, 1);
	printf("}\n");
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
leaq 0x27143(%rip), %rdi     # 0x35382
callq 0x30f0
testq %rbx, %rbx
sete %al
leaq 0x31fcf(%rip), %rcx     # 0x40220
cmpq %rcx, %rbx
sete %cl
orb %al, %cl
jne 0xe268
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe275
leaq 0x260b0(%rip), %rdi     # 0x3431f
popq %rbx
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsintern.c
// Function: dumpstringnode
static void dumpstringnode(js_StringNode *node, int level)
{
	int i;
	if (node->left != &jsS_sentinel)
		dumpstringnode(node->left, level + 1);
	printf("%d: ", node->level);
	for (i = 0; i < level; ++i)
		putchar('\t');
	printf("'%s'\n", node->string);
	if (node->right != &jsS_sentinel)
		dumpstringnode(node->right, level + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x31f94(%rip), %r13     # 0x40220
leaq 0x249f4(%rip), %r15     # 0x32c87
leaq 0x260e7(%rip), %r12     # 0x34381
movq (%r14), %rdi
cmpq %r13, %rdi
je 0xe2aa
leal 0x1(%rbx), %esi
callq 0xe275
movl 0x10(%r14), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3030
testl %ebx, %ebx
jle 0xe2cc
movl %ebx, %ebp
movl $0x9, %edi
callq 0x3150
decl %ebp
jne 0xe2be
leaq 0x14(%r14), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3030
movq 0x8(%r14), %r14
cmpq %r13, %r14
je 0xe2e7
incl %ebx
jmp 0xe29a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsintern.c
// Function: js_intern
const char *js_intern(js_State *J, const char *s)
{
	const char *result;
	if (!J->strings)
		J->strings = &jsS_sentinel;
	J->strings = jsS_insert(J, J->strings, s, &result);
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0xe358
leaq 0x31ecc(%rip), %rax     # 0x40220
movq %rax, 0x28(%rbx)
movq 0x28(%rbx), %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xe379
movq %rax, 0x28(%rbx)
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsintern.c
// Function: jsS_insert
static js_StringNode *jsS_insert(js_State *J, js_StringNode *node, const char *string, const char **result)
{
	if (node != &jsS_sentinel) {
		int c = strcmp(string, node->string);
		if (c < 0)
			node->left = jsS_insert(J, node->left, string, result);
		else if (c > 0)
			node->right = jsS_insert(J, node->right, string, result);
		else
			return *result = node->string, node;
		node = jsS_skew(node);
		node = jsS_split(node);
		return node;
	}
	return jsS_newstringnode(J, string, result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x31e8c(%rip), %rbp     # 0x40220
cmpq %rbp, %rsi
je 0xe3ea
movq %rsi, %rbx
leaq 0x14(%rsi), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
movq %rbx, %rbp
testl %eax, %eax
js 0xe3bc
je 0xe45d
leaq 0x8(%rbx), %rbp
movq (%rbp), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xe379
movq %rax, (%rbp)
movq (%rbx), %rax
movl 0x10(%rax), %ecx
cmpl 0x10(%rbx), %ecx
jne 0xe436
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, 0x8(%rax)
jmp 0xe439
movq %r15, %rdi
callq 0x3200
cmpq $0x10000001, %rax       # imm = 0x10000001
jae 0xe472
movq %rax, %r13
leal 0x15(%rax), %esi
movq %r12, %rdi
callq 0xe119
movq %rax, %rbx
movq %rbp, 0x8(%rax)
movq %rbp, (%rax)
movl $0x1, 0x10(%rax)
movq %rax, %r12
addq $0x14, %r12
incq %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x33d0
movq %r12, (%r14)
jmp 0xe460
movq %rbx, %rax
movq 0x8(%rax), %rbx
movq 0x8(%rbx), %rcx
movl 0x10(%rcx), %ecx
cmpl 0x10(%rax), %ecx
jne 0xe458
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
incl 0x10(%rbx)
jmp 0xe460
movq %rax, %rbx
jmp 0xe460
movq %r13, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x252c9(%rip), %rsi     # 0x33742
movq %r12, %rdi
xorl %eax, %eax
callq 0xcab5
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jslex.c
// Function: jsY_findword
int jsY_findword(const char *s, const char **list, int num)
{
	int l = 0;
	int r = num - 1;
	while (l <= r) {
		int m = (l + r) >> 1;
		int c = strcmp(s, list[m]);
		if (c < 0)
			r = m - 1;
		else if (c > 0)
			l = m + 1;
		else
			return m;
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
decl %r15d
xorl %r12d, %r12d
cmpl %r15d, %r12d
jg 0xe507
leal (%r12,%r15), %r13d
shrl %r13d
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
jns 0xe4f0
decl %r13d
movb $0x1, %al
movl %r13d, %r15d
jmp 0xe501
je 0xe4fc
incl %r13d
movb $0x1, %al
movl %r13d, %r12d
jmp 0xe501
xorl %eax, %eax
movl %r13d, %ebp
testb %al, %al
jne 0xe4ca
jmp 0xe50c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jslex.c
// Function: jsY_tohex
int jsY_tohex(int c)
{
	if (c >= '0' && c <= '9') return c - '0';
	if (c >= 'a' && c <= 'f') return c - 'a' + 0xA;
	if (c >= 'A' && c <= 'F') return c - 'A' + 0xA;
	return 0;
}

// Assembly:
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0xe5b0
leal -0x61(%rdi), %eax
cmpl $0x5, %eax
ja 0xe5a2
addl $-0x57, %edi
movl %edi, %eax
retq
leal -0x41(%rdi), %ecx
addl $-0x37, %edi
xorl %eax, %eax
cmpl $0x6, %ecx
cmovbl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jslex.c
// Function: jsY_next
static void jsY_next(js_State *J)
{
	Rune c;
	if (*J->source == 0) {
		J->lexchar = EOF;
		return;
	}
	J->source += chartorune(&c, J->source);
	/* consume CR LF as one unit */
	if (c == '\r' && *J->source == '\n')
		++J->source;
	if (jsY_isnewline(c)) {
		J->line++;
		c = '\n';
	}
	J->lexchar = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
cmpb $0x0, (%r14)
je 0xe63c
leaq 0xc(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18750
movl %eax, %ecx
addq %r14, %rcx
movq %rcx, 0x40(%rbx)
movl (%r15), %eax
leal -0x2028(%rax), %edx
cmpl $0x2, %edx
jb 0xe62b
cmpl $0xa, %eax
je 0xe62b
cmpl $0xd, %eax
jne 0xe636
cmpb $0xa, (%rcx)
jne 0xe61c
incq %rcx
movq %rcx, 0x40(%rbx)
cmpl $0x2, %edx
jb 0xe62b
cmpl $0xd, %eax
je 0xe62b
cmpl $0xa, %eax
jne 0xe636
incl 0x48(%rbx)
movl $0xa, 0xc(%rsp)
movl 0xc(%rsp), %eax
jmp 0xe641
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x64(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jslex.c
// Function: jsY_error
static void jsY_error(js_State *J, const char *fmt, ...)
{
	va_list ap;
	char buf[512];
	char msgbuf[256];

	va_start(ap, fmt);
	vsnprintf(msgbuf, 256, fmt, ap);
	va_end(ap);

	snprintf(buf, 256, "%s:%d: ", J->filename, J->lexline);
	strcat(buf, msgbuf);

	js_newsyntaxerror(J, buf);
	js_throw(J);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3d0, %rsp            # imm = 0x3D0
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xf93f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x3f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
leaq 0xd0(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r10, %rdx
callq 0x32b0
movq 0x38(%rbx), %rcx
movl 0x60(%rbx), %r8d
leaq 0x232fe(%rip), %rdx     # 0x32c84
leaq 0x1d0(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
movq %r15, %rdi
movq %r14, %rsi
callq 0x3270
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8eba
movq %rbx, %rdi
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsmath.c
// Function: Math_max
static void Math_max(js_State *J)
{
	int i, n = js_gettop(J);
	double x = -INFINITY;
	for (i = 1; i < n; ++i) {
		double y = js_tonumber(J, i);
		if (isnan(y)) {
			x = y;
			break;
		}
		if (signbit(x) == signbit(y))
			x = x > y ? x : y;
		else if (signbit(x))
			x = y;
	}
	js_pushnumber(J, x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %eax
movl 0x144(%rdi), %r15d
movl %eax, %ecx
subl %r15d, %ecx
cmpl $0x2, %ecx
jl 0xfd2d
subl %eax, %r15d
addl $0x2, %r15d
movsd 0x1b798(%rip), %xmm1    # 0x2b470
movl $0x1, %r14d
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x15111
ucomisd %xmm0, %xmm0
jp 0xfd15
movq 0x8(%rsp), %xmm1
movq %xmm1, %rax
movq %xmm0, %rcx
xorq %rax, %rcx
js 0xfd10
maxsd %xmm0, %xmm1
jmp 0xfd19
testq %rax, %rax
jns 0xfd19
movapd %xmm0, %xmm1
ucomisd %xmm0, %xmm0
jp 0xfd35
leal (%r15,%r14), %eax
incl %r14d
cmpl $0x1, %eax
jne 0xfcde
jmp 0xfd35
movsd 0x1b73b(%rip), %xmm1    # 0x2b470
movq %rbx, %rdi
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsmath.c
// Function: Math_pow
static void Math_pow(js_State *J)
{
	double x = js_tonumber(J, 1);
	double y = js_tonumber(J, 2);
	if (!isfinite(y) && fabs(x) == 1)
		js_pushnumber(J, NAN);
	else
		js_pushnumber(J, pow(x,y));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x144(%rdi), %eax
leaq 0x305f3(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $-0x1, %eax
jl 0xfe27
incl %eax
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0xfe27
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movl 0x144(%rbx), %eax
cmpl $-0x2, %eax
movdqa %xmm0, (%rsp)
jl 0xfe58
addl $0x2, %eax
cmpl 0x140(%rbx), %eax
jge 0xfe58
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1514c
movdqa %xmm0, %xmm1
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
movapd (%rsp), %xmm0
jl 0xfea7
movapd 0x1b583(%rip), %xmm2    # 0x2b410
andpd %xmm0, %xmm2
ucomisd 0x1b61f(%rip), %xmm2    # 0x2b4b8
jne 0xfea7
jp 0xfea7
movsd 0x1b5ab(%rip), %xmm0    # 0x2b450
jmp 0xfeac
callq 0x33b0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsnumber.c
// Function: Np_toFixed
static void Np_toFixed(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	int width = js_tointeger(J, 1);
	char buf[32];
	double x;
	if (self->type != JS_CNUMBER) js_typeerror(J, "not a number");
	if (width < 0) js_rangeerror(J, "precision %d out of range", width);
	if (width > 20) js_rangeerror(J, "precision %d out of range", width);
	x = self->u.number;
	if (isnan(x) || isinf(x) || x <= -1e21 || x >= 1e21)
		js_pushstring(J, jsV_numbertostring(J, buf, x));
	else
		numtostr(J, "%.*f", width, x);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x2fe7b(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0x10598
cmpl 0x140(%rbx), %eax
jge 0x10598
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
cmpl $0x7, (%r14)
jne 0x1064b
testl %eax, %eax
js 0x10638
cmpl $0x15, %eax
jge 0x10638
movsd 0x20(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x1061d
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
sete %cl
ucomisd 0x1af67(%rip), %xmm0    # 0x2b558
jae 0x1061d
movsd 0x1af65(%rip), %xmm1    # 0x2b560
ucomisd %xmm0, %xmm1
jae 0x1061d
testb %cl, %cl
jne 0x1061d
leaq 0x2440b(%rip), %rsi     # 0x34a17
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x21c55
movq %rsp, %rsi
callq 0x1303a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13665
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x243be(%rip), %rsi     # 0x349fd
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xcab5
leaq 0x24390(%rip), %rsi     # 0x349e2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsnumber.c
// Function: Np_toExponential
static void Np_toExponential(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	int width = js_tointeger(J, 1);
	char buf[32];
	double x;
	if (self->type != JS_CNUMBER) js_typeerror(J, "not a number");
	if (width < 0) js_rangeerror(J, "precision %d out of range", width);
	if (width > 20) js_rangeerror(J, "precision %d out of range", width);
	x = self->u.number;
	if (isnan(x) || isinf(x))
		js_pushstring(J, jsV_numbertostring(J, buf, x));
	else
		numtostr(J, "%.*e", width, x);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x2fd84(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0x1068f
cmpl 0x140(%rbx), %eax
jge 0x1068f
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
cmpl $0x7, (%r14)
jne 0x1071b
testl %eax, %eax
js 0x10708
cmpl $0x15, %eax
jge 0x10708
movq 0x20(%r14), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jl 0x106f0
movq %rsp, %rsi
callq 0x1303a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13665
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2432a(%rip), %rsi     # 0x34a21
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x21c55
leaq 0x242ee(%rip), %rsi     # 0x349fd
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xcab5
leaq 0x242c0(%rip), %rsi     # 0x349e2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsnumber.c
// Function: Np_toPrecision
static void Np_toPrecision(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	int width = js_tointeger(J, 1);
	char buf[32];
	double x;
	if (self->type != JS_CNUMBER) js_typeerror(J, "not a number");
	if (width < 1) js_rangeerror(J, "precision %d out of range", width);
	if (width > 21) js_rangeerror(J, "precision %d out of range", width);
	x = self->u.number;
	if (isnan(x) || isinf(x))
		js_pushstring(J, jsV_numbertostring(J, buf, x));
	else
		numtostr(J, "%.*g", width, x);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x2fcb4(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0x1075f
cmpl 0x140(%rbx), %eax
jge 0x1075f
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
cmpl $0x7, (%r14)
jne 0x107eb
testl %eax, %eax
jle 0x107d8
cmpl $0x16, %eax
jge 0x107d8
movq 0x20(%r14), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jl 0x107c0
movq %rsp, %rsi
callq 0x1303a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13665
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2425f(%rip), %rsi     # 0x34a26
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x21c55
leaq 0x2421e(%rip), %rsi     # 0x349fd
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xcab5
leaq 0x241f0(%rip), %rsi     # 0x349e2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsobject.c
// Function: Op_hasOwnProperty
static void Op_hasOwnProperty(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	const char *name = js_tostring(J, 1);
	js_Property *ref;
	int k;

	if (self->type == JS_CSTRING) {
		if (js_isarrayindex(J, name, &k) && k >= 0 && k < self->u.s.length) {
			js_pushboolean(J, 1);
			return;
		}
	}

	if (self->type == JS_CARRAY && self->u.a.simple) {
		if (js_isarrayindex(J, name, &k) && k >= 0 && k < self->u.a.flat_length) {
			js_pushboolean(J, 1);
			return;
		}
	}

	ref = jsV_getownproperty(J, self, name);
	js_pushboolean(J, ref != NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x2f992(%rip), %r14     # 0x403f8
movq %r14, %rsi
testq %rax, %rax
js 0x10a87
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0x10a87
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r15
movl 0x144(%rbx), %eax
cmpl $-0x1, %eax
jl 0x10ab5
incl %eax
cmpl 0x140(%rbx), %eax
jge 0x10ab5
movl %eax, %r14d
shlq $0x4, %r14
addq 0x148(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1533b
movq %rax, %r14
movl (%r15), %ebp
cmpl $0x1, %ebp
je 0x10b05
cmpl $0x8, %ebp
jne 0x10b3c
leaq 0x4(%rsp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x15b35
testl %eax, %eax
setne %cl
movl (%r12), %eax
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x10b00
movl $0x1, %esi
cmpl 0x20(%r15), %eax
jl 0x10b7e
cmpl $0x1, %ebp
jne 0x10b3c
cmpl $0x0, 0x24(%r15)
je 0x10b3c
leaq 0x4(%rsp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x15b35
testl %eax, %eax
setne %cl
movl (%r12), %eax
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x10b3c
movl $0x1, %esi
cmpl 0x28(%r15), %eax
jl 0x10b7e
movq 0x8(%r15), %r15
leaq 0x2f871(%rip), %r13     # 0x403b8
cmpq %r13, %r15
je 0x10b72
leaq 0x38(%r15), %rsi
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
je 0x10b69
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
movq (%r15,%rcx,8), %r15
jmp 0x10b6c
movq %r15, %r12
testl %eax, %eax
jne 0x10b47
jmp 0x10b75
xorl %r12d, %r12d
xorl %esi, %esi
testq %r12, %r12
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14ad9
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsobject.c
// Function: Op_isPrototypeOf
static void Op_isPrototypeOf(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	if (js_isobject(J, 1)) {
		js_Object *V = js_toobject(J, 1);
		do {
			V = V->prototype;
			if (V == self) {
				js_pushboolean(J, 1);
				return;
			}
		} while (V);
	}
	js_pushboolean(J, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x2f84e(%rip), %r15     # 0x403f8
movq %r15, %rsi
testq %rax, %rax
js 0x10bcb
movq %r15, %rsi
cmpl 0x140(%rbx), %eax
jge 0x10bcb
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movl 0x144(%rbx), %ecx
leal 0x1(%rcx), %eax
cmpl $-0x1, %ecx
jl 0x10bfa
cmpl 0x140(%rbx), %eax
jge 0x10bfa
movl %eax, %r15d
shlq $0x4, %r15
addq 0x148(%rbx), %r15
cmpb $0x7, 0xf(%r15)
jne 0x10c4f
leaq 0x2f7f0(%rip), %rsi     # 0x403f8
cmpl $-0x1, %ecx
jl 0x10c22
cmpl 0x140(%rbx), %eax
jge 0x10c22
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x15489
movq %rax, %r15
movq 0x18(%r15), %r15
cmpq %r14, %r15
je 0x10c3d
testq %r15, %r15
jne 0x10c2d
jmp 0x10c4a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14ad9
cmpq %r14, %r15
je 0x10c5e
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x14ad9
popq %rbx
popq %r14
popq %r15
retq