LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cbinary
static void cbinary(JF, js_Ast *exp, int opcode)
{
	cexp(J, F, exp->a);
	cexp(J, F, exp->b);
	emitline(J, F, exp);
	emit(J, F, opcode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rdx), %rdx
callq 0x16c1b
movq 0x18(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x16c1b
movl 0x4(%r14), %eax
movl %eax, 0x5c(%r15)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15d57
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cassignop
static void cassignop(JF, js_Ast *exp, int opcode)
{
	js_Ast *lhs = exp->a;
	js_Ast *rhs = exp->b;
	cassignop1(J, F, lhs);
	cexp(J, F, rhs);
	emitline(J, F, exp);
	emit(J, F, opcode);
	cassignop2(J, F, lhs, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rdx), %r13
movq 0x18(%rdx), %rbp
movq %r13, %rdx
callq 0x17ca8
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x16c1b
movl 0x4(%r14), %eax
movl %eax, 0x5c(%r15)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x15d57
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17d87
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: matchlabel
static int matchlabel(js_Ast *node, const char *label)
{
	while (node && node->type == STM_LABEL) {
		if (!strcmp(node->a->string, label))
			return 1;
		node = node->parent;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
testq %r14, %r14
je 0x17f9a
cmpl $0x59, (%r14)
jne 0x17f9a
movq 0x10(%r14), %rax
movq 0x38(%rax), %rdi
movq %rbx, %rsi
callq 0x32f0
testl %eax, %eax
je 0x17f98
movq 0x8(%r14), %r14
jmp 0x17f71
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: js_todate
static double js_todate(js_State *J, int idx)
{
	js_Object *self = js_toobject(J, idx);
	if (self->type != JS_CDATE)
		js_typeerror(J, "not a date");
	return self->u.number;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd49c
cmpl $0xa, (%rax)
jne 0x17fb6
movsd 0x20(%rax), %xmm0
popq %rbx
retq
leaq 0x1122b(%rip), %rsi     # 0x291e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: fmtdatetime
static char *fmtdatetime(char *buf, double t, double tza)
{
	char dbuf[20], tbuf[20];
	if (!isfinite(t))
		return "Invalid Date";
	fmtdate(dbuf, t);
	fmttime(tbuf, t, tza);
	sprintf(buf, "%sT%s", dbuf, tbuf);
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x17ff2
leaq 0x11203(%rip), %rbx     # 0x291f3
jmp 0x1803c
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x180cf
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x1814a
leaq 0x111d4(%rip), %rsi     # 0x29200
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3220
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: LocalTZA
static double LocalTZA(void)
{
	static int once = 1;
	static double tza = 0;
	if (once) {
		time_t now = time(NULL);
		time_t utc = mktime(gmtime(&now));
		time_t loc = mktime(localtime(&now));
		tza = (loc - utc) * 1000;
		once = 0;
	}
	return tza;
}

// Assembly:
cmpb $0x1, 0x1f3be(%rip)     # 0x37428
jne 0x18075
movsd 0x1f3bc(%rip), %xmm0    # 0x37430
retq
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x33f0
movq %rsp, %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3050
movq %rax, %r14
movq %rbx, %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x3050
subq %r14, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x1f370(%rip)    # 0x37430
movb $0x1, 0x1f361(%rip)     # 0x37428
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: fmtdate
static char *fmtdate(char *buf, double t)
{
	int y = YearFromTime(t);
	int m = MonthFromTime(t);
	int d = DateFromTime(t);
	if (!isfinite(t))
		return "Invalid Date";
	sprintf(buf, "%04d-%02d-%02d", y, m+1, d);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x180f9
leaq 0x110fc(%rip), %rbx     # 0x291f3
jmp 0x1813e
movq %rdi, %rbx
movq %xmm0, 0x8(%rsp)
callq 0x18372
movl %eax, %ebp
movsd 0x8(%rsp), %xmm0
callq 0x182bb
movl %eax, %r14d
movq 0x8(%rsp), %xmm0
callq 0x18252
incl %r14d
leaq 0x110da(%rip), %rsi     # 0x29206
movq %rbx, %rdi
movl %eax, %edx
movl %r14d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3220
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: fmttime
static char *fmttime(char *buf, double t, double tza)
{
	int H = HourFromTime(t);
	int M = MinFromTime(t);
	int S = SecFromTime(t);
	int ms = msFromTime(t);
	int tzh = HourFromTime(fabs(tza));
	int tzm = MinFromTime(fabs(tza));
	if (!isfinite(t))
		return "Invalid Date";
	if (tza == 0)
		sprintf(buf, "%02d:%02d:%02d.%03dZ", H, M, S, ms);
	else if (tza < 0)
		sprintf(buf, "%02d:%02d:%02d.%03d-%02d:%02d", H, M, S, ms, tzh, tzm);
	else
		sprintf(buf, "%02d:%02d:%02d.%03d+%02d:%02d", H, M, S, ms, tzh, tzm);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movapd %xmm1, 0x20(%rsp)
movq %xmm0, (%rsp)
movq %rdi, %rbx
movq %xmm0, %r13
callq 0x1853f
movl %eax, %ebp
movsd (%rsp), %xmm0
callq 0x18560
movl %eax, %r14d
movsd (%rsp), %xmm0
callq 0x18581
movl %eax, %r15d
movsd (%rsp), %xmm0
callq 0x185a2
movl %eax, %r12d
movaps 0x8410(%rip), %xmm0     # 0x205b0
andps 0x20(%rsp), %xmm0
movaps %xmm0, (%rsp)
callq 0x1853f
movq %rax, 0x18(%rsp)
movapd (%rsp), %xmm0
callq 0x18560
movl %eax, %r10d
btrq $0x3f, %r13
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %r13
jle 0x181dd
leaq 0x11018(%rip), %rbx     # 0x291f3
jmp 0x18240
xorpd %xmm0, %xmm0
movapd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1820d
jp 0x1820d
leaq 0x1101f(%rip), %rsi     # 0x29215
movq %rbx, %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x3220
jmp 0x18240
ucomisd %xmm1, %xmm0
jbe 0x1821c
leaq 0x11010(%rip), %rsi     # 0x2922a
jmp 0x18223
leaq 0x11025(%rip), %rsi     # 0x29248
movq %rbx, %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x20(%rsp)
callq 0x3220
popq %rcx
popq %rdx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: YearFromTime
static int YearFromTime(double t)
{
	int y = floor(t / (msPerDay * 365.2425)) + 1970;
	double t2 = TimeFromYear(y);
	if (t2 > t)
		--y;
	else if (t2 + msPerDay * DaysInYear(y) <= t)
		++y;
	return y;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
divsd 0x82e4(%rip), %xmm0     # 0x20548
callq 0x3370
addsd 0x82df(%rip), %xmm0     # 0x20550
cvttsd2si %xmm0, %ebx
movl %ebx, %edi
callq 0x18419
ucomisd (%rsp), %xmm0
jbe 0x18287
decl %ebx
jmp 0x182b3
movl %ebx, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x1842d
cvtsi2sd %eax, %xmm0
mulsd 0x81e8(%rip), %xmm0     # 0x20488
addsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x182b3
incl %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: MonthFromTime
static int MonthFromTime(double t)
{
	int day = DayWithinYear(t);
	int leap = InLeapYear(t);
	if (day < 31) return 0;
	if (day < 59 + leap) return 1;
	if (day < 90 + leap) return 2;
	if (day < 120 + leap) return 3;
	if (day < 151 + leap) return 4;
	if (day < 181 + leap) return 5;
	if (day < 212 + leap) return 6;
	if (day < 243 + leap) return 7;
	if (day < 273 + leap) return 8;
	if (day < 304 + leap) return 9;
	if (day < 334 + leap) return 10;
	return 11;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x184ec
movl %eax, %ebx
movsd 0x8(%rsp), %xmm0
callq 0x18524
xorl %ecx, %ecx
cmpl $0x1f, %ebx
jl 0x1835b
leal 0x3b(%rax), %ecx
cmpl %ecx, %ebx
jae 0x182ea
pushq $0x1
jmp 0x1835a
movl %eax, %ecx
orl $0x5a, %ecx
cmpl %ecx, %ebx
jae 0x182f7
pushq $0x2
jmp 0x1835a
movl %eax, %ecx
orl $0x78, %ecx
cmpl %ecx, %ebx
jae 0x18304
pushq $0x3
jmp 0x1835a
leal 0x97(%rax), %ecx
cmpl %ecx, %ebx
jae 0x18312
pushq $0x4
jmp 0x1835a
leal 0xb5(%rax), %ecx
cmpl %ecx, %ebx
jae 0x18320
pushq $0x5
jmp 0x1835a
movl %eax, %ecx
orl $0xd4, %ecx
cmpl %ecx, %ebx
jae 0x18330
pushq $0x6
jmp 0x1835a
leal 0xf3(%rax), %ecx
cmpl %ecx, %ebx
jae 0x1833e
pushq $0x7
jmp 0x1835a
leal 0x111(%rax), %ecx
cmpl %ecx, %ebx
jae 0x1834c
pushq $0x8
jmp 0x1835a
movl %eax, %ecx
orl $0x130, %ecx            # imm = 0x130
cmpl %ecx, %ebx
jae 0x18363
pushq $0x9
popq %rcx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
orl $0x14e, %eax            # imm = 0x14E
cmpl %eax, %ebx
pushq $0xb
popq %rcx
sbbl $0x0, %ecx
jmp 0x1835b
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: DateFromTime
static int DateFromTime(double t)
{
	int day = DayWithinYear(t);
	int leap = InLeapYear(t);
	switch (MonthFromTime(t)) {
	case 0: return day + 1;
	case 1: return day - 30;
	case 2: return day - 58 - leap;
	case 3: return day - 89 - leap;
	case 4: return day - 119 - leap;
	case 5: return day - 150 - leap;
	case 6: return day - 180 - leap;
	case 7: return day - 211 - leap;
	case 8: return day - 242 - leap;
	case 9: return day - 272 - leap;
	case 10: return day - 303 - leap;
	default : return day - 333 - leap;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
callq 0x184ec
movl %eax, %ebx
movsd (%rsp), %xmm0
callq 0x18524
movl %eax, %ebp
movsd (%rsp), %xmm0
callq 0x182bb
cmpl $0xa, %eax
ja 0x18408
movl %eax, %eax
leaq 0x876f(%rip), %rcx      # 0x20b14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl %ebx
jmp 0x18410
subl %ebp, %ebx
addl $-0x77, %ebx
jmp 0x18410
subl %ebp, %ebx
addl $0xfffffef0, %ebx       # imm = 0xFFFFFEF0
jmp 0x18410
subl %ebp, %ebx
addl $-0x3a, %ebx
jmp 0x18410
subl %ebp, %ebx
addl $-0x59, %ebx
jmp 0x18410
subl %ebp, %ebx
addl $0xffffff2d, %ebx       # imm = 0xFFFFFF2D
jmp 0x18410
addl $-0x1e, %ebx
jmp 0x18410
subl %ebp, %ebx
addl $0xffffff6a, %ebx       # imm = 0xFFFFFF6A
jmp 0x18410
subl %ebp, %ebx
addl $0xffffff4c, %ebx       # imm = 0xFFFFFF4C
jmp 0x18410
subl %ebp, %ebx
addl $0xfffffed1, %ebx       # imm = 0xFFFFFED1
jmp 0x18410
subl %ebp, %ebx
addl $0xffffff0e, %ebx       # imm = 0xFFFFFF0E
jmp 0x18410
subl %ebp, %ebx
addl $0xfffffeb3, %ebx       # imm = 0xFFFFFEB3
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: DayFromYear
static int DayFromYear(int y)
{
	return 365 * (y - 1970) +
		floor((y - 1969) / 4.0) -
		floor((y - 1901) / 100.0) +
		floor((y - 1601) / 400.0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
imull $0x16d, %edi, %eax      # imm = 0x16D
addl $0xfff50736, %eax       # imm = 0xFFF50736
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
leal -0x7b1(%rbx), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x80cb(%rip), %xmm0     # 0x20558
callq 0x3370
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leal -0x76d(%rbx), %eax
cvtsi2sd %eax, %xmm0
divsd 0x7ff8(%rip), %xmm0     # 0x204a8
callq 0x3370
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
addl $0xfffff9bf, %ebx       # imm = 0xFFFFF9BF
cvtsi2sd %ebx, %xmm0
divsd 0x8089(%rip), %xmm0     # 0x20560
callq 0x3370
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: pmod
static double pmod(double x, double y)
{
	x = fmod(x, y);
	if (x < 0)
		x += y;
	return x;
}

// Assembly:
subq $0x18, %rsp
movaps %xmm1, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm3
addsd %xmm0, %xmm3
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: js_setdate
static void js_setdate(js_State *J, int idx, double t)
{
	js_Object *self = js_toobject(J, idx);
	if (self->type != JS_CDATE)
		js_typeerror(J, "not a date");
	self->u.number = TimeClip(t);
	js_pushnumber(J, self->u.number);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd49c
cmpl $0xa, (%rax)
jne 0x18654
movq %rax, %r14
movsd (%rsp), %xmm0
callq 0x18665
movsd %xmm0, 0x20(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f9a
leaq 0x10b8d(%rip), %rsi     # 0x291e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: MakeDay
static double MakeDay(double y, double m, double date)
{
	/*
	 * The following array contains the day of year for the first day of
	 * each month, where index 0 is January, and day 0 is January 1.
	 */
	static const double firstDayOfMonth[2][12] = {
		{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
		{0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
	};

	double yd, md;
	int im;

	y += floor(m / 12);
	m = pmod(m, 12);

	im = (int)m;
	if (im < 0 || im >= 12)
		return NAN;

	yd = floor(TimeFromYear(y) / msPerDay);
	md = firstDayOfMonth[DaysInYear(y) == 366][im];

	return yd + md + date - 1;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movapd %xmm1, %xmm2
movsd %xmm0, (%rsp)
movsd 0x7e79(%rip), %xmm1     # 0x20588
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, %xmm0
callq 0x185b6
cvttsd2si %xmm0, %ebp
cmpl $0xb, %ebp
jbe 0x18731
movsd 0x7ce9(%rip), %xmm0     # 0x20418
jmp 0x1879f
movsd 0x8(%rsp), %xmm0
divsd 0x7e49(%rip), %xmm0     # 0x20588
callq 0x3370
addsd (%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl %ebx, %edi
callq 0x18419
divsd 0x7d2c(%rip), %xmm0     # 0x20488
callq 0x3370
movsd %xmm0, (%rsp)
movl %ebx, %edi
callq 0x1842d
movsd (%rsp), %xmm0
xorl %ecx, %ecx
cmpl $0x16e, %eax            # imm = 0x16E
sete %cl
movl %ebp, %eax
imulq $0x60, %rcx, %rcx
leaq 0xd187(%rip), %rdx      # 0x25910
addq %rcx, %rdx
addsd (%rdx,%rax,8), %xmm0
addsd 0x10(%rsp), %xmm0
addsd 0x7c69(%rip), %xmm0     # 0x20408
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsdate.c
// Function: toint
static int toint(const char **sp, int w, int *v)
{
	const char *s = *sp;
	*v = 0;
	while (w--) {
		if (*s < '0' || *s > '9')
			return 0;
		*v = *v * 10 + (*s++ - '0');
	}
	*sp = s;
	return 1;
}

// Assembly:
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, (%rdx)
subl $0x1, %esi
jb 0x18b4a
movb (%rax), %r8b
leal -0x3a(%r8), %r9d
cmpb $-0xa, %r9b
jb 0x18b51
imull $0xa, %ecx, %r9d
incq %rax
addb $-0x30, %r8b
movzbl %r8b, %ecx
addl %r9d, %ecx
jmp 0x18b22
movq %rax, (%rdi)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jserror.c
// Function: jsB_stacktrace
static int jsB_stacktrace(js_State *J, int skip)
{
	char buf[256];
	int n = J->tracetop - skip;
	if (n <= 0)
		return 0;
	for (; n > 0; --n) {
		const char *name = J->trace[n].name;
		const char *file = J->trace[n].file;
		int line = J->trace[n].line;
		if (line > 0) {
			if (name[0])
				snprintf(buf, sizeof buf, "\n\tat %s (%s:%d)", name, file, line);
			else
				snprintf(buf, sizeof buf, "\n\tat %s:%d", file, line);
		} else
			snprintf(buf, sizeof buf, "\n\tat %s (%s)", name, file);
		js_pushstring(J, buf);
		if (n < J->tracetop - skip)
			js_concat(J);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl 0x2190(%rdi), %r15d
subl %esi, %r15d
jle 0x18c2f
movl %esi, %ebx
movq %rdi, %r14
movl %r15d, %eax
imulq $0x18, %rax, %rax
leaq (%rax,%rdi), %rbp
addq $0x21a8, %rbp           # imm = 0x21A8
movq %rsp, %r12
leaq 0x10752(%rip), %r13     # 0x292e8
testl %r15d, %r15d
jle 0x18c2a
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
movl (%rbp), %r9d
testl %r9d, %r9d
jle 0x18bc9
cmpb $0x0, (%rcx)
je 0x18be1
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3080
jmp 0x18bfd
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
leaq 0x1072b(%rip), %rdx     # 0x29303
xorl %eax, %eax
callq 0x3080
jmp 0x18bfd
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
leaq 0x10708(%rip), %rdx     # 0x292f8
movq %r8, %rcx
movl %r9d, %r8d
xorl %eax, %eax
callq 0x3080
movq %r14, %rdi
movq %r12, %rsi
callq 0xe7f7
movl 0x2190(%r14), %eax
subl %ebx, %eax
cmpl %r15d, %eax
jle 0x18c1e
movq %r14, %rdi
callq 0x13be7
addq $-0x18, %rbp
decl %r15d
jmp 0x18b96
pushq $0x1
popq %rax
jmp 0x18c31
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jserror.c
// Function: jsB_ErrorX
static int jsB_ErrorX(js_State *J, js_Object *prototype)
{
	js_pushobject(J, jsV_newobject(J, JS_CERROR, prototype));
	if (js_isdefined(J, 1)) {
		js_pushstring(J, js_tostring(J, 1));
		js_defproperty(J, -2, "message", JS_DONTENUM);
	}
	if (jsB_stacktrace(J, 1))
		js_defproperty(J, -2, "stack", JS_DONTENUM);
	return 1;
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x5d6b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4274
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x18c97
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7f7
leaq 0x10651(%rip), %rdx     # 0x292da
pushq $-0x2
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
callq 0x5963
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x18b54
testl %eax, %eax
je 0x18cbc
leaq 0x10635(%rip), %rdx     # 0x292e2
pushq $-0x2
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
popq %rbx
jmp 0x5963
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsfunction.c
// Function: callbound
static void callbound(js_State *J)
{
	int top = js_gettop(J);
	int i, fun, args, n;

	fun = js_gettop(J);
	js_currentfunction(J);
	js_getproperty(J, fun, "__TargetFunction__");
	js_getproperty(J, fun, "__BoundThis__");

	args = js_gettop(J);
	js_getproperty(J, fun, "__BoundArguments__");
	n = js_getlength(J, args);
	if (n < 0)
		n = 0;
	for (i = 0; i < n; ++i)
		js_getindex(J, args, i);
	js_remove(J, args);

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

	js_call(J, n + top - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %r14d
subl 0x144(%rdi), %r14d
callq 0xf80e
leaq 0x10675(%rip), %rdx     # 0x29358
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3eff
leaq 0x10676(%rip), %rdx     # 0x2936b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3eff
movl 0x140(%rbx), %ebp
subl 0x144(%rbx), %ebp
leaq 0x10666(%rip), %rdx     # 0x29379
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3eff
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ecc
movl %eax, %r15d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r15d
movq %rbx, %rdi
cmpl %r12d, %r15d
je 0x18d4b
movl %ebp, %esi
movl %r12d, %edx
callq 0x10e96
incl %r12d
jmp 0x18d34
movl %ebp, %esi
callq 0xff6c
pushq $0x1
popq %rbp
cmpl %r14d, %ebp
jge 0x18d68
movq %rbx, %rdi
movl %ebp, %esi
callq 0xeee2
incl %ebp
jmp 0x18d55
leal (%r14,%r15), %esi
decl %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x110b0
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsfunction.c
// Function: constructbound
static void constructbound(js_State *J)
{
	int top = js_gettop(J);
	int i, fun, args, n;

	fun = js_gettop(J);
	js_currentfunction(J);
	js_getproperty(J, fun, "__TargetFunction__");

	args = js_gettop(J);
	js_getproperty(J, fun, "__BoundArguments__");
	n = js_getlength(J, args);
	if (n < 0)
		n = 0;
	for (i = 0; i < n; ++i)
		js_getindex(J, args, i);
	js_remove(J, args);

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

	js_construct(J, n + top - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %r14d
subl 0x144(%rdi), %r14d
callq 0xf80e
leaq 0x105b5(%rip), %rdx     # 0x29358
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3eff
movl 0x140(%rbx), %ebp
subl 0x144(%rbx), %ebp
leaq 0x105b8(%rip), %rdx     # 0x29379
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3eff
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ecc
movl %eax, %r15d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r15d
movq %rbx, %rdi
cmpl %r12d, %r15d
je 0x18df9
movl %ebp, %esi
movl %r12d, %edx
callq 0x10e96
incl %r12d
jmp 0x18de2
movl %ebp, %esi
callq 0xff6c
pushq $0x1
popq %rbp
cmpl %r14d, %ebp
jge 0x18e16
movq %rbx, %rdi
movl %ebp, %esi
callq 0xeee2
incl %ebp
jmp 0x18e03
leal (%r14,%r15), %esi
decl %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11554
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsgc.c
// Function: jsG_markproperty
static void jsG_markproperty(js_State *J, int mark, js_Property *node)
{
	if (node->left->level) jsG_markproperty(J, mark, node->left);
	if (node->right->level) jsG_markproperty(J, mark, node->right);

	if (node->value.t.type == JS_TMEMSTR && node->value.u.memstr->gcmark != mark)
		node->value.u.memstr->gcmark = mark;
	if (node->value.t.type == JS_TOBJECT && node->value.u.object->gcmark != mark)
		jsG_markobject(J, mark, node->value.u.object);
	if (node->getter && node->getter->gcmark != mark)
		jsG_markobject(J, mark, node->getter);
	if (node->setter && node->setter->gcmark != mark)
		jsG_markobject(J, mark, node->setter);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdx
cmpl $0x0, 0x10(%rdx)
je 0x18e4b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x18e2c
movq 0x8(%r14), %rdx
cmpl $0x0, 0x10(%rdx)
je 0x18e5f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x18e2c
movb 0x27(%r14), %al
cmpb $0x6, %al
jne 0x18e7b
movq 0x18(%r14), %rax
movsbl 0x8(%rax), %ecx
cmpl %ebp, %ecx
je 0x18e9d
movb %bpl, 0x8(%rax)
movb 0x27(%r14), %al
cmpb $0x7, %al
jne 0x18e9d
movq 0x18(%r14), %rax
cmpl %ebp, 0x60(%rax)
je 0x18e9d
movl %ebp, 0x60(%rax)
movq 0x180(%rbx), %rcx
movq %rcx, 0x58(%rax)
movq %rax, 0x180(%rbx)
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x18ec0
cmpl %ebp, 0x60(%rax)
je 0x18ec0
movl %ebp, 0x60(%rax)
movq 0x180(%rbx), %rcx
movq %rcx, 0x58(%rax)
movq %rax, 0x180(%rbx)
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x18ee3
cmpl %ebp, 0x60(%rax)
je 0x18ee3
movl %ebp, 0x60(%rax)
movq 0x180(%rbx), %rcx
movq %rcx, 0x58(%rax)
movq %rax, 0x180(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsgc.c
// Function: jsG_markfunction
static void jsG_markfunction(js_State *J, int mark, js_Function *fun)
{
	int i;
	fun->gcmark = mark;
	for (i = 0; i < fun->funlen; ++i)
		if (fun->funtab[i]->gcmark != mark)
			jsG_markfunction(J, mark, fun->funtab[i]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, 0x68(%rsi)
xorl %r14d, %r14d
movslq 0x3c(%rbx), %rax
cmpq %rax, %r14
jge 0x18f19
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rsi
cmpl %ebp, 0x68(%rsi)
je 0x18f14
movl %ebp, %edi
callq 0x18ee8
incq %r14
jmp 0x18ef7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jslex.c
// Function: jsY_unescape
static void jsY_unescape(js_State *J)
{
	if (jsY_accept(J, '\\')) {
		if (jsY_accept(J, 'u')) {
			int x = 0;
			if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 12; jsY_next(J);
			if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 8; jsY_next(J);
			if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 4; jsY_next(J);
			if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar);
			J->lexchar = x;
			return;
		}
error:
		jsY_error(J, "unexpected escape sequence");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x5c, 0x64(%rdi)
jne 0x1921e
movq %rdi, %rbx
callq 0xae12
cmpl $0x75, 0x64(%rbx)
jne 0x19227
movq %rbx, %rdi
callq 0xae12
movl 0x64(%rbx), %edi
leal -0x3a(%rdi), %eax
cmpl $-0xb, %eax
ja 0x1917a
movl %edi, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x19227
callq 0xadd8
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae12
movl 0x64(%rbx), %edi
leal -0x3a(%rdi), %eax
cmpl $-0xb, %eax
ja 0x191a5
movl %edi, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x19227
callq 0xadd8
movl %eax, %r14d
movq %rbx, %rdi
callq 0xae12
movl 0x64(%rbx), %r15d
leal -0x3a(%r15), %eax
cmpl $-0xb, %eax
ja 0x191d0
movl %r15d, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x19227
movq %rbx, %rdi
callq 0xae12
movl 0x64(%rbx), %r12d
leal -0x3a(%r12), %eax
cmpl $-0xb, %eax
ja 0x191f4
movl %r12d, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x19227
movl %r15d, %edi
callq 0xadd8
movl %eax, %r15d
shll $0xc, %ebp
shll $0x8, %r14d
orl %ebp, %r14d
shll $0x4, %r15d
movl %r12d, %edi
callq 0xadd8
orl %r15d, %eax
orl %r14d, %eax
movl %eax, 0x64(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10683(%rip), %rsi     # 0x298b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xbe61
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jslex.c
// Function: textinit
static void textinit(js_State *J)
{
	if (!J->lexbuf.text) {
		J->lexbuf.cap = 4096;
		J->lexbuf.text = js_malloc(J, J->lexbuf.cap);
	}
	J->lexbuf.len = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x1927a
movl $0x1000, 0x5c(%rbx)     # imm = 0x1000
movq %rbx, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xa9e8
movq %rax, 0x50(%rbx)
andl $0x0, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jslex.c
// Function: textpush
static void textpush(js_State *J, Rune c)
{
	int n;
	if (c == EOF)
		n = 1;
	else
		n = runelen(c);
	if (J->lexbuf.len + n > J->lexbuf.cap) {
		J->lexbuf.cap = J->lexbuf.cap * 2;
		J->lexbuf.text = js_realloc(J, J->lexbuf.text, J->lexbuf.cap);
	}
	if (c == EOF)
		J->lexbuf.text[J->lexbuf.len++] = 0;
	else
		J->lexbuf.len += runetochar(J->lexbuf.text + J->lexbuf.len, &c);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
cmpl $-0x1, %esi
je 0x1929a
movl %ebp, %edi
callq 0x15222
jmp 0x1929d
pushq $0x1
popq %rax
addl 0x58(%rbx), %eax
movl 0x5c(%rbx), %edx
cmpl %edx, %eax
jle 0x192bc
addl %edx, %edx
movl %edx, 0x5c(%rbx)
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
callq 0xaa05
movq %rax, 0x50(%rbx)
movq 0x50(%rbx), %rdi
movslq 0x58(%rbx), %rax
cmpl $-0x1, %ebp
je 0x192db
addq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0x15185
addl %eax, 0x58(%rbx)
jmp 0x192e5
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
movb $0x0, (%rdi,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsnumber.c
// Function: numtostr
static void numtostr(js_State *J, const char *fmt, int w, double n)
{
	/* buf needs to fit printf("%.20f", 1e20) */
	char buf[50], *e;
	sprintf(buf, fmt, w, n);
	e = strchr(buf, 'e');
	if (e) {
		int exp = atoi(e+1);
		sprintf(e, "e%+d", exp);
	}
	js_pushstring(J, buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x3220
pushq $0x65
popq %rsi
movq %r14, %rdi
callq 0x32a0
testq %rax, %rax
je 0x1936e
movq %rax, %r14
movq %rax, %rdi
incq %rdi
callq 0x3290
leaq 0x106c5(%rip), %rsi     # 0x29a27
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3220
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe7f7
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_getOwnPropertyNames_walk
static int O_getOwnPropertyNames_walk(js_State *J, js_Property *ref, int i)
{
	if (ref->left->level)
		i = O_getOwnPropertyNames_walk(J, ref->left, i);
	js_pushstring(J, ref->name);
	js_setindex(J, -2, i++);
	if (ref->right->level)
		i = O_getOwnPropertyNames_walk(J, ref->right, i);
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x2
popq %rbp
movq (%rbx), %rsi
cmpl $0x0, 0x10(%rsi)
je 0x193ac
movq %r14, %rdi
movl %r15d, %edx
callq 0x19381
movl %eax, %r15d
movl %r15d, %r12d
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xe7f7
leal 0x1(%r12), %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xe9c5
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x19395
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_create_walk
static void O_create_walk(js_State *J, js_Object *obj, js_Property *ref)
{
	if (ref->left->level)
		O_create_walk(J, obj, ref->left);
	if (!(ref->atts & JS_DONTENUM)) {
		if (ref->value.t.type != JS_TOBJECT)
			js_typeerror(J, "not an object");
		ToPropertyDescriptor(J, obj, ref->name, ref->value.u.object);
	}
	if (ref->right->level)
		O_create_walk(J, obj, ref->right);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%r14), %rdx
cmpl $0x0, 0x10(%rdx)
je 0x19405
movq %rbx, %rdi
movq %r15, %rsi
callq 0x193e3
testb $0x2, 0x14(%r14)
jne 0x19426
cmpb $0x7, 0x27(%r14)
jne 0x19437
leaq 0x38(%r14), %rdx
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19448
movq 0x8(%r14), %r14
cmpl $0x0, 0x10(%r14)
jne 0x193f1
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10ca9(%rip), %rsi     # 0x2a0e7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_defineProperties_walk
static void O_defineProperties_walk(js_State *J, js_Property *ref)
{
	if (ref->left->level)
		O_defineProperties_walk(J, ref->left);
	if (!(ref->atts & JS_DONTENUM)) {
		js_pushvalue(J, ref->value);
		ToPropertyDescriptor(J, js_toobject(J, 1), ref->name, js_toobject(J, -1));
		js_pop(J, 1);
	}
	if (ref->right->level)
		O_defineProperties_walk(J, ref->right);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
pushq $-0x1
popq %r15
movq (%rbx), %rsi
cmpl $0x0, 0x10(%rsi)
je 0x1960b
movq %r14, %rdi
callq 0x195e2
testb $0x2, 0x14(%rbx)
jne 0x19658
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0xf74a
movq %r14, %rdi
movl %ebp, %esi
callq 0xd49c
movq %rax, %r12
leaq 0x38(%rbx), %r13
movq %r14, %rdi
movl %r15d, %esi
callq 0xd49c
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x19448
movq %r14, %rdi
movl %ebp, %esi
callq 0x3f3d
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x195fa
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/./jsobject.c
// Function: O_seal_walk
static void O_seal_walk(js_State *J, js_Property *ref)
{
	if (ref->left->level)
		O_seal_walk(J, ref->left);
	ref->atts |= JS_DONTCONF;
	if (ref->right->level)
		O_seal_walk(J, ref->right);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x19683
callq 0x19671
orb $0x4, 0x14(%rbx)
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x19675
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_freeze_walk
static void O_freeze_walk(js_State *J, js_Property *ref)
{
	if (ref->left->level)
		O_freeze_walk(J, ref->left);
	ref->atts |= JS_READONLY | JS_DONTCONF;
	if (ref->right->level)
		O_freeze_walk(J, ref->right);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x196a5
callq 0x19693
orb $0x5, 0x14(%rbx)
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x19697
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_isSealed_walk
static int O_isSealed_walk(js_State *J, js_Property *ref)
{
	if (ref->left->level)
		if (!O_isSealed_walk(J, ref->left))
			return 0;
	if (!(ref->atts & JS_DONTCONF))
		return 0;
	if (ref->right->level)
		if (!O_isSealed_walk(J, ref->right))
			return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x196ce
callq 0x196b5
testl %eax, %eax
je 0x196ef
xorl %ebx, %ebx
testb $0x4, 0x14(%r14)
je 0x196f1
movq 0x8(%r14), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x196ea
callq 0x196b5
testl %eax, %eax
je 0x196f1
pushq $0x1
popq %rbx
jmp 0x196f1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_isFrozen_walk
static int O_isFrozen_walk(js_State *J, js_Property *ref)
{
	if (ref->left->level)
		if (!O_isFrozen_walk(J, ref->left))
			return 0;
	if (!(ref->atts & JS_READONLY))
		return 0;
	if (!(ref->atts & JS_DONTCONF))
		return 0;
	if (ref->right->level)
		if (!O_isFrozen_walk(J, ref->right))
			return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x19714
callq 0x196fb
testl %eax, %eax
je 0x19738
movl 0x14(%r14), %eax
notl %eax
xorl %ebx, %ebx
testb $0x5, %al
jne 0x1973a
movq 0x8(%r14), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x19733
callq 0x196fb
testl %eax, %eax
je 0x1973a
pushq $0x1
popq %rbx
jmp 0x1973a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsobject.c
// Function: O_keys_walk
static int O_keys_walk(js_State *J, js_Property *ref, int i)
{
	if (ref->left->level)
		i = O_keys_walk(J, ref->left, i);
	if (!(ref->atts & JS_DONTENUM)) {
		js_pushstring(J, ref->name);
		js_setindex(J, -2, i++);
	}
	if (ref->right->level)
		i = O_keys_walk(J, ref->right, i);
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x2
popq %rbp
movq (%rbx), %rsi
cmpl $0x0, 0x10(%rsi)
je 0x1976f
movq %r14, %rdi
movl %r15d, %edx
callq 0x19744
movl %eax, %r15d
testb $0x2, 0x14(%rbx)
jne 0x19795
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xe7f7
leal 0x1(%r15), %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xe9c5
movl %r12d, %r15d
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x10(%rbx)
jne 0x19758
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./json.c
// Function: jsonrevive
static void jsonrevive(js_State *J, const char *name)
{
	const char *key;
	char buf[32];

	/* revive is in 2 */
	/* holder is in -1 */

	js_getproperty(J, -1, name); /* get value from holder */

	if (js_isobject(J, -1)) {
		if (js_isarray(J, -1)) {
			int i = 0;
			int n = js_getlength(J, -1);
			for (i = 0; i < n; ++i) {
				jsonrevive(J, js_itoa(buf, i));
				if (js_isundefined(J, -1)) {
					js_pop(J, 1);
					js_delproperty(J, -1, buf);
				} else {
					js_setproperty(J, -2, buf);
				}
			}
		} else {
			js_pushiterator(J, -1, 1);
			while ((key = js_nextiterator(J, -1))) {
				js_rot2(J);
				jsonrevive(J, key);
				if (js_isundefined(J, -1)) {
					js_pop(J, 1);
					js_delproperty(J, -1, key);
				} else {
					js_setproperty(J, -2, key);
				}
				js_rot2(J);
			}
			js_pop(J, 1);
		}
	}

	js_copy(J, 2); /* reviver function */
	js_copy(J, -3); /* holder as this */
	js_pushstring(J, name); /* name */
	js_copy(J, -4); /* value */
	js_call(J, 2);
	js_rot2pop1(J); /* pop old value, leave new value on stack */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
pushq $-0x1
popq %rbp
movl %ebp, %esi
movq %rdx, 0x8(%rsp)
callq 0x3eff
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd489
testl %eax, %eax
je 0x19a9b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf97f
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0x19a19
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ecc
movl %eax, %r15d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r15d
leaq 0x10(%rsp), %r13
pushq $0x1
popq %r14
cmpl %r12d, %r15d
je 0x19a9b
movq %r13, %rdi
movl %r12d, %esi
callq 0xe0ad
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1995c
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf8bb
movq %rbx, %rdi
testl %eax, %eax
je 0x19a09
movl %r14d, %esi
callq 0x3f3d
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x10b54
jmp 0x19a14
pushq $-0x2
popq %rsi
movq %r13, %rdx
callq 0x3fdd
incl %r12d
jmp 0x199c2
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1102e
pushq $-0x2
popq %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1105b
testq %rax, %rax
je 0x19a90
movq %rax, %r14
movq %rbx, %rdi
callq 0x10070
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1995c
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf8bb
movq %rbx, %rdi
testl %eax, %eax
je 0x19a7b
movl %r15d, %esi
callq 0x3f3d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x10b54
jmp 0x19a86
movl %r12d, %esi
movq %r14, %rdx
callq 0x3fdd
movq %rbx, %rdi
callq 0x10070
jmp 0x19a2e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xeee2
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0xeee2
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0xe7f7
pushq $-0x4
popq %rsi
movq %rbx, %rdi
callq 0xeee2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x110b0
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./json.c
// Function: fmtnum
static void fmtnum(js_State *J, js_Buffer **sb, double n)
{
	if (isnan(n)) js_puts(J, sb, "null");
	else if (isinf(n)) js_puts(J, sb, "null");
	else if (n == 0) js_puts(J, sb, "0");
	else {
		char buf[40];
		js_puts(J, sb, jsV_numbertostring(J, buf, n));
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
ucomisd %xmm0, %xmm0
jp 0x1a18c
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x1a195
leaq 0xf9f3(%rip), %rdx      # 0x29b86
jmp 0x1a1a8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a1ba
jp 0x1a1ba
leaq 0xfdb8(%rip), %rdx      # 0x29f60
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xaa1e
movq %rsp, %rsi
callq 0xe36d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xaa1e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: scriptelement
static js_Ast *scriptelement(js_State *J)
{
	int line = J->lexline;
	if (jsP_accept(J, TK_FUNCTION))
		return fundec(J, line);
	return statement(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x128, 0x74(%rdi)      # imm = 0x128
jne 0x1a462
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1acfa
movl 0x74(%rbx), %edi
cmpl $0x28, %edi
jne 0x1a471
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0xdb0b
movl 0x74(%rbx), %edi
cmpl $0x29, %edi
jne 0x1a486
movq %rax, %r15
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1ae28
andq $0x0, (%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
callq 0xdb92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1a4bf
callq 0xace4
leaq 0xf790(%rip), %rsi      # 0x29c0d
leaq 0xfedd(%rip), %rcx      # 0x2a361
jmp 0x1a499
callq 0xace4
leaq 0xf77b(%rip), %rsi      # 0x29c0d
leaq 0xe713(%rip), %rcx      # 0x28bac
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: identifier
static js_Ast *identifier(js_State *J)
{
	js_Ast *a;
	if (J->lookahead == TK_IDENTIFIER) {
		a = jsP_newstrnode(J, AST_IDENTIFIER, J->text);
		jsP_next(J);
		return a;
	}
	jsP_error(J, "unexpected token: %s (expected identifier)", jsY_tokenstring(J->lookahead));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %edi
cmpl $0x100, %edi            # imm = 0x100
jne 0x1ad31
movq 0x78(%rbx), %rdx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1ae9d
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xace4
leaq 0xef2d(%rip), %rsi      # 0x29c6a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: funbody
static js_Ast *funbody(js_State *J)
{
	js_Ast *a;
	jsP_expect(J, '{');
	a = script(J, '}');
	jsP_expect(J, '}');
	return a;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %edi
cmpl $0x7b, %edi
jne 0x1ae68
movq %rbx, %rdi
callq 0xd822
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0xd830
movl 0x74(%rbx), %edi
cmpl $0x7d, %edi
jne 0x1ae7d
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xace4
leaq 0xed99(%rip), %rsi      # 0x29c0d
leaq 0xe753(%rip), %rcx      # 0x295ce
jmp 0x1ae90
callq 0xace4
leaq 0xed84(%rip), %rsi      # 0x29c0d
leaq 0xe746(%rip), %rcx      # 0x295d6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: block
static js_Ast *block(js_State *J)
{
	js_Ast *a;
	int line = J->lexline;
	jsP_expect(J, '{');
	a = statementlist(J);
	jsP_expect(J, '}');
	return STM1(BLOCK, a);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x74(%rdi), %edi
cmpl $0x7b, %edi
jne 0x1af21
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b198
movl 0x74(%rbx), %edi
cmpl $0x7d, %edi
jne 0x1af36
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
andq $0x0, (%rsp)
pushq $0x47
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xace4
leaq 0xece0(%rip), %rsi      # 0x29c0d
leaq 0xe69a(%rip), %rcx      # 0x295ce
jmp 0x1af49
callq 0xace4
leaq 0xeccb(%rip), %rsi      # 0x29c0d
leaq 0xe68d(%rip), %rcx      # 0x295d6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: vardeclist
static js_Ast *vardeclist(js_State *J, int notin)
{
	js_Ast *head, *tail;
	head = tail = LIST(vardec(J, notin));
	while (jsP_accept(J, ','))
		tail = tail->b = LIST(vardec(J, notin));
	return jsP_list(head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1b235
andq $0x0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r15
movq %rax, %r12
cmpl $0x2c, 0x74(%r14)
jne 0x1afc2
movq %r14, %rdi
callq 0xd822
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b235
andq $0x0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, 0x18(%r12)
jmp 0x1af85
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1a4a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: semicolon
static void semicolon(js_State *J)
{
	if (J->lookahead == ';') {
		jsP_next(J);
		return;
	}
	if (J->newline || J->lookahead == '}' || J->lookahead == 0)
		return;
	jsP_error(J, "unexpected token: %s (expected ';')", jsY_tokenstring(J->lookahead));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x74(%rdi), %edi
cmpl $0x3b, %edi
jne 0x1afea
movq %rbx, %rdi
popq %rbx
jmp 0xd822
cmpl $0x0, 0x6c(%rbx)
jne 0x1aff9
testl %edi, %edi
je 0x1aff9
cmpl $0x7d, %edi
jne 0x1affb
popq %rbx
retq
callq 0xace4
leaq 0xed5b(%rip), %rsi      # 0x29d62
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: expression
static js_Ast *expression(js_State *J, int notin)
{
	js_Ast *a = assignment(J, notin);
	SAVEREC();
	int line = J->lexline;
	while (jsP_accept(J, ',')) {
		INCREC();
		a = EXP2(COMMA, a, assignment(J, notin));
		line = J->lexline;
	}
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b291
movq %rax, %r14
movl 0x70(%rbx), %r13d
pushq $0x45
popq %r15
cmpl $0x2c, 0x74(%rbx)
jne 0x1b081
movl 0x60(%rbx), %r12d
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b097
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b291
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
jmp 0x1b034
movl %r13d, 0x70(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xebf7(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: jsP_warning
static void jsP_warning(js_State *J, const char *fmt, ...)
{
	va_list ap;
	char buf[512];
	char msg[256];

	va_start(ap, fmt);
	vsnprintf(msg, sizeof msg, fmt, ap);
	va_end(ap);

	snprintf(buf, sizeof buf, "%s:%d: warning: %s", J->filename, J->lexline, msg);
	js_report(J, buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
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 0x1b115
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 0xeba8(%rip), %rdx      # 0x29ce4
leaq 0xd0(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x32b0
movq 0x38(%rbx), %rcx
movl 0x60(%rbx), %r8d
leaq 0xecb4(%rip), %rdx      # 0x29e14
leaq 0x1d0(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %r9
xorl %eax, %eax
callq 0x3080
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1b18d
leaq 0x1d0(%rsp), %rsi
movq %rbx, %rdi
callq *%rax
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r14
retq