LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: equality
static js_Ast *equality(js_State *J, int notin)
{
	js_Ast *a = relational(J, notin);
	int line;
	SAVEREC();
loop:
	INCREC();
	line = J->lexline;
	if (jsP_accept(J, TK_EQ)) { a = EXP2(EQ, a, relational(J, notin)); goto loop; }
	if (jsP_accept(J, TK_NE)) { a = EXP2(NE, a, relational(J, notin)); goto loop; }
	if (jsP_accept(J, TK_STRICTEQ)) { a = EXP2(STRICTEQ, a, relational(J, notin)); goto loop; }
	if (jsP_accept(J, TK_STRICTNE)) { a = EXP2(STRICTNE, a, relational(J, notin)); goto loop; }
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x24d07
movq %rax, %r14
movl 0x70(%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x70(%rbx)
cmpl $0x18f, %r13d           # imm = 0x18F
jg 0x24ce0
movl 0x74(%rbx), %eax
leal -0x106(%rax), %ecx
cmpl $0x4, %ecx
jae 0x24cf1
movl 0x60(%rbx), %r15d
movl $0x138, %r12d           # imm = 0x138
subl %eax, %r12d
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x24d07
movq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
movq %rax, %r14
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jl 0x24c7b
leaq 0xffd3(%rip), %rsi      # 0x34cba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x240fd
movl %r13d, 0x70(%rbx)
movq %r14, %rax
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/./jsparse.c
// Function: relational
static js_Ast *relational(js_State *J, int notin)
{
	js_Ast *a = shift(J);
	int line;
	SAVEREC();
loop:
	INCREC();
	line = J->lexline;
	if (jsP_accept(J, '<')) { a = EXP2(LT, a, shift(J)); goto loop; }
	if (jsP_accept(J, '>')) { a = EXP2(GT, a, shift(J)); goto loop; }
	if (jsP_accept(J, TK_LE)) { a = EXP2(LE, a, shift(J)); goto loop; }
	if (jsP_accept(J, TK_GE)) { a = EXP2(GE, a, shift(J)); goto loop; }
	if (jsP_accept(J, TK_INSTANCEOF)) { a = EXP2(INSTANCEOF, a, shift(J)); goto loop; }
	if (!notin && jsP_accept(J, TK_IN)) { a = EXP2(IN, a, shift(J)); goto loop; }
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x24e0e
movq %rax, %r14
movl 0x70(%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x70(%rbx)
cmpl $0x18f, %r13d           # imm = 0x18F
jg 0x24de7
movl 0x60(%rbx), %r15d
movl 0x74(%rbx), %eax
cmpl $0x103, %eax            # imm = 0x103
jle 0x24d62
cmpl $0x104, %eax            # imm = 0x104
je 0x24d7a
cmpl $0x105, %eax            # imm = 0x105
je 0x24d82
cmpl $0x12b, %eax            # imm = 0x12B
jne 0x24d8a
movl $0x2a, %r12d
jmp 0x24d9b
movl $0x2e, %r12d
cmpl $0x3c, %eax
je 0x24d9b
cmpl $0x3e, %eax
jne 0x24d8a
movl $0x2d, %r12d
jmp 0x24d9b
movl $0x2c, %r12d
jmp 0x24d9b
movl $0x2b, %r12d
jmp 0x24d9b
testl %ebp, %ebp
jne 0x24df8
movl $0x29, %r12d
cmpl $0x12a, %eax            # imm = 0x12A
jne 0x24df8
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24e0e
movq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
movq %rax, %r14
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jl 0x24d37
leaq 0xfecc(%rip), %rsi      # 0x34cba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x240fd
movl %r13d, 0x70(%rbx)
movq %r14, %rax
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/./jsparse.c
// Function: shift
static js_Ast *shift(js_State *J)
{
	js_Ast *a = additive(J);
	int line;
	SAVEREC();
loop:
	INCREC();
	line = J->lexline;
	if (jsP_accept(J, TK_SHL)) { a = EXP2(SHL, a, additive(J)); goto loop; }
	if (jsP_accept(J, TK_SHR)) { a = EXP2(SHR, a, additive(J)); goto loop; }
	if (jsP_accept(J, TK_USHR)) { a = EXP2(USHR, a, additive(J)); goto loop; }
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x24ec0
movq %rax, %r14
movl 0x70(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x70(%rbx)
cmpl $0x18f, %r12d           # imm = 0x18F
jg 0x24e9b
movl 0x74(%rbx), %eax
leal -0x10a(%rax), %ecx
cmpl $0x3, %ecx
jae 0x24eac
movl 0x60(%rbx), %ebp
movl $0x132, %r15d           # imm = 0x132
subl %eax, %r15d
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24ec0
movq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
movq %rax, %r14
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jl 0x24e3a
leaq 0xfe18(%rip), %rsi      # 0x34cba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x240fd
movl %r12d, 0x70(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: additive
static js_Ast *additive(js_State *J)
{
	js_Ast *a = multiplicative(J);
	int line;
	SAVEREC();
loop:
	INCREC();
	line = J->lexline;
	if (jsP_accept(J, '+')) { a = EXP2(ADD, a, multiplicative(J)); goto loop; }
	if (jsP_accept(J, '-')) { a = EXP2(SUB, a, multiplicative(J)); goto loop; }
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x24f74
movq %rax, %r14
movl 0x70(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x70(%rbx)
cmpl $0x18f, %r12d           # imm = 0x18F
jg 0x24f4f
movl 0x60(%rbx), %ebp
movl 0x74(%rbx), %eax
movl $0x25, %r15d
cmpl $0x2b, %eax
je 0x24f08
cmpl $0x2d, %eax
jne 0x24f60
movl $0x24, %r15d
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24f74
movq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
movq %rax, %r14
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jl 0x24eec
leaq 0xfd64(%rip), %rsi      # 0x34cba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x240fd
movl %r12d, 0x70(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: multiplicative
static js_Ast *multiplicative(js_State *J)
{
	js_Ast *a = unary(J);
	int line;
	SAVEREC();
loop:
	INCREC();
	line = J->lexline;
	if (jsP_accept(J, '*')) { a = EXP2(MUL, a, unary(J)); goto loop; }
	if (jsP_accept(J, '/')) { a = EXP2(DIV, a, unary(J)); goto loop; }
	if (jsP_accept(J, '%')) { a = EXP2(MOD, a, unary(J)); goto loop; }
	POPREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x25035
movq %rax, %r14
movl 0x70(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x70(%rbx)
cmpl $0x18f, %r12d           # imm = 0x18F
jg 0x25010
movl 0x60(%rbx), %ebp
movl 0x74(%rbx), %eax
cmpl $0x25, %eax
je 0x24fc3
movl $0x23, %r15d
cmpl $0x2a, %eax
je 0x24fc9
cmpl $0x2f, %eax
jne 0x25021
movl $0x22, %r15d
jmp 0x24fc9
movl $0x21, %r15d
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x25035
movq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
movq %rax, %r14
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jl 0x24fa0
leaq 0xfca3(%rip), %rsi      # 0x34cba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x240fd
movl %r12d, 0x70(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: identifiername
static js_Ast *identifiername(js_State *J)
{
	if (J->lookahead == TK_IDENTIFIER || J->lookahead >= TK_BREAK) {
		js_Ast *a = jsP_newstrnode(J, AST_IDENTIFIER, J->text);
		jsP_next(J);
		return a;
	}
	jsP_error(J, "unexpected token: %s (expected identifier or keyword)", jsY_tokenstring(J->lookahead));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %edi
cmpl $0x100, %edi            # imm = 0x100
setne %al
cmpl $0x11c, %edi            # imm = 0x11C
setl %cl
testb %cl, %al
jne 0x25dc1
movq 0x78(%rbx), %r15
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
movq %rax, %r14
movl $0x2, (%rax)
movl %ebp, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
movq 0x88(%rbx), %rax
movq %rax, 0x50(%r14)
movq %r14, 0x88(%rbx)
movq %r15, 0x38(%r14)
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xe17c
leaq 0xef84(%rip), %rsi      # 0x34d51
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x240fd
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: arguments
static js_Ast *arguments(js_State *J)
{
	js_Ast *head, *tail;
	if (J->lookahead == ')')
		return NULL;
	head = tail = LIST(assignment(J, 0));
	while (jsP_accept(J, ',')) {
		tail = tail->b = LIST(assignment(J, 0));
	}
	return jsP_list(head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x29, 0x74(%rdi)
jne 0x25df0
xorl %ebx, %ebx
jmp 0x25ee6
movq %rdi, %r14
xorl %esi, %esi
callq 0x247dd
movq %rax, %r15
movq %r14, %rdi
movl $0x58, %esi
callq 0xde05
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
testq %r15, %r15
je 0x25e33
movq %rbx, 0x8(%r15)
movq 0x88(%r14), %rax
movq %rax, 0x50(%rbx)
movq %rbx, 0x88(%r14)
cmpl $0x2c, 0x74(%r14)
jne 0x25ee6
movq %rbx, %r12
addq $0x18, %r12
movq %rbx, %r13
movq %r14, %rdi
callq 0xe333
movl %eax, 0x68(%r14)
movl %eax, 0x74(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x247dd
movq %rax, %r15
movq %r14, %rdi
movl $0x58, %esi
callq 0xde05
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
testq %r15, %r15
je 0x25eaa
movq %rax, 0x8(%r15)
movq 0x88(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x88(%r14)
movq %rax, 0x18(%r13)
cmpl $0x2c, 0x74(%r14)
movq %rax, %r13
je 0x25e5a
movq (%r12), %rax
testq %rax, %rax
je 0x25ee6
movq %rbx, %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x25ed6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: propassign
static js_Ast *propassign(js_State *J)
{
	js_Ast *name, *value, *arg, *body;
	int line = J->lexline;

	name = propname(J);

	if (J->lookahead != ':' && name->type == AST_IDENTIFIER) {
		if (!strcmp(name->string, "get")) {
			name = propname(J);
			jsP_expect(J, '(');
			jsP_expect(J, ')');
			body = funbody(J);
			return EXP3(PROP_GET, name, NULL, body);
		}
		if (!strcmp(name->string, "set")) {
			name = propname(J);
			jsP_expect(J, '(');
			arg = identifier(J);
			jsP_expect(J, ')');
			body = funbody(J);
			return EXP3(PROP_SET, name, LIST(arg), body);
		}
	}

	jsP_expect(J, ':');
	value = assignment(J, 0);
	return EXP2(PROP_VAL, name, value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x60(%rdi), %ebp
callq 0x260fa
movq %rax, %r14
movl 0x74(%rbx), %r15d
cmpl $0x3a, %r15d
jne 0x25f4f
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x247dd
movq $0x0, (%rsp)
movq %rbx, %rdi
movl $0xe, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
jmp 0x26099
cmpl $0x2, (%r14)
jne 0x260ab
movq 0x38(%r14), %r14
leaq 0xebfa(%rip), %rsi      # 0x34b5e
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
je 0x26042
leaq 0xd007(%rip), %rsi      # 0x32f82
movq %r14, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x260ab
movq %rbx, %rdi
callq 0x260fa
movl 0x74(%rbx), %edi
cmpl $0x28, %edi
jne 0x260c3
movq %rax, %r14
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24063
movl 0x74(%rbx), %edi
cmpl $0x29, %edi
jne 0x260da
movq %rax, %r15
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x241db
movq %rax, %r12
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
testq %r15, %r15
je 0x26013
movq %rax, 0x8(%r15)
movq 0x88(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x88(%rbx)
movq $0x0, (%rsp)
movq %rbx, %rdi
movl $0x10, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
movq %r12, %r9
jmp 0x26099
movq %rbx, %rdi
callq 0x260fa
movl 0x74(%rbx), %edi
cmpl $0x28, %edi
jne 0x260c3
movq %rax, %r14
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
cmpl $0x29, %eax
jne 0x260d8
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x241db
movq $0x0, (%rsp)
movq %rbx, %rdi
movl $0xf, %esi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x1225c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %edi
callq 0xe17c
leaq 0xeb78(%rip), %rsi      # 0x34c32
leaq 0xe43e(%rip), %rcx      # 0x344ff
jmp 0x260ed
callq 0xe17c
leaq 0xeb63(%rip), %rsi      # 0x34c32
leaq 0xf2b0(%rip), %rcx      # 0x35386
jmp 0x260ed
movl %eax, %edi
callq 0xe17c
leaq 0xeb4c(%rip), %rsi      # 0x34c32
leaq 0xdaef(%rip), %rcx      # 0x33bdc
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x240fd
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: propname
static js_Ast *propname(js_State *J)
{
	js_Ast *name;
	if (J->lookahead == TK_NUMBER) {
		name = jsP_newnumnode(J, EXP_NUMBER, J->number);
		jsP_next(J);
	} else if (J->lookahead == TK_STRING) {
		name = jsP_newstrnode(J, EXP_STRING, J->text);
		jsP_next(J);
	} else {
		name = identifiername(J);
	}
	return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %eax
cmpl $0x102, %eax            # imm = 0x102
je 0x2617b
cmpl $0x101, %eax            # imm = 0x101
jne 0x261e7
movsd 0x80(%rbx), %xmm0
movsd %xmm0, (%rsp)
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
movq %rax, %r14
movl $0x4, (%rax)
movl %ebp, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
movq 0x88(%rbx), %rax
movq %rax, 0x50(%r14)
movq %r14, 0x88(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r14)
jmp 0x261cb
movq 0x78(%rbx), %r15
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
movq %rax, %r14
movl $0x5, (%rax)
movl %ebp, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
movq 0x88(%rbx), %rax
movq %rax, 0x50(%r14)
movq %r14, 0x88(%rbx)
movq %r15, 0x38(%r14)
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25d32
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: arrayelement
static js_Ast *arrayelement(js_State *J)
{
	int line = J->lexline;
	if (J->lookahead == ',')
		return EXP0(ELISION);
	return assignment(J, 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2c, 0x74(%rdi)
jne 0x26251
movl 0x60(%rbx), %ebp
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
movl $0x7, (%rax)
movl %ebp, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
movq 0x88(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x247dd
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: forexpression
static js_Ast *forexpression(js_State *J, int end)
{
	js_Ast *a = NULL;
	if (J->lookahead != end)
		a = expression(J, 0);
	jsP_expect(J, end);
	return a;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x74(%rdi)
jne 0x26272
xorl %r14d, %r14d
jmp 0x26288
movl %esi, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x24489
movl 0x74(%rbx), %edi
cmpl %ebp, %edi
jne 0x2629e
movq %rax, %r14
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xe17c
movq %rax, %r14
movl %ebp, %edi
callq 0xe17c
leaq 0xe97e(%rip), %rsi      # 0x34c32
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x240fd
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: caseclause
static js_Ast *caseclause(js_State *J)
{
	js_Ast *a, *b;
	int line = J->lexline;

	if (jsP_accept(J, TK_CASE)) {
		a = expression(J, 0);
		jsP_expect(J, ':');
		b = statementlist(J);
		return STM2(CASE, a, b);
	}

	if (jsP_accept(J, TK_DEFAULT)) {
		jsP_expect(J, ':');
		a = statementlist(J);
		return STM1(DEFAULT, a);
	}

	jsP_error(J, "unexpected token in switch: %s (expected 'case' or 'default')", jsY_tokenstring(J->lookahead));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x60(%rdi), %ebp
movl 0x74(%rdi), %edi
cmpl $0x121, %edi            # imm = 0x121
je 0x2634b
cmpl $0x11d, %edi            # imm = 0x11D
jne 0x263d7
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x24489
movl 0x74(%rbx), %edi
cmpl $0x3a, %edi
jne 0x263f2
movq %rax, %r14
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24603
movq $0x0, (%rsp)
movq %rbx, %rdi
movl $0x5a, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x1225c
jmp 0x263ce
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
cmpl $0x3a, %eax
jne 0x263f0
movq %rbx, %rdi
callq 0xe333
movl %eax, 0x68(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rdi
callq 0x24603
movq %rax, %r14
movq %rbx, %rdi
movl $0x58, %esi
callq 0xde05
movl $0x5b, (%rax)
movl %ebp, 0x4(%rax)
movq %r14, 0x10(%rax)
movq $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl $0x0, 0x48(%rax)
testq %r14, %r14
je 0x263bc
movq %rax, 0x8(%r14)
movq 0x88(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x88(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xe17c
leaq 0xea18(%rip), %rsi      # 0x34dfb
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x240fd
movl %eax, %edi
callq 0xe17c
leaq 0xe834(%rip), %rsi      # 0x34c32
leaq 0xe0fa(%rip), %rcx      # 0x344ff
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x240fd
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsparse.c
// Function: toint32
static int toint32(double d)
{
	double two32 = 4294967296.0;
	double two31 = 2147483648.0;

	if (!isfinite(d) || d == 0)
		return 0;

	d = fmod(d, two32);
	d = d >= 0 ? floor(d) : ceil(d) + two32;
	if (d >= two31)
		return d - two32;
	else
		return d;
}

// Assembly:
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setg %cl
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x26486
pushq %rax
movsd 0x5127(%rip), %xmm1     # 0x2b570
callq 0x31b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x26467
callq 0x3090
addsd 0x510b(%rip), %xmm0     # 0x2b570
jmp 0x2646c
callq 0x3370
ucomisd 0x5104(%rip), %xmm0     # 0x2b578
jb 0x2647e
addsd 0x5102(%rip), %xmm0     # 0x2b580
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrepr.c
// Function: reprnum
static void reprnum(js_State *J, js_Buffer **sb, double n)
{
	char buf[40];
	if (n == 0 && signbit(n))
		js_puts(J, sb, "-0");
	else
		js_puts(J, sb, jsV_numbertostring(J, buf, n));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq %rdi, %r14
setp %al
setne %cl
orb %al, %cl
movq %xmm0, %rax
testq %rax, %rax
setns %al
orb %cl, %al
jne 0x266c5
movb $0x2d, %al
xorl %r12d, %r12d
leaq 0xe8e2(%rip), %r15      # 0x34f84
leaq 0x1(%r12), %r13
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb 0x1(%r12,%r15), %al
movq %r13, %r12
cmpq $0x2, %r13
jne 0x266a2
jmp 0x266f1
movq %rsp, %rsi
callq 0x12c04
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x266f1
incq %r15
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x266d9
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrepr.c
// Function: reprarray
static void reprarray(js_State *J, js_Buffer **sb)
{
	int n, i;

	n = js_gettop(J) - 1;
	for (i = 0; i < n; ++i) {
		if (js_isobject(J, i)) {
			if (js_toobject(J, i) == js_toobject(J, -1)) {
				js_puts(J, sb, "[]");
				return;
			}
		}
	}

	js_putc(J, sb, '[');
	n = js_getlength(J, -1);
	for (i = 0; i < n; ++i) {
		if (i > 0)
			js_puts(J, sb, ", ");
		if (js_hasindex(J, -1, i)) {
			reprvalue(J, sb);
			js_pop(J, 1);
		}
	}
	js_putc(J, sb, ']');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x144(%rdi), %r12d
notl %r12d
addl 0x140(%rdi), %r12d
testl %r12d, %r12d
jle 0x26d88
xorl %ebp, %ebp
leaq 0x196e2(%rip), %r13     # 0x403f8
movl 0x144(%rbx), %ecx
addl %ebp, %ecx
movq %r13, %rax
js 0x26d3b
movq %r13, %rax
cmpl 0x140(%rbx), %ecx
jge 0x26d3b
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x7, 0xf(%rax)
jne 0x26d81
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1189f
movq %rax, %r15
movslq 0x140(%rbx), %rax
movq %r13, %rsi
testq %rax, %rax
jle 0x26d70
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x14fb2
cmpq %rax, %r15
je 0x26e76
incl %ebp
cmpl %ebp, %r12d
jne 0x26d16
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5b, %edx
callq 0xdda1
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3f6c
movl %eax, 0x4(%rsp)
testl %eax, %eax
jle 0x26e58
xorl %r15d, %r15d
leaq 0xe1cf(%rip), %r13      # 0x34f8a
testl %r15d, %r15d
je 0x26de6
movb $0x2c, %al
xorl %r12d, %r12d
leaq 0x1(%r12), %rbp
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdda1
movb 0x1(%r12,%r13), %al
movq %rbp, %r12
cmpq $0x2, %rbp
jne 0x26dc5
movslq 0x140(%rbx), %rax
leaq 0x19604(%rip), %rsi     # 0x403f8
testq %rax, %rax
jle 0x26e0c
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x14fb2
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x1658a
testl %eax, %eax
je 0x26e4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13ca8
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x26eb2
incl %r15d
cmpl 0x4(%rsp), %r15d
jne 0x26dbb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdda1
movb $0x5b, %al
xorl %r12d, %r12d
leaq 0xe10b(%rip), %r15      # 0x34f8d
leaq 0x1(%r12), %r13
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdda1
movb 0x1(%r12,%r15), %al
movq %r13, %r12
cmpq $0x2, %r13
jne 0x26e82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0xc8df(%rip), %rsi      # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrepr.c
// Function: reprfun
static void reprfun(js_State *J, js_Buffer **sb, js_Function *fun)
{
	int i;
	js_puts(J, sb, "function ");
	js_puts(J, sb, fun->name);
	js_putc(J, sb, '(');
	for (i = 0; i < fun->numparams; ++i) {
		if (i > 0)
			js_puts(J, sb, ", ");
		js_puts(J, sb, fun->vartab[i]);
	}
	js_puts(J, sb, ") { [byte code] }");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movb $0x66, %al
movl $0x1, %r12d
leaq 0xd449(%rip), %r13      # 0x34335
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb (%r12,%r13), %al
incq %r12
cmpq $0xa, %r12
jne 0x26eec
movq (%r15), %r12
movb (%r12), %al
testb %al, %al
je 0x26f2e
incq %r12
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb (%r12), %al
incq %r12
testb %al, %al
jne 0x26f15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x28, %edx
callq 0xdda1
cmpl $0x0, 0x18(%r15)
jle 0x26fb6
xorl %r12d, %r12d
leaq 0xe03b(%rip), %r13      # 0x34f8a
movq %r15, (%rsp)
testq %r12, %r12
je 0x26f7c
movb $0x2c, %al
xorl %ebp, %ebp
leaq 0x1(%rbp), %r15
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb 0x1(%rbp,%r13), %al
movq %r15, %rbp
cmpq $0x2, %r15
jne 0x26f5c
movq (%rsp), %r15
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rbp
movb (%rbp), %al
testb %al, %al
je 0x26faa
incq %rbp
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0x26f92
incq %r12
movslq 0x18(%r15), %rax
cmpq %rax, %r12
jl 0x26f53
movb $0x29, %al
movl $0x1, %r15d
leaq 0xd37a(%rip), %r12      # 0x3433f
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdda1
movb (%r15,%r12), %al
incq %r15
cmpq $0x12, %r15
jne 0x26fc5
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/./jsrun.c
// Function: jsR_setarrayindex
static void jsR_setarrayindex(js_State *J, js_Object *obj, int k, js_Value *value)
{
	int newlen = k + 1;
	assert(obj->u.a.simple);
	assert(k >= 0);
	if (newlen > JS_ARRAYLIMIT)
		js_rangeerror(J, "array too large");
	if (newlen > obj->u.a.flat_length) {
		assert(newlen == obj->u.a.flat_length + 1);
		if (newlen > obj->u.a.flat_capacity) {
			int newcap = obj->u.a.flat_capacity;
			if (newcap == 0)
				newcap = 8;
			while (newcap < newlen)
				newcap <<= 1;
			obj->u.a.array = js_realloc(J, obj->u.a.array, newcap * sizeof(js_Value));
			obj->u.a.flat_capacity = newcap;
		}
		obj->u.a.flat_length = newlen;
	}
	if (newlen > obj->u.a.length)
		obj->u.a.length = newlen;
	obj->u.a.array[k] = *value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x24(%rsi)
je 0x27085
movl %edx, %r14d
cmpl $0x4000000, %edx        # imm = 0x4000000
jge 0x270a4
movq %rcx, %rbx
movq %rsi, %r15
leal 0x1(%r14), %ebp
cmpl %r14d, 0x28(%rsi)
jg 0x27060
jne 0x270b2
movl 0x2c(%r15), %ecx
cmpl %r14d, %ecx
jg 0x2705c
testl %ecx, %ecx
movl $0x8, %eax
cmovnel %ecx, %eax
movl %eax, %r12d
leal (%r12,%r12), %eax
cmpl %r14d, %r12d
jle 0x27039
movq 0x30(%r15), %rsi
movl %r12d, %edx
shll $0x4, %edx
callq 0xde5c
movq %rax, 0x30(%r15)
movl %r12d, 0x2c(%r15)
movl %ebp, 0x28(%r15)
cmpl %r14d, 0x20(%r15)
jg 0x2706a
movl %ebp, 0x20(%r15)
movq 0x30(%r15), %rax
movl %r14d, %ecx
shlq $0x4, %rcx
movups (%rbx), %xmm0
movups %xmm0, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc62c(%rip), %rdi      # 0x336b8
leaq 0xdf91(%rip), %rsi      # 0x35024
leaq 0xdf94(%rip), %rcx      # 0x3502e
movl $0x286, %edx            # imm = 0x286
callq 0x3130
leaq 0xdefa(%rip), %rsi      # 0x34fa5
xorl %eax, %eax
callq 0xc7e2
leaq 0xdfb6(%rip), %rdi      # 0x3506f
leaq 0xdf64(%rip), %rsi      # 0x35024
leaq 0xdf67(%rip), %rcx      # 0x3502e
movl $0x28b, %edx            # imm = 0x28B
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_savescope
static void jsR_savescope(js_State *J, js_Environment *newE)
{
	if (J->envtop + 1 >= JS_ENVLIMIT)
		js_stackoverflow(J);
	J->envstack[J->envtop++] = J->E;
	J->E = newE;
}

// Assembly:
movslq 0x188(%rdi), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jge 0x27100
movq 0x130(%rdi), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x188(%rdi)
movq %rcx, 0x190(%rdi,%rax,8)
movq %rsi, 0x130(%rdi)
retq
pushq %rax
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movb $0x5, 0xf(%rax,%rcx)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0xdfa5(%rip), %rdx      # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_hasvar
static int js_hasvar(js_State *J, const char *name)
{
	js_Environment *E = J->E;
	do {
		js_Property *ref = jsV_getproperty(J, E->variables, name);
		if (ref) {
			if (ref->getter) {
				js_pushobject(J, ref->getter);
				js_pushobject(J, E->variables);
				js_call(J, 0);
			} else {
				js_pushvalue(J, ref->value);
			}
			return 1;
		}
		E = E->outer;
	} while (E);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x130(%rdi), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdx
callq 0x1239f
testq %rax, %rax
jne 0x28b9a
movq (%r15), %r15
testq %r15, %r15
jne 0x28b7d
xorl %eax, %eax
jmp 0x28bd8
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x28bc3
movq %rbx, %rdi
callq 0x4487
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4487
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16762
jmp 0x28bd3
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
movq %rbx, %rdi
callq 0x145a6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_setvar
static void js_setvar(js_State *J, const char *name)
{
	js_Environment *E = J->E;
	do {
		js_Property *ref = jsV_getproperty(J, E->variables, name);
		if (ref) {
			if (ref->setter) {
				js_pushobject(J, ref->setter);
				js_pushobject(J, E->variables);
				js_copy(J, -3);
				js_call(J, 1);
				js_pop(J, 1);
				return;
			}
			if (!(ref->atts & JS_READONLY))
				ref->value = *stackidx(J, -1);
			else if (J->strict)
				js_typeerror(J, "'%s' is read-only", name);
			return;
		}
		E = E->outer;
	} while (E);
	if (J->strict)
		js_referenceerror(J, "assignment to undeclared variable '%s'", name);
	jsR_setproperty(J, J->G, name, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x130(%rdi), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdx
callq 0x1239f
testq %rax, %rax
jne 0x28c2c
movq (%r15), %r15
testq %r15, %r15
jne 0x28bf0
cmpl $0x0, 0x34(%rbx)
jne 0x28cea
movq 0x128(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x15919
movq 0x30(%rax), %rsi
testq %rsi, %rsi
je 0x28c93
movq %rbx, %rdi
callq 0x4487
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4487
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x13c1a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x16762
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jg 0x28ce4
movl %eax, 0x140(%rbx)
leaq 0xab15(%rip), %rsi      # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
testb $0x1, 0x14(%rax)
jne 0x28cbd
addq $0x18, %rax
movslq 0x140(%rbx), %rcx
testq %rcx, %rcx
jle 0x28cd7
movq 0x148(%rbx), %rdx
shlq $0x4, %rcx
addq %rdx, %rcx
addq $-0x10, %rcx
jmp 0x28cde
cmpl $0x0, 0x34(%rbx)
je 0x28ce4
leaq 0xc348(%rip), %rsi      # 0x35012
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xca10
leaq 0x1771a(%rip), %rcx     # 0x403f8
movups (%rcx), %xmm0
movups %xmm0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc429(%rip), %rsi      # 0x3511a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xc8a0
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_delvar
static int js_delvar(js_State *J, const char *name)
{
	js_Environment *E = J->E;
	do {
		js_Property *ref = jsV_getownproperty(J, E->variables, name);
		if (ref) {
			if (ref->atts & JS_DONTCONF) {
				if (J->strict)
					js_typeerror(J, "'%s' is non-configurable", name);
				return 0;
			}
			jsV_delproperty(J, E->variables, name);
			return 1;
		}
		E = E->outer;
	} while (E);
	return jsR_delproperty(J, J->G, name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x130(%rdi), %r12
leaq 0x1769b(%rip), %r13     # 0x403b8
movq 0x8(%r12), %r15
movq 0x8(%r15), %rbp
cmpq %r13, %rbp
je 0x28d4c
leaq 0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x32f0
testl %eax, %eax
je 0x28d47
notl %eax
shrl $0x1f, %eax
movq (%rbp,%rax,8), %rbp
jmp 0x28d26
testq %rbp, %rbp
jne 0x28d75
movq (%r12), %r12
testq %r12, %r12
jne 0x28d1d
movq 0x128(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15d72
testb $0x4, 0x14(%rbp)
jne 0x28d90
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x125b0
movl $0x1, %eax
jmp 0x28d99
xorl %eax, %eax
cmpl $0x0, 0x34(%r14)
jne 0x28da8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2e3(%rip), %rsi      # 0x35092
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xca10
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: jsR_isindex
static int jsR_isindex(js_State *J, int idx, int *k)
{
	js_Value *v = stackidx(J, idx);
	if (v->t.type == JS_TNUMBER) {
		*k = v->u.number;
		return *k == v->u.number && *k >= 0;
	}
	return 0;
}

// Assembly:
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl 0x140(%rdi,%rax,4), %esi
leaq 0x17627(%rip), %rcx     # 0x403f8
js 0x28de8
cmpl 0x140(%rdi), %esi
jge 0x28de8
movl %esi, %ecx
shlq $0x4, %rcx
addq 0x148(%rdi), %rcx
xorl %eax, %eax
cmpb $0x4, 0xf(%rcx)
jne 0x28e18
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movl %eax, (%rdx)
ucomisd (%rcx), %xmm0
setnp %cl
sete %dl
andb %cl, %dl
testl %eax, %eax
setns %al
andb %dl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsstring.c
// Function: js_doregexec
static int js_doregexec(js_State *J, Reprog *prog, const char *string, Resub *sub, int eflags)
{
	int result = js_regexec(prog, string, sub, eflags);
	if (result < 0)
		js_error(J, "regexec failed");
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %r8d, %ebp
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
leaq 0x8(%rsp), %r12
cmovneq %rcx, %r12
movq %rdi, %rbx
movl 0x1c(%rsi), %eax
movl %eax, (%r12)
leaq 0x8(%r12), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x3060
movq (%r15), %rdi
orl 0x18(%r15), %ebp
movq %r14, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x1bccb
testl %eax, %eax
js 0x28f43
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa7c0(%rip), %rsi      # 0x3370a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: newcclass
static void newcclass(struct cstate *g)
{
	if (g->ncclass >= REG_MAXCLASS)
		die(g, "too many character classes");
	g->yycc = g->cclass + g->ncclass++;
	g->yycc->end = g->yycc->spans;
}

// Assembly:
movslq 0x20(%rdi), %rax
cmpq $0x80, %rax
jge 0x29e25
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rdi)
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,8), %rax
leaq (%rdi,%rax), %rcx
addq $0x190, %rcx            # imm = 0x190
movq %rcx, 0xb0(%rdi)
addq %rdi, %rax
addq $0x198, %rax            # imm = 0x198
movq %rax, -0x8(%rax)
retq
pushq %rax
leaq 0xb485(%rip), %rax      # 0x352b2
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: addranges_s
static void addranges_s(struct cstate *g)
{
	addrange(g, 0x9, 0xD);
	addrange(g, 0x20, 0x20);
	addrange(g, 0xA0, 0xA0);
	addrange(g, 0x2028, 0x2029);
	addrange(g, 0xFEFF, 0xFEFF);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x9, %esi
movl $0xd, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0x20, %esi
movl $0x20, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0xa0, %esi
movl $0xa0, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0x2028, %esi           # imm = 0x2028
movl $0x2029, %edx           # imm = 0x2029
callq 0x29f2b
movq %rbx, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
movl $0xfeff, %edx           # imm = 0xFEFF
popq %rbx
jmp 0x29f2b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: addranges_w
static void addranges_w(struct cstate *g)
{
	addrange(g, '0', '9');
	addrange(g, 'A', 'Z');
	addrange(g, '_', '_');
	addrange(g, 'a', 'z');
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x30, %esi
movl $0x39, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0x41, %esi
movl $0x5a, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0x5f, %esi
movl $0x5f, %edx
callq 0x29f2b
movq %rbx, %rdi
movl $0x61, %esi
movl $0x7a, %edx
popq %rbx
jmp 0x29f2b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: hex
static int hex(struct cstate *g, int c)
{
	if (c >= '0' && c <= '9') return c - '0';
	if (c >= 'a' && c <= 'f') return c - 'a' + 0xA;
	if (c >= 'A' && c <= 'F') return c - 'A' + 0xA;
	die(g, "invalid escape sequence");
	return 0;
}

// Assembly:
leal -0x30(%rsi), %eax
cmpl $0xa, %eax
jb 0x29f0a
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x29efd
addl $-0x57, %esi
jmp 0x29f08
leal -0x41(%rsi), %eax
cmpl $0x5, %eax
ja 0x29f0b
addl $-0x37, %esi
movl %esi, %eax
retq
pushq %rax
leaq 0x9e03(%rip), %rax      # 0x33d16
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: addrange
static void addrange(struct cstate *g, Rune a, Rune b)
{
	Reclass *cc = g->yycc;
	Rune *p;

	if (a > b)
		die(g, "invalid character class range");

	/* extend existing ranges if they overlap */
	for (p = cc->spans; p < cc->end; p += 2) {
		/* completely inside old range */
		if (a >= p[0] && b <= p[1])
			return;

		/* completely swallows old range */
		if (a < p[0] && b >= p[1]) {
			p[0] = a;
			p[1] = b;
			return;
		}

		/* extend at start */
		if (b >= p[0] - 1 && b <= p[1] && a < p[0]) {
			p[0] = a;
			return;
		}

		/* extend at end */
		if (a >= p[0] && a <= p[1] + 1 && b > p[1]) {
			p[1] = b;
			return;
		}
	}

	if (cc->end + 2 >= cc->spans + nelem(cc->spans))
		die(g, "too many character class ranges");
	*cc->end++ = a;
	*cc->end++ = b;
}

// Assembly:
pushq %rax
cmpl %edx, %esi
jg 0x29fbc
movq 0xb0(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rax), %r8
cmpq %rcx, %r8
jae 0x29f94
movl (%r8), %r10d
movl 0x4(%r8), %r9d
cmpl %esi, %r10d
jle 0x29f5a
cmpl %edx, %r9d
jg 0x29f5f
jmp 0x29fb3
cmpl %edx, %r9d
jge 0x29fac
leal -0x1(%r10), %r11d
cmpl %edx, %r11d
jg 0x29f72
cmpl %esi, %r10d
jle 0x29f72
cmpl %edx, %r9d
jge 0x29fae
cmpl %esi, %r10d
jg 0x29f8e
leal 0x1(%r9), %r10d
cmpl %esi, %r10d
setl %r10b
cmpl %edx, %r9d
setge %r9b
orb %r10b, %r9b
je 0x29fb6
addq $0x8, %r8
jmp 0x29f42
leaq 0x8(%rcx), %r8
leaq 0x108(%rax), %r9
cmpq %r9, %r8
jae 0x29fc5
movl %esi, (%rcx)
movq %r8, (%rax)
movl %edx, 0x4(%rcx)
popq %rax
retq
movl %esi, (%r8)
jmp 0x29fac
movl %esi, (%r8)
movl %edx, 0x4(%r8)
jmp 0x29fac
leaq 0xb30a(%rip), %rax      # 0x352cd
jmp 0x29fcc
leaq 0xb31f(%rip), %rax      # 0x352eb
movq %rax, 0xc0(%rdi)
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: parsecat
static Renode *parsecat(struct cstate *g)
{
	Renode *cat, *head, **tail;
	if (g->lookahead != EOF && g->lookahead != '|' && g->lookahead != ')') {
		/* Build a right-leaning tree by splicing in new 'cat' at the tail. */
		head = parserep(g);
		tail = &head;
		while (g->lookahead != EOF && g->lookahead != '|' && g->lookahead != ')') {
			cat = newnode(g, P_CAT);
			cat->x = *tail;
			cat->y = parserep(g);
			*tail = cat;
			tail = &cat->y;
		}
		return head;
	}
	return NULL;
}

// Assembly:
movl 0xa8(%rdi), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x2a093
cmpl $0x29, %ecx
je 0x2a093
cmpl $0x7c, %ecx
je 0x2a093
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2a094
movq %rsp, %r15
movq %rax, (%r15)
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movl 0xa8(%rbx), %eax
cmpl $-0x1, %eax
je 0x2a084
cmpl $0x29, %eax
je 0x2a084
cmpl $0x7c, %eax
je 0x2a084
movq 0x10(%rbx), %r12
leaq 0x20(%r12), %rax
movq %rax, 0x10(%rbx)
movb $0x0, (%r12)
movq %r14, 0x4(%r12)
movl $0x0, 0x1(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x2a094
movq %rax, 0x18(%r12)
movq %r12, (%r15)
leaq 0x18(%r12), %r15
jmp 0x2a027
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: newrep
static Renode *newrep(struct cstate *g, Renode *atom, int ng, int min, int max)
{
	Renode *rep = newnode(g, P_REP);
	if (max == REPINF && empty(atom))
		die(g, "infinite loop matching the empty string");
	rep->ng = ng;
	rep->m = min;
	rep->n = max;
	rep->x = atom;
	return rep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq 0x10(%rdi), %r15
leaq 0x20(%r15), %rax
movq %rax, 0x10(%rdi)
movb $0x2, (%r15)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x4(%r15)
movl $0x0, 0x1(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
cmpl $0xff, %r8d
jne 0x2a5ca
movq %rdi, %r12
movq %r14, %rdi
callq 0x2a60f
testl %eax, %eax
jne 0x2a5ec
movb %r13b, 0x1(%r15)
movb %bpl, 0x2(%r15)
movb %bl, 0x3(%r15)
movq %r14, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad97(%rip), %rax      # 0x3538a
movq %rax, 0xc0(%r12)
addq $0xc8, %r12
movq %r12, %rdi
movl $0x1, %esi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: empty
static int empty(Renode *node)
{
	if (!node) return 1;
	switch (node->type) {
	default: return 1;
	case P_CAT: return empty(node->x) && empty(node->y);
	case P_ALT: return empty(node->x) || empty(node->y);
	case P_REP: return empty(node->x) || node->m == 0;
	case P_PAR: return empty(node->x);
	case P_REF: return empty(node->x);
	case P_ANY: case P_CHAR: case P_CCLASS: case P_NCCLASS: return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2a66a
movq %rdi, %rbx
leaq 0x1876(%rip), %r14      # 0x2be98
xorl %ebp, %ebp
movzbl (%rbx), %eax
cmpq $0xe, %rax
ja 0x2a66a
movl $0x10, %ecx
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x2a60f
movl $0x18, %ecx
testl %eax, %eax
jne 0x2a661
jmp 0x2a66f
movq 0x10(%rbx), %rdi
callq 0x2a60f
movl $0x18, %ecx
testl %eax, %eax
jne 0x2a66a
movq (%rbx,%rcx), %rbx
testq %rbx, %rbx
jne 0x2a624
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rdi
callq 0x2a60f
movl $0x1, %ebp
testl %eax, %eax
jne 0x2a66f
xorl %ebp, %ebp
cmpb $0x0, 0x2(%rbx)
sete %bpl
jmp 0x2a66f
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./regexp.c
// Function: incclasscanon
static int incclasscanon(Reclass *cc, Rune c)
{
	Rune *p, r;
	for (p = cc->spans; p < cc->end; p += 2)
		for (r = p[0]; r <= p[1]; ++r)
			if (c == canon(r))
				return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
leaq 0x8(%rdi), %rax
xorl %ebx, %ebx
cmpq %r12, %rax
jae 0x2a6fb
movl %esi, %ebp
movq %rdi, %r14
movl 0x8(%r14), %r15d
movl 0xc(%r14), %r13d
movq %rax, %r14
cmpl %r13d, %r15d
jg 0x2a6eb
incl %r13d
movl %r15d, %edi
callq 0x1c418
cmpl $0x80, %eax
movl %eax, %ecx
cmovll %r15d, %ecx
cmpl $0x7f, %r15d
cmovlel %eax, %ecx
cmpl %ebp, %ecx
je 0x2a6f6
incl %r15d
cmpl %r15d, %r13d
jne 0x2a6c5
leaq 0x8(%r14), %rax
cmpq %r12, %rax
jb 0x2a6b2
jmp 0x2a6fb
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/grapheMain.c
// Function: main
int main()
{
    // creation du graphe
    // voici les graphes a choisir

    FILE* f = fopen("00014_burma.cha", "r");
    // FILE* f = fopen("05000_USA-road-d-NY.cha", "r");
    // FILE* f = fopen("07397_pla.cha", "r");
    // FILE* f = fopen("test.cha", "r");
    Chaines* c = lectureChaines(f);
    Reseau* r = reconstitueReseauArbre(c);
    Graphe* g = creerGraphe(r);
    fclose(f);
    
    if(reorganiserReseau(r)) {
        printf("ok!\n");
    }

    // liberation de memoire
    liberer_chaines(c);
    liberation_reseau(r);
    liberation_graph(g);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2da9(%rip), %rdi      # 0x4004
leaq 0x2db2(%rip), %rsi      # 0x4014
callq 0x1110
movq %rax, %r12
movq %rax, %rdi
callq 0x1bf4
movq %rax, %rbx
movq %rax, %rdi
callq 0x316f
movq %rax, %r14
movq %rax, %rdi
callq 0x12d4
movq %rax, %r15
movq %r12, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x1a89
testl %eax, %eax
je 0x12ab
leaq 0x2d70(%rip), %rdi      # 0x4016
callq 0x1070
movq %rbx, %rdi
callq 0x219f
movq %r14, %rdi
callq 0x299a
movq %r15, %rdi
callq 0x14f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/Graphe.c
// Function: libere_liste_aretes
void libere_liste_aretes(Cellule_arete* cell_a){
    // on parcourt cette liste chainee
    // si cette arete est visite pour la premiere fois, on met u a -1
    // pour la deuxieme fois on la libere (cela evitera la double free)
    // cependant, on libere toutes les cellules qu'on vues
    Cellule_arete* tmp = NULL;
    while(cell_a){
        if (cell_a->a->u == -1){
            free(cell_a->a);
        }else{
            cell_a->a->u = -1;
        }
        tmp = cell_a;
        cell_a = cell_a->suiv;
        free(tmp);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x14f7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
cmpl $-0x1, (%rdi)
je 0x14d7
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
jmp 0x14dc
callq 0x1030
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x14c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/Graphe.c
// Function: liberation_graph
void liberation_graph(Graphe* g){
    // liberation pour les listes de voisins
    for (int i = 0; i < g->nbsom; i++)
    {
        libere_liste_aretes(g->T_som[i]->L_voisin);
        free(g->T_som[i]);
    }

    // liberation de graphe
    free(g->T_commod);
    free(g->T_som);
    free(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1530
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x18(%rax), %rdi
callq 0x14bb
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1507
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/Struct_File.c
// Function: enfile
void enfile(S_file * f, int donnee){
 Cellule_file *nouv=(Cellule_file *) malloc(sizeof(Cellule_file));
  nouv->val=donnee;
  nouv->suiv=NULL;
  if (f->tete==NULL)
    f->tete=nouv;
  else
    f->dernier->suiv=nouv;
  f->dernier=nouv;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x1100
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
movq %rbx, %rcx
je 0x338e
movq 0x8(%rbx), %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq