LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: recover_from
static int recover_from(struct dhara_journal *j,
			dhara_error_t write_err,
			dhara_error_t *err)
{
	const dhara_page_t old_head = j->head;

	if (write_err != DHARA_E_BAD_BLOCK) {
		dhara_set_error(err, write_err);
		return -1;
	}

	/* Advance to the next free page */
	j->bb_current++;
	if (skip_block(j, err) < 0)
		return -1;

	/* Are we already in the middle of a recovery? */
	if (dhara_journal_in_recovery(j)) {
		restart_recovery(j, old_head);
		dhara_set_error(err, DHARA_E_RECOVER);
		return -1;
	}

	/* Were we block aligned? No recovery required! */
	if (is_aligned(old_head, j->nand->log2_ppb)) {
		dhara_nand_mark_bad(j->nand, old_head >> j->nand->log2_ppb);
		return 0;
	}

	j->recover_root = j->root;
	j->recover_next =
		j->recover_root & ~((1 << j->nand->log2_ppb) - 1);

	/* Are we holding buffered metadata? Dump it first. */
	if (!is_aligned(old_head, j->log2_ppc) &&
	    dump_meta(j, err) < 0)
		return -1;

	j->flags |= DHARA_JOURNAL_F_RECOVERY;
	dhara_set_error(err, DHARA_E_RECOVER);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x1, %esi
jne 0x26ef
movq %rdi, %r14
movl 0x24(%rdi), %r15d
incl 0x14(%rdi)
movq %rbx, %rsi
callq 0x28a8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x2762
movb 0x12(%r14), %al
testb $0x4, %al
jne 0x26fd
movq (%r14), %rdi
movzbl 0x1(%rdi), %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %esi, %r8d
notl %r8d
testl %r8d, %r15d
je 0x272e
movl 0x28(%r14), %ecx
movl %ecx, 0x30(%r14)
andl %ecx, %esi
movl %esi, 0x2c(%r14)
movb 0x10(%r14), %cl
shll %cl, %edx
notl %edx
testl %edx, %r15d
je 0x26e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28f8
testl %eax, %eax
js 0x276f
movb 0x12(%r14), %al
orb $0x4, %al
movb %al, 0x12(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x2757
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x2762
movl %esi, (%rbx)
jmp 0x2762
movl 0x34(%r14), %edx
movq (%r14), %rdi
movzbl 0x1(%rdi), %ecx
cmpl $-0x1, %edx
je 0x2716
xorl %r15d, %edx
shrl %cl, %edx
testl %edx, %edx
je 0x273d
shrl %cl, %r15d
movl %r15d, %esi
callq 0x31cb
movb 0x12(%r14), %al
movq (%r14), %rcx
movzbl 0x1(%rcx), %ecx
jmp 0x273f
shrl %cl, %r15d
movl %r15d, %esi
callq 0x31cb
xorl %ebp, %ebp
jmp 0x2762
orb $0x2, %al
andb $-0x9, %al
movb %al, 0x12(%r14)
movl 0x30(%r14), %eax
movl %eax, %edx
shrl %cl, %edx
shll %cl, %edx
movl %edx, 0x2c(%r14)
movl %eax, 0x28(%r14)
testq %rbx, %rbx
je 0x2762
movl $0x4, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x2762
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: dhara_journal_copy
int dhara_journal_copy(struct dhara_journal *j,
		       dhara_page_t p, const uint8_t *meta,
		       dhara_error_t *err)
{
	dhara_error_t my_err;
	int i;

	for (i = 0; i < DHARA_MAX_RETRIES; i++) {
		if (!(prepare_head(j, &my_err) ||
		      dhara_nand_copy(j->nand, p, j->head, &my_err)))
			return push_meta(j, meta, err);

		if (recover_from(j, my_err, err) < 0)
			return -1;
	}

	dhara_set_error(err, DHARA_E_TOO_BAD);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x8, %r13d
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x23ca
testl %eax, %eax
jne 0x27bb
movq (%r15), %rdi
movl 0x24(%r15), %edx
movl %ebp, %esi
movq %r12, %rcx
callq 0x3472
testl %eax, %eax
je 0x27e7
movl 0x4(%rsp), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2658
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x27f5
decl %r13d
jne 0x2797
testq %rbx, %rbx
je 0x27f5
movl $0x3, (%rbx)
jmp 0x27f5
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: dhara_journal_next_recoverable
dhara_page_t dhara_journal_next_recoverable(struct dhara_journal *j)
{
	const dhara_page_t n = j->recover_next;

	if (!dhara_journal_in_recovery(j))
		return DHARA_PAGE_NONE;

	if (j->flags & DHARA_JOURNAL_F_ENUM_DONE)
		return DHARA_PAGE_NONE;

	if (j->recover_next == j->recover_root)
		j->flags |= DHARA_JOURNAL_F_ENUM_DONE;
	else
		j->recover_next = next_upage(j, j->recover_next);

	return n;
}

// Assembly:
movb 0x12(%rdi), %cl
movl %ecx, %edx
andb $0xc, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x4, %dl
jne 0x2824
movl 0x2c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jne 0x2825
orb $0x8, %cl
movb %cl, 0x12(%rdi)
retq
movq (%rdi), %rsi
movb 0x10(%rdi), %cl
movb 0x1(%rsi), %dl
movl 0x4(%rsi), %esi
leal 0x1(%rax), %r8d
leal 0x2(%rax), %r9d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
shll %cl, %r10d
notl %r10d
testl %r10d, %r9d
cmovel %r9d, %r8d
movl %edx, %ecx
shll %cl, %esi
xorl %ecx, %ecx
cmpl %esi, %r8d
cmovbl %r8d, %ecx
movl %ecx, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: cp_free
static int cp_free(struct dhara_journal *j, dhara_page_t first_user)
{
	const int count = 1 << j->log2_ppc;
	int i;

	for (i = 0; i < count; i++)
		if (!dhara_nand_is_free(j->nand, first_user + i))
			return 0;

	return 1;
}

// Assembly:
movzbl 0x10(%rdi), %ecx
movl $0x1, %eax
cmpl $0x1f, %ecx
je 0x28a7
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %ebp
shll %cl, %ebp
movl $0x1, %eax
cmpl $0x2, %ebp
cmovll %eax, %ebp
movq (%r14), %rdi
movl %ebx, %esi
callq 0x33b4
testl %eax, %eax
je 0x28a1
incl %ebx
decl %ebp
jne 0x2886
movl $0x1, %eax
jmp 0x28a3
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: skip_block
static int skip_block(struct dhara_journal *j, dhara_error_t *err)
{
	const dhara_block_t next = next_block(j->nand,
		j->head >> j->nand->log2_ppb);

	/* We can't roll onto the same block as the tail */
	if ((j->tail_sync >> j->nand->log2_ppb) == next) {
		dhara_set_error(err, DHARA_E_JOURNAL_FULL);
		return -1;
	}

	j->head = next << j->nand->log2_ppb;
	if (!j->head)
		roll_stats(j);

	return 0;
}

// Assembly:
movq (%rdi), %r8
movl 0x24(%rdi), %edx
movzbl 0x1(%r8), %ecx
shrl %cl, %edx
incl %edx
xorl %eax, %eax
cmpl 0x4(%r8), %edx
cmovael %eax, %edx
movl 0x1c(%rdi), %r8d
shrl %cl, %r8d
cmpl %edx, %r8d
jne 0x28dd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x28e6
movl $0x5, (%rsi)
retq
shll %cl, %edx
movl %edx, 0x24(%rdi)
testl %edx, %edx
je 0x28e7
retq
movl 0x14(%rdi), %ecx
movl %ecx, 0x18(%rdi)
movl $0x0, 0x14(%rdi)
incb 0x11(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/dhara/journal.c
// Function: dump_meta
static int dump_meta(struct dhara_journal *j, dhara_error_t *err)
{
	int i;

	/* We've just begun recovery on a new erasable block, but we
	 * have buffered metadata from the failed block.
	 */
	for (i = 0; i < DHARA_MAX_RETRIES; i++) {
		dhara_error_t my_err;

		/* Try to dump metadata on this page */
		if (!(prepare_head(j, &my_err) ||
		      dhara_nand_prog(j->nand, j->head,
				      j->page_buf, &my_err))) {
			j->recover_meta = j->head;
			j->head = next_upage(j, j->head);
			if (!j->head)
				roll_stats(j);
			hdr_clear_user(j->page_buf, j->nand->log2_page_size);
			return 0;
		}

		/* Report fatal errors */
		if (my_err != DHARA_E_BAD_BLOCK) {
			dhara_set_error(err, my_err);
			return -1;
		}

		j->bb_current++;
		dhara_nand_mark_bad(j->nand, j->head >> j->nand->log2_ppb);

		if (skip_block(j, err) < 0)
			return -1;
	}

	dhara_set_error(err, DHARA_E_TOO_BAD);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x8, %r12d
leaq 0xc(%rsp), %r15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23ca
testl %eax, %eax
jne 0x293f
movl 0x24(%rbx), %esi
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r15, %rcx
callq 0x32ba
testl %eax, %eax
je 0x2994
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0x2985
incl 0x14(%rbx)
movq (%rbx), %rdi
movl 0x24(%rbx), %esi
movb 0x1(%rdi), %cl
shrl %cl, %esi
callq 0x31cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28a8
testl %eax, %eax
js 0x2a03
decl %r12d
jne 0x291a
testq %r14, %r14
je 0x2a03
movl $0x3, (%r14)
jmp 0x2a03
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x2a03
movl %eax, (%r14)
jmp 0x2a03
movl 0x24(%rbx), %esi
movl %esi, 0x34(%rbx)
movq (%rbx), %rdx
movb 0x10(%rbx), %cl
movb 0x1(%rdx), %al
movl 0x4(%rdx), %edi
leal 0x1(%rsi), %r8d
addl $0x2, %esi
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
shll %cl, %r9d
notl %r9d
testl %r9d, %esi
cmovnel %r8d, %esi
movl %eax, %ecx
shll %cl, %edi
xorl %ebp, %ebp
cmpl %edi, %esi
cmovael %ebp, %esi
movl %esi, 0x24(%rbx)
testl %esi, %esi
jne 0x29e2
movl 0x14(%rbx), %eax
movl %eax, 0x18(%rbx)
movl $0x0, 0x14(%rbx)
incb 0x11(%rbx)
movb (%rdx), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x8(%rbx), %rdi
addq $0x14, %rdi
addl $-0x14, %eax
movslq %eax, %rdx
movl $0xff, %esi
callq 0x1090
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/map.c
// Function: main
int main(void)
{
	for (int i = 0; i < 1000; i++) {
		printf("--------------------------------"
		       "--------------------------------\n");
		printf("Seed: %d\n", i);
		srandom(i);
		test();
	}

	sim_dump();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x1859(%rip), %rbx      # 0x42a0
leaq 0x168c(%rip), %r14      # 0x40da
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1060
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1070
movl %ebp, %edi
callq 0x1050
callq 0x2a86
incl %ebp
cmpl $0x3e8, %ebp            # imm = 0x3E8
jne 0x2a50
callq 0x35de
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/map.c
// Function: shuffle
static void shuffle(int seed)
{
	int i;

	srandom(seed);
	for (i = 0; i < NUM_SECTORS; i++)
		sector_list[i] = i;

	for (i = NUM_SECTORS - 1; i > 0; i--) {
		const int j = random() % i;
		const int tmp = sector_list[i];

		sector_list[i] = sector_list[j];
		sector_list[j] = tmp;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1050
leaq 0x425e(%rip), %rax      # 0x7090
xorl %ecx, %ecx
movl %ecx, (%rax)
incq %rcx
addq $0x4, %rax
cmpq $0xc8, %rcx
jne 0x2e34
movl $0xc7, %r14d
leaq 0x423d(%rip), %rbx      # 0x7090
callq 0x10d0
cqto
idivq %r14
movl (%rbx,%r14,4), %eax
movl (%rbx,%rdx,4), %ecx
movl %ecx, (%rbx,%r14,4)
movl %eax, (%rbx,%rdx,4)
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x2e53
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/map.c
// Function: mt_write
static void mt_write(struct dhara_map *m, dhara_sector_t s, int seed)
{
	const size_t page_size = 1 << m->journal.nand->log2_page_size;
	uint8_t buf[page_size];
	dhara_error_t err;

	seq_gen(seed, buf, sizeof(buf));
	if (dhara_map_write(m, s, buf, &err) < 0)
		dabort("map_write", err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
movq %rdi, %rbx
movq (%rdi), %rcx
movb (%rcx), %cl
movl $0x1, %edx
shll %cl, %edx
movl %esi, %r14d
movslq %edx, %rdx
leaq 0xf(%rdx), %rcx
andq $-0x10, %rcx
movq %rsp, %r15
subq %rcx, %r15
movq %r15, %rsp
movl %eax, %edi
movq %r15, %rsi
callq 0x3780
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x1527
testl %eax, %eax
jns 0x2ee1
movl -0x1c(%rbp), %esi
leaq 0x123d(%rip), %rdi      # 0x4119
callq 0x3815
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/map.c
// Function: mt_check
static void mt_check(struct dhara_map *m)
{
	int count;

	sim_freeze();
	count = check_recurse(m, m->journal.head,
		dhara_journal_root(&m->journal), 0, 0);
	sim_thaw();

	assert(m->count == count);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x35d0
movl 0x24(%rbx), %esi
movl 0x28(%rbx), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2f9f
movl %eax, %ebp
callq 0x35d7
cmpl %ebp, 0x3c(%rbx)
jne 0x2f1d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x11ff(%rip), %rdi      # 0x4123
leaq 0x120a(%rip), %rsi      # 0x4135
leaq 0x120f(%rip), %rcx      # 0x4141
movl $0x68, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/map.c
// Function: mt_assert
static void mt_assert(struct dhara_map *m, dhara_sector_t s, int seed)
{
	const size_t page_size = 1 << m->journal.nand->log2_page_size;
	uint8_t buf[page_size];
	dhara_error_t err;

	if (dhara_map_read(m, s, buf, &err) < 0)
		dabort("map_read", err);

	seq_assert(seed, buf, sizeof(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq (%rdi), %rax
movb (%rax), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %r14
leaq 0xf(%r14), %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
leaq -0x1c(%rbp), %rcx
movq %r15, %rdx
callq 0x149f
testl %eax, %eax
jns 0x2f87
movl -0x1c(%rbp), %esi
leaq 0x12b4(%rip), %rdi      # 0x4236
callq 0x3815
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37af
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: sim_reset
void sim_reset(void)
{
	int i;

	memset(&stats, 0, sizeof(stats));
	memset(blocks, 0, sizeof(blocks));
	memset(pages, 0x55, sizeof(pages));

	for (i = 0; i < NUM_BLOCKS; i++)
		blocks[i].next_page = PAGES_PER_BLOCK;
}

// Assembly:
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x427d(%rip)     # 0x73c0
movups %xmm0, 0x4266(%rip)     # 0x73b0
movq $0x0, 0x427b(%rip) # 0x73d0
leaq 0x4284(%rip), %rbx      # 0x73e0
movl $0x54c, %edx            # imm = 0x54C
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
leaq 0x47be(%rip), %rdi      # 0x7930
movl $0x71000, %edx          # imm = 0x71000
movl $0x55, %esi
callq 0x1090
movl $0x4, %eax
movl $0x8, (%rax,%rbx)
addq $0xc, %rax
cmpq $0x550, %rax            # imm = 0x550
jne 0x3186
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_is_bad
int dhara_nand_is_bad(const struct dhara_nand *n, dhara_block_t bno)
{
	if (bno >= NUM_BLOCKS) {
		fprintf(stderr, "sim: NAND_is_bad called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if (!stats.frozen)
		stats.is_bad++;
	return blocks[bno].flags & BLOCK_BAD_MARK;
}

// Assembly:
cmpl $0x71, %esi
jae 0x31c3
cmpl $0x0, 0x4209(%rip)      # 0x73b0
jne 0x31af
incl 0x4205(%rip)            # 0x73b4
movl %esi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x4224(%rip), %rcx      # 0x73e0
movl (%rcx,%rax,4), %eax
andl $0x1, %eax
retq
pushq %rax
movl %esi, %edi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_mark_bad
void dhara_nand_mark_bad(const struct dhara_nand *n, dhara_block_t bno)
{
	if (bno >= NUM_BLOCKS) {
		fprintf(stderr, "sim: NAND_mark_bad called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if (!stats.frozen)
		stats.mark_bad++;
	blocks[bno].flags |= BLOCK_BAD_MARK;
}

// Assembly:
cmpl $0x71, %esi
jae 0x31f1
cmpl $0x0, 0x41d9(%rip)      # 0x73b0
jne 0x31df
incl 0x41d9(%rip)            # 0x73b8
movl %esi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x41f4(%rip), %rcx      # 0x73e0
orb $0x1, (%rcx,%rax,4)
retq
pushq %rax
movl %esi, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_erase
int dhara_nand_erase(const struct dhara_nand *n, dhara_block_t bno,
		     dhara_error_t *err)
{
	uint8_t *blk = pages + (bno << LOG2_BLOCK_SIZE);

	if (bno >= NUM_BLOCKS) {
		fprintf(stderr, "sim: NAND_erase called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if (blocks[bno].flags & BLOCK_BAD_MARK) {
		fprintf(stderr, "sim: NAND_erase called on "
			"block which is marked bad: %d\n", bno);
		abort();
	}

	if (!stats.frozen)
		stats.erase++;
	blocks[bno].next_page = 0;

	timebomb_tick(bno);

	if (blocks[bno].flags & BLOCK_FAILED) {
		if (!stats.frozen)
			stats.erase_fail++;
		seq_gen(bno * 57 + 29, blk, BLOCK_SIZE);
		dhara_set_error(err, DHARA_E_BAD_BLOCK);
		return -1;
	}

	memset(blk, 0xff, BLOCK_SIZE);
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x71, %esi
jae 0x32ac
movq %rdx, %rbx
movl %esi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x41cd(%rip), %rdx      # 0x73e0
movl (%rdx,%rax,4), %ecx
testb $0x1, %cl
jne 0x32b3
movl %esi, %edi
shll $0xc, %edi
leaq (%rdx,%rax,4), %r8
movl 0x4182(%rip), %edx      # 0x73b0
testl %edx, %edx
jne 0x3238
incl 0x4184(%rip)            # 0x73bc
leaq 0x46f1(%rip), %rax      # 0x7930
movl $0x0, 0x4(%r8)
movl 0x8(%r8), %r9d
testl %r9d, %r9d
je 0x325f
decl %r9d
movl %r9d, 0x8(%r8)
jne 0x325f
orl $0x2, %ecx
movl %ecx, (%r8)
addq %rdi, %rax
testb $0x2, %cl
jne 0x327d
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rdi
movl $0xff, %esi
callq 0x1090
xorl %eax, %eax
jmp 0x32aa
testl %edx, %edx
jne 0x3287
incl 0x4139(%rip)            # 0x73c0
imull $0x39, %esi, %edi
addl $0x1d, %edi
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rsi
callq 0x3780
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x32aa
movl $0x1, (%rbx)
popq %rbx
retq
movl %esi, %edi
callq 0x1150
movl %esi, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_prog
int dhara_nand_prog(const struct dhara_nand *n, dhara_page_t p,
		    const uint8_t *data, dhara_error_t *err)
{
	const int bno = p >> LOG2_PAGES_PER_BLOCK;
	const int pno = p & ((1 << LOG2_PAGES_PER_BLOCK) - 1);
	uint8_t *page = pages + (p << LOG2_PAGE_SIZE);

	if ((bno < 0) || (bno >= NUM_BLOCKS)) {
		fprintf(stderr, "sim: NAND_prog called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if (blocks[bno].flags & BLOCK_BAD_MARK) {
		fprintf(stderr, "sim: NAND_prog called on "
			"block which is marked bad: %d\n", bno);
		abort();
	}

	if (pno < blocks[bno].next_page) {
		fprintf(stderr, "sim: NAND_prog: out-of-order "
			"page programming. Block %d, page %d "
			"(expected %d)\n",
			bno, pno, blocks[bno].next_page);
		abort();
	}

	if (!stats.frozen)
		stats.prog++;
	blocks[bno].next_page = pno + 1;

	timebomb_tick(bno);

	if (blocks[bno].flags & BLOCK_FAILED) {
		if (!stats.frozen)
			stats.prog_fail++;
		seq_gen(p * 57 + 29, page, PAGE_SIZE);
		dhara_set_error(err, DHARA_E_BAD_BLOCK);
		return -1;
	}

	memcpy(page, data, PAGE_SIZE);
	return 0;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movl %esi, %edx
shrl $0x3, %edx
cmpl $0x388, %esi            # imm = 0x388
jae 0x3389
movq %rcx, %rbx
movl %edx, %ecx
leaq (%rcx,%rcx,2), %r8
leaq 0x4101(%rip), %r9       # 0x73e0
movl (%r9,%r8,4), %edi
testb $0x1, %dil
jne 0x3390
movl %esi, %ecx
andl $0x7, %ecx
leaq (%r9,%r8,4), %r10
movl 0x4(%r10), %r8d
cmpl %r8d, %ecx
jl 0x3397
movl %esi, %r9d
shll $0x9, %r9d
movl 0x40a0(%rip), %edx      # 0x73b0
testl %edx, %edx
jne 0x331a
incl 0x40ae(%rip)            # 0x73c8
leaq 0x460f(%rip), %r8       # 0x7930
incl %ecx
movl %ecx, 0x4(%r10)
movl 0x8(%r10), %ecx
testl %ecx, %ecx
je 0x333d
decl %ecx
movl %ecx, 0x8(%r10)
jne 0x333d
orl $0x2, %edi
movl %edi, (%r10)
addq %r9, %r8
testb $0x2, %dil
jne 0x335a
movl $0x200, %edx            # imm = 0x200
movq %r8, %rdi
movq %rax, %rsi
callq 0x10c0
xorl %eax, %eax
jmp 0x3387
testl %edx, %edx
jne 0x3364
incl 0x4068(%rip)            # 0x73cc
imull $0x39, %esi, %edi
addl $0x1d, %edi
movl $0x200, %edx            # imm = 0x200
movq %r8, %rsi
callq 0x3780
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x3387
movl $0x1, (%rbx)
popq %rbx
retq
movl %edx, %edi
callq 0x1190
movl %edx, %edi
callq 0x1170
movq 0x3c5a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x10cc(%rip), %rsi      # 0x4474
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_is_free
int dhara_nand_is_free(const struct dhara_nand *n, dhara_page_t p)
{
	const int bno = p >> LOG2_PAGES_PER_BLOCK;
	const int pno = p & ((1 << LOG2_PAGES_PER_BLOCK) - 1);

	if ((bno < 0) || (bno >= NUM_BLOCKS)) {
		fprintf(stderr, "sim: NAND_is_free called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if (!stats.frozen)
		stats.is_erased++;
	return blocks[bno].next_page <= pno;
}

// Assembly:
movl %esi, %edi
shrl $0x3, %edi
cmpl $0x388, %esi            # imm = 0x388
jae 0x33ea
cmpl $0x0, 0x3fe8(%rip)      # 0x73b0
jne 0x33d0
incl 0x3ff4(%rip)            # 0x73c4
andl $0x7, %esi
movl %edi, %eax
leaq (%rax,%rax,2), %rcx
leaq 0x4000(%rip), %rdx      # 0x73e0
xorl %eax, %eax
cmpl %esi, 0x4(%rdx,%rcx,4)
setle %al
retq
pushq %rax
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: dhara_nand_read
int dhara_nand_read(const struct dhara_nand *n, dhara_page_t p,
		    size_t offset, size_t length,
		    uint8_t *data, dhara_error_t *err)
{
	const int bno = p >> LOG2_PAGES_PER_BLOCK;
	uint8_t *page = pages + (p << LOG2_PAGE_SIZE);

	if ((bno < 0) || (bno >= NUM_BLOCKS)) {
		fprintf(stderr, "sim: NAND_read called on "
			"invalid block: %d\n", bno);
		abort();
	}

	if ((offset > PAGE_SIZE) || (length > PAGE_SIZE) ||
	    (offset + length > PAGE_SIZE)) {
		fprintf(stderr, "sim: NAND_read called on "
			"invalid range: offset = %ld, length = %ld\n",
			offset, length);
		abort();
	}

	if (!stats.frozen) {
		stats.read++;
		stats.read_bytes += length;
	}

	memcpy(data, page + offset, length);
	return 0;
}

// Assembly:
pushq %rax
cmpl $0x388, %esi            # imm = 0x388
jae 0x344e
cmpq $0x200, %rdx            # imm = 0x200
ja 0x3455
cmpq $0x200, %rcx            # imm = 0x200
ja 0x3455
leaq (%rcx,%rdx), %rax
cmpq $0x201, %rax            # imm = 0x201
jae 0x3455
cmpl $0x0, 0x3f92(%rip)      # 0x73b0
jne 0x342c
incl 0x3faa(%rip)            # 0x73d0
addl %ecx, 0x3fa8(%rip)      # 0x73d4
shll $0x9, %esi
leaq 0x44fa(%rip), %rax      # 0x7930
addq %rsi, %rax
addq %rdx, %rax
movq %r8, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x10c0
xorl %eax, %eax
popq %rcx
retq
movl %esi, %edi
callq 0x11d0
movq 0x3b9c(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x10b9(%rip), %rsi      # 0x451f
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: sim_inject_bad
void sim_inject_bad(int count)
{
	int i;

	for (i = 0; i < count; i++) {
		const int bno = random() % NUM_BLOCKS;

		blocks[bno].flags |= BLOCK_BAD_MARK | BLOCK_FAILED;
	}
}

// Assembly:
testl %edi, %edi
jle 0x351f
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movabsq $0x487ede0487ede049, %r14 # imm = 0x487EDE0487EDE049
leaq 0x3ef3(%rip), %r15      # 0x73e0
callq 0x10d0
movq %rax, %rcx
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x5, %rdx
addq %rax, %rdx
imulq $0x71, %rdx, %rax
subq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
orb $0x3, (%r15,%rax,4)
decl %ebx
jne 0x34ed
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: sim_inject_timebombs
void sim_inject_timebombs(int count, int max_ttl)
{
	int i;

	for (i = 0; i < count; i++)
		sim_set_timebomb(random() % NUM_BLOCKS,
				 random() % max_ttl + 1);
}

// Assembly:
testl %edi, %edi
jle 0x35cf
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
movslq %esi, %r15
movabsq $0x487ede0487ede049, %r12 # imm = 0x487EDE0487EDE049
leaq 0x3e51(%rip), %r13      # 0x73e0
callq 0x10d0
movq %rax, %r14
imulq %r12
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x5, %rdx
addl %eax, %edx
imull $0x71, %edx, %eax
subl %eax, %r14d
callq 0x10d0
cqto
idivq %r15
incl %edx
leaq (%r14,%r14,2), %rax
movl %edx, 0x8(%r13,%rax,4)
decl %ebx
jne 0x358f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/sim.c
// Function: sim_dump
void sim_dump(void)
{
	int i;

	printf("NAND operation counts:\n");
	printf("    is_bad:         %d\n", stats.is_bad);
	printf("    mark_bad        %d\n", stats.mark_bad);
	printf("    erase:          %d\n", stats.erase);
	printf("    erase failures: %d\n", stats.erase_fail);
	printf("    is_erased:      %d\n", stats.is_erased);
	printf("    prog:           %d\n", stats.prog);
	printf("    prog failures:  %d\n", stats.prog_fail);
	printf("    read:           %d\n", stats.read);
	printf("    read (bytes):   %d\n", stats.read_bytes);
	printf("\n");

	printf("Block status:\n");
	i = 0;
	while (i < NUM_BLOCKS) {
		int j = NUM_BLOCKS - i;
		int k;

		if (j > 64)
			j = 64;

		printf("    ");
		for (k = 0; k < j; k++)
			fputc(rep_status(&blocks[i + k]), stdout);
		fputc('\n', stdout);

		i += j;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1050(%rip), %rdi      # 0x4640
callq 0x1060
movl 0x3db9(%rip), %esi      # 0x73b4
leaq 0xf61(%rip), %rdi       # 0x4563
xorl %eax, %eax
callq 0x1070
movl 0x3da9(%rip), %esi      # 0x73b8
leaq 0xf65(%rip), %rdi       # 0x457b
xorl %eax, %eax
callq 0x1070
movl 0x3d99(%rip), %esi      # 0x73bc
leaq 0xf69(%rip), %rdi       # 0x4593
xorl %eax, %eax
callq 0x1070
movl 0x3d89(%rip), %esi      # 0x73c0
leaq 0xf6d(%rip), %rdi       # 0x45ab
xorl %eax, %eax
callq 0x1070
movl 0x3d79(%rip), %esi      # 0x73c4
leaq 0xf71(%rip), %rdi       # 0x45c3
xorl %eax, %eax
callq 0x1070
movl 0x3d69(%rip), %esi      # 0x73c8
leaq 0xf75(%rip), %rdi       # 0x45db
xorl %eax, %eax
callq 0x1070
movl 0x3d59(%rip), %esi      # 0x73cc
leaq 0xf79(%rip), %rdi       # 0x45f3
xorl %eax, %eax
callq 0x1070
movl 0x3d49(%rip), %esi      # 0x73d0
leaq 0xf7d(%rip), %rdi       # 0x460b
xorl %eax, %eax
callq 0x1070
movl 0x3d39(%rip), %esi      # 0x73d4
leaq 0xf81(%rip), %rdi       # 0x4623
xorl %eax, %eax
callq 0x1070
movl $0xa, %edi
callq 0x1030
leaq 0xf9d(%rip), %rdi       # 0x4657
callq 0x1060
leaq 0xc6e(%rip), %r15       # 0x4334
movq 0x390b(%rip), %r13      # 0x6fd8
xorl %ebp, %ebp
movl $0x71, %r12d
subl %ebp, %r12d
cmpl $0x40, %r12d
movl $0x40, %eax
cmovael %eax, %r12d
leaq 0xf4f(%rip), %rdi       # 0x463b
xorl %eax, %eax
callq 0x1070
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
leaq 0x3ce0(%rip), %rcx      # 0x73e0
leaq (%rcx,%rax,4), %rbx
addq $0x4, %rbx
movq %r12, %r14
movl -0x4(%rbx), %eax
andl $0x3, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
cmpl $0x0, (%rbx)
movl $0x3a, %edi
movl $0x2e, %eax
cmovel %eax, %edi
jmp 0x373f
movl $0x62, %edi
jmp 0x373f
movl $0x42, %edi
jmp 0x373f
movl $0x3f, %edi
movq (%r13), %rsi
callq 0x10a0
addq $0xc, %rbx
decq %r14
jne 0x370b
movq (%r13), %rsi
movl $0xa, %edi
callq 0x10a0
addl %ebp, %r12d
movl %r12d, %ebp
cmpl $0x71, %r12d
jb 0x36cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/util.c
// Function: seq_gen
void seq_gen(unsigned int seed, uint8_t *buf, size_t length)
{
	size_t i;

	srandom(seed);
	for (i = 0; i < length; i++)
		buf[i] = random();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x1050
testq %rbx, %rbx
je 0x37a9
xorl %r15d, %r15d
callq 0x10d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x3798
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/util.c
// Function: seq_assert
void seq_assert(unsigned int seed, const uint8_t *buf, size_t length)
{
	size_t i;

	srandom(seed);
	for (i = 0; i < length; i++) {
		const uint8_t expect = random();

		if (buf[i] != expect) {
			fprintf(stderr, "seq_assert: mismatch at %ld in "
				"sequence %d: 0x%02x (expected 0x%02x)\n",
				i, seed, buf[i], expect);
			abort();
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
callq 0x1050
testq %r14, %r14
je 0x37e7
xorl %r12d, %r12d
callq 0x10d0
movzbl (%r15,%r12), %r8d
movzbl %al, %r9d
cmpl %r8d, %r9d
jne 0x37f3
incq %r12
cmpq %r12, %r14
jne 0x37cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x37fe(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0xe61(%rip), %rsi       # 0x4665
movq %r12, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/PARKINHYO[P]BlackjackGame/shm/./common.h
// Function: calc_sum
int calc_sum(const int hand_values[], int ncards)
{
	int i;
	int sum = 0;

	for (i = 0; i < ncards; ++i)
		if (hand_values[i] < 10)
			sum += hand_values[i];
		else
			sum += 10;

	for (i = 0; i < ncards; ++i)
		if (hand_values[i] == 1)
			if (sum + 10 <= 21)
				sum += 10;

	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x1498
movl %esi, %ecx
xorl %eax, %eax
movl $0xa, %r8d
xorl %edx, %edx
movl (%rdi,%rax,4), %r9d
cmpl $0xa, %r9d
cmovgel %r8d, %r9d
addl %r9d, %edx
incq %rax
cmpq %rax, %rcx
jne 0x145f
testl %esi, %esi
jle 0x149c
xorl %esi, %esi
leal 0xa(%rdx), %eax
cmpl $0xc, %edx
cmovgel %edx, %eax
cmpl $0x1, (%rdi,%rsi,4)
cmovnel %edx, %eax
incq %rsi
movl %eax, %edx
cmpq %rsi, %rcx
jne 0x147c
jmp 0x149e
xorl %eax, %eax
jmp 0x149e
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PARKINHYO[P]BlackjackGame/shm/shm_server.c
// Function: init_cards
void init_cards()
{
	int i;

	for (i = 0; i < 52; ++i)
	{
		card_values[i] = (i % 13) + 1;
		card_suits[i] = i / 13;
	}

	srand(time(NULL));
	/* srand(1); */
	for (i = 0; i < 52; ++i)
	{
		int cv, cs;
		int j = rand() % 52;

		cv = card_values[i];
		card_values[i] = card_values[j];
		card_values[j] = cv;

		cs = card_suits[i];
		card_suits[i] = card_suits[j];
		card_suits[j] = cs;
	}

	ncard = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %al
xorl %ecx, %ecx
leaq 0x3bd5(%rip), %rbx      # 0x51b0
leaq 0x3c9e(%rip), %r14      # 0x5280
xorl %edx, %edx
movzbl %dl, %esi
imull $0x4f, %esi, %esi
shrl $0xa, %esi
leal (%rsi,%rsi,2), %edi
leal (%rsi,%rdi,4), %edi
movl %eax, %r8d
subb %dil, %r8b
movzbl %r8b, %edi
movl %edi, (%rcx,%rbx)
movl %esi, (%rcx,%r14)
incq %rdx
incb %al
addq $0x4, %rcx
cmpq $0x34, %rdx
jne 0x15e4
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10b0
callq 0x11c0
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x24, %rcx
addl %edx, %ecx
imull $0x34, %ecx, %ecx
subl %ecx, %eax
movl (%r15,%rbx), %ecx
cltq
movl (%rbx,%rax,4), %edx
movl %edx, (%r15,%rbx)
movl %ecx, (%rbx,%rax,4)
movl (%r15,%r14), %ecx
movl (%r14,%rax,4), %edx
movl %edx, (%r15,%r14)
movl %ecx, (%r14,%rax,4)
addq $0x4, %r15
cmpq $0xd0, %r15
jne 0x1624
movl $0x0, 0x3cd5(%rip)      # 0x5350
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/pipe1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd[2];

	assert(pipe(fd) == 0);

	while (1) {
		char c = 0;
		int ret;

		do {
			ret = write(fd[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);

		do {
			ret = read(fd[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);

		(*iterations)++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2140
testl %eax, %eax
jne 0x2cdb
leaq 0xf(%rsp), %r14
movb $0x0, 0xf(%rsp)
movl 0x14(%rsp), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x20d0
cmpl $0x1, %eax
je 0x2cb6
callq 0x2070
cmpl $0x4, (%rax)
je 0x2c96
movl 0x10(%rsp), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x2150
cmpl $0x1, %eax
je 0x2cd6
callq 0x2070
cmpl $0x4, (%rax)
je 0x2cb6
incq (%rbx)
jmp 0x2c91
leaq 0x5c6(%rip), %rdi       # 0x32a8
leaq 0x5cd(%rip), %rsi       # 0x32b6
leaq 0x5d4(%rip), %rcx       # 0x32c4
movl $0xf, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/asn1.c
// Function: asn1_pub
void			asn1_pub(t_rsa gg, uint8_t *buf, uint8_t *buf2, int *len)
{
	uint8_t		copy[PAGESIZE];
	int			index;

	dump_to_buf(buf, INT, NULL, len);
	dump_to_buf(buf, byte_string(buf2, gg.n)[0] == 0xFF ?
	byte_len(gg.n) + 1 : byte_len(gg.n), NULL, len);
	dump_to_buf(buf, 0, byte_string(buf2, gg.n), len);
	dump_to_buf(buf, INT, NULL, len);
	dump_to_buf(buf, byte_len(gg.e), NULL, len);
	dump_to_buf(buf, 0, byte_string(buf2, gg.e), len);
	ft_memcpy(copy, buf, *len);
	ft_bzero(buf, PAGESIZE);
	index = 2;
	dump_to_buf(buf, SEQUENCE, NULL, &index);
	dump_to_buf(buf, 0, (uint8_t*)PKCS_1, &index);
	dump_to_buf(buf, BIT, NULL, &index);
	dump_to_buf(buf, (char)(*len) + 3, NULL, &index);
	dump_to_buf(buf, V1, NULL, &index);
	dump_to_buf(buf, SEQUENCE, NULL, &index);
	dump_to_buf(buf, (char)(*len), NULL, &index);
	ft_memcpy(&buf[index], copy, *len);
	*len += index;
	buf[0] = SEQUENCE;
	buf[1] = (uint8_t)*len - 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1822
movq 0x1050(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
cmpb $-0x1, (%rax)
sete %bpl
movq %r12, %rdi
callq 0x1780
addb %bpl, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1822
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1822
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1822
movq 0x1078(%rsp), %r12
movq %r12, %rdi
callq 0x1780
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1822
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1822
movslq (%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x73ac
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x7370
leaq 0xc(%rsp), %r12
movl $0x2, (%r12)
movq %rbx, %rdi
movl $0x30, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
leaq 0xa924(%rip), %rdx      # 0xc004
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x1822
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
movb (%r14), %al
addb $0x3, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
movq %rbx, %rdi
movl $0x30, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
movsbl (%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1822
movslq (%r12), %rdi
addq %rbx, %rdi
movslq (%r14), %rdx
movq %r15, %rsi
callq 0x73ac
movl (%r12), %eax
addl %eax, (%r14)
movb $0x30, (%rbx)
movb (%r14), %al
addb $-0x2, %al
movb %al, 0x1(%rbx)
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/asn1_helper.c
// Function: byte_string
uint8_t		*byte_string(uint8_t *buf, __uint64_t n)
{
	int		i;
	int		p;
	int		trig;

	i = -1;
	p = 0;
	trig = 0;
	ft_bzero(buf, 10);
	while (++i < 8)
	{
		if (trig || (n & (0xFFULL << 8 * (7 - i))) >> 8 * (7 - i))
		{
			buf[p] = (n & (0xFFULL << 8 * (7 - i))) >> 8 * (7 - i);
			DEBUG ? ft_printf("[%02x]", buf[p]) : 0;
			if (!trig && (buf[p] & 0x80))
			{
				buf[p + 1] = buf[p];
				buf[p++] = 0xFF;
			}
			p++;
			trig = 1;
		}
	}
	DEBUG ? ft_printf(" [%llu]\n", n) : 0;
	return (buf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa, %esi
callq 0x7370
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
shll $0x3, %edx
movb $0x30, %cl
subb %dl, %cl
movl $0xff, %r8d
shlq %cl, %r8
movq %rdi, %rdx
andq %r14, %r8
shrq %cl, %r8
testl %esi, %esi
je 0x17f3
movslq %eax, %rcx
movb %r8b, (%rbx,%rcx)
incl %eax
movl $0x1, %esi
leaq 0x1(%rdx), %rdi
cmpq $0x8, %rdi
jne 0x17bc
jmp 0x1817
testq %r8, %r8
je 0x1813
movslq %eax, %rcx
movb %r8b, (%rbx,%rcx)
testb %r8b, %r8b
jns 0x17e0
leaq 0x1(%rcx), %rax
movb %r8b, 0x1(%rbx,%rcx)
movb $-0x1, (%rbx,%rcx)
jmp 0x17e0
xorl %esi, %esi
jmp 0x17e7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/asn1_helper.c
// Function: dump_to_buf
void		dump_to_buf(uint8_t *buf, char c, uint8_t *s, int *len)
{
	int		i;
	int		n;

	if (!s)
	{
		buf[*len] = c;
		++(*len);
	}
	else
	{
		i = 0;
		n = ft_strlen((char*)s);
		if (n == 1 && s[2] == '\x01')
			n = 3;
		DEBUG ? ft_printf("len:[%d] ", n) : 0;
		while (i < n || s[n])
		{
			DEBUG ? ft_printf("{%d}", i) : 0;
			buf[*len] = s[i];
			++(*len);
			++i;
		}
		DEBUG ? ft_printf(" ---\n") : 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1876
movq %rdx, %r15
movq %rdx, %rdi
callq 0x8082
cmpl $0x1, %eax
jne 0x1854
xorl %eax, %eax
cmpb $0x1, 0x2(%r15)
sete %al
leaq 0x1(,%rax,2), %rax
cltq
xorl %ecx, %ecx
cmpq %rax, %rcx
jl 0x1864
cmpb $0x0, (%r15,%rax)
je 0x187f
movb (%r15,%rcx), %dl
movslq (%rbx), %rsi
movb %dl, (%r14,%rsi)
incl (%rbx)
incq %rcx
jmp 0x1858
movslq (%rbx), %rax
movb %sil, (%r14,%rax)
incl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/encode/base64.c
// Function: base64_decode
int				base64_decode(uint8_t *enc, uint8_t *dec, int len)
{
	int		i;

	i = 0;
	while (i < len)
	{
		if ((i + 4) % 64 == 0)
		{
			if (len != 65)
				i++;
			if (i == len)
				return (i - 1);
		}
		dec[3 * (i / 4)] |= (g_base64_decode[enc[i]]) << 2;
		dec[3 * (i / 4)] |= ((g_base64_decode[enc[i + 1]] & 0x30) >> 4);
		dec[3 * (i / 4) + 1] |= ((g_base64_decode[enc[i + 1]] & 0x0F) << 4);
		dec[3 * (i / 4) + 1] |= (g_base64_decode[enc[i + 2]] >> 2);
		dec[3 * (i / 4) + 2] |= (g_base64_decode[enc[i + 2]] << 6);
		dec[3 * (i / 4) + 2] |= g_base64_decode[enc[i + 3]];
		i += 4;
	}
	return (i);
}

// Assembly:
testl %edx, %edx
jle 0x1b45
pushq %rbx
xorl %ecx, %ecx
cmpl $0x41, %edx
setne %cl
xorl %r9d, %r9d
leaq 0x10659(%rip), %r8      # 0x120e0
leal 0x4(%r9), %eax
testb $0x3f, %al
jne 0x1a9f
addl %ecx, %r9d
cmpl %edx, %r9d
je 0x1b48
leal 0x4(%r9), %eax
movslq %r9d, %r9
movzbl (%rdi,%r9), %r10d
movb (%r10,%r8), %r11b
shlb $0x2, %r11b
leal 0x3(%r9), %r10d
testl %r9d, %r9d
cmovnsl %r9d, %r10d
sarl $0x2, %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orb (%rsi,%r10), %r11b
movb %r11b, (%rsi,%r10)
movzbl 0x1(%rdi,%r9), %ebx
movb (%rbx,%r8), %bl
shrb $0x4, %bl
andb $0x3, %bl
orb %r11b, %bl
movb %bl, (%rsi,%r10)
movzbl 0x1(%rdi,%r9), %r11d
movb (%r11,%r8), %r11b
shlb $0x4, %r11b
orb 0x1(%rsi,%r10), %r11b
movb %r11b, 0x1(%rsi,%r10)
movzbl 0x2(%rdi,%r9), %ebx
movb (%rbx,%r8), %bl
shrb $0x2, %bl
orb %r11b, %bl
movb %bl, 0x1(%rsi,%r10)
movzbl 0x2(%rdi,%r9), %r11d
movb (%r11,%r8), %r11b
shlb $0x6, %r11b
orb 0x2(%rsi,%r10), %r11b
movb %r11b, 0x2(%rsi,%r10)
movzbl 0x3(%rdi,%r9), %r9d
orb (%r9,%r8), %r11b
movb %r11b, 0x2(%rsi,%r10)
movl %eax, %r9d
cmpl %edx, %eax
jl 0x1a87
jmp 0x1b4c
xorl %eax, %eax
retq
decl %edx
movl %edx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/encode/base64.c
// Function: decode_driver
void			decode_driver(t_parse *b64)
{
	uint8_t		buf[66];
	uint8_t		dec[50];
	int			len;

	ft_bzero(buf, 66);
	ft_bzero(dec, 50);
	while ((len = read(b64->fd_in, buf, 65)) == 65)
	{
		buf[ft_strchri((char *)buf, '\n')] = 0;
		base64_decode(buf, dec, len);
		dec[(len / 4) * 3] = 0;
		ft_putstr_fd((char *)dec, b64->fd_out);
		ft_bzero(buf, 65);
		ft_bzero(dec, 49);
	}
	buf[ft_strchri((char *)buf, '\n')] = 0;
	base64_decode(buf, dec, len);
	dec[(int)((float)(len * 2) / 3.0)] = 0;
	ft_putstr_fd((char *)dec, b64->fd_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movl $0x42, %esi
movq %r14, %rdi
callq 0x7370
movq %rsp, %rdi
movl $0x32, %esi
callq 0x7370
movl (%rbx), %edi
movl $0x41, %edx
movq %r14, %rsi
callq 0x10b0
movq %rax, %r12
cmpl $0x41, %r12d
jne 0x1c07
leaq 0x40(%rsp), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq %r14, %rdi
movl $0xa, %esi
callq 0x7d0b
cltq
movb %bpl, 0x40(%rsp,%rax)
movq %r14, %rdi
movq %r15, %rsi
movl $0x41, %edx
callq 0x1a6c
movb %bpl, 0x30(%rsp)
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x7941
movl $0x41, %esi
movq %r14, %rdi
callq 0x7370
movl $0x31, %esi
movq %r15, %rdi
callq 0x7370
movl (%rbx), %edi
movl $0x41, %edx
movq %r14, %rsi
callq 0x10b0
movq %rax, %r12
cmpl $0x41, %r12d
je 0x1ba1
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x7d0b
cltq
xorl %ebp, %ebp
movb %bpl, 0x40(%rsp,%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1a6c
addl %r12d, %r12d
cvtsi2ss %r12d, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0xa3d1(%rip), %xmm0     # 0xc018
cvttsd2si %xmm0, %eax
cltq
movb %bpl, (%rsp,%rax)
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x7941
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_md5
void			ssl_md5(char **av, t_ssl *ssl)
{
	int		i;
	char	*line;

	i = -1;
	line = NULL;
	if (!(ssl->flag & 0x38000) && !ssl->flag && ssl->file_index[0])
		;
	else if (!(ssl->flag & S_FLAG) && (!*(ssl->fd) || ssl->flag & P_FLAG))
	{
		get_stdin(&line, 0, 1, 0);
		line = (!line) ? ft_strdup("") : line;
		ssl->flag &= ~0x40000;
		if (ssl->flag || (ssl->flag && !(ssl->flag & 0x10000)))
			ssl->flag |= 0x8000;
		hash(av[1], line, ssl, 0);
		ft_pipewrench("-s", &line) ? ssl->flag &= ~0x1000 : 0;
	}
	ssl->flag &= ~P_FLAG;
	while (ssl->fd[++i])
	{
		ssl->flag &= ~0x40000;
		hash(av[1], av[ssl->file_index[i]], ssl, i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x1eec
btl $0x12, %eax
jae 0x1efb
movl %eax, %ecx
jmp 0x1f84
xorl %ecx, %ecx
cmpl $0x0, 0x408(%rbx)
jne 0x1f84
testw %ax, %ax
js 0x1f08
cmpl $0x0, 0xc(%rbx)
movl %eax, %ecx
jne 0x1f84
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x6fce
movq (%r15), %rsi
testq %rsi, %rsi
jne 0x1f35
leaq 0xadad(%rip), %rdi      # 0xccda
callq 0x81d4
movq %rax, %rsi
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movl $0xfffbffff, %eax       # imm = 0xFFFBFFFF
andl 0x4(%rbx), %eax
movl %eax, %ecx
orl $0x8000, %ecx           # imm = 0x8000
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x4(%rbx)
movq 0x8(%r14), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2c9a
leaq 0xae3f(%rip), %rdi      # 0xcda9
movq %r15, %rsi
xorl %eax, %eax
callq 0x743c
movl 0x4(%rbx), %edx
movl %edx, %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
testl %eax, %eax
cmovel %edx, %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
movl %ecx, 0x4(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x1fc1
xorl %r15d, %r15d
andb $-0x5, 0x6(%rbx)
movq 0x8(%r14), %rdi
movslq 0x408(%rbx,%r15,4), %rax
movq (%r14,%rax,8), %rsi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x2c9a
cmpl $0x0, 0x10(%rbx,%r15,4)
leaq 0x1(%r15), %r15
jne 0x1f96
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_b64
void			ssl_b64(char **av, t_ssl *ssl)
{
	t_parse		b64;
	uint8_t		buf[64];
	int			len;
	int			i;

	ft_bzero(&b64, sizeof(b64));
	ft_bzero(buf, 64);
	b64.fd_out = 1;
	if (parse_b64(av, &b64, ssl, 1))
		;
	else
	{
		i = 0;
		if (b64.flag & D_FLAG)
			decode_driver(&b64);
		else
		{
			while ((len = read(b64.fd_in, buf, 63)) == 63)
			{
				base64_nstr_fd(buf, len, b64.fd_out, &i);
				ft_bzero(buf, 64);
			}
			base64_nstr_fd(buf, len, b64.fd_out, &i);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl $0xc, %esi
movq %r15, %rdi
callq 0x7370
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x7370
movl $0x1, 0x4(%r15)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x1c6c
testl %eax, %eax
jne 0x20a2
movl $0x0, (%rsp)
testb $0x8, 0xc(%rsp)
jne 0x2098
movl 0x4(%rsp), %edi
leaq 0x10(%rsp), %rsi
movl $0x3f, %edx
callq 0x10b0
cmpl $0x3f, %eax
jne 0x2083
leaq 0x10(%rsp), %rbx
movq %rsp, %r14
movl 0x8(%rsp), %edx
movq %rbx, %rdi
movl $0x3f, %esi
movq %r14, %rcx
callq 0x1888
movl $0x40, %esi
movq %rbx, %rdi
callq 0x7370
movl 0x4(%rsp), %edi
movl $0x3f, %edx
movq %rbx, %rsi
callq 0x10b0
cmpl $0x3f, %eax
je 0x204c
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rdi
movq %rsp, %rcx
movl %eax, %esi
callq 0x1888
jmp 0x20a2
leaq 0x4(%rsp), %rdi
callq 0x1b4e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_standard
void			ssl_standard(char **av, t_ssl *ssl)
{
	if (ssl->type == 41 && ft_printf("%s%s", VERSION, COPYRIGHT))
		;
	else if (ssl->type == 42)
		rand_command(av, ssl, 0);
	else if (ssl->type == 43 && opt_desciption(ssl->type))
		;
	(void)av;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
cmpl $0x29, %eax
jne 0x20f3
leaq 0xa560(%rip), %rdi      # 0xc637
leaq 0x9fcc(%rip), %rsi      # 0xc0aa
leaq 0x9ffb(%rip), %rdx      # 0xc0e0
xorl %eax, %eax
callq 0x7698
testl %eax, %eax
jne 0x2111
movl 0x8(%rbx), %eax
cmpl $0x2b, %eax
je 0x2119
cmpl $0x2a, %eax
jne 0x2111
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4489
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x2b, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21bc
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/encode/encode.c
// Function: p_k_s_v
int					p_k_s_v(char **av, int *i, int *j, t_ssl *ssl)
{
	if (av[*i][++(*j)])
	{
		ft_printf("will use '%s' as parameter of function '%c'\n",
		&av[*i][*j], av[*i][(*j) - 1]);
		return (1);
	}
	if (av[++(*i)] && av[*i][0])
	{
		ft_printf("will use '%s' as parameter of function '%c'\n",
		&av[*i][0], av[(*i) - 1][(*j) - 1]);
		return (1);
	}
	ssl->fd[104] = 0;
	return (0);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movslq (%rsi), %rsi
movq (%rdi,%rsi,8), %r8
movslq (%rdx), %r9
leaq 0x1(%r9), %rsi
movl %esi, (%rdx)
cmpb $0x0, 0x1(%r8,%r9)
movslq (%rax), %r8
je 0x216c
movq (%rdi,%r8,8), %rax
addq %rax, %rsi
movsbl (%rax,%r9), %edx
leaq 0x9fb1(%rip), %rdi      # 0xc10f
xorl %eax, %eax
callq 0x7698
movl $0x1, %eax
jmp 0x219b
leaq 0x1(%r8), %rsi
movl %esi, (%rax)
movq 0x8(%rdi,%r8,8), %rsi
testq %rsi, %rsi
je 0x218f
cmpb $0x0, (%rsi)
je 0x218f
movq (%rdi,%r8,8), %rax
movslq (%rdx), %rcx
movsbl -0x1(%rax,%rcx), %edx
jmp 0x2157
movl $0x0, 0x1ac(%rcx)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/error.c
// Function: full_usage
void			full_usage(char *ex, int type)
{
	dprintf(2, "%susage%s: ", YEL, NOCOL);
	if (type < 10)
		dprintf(2, "%s [-pqr] [-s string] [files ...]\n", ex);
	else if (type < 30)
	{
		dprintf(2, "%s [-a | -d | -e] [-p passwd] [-k key] [-s salt] ", ex);
		dprintf(2, "[-v vector] [-in file] [-out file]\n");
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa539(%rip), %rsi      # 0xca13
leaq 0x9d76(%rip), %rdx      # 0xc257
leaq 0x9d77(%rip), %rcx      # 0xc25f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
cmpl $0x9, %ebp
jg 0x2515
leaq 0xa51f(%rip), %rsi      # 0xca1f
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1090
cmpl $0x1d, %ebp
ja 0x2549
leaq 0xa521(%rip), %rsi      # 0xca42
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1090
leaq 0xa53d(%rip), %rsi      # 0xca74
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1090
addq $0x8, %rsp
popq %rbx
popq %rbp
retq