LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: kill_unreachable_bbs
void kill_unreachable_bbs(struct entrypoint *ep)
{
	struct basic_block *bb;
	unsigned long generation = ++bb_generation;

	mark_bb_reachable(ep->entry->bb, generation);
	FOR_EACH_PTR(ep->bbs, bb) {
		if (bb->generation == generation)
			continue;
		/* Mark it as being dead */
		kill_bb(bb);
		bb->ep = NULL;
		DELETE_CURRENT_PTR(bb);
	} END_FOR_EACH_PTR(bb);
	PACK_PTR_LIST(&ep->bbs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5c785(%rip), %rax     # 0xb6358
addq $0x1, %rax
movq %rax, 0x5c77a(%rip)     # 0xb6358
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x59d80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x59c1f
jmp 0x59d6d
jmp 0x59c21
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x59d55
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x59c73
cmpq $0x0, -0x10(%rbp)
jne 0x59c73
jmp 0x59d47
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x59c86
jmp 0x59d47
movq -0x10(%rbp), %rdi
callq 0x59900
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq -0x28(%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, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x59d05
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x59cde
movq -0x40(%rbp), %rax
movl $0xf0f0f0f0, %ecx       # imm = 0xF0F0F0F0
movq %rcx, (%rax)
movq -0x28(%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 -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59d47
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59c28
jmp 0x59d57
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x59c21
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x31170
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: mark_bb_reachable
static void mark_bb_reachable(struct basic_block *bb, unsigned long generation)
{
	struct basic_block *child;

	if (bb->generation == generation)
		return;
	bb->generation = generation;
	FOR_EACH_PTR(bb->children, child) {
		mark_bb_reachable(child, generation);
	} END_FOR_EACH_PTR(child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x59da3
jmp 0x59e4d
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x59dd4
jmp 0x59e4d
jmp 0x59dd6
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x59e39
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x59e21
cmpq $0x0, -0x18(%rbp)
jne 0x59e21
jmp 0x59e2e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59d80
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59ddd
jmp 0x59e3b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x59dd6
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: vrfy_flow
void vrfy_flow(struct entrypoint *ep)
{
	struct basic_block *bb;
	struct basic_block *entry = ep->entry->bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		if (bb == entry)
			entry = NULL;
		vrfy_bb_flow(bb);
	} END_FOR_EACH_PTR(bb);
	assert(!entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x59ea4
jmp 0x59f2f
jmp 0x59ea6
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x59f17
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x59ef1
cmpq $0x0, -0x10(%rbp)
jne 0x59ef1
jmp 0x59f0c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x59f03
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x59f60
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x59ead
jmp 0x59f19
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x59ea6
cmpq $0x0, -0x18(%rbp)
jne 0x59f38
jmp 0x59f57
leaq 0x12eb9(%rip), %rdi     # 0x6cdf8
leaq 0x12ddf(%rip), %rsi     # 0x6cd25
movl $0x316, %edx            # imm = 0x316
leaq 0x12ead(%rip), %rcx     # 0x6cdff
callq 0x11120
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: remove_other_phisources
static int remove_other_phisources(struct basic_block *bb, struct multijmp_list *list, struct basic_block *target)
{
	struct multijmp *jmp;
	int changed = 0;

	FOR_EACH_PTR(list, jmp) {
		if (jmp->target == target) {
			target = NULL;
			continue;
		}
		changed |= remove_phisources(bb, jmp->target);
	} END_FOR_EACH_PTR(jmp);
	return changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %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 0x5a27f
jmp 0x5a31c
jmp 0x5a281
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 0x5a304
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5a2cc
cmpq $0x0, -0x20(%rbp)
jne 0x5a2cc
jmp 0x5a2f9
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x5a2e3
movq $0x0, -0x18(%rbp)
jmp 0x5a2f9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x58b20
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5a288
jmp 0x5a306
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x5a281
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: bb_is_forwarder
static bool bb_is_forwarder(struct basic_block *bb)
{
	struct instruction *insn;

	FOR_EACH_PTR(bb->insns, insn) {
		if (!insn->bb)
			continue;
		switch (insn->opcode) {
		case OP_NOP:
		case OP_INLINED_CALL:
			continue;
		case OP_CBR:
		case OP_BR:
			return true;
		default:
			goto out;
		}
	} END_FOR_EACH_PTR(insn);
out:
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5a590
jmp 0x5a63d
jmp 0x5a592
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5a625
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5a5dd
cmpq $0x0, -0x18(%rbp)
jne 0x5a5dd
jmp 0x5a617
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5a5ea
jmp 0x5a617
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x38(%rbp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0x5a60f
jmp 0x5a600
movl -0x38(%rbp), %eax
addl $-0x4b, %eax
subl $0x1, %eax
ja 0x5a615
jmp 0x5a60d
jmp 0x5a617
movb $0x1, -0x1(%rbp)
jmp 0x5a643
jmp 0x5a63f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5a599
jmp 0x5a627
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x5a592
jmp 0x5a63f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: retarget_parents
static int retarget_parents(struct basic_block *bb, struct basic_block *target)
{
	struct basic_block *parent;

	/*
	 * We can't do FOR_EACH_PTR() here, because the parent list
	 * may change when we rewrite the parent.
	 */
	while ((parent = first_basic_block(bb->parents))) {
		if (!rewrite_parent_branch(parent, bb, target))
			return 0;
	}
	kill_bb(bb);
	return REPEAT_CFG_CLEANUP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5be00
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5a698
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5be20
cmpl $0x0, %eax
jne 0x5a696
movl $0x0, -0x4(%rbp)
jmp 0x5a6a8
jmp 0x5a660
movq -0x10(%rbp), %rdi
callq 0x59900
movl $0x4, -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/flow.c
// Function: rewrite_branch_bb
static struct basic_block * rewrite_branch_bb(struct basic_block *bb, struct instruction *br)
{
	struct basic_block *parent;
	struct basic_block *target = br->bb_true;

	if (br->opcode == OP_CBR) {
		pseudo_t cond = br->cond;
		if (cond->type != PSEUDO_VAL)
			return NULL;
		target = cond->value ? target : br->bb_false;
	}

	/*
	 * We can't do FOR_EACH_PTR() here, because the parent list
	 * may change when we rewrite the parent.
	 */
	while ((parent = first_basic_block(bb->parents)) != NULL) {
		if (!rewrite_parent_branch(parent, bb, target))
			return NULL;
	}
	return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x4, %eax
jne 0x5ae83
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, 0x4(%rax)
je 0x5ae5a
movq $0x0, -0x8(%rbp)
jmp 0x5aec6
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5ae6f
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5ae7b
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5ae85
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5be00
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5aebe
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5be20
cmpl $0x0, %eax
jne 0x5aebc
movq $0x0, -0x8(%rbp)
jmp 0x5aec6
jmp 0x5ae85
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: simplify_one_branch
static int simplify_one_branch(struct basic_block *bb, struct instruction *br)
{
	if (simplify_phi_branch(bb, br))
		return 1;
	return simplify_branch_branch(bb, br, &br->bb_true, 1) |
	       simplify_branch_branch(bb, br, &br->bb_false, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5af50
cmpl $0x0, %eax
je 0x5aefb
movl $0x1, -0x4(%rbp)
jmp 0x5af41
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
addq $0x8, %rdx
movl $0x1, %ecx
callq 0x5aff0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x5aff0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: simplify_phi_branch
static int simplify_phi_branch(struct basic_block *bb, struct instruction *br)
{
	pseudo_t cond = br->cond;
	struct instruction *def;

	if (cond->type != PSEUDO_REG)
		return 0;
	def = cond->def;
	if (def->bb != bb || def->opcode != OP_PHI)
		return 0;
	if (bb_has_side_effects(bb))
		return 0;
	return try_to_simplify_bb(bb, def, br);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3, 0x4(%rax)
je 0x5af7f
movl $0x0, -0x4(%rbp)
jmp 0x5afdb
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5afa7
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
je 0x5afb0
movl $0x0, -0x4(%rbp)
jmp 0x5afdb
movq -0x10(%rbp), %rdi
callq 0x5b130
cmpl $0x0, %eax
je 0x5afc7
movl $0x0, -0x4(%rbp)
jmp 0x5afdb
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5b270
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: simplify_branch_branch
static int simplify_branch_branch(struct basic_block *bb, struct instruction *br,
	struct basic_block **target_p, int bb_true)
{
	struct basic_block *target = *target_p, *final;
	struct instruction *insn;
	int retval;

	if (target == bb)
		return 0;
	insn = last_instruction(target->insns);
	if (!insn || insn->opcode != OP_CBR || insn->cond != br->cond)
		return 0;
	/*
	 * Ahhah! We've found a branch to a branch on the same conditional!
	 * Now we just need to see if we can rewrite the branch..
	 */
	retval = 0;
	final = bb_true ? insn->bb_true : insn->bb_false;
	if (bb_has_side_effects(target))
		goto try_to_rewrite_target;
	if (bb_depends_on(final, target))
		goto try_to_rewrite_target;
	if (bb_depends_on_phi(final, target))
		return 0;
	return rewrite_branch(bb, target_p, target, final);

try_to_rewrite_target:
	/*
	 * If we're the only parent, at least we can rewrite the
	 * now-known second branch.
	 */
	if (bb_list_size(target->parents) != 1)
		return retval;
	convert_to_jump(insn, final);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5b028
movl $0x0, -0x4(%rbp)
jmp 0x5b122
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5a540
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5b060
movq -0x40(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x4, %eax
jne 0x5b060
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x5b06c
movl $0x0, -0x4(%rbp)
jmp 0x5b122
movl $0x0, -0x44(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5b087
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x5b093
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5b130
cmpl $0x0, %eax
je 0x5b0ab
jmp 0x5b0f4
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5b730
cmpl $0x0, %eax
je 0x5b0bf
jmp 0x5b0f4
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5b810
cmpl $0x0, %eax
je 0x5b0da
movl $0x0, -0x4(%rbp)
jmp 0x5b122
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x5b910
movl %eax, -0x4(%rbp)
jmp 0x5b122
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5a6c0
cmpl $0x1, %eax
je 0x5b10e
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5b122
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59f90
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: bb_has_side_effects
static int bb_has_side_effects(struct basic_block *bb)
{
	struct instruction *insn;
	FOR_EACH_PTR(bb->insns, insn) {
		if (!insn->bb)
			continue;
		switch (insn->opcode) {
		case OP_CALL:
			/* FIXME! This should take "const" etc into account */
			return 1;

		case OP_LOAD:
			if (!insn->type)
				return 1;
			if (insn->is_volatile)
				return 1;
			continue;

		case OP_STORE:
		case OP_CONTEXT:
			return 1;

		case OP_ASM:
			/* FIXME! This should take "volatile" etc into account */
			return 1;

		default:
			continue;
		}
	} END_FOR_EACH_PTR(insn);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5b160
jmp 0x5b25f
jmp 0x5b162
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5b247
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5b1b4
cmpq $0x0, -0x18(%rbp)
jne 0x5b1b4
jmp 0x5b239
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5b1c1
jmp 0x5b239
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0xc, %eax
ja 0x5b237
movq -0x40(%rbp), %rax
leaq 0x11ae1(%rip), %rcx     # 0x6ccc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x5b266
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5b209
movl $0x1, -0x4(%rbp)
jmp 0x5b266
movq -0x18(%rbp), %rax
movb 0x40(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x5b223
movl $0x1, -0x4(%rbp)
jmp 0x5b266
jmp 0x5b239
movl $0x1, -0x4(%rbp)
jmp 0x5b266
movl $0x1, -0x4(%rbp)
jmp 0x5b266
jmp 0x5b239
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5b169
jmp 0x5b249
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x5b162
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: phi_check
static bool phi_check(struct instruction *node)
{
	struct basic_block *bb;
	pseudo_t phi;

	PREPARE_PTR_LIST(node->bb->parents, bb);
	FOR_EACH_PTR(node->phi_list, phi) {
		if (phi == VOID || !phi->def)
			continue;
		if (phi->def->bb != bb)
			return false;
		NEXT_PTR_LIST(bb);
	} END_FOR_EACH_PTR(phi);
	if (bb)
		return false;
	FINISH_PTR_LIST(bb);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5b544
jmp 0x5b4e8
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5b521
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5b542
movq $0x0, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5b4e8
jmp 0x5b544
jmp 0x5b546
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5b56e
jmp 0x5b687
jmp 0x5b570
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5b66f
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5b5c2
cmpq $0x0, -0x20(%rbp)
jne 0x5b5c2
jmp 0x5b661
leaq 0x307e7(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x20(%rbp)
je 0x5b5da
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5b5df
jmp 0x5b661
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x5b5fa
movb $0x0, -0x1(%rbp)
jmp 0x5b69a
cmpq $0x0, -0x18(%rbp)
je 0x5b65f
jmp 0x5b603
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5b63c
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5b65d
movq $0x0, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5b603
jmp 0x5b65f
jmp 0x5b661
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5b577
jmp 0x5b671
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x5b570
cmpq $0x0, -0x18(%rbp)
je 0x5b694
movb $0x0, -0x1(%rbp)
jmp 0x5b69a
jmp 0x5b696
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: pseudo_truth_value
static int pseudo_truth_value(pseudo_t pseudo)
{
	switch (pseudo->type) {
	case PSEUDO_VAL:
		return !!pseudo->value;

	case PSEUDO_REG: {
		struct instruction *insn = pseudo->def;

		/* A symbol address is always considered true.. */
		if (insn->opcode == OP_SYMADDR && insn->target == pseudo)
			return 1;
	}
		/* Fall through */
	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0x5b6ed
jmp 0x5b6c9
movl -0x1c(%rbp), %eax
subl $0x6, %eax
jne 0x5b720
jmp 0x5b6d3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5b727
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x3f, %eax
jne 0x5b71e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5b71e
movl $0x1, -0x4(%rbp)
jmp 0x5b727
jmp 0x5b720
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: bb_depends_on
static int bb_depends_on(struct basic_block *target, struct basic_block *src)
{
	pseudo_t pseudo;

	FOR_EACH_PTR(src->defines, pseudo) {
		if (pseudo_in_list(target->needs, pseudo))
			return 1;
	} END_FOR_EACH_PTR(pseudo);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%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 0x5b768
jmp 0x5b7f9
jmp 0x5b76a
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 0x5b7e1
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 0x5b7b5
cmpq $0x0, -0x20(%rbp)
jne 0x5b7b5
jmp 0x5b7d6
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x58af0
cmpl $0x0, %eax
je 0x5b7d4
movl $0x1, -0x4(%rbp)
jmp 0x5b800
jmp 0x5b7d6
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5b771
jmp 0x5b7e3
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5b76a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: bb_depends_on_phi
static int bb_depends_on_phi(struct basic_block *target, struct basic_block *src)
{
	struct instruction *insn;
	FOR_EACH_PTR(src->insns, insn) {
		if (!insn->bb)
			continue;
		if (insn->opcode != OP_PHI)
			continue;
		if (pseudo_in_list(target->needs, insn->target))
			return 1;
	} END_FOR_EACH_PTR(insn);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%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 0x5b848
jmp 0x5b8fd
jmp 0x5b84a
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 0x5b8e5
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 0x5b895
cmpq $0x0, -0x20(%rbp)
jne 0x5b895
jmp 0x5b8d7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5b8a2
jmp 0x5b8d7
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
je 0x5b8b2
jmp 0x5b8d7
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x58af0
cmpl $0x0, %eax
je 0x5b8d5
movl $0x1, -0x4(%rbp)
jmp 0x5b904
jmp 0x5b8d7
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5b851
jmp 0x5b8e7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5b84a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: rewrite_branch
static int rewrite_branch(struct basic_block *bb,
	struct basic_block **ptr,
	struct basic_block *old,
	struct basic_block *new)
{
	if (*ptr != old || new == old || !bb->ep)
		return 0;

	/* We might find new if-conversions or non-dominating CSEs */
	/* we may also create new dead cycles */
	repeat_phase |= REPEAT_CSE | REPEAT_CFG_CLEANUP;
	*ptr = new;
	replace_bb_in_list(&bb->children, old, new, 1);
	remove_bb_from_list(&old->parents, bb, 1);
	add_bb(&new->parents, bb);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x5b94a
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x5b94a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5b953
movl $0x0, -0x4(%rbp)
jmp 0x5b9bb
leaq 0x317fa(%rip), %rax     # 0x8d154
movl (%rax), %ecx
orl $0x5, %ecx
leaq 0x317ee(%rip), %rax     # 0x8d154
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x5b9d0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x59b90
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x5ba10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: vrfy_parents
static void vrfy_parents(struct basic_block *bb)
{
	struct basic_block *tmp;
	FOR_EACH_PTR(bb->parents, tmp) {
		vrfy_bb_in_list(bb, tmp->children);
	} END_FOR_EACH_PTR(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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)
cmpq $0x0, -0x18(%rbp)
jne 0x5bc81
jmp 0x5bcfe
jmp 0x5bc83
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 0x5bcea
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 0x5bcce
cmpq $0x0, -0x10(%rbp)
jne 0x5bcce
jmp 0x5bcdf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5bd10
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5bc8a
jmp 0x5bcec
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5bc83
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: vrfy_bb_in_list
static void vrfy_bb_in_list(struct basic_block *bb, struct basic_block_list *list)
{
	if (bb) {
		struct basic_block *tmp;
		int no_bb_in_list = 0;

		FOR_EACH_PTR(list, tmp) {
			if (bb == tmp)
				return;
		} END_FOR_EACH_PTR(tmp);
		assert(no_bb_in_list);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5bdf6
movl $0x0, -0x1c(%rbp)
movq -0x10(%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 0x5bd53
jmp 0x5bdcd
jmp 0x5bd55
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 0x5bdb9
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5bda0
cmpq $0x0, -0x18(%rbp)
jne 0x5bda0
jmp 0x5bdae
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5bdac
jmp 0x5bdf6
jmp 0x5bdae
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5bd5c
jmp 0x5bdbb
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5bd55
cmpl $0x0, -0x1c(%rbp)
je 0x5bdd5
jmp 0x5bdf4
leaq 0x1107e(%rip), %rdi     # 0x6ce5a
leaq 0x10f42(%rip), %rsi     # 0x6cd25
movl $0x2da, %edx            # imm = 0x2DA
leaq 0x11079(%rip), %rcx     # 0x6ce68
callq 0x11120
jmp 0x5bdf6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: remove_merging_phisrc
static void remove_merging_phisrc(struct instruction *insn, struct basic_block *bot)
{
	struct instruction *node = insn->phi_node;
	pseudo_t phi;

	if (!node) {
		kill_instruction(insn);
		return;
	}

	FOR_EACH_PTR(node->phi_list, phi) {
		struct instruction *phisrc;

		if (phi == VOID)
			continue;
		phisrc = phi->def;
		if (phisrc->bb == bot) {
			kill_instruction(insn);
			return;
		}
	} END_FOR_EACH_PTR(phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5c041
movq -0x8(%rbp), %rdi
callq 0x5c120
jmp 0x5c114
jmp 0x5c043
movq -0x18(%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 0x5c06b
jmp 0x5c114
jmp 0x5c06d
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 0x5c0fc
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 0x5c0b8
cmpq $0x0, -0x20(%rbp)
jne 0x5c0b8
jmp 0x5c0ee
leaq 0x2fcf1(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x20(%rbp)
jne 0x5c0c7
jmp 0x5c0ee
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5c0ec
movq -0x8(%rbp), %rdi
callq 0x5c120
jmp 0x5c114
jmp 0x5c0ee
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5c074
jmp 0x5c0fe
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5c06d
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flow.c
// Function: remove_merging_phi
static void remove_merging_phi(struct basic_block *top, struct instruction *insn)
{
	pseudo_t phi;

	FOR_EACH_PTR(insn->phi_list, phi) {
		struct instruction *def;

		if (phi == VOID)
			continue;

		def = phi->def;
		if (def->bb != top)
			continue;

		convert_instruction_target(insn, def->src);
		kill_instruction(def);
		kill_instruction(insn);
	} END_FOR_EACH_PTR(phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5c198
jmp 0x5c25d
jmp 0x5c19a
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5c245
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5c1e9
cmpq $0x0, -0x18(%rbp)
jne 0x5c1e9
jmp 0x5c237
leaq 0x2fbc0(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x18(%rbp)
jne 0x5c1f8
jmp 0x5c237
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x5c214
jmp 0x5c237
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x58e80
movq -0x40(%rbp), %rdi
callq 0x5c120
movq -0x10(%rbp), %rdi
callq 0x5c120
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5c1a1
jmp 0x5c247
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x5c19a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: cfg_postorder
int cfg_postorder(struct entrypoint *ep)
{
	struct cfg_info info = {
		.gen = ++bb_generation,
	};

	label_postorder(ep->entry->bb, &info);

	// OK, now info.list contains the node in postorder
	// Reuse ep->bbs for the reverse postorder.
	free_ptr_list(&ep->bbs);
	ep->bbs = NULL;
	reverse_bbs(&ep->bbs, info.list);
	free_ptr_list(&info.list);
	if (dbg_postorder)
		debug_postorder(ep);
	return info.nr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x5a03d(%rip), %rax     # 0xb6358
movq (%rax), %rax
addq $0x1, %rax
leaq 0x5a02f(%rip), %rcx     # 0xb6358
movq %rax, (%rcx)
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5c3a0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x31cd0
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x5c4a0
leaq -0x20(%rbp), %rdi
callq 0x31cd0
leaq 0x30e12(%rip), %rax     # 0x8d198
cmpl $0x0, (%rax)
je 0x5c394
movq -0x8(%rbp), %rdi
callq 0x5c550
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: label_postorder
static void label_postorder(struct basic_block *bb, struct cfg_info *info)
{
	struct basic_block *child;

	if (bb->generation == info->gen)
		return;

	bb->generation = info->gen;
	FOR_EACH_PTR_REVERSE(bb->children, child) {
		label_postorder(child, info);
	} END_FOR_EACH_PTR_REVERSE(child);

	bb->postorder_nr = info->nr++;
	add_bb(&info->list, bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5c3c7
jmp 0x5c498
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5c400
jmp 0x5c475
jmp 0x5c402
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jl 0x5c469
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5c45a
cmpq $0x0, -0x18(%rbp)
jne 0x5c45a
jmp 0x5c421
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c3a0
jmp 0x5c421
jmp 0x5c46b
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x5c402
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5cce0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: reverse_bbs
static void reverse_bbs(struct basic_block_list **dst, struct basic_block_list *src)
{
	struct basic_block *bb;
	FOR_EACH_PTR_REVERSE(src, bb) {
		add_bb(dst, bb);
	} END_FOR_EACH_PTR_REVERSE(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5c4d1
jmp 0x5c546
jmp 0x5c4d3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x8, %ax
cwtl
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jl 0x5c53a
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5c52b
cmpq $0x0, -0x18(%rbp)
jne 0x5c52b
jmp 0x5c4f2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5cce0
jmp 0x5c4f2
jmp 0x5c53c
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x5c4d3
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: debug_postorder
static void debug_postorder(struct entrypoint *ep)
{
	struct basic_block *bb;

	printf("%s's reverse postorder:\n", show_ident(ep->name->ident));
	FOR_EACH_PTR(ep->bbs, bb) {
		printf("\t.L%u: %u\n", bb->nr, bb->postorder_nr);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rsi
leaq 0x10a40(%rip), %rdi     # 0x6cfb6
movb $0x0, %al
callq 0x110f0
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)
cmpq $0x0, -0x18(%rbp)
jne 0x5c5a5
jmp 0x5c631
jmp 0x5c5a7
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 0x5c619
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 0x5c5f2
cmpq $0x0, -0x10(%rbp)
jne 0x5c5f2
jmp 0x5c60e
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edx
leaq 0x109c8(%rip), %rdi     # 0x6cfcf
movb $0x0, %al
callq 0x110f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5c5ae
jmp 0x5c61b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5c5a7
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: intersect_dom
static struct basic_block *intersect_dom(struct basic_block *doms[],
		struct basic_block *b1, struct basic_block *b2)
{
	int f1 = b1->postorder_nr, f2 = b2->postorder_nr;
	while (f1 != f2) {
		while (f1 < f2) {
			b1 = doms[f1];
			f1 = b1->postorder_nr;
		}
		while (f2 < f1) {
			b2 = doms[f2];
			f2 = b2->postorder_nr;
		}
	}
	return b1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x5ccda
jmp 0x5cc8e
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5ccb2
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5cc8e
jmp 0x5ccb4
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5ccd8
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x5ccb4
jmp 0x5cc84
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: debug_domtree
static void debug_domtree(struct entrypoint *ep)
{
	struct basic_block *bb = ep->entry->bb;

	printf("%s's idoms:\n", show_ident(ep->name->ident));
	FOR_EACH_PTR(ep->bbs, bb) {
		if (bb == ep->entry->bb)
			continue;	// entry node has no idom
		printf("\t%s	<- %s\n", show_label(bb), show_label(bb->idom));
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rsi
leaq 0x10294(%rip), %rdi     # 0x6cfda
movb $0x0, %al
callq 0x110f0
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)
cmpq $0x0, -0x18(%rbp)
jne 0x5cd75
jmp 0x5ce2b
jmp 0x5cd77
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 0x5ce13
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 0x5cdc2
cmpq $0x0, -0x10(%rbp)
jne 0x5cdc2
jmp 0x5ce05
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x5cdd6
jmp 0x5ce05
movq -0x10(%rbp), %rdi
callq 0x17e00
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x17e00
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x101e9(%rip), %rdi     # 0x6cfe7
movb $0x0, %al
callq 0x110f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5cd7e
jmp 0x5ce15
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5cd77
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/flowgraph.c
// Function: domtree_dominates
bool domtree_dominates(struct basic_block *a, struct basic_block *b)
{
	if (a == b)			// dominance is reflexive
		return true;
	if (a == b->idom)
		return true;
	if (b == a->idom)
		return false;

	// can't dominate if deeper in the DT
	if (a->dom_level >= b->dom_level)
		return false;

	// FIXME: can be faster if we have the DFS in-out numbers

	// walk up the dominator tree
	for (b = b->idom; b; b = b->idom) {
		if (b == a)
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5ce5c
movb $0x1, -0x1(%rbp)
jmp 0x5ced1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x5ce70
movb $0x1, -0x1(%rbp)
jmp 0x5ced1
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x5ce84
movb $0x0, -0x1(%rbp)
jmp 0x5ced1
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jl 0x5ce9a
movb $0x0, -0x1(%rbp)
jmp 0x5ced1
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5cecd
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5cebd
movb $0x1, -0x1(%rbp)
jmp 0x5ced1
jmp 0x5cebf
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5cea6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ir.c
// Function: ir_validate
int ir_validate(struct entrypoint *ep)
{
	struct basic_block *bb;
	int err = 0;

	if (!dbg_ir || has_error)
		return 0;

	FOR_EACH_PTR(ep->bbs, bb) {
		struct instruction *insn;
		FOR_EACH_PTR(bb->insns, insn) {
			if (!insn->bb)
				continue;
			err += validate_insn(ep, insn);
		} END_FOR_EACH_PTR(insn);
	} END_FOR_EACH_PTR(bb);

	if (err)
		abort();
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x3026a(%rip), %rax     # 0x8d194
cmpl $0x0, (%rax)
je 0x5cf3b
leaq 0x3022e(%rip), %rax     # 0x8d164
cmpl $0x0, (%rax)
je 0x5cf47
movl $0x0, -0x4(%rbp)
jmp 0x5d0b8
jmp 0x5cf49
movq -0x10(%rbp), %rax
movq 0x18(%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 0x5cf71
jmp 0x5d0a7
jmp 0x5cf73
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 0x5d08f
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5cfc5
cmpq $0x0, -0x18(%rbp)
jne 0x5cfc5
jmp 0x5d081
jmp 0x5cfc7
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x5cfef
jmp 0x5d07f
jmp 0x5cff1
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x58(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5d067
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5d03c
cmpq $0x0, -0x48(%rbp)
jne 0x5d03c
jmp 0x5d05c
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5d049
jmp 0x5d05c
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x5d0d0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x5cff8
jmp 0x5d069
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq -0x50(%rbp), %rax
jne 0x5cff1
jmp 0x5d081
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5cf7a
jmp 0x5d091
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5cf73
cmpl $0x0, -0x1c(%rbp)
je 0x5d0b2
callq 0x11060
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)