LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x50cd5(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x50ccd(%rip)     # 0x67b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
movq %r12, 0x30(%rbx)
testq %r12, %r12
je 0x16ed9
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16eab
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16ed9
movq %rbx, %r13
addq $0x30, %r13
leaq 0x4a2f7(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x16ef2
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x2285b
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16f23
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1401d
jmp 0x16f6f
movq %rsi, %r14
movq 0x20(%r15), %rbx
testq %rbx, %rbx
je 0x16f36
cmpq $0x0, 0x28(%rbx)
je 0x16f68
movq 0x4(%r14), %r12
xorl %edi, %edi
callq 0x30217
movq %rax, %rbx
movq %r12, (%rax)
movq %r15, 0x10(%rax)
movl 0x50e1f(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x50e16(%rip)     # 0x67d70
movl %eax, 0x38(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1401d
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_O1/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 0x16f8b
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4(%rsi), %r15
xorl %edi, %edi
callq 0x30217
movq %r15, (%rax)
movq %r14, 0x10(%rax)
movl 0x50dc2(%rip), %ecx     # 0x67d70
leal 0x1(%rcx), %edx
movl %edx, 0x50db9(%rip)     # 0x67d70
movl %ecx, 0x38(%rax)
movq %rax, 0xd0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17027
movq %rdi, %rbx
leaq 0x4f9ee(%rip), %rax     # 0x669d0
movq %r14, %r15
movzwl (%r15), %ecx
testb %cl, %cl
jle 0x1701c
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %cx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x17005
testq %rsi, %rsi
je 0x1700d
movq %rbx, %rdi
callq 0x14a3c
incq %r12
movl (%r15), %ecx
movsbq %cl, %rdx
cmpq %rdx, %r12
jl 0x16ff0
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x16fe5
jmp 0x1702e
leaq 0x4f9a2(%rip), %rax     # 0x669d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22634
movq %rax, %rbx
testq %rax, %rax
jne 0x1730f
leaq 0x28(%r13), %rbp
movl $0x46, %edi
movq %r14, %rsi
callq 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movl $0x3, 0x4(%rax)
movl 0x50862(%rip), %ecx     # 0x67b50
incl %ecx
movl %ecx, 0x5085a(%rip)     # 0x67b50
movl %ecx, (%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0x20(%rbx)
movq %r13, 0x8(%rbx)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2285b
movq 0x20(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13822
movq %rax, %r14
leaq 0x4dacf(%rip), %rax     # 0x64df8
movq %rax, 0x10(%r14)
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x2285b
movq %r14, (%rax)
testq %r14, %r14
je 0x1737e
movq %rax, %r15
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x17357
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1737e
leaq 0x49e52(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r15, 0x8(%rax)
movq %rbx, (%rax)
movq %r14, %rdi
addq $0x8, %rdi
movq %rax, %rsi
callq 0x2285b
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_O1/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 0x1748e
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x302dd
movq %rax, %r15
movl $0x80, %eax
andl (%r15), %eax
orl $0x4, %eax
movl %eax, (%r15)
movq 0x50990(%rip), %rax     # 0x67d68
movq %rax, 0x10(%r15)
movq %rbp, 0x30(%r15)
testq %rbp, %rbp
je 0x1742d
movl 0x4(%rbp), %eax
cmpl $0x6, %eax
ja 0x173f7
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1742d
movq %r15, %rax
addq $0x30, %rax
movq %rax, (%rsp)
leaq 0x49da7(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rax)
addq $0x8, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r13, 0x38(%r15)
movq %r14, 0x40(%r15)
leaq 0x18(%r13), %rdi
movq %r12, %rsi
callq 0x2285b
leaq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x2285b
addq $0x20, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2285b
movq %r12, %rdi
movq %r14, %rsi
callq 0x2285b
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1748e
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 0x2285b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x174d4
cmpb $0x3, (%rsi)
movq %rsi, %rcx
jne 0x174b0
movq 0x60(%rsi), %rcx
movq 0x60(%rcx), %rcx
cmpq 0x49a85(%rip), %rcx     # 0x60f40
je 0x174d5
testb $0x20, 0x69(%rsi)
je 0x174d4
cmpl $0xf, %eax
ja 0x174d4
movl $0xa800, %ecx           # imm = 0xA800
btl %eax, %ecx
jae 0x174d4
incl %eax
retq
cltq
leaq 0x2b772(%rip), %rcx     # 0x42c50
movsbl 0x3(%rcx,%rax,8), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17544
xorl %eax, %eax
cmpq %rdx, %rdi
setle %al
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rdi
jg 0x17567
cmpq %rdi, %r8
jne 0x1755a
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x17567
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1790c
movq 0x60(%rdi), %rdi
jmp 0x178fe
cmpl $0xe, %ecx
ja 0x17950
movl $0x6a00, %edx           # imm = 0x6A00
btl %ecx, %edx
jae 0x1791c
retq
cmpl $0x2, %ecx
je 0x1793a
cmpl $0x4, %ecx
jne 0x17950
movq 0x60(%rdi), %rcx
xorl %eax, %eax
cmpq 0x49605(%rip), %rcx     # 0x60f38
sete %al
orl $0x2, %eax
retq
movq 0x60(%rdi), %rcx
cmpq 0x495fb(%rip), %rcx     # 0x60f40
je 0x17956
cmpq 0x49632(%rip), %rcx     # 0x60f80
je 0x1791b
movl $0x5, %eax
retq
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f05f(%rip), %r13     # 0x669d0
cmpq %r13, %rdx
je 0x17a94
movq %rdx, %r12
cmpq %r13, %r14
je 0x17a9f
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
movl $0x46, %edi
callq 0x13602
movq %rax, %r15
movq %rax, %r13
addq $0x38, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2285b
movq %r12, (%rax)
testq %r12, %r12
je 0x179f0
movq %rax, %rbp
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x179cb
movl $0x43, %ecx
btl %eax, %ecx
jb 0x179f0
leaq 0x497de(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %rbp, 0x8(%rax)
movq %r15, (%rax)
leaq 0x8(%r12), %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x18(%r12), %rax
movq %r15, 0x38(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0x2285b
movq %r14, (%rax)
testq %r14, %r14
je 0x17a46
movq %rax, %r12
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x17a22
movl $0x43, %ecx
btl %eax, %ecx
jb 0x17a46
leaq 0x49787(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r12, 0x8(%rax)
movq %r15, (%rax)
leaq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x18(%r14), %rax
movq %r15, 0x38(%rax)
xorl %edi, %edi
callq 0x303a3
movq %rax, %r13
movl $0x3, 0x4(%rax)
movl 0x500eb(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x500e3(%rip)     # 0x67b50
movl %eax, (%r13)
movq %r15, 0x18(%r13)
movq %r13, 0x20(%r15)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x17aa8
movq %rdi, 0x8(%r15)
addq $0x28, %rdi
movq %r15, %rsi
callq 0x2285b
jmp 0x17aa8
cmpq %r13, %r14
je 0x17aa8
movq 0x18(%r14), %rax
jmp 0x17aa4
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_O1/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 %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17afd
movq %rax, (%rdx)
movzbl (%rsi), %eax
cmpl $0x9, %eax
jne 0x17ae5
cmpl $0x2a, 0x4(%rsi)
jne 0x17ae5
movq 0x20(%rsi), %rsi
callq 0x17bb1
movl $0x1, %ebx
jmp 0x17aff
movq 0x8(%rsi), %rdi
leaq 0x2b06d(%rip), %rsi     # 0x42b5d
xorl %ebx, %ebx
movl %eax, %edx
xorl %eax, %eax
callq 0x118b4
jmp 0x17aff
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17b4f
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
callq 0x16bc2
movq %rax, %r15
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16c41
movq %rax, %r12
movl 0x50(%r14), %eax
testq %r15, %r15
je 0x17b58
movl 0x50(%r15), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
jmp 0x17b5a
leaq 0x4ee7a(%rip), %r12     # 0x669d0
jmp 0x17b5e
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0x17b6d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movzbl 0x54(%r14), %edi
testq %rdi, %rdi
je 0x17b95
callq 0x136d3
movq %rbx, %rdi
movq %r15, %rsi
movl $0xf, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x16d46
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 0x175ad
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_simple_address
static int linearize_simple_address(struct entrypoint *ep,
	struct expression *addr,
	struct access_data *ad)
{
	if (addr->type == EXPR_SYMBOL) {
		linearize_one_symbol(ep, addr->symbol);
		ad->address = symbol_pseudo(ep, addr->symbol);
		return 1;
	}
	if (addr->type == EXPR_BINOP) {
		if (addr->right->type == EXPR_VALUE) {
			if (addr->op == '+') {
				ad->offset += get_expression_value(addr->right);
				return linearize_simple_address(ep, addr->left, ad);
			}
		}
	}
	ad->address = linearize_expression(ep, addr);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl (%r14), %eax
cmpl $0x5, %eax
jne 0x17be7
movq 0x28(%r14), %rdi
cmpb $0x1, (%rdi)
jne 0x17c06
cmpl $0x2b, 0x4(%r14)
jne 0x17c06
callq 0xf23d
addq %rax, 0x18(%rbx)
movq 0x20(%r14), %r14
jmp 0x17bbf
cmpl $0x3, %eax
jne 0x17c06
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x14815
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x16810
jmp 0x17c11
movq %r15, %rdi
movq %r14, %rsi
callq 0x1447d
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movl 0x4(%rsi), %ebp
movq 0x20(%rsi), %rsi
callq 0x17aba
testl %eax, %eax
je 0x17cc8
xorl %eax, %eax
cmpl $0x101, %ebp            # imm = 0x101
setne %al
leal 0x8(,%rax,2), %ebp
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x17b03
movq %rax, %r15
movq 0x10(%r12), %rsi
testq %rsi, %rsi
je 0x17ca3
cmpb $0x3, (%rsi)
movq %rsi, %rax
jne 0x17c88
movq 0x60(%rsi), %rax
movq 0x60(%rax), %rax
cmpq 0x492ad(%rip), %rax     # 0x60f40
jne 0x17ca3
movl %ebp, %eax
leaq 0x2afb2(%rip), %rcx     # 0x42c50
movsbl 0x3(%rcx,%rax,8), %ebp
cmpb $0x3, (%rsi)
movq %rsi, %rax
jne 0x17caf
movq 0x60(%rsi), %rax
movq 0x60(%rax), %rax
movq 0x28(%r12), %rdi
cmpq 0x49281(%rip), %rax     # 0x60f40
je 0x17cd4
callq 0x136d3
jmp 0x17cfa
leaq 0x4ed01(%rip), %r15     # 0x669d0
jmp 0x17d66
movq %rdi, 0x18(%rsp)
xorl %eax, %eax
testq %rdi, %rdi
sets %al
fildll 0x18(%rsp)
leaq 0x2a8d4(%rip), %rcx     # 0x425c0
fadds (%rcx,%rax,4)
fstpt (%rsp)
movq %r14, %rdi
callq 0x149c4
movq %rax, %r12
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
cmpq %rdx, %rcx
je 0x17d1a
movq %r14, %rdi
movq %r15, %rsi
callq 0x175ad
movq %rax, %r15
movq 0x28(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x16d46
movq %rax, %r12
movq 0x20(%rsp), %rcx
cmpq %rcx, %r13
je 0x17d50
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x175ad
movq %rax, %r12
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x16877
testl %ebx, %ebx
cmoveq %r12, %r15
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x54773(%rip), %r12     # 0x6c738
movl 0x50(%r12), %r13d
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
shll $0x8, %r13d
xorl %edi, %edi
callq 0x302dd
movq %rax, %r14
movl $0x80, %eax
andl (%r14), %eax
addl %r13d, %eax
addl $0xa, %eax
movl %eax, (%r14)
movq 0x4fd6f(%rip), %rax     # 0x67d68
movq %rax, 0x10(%r14)
movq %r12, 0x18(%r14)
movq 0x28(%r15), %rdi
callq 0x22634
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1447d
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0x18061
movq %rax, %r15
movl 0x4(%rax), %eax
cmpl $0x6, %eax
ja 0x18033
movl $0x43, %ecx
btl %eax, %ecx
jb 0x18061
movq %r14, %r13
addq $0x30, %r13
leaq 0x4916f(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
movl $0x30, %edi
callq 0x136d3
movq %rax, 0x38(%r14)
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x303a3
movq %rax, %r15
movl $0x3, 0x4(%rax)
movl 0x4fac8(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x4fac0(%rip)     # 0x67b50
movl %eax, (%r15)
movq %r14, 0x18(%r15)
movq %r15, 0x20(%r14)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x180b4
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x2285b
movl 0x50(%r12), %r13d
testl %r13d, %r13d
cmovlel %ebp, %r13d
shll $0x8, %r13d
xorl %edi, %edi
callq 0x302dd
movq %rax, %r14
movl $0x80, %eax
andl (%r14), %eax
addl %r13d, %eax
addl $0x2d, %eax
movl %eax, (%r14)
movq 0x4fc82(%rip), %rax     # 0x67d68
movq %rax, 0x10(%r14)
movq %r12, 0x18(%r14)
movq %r15, 0x30(%r14)
movl 0x4(%r15), %eax
cmpl $0x6, %eax
ja 0x18105
movl $0x43, %ecx
btl %eax, %ecx
jb 0x18133
movq %r14, %r13
addq $0x30, %r13
leaq 0x4909d(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
movl $0x9, %edi
callq 0x136d3
movq %rax, 0x38(%r14)
xorl %edi, %edi
callq 0x303a3
movl $0x3, 0x4(%rax)
movl 0x4f9fb(%rip), %ecx     # 0x67b50
incl %ecx
movl %ecx, 0x4f9f3(%rip)     # 0x67b50
movl %ecx, (%rax)
movq %r14, 0x18(%rax)
movq %rax, 0x20(%r14)
movq %r12, 0x40(%r14)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x18184
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x2285b
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_O1/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, 0x48c3c(%rip)     # 0x61960
je 0x18d56
leaq 0x48c33(%rip), %rax     # 0x61960
movl $0x1, %ecx
movq %rax, %rdx
movq 0x8(%rdx), %rdx
cmpl $0x2, (%rdx)
jne 0x18d44
movl $0x0, (%rdx)
movl %ecx, %edx
leaq (%rdx,%rdx,4), %rdx
leaq (%rax,%rdx,8), %rdx
incl %ecx
cmpq $0x0, (%rdx)
jne 0x18d35
movl $0x8, %eax
leaq 0x4015e(%rip), %rcx     # 0x58ec0
movq (%rax,%rcx), %rdx
cmpl $0x2, (%rdx)
jne 0x18d71
movl $0x0, (%rdx)
addq $0x28, %rax
cmpq $0x878, %rax            # imm = 0x878
jne 0x18d62
cmpl $-0x1, 0x48818(%rip)    # 0x6159c
je 0x18d87
retq
movl 0x487cb(%rip), %eax     # 0x61558
addl $-0x2, %eax
xorl %ecx, %ecx
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %cl
movl %ecx, 0x487fc(%rip)     # 0x6159c
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x2a271(%rip), %rsi     # 0x43032
movl $0x3, %edx
movq %r14, %rdi
callq 0xe080
xorl %ecx, %ecx
testl %eax, %eax
sete %dl
movq (%rbx), %rbp
testq %rbp, %rbp
je 0x18ea6
movb %dl, %cl
leaq (%rcx,%rcx,2), %r12
addq %r14, %r12
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0xc(%rsp)
movq %rbp, %rdi
callq 0xe0d0
movl %eax, %r13d
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xe080
movl $0x4, %ecx
testq %r14, %r14
je 0x18e90
testl %eax, %eax
jne 0x18e90
addq %r12, %r13
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x18e4c
xorl %ecx, %ecx
cmpl $0x0, 0xc(%rsp)
sete %cl
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq *%rax
movl $0x1, %ecx
testl %eax, %eax
cmovnel %eax, %r15d
jne 0x18e90
xorl %ecx, %ecx
cmpb $0x0, (%r13)
jne 0x18e90
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x18e90
movq 0x18(%rbx), %rcx
testb $0x2, %cl
je 0x18e6e
movl 0x20(%rbx), %edx
movl %edx, 0xc(%rsp)
xorl %edx, %edx
movl 0xc(%rsp), %esi
testl %esi, %esi
sete %dl
testb $0x1, %cl
cmovnel %edx, %esi
movl %esi, 0xc(%rsp)
movl %esi, (%rax)
movl $0x1, %r15d
movl $0x1, %ecx
testb $0x3, %cl
jne 0x18ea6
movq 0x28(%rbx), %rbp
addq $0x28, %rbx
testq %rbp, %rbp
jne 0x18df5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %ecx
testl %ecx, %ecx
je 0x18f7d
xorl %eax, %eax
cmpl $0x3d, %ecx
jne 0x18f92
movq %rsi, %r13
movq %rdi, (%rsp)
leaq 0x2a1f3(%rip), %r14     # 0x4310d
leaq 0x2a111(%rip), %r15     # 0x43032
leaq 0x1(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xe160
movq %rax, %rbx
testl %ebx, %ebx
je 0x18f6c
movl $0x3, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe080
addq $0x4, %r13
leal -0x3(%rbx), %ebp
xorl %edx, %edx
testl %eax, %eax
sete %dl
cmoveq %r13, %r12
cmovnel %ebx, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x1915b
testl %eax, %eax
je 0x18f6e
jmp 0x18fa1
xorl %ebp, %ebp
movl %ebp, %eax
leaq (%r12,%rax), %r13
cmpb $0x0, (%r12,%rax)
jne 0x18f21
jmp 0x18f8d
leaq 0x28949(%rip), %rdi     # 0x418cd
xorl %esi, %esi
xorl %edx, %edx
callq 0x1915b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a168(%rip), %rdi     # 0x43110
movl %ebp, %esi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x1901c
xorl %ebx, %ebx
testb $0x1, %cl
jne 0x19040
movq %rsi, %r14
leaq 0x2a15d(%rip), %rsi     # 0x43134
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x19021
leaq 0x2a152(%rip), %rsi     # 0x4313c
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x1902a
leaq 0x2a148(%rip), %rsi     # 0x43145
movq %r14, %rdi
callq 0xe1c0
testl %eax, %eax
jne 0x19040
leaq -0x1(%r15), %rax
orq %r15, %rax
andq 0x48569(%rip), %rax     # 0x61580
movq %rax, %r15
jmp 0x19034
testb $0x1, %cl
jne 0x1902a
orq 0x48558(%rip), %r15     # 0x61580
jmp 0x19034
notq %r15
andq 0x4854c(%rip), %r15     # 0x61580
movq %r15, 0x48545(%rip)     # 0x61580
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19138
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 0x1912d
leaq 0x4c625(%rip), %rcx     # 0x65750
movl %eax, (%rcx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rdi, %rax
leaq 0x2a031(%rip), %rdi     # 0x43173
movq %rax, %rsi
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x2875a(%rip), %r12     # 0x418cd
leaq 0x3f966(%rip), %r13     # 0x58ae0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe080
testl %eax, %eax
jne 0x19193
cmpb $0x0, (%r12,%r15)
je 0x191a7
movq (%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x1917a
movl $0x1, %eax
jmp 0x191cb
movq -0x8(%r13), %rax
testl %ebx, %ebx
je 0x191bb
notq %rax
andq 0x4ed5f(%rip), %rax     # 0x67f18
jmp 0x191c2
orq 0x4ed56(%rip), %rax     # 0x67f18
movq %rax, 0x4ed4f(%rip)     # 0x67f18
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rsi
cmpb $0x3d, (%r14)
jne 0x19341
movq %rdx, %r12
movq (%rdx), %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1931a
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
incq %r14
addq $0x10, %r12
leaq 0x29606(%rip), %r13     # 0x428cc
leaq 0x292ff(%rip), %r15     # 0x425cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x19309
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x19309
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x1932b
movq (%r12), %rbx
addq $0x10, %r12
testq %rbx, %rbx
jne 0x192cd
jmp 0x1931a
movl -0x8(%r12), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a09b(%rip), %rdi     # 0x433cd
movq %r14, %rsi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x11bea
leaq 0x2a064(%rip), %rdi     # 0x433ac
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x1938a
cmpb $0x6f, 0x2(%rdi)
jne 0x1938a
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 0x193cf
movq %r15, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x193c7
movl $0x1, %r12d
movl %r12d, %eax
leaq (%rax,%rax,4), %r13
movq (%r14,%r13,8), %rsi
testq %rsi, %rsi
je 0x193cf
movq %r15, %rdi
callq 0xe1c0
incl %r12d
testl %eax, %eax
jne 0x193a4
leaq (%r14,%r13,8), %r14
movq 0x8(%r14), %rax
movl %ebp, (%rax)
jmp 0x193d1
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_O1/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 0x19405
movq %rsi, %rbx
incq %rdi
callq 0x2cc4c
cmpl $0x18, %eax
je 0x19400
movl %eax, %edi
callq 0x2cd64
movq %rbx, %rax
popq %rbx
retq
leaq 0x2a498(%rip), %rdi     # 0x438a4
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x19429
movq %rsi, %rbx
incq %rdi
callq 0x2cd09
movq %rbx, %rax
popq %rbx
retq
leaq 0x2a497(%rip), %rdi     # 0x438c7
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x1946c
movq %rdi, %r14
callq 0xe300
movq (%rax), %rax
incq %r14
xorl %edi, %edi
testb $0x20, 0x1(%rax,%r15,2)
cmovneq %r14, %rdi
cmpq $0x3d, %r15
cmoveq %r14, %rdi
jmp 0x19474
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x1949c
leaq 0x2a48c(%rip), %rsi     # 0x4390c
callq 0xe1c0
testl %eax, %eax
jne 0x19493
movl $0x1, 0x4e931(%rip)     # 0x67dc4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2a445(%rip), %rdi     # 0x438e8
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/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 0x485a8(%rip), %r15     # 0x61a80
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl $0x2, %edx
callq 0x19571
addq $0x20, %r14
cmpq $0x6a0, %r14            # imm = 0x6A0
jne 0x194d8
xorl %r14d, %r14d
leaq 0x48c21(%rip), %r15     # 0x62120
leaq (%r15,%r14), %rsi
movl %ebx, %edi
movl $0x100, %edx            # imm = 0x100
callq 0x19571
addq $0x20, %r14
cmpq $0x8e0, %r14            # imm = 0x8E0
jne 0x194ff
xorl %r14d, %r14d
leaq 0x2a402(%rip), %r15     # 0x43928
leaq 0x494d3(%rip), %r12     # 0x62a00
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movl %ebx, %edi
movl $0xf, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x2c406
cmpq $0x0, 0x40(%rax)
jne 0x19558
movq 0x18(%rax), %rcx
orb $0x4, 0x11(%rcx)
movq %r12, 0x40(%rax)
addq $0x4, %r14
cmpq $0x69c, %r14            # imm = 0x69C
jne 0x1952d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xf, %edx
movl %ebp, %ecx
callq 0x2c406
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
// File: /workspace/github_c_makefile_star2_O1/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 0x195fb
cmpl %ebp, 0x10(%rbx)
jne 0x195fb
movq 0x8(%rbx), %r14
jmp 0x19679
leaq 0x4ad96(%rip), %r14     # 0x64398
cmpq %r14, %rbx
je 0x19648
movq %rbx, 0x4ad92(%rip)     # 0x643a0
movl %ebp, %edi
callq 0x2e42a
movq (%rbx), %rdi
leaq 0x2a9a5(%rip), %rsi     # 0x43fc4
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x11a38
movq %rbx, %rdi
callq 0x2e5c0
movq (%rbx), %rdi
leaq 0x319d6(%rip), %rsi     # 0x4b014
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
cmpl $0x3b, %ebp
jne 0x19679
leaq 0x6df8c(%rip), %rax     # 0x875e0
movl (%rbx), %edx
andl $0x3f, %edx
movb $0x1, %cl
cmpl $0x12, %edx
jne 0x19667
cmpl $0x3b, 0x10(%rbx)
setne %cl
cmpq %rax, %rbx
je 0x19676
testb %cl, %cl
je 0x19676
movq 0x8(%rbx), %rbx
jmp 0x19654
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3008c
movl %ebx, (%rax)
movq %r14, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b511
movq %rax, %rbx
testq %rax, %rax
jne 0x19701
movq (%r14), %rdi
movl $0xc, %esi
callq 0x2b547
movq %rax, %rbx
movq 0x10(%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x2c3dd
testl %ebp, %ebp
je 0x196ed
orb $0x2, 0x2(%rbx)
movq 0x4e83c(%rip), %rdi     # 0x67f30
testq %rdi, %rdi
je 0x19701
movq %rbx, %rsi
callq 0x2285b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: typename
struct token *typename(struct token *token, struct symbol **p, int *forced)
{
	struct decl_state ctx = {.prefer_abstract = 1};
	unsigned long class;
	struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
	*p = sym;
	token = declaration_specifiers(token, &ctx);
	token = declarator(token, &ctx);
	apply_modifiers(token->pos, &ctx);
	sym->ctype = ctx.ctype;
	sym->endpos = token->pos;
	class = ctx.storage_class;
	if (forced)
		*forced = ctx.forced;
	if (class)
		warning(sym->pos, "storage class in typename (%s%s)",
			modifier_string(class), show_typename(sym));
	return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq $0x0, 0x50(%r12)
movb $0x1, 0x50(%r12)
movq (%rdi), %rdi
movl $0x3, %esi
callq 0x2b547
movq %rax, %rbx
movq %rax, (%r14)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1981b
movq %rax, %rdi
movq %r12, %rsi
callq 0x19a74
movq %rax, %r14
movq (%rax), %rdi
movq %r12, %rsi
callq 0x1a1c6
movq 0x20(%r12), %rax
movq %rax, 0x80(%rbx)
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq (%r14), %rax
movq %rax, 0xc(%rbx)
movq 0x48(%r12), %rdi
testq %r15, %r15
je 0x197dd
movzbl 0x52(%rsp), %eax
movl %eax, (%r15)
testq %rdi, %rdi
je 0x1980a
callq 0x23040
movq %rax, %r15
movq %rbx, %rdi
callq 0x2386c
movq 0x4(%rbx), %rdi
leaq 0x2a7d6(%rip), %rsi     # 0x43fd3
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x118b4
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: apply_modifiers
static void apply_modifiers(struct position pos, struct decl_state *ctx)
{
	struct symbol *ctype;
	if (!ctx->mode)
		return;
	ctype = ctx->mode->to_mode(ctx->ctype.base_type);
	if (!ctype)
		sparse_error(pos, "don't know how to apply mode to %s",
				show_typename(ctx->ctype.base_type));
	else
		ctx->ctype.base_type = ctype;
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x1a1e7
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq *0x48(%rax)
testq %rax, %rax
je 0x1a1ef
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
callq 0x2386c
leaq 0x2c206(%rip), %rsi     # 0x46404
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a38
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: check_label_usage
void check_label_usage(struct symbol *label, struct position use_pos)
{
	struct statement *def = label->stmt;

	if (def) {
		if (!is_in_scope(def->label_scope, label_scope))
			warn_label_usage(def->pos, use_pos, label->ident);
	} else if (!label->label_scope) {
		label->label_scope = label_scope;
		label->label_pos = use_pos;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rdi), %r15
testq %r15, %r15
je 0x1a252
movq 0x18(%r15), %rdi
leaq 0x51264(%rip), %rax     # 0x6b498
movq (%rax), %rsi
callq 0x22fe4
testl %eax, %eax
jne 0x1a26b
movq 0x18(%r14), %rdx
movq 0x4(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a271
cmpq $0x0, 0x48(%r14)
jne 0x1a26b
leaq 0x51238(%rip), %rax     # 0x6b498
movq (%rax), %rax
movq %rax, 0x48(%r14)
movq %rbx, 0x50(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: warn_label_usage
static void warn_label_usage(struct position def, struct position use, struct ident *ident)
{
	const char *id = show_ident(ident);
	sparse_error(use, "label '%s' used outside statement expression", id);
	info(def, "   label '%s' defined here", id);
	current_fn->bogus_linear = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2e465
movq %rax, %r15
leaq 0x2c199(%rip), %rsi     # 0x46427
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
leaq 0x2c1b2(%rip), %rsi     # 0x46454
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11744
leaq 0x76cba(%rip), %rax     # 0x90f70
movq (%rax), %rax
orl $0x100, 0x54(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: compound_statement
struct token *compound_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_COMPOUND;
	start_block_scope();
	token = statement_list(token, &stmt->stmts);
	end_block_scope();
	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, (%rsi)
callq 0x22dc3
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a2fd
movq %rax, %rbx
callq 0x22ed4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/parse.c
// Function: handle_asm_name
static struct token *handle_asm_name(struct token *token, struct decl_state *ctx)
{
	struct expression *expr;
	struct symbol *keyword;

	if (token_type(token) != TOKEN_IDENT)
		return token;
	keyword = lookup_keyword(token->ident, NS_KEYWORD);
	if (!keyword)
		return token;
	if (!(keyword->op->type & KW_ASM))
		return token;

	token = token->next;
	token = expect(token, '(', "after asm");
	token = string_expression(token, &expr, "asm name");
	token = expect(token, ')', "after asm");
	return token;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x1afd8
movq 0x10(%rbx), %rdi
testb $0x4, 0x11(%rdi)
jne 0x1af81
xorl %eax, %eax
jmp 0x1af8b
movl $0x100, %esi            # imm = 0x100
callq 0x2b511
testq %rax, %rax
je 0x1afd8
movq 0x40(%rax), %rax
testb $0x20, (%rax)
je 0x1afd8
movq 0x8(%rbx), %rdi
leaq 0x29aa0(%rip), %rbx     # 0x44a44
movl $0x28, %esi
movq %rbx, %rdx
callq 0x195d7
leaq 0x2b58a(%rip), %rdx     # 0x46542
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x39940
movq %rax, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq 0x195d7
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq