LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1683b
movq %rsi, %r15
movq 0xd8(%rsi), %rbx
testq %rbx, %rbx
jne 0x16842
movq %rdi, %r14
xorl %edi, %edi
callq 0x2fd6f
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 0x227b4
jmp 0x16842
leaq 0x4f18e(%rip), %rbx     # 0x659d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_initializer
static pseudo_t linearize_initializer(struct entrypoint *ep, struct expression *initializer, struct access_data *ad)
{
	switch (initializer->type) {
	case EXPR_INITIALIZER: {
		struct expression *expr;
		FOR_EACH_PTR(initializer->expr_list, expr) {
			linearize_initializer(ep, expr, ad);
		} END_FOR_EACH_PTR(expr);
		break;
	}
	case EXPR_POS:
		ad->offset = initializer->init_offset;
		linearize_initializer(ep, initializer->init_expr, ad);
		break;
	default: {
		pseudo_t value = linearize_expression(ep, initializer);
		ad->type = initializer->ctype;
		linearize_store_gen(ep, value, ad);
		return value;
	}
	}

	return VOID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebp, %ebp
movzbl (%r15), %eax
cmpl $0x1b, %eax
jne 0x16adf
movl 0x20(%r15), %eax
movq %rax, 0x18(%rbx)
movq 0x28(%r15), %r15
movb $0x1, %bpl
jmp 0x16ac5
leaq 0x4eeea(%rip), %r13     # 0x659d0
cmpl $0x18, %eax
jne 0x16b50
movq 0x20(%r15), %r15
movq %r13, %r12
testq %r15, %r15
je 0x16b73
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x16b3a
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rsi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x16b1b
testq %rsi, %rsi
je 0x16b2b
movq %r14, %rdi
movq %rbx, %rdx
callq 0x16aaf
movzwl (%r12), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x16b06
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x16afa
leaq 0x4ee85(%rip), %r13     # 0x659d0
movq %r13, %r12
jmp 0x16b73
movq %r14, %rdi
movq %r15, %rsi
callq 0x144d5
movq %rax, %r12
movq 0x10(%r15), %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1684b
testb $0x1, %bpl
cmovneq %r13, %r12
movq %r12, %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: bitfield_base_type
static struct symbol *bitfield_base_type(struct symbol *sym)
{
	struct symbol *base = sym;

	if (sym) {
		if (sym->type == SYM_NODE)
			base = base->ctype.base_type;
		if (base->type == SYM_BITFIELD) {
			base = base->ctype.base_type;
			if (sym->packed) {
				int size = bits_to_bytes(sym->bit_offset + sym->bit_size);
				sym = __alloc_symbol(0);
				*sym = *base;
				sym->bit_size = bytes_to_bits(size);
				return sym;
			}
			return base;
		}
	}
	return sym;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x16bc2
movq %rdi, %rbx
movzbl (%rdi), %ecx
movq %rdi, %rax
cmpl $0x3, %ecx
jne 0x16bab
movq 0x60(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0xb, %ecx
jne 0x16c0e
movq 0x60(%rax), %r14
movl 0x54(%rbx), %eax
btl $0x15, %eax
jb 0x16bc6
movq %r14, %rbx
jmp 0x16c0e
xorl %ebx, %ebx
jmp 0x16c0e
movzbl %al, %eax
addl 0x50(%rbx), %eax
js 0x16be2
leaq 0x4db2b(%rip), %rcx     # 0x64700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
jmp 0x16be7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %edi, %edi
callq 0x2f92c
movq %rax, %rbx
movl $0xe0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe1e0
leaq 0x4daf8(%rip), %rax     # 0x64700
imull (%rax), %ebp
movl %ebp, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_load
static pseudo_t add_load(struct entrypoint *ep, struct access_data *ad)
{
	struct instruction *insn;
	pseudo_t new;

	if (!ep->active)
		return VOID;

	insn = alloc_typed_instruction(OP_LOAD, ad->btype);
	new = alloc_pseudo(insn);

	insn->target = new;
	insn->offset = ad->offset;
	insn->is_volatile = ad->type && (ad->type->ctype.modifiers & MOD_VOLATILE);
	use_pseudo(insn, ad->address, &insn->src);
	add_one_insn(ep, insn);
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x16d02
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rsi
movl $0x43, %edi
callq 0x13674
movq %rax, %r15
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %rbx
movl $0x3, 0x4(%rax)
movl 0x4fef4(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x4feec(%rip)     # 0x66b50
movl %eax, (%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, 0x20(%r15)
movq 0x18(%r12), %rax
movq %rax, 0x38(%r15)
movq (%r12), %rax
testq %rax, %rax
je 0x16c8a
movl 0x68(%rax), %ebp
shrl $0xa, %ebp
andb $0x1, %bpl
movb 0x40(%r15), %al
andb $-0x2, %al
orb %bpl, %al
movb %al, 0x40(%r15)
movq 0x10(%r12), %r12
movq %r12, 0x30(%r15)
testq %r12, %r12
je 0x16ce7
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16cb9
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16ce7
movq %r15, %r13
addq $0x30, %r13
leaq 0x494e9(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %r15, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x16d09
movq %rdi, 0x8(%r15)
addq $0x28, %rdi
movq %r15, %rsi
callq 0x227b4
jmp 0x16d09
leaq 0x4ecc7(%rip), %rbx     # 0x659d0
movq %rbx, %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: add_binary_op
static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right)
{
	struct instruction *insn = alloc_typed_instruction(op, ctype);
	pseudo_t target = alloc_pseudo(insn);
	insn->target = target;
	use_pseudo(insn, left, &insn->src1);
	use_pseudo(insn, right, &insn->src2);
	add_one_insn(ep, insn);
	return target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %r15
movl %edx, %edi
callq 0x13674
movq %rax, %rbx
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x4fe00(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x4fdf8(%rip)     # 0x66b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
movq %r13, 0x30(%rbx)
testq %r13, %r13
je 0x16daa
movl 0x4(%r13), %eax
cmpl $0x6, %eax
ja 0x16d7f
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16daa
leaq 0x30(%rbx), %rbp
leaq 0x49426(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %rbp, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x227b4
movq %r12, 0x38(%rbx)
testq %r12, %r12
je 0x16df5
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16dc7
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16df5
movq %rbx, %r13
addq $0x38, %r13
leaq 0x493db(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x16e0e
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x227b4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_unop
static pseudo_t add_unop(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t src)
{
	struct instruction *insn = alloc_typed_instruction(op, ctype);
	pseudo_t new = alloc_pseudo(insn);

	insn->target = new;
	use_pseudo(insn, src, &insn->src1);
	add_one_insn(ep, insn);
	return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdi, %r15
movl %edx, %edi
callq 0x13674
movq %rax, %rbx
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x4fd00(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x4fcf8(%rip)     # 0x66b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
movq %r12, 0x30(%rbx)
testq %r12, %r12
je 0x16eae
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16e80
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16eae
movq %rbx, %r13
addq $0x30, %r13
leaq 0x49322(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x16ec7
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x227b4
movq %r14, %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_label
static struct basic_block * add_label(struct entrypoint *ep, struct symbol *label)
{
	struct basic_block *bb = label->bb_target;

	if (bb) {
		set_activeblock(ep, bb);
		return bb;
	}
	bb = ep->active;
	if (!bb_reachable(bb) || !bb_empty(bb)) {
		bb = alloc_basic_block(ep, label->pos);
		set_activeblock(ep, bb);
	}
	label->bb_target = bb;
	return bb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0xd0(%rsi), %rbx
testq %rbx, %rbx
je 0x16ef8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14060
jmp 0x16f44
movq %rsi, %r14
movq 0x20(%r15), %rbx
testq %rbx, %rbx
je 0x16f0b
cmpq $0x0, 0x28(%rbx)
je 0x16f3d
movq 0x4(%r14), %r12
xorl %edi, %edi
callq 0x2fbe3
movq %rax, %rbx
movq %r12, (%rax)
movq %r15, 0x10(%rax)
movl 0x4fe4a(%rip), %eax     # 0x66d70
leal 0x1(%rax), %ecx
movl %ecx, 0x4fe41(%rip)     # 0x66d70
movl %eax, 0x38(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14060
movq %rbx, 0xd0(%r14)
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: get_bound_block
static struct basic_block * get_bound_block(struct entrypoint *ep, struct symbol *label)
{
	struct basic_block *bb = label->bb_target;

	if (!bb) {
		bb = alloc_basic_block(ep, label->pos);
		label->bb_target = bb;
	}
	return bb;
}

// Assembly:
movq 0xd0(%rsi), %rax
testq %rax, %rax
je 0x16f60
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4(%rsi), %r15
xorl %edi, %edi
callq 0x2fbe3
movq %r15, (%rax)
movq %r14, 0x10(%rax)
movl 0x4fded(%rip), %ecx     # 0x66d70
leal 0x1(%rcx), %edx
movl %edx, 0x4fde4(%rip)     # 0x66d70
movl %ecx, 0x38(%rax)
movq %rax, 0xd0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_compound_statement
static pseudo_t linearize_compound_statement(struct entrypoint *ep, struct statement *stmt)
{
	pseudo_t pseudo;
	struct statement *s;

	pseudo = VOID;
	FOR_EACH_PTR(stmt->stmts, s) {
		pseudo = linearize_statement(ep, s);
	} END_FOR_EACH_PTR(s);

	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rsi), %r14
testq %r14, %r14
je 0x17000
movq %rdi, %rbx
leaq 0x4ea19(%rip), %rax     # 0x659d0
movq %r14, %r15
movzwl (%r15), %ecx
testb %cl, %cl
jle 0x16ff5
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %cx, %edx
cmpl $0x100, %edx            # imm = 0x100
jb 0x16fda
testq %rsi, %rsi
je 0x16fe6
movq %rbx, %rdi
callq 0x15607
movzwl (%r15), %ecx
incq %r12
movzwl %cx, %edx
movsbq %dl, %rdx
cmpq %rdx, %r12
jl 0x16fc5
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x16fba
jmp 0x17007
leaq 0x4e9c9(%rip), %rax     # 0x659d0
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_return
static void add_return(struct entrypoint *ep, struct basic_block *bb, struct symbol *ctype, pseudo_t src)
{
	struct instruction *phi_node = first_instruction(bb->insns);
	pseudo_t phi;
	if (!phi_node) {
		phi_node = alloc_typed_instruction(OP_PHI, ctype);
		phi_node->target = alloc_pseudo(phi_node);
		phi_node->bb = bb;
		add_instruction(&bb->insns, phi_node);
	}
	phi = alloc_phi(ep->active, src, ctype);
	phi->ident = &return_ident;
	link_phi(phi_node, phi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x28(%rsi), %rdi
callq 0x225b0
movq %rax, %rbx
testq %rax, %rax
jne 0x172f0
leaq 0x28(%r13), %rbp
movl $0x46, %edi
movq %r14, %rsi
callq 0x13674
movq %rax, %rbx
xorl %edi, %edi
callq 0x2fd6f
movl $0x3, 0x4(%rax)
movl 0x4f881(%rip), %ecx     # 0x66b50
incl %ecx
movl %ecx, 0x4f879(%rip)     # 0x66b50
movl %ecx, (%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0x20(%rbx)
movq %r13, 0x8(%rbx)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x227b4
movq 0x20(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1387f
movq %rax, %r14
leaq 0x4caee(%rip), %rax     # 0x63df8
movq %rax, 0x10(%r14)
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x227b4
movq %rax, %r15
movq %r14, (%rax)
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x17333
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1735a
leaq 0x48e76(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r15, 0x8(%rax)
movq %rbx, (%rax)
movq %r14, %rdi
addq $0x8, %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x18(%r14), %rax
movq %rbx, 0x38(%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: add_branch
static void add_branch(struct entrypoint *ep, pseudo_t cond, struct basic_block *bb_true, struct basic_block *bb_false)
{
	struct basic_block *bb = ep->active;
	struct instruction *br;

	if (bb_reachable(bb)) {
		br = alloc_instruction(OP_CBR, 0);
		use_pseudo(br, cond, &br->cond);
		br->bb_true = bb_true;
		br->bb_false = bb_false;
		add_bb(&bb_true->parents, bb);
		add_bb(&bb_false->parents, bb);
		add_bb(&bb->children, bb_true);
		add_bb(&bb->children, bb_false);
		add_one_insn(ep, br);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r12
testq %r12, %r12
je 0x1746a
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2fca9
movq %rax, %r15
movl $0x80, %eax
andl (%r15), %eax
orl $0x4, %eax
movl %eax, (%r15)
movq 0x4f9b4(%rip), %rax     # 0x66d68
movq %rax, 0x10(%r15)
movq %rbp, 0x30(%r15)
testq %rbp, %rbp
je 0x17409
movl 0x4(%rbp), %eax
cmpl $0x6, %eax
ja 0x173d3
movl $0x43, %ecx
btl %eax, %ecx
jb 0x17409
movq %r15, %rax
addq $0x30, %rax
movq %rax, (%rsp)
leaq 0x48dcb(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rax)
addq $0x8, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x227b4
movq %r13, 0x38(%r15)
movq %r14, 0x40(%r15)
leaq 0x18(%r13), %rdi
movq %r12, %rsi
callq 0x227b4
leaq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x227b4
addq $0x20, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x227b4
movq %r12, %rdi
movq %r14, %rsi
callq 0x227b4
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1746a
movq %rdi, 0x8(%r15)
addq $0x28, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x227b4
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: map_opcode
static int map_opcode(int opcode, struct symbol *ctype)
{
	if (ctype && is_float_type(ctype))
		return opcode_table[opcode].to_float;
	if (ctype && (ctype->ctype.modifiers & MOD_SIGNED)) {
		switch(opcode) {
		case OP_DIVU: case OP_MODU: case OP_LSR:
			opcode++;
		}
	}
	return opcode;
}

// Assembly:
movl %edi, %eax
testq %rsi, %rsi
je 0x174b0
cmpb $0x3, (%rsi)
movq %rsi, %rcx
jne 0x1748c
movq 0x60(%rsi), %rcx
movq 0x60(%rcx), %rcx
cmpq 0x48ab9(%rip), %rcx     # 0x5ff50
je 0x174b1
testb $0x20, 0x69(%rsi)
je 0x174b0
cmpl $0xf, %eax
ja 0x174b0
movl $0xa800, %ecx           # imm = 0xA800
btl %eax, %ecx
jae 0x174b0
incl %eax
retq
cltq
leaq 0x2a766(%rip), %rcx     # 0x41c20
movsbl 0x3(%rcx,%rax,8), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: multijmp_cmp
static int multijmp_cmp(const void *_a, const void *_b)
{
	const struct multijmp *a = _a;
	const struct multijmp *b = _b;

	// "default" case?
	if (a->begin > a->end) {
		if (b->begin > b->end)
			return 0;
		return 1;
	}
	if (b->begin > b->end)
		return -1;
	if (a->begin == b->begin) {
		if (a->end == b->end)
			return 0;
		return (a->end < b->end) ? -1 : 1;
	}
	return a->begin < b->begin ? -1 : 1;
}

// Assembly:
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rdx
cmpq %rcx, %r8
jle 0x17520
xorl %eax, %eax
cmpq %rdx, %rdi
setle %al
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rdi
jg 0x17543
cmpq %rdi, %r8
jne 0x17536
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x17543
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: get_mtype
static enum mtype get_mtype(struct symbol *s)
{
	int sign = (s->ctype.modifiers & MOD_SIGNED) ? 1 : 0;

retry:	switch (s->type) {
	case SYM_NODE:
		s = s->ctype.base_type;
		goto retry;
	case SYM_PTR:
		if (s->ctype.base_type == &void_ctype)
			return MTYPE_VPTR;
		return MTYPE_PTR;
	case SYM_BITFIELD:
	case SYM_RESTRICT:
	case SYM_FOULED:
	case SYM_ENUM:
		s = s->ctype.base_type;
		/* fall-through */
	case_int:
		return sign ? MTYPE_SINT : MTYPE_UINT;
	case SYM_BASETYPE:
		if (s->ctype.base_type == &fp_type)
			return MTYPE_FLOAT;
		if (s->ctype.base_type == &int_type)
			goto case_int;
		/* fall-through */
	default:
		return MTYPE_BAD;
	}
}

// Assembly:
movl 0x68(%rdi), %eax
shrl $0xd, %eax
andl $0x1, %eax
movzbl (%rdi), %ecx
cmpl $0x3, %ecx
jne 0x17933
movq 0x60(%rdi), %rdi
jmp 0x17925
cmpl $0xe, %ecx
ja 0x17977
movl $0x6a00, %edx           # imm = 0x6A00
btl %ecx, %edx
jae 0x17943
retq
cmpl $0x2, %ecx
je 0x17961
cmpl $0x4, %ecx
jne 0x17977
movq 0x60(%rdi), %rcx
xorl %eax, %eax
cmpq 0x485ee(%rip), %rcx     # 0x5ff48
sete %al
orl $0x2, %eax
retq
movq 0x60(%rdi), %rcx
cmpq 0x485e4(%rip), %rcx     # 0x5ff50
je 0x1797d
cmpq 0x48613(%rip), %rcx     # 0x5ff88
je 0x17942
movl $0x5, %eax
retq
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: add_join_conditional
static pseudo_t add_join_conditional(struct entrypoint *ep, struct expression *expr,
				     pseudo_t phi1, pseudo_t phi2)
{
	pseudo_t target;
	struct instruction *phi_node;

	if (phi1 == VOID)
		return (phi2 == VOID) ? phi2 : phi2->def->src;
	if (phi2 == VOID)
		return (phi1 == VOID) ? phi1 : phi1->def->src;

	phi_node = alloc_typed_instruction(OP_PHI, expr->ctype);
	link_phi(phi_node, phi1);
	link_phi(phi_node, phi2);
	phi_node->target = target = alloc_pseudo(phi_node);
	add_one_insn(ep, phi_node);
	return target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
leaq 0x4e038(%rip), %r13     # 0x659d0
cmpq %r13, %rdx
je 0x17abb
movq %rdx, %r12
cmpq %r13, %r14
je 0x17ac6
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
movl $0x46, %edi
callq 0x13674
movq %rax, %r15
movq %rax, %r13
addq $0x38, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x227b4
movq %r12, (%rax)
testq %r12, %r12
je 0x17a17
movq %rax, %rbp
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x179f2
movl $0x43, %ecx
btl %eax, %ecx
jb 0x17a17
leaq 0x487b7(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %rbp, 0x8(%rax)
movq %r15, (%rax)
leaq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x18(%r12), %rax
movq %r15, 0x38(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0x227b4
movq %r14, (%rax)
testq %r14, %r14
je 0x17a6d
movq %rax, %r12
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x17a49
movl $0x43, %ecx
btl %eax, %ecx
jb 0x17a6d
leaq 0x48760(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r12, 0x8(%rax)
movq %r15, (%rax)
leaq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x227b4
movq 0x18(%r14), %rax
movq %r15, 0x38(%rax)
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r13
movl $0x3, 0x4(%rax)
movl 0x4f0c4(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x4f0bc(%rip)     # 0x66b50
movl %eax, (%r13)
movq %r15, 0x18(%r13)
movq %r13, 0x20(%r15)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x17acf
movq %rdi, 0x8(%r15)
addq $0x28, %rdi
movq %r15, %rsi
callq 0x227b4
jmp 0x17acf
cmpq %r13, %r14
je 0x17acf
movq 0x18(%r14), %rax
jmp 0x17acb
movq 0x18(%r12), %rax
movq 0x30(%rax), %r13
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: linearize_address_gen
static int linearize_address_gen(struct entrypoint *ep,
	struct expression *expr,
	struct access_data *ad)
{
	struct symbol *ctype = expr->ctype;

	if (!ctype)
		return 0;
	ad->type = ctype;
	if (expr->type == EXPR_PREOP && expr->op == '*')
		return linearize_simple_address(ep, expr->unop, ad);

	warning(expr->pos, "generating address of non-lvalue (%d)", expr->type);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17b48
movq %rdx, %rbx
movq %rsi, %r14
movq %rax, (%rdx)
movzbl (%rsi), %edx
cmpl $0x9, %edx
jne 0x17b32
cmpl $0x2a, 0x4(%r14)
jne 0x17b32
movq %rdi, %r15
movq 0x20(%r14), %r14
movzbl (%r14), %eax
cmpl $0x5, %eax
jne 0x17b4c
movq 0x28(%r14), %rdi
cmpb $0x1, (%rdi)
jne 0x17b6b
cmpl $0x2b, 0x4(%r14)
jne 0x17b6b
callq 0xf401
addq %rax, 0x18(%rbx)
jmp 0x17b0a
movq 0x8(%r14), %rdi
leaq 0x29ff0(%rip), %rsi     # 0x41b2d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x118fc
jmp 0x17b7f
xorl %ebx, %ebx
jmp 0x17b7f
cmpl $0x3, %eax
jne 0x17b6b
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x15490
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x167e4
jmp 0x17b76
movq %r15, %rdi
movq %r14, %rsi
callq 0x144d5
movq %rax, 0x10(%rbx)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_load_gen
static pseudo_t linearize_load_gen(struct entrypoint *ep, struct access_data *ad)
{
	struct symbol *ctype = ad->type;
	struct symbol *btype;
	pseudo_t new;

	if (!ep->active)
		return VOID;

	btype = ad->btype = bitfield_base_type(ctype);
	new = add_load(ep, ad);
	if (ctype->bit_size != type_size(btype))
		new = linearize_bitfield_extract(ep, new, ctype, btype);
	return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x17bd3
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
callq 0x16b8d
movq %rax, %r15
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16c16
movq %rax, %r12
movl 0x50(%r14), %eax
testq %r15, %r15
je 0x17bdc
movl 0x50(%r15), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
jmp 0x17bde
leaq 0x4ddf6(%rip), %r12     # 0x659d0
jmp 0x17be2
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0x17bf1
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movzbl 0x54(%r14), %edi
testq %rdi, %rdi
je 0x17c19
callq 0x13745
movq %rbx, %rdi
movq %r15, %rsi
movl $0xf, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x16d1b
movq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17589
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_inc_dec
static pseudo_t linearize_inc_dec(struct entrypoint *ep, struct expression *expr, int postop)
{
	struct access_data ad = { NULL, };
	pseudo_t old, new, one;
	int op = expr->op == SPECIAL_INCREMENT ? OP_ADD : OP_SUB;

	if (!linearize_address_gen(ep, expr->unop, &ad))
		return VOID;

	old = linearize_load_gen(ep, &ad);
	op = opcode_float(op, expr->ctype);
	if (is_float_type(expr->ctype))
		one = add_setfval(ep, expr->ctype, expr->op_value);
	else
		one = value_pseudo(expr->op_value);
	if (ad.btype != ad.type)
		old = cast_pseudo(ep, old, ad.type, ad.btype);
	new = add_binary_op(ep, ad.btype, op, old, one);
	if (ad.btype != ad.type)
		new = cast_pseudo(ep, new, ad.btype, ad.type);
	linearize_store_gen(ep, new, &ad);
	return postop ? old : new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movl 0x4(%rsi), %ebp
movq 0x20(%rsi), %rsi
callq 0x17ae1
testl %eax, %eax
je 0x17ce3
xorl %r13d, %r13d
cmpl $0x101, %ebp            # imm = 0x101
setne %r13b
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x17b87
movq %rax, %r15
movq 0x10(%r12), %rsi
movzbl (%rsi), %eax
movq %rsi, %rcx
cmpl $0x3, %eax
jne 0x17c9b
movq 0x60(%rsi), %rcx
leal 0x8(,%r13,2), %ebp
movq 0x60(%rcx), %rcx
cmpq 0x482a2(%rip), %rcx     # 0x5ff50
jne 0x17cbe
movl %ebp, %ecx
leaq 0x29f67(%rip), %rdx     # 0x41c20
movsbl 0x3(%rdx,%rcx,8), %ebp
movq %rsi, %rcx
cmpl $0x3, %eax
jne 0x17cca
movq 0x60(%rsi), %rcx
movq 0x60(%rcx), %rax
movq 0x28(%r12), %rdi
cmpq 0x48276(%rip), %rax     # 0x5ff50
je 0x17cef
callq 0x13745
jmp 0x17d15
leaq 0x4dce6(%rip), %r15     # 0x659d0
jmp 0x17d83
movq %rdi, 0x30(%rsp)
xorl %eax, %eax
testq %rdi, %rdi
sets %al
fildll 0x30(%rsp)
leaq 0x29889(%rip), %rcx     # 0x41590
fadds (%rcx,%rax,4)
fstpt (%rsp)
movq %r14, %rdi
callq 0x1558f
movq %rax, %r12
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
cmpq %rdx, %rcx
je 0x17d3a
movq %r14, %rdi
movq %r15, %rsi
callq 0x17589
movq %rax, %r15
movq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rcx, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x16d1b
movq %rax, %r12
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
cmpq %rcx, %rdx
je 0x17d6d
movq %r14, %rdi
movq %r12, %rsi
callq 0x17589
movq %rax, %r12
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1684b
testl %ebx, %ebx
cmoveq %r12, %r15
movq %r15, %rax
addq $0x38, %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_isdigit
static pseudo_t linearize_isdigit(struct entrypoint *ep, struct expression *expr)
{
	struct instruction *insn;
	pseudo_t src;

	insn = alloc_typed_instruction(OP_SUB, &int_ctype);
	src = linearize_expression(ep, first_expression(expr->args));
	use_pseudo(insn, src, &insn->src1);
	insn->src2 = value_pseudo('0');
	src = insn->target = alloc_pseudo(insn);
	add_one_insn(ep, insn);

	insn = alloc_typed_instruction(OP_SET_BE, &int_ctype);
	use_pseudo(insn, src, &insn->src1);
	insn->src2 = value_pseudo(9);
	insn->target = alloc_pseudo(insn);
	insn->itype = &int_ctype;
	add_one_insn(ep, insn);

	return insn->target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x53756(%rip), %r12     # 0x6b738
movl 0x50(%r12), %r13d
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
shll $0x8, %r13d
xorl %edi, %edi
callq 0x2fca9
movq %rax, %r14
movl $0x80, %eax
andl (%r14), %eax
addl %r13d, %eax
addl $0xa, %eax
movl %eax, (%r14)
movq 0x4ed52(%rip), %rax     # 0x66d68
movq %rax, 0x10(%r14)
movq %r12, 0x18(%r14)
movq 0x28(%r15), %rdi
callq 0x225b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x144d5
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0x1807e
movq %rax, %r15
movl 0x4(%rax), %eax
cmpl $0x6, %eax
ja 0x18050
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1807e
movq %r14, %r13
addq $0x30, %r13
leaq 0x48152(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
movl $0x30, %edi
callq 0x13745
movq %rax, 0x38(%r14)
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2fd6f
movq %rax, %r15
movl $0x3, 0x4(%rax)
movl 0x4eaab(%rip), %eax     # 0x66b50
incl %eax
movl %eax, 0x4eaa3(%rip)     # 0x66b50
movl %eax, (%r15)
movq %r14, 0x18(%r15)
movq %r15, 0x20(%r14)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x180d1
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x227b4
movl 0x50(%r12), %r13d
testl %r13d, %r13d
cmovlel %ebp, %r13d
shll $0x8, %r13d
xorl %edi, %edi
callq 0x2fca9
movq %rax, %r14
movl $0x80, %eax
andl (%r14), %eax
addl %r13d, %eax
addl $0x2d, %eax
movl %eax, (%r14)
movq 0x4ec65(%rip), %rax     # 0x66d68
movq %rax, 0x10(%r14)
movq %r12, 0x18(%r14)
movq %r15, 0x30(%r14)
movl 0x4(%r15), %eax
cmpl $0x6, %eax
ja 0x18122
movl $0x43, %ecx
btl %eax, %ecx
jb 0x18150
movq %r14, %r13
addq $0x30, %r13
leaq 0x48080(%rip), %rdi     # 0x601b0
movl $0x10, %esi
callq 0x2f700
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
movl $0x9, %edi
callq 0x13745
movq %rax, 0x38(%r14)
xorl %edi, %edi
callq 0x2fd6f
movl $0x3, 0x4(%rax)
movl 0x4e9de(%rip), %ecx     # 0x66b50
incl %ecx
movl %ecx, 0x4e9d6(%rip)     # 0x66b50
movl %ecx, (%rax)
movq %r14, 0x18(%rax)
movq %rax, 0x20(%r14)
movq %r12, 0x40(%r14)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x181a5
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x227b4
movq 0x20(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_finalize
static void handle_onoff_switch_finalize(const struct flag flags[])
{
	unsigned i;

	for (i = 0; flags[i].name; i++) {
		if (*flags[i].flag == FLAG_FORCE_OFF)
			*flags[i].flag = FLAG_OFF;
	}
}

// Assembly:
cmpq $0x0, 0x47cb3(%rip)     # 0x60960
je 0x18cdf
leaq 0x47caa(%rip), %rax     # 0x60960
movl $0x1, %ecx
movq %rax, %rdx
movq 0x8(%rdx), %rdx
cmpl $0x2, (%rdx)
jne 0x18ccd
movl $0x0, (%rdx)
movl %ecx, %edx
leaq (%rdx,%rdx,4), %rdx
leaq (%rax,%rdx,8), %rdx
incl %ecx
cmpq $0x0, (%rdx)
jne 0x18cbe
movl $0x8, %eax
leaq 0x3f1e5(%rip), %rcx     # 0x57ed0
movq (%rax,%rcx), %rdx
cmpl $0x2, (%rdx)
jne 0x18cfa
movl $0x0, (%rdx)
addq $0x28, %rax
cmpq $0x878, %rax            # imm = 0x878
jne 0x18ceb
cmpl $-0x1, 0x4788f(%rip)    # 0x6059c
je 0x18d10
retq
movl 0x47842(%rip), %eax     # 0x60558
addl $-0x2, %eax
xorl %ecx, %ecx
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %cl
movl %ecx, 0x47873(%rip)     # 0x6059c
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_switches
static int handle_switches(const char *ori, const char *opt, const struct flag *flags)
{
	const char *arg = opt;
	int val = 1;

	// Prefixe "no-" mean to turn flag off.
	if (strncmp(arg, "no-", 3) == 0) {
		arg += 3;
		val = 0;
	}

	for (; flags->name; flags++) {
		const char *opt = match_option(arg, flags->name);
		int rc;

		if (!opt)
			continue;

		if (flags->fun) {
			int options = 0;
			if (!val)
				options |= OPT_INVERSE;
			if ((rc = flags->fun(ori, opt, flags, options)))
				return rc;
		}

		// boolean flag
		if (opt[0] == '\0' && flags->flag) {
			if (flags->mask & OPT_VAL)
				val = flags->val;
			if (flags->mask & OPT_INVERSE)
				val = !val;
			*flags->flag = val;
			return 1;
		}
	}

	// not handled
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb $0x1, %al
cmpb $0x6e, (%rsi)
jne 0x18d5f
cmpb $0x6f, 0x1(%r14)
jne 0x18d5f
xorl %ecx, %ecx
cmpb $0x2d, 0x2(%r14)
setne %al
sete %cl
leaq (%rcx,%rcx,2), %rcx
jmp 0x18d61
xorl %ecx, %ecx
movq (%rbx), %r12
testq %r12, %r12
je 0x18dcf
addq %rcx, %r14
movzbl %al, %eax
movl %eax, 0x4(%rsp)
xorb $0x1, %al
movzbl %al, %ebp
movq %r12, %rdi
callq 0xe0d0
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe080
testl %eax, %eax
jne 0x18dc2
addq %r14, %r13
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x18db2
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq *%rax
testl %eax, %eax
jne 0x18dcf
cmpb $0x0, (%r13)
jne 0x18dc2
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x18dde
movq 0x28(%rbx), %r12
addq $0x28, %rbx
testq %r12, %r12
jne 0x18d78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rcx
testb $0x2, %cl
movl 0x4(%rsp), %esi
je 0x18dee
movl 0x20(%rbx), %esi
xorl %edx, %edx
testl %esi, %esi
sete %dl
testb $0x1, %cl
cmovel %esi, %edx
movl %edx, (%rax)
jmp 0x18dcf
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_fdump_ir
static int handle_suboption_mask(const char *arg, const char *opt, const struct mask_map *map, unsigned long *flag)
{
	if (*opt == '\0') {
		apply_mask(flag, "", 0, map, 0);
		return 1;
	}
	if (*opt++ != '=')
		return 0;
	while (1) {
		unsigned int len = strcspn(opt, ",+");
		int neg = 0;
		if (len == 0)
			goto end;
		if (!strncmp(opt, "no-", 3)) {
			opt += 3;
			len -= 3;
			neg = 1;
		}
		if (apply_mask(flag, opt, len, map, neg))
			die("error: wrong option '%.*s' for \'%s\'", len, opt, arg);

end:
		opt += len;
		if (*opt++ == '\0')
			break;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzbl (%rsi), %ecx
testl %ecx, %ecx
je 0x18ed4
xorl %eax, %eax
cmpl $0x3d, %ecx
jne 0x18ee9
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x29274(%rip), %r14     # 0x420d9
leaq 0x1(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xe160
movq %rax, %r15
testl %r15d, %r15d
je 0x18ec1
cmpb $0x6e, (%r12)
jne 0x18eae
cmpb $0x6f, 0x2(%r13)
jne 0x18eae
cmpb $0x2d, 0x3(%r13)
jne 0x18eae
addl $-0x3, %r15d
addq $0x4, %r13
movq %r13, %rdi
movl %r15d, %esi
movl $0x1, %edx
callq 0x190ad
movq %r13, %r12
jmp 0x18ebb
movq %r12, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x190ad
testl %eax, %eax
je 0x18ec4
jmp 0x18ef3
xorl %r15d, %r15d
movl %r15d, %eax
leaq (%r12,%rax), %r13
cmpb $0x0, (%r12,%rax)
jne 0x18e65
jmp 0x18ee4
leaq 0x279f2(%rip), %rdi     # 0x408cd
xorl %esi, %esi
xorl %edx, %edx
callq 0x190ad
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x291e2(%rip), %rdi     # 0x420dc
movl %r15d, %esi
movq %r12, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_fpasses
static int handle_fpasses(const char *arg, const char *opt, const struct flag *flag, int options)
{
	unsigned long mask;

	mask = flag->mask;
	if (*opt == '\0') {
		if (options & OPT_INVERSE)
			fpasses &= ~mask;
		else
			fpasses |=  mask;
		return 1;
	}
	if (options & OPT_INVERSE)
		return 0;
	if (!strcmp(opt, "-enable")) {
		fpasses |= mask;
		return 1;
	}
	if (!strcmp(opt, "-disable")) {
		fpasses &= ~mask;
		return 1;
	}
	if (!strcmp(opt, "=last")) {
		// clear everything above
		mask |= mask - 1;
		fpasses &= mask;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdx), %r15
cmpb $0x0, (%rsi)
je 0x18f6e
xorl %ebx, %ebx
testb $0x1, %cl
jne 0x18f92
movq %rsi, %r14
leaq 0x291d7(%rip), %rsi     # 0x42100
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x18f73
leaq 0x291cc(%rip), %rsi     # 0x42108
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x18f7c
leaq 0x291c2(%rip), %rsi     # 0x42111
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x18f92
leaq -0x1(%r15), %rax
orq %r15, %rax
andq 0x47617(%rip), %rax     # 0x60580
movq %rax, %r15
jmp 0x18f86
testb $0x1, %cl
jne 0x18f7c
orq 0x47606(%rip), %r15     # 0x60580
jmp 0x18f86
notq %r15
andq 0x475fa(%rip), %r15     # 0x60580
movq %r15, 0x475f3(%rip)     # 0x60580
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_ftabstop
static int handle_ftabstop(const char *arg, const char *opt, const struct flag *flag, int options)
{
	unsigned long val;
	char *end;

	if (*opt == '\0')
		die("error: missing argument to \"%s\"", arg);

	/* we silently ignore silly values */
	val = strtoul(opt, &end, 10);
	if (*end == '\0' && 1 <= val && val <= 100)
		tabstop = val;

	return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, (%rsi)
je 0x1908a
leaq 0x8(%rsp), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0xe2a0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
sete %cl
leaq -0x1(%rax), %rdx
cmpq $0x64, %rdx
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1907f
leaq 0x4b6d3(%rip), %rcx     # 0x64750
movl %eax, (%rcx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rdi, %rax
leaq 0x290ab(%rip), %rdi     # 0x4213f
movq %rax, %rsi
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: apply_mask
static int apply_mask(unsigned long *val, const char *str, unsigned len, const struct mask_map *map, int neg)
{
	const char *name;

	for (;(name = map->name); map++) {
		if (!strncmp(name, str, len) && !name[len]) {
			if (neg == 0)
				*val |= map->mask;
			else
				*val &= ~map->mask;
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %r15d
leaq 0x27808(%rip), %r12     # 0x408cd
leaq 0x3ea24(%rip), %r13     # 0x57af0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe080
testl %eax, %eax
jne 0x190e5
cmpb $0x0, (%r12,%r15)
je 0x190f9
movq (%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x190cc
movl $0x1, %eax
jmp 0x1911d
movq -0x8(%r13), %rax
testl %ebx, %ebx
je 0x1910d
notq %rax
andq 0x4de0d(%rip), %rax     # 0x66f18
jmp 0x19114
orq 0x4de04(%rip), %rax     # 0x66f18
movq %rax, 0x4ddfd(%rip)     # 0x66f18
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_subopt_val
static int handle_subopt_val(const char *opt, const char *arg, const struct val_map *map, int *flag)
{
	const char *name;

	if (*arg++ != '=')
		die("missing argument for option '%s'", opt);
	for (;(name = map->name); map++) {
		if (strcmp(name, arg) == 0 || strcmp(name, "*") == 0) {
			*flag = map->val;
			return 1;
		}
		if (strcmp(name, "?") == 0)
			die("invalid argument '%s' in option '%s'", arg, opt);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x3d, (%rsi)
jne 0x19275
movq %rdx, %r12
movq (%rdx), %r13
xorl %ebp, %ebp
testq %r13, %r13
je 0x19250
movq %rcx, %r15
movq %rsi, %r14
incq %r14
addq $0x10, %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x19243
movzbl (%r13), %eax
cmpl $0x3f, %eax
je 0x1922d
cmpl $0x2a, %eax
jne 0x19234
cmpb $0x0, 0x1(%r13)
jne 0x19234
jmp 0x19243
cmpb $0x0, 0x1(%r13)
je 0x19261
movq (%r12), %r13
addq $0x10, %r12
testq %r13, %r13
jne 0x19206
jmp 0x19250
movl -0x8(%r12), %eax
movl %eax, (%r15)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29128(%rip), %rdi     # 0x42390
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x11c32
leaq 0x290f3(%rip), %rdi     # 0x4236f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_onoff_switch
static char **handle_onoff_switch(char *arg, char **next, const struct flag flags[])
{
	int flag = FLAG_ON;
	char *p = arg + 1;
	unsigned i;

	// Prefixes "no" and "no-" mean to turn warning off.
	if (p[0] == 'n' && p[1] == 'o') {
		p += 2;
		if (p[0] == '-')
			p++;
		flag = FLAG_FORCE_OFF;
	}

	for (i = 0; flags[i].name; i++) {
		if (!strcmp(p,flags[i].name)) {
			*flags[i].flag = flag;
			return next;
		}
	}

	// Unknown.
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x1(%rdi), %r15
movl $0x1, %ebp
cmpb $0x6e, 0x1(%rdi)
jne 0x192c1
cmpb $0x6f, 0x2(%rdi)
jne 0x192c1
leaq 0x3(%rdi), %r15
cmpb $0x2d, 0x3(%rdi)
leaq 0x4(%rdi), %rax
cmoveq %rax, %r15
movl $0x2, %ebp
movq (%r14), %rsi
testq %rsi, %rsi
je 0x19306
movq %r15, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x192fe
movl $0x1, %r12d
movl %r12d, %eax
leaq (%rax,%rax,4), %r13
movq (%r14,%r13,8), %rsi
testq %rsi, %rsi
je 0x19306
movq %r15, %rdi
callq 0xe1c0
incl %r12d
testl %eax, %eax
jne 0x192db
leaq (%r14,%r13,8), %r14
movq 0x8(%r14), %rax
movl %ebp, (%rax)
jmp 0x19308
xorl %ebx, %ebx
movq %rbx, %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/options.c
// Function: handle_arch
static char **handle_arch(char *arg, char **next)
{
	enum machine mach;

	if (*arg++ != '=')
		die("missing argument for --arch option");

	mach = target_parse(arg);
	if (mach != MACH_UNKNOWN)
		target_config(mach);

	return next;
}

// Assembly:
pushq %rbx
cmpb $0x3d, (%rdi)
jne 0x1933c
movq %rsi, %rbx
incq %rdi
callq 0x2c724
cmpl $0x18, %eax
je 0x19337
movl %eax, %edi
callq 0x2c830
movq %rbx, %rax
popq %rbx
retq
leaq 0x29524(%rip), %rdi     # 0x42867
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_os
static char **handle_os(char *arg, char **next)
{
	if (*arg++ != '=')
		die("missing argument for --os option");

	target_os(arg);

	return next;
}

// Assembly:
pushq %rbx
cmpb $0x3d, (%rdi)
jne 0x19360
movq %rsi, %rbx
incq %rdi
callq 0x2c7d5
movq %rbx, %rax
popq %rbx
retq
leaq 0x29523(%rip), %rdi     # 0x4288a
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/options.c
// Function: handle_param
static char **handle_param(char *arg, char **next)
{
	char *value = NULL;

	/* For now just skip any '--param=*' or '--param *' */
	if (*arg == '\0') {
		value = *++next;
	} else if (isspace((unsigned char)*arg) || *arg == '=') {
		value = ++arg;
	}

	if (!value)
		die("missing argument for --param option");

	if (!strcmp(value, "dissect-show-all-symbols"))
		dissect_show_all_symbols = 1;

	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movzbl (%rdi), %r15d
testq %r15, %r15
je 0x193a1
movq %rdi, %r14
callq 0xe300
incq %r14
cmpq $0x3d, %r15
je 0x193ae
movq (%rax), %rax
movzwl (%rax,%r15,2), %eax
andl $0x2000, %eax           # imm = 0x2000
jne 0x193ae
jmp 0x193d4
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x193d4
addq $0x8, %rbx
leaq 0x2951a(%rip), %rsi     # 0x428cf
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x193cb
movl $0x1, 0x4d9f9(%rip)     # 0x66dc4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x294d0(%rip), %rdi     # 0x428ab
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: init_parser
void init_parser(int stream)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(typedefs); i++)
		init_keyword(stream, &typedefs[i], NS_TYPEDEF);
	for (i = 0; i < ARRAY_SIZE(keywords); i++)
		init_keyword(stream, &keywords[i], NS_KEYWORD);

	for (i = 0; i < ARRAY_SIZE(ignored_attributes); i++) {
		const char * name = ignored_attributes[i];
		struct symbol *sym = create_symbol(stream, name, SYM_KEYWORD,
						   NS_KEYWORD);
		if (!sym->op) {
			sym->ident->keyword = 1;
			sym->op = &ignore_attr_op;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r14d, %r14d
leaq 0x47670(%rip), %r15     # 0x60a80
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl $0x2, %edx
callq 0x194a9
addq $0x20, %r14
cmpq $0x6a0, %r14            # imm = 0x6A0
jne 0x19410
xorl %r14d, %r14d
leaq 0x47ce9(%rip), %r15     # 0x61120
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl $0x100, %edx            # imm = 0x100
callq 0x194a9
addq $0x20, %r14
cmpq $0x8e0, %r14            # imm = 0x8E0
jne 0x19437
xorl %r14d, %r14d
leaq 0x2948a(%rip), %r15     # 0x428e8
leaq 0x4859b(%rip), %r12     # 0x61a00
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movl %ebx, %edi
movl $0xf, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x2bf00
cmpq $0x0, 0x40(%rax)
jne 0x19490
movq 0x18(%rax), %rcx
orb $0x4, 0x11(%rcx)
movq %r12, 0x40(%rax)
addq $0x4, %r14
cmpq $0x69c, %r14            # imm = 0x69C
jne 0x19465
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: expect
struct token *expect(struct token *token, int op, const char *where)
{
	if (!match_op(token, op)) {
		if (token != &bad_token) {
			bad_token.next = token;
			sparse_error(token->pos, "Expected %s %s", show_special(op), where);
			sparse_error(token->pos, "got %s", show_token(token));
		}
		if (op == ';')
			return skip_to(token, op);
		return &bad_token;
	}
	return token->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x12, %eax
jne 0x19533
cmpl %ebp, 0x10(%rbx)
jne 0x19533
movq 0x8(%rbx), %r14
jmp 0x195b1
leaq 0x49e5e(%rip), %r14     # 0x63398
cmpq %r14, %rbx
je 0x19580
movq %rbx, 0x49e5a(%rip)     # 0x633a0
movl %ebp, %edi
callq 0x2ddfa
movq (%rbx), %rdi
leaq 0x29a2d(%rip), %rsi     # 0x42f84
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x11a80
movq %rbx, %rdi
callq 0x2df90
movq (%rbx), %rdi
leaq 0x30a0e(%rip), %rsi     # 0x49f84
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
cmpl $0x3b, %ebp
jne 0x195b1
leaq 0x6d054(%rip), %rax     # 0x865e0
movl (%rbx), %edx
andl $0x3f, %edx
movb $0x1, %cl
cmpl $0x12, %edx
jne 0x1959f
cmpl $0x3b, 0x10(%rbx)
setne %cl
cmpq %rax, %rbx
je 0x195ae
testb %cl, %cl
je 0x195ae
movq 0x8(%rbx), %rbx
jmp 0x1958c
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: alloc_statement
struct statement *alloc_statement(struct position pos, int type)
{
	struct statement *stmt = __alloc_statement(0);
	stmt->type = type;
	stmt->pos = pos;
	return stmt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
callq 0x2fa58
movl %ebx, (%rax)
movq %r14, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/parse.c
// Function: label_symbol
struct symbol *label_symbol(struct token *token, int used)
{
	struct symbol *sym = lookup_symbol(token->ident, NS_LABEL);
	if (!sym) {
		sym = alloc_symbol(token->pos, SYM_LABEL);
		bind_symbol(sym, token->ident, NS_LABEL);
		if (used)
			sym->used = 1;
		fn_local_symbol(sym);
	}
	return sym;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl $0x8, %esi
callq 0x2afd5
movq %rax, %rbx
testq %rax, %rax
jne 0x19639
movq (%r14), %rdi
movl $0xc, %esi
callq 0x2b00b
movq %rax, %rbx
movq 0x10(%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x2beca
testl %ebp, %ebp
je 0x19625
orb $0x2, 0x2(%rbx)
movq 0x4d904(%rip), %rdi     # 0x66f30
testq %rdi, %rdi
je 0x19639
movq %rbx, %rsi
callq 0x227b4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq