LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ir.c
// Function: check_user
static int check_user(struct instruction *insn, pseudo_t pseudo)
{
	struct instruction *def;

	if (!pseudo) {
		show_entry(insn->bb->ep);
		sparse_error(insn->pos, "null pseudo in %s", show_instruction(insn));
		return 1;
	}
	switch (pseudo->type) {
	case PSEUDO_PHI:
	case PSEUDO_REG:
		def = pseudo->def;
		if (def && def->bb)
			break;
		show_entry(insn->bb->ep);
		sparse_error(insn->pos, "wrong usage for %s in %s", show_pseudo(pseudo),
			show_instruction(insn));
		return 1;

	default:
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d2ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x19d60
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18200
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xfe99(%rip), %rsi      # 0x6d134
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x5d33d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x5d334
jmp 0x5d2bf
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5d2df
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5d2df
jmp 0x5d336
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x19d60
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17e80
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18200
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xfe22(%rip), %rsi      # 0x6d146
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x5d33d
jmp 0x5d336
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ir.c
// Function: check_branch
static int check_branch(struct entrypoint *ep, struct instruction *insn, struct basic_block *bb)
{
	if (bb->ep && lookup_bb(ep->bbs, bb))
		return 0;
	sparse_error(insn->pos, "branch to dead BB: %s", show_instruction(insn));
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5d38e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d8d0
cmpl $0x0, %eax
je 0x5d38e
movl $0x0, -0x4(%rbp)
jmp 0x5d3bf
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18200
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xfdae(%rip), %rsi      # 0x6d15f
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ir.c
// Function: check_return
static int check_return(struct instruction *insn)
{
	struct symbol *ctype = insn->type;

	if (ctype && ctype->bit_size > 0 && insn->src == VOID) {
		sparse_error(insn->pos, "return without value");
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5d7c9
movq -0x18(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jle 0x5d7c9
movq -0x10(%rbp), %rax
leaq 0x2e60c(%rip), %rcx     # 0x8bdb0
cmpq %rcx, 0x30(%rax)
jne 0x5d7c9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xfa4e(%rip), %rsi      # 0x6d207
movb $0x0, %al
callq 0x16f90
movl $0x1, -0x4(%rbp)
jmp 0x5d7d0
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/ir.c
// Function: check_switch
static int check_switch(struct entrypoint *ep, struct instruction *insn)
{
	struct multijmp *jmp;
	int err = 0;

	FOR_EACH_PTR(insn->multijmp_list, jmp) {
		err = check_branch(ep, insn, jmp->target);
		if (err)
			return err;
	} END_FOR_EACH_PTR(jmp);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%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 0x5d81f
jmp 0x5d8b6
jmp 0x5d821
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 0x5d89e
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 0x5d86c
cmpq $0x0, -0x20(%rbp)
jne 0x5d86c
jmp 0x5d893
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x5d350
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5d891
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d8bc
jmp 0x5d893
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5d828
jmp 0x5d8a0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x5d821
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ir.c
// Function: nbr_phi_operands
static int nbr_phi_operands(struct instruction *insn)
{
	pseudo_t p;
	int nbr = 0;

	if (!insn->phi_list)
		return 0;

	FOR_EACH_PTR(insn->phi_list, p) {
		if (p == VOID)
			continue;
		nbr++;
	} END_FOR_EACH_PTR(p);

	return nbr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x5d976
movl $0x0, -0x4(%rbp)
jmp 0x5da2e
jmp 0x5d978
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5d9a0
jmp 0x5da28
jmp 0x5d9a2
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 0x5da10
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 0x5d9ed
cmpq $0x0, -0x18(%rbp)
jne 0x5d9ed
jmp 0x5da05
leaq 0x2e3bc(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x18(%rbp)
jne 0x5d9fc
jmp 0x5da05
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5d9a9
jmp 0x5da12
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5d9a2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: clear_liveness
void clear_liveness(struct entrypoint *ep)
{
	struct basic_block *bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		free_ptr_list(&bb->needs);
		free_ptr_list(&bb->defines);
	} END_FOR_EACH_PTR(bb);
}

// 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 0x5daf4
jmp 0x5db84
jmp 0x5daf6
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 0x5db6c
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 0x5db41
cmpq $0x0, -0x10(%rbp)
jne 0x5db41
jmp 0x5db61
jmp 0x5db43
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x31cd0
jmp 0x5db52
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x31cd0
jmp 0x5db61
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5dafd
jmp 0x5db6e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5daf6
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: insn_uses
static void insn_uses(struct basic_block *bb, pseudo_t pseudo)
{
	if (trackable_pseudo(pseudo)) {
		struct instruction *def = pseudo->def;
		if (pseudo->type != PSEUDO_REG || def->bb != bb || def->opcode == OP_PHI)
			add_pseudo_exclusive(&bb->needs, pseudo);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ef80
cmpl $0x0, %eax
je 0x5e553
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x5e540
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x5e540
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
jne 0x5e551
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f010
jmp 0x5e553
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: track_bb_liveness
static void track_bb_liveness(struct basic_block *bb)
{
	pseudo_t needs;

	FOR_EACH_PTR(bb->needs, needs) {
		struct basic_block *parent;
		FOR_EACH_PTR(bb->parents, parent) {
			if (!pseudo_in_list(parent->defines, needs)) {
				add_pseudo_exclusive(&parent->needs, needs);
			}
		} END_FOR_EACH_PTR(parent);
	} END_FOR_EACH_PTR(needs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%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 0x5e594
jmp 0x5e6d3
jmp 0x5e596
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 0x5e6bb
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 0x5e5e8
cmpq $0x0, -0x10(%rbp)
jne 0x5e5e8
jmp 0x5e6ad
jmp 0x5e5ea
movq -0x8(%rbp), %rax
movq 0x18(%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 0x5e612
jmp 0x5e6ab
jmp 0x5e614
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 0x5e693
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 0x5e65f
cmpq $0x0, -0x38(%rbp)
jne 0x5e65f
jmp 0x5e688
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5da90
cmpl $0x0, %eax
jne 0x5e686
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x5f010
jmp 0x5e688
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5e61b
jmp 0x5e695
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x5e614
jmp 0x5e6ad
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5e59d
jmp 0x5e6bd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5e596
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: track_pseudo_death
void track_pseudo_death(struct entrypoint *ep)
{
	struct basic_block *bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		track_bb_phi_uses(bb);
	} END_FOR_EACH_PTR(bb);

	FOR_EACH_PTR(ep->bbs, bb) {
		track_pseudo_death_bb(bb);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 0x5e711
jmp 0x5e786
jmp 0x5e713
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 0x5e772
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 0x5e75e
cmpq $0x0, -0x10(%rbp)
jne 0x5e75e
jmp 0x5e767
movq -0x10(%rbp), %rdi
callq 0x5e830
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5e71a
jmp 0x5e774
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5e713
jmp 0x5e788
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x5e7ad
jmp 0x5e822
jmp 0x5e7af
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x5e80e
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5e7fa
cmpq $0x0, -0x10(%rbp)
jne 0x5e7fa
jmp 0x5e803
movq -0x10(%rbp), %rdi
callq 0x5e900
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x5e7b6
jmp 0x5e810
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x5e7af
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: track_bb_phi_uses
static void track_bb_phi_uses(struct basic_block *bb)
{
	struct instruction *insn;
	FOR_EACH_PTR(bb->insns, insn) {
		if (insn->bb && insn->opcode == OP_PHI)
			track_phi_uses(insn);
	} END_FOR_EACH_PTR(insn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%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 0x5e864
jmp 0x5e8f8
jmp 0x5e866
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 0x5e8e0
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 0x5e8b1
cmpq $0x0, -0x10(%rbp)
jne 0x5e8b1
jmp 0x5e8d5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5e8d3
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
jne 0x5e8d3
movq -0x10(%rbp), %rdi
callq 0x5f060
jmp 0x5e8d5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5e86d
jmp 0x5e8e2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5e866
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: phi_defines
static void phi_defines(struct instruction * phi_node, pseudo_t target,
	void (*defines)(struct basic_block *, pseudo_t))
{
	pseudo_t phi;
	FOR_EACH_PTR(phi_node->phi_list, phi) {
		struct instruction *def;
		if (phi == VOID)
			continue;
		def = phi->def;
		if (!def || !def->bb)
			continue;
		defines(def->bb, target);
	} END_FOR_EACH_PTR(phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%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 0x5ed1c
jmp 0x5edd0
jmp 0x5ed1e
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 0x5edb8
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 0x5ed69
cmpq $0x0, -0x20(%rbp)
jne 0x5ed69
jmp 0x5edaa
leaq 0x2d040(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x20(%rbp)
jne 0x5ed78
jmp 0x5edaa
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x5ed96
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5ed98
jmp 0x5edaa
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5ed25
jmp 0x5edba
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x5ed1e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: asm_liveness
static void asm_liveness(struct basic_block *bb, struct instruction *insn,
	void (*def)(struct basic_block *, pseudo_t),
	void (*use)(struct basic_block *, pseudo_t))
{
	struct asm_constraint *entry;

	FOR_EACH_PTR(insn->asm_rules->inputs, entry) {
		use(bb, entry->pseudo);
	} END_FOR_EACH_PTR(entry);
		
	FOR_EACH_PTR(insn->asm_rules->outputs, entry) {
		if (entry->is_memory)
			use(bb, entry->pseudo);
		else
			def(bb, entry->pseudo);
	} END_FOR_EACH_PTR(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%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 0x5ee20
jmp 0x5ee9d
jmp 0x5ee22
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 0x5ee89
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 0x5ee6d
cmpq $0x0, -0x28(%rbp)
jne 0x5ee6d
jmp 0x5ee7e
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5ee29
jmp 0x5ee8b
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x5ee22
jmp 0x5ee9f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%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 0x5eecb
jmp 0x5ef75
jmp 0x5eecd
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 0x5ef5d
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x5ef18
cmpq $0x0, -0x28(%rbp)
jne 0x5ef18
jmp 0x5ef4f
movq -0x28(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x5ef3c
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
jmp 0x5ef4d
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
jmp 0x5ef4f
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x5eed4
jmp 0x5ef5f
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq -0x50(%rbp), %rax
jne 0x5eecd
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: track_phi_uses
static void track_phi_uses(struct instruction *insn)
{
	pseudo_t phi;
	FOR_EACH_PTR(insn->phi_list, phi) {
		struct instruction *def;
		if (phi == VOID || !phi->def)
			continue;
		def = phi->def;
		assert(def->opcode == OP_PHISOURCE);
	} END_FOR_EACH_PTR(phi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%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 0x5f094
jmp 0x5f162
jmp 0x5f096
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 0x5f14a
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 0x5f0e5
cmpq $0x0, -0x10(%rbp)
jne 0x5f0e5
jmp 0x5f13c
leaq 0x2ccc4(%rip), %rax     # 0x8bdb0
cmpq %rax, -0x10(%rbp)
je 0x5f0fd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5f0ff
jmp 0x5f13c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x45, %eax
jne 0x5f11b
jmp 0x5f13a
leaq 0xa1f6(%rip), %rdi      # 0x69318
leaq 0xe237(%rip), %rsi      # 0x6d360
movl $0x103, %edx            # imm = 0x103
leaq 0xe2b1(%rip), %rcx      # 0x6d3e6
callq 0x11120
jmp 0x5f13c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5f09d
jmp 0x5f14c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x5f096
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/liveness.c
// Function: merge_pseudo_list
static void merge_pseudo_list(struct pseudo_list *src, struct pseudo_list **dest)
{
	pseudo_t pseudo;
	FOR_EACH_PTR(src, pseudo) {
		add_pseudo_exclusive(dest, pseudo);
	} END_FOR_EACH_PTR(pseudo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %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 0x5f1a1
jmp 0x5f21a
jmp 0x5f1a3
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 0x5f206
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 0x5f1ee
cmpq $0x0, -0x18(%rbp)
jne 0x5f1ee
jmp 0x5f1fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f010
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5f1aa
jmp 0x5f208
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x5f1a3
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/memops.c
// Function: compatible_loads
static bool compatible_loads(struct instruction *a, struct instruction *b)
{
	if (is_integral_type(a->type) && is_float_type(b->type))
		return false;
	if (is_float_type(a->type) && is_integral_type(b->type))
		return false;
	return true;
}

// 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 0x602b0
testb $0x1, %al
jne 0x5fd73
jmp 0x5fd8b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x60330
cmpl $0x0, %eax
je 0x5fd8b
movb $0x0, -0x1(%rbp)
jmp 0x5fdba
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x60330
cmpl $0x0, %eax
je 0x5fdb6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x602b0
testb $0x1, %al
jne 0x5fdb0
jmp 0x5fdb6
movb $0x0, -0x1(%rbp)
jmp 0x5fdba
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/memops.c
// Function: try_to_kill_store
static bool try_to_kill_store(struct instruction *insn,
			     struct instruction *dom, int local)
{
	int dominance = dominates(insn, dom, local);

	if (dominance) {
		/* possible partial dominance? */
		if (dominance < 0)
			return false;
		if (insn->target == dom->target && insn->bb == dom->bb) {
			// found a memop which makes the store redundant
			kill_instruction_force(insn);
			return false;
		}
		if (dom->opcode == OP_LOAD)
			return false;
		if (dom->is_volatile)
			return false;
		/* Yeehaa! Found one! */
		kill_instruction_force(dom);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x59060
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x6060f
cmpl $0x0, -0x20(%rbp)
jge 0x605a8
movb $0x0, -0x1(%rbp)
jmp 0x60613
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x605db
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x605db
movq -0x10(%rbp), %rdi
callq 0x60640
movb $0x0, -0x1(%rbp)
jmp 0x60613
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x43, %eax
jne 0x605ef
movb $0x0, -0x1(%rbp)
jmp 0x60613
movq -0x18(%rbp), %rax
movb 0x40(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x60606
movb $0x0, -0x1(%rbp)
jmp 0x60613
movq -0x18(%rbp), %rdi
callq 0x60640
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/memops.c
// Function: address_taken
static int address_taken(pseudo_t pseudo)
{
	struct pseudo_user *pu;
	FOR_EACH_PTR(pseudo->users, pu) {
		struct instruction *insn = pu->insn;
		if (insn->bb && (insn->opcode != OP_LOAD && insn->opcode != OP_STORE))
			return 1;
		if (pu->userp != &insn->src)
			return 1;
	} END_FOR_EACH_PTR(pu);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%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 0x60690
jmp 0x60762
jmp 0x60692
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 0x6074a
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 0x606e1
cmpq $0x0, -0x18(%rbp)
jne 0x606e1
jmp 0x6073c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6071c
movq -0x40(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x43, %eax
je 0x6071c
movq -0x40(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x44, %eax
je 0x6071c
movl $0x1, -0x4(%rbp)
jmp 0x60769
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
addq $0x30, %rcx
cmpq %rcx, %rax
je 0x6073a
movl $0x1, -0x4(%rbp)
jmp 0x60769
jmp 0x6073c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x60699
jmp 0x6074c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x60692
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ptrmap.c
// Function: _ptrmap_add
void __ptrmap_add(struct ptrmap **mapp, void *key, void *val)
{
	struct ptrmap *head = *mapp;
	struct ptrmap *newmap;
	struct ptrmap *map;
	struct ptrpair *pair;
	int nr;

	if ((map = head)) {
		struct ptrmap *next = map->next;
		if (next)		// head is full
			map = next;
		if ((nr = map->nr) < MAP_NR)
			goto oldmap;
	}

	// need a new block
	newmap = __alloc_ptrmap(0);
	if (!head) {
		*mapp = newmap;
	} else {
		newmap->next = head->next;
		head->next = newmap;
	}
	map = newmap;
	nr = 0;

oldmap:
	pair = &map->pairs[nr];
	pair->key = key;
	pair->val = val;
	map->nr = ++nr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x608ba
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x608a7
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x7, %eax
jge 0x608b8
jmp 0x60901
jmp 0x608ba
xorl %edi, %edi
callq 0x60770
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x608d9
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x608f2
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ptrmap.c
// Function: _ptrmap_lookup
void *__ptrmap_lookup(struct ptrmap *map, void *key)
{
	for (; map; map = map->next) {
		int i, n = map->nr;
		for (i = 0; i < n; i++) {
			struct ptrpair *pair = &map->pairs[i];
			if (pair->key == key)
				return pair->val;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x609ca
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x609bb
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x609ae
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x609d2
jmp 0x609b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60974
jmp 0x609bd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6095c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ptrmap.c
// Function: _ptrmap_update
void __ptrmap_update(struct ptrmap **mapp, void *key, void *val)
{
	struct ptrmap *map = *mapp;

	for (; map; map = map->next) {
		int i, n = map->nr;
		for (i = 0; i < n; i++) {
			struct ptrpair *pair = &map->pairs[i];
			if (pair->key == key) {
				if (pair->val != val)
					pair->val = val;
				return;
			}
		}
	}

	__ptrmap_add(mapp, key, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60a7b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x60a6c
movq -0x20(%rbp), %rax
addq $0x10, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x60a5f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x60a5d
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x60a8c
jmp 0x60a61
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x60a17
jmp 0x60a6e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x609ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x60860
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/char.c
// Function: get_char_constant
void get_char_constant(struct token *token, unsigned long long *val)
{
	const char *p = token->embedded, *end;
	unsigned v;
	int type = token_type(token);
	switch (type) {
	case TOKEN_CHAR:
	case TOKEN_WIDE_CHAR:
		p = token->string->data;
		end = p + token->string->length - 1;
		if (end == p) {
			sparse_error(token->pos, "empty character constant");
			*val = 0;
			return;
		}
		break;
	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
		end = p + type - TOKEN_CHAR;
		break;
	default:
		end = p + type - TOKEN_WIDE_CHAR;
	}
	p = parse_escape(p, &v, end,
			type < TOKEN_WIDE_CHAR ? bits_in_char : wchar_ctype->bit_size, token->pos);
	if (p != end)
		warning(token->pos,
			"multi-character character constant");
	*val = v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x6, %eax
je 0x60b1c
jmp 0x60b05
movl -0x2c(%rbp), %eax
addl $-0x7, %eax
subl $0x4, %eax
jb 0x60b7f
jmp 0x60b12
movl -0x2c(%rbp), %eax
subl $0xb, %eax
jne 0x60b94
jmp 0x60b1c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x60b7d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xca5e(%rip), %rsi      # 0x6d5c4
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x60c25
jmp 0x60ba7
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
addq %rcx, %rax
addq $-0x6, %rax
movq %rax, -0x20(%rbp)
jmp 0x60ba7
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
addq %rcx, %rax
addq $-0xb, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0xb, -0x28(%rbp)
jge 0x60bcb
leaq 0x29b0c(%rip), %rax     # 0x8a6d0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x60bdb
leaq 0x29a5e(%rip), %rax     # 0x8a630
movq (%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq -0x24(%rbp), %rsi
callq 0x60c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x60c19
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xc9cb(%rip), %rsi      # 0x6d5dd
movb $0x0, %al
callq 0x16d80
movl -0x24(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c,unsigned long long *clen,
	const unsigned char *m,unsigned long long mlen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k
)
{
/*
...
... the code for the cipher implementation goes here,
... generating a ciphertext c[0],c[1],...,c[*clen-1]
... from a plaintext m[0],m[1],...,m[mlen-1]
... and associated data ad[0],ad[1],...,ad[adlen-1]
... and secret message number nsec[0],nsec[1],...
... and public message number npub[0],npub[1],...
... and secret key k[0],k[1],...
...
*/
	size_t x, v;
	PI_ENCRYPT_SIMPLE(
			c,
			&x,
			&c[mlen + (nsec ? PI_CT_BLOCK_LENGTH_BYTES : 0)],
			&v,
			m,
			mlen,
			ad,
			adlen,
			nsec,
			npub,
			CRYPTO_NPUBBYTES,
			k,
			CRYPTO_KEYBYTES );
	*clen = x + PI_TAG_BYTES;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rdx
movq 0x58(%rsp), %rax
movq 0x90(%rsp), %r8
xorl %ecx, %ecx
movl $0x20, %esi
cmpq $0x0, %r8
cmovnel %esi, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq %rax, %rdx
movq 0x60(%rsp), %r8
movq 0x58(%rsp), %r9
movq 0x50(%rsp), %r14
movq 0x48(%rsp), %rbx
movq 0x90(%rsp), %r11
movq 0x98(%rsp), %r10
movq 0xa0(%rsp), %rax
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq $0x20, 0x30(%rsp)
callq 0x1100
movq 0x40(%rsp), %rcx
addq $0x20, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: load_u32_little
static uint32_t load_u32_little(const void *mem)
{
	uint32_t ret;
	const uint8_t *x = (const uint8_t *)mem;
	ret =   (uint32_t)x[0] <<  0
	      | (uint32_t)x[1] <<  8
	      | (uint32_t)x[2] << 16
	      | (uint32_t)x[3] << 24;
	return ret;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
movq -0x18(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x18(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: pi
static void pi(
        word_t *a )
{
    uint8_t r = PI_ROUNDS;
    word_t t[4 * 4];
    const word_t *c = (const word_t *)pi_const;
    do {
        e1(t, c, a, 4);
        c = &c[4];
        e2(a, c, t, 4);
        c = &c[4];
    } while (--r);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movb $0x3, 0x5f(%rsp)
leaq 0x19cb(%rip), %rax      # 0x3010
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl $0x4, %ecx
callq 0x26e0
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x4, %ecx
callq 0x2780
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movb 0x5f(%rsp), %al
addb $-0x1, %al
movb %al, 0x5f(%rsp)
cmpb $0x0, %al
jne 0x164a
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: pi32_process_ad_block
void PI_PROCESS_AD_BLOCK(
        PI_CTX *ctx,
        const void *ad,
        unsigned long ad_num )
{
    state_t a;
    ctr_trans(ctx, a, ad_num);
    inject_block(a, ad);
    pi((word_t*)a);
    add_tag(ctx, a);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rsp, %rsi
movq 0x40(%rsp), %rdx
callq 0x1700
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
callq 0x17a0
movq %rsp, %rdi
callq 0x1630
movq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x1840
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: ctr_trans
static void ctr_trans(
        const PI_CTX *ctx,
        state_t a,
        unsigned long ctr )
{
    uint64_t t;
    int i;
    if ((void *)ctx->cis != (void *)a) {
        memcpy(a, ctx->cis, sizeof(state_t));
    }
    t = ctx->ctr + ctr;
    for (i = 0; i * PI_WORD_SIZE < 64; ++i) {
    	a[0][i] ^= (word_t)t;
#  if PI_WORD_SIZE < 64
    	t >>= PI_WORD_SIZE;
#  endif
    }

    pi((word_t*)a);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1733
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x40, %edx
callq 0x1120
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
shll $0x5, %eax
cmpl $0x40, %eax
jge 0x178c
movq 0x8(%rsp), %rax
movl %eax, %edx
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
shrq $0x20, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x174e
movq 0x18(%rsp), %rdi
callq 0x1630
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: inject_block
static void inject_block(
        state_t a,
        const void *block )
{
	word_t x;
	int i;
	for (i = 0; i < 4; ++i) {
		x = load_word_little(&((const word_t *)block)[i]);
	    a[0][i] ^= x;
	}
	for (; i < 8; ++i) {
		x = load_word_little(&((const word_t *)block)[i]);
	    a[2][i - 4] ^= x;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, (%rsp)
cmpl $0x4, (%rsp)
jge 0x17f2
movq 0x8(%rsp), %rdi
movslq (%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x15e0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x17b5
jmp 0x17f4
cmpl $0x8, (%rsp)
jge 0x1838
movq 0x8(%rsp), %rdi
movslq (%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x15e0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
xorl 0x20(%rax,%rcx,4), %edx
movl %edx, 0x20(%rax,%rcx,4)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x17f4
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: add_tag
static void add_tag(
        PI_CTX *ctx,
        state_t a )
{
    uint8_t i;
    i = 3;
    do {
        ctx->tag[i + 0] += a[0][i];
        ctx->tag[i + 4] += a[2][i];
    } while(i--);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb $0x3, -0x11(%rsp)
movq -0x10(%rsp), %rax
movzbl -0x11(%rsp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movzbl -0x11(%rsp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
addl 0x40(%rax,%rcx,4), %edx
movl %edx, 0x40(%rax,%rcx,4)
movq -0x10(%rsp), %rax
movzbl -0x11(%rsp), %ecx
movl 0x20(%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movzbl -0x11(%rsp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
addl 0x40(%rax,%rcx,4), %edx
movl %edx, 0x40(%rax,%rcx,4)
movb -0x11(%rsp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, -0x11(%rsp)
cmpb $0x0, %al
jne 0x184f
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: pi32_process_ad_last_block
void PI_PROCESS_AD_LAST_BLOCK(
        PI_CTX *ctx,
        const void *ad,
        size_t ad_length_b,
        unsigned long ad_num )
{
    state_t a;
    while (ad_length_b >= PI_AD_BLOCK_LENGTH_BITS) {
        PI_PROCESS_AD_BLOCK(ctx, ad, ad_num);
        ad_num++;
        ad_length_b -= PI_AD_BLOCK_LENGTH_BITS;
        ad = &((uint8_t*)ad)[PI_AD_BLOCK_LENGTH_BYTES];
    }

    ctr_trans(ctx, a, ad_num);
    inject_last_block(a, ad, ad_length_b);
    pi((word_t*)a);
    add_tag(ctx, a);
    ctx->ctr += ad_num;
    inject_tag(ctx->cis, ctx->tag);
    pi((word_t*)ctx->cis);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
cmpq $0x100, 0x50(%rsp)      # imm = 0x100
jb 0x1915
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x10d0
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
subq $0x100, %rax            # imm = 0x100
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x58(%rsp)
jmp 0x18c8
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
movq 0x48(%rsp), %rdx
callq 0x1700
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x1990
movq %rsp, %rdi
callq 0x1630
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x1840
movq 0x48(%rsp), %rcx
movq 0x60(%rsp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x40, %rsi
callq 0x1a10
movq 0x60(%rsp), %rdi
callq 0x1630
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: inject_last_block
static void inject_last_block(
        state_t a,
        const void *block,
        size_t length_b )
{
    uint8_t t[PI_RATE_BYTES];
    if (length_b >= PI_RATE_BITS) {
        /* error */
    	printf("ERROR <%s %s %d>\n", __FILE__, __func__, __LINE__);
        return;
    }
    memset(t, 0, sizeof(t));
    memcpy(t, block, (length_b + 7) / 8);
    t[length_b / 8] |= 1 << (length_b & 7);
    inject_block(a, t);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x100, 0x20(%rsp)      # imm = 0x100
jb 0x19b0
jmp 0x1a0a
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
movq %rsp, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x7, %rdx
shrq $0x3, %rdx
callq 0x1120
movq 0x20(%rsp), %rax
andq $0x7, %rax
movl %eax, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x20(%rsp), %rax
shrq $0x3, %rax
movzbl (%rsp,%rax), %ecx
orl %edx, %ecx
movb %cl, (%rsp,%rax)
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x17a0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: inject_tag
static void inject_tag(
        state_t a,
        const word_t x[8] )
{
	int i;
	for (i = 0; i < 4; ++i) {
	    a[0][i] ^= x[i];
	}
	for (; i < 8; ++i) {
	    a[2][i - 4] ^= x[i];
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x4, -0x14(%rsp)
jge 0x1a53
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1a22
jmp 0x1a55
cmpl $0x8, -0x14(%rsp)
jge 0x1a8d
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
xorl 0x20(%rax,%rcx,4), %edx
movl %edx, 0x20(%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1a55
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: pi32_process_smn
void PI_PROCESS_SMN(
        PI_CTX *ctx,
        void *c0,
        const void *smn)
{
    ctx->ctr++;
    ctr_trans(ctx, ctx->cis, 0);
    inject_block(ctx->cis, smn);
    if (c0) {
        extract_block(c0, ctx->cis);
    }
    pi((word_t*)ctx->cis);
    add_tag(ctx, ctx->cis);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1700
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x17a0
cmpq $0x0, 0x8(%rsp)
je 0x1aeb
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1b10
movq 0x10(%rsp), %rdi
callq 0x1630
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1840
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref2/pi-cipher.c
// Function: extract_block
static void extract_block(
        void *block,
        state_t a)
{
	int i;
	for (i = 0; i < 4; ++i) {
		store_word_little(&((word_t *)block)[i], a[0][i]);
	}
	for (; i < 8; ++i) {
		store_word_little(&((word_t *)block)[i], a[2][i - 4]);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x1b5d
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1ef0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1b26
jmp 0x1b5f
cmpl $0x8, 0x4(%rsp)
jge 0x1b9c
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
movl 0x20(%rax,%rcx,4), %esi
callq 0x1ef0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1b5f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)