LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/./symbol.h
// Function: is_integral_type
static inline bool is_integral_type(struct symbol *type)
{
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	switch (type->type) {
	case SYM_ENUM:
	case SYM_PTR:
	case SYM_RESTRICT:	// OK, always integer types
	case SYM_FOULED:	// idem
		return 1;
	default:
		break;
	}
	if (type->ctype.base_type == &int_type)
		return 1;
	return 0;
}

// Assembly:
movzbl (%rdi), %ecx
cmpl $0x3, %ecx
jne 0xffab
movq 0x60(%rdi), %rdi
movl (%rdi), %ecx
addb $-0x4, %cl
cmpb $0xb, %cl
jae 0xffc3
movb $0x1, %al
movzbl %cl, %ecx
movl $0x621, %edx            # imm = 0x621
btl %ecx, %edx
jae 0xffc3
retq
movq 0x60(%rdi), %rax
cmpq 0x49fb2(%rip), %rax     # 0x59f80
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/expand.c
// Function: bit_offset
static unsigned long bit_offset(const struct expression *expr)
{
	unsigned long offset = 0;
	while (expr->type == EXPR_POS) {
		offset += bytes_to_bits(expr->init_offset);
		expr = expr->init_expr;
	}
	if (expr && expr->ctype)
		offset += expr->ctype->bit_offset;
	return offset;
}

// Assembly:
leaq 0x4e6fa(%rip), %rax     # 0x5e700
movslq (%rax), %rcx
xorl %eax, %eax
cmpb $0x1b, (%rdi)
jne 0x10021
movslq 0x20(%rdi), %rdx
imulq %rcx, %rdx
addq %rdx, %rax
movq 0x28(%rdi), %rdi
jmp 0x1000b
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x10031
movzbl 0x54(%rcx), %ecx
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/expand.c
// Function: expand_const_expression
static void expand_const_expression(struct expression *expr, const char *where)
{
	if (expr) {
		expand_expression(expr);
		if (expr->type != EXPR_VALUE) {
			expression_error(expr, "Expected constant expression in %s", where);
			expr->ctype = &int_ctype;
			expr->type = EXPR_VALUE;
			expr->value = 0;
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x10071
pushq %rbx
movq %rdi, %rbx
callq 0xe7b6
cmpb $0x1, (%rbx)
je 0x10070
leaq 0x292db(%rip), %rsi     # 0x39327
leaq 0x30720(%rip), %rdx     # 0x40773
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11292
leaq 0x556d4(%rip), %rax     # 0x65738
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
andq $0x0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/inline.c
// Function: create_symbol_list
static struct symbol_list *create_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = create_copy_symbol(sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x1033b
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r13
xorl %ebp, %ebp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jge 0x1032c
movq 0x18(%r13,%rbp,8), %r15
cmpw $0x100, %ax             # imm = 0x100
jb 0x102dd
testq %r15, %r15
je 0x10327
testq %r15, %r15
je 0x10319
movzbl (%r15), %esi
movq 0x4(%r15), %rdi
callq 0x2671f
movq %rax, %r12
movl $0xd0, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xe1e0
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r12)
movq %r15, 0x28(%r12)
movq %r12, 0x28(%r15)
jmp 0x1031c
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x1fae9
incq %rbp
jmp 0x102c0
movq 0x10(%r13), %r13
cmpq %rbx, %r13
jne 0x102be
movq (%rsp), %rax
jmp 0x1033d
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_O2/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 0x103aa
leaq 0x10(%rbx), %r15
movq %r12, %r13
xorl %ebp, %ebp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jge 0x103a1
movq 0x18(%r13,%rbp,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x1038c
testq %rdi, %rdi
je 0x1039c
callq 0x104f9
movq %r15, %rdi
movq %rax, %rsi
callq 0x1fae9
incq %rbp
jmp 0x1036f
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x1036d
movq 0x28(%r14), %rdi
callq 0x104f9
movq %rax, 0x28(%rbx)
movq 0x4(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x1088a
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_O2/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 0x1045f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x290ef(%rip), %r14     # 0x394e6
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x1044d
movq 0x18(%r15,%r12,8), %r13
cmpw $0x100, %ax             # imm = 0x100
jb 0x10419
testq %r13, %r13
je 0x10448
movq 0x28(%r13), %rax
testq %rax, %rax
je 0x1042e
andq $0x0, 0x28(%rax)
andq $0x0, 0x28(%r13)
jmp 0x10448
movq 0x18(%r13), %rdi
callq 0x2936d
movq 0x4(%r13), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1108a
incq %r12
jmp 0x103fd
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x103fa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1029c
movq %rax, 0x98(%r14)
testq %rbx, %rbx
je 0x104be
movq %rbx, %rax
xorl %ecx, %ecx
movl (%rax), %edx
movsbq %dl, %rsi
cmpq %rsi, %rcx
jge 0x104b5
movq 0x18(%rax,%rcx,8), %rsi
cmpw $0x100, %dx             # imm = 0x100
jb 0x104ac
testq %rsi, %rsi
je 0x104b0
movq %rsi, 0x28(%rsi)
incq %rcx
jmp 0x10490
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x1048e
movq 0x4(%r15), %rdi
pushq $0x3
popq %rsi
callq 0x17530
movq %rax, 0x90(%r15)
movq 0xa0(%r15), %rdi
movq %rax, %rsi
callq 0x1034c
movq 0x98(%r14), %rdi
callq 0x103df
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x103df
// File: /workspace/github_c_makefile_star2_O2/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 0x108a1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x5c, 0x68(%rsi)
je 0x108a4
movq %rbx, %rax
jmp 0x108ad
xorl %eax, %eax
retq
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x108b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq 0x18(%rbx), %rdi
callq 0x2936d
leaq 0x28c07(%rip), %rsi     # 0x394cf
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1108a
jmp 0x1089c
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x10cf4
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x10ce5
movq 0x18(%r15,%r12,8), %rsi
cmpw $0x100, %ax             # imm = 0x100
jb 0x10ccc
testq %rsi, %rsi
je 0x10ce0
movq 0x4(%rsi), %rdi
callq 0x1088a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fae9
incq %r12
jmp 0x10cb0
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x10cad
movq (%rsp), %rax
jmp 0x10cf6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x10d8b
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x10d7b
movq 0x18(%r12,%r13,8), %rbp
cmpw $0x100, %ax             # imm = 0x100
jb 0x10d40
testq %rbp, %rbp
je 0x10d76
xorl %edi, %edi
callq 0x2aa8e
movq %rax, %r15
movq (%rbp), %rax
movq %rax, (%r15)
movq 0x8(%rbp), %rdi
callq 0x108f4
movq %rax, 0x8(%r15)
movq 0x10(%rbp), %rdi
callq 0x108f4
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fae9
incq %r13
jmp 0x10d23
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x10d20
movq (%rsp), %rax
jmp 0x10d8d
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_O2/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
subq $0x28, %rsp
movq %rsi, %r14
movl %r14d, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
jne 0x10ea8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r13
leaq 0x4e82e(%rip), %r15     # 0x5f6e0
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xe290
movq 0x49041(%rip), %rax     # 0x59f08
movq (%rax), %rdi
callq 0xe210
movq 0x4911a(%rip), %rbx     # 0x59ff0
movq (%rbx), %rax
movq %rax, 0x20(%rsp)
movl %r14d, %r12d
shrl $0x6, %r12d
andl $0x3fff, %r12d          # imm = 0x3FFF
movl %r12d, %edi
callq 0x292d8
movq %rax, %rdx
leaq 0x50012(%rip), %rax     # 0x60f10
movq (%rax), %rbp
cmpq %rbp, %rdx
je 0x1104c
cmpq 0x4e9cf(%rip), %rdx     # 0x5f8e0
je 0x1104c
movq %r14, 0x18(%rsp)
movq %r13, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdx, 0x4e9b3(%rip)     # 0x5f8e0
movq (%rbx), %rax
movq %rax, (%rsp)
xorl %r14d, %r14d
leaq 0x4e9b2(%rip), %r15     # 0x5f8f0
movl %r12d, %edi
callq 0x292fe
testl %eax, %eax
js 0x10fe3
movl %eax, %r12d
movl %eax, %edi
callq 0x292d8
cmpq %rbp, %rax
je 0x10fe3
movq %rax, %r13
movq %rax, %rdi
callq 0xe0d0
movq %rax, %rbx
cmpl $0x3, %ebx
jl 0x10f86
cmpw $0x2f2e, (%r13)         # imm = 0x2F2E
jne 0x10f8a
addq $0x2, %r13
addl $-0x2, %ebx
jmp 0x10f8a
testl %ebx, %ebx
jle 0x10fe3
leal (%rbx,%r14), %ecx
movl %r14d, %eax
cmpl $0xb5, %ecx
jae 0x10fef
testl %r14d, %r14d
je 0x10fab
movw $0x202c, (%rax,%r15)    # imm = 0x202C
addl $0x2, %r14d
jmp 0x10fcb
movabsq $0x67756f7268742820, %rax # imm = 0x67756F7268742820
movq %rax, 0x4e934(%rip)     # 0x5f8f0
movw $0x2068, 0x4e933(%rip)  # imm = 0x2068
pushq $0xa
popq %rax
movl %eax, %r14d
movl %r14d, %edi
addq %r15, %rdi
movl %ebx, %edx
movq %r13, %rsi
callq 0xe1e0
addl %ebx, %r14d
jmp 0x10f3e
testl %r14d, %r14d
movq 0x8(%rsp), %r13
je 0x10ff9
jmp 0x11019
testl %r14d, %r14d
movq 0x8(%rsp), %r13
jne 0x11002
leaq 0x288cd(%rip), %r15     # 0x398cd
jmp 0x11023
leaq 0x4e8e7(%rip), %rcx     # 0x5f8f0
movb $0x2e, 0x4(%rax,%rcx)
movl $0x2e2e202c, (%rax,%rcx) # imm = 0x2E2E202C
addl $0x5, %r14d
movl %r14d, %eax
movw $0x29, (%rax,%r15)
movq (%rsp), %rdi
leaq 0x2852f(%rip), %rsi     # 0x3955d
movq %rbp, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xe1d0
movq 0x18(%rsp), %r14
leaq 0x4e699(%rip), %r15     # 0x5f6e0
movq 0x10(%rsp), %rdx
movq %r14, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x16, %r14d
leaq 0x494dc(%rip), %rax     # 0x5a540
movq (%rax), %r9
leaq 0x284dd(%rip), %rsi     # 0x3954b
movq 0x20(%rsp), %rdi
movl %r14d, %r8d
xorl %eax, %eax
pushq %r15
pushq %r13
callq 0xe1d0
addq $0x38, %rsp
jmp 0x10e9d
// File: /workspace/github_c_makefile_star2_O2/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 0x110e6
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 0x494f3(%rip), %rax     # 0x5a5e0
cmpl $0x0, (%rax)
je 0x11124
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 0x11196
jmp 0x1118e
leaq 0x49445(%rip), %rax     # 0x5a570
movl (%rax), %ecx
testl %ecx, %ecx
je 0x11187
leaq 0x4fc4c(%rip), %rdx     # 0x60d84
cmpl $0x0, (%rdx)
jne 0x11187
decl %ecx
movl %ecx, (%rax)
jne 0x11151
movb $0x1, 0x4e386(%rip)     # 0x5f4d0
leaq 0x283af(%rip), %r10     # 0x39500
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 0x28395(%rip), %rdi     # 0x39512
movq %r10, %rdx
callq 0x10e7d
jmp 0x1118e
movb $0x1, 0x4e342(%rip)     # 0x5f4d0
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4fbda(%rip), %rax     # 0x60d80
movl $0x1, (%rax)
movb $0x0, 0x4e31d(%rip)     # 0x5f4d0
movl %esi, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
je 0x1120d
leaq 0x4fbc0(%rip), %rax     # 0x60d84
orb $0x1, (%rax)
movl 0x4e7eb(%rip), %eax     # 0x5f9b8
leaq 0x49398(%rip), %rdi     # 0x5a56c
cmpl (%rdi), %eax
jbe 0x111f6
movb $0x1, 0x4e2f1(%rip)     # 0x5f4d0
cmpb $0x0, 0x4e7d6(%rip)     # 0x5f9bc
jne 0x1120d
movb $0x1, 0x4e7cd(%rip)     # 0x5f9bc
leaq 0x2839a(%rip), %rdx     # 0x39590
pushq %rax
leaq 0x2831e(%rip), %rdi     # 0x3951c
callq 0x10e7d
incl 0x4e7af(%rip)           # 0x5f9b8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1141d
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 0x4e09c(%rip), %rbx     # 0x5f4e0
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
movq %r10, %rdx
callq 0xe0b0
movq 0x48b95(%rip), %rax     # 0x59ff0
movq (%rax), %rdi
leaq 0x490db(%rip), %rax     # 0x5a540
movq (%rax), %rdx
leaq 0x280e8(%rip), %rsi     # 0x39557
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe1d0
pushq $0x1
popq %rdi
callq 0xe2e0
// File: /workspace/github_c_makefile_star2_O2/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 0x114e5
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 0x29be2
movq 0x48c68(%rip), %rcx     # 0x5a1a0
movq %rax, (%rcx)
movq (%r14), %rax
addq $0x8, %rax
movq %rax, 0x48c57(%rip)     # 0x5a1a0
addq $0x10e8, %rsp           # imm = 0x10E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5320a(%rip), %rax     # 0x64a00
andq $0x0, (%rax)
callq 0x200a3
cmpb $0x2d, (%rbx)
jne 0x1180a
cmpb $0x0, 0x1(%rbx)
je 0x11850
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xe2a0
movl %eax, %ebp
testl %eax, %eax
js 0x11854
leaq 0x4f6ed(%rip), %rax     # 0x60f10
movq %rbx, (%rax)
leaq 0x4bb83(%rip), %r8      # 0x5d3b0
xorl %edi, %edi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x29fca
movq %rax, %rbx
movl %ebp, %edi
callq 0xe150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x118a0
xorl %ebp, %ebp
jmp 0x1181c
leaq 0x2807a(%rip), %rdi     # 0x398d5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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 0x11865
movq %rax, %rbx
leaq 0x4f4fc(%rip), %rax     # 0x60d84
testb $0x1, (%rax)
je 0x11893
movl $0x2, (%rax)
movq %rbx, %rdi
callq 0x305cd
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x118bc
testl $0xfffc0, (%rdi)        # imm = 0xFFFC0
sete %bpl
jmp 0x118be
xorl %ebp, %ebp
callq 0x1cc0b
movq %rax, %rbx
leaq 0x4f4ef(%rip), %rcx     # 0x60dbc
leaq 0x4f4ec(%rip), %r14     # 0x60dc0
movl (%r14), %eax
movl (%rcx), %ecx
orl %eax, %ecx
je 0x118f2
testb %bpl, %bpl
jne 0x118ea
callq 0x1cf1a
movl (%r14), %eax
testl %eax, %eax
jne 0x11976
leaq 0x4f563(%rip), %rax     # 0x60e5c
cmpl $0x0, (%rax)
je 0x1197a
leaq 0x27fc2(%rip), %r12     # 0x398c7
leaq 0x27fc2(%rip), %r14     # 0x398ce
cmpq 0x485d5(%rip), %rbx     # 0x59ee8
je 0x1196e
movq 0x8(%rbx), %r13
movl (%r13), %eax
btl $0x15, %eax
leaq 0x28dc8(%rip), %r15     # 0x3a6f0
leaq 0x27f9e(%rip), %rcx     # 0x398cd
cmovaeq %rcx, %r15
movl %eax, %ebp
shrl $0x16, %ebp
cmpl $0x4, %ebp
pushq $0x4
popq %rcx
cmovael %ecx, %ebp
btl $0x14, %eax
pushq $0x1
popq %rax
cmovael %eax, %ebp
cmovbq %r12, %r15
movq %rbx, %rdi
callq 0x294bb
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xe0f0
movq %r13, %rbx
jmp 0x1190c
pushq $0xa
popq %rdi
callq 0xe040
xorl %eax, %eax
jmp 0x119a2
leaq 0x6ec5f(%rip), %r15     # 0x805e0
leaq 0x53078(%rip), %r14     # 0x64a00
cmpq %r15, %rbx
je 0x1199f
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x185c9
movq %rax, %rbx
jmp 0x11988
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x4dfec(%rip), %eax     # 0x5f9f8
incl %eax
movl %eax, 0x4dfe4(%rip)     # 0x5f9f8
testq %rdi, %rdi
je 0x11a42
andl $0x3, %eax
shll $0x4, %eax
leaq 0x4dfda(%rip), %rbx     # 0x5fa00
addq %rax, %rbx
movl 0x38(%rdi), %ecx
leaq 0x28bcb(%rip), %rdx     # 0x3a5fe
pushq $0x10
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe100
jmp 0x11a49
leaq 0x28baf(%rip), %rbx     # 0x3a5f8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x128c6
movq 0x28(%rdi), %rdi
callq 0x1f937
testq %rax, %rax
je 0x128c6
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x2, %eax
jb 0x128c6
xorl %ebx, %ebx
cmpl $0x8, %eax
setb %bl
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x18(%rdx), %rsi
pushq $0x41
popq %rdi
callq 0x12bbd
movq 0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x12b7f
movq %rax, %r15
leaq 0x30(%rax), %rdx
movq %rax, %rdi
callq 0x12bdf
movq 0x20(%r13), %rax
cmpq %r13, 0x18(%rax)
jne 0x12b9e
movq %rax, 0x20(%r15)
movq %r15, 0x18(%rax)
leaq 0x38(%r15), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12bdf
movq %r15, %rdx
addq $0x40, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12bdf
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12c2d
leaq 0x27cb7(%rip), %rdi     # 0x3a83d
leaq 0x27cb9(%rip), %rsi     # 0x3a846
leaq 0x27cbe(%rip), %rcx     # 0x3a852
movl $0x2be, %edx            # imm = 0x2BE
callq 0xe120
leaq 0x27d16(%rip), %rdi     # 0x3a8bb
leaq 0x27c9a(%rip), %rsi     # 0x3a846
leaq 0x27c9f(%rip), %rcx     # 0x3a852
movl $0x2c2, %edx            # imm = 0x2C2
callq 0xe120
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq %r15, %rdi
callq 0x1fd69
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1fae9
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fae9
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2aec5
movl $0x3, 0x4(%rax)
movl 0x4dec8(%rip), %ecx     # 0x60b50
incl %ecx
movl %ecx, 0x4dec0(%rip)     # 0x60b50
movl %ecx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4deb4(%rip), %rcx     # 0x60b60
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x12cfe
movq %rdx, %rsi
movzwl (%rsi), %edi
movsbl %dil, %r8d
testw %r8w, %r8w
movl $0x0, %r9d
cmovgl %r8d, %r9d
movzwl %r9w, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x12cf5
movq 0x18(%rsi,%r9,8), %r14
cmpw $0x100, %di             # imm = 0x100
jb 0x12cea
testq %r14, %r14
je 0x12cf0
cmpq %rbx, 0x18(%r14)
je 0x12d22
incq %r9
jmp 0x12cd4
movq 0x10(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x12cb8
leaq (%rcx,%rax,8), %r15
xorl %edi, %edi
callq 0x2aec5
movq %rax, %r14
movl $0x6, 0x4(%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1fae9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x45
popq %rdi
callq 0x12bbd
movq %rax, %r14
xorl %edi, %edi
callq 0x2aec5
movq %rax, %r15
movl $0x2, 0x4(%rax)
movl 0x4dffa(%rip), %eax     # 0x60d60
incl %eax
movl %eax, 0x4dff2(%rip)     # 0x60d60
movl %eax, (%r15)
movq %r14, 0x18(%r15)
leaq 0x30(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12bdf
movq %r15, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12dca
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x12d3c
movq %rax, %r14
movq %rbx, 0x8(%rax)
addq $0x28, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1fae9
movq 0x20(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4cbff(%rip), %rax     # 0x5f9d0
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x46
popq %rdi
callq 0x12bbd
movq %rax, %r15
movq %rax, %rdi
callq 0x12c70
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_O2/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 0x12e60
movq %rcx, %r14
movl (%r14), %edx
movl %edx, %esi
shll $0x8, %esi
movsbl %dl, %eax
movsbl %dl, %r8d
xorl %r15d, %r15d
cmpl %r8d, %r15d
jge 0x12e57
movq 0x18(%r14,%r15,8), %r9
cmpw $0x100, %dx             # imm = 0x100
jb 0x12e45
testq %r9, %r9
je 0x12e52
movl (%r9), %r9d
andl $0x7f, %r9d
cmpl $0x46, %r9d
jne 0x12e71
incq %r15
jmp 0x12e2f
movq 0x10(%r14), %r14
cmpq %rcx, %r14
jne 0x12e1d
addq $0x28, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1fae9
cmpw $0xd00, %si             # imm = 0xD00
jne 0x12ea2
movq %r14, %rdi
callq 0x1fa79
movl (%r14), %ecx
movsbl %cl, %eax
cmpl %eax, %r15d
jge 0x12e90
movsbl %cl, %eax
jmp 0x12ea2
movq 0x10(%r14), %r14
movsbl (%r14), %eax
movzwl %cx, %ecx
movsbq %cl, %rcx
subq %rcx, %r15
leaq (%r14,%r15,8), %rcx
addq $0x18, %rcx
movswq %ax, %rax
leaq (%r14,%rax,8), %rax
addq $0x10, %rax
cmpq %rcx, %rax
jb 0x12ec8
movq (%rax), %rdx
movq %rdx, 0x8(%rax)
addq $-0x8, %rax
jmp 0x12eb6
movq %rbx, (%rcx)
incb (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x46f2a(%rip), %r15     # 0x5a270
pushq $0x3
popq %rbp
pushq $0x10
popq %r14
movq -0x10(%r15), %rsi
testq %rsi, %rsi
je 0x13387
movl %ebx, %edi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x274d6
movq 0x40(%rax), %rcx
testq %rcx, %rcx
jne 0x13372
movq %r15, 0x40(%rax)
movq %r15, %rcx
orb $0x10, (%rcx)
movq -0x8(%r15), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x20(%rax)
addq $0x78, %r15
jmp 0x1334d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1346d
movq %rsi, %rdx
leaq 0x27425(%rip), %rbx     # 0x3a7db
movq %rax, %r15
movq %rax, (%rsp)
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x1345c
movq 0x18(%r15,%r12,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0x133e0
testq %r14, %r14
je 0x13454
movq 0x8(%r14), %rcx
movq %r13, %rdi
leaq 0x276a4(%rip), %rsi     # 0x3aa92
xorl %eax, %eax
callq 0xe2d0
movslq %eax, %rbp
addq %r13, %rbp
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13421
callq 0x11a4e
movq %rbp, %rdi
leaq 0x2d438(%rip), %rsi     # 0x4084a
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2d0
cltq
addq %rax, %rbp
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1344e
callq 0x2936d
movq %rbp, %rdi
leaq 0x27660(%rip), %rsi     # 0x3aa99
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2d0
movslq %eax, %r13
addq %rbp, %r13
movq %rbx, %rdx
jmp 0x13454
movq %rbx, %rdx
movq %rbp, %r13
incq %r12
jmp 0x133c0
movq 0x10(%r15), %r15
movq (%rsp), %rax
cmpq %rax, %r15
jne 0x133bd
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_O2/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_instruction
static struct instruction *alloc_instruction(int opcode, int size)
{
	struct instruction * insn = __alloc_instruction(0);
	insn->opcode = opcode;
	insn->size = size;
	insn->pos = current_pos;
	return insn;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
xorl %edi, %edi
callq 0x2aded
movl $0x80, %ecx
andl (%rax), %ecx
andl $0x7f, %ebp
orl %ebp, %ecx
shll $0x8, %ebx
orl %ecx, %ebx
movl %ebx, (%rax)
movq 0x4d8c1(%rip), %rcx     # 0x60d68
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_basic_block
static struct basic_block *alloc_basic_block(struct entrypoint *ep, struct position pos)
{
	static int nr;
	struct basic_block *bb = __alloc_basic_block(0);
	bb->pos = pos;
	bb->ep = ep;
	bb->nr = nr++;
	return bb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x2ad15
movq %rbx, (%rax)
movq %r14, 0x10(%rax)
movl 0x4d8a0(%rip), %ecx     # 0x60d70
leal 0x1(%rcx), %edx
movl %edx, 0x4d897(%rip)     # 0x60d70
movl %ecx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
callq 0x1289e
testl %eax, %eax
jne 0x13506
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13830
movq %rbx, 0x20(%r14)
testq %rbx, %rbx
je 0x13525
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fae9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15493
movq %rax, %rbx
movq 0x18(%r15), %rsi
cmpb $0x3, (%rsi)
movq %rsi, %rax
jne 0x137c1
movq 0x60(%rsi), %rax
cmpq 0x46780(%rip), %rax     # 0x59f48
je 0x13809
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x13809
callq 0x1289e
movq 0x18(%r15), %rsi
testl %eax, %eax
jne 0x13809
movq %r14, %rdi
callq 0x1544a
movq %rax, %r12
movq 0x18(%r15), %r13
callq 0x12d2b
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x15642
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x153ec
movq 0x28(%rax), %rdi
callq 0x1f919
testq %rax, %rax
je 0x13823
movq 0x20(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13889
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x3
popq %rdi
xorl %esi, %esi
callq 0x1347f
movq %rax, %r12
movq %r15, 0x38(%rax)
leaq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x1fae9
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x1fae9
movq %r14, 0x8(%r12)
addq $0x28, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x1fae9
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %edi, %edi
callq 0x12f4e
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 0x14486
movq 0x28(%rax), %rax
addq $0x4, %rax
jmp 0x1448d
leaq 0x25440(%rip), %rax     # 0x398cd
movq %rax, 0x8(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12bdf
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fae9
// File: /workspace/github_c_makefile_star2_O2/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 0x4b501(%rip), %rax     # 0x5f9d0
testq %rsi, %rsi
je 0x145a8
movq %rsi, %r14
cmpq $0x0, 0xb0(%rsi)
je 0x145a8
movl 0x54(%r14), %ecx
btl $0xa, %ecx
jb 0x145a8
testb $0x14, 0x68(%r14)
jne 0x145a8
movq %rdi, %rbx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x54(%r14)
movq %r14, %rsi
callq 0x14f2d
movq %rax, 0x10(%rsp)
movq 0xb0(%r14), %rsi
testq %rsi, %rsi
je 0x1459b
movzbl (%r14), %ecx
movq %r14, %rax
cmpl $0x3, %ecx
jne 0x1453a
movq 0x60(%r14), %rax
movl (%rax), %ecx
cmpb $0xe, %cl
ja 0x1454c
movzbl %cl, %ecx
movl $0x6a10, %edx           # imm = 0x6A10
btl %ecx, %edx
jb 0x1459d
movq 0x60(%rax), %rax
cmpq 0x45a29(%rip), %rax     # 0x59f80
sete %cl
cmpq 0x459ef(%rip), %rax     # 0x59f50
sete %al
orb %cl, %al
jne 0x1459d
movq %rsp, %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14f2d
movq %rax, 0x10(%r15)
xorl %edi, %edi
callq 0x12c98
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x14f94
movq 0xb0(%r14), %rsi
jmp 0x1459d
xorl %esi, %esi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1514d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
fldt 0x30(%rsp)
fstpt 0x4(%rsp)
pushq $0x49
popq %rdi
callq 0x12bbd
movq %rax, %r14
movq %rax, %rdi
callq 0x12c70
movq %rax, %r15
movq %rax, 0x20(%r14)
fldt 0x4(%rsp)
fstpt 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13783
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq 0x10(%rax), %r15
movslq 0x4(%rsi), %rax
leaq 0x2520a(%rip), %rcx     # 0x3a0f0
movl (%rcx,%rax,4), %edi
movq %r15, %rsi
callq 0x15cb1
movl %eax, %ebp
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x13895
movq %rax, %r12
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x13895
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x158c1
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/linearize.c
// Function: symbol_pseudo
static pseudo_t symbol_pseudo(struct entrypoint *ep, struct symbol *sym)
{
	pseudo_t pseudo;

	if (!sym)
		return VOID;

	pseudo = sym->pseudo;
	if (!pseudo) {
		pseudo = __alloc_pseudo(0);
		pseudo->nr = -1;
		pseudo->type = PSEUDO_SYM;
		pseudo->sym = sym;
		pseudo->ident = sym->ident;
		sym->pseudo = pseudo;
		add_pseudo(&ep->accesses, pseudo);
	}
	/* Symbol pseudos have neither nr nor def */
	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x14f84
movq %rsi, %r15
movq 0xd8(%rsi), %rbx
testq %rbx, %rbx
jne 0x14f8b
movq %rdi, %r14
xorl %edi, %edi
callq 0x2aec5
movq %rax, %rbx
movabsq $0x5ffffffff, %rax      # imm = 0x5FFFFFFFF
movq %rax, (%rbx)
movq %r15, 0x18(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0xd8(%r15)
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fae9
jmp 0x14f8b
leaq 0x4aa45(%rip), %rbx     # 0x5f9d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq