LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsdtoa.c
// Function: digit_gen
static void digit_gen(diy_fp_t Mp, diy_fp_t delta, char* buffer, int* len, int* K)
{
	uint32_t div, p1;
	uint64_t p2;
	int d,kappa;
	diy_fp_t one;
	one.f = ((uint64_t) 1) << -Mp.e; one.e = Mp.e;
	p1 = Mp.f >> -one.e;
	p2 = Mp.f & (one.f - 1);
	*len = 0; kappa = 3; div = TEN2;
	while (kappa > 0) {
		d = p1 / div;
		if (d || *len) buffer[(*len)++] = '0' + d;
		p1 %= div; kappa--; div /= 10;
		if ((((uint64_t)p1)<<-one.e)+p2 <= delta.f) {
			*K += kappa; return;
		}
	}
	do {
		p2 *= 10;
		d = p2 >> -one.e;
		if (d || *len) buffer[(*len)++] = '0' + d;
		p2 &= one.f - 1; kappa--; delta.f *= 10;
	} while (p2 > delta.f);
	*K += kappa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x58(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subl -0x50(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x3, -0x48(%rbp)
movl $0x64, -0x34(%rbp)
cmpl $0x0, -0x48(%rbp)
jle 0xb509
movl -0x38(%rbp), %eax
xorl %edx, %edx
divl -0x34(%rbp)
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0xb499
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb4b8
movl -0x44(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x38(%rbp)
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x34(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
xorl %ecx, %ecx
subl -0x50(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xb504
movl -0x48(%rbp), %ecx
movq 0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xb58a
jmp 0xb475
jmp 0xb50b
imulq $0xa, -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subl -0x50(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0xb534
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb553
movl -0x44(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x58(%rbp), %rax
subq $0x1, %rax
andq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xb50b
movl -0x48(%rbp), %ecx
movq 0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jserror.c
// Function: js_newerrorx
static void js_newerrorx(js_State *J, const char *message, js_Object *prototype)
{
	js_pushobject(J, jsV_newobject(J, JS_CERROR, prototype));
	js_pushstring(J, message);
	js_setproperty(J, -2, "message");
	if (jsB_stacktrace(J, 0))
		js_setproperty(J, -2, "stack");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x5, %esi
callq 0x6bc0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x4870
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30eae(%rip), %rdx     # 0x3c985
callq 0x4560
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x24260
cmpl $0x0, %eax
je 0xbb01
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30e91(%rip), %rdx     # 0x3c98d
callq 0x4560
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jserror.c
// Function: Ep_toString
static void Ep_toString(js_State *J)
{
	const char *name = "Error";
	const char *message = "";

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2f666(%rip), %rax     # 0x3b829
movq %rax, -0x10(%rbp)
leaq 0x3086e(%rip), %rax     # 0x3ca3c
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11730
cmpl $0x0, %eax
jne 0xc1f7
movq -0x8(%rbp), %rdi
leaq 0x315ad(%rip), %rsi     # 0x3d79d
movb $0x0, %al
callq 0xbfe0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x2f5ca(%rip), %rdx     # 0x3b7ce
callq 0x17710
cmpl $0x0, %eax
je 0xc220
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14b80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x30758(%rip), %rdx     # 0x3c985
callq 0x17710
cmpl $0x0, %eax
je 0xc249
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14b80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc264
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13880
jmp 0xc2bd
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc27f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13880
jmp 0xc2bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
leaq 0x2f086(%rip), %rsi     # 0x3b31d
callq 0x13880
movq -0x8(%rbp), %rdi
callq 0x1bdd0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
callq 0x1bdd0
jmp 0xc2bd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_apply
static void Fp_apply(js_State *J)
{
	int i, n;

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

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

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

	js_call(J, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15290
cmpl $0x0, %eax
jne 0xc6ae
movq -0x8(%rbp), %rdi
leaq 0x3028b(%rip), %rsi     # 0x3c932
movb $0x0, %al
callq 0xbfe0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x15130
cmpl $0x0, %eax
jne 0xc6ed
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x15100
cmpl $0x0, %eax
je 0xc6f6
movl $0x0, -0x10(%rbp)
jmp 0xc741
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4330
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xc714
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc73f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x2, %esi
callq 0x17aa0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc71b
jmp 0xc741
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x17ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_call
static void Fp_call(js_State *J)
{
	int i, top = js_gettop(J);

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

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

	js_call(J, top - 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15290
cmpl $0x0, %eax
jne 0xc79a
movq -0x8(%rbp), %rdi
leaq 0x3019f(%rip), %rsi     # 0x3c932
movb $0x0, %al
callq 0xbfe0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc7c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14410
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc7a1
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
subl $0x2, %esi
callq 0x17ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsfunction.c
// Function: Fp_bind
static void Fp_bind(js_State *J)
{
	int i, top = js_gettop(J);
	int n;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15290
cmpl $0x0, %eax
jne 0xc81a
movq -0x8(%rbp), %rdi
leaq 0x3011f(%rip), %rsi     # 0x3c932
movb $0x0, %al
callq 0xbfe0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4330
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jle 0xc845
movl -0x10(%rbp), %ecx
subl $0x2, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xc84c
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x2efdf(%rip), %rdx     # 0x3b838
callq 0x4380
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %r8d
leaq 0x17c53(%rip), %rsi     # 0x244c0
leaq 0x17d5c(%rip), %rdx     # 0x245d0
leaq 0x30181(%rip), %rcx     # 0x3c9fc
callq 0x60e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30168(%rip), %rdx     # 0x3ca03
movl $0x7, %ecx
callq 0x65c0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30153(%rip), %rdx     # 0x3ca16
movl $0x7, %ecx
callq 0x65c0
movq -0x8(%rbp), %rdi
callq 0x13830
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc910
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x2, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x13bb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc8dd
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30104(%rip), %rdx     # 0x3ca24
movl $0x7, %ecx
callq 0x65c0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ccxvii[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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14270
movq %rax, %rdi
callq 0x30e0
cmpl $0x0, %eax
je 0xc985
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
movq -0x8(%rbp), %rdi
callq 0x11b40
movq -0x8(%rbp), %rdi
callq 0x8cb0
cmpl $0x2, -0x10(%rbp)
jle 0xca07
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc9e6
cmpl $0x1, -0xc(%rbp)
jle 0xc9b7
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x2c, %edx
callq 0xd910
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14b80
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq -0x18(%rbp), %rsi
callq 0xda70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc992
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x29, %edx
callq 0xd910
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xd910
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
subl $0x1, %esi
callq 0x150d0
cmpl $0x0, %eax
je 0xca30
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
subl $0x1, %esi
callq 0x14b80
movq %rax, -0x40(%rbp)
jmp 0xca3d
leaq 0x30005(%rip), %rax     # 0x3ca3c
movq %rax, -0x40(%rbp)
jmp 0xca3d
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xca62
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0xca6a
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xca6a
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x266b3(%rip), %rsi     # 0x33130
callq 0x12170
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8e70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14a10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
movq -0x8(%rbp), %rdi
callq 0x11b40
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdx
callq 0x1b8e0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsgc.c
// Function: jsG_markstack
static void jsG_markstack(js_State *J, int mark)
{
	js_Value *v = J->stack;
	int n = J->top;
	while (n--) {
		if (v->t.type == JS_TMEMSTR && v->u.memstr->gcmark != mark)
			v->u.memstr->gcmark = mark;
		if (v->t.type == JS_TOBJECT && v->u.object->gcmark != mark)
			jsG_markobject(J, mark, v->u.object);
		++v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xd2f4
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x6, %eax
jne 0xd2b7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xd2b7
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x7, %eax
jne 0xd2e6
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x60(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xd2e6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0xd210
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xd27b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x60(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xd341
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xd210
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xd368
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd313
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsgc.c
// Function: jsG_freefunction
static void jsG_freefunction(js_State *J, js_Function *fun)
{
	js_free(J, fun->funtab);
	js_free(J, fun->vartab);
	js_free(J, fun->code);
	js_free(J, fun);
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0xd5ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x24860
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0xd635
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xd710
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1d040
movq -0x10(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xd66a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0xd668
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xd710
jmp 0xd66a
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xd68e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0xd68e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xd710
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0xd6a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x248c0
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jne 0xd6d2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xd6d2
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xd6fc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xd6fc
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd710
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsgc.c
// Function: js_freestate
void js_freestate(js_State *J)
{
	js_Function *fun, *nextfun;
	js_Object *obj, *nextobj;
	js_Environment *env, *nextenv;
	js_String *str, *nextstr;

	if (!J)
		return;

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

	jsS_freestrings(J);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd798
jmp 0xd8ca
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd7d1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xd540
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xd7a7
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd80a
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd570
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xd7e0
movq -0x8(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd843
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd5d0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xd819
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xd87b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xd710
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xd852
movq -0x8(%rbp), %rdi
callq 0xd8d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xd710
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x148(%rcx), %rsi
xorl %edx, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsintern.c
// Function: js_putc
void js_putc(js_State *J, js_Buffer **sbp, int c)
{
	js_Buffer *sb = *sbp;
	if (!sb) {
		sb = js_malloc(J, sizeof *sb);
		sb->n = 0;
		sb->m = sizeof sb->s;
		*sbp = sb;
	} else if (sb->n == sb->m) {
		sb = js_realloc(J, sb, (sb->m *= 2) + soffsetof(js_Buffer, s));
		*sbp = sb;
	}
	sb->s[sb->n++] = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd969
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0xd9d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x40, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd9a5
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xd9a3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
shll %edx
movl %edx, 0x4(%rax)
addl $0x8, %edx
callq 0xda20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd9a5
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_malloc
void *js_malloc(js_State *J, int size)
{
	void *ptr = J->alloc(J->actx, NULL, size);
	if (!ptr)
		js_outofmemory(J);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xda0b
movq -0x8(%rbp), %rdi
callq 0x14c30
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_realloc
void *js_realloc(js_State *J, void *ptr, int size)
{
	ptr = J->alloc(J->actx, ptr, size);
	if (!ptr)
		js_outofmemory(J);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xda5f
movq -0x8(%rbp), %rdi
callq 0x14c30
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsintern.c
// Function: jsS_dumpstrings
void jsS_dumpstrings(js_State *J)
{
	js_StringNode *root = J->strings;
	printf("interned strings {\n");
	if (root && root != &jsS_sentinel)
		dumpstringnode(root, 1);
	printf("}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x2ddd7(%rip), %rdi     # 0x3b906
movb $0x0, %al
callq 0x3030
cmpq $0x0, -0x10(%rbp)
je 0xdb58
leaq 0x39734(%rip), %rax     # 0x47278
cmpq %rax, -0x10(%rbp)
je 0xdb58
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xdb70
leaq 0x2ddbb(%rip), %rdi     # 0x3b91a
movb $0x0, %al
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsintern.c
// Function: dumpstringnode
static void dumpstringnode(js_StringNode *node, int level)
{
	int i;
	if (node->left != &jsS_sentinel)
		dumpstringnode(node->left, level + 1);
	printf("%d: ", node->level);
	for (i = 0; i < level; ++i)
		putchar('\t');
	printf("'%s'\n", node->string);
	if (node->right != &jsS_sentinel)
		dumpstringnode(node->right, level + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
leaq 0x396ee(%rip), %rcx     # 0x47278
cmpq %rcx, (%rax)
je 0xdba1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xdb70
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x2d76c(%rip), %rdi     # 0x3b31b
movb $0x0, %al
callq 0x3030
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xdbda
movl $0x9, %edi
callq 0x3130
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xdbbd
movq -0x8(%rbp), %rsi
addq $0x14, %rsi
leaq 0x2ee4e(%rip), %rdi     # 0x3ca37
movb $0x0, %al
callq 0x3030
movq -0x8(%rbp), %rax
leaq 0x3967d(%rip), %rcx     # 0x47278
cmpq %rcx, 0x8(%rax)
je 0xdc14
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xdb70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsintern.c
// Function: js_intern
const char *js_intern(js_State *J, const char *s)
{
	const char *result;
	if (!J->strings)
		J->strings = &jsS_sentinel;
	J->strings = jsS_insert(J, J->strings, s, &result);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xdcba
movq -0x8(%rbp), %rax
leaq 0x395c2(%rip), %rcx     # 0x47278
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0xdcf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsintern.c
// Function: jsS_insert
static js_StringNode *jsS_insert(js_State *J, js_StringNode *node, const char *string, const char **result)
{
	if (node != &jsS_sentinel) {
		int c = strcmp(string, node->string);
		if (c < 0)
			node->left = jsS_insert(J, node->left, string, result);
		else if (c > 0)
			node->right = jsS_insert(J, node->right, string, result);
		else
			return *result = node->string, node;
		node = jsS_skew(node);
		node = jsS_split(node);
		return node;
	}
	return jsS_newstringnode(J, string, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x39569(%rip), %rax     # 0x47278
cmpq %rax, -0x18(%rbp)
je 0xddc2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x14, %rsi
callq 0x32d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0xdd57
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xdcf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xdd9e
cmpl $0x0, -0x2c(%rbp)
jle 0xdd83
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xdcf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdd9c
movq -0x18(%rbp), %rcx
addq $0x14, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xddd7
jmp 0xdd9e
movq -0x18(%rbp), %rdi
callq 0x24900
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xddd7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x249c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_tokenstring
const char *jsY_tokenstring(int token)
{
	if (token >= 0 && token < (int)nelem(tokenstring))
		if (tokenstring[token])
			return tokenstring[token];
	return "<unknown>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xde2f
cmpl $0x139, -0xc(%rbp)      # imm = 0x139
jge 0xde2f
movslq -0xc(%rbp), %rcx
leaq 0x3947f(%rip), %rax     # 0x47290
cmpq $0x0, (%rax,%rcx,8)
je 0xde2d
movslq -0xc(%rbp), %rcx
leaq 0x3946d(%rip), %rax     # 0x47290
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xde3a
jmp 0xde2f
leaq 0x2dae7(%rip), %rax     # 0x3b91d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_findword
int jsY_findword(const char *s, const char **list, int num)
{
	int l = 0;
	int r = num - 1;
	while (l <= r) {
		int m = (l + r) >> 1;
		int c = strcmp(s, list[m]);
		if (c < 0)
			r = m - 1;
		else if (c > 0)
			l = m + 1;
		else
			return m;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xdebc
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
sarl %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x32d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0xde9f
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdeba
cmpl $0x0, -0x2c(%rbp)
jle 0xdeb0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdeb8
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdec3
jmp 0xdeba
jmp 0xde63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_tohex
int jsY_tohex(int c)
{
	if (c >= '0' && c <= '9') return c - '0';
	if (c >= 'a' && c <= 'f') return c - 'a' + 0xA;
	if (c >= 'A' && c <= 'F') return c - 'A' + 0xA;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x30, -0x8(%rbp)
jl 0xdffe
cmpl $0x39, -0x8(%rbp)
jg 0xdffe
movl -0x8(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0xe039
cmpl $0x61, -0x8(%rbp)
jl 0xe018
cmpl $0x66, -0x8(%rbp)
jg 0xe018
movl -0x8(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0xe039
cmpl $0x41, -0x8(%rbp)
jl 0xe032
cmpl $0x46, -0x8(%rbp)
jg 0xe032
movl -0x8(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0xe039
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_initlex
void jsY_initlex(js_State *J, const char *filename, const char *source)
{
	J->filename = filename;
	J->source = source;
	J->line = 1;
	J->lasttoken = 0;
	jsY_next(J); /* load first lookahead character */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x8(%rbp), %rdi
callq 0xe0a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_next
static void jsY_next(js_State *J)
{
	Rune c;
	if (*J->source == 0) {
		J->lexchar = EOF;
		return;
	}
	J->source += chartorune(&c, J->source);
	/* consume CR LF as one unit */
	if (c == '\r' && *J->source == '\n')
		++J->source;
	if (jsY_isnewline(c)) {
		J->line++;
		c = '\n';
	}
	J->lexchar = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xe0c9
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
jmp 0xe13f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0xc(%rbp), %rdi
callq 0x19d20
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x40(%rax)
cmpl $0xd, -0xc(%rbp)
jne 0xe114
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xe114
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movl -0xc(%rbp), %edi
callq 0xdf30
cmpl $0x0, %eax
je 0xe135
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movl $0xa, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: lexjsonstring
static int lexjsonstring(js_State *J)
{
	const char *s;

	textinit(J);

	while (J->lexchar != '"') {
		if (J->lexchar == EOF)
			jsY_error(J, "unterminated string");
		else if (J->lexchar < 32)
			jsY_error(J, "invalid control character in string");
		else if (jsY_accept(J, '\\'))
			lexjsonescape(J);
		else {
			textpush(J, J->lexchar);
			jsY_next(J);
		}
	}
	jsY_expect(J, '"');

	s = textend(J);

	J->text = js_intern(J, s);
	return TK_STRING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25540
movq -0x8(%rbp), %rax
cmpl $0x22, 0x64(%rax)
je 0xf1db
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
jne 0xf16f
movq -0x8(%rbp), %rdi
leaq 0x2def8(%rip), %rsi     # 0x3d060
movb $0x0, %al
callq 0xf250
movq -0x8(%rbp), %rax
cmpl $0x20, 0x64(%rax)
jge 0xf18b
movq -0x8(%rbp), %rdi
leaq 0x2def0(%rip), %rsi     # 0x3d074
movb $0x0, %al
callq 0xf250
movq -0x8(%rbp), %rax
cmpl $0x5c, 0x64(%rax)
jne 0xf1a6
movq -0x8(%rbp), %rdi
callq 0xe0a0
movb $0x1, %al
testb $0x1, %al
jne 0xf1ae
jmp 0xf1b9
xorl %eax, %eax
testb $0x1, %al
jne 0xf1ae
jmp 0xf1b9
movq -0x8(%rbp), %rdi
callq 0x25ba0
jmp 0xf1d2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x25590
movq -0x8(%rbp), %rdi
callq 0xe0a0
jmp 0xf1d4
jmp 0xf1d6
jmp 0xf145
movq -0x8(%rbp), %rax
cmpl $0x22, 0x64(%rax)
jne 0xf1f6
movq -0x8(%rbp), %rdi
callq 0xe0a0
movb $0x1, %al
testb $0x1, %al
jne 0xf215
jmp 0xf1fe
xorl %eax, %eax
testb $0x1, %al
jne 0xf215
jmp 0xf1fe
movq -0x8(%rbp), %rdi
leaq 0x2c71e(%rip), %rsi     # 0x3b927
movl $0x22, %edx
movb $0x0, %al
callq 0xf250
movq -0x8(%rbp), %rdi
callq 0x256e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdc90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movl $0x102, %eax            # imm = 0x102
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jslex.c
// Function: jsY_error
static void jsY_error(js_State *J, const char *fmt, ...)
{
	va_list ap;
	char buf[512];
	char msgbuf[256];

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp            # imm = 0x3E0
testb %al, %al
je 0xf297
movaps %xmm0, -0x3b0(%rbp)
movaps %xmm1, -0x3a0(%rbp)
movaps %xmm2, -0x390(%rbp)
movaps %xmm3, -0x380(%rbp)
movaps %xmm4, -0x370(%rbp)
movaps %xmm5, -0x360(%rbp)
movaps %xmm6, -0x350(%rbp)
movaps %xmm7, -0x340(%rbp)
movq %r9, -0x3b8(%rbp)
movq %r8, -0x3c0(%rbp)
movq %rcx, -0x3c8(%rbp)
movq %rdx, -0x3d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x3e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x330(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x3290
leaq -0x30(%rbp), %rax
leaq -0x230(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x60(%rax), %r8d
movl $0x100, %esi            # imm = 0x100
leaq 0x2bff9(%rip), %rdx     # 0x3b318
movb $0x0, %al
callq 0x3080
leaq -0x230(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x3250
movq -0x8(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x8c80
movq -0x8(%rbp), %rdi
callq 0x8cb0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsmath.c
// Function: Math_init_random
static void Math_init_random(js_State *J)
{
	/* Pick initial seed by scrambling current time with Xorshift. */
	/* Marsaglia (2003). Xorshift RNGs. */
	J->seed = time(0) + 123;
	J->seed ^= J->seed << 13;
	J->seed ^= J->seed >> 17;
	J->seed ^= J->seed << 5;
	J->seed %= 0x7fffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x33c0
addq $0x7b, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %ecx
shll $0xd, %ecx
movq -0x8(%rbp), %rax
xorl 0x108(%rax), %ecx
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %ecx
shrl $0x11, %ecx
movq -0x8(%rbp), %rax
xorl 0x108(%rax), %ecx
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %ecx
shll $0x5, %ecx
movq -0x8(%rbp), %rax
xorl 0x108(%rax), %ecx
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x108(%rax), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ecx
movq -0x10(%rbp), %rax
movl %edx, 0x108(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsmath.c
// Function: Math_max
static void Math_max(js_State *J)
{
	int i, n = js_gettop(J);
	double x = -INFINITY;
	for (i = 1; i < n; ++i) {
		double y = js_tonumber(J, i);
		if (isnan(y)) {
			x = y;
			break;
		}
		if (signbit(x) == signbit(y))
			x = x > y ? x : y;
		else if (signbit(x))
			x = y;
	}
	js_pushnumber(J, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movsd 0x23d48(%rip), %xmm0    # 0x33418
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf7a5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x15750
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0xf70b
jmp 0xf71a
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xf7a5
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rcx
cmpq $0x0, %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xf779
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xf763
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xf76d
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xf795
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
jge 0xf793
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xf795
jmp 0xf797
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf6dc
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x44d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsmath.c
// Function: Math_pow
static void Math_pow(js_State *J)
{
	double x = js_tonumber(J, 1);
	double y = js_tonumber(J, 2);
	if (!isfinite(y) && fabs(x) == 1)
		js_pushnumber(J, NAN);
	else
		js_pushnumber(J, pow(x,y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15750
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x15750
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0xf960
movsd -0x10(%rbp), %xmm0
movaps 0x2b737(%rip), %xmm1    # 0x3b070
pand %xmm1, %xmm0
movsd 0x23b2b(%rip), %xmm1    # 0x33470
ucomisd %xmm1, %xmm0
jne 0xf960
jp 0xf960
movq -0x8(%rbp), %rdi
movsd 0x23ab7(%rip), %xmm0    # 0x33410
callq 0x44d0
jmp 0xf980
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3380
movq -0x20(%rbp), %rdi
callq 0x44d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsnumber.c
// Function: Np_toFixed
static void Np_toFixed(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	int width = js_tointeger(J, 1);
	char buf[32];
	double x;
	if (self->type != JS_CNUMBER) js_typeerror(J, "not a number");
	if (width < 0) js_rangeerror(J, "precision %d out of range", width);
	if (width > 20) js_rangeerror(J, "precision %d out of range", width);
	x = self->u.number;
	if (isnan(x) || isinf(x) || x <= -1e21 || x >= 1e21)
		js_pushstring(J, jsV_numbertostring(J, buf, x));
	else
		numtostr(J, "%.*f", width, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x11760
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x43c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
je 0x101c7
movq -0x8(%rbp), %rdi
leaq 0x2ced8(%rip), %rsi     # 0x3d098
movb $0x0, %al
callq 0xbfe0
cmpl $0x0, -0x14(%rbp)
jge 0x101e2
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2ced8(%rip), %rsi     # 0x3d0b3
movb $0x0, %al
callq 0xbd10
cmpl $0x14, -0x14(%rbp)
jle 0x101fd
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2cebd(%rip), %rsi     # 0x3d0b3
movb $0x0, %al
callq 0xbd10
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x10286
movsd -0x48(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x2ae46(%rip), %xmm2    # 0x3b070
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x231bc(%rip), %xmm1    # 0x33408
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0x10286
movsd 0x23254(%rip), %xmm0    # 0x334c0
ucomisd -0x48(%rbp), %xmm0
jae 0x10286
movsd -0x48(%rbp), %xmm0
movsd 0x23248(%rip), %xmm1    # 0x334c8
ucomisd %xmm1, %xmm0
jb 0x102ae
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movsd -0x48(%rbp), %xmm0
callq 0x13040
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x13880
jmp 0x102c6
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movsd -0x48(%rbp), %xmm0
leaq 0x2ce0c(%rip), %rsi     # 0x3d0cd
callq 0x25ef0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsnumber.c
// Function: Np_toExponential
static void Np_toExponential(js_State *J)
{
	js_Object *self = js_toobject(J, 0);
	int width = js_tointeger(J, 1);
	char buf[32];
	double x;
	if (self->type != JS_CNUMBER) js_typeerror(J, "not a number");
	if (width < 0) js_rangeerror(J, "precision %d out of range", width);
	if (width > 20) js_rangeerror(J, "precision %d out of range", width);
	x = self->u.number;
	if (isnan(x) || isinf(x))
		js_pushstring(J, jsV_numbertostring(J, buf, x));
	else
		numtostr(J, "%.*e", width, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x11760
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x43c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
je 0x10317
movq -0x8(%rbp), %rdi
leaq 0x2cd88(%rip), %rsi     # 0x3d098
movb $0x0, %al
callq 0xbfe0
cmpl $0x0, -0x14(%rbp)
jge 0x10332
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2cd88(%rip), %rsi     # 0x3d0b3
movb $0x0, %al
callq 0xbd10
cmpl $0x14, -0x14(%rbp)
jle 0x1034d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2cd6d(%rip), %rsi     # 0x3d0b3
movb $0x0, %al
callq 0xbd10
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x103b4
movsd -0x48(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x2acf6(%rip), %xmm2    # 0x3b070
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x2306c(%rip), %xmm1    # 0x33408
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x103dc
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movsd -0x48(%rbp), %xmm0
callq 0x13040
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x13880
jmp 0x103f4
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movsd -0x48(%rbp), %xmm0
leaq 0x2cce8(%rip), %rsi     # 0x3d0d7
callq 0x25ef0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)