LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rax
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 0x1386
testl %eax, %eax
jns 0x2c35
movl -0x1c(%rbp), %esi
leaq 0x1606(%rip), %rdi      # 0x4236
callq 0x351b
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x34b8
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/map.c
// Function: check_recurse
static int check_recurse(struct dhara_map *m,
			 dhara_page_t parent,
			 dhara_page_t page,
			 dhara_sector_t id_expect,
			 int depth)
{
	uint8_t meta[DHARA_META_SIZE];
	dhara_error_t err;
	const dhara_page_t h_offset = m->journal.head - m->journal.tail;
	const dhara_page_t p_offset = parent - m->journal.tail;
	const dhara_page_t offset = page - m->journal.tail;
	dhara_sector_t id;
	int count = 1;
	int i;

	if (page == DHARA_PAGE_NONE)
		return 0;

	/* Make sure this is a valid journal user page, and one which is
	 * older than the page pointing to it.
	 */
	assert(offset < p_offset);
	assert(offset < h_offset);
	assert((~page) & ((1 << m->journal.log2_ppc) - 1));

	/* Fetch metadata */
	if (dhara_journal_read_meta(&m->journal, page, meta, &err) < 0)
		dabort("mt_check", err);

	/* Check the first <depth> bits of the ID field */
	id = dhara_r32(meta);
	if (!depth) {
		id_expect = id;
	} else {
		assert(!((id ^ id_expect) >> (32 - depth)));
	}

	/* Check all alt-pointers */
	for (i = depth; i < 32; i++) {
		dhara_page_t child = dhara_r32(meta + (i << 2) + 4);

		count += check_recurse(m, page, child,
			id ^ (1 << (31 - i)), i + 1);
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpl $-0x1, %edx
je 0x2d2b
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %r14
movl 0x20(%rdi), %eax
movl %edx, %ecx
subl %eax, %ecx
subl %eax, %esi
cmpl %esi, %ecx
jae 0x2d43
movl 0x24(%r14), %edx
subl %eax, %edx
cmpl %edx, %ecx
jae 0x2d5c
movb 0x10(%r14), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
orl %ebp, %eax
cmpl $-0x1, %eax
je 0x2d75
movl %r8d, %ebx
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1eed
testl %eax, %eax
jns 0x2ccd
movl 0xc(%rsp), %esi
leaq 0x1541(%rip), %rdi      # 0x4209
callq 0x351b
movl 0x10(%rsp), %r12d
testl %ebx, %ebx
je 0x2ce9
xorl %r12d, %r15d
movl %ebx, %ecx
negb %cl
shrl %cl, %r15d
testl %r15d, %r15d
jne 0x2d8e
movslq %ebx, %rcx
shll $0x2, %ebx
pushq $0x1
popq %r15
cmpq $0x1f, %rcx
jg 0x2d2e
movslq %ebx, %rbx
movl 0x14(%rsp,%rbx), %edx
movl $0x80000000, %eax       # imm = 0x80000000
shrl %cl, %eax
xorl %r12d, %eax
movq %rcx, %r13
incq %r13
leal 0x1(%rcx), %r8d
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %ecx
callq 0x2c4d
addl %eax, %r15d
addl $0x4, %ebx
movq %r13, %rcx
jmp 0x2cf3
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1419(%rip), %rdi      # 0x4163
leaq 0x13e4(%rip), %rsi      # 0x4135
leaq 0x141d(%rip), %rcx      # 0x4175
pushq $0x44
jmp 0x2da5
leaq 0x1469(%rip), %rdi      # 0x41cc
leaq 0x13cb(%rip), %rsi      # 0x4135
leaq 0x1404(%rip), %rcx      # 0x4175
pushq $0x45
jmp 0x2da5
leaq 0x1462(%rip), %rdi      # 0x41de
leaq 0x13b2(%rip), %rsi      # 0x4135
leaq 0x13eb(%rip), %rcx      # 0x4175
pushq $0x46
jmp 0x2da5
leaq 0x147d(%rip), %rdi      # 0x4212
leaq 0x1399(%rip), %rsi      # 0x4135
leaq 0x13d2(%rip), %rcx      # 0x4175
pushq $0x51
popq %rdx
callq 0x1080
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0x4609(%rip)     # 0x73c0
movups %xmm0, 0x45f2(%rip)     # 0x73b0
andq $0x0, 0x460a(%rip)      # 0x73d0
leaq 0x4613(%rip), %rbx      # 0x73e0
movl $0x54c, %edx            # imm = 0x54C
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
leaq 0x4b4d(%rip), %rdi      # 0x7930
pushq $0x55
popq %rsi
movl $0x71000, %edx          # imm = 0x71000
callq 0x1090
pushq $0x4
popq %rax
cmpq $0x550, %rax            # imm = 0x550
je 0x2e08
movl $0x8, (%rax,%rbx)
addq $0xc, %rax
jmp 0x2df3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %edx
cmpl $0x71, %esi
jae 0x2e34
cmpl $0x0, 0x4598(%rip)      # 0x73b0
jne 0x2e20
incl 0x4594(%rip)            # 0x73b4
movl %edx, %eax
imulq $0xc, %rax, %rax
leaq 0x45b3(%rip), %rcx      # 0x73e0
movl (%rax,%rcx), %eax
andl $0x1, %eax
retq
pushq %rax
movq 0x41bc(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1506(%rip), %rsi      # 0x434c
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %edx
cmpl $0x71, %esi
jae 0x2e7a
cmpl $0x0, 0x4550(%rip)      # 0x73b0
jne 0x2e68
incl 0x4550(%rip)            # 0x73b8
movl %edx, %eax
imulq $0xc, %rax, %rax
leaq 0x456b(%rip), %rcx      # 0x73e0
orb $0x1, (%rax,%rcx)
retq
pushq %rax
movq 0x4176(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x14ee(%rip), %rsi      # 0x437a
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
cmpl $0x71, %esi
jae 0x2f47
movl %ebx, %eax
imulq $0xc, %rax, %rcx
leaq 0x4528(%rip), %r12      # 0x73e0
testb $0x1, (%rcx,%r12)
jne 0x2f5a
movq %rdx, %r14
movl %ebx, %eax
shll $0xc, %eax
leaq 0x4a5e(%rip), %r15      # 0x7930
addq %rcx, %r12
movl 0x44d5(%rip), %ebp      # 0x73b0
testl %ebp, %ebp
jne 0x2ee5
incl 0x44d7(%rip)            # 0x73bc
addq %rax, %r15
andl $0x0, 0x4(%r12)
movl %ebx, %edi
callq 0x2f79
testb $0x2, (%r12)
jne 0x2f12
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movl $0xff, %esi
callq 0x1090
xorl %eax, %eax
jmp 0x2f3e
testl %ebp, %ebp
jne 0x2f1c
incl 0x44a4(%rip)            # 0x73c0
imull $0x39, %ebx, %edi
addl $0x1d, %edi
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rsi
callq 0x348c
pushq $-0x1
popq %rax
testq %r14, %r14
je 0x2f3e
movl $0x1, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x40aa(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1452(%rip), %rsi      # 0x43aa
jmp 0x2f6b
movq 0x4097(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x146c(%rip), %rsi      # 0x43d7
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/sim.c
// Function: timebomb_tick
static void timebomb_tick(dhara_block_t blk)
{
	struct block_status *b = &blocks[blk];

	if (b->timebomb) {
		b->timebomb--;
		if (!b->timebomb)
			b->flags |= BLOCK_FAILED;
	}
}

// Assembly:
movl %edi, %eax
imulq $0xc, %rax, %rdx
leaq 0x445a(%rip), %rax      # 0x73e0
movl 0x8(%rdx,%rax), %ecx
testl %ecx, %ecx
je 0x2f98
addq %rdx, %rax
decl %ecx
movl %ecx, 0x8(%rax)
je 0x2f99
retq
orb $0x2, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %edx
shrl $0x3, %edx
cmpl $0x388, %esi            # imm = 0x388
jae 0x306c
movl %edx, %eax
imulq $0xc, %rax, %rax
leaq 0x441a(%rip), %r12      # 0x73e0
testb $0x1, (%rax,%r12)
jne 0x307f
movq %rcx, %rbx
movl %esi, %ebp
movl %esi, %ecx
andl $0x7, %ecx
addq %rax, %r12
movl 0x4(%r12), %r8d
cmpl %r8d, %ecx
jl 0x309c
movl %ebp, %eax
shll $0x9, %eax
leaq 0x4938(%rip), %r15      # 0x7930
cmpl $0x0, 0x43b1(%rip)      # 0x73b0
jne 0x3007
incl 0x43c1(%rip)            # 0x73c8
addq %rax, %r15
incl %ecx
movl %ecx, 0x4(%r12)
movl %edx, %edi
callq 0x2f79
testb $0x2, (%r12)
jne 0x3033
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
movq %r14, %rsi
callq 0x10c0
xorl %eax, %eax
jmp 0x3063
cmpl $0x0, 0x4376(%rip)      # 0x73b0
jne 0x3042
incl 0x438a(%rip)            # 0x73cc
imull $0x39, %ebp, %edi
addl $0x1d, %edi
movl $0x200, %edx            # imm = 0x200
movq %r15, %rsi
callq 0x348c
pushq $-0x1
popq %rax
testq %rbx, %rbx
je 0x3063
movl $0x1, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f85(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1393(%rip), %rsi      # 0x4410
jmp 0x3090
movq 0x3f72(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13ac(%rip), %rsi      # 0x443c
xorl %eax, %eax
callq 0x10b0
callq 0x1040
movq 0x3f55(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13c7(%rip), %rsi      # 0x4474
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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, %edx
shrl $0x3, %edx
cmpl $0x388, %esi            # imm = 0x388
jae 0x30ef
cmpl $0x0, 0x42e3(%rip)      # 0x73b0
jne 0x30d5
incl 0x42ef(%rip)            # 0x73c4
andl $0x7, %esi
movl %edx, %eax
imulq $0xc, %rax, %rcx
leaq 0x42fb(%rip), %rdx      # 0x73e0
xorl %eax, %eax
cmpl %esi, 0x4(%rcx,%rdx)
setle %al
retq
pushq %rax
movq 0x3f01(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13c3(%rip), %rsi      # 0x44c4
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %eax
cmpl $0x388, %esi            # imm = 0x388
jae 0x316b
cmpq $0x200, %rdx            # imm = 0x200
ja 0x318d
cmpq $0x200, %rcx            # imm = 0x200
ja 0x318d
leaq (%rcx,%rdx), %rsi
cmpq $0x201, %rsi            # imm = 0x201
jae 0x318d
cmpl $0x0, 0x4272(%rip)      # 0x73b0
jne 0x314c
incl 0x428a(%rip)            # 0x73d0
addl %ecx, 0x4288(%rip)      # 0x73d4
shll $0x9, %eax
leaq 0x47da(%rip), %rsi      # 0x7930
addq %rax, %rsi
addq %rdx, %rsi
movq %r8, %rdi
movq %rcx, %rdx
callq 0x10c0
xorl %eax, %eax
popq %rcx
retq
shrl $0x3, %eax
movq 0x3e83(%rip), %rcx      # 0x6ff8
movq (%rcx), %rdi
leaq 0x1374(%rip), %rsi      # 0x44f3
movl %eax, %edx
xorl %eax, %eax
callq 0x10b0
callq 0x1040
movq 0x3e64(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1381(%rip), %rsi      # 0x451f
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testl %edi, %edi
cmovgl %edi, %ebx
pushq $0x71
popq %r14
leaq 0x41c0(%rip), %r15      # 0x73e0
subl $0x1, %ebx
jb 0x323a
callq 0x10d0
cqto
idivq %r14
imulq $0xc, %rdx, %rax
orb $0x3, (%rax,%r15)
jmp 0x3220
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %r14
xorl %ebp, %ebp
testl %edi, %edi
cmovgl %edi, %ebp
pushq $0x71
popq %r15
leaq 0x414a(%rip), %r12      # 0x73e0
subl $0x1, %ebp
jb 0x32c1
callq 0x10d0
cqto
idivq %r15
movq %rdx, %rbx
callq 0x10d0
cqto
idivq %r14
incl %edx
movl %ebx, %eax
imulq $0xc, %rax, %rax
movl %edx, 0x8(%rax,%r12)
jmp 0x3296
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
leaq 0x1353(%rip), %rdi      # 0x4640
callq 0x1060
movl 0x40bc(%rip), %esi      # 0x73b4
leaq 0x1264(%rip), %rdi      # 0x4563
xorl %eax, %eax
callq 0x1070
movl 0x40ac(%rip), %esi      # 0x73b8
leaq 0x1268(%rip), %rdi      # 0x457b
xorl %eax, %eax
callq 0x1070
movl 0x409c(%rip), %esi      # 0x73bc
leaq 0x126c(%rip), %rdi      # 0x4593
xorl %eax, %eax
callq 0x1070
movl 0x408c(%rip), %esi      # 0x73c0
leaq 0x1270(%rip), %rdi      # 0x45ab
xorl %eax, %eax
callq 0x1070
movl 0x407c(%rip), %esi      # 0x73c4
leaq 0x1274(%rip), %rdi      # 0x45c3
xorl %eax, %eax
callq 0x1070
movl 0x406c(%rip), %esi      # 0x73c8
leaq 0x1278(%rip), %rdi      # 0x45db
xorl %eax, %eax
callq 0x1070
movl 0x405c(%rip), %esi      # 0x73cc
leaq 0x127c(%rip), %rdi      # 0x45f3
xorl %eax, %eax
callq 0x1070
movl 0x404c(%rip), %esi      # 0x73d0
leaq 0x1280(%rip), %rdi      # 0x460b
xorl %eax, %eax
callq 0x1070
movl 0x403c(%rip), %esi      # 0x73d4
leaq 0x1284(%rip), %rdi      # 0x4623
xorl %eax, %eax
callq 0x1070
pushq $0xa
popq %rdi
callq 0x1030
leaq 0x12a2(%rip), %rdi      # 0x4657
callq 0x1060
movq 0x3c17(%rip), %r13      # 0x6fd8
pushq $0x62
popq %rbx
leaq 0xf69(%rip), %rbp       # 0x4334
xorl %r14d, %r14d
cmpl $0x70, %r14d
ja 0x347d
pushq $0x71
popq %rax
movl %eax, %r15d
subl %r14d, %r15d
cmpl $0x40, %r15d
pushq $0x40
popq %rax
cmovael %eax, %r15d
leaq 0x1248(%rip), %rdi      # 0x463b
xorl %eax, %eax
callq 0x1070
movl %r14d, 0xc(%rsp)
movl %r14d, %eax
movq %r15, 0x10(%rsp)
imulq $0xc, %r15, %r15
imulq $0xc, %rax, %rax
leaq 0x3fca(%rip), %rcx      # 0x73e0
leaq (%rax,%rcx), %r12
addq $0x4, %r12
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x3460
movl -0x4(%r12,%r14), %eax
andl $0x3, %eax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
movl %ebx, %edi
jmpq *%rax
cmpl $0x0, (%r12,%r14)
pushq $0x3a
popq %rdi
pushq $0x2e
popq %rax
cmovel %eax, %edi
jmp 0x3451
pushq $0x3f
jmp 0x3450
pushq $0x42
popq %rdi
movq (%r13), %rsi
callq 0x10a0
addq $0xc, %r14
jmp 0x3421
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0x10a0
movq 0x10(%rsp), %rax
addl 0xc(%rsp), %eax
movl %eax, %r14d
jmp 0x33ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x34b2
callq 0x10d0
movb %al, (%r14,%r15)
incq %r15
jmp 0x349f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rsi, %r12
movl %edi, %ebx
callq 0x1050
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x34ed
callq 0x10d0
movzbl (%r12,%r14), %r8d
movzbl %al, %r9d
cmpl %r8d, %r9d
jne 0x34f9
incq %r14
jmp 0x34d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3af8(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x115b(%rip), %rsi      # 0x4665
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10b0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0xa, %edx
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x137c
movl (%rdi,%rcx,4), %r8d
cmpl $0xa, %r8d
cmovgel %edx, %r8d
addl %r8d, %eax
incq %rcx
jmp 0x1363
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x139a
leal 0xa(%rax), %edx
cmpl $0xc, %eax
cmovgel %eax, %edx
cmpl $0x1, (%rdi,%rcx,4)
cmovnel %eax, %edx
incq %rcx
movl %edx, %eax
jmp 0x137e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PARKINHYO[P]BlackjackGame/shm/./common.h
// Function: display_state
int display_state(int hand_values[], int hand_suits[], int ncards)
{
	int i;
	int sum = calc_sum(hand_values, ncards);
	for (i = 0; i < ncards; ++i)
	{
		if (i > 0)
			printf(", ");
		printf("%s-%s", values[hand_values[i]], suits[hand_suits[i]]);
	}
	printf(" Sum: %d", sum);
	if (sum > 21){
		printf("; BUSTED");
		printf("\n");
		return 1;
		}
	else if (sum == 21){
		printf("\n");
		return 1;
	}
	printf("\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %esi
callq 0x1351
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
leaq 0xc84(%rip), %r13       # 0x2051
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x1414
testq %rbx, %rbx
je 0x13e7
leaq 0xc6e(%rip), %rdi       # 0x204e
xorl %eax, %eax
callq 0x10a0
movslq (%r12,%rbx,4), %rax
leaq 0x2d2e(%rip), %rcx      # 0x4120
movq (%rcx,%rax,8), %rsi
movslq (%r15,%rbx,4), %rax
leaq 0x2cff(%rip), %rcx      # 0x4100
movq (%rcx,%rax,8), %rdx
movq %r13, %rdi
xorl %eax, %eax
callq 0x10a0
incq %rbx
jmp 0x13cf
leaq 0xc3c(%rip), %rdi       # 0x2057
movl -0x2c(%rbp), %r14d
movl %r14d, %esi
xorl %eax, %eax
callq 0x10a0
cmpl $0x16, %r14d
jl 0x144a
leaq 0xc2a(%rip), %rdi       # 0x2060
xorl %eax, %eax
callq 0x10a0
pushq $0xa
popq %rdi
callq 0x1040
pushq $0x1
popq %rbx
jmp 0x145b
xorl %ebx, %ebx
cmpl $0x15, %r14d
sete %bl
pushq $0xa
popq %rdi
callq 0x1040
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PARKINHYO[P]BlackjackGame/shm/shm_server.c
// Function: set_shutdown
void *set_shutdown ()
{
        printf("[SIGNAL] : Got shutdown signal\n");
        shmctl( gnShmID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Shared meory segment marked for deletion\n");;
        semctl( gnSemID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Semapore segment marked for deletion\n");
        exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd89(%rip), %rdi       # 0x2200
callq 0x1080
movl 0x2d1e(%rip), %edi      # 0x41a0
xorl %esi, %esi
xorl %edx, %edx
callq 0x1120
leaq 0xd8d(%rip), %rdi       # 0x221f
callq 0x1080
movl 0x2d07(%rip), %edi      # 0x41a4
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1140
leaq 0xda4(%rip), %rdi       # 0x2253
callq 0x1080
pushq $0x1
popq %rdi
callq 0x1190
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movb $0x1, %cl
xorl %edx, %edx
movb $0xd, %sil
leaq 0x2cdb(%rip), %rbx      # 0x41b0
leaq 0x2da4(%rip), %r14      # 0x4280
xorl %edi, %edi
movzbl %dil, %eax
divb %sil
cmpq $0x34, %rdi
je 0x1517
movzbl %al, %eax
imull $0xd, %eax, %eax
movl %ecx, %r8d
subb %al, %r8b
movzbl %r8b, %eax
movl %eax, (%rdx,%rbx)
movzbl %dil, %eax
divb %sil
movzbl %al, %eax
movl %eax, (%rdx,%r14)
incq %rdi
incb %cl
addq $0x4, %rdx
jmp 0x14de
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10b0
pushq $0x34
popq %r12
cmpq $0xd0, %r15
je 0x1565
callq 0x11d0
cltd
idivl %r12d
movl (%r15,%rbx), %eax
movslq %edx, %rcx
movl (%rbx,%rcx,4), %edx
movl %edx, (%r15,%rbx)
movl %eax, (%rbx,%rcx,4)
movl (%r15,%r14), %eax
movl (%r14,%rcx,4), %edx
movl %edx, (%r15,%r14)
movl %eax, (%r14,%rcx,4)
addq $0x4, %r15
jmp 0x152c
andl $0x0, 0x2de4(%rip)      # 0x4350
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/robertdavidgraham[P]wc2/wcstream.c
// Function: main
int main()
{
    for (;;) {
        char buf[65536];
        size_t length;
        size_t i;

        length = read(STDIN_FILENO, buf, sizeof(buf));
        if (length <= 0)
            break;
        for (i=0; i<length; i++) {
            size_t count;

            count = write(STDOUT_FILENO, buf+i, 1);
            if (count <= 0)
                exit(1);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10000, %rsp          # imm = 0x10000
movq %rsp, %rbx
pushq $0x1
popq %rbp
pushq $0x1
popq %r14
movl $0x10000, %edx          # imm = 0x10000
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1040
testq %rax, %rax
je 0x11b2
movq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x1175
leaq (%rsp,%r12), %rsi
movl %ebp, %edi
movq %r14, %rdx
callq 0x1030
incq %r12
testq %rax, %rax
jne 0x118f
pushq $0x1
popq %rdi
callq 0x1050
xorl %eax, %eax
addq $0x10000, %rsp          # imm = 0x10000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2140
testl %eax, %eax
jne 0x2b99
leaq 0x7(%rsp), %r14
pushq $0x1
popq %r15
movb $0x0, 0x7(%rsp)
movl 0xc(%rsp), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20d0
cmpl $0x1, %eax
je 0x2b76
callq 0x2070
cmpl $0x4, (%rax)
je 0x2b58
movl 0x8(%rsp), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2150
cmpl $0x1, %eax
je 0x2b94
callq 0x2070
cmpl $0x4, (%rax)
je 0x2b76
incq (%rbx)
jmp 0x2b53
leaq 0x6d8(%rip), %rdi       # 0x3278
leaq 0x6df(%rip), %rsi       # 0x3286
leaq 0x6e6(%rip), %rcx       # 0x3294
pushq $0xf
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17e5
movq 0x1060(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1758
cmpb $-0x1, (%rax)
sete %r13b
movq %r12, %rdi
callq 0x1748
addb %r13b, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17e5
movq %r15, %rdi
movq %r12, %rsi
callq 0x1758
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x17e5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17e5
movq 0x1088(%rsp), %r12
movq %r12, %rdi
callq 0x1748
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17e5
movq %r15, %rdi
movq %r12, %rsi
callq 0x1758
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x17e5
movslq (%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x675c
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x6720
leaq 0xc(%rsp), %r12
movl $0x2, (%r12)
pushq $0x30
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
leaq 0x9956(%rip), %rdx      # 0xb004
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x17e5
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
movb (%r14), %al
addb $0x3, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
movsbl (%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x17e5
movslq (%r12), %rdi
addq %rbx, %rdi
movslq (%r14), %rdx
movq %r15, %rsi
callq 0x675c
movl (%r12), %eax
addl %eax, (%r14)
movb $0x30, (%rbx)
movb (%r14), %al
addb $-0x2, %al
movb %al, 0x1(%rbx)
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xa
popq %rsi
callq 0x6720
xorl %edx, %edx
pushq $-0x1
popq %rax
pushq $0x30
popq %rsi
xorl %r9d, %r9d
leal (,%rax,8), %edi
movl %esi, %ecx
subl %edi, %ecx
incl %eax
cmpl $0x8, %eax
je 0x17da
movl %r9d, %edi
movl $0xff, %r8d
shlq %cl, %r8
andq %r14, %r8
shrq %cl, %r8
addl $-0x8, %ecx
testq %r8, %r8
setne %r10b
orb %r9b, %r10b
xorl %r9d, %r9d
testb $0x1, %r10b
je 0x1780
movslq %edx, %rcx
movb %r8b, (%rbx,%rcx)
testb %r8b, %r8b
setns %r9b
orb %r9b, %dil
testb $0x1, %dil
jne 0x17d3
leaq 0x1(%rcx), %rdx
movb %r8b, 0x1(%rbx,%rcx)
movb $-0x1, (%rbx,%rcx)
incl %edx
movb $0x1, %r9b
jmp 0x1775
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1839
movq %rdx, %r15
movq %rdx, %rdi
callq 0x739e
cmpl $0x1, %eax
jne 0x1817
xorl %eax, %eax
cmpb $0x1, 0x2(%r15)
sete %al
leaq 0x1(,%rax,2), %rax
cltq
xorl %ecx, %ecx
cmpq %rax, %rcx
jl 0x1827
cmpb $0x0, (%r15,%rax)
je 0x1842
movb (%r15,%rcx), %dl
movslq (%rbx), %rsi
movb %dl, (%r14,%rsi)
incl (%rbx)
incq %rcx
jmp 0x181b
movslq (%rbx), %rax
movb %sil, (%r14,%rax)
incl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ecx
xorl %r9d, %r9d
cmpl $0x41, %edx
setne %r9b
xorl %eax, %eax
leaq 0x10699(%rip), %r10     # 0x120d0
movl $0x4, %r11d
cmpl %ecx, %eax
jge 0x1aef
leal 0x4(%rax), %ebx
testb $0x3f, %bl
jne 0x1a5b
addl %r9d, %eax
cmpl %ecx, %eax
je 0x1aeb
leal 0x4(%rax), %ebx
movslq %eax, %r8
movzbl (%rdi,%r8), %eax
movb (%rax,%r10), %bpl
shlb $0x2, %bpl
movl %r8d, %eax
cltd
idivl %r11d
cltq
leaq (%rax,%rax,2), %rax
orb (%rsi,%rax), %bpl
movb %bpl, (%rsi,%rax)
movzbl 0x1(%rdi,%r8), %edx
movb (%rdx,%r10), %dl
shrb $0x4, %dl
andb $0x3, %dl
orb %bpl, %dl
movb %dl, (%rsi,%rax)
movzbl 0x1(%rdi,%r8), %edx
movb (%rdx,%r10), %dl
shlb $0x4, %dl
orb 0x1(%rsi,%rax), %dl
movb %dl, 0x1(%rsi,%rax)
movzbl 0x2(%rdi,%r8), %r14d
movb (%r14,%r10), %bpl
shrb $0x2, %bpl
orb %dl, %bpl
movb %bpl, 0x1(%rsi,%rax)
movzbl 0x2(%rdi,%r8), %edx
movb (%rdx,%r10), %dl
shlb $0x6, %dl
orb 0x2(%rsi,%rax), %dl
movb %dl, 0x2(%rsi,%rax)
movzbl 0x3(%rdi,%r8), %r8d
orb (%r8,%r10), %dl
movb %dl, 0x2(%rsi,%rax)
movl %ebx, %eax
jmp 0x1a3d
decl %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
pushq $0x42
popq %rsi
movq %r14, %rdi
callq 0x6720
movq %rsp, %r15
pushq $0x32
popq %rsi
movq %r15, %rdi
callq 0x6720
pushq $0x41
popq %r12
pushq $0xa
popq %rbp
movl (%rbx), %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x10a0
movq %rax, %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x70af
cltq
movb $0x0, 0x40(%rsp,%rax)
cmpl $0x41, %r13d
jne 0x1b8a
movq %r14, %rdi
movq %r15, %rsi
pushq $0x41
popq %rdx
callq 0x1a1e
movb $0x0, 0x30(%rsp)
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x6d07
movq %r14, %rdi
movq %r12, %rsi
callq 0x6720
movq %r15, %rdi
pushq $0x31
popq %rsi
callq 0x6720
jmp 0x1b2d
leaq 0x40(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
movl %r13d, %edx
callq 0x1a1e
addl %r13d, %r13d
cvtsi2ss %r13d, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x9467(%rip), %xmm0     # 0xb018
cvttsd2si %xmm0, %eax
cltq
movb $0x0, (%rsp,%rax)
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x6d07
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/encode/base64.c
// Function: parse_b64
int				parse_b64(char **av, t_parse *b64, t_ssl *ssl, int i)
{
	while ((av[++i]))
	{
		if (av[i][0] == '-')
		{
			if (valid_arg(b64, &av[i][1], av[i + 1]))
			{
				ssl->flag = b64->flag & F_IN ? -42 : ssl->flag;
				ssl->flag = b64->flag & F_OUT ? -42 : ssl->flag;
				return (ft_error(6, &av[i][1], ssl));
			}
			else if (b64->fd_out == 1 && b64->flag & F_OUT)
				open_file_to_fd((int*)&b64->fd_out, av[++i], 1);
			else if ((!b64->fd_in) && (b64->flag & F_IN))
				open_file_to_fd((int*)&b64->fd_in, av[++i], 0);
		}
		else
			return (ft_error(6, av[i], ssl));
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x4(%rsi), %r12
movslq %ebp, %r14
movq (%rsp), %rax
movq 0x8(%rax,%r14,8), %r13
testq %r13, %r13
je 0x1d7b
cmpb $0x2d, (%r13)
jne 0x1d7f
incq %r13
movq (%rsp), %rax
movq 0x10(%rax,%r14,8), %rbx
cmpl $0x1, (%r12)
jne 0x1c59
movq %r13, %rdi
leaq 0xab9d(%rip), %rsi      # 0xc7d2
callq 0x70f4
testl %eax, %eax
je 0x1d15
movq %r13, %rdi
leaq 0x9fb5(%rip), %rsi      # 0xbc01
callq 0x70f4
testl %eax, %eax
je 0x1d15
movq %r13, %rdi
leaq 0xab40(%rip), %rsi      # 0xc7a3
callq 0x70f4
testl %eax, %eax
je 0x1cda
movq %r13, %rdi
leaq 0x93c7(%rip), %rsi      # 0xb03d
callq 0x70f4
testl %eax, %eax
je 0x1cda
movq %r13, %rdi
leaq 0x9e80(%rip), %rsi      # 0xbb09
callq 0x70f4
testl %eax, %eax
je 0x1d21
movq %r13, %rdi
leaq 0x93bb(%rip), %rsi      # 0xb05b
callq 0x70f4
testl %eax, %eax
je 0x1d21
movq %r13, %rdi
leaq 0x93ae(%rip), %rsi      # 0xb061
callq 0x70f4
testl %eax, %eax
je 0x1cd3
movq %r13, %rdi
leaq 0x939d(%rip), %rsi      # 0xb063
callq 0x70f4
testl %eax, %eax
jne 0x1d95
orb $0x10, 0x8(%r15)
jmp 0x1d26
orb $0x2, 0x8(%r15)
testq %rbx, %rbx
jne 0x1cf3
leaq 0x9354(%rip), %rdi      # 0xb03f
pushq $0x2
popq %rsi
callq 0x6d07
leaq 0x14(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6264
testl %eax, %eax
jne 0x1d95
movl 0x14(%rsp), %edi
callq 0x1070
jmp 0x1d26
orb $0x1, 0x8(%r15)
testq %rbx, %rbx
jne 0x1d26
jmp 0x1d86
orb $0x8, 0x8(%r15)
leal 0x2(%rbp), %ebx
addq $0x2, %r14
cmpl $0x1, (%r12)
jne 0x1d3b
testb $0x1, 0x8(%r15)
jne 0x1d61
incl %ebp
cmpl $0x0, (%r15)
jne 0x1bf8
testb $0x2, 0x8(%r15)
je 0x1bf8
movq (%rsp), %rax
movq (%rax,%r14,8), %rsi
movq %r15, %rdi
xorl %edx, %edx
jmp 0x1d6f
movq (%rsp), %rax
movq (%rax,%r14,8), %rsi
movq %r12, %rdi
pushq $0x1
popq %rdx
callq 0x6264
movl %ebx, %ebp
jmp 0x1bf8
xorl %eax, %eax
jmp 0x1dd4
movq 0x8(%rsp), %rdx
jmp 0x1dc9
leaq 0x9293(%rip), %rdi      # 0xb020
pushq $0x2
popq %rsi
callq 0x6d07
movq 0x8(%rsp), %rdx
incq %r14
pushq $-0x2a
popq %rax
testb $0x2, 0x8(%r15)
movl %eax, %ecx
jne 0x1dac
movl 0x4(%rdx), %ecx
movl %ecx, 0x4(%rdx)
movzwl 0x8(%r15), %esi
testb $0x1, %sil
cmovel %ecx, %eax
movl %eax, 0x4(%rdx)
movq (%rsp), %rax
movq (%rax,%r14,8), %r13
incq %r13
pushq $0x6
popq %rdi
movq %r13, %rsi
callq 0x2608
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x1e0d
btl $0x12, %eax
jae 0x1e1c
movl %eax, %ecx
jmp 0x1ea3
xorl %ecx, %ecx
cmpl $0x0, 0x408(%rbx)
jne 0x1ea3
testw %ax, %ax
js 0x1e29
cmpl $0x0, 0xc(%rbx)
movl %eax, %ecx
jne 0x1ea3
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x63ee
movq (%r15), %rsi
testq %rsi, %rsi
jne 0x1e54
leaq 0x9e8e(%rip), %rdi      # 0xbcda
callq 0x74dc
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 0x2add
leaq 0x9f20(%rip), %rdi      # 0xbda9
movq %r15, %rsi
xorl %eax, %eax
callq 0x67f0
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)
xorl %r15d, %r15d
cmpl $0x0, 0xc(%rbx,%r15,4)
je 0x1edb
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 0x2add
incq %r15
jmp 0x1eaf
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
pushq $0xc
popq %rsi
movq %r15, %rdi
callq 0x6720
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x6720
movl $0x1, 0x4(%r15)
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1bd8
testl %eax, %eax
jne 0x1f9c
andl $0x0, (%rsp)
testb $0x8, 0xc(%rsp)
jne 0x1f92
leaq 0x10(%rsp), %rbx
pushq $0x3f
popq %r14
pushq $0x3f
popq %rbp
movq %rsp, %r15
pushq $0x40
popq %r12
movl 0x4(%rsp), %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10a0
movl 0x8(%rsp), %edx
cmpl $0x3f, %eax
jne 0x1f81
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rcx
callq 0x1848
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6720
jmp 0x1f4f
leaq 0x10(%rsp), %rdi
movq %rsp, %rcx
movl %eax, %esi
callq 0x1848
jmp 0x1f9c
leaq 0x4(%rsp), %rdi
callq 0x1af4
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ff0
leaq 0x9663(%rip), %rdi      # 0xb637
leaq 0x90cf(%rip), %rsi      # 0xb0aa
leaq 0x90fe(%rip), %rdx      # 0xb0e0
xorl %eax, %eax
callq 0x6a50
testl %eax, %eax
jne 0x200e
movl 0x8(%rbx), %eax
cmpl $0x2b, %eax
je 0x2016
cmpl $0x2a, %eax
jne 0x200e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x2b
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2066
movq (%rdi,%r8,8), %rax
addq %rax, %rsi
movsbl (%rax,%r9), %edx
leaq 0x90b5(%rip), %rdi      # 0xb10f
xorl %eax, %eax
callq 0x6a50
pushq $0x1
popq %rax
jmp 0x2092
leaq 0x1(%r8), %rsi
movl %esi, (%rax)
movq 0x8(%rdi,%r8,8), %rsi
testq %rsi, %rsi
je 0x2089
cmpb $0x0, (%rsi)
je 0x2089
movq (%rdi,%r8,8), %rax
movslq (%rdx), %rcx
movsbl -0x1(%rax,%rcx), %edx
jmp 0x2053
andl $0x0, 0x1ac(%rcx)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9657(%rip), %rsi      # 0xba13
leaq 0x8e94(%rip), %rdx      # 0xb257
leaq 0x8e95(%rip), %rcx      # 0xb25f
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
cmpl $0x9, %ebp
jg 0x23f3
leaq 0x963f(%rip), %rsi      # 0xba1f
pushq $0x2
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1080
cmpl $0x1d, %ebp
ja 0x2424
leaq 0x9643(%rip), %rsi      # 0xba42
pushq $0x2
popq %rbp
movl %ebp, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1080
leaq 0x965f(%rip), %rsi      # 0xba74
movl %ebp, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1080
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/error.c
// Function: rsa_error
void			rsa_error(int e)
{
	if (e == 20)
		ft_putstr_fd("Only private keys can be checked\n", 2);
	if (e == 19)
		ft_putstr_fd("A private key is needed for this operation\n", 2);
	else
	{
		e > 22 ? ft_putstr_fd("no keyfile specified\n", 2) : 0;
		ft_putstr_fd("Unable to load", 2);
		ft_putstr_fd(e % 2 ? " Public " : " Private ", 2);
		ft_putstr_fd("Key\n", 2);
	}
	if (e <= 8)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad base64 decode\n", 2);
	else if (e <= 10)
		ft_putstr_fd("PEM routines:PEM_read_bio:no start line\n", 2);
	else if (e <= 12)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad end line\n", 2);
	else if (e <= 14)
		ft_putstr_fd("asn1 encoding routines:ASN1_CHECK_T:wrong tag\n", 2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x13, %edi
je 0x2443
movl %edi, %ebx
cmpl $0x14, %edi
jne 0x244f
leaq 0x9657(%rip), %rdi      # 0xba98
jmp 0x245b
leaq 0x9670(%rip), %rdi      # 0xbaba
jmp 0x24d4
cmpl $0x17, %ebx
jl 0x2463
leaq 0x968b(%rip), %rdi      # 0xbae6
pushq $0x2
popq %rsi
callq 0x6d07
leaq 0x9692(%rip), %rdi      # 0xbafc
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x6d07
testb $0x1, %bl
leaq 0x9696(%rip), %rax      # 0xbb14
leaq 0x9686(%rip), %rdi      # 0xbb0b
cmoveq %rax, %rdi
movl %ebp, %esi
callq 0x6d07
leaq 0x9687(%rip), %rdi      # 0xbb1e
movl %ebp, %esi
callq 0x6d07
cmpl $0x9, %ebx
jge 0x24ac
leaq 0x9679(%rip), %rdi      # 0xbb23
jmp 0x24d4
cmpl $0xb, %ebx
jae 0x24ba
leaq 0x9698(%rip), %rdi      # 0xbb50
jmp 0x24d4
cmpl $0xd, %ebx
jae 0x24c8
leaq 0x96b3(%rip), %rdi      # 0xbb79
jmp 0x24d4
cmpl $0xe, %ebx
ja 0x24e2
leaq 0x96cd(%rip), %rdi      # 0xbba1
pushq $0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6d07
addq $0x8, %rsp
popq %rbx
popq %rbp
retq