LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: copy_statement
static void copy_statement(struct statement *src, struct statement *dst)
{
	struct statement *stmt;

	FOR_EACH_PTR(src->stmts, stmt) {
		add_statement(&dst->stmts, copy_one_statement(stmt));
	} END_FOR_EACH_PTR(stmt);
	dst->args = copy_one_statement(src->args);
	dst->ret = copy_symbol(src->pos, src->ret);
	dst->inline_fn = src->inline_fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15508
jmp 0x15599
jmp 0x1550a
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x15581
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x15555
cmpq $0x0, -0x18(%rbp)
jne 0x15555
jmp 0x15576
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x158a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x15870
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15511
jmp 0x15583
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x1550a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x158a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x4(%rax), %rdi
callq 0x15f30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: unset_replace_list
static void unset_replace_list(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		unset_replace(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1561d
jmp 0x15692
jmp 0x1561f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1567e
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1566a
cmpq $0x0, -0x10(%rbp)
jne 0x1566a
jmp 0x15673
movq -0x10(%rbp), %rdi
callq 0x16b70
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15626
jmp 0x15680
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1561f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: uninline
void uninline(struct symbol *sym)
{
	struct symbol *fn = sym->ctype.base_type;
	struct symbol_list *arg_list = fn->arguments;
	struct symbol *p;

	sym->symbol_list = create_symbol_list(sym->inline_symbol_list);
	FOR_EACH_PTR(arg_list, p) {
		p->replace = p;
	} END_FOR_EACH_PTR(p);
	fn->stmt = alloc_statement(fn->pos, STMT_COMPOUND);
	copy_statement(fn->inline_stmt, fn->stmt);
	unset_replace_list(sym->symbol_list);
	unset_replace_list(arg_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x153d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x15706
jmp 0x1577e
jmp 0x15708
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1576a
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x15753
cmpq $0x0, -0x20(%rbp)
jne 0x15753
jmp 0x1575f
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1570f
jmp 0x1576c
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x15708
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x23020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x154d0
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x155f0
movq -0x18(%rbp), %rdi
callq 0x155f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: create_copy_symbol
static struct symbol *create_copy_symbol(struct symbol *orig)
{
	struct symbol *sym = orig;
	if (orig) {
		sym = alloc_symbol(orig->pos, orig->type);
		*sym = *orig;
		sym->bb_target = NULL;
		sym->pseudo = NULL;
		set_replace(orig, sym);
		orig = sym;
	}
	return orig;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1585d
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %esi
andl $0xff, %esi
movq 0x4(%rax), %rdi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
movq -0x10(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x154a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: copy_symbol
static struct symbol *copy_symbol(struct position pos, struct symbol *sym)
{
	if (!sym)
		return sym;
	if (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN | MOD_TOPLEVEL | MOD_INLINE))
		return sym;
	if (!sym->replace) {
		warning(pos, "unreplaced symbol '%s'", show_ident(sym->ident));
		return sym;
	}
	return sym->replace;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15f51
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15fb0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x5c, %rax
cmpq $0x0, %rax
je 0x15f6d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15fb0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x15fa4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x10(%rbp), %rdi
leaq 0x4c498(%rip), %rsi     # 0x6242b
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15fb0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: copy_symbol_list
static struct symbol_list *copy_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = copy_symbol(sym->pos, sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x168c8
jmp 0x1695a
jmp 0x168ca
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x16942
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x16915
cmpq $0x0, -0x18(%rbp)
jne 0x16915
jmp 0x16937
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x4(%rax), %rdi
callq 0x15f30
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x15020
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x168d1
jmp 0x16944
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x168ca
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: copy_asm_operands
static struct asm_operand_list *copy_asm_operands(struct asm_operand_list *in)
{
	struct asm_operand_list *out = NULL;
	struct asm_operand *old;

	FOR_EACH_PTR(in, old) {
		struct asm_operand *new = __alloc_asm_operand(0);
		new->name = old->name;
		new->constraint = copy_expression(old->constraint);
		new->expr = copy_expression(old->expr);
		add_ptr_list(&out, new);
	} END_FOR_EACH_PTR(old);
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x169a8
jmp 0x16a81
jmp 0x169aa
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x16a69
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x169f9
cmpq $0x0, -0x18(%rbp)
jne 0x169f9
jmp 0x16a5b
xorl %edi, %edi
callq 0x46c50
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16000
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x16000
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x31370
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x169b1
jmp 0x16a6b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x169aa
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/inline.c
// Function: unset_replace
static void unset_replace(struct symbol *sym)
{
	struct symbol *r = sym->replace;
	if (!r) {
		warning(sym->pos, "symbol '%s' not replaced?", show_ident(sym->ident));
		return;
	}
	r->replace = NULL;
	sym->replace = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16bbf
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x4b88c(%rip), %rsi     # 0x62442
movb $0x0, %al
callq 0x16d80
jmp 0x16bd7
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: info
void info(struct position pos, const char * fmt, ...)
{
	va_list args;

	if (!show_info)
		return;
	va_start(args, fmt);
	do_warn("", pos, fmt, args);
	va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x16c48
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x6d51d(%rip)     # 0x84190
jne 0x16c77
jmp 0x16cb7
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rsi
leaq 0x4bb7b(%rip), %rdi     # 0x62829
callq 0x16cc0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: do_warn
static void do_warn(const char *type, struct position pos, const char * fmt, va_list args)
{
	static char buffer[512];

	/* Shut up warnings if position is bad_token.pos */
	if (pos.type == TOKEN_BAD)
		return;

	vsprintf(buffer, fmt, args);	

	fflush(stdout);
	fprintf(stderr, "%s:%d:%d: %s%s%s\n",
		show_stream_name(pos), pos.line, pos.pos,
		diag_prefix, type, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
andq $0x3f, %rax
cmpl $0x1, %eax
jne 0x16cea
jmp 0x16d78
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x74dc7(%rip), %rdi     # 0x8bac0
callq 0x11280
movq 0x6d2cb(%rip), %rax     # 0x83fd0
movq (%rax), %rdi
callq 0x11210
movq 0x6d2dc(%rip), %rax     # 0x83ff0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17820
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, %ecx
movq -0x8(%rbp), %rax
shrq $0x16, %rax
andq $0x3ff, %rax            # imm = 0x3FF
movl %eax, %r8d
leaq 0x6da6d(%rip), %rax     # 0x847c0
movq (%rax), %r9
movq -0x10(%rbp), %r10
leaq 0x4b746(%rip), %rsi     # 0x624a7
leaq 0x74d58(%rip), %rax     # 0x8bac0
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x111c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: warning
void warning(struct position pos, const char * fmt, ...)
{
	va_list args;

	if (Wsparse_error) {
		va_start(args, fmt);
		do_error(pos, fmt, args);
		va_end(args);
		return;
	}

	if (!fmax_warnings || has_error) {
		show_info = 0;
		return;
	}

	if (!--fmax_warnings) {
		show_info = 0;
		fmt = "too many warnings";
	}

	va_start(args, fmt);
	do_warn("warning: ", pos, fmt, args);
	va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x16db8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6da7d(%rip), %rax     # 0x84860
cmpl $0x0, (%rax)
je 0x16e26
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rdi
callq 0x16ed0
leaq -0x30(%rbp), %rax
jmp 0x16eb9
leaq 0x6d9c3(%rip), %rax     # 0x847f0
cmpl $0x0, (%rax)
je 0x16e3e
leaq 0x7632b(%rip), %rax     # 0x8d164
cmpl $0x0, (%rax)
je 0x16e4a
movl $0x0, 0x6d348(%rip)     # 0x84190
jmp 0x16eb9
leaq 0x6d99f(%rip), %rax     # 0x847f0
movl (%rax), %eax
addl $-0x1, %eax
leaq 0x6d993(%rip), %rcx     # 0x847f0
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x16e79
movl $0x0, 0x6d322(%rip)     # 0x84190
leaq 0x4b5e7(%rip), %rax     # 0x6245c
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rsi
leaq 0x4b5be(%rip), %rdi     # 0x6246e
callq 0x16cc0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: do_error
static void do_error(struct position pos, const char * fmt, va_list args)
{
	static int errors = 0;
        die_if_error = 1;
	show_info = 1;
	/* Shut up warnings if position is bad_token.pos */
	if (pos.type == TOKEN_BAD)
		return;
	/* Shut up warnings after an error */
	has_error |= ERROR_CURR_PHASE;
	if (errors > fmax_errors) {
		static int once = 0;
		show_info = 0;
		if (once)
			return;
		fmt = "too many errors";
		once = 1;
	}

	do_warn("error: ", pos, fmt, args);
	errors++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x76275(%rip), %rax     # 0x8d160
movl $0x1, (%rax)
movl $0x1, 0x6d295(%rip)     # 0x84190
movq -0x8(%rbp), %rax
andq $0x3f, %rax
cmpl $0x1, %eax
jne 0x16f0a
jmp 0x16f81
leaq 0x76253(%rip), %rax     # 0x8d164
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x76247(%rip), %rax     # 0x8d164
movl %ecx, (%rax)
movl 0x74e73(%rip), %eax     # 0x8bd98
leaq 0x6d8c0(%rip), %rcx     # 0x847ec
cmpl (%rcx), %eax
jbe 0x16f5a
movl $0x0, 0x6d256(%rip)     # 0x84190
cmpl $0x0, 0x74e5b(%rip)     # 0x8bd9c
je 0x16f45
jmp 0x16f81
leaq 0x4b5a0(%rip), %rax     # 0x624ec
movq %rax, -0x10(%rbp)
movl $0x1, 0x74e42(%rip)     # 0x8bd9c
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rsi
leaq 0x4b50b(%rip), %rdi     # 0x62478
callq 0x16cc0
movl 0x74e20(%rip), %eax     # 0x8bd98
addl $0x1, %eax
movl %eax, 0x74e17(%rip)     # 0x8bd98
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: error_die
NORETURN_ATTR
void error_die(struct position pos, const char * fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	do_warn("error: ", pos, fmt, args);
	va_end(args);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x17118
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rsi
leaq 0x4b305(%rip), %rdi     # 0x62478
callq 0x16cc0
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x112d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: die
NORETURN_ATTR
void die(const char *fmt, ...)
{
	va_list args;
	static char buffer[512];

	va_start(args, fmt);
	vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	fprintf(stderr, "%s%s\n", diag_prefix, buffer);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x171c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq 0x746a1(%rip), %rdi     # 0x8b8c0
movl $0x200, %esi            # imm = 0x200
callq 0x110b0
leaq -0x20(%rbp), %rax
movq 0x6cdbc(%rip), %rax     # 0x83ff0
movq (%rax), %rdi
leaq 0x6d582(%rip), %rax     # 0x847c0
movq (%rax), %rdx
leaq 0x4b26b(%rip), %rsi     # 0x624b3
leaq 0x74671(%rip), %rcx     # 0x8b8c0
movb $0x0, %al
callq 0x111c0
movl $0x1, %edi
callq 0x112d0
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: add_pre_buffer
void add_pre_buffer(const char *fmt, ...)
{
	va_list args;
	unsigned int size;
	struct token *begin, *end;
	char buffer[4096];

	va_start(args, fmt);
	size = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);
	begin = tokenize_buffer(buffer, size, &end);
	*pre_buffer_next = begin;
	pre_buffer_next = &end->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1100, %rsp           # imm = 0x1100
testb %al, %al
je 0x172a7
movaps %xmm0, -0x10c0(%rbp)
movaps %xmm1, -0x10b0(%rbp)
movaps %xmm2, -0x10a0(%rbp)
movaps %xmm3, -0x1090(%rbp)
movaps %xmm4, -0x1080(%rbp)
movaps %xmm5, -0x1070(%rbp)
movaps %xmm6, -0x1060(%rbp)
movaps %xmm7, -0x1050(%rbp)
movq %r9, -0x10c8(%rbp)
movq %r8, -0x10d0(%rbp)
movq %rcx, -0x10d8(%rbp)
movq %rdx, -0x10e0(%rbp)
movq %rsi, -0x10e8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10f0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x1040(%rbp), %rdi
movq %rdi, -0x10f8(%rbp)
movl $0x1000, %esi           # imm = 0x1000
leaq -0x20(%rbp), %rcx
callq 0x110b0
movq -0x10f8(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdx
callq 0x450c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq 0x6ce62(%rip), %rax     # 0x84198
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, 0x6ce50(%rip)     # 0x84198
addq $0x1100, %rsp           # imm = 0x1100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: create_builtin_stream
static void create_builtin_stream(void)
{
	// Temporary hack
	add_pre_buffer("#define _Pragma(x)\n");

	/* add the multiarch include directories, if any */
	if (multiarch_dir && *multiarch_dir) {
		add_pre_buffer("#add_system \"/usr/include/%s\"\n", multiarch_dir);
		add_pre_buffer("#add_system \"/usr/local/include/%s\"\n", multiarch_dir);
	}

	/* We add compiler headers path here because we have to parse
	 * the arguments to get it, falling back to default. */
	add_pre_buffer("#add_system \"%s/include\"\n", gcc_base_dir);
	add_pre_buffer("#add_system \"%s/include-fixed\"\n", gcc_base_dir);

	add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
	add_pre_buffer("#define __builtin_va_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
	add_pre_buffer("#define __builtin_ms_va_start(a,b) ((a) = (__builtin_ms_va_list)(&(b)))\n");
	add_pre_buffer("#define __builtin_va_arg(arg,type)  ({ type __va_arg_ret = *(type *)(arg); arg += sizeof(type); __va_arg_ret; })\n");
	add_pre_buffer("#define __builtin_va_alist (*(void *)0)\n");
	add_pre_buffer("#define __builtin_va_arg_incr(x) ((x) + 1)\n");
	add_pre_buffer("#define __builtin_va_copy(dest, src) ({ dest = src; (void)0; })\n");
	add_pre_buffer("#define __builtin_ms_va_copy(dest, src) ({ dest = src; (void)0; })\n");
	add_pre_buffer("#define __builtin_va_end(arg)\n");
	add_pre_buffer("#define __builtin_ms_va_end(arg)\n");
	add_pre_buffer("#define __builtin_va_arg_pack()\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4afc1(%rip), %rdi     # 0x624fc
movb $0x0, %al
callq 0x17260
leaq 0x6d287(%rip), %rax     # 0x847d0
cmpq $0x0, (%rax)
je 0x17591
leaq 0x6d27a(%rip), %rax     # 0x847d0
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17591
leaq 0x6d268(%rip), %rax     # 0x847d0
movq (%rax), %rsi
leaq 0x4af9e(%rip), %rdi     # 0x62510
movb $0x0, %al
callq 0x17260
leaq 0x6d250(%rip), %rax     # 0x847d0
movq (%rax), %rsi
leaq 0x4afa5(%rip), %rdi     # 0x6252f
movb $0x0, %al
callq 0x17260
leaq 0x6d230(%rip), %rax     # 0x847c8
movq (%rax), %rsi
leaq 0x4afb2(%rip), %rdi     # 0x62554
movb $0x0, %al
callq 0x17260
leaq 0x6d218(%rip), %rax     # 0x847c8
movq (%rax), %rsi
leaq 0x4afb4(%rip), %rdi     # 0x6256e
movb $0x0, %al
callq 0x17260
leaq 0x4afc6(%rip), %rdi     # 0x6258e
movb $0x0, %al
callq 0x17260
leaq 0x4afff(%rip), %rdi     # 0x625d5
movb $0x0, %al
callq 0x17260
leaq 0x4b034(%rip), %rdi     # 0x62618
movb $0x0, %al
callq 0x17260
leaq 0x4b06f(%rip), %rdi     # 0x62661
movb $0x0, %al
callq 0x17260
leaq 0x4b0d3(%rip), %rdi     # 0x626d3
movb $0x0, %al
callq 0x17260
leaq 0x4b0ee(%rip), %rdi     # 0x626fc
movb $0x0, %al
callq 0x17260
leaq 0x4b10c(%rip), %rdi     # 0x62728
movb $0x0, %al
callq 0x17260
leaq 0x4b13f(%rip), %rdi     # 0x62769
movb $0x0, %al
callq 0x17260
leaq 0x4b175(%rip), %rdi     # 0x627ad
movb $0x0, %al
callq 0x17260
leaq 0x4b186(%rip), %rdi     # 0x627cc
movb $0x0, %al
callq 0x17260
leaq 0x4b19a(%rip), %rdi     # 0x627ee
movb $0x0, %al
callq 0x17260
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: sparse_initial
static struct symbol_list *sparse_initial(void)
{
	int i;

	// Prepend any "include" file to the stream.
	// We're in global scope, it will affect all files!
	for (i = 0; i < cmdline_include_nr; i++)
		add_pre_buffer("#argv_include \"%s\"\n", cmdline_include[i]);

	return sparse_tokenstream(pre_buffer_begin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x75aef(%rip), %rcx     # 0x8d168
cmpl (%rcx), %eax
jge 0x176a5
movslq -0x4(%rbp), %rcx
leaq 0x75bc8(%rip), %rax     # 0x8d250
movq (%rax,%rcx,8), %rsi
leaq 0x4b17c(%rip), %rdi     # 0x6280f
movb $0x0, %al
callq 0x17260
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1766f
movq 0x746f4(%rip), %rdi     # 0x8bda0
callq 0x17af0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: sparse_keep_tokens
struct symbol_list * sparse_keep_tokens(char *filename)
{
	struct symbol_list *res;

	/* Clear previous symbol list */
	translation_unit_used_list = NULL;

	new_file_scope();
	res = sparse_file(filename);

	/* And return it */
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7970d(%rip), %rax     # 0x90de0
movq $0x0, (%rax)
callq 0x32000
movq -0x8(%rbp), %rdi
callq 0x17700
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: sparse_file
static struct symbol_list *sparse_file(const char *filename)
{
	int fd;
	struct token *token;

	if (strcmp(filename, "-") == 0) {
		fd = 0;
	} else {
		fd = open(filename, O_RDONLY);
		if (fd < 0)
			die("No such file: %s", filename);
	}
	base_filename = filename;

	// Tokenize the input stream
	token = tokenize(NULL, filename, fd, NULL, includepath);
	close(fd);

	return sparse_tokenstream(token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x54922(%rip), %rsi     # 0x6c039
callq 0x111b0
cmpl $0x0, %eax
jne 0x1772a
movl $0x0, -0xc(%rbp)
jmp 0x17754
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x11290
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x17752
movq -0x8(%rbp), %rsi
leaq 0x4b0e6(%rip), %rdi     # 0x62831
movb $0x0, %al
callq 0x17190
jmp 0x17754
movq -0x8(%rbp), %rcx
leaq 0x75b91(%rip), %rax     # 0x8d2f0
movq %rcx, (%rax)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x70cac(%rip), %r8      # 0x88420
movq %rcx, %rdi
callq 0x45270
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x11150
movq -0x18(%rbp), %rdi
callq 0x17af0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: sparse
struct symbol_list * sparse(char *filename)
{
	struct symbol_list *res = __sparse(filename);

	if (has_error & ERROR_CURR_PHASE)
		has_error = ERROR_PREV_PHASE;
	/* Evaluate the complete symbol list */
	evaluate_symbol_list(res);

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x177a0
movq %rax, -0x10(%rbp)
leaq 0x75974(%rip), %rax     # 0x8d164
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17807
leaq 0x75963(%rip), %rax     # 0x8d164
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4ff30
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: show_stream_name
static const char *show_stream_name(struct position pos)
{
	const char *name = stream_name(pos.stream);
	static const char *last;

	if (name == base_filename)
		return name;
	if (name == last)
		return name;
	last = name;

	fprintf(stderr, "%s: note: in included file%s:\n",
		base_filename,
		show_include_chain(pos.stream, base_filename));
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, %edi
callq 0x44030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x75aa0(%rip), %rcx     # 0x8d2f0
cmpq (%rcx), %rax
jne 0x1785f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x178dd
movq -0x18(%rbp), %rax
cmpq 0x74456(%rip), %rax     # 0x8bcc0
jne 0x17876
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x178dd
movq -0x18(%rbp), %rax
movq %rax, 0x7443f(%rip)     # 0x8bcc0
movq 0x6c768(%rip), %rax     # 0x83ff0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x75a5a(%rip), %rax     # 0x8d2f0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, %edi
leaq 0x75a3c(%rip), %rax     # 0x8d2f0
movq (%rax), %rsi
callq 0x178f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x4abeb(%rip), %rsi     # 0x624b9
movb $0x0, %al
callq 0x111c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: show_include_chain
static const char *show_include_chain(int stream, const char *base)
{
	static char buffer[200];
	int len = 0;

	while ((stream = stream_prev(stream)) >= 0) {
		const char *p = stream_name(stream);
		int pretty_len;

		if (p == base)
			break;

		pretty_len = prettify(&p);
		if (pretty_len <= 0)
			break;

		/*
		 * At worst, we'll need " (through %s, ...)" in addition to the
		 * new filename
		 */
		if (pretty_len + len + 20 > sizeof(buffer)) {
			if (!len)
				return "";
			memcpy(buffer+len, ", ...", 5);
			len += 5;
			break;
		}

		if (!len) {
			memcpy(buffer, " (through ", 10);
			len = 10;
		} else {
			buffer[len++] = ',';
			buffer[len++] = ' ';
		}

		memcpy(buffer+len, p, pretty_len);
		len += pretty_len;
	}
	if (!len)
		return "";

	buffer[len] = ')';
	buffer[len+1] = 0;
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0xc(%rbp), %edi
callq 0x44080
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x17a27
movl -0xc(%rbp), %edi
callq 0x44030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x17935
jmp 0x17a27
leaq -0x28(%rbp), %rdi
callq 0x17a80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x1794c
jmp 0x17a27
movl -0x2c(%rbp), %eax
addl -0x1c(%rbp), %eax
addl $0x14, %eax
cltq
cmpq $0xc8, %rax
jbe 0x179a1
cmpl $0x0, -0x1c(%rbp)
jne 0x17975
leaq 0x4aebd(%rip), %rax     # 0x62829
movq %rax, -0x8(%rbp)
jmp 0x17a68
movslq -0x1c(%rbp), %rcx
leaq 0x74350(%rip), %rax     # 0x8bcd0
movl 0x4ab52(%rip), %edx     # 0x624d8
movl %edx, (%rax,%rcx)
movb 0x4ab4d(%rip), %dl      # 0x624dc
movb %dl, 0x4(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17a27
cmpl $0x0, -0x1c(%rbp)
jne 0x179cc
movq 0x4ab30(%rip), %rax     # 0x624de
movq %rax, 0x7431b(%rip)     # 0x8bcd0
movw 0x4ab2a(%rip), %ax      # 0x624e6
movw %ax, 0x74315(%rip)      # 0x8bcd8
movl $0xa, -0x1c(%rbp)
jmp 0x179fe
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0x742ef(%rip), %rax     # 0x8bcd0
movb $0x2c, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0x742d6(%rip), %rax     # 0x8bcd0
movb $0x20, (%rax,%rcx)
movslq -0x1c(%rbp), %rax
leaq 0x742c7(%rip), %rdi     # 0x8bcd0
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x111d0
movl -0x2c(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x17906
cmpl $0x0, -0x1c(%rbp)
jne 0x17a3a
leaq 0x4adf5(%rip), %rax     # 0x62829
movq %rax, -0x8(%rbp)
jmp 0x17a68
movslq -0x1c(%rbp), %rcx
leaq 0x7428b(%rip), %rax     # 0x8bcd0
movb $0x29, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x74277(%rip), %rax     # 0x8bcd0
movb $0x0, (%rax,%rcx)
leaq 0x7426c(%rip), %rax     # 0x8bcd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/lib.c
// Function: prettify
static int prettify(const char **fnamep)
{
	const char *name = *fnamep;
	int len = strlen(name);

	if (len > 2 && !memcmp(name, "./", 2)) {
		name += 2;
		len -= 2;
	}

	*fnamep = name;
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x110c0
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jle 0x17ad4
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x2f2e, %ax            # imm = 0x2F2E
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17ad4
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: show_label
const char *show_label(struct basic_block *bb)
{
	static int n;
	static char buffer[4][16];
	char *buf = buffer[3 & ++n];

	if (!bb)
		return ".L???";
	snprintf(buf, 16, ".L%u", bb->nr);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x73fc6(%rip), %eax     # 0x8bdd8
addl $0x1, %eax
movl %eax, 0x73fbd(%rip)     # 0x8bdd8
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x73fb8(%rip), %rax     # 0x8bde0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17e47
leaq 0x4b687(%rip), %rax     # 0x634c8
movq %rax, -0x8(%rbp)
jmp 0x17e6d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
movl $0x10, %esi
leaq 0x4b670(%rip), %rdx     # 0x634ce
movb $0x0, %al
callq 0x11100
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: show_asm
static char *show_asm(char *buf, struct instruction *insn)
{
	struct asm_rules *rules = insn->asm_rules;

	buf += sprintf(buf, "\"%s\"", insn->string);
	buf = show_asm_constraints(buf, "\n\t\tout: ", rules->outputs);
	buf = show_asm_constraints(buf, "\n\t\tin: ", rules->inputs);
	buf = show_asm_constraints(buf, "\n\t\tclobber: ", rules->clobbers);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x4e71a(%rip), %rsi     # 0x67bc9
movb $0x0, %al
callq 0x112c0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x4a495(%rip), %rsi     # 0x6396e
callq 0x1ae10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x4a483(%rip), %rsi     # 0x63977
callq 0x1ae10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x4a46f(%rip), %rsi     # 0x6397f
callq 0x1ae10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./linearize.h
// Function: bb_terminated
static inline int bb_terminated(struct basic_block *bb)
{
	struct instruction *insn;
	if (!bb)
		return 0;
	insn = last_instruction(bb->insns);
	return insn && insn->opcode >= OP_TERMINATOR
	            && insn->opcode <= OP_TERMINATOR_END;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x19cbc
movl $0x0, -0x4(%rbp)
jmp 0x19d09
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1af90
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x19cfe
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
movb %al, -0x19(%rbp)
jl 0x19cfe
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x7, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: show_symbol_usage
static void show_symbol_usage(pseudo_t pseudo)
{
	struct pseudo_user *pu;

	if (pseudo) {
		FOR_EACH_PTR(pseudo->users, pu) {
			printf("\t%s\n", show_instruction(pu->insn));
		} END_FOR_EACH_PTR(pu);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a0d0
jmp 0x1a019
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1a041
jmp 0x1a0ce
jmp 0x1a043
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1a0b6
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1a08e
cmpq $0x0, -0x10(%rbp)
jne 0x1a08e
jmp 0x1a0ab
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x18200
movq %rax, %rsi
leaq 0x4e503(%rip), %rdi     # 0x685a7
movb $0x0, %al
callq 0x110f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a04a
jmp 0x1a0b8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1a043
jmp 0x1a0d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: insert_select
void insert_select(struct basic_block *bb, struct instruction *br, struct instruction *phi_node, pseudo_t if_true, pseudo_t if_false)
{
	pseudo_t target;
	struct instruction *select;

	select = alloc_typed_instruction(OP_SEL, phi_node->type);

	assert(br->cond);
	use_pseudo(select, br->cond, &select->src1);

	target = phi_node->target;
	assert(target->def == phi_node);
	select->target = target;
	target->def = select;

	use_pseudo(select, if_true, &select->src2);
	use_pseudo(select, if_false, &select->src3);

	insert_last_instruction(bb, select);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x41, %edi
callq 0x1a240
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1a16f
jmp 0x1a18e
leaq 0x495bd(%rip), %rdi     # 0x63733
leaq 0x495bf(%rip), %rsi     # 0x6373c
movl $0x2be, %edx            # imm = 0x2BE
leaq 0x495bf(%rip), %rcx     # 0x63748
callq 0x11120
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x38(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1a1c3
jmp 0x1a1e2
leaq 0x495e7(%rip), %rdi     # 0x637b1
leaq 0x4956b(%rip), %rsi     # 0x6373c
movl $0x2c2, %edx            # imm = 0x2C2
leaq 0x4956b(%rip), %rcx     # 0x63748
callq 0x11120
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x30, %rdx
addq $0x8, %rdx
callq 0x1a290
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x30, %rdx
addq $0x10, %rdx
callq 0x1a290
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a2e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./linearize.h
// Function: insert_last_instruction
static inline void insert_last_instruction(struct basic_block *bb, struct instruction *insn)
{
	struct instruction *last = delete_last_instruction(&bb->insns);
	add_instruction(&bb->insns, insn);
	add_instruction(&bb->insns, last);
	insn->bb = bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x1b0e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a620
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a620
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_pseudo
pseudo_t alloc_pseudo(struct instruction *def)
{
	static int nr = 0;
	struct pseudo * pseudo = __alloc_pseudo(0);
	pseudo->type = PSEUDO_REG;
	pseudo->nr = ++nr;
	pseudo->def = def;
	return pseudo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x475b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, 0x4(%rax)
movl 0x72bc8(%rip), %ecx     # 0x8cf30
addl $0x1, %ecx
movl %ecx, 0x72bbf(%rip)     # 0x8cf30
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: value_pseudo
pseudo_t value_pseudo(long long val)
{
#define MAX_VAL_HASH 64
	static struct pseudo_list *prev[MAX_VAL_HASH];
	int hash = val & (MAX_VAL_HASH-1);
	struct pseudo_list **list = prev + hash;
	pseudo_t pseudo;

	FOR_EACH_PTR(*list, pseudo) {
		if (pseudo->value == val)
			return pseudo;
	} END_FOR_EACH_PTR(pseudo);

	pseudo = __alloc_pseudo(0);
	pseudo->type = PSEUDO_VAL;
	pseudo->value = val;
	add_pseudo(list, pseudo);

	/* Value pseudos have neither nr, usage nor def */
	return pseudo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x72b8e(%rip), %rax     # 0x8cf40
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1a3e4
jmp 0x1a46e
jmp 0x1a3e6
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1a456
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1a431
cmpq $0x0, -0x28(%rbp)
jne 0x1a431
jmp 0x1a44b
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1a449
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a4a5
jmp 0x1a44b
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1a3ed
jmp 0x1a458
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x1a3e6
xorl %edi, %edi
callq 0x475b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x6, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a4b0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phisrc
struct instruction *alloc_phisrc(pseudo_t pseudo, struct symbol *type)
{
	struct instruction *insn = alloc_typed_instruction(OP_PHISOURCE, type);
	pseudo_t phi = __alloc_pseudo(0);
	static int nr = 0;

	phi->type = PSEUDO_PHI;
	phi->nr = ++nr;
	phi->def = insn;

	use_pseudo(insn, pseudo, &insn->phi_src);
	insn->target = phi;
	return insn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x45, %edi
callq 0x1a240
movq %rax, -0x18(%rbp)
xorl %edi, %edi
callq 0x475b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x4(%rax)
movl 0x72be2(%rip), %ecx     # 0x8d140
addl $0x1, %ecx
movl %ecx, 0x72bd9(%rip)     # 0x8d140
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phi
pseudo_t alloc_phi(struct basic_block *source, pseudo_t pseudo, struct symbol *type)
{
	struct instruction *insn;

	if (!source)
		return VOID;

	insn = alloc_phisrc(pseudo, type);
	insn->bb = source;
	add_instruction(&source->insns, insn);
	return insn->target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a5d8
leaq 0x717de(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x1a612
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a520
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0x1a620
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phi_node
struct instruction *alloc_phi_node(struct basic_block *bb, struct symbol *type, struct ident *ident)
{
	struct instruction *phi_node = alloc_typed_instruction(OP_PHI, type);
	pseudo_t phi;

	phi = alloc_pseudo(phi_node);
	phi->ident = ident;
	phi->def = phi_node;
	phi_node->target = phi;
	phi_node->bb = bb;
	return phi_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x46, %edi
callq 0x1a240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a340
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)