LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x13989(%rip), %rcx     # 0x2ff80
movl %eax, %edx
shrl %edx
leal (,%rdx,4), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c60f
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c611
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c5f7
testl %eax, %eax
je 0x1c620
movl (%rcx), %edx
cmpl %edi, %edx
jle 0x1c623
xorl %eax, %eax
retq
addq $0x4, %rcx
xorl %eax, %eax
cmpl %edi, %edx
cmoveq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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 0x13b04(%rip), %rcx     # 0x30140
movl %eax, %edx
shrl %edx
leal (%rdx,%rdx,4), %esi
cmpl %edi, (%rcx,%rsi,4)
jg 0x1c650
leaq (%rcx,%rsi,4), %rcx
subl %edx, %eax
jmp 0x1c652
movl %edx, %eax
cmpl $0x1, %eax
jg 0x1c63c
testl %eax, %eax
je 0x1c661
movl (%rcx), %edx
cmpl %edi, %edx
jle 0x1c664
xorl %eax, %eax
retq
addq $0x4, %rcx
xorl %eax, %eax
cmpl %edi, %edx
cmoveq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
leal 0x1(,%rbx,2), %r12d
leal 0x2(,%rbx,2), %r13d
cmpl %edx, %r13d
jge 0x1c6c7
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x1c85f
testl %eax, %eax
jg 0x1c6ad
movl %r12d, %r13d
movl %r13d, %r15d
leal 0x1(,%r15,2), %r12d
leal 0x2(,%r15,2), %r13d
cmpl %ebp, %r13d
jl 0x1c698
jmp 0x1c6ca
movl %ebx, %r15d
cmpl %ebp, %r12d
cmovll %r12d, %r15d
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x1c85f
testl %eax, %eax
jle 0x1c6fd
decl %r15d
sarl %r15d
jmp 0x1c6d1
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x1c711
decl %r15d
shrl %r15d
cmpl %ebx, %r15d
jg 0x1c6ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rsi
testq %rsi, %rsi
js 0x1c755
cmpl 0x140(%r14), %esi
jge 0x1c755
movq 0x148(%r14), %rax
shlq $0x4, %rsi
movq (%rax,%rsi), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1c762
addq 0x148(%r14), %rsi
jmp 0x1c7a0
movq 0x23c9c(%rip), %rax     # 0x403f8
cmpl $0x0, 0x24(%rax)
je 0x1c799
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
leaq 0x23c58(%rip), %rsi     # 0x403f8
movq %r14, %rdi
callq 0x14fb2
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x1658a
movl %eax, %r15d
movslq 0x144(%r14), %rax
leaq 0x23c32(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0x1c7e2
cmpl 0x140(%r14), %eax
jge 0x1c7e2
shlq $0x4, %rax
addq 0x148(%r14), %rax
movq %rax, %rsi
movq %r14, %rdi
callq 0x14fb2
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x1658a
testl %r15d, %r15d
je 0x1c80e
testl %eax, %eax
je 0x1c80e
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x134ed
jmp 0x1c823
testl %r15d, %r15d
je 0x1c839
testl %eax, %eax
jne 0x1c839
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16682
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x134ed
testl %r15d, %r15d
jne 0x1c78e
testl %eax, %eax
je 0x1c78e
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x16682
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
jmp 0x1c82a
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x10(%rsp)
callq 0x13b6c
movq %rax, %rdi
callq 0x3100
testl %eax, %eax
jne 0x1cfec
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1cf91
leaq 0x10(%rsp), %r15
leaq 0x16e5f(%rip), %r13     # 0x33d81
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 0x1cf49
movl %r12d, %edx
jmp 0x1cf7c
movq %r12, %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl $0x25, %edx
callq 0xdda1
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdda1
movl %r12d, %eax
andl $0xf, %eax
movsbl (%rax,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdda1
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x1cf22
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xdda1
movq (%r14), %r14
leaq 0x8(%r14), %rax
testq %r14, %r14
leaq 0x17402(%rip), %rsi     # 0x343b6
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x13215
movl 0x8198(%rbx), %eax
testl %eax, %eax
je 0x1cffe
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 0x8e1b
leaq 0x16834(%rip), %rsi     # 0x33839
xorl %eax, %eax
movq %rbx, %rdi
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rbx
testq %rdx, %rdx
je 0x1d319
movq %rdx, %r14
movq %rdi, %r15
xorl %eax, %eax
movq %rdx, %rcx
incl %eax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x1d2e0
movl %eax, 0x18(%rbx)
testq %r14, %r14
je 0x1d320
movq 0x10(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d3df
movq 0x10(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x1d4cd
movq 0x18(%r14), %r14
jmp 0x1d2ee
movl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rbx), %eax
cmpl $0x45, %eax
jle 0x1d365
cmpl $0x46, %eax
jne 0x1d376
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d3df
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x1d4cd
jmp 0x1d376
leal -0xf(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1d3d9
testl %eax, %eax
je 0x1d3c1
cmpl $0x1, %eax
je 0x1d3d9
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1d38a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d326
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x1d39e
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d326
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x1d3b2
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d326
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d334
jmp 0x1d3d9
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d326
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d3c1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22e45(%rip), %rsi     # 0x40240
movq %rbx, %rdi
movl $0x7, %edx
callq 0xe1a9
testl %eax, %eax
jns 0x1d438
cmpl $0x0, 0x10(%r12)
je 0x1d42c
leaq 0x22e65(%rip), %rsi     # 0x40280
movq %rbx, %rdi
movl $0x9, %edx
callq 0xe1a9
testl %eax, %eax
jns 0x1d441
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x169a6(%rip), %rdx     # 0x33de5
jmp 0x1d448
leaq 0x169bc(%rip), %rdx     # 0x33e04
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movq 0x38(%rdx), %rbx
movl 0x10(%rsi), %r15d
testl %r15d, %r15d
je 0x1d52d
leaq 0x169ca(%rip), %rsi     # 0x33ec4
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1d60f
movq %r12, (%rsp)
leaq 0x169ee(%rip), %rsi     # 0x33f03
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1d61e
testl %ebp, %ebp
sete %r12b
jmp 0x1d54f
leaq 0x169cf(%rip), %rsi     # 0x33f03
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1d633
testl %ebp, %ebp
je 0x1d59b
movq %r12, (%rsp)
xorl %r12d, %r12d
movl 0x4c(%r14), %ebp
testl %ebp, %ebp
jle 0x1d59f
movq %r13, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq 0x40(%r14), %r14
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
movq %rbx, %rsi
callq 0x32f0
testl %eax, %eax
jne 0x1d582
testb %r12b, %r12b
je 0x1d596
testl %r15d, %r15d
jne 0x1d5f5
incq %r13
cmpq %r13, %rbp
jne 0x1d568
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r13
jmp 0x1d59f
incl %r13d
jmp 0x1d5e3
movl 0x4c(%r14), %ebp
movl 0x48(%r14), %eax
cmpl %eax, %ebp
jge 0x1d5ad
movq 0x40(%r14), %rax
jmp 0x1d5d5
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %edx
cmovnel %ecx, %edx
movl %edx, 0x48(%r14)
movq 0x40(%r14), %rsi
shll $0x3, %edx
movq %r13, %rdi
callq 0xde5c
movq %rax, 0x40(%r14)
movl 0x4c(%r14), %ebp
movslq %ebp, %r13
movq %rbx, (%rax,%r13,8)
incl %r13d
movl %r13d, 0x4c(%r14)
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16959(%rip), %rdx     # 0x33f55
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8d38
leaq 0x168b8(%rip), %rdx     # 0x33ece
movq %r13, %rdi
movq %r12, %rsi
jmp 0x1d62c
leaq 0x168e3(%rip), %rdx     # 0x33f08
movq %r13, %rdi
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x8d38
movq 0x38(%r13), %rdx
movl 0x4(%r12), %ecx
leaq 0x168f5(%rip), %rsi     # 0x33f38
movq %r13, %rdi
xorl %eax, %eax
callq 0xc724
// File: /workspace/github_c_makefile_star2_O3/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 0x1d725
movl %edx, %ebx
movq %rsi, %r14
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %ecx
cmpl %eax, %ecx
jge 0x1d6eb
movq 0x20(%r14), %rax
jmp 0x1d70f
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 0xde5c
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 0x16771(%rip), %rsi     # 0x33e9d
xorl %eax, %eax
callq 0xc952
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0x1e54d
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 0x1e539
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e54e
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 0x1f447
movl 0x5c(%r14), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d6ca
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e4e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x5c(%rsi), %edx
callq 0x1d6ca
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d6ca
movl 0x2c(%r14), %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d6ca
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x5c(%rsi), %edx
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1d6ca
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x1edd4
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d6ca
leaq 0x1539f(%rip), %rsi     # 0x3417a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc952
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdx, %r14
movq %rsi, %r12
movq 0x40(%rdx), %rsi
testq %rsi, %rsi
je 0x1ee4d
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdi, %rbx
movq 0x8(%rsi), %r13
movl (%rsi), %eax
cmpl $0x51, %eax
je 0x1ee26
cmpl $0x52, %eax
jne 0x1ee3d
movl %r15d, %eax
cmpl $0x10000, %r15d         # imm = 0x10000
jb 0x1ee30
jmp 0x1ee64
movl %ebp, %eax
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x1ee64
movslq 0x4(%rsi), %rcx
movq 0x20(%r12), %rdx
movw %ax, (%rdx,%rcx,2)
movq (%rbx), %rdi
xorl %edx, %edx
callq *0x10(%rbx)
movq %r13, %rsi
testq %r13, %r13
jne 0x1ee08
movq $0x0, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1530f(%rip), %rsi     # 0x3417a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc952
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[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, %r12
movq %rcx, %r13
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl 0x5c(%rsi), %edx
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4a, %edx
callq 0x1d6ca
movslq 0x2c(%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d3df
cmpl $0x0, 0x10(%r14)
movq 0x38(%r13), %rbp
je 0x1f33c
leaq 0x14baf(%rip), %rsi     # 0x33ec4
movq %rbp, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1f42a
leaq 0x14bd7(%rip), %rsi     # 0x33f03
movq %rbp, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1f433
movl 0x4(%r13), %eax
movl %eax, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4c, %edx
movq %rbp, %rcx
callq 0x1f56f
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1d733
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4d, %edx
callq 0x1d6ca
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x51, %edx
callq 0x1d6ca
movslq 0x2c(%r14), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d6ca
movl 0x2c(%r14), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x1f419
movq 0x20(%r14), %rcx
movw %ax, (%rcx,%r15,2)
movq %rbx, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
callq 0x1d733
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4b, %edx
callq 0x1d6ca
movl 0x2c(%r14), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x1f419
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 0x14d5a(%rip), %rsi     # 0x3417a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc952
leaq 0x14a9d(%rip), %rdx     # 0x33ece
jmp 0x1f43a
leaq 0x14ace(%rip), %rdx     # 0x33f08
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/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 0x14a58(%rip), %rsi     # 0x33ec4
movq %r12, %rdi
callq 0x32f0
movl %eax, %r13d
leaq 0x14a85(%rip), %rsi     # 0x33f03
movq %r12, %rdi
callq 0x32f0
movl %eax, %r12d
testl %r13d, %r13d
jne 0x1f49e
movl $0x0, 0xc(%r14)
movl $0x1, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d3df
cmpl $0x14, %ebp
jne 0x1f4d2
cmpl $0x0, 0x10(%r14)
je 0x1f4d2
testl %r13d, %r13d
je 0x1f55b
testl %r12d, %r12d
jne 0x1f4d7
leaq 0x14b9d(%rip), %rdx     # 0x3406a
jmp 0x1f562
testl %r12d, %r12d
je 0x1f542
movq 0x38(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d458
testl %eax, %eax
js 0x1f525
movl %eax, %r15d
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f56f
movq 0x38(%rbx), %rdx
movl 0x4(%r15), %ecx
leaq 0x149e7(%rip), %rsi     # 0x33f38
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc724
leaq 0x14ae0(%rip), %rdx     # 0x34042
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/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 %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 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1d6ca
movq %r15, (%rsp)
xorl %r15d, %r15d
movzwl (%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
incq %r15
cmpq $0x4, %r15
jne 0x1f59d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1f63d
jp 0x1f63d
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x1d6ca
movdqa (%rsp), %xmm0
movq %xmm0, %rax
testq %rax, %rax
jns 0x1f6ee
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2d, %edx
jmp 0x1f69a
ucomisd 0xbf4b(%rip), %xmm0     # 0x2b590
jb 0x1f6a8
movsd 0xbf49(%rip), %xmm1     # 0x2b598
ucomisd %xmm0, %xmm1
jb 0x1f6a8
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jne 0x1f6a8
jp 0x1f6a8
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x1d6ca
movapd (%rsp), %xmm0
addsd 0xbf10(%rip), %xmm0     # 0x2b5a0
cvttsd2si %xmm0, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1d6ca
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x7, %edx
callq 0x1d6ca
movdqa (%rsp), %xmm0
movq %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
movzwl 0x18(%rsp,%r15,2), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
incq %r15
cmpq $0x4, %r15
jne 0x1f6d4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: carray
static void carray(JF, js_Ast *list)
{
	while (list) {
		emitline(J, F, list->a);
		if (list->a->type == EXP_ELISION) {
			emit(J, F, OP_SKIPARRAY);
		} else {
			cexp(J, F, list->a);
			emit(J, F, OP_INITARRAY);
		}
		list = list->b;
	}
}

// Assembly:
testq %rdx, %rdx
je 0x1f961
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rbx), %rax
movl 0x4(%rax), %edx
movl %edx, 0x5c(%r14)
movl $0x1b, %ebp
cmpl $0x7, (%rax)
je 0x1f936
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1e54e
movl 0x5c(%r14), %edx
movl $0x1c, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d6ca
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1f90a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: ccall
static void ccall(JF, js_Ast *fun, js_Ast *args)
{
	int n;
	switch (fun->type) {
	case EXP_INDEX:
		cexp(J, F, fun->a);
		emit(J, F, OP_DUP);
		cexp(J, F, fun->b);
		emit(J, F, OP_GETPROP);
		emit(J, F, OP_ROT2);
		break;
	case EXP_MEMBER:
		cexp(J, F, fun->a);
		emit(J, F, OP_DUP);
		emitstring(J, F, OP_GETPROP_S, fun->b->string);
		emit(J, F, OP_ROT2);
		break;
	case EXP_IDENTIFIER:
		if (!strcmp(fun->string, "eval")) {
			ceval(J, F, fun, args);
			return;
		}
		/* fallthrough */
	default:
		cexp(J, F, fun);
		emit(J, F, OP_UNDEF);
		break;
	}
	n = cargs(J, F, args);
	emit(J, F, OP_CALL);
	emitarg(J, F, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0x3, %eax
je 0x1fa3b
cmpl $0x13, %eax
je 0x1f9ed
cmpl $0x12, %eax
jne 0x1fa50
movq 0x10(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e54e
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1d6ca
movq 0x18(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e54e
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x20, %edx
callq 0x1d6ca
jmp 0x1fa34
movq 0x10(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e54e
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1d6ca
movq 0x18(%r12), %rax
movq 0x38(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x21, %edx
callq 0x1f56f
movl $0x3, %ebp
jmp 0x1fa63
movq 0x38(%r12), %rdi
leaq 0x144bc(%rip), %rsi     # 0x33f03
callq 0x32f0
testl %eax, %eax
je 0x1facf
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1e54e
movl $0xd, %ebp
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1d6ca
xorl %ebp, %ebp
testq %r15, %r15
je 0x1fa9c
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e54e
movq 0x18(%r15), %r15
incl %ebp
jmp 0x1fa80
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x29, %edx
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d6ca
testq %r15, %r15
je 0x1fb2a
movl $0x1, %ebp
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e54e
movq 0x18(%r15), %r15
incl %ebp
testq %r15, %r15
jne 0x1fad9
movl $0x0, 0xc(%rbx)
movl $0x1, 0x14(%rbx)
cmpl $0x2, %ebp
je 0x1fb56
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1d6ca
decl %ebp
cmpl $0x2, %ebp
ja 0x1fb06
jmp 0x1fb56
movl $0x0, 0xc(%rbx)
movl $0x1, 0x14(%rbx)
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0xd, %edx
callq 0x1d6ca
movl 0x5c(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x28, %edx
jmp 0x1fac2
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cdelete
static void cdelete(JF, js_Ast *exp)
{
	js_Ast *arg = exp->a;
	switch (arg->type) {
	case EXP_IDENTIFIER:
		if (F->strict)
			jsC_error(J, exp, "delete on an unqualified name is not allowed in strict mode");
		emitline(J, F, exp);
		emitlocal(J, F, OP_DELLOCAL, OP_DELVAR, arg);
		break;
	case EXP_INDEX:
		cexp(J, F, arg->a);
		cexp(J, F, arg->b);
		emitline(J, F, exp);
		emit(J, F, OP_DELPROP);
		break;
	case EXP_MEMBER:
		cexp(J, F, arg->a);
		emitline(J, F, exp);
		emitstring(J, F, OP_DELPROP_S, arg->b->string);
		break;
	default:
		jsC_error(J, exp, "invalid l-value in delete expression");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r12
movl (%r12), %eax
cmpl $0x13, %eax
je 0x1fc28
cmpl $0x12, %eax
je 0x1fbda
cmpl $0x3, %eax
jne 0x1fc64
cmpl $0x0, 0x10(%r14)
jne 0x1fc6d
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x15, %edx
movl $0x19, %ecx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f447
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movq 0x18(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x24, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d6ca
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
movq 0x18(%r12), %rax
movq 0x38(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x25, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f56f
leaq 0x144cc(%rip), %rdx     # 0x34137
jmp 0x1fc74
leaq 0x14487(%rip), %rdx     # 0x340fb
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/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 0x1fd32
cmpl $0x12, %eax
je 0x1fccd
cmpl $0x3, %eax
jne 0x1fd81
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13, %edx
movl $0x17, %ecx
movq %r15, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x1f447
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x1d6ca
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1d6ca
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1d6ca
movq 0x18(%r15), %rax
movq 0x38(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1f56f
leaq 0x143d4(%rip), %rdx     # 0x3415c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/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 0x1fe4b
cmpl $0x12, %eax
je 0x1fe00
cmpl $0x3, %eax
jne 0x1fe8f
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
testl %ecx, %ecx
je 0x1fde3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x14, %edx
movl $0x18, %ecx
movq %r15, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x1f447
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
testl %ecx, %ecx
je 0x1fe2b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5, %edx
callq 0x1d6ca
movl 0x5c(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x22, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1d6ca
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
testl %ecx, %ecx
je 0x1fe72
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x1d6ca
movq 0x18(%r15), %rax
movq 0x38(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x23, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1f56f
leaq 0x142c6(%rip), %rdx     # 0x3415c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: ctypeof
static void ctypeof(JF, js_Ast *exp)
{
	if (exp->a->type == EXP_IDENTIFIER) {
		emitline(J, F, exp->a);
		emitlocal(J, F, OP_GETLOCAL, OP_HASVAR, exp->a);
	} else {
		cexp(J, F, exp->a);
	}
	emitline(J, F, exp);
	emit(J, F, OP_TYPEOF);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %r8
cmpl $0x3, (%r8)
jne 0x1fed9
movl 0x4(%r8), %eax
movl %eax, 0x5c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x13, %edx
movl $0x16, %ecx
callq 0x1f447
jmp 0x1fee7
movq %r14, %rdi
movq %rbx, %rsi
movq %r8, %rdx
callq 0x1e54e
movl 0x4(%r15), %edx
movl %edx, 0x5c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2b, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1d6ca
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cbinary
static void cbinary(JF, js_Ast *exp, int opcode)
{
	cexp(J, F, exp->a);
	cexp(J, F, exp->b);
	emitline(J, F, exp);
	emit(J, F, opcode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rdx), %rdx
callq 0x1e54e
movq 0x18(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e54e
movl 0x4(%r14), %edx
movl %edx, 0x5c(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d6ca
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d6ca
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cassign
static void cassign(JF, js_Ast *exp)
{
	js_Ast *lhs = exp->a;
	js_Ast *rhs = exp->b;
	switch (lhs->type) {
	case EXP_IDENTIFIER:
		cexp(J, F, rhs);
		emitline(J, F, exp);
		emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, lhs);
		break;
	case EXP_INDEX:
		cexp(J, F, lhs->a);
		cexp(J, F, lhs->b);
		cexp(J, F, rhs);
		emitline(J, F, exp);
		emit(J, F, OP_SETPROP);
		break;
	case EXP_MEMBER:
		cexp(J, F, lhs->a);
		cexp(J, F, rhs);
		emitline(J, F, exp);
		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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r12
movq 0x18(%rdx), %r13
movl (%r12), %eax
cmpl $0x13, %eax
je 0x20071
cmpl $0x12, %eax
je 0x20017
cmpl $0x3, %eax
jne 0x200b9
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1e54e
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x14, %edx
movl $0x18, %ecx
movq %r12, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f447
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movq 0x18(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1e54e
movl 0x4(%r15), %edx
movl %edx, 0x5c(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d6ca
movq %rbx, %rdi
movq %r14, %rsi
movl $0x22, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1d6ca
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e54e
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1e54e
movl 0x4(%r15), %eax
movl %eax, 0x5c(%r14)
movq 0x18(%r12), %rax
movq 0x38(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x23, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f56f
leaq 0x1409c(%rip), %rdx     # 0x3415c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x8d38
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: cassignop
static void cassignop(JF, js_Ast *exp, int opcode)
{
	js_Ast *lhs = exp->a;
	js_Ast *rhs = exp->b;
	cassignop1(J, F, lhs);
	cexp(J, F, rhs);
	emitline(J, F, exp);
	emit(J, F, opcode);
	cassignop2(J, F, lhs, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdx), %r12
movq 0x18(%rdx), %r13
movq %r12, %rdx
callq 0x1fc81
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1e54e
movl 0x4(%r14), %edx
movl %edx, 0x5c(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d6ca
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1d6ca
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fd95
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jscompile.c
// Function: matchlabel
static int matchlabel(js_Ast *node, const char *label)
{
	while (node && node->type == STM_LABEL) {
		if (!strcmp(node->a->string, label))
			return 1;
		node = node->parent;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2017a
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x59, (%r15)
jne 0x2017a
movq 0x10(%r15), %rax
movq 0x38(%rax), %rdi
movq %r14, %rsi
callq 0x32f0
testl %eax, %eax
je 0x20175
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x20150
jmp 0x2017a
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: js_todate
static double js_todate(js_State *J, int idx)
{
	js_Object *self = js_toobject(J, idx);
	if (self->type != JS_CDATE)
		js_typeerror(J, "not a date");
	return self->u.number;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x20264(%rip), %rsi     # 0x403f8
testq %rax, %rax
js 0x201af
cmpl 0x140(%rbx), %eax
jge 0x201af
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x14fb2
cmpl $0xa, (%rax)
jne 0x201c3
movsd 0x20(%rax), %xmm0
popq %rbx
retq
leaq 0x1404e(%rip), %rsi     # 0x34218
movq %rbx, %rdi
xorl %eax, %eax
callq 0xca10
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: fmtdatetime
static char *fmtdatetime(char *buf, double t, double tza)
{
	char dbuf[20], tbuf[20];
	if (!isfinite(t))
		return "Invalid Date";
	fmtdate(dbuf, t);
	fmttime(tbuf, t, tza);
	sprintf(buf, "%sT%s", dbuf, tbuf);
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x201ff
leaq 0x14026(%rip), %rbx     # 0x34223
jmp 0x20249
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x202c2
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2033d
leaq 0x13ff7(%rip), %rsi     # 0x34230
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3220
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: LocalTZA
static double LocalTZA(void)
{
	static int once = 1;
	static double tza = 0;
	if (once) {
		time_t now = time(NULL);
		time_t utc = mktime(gmtime(&now));
		time_t loc = mktime(localtime(&now));
		tza = (loc - utc) * 1000;
		once = 0;
	}
	return tza;
}

// Assembly:
cmpb $0x1, 0x201cb(%rip)     # 0x40428
jne 0x20268
movsd 0x201c9(%rip), %xmm0    # 0x40430
retq
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x33f0
movq %rsp, %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3050
movq %rax, %r14
movq %rbx, %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x3050
subq %r14, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x2017d(%rip)    # 0x40430
movb $0x1, 0x2016e(%rip)     # 0x40428
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: fmtdate
static char *fmtdate(char *buf, double t)
{
	int y = YearFromTime(t);
	int m = MonthFromTime(t);
	int d = DateFromTime(t);
	if (!isfinite(t))
		return "Invalid Date";
	sprintf(buf, "%04d-%02d-%02d", y, m+1, d);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x202ec
leaq 0x13f39(%rip), %rbx     # 0x34223
jmp 0x20331
movq %rdi, %rbx
movq %xmm0, 0x8(%rsp)
callq 0x207bf
movl %eax, %ebp
movsd 0x8(%rsp), %xmm0
callq 0x206c7
movl %eax, %r14d
movq 0x8(%rsp), %xmm0
callq 0x2059d
incl %r14d
leaq 0x13f17(%rip), %rsi     # 0x34236
movq %rbx, %rdi
movl %eax, %edx
movl %r14d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3220
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: YearFromTime
static int YearFromTime(double t)
{
	int y = floor(t / (msPerDay * 365.2425)) + 1970;
	double t2 = TimeFromYear(y);
	if (t2 > t)
		--y;
	else if (t2 + msPerDay * DaysInYear(y) <= t)
		++y;
	return y;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
divsd 0xaff8(%rip), %xmm0     # 0x2b5a8
callq 0x3370
addsd 0xaff3(%rip), %xmm0     # 0x2b5b0
cvttsd2si %xmm0, %ebx
imull $0x16d, %ebx, %eax      # imm = 0x16D
addl $0xfff50736, %eax       # imm = 0xFFF50736
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
leal -0x7b1(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0xafcb(%rip), %xmm0     # 0x2b5b8
callq 0x3370
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leal -0x76d(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0xaeff(%rip), %xmm0     # 0x2b510
callq 0x3370
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leal -0x641(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0xaf87(%rip), %xmm0     # 0x2b5c0
callq 0x3370
movsd 0x8(%rsp), %xmm2
addsd (%rsp), %xmm0
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
mulsd 0xae67(%rip), %xmm0     # 0x2b4c0
ucomisd %xmm2, %xmm0
jbe 0x20663
decl %ebx
jmp 0x206bf
testb $0x3, %bl
je 0x20672
movsd 0xaf58(%rip), %xmm1     # 0x2b5c8
jmp 0x206ab
imull $0xc28f5c29, %ebx, %eax # imm = 0xC28F5C29
addl $0x51eb850, %eax        # imm = 0x51EB850
movl %eax, %ecx
rorl $0x2, %ecx
cmpl $0x28f5c28, %ecx        # imm = 0x28F5C28
jbe 0x20694
movsd 0xaf3e(%rip), %xmm1     # 0x2b5d0
jmp 0x206ab
rorl $0x4, %eax
xorl %ecx, %ecx
cmpl $0xa3d70b, %eax         # imm = 0xA3D70B
adcl $0x16d, %ecx            # imm = 0x16D
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0xae0d(%rip), %xmm1     # 0x2b4c0
addsd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x206bf
incl %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsdate.c
// Function: MonthFromTime
static int MonthFromTime(double t)
{
	int day = DayWithinYear(t);
	int leap = InLeapYear(t);
	if (day < 31) return 0;
	if (day < 59 + leap) return 1;
	if (day < 90 + leap) return 2;
	if (day < 120 + leap) return 3;
	if (day < 151 + leap) return 4;
	if (day < 181 + leap) return 5;
	if (day < 212 + leap) return 6;
	if (day < 243 + leap) return 7;
	if (day < 273 + leap) return 8;
	if (day < 304 + leap) return 9;
	if (day < 334 + leap) return 10;
	return 11;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x208a3
movl %eax, %ebx
movsd 0x8(%rsp), %xmm0
callq 0x2059d
movl %eax, %ecx
xorl %eax, %eax
movl $0x0, %edx
testb $0x3, %cl
jne 0x2071e
imull $0xc28f5c29, %ecx, %ecx # imm = 0xC28F5C29
addl $0x51eb850, %ecx        # imm = 0x51EB850
movl %ecx, %esi
rorl $0x2, %esi
movl $0x1, %edx
cmpl $0x28f5c28, %esi        # imm = 0x28F5C28
ja 0x2071e
rorl $0x4, %ecx
xorl %edx, %edx
cmpl $0xa3d70b, %ecx         # imm = 0xA3D70B
setb %dl
cmpl $0x1f, %ebx
jl 0x207b9
leal 0x3b(%rdx), %ecx
movl $0x1, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0x5a(%rdx), %ecx
movl $0x2, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0x78(%rdx), %ecx
movl $0x3, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0x97(%rdx), %ecx
movl $0x4, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0xb5(%rdx), %ecx
movl $0x5, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0xd4(%rdx), %ecx
movl $0x6, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0xf3(%rdx), %ecx
movl $0x7, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0x111(%rdx), %ecx
movl $0x8, %eax
cmpl %ecx, %ebx
jb 0x207b9
leal 0x130(%rdx), %ecx
movl $0x9, %eax
cmpl %ecx, %ebx
jb 0x207b9
orl $0x14e, %edx            # imm = 0x14E
cmpl %edx, %ebx
movl $0xb, %eax
sbbl $0x0, %eax
addq $0x10, %rsp
popq %rbx
retq