LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_store_gen
static pseudo_t linearize_store_gen(struct entrypoint *ep,
		pseudo_t value,
		struct access_data *ad)
{
	struct symbol *ctype = ad->type;
	struct symbol *btype;
	pseudo_t store = value;

	if (!ep->active)
		return VOID;

	btype = ad->btype = bitfield_base_type(ctype);
	if (type_size(btype) != type_size(ctype)) {
		pseudo_t orig = add_load(ep, ad);
		store = linearize_bitfield_insert(ep, orig, value, ctype, btype);
	}
	add_store(ep, ad, store);
	return value;
}

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x150f4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rbp
movq %rbp, %rdi
callq 0x1521b
movq %rax, %r12
movq %rax, 0x8(%r15)
xorl %eax, %eax
movl $0x0, %ecx
testq %r12, %r12
je 0x14fe0
movl 0x50(%r12), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
testq %rbp, %rbp
je 0x14fef
movl 0x50(%rbp), %edx
xorl %eax, %eax
testl %edx, %edx
cmovgl %edx, %eax
movq %rbx, 0x8(%rsp)
cmpl %eax, %ecx
je 0x150be
movq %r14, %rdi
movq %r15, 0x18(%rsp)
movq %r15, %rsi
callq 0x152a2
movq %rax, 0x20(%rsp)
movzbl 0x54(%rbp), %r13d
movb 0x50(%rbp), %cl
pushq $-0x1
popq %rbx
shlq %cl, %rbx
movl 0x50(%r12), %eax
movl %eax, 0x14(%rsp)
pushq $0x35
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rcx
callq 0x1539c
movq %rax, %r15
movq 0x18(%rax), %rax
movq %rbp, 0x40(%rax)
testq %r13, %r13
je 0x15078
movq %r13, %rbp
notq %rbx
movq %r13, %rdi
callq 0x12c98
pushq $0x11
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %rax, %r8
callq 0x15338
movq %rax, %r15
movl %ebp, %ecx
shlq %cl, %rbx
notq %rbx
movl 0x14(%rsp), %ecx
negb %cl
shlq %cl, %rbx
shrq %cl, %rbx
movq %rbx, %rdi
callq 0x12c98
pushq $0x16
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq 0x20(%rsp), %rcx
movq %rax, %r8
callq 0x15338
pushq $0x17
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rcx
movq %r15, %r8
callq 0x15338
movq %rax, %rbx
movq 0x18(%rsp), %r15
cmpq $0x0, 0x20(%r14)
je 0x15139
movq 0x8(%r15), %rsi
pushq $0x44
popq %rdi
callq 0x12bbd
movq %rax, %r12
movq 0x18(%r15), %rax
leaq 0x30(%r12), %r13
movq %rax, 0x38(%r12)
movq (%r15), %rax
testq %rax, %rax
je 0x150fc
movl 0x68(%rax), %eax
shrl $0xa, %eax
andb $0x1, %al
jmp 0x150fe
leaq 0x4a8d5(%rip), %rax     # 0x5f9d0
retq
xorl %eax, %eax
movb 0x40(%r12), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x40(%r12)
movq %r12, %rdx
addq $0x20, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x12bdf
movq 0x10(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x12bdf
movq %r14, %rdi
movq %r12, %rsi
callq 0x13783
movq 0x8(%rsp), %rax
addq $0x28, %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: 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 0x1517d
movl 0x20(%r15), %eax
movq %rax, 0x18(%rbx)
movq 0x28(%r15), %r15
movb $0x1, %bpl
jmp 0x15163
leaq 0x4a84c(%rip), %r13     # 0x5f9d0
cmpl $0x18, %eax
jne 0x151de
movq 0x20(%r15), %r15
movq %r13, %r12
testq %r15, %r15
je 0x15201
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jge 0x151c8
movq 0x18(%r12,%r13,8), %rsi
cmpw $0x100, %ax             # imm = 0x100
jb 0x151b8
testq %rsi, %rsi
je 0x151c3
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1514d
incq %r13
jmp 0x1519b
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x15198
leaq 0x4a7f7(%rip), %r13     # 0x5f9d0
movq %r13, %r12
jmp 0x15201
movq %r14, %rdi
movq %r15, %rsi
callq 0x13895
movq %rax, %r12
movq 0x10(%r15), %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x14f94
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_O2/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 0x15250
movq %rdi, %rbx
movzbl (%rdi), %ecx
movq %rdi, %rax
cmpl $0x3, %ecx
jne 0x15239
movq 0x60(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0xb, %ecx
jne 0x1529a
movq 0x60(%rax), %r14
movl 0x54(%rbx), %eax
btl $0x15, %eax
jb 0x15254
movq %r14, %rbx
jmp 0x1529a
xorl %ebx, %ebx
jmp 0x1529a
movzbl %al, %eax
addl 0x50(%rbx), %eax
js 0x15270
leaq 0x4949d(%rip), %rcx     # 0x5e700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
jmp 0x15273
pushq $-0x1
popq %rbp
xorl %edi, %edi
callq 0x2aa1f
movq %rax, %rbx
movl $0xe0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe1e0
leaq 0x4946c(%rip), %rax     # 0x5e700
imull (%rax), %ebp
movl %ebp, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x152f8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
pushq $0x43
popq %rdi
callq 0x12bbd
movq %rax, %r12
movq %rax, %rdi
callq 0x12c70
movq %rax, %r15
movq %rax, 0x20(%r12)
movq 0x18(%r14), %rax
movq %rax, 0x38(%r12)
movq %r12, %rdx
addq $0x30, %rdx
movq (%r14), %rax
testq %rax, %rax
je 0x15301
movl 0x68(%rax), %eax
shrl $0xa, %eax
andb $0x1, %al
jmp 0x15303
leaq 0x4a6d1(%rip), %r15     # 0x5f9d0
jmp 0x15329
xorl %eax, %eax
movb 0x40(%r12), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x40(%r12)
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq 0x12bdf
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13783
movq %r15, %rax
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_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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movl %edx, %edi
callq 0x12bbd
movq %rax, %r12
movq %rax, %rdi
callq 0x12c70
movq %rax, %r13
movq %rax, 0x20(%r12)
leaq 0x30(%r12), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x12bdf
leaq 0x38(%r12), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x12bdf
movq %r15, %rdi
movq %r12, %rsi
callq 0x13783
movq %r13, %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_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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl %edx, %edi
callq 0x12bbd
movq %rax, %r15
movq %rax, %rdi
callq 0x12c70
movq %rax, %r12
movq %rax, 0x20(%r15)
leaq 0x30(%r15), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12bdf
movq %r14, %rdi
movq %r15, %rsi
callq 0x13783
movq %r12, %rax
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_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 %rbx
movq %rdi, %r15
movq 0xd0(%rsi), %rbx
testq %rbx, %rbx
je 0x1540d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x134e4
jmp 0x15441
movq %rsi, %r14
movq 0x20(%r15), %rbx
testq %rbx, %rbx
je 0x15420
cmpq $0x0, 0x28(%rbx)
je 0x1543a
movq 0x4(%r14), %rsi
movq %r15, %rdi
callq 0x134b2
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x134e4
movq %rbx, 0xd0(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15457
retq
pushq %rbx
movq %rsi, %rbx
movq 0x4(%rsi), %rsi
callq 0x134b2
movq %rax, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_multijmp
static struct multijmp *alloc_multijmp(struct basic_block *target, long long begin, long long end)
{
	struct multijmp *multijmp = __alloc_multijmp(0);
	multijmp->target = target;
	multijmp->begin = begin;
	multijmp->end = end;
	return multijmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0x2ae59
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x154e9
movq %rdi, %rbx
leaq 0x4a522(%rip), %rax     # 0x5f9d0
movq %r14, %r15
xorl %r12d, %r12d
movl (%r15), %ecx
movsbq %cl, %rdx
cmpq %rdx, %r12
jge 0x154de
movq 0x18(%r15,%r12,8), %rsi
cmpw $0x100, %cx             # imm = 0x100
jb 0x154d1
testq %rsi, %rsi
je 0x154d9
movq %rbx, %rdi
callq 0x14600
incq %r12
jmp 0x154b4
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x154b1
jmp 0x154f0
leaq 0x4a4e0(%rip), %rax     # 0x5f9d0
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: linearize_cond_branch
static pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
{
	pseudo_t cond;

	if (!expr || !valid_type(expr->ctype) || !bb_reachable(ep->active))
		return VOID;

	switch (expr->type) {

	case EXPR_STRING:
	case EXPR_VALUE:
		add_goto(ep, expr->value ? bb_true : bb_false);
		break;
	case EXPR_FVALUE:
		add_goto(ep, expr->fvalue ? bb_true : bb_false);
		break;
	case EXPR_LOGICAL:
		linearize_logical_branch(ep, expr, bb_true, bb_false);
		break;
	case EXPR_COMPARE:
		cond = linearize_compare(ep, expr);
		add_branch(ep, cond, bb_true, bb_false);
		break;
	case EXPR_PREOP:
		if (expr->op == '!')
			return linearize_cond_branch(ep, expr->unop, bb_false, bb_true);
		/* fall through */
	default:
		cond = linearize_expression_to_bool(ep, expr);
		add_branch(ep, cond, bb_true, bb_false);
		break;
	}
	return VOID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x513a1(%rip), %rbp     # 0x668b8
movq %rdx, %r15
testq %r12, %r12
je 0x155b4
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x155b4
cmpq %rbp, %rax
je 0x155b4
cmpq $0x0, 0x20(%r14)
je 0x155b4
movzbl (%r12), %eax
cmpl $0x7, %eax
jne 0x1558f
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x134b2
movq %rax, %r13
cmpl $0x10e, 0x4(%r12)       # imm = 0x10E
movq 0x20(%r12), %rsi
movq %r14, %rdi
jne 0x15572
movq %r15, %rdx
movq %r13, %rcx
jmp 0x15578
movq %r13, %rdx
movq %rbx, %rcx
callq 0x154fc
movq %r14, %rdi
movq %r13, %rsi
callq 0x134e4
movq 0x28(%r12), %r12
jmp 0x1551a
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x155e8
cmpl $0x9, %eax
jne 0x155c3
cmpl $0x21, 0x4(%r12)
jne 0x1560b
movq 0x20(%r12), %r12
movq %rbx, %rdx
movq %r15, %rbx
jmp 0x15517
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x16, %eax
je 0x15618
cmpl $0x1c, %eax
jne 0x1560b
fldt 0x20(%r12)
fldz
fucompi %st(1), %st
fstp %st(0)
cmovneq %r15, %rbx
cmovpq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x155f8
cmpq $0x0, 0x20(%r12)
cmoveq %rbx, %r15
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13830
movq %r14, %rdi
movq %r12, %rsi
callq 0x15799
jmp 0x15623
movq %r14, %rdi
movq %r12, %rsi
callq 0x14ec5
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x156fa
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq 0x28(%rsi), %rdi
callq 0x1f919
movq %rax, %r12
testq %rax, %rax
jne 0x15699
leaq 0x28(%r13), %rbp
pushq $0x46
popq %rdi
movq %rbx, %rsi
callq 0x12bbd
movq %rax, %r12
movq %rax, %rdi
callq 0x12c70
movq %rax, 0x20(%r12)
movq %r13, 0x8(%r12)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1fae9
movq 0x20(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12d91
leaq 0x48749(%rip), %rcx     # 0x5ddf8
movq %rcx, 0x10(%rax)
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x156c9
// File: /workspace/github_c_makefile_star2_O2/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), %r15
testq %r15, %r15
je 0x1578a
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
pushq $0x4
popq %rdi
xorl %esi, %esi
callq 0x1347f
movq %rax, %r13
leaq 0x30(%rax), %rdx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12bdf
movq %r12, 0x38(%r13)
movq %r14, 0x40(%r13)
leaq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x1fae9
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x1fae9
addq $0x20, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fae9
movq %r15, %rdi
movq %r14, %rsi
callq 0x1fae9
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13783
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: linearize_expression_to_bool
static pseudo_t linearize_expression_to_bool(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t dst;
	dst = linearize_expression(ep, expr);
	dst = add_convert_to_bool(ep, dst, expr->ctype);
	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x13895
movq %rax, %rbx
movq 0x10(%r15), %r15
testq %r15, %r15
sete %cl
leaq 0x4a20d(%rip), %rax     # 0x5f9d0
cmpq %rax, %rbx
sete %dl
orb %cl, %dl
jne 0x157f3
cmpb $0x3, (%r15)
movq %r15, %rax
jne 0x157da
movq 0x60(%r15), %rax
cmpq 0x447ff(%rip), %rax     # 0x59fe0
je 0x157f0
cmpl $0x6, 0x4(%rbx)
jne 0x157ff
cmpq $0x2, 0x18(%rbx)
jae 0x157ff
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x1585a
testl %eax, %eax
je 0x1582d
fldz
fstpt (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x145b2
movq %rax, %r12
pushq $0x30
popq %rdi
movq %r15, %rsi
callq 0x15874
movl %eax, %edx
jmp 0x1583a
xorl %edi, %edi
callq 0x12c98
movq %rax, %r12
pushq $0x30
popq %rdx
leaq 0x4f7f7(%rip), %rsi     # 0x65038
movq %r14, %rdi
movq %r15, %rcx
movq %rbx, %r8
movq %r12, %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x158c1
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testq %rsi, %rsi
je 0x158b7
movq %rsi, %r14
movq %rsi, %rdi
callq 0x1585a
testl %eax, %eax
je 0x1589f
movslq %ebx, %rax
leaq 0x253e8(%rip), %rcx     # 0x3ac80
movsbl 0x3(%rcx,%rax,8), %ebx
jmp 0x158b7
testb $0x20, 0x69(%r14)
je 0x158b7
cmpl $0xf, %ebx
ja 0x158b7
movl $0xa800, %eax           # imm = 0xA800
btl %ebx, %eax
jae 0x158b7
incl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rdx
cmpq %rcx, %rax
jle 0x1593a
xorl %eax, %eax
cmpq %rdx, %rdi
setle %al
retq
cmpq %rdx, %rdi
jle 0x15943
pushq $-0x1
popq %rax
retq
cmpq %rdi, %rax
jne 0x1594f
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x1595c
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x23edf(%rip), %rcx     # 0x39b18
movzbl (%rdi), %edx
addl $-0x2, %edx
cmpl $0xc, %edx
ja 0x15c69
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq 0x60(%rdi), %rdi
jmp 0x15c39
movq 0x60(%rdi), %rcx
cmpq 0x442f2(%rip), %rcx     # 0x59f50
je 0x15c81
cmpq 0x44319(%rip), %rcx     # 0x59f80
je 0x15c6c
pushq $0x5
popq %rax
retq
movq 0x60(%rdi), %rcx
xorl %eax, %eax
cmpq 0x442ce(%rip), %rcx     # 0x59f48
sete %al
orl $0x2, %eax
retq
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/linearize.c
// Function: taint_undefined_behaviour
static void taint_undefined_behaviour(struct instruction *insn)
{
	pseudo_t src2;

	switch (insn->opcode) {
	case OP_LSR:
	case OP_ASR:
	case OP_SHL:
		src2 = insn->src2;
		if (src2->type != PSEUDO_VAL)
			break;
		if ((unsigned long long)src2->value >= insn->size)
			insn->tainted = 1;
		break;
	}
}

// Assembly:
movl (%rdi), %eax
movl %eax, %ecx
andl $0x7f, %ecx
addl $-0xf, %ecx
cmpl $0x2, %ecx
ja 0x15cb0
movq 0x38(%rdi), %rcx
cmpl $0x6, 0x4(%rcx)
jne 0x15cb0
movl %eax, %edx
shrl $0x8, %edx
cmpq %rdx, 0x18(%rcx)
jb 0x15cb0
orl $0x80, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
leaq 0x49ce5(%rip), %r15     # 0x5f9d0
cmpq %r15, %rdx
je 0x15d3c
movq %rdx, %r12
cmpq %r15, %r14
je 0x15d47
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
pushq $0x46
popq %rdi
callq 0x12bbd
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x156c9
movq %r13, %rdi
movq %r14, %rsi
callq 0x156c9
movq %r13, %rdi
callq 0x12c70
movq %rax, %r15
movq %rax, 0x20(%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13783
jmp 0x15d50
cmpq %r15, %r14
je 0x15d50
movq 0x18(%r14), %rax
jmp 0x15d4c
movq 0x18(%r12), %rax
movq 0x30(%rax), %r15
movq %r15, %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: 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 0x15dc4
movq %rdx, %rbx
movq %rsi, %r14
movq %rax, (%rdx)
movzbl (%rsi), %edx
cmpl $0x9, %edx
jne 0x15dae
cmpl $0x2a, 0x4(%r14)
jne 0x15dae
movq %rdi, %r15
movq 0x20(%r14), %r14
movzbl (%r14), %eax
cmpl $0x5, %eax
jne 0x15dc8
movq 0x28(%r14), %rdi
cmpb $0x1, (%rdi)
jne 0x15de7
cmpl $0x2b, 0x4(%r14)
jne 0x15de7
callq 0xfe1b
addq %rax, 0x18(%rbx)
jmp 0x15d86
movq 0x8(%r14), %rdi
leaq 0x24dd4(%rip), %rsi     # 0x3ab8d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1108a
jmp 0x15df9
xorl %ebx, %ebx
jmp 0x15df9
cmpl $0x3, %eax
jne 0x15de7
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x144b3
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x14f2d
jmp 0x15df2
movq %r15, %rdi
movq %r14, %rsi
callq 0x13895
movq %rax, 0x10(%rbx)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15e4d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
callq 0x1521b
movq %rax, %r15
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x152a2
movq %rax, %r12
movl 0x50(%r14), %eax
testq %r15, %r15
je 0x15e56
movl 0x50(%r15), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
jmp 0x15e58
leaq 0x49b7c(%rip), %r12     # 0x5f9d0
jmp 0x15e5c
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0x15e6b
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movzbl 0x54(%r14), %edi
testq %rdi, %rdi
je 0x15e91
callq 0x12c98
pushq $0xf
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %rax, %r8
callq 0x15338
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 0x1597d
// File: /workspace/github_c_makefile_star2_O2/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 0x15d5d
testl %eax, %eax
je 0x15f51
xorl %eax, %eax
cmpl $0x101, %ebp            # imm = 0x101
setne %al
leal 0x8(,%rax,2), %ebp
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x15e01
movq %rax, %r15
movq 0x10(%r12), %r13
movl %ebp, %edi
movq %r13, %rsi
callq 0x15cb1
movl %eax, %ebp
movq %r13, %rdi
callq 0x1585a
movq 0x28(%r12), %rdi
testl %eax, %eax
je 0x15f5a
movq %rdi, 0x30(%rsp)
xorl %eax, %eax
testq %rdi, %rdi
sets %al
fildll 0x30(%rsp)
leaq 0x246b2(%rip), %rcx     # 0x3a5f0
fadds (%rcx,%rax,4)
fstpt (%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x145b2
jmp 0x15f5f
leaq 0x49a78(%rip), %r15     # 0x5f9d0
jmp 0x15fcd
callq 0x12c98
movq %rax, %r12
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
cmpq %rdx, %rcx
je 0x15f84
movq %r14, %rdi
movq %r15, %rsi
callq 0x1597d
movq %rax, %r15
movq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rcx, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x15338
movq %rax, %r12
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
cmpq %rcx, %rdx
je 0x15fb7
movq %r14, %rdi
movq %r12, %rsi
callq 0x1597d
movq %rax, %r12
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x14f94
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_O2/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_fma
static pseudo_t linearize_fma(struct entrypoint *ep, struct expression *expr)
{
	struct instruction *insn = alloc_typed_instruction(OP_FMADD, expr->ctype);
	struct expression *arg;

	PREPARE_PTR_LIST(expr->args, arg);
		use_pseudo(insn, linearize_expression(ep, arg), &insn->src1);
		NEXT_PTR_LIST(arg)
		use_pseudo(insn, linearize_expression(ep, arg), &insn->src2);
		NEXT_PTR_LIST(arg)
		use_pseudo(insn, linearize_expression(ep, arg), &insn->src3);
	FINISH_PTR_LIST(arg);

	add_one_insn(ep, insn);
	return insn->target = alloc_pseudo(insn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rsi
pushq $0x42
popq %rdi
callq 0x12bbd
movq %rax, %rbx
movq 0x28(%r15), %r13
testq %r13, %r13
je 0x1601f
movq %r13, %rbp
cmpb $0x0, (%rbp)
jg 0x16029
movq 0x10(%rbp), %rbp
cmpq %r13, %rbp
jne 0x1600b
xorl %r12d, %r12d
jmp 0x16024
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r15d, %r15d
jmp 0x16035
movq 0x18(%rbp), %r12
andq $-0x4, %r12
pushq $0x1
popq %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x13895
leaq 0x30(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bdf
testq %r12, %r12
je 0x16069
movsbl (%rbp), %eax
cmpl %eax, %r15d
jl 0x1606e
movq 0x10(%rbp), %rbp
xorl %r15d, %r15d
cmpq %r13, %rbp
jne 0x16054
xorl %r12d, %r12d
jmp 0x1607d
movl %r15d, %eax
movq 0x18(%rbp,%rax,8), %r12
andq $-0x4, %r12
incl %r15d
movq %r14, %rdi
movq %r12, %rsi
callq 0x13895
leaq 0x38(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bdf
testq %r12, %r12
je 0x160b3
movsbl (%rbp), %eax
cmpl %eax, %r15d
jl 0x160b8
movq 0x10(%rbp), %rbp
xorl %r15d, %r15d
cmpq %r13, %rbp
jne 0x1609c
jmp 0x160c4
xorl %r15d, %r15d
jmp 0x160c4
movl %r15d, %eax
movq 0x18(%rbp,%rax,8), %r15
andq $-0x4, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x13895
movq %rbx, %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bdf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13783
movq %rbx, %rdi
callq 0x12c70
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/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x4f61c(%rip), %r14     # 0x65738
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x12bbd
movq %rax, %r15
movq 0x28(%r12), %rdi
callq 0x1f919
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13895
leaq 0x30(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x12bdf
pushq $0x30
popq %rdi
callq 0x12c98
movq %rax, 0x38(%r15)
movq %r15, %rdi
callq 0x12c70
movq %rax, %r12
movq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13783
pushq $0x2d
popq %rdi
movq %r14, %rsi
callq 0x12bbd
movq %rax, %r15
leaq 0x30(%rax), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x12bdf
pushq $0x9
popq %rdi
callq 0x12c98
movq %rax, 0x38(%r15)
movq %r15, %rdi
callq 0x12c70
movq %rax, 0x20(%r15)
movq %r14, 0x40(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13783
movq 0x20(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16caa
cmpb $0x6f, 0x1(%r14)
jne 0x16caa
xorl %ecx, %ecx
cmpb $0x2d, 0x2(%r14)
setne %al
sete %cl
leaq (%rcx,%rcx,2), %rcx
jmp 0x16cac
xorl %ecx, %ecx
addq %rcx, %r14
movzbl %al, %r13d
movl %r13d, %eax
xorb $0x1, %al
movzbl %al, %ebp
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x16d21
movq %r14, %rdi
callq 0x16d30
testq %rax, %rax
je 0x16cfd
movq %rax, %r12
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x16ced
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq *%rax
testl %eax, %eax
jne 0x16d21
cmpb $0x0, (%r12)
jne 0x16cfd
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x16d03
addq $0x28, %rbx
jmp 0x16cbb
movq 0x18(%rbx), %rcx
testb $0x2, %cl
je 0x16d10
movl 0x20(%rbx), %r13d
xorl %edx, %edx
testl %r13d, %r13d
sete %dl
testb $0x1, %cl
cmovel %r13d, %edx
movl %edx, (%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/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl (%rsi), %eax
testl %eax, %eax
je 0x16e2b
xorl %ebp, %ebp
cmpl $0x3d, %eax
jne 0x16e3e
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x2436f(%rip), %r14     # 0x3b139
pushq $0x1
popq %rbp
leaq 0x1(%r13), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xe160
movq %rax, %r12
testl %r12d, %r12d
je 0x16e18
xorl %edx, %edx
cmpb $0x6e, (%r15)
jne 0x16e07
cmpb $0x6f, 0x2(%r13)
jne 0x16e07
cmpb $0x2d, 0x3(%r13)
jne 0x16e07
addq $0x4, %r13
addl $-0x3, %r12d
movq %r13, %r15
movl %ebp, %edx
movq %r15, %rdi
movl %r12d, %esi
callq 0x16ffb
testl %eax, %eax
je 0x16e1b
jmp 0x16e4f
xorl %r12d, %r12d
movl %r12d, %eax
leaq (%r15,%rax), %r13
cmpb $0x0, (%r15,%rax)
jne 0x16dcd
jmp 0x16e3e
leaq 0x22a9b(%rip), %rdi     # 0x398cd
xorl %esi, %esi
xorl %edx, %edx
callq 0x16ffb
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x242e6(%rip), %rdi     # 0x3b13c
movl %r12d, %esi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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 0x16eca
xorl %ebx, %ebx
testb $0x1, %cl
jne 0x16eec
movq %rsi, %r14
leaq 0x242db(%rip), %rsi     # 0x3b160
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x16ecf
leaq 0x242d0(%rip), %rsi     # 0x3b168
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x16ed8
leaq 0x242c6(%rip), %rsi     # 0x3b171
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x16eec
leaq -0x1(%r15), %rax
orq %r15, %rax
andq 0x436bb(%rip), %rax     # 0x5a580
movq %rax, %r15
jmp 0x16ee2
testb $0x1, %cl
jne 0x16ed8
orq 0x436aa(%rip), %r15     # 0x5a580
jmp 0x16ee2
notq %r15
andq 0x4369e(%rip), %r15     # 0x5a580
movq %r15, 0x43697(%rip)     # 0x5a580
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16fda
leaq 0x8(%rsp), %rbx
pushq $0xa
popq %rdx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xe2b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
sete %cl
leaq -0x1(%rax), %rdx
cmpq $0x64, %rdx
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x16fd1
leaq 0x47781(%rip), %rcx     # 0x5e750
movl %eax, (%rcx)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rdi, %rax
leaq 0x241bb(%rip), %rdi     # 0x3b19f
movq %rax, %rsi
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %r15d
leaq 0x3aad3(%rip), %r13     # 0x51ae8
pushq $0x1
popq %rbp
movq -0x8(%r13), %r12
testq %r12, %r12
je 0x17064
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe080
testl %eax, %eax
jne 0x1703a
cmpb $0x0, (%r12,%r15)
je 0x17040
addq $0x10, %r13
jmp 0x17018
movq (%r13), %rax
testl %ebx, %ebx
je 0x17054
notq %rax
andq 0x49ec6(%rip), %rax     # 0x60f18
jmp 0x1705b
orq 0x49ebd(%rip), %rax     # 0x60f18
movq %rax, 0x49eb6(%rip)     # 0x60f18
xorl %ebp, %ebp
movl %ebp, %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/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x3d, (%rsi)
jne 0x171e0
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
incq %r14
addq $0x8, %r12
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x171c0
movq %r13, %rdi
movq %r14, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x171b4
movzbl (%r13), %eax
cmpl $0x3f, %eax
je 0x171a7
cmpl $0x2a, %eax
jne 0x171ae
cmpb $0x0, 0x1(%r13)
jne 0x171ae
jmp 0x171b4
cmpb $0x0, 0x1(%r13)
je 0x171cc
addq $0x10, %r12
jmp 0x17176
movl (%r12), %eax
movl %eax, (%r15)
pushq $0x1
popq %rax
jmp 0x171c2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2421d(%rip), %rdi     # 0x3b3f0
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x113be
leaq 0x241e8(%rip), %rdi     # 0x3b3cf
movq %rbx, %rsi
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
cmpb $0x6e, 0x1(%rdi)
jne 0x17228
cmpb $0x6f, 0x2(%rdi)
jne 0x17228
leaq 0x3(%rdi), %r15
cmpb $0x2d, 0x3(%rdi)
leaq 0x4(%rdi), %rax
cmoveq %rax, %r15
pushq $0x2
popq %rbp
xorl %r12d, %r12d
movl %r12d, %eax
imulq $0x28, %rax, %r13
movq (%r14,%r13), %rsi
testq %rsi, %rsi
je 0x17255
movq %r15, %rdi
callq 0xe1c0
incl %r12d
testl %eax, %eax
jne 0x1722b
addq %r13, %r14
movq 0x8(%r14), %rax
movl %ebp, (%rax)
jmp 0x17257
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_O2/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 0x1728b
movq %rsi, %rbx
incq %rdi
callq 0x27d0c
cmpl $0x18, %eax
je 0x17286
movl %eax, %edi
callq 0x27e08
movq %rbx, %rax
popq %rbx
retq
leaq 0x24635(%rip), %rdi     # 0x3b8c7
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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 0x172af
movq %rsi, %rbx
incq %rdi
callq 0x27db3
movq %rbx, %rax
popq %rbx
retq
leaq 0x24634(%rip), %rdi     # 0x3b8ea
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/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 0x172f0
movq %rdi, %r14
callq 0xe310
incq %r14
cmpq $0x3d, %r15
je 0x172fd
movq (%rax), %rax
movzwl (%rax,%r15,2), %eax
andl $0x2000, %eax           # imm = 0x2000
jne 0x172fd
jmp 0x17323
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x17323
addq $0x8, %rbx
leaq 0x2462b(%rip), %rsi     # 0x3b92f
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x1731a
movl $0x1, 0x49aaa(%rip)     # 0x60dc4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x245e1(%rip), %rdi     # 0x3b90b
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/options.c
// Function: handle_onoff_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:
xorl %eax, %eax
movl %eax, %ecx
imulq $0x28, %rcx, %rcx
cmpq $0x0, (%rdi,%rcx)
je 0x1736a
addq %rdi, %rcx
movq 0x8(%rcx), %rcx
cmpl $0x2, (%rcx)
jne 0x17366
andl $0x0, (%rcx)
incl %eax
jmp 0x1734a
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
leaq 0x43700(%rip), %r15     # 0x5aa80
pushq $0x2
popq %rbp
cmpq $0x6a0, %r14            # imm = 0x6A0
je 0x1739f
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl %ebp, %edx
callq 0x1741c
addq $0x20, %r14
jmp 0x17383
xorl %r14d, %r14d
leaq 0x43d77(%rip), %r15     # 0x5b120
cmpq $0x8e0, %r14            # imm = 0x8E0
je 0x173c8
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl $0x100, %edx            # imm = 0x100
callq 0x1741c
addq $0x20, %r14
jmp 0x173a9
xorl %r14d, %r14d
leaq 0x24576(%rip), %r15     # 0x3b948
pushq $0xf
popq %rbp
leaq 0x44624(%rip), %r12     # 0x5ba00
cmpq $0x69c, %r14            # imm = 0x69C
je 0x17413
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movl %ebx, %edi
movl %ebp, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x274d6
cmpq $0x0, 0x40(%rax)
jne 0x1740d
movq 0x18(%rax), %rcx
orb $0x4, 0x11(%rcx)
movq %r12, 0x40(%rax)
addq $0x4, %r14
jmp 0x173dc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/parse.c
// Function: init_keyword
static void init_keyword(int stream, struct init_keyword *kw, enum namespace ns)
{
	struct symbol *sym = create_symbol(stream, kw->name, SYM_KEYWORD, ns);
	sym->ident->keyword = 1;
	sym->ident->reserved |= (ns == NS_TYPEDEF);
	sym->ctype.modifiers = kw->mods;
	sym->ctype.base_type = kw->type;
	sym->op = kw->op;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq (%rsi), %rsi
pushq $0xf
popq %rdx
movl %ebp, %ecx
callq 0x274d6
movq 0x18(%rax), %rcx
orb $0x4, 0x11(%rcx)
cmpl $0x2, %ebp
sete %cl
movq 0x18(%rax), %rdx
movb 0x11(%rdx), %sil
movl %esi, %edi
andb $0x2, %dil
shrb %dil
orb %cl, %dil
addb %dil, %dil
andb $-0x3, %sil
orb %dil, %sil
movb %sil, 0x11(%rdx)
movq 0x18(%rbx), %rcx
movq %rcx, 0x68(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x60(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq