LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x1ffbd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1bf90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1d630
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x20044
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x5, %eax
jne 0x20025
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x20023
movq -0x18(%rbp), %rax
cmpl $0x2b, 0x4(%rax)
jne 0x20021
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11ff0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ff60
movl %eax, -0x4(%rbp)
jmp 0x20044
jmp 0x20023
jmp 0x20025
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bb90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_bitfield_extract
static pseudo_t linearize_bitfield_extract(struct entrypoint *ep,
		pseudo_t val, struct symbol *ctype, struct symbol *btype)
{
	unsigned int off = ctype->bit_offset;

	if (off) {
		pseudo_t shift = value_pseudo(off);
		val = add_binary_op(ep, btype, OP_LSR, val, shift);
	}
	val = cast_pseudo(ep, val, btype, ctype);
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x200a9
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x1a390
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0xf, %edx
callq 0x1de90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1f5f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_access
static pseudo_t linearize_access(struct entrypoint *ep, struct expression *expr)
{
	struct access_data ad = { NULL, };
	pseudo_t value;

	if (!linearize_address_gen(ep, expr, &ad))
		return VOID;
	value = linearize_load_gen(ep, &ad);
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x11130
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x1fe10
cmpl $0x0, %eax
jne 0x20113
leaq 0x6bca3(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x2012c
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1fec0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x11130
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movl $0xa, %eax
movl $0x8, %ecx
cmpl $0x101, %edx            # imm = 0x101
cmovel %ecx, %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1fe10
cmpl $0x0, %eax
jne 0x201ad
leaq 0x6bc0c(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x202c5
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fec0
movq %rax, -0x48(%rbp)
movl -0x5c(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1fcc0
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1f2b0
cmpl $0x0, %eax
je 0x20221
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rax), %rax
movq %rax, -0x68(%rbp)
testq %rax, %rax
sets %al
movzbl %al, %eax
movl %eax, %ecx
fildll -0x68(%rbp)
leaq 0x432b4(%rip), %rax     # 0x634c0
flds (%rax,%rcx,4)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0x1c1c0
movq %rax, -0x58(%rbp)
jmp 0x20232
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1a390
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x20255
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1f5f0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x5c(%rbp), %edx
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %r8
callq 0x1de90
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x20294
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x1f5f0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1d790
cmpl $0x0, -0x1c(%rbp)
je 0x202b5
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x202bd
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_regular_preop
static pseudo_t linearize_regular_preop(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t pre = linearize_expression(ep, expr->unop);
	struct symbol *ctype = expr->ctype;
	switch (expr->op) {
	case '+':
		return pre;
	case '!': {
		pseudo_t zero = value_pseudo(0);
		return add_cmp_op(ep, ctype, OP_SET_EQ, expr->unop->ctype, pre, zero);
	}
	case '~':
		return add_unop(ep, ctype, OP_NOT, pre);
	case '-':
		return add_unop(ep, ctype, opcode_float(OP_NEG, ctype), pre);
	}
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1bb90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x21, %eax
je 0x20350
jmp 0x20322
movl -0x34(%rbp), %eax
subl $0x2b, %eax
je 0x20343
jmp 0x2032c
movl -0x34(%rbp), %eax
subl $0x2d, %eax
je 0x203a5
jmp 0x20336
movl -0x34(%rbp), %eax
subl $0x7e, %eax
je 0x20389
jmp 0x203dc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x203e7
xorl %eax, %eax
movl %eax, %edi
callq 0x1a390
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x27, %edx
callq 0x1f390
movq %rax, -0x8(%rbp)
jmp 0x203e7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x31, %edx
callq 0x1df40
movq %rax, -0x8(%rbp)
jmp 0x203e7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movl $0x32, %edi
callq 0x1fcc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movq -0x20(%rbp), %rcx
callq 0x1df40
movq %rax, -0x8(%rbp)
jmp 0x203e7
leaq 0x6b9cd(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: argument_pseudo
static pseudo_t argument_pseudo(struct entrypoint *ep, int nr)
{
	pseudo_t pseudo = __alloc_pseudo(0);
	struct instruction *entry = ep->entry;

	pseudo->type = PSEUDO_ARG;
	pseudo->nr = nr;
	pseudo->def = entry;
	add_pseudo(&entry->arg_list, pseudo);

	/* Argument pseudos have neither usage nor def */
	return pseudo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x475b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a4b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: check_tainted_insn
static void check_tainted_insn(struct instruction *insn)
{
	unsigned long long uval;
	long long sval;
	pseudo_t src2;

	switch (insn->opcode) {
	case OP_DIVU: case OP_DIVS:
	case OP_MODU: case OP_MODS:
		if (insn->src2 == value_pseudo(0))
			warning(insn->pos, "divide by zero");
		break;
	case OP_SHL: case OP_LSR: case OP_ASR:
		src2 = insn->src2;
		if (src2->type != PSEUDO_VAL)
			break;
		uval = src2->value;
		if (uval < insn->size)
			break;
		sval = sign_extend(uval, insn->size);
		if (Wshift_count_negative && sval < 0)
			warning(insn->pos, "shift count is negative (%lld)", sval);
		else if (Wshift_count_overflow)
			warning(insn->pos, "shift too big (%llu) for type %s", uval, show_typename(insn->type));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x24(%rbp)
addl $-0xb, %eax
subl $0x4, %eax
jb 0x204a2
jmp 0x20492
movl -0x24(%rbp), %eax
addl $-0xf, %eax
subl $0x3, %eax
jb 0x204de
jmp 0x205ad
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1a390
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x204d9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x435db(%rip), %rsi     # 0x63aad
movb $0x0, %al
callq 0x16d80
jmp 0x205ad
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, 0x4(%rax)
je 0x204f9
jmp 0x205ad
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x2051e
jmp 0x205ad
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
shrl $0x8, %esi
callq 0x205c0
movq %rax, -0x18(%rbp)
leaq 0x6431d(%rip), %rax     # 0x84858
cmpl $0x0, (%rax)
je 0x20563
cmpq $0x0, -0x18(%rbp)
jge 0x20563
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x10(%rax), %rdi
leaq 0x43562(%rip), %rsi     # 0x63abc
movb $0x0, %al
callq 0x16d80
jmp 0x205ab
leaq 0x642f2(%rip), %rax     # 0x8485c
cmpl $0x0, (%rax)
je 0x205a9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33340
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x43539(%rip), %rsi     # 0x63adb
movb $0x0, %al
callq 0x16d80
jmp 0x205ab
jmp 0x205ad
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, %edi
leaq 0x7129c(%rip), %rsi     # 0x91b18
callq 0x1a240
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x209b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1bb90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movl $0x30, %edi
callq 0x1a390
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x1a340
movq -0x18(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5b0
movl $0x2d, %edi
leaq 0x71216(%rip), %rsi     # 0x91b18
callq 0x1a240
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movl $0x9, %edi
callq 0x1a390
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x1a340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x711c4(%rip), %rcx     # 0x91b18
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5b0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/optimize.c
// Function: clean_up_insns
static void clean_up_insns(struct entrypoint *ep)
{
	struct basic_block *bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		struct instruction *insn;
		FOR_EACH_PTR(bb->insns, insn) {
			if (!insn->bb)
				continue;
			repeat_phase |= simplify_instruction(insn);
			if (!insn->bb)
				continue;
			assert(insn->bb == bb);
			cse_collect(insn);
		} END_FOR_EACH_PTR(insn);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x20c44
jmp 0x20dc8
jmp 0x20c46
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x20db0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x20c98
cmpq $0x0, -0x10(%rbp)
jne 0x20c98
jmp 0x20da2
jmp 0x20c9a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x20cc2
jmp 0x20da0
jmp 0x20cc4
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x20d88
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x20d13
cmpq $0x0, -0x38(%rbp)
jne 0x20d13
jmp 0x20d7a
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x20d20
jmp 0x20d7a
movq -0x38(%rbp), %rdi
callq 0x35810
orl 0x6c425(%rip), %eax     # 0x8d154
movl %eax, 0x6c41f(%rip)     # 0x8d154
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x20d42
jmp 0x20d7a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x20d52
jmp 0x20d71
leaq 0x43087(%rip), %rdi     # 0x63de0
leaq 0x4308f(%rip), %rsi     # 0x63def
movl $0x2d, %edx
leaq 0x4308e(%rip), %rcx     # 0x63dfa
callq 0x11120
movq -0x38(%rbp), %rdi
callq 0x49520
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x20ccb
jmp 0x20d8a
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x20cc4
jmp 0x20da2
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x20c4d
jmp 0x20db2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x20c46
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/optimize.c
// Function: clear_symbol_pseudos
static void clear_symbol_pseudos(struct entrypoint *ep)
{
	pseudo_t pseudo;

	FOR_EACH_PTR(ep->accesses, pseudo) {
		pseudo->sym->pseudo = NULL;
	} END_FOR_EACH_PTR(pseudo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x20e2d
jmp 0x20eac
jmp 0x20e2f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x20e98
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x20e7a
cmpq $0x0, -0x10(%rbp)
jne 0x20e7a
jmp 0x20e8d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0xd8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x20e36
jmp 0x20e9a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x20e2f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_D
static char **handle_switch_D(char *arg, char **next)
{
	const char *name = arg + 1;
	const char *value = "1";

	if (!*name) {
		arg = *++next;
		if (!arg)
			die("argument to `-D' is missing");
		name = arg;
	}

	for (;;arg++) {
		char c;
		c = *arg;
		if (!c)
			break;
		if (c == '=') {
			*arg = '\0';
			value = arg + 1;
			break;
		}
	}
	add_pre_buffer("#define %s %s\n", name, value);
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
leaq 0x4be44(%rip), %rax     # 0x6cf77
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x21174
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2116c
leaq 0x42e6a(%rip), %rdi     # 0x63fcf
movb $0x0, %al
callq 0x17190
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x21176
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
cmpb $0x0, -0x21(%rbp)
jne 0x21187
jmp 0x211b5
movsbl -0x21(%rbp), %eax
cmpl $0x3d, %eax
jne 0x211a5
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x211b5
jmp 0x211a7
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x21176
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x42e27(%rip), %rdi     # 0x63feb
movb $0x0, %al
callq 0x17260
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_d
static char **handle_switch_d(char *arg, char **next)
{
	char *arg_char = arg + 1;

	/*
	 * -d<CHARS>, where <CHARS> is a sequence of characters, not preceded
	 * by a space. If you specify characters whose behaviour conflicts,
	 * the result is undefined.
	 */
	while (*arg_char) {
		switch (*arg_char) {
		case 'M': /* dump just the macro definitions */
			dump_macros_only = 1;
			dump_macro_defs = 0;
			break;
		case 'D': /* like 'M', but also output pre-processed text */
			dump_macro_defs = 1;
			dump_macros_only = 0;
			break;
		case 'N': /* like 'D', but only output macro names not bodies */
			break;
		case 'I': /* like 'D', but also output #include directives */
			break;
		case 'U': /* like 'D', but only output expanded macros */
			break;
		}
		arg_char++;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2126a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x44, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x11, %eax
ja 0x2125c
movq -0x20(%rbp), %rax
leaq 0x42d33(%rip), %rcx     # 0x63f54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x6bf6c(%rip)     # 0x8d1a0
movl $0x0, 0x6bf5e(%rip)     # 0x8d19c
jmp 0x2125c
movl $0x1, 0x6bf52(%rip)     # 0x8d19c
movl $0x0, 0x6bf4c(%rip)     # 0x8d1a0
jmp 0x2125c
jmp 0x2125c
jmp 0x2125c
jmp 0x2125c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x211f8
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_I
static char **handle_switch_I(char *arg, char **next)
{
	char *path = arg+1;

	switch (arg[1]) {
	case '-':
		add_pre_buffer("#split_include\n");
		break;

	case '\0':	/* Plain "-I" */
		path = *++next;
		if (!path)
			die("missing argument for -I option");
		/* Fall through */
	default:
		add_pre_buffer("#add_include \"%s/\"\n", path);
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
incq %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x213d6
jmp 0x213bc
movl -0x1c(%rbp), %eax
subl $0x2d, %eax
jne 0x21404
jmp 0x213c6
leaq 0x42dc5(%rip), %rdi     # 0x64192
movb $0x0, %al
callq 0x17260
jmp 0x21416
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21402
leaq 0x42da7(%rip), %rdi     # 0x641a2
movb $0x0, %al
callq 0x17190
jmp 0x21404
movq -0x18(%rbp), %rsi
leaq 0x42db2(%rip), %rdi     # 0x641c1
movb $0x0, %al
callq 0x17260
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_i
static char **handle_switch_i(char *arg, char **next)
{
	if (*next && !strcmp(arg, "include"))
		add_cmdline_include(*++next);
	else if (*next && !strcmp(arg, "imacros"))
		add_cmdline_include(*++next);
	else if (*next && !strcmp(arg, "isystem")) {
		char *path = *++next;
		if (!path)
			die("missing argument for -isystem option");
		add_pre_buffer("#add_isystem \"%s/\"\n", path);
	} else if (*next && !strcmp(arg, "idirafter")) {
		char *path = *++next;
		if (!path)
			die("missing argument for -idirafter option");
		add_pre_buffer("#add_dirafter \"%s/\"\n", path);
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2146c
movq -0x8(%rbp), %rdi
leaq 0x4637f(%rip), %rsi     # 0x677c4
callq 0x111b0
cmpl $0x0, %eax
jne 0x2146c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x22740
jmp 0x2156a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x214a8
movq -0x8(%rbp), %rdi
leaq 0x42d54(%rip), %rsi     # 0x641d5
callq 0x111b0
cmpl $0x0, %eax
jne 0x214a8
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x22740
jmp 0x21568
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21507
movq -0x8(%rbp), %rdi
leaq 0x46432(%rip), %rsi     # 0x678ef
callq 0x111b0
cmpl $0x0, %eax
jne 0x21507
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x214f3
leaq 0x42cf1(%rip), %rdi     # 0x641dd
movb $0x0, %al
callq 0x17190
movq -0x18(%rbp), %rsi
leaq 0x42d04(%rip), %rdi     # 0x64202
movb $0x0, %al
callq 0x17260
jmp 0x21566
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21564
movq -0x8(%rbp), %rdi
leaq 0x42cfa(%rip), %rsi     # 0x64216
callq 0x111b0
cmpl $0x0, %eax
jne 0x21564
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x21552
leaq 0x42cd5(%rip), %rdi     # 0x64220
movb $0x0, %al
callq 0x17190
movq -0x20(%rbp), %rsi
leaq 0x42cea(%rip), %rdi     # 0x64247
movb $0x0, %al
callq 0x17260
jmp 0x21566
jmp 0x21568
jmp 0x2156a
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_M
static char **handle_switch_M(char *arg, char **next)
{
	if (!strcmp(arg, "MF") || !strcmp(arg,"MQ") || !strcmp(arg,"MT")) {
		if (!*next)
			die("missing argument for -%s option", arg);
		return next + 1;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x42ce0(%rip), %rsi     # 0x6427b
callq 0x111b0
cmpl $0x0, %eax
je 0x215cf
movq -0x10(%rbp), %rdi
leaq 0x42cce(%rip), %rsi     # 0x6427e
callq 0x111b0
cmpl $0x0, %eax
je 0x215cf
movq -0x10(%rbp), %rdi
leaq 0x42cbc(%rip), %rsi     # 0x64281
callq 0x111b0
cmpl $0x0, %eax
jne 0x215f9
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x215eb
movq -0x10(%rbp), %rsi
leaq 0x42ca0(%rip), %rdi     # 0x64284
movb $0x0, %al
callq 0x17190
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x21601
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_m
static char **handle_switch_m(char *arg, char **next)
{
	if (!strcmp(arg, "meabi") && next[1] && next[1][0] != '-') {
		// clang has such an option with syntax: -meabi <arg>
		// It's used by the kernel for armv7.
		// GCC has the same option but with no argument.
		// Parse it here to consume the possible argument.
		static const char *valid[] = { "gnu", "4", "5", "default", NULL };
		int i;
		for (i = 0; valid[i]; i++) {
			if (!strcmp(next[1], valid[i]))
				return ++next;
		}
	}

	if (!strcmp(arg, "multiarch-dir")) {
		return handle_multiarch_dir(arg, next);
	} else {
		handle_switches(arg-1, arg+1, mflags);
	}

	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x42c79(%rip), %rsi     # 0x642a4
callq 0x111b0
cmpl $0x0, %eax
jne 0x216ab
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x216ab
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x216ab
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x6357e(%rip), %rax     # 0x84be0
cmpq $0x0, (%rax,%rcx,8)
je 0x216a9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x63564(%rip), %rax     # 0x84be0
movq (%rax,%rcx,8), %rsi
callq 0x111b0
cmpl $0x0, %eax
jne 0x2169c
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x8(%rbp)
jmp 0x216f7
jmp 0x2169e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21657
jmp 0x216ab
movq -0x10(%rbp), %rdi
leaq 0x42bfa(%rip), %rsi     # 0x642b0
callq 0x111b0
cmpl $0x0, %eax
jne 0x216d3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22790
movq %rax, -0x8(%rbp)
jmp 0x216f7
movq -0x10(%rbp), %rdi
addq $-0x1, %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
leaq 0x5b7a6(%rip), %rdx     # 0x7ce90
callq 0x21e50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_o
static char **handle_switch_o(char *arg, char **next)
{
	if (!strcmp(arg, "o")) {	// "-o foo"
		if (!*++next)
			die("argument to '-o' is missing");
		outfile = *next;
	}
	// else "-ofoo"

	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x48a28(%rip), %rsi     # 0x6a1a3
callq 0x111b0
cmpl $0x0, %eax
jne 0x217b7
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x217a9
leaq 0x42c3d(%rip), %rdi     # 0x643df
movb $0x0, %al
callq 0x17190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x6b9b9(%rip)     # 0x8d170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_O
static char **handle_switch_O(char *arg, char **next)
{
	int level = 1;
	if (arg[1] >= '0' && arg[1] <= '9')
		level = arg[1] - '0';
	optimize_level = level;
	optimize_size = arg[1] == 's';
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x2180b
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x2180b
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, 0x6ba20(%rip)     # 0x8d234
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x6ba0b(%rip)     # 0x8d238
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_U
static char **handle_switch_U(char *arg, char **next)
{
	const char *name = arg + 1;

	if (*name == '\0') {
		name = *++next;
		if (!name)
			die("argument to `-U' is missing");
	}
	add_pre_buffer("#undef %s\n", name);
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21b56
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21b54
leaq 0x4296f(%rip), %rdi     # 0x644bc
movb $0x0, %al
callq 0x17190
jmp 0x21b56
movq -0x18(%rbp), %rsi
leaq 0x42977(%rip), %rdi     # 0x644d8
movb $0x0, %al
callq 0x17260
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_v
static char **handle_switch_v(char *arg, char **next)
{
	char ** ret = handle_onoff_switch(arg, next, debugs);
	if (ret)
		return ret;

	// Unknown.
	do {
		verbose++;
	} while (*++arg == 'v');
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x63071(%rip), %rdx     # 0x84c10
callq 0x229c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21bb9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21bea
jmp 0x21bbb
movl 0x6b683(%rip), %eax     # 0x8d244
addl $0x1, %eax
movl %eax, 0x6b67a(%rip)     # 0x8d244
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x76, %eax
je 0x21bbb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_W
static char **handle_switch_W(char *arg, char **next)
{
	char ** ret = handle_onoff_switch(arg, next, warnings);
	if (ret)
		return ret;

	if (!strcmp(arg, "Wsparse-all")) {
		int i;
		for (i = 0; warnings[i].name; i++) {
			if (*warnings[i].flag != FLAG_FORCE_OFF)
				*warnings[i].flag = FLAG_ON;
		}
	}

	// Unknown.
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x5b5e1(%rip), %rdx     # 0x7d200
callq 0x229c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21c3c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21cbe
movq -0x10(%rbp), %rdi
leaq 0x428b7(%rip), %rsi     # 0x644fe
callq 0x111b0
cmpl $0x0, %eax
jne 0x21cb6
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x5b59d(%rip), %rax     # 0x7d200
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x21cb4
movslq -0x24(%rbp), %rcx
leaq 0x5b585(%rip), %rax     # 0x7d200
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
je 0x21ca7
movslq -0x24(%rbp), %rcx
leaq 0x5b56a(%rip), %rax     # 0x7d200
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl $0x1, (%rax)
jmp 0x21ca9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21c58
jmp 0x21cb6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_long_options
static char **handle_long_options(char *arg, char **next)
{
	static struct switches cmd[] = {
		{ "arch", handle_arch, 1 },
		{ "os",   handle_os, 1 },
		{ "param", handle_param, 1 },
		{ "version", handle_version },
		{ NULL, NULL }
	};
	struct switches *s = cmd;

	while (s->name) {
		int optlen = strlen(s->name);
		if (!strncmp(s->name, arg, optlen + !s->prefix))
			return s->fn(arg + optlen, next);
		s++;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x63009(%rip), %rax     # 0x84d30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21daa
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x110c0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movslq %eax, %rdx
callq 0x11080
cmpl $0x0, %eax
jne 0x21d9c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rcx
addq %rcx, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x21db2
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x21d2b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_switch_W_finalize
static void handle_switch_W_finalize(void)
{
	handle_onoff_switch_finalize(warnings);

	/* default Wdeclarationafterstatement based on the C dialect */
	if (-1 == Wdeclarationafterstatement) {
		switch (standard) {
			case STANDARD_C89:
			case STANDARD_C94:
				Wdeclarationafterstatement = 1;
				break;
			default:
				Wdeclarationafterstatement = 0;
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5b401(%rip), %rdi     # 0x7d200
callq 0x22c50
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x62a0d(%rip), %eax     # 0x8481c
jne 0x21e43
movl 0x629c1(%rip), %eax     # 0x847d8
movl %eax, -0x4(%rbp)
subl $0x2, %eax
je 0x21e2b
jmp 0x21e21
movl -0x4(%rbp), %eax
subl $0x4, %eax
jne 0x21e37
jmp 0x21e2b
movl $0x1, 0x629e7(%rip)     # 0x8481c
jmp 0x21e41
movl $0x0, 0x629db(%rip)     # 0x8481c
jmp 0x21e43
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x4217c(%rip), %rsi     # 0x63ffa
movl $0x3, %edx
callq 0x11080
cmpl $0x0, %eax
jne 0x21ea0
movq -0x28(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x21ea2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21f9e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x21fb0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x21ed0
jmp 0x21f8d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21f1f
movl $0x0, -0x40(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x21ef1
movl -0x40(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x40(%rbp), %ecx
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x21f1d
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21fa5
jmp 0x21f1f
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21f8b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x21f8b
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x21f52
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x21f75
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x21fa5
jmp 0x21f8d
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
jmp 0x21ea2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: match_option
static const char *match_option(const char *arg, const char *prefix)
{
	unsigned int n = strlen(prefix);
	if (strncmp(arg, prefix, n) == 0)
		return arg + n;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x110c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x11080
cmpl $0x0, %eax
jne 0x21ff3
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x21ffb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_fdiagnostic_prefix
static int handle_fdiagnostic_prefix(const char *arg, const char *opt, const struct flag *flag, int options)
{
	switch (*opt) {
	case '\0':
		diag_prefix = "sparse: ";
		return 1;
	case '=':
		diag_prefix = xasprintf("%s: ", opt+1);
		return 1;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x22041
jmp 0x22037
movl -0x28(%rbp), %eax
subl $0x3d, %eax
je 0x22058
jmp 0x2207e
leaq 0x42079(%rip), %rax     # 0x640c1
movq %rax, 0x62771(%rip)     # 0x847c0
movl $0x1, -0x4(%rbp)
jmp 0x22085
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
leaq 0x42063(%rip), %rdi     # 0x640ca
movb $0x0, %al
callq 0x46400
movq %rax, 0x6274b(%rip)     # 0x847c0
movl $0x1, -0x4(%rbp)
jmp 0x22085
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22140
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x22122
movq -0x30(%rbp), %rax
xorq $-0x1, %rax
andq 0x626e7(%rip), %rax     # 0x84800
movq %rax, 0x626e0(%rip)     # 0x84800
jmp 0x22134
movq -0x30(%rbp), %rax
orq 0x626d3(%rip), %rax     # 0x84800
movq %rax, 0x626cc(%rip)     # 0x84800
movl $0x1, -0x4(%rbp)
jmp 0x22202
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x22157
movl $0x0, -0x4(%rbp)
jmp 0x22202
movq -0x18(%rbp), %rdi
leaq 0x41f9a(%rip), %rsi     # 0x640fc
callq 0x111b0
cmpl $0x0, %eax
jne 0x22187
movq -0x30(%rbp), %rax
orq 0x62689(%rip), %rax     # 0x84800
movq %rax, 0x62682(%rip)     # 0x84800
movl $0x1, -0x4(%rbp)
jmp 0x22202
movq -0x18(%rbp), %rdi
leaq 0x41f72(%rip), %rsi     # 0x64104
callq 0x111b0
cmpl $0x0, %eax
jne 0x221bb
movq -0x30(%rbp), %rax
xorq $-0x1, %rax
andq 0x62655(%rip), %rax     # 0x84800
movq %rax, 0x6264e(%rip)     # 0x84800
movl $0x1, -0x4(%rbp)
jmp 0x22202
movq -0x18(%rbp), %rdi
leaq 0x41f47(%rip), %rsi     # 0x6410d
callq 0x111b0
cmpl $0x0, %eax
jne 0x221fb
movq -0x30(%rbp), %rax
subq $0x1, %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq 0x62615(%rip), %rax     # 0x84800
movq %rax, 0x6260e(%rip)     # 0x84800
movl $0x1, -0x4(%rbp)
jmp 0x22202
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22305
movq -0x8(%rbp), %rsi
leaq 0x41e3d(%rip), %rdi     # 0x6413b
movb $0x0, %al
callq 0x17190
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x112a0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22348
movl $0x1, %eax
cmpq -0x28(%rbp), %rax
ja 0x22348
cmpq $0x64, -0x28(%rbp)
ja 0x22348
movq -0x28(%rbp), %rax
movl %eax, %ecx
leaq 0x6862a(%rip), %rax     # 0x8a970
movl %ecx, (%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_suboption_mask
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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x223da
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0x40466(%rip), %rsi     # 0x62829
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x224d0
movl $0x1, -0x4(%rbp)
jmp 0x224c4
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x223fd
movl $0x0, -0x4(%rbp)
jmp 0x224c4
jmp 0x223ff
movq -0x18(%rbp), %rdi
leaq 0x41ccb(%rip), %rsi     # 0x640d5
callq 0x11160
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x22421
jmp 0x2248f
movq -0x18(%rbp), %rdi
leaq 0x41bce(%rip), %rsi     # 0x63ffa
movl $0x3, %edx
callq 0x11080
cmpl $0x0, %eax
jne 0x22457
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x30(%rbp), %r8d
callq 0x224d0
cmpl $0x0, %eax
je 0x2248d
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x41c52(%rip), %rdi     # 0x640d8
movb $0x0, %al
callq 0x17190
jmp 0x2248f
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x224b8
jmp 0x224bd
jmp 0x223ff
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x22569
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x11080
cmpl $0x0, %eax
jne 0x22559
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x22559
cmpl $0x0, -0x2c(%rbp)
jne 0x2253a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x22550
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
xorq $-0x1, %rcx
movq -0x10(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x22570
jmp 0x2255b
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x224eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/options.c
// Function: handle_base_dir
static char **handle_base_dir(char *arg, char **next)
{
	gcc_base_dir = *++next;
	if (!gcc_base_dir)
		die("missing argument for -gcc-base-dir option");
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, 0x620ae(%rip)     # 0x847c8
cmpq $0x0, 0x620a6(%rip)     # 0x847c8
jne 0x22732
leaq 0x41a3d(%rip), %rdi     # 0x64168
movb $0x0, %al
callq 0x17190
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)