LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: Dp_setHours
static void Dp_setHours(js_State *J)
{
	double t = LocalTime(js_todate(J, 0));
	double h = js_tonumber(J, 1);
	double m = js_optnumber(J, 2, MinFromTime(t));
	double s = js_optnumber(J, 3, SecFromTime(t));
	double ms = js_optnumber(J, 4, msFromTime(t));
	js_setdate(J, 0, UTC(MakeDate(Day(t), MakeTime(h, m, s, ms))));
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x17f9f
callq 0x18049
movsd %xmm0, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x28(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x84ba
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x84c9
movsd 0x8(%rsp), %xmm0
callq 0x18560
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x84eb
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x84fa
movsd 0x8(%rsp), %xmm0
callq 0x18581
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x851c
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x852b
movsd 0x8(%rsp), %xmm0
callq 0x185a2
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x17f49(%rip), %xmm0    # 0x20488
callq 0x3370
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movsd 0x17f3c(%rip), %xmm1    # 0x20490
movsd 0x28(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x20(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x18(%rsp), %xmm2
mulsd 0x17f22(%rip), %xmm2    # 0x20498
addsd 0x10(%rsp), %xmm2
mulsd 0x17f04(%rip), %xmm0    # 0x20488
addsd %xmm2, %xmm0
callq 0x186cd
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: Dp_setUTCHours
static void Dp_setUTCHours(js_State *J)
{
	double t = js_todate(J, 0);
	double h = js_tonumber(J, 1);
	double m = js_optnumber(J, 2, HourFromTime(t));
	double s = js_optnumber(J, 3, SecFromTime(t));
	double ms = js_optnumber(J, 4, msFromTime(t));
	js_setdate(J, 0, MakeDate(Day(t), MakeTime(h, m, s, ms)));
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x17f9f
movsd %xmm0, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x28(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x85da
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x85e9
movsd 0x8(%rsp), %xmm0
callq 0x1853f
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x860b
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x861a
movsd 0x8(%rsp), %xmm0
callq 0x18581
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x863c
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x864b
movsd 0x8(%rsp), %xmm0
callq 0x185a2
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x17e29(%rip), %xmm0    # 0x20488
callq 0x3370
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movsd 0x17e1c(%rip), %xmm1    # 0x20490
movsd 0x28(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x20(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x18(%rsp), %xmm2
mulsd 0x17e02(%rip), %xmm2    # 0x20498
addsd 0x10(%rsp), %xmm2
mulsd 0x17de4(%rip), %xmm0    # 0x20488
addsd %xmm2, %xmm0
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: Dp_setDate
static void Dp_setDate(js_State *J)
{
	double t = LocalTime(js_todate(J, 0));
	double y = YearFromTime(t);
	double m = MonthFromTime(t);
	double d = js_tonumber(J, 1);
	js_setdate(J, 0, UTC(MakeDate(MakeDay(y, m, d), TimeWithinDay(t))));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
callq 0x18049
movsd %xmm0, 0x10(%rsp)
callq 0x18252
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x182bb
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x17d58(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
callq 0x186cd
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
movsd %xmm0, 0x10(%rsp)
callq 0x18252
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x182bb
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x17ccc(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
callq 0x18049
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8812
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x8821
movsd 0x10(%rsp), %xmm0
callq 0x18372
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x18252
cvtsi2sd %eax, %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x17c22(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
callq 0x186cd
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x88bc
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x88cb
movsd 0x10(%rsp), %xmm0
callq 0x18372
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x18252
cvtsi2sd %eax, %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x17b78(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
callq 0x18049
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8966
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x8975
movsd 0x10(%rsp), %xmm0
callq 0x182bb
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x899b
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movapd %xmm0, %xmm2
jmp 0x89aa
movsd 0x10(%rsp), %xmm0
callq 0x18372
cvtsi2sd %eax, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x17aae(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
callq 0x186cd
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x17f9f
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8a30
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x8a3f
movsd 0x10(%rsp), %xmm0
callq 0x182bb
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8a65
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movapd %xmm0, %xmm2
jmp 0x8a74
movsd 0x10(%rsp), %xmm0
callq 0x18372
cvtsi2sd %eax, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x186f2
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x187a6
movsd 0x8(%rsp), %xmm1
mulsd 0x179e4(%rip), %xmm1    # 0x20488
addsd %xmm1, %xmm0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x1861a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0x17f9f
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x8af7
movq %rsp, %rdi
xorps %xmm1, %xmm1
callq 0x17fc7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7f7
addq $0x40, %rsp
popq %rbx
retq
leaq 0x20768(%rip), %rsi     # 0x29266
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9778
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xeee2
pushq $-0x1
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfe13
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf8f4
testl %eax, %eax
je 0x8b65
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x8b65
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe756
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
leaq 0x1f584(%rip), %rdx     # 0x280fb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3eff
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf950
testl %eax, %eax
je 0x8baa
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeee2
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x110b0
leaq 0x206c2(%rip), %rsi     # 0x29273
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: D_UTC
static void D_UTC(js_State *J)
{
	double y, m, d, H, M, S, ms, t;
	y = js_tonumber(J, 1);
	if (y < 100) y += 1900;
	m = js_tonumber(J, 2);
	d = js_optnumber(J, 3, 1);
	H = js_optnumber(J, 4, 0);
	M = js_optnumber(J, 5, 0);
	S = js_optnumber(J, 6, 0);
	ms = js_optnumber(J, 7, 0);
	t = MakeDate(MakeDay(y, m, d), MakeTime(H, M, S, ms));
	t = TimeClip(t);
	js_pushnumber(J, t);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xfb28
movaps %xmm0, 0x30(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x28(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8e76
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xfb28
jmp 0x8e7e
movsd 0x17592(%rip), %xmm0    # 0x20410
movsd %xmm0, (%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
testl %eax, %eax
je 0x8ea6
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x20(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8ecc
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x10(%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testl %eax, %eax
je 0x8eef
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x18(%rsp)
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x8f15
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x8(%rsp)
movsd 0x17583(%rip), %xmm1    # 0x204a0
movapd 0x30(%rsp), %xmm2
movapd %xmm2, %xmm0
cmpltsd 0x17578(%rip), %xmm0    # 0x204a8
addsd %xmm2, %xmm1
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x186f2
movsd 0x17538(%rip), %xmm1    # 0x20490
movsd 0x20(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x10(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd 0x18(%rsp), %xmm2
mulsd 0x1751e(%rip), %xmm2    # 0x20498
addsd 0x8(%rsp), %xmm2
mulsd 0x17500(%rip), %xmm0    # 0x20488
addsd %xmm2, %xmm0
callq 0x18665
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x3f9a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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:
movl %esi, %ecx
shrl $0x1f, %ecx
addb %cl, %cl
addb $0x2b, %cl
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movb $0x65, (%rdi)
movb %cl, 0x1(%rdi)
xorl %ecx, %ecx
movl $0xa, %esi
testl %eax, %eax
je 0x8fe2
xorl %edx, %edx
divl %esi
orb $0x30, %dl
movb %dl, -0x9(%rsp,%rcx)
incq %rcx
jmp 0x8fce
movb -0x9(%rsp), %al
movl $0x1, %edx
movl %ecx, %esi
movl %eax, %r8d
movb $0x30, %al
movl %edx, %ecx
testl %esi, %esi
je 0x8feb
movb %r8b, -0x9(%rsp)
addq $0x2, %rdi
movl %esi, %eax
testq %rax, %rax
jle 0x9016
movb -0xa(%rsp,%rax), %cl
decq %rax
movb %cl, (%rdi)
incq %rdi
jmp 0x9003
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x5d6b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4274
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe7f7
leaq 0x1fd18(%rip), %rdx     # 0x292da
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3fdd
movq %rbx, %rdi
xorl %esi, %esi
callq 0x18b54
testl %eax, %eax
je 0x95f4
leaq 0x1fd00(%rip), %rdx     # 0x292e2
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fdd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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
pushq $-0x1
popq %rsi
callq 0xd489
testl %eax, %eax
je 0x9bf5
leaq 0x1e603(%rip), %rdx     # 0x2813a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c15
testl %eax, %eax
je 0x9b55
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r14
jmp 0x9b5c
leaq 0x1e639(%rip), %r14     # 0x28195
leaq 0x1f777(%rip), %rdx     # 0x292da
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c15
testl %eax, %eax
je 0x9b81
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r15
jmp 0x9b88
leaq 0x1f809(%rip), %r15     # 0x29391
cmpb $0x0, (%r14)
je 0x9bd5
movb (%r15), %bpl
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe7f7
testb %bpl, %bpl
je 0x9bea
leaq 0x1e0e1(%rip), %rsi     # 0x27c89
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0x13be7
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe7f7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13be7
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe7f7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x204eb(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsfunction.c
// Function: Fp_toString
static void Fp_toString(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	js_Buffer *sb = NULL;
	int i;

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

	if (self->type == JS_CFUNCTION || self->type == JS_CSCRIPT) {
		js_Function *F = self->u.f.function;

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

		js_puts(J, &sb, "function ");
		js_puts(J, &sb, F->name);
		js_putc(J, &sb, '(');
		for (i = 0; i < F->numparams; ++i) {
			if (i > 0) js_putc(J, &sb, ',');
			js_puts(J, &sb, F->vartab[i]);
		}
		js_puts(J, &sb, ") { [byte code] }");
		js_putc(J, &sb, 0);

		js_pushstring(J, sb->s);
		js_endtry(J);
		js_free(J, sb);
	} else if (self->type == JS_CCFUNCTION) {
		if (js_try(J)) {
			js_free(J, sb);
			js_throw(J);
		}

		js_puts(J, &sb, "function ");
		js_puts(J, &sb, self->u.c.name);
		js_puts(J, &sb, "() { [native code] }");
		js_putc(J, &sb, 0);

		js_pushstring(J, sb->s);
		js_endtry(J);
		js_free(J, sb);
	} else {
		js_pushliteral(J, "function () { }");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, %esi
callq 0xd49c
movq %rax, %r14
andq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf950
testl %eax, %eax
je 0x9de6
movq %r14, %r15
movl (%r14), %eax
movl %eax, %ecx
addl $-0x2, %ecx
cmpl $0x2, %ecx
jae 0x9d30
movq 0x20(%r15), %r15
movq %rbx, %rdi
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x9df7
leaq 0x1f647(%rip), %rdx     # 0x29310
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
pushq $0x28
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa986
xorl %eax, %eax
movl %eax, %r12d
pushq $0x2c
popq %rbp
movslq 0x18(%r15), %rax
cmpq %rax, %r12
jge 0x9d80
testq %r12, %r12
je 0x9d18
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa986
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
incq %r12
jmp 0x9cfd
cmpl $0x4, %eax
jne 0x9dca
movq %rbx, %rdi
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x9df7
leaq 0x1f5b8(%rip), %rdx     # 0x29310
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
leaq 0x1f5ae(%rip), %rdx     # 0x2932c
jmp 0x9d8c
leaq 0x1f593(%rip), %rdx     # 0x2931a
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa1e
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa986
movq (%r14), %r14
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq (%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *0x10(%rbx)
jmp 0x9dd9
leaq 0x1f570(%rip), %rsi     # 0x29341
movq %rbx, %rdi
callq 0x5a13
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f49a(%rip), %rsi     # 0x29287
xorl %eax, %eax
movq %rbx, %rdi
callq 0x99a6
movq (%rbx), %rdi
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./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 %ebp, %ebp
xorl %esi, %esi
callq 0xf950
testl %eax, %eax
je 0x9e99
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeee2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xeee2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8ce
testl %eax, %eax
jne 0x9e53
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8bb
testl %eax, %eax
je 0x9e67
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x110b0
pushq $0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3ecc
movl %eax, %ebp
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %ebp
cmpl %r15d, %ebp
je 0x9e53
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x10e96
incl %r15d
jmp 0x9e81
leaq 0x1f3e7(%rip), %rsi     # 0x29287
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %ebp
subl 0x144(%rdi), %ebp
xorl %r14d, %r14d
xorl %esi, %esi
callq 0xf950
testl %eax, %eax
je 0x9f06
testl %ebp, %ebp
movl $0x0, %r15d
cmovgl %ebp, %r15d
cmpl %r14d, %r15d
je 0x9eef
movq %rbx, %rdi
movl %r14d, %esi
callq 0xeee2
incl %r14d
jmp 0x9eda
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x110b0
leaq 0x1f37a(%rip), %rsi     # 0x29287
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xf950
testl %eax, %eax
je 0xa01a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3ecc
movl %eax, %ebp
leal -0x2(%r15), %eax
subl %eax, %ebp
cmovlel %r14d, %ebp
leaq 0x1e246(%rip), %rdx     # 0x281a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3eff
leaq 0xed4f(%rip), %rsi      # 0x18cbe
leaq 0xee08(%rip), %rdx      # 0x18d7e
leaq 0x1f3d4(%rip), %rcx     # 0x29351
movq %rbx, %rdi
movl %ebp, %r8d
callq 0x565e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeee2
leaq 0x1f3bf(%rip), %rdx     # 0x29358
pushq $-0x2
popq %rbp
pushq $0x7
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %ecx
callq 0x5963
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xeee2
leaq 0x1f3ac(%rip), %rdx     # 0x2936b
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %ecx
callq 0x5963
movq %rbx, %rdi
callq 0xe7d1
pushq $0x2
popq %r14
cmpl %r15d, %r14d
jge 0x9ffb
movq %rbx, %rdi
movl %r14d, %esi
callq 0xeee2
leal -0x2(%r14), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe9c5
incl %r14d
jmp 0x9fd8
leaq 0x1f377(%rip), %rdx     # 0x29379
pushq $-0x2
popq %rsi
pushq $0x7
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5963
leaq 0x1f266(%rip), %rsi     # 0x29287
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsfunction.c
// Function: jsB_Function
static void jsB_Function(js_State *J)
{
	int i, top = js_gettop(J);
	js_Buffer *sb = NULL;
	const char *body;
	js_Ast *parse;
	js_Function *fun;

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

	/* p1, p2, ..., pn */
	if (top > 2) {
		for (i = 1; i < top - 1; ++i) {
			if (i > 1)
				js_putc(J, &sb, ',');
			js_puts(J, &sb, js_tostring(J, i));
		}
		js_putc(J, &sb, ')');
		js_putc(J, &sb, 0);
	}

	/* body */
	body = js_isdefined(J, top - 1) ? js_tostring(J, top - 1) : "";

	parse = jsP_parsefunction(J, "[string]", sb ? sb->s : NULL, body);
	fun = jsC_compilefunction(J, parse);

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

	js_newfunction(J, fun, J->GE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %ebp
movl 0x144(%rdi), %r14d
andq $0x0, 0x8(%rsp)
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0xa160
movl %ebp, %eax
subl %r14d, %eax
movl %eax, %ecx
leal -0x1(%rcx), %ebp
cmpl $0x3, %eax
jl 0xa0d5
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r14
pushq $0x2c
popq %r15
cmpl %ebp, %r12d
jge 0xa0b5
cmpl $0x2, %r12d
jb 0xa097
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0xa986
movq %rbx, %rdi
movl %r12d, %esi
callq 0xf64d
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xaa1e
incl %r12d
jmp 0xa07e
leaq 0x8(%rsp), %r14
pushq $0x29
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa986
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa986
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf8a8
testl %eax, %eax
je 0xa0f2
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf64d
movq %rax, %rcx
jmp 0xa0f9
leaq 0x1f298(%rip), %rcx     # 0x29391
movq 0x8(%rsp), %r14
leaq 0x8(%r14), %rdx
testq %r14, %r14
cmoveq %r14, %rdx
leaq 0x16020(%rip), %rsi     # 0x20130
movq %rbx, %rdi
callq 0xda9a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x77cc
movq %rax, %r15
movq %rbx, %rdi
callq 0xf5a7
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0xd795
movq 0x138(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1388f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0xd795
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsgc.c
// Function: jsG_markenvironment
static void jsG_markenvironment(js_State *J, int mark, js_Environment *env)
{
	do {
		env->gcmark = mark;
		if (env->variables->gcmark != mark)
			jsG_markobject(J, mark, env->variables);
		env = env->outer;
	} while (env && env->gcmark != mark);
}

// Assembly:
movl %esi, 0x18(%rdx)
movq 0x8(%rdx), %rax
cmpl %esi, 0x60(%rax)
je 0xa75e
movl %esi, 0x60(%rax)
movq 0x180(%rdi), %rcx
movq %rcx, 0x58(%rax)
movq %rax, 0x180(%rdi)
movq (%rdx), %rdx
testq %rdx, %rdx
je 0xa76b
cmpl %esi, 0x18(%rdx)
jne 0xa73d
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpl $0x0, 0x10(%rsi)
je 0xa7cf
movq %r14, %rdi
callq 0x18f1e
movl (%rbx), %eax
cmpl $0x9, %eax
jne 0xa7f5
movq 0x28(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq (%r14), %rsi
movq 0x10(%r14), %rdi
movq 0x20(%rbx), %rdx
callq 0x14c76
movl (%rbx), %eax
cmpl $0x8, %eax
jne 0xa812
movq 0x28(%rbx), %rsi
leaq 0x30(%rbx), %rax
cmpq %rax, %rsi
je 0xa87d
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0xa82c
cmpl $0x0, 0x24(%rbx)
je 0xa87d
movq 0x30(%rbx), %rsi
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movl (%rbx), %eax
cmpl $0xe, %eax
jne 0xa84d
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0xa84b
movq (%rsi), %r15
movq (%r14), %rdi
xorl %edx, %edx
callq *0x10(%r14)
movq %r15, %rsi
jmp 0xa835
movl (%rbx), %eax
cmpl $0xf, %eax
jne 0xa866
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xa87d
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq *%rax
movl (%rbx), %eax
cmpl $0x4, %eax
jne 0xa87d
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xa87d
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 %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xa965
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x160(%rdi), %rsi
testq %rsi, %rsi
je 0xa8d7
movq 0x10(%rsi), %r14
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r14, %rsi
jmp 0xa8c1
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0xa8f4
movq 0x60(%rsi), %r14
movq %rbx, %rdi
callq 0xa76c
movq %r14, %rsi
jmp 0xa8de
movq 0x170(%rbx), %rsi
testq %rsi, %rsi
je 0xa911
movq 0x50(%rsi), %r14
movq %rbx, %rdi
callq 0xa7b2
movq %r14, %rsi
jmp 0xa8fb
movq 0x178(%rbx), %rsi
testq %rsi, %rsi
je 0xa92d
movq (%rsi), %r14
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r14, %rsi
jmp 0xa918
movq %rbx, %rdi
callq 0xa966
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_O2/ArtifexSoftware[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 0xa9ba
movl (%rax), %ecx
cmpl 0x4(%rax), %ecx
jne 0xa9d4
leal (%rcx,%rcx), %edx
movl %edx, 0x4(%rax)
leal 0x8(,%rcx,2), %edx
movq %rax, %rsi
callq 0xaa05
movq %rax, (%r14)
movl (%rax), %ecx
jmp 0xa9d4
pushq $0x48
popq %rsi
callq 0xa9e8
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, (%rax)
movq %rax, (%r14)
xorl %ecx, %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movslq %ecx, %rcx
movb %bl, 0x8(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xa9fd
popq %rbx
retq
movq %rbx, %rdi
callq 0xf6a9
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xaa16
popq %rbx
retq
movq %rbx, %rdi
callq 0xf6a9
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0x1f8ff(%rip), %rdi     # 0x2a38d
callq 0x30f0
testq %rbx, %rbx
sete %al
leaq 0x2c780(%rip), %rcx     # 0x37220
cmpq %rcx, %rbx
sete %cl
orb %al, %cl
jne 0xaab5
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xaac2
leaq 0x1e86e(%rip), %rdi     # 0x2932a
popq %rbx
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0x2c747(%rip), %r13     # 0x37220
leaq 0x1e8ac(%rip), %r12     # 0x2938c
pushq $0x9
popq %rbp
testl %ebx, %ebx
movl $0x0, %r15d
cmovgl %ebx, %r15d
movq (%r14), %rdi
cmpq %r13, %rdi
je 0xaaff
leal 0x1(%rbx), %esi
callq 0xaac2
movl 0x10(%r14), %esi
leaq 0x1d17d(%rip), %rdi     # 0x27c87
xorl %eax, %eax
callq 0x3030
subl $0x1, %r15d
jb 0xab20
movl %ebp, %edi
callq 0x3150
jmp 0xab11
leaq 0x14(%r14), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3030
movq 0x8(%r14), %r14
incl %ebx
cmpq %r13, %r14
jne 0xaae3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
jne 0xabac
leaq 0x2c678(%rip), %rsi     # 0x37220
movq %rsi, 0x28(%rbx)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xabc9
movq %rax, 0x28(%rbx)
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0x2c63c(%rip), %rbp     # 0x37220
cmpq %rbp, %rsi
je 0xac15
movq %rsi, %rbx
leaq 0x14(%rsi), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32f0
testl %eax, %eax
jns 0xac65
movq (%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xabc9
movq %rax, (%rbx)
jmp 0xac80
movq %r15, %rdi
callq 0x3200
cmpq $0x10000001, %rax       # imm = 0x10000001
jae 0xacd3
movq %rax, %r13
leal 0x15(%rax), %esi
movq %r12, %rdi
callq 0xa9e8
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 0xacc1
je 0xacbe
movq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xabc9
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
movl 0x10(%rax), %ecx
movl 0x10(%rbx), %edx
cmpl %edx, %ecx
jne 0xac9f
movq 0x8(%rax), %rdx
movq %rdx, (%rbx)
movq %rbx, 0x8(%rax)
movl %ecx, %edx
movq %rbx, %rcx
movq %rax, %rbx
jmp 0xaca3
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rax
cmpl %edx, 0x10(%rax)
jne 0xacc1
movq (%rcx), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%rcx)
incl 0x10(%rcx)
movq %rcx, %rbx
jmp 0xacc1
movq %r13, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1da68(%rip), %rsi     # 0x28742
movq %r12, %rdi
xorl %eax, %eax
callq 0x9778
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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, %r14
movq %rdi, %r12
xorl %ebx, %ebx
leal -0x1(%r15), %ebp
cmpl %r15d, %ebx
jge 0xad56
leal (%rbx,%rbp), %r13d
shrl %r13d
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
callq 0x32f0
testl %eax, %eax
js 0xad51
je 0xad5b
incl %r13d
movl %r13d, %ebx
jmp 0xad2b
movl %r13d, %r15d
jmp 0xad27
pushq $-0x1
popq %rax
jmp 0xad5e
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xadfc
leal -0x61(%rdi), %eax
cmpl $0x5, %eax
ja 0xadee
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_O2/ArtifexSoftware[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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
cmpb $0x0, (%r14)
je 0xae65
leaq 0x4(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1241b
movl %eax, %eax
addq %r14, %rax
movq %rax, 0x40(%rbx)
movl (%r15), %ebp
cmpl $0xd, %ebp
jne 0xae53
cmpb $0xa, (%rax)
jne 0xae53
incq %rax
movq %rax, 0x40(%rbx)
movl %ebp, %edi
callq 0xad9c
testl %eax, %eax
je 0xae68
incl 0x48(%rbx)
pushq $0xa
jmp 0xae67
pushq $-0x1
popq %rbp
movl %ebp, 0x64(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 0xbec3
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 0x1bd7a(%rip), %rdx     # 0x27c84
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 0x7708
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %r14d
subl 0x144(%rdi), %r14d
pushq $0x1
popq %rbp
movsd 0x143ad(%rip), %xmm1    # 0x20438
cmpl %r14d, %ebp
jge 0xc0d2
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfb28
ucomisd %xmm0, %xmm0
jp 0xc0ce
movq 0x8(%rsp), %xmm1
movq %xmm1, %rax
movq %xmm0, %rcx
xorq %rax, %rcx
js 0xc0c1
maxsd %xmm0, %xmm1
jmp 0xc0ca
testq %rax, %rax
jns 0xc0ca
movapd %xmm0, %xmm1
incl %ebp
jmp 0xc08b
movapd %xmm0, %xmm1
movq %rbx, %rdi
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3f9a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xfb28
movdqa %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movapd (%rsp), %xmm2
movdqa %xmm0, %xmm1
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xc1c9
movapd 0x14401(%rip), %xmm0    # 0x205b0
andpd %xmm2, %xmm0
ucomisd 0x14255(%rip), %xmm0    # 0x20410
jne 0xc1c9
jp 0xc1c9
movsd 0x14251(%rip), %xmm0    # 0x20418
jmp 0xc1d2
movapd %xmm2, %xmm0
callq 0x33b0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3f9a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f23
cmpl $0x7, (%r14)
jne 0xc73f
testl %eax, %eax
js 0xc72c
cmpl $0x15, %eax
jae 0xc72c
movsd 0x20(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0xc711
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
sete %cl
ucomisd 0x13e13(%rip), %xmm0    # 0x204f8
jae 0xc711
movsd 0x13e11(%rip), %xmm1    # 0x20500
ucomisd %xmm0, %xmm1
jae 0xc711
testb %cl, %cl
jne 0xc711
leaq 0x1d322(%rip), %rsi     # 0x29a22
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x19326
movq %rsp, %rsi
callq 0xe36d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7f7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d2d5(%rip), %rsi     # 0x29a08
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x9778
leaq 0x1d2a7(%rip), %rsi     # 0x299ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f23
cmpl $0x7, (%r14)
jne 0xc7e3
testl %eax, %eax
js 0xc7d0
cmpl $0x15, %eax
jae 0xc7d0
movq 0x20(%r14), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jl 0xc7b8
movq %rsp, %rsi
callq 0xe36d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7f7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d26d(%rip), %rsi     # 0x29a2c
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x19326
leaq 0x1d231(%rip), %rsi     # 0x29a08
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x9778
leaq 0x1d203(%rip), %rsi     # 0x299ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[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
xorl %esi, %esi
callq 0xd49c
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f23
cmpl $0x7, (%r14)
jne 0xc887
testl %eax, %eax
jle 0xc874
cmpl $0x16, %eax
jae 0xc874
movq 0x20(%r14), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jl 0xc85c
movq %rsp, %rsi
callq 0xe36d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7f7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d1ce(%rip), %rsi     # 0x29a31
movq %rbx, %rdi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x19326
leaq 0x1d18d(%rip), %rsi     # 0x29a08
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x9778
leaq 0x1d15f(%rip), %rsi     # 0x299ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6