LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_conditional_expr
static int show_conditional_expr(struct expression *expr)
{
	int cond = show_expression(expr->conditional);
	int valt = show_expression(expr->cond_true);
	int valf = show_expression(expr->cond_false);
	int new = new_pseudo();

	printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond, expr->ctype->bit_size, new, valt, valf);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33a40
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x33a40
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x33a40
movl %eax, -0x14(%rbp)
callq 0x33f60
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %edx
movl -0x18(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl -0x14(%rbp), %r9d
leaq 0x33d19(%rip), %rdi     # 0x686cd
movb $0x0, %al
callq 0x110f0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_slice
static int show_slice(struct expression *expr)
{
	int target = show_expression(expr->base);
	int new = new_pseudo();
	printf("\tslice.%d\t\tv%d,v%d,%d\n", expr->ctype->bit_size, target, new, expr->r_bitpos);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33a40
movl %eax, -0xc(%rbp)
callq 0x33f60
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %r8d
leaq 0x33c89(%rip), %rdi     # 0x686fd
movb $0x0, %al
callq 0x110f0
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./symbol.h
// Function: combine_address_space
static inline void combine_address_space(struct position pos,
	struct ident **tas, struct ident *sas)
{
	struct ident *as;
	if (!sas)
		return;
	as = *tas;
	if (!as)
		*tas = sas;
	else if (as != sas) {
		*tas = &bad_address_space;
		sparse_error(pos, "multiple address spaces given");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x34c4d
jmp 0x34c98
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x34c6c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x34c98
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x34c96
movq -0x10(%rbp), %rax
leaq 0x56a4f(%rip), %rcx     # 0x8b6d0
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x337d9(%rip), %rsi     # 0x68468
movb $0x0, %al
callq 0x16f90
jmp 0x34c98
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_symbol_init
static int show_symbol_init(struct symbol *sym)
{
	struct expression *expr = sym->initializer;

	if (expr) {
		int val, addr, bits;

		bits = expr->ctype->bit_size;
		val = show_expression(expr);
		addr = show_symbol_expr(sym);
		show_store_gen(bits, val, NULL, addr);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34cfa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33a40
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33e30
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x34d10
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_inc_dec
static int show_inc_dec(struct expression *expr, int postop)
{
	int addr = show_address_gen(expr->unop);
	int retval, new;
	const char *opname = expr->op == SPECIAL_INCREMENT ? "add" : "sub";
	int bits = expr->ctype->bit_size;

	retval = show_load_gen(bits, expr->unop, addr);
	new = retval;
	if (postop)
		new = new_pseudo();
	printf("\t%s.%d\t\tv%d,v%d,$1\n", opname, bits, new, retval);
	show_store_gen(bits, new, expr->unop, addr);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x34d90
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x363f6(%rip), %rax     # 0x6b213
leaq 0x3639b(%rip), %rcx     # 0x6b1bf
cmpl $0x101, %edx            # imm = 0x101
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x10(%rbp), %edx
callq 0x34f40
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x34e6a
callq 0x33f60
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x33782(%rip), %rdi     # 0x68601
movb $0x0, %al
callq 0x110f0
movl -0x24(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movl -0x10(%rbp), %ecx
callq 0x34d10
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_regular_preop
static int show_regular_preop(struct expression *expr)
{
	int target = show_expression(expr->unop);
	int new = new_pseudo();
	static const char *name[] = {
		['!'] = "nonzero", ['-'] = "neg",
		['~'] = "not",
	};
	unsigned int op = expr->op;
	const char *opname;

	opname = show_special(op);
	if (op < ARRAY_SIZE(name))
		opname = name[op];
	printf("\t%s.%d\t\tv%d,v%d\n", opname, expr->ctype->bit_size, new, target);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33a40
movl %eax, -0xc(%rbp)
callq 0x33f60
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x440f0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x7f, %rax
jae 0x34f07
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x54a81(%rip), %rax     # 0x89980
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %edx
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0x336f9(%rip), %rdi     # 0x6861d
movb $0x0, %al
callq 0x110f0
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_position_expr
static int show_position_expr(struct expression *expr, struct symbol *base)
{
	int new = show_expression(expr->init_expr);
	struct symbol *ctype = expr->init_expr->ctype;
	int bit_offset;

	bit_offset = ctype ? ctype->bit_offset : -1;

	printf("\tinsert v%d at [%d:%d] of %s\n", new,
		expr->init_offset, bit_offset,
		show_ident(base->ident));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x33a40
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x35038
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
andl $0xff, %eax
movl %eax, -0x28(%rbp)
jmp 0x35042
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x35042
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq %rax, %r8
leaq 0x33631(%rip), %rdi     # 0x686af
movb $0x0, %al
callq 0x110f0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/show-parse.c
// Function: show_initialization
static int show_initialization(struct symbol *sym, struct expression *expr)
{
	int val, addr, bits;

	if (!expr->ctype)
		return 0;

	bits = expr->ctype->bit_size;
	val = show_expression(expr);
	addr = show_symbol_expr(sym);
	// FIXME! The "target" expression is for bitfield store information.
	// Leave it NULL, which works fine.
	show_store_gen(bits, val, NULL, addr);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x350b4
movl $0x0, -0x4(%rbp)
jmp 0x350f3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33a40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33e30
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x34d10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: kill_use
void kill_use(pseudo_t *usep)
{
	if (usep) {
		pseudo_t p = *usep;
		*usep = VOID;
		rem_usage(p, usep, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3519e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x56c27(%rip), %rcx     # 0x8bdb0
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x351b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: rem_usage
static inline void rem_usage(pseudo_t p, pseudo_t *usep, int kill)
{
	if (has_use_list(p)) {
		delete_pseudo_user_list_entry(&p->users, usep, 1);
		if (kill && !p->users && has_definition(p))
			kill_instruction(p->def);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37e80
cmpl $0x0, %eax
je 0x35216
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x37ed0
cmpl $0x0, -0x14(%rbp)
je 0x35214
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x35214
movq -0x8(%rbp), %rdi
callq 0x38040
testb $0x1, %al
jne 0x35207
jmp 0x35214
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x357c0
jmp 0x35216
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: kill_use_list
static void kill_use_list(struct pseudo_list *list)
{
	pseudo_t p;
	FOR_EACH_PTR(list, p) {
		if (p == VOID)
			continue;
		kill_use(THIS_ADDRESS(p));
	} END_FOR_EACH_PTR(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %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 0x35450
jmp 0x354e7
jmp 0x35452
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 0x354cf
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x3549d
cmpq $0x0, -0x10(%rbp)
jne 0x3549d
jmp 0x354c4
leaq 0x5690c(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x10(%rbp)
jne 0x354ac
jmp 0x354c4
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x35160
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35459
jmp 0x354d1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x35452
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: kill_asm
static void kill_asm(struct instruction *insn)
{
	struct asm_constraint *con;

	FOR_EACH_PTR(insn->asm_rules->inputs, con) {
		kill_use(&con->pseudo);
	} END_FOR_EACH_PTR(con);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%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 0x35544
jmp 0x355b9
jmp 0x35546
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 0x355a5
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x35591
cmpq $0x0, -0x10(%rbp)
jne 0x35591
jmp 0x3559a
movq -0x10(%rbp), %rdi
callq 0x35160
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3554d
jmp 0x355a7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x35546
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: remove_dead_insns
void remove_dead_insns(struct entrypoint *ep)
{
	struct basic_block *bb;

	FOR_EACH_PTR_REVERSE(ep->bbs, bb) {
		struct instruction *insn;
		FOR_EACH_PTR_REVERSE(bb->insns, insn) {
			if (!insn->bb)
				continue;
			if (!has_target(insn))
				continue;
			if (!has_users(insn->target))
				kill_instruction(insn);
		} END_FOR_EACH_PTR_REVERSE(insn);
	} END_FOR_EACH_PTR_REVERSE(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x355f8
jmp 0x3573c
jmp 0x355fa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jl 0x3572c
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x35656
cmpq $0x0, -0x10(%rbp)
jne 0x35656
jmp 0x35619
jmp 0x35658
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x35684
jmp 0x35727
jmp 0x35686
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
jl 0x35717
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 0x356de
cmpq $0x0, -0x38(%rbp)
jne 0x356de
jmp 0x356a5
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x356eb
jmp 0x356a5
movq -0x38(%rbp), %rdi
callq 0x35750
testb $0x1, %al
jne 0x356fa
jmp 0x356a5
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x35790
cmpl $0x0, %eax
jne 0x35715
movq -0x38(%rbp), %rdi
callq 0x357c0
jmp 0x356a5
jmp 0x35719
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x35686
jmp 0x35619
jmp 0x3572e
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x355fa
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: canonicalize_commutative
static int canonicalize_commutative(struct instruction *insn)
{
	if (canonical_order(insn->src1, insn->src2))
		return 0;

	switch_pseudo(insn, &insn->src1, insn, &insn->src2);
	return repeat_phase |= REPEAT_CSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x38090
cmpl $0x0, %eax
je 0x35abf
movl $0x0, -0x4(%rbp)
jmp 0x35af8
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
addq $0x8, %rcx
callq 0x38130
leaq 0x5766d(%rip), %rax     # 0x8d154
movl (%rax), %eax
orl $0x1, %eax
leaq 0x57661(%rip), %rcx     # 0x8d154
movl %eax, (%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: canonicalize_compare
static int canonicalize_compare(struct instruction *insn)
{
	if (canonical_order(insn->src1, insn->src2))
		return 0;

	switch_pseudo(insn, &insn->src1, insn, &insn->src2);
	insn->opcode = opcode_table[insn->opcode].swap;
	return repeat_phase |= REPEAT_CSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x38090
cmpl $0x0, %eax
je 0x35b3f
movl $0x0, -0x4(%rbp)
jmp 0x35baa
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
addq $0x8, %rcx
callq 0x38130
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2dfdc(%rip), %rax     # 0x63b50
movq (%rax,%rcx,8), %rax
shlq $0x30, %rax
sarq $0x38, %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x7f, %edx
andl $-0x80, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
leaq 0x575bb(%rip), %rax     # 0x8d154
movl (%rax), %eax
orl $0x1, %eax
leaq 0x575af(%rip), %rcx     # 0x8d154
movl %eax, (%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_binop
static int simplify_binop(struct instruction *insn)
{
	if (constant(insn->src1)) {
		if (constant(insn->src2))
			return simplify_constant_binop(insn);
		return simplify_constant_leftside(insn);
	}
	if (constant(insn->src2))
		return simplify_constant_rightside(insn);
	if (insn->src1 == insn->src2)
		return simplify_binop_same_args(insn, insn->src1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x35c0c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x35bfe
movq -0x10(%rbp), %rdi
callq 0x382c0
movl %eax, -0x4(%rbp)
jmp 0x35c5b
movq -0x10(%rbp), %rdi
callq 0x38310
movl %eax, -0x4(%rbp)
jmp 0x35c5b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x35c2c
movq -0x10(%rbp), %rdi
callq 0x38430
movl %eax, -0x4(%rbp)
jmp 0x35c5b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x35c54
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x386b0
movl %eax, -0x4(%rbp)
jmp 0x35c5b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_associative_binop
static int simplify_associative_binop(struct instruction *insn)
{
	struct instruction *def;
	pseudo_t pseudo = insn->src1;

	if (!simple_pseudo(insn->src2))
		return 0;
	if (pseudo->type != PSEUDO_REG)
		return 0;
	def = pseudo->def;
	if (def == insn)
		return 0;
	if (def->opcode != insn->opcode)
		return 0;
	if (!simple_pseudo(def->src2))
		return 0;
	if (constant(def->src2) && constant(insn->src2)) {
		// (x # C) # K --> x # eval(C # K)
		insn->src2 = eval_op(insn->opcode, insn->size, insn->src2, def->src2);
		return replace_pseudo(insn, &insn->src1, def->src1);
	}

	if (!canonical_order(def->src1, insn->src2) && can_move_to(insn->src2, def)) {
		// (x # y) # z -> (z # y) # x  when x ≻ z
		return switch_pseudo(def, &def->src1, insn, &insn->src2);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3b480
cmpl $0x0, %eax
jne 0x35ca6
movl $0x0, -0x4(%rbp)
jmp 0x35df0
movq -0x20(%rbp), %rax
cmpl $0x3, 0x4(%rax)
je 0x35cbc
movl $0x0, -0x4(%rbp)
jmp 0x35df0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x35cde
movl $0x0, -0x4(%rbp)
jmp 0x35df0
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7f, %ecx
cmpl %ecx, %eax
je 0x35d00
movl $0x0, -0x4(%rbp)
jmp 0x35df0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3b480
cmpl $0x0, %eax
jne 0x35d1e
movl $0x0, -0x4(%rbp)
jmp 0x35df0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x35d92
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x35d92
movq -0x10(%rbp), %rax
movl (%rax), %edi
andl $0x7f, %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
shrl $0x8, %esi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
callq 0x38800
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x38d50
movl %eax, -0x4(%rbp)
jmp 0x35df0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x38090
cmpl $0x0, %eax
jne 0x35de9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b4b0
testb $0x1, %al
jne 0x35dc3
jmp 0x35de9
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
addq $0x8, %rcx
callq 0x38130
movl %eax, -0x4(%rbp)
jmp 0x35df0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_sub
static int simplify_sub(struct instruction *insn)
{
	pseudo_t src1 = insn->src1;
	pseudo_t src2 = insn->src2;
	struct instruction *def;

	switch (DEF_OPCODE(def, src1)) {
	case OP_ADD:
		if (def->src1 == src2)		// (x + y) - x --> y
			return replace_with_pseudo(insn, def->src2);
		if (def->src2 == src2)		// (x + y) - y --> x
			return replace_with_pseudo(insn, def->src1);
		break;
	}

	switch (DEF_OPCODE(def, src2)) {
	case OP_ADD:
		if (src1 == def->src1)		// x - (x + z) --> -z
			return replace_with_unop(insn, OP_NEG, def->src2);
		if (src1 == def->src2)		// x - (y + x) --> -y
			return replace_with_unop(insn, OP_NEG, def->src1);
		break;
	case OP_NEG:				// (x - -y) --> (x + y)
		insn->opcode = OP_ADD;
		return replace_pseudo(insn, &insn->src2, def->src);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x362de
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x362de
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x2c(%rbp)
jmp 0x362e5
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x362e5
movl -0x2c(%rbp), %eax
subl $0x8, %eax
jne 0x3633f
jmp 0x362ef
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x36316
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x357e0
movl %eax, -0x4(%rbp)
jmp 0x36415
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3633d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x357e0
movl %eax, -0x4(%rbp)
jmp 0x36415
jmp 0x3633f
movq -0x20(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x36369
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x36369
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x30(%rbp)
jmp 0x36370
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x36370
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x8, %eax
je 0x3638a
jmp 0x3637d
movl -0x34(%rbp), %eax
subl $0x32, %eax
je 0x363de
jmp 0x3640e
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x363b3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdx
movl $0x32, %esi
callq 0x38bc0
movl %eax, -0x4(%rbp)
jmp 0x36415
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x363dc
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
movl $0x32, %esi
callq 0x38bc0
movl %eax, -0x4(%rbp)
jmp 0x36415
jmp 0x3640e
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x80, %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x38d50
movl %eax, -0x4(%rbp)
jmp 0x36415
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_compare
static int simplify_compare(struct instruction *insn)
{
	pseudo_t src1 = insn->src1;
	pseudo_t src2 = insn->src2;
	struct instruction *def = NULL;
	unsigned int osize;
	pseudo_t src;

	switch (DEF_OPCODE(def, src1)) {
	case OP_SEXT: case OP_ZEXT:
		osize = def->orig_type->bit_size;
		if ((src = is_same_op(src2, def->opcode, osize))) {
			const struct opcode_table *op = &opcode_table[insn->opcode];
			if ((def->opcode == OP_ZEXT) && (op->flags & OPF_SIGNED))
				insn->opcode = op->sign;
			insn->itype = def->orig_type;
			replace_pseudo(insn, &insn->src1, def->src);
			return replace_pseudo(insn, &insn->src2, src);
		}
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x365c6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x365c6
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x44(%rbp)
jmp 0x365cd
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x365cd
movl -0x44(%rbp), %eax
addl $-0x35, %eax
subl $0x1, %eax
ja 0x366bf
jmp 0x365de
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
andl $0x7f, %esi
movl -0x2c(%rbp), %edx
callq 0x3c760
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x366bd
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2d52d(%rip), %rax     # 0x63b50
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x35, %eax
jne 0x36676
movq -0x40(%rbp), %rax
movq (%rax), %rax
shrq $0x28, %rax
andq $0xff, %rax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x36676
movq -0x40(%rbp), %rax
movq (%rax), %rax
shlq $0x28, %rax
sarq $0x38, %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x7f, %edx
andl $-0x80, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x38d50
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rdx
callq 0x38d50
movl %eax, -0x4(%rbp)
jmp 0x366c6
jmp 0x366bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_memop
static int simplify_memop(struct instruction *insn)
{
	int one, ret = 0;
	pseudo_t orig = insn->src;

	do {
		one = simplify_one_memop(insn, orig);
		ret |= one;
	} while (one);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c7e0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x366ef
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_setval
static int simplify_setval(struct instruction *insn)
{
	struct expression *val = insn->val;

	switch (val->type) {
	case EXPR_LABEL:
		insn->opcode = OP_LABEL;
		insn->bb_true = val->symbol->bb_target;
		return REPEAT_CSE;
	default:
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
subb $0x17, %al
jne 0x36e2e
jmp 0x36e00
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x80, %ecx
orl $0x47, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0xd0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x36e37
jmp 0x36e30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: clean_up_phi
static int clean_up_phi(struct instruction *insn)
{
	struct pseudo_list *list = NULL;
	pseudo_t pseudo;

	if ((pseudo = trivial_phi(NULL, insn, &list))) {
		convert_instruction_target(insn, pseudo);
		kill_instruction(insn);
		return REPEAT_CSE;
	}

	return if_convert_phi(insn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x18(%rbp), %rdx
callq 0x3c9c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x36e8e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x58e80
movq -0x10(%rbp), %rdi
callq 0x357c0
movl $0x1, -0x4(%rbp)
jmp 0x36e9a
movq -0x10(%rbp), %rdi
callq 0x3cbc0
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/simplify.c
// Function: simplify_switch
static int simplify_switch(struct instruction *insn)
{
	pseudo_t cond = insn->cond;
	long long val;
	struct multijmp *jmp;

	if (!constant(cond))
		return 0;
	val = insn->cond->value;

	FOR_EACH_PTR(insn->multijmp_list, jmp) {
		/* Default case */
		if (jmp->begin > jmp->end)
			goto found;
		if (val >= jmp->begin && val <= jmp->end)
			goto found;
	} END_FOR_EACH_PTR(jmp);
	warning(insn->pos, "Impossible case statement");
	return 0;

found:
	return convert_to_jump(insn, jmp->target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x382a0
cmpl $0x0, %eax
jne 0x379e2
movl $0x0, -0x4(%rbp)
jmp 0x37af3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%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 0x37a1a
jmp 0x37ac1
jmp 0x37a1c
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 0x37aa9
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 0x37a67
cmpq $0x0, -0x28(%rbp)
jne 0x37a67
jmp 0x37a9b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x37a7b
jmp 0x37ae0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x37a99
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jg 0x37a99
jmp 0x37ae0
jmp 0x37a9b
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x37a23
jmp 0x37aab
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x37a1c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x31864(%rip), %rsi     # 0x69334
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x4(%rbp)
jmp 0x37af3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x59f90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_range
static int simplify_range(struct instruction *insn)
{
	pseudo_t src1, src2, src3;

	src1 = insn->src1;
	src2 = insn->src2;
	src3 = insn->src3;
	if (src2->type != PSEUDO_VAL || src3->type != PSEUDO_VAL)
		return 0;
	if (is_in_range(src1, src2->value, src3->value)) {
		kill_instruction(insn);
		return REPEAT_CSE;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, 0x4(%rax)
jne 0x37e34
movq -0x28(%rbp), %rax
cmpl $0x6, 0x4(%rax)
je 0x37e3d
movl $0x0, -0x4(%rbp)
jmp 0x37e74
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x3d2d0
cmpl $0x0, %eax
je 0x37e6d
movq -0x10(%rbp), %rdi
callq 0x357c0
movl $0x1, -0x4(%rbp)
jmp 0x37e74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: delete_pseudo_user_list_entry
static int delete_pseudo_user_list_entry(struct pseudo_user_list **list, pseudo_t *entry, int count)
{
	struct pseudo_user *pu;

	FOR_EACH_PTR(*list, pu) {
		if (pu->userp == entry) {
			MARK_CURRENT_DELETED(pu);
			if (!--count)
				goto out;
		}
	} END_FOR_EACH_PTR(pu);
	assert(count <= 0);
out:
	if (pseudo_user_list_empty(*list))
		*list = NULL;
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%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 0x37f0a
jmp 0x37fe3
jmp 0x37f0c
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 0x37fcb
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 0x37f5b
cmpq $0x0, -0x20(%rbp)
jne 0x37f5b
jmp 0x37fbd
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x37fbb
jmp 0x37f6b
jmp 0x37f6d
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movq -0x30(%rbp), %rax
movw (%rax), %cx
sarw $0x8, %cx
movswl %cx, %ecx
addl $0x1, %ecx
movw %cx, %dx
movw (%rax), %cx
andw $0xff, %dx
shlw $0x8, %dx
andw $0xff, %cx
orw %dx, %cx
movw %cx, (%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x37fb9
jmp 0x3800c
jmp 0x37fbb
jmp 0x37fbd
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x37f13
jmp 0x37fcd
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x37f0c
cmpl $0x0, -0x14(%rbp)
jg 0x37feb
jmp 0x3800a
leaq 0x2fe51(%rip), %rdi     # 0x67e43
leaq 0x311cf(%rip), %rsi     # 0x691c8
movl $0x107, %edx            # imm = 0x107
leaq 0x311ce(%rip), %rcx     # 0x691d3
callq 0x11120
jmp 0x3800c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x38070
testb $0x1, %al
jne 0x3801e
jmp 0x38029
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: canonical_order
static int canonical_order(pseudo_t p1, pseudo_t p2)
{
	int t1 = p1->type;
	int t2 = p2->type;

	/* symbol/constants on the right */
	if (t1 < t2)
		return 1;
	if (t1 > t2)
		return 0;
	switch (t1) {
	case PSEUDO_SYM:
		return p1->sym <= p2->sym;
	case PSEUDO_REG:
	case PSEUDO_ARG:
		return p1->nr <= p2->nr;
	default:
		return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x380c1
movl $0x1, -0x4(%rbp)
jmp 0x38129
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x380d2
movl $0x0, -0x4(%rbp)
jmp 0x38129
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0x38109
jmp 0x380e2
movl -0x24(%rbp), %eax
subl $0x5, %eax
jne 0x38122
jmp 0x380ec
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x38129
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x38129
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: switch_pseudo
static int switch_pseudo(struct instruction *insn1, pseudo_t *pp1, struct instruction *insn2, pseudo_t *pp2)
{
	pseudo_t p1 = *pp1, p2 = *pp2;

	use_pseudo(insn1, p2, pp1);
	use_pseudo(insn2, p1, pp2);
	remove_usage(p1, pp1);
	remove_usage(p2, pp2);
	return REPEAT_CSE;
}

// 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 (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x381b0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x381b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x38200
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x38200
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_constant_binop
static int simplify_constant_binop(struct instruction *insn)
{
	pseudo_t res = eval_insn(insn);

	if (!res)
		return 0;

	return replace_with_pseudo(insn, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x382e9
movl $0x0, -0x4(%rbp)
jmp 0x382f9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x357e0
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/simplify.c
// Function: simplify_constant_leftside
static int simplify_constant_leftside(struct instruction *insn)
{
	long long value = insn->src1->value;

	switch (insn->opcode) {
	case OP_ADD: case OP_OR: case OP_XOR:
		if (!value)
			return replace_with_pseudo(insn, insn->src2);
		return 0;

	case OP_SHL:
	case OP_LSR: case OP_ASR:
	case OP_AND:
	case OP_MUL:
		if (!value)
			return replace_with_pseudo(insn, insn->src1);
		return 0;
	case OP_SUB:
		if (!value)			// (0 - x) --> -x
			return replace_with_unop(insn, OP_NEG, insn->src2);
		if (insn->src2->type == PSEUDO_REG)
			return simplify_const_leftsub(insn, insn->src2->def);
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x1c(%rbp)
subl $0x8, %eax
je 0x3837b
jmp 0x3833f
movl -0x1c(%rbp), %eax
subl $0x9, %eax
je 0x383a4
jmp 0x38349
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0x383ca
jmp 0x38353
movl -0x1c(%rbp), %eax
addl $-0xf, %eax
subl $0x3, %eax
jb 0x383a4
jmp 0x38360
movl -0x1c(%rbp), %eax
subl $0x16, %eax
je 0x383a4
jmp 0x3836a
movl -0x1c(%rbp), %eax
addl $-0x17, %eax
subl $0x1, %eax
ja 0x38416
jmp 0x3837b
cmpq $0x0, -0x18(%rbp)
jne 0x3839b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x357e0
movl %eax, -0x4(%rbp)
jmp 0x3841d
movl $0x0, -0x4(%rbp)
jmp 0x3841d
cmpq $0x0, -0x18(%rbp)
jne 0x383c1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x357e0
movl %eax, -0x4(%rbp)
jmp 0x3841d
movl $0x0, -0x4(%rbp)
jmp 0x3841d
cmpq $0x0, -0x18(%rbp)
jne 0x383ec
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movl $0x32, %esi
callq 0x38bc0
movl %eax, -0x4(%rbp)
jmp 0x3841d
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x3, 0x4(%rax)
jne 0x38414
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x38c20
movl %eax, -0x4(%rbp)
jmp 0x3841d
jmp 0x38416
movl $0x0, -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/simplify.c
// Function: simplify_binop_same_args
static int simplify_binop_same_args(struct instruction *insn, pseudo_t arg)
{
	switch (insn->opcode) {
	case OP_SET_NE:
	case OP_SET_LT: case OP_SET_GT:
	case OP_SET_B:  case OP_SET_A:
		if (Wtautological_compare)
			warning(insn->pos, "self-comparison always evaluates to false");
	case OP_SUB:
	case OP_XOR:
		return replace_with_value(insn, 0);

	case OP_SET_EQ:
	case OP_SET_LE: case OP_SET_GE:
	case OP_SET_BE: case OP_SET_AE:
		if (Wtautological_compare)
			warning(insn->pos, "self-comparison always evaluates to true");
		return replace_with_value(insn, 1);

	case OP_AND:
	case OP_OR:
		return replace_with_pseudo(insn, arg);

	default:
		break;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x26, %eax
ja 0x3876c
movq -0x20(%rbp), %rax
leaq 0x30542(%rip), %rcx     # 0x68c28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x54b22(%rip), %rax     # 0x8d218
cmpl $0x0, (%rax)
je 0x38711
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x30b18(%rip), %rsi     # 0x69222
movb $0x0, %al
callq 0x16d80
jmp 0x38713
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39480
movl %eax, -0x4(%rbp)
jmp 0x38775
leaq 0x54aec(%rip), %rax     # 0x8d218
cmpl $0x0, (%rax)
je 0x38747
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x30b0c(%rip), %rsi     # 0x6924c
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x39480
movl %eax, -0x4(%rbp)
jmp 0x38775
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x357e0
movl %eax, -0x4(%rbp)
jmp 0x38775
jmp 0x3876e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: eval_insn
static pseudo_t eval_insn(struct instruction *insn)
{
	unsigned size = insn->size;

	if (opcode_table[insn->opcode].flags & OPF_COMPARE)
		size = insn->itype->bit_size;
	return eval_op(insn->opcode, size, insn->src1, insn->src2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2b3a4(%rip), %rax     # 0x63b50
movq (%rax,%rcx,8), %rax
shrq $0x28, %rax
andq $0xff, %rax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x387d0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
andl $0x7f, %edi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
callq 0x38800
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: replace_with_unop
static inline int replace_with_unop(struct instruction *insn, int op, pseudo_t src)
{
	insn->opcode = op;
	replace_pseudo(insn, &insn->src1, src);
	remove_usage(insn->src2, &insn->src2);
	return REPEAT_CSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0x7f, %edx
andl $-0x80, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
movq -0x18(%rbp), %rdx
callq 0x38d50
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
callq 0x38200
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: simplify_const_leftsub
static int simplify_const_leftsub(struct instruction *insn, struct instruction *def)
{
	unsigned size = insn->size;
	pseudo_t src1 = insn->src1;

	switch (def->opcode) {
	case OP_ADD:
		if (constant(def->src2)) { // C - (y + D) --> eval(C-D) - y
			insn->src1 = eval_op(OP_SUB, size, src1, def->src2);
			return replace_pseudo(insn, &insn->src2, def->src1);
		}
		break;
	case OP_SUB:
		if (constant(def->src1)) { // C - (D - z) --> z + eval(C-D)
			pseudo_t val = eval_op(OP_SUB, size, src1, def->src1);
			insn->opcode = OP_ADD;
			use_pseudo(insn, def->src2, &insn->src1);
			return replace_pseudo(insn, &insn->src2, val);
		}
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x34(%rbp)
subl $0x8, %eax
je 0x38c68
jmp 0x38c5b
movl -0x34(%rbp), %eax
subl $0xa, %eax
je 0x38cc2
jmp 0x38d38
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x38cc0
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0xa, %edi
callq 0x38800
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x38d50
movl %eax, -0x4(%rbp)
jmp 0x38d3f
jmp 0x38d38
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x382a0
cmpl $0x0, %eax
je 0x38d36
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movl $0xa, %edi
callq 0x38800
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x80, %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x30, %rdx
callq 0x381b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
callq 0x38d50
movl %eax, -0x4(%rbp)
jmp 0x38d3f
jmp 0x38d38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/simplify.c
// Function: replace_pseudo
static inline int replace_pseudo(struct instruction *insn, pseudo_t *pp, pseudo_t new)
{
	pseudo_t old = *pp;
	use_pseudo(insn, new, pp);
	remove_usage(old, pp);
	return REPEAT_CSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x381b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x38200
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)