LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: Sp_indexOf
static void Sp_indexOf(js_State *J)
{
	const char *haystack = checkstring(J, 0);
	const char *needle = js_tostring(J, 1);
	int pos = js_tointeger(J, 2);
	int len = strlen(needle);
	int k = 0;
	Rune rune;
	while (*haystack) {
		if (k >= pos && !strncmp(haystack, needle, len)) {
			js_pushnumber(J, k);
			return;
		}
		haystack += chartorune(&rune, haystack);
		++k;
	}
	js_pushnumber(J, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movl 0x144(%rbx), %eax
leaq 0x27dad(%rip), %rsi     # 0x403f8
cmpl $-0x1, %eax
jl 0x18667
incl %eax
cmpl 0x140(%rbx), %eax
jge 0x18667
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x14e64
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x403b
movl %eax, %ebp
movq %r15, %rdi
callq 0x3200
movsd 0x12db7(%rip), %xmm0    # 0x2b448
cmpb $0x0, (%r14)
je 0x186f1
movq %rbx, 0x8(%rsp)
movslq %eax, %r12
xorl %ebx, %ebx
leaq 0x14(%rsp), %r13
cmpl %ebp, %ebx
jl 0x186bc
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3160
testl %eax, %eax
je 0x186e5
movq %r13, %rdi
movq %r14, %rsi
callq 0x18239
movl %eax, %eax
incl %ebx
cmpb $0x0, (%r14,%rax)
leaq (%r14,%rax), %r14
jne 0x186a6
movq 0x8(%rsp), %rbx
movsd 0x12d65(%rip), %xmm0    # 0x2b448
jmp 0x186f1
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4124
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: Sp_lastIndexOf
static void Sp_lastIndexOf(js_State *J)
{
	const char *haystack = checkstring(J, 0);
	const char *needle = js_tostring(J, 1);
	int pos = js_isdefined(J, 2) ? js_tointeger(J, 2) : (int)strlen(haystack);
	int len = strlen(needle);
	int k = 0, last = -1;
	Rune rune;
	while (*haystack && k <= pos) {
		if (!strncmp(haystack, needle, len))
			last = k;
		haystack += chartorune(&rune, haystack);
		++k;
	}
	js_pushnumber(J, last);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movl 0x144(%rbx), %eax
leaq 0x27ccb(%rip), %r12     # 0x403f8
movq %r12, %rsi
cmpl $-0x1, %eax
jl 0x1874f
incl %eax
movq %r12, %rsi
cmpl 0x140(%rbx), %eax
jge 0x1874f
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x14e64
movq %rax, %r15
movl 0x144(%rbx), %eax
cmpl $-0x2, %eax
jl 0x1877e
addl $0x2, %eax
cmpl 0x140(%rbx), %eax
jge 0x1877e
movl %eax, %r12d
shlq $0x4, %r12
addq 0x148(%rbx), %r12
cmpb $0x1, 0xf(%r12)
jne 0x18793
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
jmp 0x187a3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x403b
movl %eax, %r12d
movq %r15, %rdi
callq 0x3200
cmpb $0x0, (%r14)
setne %cl
testl %r12d, %r12d
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1880f
movq %rbx, 0x8(%rsp)
movslq %eax, %r13
xorl %ebp, %ebp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3160
testl %eax, %eax
cmovel %ebp, %ebx
leaq 0x14(%rsp), %rdi
movq %r14, %rsi
callq 0x18239
movl %eax, %eax
cmpb $0x0, (%r14,%rax)
je 0x18804
addq %rax, %r14
leal 0x1(%rbp), %eax
cmpl %r12d, %ebp
movl %eax, %ebp
jl 0x187ce
cvtsi2sd %ebx, %xmm0
movq 0x8(%rsp), %rbx
jmp 0x18817
movsd 0x12c31(%rip), %xmm0    # 0x2b448
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4124
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: Sp_search
static void Sp_search(js_State *J)
{
	js_Regexp *re;
	const char *text;
	Resub m;

	text = checkstring(J, 0);

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

	re = js_toregexp(J, -1);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movl 0x144(%rbx), %ecx
leal 0x1(%rcx), %eax
leaq 0x27923(%rip), %rdx     # 0x403f8
cmpl $-0x1, %ecx
jl 0x18aef
cmpl 0x140(%rbx), %eax
jge 0x18aef
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
cmpb $0x7, 0xf(%rdx)
jne 0x18b0c
movq (%rdx), %rdx
cmpl $0x9, (%rdx)
jne 0x18b0c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13c1a
jmp 0x18b70
cmpl $-0x1, %ecx
jl 0x18b3d
cmpl 0x140(%rbx), %eax
jge 0x18b3d
movq 0x148(%rbx), %rcx
movl %eax, %esi
movq %rsi, %rax
shlq $0x4, %rax
cmpb $0x1, 0xf(%rcx,%rax)
je 0x18b46
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0x18b59
cmpb $0x1, 0x278c3(%rip)     # 0x40407
jne 0x18b52
leaq 0x1b869(%rip), %rsi     # 0x343b6
movq %rbx, %rdi
jmp 0x18b67
leaq 0x2789f(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x14e64
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12e00
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1524a
movq (%rax), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x28ed6
testl %eax, %eax
je 0x18b9f
movsd 0x128ab(%rip), %xmm0    # 0x2b448
jmp 0x18bb0
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x13352
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x4124
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: Sp_slice
static void Sp_slice(js_State *J)
{
	const char *str = checkstring(J, 0);
	int len = js_utflen(str);
	int s = js_tointeger(J, 1);
	int e = js_isdefined(J, 2) ? js_tointeger(J, 2) : len;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movq %rax, %rdi
callq 0x18313
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x403b
movl %eax, %r15d
movl 0x144(%rbx), %ecx
leaq 0x277fc(%rip), %rax     # 0x403f8
cmpl $-0x2, %ecx
jl 0x18c19
addl $0x2, %ecx
cmpl 0x140(%rbx), %ecx
jge 0x18c19
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
movl %ebp, %eax
je 0x18c2e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x403b
movl %r15d, %ecx
sarl $0x1f, %ecx
andl %ebp, %ecx
addl %r15d, %ecx
movl %eax, %esi
sarl $0x1f, %esi
andl %ebp, %esi
addl %eax, %esi
cmpl %ebp, %ecx
movl %ebp, %edx
cmovll %ecx, %edx
xorl %eax, %eax
testl %ecx, %ecx
cmovsl %eax, %edx
cmpl %ebp, %esi
cmovll %esi, %ebp
testl %esi, %esi
cmovsl %eax, %ebp
movl %edx, %ecx
subl %ebp, %ecx
jge 0x18c6c
subl %edx, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
jmp 0x18c76
jle 0x18c85
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2994e
leaq 0x1b72a(%rip), %rsi     # 0x343b6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x670c
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: Sp_trim
static void Sp_trim(js_State *J)
{
	const char *s, *e;
	s = checkstring(J, 0);
	while (istrim(*s))
		++s;
	e = s + strlen(s);
	while (e > s && istrim(e[-1]))
		--e;
	js_pushlstring(J, s, e - s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x28e6e
movq %rax, %r14
movq %rax, %r15
movzbl (%r15), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x19714
incq %r15
incl %r14d
jmp 0x19700
cmpl $0x20, %eax
je 0x1970c
movq %r15, %rdi
callq 0x3200
leaq (%r15,%rax), %rdx
testq %rax, %rax
jle 0x19745
movzbl -0x1(%rdx), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x19740
decq %rdx
cmpq %r15, %rdx
ja 0x1972a
jmp 0x19745
cmpl $0x20, %eax
je 0x19736
subl %r14d, %edx
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x133b3
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: S_fromCharCode
static void S_fromCharCode(js_State *J)
{
	int i, top = js_gettop(J);
	char * volatile s = NULL;
	char *p;
	Rune c;

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

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

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

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

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

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4487
leaq 0x19337(%rip), %rdx     # 0x32ce2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fd2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14940
testl %eax, %eax
je 0x19a36
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, (%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movaps (%rsp), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16762
movslq 0x140(%rbx), %rcx
testq %rcx, %rcx
jle 0x19a53
movq 0x148(%rbx), %rax
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $-0x10, %rdx
jmp 0x19a5a
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
addl $-0x2, %ecx
movl %ecx, 0x140(%rbx)
cmpl %eax, %ecx
jl 0x19a78
xorl %eax, %eax
jmp 0x19a8f
leaq 0x2699e(%rip), %rdx     # 0x403f8
movl $0x1, %eax
cmpb $0x7, 0xf(%rdx)
jne 0x19a8f
leal -0x1(%rcx), %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %ecx
jg 0x19a4f
movl %eax, 0x140(%rbx)
leaq 0x19d19(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_valueOf
static int jsV_valueOf(js_State *J, js_Object *obj)
{
	js_pushobject(J, obj);
	js_getproperty(J, -1, "valueOf");
	if (js_iscallable(J, -1)) {
		js_rot2(J);
		js_call(J, 0);
		if (js_isprimitive(J, -1))
			return 1;
		js_pop(J, 1);
		return 0;
	}
	js_pop(J, 2);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4487
leaq 0x19222(%rip), %rdx     # 0x32ccb
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fd2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14940
testl %eax, %eax
je 0x19b34
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movaps %xmm0, (%rsp)
movups -0x20(%rax,%rcx), %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movaps (%rsp), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16762
movslq 0x140(%rbx), %rcx
testq %rcx, %rcx
jle 0x19b51
movq 0x148(%rbx), %rax
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $-0x10, %rdx
jmp 0x19b58
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
addl $-0x2, %ecx
movl %ecx, 0x140(%rbx)
cmpl %eax, %ecx
jl 0x19b76
xorl %eax, %eax
jmp 0x19b8d
leaq 0x268a0(%rip), %rdx     # 0x403f8
movl $0x1, %eax
cmpb $0x7, 0xf(%rdx)
jne 0x19b8d
leal -0x1(%rcx), %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %ecx
jg 0x19b4d
movl %eax, 0x140(%rbx)
leaq 0x19c1b(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_stringtofloat
double js_stringtofloat(const char *s, char **ep)
{
	char *end;
	double n;
	const char *e = s;
	int isflt = 0;
	if (*e == '+' || *e == '-') ++e;
	while (*e >= '0' && *e <= '9') ++e;
	if (*e == '.') { ++e; isflt = 1; }
	while (*e >= '0' && *e <= '9') ++e;
	if (*e == 'e' || *e == 'E') {
		++e;
		if (*e == '+' || *e == '-') ++e;
		while (*e >= '0' && *e <= '9') ++e;
		isflt = 1;
	}
	if (isflt)
		n = js_strtod(s, &end);
	else {
		/* js_strtol doesn't parse the sign */
		if (*s == '-')
			n = -js_strtol(s+1, &end, 10);
		else if (*s == '+')
			n = js_strtol(s+1, &end, 10);
		else
			n = js_strtol(s, &end, 10);
	}
	if (end == e) {
		*ep = (char*)e;
		return n;
	}
	*ep = (char*)s;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %ecx
cmpl $0x2d, %ecx
je 0x19bb1
movq %r14, %rdi
cmpl $0x2b, %ecx
jne 0x19bb5
leaq 0x1(%r14), %rdi
movb (%rdi), %al
leal -0x30(%rax), %edx
incq %rdi
cmpb $0xa, %dl
jb 0x19bb5
xorl %r8d, %r8d
cmpb $0x2e, %al
sete %r8b
leaq (%rdi,%r8), %rdx
leaq (%rdi,%r8), %rsi
decq %rsi
leaq (%rdi,%r8), %r12
addq $-0x2, %r12
movzbl (%rsi), %edi
leal -0x30(%rdi), %r8d
incq %rsi
incq %r12
incq %rdx
cmpb $0xa, %r8b
jb 0x19bde
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x19c4d
movzbl (%rsi), %eax
cmpl $0x2b, %eax
je 0x19c0c
cmpl $0x2d, %eax
je 0x19c0c
movq %rsi, %rdx
decq %rdx
movq %rdx, %r12
movb 0x1(%r12), %al
incq %r12
addb $-0x30, %al
cmpb $0xa, %al
jb 0x19c12
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc2ce
movq (%r15), %rax
cmpq %r12, %rax
cmoveq %r12, %r14
je 0x19c3e
xorpd %xmm0, %xmm0
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x2e, %al
je 0x19c20
cmpl $0x2b, %ecx
je 0x19ca8
cmpl $0x2d, %ecx
jne 0x19cf0
leaq 0x1(%r14), %rax
movb 0x1(%r14), %cl
leal -0x30(%rcx), %edx
xorpd %xmm0, %xmm0
cmpb $0x9, %dl
ja 0x19c9e
movsd 0x1190d(%rip), %xmm1    # 0x2b588
movzbl %cl, %ecx
addl $-0x30, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x19c7b
xorpd 0x1175a(%rip), %xmm0    # 0x2b400
jmp 0x19c31
leaq 0x1(%r14), %rax
movb 0x1(%r14), %cl
leal -0x30(%rcx), %edx
xorpd %xmm0, %xmm0
cmpb $0x9, %dl
ja 0x19c31
movsd 0x118c0(%rip), %xmm1    # 0x2b588
movzbl %cl, %ecx
addl $-0x30, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x19cc8
jmp 0x19c31
leal -0x30(%rcx), %eax
xorpd %xmm0, %xmm0
cmpb $0x9, %al
ja 0x19d2e
movsd 0x11885(%rip), %xmm1    # 0x2b588
movq %r14, %rax
movzbl %cl, %ecx
addl $-0x30, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movb 0x1(%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x19d06
jmp 0x19c31
movq %r14, %rax
jmp 0x19c31
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: jsV_newstring
static js_Object *jsV_newstring(js_State *J, const char *v)
{
	js_Object *obj = jsV_newobject(J, JS_CSTRING, J->String_prototype);
	size_t n = strlen(v);
	if (n < sizeof(obj->u.s.shrstr)) {
		obj->u.s.string = obj->u.s.shrstr;
		memcpy(obj->u.s.shrstr, v, n + 1);
	} else {
		obj->u.s.string = js_strdup(J, v);
	}
	obj->u.s.length = js_utflen(v);
	return obj;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %eax
leal -0x1(%rax), %ecx
testl %eax, %eax
jle 0x19eaa
movq 0x148(%rbx), %rsi
movl %ecx, %edx
shlq $0x4, %rdx
cmpb $0x7, 0xf(%rsi,%rdx)
jne 0x19ed0
addq %rdx, %rsi
jmp 0x19eba
cmpb $0x7, 0x26556(%rip)     # 0x40407
jne 0x19ed0
leaq 0x2653e(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x14fb2
movq %rax, %r14
movl 0x140(%rbx), %eax
leal -0x1(%rax), %ecx
jmp 0x19ed3
xorl %r14d, %r14d
movl %ecx, 0x140(%rbx)
movl 0x144(%rbx), %ecx
cmpl %ecx, %eax
jle 0x19f52
movq %rbx, %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(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
leaq 0x26487(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r14, 0x18(%rax)
movl $0x1, 0x4(%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4487
movl %ecx, 0x140(%rbx)
leaq 0x1983f(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_newfunction
void js_newfunction(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CFUNCTION, J->Function_prototype);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
	{
		js_pushnumber(J, fun->numparams);
		js_defproperty(J, -2, "length", JS_READONLY | JS_DONTENUM | JS_DONTCONF);
		js_newobject(J);
		{
			js_copy(J, -2);
			js_defproperty(J, -2, "constructor", JS_DONTENUM);
		}
		js_defproperty(J, -2, "prototype", JS_DONTENUM | JS_DONTCONF);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rdi), %r12
movl $0x68, %esi
callq 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(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000002, %rcx      # imm = 0x100000002
movq %rcx, (%rax)
leaq 0x261bc(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r12, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4487
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x4124
leaq 0x19552(%rip), %rdx     # 0x33781
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x7, %ecx
callq 0x662a
movq %rbx, %rdi
callq 0x19f69
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x13c1a
leaq 0x198b8(%rip), %rdx     # 0x33b15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %ecx
callq 0x662a
leaq 0x18f5e(%rip), %rdx     # 0x331d4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x6, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x662a
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_newscript
void js_newscript(js_State *J, js_Function *fun, js_Environment *scope)
{
	js_Object *obj = jsV_newobject(J, JS_CSCRIPT, NULL);
	obj->u.f.function = fun;
	obj->u.f.scope = scope;
	js_pushobject(J, obj);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %esi
callq 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(%r15), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%r15)
incl 0x154(%r15)
movabsq $0x100000003, %rcx      # imm = 0x100000003
movq %rcx, (%rax)
leaq 0x260be(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4487
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_newcfunctionx
void js_newcfunctionx(js_State *J, js_CFunction cfun, const char *name, int length, void *data, js_Finalize finalize)
{
	js_Object *obj;

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

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

	js_endtry(J);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1a463
movq 0xa0(%rbx), %r14
movq %rbx, %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)
xorl %ecx, %ecx
movq %rcx, 0x60(%rax)
movq 0x170(%rbx), %rdx
movq %rdx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x100000004, %rdx      # imm = 0x100000004
movq %rdx, (%rax)
leaq 0x26010(%rip), %rdx     # 0x403b8
movq %rdx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %rcx, 0x30(%rax)
movl %ebp, 0x38(%rax)
movq %r15, 0x40(%rax)
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x1a47b
movq %rax, %rsi
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %rbx, %rdi
callq 0x4487
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4124
leaq 0x1937f(%rip), %rdx     # 0x33781
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %ebp, %esi
movl $0x7, %ecx
callq 0x662a
movq %rbx, %rdi
callq 0x19f69
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13c1a
leaq 0x196e6(%rip), %rdx     # 0x33b15
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %ecx
callq 0x662a
leaq 0x18d8f(%rip), %rdx     # 0x331d4
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %ecx
callq 0x662a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, (%rsp)
je 0x1a473
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rsp)
movq %rbx, %rdi
callq 0x8e1b
leaq 0x193b7(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_newuserdatax
void js_newuserdatax(js_State *J, const char *tag, void *data, js_HasProperty has, js_Put put, js_Delete delete, js_Finalize finalize)
{
	js_Object *prototype = NULL;
	js_Object *obj;

	if (js_isobject(J, -1))
		prototype = js_toobject(J, -1);
	js_pop(J, 1);

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

	obj = jsV_newobject(J, JS_CUSERDATA, prototype);
	obj->u.user.tag = tag;
	obj->u.user.data = data;
	obj->u.user.has = has;
	obj->u.user.put = put;
	obj->u.user.delete = delete;
	obj->u.user.finalize = finalize;

	js_endtry(J);

	js_pushobject(J, obj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movl 0x140(%rdi), %eax
movl %eax, %ecx
decl %ecx
testl %eax, %eax
jle 0x1a4d4
movq 0x148(%rbx), %rdx
movl %ecx, %esi
shlq $0x4, %rsi
cmpb $0x7, 0xf(%rdx,%rsi)
jne 0x1a4fb
addq %rsi, %rdx
movq %rdx, %rsi
jmp 0x1a4e4
cmpb $0x7, 0x25f2c(%rip)     # 0x40407
jne 0x1a4fb
leaq 0x25f14(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x14fb2
movq %rax, %r14
movl 0x140(%rbx), %ecx
movl %ecx, %eax
decl %ecx
jmp 0x1a500
xorl %edx, %edx
movl %edx, %r14d
movl %eax, %edx
movl %ecx, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %edx
jle 0x1a5de
movq %rbx, %rdi
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1a5ed
movq %rbx, %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(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x10000000f, %rcx      # imm = 0x10000000F
movq %rcx, (%rax)
leaq 0x25e2f(%rip), %rcx     # 0x403b8
movq %rcx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq (%rsp), %rcx
movq %rcx, 0x28(%rax)
movq %r13, 0x30(%rax)
movq %r12, 0x38(%rax)
movq %r15, 0x40(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl 0x8198(%rbx), %ecx
testl %ecx, %ecx
je 0x1a608
movq %rax, %rsi
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %rbx, %rdi
callq 0x4487
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x191b3(%rip), %rsi     # 0x3379e
jmp 0x1a60f
cmpq $0x0, 0x40(%rsp)
je 0x1a600
movq %rbx, %rdi
movq (%rsp), %rsi
callq *0x40(%rsp)
movq %rbx, %rdi
callq 0x8e1b
leaq 0x1922a(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_instanceof
int js_instanceof(js_State *J)
{
	js_Object *O, *V;

	if (!js_iscallable(J, -1))
		js_typeerror(J, "instanceof: invalid operand");

	if (!js_isobject(J, -2))
		return 0;

	js_getproperty(J, -1, "prototype");
	if (!js_isobject(J, -1))
		js_typeerror(J, "instanceof: 'prototype' property is not an object");
	O = js_toobject(J, -1);
	js_pop(J, 1);

	V = js_toobject(J, -2);
	while (V) {
		V = V->prototype;
		if (O == V)
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14940
testl %eax, %eax
je 0x1a72c
movslq 0x140(%rbx), %rax
cmpq $0x2, %rax
jge 0x1a65c
leaq 0x25d9e(%rip), %rax     # 0x403f8
jmp 0x1a66e
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x20, %rax
xorl %ebp, %ebp
cmpb $0x7, 0xf(%rax)
jne 0x1a725
leaq 0x18b53(%rip), %rdx     # 0x331d4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fd2
movl 0x140(%rbx), %eax
testl %eax, %eax
jle 0x1a6b5
decl %eax
movq 0x148(%rbx), %rsi
shlq $0x4, %rax
cmpb $0x7, 0xf(%rsi,%rax)
jne 0x1a735
addq %rax, %rsi
jmp 0x1a6c5
cmpb $0x7, 0x25d4b(%rip)     # 0x40407
jne 0x1a735
leaq 0x25d33(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x14fb2
movq %rax, %r14
movl 0x140(%rbx), %eax
movl 0x144(%rbx), %ecx
leal -0x1(%rax), %edx
movl %edx, 0x140(%rbx)
cmpl %ecx, %eax
jle 0x1a746
cmpl $0x3, %eax
jge 0x1a6f7
leaq 0x25d03(%rip), %rsi     # 0x403f8
jmp 0x1a70a
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x30, %rsi
movq %rbx, %rdi
callq 0x14fb2
testq %rax, %rax
je 0x1a725
movq 0x18(%rax), %rax
cmpq %rax, %r14
jne 0x1a712
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x193ee(%rip), %rsi     # 0x33b21
jmp 0x1a73c
leaq 0x19401(%rip), %rsi     # 0x33b3d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xca10
movl %ecx, 0x140(%rbx)
leaq 0x1904b(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_compare
int js_compare(js_State *J, int *okay)
{
	js_toprimitive(J, -2, JS_HNUMBER);
	js_toprimitive(J, -1, JS_HNUMBER);

	*okay = 1;
	if (js_isstring(J, -2) && js_isstring(J, -1)) {
		return strcmp(js_tostring(J, -2), js_tostring(J, -1));
	} else {
		double x = js_tonumber(J, -2);
		double y = js_tonumber(J, -1);
		if (isnan(x) || isnan(y))
			*okay = 0;
		return x < y ? -1 : x > y ? 1 : 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x140(%rdi), %rax
leaq 0x259c3(%rip), %r15     # 0x403f8
movq %r15, %rsi
cmpq $0x2, %rax
jl 0x1aa51
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1515d
movslq 0x140(%rbx), %rax
movq %r15, %rsi
testq %rax, %rax
jle 0x1aa80
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1515d
movl $0x1, (%r14)
movslq 0x140(%rbx), %rcx
leal -0x2(%rcx), %eax
cmpq $0x2, %rcx
jl 0x1aab2
movl %eax, %r15d
shlq $0x4, %r15
addq 0x148(%rbx), %r15
movzbl 0xf(%r15), %edx
cmpl $0x6, %edx
ja 0x1ab68
movl $0x61, %esi
btl %edx, %esi
jae 0x1ab68
testl %ecx, %ecx
jle 0x1aae9
movq 0x148(%rbx), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
addq $-0x10, %rdx
jmp 0x1aaf0
leaq 0x25908(%rip), %rdx     # 0x403f8
movzbl 0xf(%rdx), %edx
cmpl $0x6, %edx
ja 0x1ab68
movl $0x61, %esi
btl %edx, %esi
jae 0x1ab68
leaq 0x258ee(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $0x2, %ecx
jl 0x1ab1f
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x14e64
movq %rax, %r15
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x1ab49
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r14
addq $-0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14e64
movq %r15, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x32f0
leaq 0x25889(%rip), %r15     # 0x403f8
movq %r15, %rsi
cmpl $0x2, %ecx
jl 0x1ab84
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x14c75
movsd %xmm0, 0x8(%rsp)
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x1abb1
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r15
addq $-0x10, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14c75
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x1abce
ucomisd %xmm0, %xmm0
jnp 0x1abd5
movl $0x0, (%r14)
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_strictequal
int js_strictequal(js_State *J)
{
	js_Value *x = js_tovalue(J, -2);
	js_Value *y = js_tovalue(J, -1);

	if (JSV_ISSTRING(x) && JSV_ISSTRING(y))
		return !strcmp(JSV_TOSTRING(x), JSV_TOSTRING(y));

	if (x->t.type != y->t.type) return 0;
	if (x->t.type == JS_TUNDEFINED) return 1;
	if (x->t.type == JS_TNULL) return 1;
	if (x->t.type == JS_TNUMBER) return x->u.number == y->u.number;
	if (x->t.type == JS_TBOOLEAN) return x->u.boolean == y->u.boolean;
	if (x->t.type == JS_TOBJECT) return x->u.object == y->u.object;
	return 0;
}

// Assembly:
movq %rdi, %rax
movslq 0x140(%rdi), %rcx
cmpq $0x2, %rcx
jge 0x1ae7a
leaq 0x25588(%rip), %rdi     # 0x403f8
movq %rdi, %rsi
cmpl $0x1, %ecx
je 0x1ae90
jmp 0x1aea3
movq 0x148(%rax), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
leaq (%rdx,%rsi), %rdi
addq $-0x20, %rdi
movq 0x148(%rax), %rax
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
movzbl 0xf(%rdi), %ecx
cmpl $0x6, %ecx
ja 0x1aedc
movl $0x61, %eax
btl %ecx, %eax
jae 0x1aedc
movzbl 0xf(%rsi), %eax
cmpl $0x6, %eax
ja 0x1aedf
movl $0x61, %edx
btl %eax, %edx
jae 0x1aedf
testl %ecx, %ecx
je 0x1af12
cmpl $0x6, %ecx
je 0x1af02
cmpl $0x5, %ecx
jne 0x1af0b
movq (%rdi), %rdi
jmp 0x1af12
movb 0xf(%rsi), %al
cmpb %al, %cl
jne 0x1aefe
decl %ecx
cmpl $0x6, %ecx
ja 0x1aefe
leaq 0x10a33(%rip), %rax     # 0x2b924
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x1, %al
jmp 0x1af44
xorl %eax, %eax
jmp 0x1af44
movq (%rdi), %rdi
addq $0x9, %rdi
jmp 0x1af12
leaq 0x194a4(%rip), %rdi     # 0x343b6
testl %eax, %eax
je 0x1af35
cmpl $0x6, %eax
je 0x1af25
cmpl $0x5, %eax
jne 0x1af2e
movq (%rsi), %rsi
jmp 0x1af35
movq (%rsi), %rsi
addq $0x9, %rsi
jmp 0x1af35
leaq 0x19481(%rip), %rsi     # 0x343b6
pushq %rax
callq 0x32f0
testl %eax, %eax
sete %al
addq $0x8, %rsp
movzbl %al, %eax
retq
movl (%rdi), %eax
cmpl (%rsi), %eax
jmp 0x1af67
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1af44
movq (%rdi), %rax
cmpq (%rsi), %rax
sete %al
jmp 0x1af44
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: parsealt
static Renode *parsealt(struct cstate *g)
{
	Renode *alt, *x;
	alt = parsecat(g);
	while (accept(g, '|')) {
		x = alt;
		alt = newnode(g, P_ALT);
		alt->x = x;
		alt->y = parsecat(g);
	}
	return alt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x29fe4
movq %rax, %r14
cmpl $0x7c, 0xa8(%rbx)
jne 0x1b6a2
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
callq 0x1af6c
movq 0x10(%rbx), %r15
leaq 0x20(%r15), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%r15)
movq %r12, 0x4(%r15)
movl $0x0, 0x1(%r15)
movq $0x0, 0x18(%r15)
movq %r14, 0x10(%r15)
movq %rbx, %rdi
callq 0x29fe4
movq %rax, 0x18(%r15)
cmpl $0x7c, 0xa8(%rbx)
movq %r15, %r14
je 0x1b658
jmp 0x1b6a5
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: count
static int count(struct cstate *g, Renode *node, int depth)
{
	int min, max, n;
	if (!node) return 0;
	if (++depth > REG_MAXREC) die(g, "stack overflow");
	switch (node->type) {
	default: return 1;
	case P_CAT: return count(g, node->x, depth) + count(g, node->y, depth);
	case P_ALT: return count(g, node->x, depth) + count(g, node->y, depth) + 2;
	case P_REP:
		min = node->m;
		max = node->n;
		if (min == max) n = count(g, node->x, depth) * min;
		else if (max < REPINF) n = count(g, node->x, depth) * max + (max - min);
		else n = count(g, node->x, depth) * (min + 1) + 2;
		if (n < 0 || n > REG_MAXPROG) die(g, "program too large");
		return n;
	case P_PAR: return count(g, node->x, depth) + 2;
	case P_PLA: return count(g, node->x, depth) + 2;
	case P_NLA: return count(g, node->x, depth) + 2;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10271(%rip), %rbp     # 0x2b940
xorl %eax, %eax
testq %r12, %r12
je 0x1b7db
movq %rax, (%rsp)
cmpl $0x401, %r15d           # imm = 0x401
movl $0x400, %r13d           # imm = 0x400
cmovgel %r15d, %r13d
negl %r13d
incl %r15d
xorl %ebx, %ebx
leal (%r15,%r13), %eax
cmpl $0x1, %eax
je 0x1b80e
movzbl (%r12), %eax
testl %eax, %eax
jne 0x1b72e
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1b6b4
movq 0x18(%r12), %r12
addl %eax, %ebx
incl %r15d
testq %r12, %r12
jne 0x1b6f7
jmp 0x1b7aa
decl %eax
cmpl $0x8, %eax
ja 0x1b7ae
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1b6b4
movq 0x18(%r12), %r12
addl %eax, %ebx
movq (%rsp), %rax
addl %ebx, %eax
addl $0x2, %eax
jmp 0x1b6d1
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1b6b4
addl %eax, %ebx
movq (%rsp), %rax
addl %eax, %ebx
addl $0x2, %ebx
jmp 0x1b7fd
movzbl 0x2(%r12), %r13d
movzbl 0x3(%r12), %ebp
cmpb %bpl, %r13b
jne 0x1b7b9
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1b6b4
movl %eax, %ebp
imull %r13d, %ebp
jmp 0x1b7ed
xorl %ebp, %ebp
jmp 0x1b7b3
movl $0x1, %ebp
movq (%rsp), %rax
jmp 0x1b7f9
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1b6b4
cmpl $0xff, %ebp
je 0x1b7e1
imull %ebp, %eax
subl %r13d, %ebp
addl %eax, %ebp
jmp 0x1b7ed
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0x1b7f9
incl %r13d
imull %r13d, %eax
addl $0x2, %eax
movl %eax, %ebp
cmpl $0x8001, %ebp           # imm = 0x8001
movq (%rsp), %rax
jae 0x1b830
addl %ebp, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x198c1(%rip), %rax     # 0x350d6
movq %rax, 0xc0(%r14)
addq $0xc8, %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x3320
leaq 0x1835b(%rip), %rax     # 0x33b92
jmp 0x1b815
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: js_regfreex
void regfreex(void *(*alloc)(void *ctx, void *p, int n), void *ctx, Reprog *prog)
{
	if (prog) {
		if (prog->cclass)
			alloc(ctx, prog->cclass, 0);
		alloc(ctx, prog->start, 0);
		alloc(ctx, prog, 0);
	}
}

// Assembly:
testq %rdx, %rdx
je 0x1bc72
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movq 0x10(%rdx), %rsi
testq %rsi, %rsi
je 0x1bc53
movq %r14, %rdi
xorl %edx, %edx
movq %rax, %r15
callq *%rax
movq %r15, %rax
movq (%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rax, %r15
callq *%rax
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_runetochar
int
runetochar(char *str, const Rune *rune)
{
	int c = *rune;

	/* overlong null character */
	if (c == 0) {
		str[0] = (char)0xc0;
		str[1] = (char)0x80;
		return 2;
	}

	/*
	 * one character sequence
	 *	00000-0007F => 00-7F
	 */
	if(c <= Rune1) {
		str[0] = c;
		return 1;
	}

	/*
	 * two character sequence
	 *	00080-007FF => T2 Tx
	 */
	if(c <= Rune2) {
		str[0] = T2 | (c >> 1*Bitx);
		str[1] = Tx | (c & Maskx);
		return 2;
	}

	/*
	 * three character sequence
	 *	00800-0FFFF => T3 Tx Tx
	 */
	if(c > Runemax)
		c = Runeerror;
	if(c <= Rune3) {
		str[0] = T3 |  (c >> 2*Bitx);
		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
		str[2] = Tx |  (c & Maskx);
		return 3;
	}

	/*
	 * four character sequence
	 *	010000-1FFFFF => T4 Tx Tx Tx
	 */
	str[0] = T4 |  (c >> 3*Bitx);
	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
	str[3] = Tx |  (c & Maskx);
	return 4;
}

// Assembly:
movl (%rsi), %ecx
testl %ecx, %ecx
je 0x1c2f5
cmpl $0x7f, %ecx
jg 0x1c2fc
movb %cl, (%rdi)
movl $0x1, %eax
retq
movw $0x80c0, (%rdi)         # imm = 0x80C0
jmp 0x1c316
cmpl $0x7ff, %ecx            # imm = 0x7FF
ja 0x1c31c
movl %ecx, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rdi)
movl $0x2, %eax
retq
cmpl $0x110000, %ecx         # imm = 0x110000
movl $0xfffd, %eax           # imm = 0xFFFD
cmovbl %ecx, %eax
movl %eax, %ecx
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x1c356
shrl $0xc, %ecx
orb $-0x20, %cl
movb %cl, (%rdi)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rdi)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdi)
movl $0x3, %eax
retq
shrl $0x12, %ecx
orb $-0x10, %cl
movb %cl, (%rdi)
movl %eax, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rdi)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rdi)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rdi)
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_tolowerrune
Rune
tolowerrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_tolower2, nelem(ucd_tolower2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return c + p[2];
	p = ucd_bsearch(c, ucd_tolower1, nelem(ucd_tolower1)/2, 2);
	if(p && c == p[0])
		return c + p[1];
	return c;
}

// Assembly:
movl %edi, %eax
movl $0x34, %edx
leaq 0xfc81(%rip), %rcx      # 0x2c030
movl %edx, %esi
shrl %esi
leal (%rsi,%rsi,2), %edi
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c3c3
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c3c5
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c3af
testl %edx, %edx
je 0x1c3d7
cmpl %eax, (%rcx)
jg 0x1c3d7
cmpl %eax, 0x4(%rcx)
jge 0x1c411
movl $0x26e, %edx            # imm = 0x26E
leaq 0xfebd(%rip), %rcx      # 0x2c2a0
movl %edx, %esi
shrl %esi
movl %edx, %edi
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c3fc
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c3fe
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c3e3
testl %edx, %edx
je 0x1c417
cmpl %eax, (%rcx)
jne 0x1c417
addq $0x4, %rcx
jmp 0x1c415
addq $0x8, %rcx
addl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_toupperrune
Rune
toupperrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_toupper2, nelem(ucd_toupper2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return c + p[2];
	p = ucd_bsearch(c, ucd_toupper1, nelem(ucd_toupper1)/2, 2);
	if(p && c == p[0])
		return c + p[1];
	return c;
}

// Assembly:
movl %edi, %eax
movl $0x35, %edx
leaq 0x111ea(%rip), %rcx     # 0x2d610
movl %edx, %esi
shrl %esi
leal (%rsi,%rsi,2), %edi
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c43a
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c43c
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c426
testl %edx, %edx
je 0x1c44e
cmpl %eax, (%rcx)
jg 0x1c44e
cmpl %eax, 0x4(%rcx)
jge 0x1c488
movl $0x27d, %edx            # imm = 0x27D
leaq 0x11436(%rip), %rcx     # 0x2d890
movl %edx, %esi
shrl %esi
movl %edx, %edi
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c473
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c475
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c45a
testl %edx, %edx
je 0x1c48e
cmpl %eax, (%rcx)
jne 0x1c48e
addq $0x4, %rcx
jmp 0x1c48c
addq $0x8, %rcx
addl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_islowerrune
int
islowerrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_toupper2, nelem(ucd_toupper2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_toupper1, nelem(ucd_toupper1)/2, 2);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
movl $0x35, %eax
leaq 0x11175(%rip), %rcx     # 0x2d610
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,2), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c4af
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c4b1
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c49b
testl %eax, %eax
je 0x1c4c8
cmpl %edi, (%rcx)
jg 0x1c4c8
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1c503
movl $0x27d, %eax            # imm = 0x27D
leaq 0x113bc(%rip), %rcx     # 0x2d890
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c4ed
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c4ef
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c4d4
testl %eax, %eax
je 0x1c501
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1c503
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_isupperrune
int
isupperrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_tolower2, nelem(ucd_tolower2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_tolower1, nelem(ucd_tolower1)/2, 2);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
movl $0x34, %eax
leaq 0xfb20(%rip), %rcx      # 0x2c030
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,2), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c524
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c526
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c510
testl %eax, %eax
je 0x1c53d
cmpl %edi, (%rcx)
jg 0x1c53d
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1c578
movl $0x26e, %eax            # imm = 0x26E
leaq 0xfd57(%rip), %rcx      # 0x2c2a0
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c562
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c564
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c549
testl %eax, %eax
je 0x1c576
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1c578
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./utf.c
// Function: jsU_isalpharune
int
isalpharune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_alpha2, nelem(ucd_alpha2)/2, 2);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_alpha1, nelem(ucd_alpha1), 1);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
movl $0x20b, %eax            # imm = 0x20B
leaq 0x126fb(%rip), %rcx     # 0x2ec80
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c59e
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c5a0
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c585
testl %eax, %eax
je 0x1c5b7
cmpl %edi, (%rcx)
jg 0x1c5b7
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1c5ea
movl $0xa7, %eax
leaq 0x1371d(%rip), %rcx     # 0x2fce0
movl %eax, %edx
shrl %edx
cmpl %edi, (%rcx,%rdx,4)
jg 0x1c5d4
leaq (%rcx,%rdx,4), %rcx
subl %edx, %eax
jmp 0x1c5d6
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c5c3
testl %eax, %eax
je 0x1c5e8
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1c5ea
xorl %eax, %eax
retq