LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_stringtonumber
double jsV_stringtonumber(js_State *J, const char *s)
{
	char *e;
	double n;
	while (jsY_iswhite(*s) || jsY_isnewline(*s)) ++s;
	if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && s[2] != 0)
		n = js_strtol(s + 2, &e, 16);
	else if (!strncmp(s, "Infinity", 8))
		n = INFINITY, e = (char*)s + 8;
	else if (!strncmp(s, "+Infinity", 9))
		n = INFINITY, e = (char*)s + 9;
	else if (!strncmp(s, "-Infinity", 9))
		n = -INFINITY, e = (char*)s + 9;
	else
		n = js_stringtofloat(s, &e);
	while (jsY_iswhite(*e) || jsY_isnewline(*e)) ++e;
	if (*e) return NAN;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xded0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x12e9d
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf30
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x12ea6
jmp 0x12eb4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12e70
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x12f07
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
je 0x12eda
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x58, %eax
jne 0x12f07
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x12f07
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1b0f0
movsd %xmm0, -0x28(%rbp)
jmp 0x12fc1
movq -0x18(%rbp), %rdi
leaq 0x2921f(%rip), %rsi     # 0x3c131
movl $0x8, %edx
callq 0x3140
cmpl $0x0, %eax
jne 0x12f3f
movsd 0x204df(%rip), %xmm0    # 0x33408
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x12fbf
movq -0x18(%rbp), %rdi
leaq 0x291e6(%rip), %rsi     # 0x3c130
movl $0x9, %edx
callq 0x3140
cmpl $0x0, %eax
jne 0x12f74
movsd 0x204a7(%rip), %xmm0    # 0x33408
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x20(%rbp)
jmp 0x12fbd
movq -0x18(%rbp), %rdi
leaq 0x291bb(%rip), %rsi     # 0x3c13a
movl $0x9, %edx
callq 0x3140
cmpl $0x0, %eax
jne 0x12fa9
movsd 0x20482(%rip), %xmm0    # 0x33418
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x20(%rbp)
jmp 0x12fbb
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b380
movsd %xmm0, -0x28(%rbp)
jmp 0x12fbd
jmp 0x12fbf
jmp 0x12fc1
jmp 0x12fc3
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xded0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
jne 0x12ff0
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf30
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x12ff9
jmp 0x13007
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12fc3
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1301f
movsd 0x203f8(%rip), %xmm0    # 0x33410
movsd %xmm0, -0x8(%rbp)
jmp 0x13029
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsregexp.c
// Function: js_newregexpx
static void js_newregexpx(js_State *J, const char *pattern, int flags, int is_clone)
{
	const char *error;
	js_Object *obj;
	Reprog *prog;
	int opts;

	obj = jsV_newobject(J, JS_CREGEXP, J->RegExp_prototype);

	opts = 0;
	if (flags & JS_REGEXP_I) opts |= REG_ICASE;
	if (flags & JS_REGEXP_M) opts |= REG_NEWLINE;

	prog = js_regcompx(J->alloc, J->actx, pattern, opts, &error);
	if (!prog)
		js_syntaxerror(J, "regular expression: %s", error);

	obj->u.r.prog = prog;
	obj->u.r.source = is_clone ? js_strdup(J, pattern) : escaperegexp(J, pattern);
	obj->u.r.flags = flags;
	obj->u.r.last = 0;
	js_pushobject(J, obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rdx
movl $0x9, %esi
callq 0x6bc0
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x133fe
movl -0x34(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x13412
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x34(%rbp), %ecx
leaq -0x20(%rbp), %r8
callq 0x6c70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x13452
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x2a087(%rip), %rsi     # 0x3d4d2
movb $0x0, %al
callq 0xbee0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x13477
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x71c0
movq %rax, -0x40(%rbp)
jmp 0x13488
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d1c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x28(%rbp), %rax
movw $0x0, 0x32(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4870
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./regexp.c
// Function: js_regexec
int regexec(Reprog *prog, const char *sp, Resub *sub, int eflags)
{
	Resub scratch;
	int i;

	if (!sub)
		sub = &scratch;

	sub->nsub = prog->nsub;
	for (i = 0; i < REG_MAXSUB; ++i)
		sub->sub[i].sp = sub->sub[i].ep = NULL;

	return match(prog->start, sp, sp, prog->flags | eflags, sub, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1378c
leaq -0x128(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x12c(%rbp)
cmpl $0x10, -0x12c(%rbp)
jge 0x137f8
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x137a3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
orl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %r8
xorl %r9d, %r9d
callq 0x1d170
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_pushstring
void js_pushstring(js_State *J, const char *v)
{
	size_t n = strlen(v);
	if (n > JS_STRLIMIT)
		js_rangeerror(J, "invalid string length");
	CHECKSTACK(1);
	if (n <= soffsetof(js_Value, t.type)) {
		char *s = STACK[TOP].u.shrstr;
		while (n--) *s++ = *v++;
		*s = 0;
		STACK[TOP].t.type = JS_TSHRSTR;
	} else {
		STACK[TOP].t.type = JS_TMEMSTR;
		STACK[TOP].u.memstr = jsV_newmemstring(J, v, n);
	}
	++TOP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x18(%rbp)
cmpq $0x10000000, -0x18(%rbp) # imm = 0x10000000
jbe 0x138b9
movq -0x8(%rbp), %rdi
leaq 0x2853b(%rip), %rsi     # 0x3bded
movb $0x0, %al
callq 0xbd10
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x138d6
movq -0x8(%rbp), %rdi
callq 0x14dc0
cmpq $0xf, -0x18(%rbp)
ja 0x13965
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1393b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x13902
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0xf(%rax)
jmp 0x139bc
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x6, 0xf(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x14ca0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x140(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsstring.c
// Function: js_utfptrtoidx
int js_utfptrtoidx(const char *s, const char *p)
{
	Rune rune;
	int i = 0;
	while (s < p) {
		if (*(unsigned char *)s < Runeself)
			++s;
		else
			s += chartorune(&rune, s);
		if (rune >= 0x10000)
			i += 2;
		else
			i += 1;
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x13a59
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x13a1d
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x13a3a
movq -0x8(%rbp), %rsi
leaq -0x14(%rbp), %rdi
callq 0x19d20
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jl 0x13a4e
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x13a57
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x139f7
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_pushlstring
void js_pushlstring(js_State *J, const char *v, int n)
{
	if (n > JS_STRLIMIT)
		js_rangeerror(J, "invalid string length");
	CHECKSTACK(1);
	if (n <= soffsetof(js_Value, t.type)) {
		char *s = STACK[TOP].u.shrstr;
		while (n--) *s++ = *v++;
		*s = 0;
		STACK[TOP].t.type = JS_TSHRSTR;
	} else {
		STACK[TOP].t.type = JS_TMEMSTR;
		STACK[TOP].u.memstr = jsV_newmemstring(J, v, n);
	}
	++TOP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x10000000, -0x14(%rbp) # imm = 0x10000000
jle 0x13a9e
movq -0x8(%rbp), %rdi
leaq 0x28356(%rip), %rsi     # 0x3bded
movb $0x0, %al
callq 0xbd10
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x13abb
movq -0x8(%rbp), %rdi
callq 0x14dc0
cmpl $0xf, -0x14(%rbp)
jg 0x13b40
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x13b16
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x13ae2
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0xf(%rax)
jmp 0x13b94
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x6, 0xf(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x14ca0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x140(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsregexp.c
// Function: Rp_toString
static void Rp_toString(js_State *J)
{
	js_Regexp *re;
	char * volatile out = NULL;

	re = js_toregexp(J, 0);

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

	out = js_malloc(J, strlen(re->source) + 6); /* extra space for //gim */
	strcpy(out, "/");
	strcat(out, re->source);
	strcat(out, "/");
	if (re->flags & JS_REGEXP_G) strcat(out, "g");
	if (re->flags & JS_REGEXP_I) strcat(out, "i");
	if (re->flags & JS_REGEXP_M) strcat(out, "m");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15f20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14270
movq %rax, %rdi
callq 0x30e0
cmpl $0x0, %eax
je 0x13c6f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
movq -0x8(%rbp), %rdi
callq 0x8cb0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31e0
movq -0x20(%rbp), %rdi
addq $0x6, %rax
movl %eax, %esi
callq 0xd9d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x29847(%rip), %rsi     # 0x3d4e9
callq 0x32f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3250
movq -0x18(%rbp), %rdi
leaq 0x29826(%rip), %rsi     # 0x3d4e9
callq 0x3250
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13ce8
movq -0x18(%rbp), %rdi
leaq 0x293fc(%rip), %rsi     # 0x3d0df
callq 0x3250
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x13d08
movq -0x18(%rbp), %rdi
leaq 0x297e8(%rip), %rsi     # 0x3d4eb
callq 0x3250
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x13d28
movq -0x18(%rbp), %rdi
leaq 0x283cb(%rip), %rsi     # 0x3c0ee
callq 0x3250
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4400
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
callq 0x14a10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsregexp.c
// Function: Rp_test
static void Rp_test(js_State *J)
{
	js_Regexp *re;
	const char *text;
	int result;
	int opts;
	Resub m;

	re = js_toregexp(J, 0);
	text = js_tostring(J, 1);

	opts = 0;
	if (re->flags & JS_REGEXP_G) {
		if (re->last > strlen(text)) {
			re->last = 0;
			js_pushboolean(J, 0);
			return;
		}
		if (re->last > 0) {
			text += re->last;
			opts |= REG_NOTBOL;
		}
	}

	result = js_regexec(re->prog, text, &m, opts);
	if (result < 0)
		js_error(J, "regexec failed");
	if (result == 0) {
		if (re->flags & JS_REGEXP_G)
			re->last = re->last + (m.sub[0].ep - text);
		js_pushboolean(J, 1);
		return;
	}

	if (re->flags & JS_REGEXP_G)
		re->last = 0;

	js_pushboolean(J, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15f20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14b80
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13e16
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
movq %rax, -0x130(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x130(%rbp), %rax
cmpq %rcx, %rax
jbe 0x13de8
movq -0x10(%rbp), %rax
movw $0x0, 0x12(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14e30
jmp 0x13eba
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
cmpl $0x0, %eax
jle 0x13e14
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x20(%rbp)
jmp 0x13e16
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %ecx
leaq -0x128(%rbp), %rdx
callq 0x13760
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x13e4b
movq -0x8(%rbp), %rdi
leaq 0x27f41(%rip), %rsi     # 0x3bd85
movb $0x0, %al
callq 0xbb10
cmpl $0x0, -0x1c(%rbp)
jne 0x13e95
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13e85
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
movq -0x118(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x12(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14e30
jmp 0x13eba
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13eaf
movq -0x10(%rbp), %rax
movw $0x0, 0x12(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14e30
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrepr.c
// Function: js_repr
void js_repr(js_State *J, int idx)
{
	js_Buffer *sb = NULL;
	int savebot;

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

	js_copy(J, idx);

	savebot = J->bot;
	J->bot = J->top - 1;
	reprvalue(J, &sb);
	J->bot = savebot;

	js_pop(J, 1);

	js_putc(J, &sb, 0);
	js_pushstring(J, sb ? sb->s : "undefined");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14270
movq %rax, %rdi
callq 0x30e0
cmpl $0x0, %eax
je 0x141b3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
movq -0x8(%rbp), %rdi
callq 0x8cb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14410
movq -0x8(%rbp), %rax
movl 0x144(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x144(%rax)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x144a0
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x144(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xd910
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14237
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x14244
leaq 0x296d7(%rip), %rax     # 0x3d915
movq %rax, -0x30(%rbp)
jmp 0x14244
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
callq 0x14a10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd710
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_savetry
void *js_savetry(js_State *J)
{
	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 = NULL;
	return J->trybuf[J->trytop++].buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x8198(%rax)
jne 0x14292
movq -0x8(%rbp), %rdi
callq 0x18c50
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl 0x188(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movl 0x2190(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xd4(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movl 0x144(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xdc(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movslq 0x8198(%rdx), %rdx
imulq $0xf0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xe0(%rax)
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rcx
movslq 0x8198(%rcx), %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rax
addq $0x81a0, %rax           # imm = 0x81A0
movq -0x8(%rbp), %rdx
movl 0x8198(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8198(%rdx)
movslq %ecx, %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_replace
void js_replace(js_State* J, int idx)
{
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < BOT || idx >= TOP)
		js_error(J, "stack error!");
	STACK[idx] = STACK[--TOP];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x14ae7
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x14af7
movq -0x8(%rbp), %rax
movl 0x144(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x144(%rcx), %eax
jl 0x14b1b
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x140(%rcx), %eax
jl 0x14b2d
movq -0x8(%rbp), %rdi
leaq 0x27304(%rip), %rsi     # 0x3be2a
movb $0x0, %al
callq 0xbb10
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x148(%rcx), %rcx
movq -0x8(%rbp), %rsi
movl 0x140(%rsi), %edx
addl $-0x1, %edx
movl %edx, 0x140(%rsi)
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrepr.c
// Function: js_tryrepr
const char *js_tryrepr(js_State *J, int idx, const char *error)
{
	const char *s;
	if (js_try(J)) {
		js_pop(J, 1);
		return error;
	}
	s = js_torepr(J, idx);
	js_endtry(J);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14270
movq %rax, %rdi
callq 0x30e0
cmpl $0x0, %eax
je 0x14c01
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14c22
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14a60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14a10
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_outofmemory
static void js_outofmemory(js_State *J)
{
	STACK[TOP].t.type = JS_TLITSTR;
	STACK[TOP].u.litstr = "out of memory";
	++TOP;
	js_throw(J);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x5, 0xf(%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
leaq 0x1e50f(%rip), %rcx     # 0x33190
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rdi
callq 0x8cb0
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: jsV_newmemstring
js_String *jsV_newmemstring(js_State *J, const char *s, int n)
{
	js_String *v = js_malloc(J, soffsetof(js_String, p) + n + 1);
	memcpy(v->p, s, n);
	v->p[n] = 0;
	v->gcmark = 0;
	v->gcnext = J->gcstr;
	J->gcstr = v;
	++J->gccounter;
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x9, %esi
addl $0x1, %esi
callq 0xd9d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x9, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x33a0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, 0x9(%rax,%rcx)
movq -0x20(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x8(%rbp), %rax
movl 0x154(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x154(%rax)
movq -0x20(%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_stackoverflow
static void js_stackoverflow(js_State *J)
{
	STACK[TOP].t.type = JS_TLITSTR;
	STACK[TOP].u.litstr = "stack overflow";
	++TOP;
	js_throw(J);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x5, 0xf(%rax)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
leaq 0x28956(%rip), %rcx     # 0x3d767
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rdi
callq 0x8cb0
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_pushboolean
void js_pushboolean(js_State *J, int v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TBOOLEAN;
	STACK[TOP].u.boolean = !!v;
	++TOP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x14e5c
movq -0x8(%rbp), %rdi
callq 0x14dc0
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x3, 0xf(%rax)
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x140(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_currentfunction
void js_currentfunction(js_State *J)
{
	CHECKSTACK(1);
	if (BOT > 0)
		STACK[TOP] = STACK[BOT-1];
	else
		STACK[TOP].t.type = JS_TUNDEFINED;
	++TOP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x14f29
movq -0x8(%rbp), %rdi
callq 0x14dc0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x144(%rax)
jle 0x14f85
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x148(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x144(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x14fa6
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0xf(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: stackidx
static js_Value *stackidx(js_State *J, int idx)
{
	static js_Value undefined = { { {0}, JS_TUNDEFINED } };
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < 0 || idx >= TOP)
		return &undefined;
	return STACK + idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x15073
movq -0x10(%rbp), %rax
movl 0x140(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x15083
movq -0x10(%rbp), %rax
movl 0x144(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1509e
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x140(%rcx), %eax
jl 0x150ab
leaq 0x32d83(%rip), %rax     # 0x47e28
movq %rax, -0x8(%rbp)
jmp 0x150c5
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_iscallable
int js_iscallable(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT)
		return v->u.object->type == JS_CFUNCTION ||
			v->u.object->type == JS_CSCRIPT ||
			v->u.object->type == JS_CCFUNCTION;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x7, %eax
jne 0x152fb
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, -0x21(%rbp)
je 0x152ee
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x3, (%rcx)
movb %al, -0x21(%rbp)
je 0x152ee
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15302
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_isuserdata
int js_isuserdata(js_State *J, int idx, const char *tag)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT && v->u.object->type == JS_CUSERDATA)
		return !strcmp(tag, v->u.object->u.user.tag);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x7, %eax
jne 0x15412
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpl $0xf, (%rax)
jne 0x15412
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rsi
callq 0x32d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15419
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_typeof
const char *js_typeof(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return "string";
	case JS_TUNDEFINED: return "undefined";
	case JS_TNULL: return "object";
	case JS_TBOOLEAN: return "boolean";
	case JS_TNUMBER: return "number";
	case JS_TLITSTR: return "string";
	case JS_TMEMSTR: return "string";
	case JS_TOBJECT:
		if (v->u.object->type == JS_CFUNCTION || v->u.object->type == JS_CCFUNCTION)
			return "function";
		return "object";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x154c6
movq -0x28(%rbp), %rax
leaq 0x1e393(%rip), %rcx     # 0x33850
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x154c8
leaq 0x2841d(%rip), %rax     # 0x3d8ec
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x28439(%rip), %rax     # 0x3d915
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x282bb(%rip), %rax     # 0x3d7a4
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x26e79(%rip), %rax     # 0x3c36f
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x27b9b(%rip), %rax     # 0x3d09e
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x283dc(%rip), %rax     # 0x3d8ec
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x283cf(%rip), %rax     # 0x3d8ec
movq %rax, -0x8(%rbp)
jmp 0x15553
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0x1553b
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
jne 0x15548
leaq 0x273f6(%rip), %rax     # 0x3c938
movq %rax, -0x8(%rbp)
jmp 0x15553
leaq 0x28255(%rip), %rax     # 0x3d7a4
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_type
int js_type(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return JS_ISSTRING;
	case JS_TUNDEFINED: return JS_ISUNDEFINED;
	case JS_TNULL: return JS_ISNULL;
	case JS_TBOOLEAN: return JS_ISBOOLEAN;
	case JS_TNUMBER: return JS_ISNUMBER;
	case JS_TLITSTR: return JS_ISSTRING;
	case JS_TMEMSTR: return JS_ISSTRING;
	case JS_TOBJECT:
		if (v->u.object->type == JS_CFUNCTION || v->u.object->type == JS_CCFUNCTION)
			return JS_ISFUNCTION;
		return JS_ISOBJECT;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x155a6
movq -0x28(%rbp), %rax
leaq 0x1e2d3(%rip), %rcx     # 0x33870
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x155a8
movl $0x4, -0x4(%rbp)
jmp 0x1560f
movl $0x0, -0x4(%rbp)
jmp 0x1560f
movl $0x1, -0x4(%rbp)
jmp 0x1560f
movl $0x2, -0x4(%rbp)
jmp 0x1560f
movl $0x3, -0x4(%rbp)
jmp 0x1560f
movl $0x4, -0x4(%rbp)
jmp 0x1560f
movl $0x4, -0x4(%rbp)
jmp 0x1560f
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0x155ff
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
jne 0x15608
movl $0x5, -0x4(%rbp)
jmp 0x1560f
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_toboolean
int jsV_toboolean(js_State *J, js_Value *v)
{
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return v->u.shrstr[0] != 0;
	case JS_TUNDEFINED: return 0;
	case JS_TNULL: return 0;
	case JS_TBOOLEAN: return v->u.boolean;
	case JS_TNUMBER: return v->u.number != 0 && !isnan(v->u.number);
	case JS_TLITSTR: return v->u.litstr[0] != 0;
	case JS_TMEMSTR: return v->u.memstr->p[0] != 0;
	case JS_TOBJECT: return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x15693
movq -0x20(%rbp), %rax
leaq 0x1e206(%rip), %rcx     # 0x33890
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x15695
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15749
movl $0x0, -0x4(%rbp)
jmp 0x15749
movl $0x0, -0x4(%rbp)
jmp 0x15749
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x15749
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jne 0x156ec
jp 0x156ec
jmp 0x15700
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm0
setp %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15749
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15749
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x9(%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x15749
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_tonumber
double jsV_tonumber(js_State *J, js_Value *v)
{
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return jsV_stringtonumber(J, v->u.shrstr);
	case JS_TUNDEFINED: return NAN;
	case JS_TNULL: return 0;
	case JS_TBOOLEAN: return v->u.boolean;
	case JS_TNUMBER: return v->u.number;
	case JS_TLITSTR: return jsV_stringtonumber(J, v->u.litstr);
	case JS_TMEMSTR: return jsV_stringtonumber(J, v->u.memstr->p);
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HNUMBER);
		return jsV_tonumber(J, v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x157c7
movq -0x20(%rbp), %rax
leaq 0x1e0f2(%rip), %rcx     # 0x338b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x157c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12e60
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movsd 0x1dc28(%rip), %xmm0    # 0x33410
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x12e60
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x9, %rsi
callq 0x12e60
movsd %xmm0, -0x8(%rbp)
jmp 0x1586d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x15dc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15790
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_numbertoint32
int jsV_numbertoint32(double n)
{
	double two32 = 4294967296.0;
	double two31 = 2147483648.0;

	if (!isfinite(n) || n == 0)
		return 0;

	n = fmod(n, two32);
	n = n >= 0 ? floor(n) : ceil(n) + two32;
	if (n >= two31)
		return n - two32;
	else
		return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd 0x1dc0b(%rip), %xmm0    # 0x334e0
movsd %xmm0, -0x18(%rbp)
movsd 0x1dbf6(%rip), %xmm0    # 0x334d8
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%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 0x15914
jmp 0x15924
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1592d
jp 0x1592d
movl $0x0, -0x4(%rbp)
jmp 0x159a5
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3190
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15960
movsd -0x10(%rbp), %xmm0
callq 0x3340
movsd %xmm0, -0x28(%rbp)
jmp 0x15974
movsd -0x10(%rbp), %xmm0
callq 0x3090
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x1599d
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0x159a5
cvttsd2si -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_tostring
const char *jsV_tostring(js_State *J, js_Value *v)
{
	char buf[32];
	const char *p;
	switch (v->t.type) {
	default:
	case JS_TSHRSTR: return v->u.shrstr;
	case JS_TUNDEFINED: return "undefined";
	case JS_TNULL: return "null";
	case JS_TBOOLEAN: return v->u.boolean ? "true" : "false";
	case JS_TLITSTR: return v->u.litstr;
	case JS_TMEMSTR: return v->u.memstr->p;
	case JS_TNUMBER:
		p = jsV_numbertostring(J, buf, v->u.number);
		if (p == buf) {
			int n = strlen(p);
			if (n <= soffsetof(js_Value, t.type)) {
				char *s = v->u.shrstr;
				while (n--) *s++ = *p++;
				*s = 0;
				v->t.type = JS_TSHRSTR;
				return v->u.shrstr;
			} else {
				v->u.memstr = jsV_newmemstring(J, p, n);
				v->t.type = JS_TMEMSTR;
				return v->u.memstr->p;
			}
		}
		return p;
	case JS_TOBJECT:
		jsV_toprimitive(J, v, JS_HSTRING);
		return jsV_tostring(J, v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x60(%rbp)
subl $0x7, %eax
ja 0x15b07
movq -0x60(%rbp), %rax
leaq 0x1ddd2(%rip), %rcx     # 0x338d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x15b09
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
leaq 0x27df8(%rip), %rax     # 0x3d915
movq %rax, -0x8(%rbp)
jmp 0x15c6f
leaq 0x27704(%rip), %rax     # 0x3d231
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x26606(%rip), %rax     # 0x3c149
leaq 0x265fa(%rip), %rcx     # 0x3c144
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x9, %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x13040
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
leaq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jne 0x15c42
movq -0x48(%rbp), %rdi
callq 0x31e0
movl %eax, -0x4c(%rbp)
cmpl $0xf, -0x4c(%rbp)
jg 0x15c0f
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x15bf6
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
jmp 0x15bc2
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xf(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x4c(%rbp), %edx
callq 0x14ca0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb $0x6, 0xf(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x9, %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15c6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x15dc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ad0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_toobject
js_Object *jsV_toobject(js_State *J, js_Value *v)
{
	js_Object *o;
	switch (v->t.type) {
	default:
	case JS_TUNDEFINED: js_typeerror(J, "cannot convert undefined to object");
	case JS_TNULL: js_typeerror(J, "cannot convert null to object");
	case JS_TOBJECT: return v->u.object;
	case JS_TSHRSTR: o = jsV_newstring(J, v->u.shrstr); break;
	case JS_TLITSTR: o = jsV_newstring(J, v->u.litstr); break;
	case JS_TMEMSTR: o = jsV_newstring(J, v->u.memstr->p); break;
	case JS_TBOOLEAN: o = jsV_newboolean(J, v->u.boolean); break;
	case JS_TNUMBER: o = jsV_newnumber(J, v->u.number); break;
	}
	v->t.type = JS_TOBJECT;
	v->u.object = o;
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x15cb7
movq -0x28(%rbp), %rax
leaq 0x1dc42(%rip), %rcx     # 0x338f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x15cb9
movq -0x10(%rbp), %rdi
leaq 0x2648b(%rip), %rsi     # 0x3c14f
movb $0x0, %al
callq 0xbfe0
movq -0x10(%rbp), %rdi
leaq 0x2649c(%rip), %rsi     # 0x3c172
movb $0x0, %al
callq 0xbfe0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15d75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5f0
movq %rax, -0x20(%rbp)
jmp 0x15d5a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1b5f0
movq %rax, -0x20(%rbp)
jmp 0x15d5a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x9, %rsi
callq 0x1b5f0
movq %rax, -0x20(%rbp)
jmp 0x15d5a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x1b6a0
movq %rax, -0x20(%rbp)
jmp 0x15d5a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x1b6e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x7, 0xf(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsvalue.c
// Function: jsV_toprimitive
void jsV_toprimitive(js_State *J, js_Value *v, int preferred)
{
	js_Object *obj;

	if (v->t.type != JS_TOBJECT)
		return;

	obj = v->u.object;

	if (preferred == JS_HNONE)
		preferred = obj->type == JS_CDATE ? JS_HSTRING : JS_HNUMBER;

	if (preferred == JS_HSTRING) {
		if (jsV_toString(J, obj) || jsV_valueOf(J, obj)) {
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	} else {
		if (jsV_valueOf(J, obj) || jsV_toString(J, obj)) {
			*v = *js_tovalue(J, -1);
			js_pop(J, 1);
			return;
		}
	}

	if (J->strict)
		js_typeerror(J, "cannot convert object to primitive");

	v->t.type = JS_TLITSTR;
	v->u.litstr = "[object]";
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x7, %eax
je 0x15de5
jmp 0x15f0c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x15e0f
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0xa, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x15e79
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b220
cmpl $0x0, %eax
jne 0x15e39
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b2d0
cmpl $0x0, %eax
je 0x15e77
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15020
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
jmp 0x15f0c
jmp 0x15eda
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b2d0
cmpl $0x0, %eax
jne 0x15e9d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b220
cmpl $0x0, %eax
je 0x15ed8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15020
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
jmp 0x15f0c
jmp 0x15eda
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x15ef6
movq -0x8(%rbp), %rdi
leaq 0x26215(%rip), %rsi     # 0x3c104
movb $0x0, %al
callq 0xbfe0
movq -0x10(%rbp), %rax
movb $0x5, 0xf(%rax)
movq -0x10(%rbp), %rax
leaq 0x2621e(%rip), %rcx     # 0x3c127
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsrun.c
// Function: js_toregexp
js_Regexp *js_toregexp(js_State *J, int idx)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TOBJECT && v->u.object->type == JS_CREGEXP)
		return &v->u.object->u.r;
	js_typeerror(J, "not a regexp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x15050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x7, %eax
jne 0x15f69
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0x15f69
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
leaq 0x25e8f(%rip), %rsi     # 0x3be03
movb $0x0, %al
callq 0xbfe0
nopl (%rax,%rax)