LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_savetrypc
void *js_savetrypc(js_State *J, js_Instruction *pc)
{
	if (J->trytop == JS_TRYLIMIT)
		js_trystackoverflow(J);
	J->trybuf[J->trytop].E = J->E;
	J->trybuf[J->trytop].envtop = J->envtop;
	J->trybuf[J->trytop].tracetop = J->tracetop;
	J->trybuf[J->trytop].top = J->top;
	J->trybuf[J->trytop].bot = J->bot;
	J->trybuf[J->trytop].strict = J->strict;
	J->trybuf[J->trytop].pc = pc;
	return J->trybuf[J->trytop++].buf;
}

// Assembly:
movslq 0x8198(%rdi), %rcx
cmpq $0x40, %rcx
je 0x17702
movq 0x130(%rdi), %rdx
imulq $0xf0, %rcx, %rax
addq %rdi, %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq %rdx, 0xc8(%rax)
movl 0x188(%rdi), %edx
movl %edx, 0xd0(%rax)
movl 0x2190(%rdi), %edx
movl %edx, 0xd4(%rax)
movl 0x140(%rdi), %edx
movl %edx, 0xd8(%rax)
movl 0x144(%rdi), %edx
movl %edx, 0xdc(%rax)
movl 0x34(%rdi), %edx
movl %edx, 0xe0(%rax)
movq %rsi, 0xe8(%rax)
incl %ecx
movl %ecx, 0x8198(%rdi)
retq
pushq %rax
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x1c0f8(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_ploadstring
int js_ploadstring(js_State *J, const char *filename, const char *source)
{
	if (js_ptry(J))
		return 1;
	if (js_try(J))
		return 1;
	js_loadstring(J, filename, source);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x17a5f
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1bddd(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movl $0x1, %ebp
jmp 0x17aa2
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
movl $0x1, %ebp
testl %eax, %eax
jne 0x17aa2
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x180dd
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17aaf
decl %eax
movl %eax, 0x8198(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bd53(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_ploadfile
int js_ploadfile(js_State *J, const char *filename)
{
	if (js_ptry(J))
		return 1;
	if (js_try(J))
		return 1;
	js_loadfile(J, filename);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x17b18
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1bd24(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movl $0x1, %ecx
jmp 0x17b53
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
movl $0x1, %ecx
testl %eax, %eax
jne 0x17b53
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17b6e
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17b5d
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bca5(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_trystring
const char *js_trystring(js_State *J, int idx, const char *error)
{
	const char *s;
	if (js_ptry(J)) {
		js_pop(J, 1);
		return error;
	}
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	s = js_tostring(J, idx);
	js_endtry(J);
	return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x17dfc
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1ba43(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x17e62
jmp 0x17e2c
movl %esi, %ebp
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17e43
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x17e62
movl %eax, 0x140(%rbx)
leaq 0x1b935(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14963
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x17e6a
movq %rax, %r14
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b998(%rip), %rsi     # 0x33809
jmp 0x17e39
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_trynumber
double js_trynumber(js_State *J, int idx, double error)
{
	double v;
	if (js_ptry(J)) {
		js_pop(J, 1);
		return error;
	}
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	v = js_tonumber(J, idx);
	js_endtry(J);
	return v;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x17ec6
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1b979(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x17f33
jmp 0x17f00
movl %esi, %ebp
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17f17
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
movsd (%rsp), %xmm0
cmpl %eax, %ecx
jg 0x17f33
movl %eax, 0x140(%rbx)
leaq 0x1b861(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15111
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17f3a
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1b8c8(%rip), %rsi     # 0x33809
jmp 0x17f0d
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_tryinteger
int js_tryinteger(js_State *J, int idx, int error)
{
	int v;
	if (js_ptry(J)) {
		js_pop(J, 1);
		return error;
	}
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	v = js_tointeger(J, idx);
	js_endtry(J);
	return v;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x17f99
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1b8a6(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x18000
jmp 0x17fca
movl %esi, %r14d
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17fe1
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x18000
movl %eax, 0x140(%rbx)
leaq 0x1b797(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
movq %rbx, %rdi
movl %r14d, %esi
callq 0x409b
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x18007
movl %eax, %ebp
decl %ecx
movl %ecx, 0x8198(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b7fb(%rip), %rsi     # 0x33809
jmp 0x17fd7
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_tryboolean
int js_tryboolean(js_State *J, int idx, int error)
{
	int v;
	if (js_ptry(J)) {
		js_pop(J, 1);
		return error;
	}
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	v = js_toboolean(J, idx);
	js_endtry(J);
	return v;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x18066
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1b7d9(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x180cd
jmp 0x18097
movl %esi, %r14d
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x180ae
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x180cd
movl %eax, 0x140(%rbx)
leaq 0x1b6ca(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
movl 0x8198(%rbx), %ebp
testl %ebp, %ebp
je 0x180d4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x15085
decl %ebp
movl %ebp, 0x8198(%rbx)
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b72e(%rip), %rsi     # 0x33809
jmp 0x180a4
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_loadstringx
static void js_loadstringx(js_State *J, const char *filename, const char *source, int iseval)
{
	js_Ast *P;
	js_Function *F;

	if (js_try(J)) {
		jsP_freeparse(J);
		js_throw(J);
	}

	P = jsP_parse(J, filename, source);
	F = jsC_compilescript(J, P, iseval ? J->strict : J->default_strict);
	jsP_freeparse(J);
	js_newscript(J, F, iseval ? (J->strict ? J->E : NULL) : J->GE);

	js_endtry(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
movq %rbx, %rdi
testl %eax, %eax
jne 0x181a0
movq %r15, %rsi
movq %r14, %rdx
callq 0x120f8
movq %rax, %r8
xorl %ecx, %ecx
testl %ebp, %ebp
setne %dl
movb %dl, %cl
movl 0x30(%rbx,%rcx,4), %r10d
testq %rax, %rax
je 0x1812e
movl 0x4(%r8), %esi
jmp 0x18130
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rbx, %rdi
movq %rcx, %rdx
movl $0x1, %r9d
pushq $0x0
movl %r10d, %eax
pushq %rax
callq 0x8fb5
addq $0x10, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x12096
testl %ebp, %ebp
je 0x1816f
movl $0x130, %eax            # imm = 0x130
cmpl $0x0, 0x34(%rbx)
jne 0x18174
xorl %eax, %eax
movl %eax, %edx
jmp 0x18178
movl $0x138, %eax            # imm = 0x138
movq (%rbx,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a75b
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x181ad
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x12096
movq %rbx, %rdi
callq 0x8ec6
leaq 0x1b655(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_dostring
int js_dostring(js_State *J, const char *source)
{
	if (js_ptry(J)) {
		js_report(J, "exception stack overflow");
		js_pop(J, 1);
		return 1;
	}
	if (js_try(J)) {
		js_report(J, js_trystring(J, -1, "Error"));
		js_pop(J, 1);
		return 1;
	}
	js_loadstring(J, "[string]", source);
	js_pushundefined(J);
	js_call(J, 0);
	js_pop(J, 1);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x1821f
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1b62d(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1825b
leaq 0x1b613(%rip), %rsi     # 0x3382b
movq %rbx, %rdi
callq *%rax
jmp 0x1825b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x18281
leaq 0x1af58(%rip), %rdx     # 0x33195
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x17da5
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1825b
movq %rax, %rsi
movq %rbx, %rdi
callq *%rcx
movl 0x140(%rbx), %edx
movl 0x144(%rbx), %eax
movl %edx, %ecx
decl %ecx
movl %ecx, 0x140(%rbx)
movl $0x1, %ecx
cmpl %eax, %edx
jle 0x182d9
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x12ea8(%rip), %rsi     # 0x2b130
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x180dd
movq %rbx, %rdi
callq 0x89b6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x16c25
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x182d9
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x182f0
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
jmp 0x1827a
movl %eax, 0x140(%rbx)
leaq 0x1b488(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
leaq 0x1b512(%rip), %rsi     # 0x33809
jmp 0x182e6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstate.c
// Function: js_dofile
int js_dofile(js_State *J, const char *filename)
{
	if (js_ptry(J)) {
		js_report(J, "exception stack overflow");
		js_pop(J, 1);
		return 1;
	}
	if (js_try(J)) {
		js_report(J, js_trystring(J, -1, "Error"));
		js_pop(J, 1);
		return 1;
	}
	js_loadfile(J, filename);
	js_pushundefined(J);
	js_call(J, 0);
	js_pop(J, 1);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x8198(%rdi)
jne 0x1835a
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
leaq 0x1b4f2(%rip), %rdx     # 0x3382b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x18396
leaq 0x1b4d8(%rip), %rsi     # 0x3382b
movq %rbx, %rdi
callq *%rax
jmp 0x18396
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x183bf
leaq 0x1ae1d(%rip), %rdx     # 0x33195
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x17da5
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x18396
movq %rax, %rsi
movq %rbx, %rdi
callq *%rcx
movl 0x140(%rbx), %edx
movl 0x144(%rbx), %eax
movl %edx, %ecx
decl %ecx
movl %ecx, 0x140(%rbx)
movl $0x1, %ecx
cmpl %eax, %edx
jle 0x1840c
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17b6e
movq %rbx, %rdi
callq 0x89b6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16c25
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x1840c
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x18423
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
jmp 0x183b5
movl %eax, 0x140(%rbx)
leaq 0x1b355(%rip), %rsi     # 0x3376e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
leaq 0x1b3df(%rip), %rsi     # 0x33809
jmp 0x18419
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: js_runeat
int js_runeat(js_State *J, const char *s, int i)
{
	Rune rune = EOF;
	while (i >= 0) {
		rune = *(unsigned char*)s;
		if (rune < Runeself) {
			if (rune == 0)
				return EOF;
			++s;
			--i;
		} else {
			s += chartorune(&rune, s);
			if (rune >= 0x10000)
				i -= 2;
			else
				--i;
		}
	}
	if (rune >= 0x10000) {
		/* high surrogate */
		if (i == -2)
			return 0xd800 + ((rune - 0x10000) >> 10);
		/* low surrogate */
		else
			return 0xdc00 + ((rune - 0x10000) & 0x3ff);
	}
	return rune;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
testl %edx, %edx
js 0x18716
movq %rsi, %r14
leaq 0xc(%rsp), %r15
movzbl (%r14), %eax
movl %eax, 0xc(%rsp)
testb %al, %al
js 0x186f3
je 0x18735
incq %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x18712
movq %r15, %rdi
movq %r14, %rsi
callq 0x18750
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
setge %al
notl %eax
addl %eax, %ebx
jns 0x186db
movl 0xc(%rsp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jl 0x18746
cmpl $-0x2, %ebx
jne 0x1873c
addl $0xffff0000, %eax       # imm = 0xFFFF0000
shrl $0xa, %eax
addl $0xd800, %eax           # imm = 0xD800
jmp 0x18746
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x18746
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xdc00, %eax           # imm = 0xDC00
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: js_utflen
int js_utflen(const char *s)
{
	int c;
	int n;
	Rune rune;

	n = 0;
	for(;;) {
		c = *(unsigned char *)s;
		if (c < Runeself) {
			if (c == 0)
				return n;
			s++;
			n++;
		} else {
			s += chartorune(&rune, s);
			if (rune >= 0x10000)
				n += 2;
			else
				n++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0xc(%rsp), %r15
cmpb $0x0, (%r14)
js 0x18860
je 0x18883
incq %r14
movl $0x1, %eax
jmp 0x1887f
movq %r15, %rdi
movq %r14, %rsi
callq 0x18750
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
setge %al
incl %eax
addl %eax, %ebx
jmp 0x1884e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_charAt
static void Sp_charAt(js_State *J)
{
	char buf[UTFmax + 1];
	const char *s = checkstring(J, 0);
	int pos = js_tointeger(J, 1);
	Rune rune = js_runeat(J, s, pos);
	if (rune >= 0) {
		buf[runetochar(buf, &rune)] = 0;
		js_pushstring(J, buf);
	} else {
		js_pushliteral(J, "");
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
movq %r14, %rsi
movl %eax, %edx
callq 0x186bc
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x1899c
leaq 0x13(%rsp), %r14
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1c76f
movl %eax, %eax
movb $0x0, 0x13(%rsp,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13665
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b9e3(%rip), %rsi     # 0x34386
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x67c1
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_charCodeAt
static void Sp_charCodeAt(js_State *J)
{
	const char *s = checkstring(J, 0);
	int pos = js_tointeger(J, 1);
	Rune rune = js_runeat(J, s, pos);
	if (rune >= 0)
		js_pushnumber(J, rune);
	else
		js_pushnumber(J, NAN);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
movq %r14, %rsi
movl %eax, %edx
callq 0x186bc
testl %eax, %eax
jns 0x189e6
movsd 0x12a6c(%rip), %xmm0    # 0x2b450
jmp 0x189ea
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_concat
static void Sp_concat(js_State *J)
{
	int i, top = js_gettop(J);
	int n;
	char * volatile out = NULL;
	const char *s;

	if (top == 1)
		return;

	s = checkstring(J, 0);
	n = 1 + strlen(s);

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

	if (n > JS_STRLIMIT)
		js_rangeerror(J, "invalid string length");
	out = js_malloc(J, n);
	strcpy(out, s);

	for (i = 1; i < top; ++i) {
		s = js_tostring(J, i);
		n += strlen(s);
		if (n > JS_STRLIMIT)
			js_rangeerror(J, "invalid string length");
		out = js_realloc(J, out, n);
		strcat(out, s);
	}

	js_pushstring(J, out);
	js_endtry(J);
	js_free(J, out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
movq $0x0, (%rsp)
cmpl $0x1, %r12d
je 0x18b08
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movq %rax, %rdi
callq 0x3200
movq %rax, %r15
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x18b28
movl %r15d, %ebp
incl %ebp
cmpl $0x10000001, %ebp       # imm = 0x10000001
jge 0x18b17
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe119
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x3310
cmpl $0x2, %r12d
jl 0x18ade
movl $0x1, %eax
movl %ebp, %r14d
movl %eax, %ebp
movl %r14d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14963
movq %rax, %r15
movq %rax, %rdi
callq 0x3200
movl %eax, %r14d
addl %r13d, %r14d
cmpl $0x10000001, %r14d      # imm = 0x10000001
jge 0x18b17
movq (%rsp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xe170
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3270
movl %ebp, %eax
incl %eax
movl %eax, %ebp
cmpl %eax, %r12d
jne 0x18a8d
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x13665
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x18b3c
decl %eax
movl %eax, 0x8198(%rbx)
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ac24(%rip), %rsi     # 0x33742
xorl %eax, %eax
movq %rbx, %rdi
callq 0xcab5
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x8ec6
leaq 0x1acc6(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_indexOf
static void Sp_indexOf(js_State *J)
{
	const char *haystack = checkstring(J, 0);
	const char *needle = js_tostring(J, 1);
	int pos = js_tointeger(J, 2);
	int len = strlen(needle);
	int k = 0;
	Rune rune;
	while (*haystack) {
		if (k >= pos && !strncmp(haystack, needle, len)) {
			js_pushnumber(J, k);
			return;
		}
		haystack += chartorune(&rune, haystack);
		++k;
	}
	js_pushnumber(J, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movl 0x144(%rbx), %eax
leaq 0x27885(%rip), %rsi     # 0x403f8
cmpl $-0x1, %eax
jl 0x18b8f
incl %eax
cmpl 0x140(%rbx), %eax
jge 0x18b8f
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
movl %eax, %ebp
movq %r15, %rdi
callq 0x3200
movsd 0x1288f(%rip), %xmm0    # 0x2b448
cmpb $0x0, (%r14)
je 0x18c19
movq %rbx, 0x8(%rsp)
movslq %eax, %r12
xorl %ebx, %ebx
leaq 0x14(%rsp), %r13
cmpl %ebp, %ebx
jl 0x18be4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3160
testl %eax, %eax
je 0x18c0d
movq %r13, %rdi
movq %r14, %rsi
callq 0x18750
movl %eax, %eax
incl %ebx
cmpb $0x0, (%r14,%rax)
leaq (%r14,%rax), %r14
jne 0x18bce
movq 0x8(%rsp), %rbx
movsd 0x1283d(%rip), %xmm0    # 0x2b448
jmp 0x18c19
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_lastIndexOf
static void Sp_lastIndexOf(js_State *J)
{
	const char *haystack = checkstring(J, 0);
	const char *needle = js_tostring(J, 1);
	int pos = js_isdefined(J, 2) ? js_tointeger(J, 2) : (int)strlen(haystack);
	int len = strlen(needle);
	int k = 0, last = -1;
	Rune rune;
	while (*haystack && k <= pos) {
		if (!strncmp(haystack, needle, len))
			last = k;
		haystack += chartorune(&rune, haystack);
		++k;
	}
	js_pushnumber(J, last);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movl 0x144(%rbx), %eax
leaq 0x277a3(%rip), %r12     # 0x403f8
movq %r12, %rsi
cmpl $-0x1, %eax
jl 0x18c77
incl %eax
movq %r12, %rsi
cmpl 0x140(%rbx), %eax
jge 0x18c77
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r15
movl 0x144(%rbx), %eax
cmpl $-0x2, %eax
jl 0x18ca6
addl $0x2, %eax
cmpl 0x140(%rbx), %eax
jge 0x18ca6
movl %eax, %r12d
shlq $0x4, %r12
addq 0x148(%rbx), %r12
cmpb $0x1, 0xf(%r12)
jne 0x18cbb
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
jmp 0x18ccb
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
movl %eax, %r12d
movq %r15, %rdi
callq 0x3200
cmpb $0x0, (%r14)
setne %cl
testl %r12d, %r12d
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x18d37
movq %rbx, 0x8(%rsp)
movslq %eax, %r13
xorl %ebp, %ebp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3160
testl %eax, %eax
cmovel %ebp, %ebx
leaq 0x14(%rsp), %rdi
movq %r14, %rsi
callq 0x18750
movl %eax, %eax
cmpb $0x0, (%r14,%rax)
je 0x18d2c
addq %rax, %r14
leal 0x1(%rbp), %eax
cmpl %r12d, %ebp
movl %eax, %ebp
jl 0x18cf6
cvtsi2sd %ebx, %xmm0
movq 0x8(%rsp), %rbx
jmp 0x18d3f
movsd 0x12709(%rip), %xmm0    # 0x2b448
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_search
static void Sp_search(js_State *J)
{
	js_Regexp *re;
	const char *text;
	Resub m;

	text = checkstring(J, 0);

	if (js_isregexp(J, 1))
		js_copy(J, 1);
	else if (js_isundefined(J, 1))
		js_newregexp(J, "", 0);
	else
		js_newregexp(J, js_tostring(J, 1), 0);

	re = js_toregexp(J, -1);

	if (!js_doregexec(J, re->prog, text, &m, 0))
		js_pushnumber(J, js_utfptrtoidx(text, m.sub[0].sp));
	else
		js_pushnumber(J, -1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movl 0x144(%rbx), %ecx
leal 0x1(%rcx), %eax
leaq 0x273cf(%rip), %rdx     # 0x403f8
cmpl $-0x1, %ecx
jl 0x19043
cmpl 0x140(%rbx), %eax
jge 0x19043
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x7, 0xf(%rdx)
jne 0x19060
movq (%rdx), %rdx
cmpl $0x9, (%rdx)
jne 0x19060
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
jmp 0x190cb
leaq 0x27391(%rip), %rdx     # 0x403f8
cmpl $-0x1, %ecx
jl 0x19081
cmpl 0x140(%rbx), %eax
jge 0x19081
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x1, 0xf(%rdx)
jne 0x19093
leaq 0x1b2f8(%rip), %rsi     # 0x34386
movq %rbx, %rdi
jmp 0x190c2
leaq 0x2735e(%rip), %rsi     # 0x403f8
cmpl $-0x1, %ecx
jl 0x190b4
cmpl 0x140(%rbx), %eax
jge 0x190b4
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1533b
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13250
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15720
movq (%rax), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x292cf
testl %eax, %eax
je 0x190fa
movsd 0x12350(%rip), %xmm0    # 0x2b448
jmp 0x1910b
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x137a2
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x4184
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_slice
static void Sp_slice(js_State *J)
{
	const char *str = checkstring(J, 0);
	int len = js_utflen(str);
	int s = js_tointeger(J, 1);
	int e = js_isdefined(J, 2) ? js_tointeger(J, 2) : len;

	s = s < 0 ? s + len : s;
	e = e < 0 ? e + len : e;

	s = s < 0 ? 0 : s > len ? len : s;
	e = e < 0 ? 0 : e > len ? len : e;

	if (s < e)
		Sp_substring_imp(J, str, s, e - s);
	else if (s > e)
		Sp_substring_imp(J, str, e, s - e);
	else
		js_pushliteral(J, "");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movq %rax, %rdi
callq 0x1883b
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
movl %eax, %r15d
movl 0x144(%rbx), %ecx
leaq 0x272a1(%rip), %rax     # 0x403f8
cmpl $-0x2, %ecx
jl 0x19174
addl $0x2, %ecx
cmpl 0x140(%rbx), %ecx
jge 0x19174
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
movl %ebp, %eax
je 0x19189
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
movl %r15d, %ecx
sarl $0x1f, %ecx
andl %ebp, %ecx
addl %r15d, %ecx
movl %eax, %esi
sarl $0x1f, %esi
andl %ebp, %esi
addl %eax, %esi
cmpl %ebp, %ecx
movl %ebp, %edx
cmovll %ecx, %edx
xorl %eax, %eax
testl %ecx, %ecx
cmovsl %eax, %edx
cmpl %ebp, %esi
cmovll %esi, %ebp
testl %esi, %esi
cmovsl %eax, %ebp
movl %edx, %ecx
subl %ebp, %ecx
jge 0x191c7
subl %edx, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
jmp 0x191d1
jle 0x191e0
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29d73
leaq 0x1b19f(%rip), %rsi     # 0x34386
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x67c1
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: Sp_trim
static void Sp_trim(js_State *J)
{
	const char *s, *e;
	s = checkstring(J, 0);
	while (istrim(*s))
		++s;
	e = s + strlen(s);
	while (e > s && istrim(e[-1]))
		--e;
	js_pushlstring(J, s, e - s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2925f
movq %rax, %r14
movq %rax, %r15
movzbl (%r15), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x19ba8
incq %r15
incl %r14d
jmp 0x19b94
cmpl $0x20, %eax
je 0x19ba0
movq %r15, %rdi
callq 0x3200
leaq (%r15,%rax), %rdx
testq %rax, %rax
jle 0x19bd9
movzbl -0x1(%rdx), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x19bd4
decq %rdx
cmpq %r15, %rdx
ja 0x19bbe
jmp 0x19bd9
cmpl $0x20, %eax
je 0x19bca
subl %r14d, %edx
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13802
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsstring.c
// Function: S_fromCharCode
static void S_fromCharCode(js_State *J)
{
	int i, top = js_gettop(J);
	char * volatile s = NULL;
	char *p;
	Rune c;

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

	s = p = js_malloc(J, (top-1) * UTFmax + 1);

	for (i = 1; i < top; ++i) {
		c = js_touint32(J, i);
		p += runetochar(p, &c);
	}
	*p = 0;

	js_pushstring(J, s);
	js_endtry(J);
	js_free(J, s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
movq $0x0, (%rsp)
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x19d82
movl %r12d, %eax
leal -0x3(,%rax,4), %esi
movq %rbx, %rdi
callq 0xe119
movq %rax, (%rsp)
cmpl $0x2, %r12d
jl 0x19d48
movl $0x1, %ebp
leaq 0xc(%rsp), %r14
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15276
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c76f
movl %eax, %eax
movq %rax, %rcx
addq %r15, %rcx
movl %ebp, %edx
incl %edx
movq %rcx, %rax
movq %rcx, %r15
movl %edx, %ebp
cmpl %edx, %r12d
jne 0x19d16
movb $0x0, (%rax)
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x13665
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x19d96
decl %eax
movl %eax, 0x8198(%rbx)
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x8ec6
leaq 0x19a6c(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_strtol
double js_strtol(const char *s, char **p, int base)
{
	/* ascii -> digit value. max base is 36. */
	static const unsigned char table[256] = {
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 80, 80, 80, 80, 80, 80,
		80, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
		25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 80, 80, 80, 80, 80,
		80, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
		25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
		80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
	};
	double x;
	unsigned char c;
	if (base == 10)
		for (x = 0, c = *s++; (0 <= c - '0') && (c - '0' < 10); c = *s++)
			x = x * 10 + (c - '0');
	else
		for (x = 0, c = *s++; table[c] < base; c = *s++)
			x = x * base + table[c];
	if (p)
		*p = (char*)s-1;
	return x;
}

// Assembly:
movb (%rdi), %al
cmpl $0xa, %edx
jne 0x19de7
leal -0x30(%rax), %ecx
xorpd %xmm0, %xmm0
cmpb $0x9, %cl
ja 0x19e22
movsd 0x117c6(%rip), %xmm1    # 0x2b588
movzbl %al, %eax
addl $-0x30, %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rdi), %al
incq %rdi
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x19dc2
jmp 0x19e22
movzbl %al, %ecx
leaq 0x1210f(%rip), %rax     # 0x2bf00
movzbl (%rcx,%rax), %ecx
xorpd %xmm0, %xmm0
cmpl %edx, %ecx
jge 0x19e22
cvtsi2sd %edx, %xmm1
mulsd %xmm1, %xmm0
movzbl %cl, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
addsd %xmm2, %xmm0
movzbl 0x1(%rdi), %ecx
incq %rdi
movzbl (%rcx,%rax), %ecx
cmpl %edx, %ecx
jl 0x19e01
testq %rsi, %rsi
je 0x19e2a
movq %rdi, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_toString
static int jsV_toString(js_State *J, js_Object *obj)
{
	js_pushobject(J, obj);
	js_getproperty(J, -1, "toString");
	if (js_iscallable(J, -1)) {
		js_rot2(J);
		js_call(J, 0);
		if (js_isprimitive(J, -1))
			return 1;
		js_pop(J, 1);
		return 0;
	}
	js_pop(J, 2);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x44e7
leaq 0x18e73(%rip), %rdx     # 0x32cb2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4032
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14e17
testl %eax, %eax
je 0x19eca
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, (%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movaps (%rsp), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16c25
movslq 0x140(%rbx), %rcx
testq %rcx, %rcx
jle 0x19ee7
movq 0x148(%rbx), %rax
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $-0x10, %rdx
jmp 0x19eee
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
addl $-0x2, %ecx
movl %ecx, 0x140(%rbx)
cmpl %eax, %ecx
jl 0x19f0c
xorl %eax, %eax
jmp 0x19f23
leaq 0x2650a(%rip), %rdx     # 0x403f8
movl $0x1, %eax
cmpb $0x7, 0xf(%rdx)
jne 0x19f23
leal -0x1(%rcx), %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %ecx
jg 0x19ee3
movl %eax, 0x140(%rbx)
leaq 0x19855(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_valueOf
static int jsV_valueOf(js_State *J, js_Object *obj)
{
	js_pushobject(J, obj);
	js_getproperty(J, -1, "valueOf");
	if (js_iscallable(J, -1)) {
		js_rot2(J);
		js_call(J, 0);
		if (js_isprimitive(J, -1))
			return 1;
		js_pop(J, 1);
		return 0;
	}
	js_pop(J, 2);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x44e7
leaq 0x18d5e(%rip), %rdx     # 0x32c9b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4032
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14e17
testl %eax, %eax
je 0x19fc8
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, (%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movaps (%rsp), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16c25
movslq 0x140(%rbx), %rcx
testq %rcx, %rcx
jle 0x19fe5
movq 0x148(%rbx), %rax
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $-0x10, %rdx
jmp 0x19fec
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
addl $-0x2, %ecx
movl %ecx, 0x140(%rbx)
cmpl %eax, %ecx
jl 0x1a00a
xorl %eax, %eax
jmp 0x1a021
leaq 0x2640c(%rip), %rdx     # 0x403f8
movl $0x1, %eax
cmpb $0x7, 0xf(%rdx)
jne 0x1a021
leal -0x1(%rcx), %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %ecx
jg 0x19fe1
movl %eax, 0x140(%rbx)
leaq 0x19757(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_stringtofloat
double js_stringtofloat(const char *s, char **ep)
{
	char *end;
	double n;
	const char *e = s;
	int isflt = 0;
	if (*e == '+' || *e == '-') ++e;
	while (*e >= '0' && *e <= '9') ++e;
	if (*e == '.') { ++e; isflt = 1; }
	while (*e >= '0' && *e <= '9') ++e;
	if (*e == 'e' || *e == 'E') {
		++e;
		if (*e == '+' || *e == '-') ++e;
		while (*e >= '0' && *e <= '9') ++e;
		isflt = 1;
	}
	if (isflt)
		n = js_strtod(s, &end);
	else {
		/* js_strtol doesn't parse the sign */
		if (*s == '-')
			n = -js_strtol(s+1, &end, 10);
		else if (*s == '+')
			n = js_strtol(s+1, &end, 10);
		else
			n = js_strtol(s, &end, 10);
	}
	if (end == e) {
		*ep = (char*)e;
		return n;
	}
	*ep = (char*)s;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1a046
movq %r14, %rdi
cmpl $0x2b, %eax
jne 0x1a04a
leaq 0x1(%r14), %rdi
movb (%rdi), %dl
leal -0x30(%rdx), %ecx
incq %rdi
cmpb $0xa, %cl
jb 0x1a04a
xorl %r8d, %r8d
cmpb $0x2e, %dl
sete %r8b
leaq (%rdi,%r8), %rcx
leaq (%rdi,%r8), %rsi
decq %rsi
leaq (%rdi,%r8), %r15
addq $-0x2, %r15
movzbl (%rsi), %edi
leal -0x30(%rdi), %r8d
incq %rsi
incq %r15
incq %rcx
cmpb $0xa, %r8b
jb 0x1a074
xorl %r8d, %r8d
cmpb $0x2e, %dl
sete %dl
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x1a0c8
movzbl (%rsi), %edx
cmpl $0x2b, %edx
je 0x1a0ab
cmpl $0x2d, %edx
je 0x1a0ab
movq %rsi, %rcx
decq %rcx
movq %rcx, %r15
movb 0x1(%r15), %cl
incq %r15
addb $-0x30, %cl
cmpb $0xa, %cl
jb 0x1a0b1
movl $0x1, %r8d
jmp 0x1a0cb
movb %dl, %r8b
testl %r8d, %r8d
je 0x1a0f9
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xc57f
cmpq %r15, 0x8(%rsp)
cmoveq %r15, %r14
je 0x1a0ec
xorpd %xmm0, %xmm0
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x2b, %eax
je 0x1a155
cmpl $0x2d, %eax
jne 0x1a19e
leaq 0x1(%r14), %rax
movb 0x1(%r14), %cl
leal -0x30(%rcx), %edx
xorpd %xmm0, %xmm0
cmpb $0x9, %dl
ja 0x1a146
movsd 0x11465(%rip), %xmm1    # 0x2b588
movzbl %cl, %ecx
addl $-0x30, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x1a123
movq %rax, 0x8(%rsp)
xorpd 0x112ad(%rip), %xmm0    # 0x2b400
jmp 0x1a0dd
leaq 0x1(%r14), %rax
movb 0x1(%r14), %cl
leal -0x30(%rcx), %edx
xorpd %xmm0, %xmm0
cmpb $0x9, %dl
ja 0x1a194
movsd 0x11417(%rip), %xmm1    # 0x2b588
movzbl %cl, %ecx
addl $-0x30, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x1a171
movq %rax, 0x8(%rsp)
jmp 0x1a0dd
leal -0x30(%rax), %edx
xorpd %xmm0, %xmm0
movq %r14, %rcx
cmpb $0x9, %dl
ja 0x1a1db
movsd 0x113d3(%rip), %xmm1    # 0x2b588
movq %r14, %rcx
movzbl %al, %eax
addl $-0x30, %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rcx), %al
incq %rcx
leal -0x30(%rax), %edx
cmpb $0xa, %dl
jb 0x1a1b8
movq %rcx, 0x8(%rsp)
jmp 0x1a0dd
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_newstring
static js_Object *jsV_newstring(js_State *J, const char *v)
{
	js_Object *obj = jsV_newobject(J, JS_CSTRING, J->String_prototype);
	size_t n = strlen(v);
	if (n < sizeof(obj->u.s.shrstr)) {
		obj->u.s.string = obj->u.s.shrstr;
		memcpy(obj->u.s.shrstr, v, n + 1);
	} else {
		obj->u.s.string = js_strdup(J, v);
	}
	obj->u.s.length = js_utflen(v);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0xb8(%rdi), %r12
movl $0x68, %esi
callq 0xe119
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%r15), %rax
movq %rax, 0x50(%r14)
movq %r14, 0x170(%r15)
incl 0x154(%r15)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, (%r14)
leaq 0x26106(%rip), %rax     # 0x403b8
movq %rax, 0x8(%r14)
movq %r12, 0x18(%r14)
movq %rbx, %rdi
callq 0x3200
cmpq $0xf, %rax
ja 0x1a2e3
movq %r14, %rdi
addq $0x30, %rdi
movq %rdi, 0x28(%r14)
incq %rax
movq %rbx, %rsi
movq %rax, %rdx
callq 0x33d0
jmp 0x1a311
movq %rbx, %rdi
callq 0x3200
movq %rax, %r12
incl %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0xe119
movq %rax, %r15
movslq %r12d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x33d0
movq %r15, 0x28(%r14)
movq %rbx, %rdi
callq 0x1883b
movl %eax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_newobjectx
void js_newobjectx(js_State *J)
{
	js_Object *prototype = NULL;
	if (js_isobject(J, -1))
		prototype = js_toobject(J, -1);
	js_pop(J, 1);
	js_pushobject(J, jsV_newobject(J, JS_COBJECT, prototype));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %ecx
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jle 0x1a34f
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
jmp 0x1a356
leaq 0x260a2(%rip), %rdx     # 0x403f8
cmpb $0x7, 0xf(%rdx)
jne 0x1a36f
testl %ecx, %ecx
jle 0x1a374
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0x1a37b
xorl %r14d, %r14d
jmp 0x1a386
leaq 0x2607d(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x1a414
movq %rbx, %rdi
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, (%rax)
leaq 0x25fbe(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44e7
movl %eax, 0x140(%rbx)
leaq 0x1934d(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_newfunction
void js_newfunction(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CFUNCTION, J->Function_prototype);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
	{
		js_pushnumber(J, fun->numparams);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_newobject(J);
		{
			js_copy(J, -2);
			js_defproperty(J, -2, "constructor", JS_DONTENUM);
		}
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rdi), %r12
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000002, %rcx      # imm = 0x100000002
movq %rcx, (%rax)
leaq 0x25cf4(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r12, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x44e7
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x1905a(%rip), %rdx     # 0x33751
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x7, %ecx
callq 0x66df
movq %rbx, %rdi
callq 0x1a42b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x14073
leaq 0x193c0(%rip), %rdx     # 0x33ae5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %ecx
callq 0x66df
leaq 0x18a66(%rip), %rdx     # 0x331a4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x6, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x66df
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_newscript
void js_newscript(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CSCRIPT, NULL);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
xorl %ecx, %ecx
movq %rcx, 0x60(%rax)
movq 0x170(%r15), %rdx
movq %rdx, 0x50(%rax)
movq %rax, 0x170(%r15)
incl 0x154(%r15)
movabsq $0x100000003, %rdx      # imm = 0x100000003
movq %rdx, (%rax)
leaq 0x25bf8(%rip), %rdx     # 0x403b8
movq %rdx, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x44e7
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_newcfunctionx
void js_newcfunctionx(js_State *J, js_CFunction cfun, const char *name, int length, void *data, js_Finalize finalize)
{
	js_Object *obj;

	if (js_try(J)) {
		if (finalize)
			finalize(J, data);
		js_throw(J);
	}

	obj = jsV_newobject(J, JS_CCFUNCTION, J->Function_prototype);
	obj->u.c.name = name;
	obj->u.c.function = cfun;
	obj->u.c.constructor = NULL;
	obj->u.c.length = length;
	obj->u.c.data = data;
	obj->u.c.finalize = finalize;

	js_endtry(J);

	js_pushobject(J, obj);
	{
		js_pushnumber(J, length);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_newobject(J);
		{
			js_copy(J, -2);
			js_defproperty(J, -2, "constructor", JS_DONTENUM);
		}
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1a92d
movq 0xa0(%rbx), %r14
movq %rbx, %rdi
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
xorl %ecx, %ecx
movq %rcx, 0x60(%rax)
movq 0x170(%rbx), %rdx
movq %rdx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000004, %rdx      # imm = 0x100000004
movq %rdx, (%rax)
leaq 0x25b46(%rip), %rdx     # 0x403b8
movq %rdx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %rcx, 0x30(%rax)
movl %ebp, 0x38(%rax)
movq %r15, 0x40(%rax)
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x1a945
movq %rax, %rsi
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %rbx, %rdi
callq 0x44e7
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x18e85(%rip), %rdx     # 0x33751
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %ebp, %esi
movl $0x7, %ecx
callq 0x66df
movq %rbx, %rdi
callq 0x1a42b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14073
leaq 0x191ec(%rip), %rdx     # 0x33ae5
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %ecx
callq 0x66df
leaq 0x18895(%rip), %rdx     # 0x331a4
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %ecx
callq 0x66df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, (%rsp)
je 0x1a93d
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rsp)
movq %rbx, %rdi
callq 0x8ec6
leaq 0x18ebd(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939