LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: statementlist
static js_Ast *statementlist(js_State *J)
{
	js_Ast *head, *tail;
	if (J->lookahead == '}' || J->lookahead == TK_CASE || J->lookahead == TK_DEFAULT)
		return NULL;
	head = tail = LIST(statement(J));
	while (J->lookahead != '}' && J->lookahead != TK_CASE && J->lookahead != TK_DEFAULT)
		tail = tail->b = LIST(statement(J));
	return jsP_list(head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x74(%rdi), %eax
xorl %r14d, %r14d
cmpl $0x7d, %eax
je 0x1b228
cmpl $0x11d, %eax            # imm = 0x11D
je 0x1b228
cmpl $0x121, %eax            # imm = 0x121
je 0x1b228
movq %rdi, %rbx
callq 0x1a4bf
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movq %rax, %r15
movl 0x74(%rbx), %eax
cmpl $0x7d, %eax
je 0x1b220
cmpl $0x11d, %eax            # imm = 0x11D
je 0x1b220
cmpl $0x121, %eax            # imm = 0x121
je 0x1b220
movq %rbx, %rdi
callq 0x1a4bf
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, 0x18(%r15)
jmp 0x1b1df
movq %r14, %rdi
callq 0x1a4a6
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: vardec
static js_Ast *vardec(js_State *J, int notin)
{
	js_Ast *a = identifier(J);
	int line = J->lexline;
	if (jsP_accept(J, '='))
		return EXP2(VAR, a, assignment(J, notin));
	return EXP1(VAR, a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
callq 0x1acfa
movq %rax, %r14
movl 0x60(%rbx), %ebp
cmpl $0x3d, 0x74(%rbx)
jne 0x1b26b
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1b291
movq %rax, %r8
jmp 0x1b26e
xorl %r8d, %r8d
andq $0x0, (%rsp)
pushq $0x46
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %r9d, %r9d
callq 0xdb92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: assignment
static js_Ast *assignment(js_State *J, int notin)
{
	js_Ast *a = conditional(J, notin);
	int line = J->lexline;
	INCREC();
	if (jsP_accept(J, '=')) a = EXP2(ASS, a, assignment(J, notin));
	else if (jsP_accept(J, TK_MUL_ASS)) a = EXP2(ASS_MUL, a, assignment(J, notin));
	else if (jsP_accept(J, TK_DIV_ASS)) a = EXP2(ASS_DIV, a, assignment(J, notin));
	else if (jsP_accept(J, TK_MOD_ASS)) a = EXP2(ASS_MOD, a, assignment(J, notin));
	else if (jsP_accept(J, TK_ADD_ASS)) a = EXP2(ASS_ADD, a, assignment(J, notin));
	else if (jsP_accept(J, TK_SUB_ASS)) a = EXP2(ASS_SUB, a, assignment(J, notin));
	else if (jsP_accept(J, TK_SHL_ASS)) a = EXP2(ASS_SHL, a, assignment(J, notin));
	else if (jsP_accept(J, TK_SHR_ASS)) a = EXP2(ASS_SHR, a, assignment(J, notin));
	else if (jsP_accept(J, TK_USHR_ASS)) a = EXP2(ASS_USHR, a, assignment(J, notin));
	else if (jsP_accept(J, TK_AND_ASS)) a = EXP2(ASS_BITAND, a, assignment(J, notin));
	else if (jsP_accept(J, TK_XOR_ASS)) a = EXP2(ASS_BITXOR, a, assignment(J, notin));
	else if (jsP_accept(J, TK_OR_ASS)) a = EXP2(ASS_BITOR, a, assignment(J, notin));
	DECREC();
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b3fd
movq %rax, %r14
movl 0x60(%rbx), %r15d
cmpl $0x3f, 0x74(%rbx)
jne 0x1b321
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b3cc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b291
movl 0x74(%rbx), %edi
cmpl $0x3a, %edi
jne 0x1b3dd
movq %rax, %r12
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b291
decl 0x70(%rbx)
andq $0x0, (%rsp)
pushq $0x38
popq %rsi
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %rcx
movq %r12, %r8
movq %rax, %r9
callq 0xdb92
movq %rax, %r14
movl 0x60(%rbx), %r15d
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b3cc
movl 0x74(%rbx), %ecx
leal -0x10f(%rcx), %eax
cmpl $0xa, %eax
ja 0x1b357
leaq 0x58a2(%rip), %rcx      # 0x20bec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x3d
jmp 0x1b386
cmpl $0x3d, %ecx
jne 0x1b3b9
pushq $0x39
jmp 0x1b386
pushq $0x3c
jmp 0x1b386
pushq $0x44
jmp 0x1b386
pushq $0x3a
jmp 0x1b386
pushq $0x3b
jmp 0x1b386
pushq $0x41
jmp 0x1b386
pushq $0x3e
jmp 0x1b386
pushq $0x3f
jmp 0x1b386
pushq $0x40
jmp 0x1b386
pushq $0x43
jmp 0x1b386
pushq $0x42
popq %r12
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b291
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
decl 0x70(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8c2(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
callq 0xace4
leaq 0xe824(%rip), %rsi      # 0x29c0d
leaq 0xe0ea(%rip), %rcx      # 0x294da
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: logor
static js_Ast *logor(js_State *J, int notin)
{
	js_Ast *a = logand(J, notin);
	int line = J->lexline;
	if (jsP_accept(J, TK_OR)) {
		INCREC();
		a = EXP2(LOGOR, a, logor(J, notin));
		DECREC();
	}
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b480
movq %rax, %r14
cmpl $0x10e, 0x74(%rbx)      # imm = 0x10E
jne 0x1b461
movl 0x60(%rbx), %r15d
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b46f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b3fd
andq $0x0, (%rsp)
pushq $0x37
popq %rsi
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
decl 0x70(%rbx)
jmp 0x1b464
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe81f(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: logand
static js_Ast *logand(js_State *J, int notin)
{
	js_Ast *a = bitor(J, notin);
	int line = J->lexline;
	if (jsP_accept(J, TK_AND)) {
		INCREC();
		a = EXP2(LOGAND, a, logand(J, notin));
		DECREC();
	}
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b564
movq %rax, %r14
movl 0x70(%rbx), %r13d
pushq $0x35
popq %r12
movl 0x60(%rbx), %r15d
movl 0x74(%rbx), %eax
cmpl $0x7c, %eax
jne 0x1b4f3
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b553
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b564
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
jmp 0x1b4a0
movl %r13d, 0x70(%rbx)
cmpl $0x10d, %eax            # imm = 0x10D
jne 0x1b541
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b553
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b480
andq $0x0, (%rsp)
pushq $0x36
popq %rsi
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
decl 0x70(%rbx)
jmp 0x1b544
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe73b(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: bitxor
static js_Ast *bitxor(js_State *J, int notin)
{
	js_Ast *a = bitand(J, notin);
	SAVEREC();
	int line = J->lexline;
	while (jsP_accept(J, '^')) {
		INCREC();
		a = EXP2(BITXOR, a, bitand(J, notin));
		line = J->lexline;
	}
	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 0x1b5f8
movq %rax, %r14
movl 0x70(%rbx), %r13d
pushq $0x34
popq %r15
cmpl $0x5e, 0x74(%rbx)
jne 0x1b5d1
movl 0x60(%rbx), %r12d
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b5e7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b5f8
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
jmp 0x1b584
movl %r13d, 0x70(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe6a7(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsparse.c
// Function: bitand
static js_Ast *bitand(js_State *J, int notin)
{
	js_Ast *a = equality(J, notin);
	SAVEREC();
	int line = J->lexline;
	while (jsP_accept(J, '&')) {
		INCREC();
		a = EXP2(BITAND, a, equality(J, notin));
		line = J->lexline;
	}
	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 0x1b68c
movq %rax, %r14
movl 0x70(%rbx), %r13d
pushq $0x33
popq %r15
cmpl $0x26, 0x74(%rbx)
jne 0x1b665
movl 0x60(%rbx), %r12d
movq %rbx, %rdi
callq 0xd822
movl 0x70(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b67b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b68c
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
jmp 0x1b618
movl %r13d, 0x70(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe613(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 0x1b730
movq %rax, %r14
movl 0x70(%rbx), %r13d
movl %r13d, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b71f
movl 0x74(%rbx), %eax
leal -0x106(%rax), %ecx
cmpl $0x4, %ecx
jae 0x1b709
movl 0x60(%rbx), %r15d
movl $0x138, %r12d           # imm = 0x138
subl %eax, %r12d
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b730
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movl 0x70(%rbx), %eax
jmp 0x1b6ab
movl %r13d, 0x70(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe56f(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b80d
movq %rax, %r14
movl 0x70(%rbx), %eax
pushq $0x2e
popq %r13
movl %eax, 0x14(%rsp)
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b7fc
movl 0x60(%rbx), %r15d
movl 0x74(%rbx), %eax
movl %r13d, %r12d
cmpl $0x3c, %eax
je 0x1b7a0
cmpl $0x12b, %eax            # imm = 0x12B
je 0x1b794
cmpl $0x104, %eax            # imm = 0x104
je 0x1b79c
cmpl $0x105, %eax            # imm = 0x105
je 0x1b798
cmpl $0x3e, %eax
jne 0x1b7d4
pushq $0x2d
jmp 0x1b79e
pushq $0x2a
jmp 0x1b79e
pushq $0x2b
jmp 0x1b79e
pushq $0x2c
popq %r12
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b80d
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movl 0x70(%rbx), %eax
jmp 0x1b756
testl %ebp, %ebp
jne 0x1b7e3
pushq $0x29
popq %r12
cmpl $0x12a, %eax            # imm = 0x12A
je 0x1b7a0
movl 0x14(%rsp), %eax
movl %eax, 0x70(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe492(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 0x1b8aa
movq %rax, %r14
movl 0x70(%rbx), %r12d
movl %r12d, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b899
movl 0x74(%rbx), %eax
leal -0x10a(%rax), %ecx
cmpl $0x3, %ecx
jae 0x1b885
movl 0x60(%rbx), %ebp
movl $0x132, %r15d           # imm = 0x132
subl %eax, %r15d
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b8aa
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movl 0x70(%rbx), %eax
jmp 0x1b82b
movl %r12d, 0x70(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe3f5(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1b952
movq %rax, %r14
movl 0x70(%rbx), %eax
pushq $0x25
popq %r13
pushq $0x24
popq %r12
movl %eax, 0x14(%rsp)
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b941
movl 0x60(%rbx), %ebp
movl 0x74(%rbx), %eax
movl %r13d, %r15d
cmpl $0x2b, %eax
je 0x1b8f5
cmpl $0x2d, %eax
jne 0x1b928
movl %r12d, %r15d
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b952
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movl 0x70(%rbx), %eax
jmp 0x1b8d2
movl 0x14(%rsp), %eax
movl %eax, 0x70(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe34d(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1ba05
movq %rax, %r14
movl 0x70(%rbx), %eax
pushq $0x23
popq %r13
pushq $0x22
popq %r12
movl %eax, 0x14(%rsp)
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rbx)
cmpl $0x190, %eax            # imm = 0x190
jge 0x1b9f4
movl 0x60(%rbx), %ebp
movl 0x74(%rbx), %eax
cmpl $0x25, %eax
je 0x1b9a4
movl %r13d, %r15d
cmpl $0x2a, %eax
je 0x1b9a8
cmpl $0x2f, %eax
jne 0x1b9db
movl %r12d, %r15d
jmp 0x1b9a8
pushq $0x21
popq %r15
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1ba05
andq $0x0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movl 0x70(%rbx), %eax
jmp 0x1b97a
movl 0x14(%rsp), %eax
movl %eax, 0x70(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe29a(%rip), %rsi      # 0x29c95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 %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 0x1c232
movq 0x78(%rbx), %rdx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1ae9d
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xace4
leaq 0xdaee(%rip), %rsi      # 0x29d2c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
cmpl $0x29, 0x74(%rdi)
jne 0x1c25f
xorl %r14d, %r14d
jmp 0x1c2c9
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1b291
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, %r14
movq %rax, %r15
cmpl $0x2c, 0x74(%rbx)
jne 0x1c2c1
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b291
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
movq %rax, 0x18(%r15)
jmp 0x1c286
movq %r14, %rdi
callq 0x1a4a6
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c4b8
movq %rax, %r15
movl 0x74(%rbx), %r14d
cmpl $0x3a, %r14d
jne 0x1c359
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b291
andq $0x0, (%rsp)
pushq $0xe
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %r9d, %r9d
jmp 0x1c459
cmpl $0x2, (%r15)
jne 0x1c46b
movq 0x38(%r15), %r15
leaq 0xd7cb(%rip), %rsi      # 0x29b39
movq %r15, %rdi
callq 0x32f0
testl %eax, %eax
je 0x1c410
leaq 0xbbcd(%rip), %rsi      # 0x27f52
movq %r15, %rdi
callq 0x32f0
testl %eax, %eax
jne 0x1c46b
movq %rbx, %rdi
callq 0x1c4b8
movl 0x74(%rbx), %edi
cmpl $0x28, %edi
jne 0x1c483
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1acfa
movl 0x74(%rbx), %edi
cmpl $0x29, %edi
jne 0x1c498
movq %rax, %r15
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1ae28
movq %rax, %r12
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
andq $0x0, (%rsp)
pushq $0x10
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
movq %r12, %r9
jmp 0x1c459
movq %rbx, %rdi
callq 0x1c4b8
movl 0x74(%rbx), %edi
cmpl $0x28, %edi
jne 0x1c483
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movl 0x74(%rbx), %edi
cmpl $0x29, %edi
jne 0x1c498
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1ae28
andq $0x0, (%rsp)
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
callq 0xdb92
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
callq 0xace4
leaq 0xd793(%rip), %rsi      # 0x29c0d
leaq 0xd059(%rip), %rcx      # 0x294da
jmp 0x1c4ab
callq 0xace4
leaq 0xd77e(%rip), %rsi      # 0x29c0d
leaq 0xdecb(%rip), %rcx      # 0x2a361
jmp 0x1c4ab
callq 0xace4
leaq 0xd769(%rip), %rsi      # 0x29c0d
leaq 0xc701(%rip), %rcx      # 0x28bac
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %eax
cmpl $0x102, %eax            # imm = 0x102
je 0x1c4e2
cmpl $0x101, %eax            # imm = 0x101
jne 0x1c507
movsd 0x80(%rbx), %xmm0
movq %rbx, %rdi
callq 0x1c2d6
jmp 0x1c4f1
movq 0x78(%rbx), %rdx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x1ae9d
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c1ed
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x2c, 0x74(%rdi)
jne 0x1c537
pushq %rax
movl 0x60(%rdi), %edx
andq $0x0, (%rsp)
pushq $0x7
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
popq %rcx
retq
xorl %esi, %esi
jmp 0x1b291
// File: /workspace/github_c_makefile_star2_O2/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 0x1c54f
xorl %r14d, %r14d
jmp 0x1c565
movl %esi, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b014
movl 0x74(%rbx), %edi
cmpl %ebp, %edi
jne 0x1c575
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xace4
movq %rax, %r14
movl %ebp, %edi
callq 0xace4
leaq 0xd682(%rip), %rsi      # 0x29c0d
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 0x1c602
cmpl $0x11d, %edi            # imm = 0x11D
jne 0x1c666
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b014
movl 0x74(%rbx), %edi
cmpl $0x3a, %edi
jne 0x1c646
movq %rax, %r14
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b198
andq $0x0, (%rsp)
pushq $0x5a
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rax, %r8
jmp 0x1c635
movq %rbx, %rdi
callq 0xd822
movl 0x74(%rbx), %edi
cmpl $0x3a, %edi
jne 0x1c646
movq %rbx, %rdi
callq 0xd822
movq %rbx, %rdi
callq 0x1b198
andq $0x0, (%rsp)
pushq $0x5b
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xdb92
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xace4
leaq 0xd5bb(%rip), %rsi      # 0x29c0d
leaq 0xce81(%rip), %rcx      # 0x294da
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
callq 0xace4
leaq 0xd764(%rip), %rsi      # 0x29dd6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ad4a
// File: /workspace/github_c_makefile_star2_O2/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 0x1c6f3
pushq %rax
movsd 0x3e5a(%rip), %xmm1     # 0x20510
callq 0x31b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1c6d4
callq 0x3090
addsd 0x3e3e(%rip), %xmm0     # 0x20510
jmp 0x1c6d9
callq 0x3370
ucomisd 0x3e37(%rip), %xmm0     # 0x20518
jb 0x1c6eb
addsd 0x3e35(%rip), %xmm0     # 0x20520
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: skew
static js_Property *skew(js_Property *node)
{
	if (node->left->level == node->level) {
		js_Property *temp = node;
		node = node->left;
		temp->left = node->right;
		node->right = temp;
	}
	return node;
}

// Assembly:
movq (%rdi), %rax
movl 0x10(%rax), %ecx
cmpl 0x10(%rdi), %ecx
jne 0x1c70b
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x8(%rax)
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsproperty.c
// Function: split
static js_Property *split(js_Property *node)
{
	if (node->right->right->level == node->level) {
		js_Property *temp = node;
		node = node->right;
		temp->right = node->left;
		node->left = temp;
		++node->level;
	}
	return node;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movl 0x10(%rcx), %ecx
cmpl 0x10(%rdi), %ecx
jne 0x1c72d
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rdi, (%rax)
incl 0x10(%rax)
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1cb71
movl %edx, %r14d
cmpl $0x4000000, %edx        # imm = 0x4000000
jge 0x1cb90
movq %rcx, %rbx
movq %rsi, %r15
leal 0x1(%r14), %ebp
cmpl %r14d, 0x28(%rsi)
jg 0x1cb4c
jne 0x1cb9e
movl 0x2c(%r15), %ecx
cmpl %r14d, %ecx
jg 0x1cb48
testl %ecx, %ecx
pushq $0x8
popq %rax
cmovnel %ecx, %eax
movl %eax, %r12d
leal (%r12,%r12), %eax
cmpl %r14d, %r12d
jle 0x1cb25
movq 0x30(%r15), %rsi
movl %r12d, %edx
shll $0x4, %edx
callq 0xaa05
movq %rax, 0x30(%r15)
movl %r12d, 0x2c(%r15)
movl %ebp, 0x28(%r15)
cmpl %r14d, 0x20(%r15)
jg 0x1cb56
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 0xbb10(%rip), %rdi      # 0x28688
leaq 0xd480(%rip), %rsi      # 0x29fff
leaq 0xd483(%rip), %rcx      # 0x2a009
movl $0x286, %edx            # imm = 0x286
callq 0x3130
leaq 0xd3e9(%rip), %rsi      # 0x29f80
xorl %eax, %eax
callq 0x9778
leaq 0xd4a5(%rip), %rdi      # 0x2a04a
leaq 0xd453(%rip), %rsi      # 0x29fff
leaq 0xd456(%rip), %rcx      # 0x2a009
movl $0x28b, %edx            # imm = 0x28B
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/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 0x1cbec
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
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/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 0xdca4
testq %rax, %rax
jne 0x1db56
movq (%r15), %r15
testq %r15, %r15
jne 0x1db39
xorl %eax, %eax
jmp 0x1db92
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x1db7f
movq %rbx, %rdi
callq 0x4274
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4274
movq %rbx, %rdi
xorl %esi, %esi
callq 0x110b0
jmp 0x1db8f
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
movq %rbx, %rdi
callq 0xf74a
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x130(%rdi), %r12
movq 0x8(%r12), %rsi
movq %r14, %rdx
callq 0xdca4
testq %rax, %rax
jne 0x1dbee
movq (%r12), %r12
testq %r12, %r12
jne 0x1dbad
cmpl $0x0, 0x34(%rbx)
jne 0x1dc64
movq 0x128(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10447
movq %rax, %r15
movq 0x30(%rax), %rsi
testq %rsi, %rsi
je 0x1dc39
movq %rbx, %rdi
callq 0x4274
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x4274
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0xeee2
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x110b0
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f3d
testb $0x1, 0x14(%r15)
jne 0x1dc55
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf87b
movups (%rax), %xmm0
movups %xmm0, 0x18(%r15)
jmp 0x1dc5b
cmpl $0x0, 0x34(%rbx)
jne 0x1dc78
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc48a(%rip), %rsi      # 0x2a0f5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9836
leaq 0xc36e(%rip), %rsi      # 0x29fed
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x130(%rdi), %r12
movq 0x8(%r12), %r15
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0xdc30
testq %rax, %rax
jne 0x1dcdd
movq (%r12), %r12
testq %r12, %r12
jne 0x1dca1
movq 0x128(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x107a4
testb $0x4, 0x14(%rax)
jne 0x1dcf6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xde25
pushq $0x1
popq %rax
jmp 0x1dcff
xorl %eax, %eax
cmpl $0x0, 0x34(%r14)
jne 0x1dd0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc35b(%rip), %rsi      # 0x2a06d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdx, %rbx
callq 0xf87b
xorl %ecx, %ecx
cmpb $0x4, 0xf(%rax)
jne 0x1dd58
movsd (%rax), %xmm0
cvttsd2si %xmm0, %ecx
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movl %ecx, (%rbx)
ucomisd (%rax), %xmm0
setnp %al
sete %dl
andb %al, %dl
testl %ecx, %ecx
setns %al
andb %dl, %al
movzbl %al, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0xe782
testl %eax, %eax
js 0x1ddee
popq %rbx
retq
leaq 0xa8e5(%rip), %rsi      # 0x286da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/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 0x1e8c8
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rdi)
imulq $0x108, %rax, %rax      # imm = 0x108
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 0xb9bd(%rip), %rsi      # 0x2a28d
callq 0x14129
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x9
popq %rsi
pushq $0xd
popq %rdx
callq 0x1e996
pushq $0x20
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x1e996
movq %rbx, %rdi
movl $0xa0, %esi
movl $0xa0, %edx
callq 0x1e996
movq %rbx, %rdi
movl $0x2028, %esi           # imm = 0x2028
movl $0x2029, %edx           # imm = 0x2029
callq 0x1e996
movq %rbx, %rdi
movl $0xfeff, %esi           # imm = 0xFEFF
movl $0xfeff, %edx           # imm = 0xFEFF
popq %rbx
jmp 0x1e996
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x30
popq %rsi
pushq $0x39
popq %rdx
callq 0x1e996
pushq $0x41
popq %rsi
pushq $0x5a
popq %rdx
movq %rbx, %rdi
callq 0x1e996
pushq $0x5f
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x1e996
pushq $0x61
popq %rsi
pushq $0x7a
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x1e996
// File: /workspace/github_c_makefile_star2_O2/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 0x1e988
leal -0x61(%rsi), %eax
cmpl $0x5, %eax
ja 0x1e97b
addl $-0x57, %esi
jmp 0x1e986
leal -0x41(%rsi), %eax
cmpl $0x5, %eax
ja 0x1e989
addl $-0x37, %esi
movl %esi, %eax
retq
pushq %rax
leaq 0xa355(%rip), %rsi      # 0x28ce6
callq 0x14129
// File: /workspace/github_c_makefile_star2_O2/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 0x1ea27
movq 0xb0(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rax), %r8
cmpq %rcx, %r8
jae 0x1e9ff
movl (%r8), %r10d
movl 0x4(%r8), %r9d
cmpl %esi, %r10d
jle 0x1e9c5
cmpl %edx, %r9d
jg 0x1e9ca
jmp 0x1ea1e
cmpl %edx, %r9d
jge 0x1ea25
leal -0x1(%r10), %r11d
cmpl %edx, %r11d
jg 0x1e9dd
cmpl %esi, %r10d
jle 0x1e9dd
cmpl %edx, %r9d
jge 0x1ea19
cmpl %esi, %r10d
jg 0x1e9f9
leal 0x1(%r9), %r10d
cmpl %esi, %r10d
setl %r10b
cmpl %edx, %r9d
setge %r9b
orb %r10b, %r9b
je 0x1ea21
addq $0x8, %r8
jmp 0x1e9ad
leaq 0x8(%rcx), %r8
leaq 0x108(%rax), %r9
cmpq %r9, %r8
jae 0x1ea33
movl %esi, (%rcx)
movq %r8, (%rax)
movl %edx, 0x4(%rcx)
jmp 0x1ea25
movl %esi, (%r8)
jmp 0x1ea25
movl %esi, (%r8)
movl %edx, 0x4(%r8)
popq %rax
retq
leaq 0xb87a(%rip), %rsi      # 0x2a2a8
callq 0x14129
leaq 0xb88c(%rip), %rsi      # 0x2a2c6
callq 0x14129
// File: /workspace/github_c_makefile_star2_O2/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 0x1eb03
cmpl $0x29, %ecx
je 0x1eb03
cmpl $0x7c, %ecx
je 0x1eb03
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1eb1c
movq %rsp, %r15
movq %rax, (%r15)
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movl 0xa8(%rbx), %eax
cmpl $-0x1, %eax
je 0x1eaf4
cmpl $0x29, %eax
je 0x1eaf4
cmpl $0x7c, %eax
je 0x1eaf4
movq 0x10(%rbx), %r12
leaq 0x20(%r12), %rax
movq %rax, 0x10(%rbx)
movb $0x0, (%r12)
movq %r14, 0x4(%r12)
andl $0x0, 0x1(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x1eb1c
movq %rax, 0x18(%r12)
movq %r12, (%r15)
leaq 0x18(%r12), %r15
jmp 0x1ea9a
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
movq 0x10(%rdi), %r14
leaq 0x20(%r14), %rax
movq %rax, 0x10(%rdi)
movb $0x2, (%r14)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x4(%r14)
andl $0x0, 0x1(%r14)
movq %rsi, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
cmpl $0xff, %r8d
jne 0x1efb0
movq %rdi, %r12
movq %r13, %rdi
callq 0x1efe1
testl %eax, %eax
jne 0x1efd2
movb %r15b, 0x1(%r14)
movb %bpl, 0x2(%r14)
movb %bl, 0x3(%r14)
movq %r13, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb38c(%rip), %rsi      # 0x2a365
movq %r12, %rdi
callq 0x14129
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
pushq $0x10
popq %r15
leaq 0x1e76(%rip), %r12      # 0x20e74
pushq $0x18
popq %r13
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1f046
movzbl (%rbx), %eax
cmpq $0xe, %rax
ja 0x1f046
movslq (%r12,%rax,4), %rax
addq %r12, %rax
movq %r15, %rcx
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x1efe1
movq %r13, %rcx
testl %eax, %eax
jne 0x1f040
jmp 0x1f049
movq 0x10(%rbx), %rdi
callq 0x1efe1
movq %r13, %rcx
testl %eax, %eax
jne 0x1f046
movq (%rbx,%rcx), %rbx
jmp 0x1f004
movl %r14d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rdi
callq 0x1efe1
movl %r14d, %ebp
testl %eax, %eax
jne 0x1f049
xorl %ebp, %ebp
cmpb $0x0, 0x2(%rbx)
sete %bpl
jmp 0x1f049
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebp
movq (%rdi), %r15
pushq $0x1
popq %rbx
leaq 0x8(%rdi), %r12
cmpq %r15, %r12
jae 0x1f0f0
movl 0x8(%rdi), %r14d
movl 0xc(%rdi), %r13d
cmpl %r13d, %r14d
jg 0x1f0eb
movl %r14d, %edi
callq 0x1f076
incl %r14d
cmpl %ebp, %eax
jne 0x1f0d5
jmp 0x1f0f2
movq %r12, %rdi
jmp 0x1f0c4
xorl %ebx, %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_O2/ArtifexSoftware[P]mujs/./regexp.c
// Function: incclass
static int incclass(Reclass *cc, Rune c)
{
	Rune *p;
	for (p = cc->spans; p < cc->end; p += 2)
		if (p[0] <= c && c <= p[1])
			return 1;
	return 0;
}

// Assembly:
movq (%rdi), %rcx
addq $0x8, %rdi
pushq $0x1
popq %rax
cmpq %rcx, %rdi
jae 0x1f121
cmpl %esi, (%rdi)
jg 0x1f11b
cmpl %esi, 0x4(%rdi)
jge 0x1f123
addq $0x8, %rdi
jmp 0x1f10d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1db9(%rip), %rdi      # 0x3004
leaq 0x1dc2(%rip), %rsi      # 0x3014
callq 0x1100
movq %rax, %r12
movq %rax, %rdi
callq 0x1a78
movq %rax, %rbx
movq %rax, %rdi
callq 0x2d04
movq %rax, %r14
movq %rax, %rdi
callq 0x12c4
movq %rax, %r15
movq %r12, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x190a
testl %eax, %eax
je 0x129b
leaq 0x1d80(%rip), %rdi      # 0x3016
callq 0x1070
movq %rbx, %rdi
callq 0x1f60
movq %r14, %rdi
callq 0x2615
movq %r15, %rdi
callq 0x14cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x14c3
movq (%rbx), %rdi
cmpl $-0x1, (%rdi)
je 0x14ad
orl $-0x1, (%rdi)
jmp 0x14b2
callq 0x1030
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x149b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x1500
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x18(%rax), %rdi
callq 0x1494
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x14d5
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030