LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: show_label
const char *show_label(struct basic_block *bb)
{
	static int n;
	static char buffer[4][16];
	char *buf = buffer[3 & ++n];

	if (!bb)
		return ".L???";
	snprintf(buf, 16, ".L%u", bb->nr);
	return buf;
}

// Assembly:
pushq %rbx
movl 0x54780(%rip), %eax     # 0x669f8
incl %eax
movl %eax, 0x54778(%rip)     # 0x669f8
testq %rdi, %rdi
je 0x122b0
andl $0x3, %eax
shll $0x4, %eax
leaq 0x5476e(%rip), %rbx     # 0x66a00
addq %rax, %rbx
movl 0x38(%rdi), %ecx
leaq 0x3032f(%rip), %rdx     # 0x425ce
movl $0x10, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe100
jmp 0x122b7
leaq 0x30311(%rip), %rbx     # 0x425c8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: show_asm
static char *show_asm(char *buf, struct instruction *insn)
{
	struct asm_rules *rules = insn->asm_rules;

	buf += sprintf(buf, "\"%s\"", insn->string);
	buf = show_asm_constraints(buf, "\n\t\tout: ", rules->outputs);
	buf = show_asm_constraints(buf, "\n\t\tin: ", rules->inputs);
	buf = show_asm_constraints(buf, "\n\t\tclobber: ", rules->clobbers);
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rsi), %rdx
movq 0x38(%rsi), %r14
leaq 0x34494(%rip), %rsi     # 0x4723d
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %rdi
addq %rbx, %rdi
movq 0x8(%r14), %rdx
leaq 0x2fc83(%rip), %rsi     # 0x42a44
callq 0x13f25
movq (%r14), %rdx
leaq 0x2fc7d(%rip), %rsi     # 0x42a4d
movq %rax, %rdi
callq 0x13f25
movq 0x10(%r14), %rdx
leaq 0x2fc72(%rip), %rsi     # 0x42a55
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13f25
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: insert_select
void insert_select(struct basic_block *bb, struct instruction *br, struct instruction *phi_node, pseudo_t if_true, pseudo_t if_false)
{
	pseudo_t target;
	struct instruction *select;

	select = alloc_typed_instruction(OP_SEL, phi_node->type);

	assert(br->cond);
	use_pseudo(select, br->cond, &select->src1);

	target = phi_node->target;
	assert(target->def == phi_node);
	select->target = target;
	target->def = select;

	use_pseudo(select, if_true, &select->src2);
	use_pseudo(select, if_false, &select->src3);

	insert_last_instruction(bb, select);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x18(%rdx), %rsi
movl $0x41, %edi
callq 0x13602
movq 0x30(%rbp), %rbp
testq %rbp, %rbp
je 0x135c4
movq %rax, %r14
movq %rbp, 0x30(%rax)
movl 0x4(%rbp), %eax
cmpl $0x6, %eax
ja 0x134b1
movl $0x43, %ecx
btl %eax, %ecx
jb 0x134e4
leaq 0x30(%r14), %rax
movq %rax, (%rsp)
leaq 0x4dcf0(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r13), %rax
cmpq %r13, 0x18(%rax)
jne 0x135e3
movq %rax, 0x20(%r14)
movq %r14, 0x18(%rax)
movq %r12, 0x38(%r14)
testq %r12, %r12
je 0x13542
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x13517
movl $0x43, %ecx
btl %eax, %ecx
jb 0x13542
leaq 0x38(%r14), %r13
leaq 0x4dc8e(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r15, 0x40(%r14)
testq %r15, %r15
je 0x1358c
movl 0x4(%r15), %eax
cmpl $0x6, %eax
ja 0x1355e
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1358c
movq %r14, %r12
addq $0x40, %r12
leaq 0x4dc44(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r12, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x22b10
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2285b
movq %r15, %rdi
movq %r12, %rsi
callq 0x2285b
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f242(%rip), %rdi     # 0x4280d
leaq 0x2f244(%rip), %rsi     # 0x42816
leaq 0x2f249(%rip), %rcx     # 0x42822
movl $0x2be, %edx            # imm = 0x2BE
callq 0xe120
leaq 0x2f2a1(%rip), %rdi     # 0x4288b
leaq 0x2f225(%rip), %rsi     # 0x42816
leaq 0x2f22a(%rip), %rcx     # 0x42822
movl $0x2c2, %edx            # imm = 0x2C2
callq 0xe120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_pseudo
pseudo_t alloc_pseudo(struct instruction *def)
{
	static int nr = 0;
	struct pseudo * pseudo = __alloc_pseudo(0);
	pseudo->type = PSEUDO_REG;
	pseudo->nr = ++nr;
	pseudo->def = def;
	return pseudo;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x303a3
movl $0x3, 0x4(%rax)
movl 0x5448d(%rip), %ecx     # 0x67b50
incl %ecx
movl %ecx, 0x54485(%rip)     # 0x67b50
movl %ecx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: value_pseudo
pseudo_t value_pseudo(long long val)
{
#define MAX_VAL_HASH 64
	static struct pseudo_list *prev[MAX_VAL_HASH];
	int hash = val & (MAX_VAL_HASH-1);
	struct pseudo_list **list = prev + hash;
	pseudo_t pseudo;

	FOR_EACH_PTR(*list, pseudo) {
		if (pseudo->value == val)
			return pseudo;
	} END_FOR_EACH_PTR(pseudo);

	pseudo = __alloc_pseudo(0);
	pseudo->type = PSEUDO_VAL;
	pseudo->value = val;
	add_pseudo(list, pseudo);

	/* Value pseudos have neither nr, usage nor def */
	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3f, %eax
leaq 0x54479(%rip), %rcx     # 0x67b60
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x1373f
movq %rdx, %rsi
movzwl (%rsi), %r8d
movsbl %r8b, %edi
testw %di, %di
jle 0x1372b
movzwl %di, %edi
movzwl %r8w, %r8d
xorl %r9d, %r9d
movq 0x18(%rsi,%r9,8), %r14
cmpl $0x100, %r8d            # imm = 0x100
jb 0x1371d
testq %r14, %r14
je 0x13723
cmpq %rbx, 0x18(%r14)
je 0x13738
incq %r9
cmpq %r9, %rdi
jne 0x1370a
movq 0x10(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x136f3
xorl %edx, %edx
jmp 0x13744
movl $0x1, %edx
jmp 0x13744
movl $0x2, %edx
testb $0x1, %dl
jne 0x1376d
leaq (%rcx,%rax,8), %r15
xorl %edi, %edi
callq 0x303a3
movq %rax, %r14
movl $0x6, 0x4(%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phisrc
struct instruction *alloc_phisrc(pseudo_t pseudo, struct symbol *type)
{
	struct instruction *insn = alloc_typed_instruction(OP_PHISOURCE, type);
	pseudo_t phi = __alloc_pseudo(0);
	static int nr = 0;

	phi->type = PSEUDO_PHI;
	phi->nr = ++nr;
	phi->def = insn;

	use_pseudo(insn, pseudo, &insn->phi_src);
	insn->target = phi;
	return insn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x45, %edi
callq 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movq %rax, %r15
movl $0x2, 0x4(%rax)
movl 0x545aa(%rip), %eax     # 0x67d60
incl %eax
movl %eax, 0x545a2(%rip)     # 0x67d60
movl %eax, (%r15)
movq %rbx, 0x18(%r15)
movq %r14, 0x30(%rbx)
testq %r14, %r14
je 0x1380f
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x137e1
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1380f
movq %rbx, %r12
addq $0x30, %r12
leaq 0x4d9c1(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r12, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r15, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phi
pseudo_t alloc_phi(struct basic_block *source, pseudo_t pseudo, struct symbol *type)
{
	struct instruction *insn;

	if (!source)
		return VOID;

	insn = alloc_phisrc(pseudo, type);
	insn->bb = source;
	add_instruction(&source->insns, insn);
	return insn->target;
}

// Assembly:
testq %rdi, %rdi
je 0x1385b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x13787
movq %rax, %r14
movq %rbx, 0x8(%rax)
addq $0x28, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5316e(%rip), %rax     # 0x669d0
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_phi_node
struct instruction *alloc_phi_node(struct basic_block *bb, struct symbol *type, struct ident *ident)
{
	struct instruction *phi_node = alloc_typed_instruction(OP_PHI, type);
	pseudo_t phi;

	phi = alloc_pseudo(phi_node);
	phi->ident = ident;
	phi->def = phi_node;
	phi_node->target = phi;
	phi_node->bb = bb;
	return phi_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl $0x46, %edi
callq 0x13602
movq %rax, %r15
xorl %edi, %edi
callq 0x303a3
movl $0x3, 0x4(%rax)
movl 0x542c1(%rip), %ecx     # 0x67b50
incl %ecx
movl %ecx, 0x542b9(%rip)     # 0x67b50
movl %ecx, (%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x20(%r15)
movq %r14, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_phi_node
void add_phi_node(struct basic_block *bb, struct instruction *phi_node)
{
	struct instruction *insn;

	FOR_EACH_PTR(bb->insns, insn) {
		enum opcode op = insn->opcode;
		if (op == OP_PHI)
			continue;
		INSERT_CURRENT(phi_node, insn);
		return;
	} END_FOR_EACH_PTR(insn);

	// FIXME
	add_instruction(&bb->insns, phi_node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r12
testq %r12, %r12
je 0x13996
movq %r12, %r15
movl (%r15), %ecx
movl %ecx, %eax
shll $0x8, %eax
testw %ax, %ax
jle 0x13985
xorl %ebp, %ebp
movslq %ebp, %rdx
movq 0x18(%r15,%rdx,8), %rdx
movzwl %cx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x138fe
testq %rdx, %rdx
je 0x13970
movl (%rdx), %r13d
andl $0x7f, %r13d
movl $0x8, %ecx
cmpl $0x46, %r13d
je 0x1396a
movzwl %ax, %eax
cmpl $0xd00, %eax            # imm = 0xD00
jne 0x1392c
movq %r15, %rdi
callq 0x227d1
movsbl (%r15), %ecx
movl %ebp, %eax
subl %ecx, %eax
jge 0x13930
movl %ebp, %eax
jmp 0x13934
movq 0x10(%r15), %r15
movslq %eax, %rcx
leaq (%r15,%rcx,8), %rcx
addq $0x18, %rcx
movsbq (%r15), %rdx
leaq (%r15,%rdx,8), %rdx
addq $0x10, %rdx
cmpq %rcx, %rdx
jb 0x1395d
movq (%rdx), %rsi
movq %rsi, 0x8(%rdx)
addq $-0x8, %rdx
jmp 0x1394b
movq %rbx, (%rcx)
incb (%r15)
movl $0x1, %ecx
movl %eax, %ebp
cmpl $0x46, %r13d
jne 0x1399b
incl %ebp
movl (%r15), %ecx
movl %ecx, %eax
shll $0x8, %eax
movsbl %cl, %edx
cmpl %edx, %ebp
jl 0x138e6
movq 0x10(%r15), %r15
cmpq %r12, %r15
jne 0x138d3
xorl %ecx, %ecx
jmp 0x1399b
movl $0x2, %ecx
testb $0xd, %cl
jne 0x139bd
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2285b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: init_linearized_builtins
void init_linearized_builtins(int stream)
{
	struct sym_init *ptr;

	for (ptr = builtins_table; ptr->name; ptr++) {
		struct symbol *sym;
		sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
		if (!sym->op)
			sym->op = &ptr->op;
		sym->op->type |= KW_BUILTIN;
		sym->op->linearize = ptr->linearize;
	}
}

// Assembly:
movq 0x4d394(%rip), %rsi     # 0x61260
testq %rsi, %rsi
je 0x13f24
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4d3fa(%rip), %r14     # 0x612d8
movl %ebx, %edi
movl $0x3, %edx
movl $0x10, %ecx
callq 0x2c406
cmpq $0x0, 0x40(%rax)
jne 0x13efe
leaq -0x68(%r14), %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rcx
orl $0x10, (%rcx)
movq -0x70(%r14), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x20(%rax)
movq (%r14), %rsi
addq $0x78, %r14
testq %rsi, %rsi
jne 0x13ede
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: show_asm_constraints
static char *show_asm_constraints(char *buf, const char *sep, struct asm_constraint_list *list)
{
	struct asm_constraint *entry;

	FOR_EACH_PTR(list, entry) {
		buf += sprintf(buf, "%s\"%s\"", sep, entry->constraint);
		if (entry->pseudo)
			buf += sprintf(buf, " (%s)", show_pseudo(entry->pseudo));
		if (entry->ident)
			buf += sprintf(buf, " [%s]", show_ident(entry->ident));
		sep = ", ";		
	} END_FOR_EACH_PTR(entry);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rdi, %r13
testq %rdx, %rdx
je 0x1400b
movq %rsi, %rdx
leaq 0x2e862(%rip), %rbx     # 0x427ab
movq %rax, %r15
movq %rax, (%rsp)
movzwl (%r15), %eax
testb %al, %al
jle 0x13ffa
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x13f73
testq %r14, %r14
je 0x13fe7
movq 0x8(%r14), %rcx
movq %r13, %rdi
leaq 0x2eae1(%rip), %rsi     # 0x42a62
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %rbp
addq %r13, %rbp
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13fb4
callq 0x122bc
movq %rbp, %rdi
leaq 0x34755(%rip), %rsi     # 0x486fa
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2c0
cltq
addq %rax, %rbp
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x13fe1
callq 0x2e465
movq %rbp, %rdi
leaq 0x2ea9d(%rip), %rsi     # 0x42a69
movq %rax, %rdx
xorl %eax, %eax
callq 0xe2c0
movslq %eax, %r13
addq %rbp, %r13
movq %rbx, %rdx
jmp 0x13fe7
movq %rbx, %rdx
movq %rbp, %r13
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x13f5f
movq 0x10(%r15), %r15
movq (%rsp), %rax
cmpq %rax, %r15
jne 0x13f50
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: set_activeblock
static void set_activeblock(struct entrypoint *ep, struct basic_block *bb)
{
	if (!bb_terminated(ep->active))
		add_goto(ep, bb);

	ep->active = bb;
	if (bb_reachable(bb))
		add_bb(&ep->bbs, bb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1404b
movq 0x28(%rax), %rdi
callq 0x22652
testq %rax, %rax
je 0x1404b
movl (%rax), %eax
andl $0x7e, %eax
addl $-0x8, %eax
cmpl $-0x7, %eax
ja 0x14056
movq %r14, %rdi
movq %rbx, %rsi
callq 0x143fb
movq %rbx, 0x20(%r14)
testq %rbx, %rbx
je 0x14075
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2285b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_fn_statement
static pseudo_t linearize_fn_statement(struct entrypoint *ep, struct statement *stmt)
{
	struct instruction *phi_node;
	struct basic_block *bb;
	pseudo_t pseudo;

	pseudo = linearize_compound_statement(ep, stmt);
	if (!is_void_type(stmt->ret)) {			// non-void function
		struct basic_block *active = ep->active;
		if (active && !bb_terminated(active)) {	// missing return
			struct basic_block *bb_ret;
			bb_ret = get_bound_block(ep, stmt->ret);
			add_return(ep, bb_ret, stmt->ret, undef_pseudo());
		}
	}
	bb = add_label(ep, stmt->ret);
	phi_node = first_instruction(bb->insns);
	if (phi_node)
		pseudo = phi_node->target;
	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x16fc7
movq %rax, %rbx
movq 0x18(%r15), %rax
cmpb $0x3, (%rax)
jne 0x14371
movq 0x60(%rax), %rax
cmpq 0x4cbc0(%rip), %rax     # 0x60f38
je 0x143d0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x143d0
movq 0x28(%rax), %rdi
callq 0x22652
testq %rax, %rax
je 0x1439e
movl (%rax), %eax
andl $0x7e, %eax
addl $-0x8, %eax
cmpl $-0x7, %eax
ja 0x143d0
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x16f7e
movq %rax, %r12
movq 0x18(%r15), %r13
xorl %edi, %edi
callq 0x303a3
movl $0x1, 0x4(%rax)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x1729e
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x16eff
movq 0x28(%rax), %rdi
callq 0x22634
testq %rax, %rax
je 0x143ee
movq 0x20(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_goto
static void add_goto(struct entrypoint *ep, struct basic_block *dst)
{
	struct basic_block *src = ep->active;
	if (bb_reachable(src)) {
		struct instruction *br = alloc_instruction(OP_BR, 0);
		br->bb_true = dst;
		add_bb(&dst->parents, src);
		add_bb(&src->children, dst);
		br->bb = src;
		add_instruction(&src->insns, br);
		ep->active = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x14471
movq %rsi, %r15
movq %rdi, %rbx
xorl %edi, %edi
callq 0x302dd
movq %rax, %r12
movl $0x80, %eax
andl (%r12), %eax
orl $0x3, %eax
movl %eax, (%r12)
movq 0x53935(%rip), %rax     # 0x67d68
movq %rax, 0x10(%r12)
movq %r15, 0x38(%r12)
leaq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x2285b
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x2285b
movq %r14, 0x8(%r12)
addq $0x28, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2285b
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_asm_rule
static void add_asm_rule(struct instruction *insn, struct asm_constraint_list **list, struct asm_operand *op, pseudo_t pseudo)
{
	struct asm_constraint *rule = __alloc_asm_constraint(0);
	rule->is_memory = op->is_memory;
	rule->ident = op->name;
	rule->constraint = op->constraint ? op->constraint->string->data : "";
	use_pseudo(insn, pseudo, &rule->pseudo);
	add_ptr_list(list, rule);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x4caaa(%rip), %rdi     # 0x61220
movl $0x20, %esi
callq 0x2fd3c
movq %rax, %r15
movb 0x18(%r13), %al
shrb $0x5, %al
andb $0x1, %al
movb 0x18(%r15), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x18(%r15)
movq (%r13), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x147b4
movq 0x28(%rax), %rax
addq $0x4, %rax
jmp 0x147bb
leaq 0x2d112(%rip), %rax     # 0x418cd
movq %rax, 0x8(%r15)
movq %r14, (%r15)
testq %r14, %r14
je 0x14801
movl 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x147da
movl $0x43, %ecx
btl %eax, %ecx
jb 0x14801
leaq 0x4c9cf(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r15, 0x8(%rax)
movq %r12, (%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2285b
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2285b
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_one_symbol
static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
{
	struct access_data ad = { NULL, };
	pseudo_t value;

	if (!sym || !sym->initializer || sym->initialized)
		return VOID;

	/* We need to output these puppies some day too.. */
	if (sym->ctype.modifiers & (MOD_STATIC | MOD_TOPLEVEL))
		return VOID;

	sym->initialized = 1;
	ad.address = symbol_pseudo(ep, sym);

	if (sym->initializer && !is_scalar_type(sym)) {
		// default zero initialization [6.7.9.21]
		// FIXME: this init the whole aggregate while
		// only the existing fields need to be initialized.
		// FIXME: this init the whole aggregate even if
		// all fields arelater  explicitely initialized.
		ad.type = sym;
		ad.address = symbol_pseudo(ep, sym);
		linearize_store_gen(ep, value_pseudo(0), &ad);
	}

	value = linearize_initializer(ep, sym->initializer, &ad);
	return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x5219f(%rip), %rax     # 0x669d0
testq %rsi, %rsi
je 0x148a9
movq %rsi, %r14
cmpq $0x0, 0xb0(%rsi)
je 0x148a9
movl 0x54(%r14), %ecx
btl $0xa, %ecx
jb 0x148a9
testb $0x14, 0x68(%r14)
jne 0x148a9
movq %rdi, %rbx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x54(%r14)
movq %r14, %rsi
callq 0x16810
movq %rax, 0x10(%rsp)
cmpq $0x0, 0xb0(%r14)
je 0x14897
cmpb $0x3, (%r14)
movq %r14, %rax
jne 0x14885
movq 0x60(%r14), %rax
movzbl (%rax), %ecx
cmpl $0xe, %ecx
ja 0x148b3
movl $0x6a10, %edx           # imm = 0x6A10
btl %ecx, %edx
jae 0x148b3
movq 0xb0(%r14), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x16adb
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x60(%rax), %rax
cmpq 0x4c6c2(%rip), %rax     # 0x60f80
sete %cl
cmpq 0x4c678(%rip), %rax     # 0x60f40
sete %al
orb %cl, %al
jne 0x14897
movq %rsp, %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16810
movq %rax, 0x10(%r15)
xorl %edi, %edi
callq 0x136d3
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x16877
jmp 0x14897
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_symbol_address
static pseudo_t add_symbol_address(struct entrypoint *ep, struct expression *expr)
{
	struct instruction *insn = alloc_typed_instruction(OP_SYMADDR, expr->ctype);
	pseudo_t target = alloc_pseudo(insn);

	insn->target = target;
	use_pseudo(insn, symbol_pseudo(ep, expr->symbol), &insn->src);
	add_one_insn(ep, insn);
	return target;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rsi), %rsi
movl $0x3f, %edi
callq 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x5321e(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x53216(%rip)     # 0x67b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
movq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x16810
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x1499e
movq %rax, %r12
movl 0x4(%rax), %eax
cmpl $0x6, %eax
ja 0x14970
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1499e
movq %rbx, %r13
addq $0x30, %r13
leaq 0x4c832(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x149b7
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x2285b
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_setfval
static pseudo_t add_setfval(struct entrypoint *ep, struct symbol *ctype, long double fval)
{
	struct instruction *insn = alloc_typed_instruction(OP_SETFVAL, ctype);
	pseudo_t target = alloc_pseudo(insn);
	insn->target = target;
	insn->fvalue = fval;
	add_one_insn(ep, insn);
	return target;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
fldt 0x30(%rsp)
fstpt 0x4(%rsp)
movl $0x49, %edi
callq 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x53154(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x5314c(%rip)     # 0x67b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
fldt 0x4(%rsp)
fstpt 0x30(%rbx)
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x14a2f
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x2285b
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_binop
static pseudo_t linearize_binop(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t src1, src2, dst;
	static const int opcode[] = {
		['+'] = OP_ADD, ['-'] = OP_SUB,
		['*'] = OP_MUL, ['/'] = OP_DIVU,
		['%'] = OP_MODU, ['&'] = OP_AND,
		['|'] = OP_OR,  ['^'] = OP_XOR,
		[SPECIAL_LEFTSHIFT] = OP_SHL,
		[SPECIAL_RIGHTSHIFT] = OP_LSR,
	};
	int op;

	src1 = linearize_expression(ep, expr->left);
	src2 = linearize_expression(ep, expr->right);
	op = map_opcode(opcode[expr->op], expr->ctype);
	dst = add_binary_op(ep, expr->ctype, op, src1, src2);
	taint_undefined_behaviour(dst->def);
	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x1447d
movq %rax, %r15
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x1447d
movq %rax, %r12
movslq 0x4(%rbx), %rax
leaq 0x2c069(%rip), %rcx     # 0x41c60
movl (%rcx,%rax,4), %edi
movq 0x10(%rbx), %rbx
movq %rbx, %rsi
callq 0x1749d
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x16d46
movq 0x18(%rax), %rcx
movl (%rcx), %edx
movl %edx, %esi
andl $0x7f, %esi
addl $-0xf, %esi
cmpl $0x2, %esi
ja 0x15c49
movq 0x38(%rcx), %rsi
cmpl $0x6, 0x4(%rsi)
jne 0x15c49
movl %edx, %edi
shrl $0x8, %edi
cmpq %rdi, 0x18(%rsi)
jb 0x15c49
orl $0x80, %edx
movl %edx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_compare
static pseudo_t linearize_compare(struct entrypoint *ep, struct expression *expr)
{
	static const int cmpop[] = {
		['>'] = OP_SET_GT, ['<'] = OP_SET_LT,
		[SPECIAL_EQUAL] = OP_SET_EQ,
		[SPECIAL_NOTEQUAL] = OP_SET_NE,
		[SPECIAL_GTE] = OP_SET_GE,
		[SPECIAL_LTE] = OP_SET_LE,
		[SPECIAL_UNSIGNED_LT] = OP_SET_B,
		[SPECIAL_UNSIGNED_GT] = OP_SET_A,
		[SPECIAL_UNSIGNED_LTE] = OP_SET_BE,
		[SPECIAL_UNSIGNED_GTE] = OP_SET_AE,
	};
	struct symbol *itype = expr->right->ctype;
	int op = opcode_float(cmpop[expr->op], itype);
	pseudo_t src1 = linearize_expression(ep, expr->left);
	pseudo_t src2 = linearize_expression(ep, expr->right);
	pseudo_t dst = add_cmp_op(ep, expr->ctype, op, itype, src1, src2);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq 0x10(%rax), %r12
movslq 0x4(%rsi), %rax
leaq 0x2c07a(%rip), %rcx     # 0x420b0
movl (%rcx,%rax,4), %ebp
testq %r12, %r12
je 0x16069
cmpb $0x3, (%r12)
movq %r12, %rax
jne 0x1604d
movq 0x60(%r12), %rax
movq 0x60(%rax), %rax
cmpq 0x4aee8(%rip), %rax     # 0x60f40
jne 0x16069
movslq %ebp, %rax
leaq 0x2cbec(%rip), %rcx     # 0x42c50
movsbl 0x3(%rcx,%rax,8), %ebp
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1447d
movq %rax, %r15
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x1447d
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x16d46
movq 0x18(%rax), %rcx
movq %r12, 0x40(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_select
static pseudo_t linearize_select(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t cond, valt, valf, res;
	struct instruction *insn;

	valt = linearize_expression(ep, expr->cond_true);
	valf = linearize_expression(ep, expr->cond_false);
	cond = linearize_expression(ep, expr->conditional);

	insn = alloc_typed_instruction(OP_SEL, expr->ctype);
	if (!expr->cond_true)
		valt = cond;
	use_pseudo(insn, cond, &insn->src1);
	use_pseudo(insn, valt, &insn->src2);
	use_pseudo(insn, valf, &insn->src3);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
callq 0x1447d
movq %rax, %r12
movq 0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1447d
movq %rax, %r15
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x1447d
movq %rax, %r13
movq 0x10(%rbp), %rsi
movl $0x41, %edi
callq 0x13602
movq %rax, %r14
cmpq $0x0, 0x28(%rbp)
cmoveq %r13, %r12
movq %r13, 0x30(%rax)
testq %r13, %r13
je 0x16145
movl 0x4(%r13), %eax
cmpl $0x6, %eax
ja 0x1611a
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16145
leaq 0x30(%r14), %rbp
leaq 0x4b08b(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %rbp, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r12, 0x38(%r14)
testq %r12, %r12
je 0x1618d
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16162
movl $0x43, %ecx
btl %eax, %ecx
jb 0x1618d
leaq 0x38(%r14), %r13
leaq 0x4b043(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r15, 0x40(%r14)
testq %r15, %r15
je 0x161d7
movl 0x4(%r15), %eax
cmpl $0x6, %eax
ja 0x161a9
movl $0x43, %ecx
btl %eax, %ecx
jb 0x161d7
movq %r14, %r12
addq $0x40, %r12
leaq 0x4aff9(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r12, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
xorl %edi, %edi
callq 0x303a3
movq %rax, %r15
movl $0x3, 0x4(%rax)
movl 0x51962(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x5195a(%rip)     # 0x67b50
movl %eax, (%r15)
movq %r14, 0x18(%r15)
movq %r15, 0x20(%r14)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1621a
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x2285b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_short_conditional
static pseudo_t linearize_short_conditional(struct entrypoint *ep, struct expression *expr,
					    struct expression *cond,
					    struct expression *expr_false)
{
	pseudo_t src1, src2;
	struct basic_block *bb_false;
	struct basic_block *merge;
	pseudo_t phi1, phi2;

	if (!expr_false || !ep->active)
		return VOID;

	bb_false = alloc_basic_block(ep, expr_false->pos);
	merge = alloc_basic_block(ep, expr->pos);

	src1 = linearize_expression(ep, cond);
	phi1 = alloc_phi(ep->active, src1, expr->ctype);
	add_branch(ep, src1, merge, bb_false);

	set_activeblock(ep, bb_false);
	src2 = linearize_expression(ep, expr_false);
	phi2 = alloc_phi(ep->active, src2, expr->ctype);
	set_activeblock(ep, merge);

	return add_join_conditional(ep, expr, phi1, phi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x16331
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x16331
movq %rcx, %r15
movq %rsi, %rbx
movq 0x8(%rcx), %r12
xorl %edi, %edi
movq %rdx, (%rsp)
callq 0x30217
movq %rax, %r13
movq %r12, (%rax)
movq %r14, 0x10(%rax)
movl 0x51afd(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x51af4(%rip)     # 0x67d70
movl %eax, 0x38(%r13)
movq 0x8(%rbx), %rbp
xorl %edi, %edi
callq 0x30217
movq %rax, %r12
movq %rbp, (%rax)
movq %r14, 0x10(%rax)
movl 0x51ad5(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x51acc(%rip)     # 0x67d70
movl %eax, 0x38(%r12)
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x1447d
movq %rax, %rbp
movq 0x20(%r14), %rdi
movq 0x10(%rbx), %rdx
movq %rax, %rsi
callq 0x13822
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x17395
movq %r14, %rdi
movq %r13, %rsi
callq 0x1401d
movq %r14, %rdi
movq %r15, %rsi
callq 0x1447d
movq 0x20(%r14), %rdi
movq 0x10(%rbx), %rdx
movq %rax, %rsi
callq 0x13822
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x1401d
movq %r14, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1795c
leaq 0x50698(%rip), %rax     # 0x669d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_conditional
static pseudo_t linearize_conditional(struct entrypoint *ep, struct expression *expr,
				      struct expression *cond,
				      struct expression *expr_true,
				      struct expression *expr_false)
{
	pseudo_t src1, src2;
	pseudo_t phi1, phi2;
	struct basic_block *bb_true, *bb_false, *merge;

	if (!cond || !expr_true || !expr_false || !ep->active)
		return VOID;
	bb_true = alloc_basic_block(ep, expr_true->pos);
	bb_false = alloc_basic_block(ep, expr_false->pos);
	merge = alloc_basic_block(ep, expr->pos);

	linearize_cond_branch(ep, cond, bb_true, bb_false);

	set_activeblock(ep, bb_true);
	src1 = linearize_expression(ep, expr_true);
	phi1 = alloc_phi(ep->active, src1, expr->ctype);
	add_goto(ep, merge); 

	set_activeblock(ep, bb_false);
	src2 = linearize_expression(ep, expr_false);
	phi2 = alloc_phi(ep->active, src2, expr->ctype);
	set_activeblock(ep, merge);

	return add_join_conditional(ep, expr, phi1, phi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
jne 0x164ab
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x164ab
movq %r8, %r15
movq 0x8(%rcx), %rbx
xorl %edi, %edi
movq %rsi, (%rsp)
movq %rcx, 0x10(%rsp)
callq 0x30217
movq %rax, %r12
movq %rbx, (%rax)
movq %r14, 0x10(%rax)
movl 0x519cf(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x519c6(%rip)     # 0x67d70
movl %eax, 0x38(%r12)
movq 0x8(%r15), %r13
xorl %edi, %edi
callq 0x30217
movq %rax, %rbx
movq %r13, (%rax)
movq %r14, 0x10(%rax)
movl 0x519a6(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x5199d(%rip)     # 0x67d70
movl %eax, 0x38(%rbx)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x30217
movq %rax, %r13
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movq %r14, 0x10(%r13)
movl 0x51970(%rip), %eax     # 0x67d70
leal 0x1(%rax), %ecx
movl %ecx, 0x51967(%rip)     # 0x67d70
movl %eax, 0x38(%r13)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1703a
movq %r14, %rdi
movq %r12, %rsi
callq 0x1401d
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x1447d
movq 0x20(%r14), %rdi
movq (%rsp), %rbp
movq 0x10(%rbp), %rdx
movq %rax, %rsi
callq 0x13822
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x143fb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1401d
movq %r14, %rdi
movq %r15, %rsi
callq 0x1447d
movq 0x20(%r14), %rdi
movq 0x10(%rbp), %rdx
movq %rax, %rsi
callq 0x13822
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1401d
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1795c
leaq 0x5051e(%rip), %rax     # 0x669d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_assignment
static pseudo_t linearize_assignment(struct entrypoint *ep, struct expression *expr)
{
	struct access_data ad = { NULL, };
	struct expression *target = expr->left;
	struct expression *src = expr->right;
	struct symbol *ctype;
	pseudo_t value;

	value = linearize_expression(ep, src);
	if (!target || !linearize_address_gen(ep, target, &ad))
		return value;
	if (expr->op != '=') {
		pseudo_t oldvalue = linearize_load_gen(ep, &ad);
		pseudo_t dst;
		static const int op_trans[] = {
			[SPECIAL_ADD_ASSIGN - SPECIAL_BASE] = OP_ADD,
			[SPECIAL_SUB_ASSIGN - SPECIAL_BASE] = OP_SUB,
			[SPECIAL_MUL_ASSIGN - SPECIAL_BASE] = OP_MUL,
			[SPECIAL_DIV_ASSIGN - SPECIAL_BASE] = OP_DIVU,
			[SPECIAL_MOD_ASSIGN - SPECIAL_BASE] = OP_MODU,
			[SPECIAL_SHL_ASSIGN - SPECIAL_BASE] = OP_SHL,
			[SPECIAL_SHR_ASSIGN - SPECIAL_BASE] = OP_LSR,
			[SPECIAL_AND_ASSIGN - SPECIAL_BASE] = OP_AND,
			[SPECIAL_OR_ASSIGN  - SPECIAL_BASE] = OP_OR,
			[SPECIAL_XOR_ASSIGN - SPECIAL_BASE] = OP_XOR
		};
		int opcode;

		if (!src)
			return VOID;

		ctype = src->ctype;
		oldvalue = cast_pseudo(ep, oldvalue, target->ctype, ctype);
		opcode = map_opcode(op_trans[expr->op - SPECIAL_BASE], ctype);
		dst = add_binary_op(ep, ctype, opcode, oldvalue, value);
		taint_undefined_behaviour(dst->def);
		value = cast_pseudo(ep, dst, ctype, expr->ctype);
	}
	value = linearize_store_gen(ep, value, &ad);
	return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r14
movq %r14, %rsi
callq 0x1447d
movq %rax, %r12
testq %rbp, %rbp
je 0x165d3
movq %rsp, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17aba
testl %eax, %eax
je 0x165d3
cmpl $0x3d, 0x4(%r15)
je 0x165c2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b03
testq %r14, %r14
je 0x165bd
movq 0x10(%r14), %r13
movq 0x10(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rcx
callq 0x175ad
movq %rax, %rbp
movslq 0x4(%r15), %rax
leaq 0x2bfda(%rip), %rcx     # 0x42530
movl -0x400(%rcx,%rax,4), %edi
movq %r13, %rsi
callq 0x1749d
movq %rbx, %rdi
movq %r13, %rsi
movl %eax, %edx
movq %rbp, %rcx
movq %r12, %r8
callq 0x16d46
movq 0x18(%rax), %rcx
movl (%rcx), %edx
movl %edx, %esi
andl $0x7f, %esi
addl $-0xf, %esi
cmpl $0x2, %esi
ja 0x165a8
movq 0x38(%rcx), %rsi
cmpl $0x6, 0x4(%rsi)
jne 0x165a8
movl %edx, %edi
shrl $0x8, %edi
cmpq %rdi, 0x18(%rsi)
jb 0x165a8
orl $0x80, %edx
movl %edx, (%rcx)
movq 0x10(%r15), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x175ad
movq %rax, %r12
testq %r14, %r14
je 0x165e5
movq %rsp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16877
movq %rax, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x503e4(%rip), %r12     # 0x669d0
jmp 0x165d3
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_preop
static pseudo_t linearize_preop(struct entrypoint *ep, struct expression *expr)
{
	/*
	 * '*' is an lvalue access, and is fundamentally different
	 * from an arithmetic operation. Maybe it should have an
	 * expression type of its own..
	 */
	if (expr->op == '*')
		return linearize_access(ep, expr);
	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
		return linearize_inc_dec(ep, expr, 0);
	return linearize_regular_preop(ep, expr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl 0x4(%rsi), %eax
cmpl $0x103, %eax            # imm = 0x103
je 0x16644
cmpl $0x101, %eax            # imm = 0x101
je 0x16644
cmpl $0x2a, %eax
jne 0x1665c
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17aba
testl %eax, %eax
je 0x166a1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17b03
movq %rax, %r14
jmp 0x166db
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17c1b
movq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x1447d
movq %rax, %r14
movq 0x10(%r12), %r15
movl 0x4(%r12), %eax
cmpl $0x2c, %eax
jg 0x16687
cmpl $0x21, %eax
je 0x166aa
cmpl $0x2b, %eax
je 0x166db
jmp 0x166a1
cmpl $0x2d, %eax
je 0x166ea
cmpl $0x7e, %eax
jne 0x166a1
movq %rbx, %rdi
movq %r15, %rsi
movl $0x31, %edx
jmp 0x16722
leaq 0x50328(%rip), %r14     # 0x669d0
jmp 0x166db
xorl %edi, %edi
callq 0x136d3
movq 0x20(%r12), %rcx
movq 0x10(%rcx), %r12
movq %rbx, %rdi
movq %r15, %rsi
movl $0x27, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x16d46
movq %rax, %r14
movq 0x18(%rax), %rax
movq %r12, 0x40(%rax)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x32, %edx
testq %r15, %r15
je 0x1671c
cmpb $0x3, (%r15)
movq %r15, %rax
jne 0x16701
movq 0x60(%r15), %rax
movq 0x60(%rax), %rax
cmpq 0x4a834(%rip), %rax     # 0x60f40
jne 0x1671c
leaq 0x2c53b(%rip), %rax     # 0x42c50
movsbl 0x193(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16e4b
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_slice
static pseudo_t linearize_slice(struct entrypoint *ep, struct expression *expr)
{
	pseudo_t pre = linearize_expression(ep, expr->base);
	struct instruction *insn = alloc_typed_instruction(OP_SLICE, expr->ctype);
	pseudo_t new = alloc_pseudo(insn);

	insn->target = new;
	insn->from = expr->r_bitpos;
	insn->orig_type = expr->base->ctype;
	use_pseudo(insn, pre, &insn->src);
	add_one_insn(ep, insn);
	return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
callq 0x1447d
movq %rax, %r12
movq 0x10(%r13), %rsi
movl $0x40, %edi
callq 0x13602
movq %rax, %r14
xorl %edi, %edi
callq 0x303a3
movq %rax, %r15
movl $0x3, 0x4(%rax)
movl 0x513d8(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x513d0(%rip)     # 0x67b50
movl %eax, (%r15)
movq %r14, 0x18(%r15)
movq %r15, 0x20(%r14)
movl 0x28(%r13), %eax
movl %eax, 0x38(%r14)
movq 0x20(%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%r14)
movq %r12, 0x30(%r14)
testq %r12, %r12
je 0x167ea
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x167bc
movl $0x43, %ecx
btl %eax, %ecx
jb 0x167ea
movq %r14, %r13
addq $0x30, %r13
leaq 0x4a9e6(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r14, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x16803
movq %rdi, 0x8(%r14)
addq $0x28, %rdi
movq %r14, %rsi
callq 0x2285b
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: symbol_pseudo
static pseudo_t symbol_pseudo(struct entrypoint *ep, struct symbol *sym)
{
	pseudo_t pseudo;

	if (!sym)
		return VOID;

	pseudo = sym->pseudo;
	if (!pseudo) {
		pseudo = __alloc_pseudo(0);
		pseudo->nr = -1;
		pseudo->type = PSEUDO_SYM;
		pseudo->sym = sym;
		pseudo->ident = sym->ident;
		sym->pseudo = pseudo;
		add_pseudo(&ep->accesses, pseudo);
	}
	/* Symbol pseudos have neither nr nor def */
	return pseudo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x16867
movq %rsi, %r15
movq 0xd8(%rsi), %rbx
testq %rbx, %rbx
jne 0x1686e
movq %rdi, %r14
xorl %edi, %edi
callq 0x303a3
movq %rax, %rbx
movabsq $0x5ffffffff, %rax      # imm = 0x5FFFFFFFF
movq %rax, (%rbx)
movq %r15, 0x18(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0xd8(%r15)
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2285b
jmp 0x1686e
leaq 0x50162(%rip), %rbx     # 0x669d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_initializer
static pseudo_t linearize_initializer(struct entrypoint *ep, struct expression *initializer, struct access_data *ad)
{
	switch (initializer->type) {
	case EXPR_INITIALIZER: {
		struct expression *expr;
		FOR_EACH_PTR(initializer->expr_list, expr) {
			linearize_initializer(ep, expr, ad);
		} END_FOR_EACH_PTR(expr);
		break;
	}
	case EXPR_POS:
		ad->offset = initializer->init_offset;
		linearize_initializer(ep, initializer->init_expr, ad);
		break;
	default: {
		pseudo_t value = linearize_expression(ep, initializer);
		ad->type = initializer->ctype;
		linearize_store_gen(ep, value, ad);
		return value;
	}
	}

	return VOID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x4fed8(%rip), %rbx     # 0x669d0
movzbl (%r12), %eax
cmpl $0x1b, %eax
jne 0x16b1d
movl 0x20(%r12), %eax
movq %rax, 0x18(%r14)
movq 0x28(%r12), %r12
testb $0x1, %bpl
cmoveq %rbx, %r13
movb $0x1, %bpl
jmp 0x16af8
cmpl $0x18, %eax
jne 0x16b84
movq %r13, (%rsp)
movq 0x20(%r12), %r13
testq %r13, %r13
je 0x16b7e
movq %r13, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x16b6d
xorl %ebx, %ebx
movq 0x18(%r12,%rbx,8), %rsi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x16b52
testq %rsi, %rsi
je 0x16b5d
movq %r15, %rdi
movq %r14, %rdx
callq 0x16adb
incq %rbx
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0x16b3e
movq 0x10(%r12), %r12
cmpq %r13, %r12
jne 0x16b33
leaq 0x4fe52(%rip), %rbx     # 0x669d0
movq (%rsp), %r13
jmp 0x16ba8
movq %r15, %rdi
movq %r12, %rsi
callq 0x1447d
movq %rax, %rbx
movq 0x10(%r12), %rax
movq %rax, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16877
testb $0x1, %bpl
cmovneq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: bitfield_base_type
static struct symbol *bitfield_base_type(struct symbol *sym)
{
	struct symbol *base = sym;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x16c39
cmpb $0x3, (%rbx)
movq %rbx, %rax
jne 0x16bda
movq 0x60(%rbx), %rax
cmpb $0xb, (%rax)
jne 0x16c39
movq 0x60(%rax), %r14
movl 0x54(%rbx), %eax
btl $0x15, %eax
jb 0x16bf1
movq %r14, %rbx
jmp 0x16c39
movzbl %al, %eax
addl 0x50(%rbx), %eax
js 0x16c0d
leaq 0x4eb00(%rip), %rcx     # 0x65700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
jmp 0x16c12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %edi, %edi
callq 0x2ff60
movq %rax, %rbx
movl $0xe0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe1e0
leaq 0x4eacd(%rip), %rax     # 0x65700
imull (%rax), %ebp
movl %ebp, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_load
static pseudo_t add_load(struct entrypoint *ep, struct access_data *ad)
{
	struct instruction *insn;
	pseudo_t new;

	if (!ep->active)
		return VOID;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x16d2d
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rsi
movl $0x43, %edi
callq 0x13602
movq %rax, %r15
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x303a3
movq %rax, %rbx
movl $0x3, 0x4(%rax)
movl 0x50ec9(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x50ec1(%rip)     # 0x67b50
movl %eax, (%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, 0x20(%r15)
movq 0x18(%r12), %rax
movq %rax, 0x38(%r15)
movq (%r12), %rax
testq %rax, %rax
je 0x16cb5
movl 0x68(%rax), %ebp
shrl $0xa, %ebp
andb $0x1, %bpl
movb 0x40(%r15), %al
andb $-0x2, %al
orb %bpl, %al
movb %al, 0x40(%r15)
movq 0x10(%r12), %r12
movq %r12, 0x30(%r15)
testq %r12, %r12
je 0x16d12
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16ce4
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16d12
movq %r15, %r13
addq $0x30, %r13
leaq 0x4a4be(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %r15, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x16d34
movq %rdi, 0x8(%r15)
addq $0x28, %rdi
movq %r15, %rsi
callq 0x2285b
jmp 0x16d34
leaq 0x4fc9c(%rip), %rbx     # 0x669d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/linearize.c
// Function: add_binary_op
static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right)
{
	struct instruction *insn = alloc_typed_instruction(op, ctype);
	pseudo_t target = alloc_pseudo(insn);
	insn->target = target;
	use_pseudo(insn, left, &insn->src1);
	use_pseudo(insn, right, &insn->src2);
	add_one_insn(ep, insn);
	return target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %r15
movl %edx, %edi
callq 0x13602
movq %rax, %rbx
xorl %edi, %edi
callq 0x303a3
movq %rax, %r14
movl $0x3, 0x4(%rax)
movl 0x50dd5(%rip), %eax     # 0x67b50
incl %eax
movl %eax, 0x50dcd(%rip)     # 0x67b50
movl %eax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, 0x20(%rbx)
movq %r13, 0x30(%rbx)
testq %r13, %r13
je 0x16dd5
movl 0x4(%r13), %eax
cmpl $0x6, %eax
ja 0x16daa
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16dd5
leaq 0x30(%rbx), %rbp
leaq 0x4a3fb(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %rbp, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x2285b
movq %r12, 0x38(%rbx)
testq %r12, %r12
je 0x16e20
movl 0x4(%r12), %eax
cmpl $0x6, %eax
ja 0x16df2
movl $0x43, %ecx
btl %eax, %ecx
jb 0x16e20
movq %rbx, %r13
addq $0x38, %r13
leaq 0x4a3b0(%rip), %rdi     # 0x611b0
movl $0x10, %esi
callq 0x2fd3c
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2285b
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x16e39
movq %rdi, 0x8(%rbx)
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x2285b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq