LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x54(%rbp)
subl $0x18, %eax
je 0x1d896
jmp 0x1d885
movl -0x54(%rbp), %eax
subl $0x1b, %eax
je 0x1d93c
jmp 0x1d964
jmp 0x1d898
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1d8bd
jmp 0x1d93a
jmp 0x1d8bf
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1d926
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1d90a
cmpq $0x0, -0x28(%rbp)
jne 0x1d90a
jmp 0x1d91b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1d860
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1d8c6
jmp 0x1d928
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x1d8bf
jmp 0x1d99f
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1d860
jmp 0x1d99f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bb90
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1d790
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d9aa
leaq 0x6e40a(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1da89
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x1d9fb
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0xb, %eax
jne 0x1da87
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x15, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1da7d
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
andl $0xff, %edi
movq -0x10(%rbp), %rax
addl 0x50(%rax), %edi
callq 0x1ddb0
movl %eax, -0x1c(%rbp)
xorl %edi, %edi
callq 0x46b60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
movl -0x1c(%rbp), %edi
callq 0x1ddf0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1da91
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1da91
jmp 0x1da89
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1dacb
leaq 0x6e2ee(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x1db7e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x43, %edi
callq 0x1a240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a340
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x1db34
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x68(%rax), %rax
andq $0x400, %rax            # imm = 0x400
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movb 0x40(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x40(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b5b0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_bitfield_insert
static pseudo_t linearize_bitfield_insert(struct entrypoint *ep,
	pseudo_t ori, pseudo_t val, struct symbol *ctype, struct symbol *btype)
{
	unsigned int shift = ctype->bit_offset;
	unsigned int size = ctype->bit_size;
	unsigned long long mask = ((1ULL << size) - 1);
	unsigned long long smask= bits_mask(btype->bit_size);

	val = add_cast(ep, btype, ctype, OP_ZEXT, val);
	if (shift) {
		val = add_binary_op(ep, btype, OP_SHL, val, value_pseudo(shift));
		mask <<= shift;
	}
	ori = add_binary_op(ep, btype, OP_AND, ori, value_pseudo(~mask & smask));
	val = add_binary_op(ep, btype, OP_OR, ori, val);

	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x1de10
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0x35, %ecx
callq 0x1de40
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1dc5d
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0x1a390
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq %rax, %r8
movl $0x11, %edx
callq 0x1de90
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
xorq $-0x1, %rdi
andq -0x40(%rbp), %rdi
callq 0x1a390
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
movq %rax, %r8
movl $0x16, %edx
callq 0x1de90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x17, %edx
callq 0x1de90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_store
static void add_store(struct entrypoint *ep, struct access_data *ad, pseudo_t value)
{
	struct basic_block *bb = ep->active;
	struct instruction *store;

	if (!bb)
		return;

	store = alloc_typed_instruction(OP_STORE, ad->btype);
	store->offset = ad->offset;
	store->is_volatile = ad->type && (ad->type->ctype.modifiers & MOD_VOLATILE);
	use_pseudo(store, value, &store->target);
	use_pseudo(store, ad->address, &store->src);
	add_one_insn(ep, store);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1dcfc
jmp 0x1dda3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x44, %edi
callq 0x1a240
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x1dd4c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x68(%rax), %rax
andq $0x400, %rax            # imm = 0x400
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x28(%rbp), %rax
movb %cl, %dl
movb 0x40(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x40(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x20, %rdx
callq 0x1a290
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b5b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1a240
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a340
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x30, %rdx
addq $0x8, %rdx
callq 0x1a290
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1b5b0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_unop
static pseudo_t add_unop(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t src)
{
	struct instruction *insn = alloc_typed_instruction(op, ctype);
	pseudo_t new = alloc_pseudo(insn);

	insn->target = new;
	use_pseudo(insn, src, &insn->src1);
	add_one_insn(ep, insn);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1a240
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1a340
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b5b0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_declaration
static pseudo_t linearize_declaration(struct entrypoint *ep, struct statement *stmt)
{
	struct symbol *sym;

	concat_symbol_list(stmt->declaration, &ep->syms);

	FOR_EACH_PTR(stmt->declaration, sym) {
		linearize_one_symbol(ep, sym);
	} END_FOR_EACH_PTR(sym);
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b600
movq -0x10(%rbp), %rax
movq 0x10(%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 0x1dffa
jmp 0x1e073
jmp 0x1dffc
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 0x1e05f
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 0x1e047
cmpq $0x0, -0x18(%rbp)
jne 0x1e047
jmp 0x1e054
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bf90
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e003
jmp 0x1e061
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x1dffc
leaq 0x6dd36(%rip), %rax     # 0x8bdb0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_context
static pseudo_t linearize_context(struct entrypoint *ep, struct statement *stmt)
{
	struct instruction *insn = alloc_instruction(OP_CONTEXT, 0);
	struct expression *expr = stmt->expression;

	insn->increment = get_expression_value(expr);
	insn->context_expr = stmt->context;
	add_one_insn(ep, insn);
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4f, %edi
xorl %esi, %esi
callq 0x1afb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11ff0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5b0
leaq 0x6dcce(%rip), %rax     # 0x8bdb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_range
static pseudo_t linearize_range(struct entrypoint *ep, struct statement *stmt)
{
	struct instruction *insn = alloc_instruction(OP_RANGE, 0);

	use_pseudo(insn, linearize_expression(ep, stmt->range_expression), &insn->src1);
	use_pseudo(insn, linearize_expression(ep, stmt->range_low), &insn->src2);
	use_pseudo(insn, linearize_expression(ep, stmt->range_high), &insn->src3);
	add_one_insn(ep, insn);
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x50, %edi
xorl %esi, %esi
callq 0x1afb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1bb90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1bb90
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
addq $0x8, %rdx
callq 0x1a290
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1bb90
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
addq $0x10, %rdx
callq 0x1a290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5b0
leaq 0x6dbfd(%rip), %rax     # 0x8bdb0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_return
static pseudo_t linearize_return(struct entrypoint *ep, struct statement *stmt)
{
	struct expression *expr = stmt->expression;
	struct symbol *ret = stmt->ret_target;
	struct basic_block *bb_return = get_bound_block(ep, ret);
	struct basic_block *active;
	pseudo_t src = linearize_expression(ep, expr);
	active = ep->active;
	if (active && !is_void_type(ret)) {
		add_return(ep, bb_return, ret, src);
	}
	add_goto(ep, bb_return);
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e310
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bb90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1e240
movq -0x20(%rbp), %rdi
callq 0x1ee10
cmpl $0x0, %eax
jne 0x1e240
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1ee50
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b930
leaq 0x6db5c(%rip), %rax     # 0x8bdb0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_label
static struct basic_block * add_label(struct entrypoint *ep, struct symbol *label)
{
	struct basic_block *bb = label->bb_target;

	if (bb) {
		set_activeblock(ep, bb);
		return bb;
	}
	bb = ep->active;
	if (!bb_reachable(bb) || !bb_empty(bb)) {
		bb = alloc_basic_block(ep, label->pos);
		set_activeblock(ep, bb);
	}
	label->bb_target = bb;
	return bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e29d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b170
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e2fe
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b9d0
cmpl $0x0, %eax
je 0x1e2c5
movq -0x20(%rbp), %rdi
callq 0x1ef80
cmpl $0x0, %eax
jne 0x1e2e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rsi
callq 0x1b110
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b170
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: get_bound_block
static struct basic_block * get_bound_block(struct entrypoint *ep, struct symbol *label)
{
	struct basic_block *bb = label->bb_target;

	if (!bb) {
		bb = alloc_basic_block(ep, label->pos);
		label->bb_target = bb;
	}
	return bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e35a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rsi
callq 0x1b110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: alloc_multijmp
static struct multijmp *alloc_multijmp(struct basic_block *target, long long begin, long long end)
{
	struct multijmp *multijmp = __alloc_multijmp(0);
	multijmp->target = target;
	multijmp->begin = begin;
	multijmp->end = end;
	return multijmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %edi, %edi
callq 0x474c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_inlined_call
static pseudo_t linearize_inlined_call(struct entrypoint *ep, struct statement *stmt)
{
	struct instruction *insn = alloc_instruction(OP_INLINED_CALL, 0);
	struct statement *args = stmt->args;
	struct basic_block *bb;
	pseudo_t pseudo;

	if (args) {
		struct symbol *sym;

		concat_symbol_list(args->declaration, &ep->syms);
		FOR_EACH_PTR(args->declaration, sym) {
			pseudo_t value = linearize_one_symbol(ep, sym);
			add_pseudo(&insn->arguments, value);
		} END_FOR_EACH_PTR(sym);
	}

	pseudo = linearize_fn_statement(ep, stmt);
	insn->target = pseudo;

	insn->func = symbol_pseudo(ep, stmt->inline_fn);
	bb = ep->active;
	if (!bb->insns)
		bb->pos = stmt->pos;
	add_one_insn(ep, insn);
	return pseudo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4b, %edi
xorl %esi, %esi
callq 0x1afb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e53c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b600
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x1e4a4
jmp 0x1e53a
jmp 0x1e4a6
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1e522
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1e4f1
cmpq $0x0, -0x38(%rbp)
jne 0x1e4f1
jmp 0x1e517
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1bf90
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
addq $0x8, %rdi
movq -0x60(%rbp), %rsi
callq 0x1a4b0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x1e4ad
jmp 0x1e524
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x1e4a6
jmp 0x1e53c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b6a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1d630
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1e59b
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x4(%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5b0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_compound_statement
static pseudo_t linearize_compound_statement(struct entrypoint *ep, struct statement *stmt)
{
	pseudo_t pseudo;
	struct statement *s;

	pseudo = VOID;
	FOR_EACH_PTR(stmt->stmts, s) {
		pseudo = linearize_statement(ep, s);
	} END_FOR_EACH_PTR(s);

	return pseudo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6d7d9(%rip), %rax     # 0x8bdb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e600
jmp 0x1e67d
jmp 0x1e602
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1e669
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1e64d
cmpq $0x0, -0x20(%rbp)
jne 0x1e64d
jmp 0x1e65e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c230
movq %rax, -0x18(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1e609
jmp 0x1e66b
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x1e602
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_cond_branch
static pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
{
	pseudo_t cond;

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

	switch (expr->type) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1e6d3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1bf60
cmpl $0x0, %eax
je 0x1e6d3
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1b9d0
cmpl $0x0, %eax
jne 0x1e6e3
leaq 0x6d6d6(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x1e822
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x1b, %eax
ja 0x1e7f1
movq -0x38(%rbp), %rax
leaq 0x443be(%rip), %rcx     # 0x62ac4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1e72c
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1e734
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1b930
jmp 0x1e817
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
fldt 0x20(%rax)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x1e763
jp 0x1e763
jmp 0x1e76d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x1e775
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1b930
jmp 0x1e817
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1efa0
jmp 0x1e817
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cee0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1f050
jmp 0x1e817
movq -0x18(%rbp), %rax
cmpl $0x21, 0x4(%rax)
jne 0x1e7ef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1e690
movq %rax, -0x8(%rbp)
jmp 0x1e822
jmp 0x1e7f1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f120
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1f050
leaq 0x6d592(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_return
static void add_return(struct entrypoint *ep, struct basic_block *bb, struct symbol *ctype, pseudo_t src)
{
	struct instruction *phi_node = first_instruction(bb->insns);
	pseudo_t phi;
	if (!phi_node) {
		phi_node = alloc_typed_instruction(OP_PHI, ctype);
		phi_node->target = alloc_pseudo(phi_node);
		phi_node->bb = bb;
		add_instruction(&bb->insns, phi_node);
	}
	phi = alloc_phi(ep->active, src, ctype);
	phi->ident = &return_ident;
	link_phi(phi_node, phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1ef00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1eec3
movq -0x18(%rbp), %rsi
movl $0x46, %edi
callq 0x1a240
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1a340
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0x1a620
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1a5b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
leaq 0x6aee1(%rip), %rcx     # 0x89dc8
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1ef20
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_logical_branch
static pseudo_t linearize_logical_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
{
	struct basic_block *next = alloc_basic_block(ep, expr->pos);

	if (expr->op == SPECIAL_LOGICAL_OR)
		linearize_cond_branch(ep, expr->left, bb_true, next);
	else
		linearize_cond_branch(ep, expr->left, next, bb_false);
	set_activeblock(ep, next);
	linearize_cond_branch(ep, expr->right, bb_true, bb_false);
	return VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1b110
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10e, 0x4(%rax)       # imm = 0x10E
jne 0x1eff5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e690
jmp 0x1f00e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1e690
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1e690
leaq 0x6cd75(%rip), %rax     # 0x8bdb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_branch
static void add_branch(struct entrypoint *ep, pseudo_t cond, struct basic_block *bb_true, struct basic_block *bb_false)
{
	struct basic_block *bb = ep->active;
	struct instruction *br;

	if (bb_reachable(bb)) {
		br = alloc_instruction(OP_CBR, 0);
		use_pseudo(br, cond, &br->cond);
		br->bb_true = bb_true;
		br->bb_false = bb_false;
		add_bb(&bb_true->parents, bb);
		add_bb(&bb_false->parents, bb);
		add_bb(&bb->children, bb_true);
		add_bb(&bb->children, bb_false);
		add_one_insn(ep, br);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b9d0
cmpl $0x0, %eax
je 0x1f114
movl $0x4, %edi
xorl %esi, %esi
callq 0x1afb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x30, %rdx
callq 0x1a290
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x1b9f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x1b9f0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x1b9f0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x1b9f0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1b5b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_convert_to_bool
static inline pseudo_t add_convert_to_bool(struct entrypoint *ep, pseudo_t src, struct symbol *type)
{
	pseudo_t zero;
	int op;

	if (!type || src == VOID)
		return VOID;
	if (is_bool_type(type))
		return src;
	if (src->type == PSEUDO_VAL && (src->value == 0 || src->value == 1))
		return src;
	if (is_float_type(type)) {
		zero = add_setfval(ep, type, 0.0);
		op = map_opcode(OP_SET_NE, type);
	} else {
		zero = value_pseudo(0);
		op = OP_SET_NE;
	}
	return add_cmp_op(ep, &bool_ctype, op, type, src, zero);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f198
leaq 0x6cc1e(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x18(%rbp)
jne 0x1f1a8
leaq 0x6cc11(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x1f25d
movq -0x20(%rbp), %rdi
callq 0x1f270
cmpl $0x0, %eax
je 0x1f1c3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f25d
movq -0x18(%rbp), %rax
cmpl $0x6, 0x4(%rax)
jne 0x1f1ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f1e3
movq -0x18(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x1f1ed
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f25d
movq -0x20(%rbp), %rdi
callq 0x1f2b0
cmpl $0x0, %eax
je 0x1f226
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rsp, %rax
fldz
fstpt (%rax)
callq 0x1c1c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movl $0x30, %edi
callq 0x1f2f0
movl %eax, -0x2c(%rbp)
jmp 0x1f23a
xorl %eax, %eax
movl %eax, %edi
callq 0x1a390
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x721c4(%rip), %rsi     # 0x91418
callq 0x1f390
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/linearize.c
// Function: map_opcode
static int map_opcode(int opcode, struct symbol *ctype)
{
	if (ctype && is_float_type(ctype))
		return opcode_table[opcode].to_float;
	if (ctype && (ctype->ctype.modifiers & MOD_SIGNED)) {
		switch(opcode) {
		case OP_DIVU: case OP_MODU: case OP_LSR:
			opcode++;
		}
	}
	return opcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f330
movq -0x10(%rbp), %rdi
callq 0x1f2b0
cmpl $0x0, %eax
je 0x1f330
movslq -0x8(%rbp), %rcx
leaq 0x44831(%rip), %rax     # 0x63b50
movq (%rax,%rcx,8), %rax
shlq $0x20, %rax
sarq $0x38, %rax
movl %eax, -0x4(%rbp)
jmp 0x1f37d
cmpq $0x0, -0x10(%rbp)
je 0x1f377
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x2000, %rax           # imm = 0x2000
cmpq $0x0, %rax
je 0x1f377
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0xb, %eax
je 0x1f36c
jmp 0x1f358
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x1f36c
jmp 0x1f362
movl -0x14(%rbp), %eax
subl $0xf, %eax
jne 0x1f375
jmp 0x1f36c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1f377
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: multijmp_cmp
static int multijmp_cmp(const void *_a, const void *_b)
{
	const struct multijmp *a = _a;
	const struct multijmp *b = _b;

	// "default" case?
	if (a->begin > a->end) {
		if (b->begin > b->end)
			return 0;
		return 1;
	}
	if (b->begin > b->end)
		return -1;
	if (a->begin == b->begin) {
		if (a->end == b->end)
			return 0;
		return (a->end < b->end) ? -1 : 1;
	}
	return a->begin < b->begin ? -1 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x1f4d8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x1f4cc
movl $0x0, -0x4(%rbp)
jmp 0x1f568
movl $0x1, -0x4(%rbp)
jmp 0x1f568
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x1f4f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f568
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1f545
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1f520
movl $0x0, -0x4(%rbp)
jmp 0x1f568
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1f568
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: get_mtype
static enum mtype get_mtype(struct symbol *s)
{
	int sign = (s->ctype.modifiers & MOD_SIGNED) ? 1 : 0;

retry:	switch (s->type) {
	case SYM_NODE:
		s = s->ctype.base_type;
		goto retry;
	case SYM_PTR:
		if (s->ctype.base_type == &void_ctype)
			return MTYPE_VPTR;
		return MTYPE_PTR;
	case SYM_BITFIELD:
	case SYM_RESTRICT:
	case SYM_FOULED:
	case SYM_ENUM:
		s = s->ctype.base_type;
		/* fall-through */
	case_int:
		return sign ? MTYPE_SINT : MTYPE_UINT;
	case SYM_BASETYPE:
		if (s->ctype.base_type == &fp_type)
			return MTYPE_FLOAT;
		if (s->ctype.base_type == &int_type)
			goto case_int;
		/* fall-through */
	default:
		return MTYPE_BAD;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
andq $0x2000, %rdx           # imm = 0x2000
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xc, %eax
ja 0x1fb46
movq -0x20(%rbp), %rax
leaq 0x430a0(%rip), %rcx     # 0x62b5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1fa98
movq -0x10(%rbp), %rax
leaq 0x71a1a(%rip), %rcx     # 0x914f8
cmpq %rcx, 0x60(%rax)
jne 0x1faed
movl $0x3, -0x4(%rbp)
jmp 0x1fb4d
movl $0x2, -0x4(%rbp)
jmp 0x1fb4d
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1fb4d
movq -0x10(%rbp), %rax
leaq 0x71816(%rip), %rcx     # 0x91338
cmpq %rcx, 0x60(%rax)
jne 0x1fb31
movl $0x4, -0x4(%rbp)
jmp 0x1fb4d
movq -0x10(%rbp), %rax
leaq 0x7171c(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
jne 0x1fb44
jmp 0x1fb02
jmp 0x1fb46
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: taint_undefined_behaviour
static void taint_undefined_behaviour(struct instruction *insn)
{
	pseudo_t src2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
addl $-0xf, %eax
subl $0x2, %eax
ja 0x1fbc1
jmp 0x1fb7b
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, 0x4(%rax)
je 0x1fb93
jmp 0x1fbc1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x8, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x1fbbf
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
orl $0x80, %ecx
movl %ecx, (%rax)
jmp 0x1fbc1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: insert_phis
static void insert_phis(struct basic_block *bb, pseudo_t src, struct symbol *ctype,
	struct instruction *node)
{
	struct basic_block *parent;

	FOR_EACH_PTR(bb->parents, parent) {
		struct instruction *phisrc = alloc_phisrc(src, ctype);
		insert_last_instruction(parent, phisrc);
		link_phi(node, phisrc->target);
	} END_FOR_EACH_PTR(parent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1fc10
jmp 0x1fcaf
jmp 0x1fc12
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1fc97
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1fc5d
cmpq $0x0, -0x28(%rbp)
jne 0x1fc5d
jmp 0x1fc8c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a520
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1a2e0
movq -0x20(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1ef20
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1fc19
jmp 0x1fc99
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x1fc12
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: add_join_conditional
static pseudo_t add_join_conditional(struct entrypoint *ep, struct expression *expr,
				     pseudo_t phi1, pseudo_t phi2)
{
	pseudo_t target;
	struct instruction *phi_node;

	if (phi1 == VOID)
		return (phi2 == VOID) ? phi2 : phi2->def->src;
	if (phi2 == VOID)
		return (phi1 == VOID) ? phi1 : phi1->def->src;

	phi_node = alloc_typed_instruction(OP_PHI, expr->ctype);
	link_phi(phi_node, phi1);
	link_phi(phi_node, phi2);
	phi_node->target = target = alloc_pseudo(phi_node);
	add_one_insn(ep, phi_node);
	return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x6c081(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x20(%rbp)
jne 0x1fd69
leaq 0x6c074(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x28(%rbp)
jne 0x1fd4c
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1fd5c
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fe04
leaq 0x6c040(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x28(%rbp)
jne 0x1fda7
leaq 0x6c033(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x20(%rbp)
jne 0x1fd8d
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1fd9d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fe04
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x46, %edi
callq 0x1a240
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1ef20
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1ef20
movq -0x38(%rbp), %rdi
callq 0x1a340
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1b5b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_address_gen
static int linearize_address_gen(struct entrypoint *ep,
	struct expression *expr,
	struct access_data *ad)
{
	struct symbol *ctype = expr->ctype;

	if (!ctype)
		return 0;
	ad->type = ctype;
	if (expr->type == EXPR_PREOP && expr->op == '*')
		return linearize_simple_address(ep, expr->unop, ad);

	warning(expr->pos, "generating address of non-lvalue (%d)", expr->type);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1fe40
movl $0x0, -0x4(%rbp)
jmp 0x1fea8
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
jne 0x1fe7f
movq -0x18(%rbp), %rax
cmpl $0x2a, 0x4(%rax)
jne 0x1fe7f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ff60
movl %eax, -0x4(%rbp)
jmp 0x1fea8
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
andl $0xff, %edx
movq 0x8(%rax), %rdi
leaq 0x43bed(%rip), %rsi     # 0x63a87
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/linearize.c
// Function: linearize_load_gen
static pseudo_t linearize_load_gen(struct entrypoint *ep, struct access_data *ad)
{
	struct symbol *ctype = ad->type;
	struct symbol *btype;
	pseudo_t new;

	if (!ep->active)
		return VOID;

	btype = ad->btype = bitfield_base_type(ctype);
	new = add_load(ep, ad);
	if (ctype->bit_size != type_size(btype))
		new = linearize_bitfield_extract(ep, new, ctype, btype);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1fef3
leaq 0x6bec3(%rip), %rax     # 0x8bdb0
movq %rax, -0x8(%rbp)
jmp 0x1ff56
movq -0x20(%rbp), %rdi
callq 0x1d9c0
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1daa0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19440
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
je 0x1ff4e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x20050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq