LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsvalue.c
// Function: js_concat
void js_concat(js_State *J)
{
	js_toprimitive(J, -2, JS_HNONE);
	js_toprimitive(J, -1, JS_HNONE);

	if (js_isstring(J, -2) || js_isstring(J, -1)) {
		const char *sa = js_tostring(J, -2);
		const char *sb = js_tostring(J, -1);
		char * volatile sab = NULL;
		/* TODO: create js_String directly */
		if (js_try(J)) {
			js_free(J, sab);
			js_throw(J);
		}
		sab = js_malloc(J, strlen(sa) + strlen(sb) + 1);
		strcpy(sab, sa);
		strcat(sab, sb);
		js_pop(J, 2);
		js_pushstring(J, sab);
		js_endtry(J);
		js_free(J, sab);
	} else {
		double x = js_tonumber(J, -2);
		double y = js_tonumber(J, -1);
		js_pop(J, 2);
		js_pushnumber(J, x + y);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $-0x2
popq %rbp
xorl %r14d, %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0xfe13
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xfe13
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf907
testl %eax, %eax
jne 0x13c35
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf907
testl %eax, %eax
je 0x13cf1
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r12
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf64d
movq %rax, %r15
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x13d34
movq %r15, %r14
movq %r12, %rdi
callq 0x3200
movq %rax, %r15
movq %r14, %rdi
callq 0x3200
movl %r15d, %ecx
leal (%rax,%rcx), %esi
incl %esi
movq %rbx, %rdi
callq 0xa9e8
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3310
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3270
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq 0x8(%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x18(%rsp)
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xfb28
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
movsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x3f9a
jmp 0x13ce4
movq 0x8(%rsp), %rsi
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x2
popq %rbp
pushq $0x1
popq %r15
movl %ebp, %esi
movl %r15d, %edx
callq 0xfe13
pushq $-0x1
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xfe13
movl $0x1, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0xf907
testl %eax, %eax
je 0x13dc6
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xf907
testl %eax, %eax
je 0x13dc6
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0xf64d
movq %rax, %rbx
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xf64d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32f0
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0xfb28
movsd %xmm0, (%rsp)
pushq $-0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0xfb28
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x13df4
ucomisd %xmm0, %xmm0
jnp 0x13df7
andl $0x0, (%rbx)
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
ucomisd %xmm1, %xmm0
cmoval %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $-0x2
popq %rsi
callq 0xf87b
movq %rax, %rbx
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xf87b
movzbl 0xf(%rbx), %edx
cmpl $0x6, %edx
ja 0x14094
pushq $0x61
popq %rsi
btl %edx, %esi
jae 0x14094
movzbl 0xf(%rax), %ecx
cmpl $0x6, %ecx
ja 0x14097
btl %ecx, %esi
jae 0x14097
testl %edx, %edx
je 0x140ca
cmpl $0x6, %edx
je 0x140ba
cmpl $0x5, %edx
jne 0x140c3
movq (%rbx), %rbx
jmp 0x140ca
movb 0xf(%rax), %cl
cmpb %cl, %dl
jne 0x140b6
decl %edx
cmpl $0x6, %edx
ja 0x140b6
leaq 0xc84f(%rip), %rcx      # 0x208f8
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb $0x1, %al
jmp 0x140fd
xorl %eax, %eax
jmp 0x140fd
movq (%rbx), %rbx
addq $0x9, %rbx
jmp 0x140ca
leaq 0x152c7(%rip), %rbx     # 0x29391
testl %ecx, %ecx
je 0x140ed
cmpl $0x6, %ecx
je 0x140dd
cmpl $0x5, %ecx
jne 0x140e6
movq (%rax), %rax
jmp 0x140ed
movq (%rax), %rax
addq $0x9, %rax
jmp 0x140ed
leaq 0x152a4(%rip), %rax     # 0x29391
movq %rbx, %rdi
movq %rax, %rsi
callq 0x32f0
testl %eax, %eax
sete %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl (%rbx), %ecx
cmpl (%rax), %ecx
jmp 0x140fa
movsd (%rax), %xmm0
cmpeqsd (%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x140fd
movq (%rbx), %rcx
cmpq (%rax), %rcx
jmp 0x140fa
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1ea57
movq %rax, %r14
pushq $0x7c
popq %rbp
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1eb04
testl %eax, %eax
je 0x14773
movq 0x10(%rbx), %r12
leaq 0x20(%r12), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%r12)
movq %r15, 0x4(%r12)
andl $0x0, 0x1(%r12)
andq $0x0, 0x18(%r12)
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0x1ea57
movq %rax, 0x18(%r12)
movq %r12, %r14
jmp 0x1472b
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq $0x0, (%rsp)
pushq $0x1
popq %rbp
leaq 0xc16f(%rip), %r13      # 0x20914
xorl %ebx, %ebx
testq %r12, %r12
je 0x14835
cmpl $0x400, %r15d           # imm = 0x400
jge 0x148ae
movzbl (%r12), %eax
cmpq $0x9, %rax
ja 0x14898
incl %r15d
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1477f
movq 0x18(%r12), %r12
addl %eax, %ebx
jmp 0x147a7
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1477f
movq 0x18(%r12), %r12
addl %eax, %ebx
movq (%rsp), %rax
addl %ebx, %eax
addl $0x2, %eax
movq %rax, (%rsp)
jmp 0x147a5
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1477f
addl %eax, %ebx
movq (%rsp), %rax
addl %eax, %ebx
addl $0x2, %ebx
jmp 0x1489d
xorl %ebp, %ebp
jmp 0x14898
movzbl 0x2(%r12), %r13d
movzbl 0x3(%r12), %ebp
cmpb %bpl, %r13b
jne 0x14862
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1477f
movl %eax, %ebp
imull %r13d, %ebp
jmp 0x14890
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1477f
cmpl $0xff, %ebp
je 0x14884
imull %ebp, %eax
subl %r13d, %ebp
addl %eax, %ebp
jmp 0x14890
incl %r13d
imull %r13d, %eax
addl $0x2, %eax
movl %eax, %ebp
cmpl $0x8001, %ebp           # imm = 0x8001
jae 0x148bd
addl (%rsp), %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x157fc(%rip), %rsi     # 0x2a0b1
movq %r14, %rdi
callq 0x14129
leaq 0x1429e(%rip), %rsi     # 0x28b62
jmp 0x148b5
// File: /workspace/github_c_makefile_star2_O2/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 0x14cbe
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movq 0x10(%rdx), %rsi
testq %rsi, %rsi
je 0x14c9f
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_O2/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 0x15196
cmpl $0x7f, %ecx
jg 0x1519d
movb %cl, (%rdi)
pushq $0x1
jmp 0x151b9
movw $0x80c0, (%rdi)         # imm = 0x80C0
jmp 0x151b7
cmpl $0x7ff, %ecx            # imm = 0x7FF
ja 0x151bb
movl %ecx, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rdi)
pushq $0x2
popq %rax
retq
cmpl $0x110000, %ecx         # imm = 0x110000
movl $0xfffd, %eax           # imm = 0xFFFD
cmovbl %ecx, %eax
movl %eax, %ecx
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x151f3
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)
pushq $0x3
jmp 0x151b9
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)
pushq $0x4
jmp 0x151b9
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movl %edi, %ebx
leaq 0xbdba(%rip), %rsi      # 0x21000
pushq $0x34
popq %rdx
pushq $0x3
popq %rcx
callq 0x1528e
testq %rax, %rax
je 0x1525f
cmpl %ebx, (%rax)
jg 0x1525f
cmpl %ebx, 0x4(%rax)
jge 0x15284
leaq 0xc00a(%rip), %rsi      # 0x21270
pushq $0x2
popq %rcx
movl %ebx, %edi
movl $0x26e, %edx            # imm = 0x26E
callq 0x1528e
testq %rax, %rax
je 0x1528a
cmpl %ebx, (%rax)
jne 0x1528a
addq $0x4, %rax
jmp 0x15288
addq $0x8, %rax
addl (%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./utf.c
// Function: ucd_bsearch
static const Rune *
ucd_bsearch(Rune c, const Rune *t, int n, int ne)
{
	const Rune *p;
	int m;

	while(n > 1) {
		m = n/2;
		p = t + m*ne;
		if(c >= p[0]) {
			t = p;
			n = n-m;
		} else
			n = m;
	}
	if(n && c >= t[0])
		return t;
	return 0;
}

// Assembly:
movq %rsi, %rax
cmpl $0x2, %edx
jl 0x152b3
movl %edx, %esi
shrl %esi
movl %esi, %r8d
imull %ecx, %r8d
cmpl %edi, (%rax,%r8,4)
jg 0x152af
leaq (%rax,%r8,4), %rax
subl %esi, %edx
jmp 0x15291
movl %esi, %edx
jmp 0x15291
testl %edx, %edx
je 0x152bb
cmpl %edi, (%rax)
jle 0x152bd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movl %edi, %ebx
leaq 0xd318(%rip), %rsi      # 0x225e0
pushq $0x35
popq %rdx
pushq $0x3
popq %rcx
callq 0x1528e
testq %rax, %rax
je 0x152e1
cmpl %ebx, (%rax)
jg 0x152e1
cmpl %ebx, 0x4(%rax)
jge 0x15306
leaq 0xd578(%rip), %rsi      # 0x22860
pushq $0x2
popq %rcx
movl %ebx, %edi
movl $0x27d, %edx            # imm = 0x27D
callq 0x1528e
testq %rax, %rax
je 0x1530c
cmpl %ebx, (%rax)
jne 0x1530c
addq $0x4, %rax
jmp 0x1530a
addq $0x8, %rax
addl (%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xd2c4(%rip), %rsi      # 0x225e0
pushq $0x35
popq %rdx
pushq $0x3
popq %rcx
callq 0x1528e
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x15338
cmpl %ebx, (%rax)
jg 0x15338
cmpl %ebx, 0x4(%rax)
jge 0x15359
leaq 0xd521(%rip), %rsi      # 0x22860
pushq $0x2
popq %rcx
movl %ebx, %edi
movl $0x27d, %edx            # imm = 0x27D
callq 0x1528e
testq %rax, %rax
je 0x15357
cmpl %ebx, (%rax)
je 0x15359
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xbc92(%rip), %rsi      # 0x21000
pushq $0x34
popq %rdx
pushq $0x3
popq %rcx
callq 0x1528e
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x1538a
cmpl %ebx, (%rax)
jg 0x1538a
cmpl %ebx, 0x4(%rax)
jge 0x153ab
leaq 0xbedf(%rip), %rsi      # 0x21270
pushq $0x2
popq %rcx
movl %ebx, %edi
movl $0x26e, %edx            # imm = 0x26E
callq 0x1528e
testq %rax, %rax
je 0x153a9
cmpl %ebx, (%rax)
je 0x153ab
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xe890(%rip), %rsi      # 0x23c50
pushq $0x2
popq %rcx
movl $0x20b, %edx            # imm = 0x20B
callq 0x1528e
testq %rax, %rax
je 0x153db
cmpl %ebx, (%rax)
jg 0x153db
cmpl %ebx, 0x4(%rax)
jge 0x15400
leaq 0xf8ce(%rip), %rsi      # 0x24cb0
pushq $0x1
popq %rbp
movl %ebx, %edi
movl $0xa7, %edx
movl %ebp, %ecx
callq 0x1528e
testq %rax, %rax
je 0x153fc
cmpl %ebx, (%rax)
je 0x15403
xorl %ebp, %ebp
jmp 0x15403
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_sort_sift
static void Ap_sort_sift(js_State *J, int i, int end)
{
	int j = Ap_sort_leaf(J, i, end);
	while (Ap_sort_cmp(J, i, j) > 0)
		j = (j - 1) >> 1; /* parent */
	while (j > i) {
		Ap_sort_swap(J, i, j);
		j = (j - 1) >> 1; /* parent */
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
leal 0x1(,%r15,2), %r12d
leal 0x2(,%r15,2), %r13d
cmpl %ebp, %r13d
jge 0x154b4
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x15608
testl %eax, %eax
jg 0x154af
movl %r12d, %r13d
movl %r13d, %r15d
jmp 0x15485
cmpl %ebp, %r12d
cmovll %r12d, %r15d
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x15608
testl %eax, %eax
jle 0x154e7
decl %r15d
sarl %r15d
jmp 0x154bb
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x154fb
decl %r15d
shrl %r15d
cmpl %ebx, %r15d
jg 0x154d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_sort_swap
static void Ap_sort_swap(js_State *J, int idx_a, int idx_b)
{
	js_Object *obj = js_tovalue(J, 0)->u.object;
	if (obj->u.a.simple) {
		js_Value tmp = obj->u.a.array[idx_a];
		obj->u.a.array[idx_a] = obj->u.a.array[idx_b];
		obj->u.a.array[idx_b] = tmp;
	} else {
		int has_a = js_hasindex(J, 0, idx_a);
		int has_b = js_hasindex(J, 0, idx_b);
		if (has_a && has_b) {
			js_setindex(J, 0, idx_a);
			js_setindex(J, 0, idx_b);
		} else if (has_a && !has_b) {
			js_delindex(J, 0, idx_a);
			js_setindex(J, 0, idx_b);
		} else if (!has_a && has_b) {
			js_delindex(J, 0, idx_b);
			js_setindex(J, 0, idx_a);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x144(%rdi), %rax
leaq 0x21ede(%rip), %rcx     # 0x373f8
testq %rax, %rax
js 0x15536
cmpl 0x140(%r14), %eax
jge 0x15536
shlq $0x4, %rax
addq 0x148(%r14), %rax
movq %rax, %rcx
movq (%rcx), %rax
cmpl $0x0, 0x24(%rax)
je 0x15576
movq 0x30(%rax), %rcx
movl %ebp, %edx
shlq $0x4, %rdx
movups (%rcx,%rdx), %xmm0
movaps %xmm0, (%rsp)
movl %ebx, %esi
shlq $0x4, %rsi
movups (%rcx,%rsi), %xmm0
movups %xmm0, (%rcx,%rdx)
movq 0x30(%rax), %rax
movaps (%rsp), %xmm0
movups %xmm0, (%rax,%rsi)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10ecd
movl %eax, %r15d
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x10ecd
testl %r15d, %r15d
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x155b1
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xe9c5
jmp 0x155f2
testl %eax, %eax
setne %cl
testl %r15d, %r15d
sete %dl
orb %cl, %dl
je 0x155e6
testl %r15d, %r15d
sete %cl
testl %eax, %eax
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1556b
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x10fd5
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
jmp 0x155f9
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10fd5
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe9c5
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsbuiltin.c
// Function: Decode
static void Decode(js_State *J, const char *str_, const char *reserved)
{
	/* NOTE: volatile to silence GCC warning about longjmp clobbering a variable */
	const char * volatile str = str_;
	js_Buffer *sb = NULL;
	int a, b;

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

	while (*str) {
		int c = (unsigned char) *str++;
		if (c != '%')
			js_putc(J, &sb, c);
		else {
			if (!str[0] || !str[1])
				js_urierror(J, "truncated escape sequence");
			a = *str++;
			b = *str++;
			if (!jsY_ishex(a) || !jsY_ishex(b))
				js_urierror(J, "invalid escape sequence");
			c = jsY_tohex(a) << 4 | jsY_tohex(b);
			if (!strchr(reserved, c))
				js_putc(J, &sb, c);
			else {
				js_putc(J, &sb, '%');
				js_putc(J, &sb, a);
				js_putc(J, &sb, b);
			}
		}
	}
	js_putc(J, &sb, 0);

	js_pushstring(J, sb ? sb->s : "");
	js_endtry(J);
	js_free(J, sb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %rbx
movq %rsi, (%rsp)
andq $0x0, 0x8(%rsp)
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x15a5b
leaq 0x8(%rsp), %r15
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x159ee
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movzbl (%rax), %eax
movl %eax, %edx
cmpl $0x25, %eax
jne 0x159de
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x15a41
movq (%rsp), %rax
cmpb $0x0, 0x1(%rax)
je 0x15a41
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movsbl (%rax), %r12d
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movsbl (%rax), %r13d
movl %r12d, %eax
addl $-0x3a, %eax
cmpl $-0xb, %eax
ja 0x15973
movl %r12d, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x15a4a
movl %r13d, %eax
addl $-0x3a, %eax
cmpl $-0xb, %eax
ja 0x15990
movl %r13d, %eax
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x7, %eax
jbe 0x15a4a
movl %r12d, %edi
callq 0xadd8
movl %eax, %r14d
shll $0x4, %r14d
movl %r13d, %edi
callq 0xadd8
movl %eax, %ebp
orl %r14d, %ebp
movq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x32a0
movl %ebp, %edx
testq %rax, %rax
je 0x159de
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x25
popq %rdx
callq 0xa986
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xa986
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa986
jmp 0x158f4
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa986
movq (%r14), %r14
leaq 0x8(%r14), %rax
testq %r14, %r14
leaq 0x1397e(%rip), %rsi     # 0x29391
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq (%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13284(%rip), %rsi     # 0x28ccc
jmp 0x15a51
leaq 0x13295(%rip), %rsi     # 0x28ce6
xorl %eax, %eax
movq %rbx, %rdi
callq 0x9a64
movq (%rbx), %rdi
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsbuiltin.c
// Function: Encode
static void Encode(js_State *J, const char *str_, const char *unescaped)
{
	/* NOTE: volatile to silence GCC warning about longjmp clobbering a variable */
	const char * volatile str = str_;
	js_Buffer *sb = NULL;

	static const char *HEX = "0123456789ABCDEF";

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

	while (*str) {
		int c = (unsigned char) *str++;
		if (strchr(unescaped, c))
			js_putc(J, &sb, c);
		else {
			js_putc(J, &sb, '%');
			js_putc(J, &sb, HEX[(c >> 4) & 0xf]);
			js_putc(J, &sb, HEX[c & 0xf]);
		}
	}
	js_putc(J, &sb, 0);

	js_pushstring(J, sb ? sb->s : "");
	js_endtry(J);
	js_free(J, sb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
callq 0xee71
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x15b6f
leaq 0x10(%rsp), %r15
leaq 0x132a4(%rip), %r13     # 0x28d51
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x15b1c
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movzbl (%rax), %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x32a0
testq %rax, %rax
je 0x15ade
movl %r12d, %edx
jmp 0x15b0f
movq %r12, %rbp
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x25
popq %rdx
callq 0xa986
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa986
movl %r12d, %eax
andl $0xf, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa986
jmp 0x15aad
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa986
movq (%r14), %r14
leaq 0x8(%r14), %rax
testq %r14, %r14
leaq 0x13850(%rip), %rsi     # 0x29391
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xe7f7
movq %rbx, %rdi
callq 0xf5a7
movq (%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rbx)
movq %rbx, %rdi
callq 0x7714
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cparams
static void cparams(JF, js_Ast *list, js_Ast *fname)
{
	F->numparams = listlength(list);
	while (list) {
		checkfutureword(J, F, list->a);
		addlocal(J, F, list->a, 0);
		list = list->b;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
movq %rdx, %rcx
testq %rcx, %rcx
je 0x15ba1
incl %eax
movq 0x18(%rcx), %rcx
jmp 0x15b94
movl %eax, 0x18(%r14)
testq %rbx, %rbx
je 0x15bd0
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x15c99
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x15d7e
movq 0x18(%rbx), %rbx
jmp 0x15ba5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cvardecs
static void cvardecs(JF, js_Ast *node)
{
	if (node->type == AST_LIST) {
		while (node) {
			cvardecs(J, F, node->a);
			node = node->b;
		}
		return;
	}

	if (isfun(node->type))
		return; /* stop at inner functions */

	if (node->type == EXP_VAR) {
		checkfutureword(J, F, node->a);
		addlocal(J, F, node->a, 1);
	}

	if (node->a) cvardecs(J, F, node->a);
	if (node->b) cvardecs(J, F, node->b);
	if (node->c) cvardecs(J, F, node->c);
	if (node->d) cvardecs(J, F, node->d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbp
movl (%rbx), %eax
cmpl $0x46, %eax
je 0x15c0b
leal -0xf(%rax), %ecx
cmpl $0x3, %ecx
jb 0x15c8e
cmpl $0x1, %eax
je 0x15c8e
testl %eax, %eax
jne 0x15c2b
jmp 0x15c89
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x15c99
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x15d7e
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x15c3f
movq %r15, %rdi
movq %r14, %rsi
callq 0x15bd6
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x15c53
movq %r15, %rdi
movq %r14, %rsi
callq 0x15bd6
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x15c67
movq %r15, %rdi
movq %r14, %rsi
callq 0x15bd6
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x15be9
jmp 0x15c8e
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x15bd6
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x15c76
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: checkfutureword
static void checkfutureword(JF, js_Ast *exp)
{
	if (jsY_findword(exp->string, futurewords, nelem(futurewords)) >= 0)
		jsC_error(J, exp, "'%s' is a future reserved word", exp->string);
	if (F->strict) {
		if (jsY_findword(exp->string, strictfuturewords, nelem(strictfuturewords)) >= 0)
			jsC_error(J, exp, "'%s' is a strict mode future reserved word", exp->string);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x38(%rdx), %rbx
leaq 0x2158b(%rip), %rsi     # 0x37240
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0xad11
testl %eax, %eax
jns 0x15cee
cmpl $0x0, 0x10(%r12)
je 0x15ce2
leaq 0x215ad(%rip), %rsi     # 0x37280
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0xad11
testl %eax, %eax
jns 0x15cf7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x130c0(%rip), %rdx     # 0x28db5
jmp 0x15cfe
leaq 0x130d6(%rip), %rdx     # 0x28dd4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7631
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: findlocal
static int findlocal(JF, const char *name)
{
	int i;
	for (i = F->varlen; i > 0; --i)
		if (!strcmp(F->vartab[i-1], name))
			return i;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4c(%rdi), %r15d
leal 0x1(%r15), %ebp
pushq $-0x1
popq %r12
testl %r15d, %r15d
jle 0x15d49
movq 0x40(%r14), %rax
movq -0x8(%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x32f0
decq %r15
decl %ebp
testl %eax, %eax
jne 0x15d28
jmp 0x15d4c
movl %r12d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: addlocal
static int addlocal(JF, js_Ast *ident, int reuse)
{
	const char *name = ident->string;
	if (F->strict) {
		if (!strcmp(name, "arguments"))
			jsC_error(J, ident, "redefining 'arguments' is not allowed in strict mode");
		if (!strcmp(name, "eval"))
			jsC_error(J, ident, "redefining 'eval' is not allowed in strict mode");
	} else {
		if (!strcmp(name, "eval"))
			js_evalerror(J, "%s:%d: invalid use of 'eval'", J->filename, ident->line);
	}
	if (reuse || F->strict) {
		int i;
		for (i = 0; i < F->varlen; ++i) {
			if (!strcmp(F->vartab[i], name)) {
				if (reuse)
					return i+1;
				if (F->strict)
					jsC_error(J, ident, "duplicate formal parameter '%s'", name);
			}
		}
	}
	if (F->varlen >= F->varcap) {
		F->varcap = F->varcap ? F->varcap * 2 : 16;
		F->vartab = js_realloc(J, F->vartab, F->varcap * sizeof *F->vartab);
	}
	F->vartab[F->varlen] = name;
	return ++F->varlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x38(%rdx), %rbx
movl 0x10(%rsi), %r15d
testl %r15d, %r15d
je 0x15de0
leaq 0x130e8(%rip), %rsi     # 0x28e94
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x15ec2
leaq 0x13110(%rip), %rsi     # 0x28ed3
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x15ecb
movq %r12, 0x10(%rsp)
testl %ebp, %ebp
sete %r12b
jmp 0x15e07
leaq 0x130ec(%rip), %rsi     # 0x28ed3
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x15ee0
testl %ebp, %ebp
je 0x15ea2
movq %r12, 0x10(%rsp)
xorl %r12d, %r12d
movl 0x4c(%r14), %eax
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %ebp
movl %eax, 0xc(%rsp)
cmovgl %eax, %ebp
cmpq %r13, %rbp
je 0x15e44
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x32f0
testl %eax, %eax
jne 0x15e3f
testb %r12b, %r12b
je 0x15e8d
testl %r15d, %r15d
jne 0x15ea8
incq %r13
jmp 0x15e1c
movl 0xc(%rsp), %ecx
movl 0x48(%r14), %eax
cmpl %eax, %ecx
jge 0x15e56
movq 0x40(%r14), %rax
jmp 0x15e7d
leal (%rax,%rax), %ecx
testl %eax, %eax
pushq $0x10
popq %rdx
cmovnel %ecx, %edx
movl %edx, 0x48(%r14)
movq 0x40(%r14), %rsi
shll $0x3, %edx
movq (%rsp), %rdi
callq 0xaa05
movq %rax, 0x40(%r14)
movl 0x4c(%r14), %ecx
movslq %ecx, %r13
movq %rbx, (%rax,%r13,8)
incl %r13d
movl %r13d, 0x4c(%r14)
jmp 0x15e90
incl %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4c(%r14), %ecx
jmp 0x15e48
leaq 0x13076(%rip), %rdx     # 0x28f25
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7631
leaq 0x12fd5(%rip), %rdx     # 0x28e9e
jmp 0x15ed2
leaq 0x13006(%rip), %rdx     # 0x28ed8
movq (%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x7631
movq (%rsp), %rdi
movq 0x38(%rdi), %rdx
movl 0x4(%r12), %ecx
leaq 0x13014(%rip), %rsi     # 0x28f08
xorl %eax, %eax
callq 0x96ba
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitraw
static void emitraw(JF, int value)
{
	if (value != (js_Instruction)value)
		js_syntaxerror(J, "integer overflow in instruction coding");
	if (F->codelen >= F->codecap) {
		F->codecap = F->codecap ? F->codecap * 2 : 64;
		F->code = js_realloc(J, F->code, F->codecap * sizeof *F->code);
	}
	F->code[F->codelen++] = value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x10000, %edx          # imm = 0x10000
jae 0x15fea
movl %edx, %ebx
movq %rsi, %r14
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %ecx
cmpl %eax, %ecx
jge 0x15fb2
movq 0x20(%r14), %rax
jmp 0x15fd4
leal (%rax,%rax), %ecx
testl %eax, %eax
pushq $0x40
popq %rdx
cmovnel %ecx, %edx
movl %edx, 0x28(%r14)
movq 0x20(%r14), %rsi
addl %edx, %edx
callq 0xaa05
movq %rax, 0x20(%r14)
movl 0x2c(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%r14)
movslq %ecx, %rcx
movw %bx, (%rax,%rcx,2)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x12e7c(%rip), %rsi     # 0x28e6d
xorl %eax, %eax
callq 0x98e8
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cvarinit
static void cvarinit(JF, js_Ast *list)
{
	while (list) {
		js_Ast *var = list->a;
		if (var->b) {
			cexp(J, F, var->b);
			emitline(J, F, var);
			emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, var->a);
			emit(J, F, OP_POP);
		}
		list = list->b;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x14
popq %rbp
pushq $0x18
popq %r12
testq %rbx, %rbx
je 0x16c0c
movq 0x10(%rbx), %r13
movq 0x18(%r13), %rdx
testq %rdx, %rdx
je 0x16c06
movq %r15, %rdi
movq %r14, %rsi
callq 0x16c1b
movl 0x4(%r13), %eax
movl %eax, 0x5c(%r14)
movq 0x10(%r13), %r8
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x17a09
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x15d57
movq 0x18(%rbx), %rbx
jmp 0x16bc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitjump
static int emitjump(JF, int opcode)
{
	int inst;
	emit(J, F, opcode);
	inst = F->codelen;
	emitarg(J, F, 0);
	return inst;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15d57
movl 0x2c(%rbx), %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x15f91
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitjumpto
static void emitjumpto(JF, int opcode, int dest)
{
	emit(J, F, opcode);
	if (dest != (js_Instruction)dest)
		js_syntaxerror(J, "jump address integer overflow");
	emitarg(J, F, dest);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x15d57
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x1771d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x15f91
leaq 0x11a26(%rip), %rsi     # 0x2914a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x98e8
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: labeljumps
static void labeljumps(JF, js_Ast *stm, int baddr, int caddr)
{
	js_JumpList *jump = stm->jumps;
	while (jump) {
		js_JumpList *next = jump->next;
		if (jump->type == STM_BREAK)
			labelto(J, F, jump->inst, baddr);
		if (jump->type == STM_CONTINUE)
			labelto(J, F, jump->inst, caddr);
		js_free(J, jump);
		jump = next;
	}
	stm->jumps = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, (%rsp)
movq 0x40(%rdx), %r13
testq %r13, %r13
je 0x1779c
movq 0x8(%r13), %r14
movl (%r13), %eax
cmpl $0x52, %eax
jne 0x17773
movl 0x4(%r13), %edx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x17f41
movl (%r13), %eax
cmpl $0x51, %eax
jne 0x17789
movl 0x4(%r13), %edx
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %ecx
callq 0x17f41
movq (%r12), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq *0x10(%r12)
movq %r14, %r13
jmp 0x1774c
movq (%rsp), %rax
andq $0x0, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: breaktarget
static js_Ast *breaktarget(JF, js_Ast *node, const char *label)
{
	while (node) {
		if (isfun(node->type))
			break;
		if (!label) {
			if (isloop(node->type) || node->type == STM_SWITCH)
				return node;
		} else {
			if (matchlabel(node->parent, label))
				return node;
		}
		node = node->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x43f, %ebp            # imm = 0x43F
movl $0x38002, %r12d         # imm = 0x38002
testq %r15, %r15
je 0x17810
movq %r15, %r14
movl (%r15), %eax
cmpl $0x11, %eax
ja 0x177e3
btl %eax, %r12d
jb 0x17810
testq %rbx, %rbx
je 0x177fd
movq 0x8(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x17f64
testl %eax, %eax
je 0x177cd
jmp 0x17813
addl $-0x4b, %eax
cmpl $0xa, %eax
ja 0x1780a
btl %eax, %ebp
jb 0x17813
movq 0x8(%r14), %r15
jmp 0x177cd
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: addjump
static void addjump(JF, enum js_AstType type, js_Ast *target, int inst)
{
	js_JumpList *jump = js_malloc(J, sizeof *jump);
	jump->type = type;
	jump->inst = inst;
	jump->next = target->jumps;
	target->jumps = jump;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
pushq $0x10
popq %rsi
callq 0xa9e8
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
movq 0x40(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x40(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: continuetarget
static js_Ast *continuetarget(JF, js_Ast *node, const char *label)
{
	while (node) {
		if (isfun(node->type))
			break;
		if (isloop(node->type)) {
			if (!label)
				return node;
			else if (matchlabel(node->parent, label))
				return node;
		}
		node = node->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl $0x38002, %ebp          # imm = 0x38002
testq %r15, %r15
je 0x179f8
movq %r15, %r14
movl (%r15), %eax
cmpl $0x11, %eax
ja 0x179d0
btl %eax, %ebp
jb 0x179f8
addl $-0x51, %eax
cmpl $-0x7, %eax
ja 0x179de
movq 0x8(%r14), %r15
jmp 0x179bb
testq %rbx, %rbx
je 0x179fb
movq 0x8(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x17f64
testl %eax, %eax
je 0x179bb
jmp 0x179fb
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitlocal
static void emitlocal(JF, int oploc, int opvar, js_Ast *ident)
{
	int is_arguments = !strcmp(ident->string, "arguments");
	int is_eval = !strcmp(ident->string, "eval");
	int i;

	if (is_arguments) {
		F->lightweight = 0;
		F->arguments = 1;
	}

	checkfutureword(J, F, ident);
	if (F->strict && oploc == OP_SETLOCAL) {
		if (is_arguments)
			jsC_error(J, ident, "'arguments' is read-only in strict mode");
		if (is_eval)
			jsC_error(J, ident, "'eval' is read-only in strict mode");
	}
	if (is_eval)
		js_evalerror(J, "%s:%d: invalid use of 'eval'", J->filename, ident->line);

	i = findlocal(J, F, ident->string);
	if (i < 0) {
		emitstring(J, F, opvar, ident->string);
	} else {
		emit(J, F, oploc);
		emitarg(J, F, i);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%r8), %r12
leaq 0x11466(%rip), %rsi     # 0x28e94
movq %r12, %rdi
callq 0x32f0
movl %eax, %r13d
leaq 0x11493(%rip), %rsi     # 0x28ed3
movq %r12, %rdi
callq 0x32f0
movl %eax, %r12d
testl %r13d, %r13d
jne 0x17a5d
andl $0x0, 0xc(%r14)
movl $0x1, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x15c99
cmpl $0x14, %ebp
jne 0x17a91
cmpl $0x0, 0x10(%r14)
je 0x17a91
testl %r13d, %r13d
je 0x17b0b
testl %r12d, %r12d
jne 0x17a96
leaq 0x115ae(%rip), %rdx     # 0x2903a
jmp 0x17b12
testl %r12d, %r12d
je 0x17af2
movq 0x38(%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x15d0e
testl %eax, %eax
js 0x17ad5
movl %eax, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x15d57
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15f91
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17b1f
movq 0x38(%rbx), %rdx
movl 0x4(%r15), %ecx
leaq 0x11407(%rip), %rsi     # 0x28f08
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96ba
leaq 0x11500(%rip), %rdx     # 0x29012
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x7631
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitstring
static void emitstring(JF, int opcode, const char *str)
{
#define N (sizeof(str) / sizeof(js_Instruction))
	js_Instruction x[N];
	size_t i;
	emit(J, F, opcode);
	memcpy(x, &str, sizeof(str));
	for (i = 0; i < N; ++i)
		emitarg(J, F, x[i]);
#undef N
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15d57
movq %r15, 0x8(%rsp)
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x17b5a
movzwl 0x8(%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15f91
incq %r15
jmp 0x17b3e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: emitnumber
static void emitnumber(JF, double num)
{
	if (num == 0) {
		emit(J, F, OP_INTEGER);
		emitarg(J, F, 32768);
		if (signbit(num))
			emit(J, F, OP_NEG);
	} else if (num >= SHRT_MIN && num <= SHRT_MAX && num == (int)num) {
		emit(J, F, OP_INTEGER);
		emitarg(J, F, num + 32768);
	} else {
#define N (sizeof(num) / sizeof(js_Instruction))
		js_Instruction x[N];
		size_t i;
		emit(J, F, OP_NUMBER);
		memcpy(x, &num, sizeof(num));
		for (i = 0; i < N; ++i)
			emitarg(J, F, x[i]);
#undef N
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm0, (%rsp)
jne 0x17bbf
jp 0x17bbf
pushq $0x6
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15d57
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x15f91
movdqa (%rsp), %xmm0
movq %xmm0, %rax
testq %rax, %rax
js 0x17c56
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
ucomisd 0x8969(%rip), %xmm0     # 0x20530
jb 0x17c1a
movsd 0x8967(%rip), %xmm1     # 0x20538
ucomisd %xmm0, %xmm1
jb 0x17c1a
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jne 0x17c1a
jp 0x17c1a
pushq $0x6
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15d57
movapd (%rsp), %xmm0
addsd 0x893e(%rip), %xmm0     # 0x20540
cvttsd2si %xmm0, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x15f91
pushq $0x7
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15d57
movdqa (%rsp), %xmm0
movq %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x17bb5
movzwl 0x18(%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15f91
incq %r15
jmp 0x17c36
pushq $0x2d
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x15d57
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cargs
static int cargs(JF, js_Ast *list)
{
	int n = 0;
	while (list) {
		cexp(J, F, list->a);
		list = list->b;
		++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x17c9b
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x16c1b
movq 0x18(%rbx), %rbx
incl %ebp
jmp 0x17c7f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cassignop1
static void cassignop1(JF, js_Ast *lhs)
{
	switch (lhs->type) {
	case EXP_IDENTIFIER:
		emitline(J, F, lhs);
		emitlocal(J, F, OP_GETLOCAL, OP_GETVAR, lhs);
		break;
	case EXP_INDEX:
		cexp(J, F, lhs->a);
		cexp(J, F, lhs->b);
		emitline(J, F, lhs);
		emit(J, F, OP_DUP2);
		emit(J, F, OP_GETPROP);
		break;
	case EXP_MEMBER:
		cexp(J, F, lhs->a);
		emitline(J, F, lhs);
		emit(J, F, OP_DUP);
		emitstring(J, F, OP_GETPROP_S, lhs->b->string);
		break;
	default:
		jsC_error(J, lhs, "invalid l-value in assignment");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
cmpl $0x13, %eax
je 0x17d33
cmpl $0x12, %eax
je 0x17cec
cmpl $0x3, %eax
jne 0x17d73
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
pushq $0x13
popq %rdx
pushq $0x17
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x17a09
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c1b
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c1b
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d57
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x15d57
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c1b
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d57
movq 0x18(%r15), %rax
movq 0x38(%rax), %rcx
pushq $0x21
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17b1f
leaq 0x113b2(%rip), %rdx     # 0x2912c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x7631
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cassignop2
static void cassignop2(JF, js_Ast *lhs, int postfix)
{
	switch (lhs->type) {
	case EXP_IDENTIFIER:
		emitline(J, F, lhs);
		if (postfix) emit(J, F, OP_ROT2);
		emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, lhs);
		break;
	case EXP_INDEX:
		emitline(J, F, lhs);
		if (postfix) emit(J, F, OP_ROT4);
		emit(J, F, OP_SETPROP);
		break;
	case EXP_MEMBER:
		emitline(J, F, lhs);
		if (postfix) emit(J, F, OP_ROT3);
		emitstring(J, F, OP_SETPROP_S, lhs->b->string);
		break;
	default:
		jsC_error(J, lhs, "invalid l-value in assignment");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
cmpl $0x13, %eax
je 0x17e0a
cmpl $0x12, %eax
je 0x17ddd
cmpl $0x3, %eax
jne 0x17e3f
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
testl %ecx, %ecx
je 0x17dc4
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d57
pushq $0x14
popq %rdx
pushq $0x18
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x17a09
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
testl %ecx, %ecx
je 0x17df7
pushq $0x5
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d57
pushq $0x22
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x15d57
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
testl %ecx, %ecx
je 0x17e24
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d57
movq 0x18(%r15), %rax
movq 0x38(%rax), %rcx
pushq $0x23
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17b1f
leaq 0x112e6(%rip), %rdx     # 0x2912c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x7631