LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_call
static void generate_call(struct bb_state *state, struct instruction *insn)
{
	int offset = 0;
	pseudo_t arg;

	FOR_EACH_PTR(insn->arguments, arg) {
		output_insn(state, "pushl %s", generic(state, arg));
		offset += 4;
	} END_FOR_EACH_PTR(arg);
	flush_reg(state, hardregs+0);
	flush_reg(state, hardregs+1);
	flush_reg(state, hardregs+2);
	output_insn(state, "call %s", show_pseudo(insn->func));
	if (offset)
		output_insn(state, "addl $%d,%%esp", offset);
	if (insn->target && insn->target != VOID)
		add_pseudo_reg(state, insn->target, hardregs+0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%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 0x132af
jmp 0x1335c
jmp 0x132b1
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 0x13344
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 0x132fc
cmpq $0x0, -0x20(%rbp)
jne 0x132fc
jmp 0x13336
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15800
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x56420(%rip), %rsi     # 0x6973f
leaq 0x56428(%rip), %rcx     # 0x6974e
movb $0x0, %al
callq 0x135a0
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x132b8
jmp 0x13346
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x132b1
movq -0x8(%rbp), %rdi
leaq 0x79e39(%rip), %rsi     # 0x8d1a0
callq 0x13de0
movq -0x8(%rbp), %rdi
leaq 0x79e29(%rip), %rsi     # 0x8d1a0
addq $0x18, %rsi
callq 0x13de0
movq -0x8(%rbp), %rdi
leaq 0x79e15(%rip), %rsi     # 0x8d1a0
addq $0x30, %rsi
callq 0x13de0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x20c10
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x563a5(%rip), %rsi     # 0x6975c
leaq 0x56390(%rip), %rcx     # 0x6974e
movb $0x0, %al
callq 0x135a0
cmpl $0x0, -0x14(%rbp)
je 0x133e7
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x56391(%rip), %rsi     # 0x6976a
leaq 0x5636e(%rip), %rcx     # 0x6974e
movb $0x0, %al
callq 0x135a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1341b
movq -0x10(%rbp), %rax
leaq 0x837d3(%rip), %rcx     # 0x96bd0
cmpq %rcx, 0x20(%rax)
je 0x1341b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x79d8a(%rip), %rdx     # 0x8d1a0
callq 0x126b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_ret
static void generate_ret(struct bb_state *state, struct instruction *ret)
{
	if (ret->src && ret->src != VOID) {
		struct hardreg *wants = hardregs+0;
		struct hardreg *reg = getreg(state, ret->src, NULL);
		if (reg != wants)
			output_insn(state, "movl %s,%s", reg->name, wants->name);
	}
	output_insn(state, "ret");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x134b3
movq -0x10(%rbp), %rax
leaq 0x8377a(%rip), %rcx     # 0x96bd0
cmpq %rcx, 0x30(%rax)
je 0x134b3
leaq 0x79d3d(%rip), %rax     # 0x8d1a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13750
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x134b1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x55e76(%rip), %rsi     # 0x69319
leaq 0x562d5(%rip), %r8      # 0x6977f
movb $0x0, %al
callq 0x135a0
jmp 0x134b3
movq -0x8(%rbp), %rdi
leaq 0x562ce(%rip), %rsi     # 0x6978c
leaq 0x562ba(%rip), %rdx     # 0x6977f
movb $0x0, %al
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_asm
static void generate_asm(struct bb_state *state, struct instruction *insn)
{
	const char *str = insn->string;

	if (insn->asm_rules->outputs || insn->asm_rules->inputs) {
		struct asm_arg *arg;

		arg = generate_asm_outputs(state, insn->asm_rules->outputs, asm_arguments);
		arg = generate_asm_inputs(state, insn->asm_rules->inputs, arg);
		str = replace_asm_args(str, asm_arguments, arg - asm_arguments);
	}
	output_insn(state, "%s", str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13519
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, (%rax)
je 0x1357d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x82520(%rip), %rdx     # 0x95a50
callq 0x16520
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x166f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
leaq 0x824ec(%rip), %rcx     # 0x95a50
subq %rcx, %rax
sarq $0x5, %rax
movl %eax, %edx
leaq 0x824dc(%rip), %rsi     # 0x95a50
callq 0x16910
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x56264(%rip), %rsi     # 0x697f0
leaq 0x56203(%rip), %rcx     # 0x69796
movb $0x0, %al
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: address
static const char *address(struct bb_state *state, struct instruction *memop)
{
	struct operand *op = get_address_operand(state, memop);
	const char *str = show_op(state, op);
	put_operand(state, op);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14790
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14860
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14b00
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: getreg
static struct hardreg *getreg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
{
	struct hardreg *reg;

	reg = find_in_reg(state, pseudo);
	if (reg)
		return reg;
	reg = target_reg(state, pseudo, target);
	return fill_reg(state, reg, pseudo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x137c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13786
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x137b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13920
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13a30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: find_in_reg
static struct hardreg *find_in_reg(struct bb_state *state, pseudo_t pseudo)
{
	int i;
	struct hardreg *reg;

	for (i = 0; i < REGNO; i++) {
		pseudo_t p;

		reg = hardregs + i;
		FOR_EACH_PTR_TAG(reg->contains, p) {
			if (p == pseudo) {
				last_reg = i;
				output_comment(state, "found pseudo %s in reg %s (busy=%d)", show_pseudo(pseudo), reg->name, reg->busy);
				return reg;
			}
		} END_FOR_EACH_PTR(p);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0x13905
movslq -0x1c(%rbp), %rcx
leaq 0x799b4(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1381f
jmp 0x138f5
jmp 0x13821
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x138dd
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x13874
cmpq $0x0, -0x30(%rbp)
jne 0x13874
jmp 0x138cf
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x138cd
movl -0x1c(%rbp), %eax
movl %eax, 0x81549(%rip)     # 0x94dd0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c10
movq -0x58(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movl 0x10(%rax), %r8d
andl $0xffff, %r8d           # imm = 0xFFFF
leaq 0x559a5(%rip), %rsi     # 0x69261
movb $0x0, %al
callq 0x125e0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1390d
jmp 0x138cf
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x13828
jmp 0x138df
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x13821
jmp 0x138f7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x137d7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: target_reg
static struct hardreg *target_reg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
{
	int i;
	int unable_to_find_reg = 0;
	struct hardreg *reg;

	/* First, see if we have a preferred target register.. */
	reg = preferred_reg(state, target);
	if (reg && !reg->contains)
		goto found;

	reg = empty_reg(state);
	if (reg)
		goto found;

	i = last_reg;
	do {
		i++;
		if (i >= REGNO)
			i = 0;
		reg = hardregs + i;
		if (!reg->busy) {
			flush_reg(state, reg);
			last_reg = i;
			goto found;
		}
	} while (i != last_reg);
	assert(unable_to_find_reg);

found:
	add_pseudo_reg(state, pseudo, reg);
	return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13963
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13963
jmp 0x13a10
movq -0x8(%rbp), %rdi
callq 0x13d80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1397c
jmp 0x13a10
movl 0x8144e(%rip), %eax     # 0x94dd0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jl 0x1399b
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x797fa(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x139da
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13de0
movl -0x1c(%rbp), %eax
movl %eax, 0x813f8(%rip)     # 0x94dd0
jmp 0x13a10
jmp 0x139dc
movl -0x1c(%rbp), %eax
cmpl 0x813eb(%rip), %eax     # 0x94dd0
jne 0x13985
cmpl $0x0, -0x20(%rbp)
je 0x139ef
jmp 0x13a0e
leaq 0x5588f(%rip), %rdi     # 0x69285
leaq 0x5589b(%rip), %rsi     # 0x69298
movl $0x202, %edx            # imm = 0x202
leaq 0x55899(%rip), %rcx     # 0x692a2
callq 0x11120
jmp 0x13a10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x126b0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: preferred_reg
static struct hardreg *preferred_reg(struct bb_state *state, pseudo_t target)
{
	struct storage_hash *dst;

	dst = find_storage_hash(target, state->outputs);
	if (dst) {
		struct storage *storage = dst->storage;
		if (storage->type == REG_REG)
			return hardregs + storage->regno;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13f70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13d5f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x13d5d
movq -0x28(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x79450(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x13d67
jmp 0x13d5f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: empty_reg
static struct hardreg *empty_reg(struct bb_state *state)
{
	int i;
	struct hardreg *reg = hardregs;

	for (i = 0; i < REGNO; i++, reg++) {
		if (!reg->contains)
			return reg;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x79411(%rip), %rax     # 0x8d1a0
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x13dce
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x13db5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13dd6
jmp 0x13db7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x13d9a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: find_storage_hash
static struct storage_hash *find_storage_hash(pseudo_t pseudo, struct storage_hash_list *list)
{
	struct storage_hash *entry;
	FOR_EACH_PTR(list, entry) {
		if (entry->pseudo == pseudo)
			return entry;
	} END_FOR_EACH_PTR(entry);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %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 0x13fa0
jmp 0x1402a
jmp 0x13fa2
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 0x14012
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 0x13fed
cmpq $0x0, -0x20(%rbp)
jne 0x13fed
jmp 0x14007
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x14005
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14032
jmp 0x14007
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x13fa9
jmp 0x14014
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x13fa2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: find_or_create_hash
static struct storage_hash *find_or_create_hash(pseudo_t pseudo, struct storage_hash_list **listp)
{
	struct storage_hash *entry;

	entry = find_storage_hash(pseudo, *listp);
	if (!entry) {
		entry = alloc_storage_hash(alloc_storage());
		entry->pseudo = pseudo;
		add_ptr_list(listp, entry);
	}
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x13f70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14281
callq 0x11c80
movq %rax, %rdi
callq 0x143a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a100
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./storage.h
// Function: alloc_storage_hash
static inline struct storage_hash *alloc_storage_hash(struct storage *s)
{
	struct storage_hash *entry = __alloc_storage_hash(0);
	struct storage **usep = &entry->storage;

	*usep = s;
	add_ptr_list(&s->users, usep);
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x48270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: flush_cc_cache_to_reg
static void flush_cc_cache_to_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	int opcode = state->cc_opcode;

	state->cc_opcode = 0;
	state->cc_target = NULL;
	output_insn(state, "%s %s", opcodes[opcode], reg->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x78dec(%rip), %rax     # 0x8d260
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x54f1d(%rip), %rsi     # 0x693a3
leaq 0x54f22(%rip), %r8      # 0x693af
movb $0x0, %al
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: find_pseudo_storage
static struct storage_hash *find_pseudo_storage(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	struct storage_hash *src;

	src = find_storage_hash(pseudo, state->internal);
	if (!src) {
		src = find_storage_hash(pseudo, state->inputs);
		if (!src) {
			src = find_storage_hash(pseudo, state->outputs);
			/* Undefined? Screw it! */
			if (!src)
				return NULL;

			/*
			 * If we found output storage, it had better be local stack
			 * that we flushed to earlier..
			 */
			if (src->storage->type != REG_STACK)
				return NULL;
		}
	}

	/*
	 * Incoming pseudo with out any pre-set storage allocation?
	 * We can make up our own, and obviously prefer to get it
	 * in the register we already selected (if it hasn't been
	 * used yet).
	 */
	if (src->storage->type == REG_UDEF) {
		if (reg && !reg->used) {
			src->storage->type = REG_REG;
			src->storage->regno = reg - hardregs;
			return NULL;
		}
		alloc_stack(state, src->storage);
	}
	return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x13f70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14533
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x13f70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14531
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x13f70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14515
movq $0x0, -0x8(%rbp)
jmp 0x145af
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, (%rax)
je 0x1452f
movq $0x0, -0x8(%rbp)
jmp 0x145af
jmp 0x14531
jmp 0x14533
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, (%rax)
jne 0x145a7
cmpq $0x0, -0x20(%rbp)
je 0x14596
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x18, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x14596
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
leaq 0x78c2e(%rip), %rcx     # 0x8d1a0
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x145af
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x14290
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: mark_reg_dead
static void mark_reg_dead(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	pseudo_t p;

	FOR_EACH_PTR_TAG(reg->contains, p) {
		if (p != pseudo)
			continue;
		if (CURRENT_TAG(p) & TAG_DEAD)
			continue;
		output_comment(state, "marking pseudo %s in reg %s dead", show_pseudo(pseudo), reg->name);
		TAG_CURRENT(p, TAG_DEAD);
		reg->dead++;
	} END_FOR_EACH_PTR(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%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 0x1463c
jmp 0x1475a
jmp 0x1463e
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 0x14742
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x14694
cmpq $0x0, -0x20(%rbp)
jne 0x14694
jmp 0x14734
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x146a3
jmp 0x14734
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $0x3, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x146c0
jmp 0x14734
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c10
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x54db1(%rip), %rsi     # 0x69497
movb $0x0, %al
callq 0x125e0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movslq -0x3c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x14760
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x10, %edx
andl $0xff, %edx
addl $0x1, %edx
movl 0x10(%rax), %ecx
andl $0xff, %edx
shll $0x10, %edx
andl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14645
jmp 0x14744
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x1463e
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: get_address_operand
static struct operand *get_address_operand(struct bb_state *state, struct instruction *memop)
{
	struct hardreg *base;
	struct operand *op = get_generic_operand(state, memop->src);

	switch (op->type) {
	case OP_ADDR:
		op->offset += memop->offset;
		break;
	default:
		put_operand(state, op);
		base = getreg(state, memop->src, NULL);
		op->type = OP_ADDR;
		op->base = base;
		base->busy++;
		op->offset = memop->offset;
		op->sym = NULL;
	}
	return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x14bd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x4, %eax
jne 0x147d9
jmp 0x147c2
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x8(%rax)
jmp 0x14856
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14b00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13750
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
addl $0x1, %edx
movl 0x10(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: put_operand
static void put_operand(struct bb_state *state, struct operand *op)
{
	switch (op->type) {
	case OP_REG:
		op->reg->busy--;
		break;
	case OP_ADDR:
	case OP_MEM:
		if (op->base)
			op->base->busy--;
		if (op->index)
			op->index->busy--;
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x14b2c
jmp 0x14b1c
movl -0x14(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x14b56
jmp 0x14bbe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
addl $-0x1, %edx
movl 0x10(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
jmp 0x14bc0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x14b89
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
addl $-0x1, %edx
movl 0x10(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x14bbc
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
addl $-0x1, %edx
movl 0x10(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
jmp 0x14bc0
jmp 0x14bc0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: get_sym_frame_offset
static int get_sym_frame_offset(struct bb_state *state, pseudo_t pseudo)
{
	int offset = pseudo->nr;
	if (offset < 0) {
		offset = alloc_stack_offset(4);
		pseudo->nr = offset;
	}
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x14e55
movl $0x4, %edi
callq 0x14400
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: flush_cc_cache
static void flush_cc_cache(struct bb_state *state)
{
	pseudo_t pseudo = state->cc_target;

	if (pseudo) {
		struct hardreg *dst;

		state->cc_target = NULL;

		if (!state->cc_dead) {
			dst = target_reg(state, pseudo, pseudo);
			flush_cc_cache_to_reg(state, pseudo, dst);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1511d
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1511b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x13920
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14430
jmp 0x1511d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: is_dead_reg
static int is_dead_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	pseudo_t p;
	FOR_EACH_PTR_TAG(reg->contains, p) {
		if (p == pseudo)
			return CURRENT_TAG(p) & TAG_DEAD;
	} END_FOR_EACH_PTR(p);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%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 0x15168
jmp 0x15202
jmp 0x1516a
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 0x151ea
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x151b9
cmpq $0x0, -0x28(%rbp)
jne 0x151b9
jmp 0x151df
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x151dd
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $0x3, %rax
andq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0x15209
jmp 0x151df
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x15171
jmp 0x151ec
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x1516a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: do_binop
static void do_binop(struct bb_state *state, struct instruction *insn, pseudo_t val1, pseudo_t val2)
{
	const char *op = opcodes[insn->opcode];
	struct operand *src = get_register_operand(state, val1, insn->target);
	struct operand *src2 = get_generic_operand(state, val2);
	struct hardreg *dst;

	dst = target_copy_reg(state, src->reg, insn->target);
	output_insn(state, "%s.%d %s,%s", op, insn->size, show_op(state, src2), dst->name);
	put_operand(state, src);
	put_operand(state, src2);
	add_pseudo_reg(state, insn->target, dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x78024(%rip), %rax     # 0x8d260
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x15320
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14bd0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x153a0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x14860
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movl -0x44(%rbp), %ecx
movq %rax, %r8
movq -0x40(%rbp), %rax
movq (%rax), %r9
leaq 0x5423b(%rip), %rsi     # 0x6950b
leaq 0x54246(%rip), %rax     # 0x6951d
movq %rax, (%rsp)
movb $0x0, %al
callq 0x135a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14b00
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x14b00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x126b0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: get_register_operand
static struct operand *get_register_operand(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
{
	struct operand *op = alloc_op();
	op->type = OP_REG;
	op->reg = getreg(state, pseudo, target);
	op->reg->busy++;
	return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x153e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13750
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
addl $0x1, %edx
movl 0x10(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: kill_dead_reg
static void kill_dead_reg(struct hardreg *reg)
{
	if (reg->dead) {
		pseudo_t p;
		
		FOR_EACH_PTR_TAG(reg->contains, p) {
			if (CURRENT_TAG(p) & TAG_DEAD) {
				DELETE_CURRENT_PTR(p);
				reg->dead--;
			}
		} END_FOR_EACH_PTR(p);
		PACK_PTR_LIST(&reg->contains);
		assert(!reg->dead);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x15617
jmp 0x15436
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1545e
jmp 0x155d3
jmp 0x15460
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x155bb
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x154b6
cmpq $0x0, -0x10(%rbp)
jne 0x154b6
jmp 0x155ad
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $0x3, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x155ab
jmp 0x154d7
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x15541
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x1551a
movq -0x38(%rbp), %rax
movl $0xf0f0f0f0, %ecx       # imm = 0xF0F0F0F0
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movw (%rax), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
addl $-0x1, %ecx
movw %cx, %dx
movw (%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x10, %edx
andl $0xff, %edx
addl $-0x1, %edx
movl 0x10(%rax), %ecx
andl $0xff, %edx
shll $0x10, %edx
andl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
jmp 0x155ad
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15467
jmp 0x155bd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x15460
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x39f00
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x155f6
jmp 0x15615
leaq 0x53f29(%rip), %rdi     # 0x69526
leaq 0x53c94(%rip), %rsi     # 0x69298
movl $0x36d, %edx            # imm = 0x36D
leaq 0x53f21(%rip), %rcx     # 0x69531
callq 0x11120
jmp 0x15617
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: copy_reg
static struct hardreg *copy_reg(struct bb_state *state, struct hardreg *src, pseudo_t target)
{
	int i;
	struct hardreg *reg;

	/* If the container has been killed off, just re-use it */
	if (!src->contains)
		return src;

	/* If "src" only has one user, and the contents are dead, we can re-use it */
	if (src->busy == 1 && src->dead == 1)
		return src;

	reg = preferred_reg(state, target);
	if (reg && !reg->contains) {
		output_comment(state, "copying %s to preferred target %s", show_pseudo(target), reg->name);
		move_reg(state, src, reg);
		return reg;
	}

	for (i = 0; i < REGNO; i++) {
		reg = hardregs + i;
		if (!reg->contains) {
			output_comment(state, "copying %s to %s", show_pseudo(target), reg->name);
			output_insn(state, "movl %s,%s", src->name, reg->name);
			return reg;
		}
	}

	flush_reg(state, src);
	return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1564c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x157a1
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x1, %eax
jne 0x1567e
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x1567e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x157a1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13d00
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x156ec
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x156ec
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20c10
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
leaq 0x53e8f(%rip), %rsi     # 0x69556
movb $0x0, %al
callq 0x125e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x157b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x157a1
movl $0x0, -0x24(%rbp)
cmpl $0x6, -0x24(%rbp)
jge 0x1578c
movslq -0x24(%rbp), %rcx
leaq 0x77a98(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1577c
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20c10
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
leaq 0x53e34(%rip), %rsi     # 0x69578
movb $0x0, %al
callq 0x125e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
leaq 0x53bb5(%rip), %rsi     # 0x69319
leaq 0x53e1e(%rip), %r8      # 0x69589
movb $0x0, %al
callq 0x135a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x157a1
jmp 0x1577e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x156f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13de0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generic
static const char *generic(struct bb_state *state, pseudo_t pseudo)
{
	struct hardreg *reg;
	struct operand *op = get_generic_operand(state, pseudo);
	static char buf[100];
	const char *str;

	switch (op->type) {
	case OP_ADDR:
		if (!op->offset && op->base && !op->sym)
			return op->base->name;
		if (op->sym && !op->base) {
			int len = sprintf(buf, "$ %s", show_op(state, op));
			if (op->offset)
				sprintf(buf + len, " + %d", op->offset);
			return buf;
		}
		str = show_op(state, op);
		put_operand(state, op);
		reg = target_reg(state, pseudo, NULL);
		output_insn(state, "lea %s,%s", show_op(state, op), reg->name);
		return reg->name;		

	default:
		str = show_op(state, op);
	}
	put_operand(state, op);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14bd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
subl $0x4, %eax
jne 0x15959
jmp 0x15832
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x15866
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x15866
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x15866
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1597f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x158e1
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x158e1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14860
movq %rax, %rdx
leaq 0x8014d(%rip), %rdi     # 0x959e0
leaq 0x53d25(%rip), %rsi     # 0x695bf
movb $0x0, %al
callq 0x112d0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x158d1
movslq -0x34(%rbp), %rax
leaq 0x80127(%rip), %rdi     # 0x959e0
addq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x53cfa(%rip), %rsi     # 0x695c4
movb $0x0, %al
callq 0x112d0
leaq 0x80108(%rip), %rax     # 0x959e0
movq %rax, -0x8(%rbp)
jmp 0x1597f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14860
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14b00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13920
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14860
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq 0x53c8c(%rip), %rsi     # 0x695ca
leaq 0x53c95(%rip), %r8      # 0x695da
movb $0x0, %al
callq 0x135a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1597f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14860
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14b00
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: add_cc_cache
static void add_cc_cache(struct bb_state *state, int opcode, pseudo_t pseudo)
{
	assert(!state->cc_target);
	state->cc_target = pseudo;
	state->cc_opcode = opcode;
	state->cc_dead = 0;
	output_comment(state, "caching %s", opcodes[opcode]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x159b0
jmp 0x159cf
leaq 0x53c2b(%rip), %rdi     # 0x695e2
leaq 0x538da(%rip), %rsi     # 0x69298
movl $0x240, %edx            # imm = 0x240
leaq 0x53c2a(%rip), %rcx     # 0x695f4
callq 0x11120
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x77861(%rip), %rax     # 0x8d260
movq (%rax,%rcx,8), %rdx
leaq 0x53c1e(%rip), %rsi     # 0x69628
movb $0x0, %al
callq 0x125e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: write_val_to_storage
static void write_val_to_storage(struct bb_state *state, pseudo_t src, struct storage *storage)
{
	struct hardreg *out;

	switch (storage->type) {
	case REG_UDEF:
		alloc_stack(state, storage);
	default:
		output_insn(state, "movl %s,%s", show_pseudo(src), show_memop(storage));
		break;
	case REG_REG:
		out = hardregs + storage->regno;
		output_insn(state, "movl %s,%s", show_pseudo(src), out->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x162ad
jmp 0x162a3
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x162fa
jmp 0x162ba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14290
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c10
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x142d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x5302f(%rip), %rsi     # 0x69319
leaq 0x53401(%rip), %r8      # 0x696f2
movb $0x0, %al
callq 0x135a0
jmp 0x16348
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x76e97(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c10
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq 0x52fdf(%rip), %rsi     # 0x69319
leaq 0x533b1(%rip), %r8      # 0x696f2
movb $0x0, %al
callq 0x135a0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: replace_asm_args
static const char *replace_asm_args(const char *str, struct asm_arg *args, int nr)
{
	static char buffer[1000];
	char *p = buffer;

	for (;;) {
		char c = *str;
		*p = c;
		if (!c)
			return buffer;
		str++;
		switch (c) {
		case '%':
			if (*str == '%') {
				str++;
				p++;
				continue;
			}
			replace_asm_percent(&str, &p, args, nr);
			continue;
		case '[':
			replace_asm_named(&str, &p, args, nr);
			continue;
		default:
			break;
		}
		p++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x7f766(%rip), %rax     # 0x96090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
cmpb $0x0, -0x21(%rbp)
jne 0x16953
leaq 0x7f743(%rip), %rax     # 0x96090
addq $0x30, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rax
incq %rax
movq %rax, -0x8(%rbp)
movsbl -0x21(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x25, %eax
je 0x16976
jmp 0x1696c
movl -0x28(%rbp), %eax
subl $0x5b, %eax
je 0x169b5
jmp 0x169ce
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x1699c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1692e
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x169f0
jmp 0x1692e
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16a70
jmp 0x1692e
jmp 0x169d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1692e
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: replace_asm_percent
static void replace_asm_percent(const char **src_p, char **dst_p, struct asm_arg *args, int nr)
{
	const char *src = *src_p;
	char c;
	int index;

	c = *src++;
	switch (c) {
	case '0' ... '9':
		index = c - '0';
		if (index < nr)
			replace_asm_arg(dst_p, args+index);
		break;
	}	
	*src_p = src;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
addl $-0x30, %eax
subl $0x9, %eax
ja 0x16a5f
jmp 0x16a33
movsbl -0x29(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x16a5d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x30(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x16b60
jmp 0x16a5f
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq