LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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), %ecx
movl %ecx, %eax
decl %eax
testl %ecx, %ecx
jle 0x1a991
movl %eax, %edx
shlq $0x4, %rdx
addq 0x148(%rbx), %rdx
jmp 0x1a998
leaq 0x25a60(%rip), %rdx     # 0x403f8
cmpb $0x7, 0xf(%rdx)
jne 0x1a9b4
testl %ecx, %ecx
jle 0x1a9bb
movl %eax, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
jmp 0x1a9c2
xorl %eax, %eax
movl %eax, %r14d
jmp 0x1a9cd
leaq 0x25a36(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
movl %ecx, %edx
decl %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x1aab3
movq %rbx, %rdi
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1aac2
movq %rbx, %rdi
movl $0x68, %esi
callq 0xe119
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq 0x170(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x170(%rbx)
incl 0x154(%rbx)
movabsq $0x10000000f, %rcx      # imm = 0x10000000F
movq %rcx, (%rax)
leaq 0x2595a(%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 0x1aadd
movq %rax, %rsi
decl %ecx
movl %ecx, 0x8198(%rbx)
movq %rbx, %rdi
callq 0x44e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x18cae(%rip), %rsi     # 0x3376e
jmp 0x1aae4
cmpq $0x0, 0x40(%rsp)
je 0x1aad5
movq %rbx, %rdi
movq (%rsp), %rsi
callq *0x40(%rsp)
movq %rbx, %rdi
callq 0x8ec6
leaq 0x18d25(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_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 0x14e17
testl %eax, %eax
je 0x1ac12
movslq 0x140(%rbx), %rax
cmpq $0x2, %rax
jge 0x1ab31
leaq 0x258c9(%rip), %rax     # 0x403f8
jmp 0x1ab43
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x20, %rax
xorl %ebp, %ebp
cmpb $0x7, 0xf(%rax)
jne 0x1ac0b
leaq 0x1864e(%rip), %rdx     # 0x331a4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4032
movl 0x140(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, %esi
testl %eax, %eax
jle 0x1ab82
movq %rsi, %rcx
shlq $0x4, %rcx
addq 0x148(%rbx), %rcx
jmp 0x1ab89
leaq 0x2586f(%rip), %rcx     # 0x403f8
cmpb $0x7, 0xf(%rcx)
jne 0x1ac1b
testl %eax, %eax
jle 0x1aba4
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
jmp 0x1abab
leaq 0x2584d(%rip), %rsi     # 0x403f8
movq %rbx, %rdi
callq 0x15489
movq %rax, %r14
movl 0x140(%rbx), %eax
movl 0x144(%rbx), %ecx
leal -0x1(%rax), %edx
movl %edx, 0x140(%rbx)
cmpl %ecx, %eax
jle 0x1ac2c
cmpl $0x3, %eax
jge 0x1abdd
leaq 0x2581d(%rip), %rsi     # 0x403f8
jmp 0x1abf0
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x30, %rsi
movq %rbx, %rdi
callq 0x15489
testq %rax, %rax
je 0x1ac0b
movq 0x18(%rax), %rax
cmpq %rax, %r14
jne 0x1abf8
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18ed8(%rip), %rsi     # 0x33af1
jmp 0x1ac22
leaq 0x18eeb(%rip), %rsi     # 0x33b0d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
movl %ecx, 0x140(%rbx)
leaq 0x18b35(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsvalue.c
// Function: js_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 0x254dd(%rip), %r15     # 0x403f8
movq %r15, %rsi
cmpq $0x2, %rax
jl 0x1af37
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x15634
movslq 0x140(%rbx), %rax
movq %r15, %rsi
testq %rax, %rax
jle 0x1af66
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x15634
movl $0x1, (%r14)
movslq 0x140(%rbx), %rcx
leal -0x2(%rcx), %eax
cmpq $0x2, %rcx
jl 0x1af98
movl %eax, %r15d
shlq $0x4, %r15
addq 0x148(%rbx), %r15
movzbl 0xf(%r15), %edx
cmpl $0x6, %edx
ja 0x1b04e
movl $0x61, %esi
btl %edx, %esi
jae 0x1b04e
testl %ecx, %ecx
jle 0x1afcf
movq 0x148(%rbx), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
addq $-0x10, %rdx
jmp 0x1afd6
leaq 0x25422(%rip), %rdx     # 0x403f8
movzbl 0xf(%rdx), %edx
cmpl $0x6, %edx
ja 0x1b04e
movl $0x61, %esi
btl %edx, %esi
jae 0x1b04e
leaq 0x25408(%rip), %r14     # 0x403f8
movq %r14, %rsi
cmpl $0x2, %ecx
jl 0x1b005
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1533b
movq %rax, %r15
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x1b02f
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r14
addq $-0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1533b
movq %r15, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x32f0
leaq 0x253a3(%rip), %r15     # 0x403f8
movq %r15, %rsi
cmpl $0x2, %ecx
jl 0x1b06a
movl %eax, %esi
shlq $0x4, %rsi
addq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x1514c
movsd %xmm0, 0x8(%rsp)
movslq 0x140(%rbx), %rax
testq %rax, %rax
jle 0x1b097
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r15
addq $-0x10, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1514c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x1b0b4
ucomisd %xmm0, %xmm0
jnp 0x1b0bb
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_O1/ccxvii[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
leaq 0x250ad(%rip), %rsi     # 0x403f8
movq %rsi, %rdi
cmpq $0x2, %rcx
jl 0x1b369
movq 0x148(%rax), %rdx
movq %rcx, %rdi
shlq $0x4, %rdi
addq %rdx, %rdi
addq $-0x20, %rdi
testl %ecx, %ecx
jle 0x1b380
movq 0x148(%rax), %rax
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
movzbl 0xf(%rdi), %ecx
cmpl $0x6, %ecx
ja 0x1b3b9
movl $0x61, %eax
btl %ecx, %eax
jae 0x1b3b9
movzbl 0xf(%rsi), %eax
cmpl $0x6, %eax
ja 0x1b3b9
movl $0x61, %edx
btl %eax, %edx
jae 0x1b3b9
testl %ecx, %ecx
je 0x1b3ed
cmpl $0x6, %ecx
je 0x1b3dd
cmpl $0x5, %ecx
jne 0x1b3e6
movq (%rdi), %rdi
jmp 0x1b3ed
cmpb 0xf(%rsi), %cl
jne 0x1b3d9
decl %ecx
cmpl $0x6, %ecx
ja 0x1b3d9
leaq 0x10518(%rip), %rax     # 0x2b8e4
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x1, %al
jmp 0x1b41f
xorl %eax, %eax
jmp 0x1b41f
movq (%rdi), %rdi
addq $0x9, %rdi
jmp 0x1b3ed
leaq 0x18f99(%rip), %rdi     # 0x34386
testl %eax, %eax
je 0x1b410
cmpl $0x6, %eax
je 0x1b400
cmpl $0x5, %eax
jne 0x1b409
movq (%rsi), %rsi
jmp 0x1b410
movq (%rsi), %rsi
addq $0x9, %rsi
jmp 0x1b410
leaq 0x18f76(%rip), %rsi     # 0x34386
pushq %rax
callq 0x32f0
testl %eax, %eax
sete %al
addq $0x8, %rsp
movzbl %al, %eax
retq
movl (%rdi), %eax
cmpl (%rsi), %eax
jmp 0x1b442
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1b41f
movq (%rdi), %rax
cmpq (%rsi), %rax
sete %al
jmp 0x1b41f
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x2a404
movq %rax, %r14
cmpl $0x7c, 0xa8(%rbx)
jne 0x1bb7e
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
callq 0x1b447
movq 0x10(%rbx), %r15
leaq 0x20(%r15), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%r15)
movq %r12, 0x4(%r15)
movl $0x0, 0x1(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %r14, 0x10(%r15)
movq %rbx, %rdi
callq 0x2a404
movq %rax, 0x18(%r15)
cmpl $0x7c, 0xa8(%rbx)
movq %r15, %r14
je 0x1bb34
jmp 0x1bb81
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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, %ebp
movq %rsi, %r12
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
testq %r12, %r12
je 0x1bca8
cmpl $0x400, %ebp            # imm = 0x400
jge 0x1bcbc
incl %ebp
movzbl (%r12), %eax
testl %eax, %eax
jne 0x1bbe0
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
movq 0x18(%r12), %r12
addl %eax, %ebx
jmp 0x1bba8
movl $0x1, %r15d
decl %eax
cmpl $0x8, %eax
ja 0x1bca8
leaq 0xfd08(%rip), %rcx      # 0x2b900
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
addl %eax, %ebx
addl $0x2, %ebx
jmp 0x1bcab
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
movl %eax, %r15d
movq 0x18(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
addl %r15d, %eax
addl %eax, %ebx
addl $0x2, %ebx
jmp 0x1bcab
movzbl 0x2(%r12), %r13d
movzbl 0x3(%r12), %r15d
cmpb %r15b, %r13b
jne 0x1bc6e
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
movl %eax, %r15d
imull %r13d, %r15d
jmp 0x1bc9f
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1bb90
cmpl $0xff, %r15d
je 0x1bc92
imull %r15d, %eax
subl %r13d, %r15d
addl %eax, %r15d
jmp 0x1bc9f
incl %r13d
imull %r13d, %eax
addl $0x2, %eax
movl %eax, %r15d
cmpl $0x8001, %r15d          # imm = 0x8001
jae 0x1bcde
addl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x193e3(%rip), %rax     # 0x350a6
movq %rax, 0xc0(%r14)
addq $0xc8, %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x3320
leaq 0x17e7d(%rip), %rax     # 0x33b62
jmp 0x1bcc3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x1c118
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movq 0x10(%rdx), %rsi
testq %rsi, %rsi
je 0x1c0f9
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_O1/ccxvii[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 0x1c782
cmpl $0x7f, %ecx
jg 0x1c789
movb %cl, (%rdi)
movl $0x1, %eax
retq
movw $0x80c0, (%rdi)         # imm = 0x80C0
jmp 0x1c7a3
cmpl $0x7ff, %ecx            # imm = 0x7FF
jg 0x1c7a9
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
cmovll %ecx, %eax
movl %eax, %ecx
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x1c7e3
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_O1/ccxvii[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 0xf7c4(%rip), %rcx      # 0x2c000
movl %edx, %esi
shrl %esi
leal (%rsi,%rsi,2), %edi
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c850
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c852
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c83c
testl %edx, %edx
je 0x1c85f
cmpl %eax, (%rcx)
jle 0x1c861
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c86f
cmpl %eax, (%rcx)
jg 0x1c86f
cmpl %eax, 0x4(%rcx)
jge 0x1c8b4
movl $0x26e, %edx            # imm = 0x26E
leaq 0xf9f5(%rip), %rcx      # 0x2c270
movl %edx, %esi
shrl %esi
movl %edx, %edi
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c894
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c896
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c87b
testl %edx, %edx
je 0x1c8a3
cmpl %eax, (%rcx)
jle 0x1c8a5
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c8ba
cmpl %eax, (%rcx)
jne 0x1c8ba
addq $0x4, %rcx
jmp 0x1c8b8
addq $0x8, %rcx
addl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x10d17(%rip), %rcx     # 0x2d5e0
movl %edx, %esi
shrl %esi
leal (%rsi,%rsi,2), %edi
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c8dd
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c8df
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c8c9
testl %edx, %edx
je 0x1c8ec
cmpl %eax, (%rcx)
jle 0x1c8ee
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c8fc
cmpl %eax, (%rcx)
jg 0x1c8fc
cmpl %eax, 0x4(%rcx)
jge 0x1c941
movl $0x27d, %edx            # imm = 0x27D
leaq 0x10f58(%rip), %rcx     # 0x2d860
movl %edx, %esi
shrl %esi
movl %edx, %edi
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
cmpl %eax, (%rcx,%rdi,4)
jg 0x1c921
leaq (%rcx,%rdi,4), %rcx
subl %esi, %edx
jmp 0x1c923
movl %esi, %edx
cmpl $0x1, %edx
jg 0x1c908
testl %edx, %edx
je 0x1c930
cmpl %eax, (%rcx)
jle 0x1c932
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c947
cmpl %eax, (%rcx)
jne 0x1c947
addq $0x4, %rcx
jmp 0x1c945
addq $0x8, %rcx
addl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x10c8c(%rip), %rcx     # 0x2d5e0
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,2), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c968
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c96a
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c954
testl %eax, %eax
je 0x1c977
cmpl %edi, (%rcx)
jle 0x1c979
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c98c
cmpl %edi, (%rcx)
jg 0x1c98c
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1c9d2
movl $0x27d, %eax            # imm = 0x27D
leaq 0x10ec8(%rip), %rcx     # 0x2d860
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c9b1
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c9b3
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c998
testl %eax, %eax
je 0x1c9c0
cmpl %edi, (%rcx)
jle 0x1c9c2
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c9d0
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1c9d2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0xf621(%rip), %rcx      # 0x2c000
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,2), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c9f3
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c9f5
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c9df
testl %eax, %eax
je 0x1ca02
cmpl %edi, (%rcx)
jle 0x1ca04
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1ca17
cmpl %edi, (%rcx)
jg 0x1ca17
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1ca5d
movl $0x26e, %eax            # imm = 0x26E
leaq 0xf84d(%rip), %rcx      # 0x2c270
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1ca3c
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1ca3e
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1ca23
testl %eax, %eax
je 0x1ca4b
cmpl %edi, (%rcx)
jle 0x1ca4d
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1ca5b
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1ca5d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x121e6(%rip), %rcx     # 0x2ec50
movl %eax, %edx
shrl %edx
movl %eax, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl %edi, (%rcx,%rsi,4)
jg 0x1ca83
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1ca85
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1ca6a
testl %eax, %eax
je 0x1ca92
cmpl %edi, (%rcx)
jle 0x1ca94
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1caa7
cmpl %edi, (%rcx)
jg 0x1caa7
movl $0x1, %eax
cmpl %edi, 0x4(%rcx)
jge 0x1cae5
movl $0xa7, %eax
leaq 0x131fd(%rip), %rcx     # 0x2fcb0
movl %eax, %edx
shrl %edx
cmpl %edi, (%rcx,%rdx,4)
jg 0x1cac4
leaq (%rcx,%rdx,4), %rcx
subl %edx, %eax
jmp 0x1cac6
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1cab3
testl %eax, %eax
je 0x1cad3
cmpl %edi, (%rcx)
jle 0x1cad5
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1cae3
movl $0x1, %eax
cmpl %edi, (%rcx)
je 0x1cae5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./utf.c
// Function: jsU_tolowerrune_full
const Rune *
tolowerrune_full(Rune c)
{
	const Rune *p;
	p = ucd_bsearch(c, ucd_tolower_full, nelem(ucd_tolower_full)/4, 4);
	if(p && c == p[0])
		return p + 1;
	return NULL;
}

// Assembly:
movl $0x1c, %eax
leaq 0x1345e(%rip), %rcx     # 0x2ff50
movl %eax, %edx
shrl %edx
leal (,%rdx,4), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1cb0a
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1cb0c
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1caf2
testl %eax, %eax
je 0x1cb19
cmpl %edi, (%rcx)
jle 0x1cb1b
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1cb2d
leaq 0x4(%rcx), %rdx
xorl %eax, %eax
cmpl %edi, (%rcx)
cmoveq %rdx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./utf.c
// Function: jsU_toupperrune_full
const Rune *
toupperrune_full(Rune c)
{
	const Rune *p;
	p = ucd_bsearch(c, ucd_toupper_full, nelem(ucd_toupper_full)/5, 5);
	if(p && c == p[0])
		return p + 1;
	return NULL;
}

// Assembly:
movl $0x66, %eax
leaq 0x135d4(%rip), %rcx     # 0x30110
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,4), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1cb50
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1cb52
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1cb3c
testl %eax, %eax
je 0x1cb5f
cmpl %edi, (%rcx)
jle 0x1cb61
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1cb73
leaq 0x4(%rcx), %rdx
xorl %eax, %eax
cmpl %edi, (%rcx)
cmoveq %rdx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
leal 0x1(,%rbx,2), %r12d
leal 0x2(,%rbx,2), %r13d
cmpl %edx, %r13d
jge 0x1cbcc
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x1cd7a
testl %eax, %eax
jg 0x1cbb2
movl %r12d, %r13d
movl %r13d, %r15d
leal 0x1(,%r15,2), %r12d
leal 0x2(,%r15,2), %r13d
cmpl %ebp, %r13d
jl 0x1cb9d
jmp 0x1cbcf
movl %ebx, %r15d
cmpl %ebp, %r12d
cmovll %r12d, %r15d
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x1cd7a
testl %eax, %eax
jle 0x1cc02
decl %r15d
sarl %r15d
jmp 0x1cbd6
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x1cc16
decl %r15d
shrl %r15d
cmpl %ebx, %r15d
jg 0x1cbef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x144(%rdi), %rax
leaq 0x237c1(%rip), %rcx     # 0x403f8
testq %rax, %rax
js 0x1cc53
cmpl 0x140(%r14), %eax
jge 0x1cc53
movq %rax, %rcx
shlq $0x4, %rcx
addq 0x148(%r14), %rcx
movq (%rcx), %rcx
cmpl $0x0, 0x24(%rcx)
je 0x1cc95
movq 0x30(%rcx), %rax
movl %ebp, %edx
shlq $0x4, %rdx
movups (%rax,%rdx), %xmm0
movaps %xmm0, (%rsp)
movl %ebx, %esi
shlq $0x4, %rsi
movups (%rax,%rsi), %xmm0
movups %xmm0, (%rax,%rdx)
movq 0x30(%rcx), %rax
movaps (%rsp), %xmm0
movups %xmm0, (%rax,%rsi)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2375c(%rip), %r15     # 0x403f8
movq %r15, %rsi
testl %eax, %eax
js 0x1ccbd
movq %r15, %rsi
cmpl 0x140(%r14), %eax
jge 0x1ccbd
shlq $0x4, %rax
addq 0x148(%r14), %rax
movq %rax, %rsi
movq %r14, %rdi
callq 0x15489
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
movl %eax, %r12d
movslq 0x144(%r14), %rax
testq %rax, %rax
js 0x1ccf8
cmpl 0x140(%r14), %eax
jge 0x1ccf8
shlq $0x4, %rax
addq 0x148(%r14), %rax
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x15489
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x16a4d
testl %r12d, %r12d
je 0x1cd27
testl %eax, %eax
je 0x1cd27
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1393c
jmp 0x1cd3c
testl %r12d, %r12d
je 0x1cd54
testl %eax, %eax
jne 0x1cd54
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16b45
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1393c
testl %r12d, %r12d
jne 0x1cc88
testl %eax, %eax
je 0x1cc88
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x16b45
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
jmp 0x1cd43
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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)
movq $0x0, 0x10(%rsp)
callq 0x13fbb
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1d517
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1d4bc
leaq 0x10(%rsp), %r15
leaq 0x16904(%rip), %r13     # 0x33d51
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 0x1d474
movl %r12d, %edx
jmp 0x1d4a7
movq %r12, %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl $0x25, %edx
callq 0xe0bc
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe0bc
movl %r12d, %eax
andl $0xf, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe0bc
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x1d44d
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe0bc
movq (%r14), %r14
leaq 0x8(%r14), %rax
testq %r14, %r14
leaq 0x16ea7(%rip), %rsi     # 0x34386
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x13665
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x1d529
decl %eax
movl %eax, 0x8198(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %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 0x8ec6
leaq 0x162d9(%rip), %rsi     # 0x33809
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
testq %rdx, %rdx
je 0x1d55d
movq %rbx, %rcx
incl %eax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x1d552
movl %eax, 0x18(%r14)
testq %rbx, %rbx
je 0x1d58c
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d64b
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1d6eb
movq 0x18(%rbx), %rbx
jmp 0x1d561
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rbx), %eax
cmpl $0x45, %eax
jle 0x1d5d1
cmpl $0x46, %eax
jne 0x1d5e2
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d64b
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x1d6eb
jmp 0x1d5e2
leal -0xf(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1d645
testl %eax, %eax
je 0x1d62d
cmpl $0x1, %eax
je 0x1d645
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1d5f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d592
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x1d60a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d592
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x1d61e
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d592
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d5a0
jmp 0x1d645
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d592
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d62d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x22bd9(%rip), %rsi     # 0x40240
movq %rbx, %rdi
movl $0x7, %edx
callq 0xe4b0
testl %eax, %eax
jns 0x1d6a4
cmpl $0x0, 0x10(%r12)
je 0x1d698
leaq 0x22bf9(%rip), %rsi     # 0x40280
movq %rbx, %rdi
movl $0x9, %edx
callq 0xe4b0
testl %eax, %eax
jns 0x1d6ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1670a(%rip), %rdx     # 0x33db5
jmp 0x1d6b4
leaq 0x16720(%rip), %rdx     # 0x33dd4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8de3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 $0x28, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq 0x38(%rdx), %r14
movl 0x10(%rsi), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x1d74b
leaq 0x16778(%rip), %rsi     # 0x33e94
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1d84f
leaq 0x167a0(%rip), %rsi     # 0x33ed3
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x1d762
leaq 0x16792(%rip), %rdx     # 0x33ed8
jmp 0x1d856
leaq 0x16781(%rip), %rsi     # 0x33ed3
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1d863
movl 0x8(%rsp), %eax
orl 0xc(%rsp), %eax
je 0x1d7e0
movq %rbx, 0x10(%rsp)
movslq 0x4c(%r15), %rbx
testq %rbx, %rbx
setg %r12b
movq %r15, 0x20(%rsp)
jle 0x1d7d0
movq %r13, 0x18(%rsp)
movq 0x40(%r15), %rbp
movq %rbx, %r15
negq %r15
movl $0x1, %r13d
movq -0x8(%rbp,%r13,8), %rdi
movq %r14, %rsi
callq 0x32f0
testl %eax, %eax
jne 0x1d7b7
cmpl $0x0, 0xc(%rsp)
jne 0x1d7d0
cmpl $0x0, 0x8(%rsp)
jne 0x1d834
cmpq %rbx, %r13
setb %r12b
leaq (%r15,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x1d798
jmp 0x1d7d0
testb $0x1, %r12b
movq 0x10(%rsp), %rbx
movq 0x20(%rsp), %r15
jne 0x1d822
movl 0x48(%r15), %eax
cmpl %eax, 0x4c(%r15)
jl 0x1d80e
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %edx
cmovnel %ecx, %edx
movl %edx, 0x48(%r15)
movq 0x40(%r15), %rsi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe170
movq %rax, 0x40(%r15)
movq 0x40(%r15), %rax
movslq 0x4c(%r15), %rcx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %r13d
movl %r13d, 0x4c(%r15)
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x166ea(%rip), %rdx     # 0x33f25
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x8de3
leaq 0x16648(%rip), %rdx     # 0x33e9e
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x8de3
movq 0x38(%rbx), %rdx
movl 0x4(%r13), %ecx
leaq 0x16696(%rip), %rsi     # 0x33f08
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc9f7
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x1d947
movl %edx, %ebx
movq %rsi, %r14
movl 0x28(%rsi), %eax
cmpl %eax, 0x2c(%rsi)
jl 0x1d92c
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x40, %edx
cmovnel %ecx, %edx
movl %edx, 0x28(%r14)
movq 0x20(%r14), %rsi
addl %edx, %edx
callq 0xe170
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rax
movslq 0x2c(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%r14)
movw %bx, (%rax,%rcx,2)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1651f(%rip), %rsi     # 0x33e6d
xorl %eax, %eax
callq 0xcc25
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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:
testq %rdx, %rdx
je 0x1e791
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rbx), %r12
movq 0x18(%r12), %rdx
testq %rdx, %rdx
je 0x1e77d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e792
movl 0x4(%r12), %eax
movl %eax, 0x5c(%r14)
movq 0x10(%r12), %r8
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
movl $0x18, %ecx
callq 0x1f6a1
movl 0x5c(%r14), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d8f3
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d8f3
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e725
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x5c(%rsi), %edx
callq 0x1d8f3
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d8f3
movl 0x2c(%r14), %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d8f3
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x5c(%rsi), %edx
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1d8f3
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x1f00d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d8f3
leaq 0x15136(%rip), %rsi     # 0x3414a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcc25
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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
movq %rdx, %r14
movq 0x40(%rdx), %r13
testq %r13, %r13
je 0x1f092
movl %r8d, %ebp
movl %ecx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq %r13, %rsi
movq 0x8(%r13), %r13
movl (%rsi), %eax
cmpl $0x51, %eax
je 0x1f070
cmpl $0x52, %eax
jne 0x1f085
cmpl $0x10000, %r15d         # imm = 0x10000
jae 0x1f0a9
movslq 0x4(%rsi), %rcx
movq 0x20(%r12), %rdx
movw %r15w, (%rdx,%rcx,2)
cmpl $0x51, %eax
jne 0x1f085
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x1f0a9
movslq 0x4(%rsi), %rax
movq 0x20(%r12), %rcx
movw %bp, (%rcx,%rax,2)
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
testq %r13, %r13
jne 0x1f041
movq $0x0, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1509a(%rip), %rsi     # 0x3414a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcc25
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jscompile.c
// Function: ctrycatch
static void ctrycatch(JF, js_Ast *trystm, js_Ast *catchvar, js_Ast *catchstm)
{
	int L1, L2;
	L1 = emitjump(J, F, OP_TRY);
	{
		/* if we get here, we have caught an exception in the try block */
		checkfutureword(J, F, catchvar);
		if (F->strict) {
			if (!strcmp(catchvar->string, "arguments"))
				jsC_error(J, catchvar, "redefining 'arguments' is not allowed in strict mode");
			if (!strcmp(catchvar->string, "eval"))
				jsC_error(J, catchvar, "redefining 'eval' is not allowed in strict mode");
		}
		emitline(J, F, catchvar);
		emitstring(J, F, OP_CATCH, catchvar->string);
		cstm(J, F, catchstm);
		emit(J, F, OP_ENDCATCH);
		L2 = emitjump(J, F, OP_JUMP); /* skip past the try block */
	}
	label(J, F, L1);
	cstm(J, F, trystm);
	emit(J, F, OP_ENDTRY);
	label(J, F, L2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x5c(%rsi), %edx
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4a, %edx
callq 0x1d8f3
movslq 0x2c(%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1d64b
cmpl $0x0, 0x10(%r14)
je 0x1f594
movq %r13, (%rsp)
movq %r15, %r13
movq %rbp, %r15
movq 0x38(%r12), %rbp
leaq 0x14931(%rip), %rsi     # 0x33e94
movq %rbp, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1f684
leaq 0x14959(%rip), %rsi     # 0x33ed3
movq %rbp, %rdi
callq 0x32f0
testl %eax, %eax
movq %r15, %rbp
movq %r13, %r15
movq (%rsp), %r13
je 0x1f68d
movl 0x4(%r12), %eax
movl %eax, 0x5c(%r14)
movq 0x38(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4c, %edx
callq 0x1f7fe
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d955
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4d, %edx
callq 0x1d8f3
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x51, %edx
callq 0x1d8f3
movslq 0x2c(%r14), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d8f3
movl 0x2c(%r14), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x1f673
movq 0x20(%r14), %rcx
movw %ax, (%rcx,%r15,2)
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1d955
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4b, %edx
callq 0x1d8f3
movl 0x2c(%r14), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x1f673
movq 0x20(%r14), %rcx
movw %ax, (%rcx,%r12,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14ad0(%rip), %rsi     # 0x3414a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcc25
leaq 0x14813(%rip), %rdx     # 0x33e9e
jmp 0x1f694
leaq 0x14844(%rip), %rdx     # 0x33ed8
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x8de3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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, %r12
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%r8), %r15
leaq 0x147ce(%rip), %rsi     # 0x33e94
movq %r15, %rdi
callq 0x32f0
movl %eax, %r13d
leaq 0x147fb(%rip), %rsi     # 0x33ed3
movq %r15, %rdi
callq 0x32f0
movl %eax, %r15d
testl %r13d, %r13d
jne 0x1f6f8
movl $0x0, 0xc(%r14)
movl $0x1, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1d64b
cmpl $0x14, %ebp
jne 0x1f72c
cmpl $0x0, 0x10(%r14)
je 0x1f72c
testl %r13d, %r13d
je 0x1f7ea
testl %r15d, %r15d
jne 0x1f735
leaq 0x14913(%rip), %rdx     # 0x3403a
jmp 0x1f7f1
testl %r15d, %r15d
je 0x1f7d0
movq 0x38(%r12), %r13
movslq 0x4c(%r14), %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0x1f776
movl %ebp, (%rsp)
movq 0x40(%r14), %rbp
movq -0x8(%rbp,%r15,8), %rdi
movq %r13, %rsi
callq 0x32f0
testl %eax, %eax
je 0x1f770
leaq -0x1(%r15), %rax
cmpq $0x1, %r15
movq %rax, %r15
jg 0x1f750
jmp 0x1f773
movl %r15d, %r12d
movl (%rsp), %ebp
testl %r12d, %r12d
js 0x1f7b3
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d8f3
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 0x1d8f3
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movq %r13, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f7fe
movq 0x38(%rbx), %rdx
movl 0x4(%r12), %ecx
leaq 0x14728(%rip), %rsi     # 0x33f08
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc9f7
leaq 0x14821(%rip), %rdx     # 0x34012
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x8de3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x5c(%rsi), %edx
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1d8f3
movq %r15, (%rsp)
xorl %r15d, %r15d
movzwl (%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
incq %r15
cmpq $0x4, %r15
jne 0x1f82c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[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 0x1f8cc
jp 0x1f8cc
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x1d8f3
movdqa (%rsp), %xmm0
movq %xmm0, %rax
testq %rax, %rax
jns 0x1f97d
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2d, %edx
jmp 0x1f929
ucomisd 0xbcbc(%rip), %xmm0     # 0x2b590
jb 0x1f937
movsd 0xbcba(%rip), %xmm1     # 0x2b598
ucomisd %xmm0, %xmm1
jb 0x1f937
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jne 0x1f937
jp 0x1f937
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x1d8f3
movapd (%rsp), %xmm0
addsd 0xbc81(%rip), %xmm0     # 0x2b5a0
cvttsd2si %xmm0, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1d8f3
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x7, %edx
callq 0x1d8f3
movdqa (%rsp), %xmm0
movq %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
movzwl 0x18(%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8f3
incq %r15
cmpq $0x4, %r15
jne 0x1f963
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq