LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x14644
shlq $0x4, %rax
movb $0x3, 0xf(%rcx,%rax)
xorl %eax, %eax
testl %esi, %esi
setne %al
movq 0x148(%rdi), %rcx
movslq 0x140(%rdi), %rdx
shlq $0x4, %rdx
movl %eax, (%rcx,%rdx)
incl 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x20a6f(%rip), %rdx     # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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:
movslq 0x140(%rdi), %rax
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x146c3
movslq 0x144(%rdi), %rdx
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
testq %rdx, %rdx
jle 0x146b7
shlq $0x4, %rdx
movups -0x10(%rcx,%rdx), %xmm0
movups %xmm0, (%rcx,%rax)
jmp 0x146bc
movb $0x1, 0xf(%rcx,%rax)
incl 0x140(%rdi)
retq
pushq %rax
movq 0x148(%rdi), %rcx
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x209e9(%rip), %rdx     # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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:
movzbl 0xf(%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x14c13
leaq 0x16be5(%rip), %rcx     # 0x2b7e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
retq
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd (%rsi), %xmm0
jmp 0x14c36
xorl %eax, %eax
cmpb $0x0, (%rsi)
jmp 0x14c36
movl (%rsi), %eax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, 0x9(%rcx)
jmp 0x14c36
movl $0x1, %eax
retq
movq (%rsi), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0xf(%rbx), %eax
cmpl $0x7, %eax
jne 0x14c9a
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1515d
jmp 0x14c7f
decl %eax
cmpl $0x5, %eax
ja 0x14ce1
leaq 0x16b54(%rip), %rcx     # 0x2b7fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x16797(%rip), %xmm0    # 0x2b450
jmp 0x14cd0
movq (%rbx), %rsi
jmp 0x14ce4
cvtsi2sdl (%rbx), %xmm0
jmp 0x14cd0
movsd (%rbx), %xmm0
jmp 0x14cd0
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0x14ce4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12ada
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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:
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setg %cl
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x14d9e
pushq %rax
movsd 0x1680f(%rip), %xmm1    # 0x2b570
callq 0x31b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x14d7f
callq 0x3090
addsd 0x167f3(%rip), %xmm0    # 0x2b570
jmp 0x14d84
callq 0x3370
ucomisd 0x167ec(%rip), %xmm0    # 0x2b578
jb 0x14d96
addsd 0x167ea(%rip), %xmm0    # 0x2b580
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl 0xf(%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x14ee4
movq %rdi, %r14
leaq 0x1698a(%rip), %rcx     # 0x2b814
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x203d3(%rip), %rbx     # 0x3526d
jmp 0x14ee4
movq (%rbx), %rbx
jmp 0x14ee4
cmpl $0x0, (%rbx)
leaq 0x1ec23(%rip), %rax     # 0x33ace
leaq 0x1ec17(%rip), %rbx     # 0x33ac9
cmoveq %rax, %rbx
jmp 0x14ee4
movsd (%rbx), %xmm0
movq %rsp, %r12
movq %r12, %rsi
callq 0x12c04
movq %rax, %r15
cmpq %r12, %rax
je 0x14f1f
movq %r15, %rbx
jmp 0x14ee4
leaq 0x1fcd0(%rip), %rbx     # 0x34bab
jmp 0x14ee4
movq (%rbx), %rbx
addq $0x9, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x1515d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14e64
movq %r15, %rdi
callq 0x3200
movq %rax, %r12
cmpl $0xf, %r12d
jg 0x14f55
movq %rbx, %rax
testl %r12d, %r12d
je 0x14f4c
xorl %eax, %eax
movb (%r15,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpl %eax, %r12d
jne 0x14f3a
addq %rbx, %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0xf(%rbx)
jmp 0x14ee4
movl %r12d, %esi
addl $0xa, %esi
movq %r14, %rdi
callq 0xde05
movq %rax, %r13
leaq 0x9(%rax), %rbp
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33d0
xorl %eax, %eax
movb %al, 0x9(%r13,%r12)
movb %al, 0x8(%r13)
movq 0x178(%r14), %rax
movq %rax, (%r13)
movq %r13, 0x178(%r14)
incl 0x154(%r14)
movq %r13, (%rbx)
movb $0x6, 0xf(%rbx)
movq %rbp, %rbx
jmp 0x14ee4
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movzbl 0xf(%rsi), %eax
cmpq $0x7, %rax
ja 0x15111
movq %rsi, %rbx
leaq 0x1685c(%rip), %rcx     # 0x2b830
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x150f1
movl (%rbx), %ebp
movq 0xa8(%r14), %r15
movq %r14, %rdi
movl $0x68, %esi
callq 0xde05
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(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%r14)
incl 0x154(%r14)
movabsq $0x100000006, %rcx      # imm = 0x100000006
movq %rcx, (%rax)
leaq 0x2b36b(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r15, 0x18(%rax)
movl %ebp, 0x20(%rax)
jmp 0x150f6
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0xb0(%r14), %r15
movq %r14, %rdi
movl $0x68, %esi
callq 0xde05
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(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%r14)
incl 0x154(%r14)
movabsq $0x100000007, %rcx      # imm = 0x100000007
movq %rcx, (%rax)
leaq 0x2b2ef(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r15, 0x18(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0x150f6
movq (%rbx), %rsi
addq $0x9, %rsi
jmp 0x150ee
movq (%rbx), %rax
jmp 0x150fd
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x19d92
movb $0x7, 0xf(%rbx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e9e8(%rip), %rsi     # 0x33af7
jmp 0x15118
leaq 0x1e9bc(%rip), %rsi     # 0x33ad4
movq %r14, %rdi
xorl %eax, %eax
callq 0xca10
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 %r15
pushq %r14
pushq %rbx
cmpb $0x7, 0xf(%rsi)
jne 0x15205
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
cmpl $0x2, %edx
je 0x15184
testl %edx, %edx
jne 0x151a0
cmpl $0xa, (%r15)
jne 0x151a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19997
testl %eax, %eax
jne 0x151be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19a95
jmp 0x151ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19a95
testl %eax, %eax
jne 0x151be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19997
testl %eax, %eax
je 0x1520b
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x151de
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x151e5
leaq 0x2b213(%rip), %rax     # 0x403f8
movups (%rax), %xmm0
movups %xmm0, (%r14)
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x15222
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x34(%rbx)
jne 0x15239
movb $0x5, 0xf(%r14)
leaq 0x1e88f(%rip), %rax     # 0x33aac
movq %rax, (%r14)
jmp 0x15205
movl %eax, 0x140(%rbx)
leaq 0x1e56f(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
leaq 0x1e849(%rip), %rsi     # 0x33a89
movq %rbx, %rdi
xorl %eax, %eax
callq 0xca10
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_touserdata
void *js_touserdata(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)
		if (!strcmp(tag, v->u.object->u.user.tag))
			return v->u.object->u.user.data;
	js_typeerror(J, "not a %s", tag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x2b140(%rip), %rax     # 0x403f8
js 0x152d0
cmpl 0x140(%r14), %esi
jge 0x152d0
movl %esi, %eax
shlq $0x4, %rax
addq 0x148(%r14), %rax
cmpb $0x7, 0xf(%rax)
jne 0x152f9
movq (%rax), %r15
cmpl $0xf, (%r15)
jne 0x152f9
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x152f9
movq 0x28(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e495(%rip), %rsi     # 0x33795
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xca10
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_remove
void js_remove(js_State *J, int idx)
{
	idx = idx < 0 ? TOP + idx : BOT + idx;
	if (idx < BOT || idx >= TOP)
		js_error(J, "stack error!");
	for (;idx < TOP - 1; ++idx)
		STACK[idx] = STACK[idx+1];
	--TOP;
}

// Assembly:
pushq %rax
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
movslq 0x140(%rdi,%rax,4), %rax
leal (%rax,%rsi), %edx
cmpl 0x144(%rdi), %edx
jl 0x15387
movl 0x140(%rdi), %ecx
cmpl %ecx, %edx
jge 0x15387
decl %ecx
cmpl %ecx, %edx
jge 0x1537f
movslq %esi, %rcx
addq %rcx, %rax
movq %rax, %rdx
shlq $0x4, %rdx
leaq 0x10(%rdx), %rsi
movq 0x148(%rdi), %rcx
incq %rax
movups (%rcx,%rsi), %xmm0
movups %xmm0, (%rcx,%rdx)
movslq 0x140(%rdi), %rcx
decq %rcx
addq $0x10, %rdx
addq $0x10, %rsi
cmpq %rcx, %rax
jl 0x15356
movl %ecx, 0x140(%rdi)
popq %rax
retq
leaq 0x1e421(%rip), %rsi     # 0x337af
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_dup2
void js_dup2(js_State *J)
{
	CHECKSTACK(2);
	STACK[TOP] = STACK[TOP-2];
	STACK[TOP+1] = STACK[TOP-1];
	TOP += 2;
}

// Assembly:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xffe, %rax            # imm = 0xFFE
jge 0x15447
shlq $0x4, %rax
movups -0x20(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
addl $0x2, 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x1fc6c(%rip), %rdx     # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_rot
void js_rot(js_State *J, int n)
{
	int i;
	js_Value tmp = STACK[TOP-1];
	for (i = 1; i < n; ++i)
		STACK[TOP-i] = STACK[TOP-i-1];
	STACK[TOP-i] = tmp;
}

// Assembly:
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movups -0x10(%rax,%rdx), %xmm0
movaps %xmm0, -0x18(%rsp)
cmpl $0x2, %esi
jl 0x15641
leal -0x1(%rsi), %eax
movq $-0x1, %rcx
movq 0x148(%rdi), %rdx
movslq 0x140(%rdi), %r8
addq %rcx, %r8
shlq $0x4, %r8
movups -0x10(%rdx,%r8), %xmm0
movups %xmm0, (%rdx,%r8)
decq %rcx
decl %eax
jne 0x1560b
movq 0x148(%rdi), %rax
movl 0x140(%rdi), %ecx
jmp 0x15646
movl $0x1, %esi
subl %esi, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_isarrayindex
int js_isarrayindex(js_State *J, const char *p, int *idx)
{
	int n = 0;

	/* check for empty string */
	if (p[0] == 0)
		return 0;

	/* check for '0' and integers with leading zero */
	if (p[0] == '0')
		return (p[1] == 0) ? *idx = 0, 1 : 0;

	while (*p) {
		int c = *p++;
		if (c >= '0' && c <= '9') {
			if (n >= INT_MAX / 10)
				return 0;
			n = n * 10 + (c - '0');
		} else {
			return 0;
		}
	}
	return *idx = n, 1;
}

// Assembly:
movzbl (%rsi), %eax
testl %eax, %eax
je 0x15672
cmpl $0x30, %eax
jne 0x15673
xorl %ecx, %ecx
cmpb $0x0, 0x1(%rsi)
movl $0x0, %eax
je 0x156a3
retq
movl %eax, %edi
incq %rsi
xorl %eax, %eax
xorl %ecx, %ecx
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x15672
cmpl $0xccccccc, %ecx        # imm = 0xCCCCCCC
jge 0x15672
leal (%rcx,%rcx,4), %ecx
movzbl %dil, %edi
leal (%rdi,%rcx,2), %ecx
movb (%rsi), %dil
incq %rsi
testb %dil, %dil
jne 0x1567c
movl %ecx, (%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_unflattenarray
void jsR_unflattenarray(js_State *J, js_Object *obj) {
	if (obj->type == JS_CARRAY && obj->u.a.simple) {
		js_Property *ref;
		int i;
		char name[32];
		if (js_try(J)) {
			obj->properties = NULL;
			js_throw(J);
		}
		for (i = 0; i < obj->u.a.flat_length; ++i) {
			js_itoa(name, i);
			ref = jsV_setproperty(J, obj, name);
			ref->value = obj->u.a.array[i];
		}
		js_free(J, obj->u.a.array);
		obj->u.a.simple = 0;
		obj->u.a.flat_length = 0;
		obj->u.a.flat_capacity = 0;
		obj->u.a.array = NULL;
		js_endtry(J);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rsi)
jne 0x1576a
movq %rsi, %r14
cmpl $0x0, 0x24(%rsi)
je 0x1576a
movq %rdi, %rbx
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x15779
leaq 0x24(%r14), %r12
cmpl $0x0, 0x28(%r14)
jle 0x1573b
xorl %eax, %eax
movq %rsp, %r15
movq %rax, %rcx
movq %rcx, %r13
movq %rax, %rbp
movl %r13d, %esi
movq %r15, %rdi
callq 0x1289d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x123f8
movq 0x30(%r14), %rcx
movups (%rcx,%rbp), %xmm0
movups %xmm0, 0x18(%rax)
incq %r13
movslq 0x28(%r14), %rdx
addq $0x10, %rbp
movq %rbp, %rax
movq %r13, %rcx
cmpq %rdx, %r13
jl 0x156fa
movq 0x30(%r14), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x0, 0x10(%r12)
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x15789
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x8e1b
leaq 0x1e0a9(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_ref
const char *js_ref(js_State *J)
{
	js_Value *v = stackidx(J, -1);
	const char *s;
	char buf[32];
	switch (v->t.type) {
	case JS_TUNDEFINED: s = "_Undefined"; break;
	case JS_TNULL: s = "_Null"; break;
	case JS_TBOOLEAN:
		s = v->u.boolean ? "_True" : "_False";
		break;
	case JS_TOBJECT:
		sprintf(buf, "%p", (void*)v->u.object);
		s = js_intern(J, buf);
		break;
	default:
		sprintf(buf, "%d", J->nextref++);
		s = js_intern(J, buf);
		break;
	}
	js_setregistry(J, s);
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movslq 0x140(%rdi), %rax
testq %rax, %rax
jle 0x157c4
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x157cb
leaq 0x2ac2d(%rip), %rax     # 0x403f8
movzbl 0xf(%rax), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x1582a
leaq 0x16073(%rip), %rdx     # 0x2b850
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1dfe3(%rip), %r14     # 0x337d0
jmp 0x1587c
cmpl $0x0, (%rax)
leaq 0x1dfeb(%rip), %rax     # 0x337e7
leaq 0x1dfde(%rip), %r14     # 0x337e1
cmoveq %rax, %r14
jmp 0x1587c
leaq 0x1dfcb(%rip), %r14     # 0x337db
jmp 0x1587c
movq (%rax), %rdx
leaq 0x1dfd2(%rip), %rsi     # 0x337ee
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x3220
jmp 0x1584c
movl 0x118(%rbx), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x118(%rbx)
leaq 0x1eae5(%rip), %rsi     # 0x34325
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x3220
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
jne 0x15860
leaq 0x2a9c4(%rip), %rsi     # 0x40220
movq %rsi, 0x28(%rbx)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xe061
movq %rax, 0x28(%rbx)
movq (%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15892
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_hasindex
static int jsR_hasindex(js_State *J, js_Object *obj, int k)
{
	char buf[32];
	if (obj->type == JS_CARRAY && obj->u.a.simple) {
		if (k >= 0 && k < obj->u.a.flat_length) {
			js_pushvalue(J, obj->u.a.array[k]);
			return 1;
		}
		return 0;
	}
	return jsR_hasproperty(J, obj, js_itoa(buf, k));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x165d3
cmpl $0x0, 0x24(%r14)
je 0x165d3
xorl %eax, %eax
testl %edx, %edx
js 0x165ee
cmpl %edx, 0x28(%r14)
jle 0x165ee
movq 0x30(%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x145a6
movl $0x1, %eax
jmp 0x165ee
movq %rsp, %r15
movq %r15, %rdi
movl %edx, %esi
callq 0x1289d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x162b5
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_setindex
static void jsR_setindex(js_State *J, js_Object *obj, int k, int transient)
{
	char buf[32];
	if (obj->type == JS_CARRAY && obj->u.a.simple && k >= 0 && k <= obj->u.a.flat_length) {
		jsR_setarrayindex(J, obj, k, stackidx(J, -1));
	} else {
		jsR_setproperty(J, obj, js_itoa(buf, k), transient);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, (%rsi)
jne 0x1661e
testl %edx, %edx
js 0x1661e
cmpl $0x0, 0x24(%rbx)
je 0x1661e
cmpl %edx, 0x28(%rbx)
jge 0x16646
movq %rsp, %r15
movq %r15, %rdi
movl %edx, %esi
callq 0x1289d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x15919
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x140(%r14), %rax
testq %rax, %rax
jle 0x16666
movq 0x148(%r14), %rcx
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
jmp 0x1666d
leaq 0x29d8b(%rip), %rcx     # 0x403f8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26fef
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_newenvironment
js_Environment *jsR_newenvironment(js_State *J, js_Object *vars, js_Environment *outer)
{
	js_Environment *E = js_malloc(J, sizeof *E);
	E->gcmark = 0;
	E->gcnext = J->gcenv;
	J->gcenv = E;
	++J->gccounter;

	E->outer = outer;
	E->variables = vars;
	return E;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %esi
callq 0xde05
movl $0x0, 0x18(%rax)
movq 0x160(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x160(%r15)
incl 0x154(%r15)
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_pushtrace
static void jsR_pushtrace(js_State *J, const char *name, const char *file, int line)
{
	if (J->tracetop + 1 == JS_ENVLIMIT)
		js_error(J, "call stack overflow");
	++J->tracetop;
	J->trace[J->tracetop].name = name;
	J->trace[J->tracetop].file = file;
	J->trace[J->tracetop].line = line;
}

// Assembly:
movslq 0x2190(%rdi), %rax
incq %rax
cmpl $0x400, %eax            # imm = 0x400
je 0x16ca6
movl %eax, 0x2190(%rdi)
leaq (%rax,%rax,2), %rax
movq %rsi, 0x2198(%rdi,%rax,8)
movq %rdx, 0x21a0(%rdi,%rax,8)
movl %ecx, 0x21a8(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1e423(%rip), %rsi     # 0x350d1
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_callcfunction
static void jsR_callcfunction(js_State *J, int n, int min, js_CFunction F)
{
	int save_top;
	int i;
	js_Value v;

	for (i = n; i < min; ++i)
		js_pushundefined(J);

	save_top = TOP;
	F(J);
	if (TOP > save_top) {
		v = *stackidx(J, -1);
		TOP = --BOT; /* clear stack */
		js_pushvalue(J, v);
	} else {
		TOP = --BOT; /* clear stack */
		js_pushundefined(J);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
subl %esi, %ebp
jle 0x16cd1
movq %rbx, %rdi
callq 0x88f1
decl %ebp
jne 0x16cc5
movl 0x140(%rbx), %ebp
movq %rbx, %rdi
callq *%r14
movl 0x140(%rbx), %eax
cmpl %ebp, %eax
jle 0x16cff
testl %eax, %eax
jle 0x16d1f
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x16d26
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x88f1
leaq 0x296d2(%rip), %rax     # 0x403f8
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl 0x144(%rbx), %eax
decl %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x140(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x145a6
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_eval
void js_eval(js_State *J)
{
	if (!js_isstring(J, -1))
		return;
	js_loadeval(J, "(eval)", js_tostring(J, -1));
	js_rot2pop1(J);
	js_copy(J, 0); /* copy 'this' */
	js_call(J, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, %esi
testl %eax, %eax
jle 0x16fc7
movq %rsi, %rcx
shlq $0x4, %rcx
addq 0x148(%rbx), %rcx
jmp 0x16fce
leaq 0x2942a(%rip), %rcx     # 0x403f8
movzbl 0xf(%rcx), %ecx
cmpl $0x6, %ecx
ja 0x1704f
movl $0x61, %edx
btl %ecx, %edx
jae 0x1704f
testl %eax, %eax
jle 0x16ff2
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0x16ff9
leaq 0x293ff(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x14e64
leaq 0x1c82a(%rip), %rsi     # 0x33832
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x17bb5
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13c1a
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x16762
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pconstruct
int js_pconstruct(js_State *J, int n)
{
	int savetop = TOP - n - 2;
	if (js_try(J)) {
		/* clean up the stack to only hold the error object */
		STACK[savetop] = STACK[TOP-1];
		TOP = savetop + 1;
		return 1;
	}
	js_construct(J, n);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x140(%rdi), %r14
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x170b6
leaq 0x140(%rbx), %rdx
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movl %r14d, %ecx
movq 0x148(%rbx), %rsi
shlq $0x4, %rax
movslq 0x140(%rbx), %rdi
shlq $0x4, %rdi
movups -0x10(%rsi,%rdi), %xmm0
movups %xmm0, -0x20(%rsi,%rax)
movl $0x1, %eax
jmp 0x170d6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x16d4d
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x170df
addq $0x8198, %rbx           # imm = 0x8198
xorl %eax, %eax
movq %rbx, %rdx
decl %ecx
movl %ecx, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c753(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pcall
int js_pcall(js_State *J, int n)
{
	int savetop = TOP - n - 2;
	if (js_try(J)) {
		/* clean up the stack to only hold the error object */
		STACK[savetop] = STACK[TOP-1];
		TOP = savetop + 1;
		return 1;
	}
	js_call(J, n);
	js_endtry(J);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x140(%rdi), %r14
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x1714b
leaq 0x140(%rbx), %rdx
movslq %ebp, %rax
subq %rax, %r14
movq %r14, %rax
movl %r14d, %ecx
movq 0x148(%rbx), %rsi
shlq $0x4, %rax
movslq 0x140(%rbx), %rdi
shlq $0x4, %rdi
movups -0x10(%rsi,%rdi), %xmm0
movups %xmm0, -0x20(%rsi,%rax)
movl $0x1, %eax
jmp 0x1716b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x16762
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x17174
addq $0x8198, %rbx           # imm = 0x8198
xorl %eax, %eax
movq %rbx, %rdx
decl %ecx
movl %ecx, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c6be(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x171ef
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)
movq 0x140(%rdi), %rdx
movq %rdx, 0xd8(%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 0x1c63b(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x17537
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 0x1c335(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movl $0x1, %ebp
jmp 0x1757a
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
movl $0x1, %ebp
testl %eax, %eax
jne 0x1757a
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x17bb5
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17587
decl %eax
movl %eax, 0x8198(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c2ab(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x175f0
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 0x1c27c(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
incl 0x140(%rbx)
movl $0x1, %ecx
jmp 0x1762b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
movl $0x1, %ecx
testl %eax, %eax
jne 0x1762b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17646
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17635
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c1fd(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x178d4
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 0x1bf9b(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x1793a
jmp 0x17904
movl %esi, %ebp
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x1791b
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x1793a
movl %eax, 0x140(%rbx)
leaq 0x1be8d(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1448c
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x17942
movq %rax, %r14
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bef0(%rip), %rsi     # 0x33839
jmp 0x17911
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x1799e
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 0x1bed1(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x17a0b
jmp 0x179d8
movl %esi, %ebp
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x179ef
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
movsd (%rsp), %xmm0
cmpl %eax, %ecx
jg 0x17a0b
movl %eax, 0x140(%rbx)
leaq 0x1bdb9(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14c3a
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17a12
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1be20(%rip), %rsi     # 0x33839
jmp 0x179e5
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x17a71
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 0x1bdfe(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x17ad8
jmp 0x17aa2
movl %esi, %r14d
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17ab9
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x17ad8
movl %eax, 0x140(%rbx)
leaq 0x1bcef(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
movq %rbx, %rdi
movl %r14d, %esi
callq 0x403b
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x17adf
movl %eax, %ebp
decl %ecx
movl %ecx, 0x8198(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bd53(%rip), %rsi     # 0x33839
jmp 0x17aaf
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x17b3e
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 0x1bd31(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x144(%rbx), %eax
cmpl %eax, 0x140(%rbx)
jge 0x17ba5
jmp 0x17b6f
movl %esi, %r14d
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17b86
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x17ba5
movl %eax, 0x140(%rbx)
leaq 0x1bc22(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
movl 0x8198(%rbx), %ebp
testl %ebp, %ebp
je 0x17bac
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14bae
decl %ebp
movl %ebp, 0x8198(%rbx)
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bc86(%rip), %rsi     # 0x33839
jmp 0x17b7c
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x13b6c
movq %rax, %rdi
callq 0x3100
movq %rbx, %rdi
testl %eax, %eax
jne 0x17c4f
movq %r15, %rsi
movq %r14, %rdx
callq 0x11d60
xorl %ecx, %ecx
testl %ebp, %ebp
setne %dl
movb %dl, %cl
movl 0x30(%rbx,%rcx,4), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8ffd
movq %rax, %r14
movq %rbx, %rdi
callq 0x11cfe
testl %ebp, %ebp
je 0x17c1e
movl $0x130, %eax            # imm = 0x130
cmpl $0x0, 0x34(%rbx)
jne 0x17c23
xorl %eax, %eax
movl %eax, %edx
jmp 0x17c27
movl $0x138, %eax            # imm = 0x138
movq (%rbx,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a293
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17c5c
decl %eax
movl %eax, 0x8198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x11cfe
movq %rbx, %rdi
callq 0x8e1b
leaq 0x1bbd6(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x17cee
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 0x1bbae(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x140(%rbx), %ecx
incl %ecx
movl %ecx, 0x140(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17cda
leaq 0x1bb8c(%rip), %rsi     # 0x3385b
movq %rbx, %rdi
callq *%rax
movl 0x140(%rbx), %ecx
movl %ecx, %edx
movl %ecx, %eax
decl %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
jmp 0x17d40
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17d50
leaq 0x1b4b9(%rip), %rdx     # 0x331c5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1787d
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x17d2a
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 0x17da8
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x133d9(%rip), %rsi     # 0x2b130
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x17bb5
movq %rbx, %rdi
callq 0x88f1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x16762
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x17da8
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17dbf
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
jmp 0x17d49
movl %eax, 0x140(%rbx)
leaq 0x1b9e9(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
leaq 0x1ba73(%rip), %rsi     # 0x33839
jmp 0x17db5
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x17e49
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 0x1ba53(%rip), %rdx     # 0x3385b
movq %rdx, (%rax,%rcx)
movl 0x140(%rbx), %ecx
incl %ecx
movl %ecx, 0x140(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17e35
leaq 0x1ba31(%rip), %rsi     # 0x3385b
movq %rbx, %rdi
callq *%rax
movl 0x140(%rbx), %ecx
movl %ecx, %edx
movl %ecx, %eax
decl %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
jmp 0x17e9b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
je 0x17eae
leaq 0x1b35e(%rip), %rdx     # 0x331c5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1787d
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x17e85
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 0x17efb
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17646
movq %rbx, %rdi
callq 0x88f1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16762
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x17efb
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x17f12
decl %eax
movl %eax, 0x8198(%rbx)
xorl %ecx, %ecx
jmp 0x17ea4
movl %eax, 0x140(%rbx)
leaq 0x1b896(%rip), %rsi     # 0x3379e
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
leaq 0x1b920(%rip), %rsi     # 0x33839
jmp 0x17f08
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
js 0x1822c
movl %edx, %ebp
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movzbl (%r14), %eax
movl %eax, 0x4(%rsp)
testb %al, %al
js 0x181e1
testl %eax, %eax
je 0x1822c
incq %r14
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x18201
movq %r15, %rdi
movq %r14, %rsi
callq 0x18239
movl %eax, %eax
addq %rax, %r14
movl 0x4(%rsp), %eax
xorl %ecx, %ecx
cmpl $0x10000, %eax          # imm = 0x10000
setge %cl
notl %ecx
addl %ecx, %ebp
jns 0x181c7
cmpl $0x10000, %eax          # imm = 0x10000
jl 0x1822a
cmpl $-0x2, %ebp
jne 0x18220
addl $0xffff0000, %eax       # imm = 0xFFFF0000
shrl $0xa, %eax
addl $0xd800, %eax           # imm = 0xD800
jmp 0x1822a
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xdc00, %eax           # imm = 0xDC00
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x18338
je 0x1835b
incq %r14
movl $0x1, %eax
jmp 0x18357
movq %r15, %rdi
movq %r14, %rsi
callq 0x18239
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
setge %al
incl %eax
addl %eax, %ebx
jmp 0x18326
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x28e6e
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x403b
movq %r14, %rsi
movl %eax, %edx
callq 0x181a5
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x18474
leaq 0x13(%rsp), %r14
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x1c2e2
movl %eax, %eax
movb $0x0, 0x13(%rsp,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13215
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bf3b(%rip), %rsi     # 0x343b6
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x670c
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x28e6e
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x403b
movq %r14, %rsi
movl %eax, %edx
callq 0x181a5
testl %eax, %eax
jns 0x184be
movsd 0x12f94(%rip), %xmm0    # 0x2b450
jmp 0x184c2
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4124
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x185e0
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movq %rax, %rdi
callq 0x3200
movq %rax, %r15
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x18600
movl %r15d, %ebp
incl %ebp
cmpl $0x10000001, %ebp       # imm = 0x10000001
jge 0x185ef
movq %rbx, %rdi
movl %ebp, %esi
callq 0xde05
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x3310
cmpl $0x2, %r12d
jl 0x185b6
movl $0x1, %eax
movl %ebp, %r14d
movl %eax, %ebp
movl %r14d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1448c
movq %rax, %r15
movq %rax, %rdi
callq 0x3200
movl %eax, %r14d
addl %r13d, %r14d
cmpl $0x10000001, %r14d      # imm = 0x10000001
jge 0x185ef
movq (%rsp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xde5c
movq %rax, (%rsp)
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3270
movl %ebp, %eax
incl %eax
movl %eax, %ebp
cmpl %eax, %r12d
jne 0x18565
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x13215
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x18614
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 0x1b17c(%rip), %rsi     # 0x33772
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc7e2
movq (%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x8e1b
leaq 0x1b21e(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666