LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: rewrite_local_var
static void rewrite_local_var(struct basic_block *bb, pseudo_t addr, int nbr_stores, int nbr_uses)
{
	struct instruction *store = NULL;
	struct instruction *insn;
	bool remove = false;

	if (!bb)
		return;

	FOR_EACH_PTR(bb->insns, insn) {

		if (!insn->bb || insn->src != addr)
			continue;
		switch (insn->opcode) {
		case OP_LOAD:
			if (!store)
				replace_with_pseudo(insn, undef_pseudo());
			else if (same_memop(store, insn))
				replace_with_pseudo(insn, store->target);
			else
				remove = false;
			break;
		case OP_STORE:
			store = insn;
			remove = true;
			break;
		}
	} END_FOR_EACH_PTR(insn);
	if (remove)
		kill_store(store);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3e82e
jmp 0x3e977
jmp 0x3e830
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3e858
jmp 0x3e968
jmp 0x3e85a
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x3e950
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x3e8ac
cmpq $0x0, -0x28(%rbp)
jne 0x3e8ac
jmp 0x3e942
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3e8c5
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x3e8c7
jmp 0x3e942
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x50(%rbp)
subl $0x43, %eax
je 0x3e8e4
jmp 0x3e8da
movl -0x50(%rbp), %eax
subl $0x44, %eax
je 0x3e934
jmp 0x3e940
cmpq $0x0, -0x20(%rbp)
jne 0x3e906
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1a4f0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x357e0
jmp 0x3e932
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3eb00
testb $0x1, %al
jne 0x3e919
jmp 0x3e92c
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x357e0
jmp 0x3e930
movb $0x0, -0x29(%rbp)
jmp 0x3e932
jmp 0x3e940
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x29(%rbp)
jmp 0x3e942
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3e861
jmp 0x3e952
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x3e85a
testb $0x1, -0x29(%rbp)
je 0x3e977
movq -0x20(%rbp), %rdi
callq 0x3ebb0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: same_memop
static bool same_memop(struct instruction *a, struct instruction *b)
{
	if (a->size != b->size || a->offset != b->offset)
		return false;
	if (is_integral_type(a->type) && is_float_type(b->type))
		return false;
	if (is_float_type(a->type) && is_integral_type(b->type))
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
cmpl %ecx, %eax
jne 0x3eb38
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
je 0x3eb3e
movb $0x0, -0x1(%rbp)
jmp 0x3eb98
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ea80
testb $0x1, %al
jne 0x3eb51
jmp 0x3eb69
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ebf0
cmpl $0x0, %eax
je 0x3eb69
movb $0x0, -0x1(%rbp)
jmp 0x3eb98
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ebf0
cmpl $0x0, %eax
je 0x3eb94
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ea80
testb $0x1, %al
jne 0x3eb8e
jmp 0x3eb94
movb $0x0, -0x1(%rbp)
jmp 0x3eb98
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: lookup_var
static struct instruction *lookup_var(struct basic_block *bb, struct symbol *var)
{
	do {
		struct instruction *insn = phi_map_lookup(bb->phi_map, var);
		if (insn)
			return insn;
	} while ((bb = bb->idom));
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ef20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ee76
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ee92
jmp 0x3ee78
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3ee50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: matching_load
static bool matching_load(struct instruction *def, struct instruction *insn)
{
	if (insn->size != def->size)
		return false;
	switch (def->opcode) {
	case OP_STORE:
	case OP_LOAD:
		if (insn->offset != def->offset)
			return false;
	case OP_PHI:
		break;
	default:
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
cmpl %ecx, %eax
je 0x3eec8
movb $0x0, -0x1(%rbp)
jmp 0x3ef0e
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x1c(%rbp)
addl $-0x43, %eax
subl $0x2, %eax
jb 0x3eee8
jmp 0x3eede
movl -0x1c(%rbp), %eax
subl $0x46, %eax
je 0x3ef02
jmp 0x3ef04
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
je 0x3ef00
movb $0x0, -0x1(%rbp)
jmp 0x3ef0e
jmp 0x3ef02
jmp 0x3ef0a
movb $0x0, -0x1(%rbp)
jmp 0x3ef0e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: ssa_rename_phi
static void ssa_rename_phi(struct instruction *insn)
{
	struct basic_block *par;
	struct symbol *var;

	if (!insn->phi_var)
		return;
	var = insn->phi_var->sym;
	if (!var->torename)
		return;
	FOR_EACH_PTR(insn->bb->parents, par) {
		struct instruction *def = lookup_var(par, var);
		pseudo_t val = def ? def->target : undef_pseudo();
		struct instruction *phisrc = alloc_phisrc(val, var);
		pseudo_t phi = phisrc->target;
		phi->ident = var->ident;
		insert_last_instruction(par, phisrc);
		link_phi(insn, phi);
		mark_phi_used(val);
	} END_FOR_EACH_PTR(par);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3ef9c
jmp 0x3f0f2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x14, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3efc3
jmp 0x3f0f2
jmp 0x3efc5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3eff1
jmp 0x3f0f2
jmp 0x3eff3
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x3f0da
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x3f045
cmpq $0x0, -0x10(%rbp)
jne 0x3f045
jmp 0x3f0cc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ee40
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3f06b
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x3f074
callq 0x1a4f0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a520
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3f120
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3f180
movq -0x48(%rbp), %rdi
callq 0x3f1e0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3effa
jmp 0x3f0dc
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x3eff3
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ssa.c
// Function: mark_phi_used
static void mark_phi_used(pseudo_t val)
{
	struct instruction *node;

	if (val->type != PSEUDO_REG)
		return;
	node = val->def;
	if (node->opcode != OP_PHI)
		return;
	if (node->used)
		return;
	node->used = 1;
	add_instruction(&phis_used, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x4(%rax)
je 0x3f1f8
jmp 0x3f247
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
je 0x3f214
jmp 0x3f247
movq -0x10(%rbp), %rax
movb 0x40(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3f227
jmp 0x3f247
movq -0x10(%rbp), %rax
movb 0x40(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x40(%rax)
movq -0x10(%rbp), %rsi
leaq 0x51b8e(%rip), %rdi     # 0x90dd0
callq 0x3ee10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: access_symbol
void access_symbol(struct symbol *sym)
{
	if (sym->ctype.modifiers & MOD_INLINE) {
		if (!sym->accessed) {
			add_symbol(&translation_unit_used_list, sym);
			sym->accessed = 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x3f448
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x12, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3f446
movq -0x8(%rbp), %rsi
leaq 0x519b5(%rip), %rdi     # 0x90de0
callq 0x3f3c0
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xfffbffff, %ecx       # imm = 0xFFFBFFFF
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x54(%rax)
jmp 0x3f448
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: lookup_symbol
struct symbol *lookup_symbol(struct ident *ident, enum namespace ns)
{
	struct symbol *sym;

	for (sym = ident->symbols; sym; sym = sym->next_id) {
		if (sym->namespace & ns) {
			sym->used = 1;
			return sym;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f4b2
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x3f4a2
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xfffdffff, %ecx       # imm = 0xFFFDFFFF
orl $0x20000, %ecx          # imm = 0x20000
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f4ba
jmp 0x3f4a4
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f467
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: alloc_symbol
struct symbol *alloc_symbol(struct position pos, int type)
{
	struct symbol *sym = __alloc_symbol(0);
	sym->type = type;
	sym->pos = pos;
	sym->endpos.type = 0;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x46b60
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0xc(%rax), %rcx
andq $-0x40, %rcx
orq $0x0, %rcx
movq %rcx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: merge_type
void merge_type(struct symbol *sym, struct symbol *base_type)
{
	combine_address_space(sym->pos, &sym->ctype.as, base_type->ctype.as);
	sym->ctype.modifiers |= (base_type->ctype.modifiers & ~MOD_STORAGE);
	concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
	                (struct ptr_list **)&sym->ctype.contexts);
	sym->ctype.base_type = base_type->ctype.base_type;
	if (sym->ctype.base_type->type == SYM_NODE)
		merge_type(sym, sym->ctype.base_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
addq $0x48, %rsi
addq $0x18, %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rdx
movq 0x4(%rax), %rdi
callq 0x3f5e0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
andq $-0x60, %rcx
movq -0x8(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x48, %rsi
addq $0x18, %rsi
addq $0x18, %rsi
callq 0x31a70
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x3f5d2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x3f530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_node_type
static struct symbol * examine_node_type(struct symbol *sym)
{
	struct symbol *base_type = examine_base_type(sym);
	int bit_size;
	unsigned long alignment;

	/* SYM_NODE - figure out what the type of the node was.. */
	bit_size = 0;
	alignment = 0;
	if (!base_type)
		return sym;

	bit_size = base_type->bit_size;
	alignment = base_type->ctype.alignment;

	/* Pick up signedness information into the node */
	sym->ctype.modifiers |= (MOD_SIGNEDNESS & base_type->ctype.modifiers);

	if (!sym->ctype.alignment)
		sym->ctype.alignment = alignment;

	/* Unsized array? The size might come from the initializer.. */
	if (bit_size < 0 && base_type->type == SYM_ARRAY) {
		struct expression *initializer = get_symbol_initializer(sym);
		if (initializer) {
			struct symbol *node_type = base_type->ctype.base_type;
			int count = count_array_initializer(node_type, initializer);

			if (node_type && node_type->bit_size >= 0)
				bit_size = implicit_array_size(sym, count);
		}
	}
	
	sym->bit_size = bit_size;
	sym->rank = base_type->rank;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40070
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f87c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f965
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
andq $0xe000, %rcx           # imm = 0xE000
movq -0x10(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3f8c4
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
cmpl $0x0, -0x1c(%rbp)
jge 0x3f92e
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x6, %eax
jne 0x3f92e
movq -0x10(%rbp), %rdi
callq 0x41210
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f92c
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x41260
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3f92a
movq -0x38(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jl 0x3f92a
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x41570
movl %eax, -0x1c(%rbp)
jmp 0x3f92c
jmp 0x3f92e
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rax
movl 0x54(%rax), %edx
shll $0x6, %edx
sarl $0x1d, %edx
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0x7, %edx
shll $0x17, %edx
andl $0xfc7fffff, %ecx       # imm = 0xFC7FFFFF
orl %edx, %ecx
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_array_type
static struct symbol * examine_array_type(struct symbol *sym)
{
	struct symbol *base_type = examine_base_type(sym);
	unsigned long bit_size = -1, alignment;
	struct expression *array_size = sym->array_size;

	if (!base_type)
		return sym;

	if (array_size) {	
		bit_size = array_element_offset(base_type->bit_size,
						get_expression_value_silent(array_size));
		if (array_size->type != EXPR_VALUE) {
			if (Wvla)
				warning(array_size->pos, "Variable length array is used.");
			bit_size = -1;
		}
	}
	if (has_flexible_array(base_type) && Wflexible_array_array)
		warning(sym->pos, "array of flexible structures");
	alignment = base_type->ctype.alignment;
	if (!sym->ctype.alignment)
		sym->ctype.alignment = alignment;
	sym->bit_size = bit_size;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40070
movq %rax, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f9b1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3fa80
cmpq $0x0, -0x30(%rbp)
je 0x3fa18
movq -0x18(%rbp), %rax
movslq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x12190
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x41770
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x3fa16
leaq 0x44e79(%rip), %rax     # 0x8486c
cmpl $0x0, (%rax)
je 0x3fa0e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x29b12(%rip), %rsi     # 0x69519
movb $0x0, %al
callq 0x16d80
movq $-0x1, -0x20(%rbp)
jmp 0x3fa18
movq -0x18(%rbp), %rdi
callq 0x417c0
cmpl $0x0, %eax
je 0x3fa48
leaq 0x44dff(%rip), %rax     # 0x8482c
cmpl $0x0, (%rax)
je 0x3fa48
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x29af7(%rip), %rsi     # 0x69538
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3fa6b
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_pointer_type
static struct symbol *examine_pointer_type(struct symbol *sym)
{
	/*
	 * Since pointers to incomplete types can be used,
	 * for example in a struct-declaration-list,
	 * the base type must *not* be examined here.
	 * It thus means that it needs to be done later,
	 * when the base type of the pointer is looked at.
	 */
	if (!sym->bit_size)
		sym->bit_size = bits_in_pointer;
	if (!sym->ctype.alignment)
		sym->ctype.alignment = pointer_alignment;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x3fdb2
leaq 0x4a953(%rip), %rax     # 0x8a6fc
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3fdcf
leaq 0x4a93c(%rip), %rax     # 0x8a700
movslq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_enum_type
static struct symbol *examine_enum_type(struct symbol *sym)
{
	struct symbol *base_type = examine_base_type(sym);

	sym->ctype.modifiers |= (base_type->ctype.modifiers & MOD_SIGNEDNESS);
	sym->bit_size = bits_in_enum;
	if (base_type->bit_size > sym->bit_size)
		sym->bit_size = base_type->bit_size;
	sym->ctype.alignment = enum_alignment;
	if (base_type->ctype.alignment > sym->ctype.alignment)
		sym->ctype.alignment = base_type->ctype.alignment;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40070
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
andq $0xe000, %rcx           # imm = 0xE000
movq -0x8(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
leaq 0x4a8e9(%rip), %rax     # 0x8a704
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x3fe42
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
leaq 0x4a8bf(%rip), %rax     # 0x8a708
movslq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jbe 0x3fe76
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_bitfield_type
static struct symbol *examine_bitfield_type(struct symbol *sym)
{
	struct symbol *base_type = examine_base_type(sym);
	unsigned long alignment, modifiers;

	if (!base_type)
		return sym;
	if (sym->bit_size > base_type->bit_size) {
		sparse_error(sym->pos, "bitfield '%s' is wider (%d) than its type (%s)",
			show_ident(sym->ident), sym->bit_size, show_typename(base_type));
		sym->bit_size = -1;
	}

	alignment = base_type->ctype.alignment;
	if (!sym->ctype.alignment)
		sym->ctype.alignment = alignment;
	modifiers = base_type->ctype.modifiers;

	/* use -funsigned-bitfields to determine the sign if not explicit */
	if (!(modifiers & MOD_EXPLICITLY_SIGNED) && funsigned_bitfields)
		modifiers = (modifiers & ~MOD_SIGNED) | MOD_UNSIGNED;
	sym->ctype.modifiers |= modifiers & MOD_SIGNEDNESS;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3fead
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ff92
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x3ff14
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33340
movq -0x40(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq %rax, %r8
movq -0x30(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x29720(%rip), %rsi     # 0x69622
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3ff37
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x8000, %rax           # imm = 0x8000
cmpq $0x0, %rax
jne 0x3ff73
leaq 0x4d25e(%rip), %rax     # 0x8d1b8
cmpl $0x0, (%rax)
je 0x3ff73
movq -0x28(%rbp), %rax
andq $-0x2001, %rax          # imm = 0xDFFF
orq $0x4000, %rax           # imm = 0x4000
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
andq $0xe000, %rcx           # imm = 0xE000
movq -0x10(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_typeof
static struct symbol *examine_typeof(struct symbol *sym)
{
	struct symbol *base = evaluate_expression(sym->initializer);
	unsigned long mod = 0;

	if (!base)
		base = &bad_ctype;
	if (base->type == SYM_NODE) {
		mod |= base->ctype.modifiers & MOD_TYPEOF;
		base = base->ctype.base_type;
	}
	if (base->type == SYM_BITFIELD)
		warning(base->pos, "typeof applied to bitfield type");
	sym->type = SYM_NODE;
	sym->ctype.modifiers = mod;
	sym->ctype.base_type = base;
	return examine_node_type(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x4bb70
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3ffda
leaq 0x52cc2(%rip), %rax     # 0x92c98
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x4000c
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x400fe00, %rax        # imm = 0x400FE00
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xb, %eax
jne 0x40032
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x29626(%rip), %rsi     # 0x69651
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x3, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rdi
callq 0x3f840
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: create_fouled
void create_fouled(struct symbol *type)
{
	if (type->bit_size < bits_in_int) {
		struct symbol *new = alloc_symbol(type->pos, type->type);
		*new = *type;
		new->bit_size = bits_in_int;
		new->rank = 0;
		new->type = SYM_FOULED;
		new->ctype.base_type = type;
		add_symbol(&restr, type);
		add_symbol(&fouled, new);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
leaq 0x4a43e(%rip), %rcx     # 0x8a6d8
cmpl (%rcx), %eax
jge 0x40331
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %esi
andl $0xff, %esi
movq 0x4(%rax), %rdi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
leaq 0x4a400(%rip), %rax     # 0x8a6d8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xfc7fffff, %ecx       # imm = 0xFC7FFFFF
orl $0x0, %ecx
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0xe, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rsi
leaq 0x50acc(%rip), %rdi     # 0x90de8
callq 0x3f3c0
movq -0x10(%rbp), %rsi
leaq 0x50ac4(%rip), %rdi     # 0x90df0
callq 0x3f3c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: check_declaration
void check_declaration(struct symbol *sym)
{
	int warned = 0;
	struct symbol *next = sym;

	while ((next = next->next_id) != NULL) {
		if (next->namespace != sym->namespace)
			continue;
		if (sym->scope == next->scope) {
			sym->same_symbol = next;
			inherit_declaration(sym, next);
			return;
		}
		/* Extern in block level matches a TOPLEVEL non-static symbol */
		if (sym->ctype.modifiers & MOD_EXTERN) {
			if ((next->ctype.modifiers & (MOD_TOPLEVEL|MOD_STATIC)) == MOD_TOPLEVEL) {
				sym->same_symbol = next;
				return;
			}
		}

		if (!Wshadow || warned)
			continue;
		if (get_sym_type(next) == SYM_FN)
			continue;
		warned = 1;
		warning(sym->pos, "symbol '%s' shadows an earlier one", show_ident(sym->ident));
		info(next->pos, "originally declared here");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x406b2
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
cmpl %ecx, %eax
je 0x405d4
jmp 0x4059b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x40604
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x406c0
jmp 0x406b2
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x8, %rax
cmpq $0x0, %rax
je 0x40638
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x14, %rax
cmpq $0x10, %rax
jne 0x40636
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x406b2
jmp 0x40638
leaq 0x4cbd1(%rip), %rax     # 0x8d210
cmpl $0x0, (%rax)
je 0x4064a
cmpl $0x0, -0xc(%rbp)
je 0x4064f
jmp 0x4059b
movq -0x18(%rbp), %rdi
callq 0x40700
cmpl $0x5, %eax
jne 0x40662
jmp 0x4059b
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x28da8(%rip), %rsi     # 0x69438
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x28db5(%rip), %rsi     # 0x6945b
movb $0x0, %al
callq 0x16c10
jmp 0x4059b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: inherit_static
static void inherit_static(struct symbol *sym)
{
	struct symbol *prev;

	// only 'plain' symbols are concerned
	if (sym->ctype.modifiers & (MOD_STATIC|MOD_EXTERN))
		return;

	for (prev = sym->next_id; prev; prev = prev->next_id) {
		if (prev->namespace != NS_SYMBOL)
			continue;
		if (prev->scope != file_scope)
			continue;

		sym->ctype.modifiers |= prev->ctype.modifiers & MOD_STATIC;

		// previous declarations are already converted
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0xc, %rax
cmpq $0x0, %rax
je 0x4096c
jmp 0x409d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x409d2
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x10, %eax
je 0x40994
jmp 0x409c4
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
leaq 0x48715(%rip), %rcx     # 0x890b8
cmpq (%rcx), %rax
je 0x409aa
jmp 0x409c4
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
andq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
jmp 0x409d2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x40978
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: bind_symbol
void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
{
	struct scope *scope = block_scope;;

	if (ns == NS_MACRO)
		scope = file_scope;
	if (ns == NS_LABEL)
		scope = function_scope;
	bind_symbol_with_scope(sym, ident, ns, scope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x4864e(%rip), %rax     # 0x890a8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x40a75
leaq 0x4864a(%rip), %rax     # 0x890b8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x40a89
leaq 0x4862e(%rip), %rax     # 0x890b0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x40750
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: create_symbol
struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
{
	struct ident *ident = built_in_ident(name);
	struct symbol *sym = lookup_symbol(ident, namespace);

	if (sym && sym->type != type)
		die("symbol %s created with different types: %d old %d", name,
				type, sym->type);

	if (!sym) {
		struct token *token = built_in_token(stream, ident);

		sym = alloc_symbol(token->pos, type);
		bind_symbol(sym, token->ident, namespace);
	}
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44f10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3f450
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x40b1a
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl -0x14(%rbp), %eax
je 0x40b1a
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
leaq 0x289d4(%rip), %rdi     # 0x694e7
movb $0x0, %al
callq 0x17190
cmpq $0x0, -0x28(%rbp)
jne 0x40b58
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x45050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %esi
movq (%rax), %rdi
callq 0x3f4d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x18(%rbp), %edx
callq 0x40a40
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: get_symbol_initializer
static struct expression *get_symbol_initializer(struct symbol *sym)
{
	do {
		if (sym->initializer)
			return sym->initializer;
	} while ((sym = sym->same_symbol) != NULL);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x41237
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x41253
jmp 0x41239
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x41218
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: implicit_array_size
static unsigned int implicit_array_size(struct symbol *node, unsigned int count)
{
	struct symbol *arr_ori = node->ctype.base_type;
	struct symbol *arr_new = alloc_symbol(node->pos, SYM_ARRAY);
	struct symbol *elem_type = arr_ori->ctype.base_type;
	struct expression *size = alloc_const_expression(node->pos, count);
	unsigned int bit_size = array_element_offset(elem_type->bit_size, count);

	*arr_new = *arr_ori;
	arr_new->bit_size = bit_size;
	arr_new->array_size = size;
	node->array_size = size;
	node->ctype.base_type = arr_new;

	return bit_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x6, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x4(%rax), %rdi
callq 0x41700
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movslq 0x50(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x41770
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: is_wstring_expr
static bool is_wstring_expr(struct expression *expr)
{
	while (expr) {
		switch (expr->type) {
		case EXPR_STRING:
			return 1;
		case EXPR_INITIALIZER:
			if (expression_list_size(expr->expr_list) != 1)
				return 0;
			expr = first_expression(expr->expr_list);
			break;
		case EXPR_PREOP:
			if (expr->op == '(') {
				expr = expr->unop;
				break;
			}
		default:
			return 0;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x416ab
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x41658
jmp 0x41644
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x41689
jmp 0x4164e
movl -0x14(%rbp), %eax
subl $0x18, %eax
je 0x4165e
jmp 0x416a3
movb $0x1, -0x1(%rbp)
jmp 0x416af
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x416c0
cmpl $0x1, %eax
je 0x41676
movb $0x0, -0x1(%rbp)
jmp 0x416af
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x416e0
movq %rax, -0x10(%rbp)
jmp 0x416a9
movq -0x10(%rbp), %rax
cmpl $0x28, 0x4(%rax)
jne 0x416a1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x416a9
jmp 0x416a3
movb $0x0, -0x1(%rbp)
jmp 0x416af
jmp 0x4162c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./expression.h
// Function: alloc_const_expression
static inline struct expression *alloc_const_expression(struct position pos, int value)
{
	struct expression *expr = __alloc_expression(0);
	expr->type = EXPR_VALUE;
	expr->pos = pos;
	expr->value = value;
	expr->ctype = &int_ctype;
	expr->flags = CEF_SET_INT;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x46d40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x503ca(%rip), %rcx     # 0x91b18
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl $0x3100, %ecx           # imm = 0x3100
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./target.h
// Function: array_element_offset
static inline unsigned long array_element_offset(unsigned long base_bits, int idx)
{
	int fragment = base_bits % bits_in_char;
	if (fragment)
		base_bits += bits_in_char - fragment;
	return base_bits * idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
leaq 0x48f4a(%rip), %rcx     # 0x8a6d0
movslq (%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x417af
leaq 0x48f30(%rip), %rax     # 0x8a6d0
movl (%rax), %eax
subl -0x10(%rbp), %eax
cltq
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq %rcx, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: lay_out_union
static void lay_out_union(struct symbol *sym, struct struct_union_info *info)
{
	if (sym->bit_size < 0 && is_array_type(sym))
		sparse_error(sym->pos, "flexible array member '%s' in a union", show_ident(sym->ident));

	if (sym->bit_size > info->bit_size)
		info->bit_size = sym->bit_size;

	sym->offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jge 0x41a66
movq -0x8(%rbp), %rdi
callq 0x41c60
cmpl $0x0, %eax
je 0x41a66
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x27b4f(%rip), %rsi     # 0x695ae
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x41a88
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: examine_anonymous_member
static void examine_anonymous_member(struct symbol *sym)
{
	unsigned long mod = sym->ctype.modifiers & MOD_QUALIFIER;
	struct symbol *sub;

	if (sym->type == SYM_NODE)
		sym = sym->ctype.base_type;
	if (sym->type != SYM_STRUCT && sym->type != SYM_UNION)
		return;

	FOR_EACH_PTR(sym->symbol_list, sub) {
		assert(sub->type == SYM_NODE);
		sub->ctype.modifiers |= mod;

		// if nested, propagate all the way down
		if (!sub->ident)
			examine_anonymous_member(sub);
	} END_FOR_EACH_PTR(sub);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0xe00, %rax            # imm = 0xE00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x41ada
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x7, %eax
je 0x41aff
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
je 0x41aff
jmp 0x41bfa
jmp 0x41b01
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x41b2c
jmp 0x41bfa
jmp 0x41b2e
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x41be2
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x41b7d
cmpq $0x0, -0x18(%rbp)
jne 0x41b7d
jmp 0x41bd4
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x41b8f
jmp 0x41bae
leaq 0x27a3e(%rip), %rdi     # 0x695d4
leaq 0x27a4d(%rip), %rsi     # 0x695ea
movl $0xc3, %edx
leaq 0x27a4a(%rip), %rcx     # 0x695f3
callq 0x11120
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x41bd2
movq -0x18(%rbp), %rdi
callq 0x41aa0
jmp 0x41bd4
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x41b35
jmp 0x41be4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x41b2e
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/symbol.c
// Function: bitfield_base_size
static int bitfield_base_size(struct symbol *sym)
{
	if (sym->type == SYM_NODE)
		sym = sym->ctype.base_type;
	if (sym->type == SYM_BITFIELD)
		sym = sym->ctype.base_type;
	return sym->bit_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x41cc4
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xb, %eax
jne 0x41ce0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target.c
// Function: target_parse
enum machine target_parse(const char *name)
{
	static const struct arch {
		const char *name;
		enum machine mach;
		char bits;
	} archs[] = {
		{ "alpha",	MACH_ALPHA,	64, },
		{ "aarch64",	MACH_ARM64,	64, },
		{ "arm64",	MACH_ARM64,	64, },
		{ "arm",	MACH_ARM,	32, },
		{ "bfin",	MACH_BFIN,	32, },
		{ "h8300",	MACH_H8300,	32, },
		{ "i386",	MACH_I386,	32, },
		{ "m68k",	MACH_M68K,	32, },
		{ "microblaze",	MACH_MICROBLAZE,32, },
		{ "mips",	MACH_MIPS32,	0,  },
		{ "nds32",	MACH_NDS32,	32, },
		{ "nios2",	MACH_NIOS2,	32, },
		{ "openrisc",	MACH_OPENRISC,	32, },
		{ "powerpc",	MACH_PPC32,	0,  },
		{ "ppc",	MACH_PPC32,	0,  },
		{ "riscv",	MACH_RISCV32,	0,  },
		{ "s390x",	MACH_S390X,	64, },
		{ "s390",	MACH_S390,	32, },
		{ "sparc",	MACH_SPARC32,	0,  },
		{ "x86_64",	MACH_X86_64,	64, },
		{ "x86-64",	MACH_X86_64,	64, },
		{ "sh",		MACH_SH,	32, },
		{ "xtensa",	MACH_XTENSA,	32, },
		{ NULL },
	};
	const struct arch *p;

	for (p = &archs[0]; p->name; p++) {
		size_t len = strlen(p->name);
		if (strncmp(p->name, name, len) == 0) {
			enum machine mach = p->mach;
			const char *suf = name + len;
			int bits = p->bits;

			if (bits == 0) {
				if (!strcmp(suf, "") || !strcmp(suf, "32")) {
					;
				} else if (!strcmp(suf, "64")) {
					mach += 1;
				} else {
					die("invalid architecture: %s", name);
				}
			} else {
				if (strcmp(suf, ""))
					die("invalid architecture: %s", name);
			}

			return mach;
		}
	}

	return MACH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x3cb7d(%rip), %rax     # 0x7e8f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x41e7f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x110c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11080
cmpl $0x0, %eax
jne 0x41e6c
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x41e3b
movq -0x30(%rbp), %rdi
leaq 0x20a45(%rip), %rsi     # 0x62829
callq 0x111b0
cmpl $0x0, %eax
je 0x41e03
movq -0x30(%rbp), %rdi
leaq 0x2559b(%rip), %rsi     # 0x67394
callq 0x111b0
cmpl $0x0, %eax
jne 0x41e05
jmp 0x41e39
movq -0x30(%rbp), %rdi
leaq 0x278d7(%rip), %rsi     # 0x696e7
callq 0x111b0
cmpl $0x0, %eax
jne 0x41e25
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41e37
movq -0x10(%rbp), %rsi
leaq 0x278c4(%rip), %rdi     # 0x696f4
movb $0x0, %al
callq 0x17190
jmp 0x41e39
jmp 0x41e64
movq -0x30(%rbp), %rdi
leaq 0x209e3(%rip), %rsi     # 0x62829
callq 0x111b0
cmpl $0x0, %eax
je 0x41e62
movq -0x10(%rbp), %rsi
leaq 0x27899(%rip), %rdi     # 0x696f4
movb $0x0, %al
callq 0x17190
jmp 0x41e64
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41e86
jmp 0x41e6e
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x41d77
movl $0x18, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target.c
// Function: target_os
void target_os(const char *name)
{
	static const struct os {
		const char *name;
		int os;
	} oses[] = {
		{ "cygwin",	OS_CYGWIN },
		{ "darwin",	OS_DARWIN },
		{ "freebsd",	OS_FREEBSD },
		{ "linux",	OS_LINUX },
		{ "native",	OS_NATIVE, },
		{ "netbsd",	OS_NETBSD },
		{ "none",	OS_NONE },
		{ "openbsd",	OS_OPENBSD },
		{ "sunos",	OS_SUNOS },
		{ "unix",	OS_UNIX },
		{ NULL },
	}, *p;

	for (p = &oses[0]; p->name; p++) {
		if (!strcmp(p->name, name)) {
			arch_os = p->os;
			return;
		}
	}

	die("invalid os: %s", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3cbcd(%rip), %rax     # 0x7ea70
movq %rax, 0x524ae(%rip)     # 0x94358
movq 0x524a7(%rip), %rax     # 0x94358
cmpq $0x0, (%rax)
je 0x41efe
movq 0x5249a(%rip), %rax     # 0x94358
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x111b0
cmpl $0x0, %eax
jne 0x41ee8
movq 0x52482(%rip), %rax     # 0x94358
movl 0x8(%rax), %ecx
leaq 0x42904(%rip), %rax     # 0x847e4
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
jmp 0x41eea
movq 0x52467(%rip), %rax     # 0x94358
addq $0x10, %rax
movq %rax, 0x5245c(%rip)     # 0x94358
jmp 0x41eaa
movq -0x8(%rbp), %rsi
leaq 0x27836(%rip), %rdi     # 0x6973f
movb $0x0, %al
callq 0x17190
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target.c
// Function: target_config
void target_config(enum machine mach)
{
	const struct target *target = targets[mach];

	arch_target = target;
	arch_m64 = target->bitness;
	arch_big_endian = target->big_endian;

	funsigned_char = target->unsigned_char;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x487fd(%rip), %rax     # 0x8a720
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x487da(%rip)     # 0x8a710
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x4289c(%rip), %rax     # 0x847e0
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x4b21f(%rip), %rax     # 0x8d178
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x4b24c(%rip), %rax     # 0x8d1bc
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)