LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x10b41
leaq 0x10(%rbx), %r15
movq %r12, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x10b38
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x10b14
testq %rdi, %rdi
je 0x10b29
callq 0x10cb8
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
movzwl (%r13), %eax
incq %rbp
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbp
jl 0x10aff
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x10af4
movq 0x28(%r14), %rdi
callq 0x10cb8
movq %rax, 0x28(%rbx)
movq 0x4(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x11111
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x10c0f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x2f94f(%rip), %r14     # 0x404e6
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x10bf7
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10bba
testq %rbp, %rbp
je 0x10be7
movq 0x28(%rbp), %rax
testq %rax, %rax
je 0x10bcd
movq %r15, 0x28(%rax)
movq %r15, 0x28(%rbp)
jmp 0x10be7
movq 0x18(%rbp), %rdi
callq 0x2de35
movq 0x4(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x10ba6
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x10b9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x60(%rdi), %r15
movq 0xa8(%rdi), %rdi
movq 0x88(%r15), %rbx
callq 0x10a0c
movq %rax, 0x98(%r14)
testq %rbx, %rbx
je 0x10c7b
movq %rbx, %rax
movzwl (%rax), %ecx
testb %cl, %cl
jle 0x10c72
xorl %edx, %edx
movq 0x18(%rax,%rdx,8), %rsi
movzwl %cx, %edi
cmpl $0x100, %edi            # imm = 0x100
jb 0x10c5c
testq %rsi, %rsi
je 0x10c63
movq %rsi, 0x28(%rsi)
movzwl (%rax), %ecx
incq %rdx
movzwl %cx, %esi
movsbq %sil, %rsi
cmpq %rsi, %rdx
jl 0x10c47
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x10c3e
movq 0x4(%r15), %rdi
movl $0x3, %esi
callq 0x195bf
movq %rax, 0x90(%r15)
movq 0xa0(%r15), %rdi
movq %rax, %rsi
callq 0x10ad3
movq 0x98(%r14), %rdi
callq 0x10b76
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10b76
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x11128
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x5c, 0x68(%rsi)
je 0x1112b
movq %rbx, %rax
jmp 0x11134
xorl %eax, %eax
retq
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x1113c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq 0x18(%rbx), %rdi
callq 0x2de35
leaq 0x2f380(%rip), %rsi     # 0x404cf
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
jmp 0x11123
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x1168b
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x1167c
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x11655
testq %rsi, %rsi
je 0x1166d
movq 0x4(%rsi), %rdi
callq 0x11111
movq %r14, %rdi
movq %rax, %rsi
callq 0x227b4
movzwl (%r15), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0x11640
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x11635
movq (%rsp), %rax
jmp 0x1168d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x11739
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x11729
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x116df
testq %rbp, %rbp
je 0x1171a
xorl %edi, %edi
callq 0x2f992
movq %rax, %r15
movq (%rbp), %rax
movq %rax, (%r15)
movq 0x8(%rbp), %rdi
callq 0x1115e
movq %rax, 0x8(%r15)
movq 0x10(%rbp), %rdi
callq 0x1115e
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x227b4
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x116ca
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x116be
movq (%rsp), %rax
jmp 0x1173b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %r14d, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
jne 0x11855
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x53e81(%rip), %r15     # 0x656e0
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xe280
movq 0x4e694(%rip), %rax     # 0x5ff08
movq (%rax), %rdi
callq 0xe210
movq 0x4e775(%rip), %rax     # 0x5fff8
movq (%rax), %r12
movl %r14d, %ebp
shrl $0x6, %ebp
andl $0x3fff, %ebp           # imm = 0x3FFF
movl %ebp, %edi
callq 0x2dd94
movq %rax, %r13
leaq 0x5566d(%rip), %rax     # 0x66f10
movq (%rax), %rdx
cmpq %rdx, %r13
je 0x118be
cmpq 0x5402e(%rip), %r13     # 0x658e0
je 0x118be
movq %r13, %rdi
movl %ebp, %esi
callq 0xe320
movq %r14, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x16, %r14d
leaq 0x4ec6a(%rip), %rax     # 0x60540
movq (%rax), %r9
leaq 0x2ec6b(%rip), %rsi     # 0x4054b
movq %r12, %rdi
movq %r13, %rdx
movl %r14d, %r8d
xorl %eax, %eax
pushq %r15
pushq %rbx
callq 0xe1d0
addq $0x18, %rsp
jmp 0x1184a
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0xd8, %rsp
movq %rsi, %r10
movq %rdi, %rsi
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x11958
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x4ec81(%rip), %rax     # 0x605e0
cmpl $0x0, (%rax)
je 0x11996
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %rsi, %rdi
movq %r10, %rsi
callq 0x11a08
jmp 0x11a00
leaq 0x4ebd3(%rip), %rax     # 0x60570
movl (%rax), %ecx
testl %ecx, %ecx
je 0x119f9
leaq 0x553da(%rip), %rdx     # 0x66d84
cmpl $0x0, (%rdx)
jne 0x119f9
decl %ecx
movl %ecx, (%rax)
jne 0x119c3
movb $0x1, 0x53b14(%rip)     # 0x654d0
leaq 0x2eb3d(%rip), %r10     # 0x40500
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0x2eb23(%rip), %rdi     # 0x40512
movq %r10, %rdx
callq 0x1182d
jmp 0x11a00
movb $0x1, 0x53ad0(%rip)     # 0x654d0
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x55368(%rip), %rax     # 0x66d80
movl $0x1, (%rax)
movb $0x0, 0x53aab(%rip)     # 0x654d0
movl %esi, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
je 0x11a7f
leaq 0x5534e(%rip), %rax     # 0x66d84
orb $0x1, (%rax)
movl 0x53f79(%rip), %eax     # 0x659b8
leaq 0x4eb26(%rip), %rdi     # 0x6056c
cmpl (%rdi), %eax
jbe 0x11a68
movb $0x1, 0x53a7f(%rip)     # 0x654d0
cmpb $0x0, 0x53f64(%rip)     # 0x659bc
jne 0x11a7f
movb $0x1, 0x53f5b(%rip)     # 0x659bc
leaq 0x2eb28(%rip), %rdx     # 0x40590
pushq %rax
leaq 0x2eaac(%rip), %rdi     # 0x4051c
callq 0x1182d
incl 0x53f3d(%rip)           # 0x659b8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x11c91
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x53828(%rip), %rbx     # 0x654e0
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
movq %r10, %rdx
callq 0xe0b0
movq 0x4e329(%rip), %rax     # 0x5fff8
movq (%rax), %rdi
leaq 0x4e867(%rip), %rax     # 0x60540
movq (%rax), %rdx
leaq 0x2e874(%rip), %rsi     # 0x40557
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe1d0
movl $0x1, %edi
callq 0xe2d0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10e8, %rsp           # imm = 0x10E8
movq %rdi, %r10
leaq 0x30(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x11d5b
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x1100(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r10, %rdx
callq 0xe0b0
movl %eax, %esi
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2e8ba
movq 0x4e3f2(%rip), %rcx     # 0x601a0
movq %rax, (%rcx)
movq (%r14), %rax
addq $0x8, %rax
movq %rax, 0x4e3e1(%rip)     # 0x601a0
addq $0x10e8, %rsp           # imm = 0x10E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x58983(%rip), %rax     # 0x6aa00
movq $0x0, (%rax)
callq 0x22df7
cmpb $0x2d, (%rbx)
jne 0x12094
cmpb $0x0, 0x1(%rbx)
je 0x120da
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xe290
movl %eax, %ebp
testl %eax, %eax
js 0x120de
leaq 0x54e63(%rip), %rax     # 0x66f10
movq %rbx, (%rax)
leaq 0x512f9(%rip), %r8      # 0x633b0
xorl %edi, %edi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2ed56
movq %rax, %rbx
movl %ebp, %edi
callq 0xe150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1212f
xorl %ebp, %ebp
jmp 0x120a6
leaq 0x2e7f0(%rip), %rdi     # 0x408d5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x12070
movq %rax, %rbx
callq 0x2f8b1
leaq 0x54c6d(%rip), %rax     # 0x66d84
testb $0x1, (%rax)
je 0x12122
movl $0x2, (%rax)
movq %rbx, %rdi
callq 0x3642b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/lib.c
// Function: sparse_tokenstream
static struct symbol_list *sparse_tokenstream(struct token *token)
{
	int builtin = token && !token->pos.stream;

	// Preprocess the stream
	token = preprocess(token);

	if (dump_macro_defs || dump_macros_only) {
		if (!builtin)
			dump_macro_definitions();
		if (dump_macros_only)
			return NULL;
	}

	if (preprocess_only) {
		while (!eof_token(token)) {
			int prec = 1;
			struct token *next = token->next;
			const char *separator = "";
			if (next->pos.whitespace)
				separator = " ";
			if (next->pos.newline) {
				separator = "\n\t\t\t\t\t";
				prec = next->pos.pos;
				if (prec > 4)
					prec = 4;
			}
			printf("%s%.*s", show_token(token), prec, separator);
			token = next;
		}
		putchar('\n');

		return NULL;
	}

	// Parse the resulting C code
	while (!eof_token(token))
		token = external_declaration(token, &translation_unit_used_list, NULL);
	return translation_unit_used_list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1214b
testl $0xfffc0, (%rdi)        # imm = 0xFFFC0
sete %bpl
jmp 0x1214d
xorl %ebp, %ebp
callq 0x1f57b
movq %rax, %rbx
leaq 0x54c60(%rip), %rcx     # 0x66dbc
leaq 0x54c5d(%rip), %r14     # 0x66dc0
movl (%r14), %eax
movl (%rcx), %ecx
orl %eax, %ecx
je 0x12181
testb %bpl, %bpl
jne 0x12179
callq 0x1f884
movl (%r14), %eax
testl %eax, %eax
jne 0x12219
leaq 0x54cd4(%rip), %rax     # 0x66e5c
cmpl $0x0, (%rax)
je 0x1221d
cmpq 0x4dd50(%rip), %rbx     # 0x5fee8
je 0x1220f
leaq 0x2e72d(%rip), %r14     # 0x408ce
leaq 0x74438(%rip), %r13     # 0x865e0
movq 0x8(%rbx), %r12
movl (%r12), %eax
btl $0x15, %eax
leaq 0x2f4d5(%rip), %r15     # 0x41690
leaq 0x2e70b(%rip), %rcx     # 0x408cd
cmovaeq %rcx, %r15
movl %eax, %ebp
shrl $0x16, %ebp
cmpl $0x4, %ebp
movl $0x4, %ecx
cmovael %ecx, %ebp
btl $0x14, %eax
movl $0x1, %eax
cmovael %eax, %ebp
leaq 0x2e6de(%rip), %rax     # 0x408c7
cmovbq %rax, %r15
movq %rbx, %rdi
callq 0x2df90
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xe0f0
movq %r12, %rbx
cmpq %r13, %r12
jne 0x121a8
movl $0xa, %edi
callq 0xe040
xorl %eax, %eax
jmp 0x12253
cmpq 0x4dcc4(%rip), %rbx     # 0x5fee8
je 0x12249
leaq 0x587d3(%rip), %r14     # 0x6aa00
leaq 0x743ac(%rip), %r15     # 0x865e0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a785
movq %rax, %rbx
cmpq %r15, %rax
jne 0x12234
leaq 0x587b0(%rip), %rax     # 0x6aa00
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl 0x5373c(%rip), %eax     # 0x659f8
incl %eax
movl %eax, 0x53734(%rip)     # 0x659f8
testq %rdi, %rdi
je 0x122f4
andl $0x3, %eax
shll $0x4, %eax
leaq 0x5372a(%rip), %rbx     # 0x65a00
addq %rax, %rbx
movl 0x38(%rdi), %ecx
leaq 0x2f2bb(%rip), %rdx     # 0x4159e
movl $0x10, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe100
jmp 0x122fb
leaq 0x2f29d(%rip), %rbx     # 0x41598
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x333d5(%rip), %rsi     # 0x461bd
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %rdi
addq %r14, %rdi
movq 0x8(%rbx), %rdx
leaq 0x2ec14(%rip), %rsi     # 0x41a14
callq 0x13f68
movq (%rbx), %rdx
leaq 0x2ec0e(%rip), %rsi     # 0x41a1d
movq %rax, %rdi
callq 0x13f68
movq 0x10(%rbx), %rdx
leaq 0x2ec03(%rip), %rsi     # 0x41a25
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13f68
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x18(%rdx), %rsi
movl $0x41, %edi
callq 0x13674
movq 0x30(%rbp), %rbp
testq %rbp, %rbp
je 0x13636
movq %rax, %r14
movq %rbp, 0x30(%rax)
movl 0x4(%rbp), %eax
cmpl $0x6, %eax
ja 0x13523
movl $0x43, %ecx
btl %eax, %ecx
jb 0x13556
leaq 0x30(%r14), %rax
movq %rax, (%rsp)
leaq 0x4cc7e(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x20(%r13), %rax
cmpq %r13, 0x18(%rax)
jne 0x13655
movq %rax, 0x20(%r14)
movq %r14, 0x18(%rax)
movq %r12, 0x38(%r14)
testq %r12, %r12
je 0x135b4
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x13589
movl $0x43, %ecx
btl %eax, %ecx
jb 0x135b4
leaq 0x38(%r14), %r13
leaq 0x4cc1c(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x227b4
movq %r15, 0x40(%r14)
testq %r15, %r15
je 0x135fe
movl 0x4(%r15), %eax
cmpl $0x6, %eax
ja 0x135d0
movl $0x43, %ecx
btl %eax, %ecx
jb 0x135fe
movq %r14, %r12
addq $0x40, %r12
leaq 0x4cbd2(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r12, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x22a6b
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x227b4
movq %r15, %rdi
movq %r12, %rsi
callq 0x227b4
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e1a0(%rip), %rdi     # 0x417dd
leaq 0x2e1a2(%rip), %rsi     # 0x417e6
leaq 0x2e1a7(%rip), %rcx     # 0x417f2
movl $0x2be, %edx            # imm = 0x2BE
callq 0xe120
leaq 0x2e1ff(%rip), %rdi     # 0x4185b
leaq 0x2e183(%rip), %rsi     # 0x417e6
leaq 0x2e188(%rip), %rcx     # 0x417f2
movl $0x2c2, %edx            # imm = 0x2C2
callq 0xe120
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2fd6f
movl $0x3, 0x4(%rax)
movl 0x5341b(%rip), %ecx     # 0x66b50
incl %ecx
movl %ecx, 0x53413(%rip)     # 0x66b50
movl %ecx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3f, %eax
leaq 0x53407(%rip), %rcx     # 0x66b60
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x137a6
movq %rdx, %rsi
movzwl (%rsi), %r8d
movsbl %r8b, %edi
testw %di, %di
jle 0x1379d
movzwl %di, %edi
movzwl %r8w, %r8d
xorl %r9d, %r9d
movq 0x18(%rsi,%r9,8), %r14
cmpl $0x100, %r8d            # imm = 0x100
jb 0x1378f
testq %r14, %r14
je 0x13795
cmpq %rbx, 0x18(%r14)
je 0x137ca
incq %r9
cmpq %r9, %rdi
jne 0x1377c
movq 0x10(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x13765
leaq (%rcx,%rax,8), %r15
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r14
movl $0x6, 0x4(%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x45, %edi
callq 0x13674
movq %rax, %rbx
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r15
movl $0x2, 0x4(%rax)
movl 0x5354d(%rip), %eax     # 0x66d60
incl %eax
movl %eax, 0x53545(%rip)     # 0x66d60
movl %eax, (%r15)
movq %rbx, 0x18(%r15)
movq %r14, 0x30(%rbx)
testq %r14, %r14
je 0x1386c
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x1383e
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1386c
movq %rbx, %r12
addq $0x30, %r12
leaq 0x4c964(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r12, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x227b4
movq %r15, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x138b8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x137e4
movq %rax, %r14
movq %rbx, 0x8(%rax)
addq $0x28, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x20(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x52111(%rip), %rax     # 0x659d0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl $0x46, %edi
callq 0x13674
movq %rax, %r15
xorl %edi, %edi
callq 0x2fd6f
movl $0x3, 0x4(%rax)
movl 0x53264(%rip), %ecx     # 0x66b50
incl %ecx
movl %ecx, 0x5325c(%rip)     # 0x66b50
movl %ecx, (%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rax, 0x20(%r15)
movq %r14, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_phi_node
void add_phi_node(struct basic_block *bb, struct instruction *phi_node)
{
	struct instruction *insn;

	FOR_EACH_PTR(bb->insns, insn) {
		enum opcode op = insn->opcode;
		if (op == OP_PHI)
			continue;
		INSERT_CURRENT(phi_node, insn);
		return;
	} END_FOR_EACH_PTR(insn);

	// FIXME
	add_instruction(&bb->insns, phi_node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x13973
movq %rcx, %r14
movl (%r14), %eax
movl %eax, %edx
shll $0x8, %edx
testw %dx, %dx
jle 0x1396a
movl %eax, %esi
shll $0x8, %esi
movsbl %al, %r8d
movzwl %ax, %r9d
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %r10
cmpl $0x100, %r9d            # imm = 0x100
jb 0x13953
testq %r10, %r10
je 0x13960
movl (%r10), %r10d
andl $0x7f, %r10d
cmpl $0x46, %r10d
jne 0x13984
incq %r15
movl %esi, %edx
cmpl %r8d, %r15d
jl 0x13940
movq 0x10(%r14), %r14
cmpq %rcx, %r14
jne 0x13923
addq $0x28, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x227b4
movzwl %dx, %ecx
cmpl $0xd00, %ecx            # imm = 0xD00
jne 0x139b6
movq %r14, %rdi
callq 0x22738
movl (%r14), %eax
movsbl %al, %ecx
cmpl %ecx, %r15d
jl 0x139b6
movq 0x10(%r14), %r14
movzwl %ax, %eax
movzwl (%r14), %ecx
movsbq %al, %rax
subq %rax, %r15
movl %ecx, %eax
leaq (%r14,%r15,8), %rcx
addq $0x18, %rcx
movzwl %ax, %eax
movsbq %al, %rax
leaq (%r14,%rax,8), %rax
addq $0x10, %rax
cmpq %rcx, %rax
jb 0x139df
movq (%rax), %rdx
movq %rdx, 0x8(%rax)
addq $-0x8, %rax
jmp 0x139cd
movq %rbx, (%rcx)
incb (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: init_linearized_builtins
void init_linearized_builtins(int stream)
{
	struct sym_init *ptr;

	for (ptr = builtins_table; ptr->name; ptr++) {
		struct symbol *sym;
		sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
		if (!sym->op)
			sym->op = &ptr->op;
		sym->op->type |= KW_BUILTIN;
		sym->op->linearize = ptr->linearize;
	}
}

// Assembly:
movq 0x4c34f(%rip), %rsi     # 0x60260
testq %rsi, %rsi
je 0x13f67
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4c3b5(%rip), %r14     # 0x602d8
movl %ebx, %edi
movl $0x3, %edx
movl $0x10, %ecx
callq 0x2bf00
movq 0x40(%rax), %rcx
testq %rcx, %rcx
jne 0x13f45
leaq -0x68(%r14), %rcx
movq %rcx, 0x40(%rax)
orb $0x10, (%rcx)
movq -0x70(%r14), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x20(%rax)
movq (%r14), %rsi
addq $0x78, %r14
testq %rsi, %rsi
jne 0x13f23
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: show_asm_constraints
static char *show_asm_constraints(char *buf, const char *sep, struct asm_constraint_list *list)
{
	struct asm_constraint *entry;

	FOR_EACH_PTR(list, entry) {
		buf += sprintf(buf, "%s\"%s\"", sep, entry->constraint);
		if (entry->pseudo)
			buf += sprintf(buf, " (%s)", show_pseudo(entry->pseudo));
		if (entry->ident)
			buf += sprintf(buf, " [%s]", show_ident(entry->ident));
		sep = ", ";		
	} END_FOR_EACH_PTR(entry);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rdi, %r13
testq %rdx, %rdx
je 0x1404e
movq %rsi, %rdx
leaq 0x2d7ef(%rip), %rbx     # 0x4177b
movq %rax, %r15
movq %rax, (%rsp)
movzwl (%r15), %eax
testb %al, %al
jle 0x1403d
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x13fb6
testq %r14, %r14
je 0x1402a
movq 0x8(%r14), %rcx
movq %r13, %rdi
leaq 0x2da6e(%rip), %rsi     # 0x41a32
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %rbp
addq %r13, %rbp
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13ff7
callq 0x12300
movq %rbp, %rdi
leaq 0x33692(%rip), %rsi     # 0x4767a
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2c0
cltq
addq %rax, %rbp
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x14024
callq 0x2de35
movq %rbp, %rdi
leaq 0x2da2a(%rip), %rsi     # 0x41a39
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %r13
addq %rbp, %r13
movq %rbx, %rdx
jmp 0x1402a
movq %rbx, %rdx
movq %rbp, %r13
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x13fa2
movq 0x10(%r15), %r15
movq (%rsp), %rax
cmpq %rax, %r15
jne 0x13f93
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: set_activeblock
static void set_activeblock(struct entrypoint *ep, struct basic_block *bb)
{
	if (!bb_terminated(ep->active))
		add_goto(ep, bb);

	ep->active = bb;
	if (bb_reachable(bb))
		add_bb(&ep->bbs, bb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1408e
movq 0x28(%rax), %rdi
callq 0x225ce
testq %rax, %rax
je 0x1408e
movl (%rax), %eax
andl $0x7e, %eax
addl $-0x8, %eax
cmpl $-0x7, %eax
ja 0x14099
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14453
movq %rbx, 0x20(%r14)
testq %rbx, %rbx
je 0x140b8
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x227b4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_fn_statement
static pseudo_t linearize_fn_statement(struct entrypoint *ep, struct statement *stmt)
{
	struct instruction *phi_node;
	struct basic_block *bb;
	pseudo_t pseudo;

	pseudo = linearize_compound_statement(ep, stmt);
	if (!is_void_type(stmt->ret)) {			// non-void function
		struct basic_block *active = ep->active;
		if (active && !bb_terminated(active)) {	// missing return
			struct basic_block *bb_ret;
			bb_ret = get_bound_block(ep, stmt->ret);
			add_return(ep, bb_ret, stmt->ret, undef_pseudo());
		}
	}
	bb = add_label(ep, stmt->ret);
	phi_node = first_instruction(bb->insns);
	if (phi_node)
		pseudo = phi_node->target;
	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x16f9c
movq %rax, %rbx
movq 0x18(%r15), %rax
cmpb $0x3, (%rax)
jne 0x143c9
movq 0x60(%rax), %rax
cmpq 0x4bb78(%rip), %rax     # 0x5ff48
je 0x14428
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x14428
movq 0x28(%rax), %rdi
callq 0x225ce
testq %rax, %rax
je 0x143f6
movl (%rax), %eax
andl $0x7e, %eax
addl $-0x8, %eax
cmpl $-0x7, %eax
ja 0x14428
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x16f53
movq %rax, %r12
movq 0x18(%r15), %r13
xorl %edi, %edi
callq 0x2fd6f
movl $0x1, 0x4(%rax)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x1727f
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x16ed4
movq 0x28(%rax), %rdi
callq 0x225b0
testq %rax, %rax
je 0x14446
movq 0x20(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_goto
static void add_goto(struct entrypoint *ep, struct basic_block *dst)
{
	struct basic_block *src = ep->active;
	if (bb_reachable(src)) {
		struct instruction *br = alloc_instruction(OP_BR, 0);
		br->bb_true = dst;
		add_bb(&dst->parents, src);
		add_bb(&src->children, dst);
		br->bb = src;
		add_instruction(&src->insns, br);
		ep->active = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x144c9
movq %rsi, %r15
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2fca9
movq %rax, %r12
movl $0x80, %eax
andl (%r12), %eax
orl $0x3, %eax
movl %eax, (%r12)
movq 0x528dd(%rip), %rax     # 0x66d68
movq %rax, 0x10(%r12)
movq %r15, 0x38(%r12)
leaq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x227b4
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x227b4
movq %r14, 0x8(%r12)
addq $0x28, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x227b4
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_asm_rule
static void add_asm_rule(struct instruction *insn, struct asm_constraint_list **list, struct asm_operand *op, pseudo_t pseudo)
{
	struct asm_constraint *rule = __alloc_asm_constraint(0);
	rule->is_memory = op->is_memory;
	rule->ident = op->name;
	rule->constraint = op->constraint ? op->constraint->string->data : "";
	use_pseudo(insn, pseudo, &rule->pseudo);
	add_ptr_list(list, rule);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x4ae2f(%rip), %rdi     # 0x60220
movl $0x20, %esi
callq 0x2f700
movq %rax, %r15
movb 0x18(%r13), %al
shrb $0x5, %al
andb $0x1, %al
movb 0x18(%r15), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x18(%r15)
movq (%r13), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x1542f
movq 0x28(%rax), %rax
addq $0x4, %rax
jmp 0x15436
leaq 0x2b497(%rip), %rax     # 0x408cd
movq %rax, 0x8(%r15)
movq %r14, (%r15)
testq %r14, %r14
je 0x1547c
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x15455
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1547c
leaq 0x4ad54(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r15, 0x8(%rax)
movq %r12, (%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x227b4
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x227b4
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_one_symbol
static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
{
	struct access_data ad = { NULL, };
	pseudo_t value;

	if (!sym || !sym->initializer || sym->initialized)
		return VOID;

	/* We need to output these puppies some day too.. */
	if (sym->ctype.modifiers & (MOD_STATIC | MOD_TOPLEVEL))
		return VOID;

	sym->initialized = 1;
	ad.address = symbol_pseudo(ep, sym);

	if (sym->initializer && !is_scalar_type(sym)) {
		// default zero initialization [6.7.9.21]
		// FIXME: this init the whole aggregate while
		// only the existing fields need to be initialized.
		// FIXME: this init the whole aggregate even if
		// all fields arelater  explicitely initialized.
		ad.type = sym;
		ad.address = symbol_pseudo(ep, sym);
		linearize_store_gen(ep, value_pseudo(0), &ad);
	}

	value = linearize_initializer(ep, sym->initializer, &ad);
	return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x50524(%rip), %rax     # 0x659d0
testq %rsi, %rsi
je 0x15585
movq %rsi, %r14
cmpq $0x0, 0xb0(%rsi)
je 0x15585
movl 0x54(%r14), %ecx
btl $0xa, %ecx
jb 0x15585
testb $0x14, 0x68(%r14)
jne 0x15585
movq %rdi, %rbx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x54(%r14)
movq %r14, %rsi
callq 0x167e4
movq %rax, 0x10(%rsp)
movq 0xb0(%r14), %rsi
testq %rsi, %rsi
je 0x15578
movzbl (%r14), %ecx
movq %r14, %rax
cmpl $0x3, %ecx
jne 0x15517
movq 0x60(%r14), %rax
movl (%rax), %ecx
cmpb $0xe, %cl
ja 0x15529
movzbl %cl, %ecx
movl $0x6a10, %edx           # imm = 0x6A10
btl %ecx, %edx
jb 0x1557a
movq 0x60(%rax), %rax
cmpq 0x4aa54(%rip), %rax     # 0x5ff88
sete %cl
cmpq 0x4aa12(%rip), %rax     # 0x5ff50
sete %al
orb %cl, %al
jne 0x1557a
movq %rsp, %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x167e4
movq %rax, 0x10(%r15)
xorl %edi, %edi
callq 0x13745
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1684b
movq 0xb0(%r14), %rsi
jmp 0x1557a
xorl %esi, %esi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x16aaf
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_setfval
static pseudo_t add_setfval(struct entrypoint *ep, struct symbol *ctype, long double fval)
{
	struct instruction *insn = alloc_typed_instruction(OP_SETFVAL, ctype);
	pseudo_t target = alloc_pseudo(insn);
	insn->target = target;
	insn->fvalue = fval;
	add_one_insn(ep, insn);
	return target;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
fldt 0x30(%rsp)
fstpt 0x4(%rsp)
movl $0x49, %edi
callq 0x13674
movq %rax, %rbx
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x51589(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x51581(%rip)     # 0x66b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
fldt 0x4(%rsp)
fstpt 0x30(%rbx)
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x155fa
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x227b4
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_binop
static pseudo_t linearize_binop(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t src1, src2, dst;
	static const int opcode[] = {
		['+'] = OP_ADD, ['-'] = OP_SUB,
		['*'] = OP_MUL, ['/'] = OP_DIVU,
		['%'] = OP_MODU, ['&'] = OP_AND,
		['|'] = OP_OR,  ['^'] = OP_XOR,
		[SPECIAL_LEFTSHIFT] = OP_SHL,
		[SPECIAL_RIGHTSHIFT] = OP_LSR,
	};
	int op;

	src1 = linearize_expression(ep, expr->left);
	src2 = linearize_expression(ep, expr->right);
	op = map_opcode(opcode[expr->op], expr->ctype);
	dst = add_binary_op(ep, expr->ctype, op, src1, src2);
	taint_undefined_behaviour(dst->def);
	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x144d5
movq %rax, %r15
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x144d5
movq %rax, %r12
movslq 0x4(%rbx), %rax
leaq 0x2a7e3(%rip), %rcx     # 0x40c40
movl (%rcx,%rax,4), %edi
movq 0x10(%rbx), %rbx
movq %rbx, %rsi
callq 0x17479
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x16d1b
movq 0x18(%rax), %rcx
movl (%rcx), %edx
movl %edx, %esi
andl $0x7f, %esi
addl $-0xf, %esi
cmpl $0x2, %esi
ja 0x164af
movq 0x38(%rcx), %rsi
cmpl $0x6, 0x4(%rsi)
jne 0x164af
movl %edx, %edi
shrl $0x8, %edi
cmpq %rdi, 0x18(%rsi)
jb 0x164af
orl $0x80, %edx
movl %edx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_compare
static pseudo_t linearize_compare(struct entrypoint *ep, struct expression *expr)
{
	static const int cmpop[] = {
		['>'] = OP_SET_GT, ['<'] = OP_SET_LT,
		[SPECIAL_EQUAL] = OP_SET_EQ,
		[SPECIAL_NOTEQUAL] = OP_SET_NE,
		[SPECIAL_GTE] = OP_SET_GE,
		[SPECIAL_LTE] = OP_SET_LE,
		[SPECIAL_UNSIGNED_LT] = OP_SET_B,
		[SPECIAL_UNSIGNED_GT] = OP_SET_A,
		[SPECIAL_UNSIGNED_LTE] = OP_SET_BE,
		[SPECIAL_UNSIGNED_GTE] = OP_SET_AE,
	};
	struct symbol *itype = expr->right->ctype;
	int op = opcode_float(cmpop[expr->op], itype);
	pseudo_t src1 = linearize_expression(ep, expr->left);
	pseudo_t src2 = linearize_expression(ep, expr->right);
	pseudo_t dst = add_cmp_op(ep, expr->ctype, op, itype, src1, src2);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq 0x10(%rax), %r12
movslq 0x4(%rsi), %rax
leaq 0x2abb4(%rip), %rcx     # 0x41090
movl (%rcx,%rax,4), %ebp
testq %r12, %r12
je 0x1650f
cmpb $0x3, (%r12)
movq %r12, %rax
jne 0x164f3
movq 0x60(%r12), %rax
movq 0x60(%rax), %rax
cmpq 0x49a52(%rip), %rax     # 0x5ff50
jne 0x1650f
movslq %ebp, %rax
leaq 0x2b716(%rip), %rcx     # 0x41c20
movsbl 0x3(%rcx,%rax,8), %ebp
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x144d5
movq %rax, %r15
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x144d5
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x16d1b
movq 0x18(%rax), %rcx
movq %r12, 0x40(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_short_conditional
static pseudo_t linearize_short_conditional(struct entrypoint *ep, struct expression *expr,
					    struct expression *cond,
					    struct expression *expr_false)
{
	pseudo_t src1, src2;
	struct basic_block *bb_false;
	struct basic_block *merge;
	pseudo_t phi1, phi2;

	if (!expr_false || !ep->active)
		return VOID;

	bb_false = alloc_basic_block(ep, expr_false->pos);
	merge = alloc_basic_block(ep, expr->pos);

	src1 = linearize_expression(ep, cond);
	phi1 = alloc_phi(ep->active, src1, expr->ctype);
	add_branch(ep, src1, merge, bb_false);

	set_activeblock(ep, bb_false);
	src2 = linearize_expression(ep, expr_false);
	phi2 = alloc_phi(ep->active, src2, expr->ctype);
	set_activeblock(ep, merge);

	return add_join_conditional(ep, expr, phi1, phi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x16654
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x16654
movq %rcx, %r15
movq %rsi, %rbx
movq 0x8(%rcx), %r12
xorl %edi, %edi
movq %rdx, (%rsp)
callq 0x2fbe3
movq %rax, %r13
movq %r12, (%rax)
movq %r14, 0x10(%rax)
movl 0x507da(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x507d1(%rip)     # 0x66d70
movl %eax, 0x38(%r13)
movq 0x8(%rbx), %rbp
xorl %edi, %edi
callq 0x2fbe3
movq %rax, %r12
movq %rbp, (%rax)
movq %r14, 0x10(%rax)
movl 0x507b2(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x507a9(%rip)     # 0x66d70
movl %eax, 0x38(%r12)
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x144d5
movq %rax, %rbp
movq 0x20(%r14), %rdi
movq 0x10(%rbx), %rdx
movq %rax, %rsi
callq 0x1387f
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x17371
movq %r14, %rdi
movq %r13, %rsi
callq 0x14060
movq %r14, %rdi
movq %r15, %rsi
callq 0x144d5
movq 0x20(%r14), %rdi
movq 0x10(%rbx), %rdx
movq %rax, %rsi
callq 0x1387f
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x14060
movq %r14, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17983
leaq 0x4f375(%rip), %rax     # 0x659d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_conditional
static pseudo_t linearize_conditional(struct entrypoint *ep, struct expression *expr,
				      struct expression *cond,
				      struct expression *expr_true,
				      struct expression *expr_false)
{
	pseudo_t src1, src2;
	pseudo_t phi1, phi2;
	struct basic_block *bb_true, *bb_false, *merge;

	if (!cond || !expr_true || !expr_false || !ep->active)
		return VOID;
	bb_true = alloc_basic_block(ep, expr_true->pos);
	bb_false = alloc_basic_block(ep, expr_false->pos);
	merge = alloc_basic_block(ep, expr->pos);

	linearize_cond_branch(ep, cond, bb_true, bb_false);

	set_activeblock(ep, bb_true);
	src1 = linearize_expression(ep, expr_true);
	phi1 = alloc_phi(ep->active, src1, expr->ctype);
	add_goto(ep, merge); 

	set_activeblock(ep, bb_false);
	src2 = linearize_expression(ep, expr_false);
	phi2 = alloc_phi(ep->active, src2, expr->ctype);
	set_activeblock(ep, merge);

	return add_join_conditional(ep, expr, phi1, phi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
jne 0x167ce
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x167ce
movq %r8, %r15
movq 0x8(%rcx), %rbx
xorl %edi, %edi
movq %rsi, (%rsp)
movq %rcx, 0x10(%rsp)
callq 0x2fbe3
movq %rax, %r12
movq %rbx, (%rax)
movq %r14, 0x10(%rax)
movl 0x506ac(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x506a3(%rip)     # 0x66d70
movl %eax, 0x38(%r12)
movq 0x8(%r15), %r13
xorl %edi, %edi
callq 0x2fbe3
movq %rax, %rbx
movq %r13, (%rax)
movq %r14, 0x10(%rax)
movl 0x50683(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x5067a(%rip)     # 0x66d70
movl %eax, 0x38(%rbx)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x2fbe3
movq %rax, %r13
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movq %r14, 0x10(%r13)
movl 0x5064d(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x50644(%rip)     # 0x66d70
movl %eax, 0x38(%r13)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x17013
movq %r14, %rdi
movq %r12, %rsi
callq 0x14060
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x144d5
movq 0x20(%r14), %rdi
movq (%rsp), %rbp
movq 0x10(%rbp), %rdx
movq %rax, %rsi
callq 0x1387f
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x14453
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14060
movq %r14, %rdi
movq %r15, %rsi
callq 0x144d5
movq 0x20(%r14), %rdi
movq 0x10(%rbp), %rdx
movq %rax, %rsi
callq 0x1387f
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x14060
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17983
leaq 0x4f1fb(%rip), %rax     # 0x659d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq