LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/uniprot.c
// Function: renderNumberAligned
void renderNumberAligned(const mem_opt_t * passOptions) {
	int listIdx, successTotal, alignTotal;

	// Primary alignments
	for (successTotal = 0, alignTotal = 0, listIdx = 0 ; listIdx < uniprotPriListCount ; listIdx++) {
		successTotal += uniprotPriEntryLists[listIdx].entryCount;
		alignTotal += uniprotPriEntryLists[listIdx].entryCount + uniprotPriEntryLists[listIdx].unalignedCount;
	}

	// Secondary alignments (if requested)
	if (passOptions->flag & MEM_F_ALL) {
		for (listIdx = 0 ; listIdx < uniprotSecListCount ; listIdx++) {
			successTotal += uniprotSecEntryLists[listIdx].entryCount;
			alignTotal += uniprotSecEntryLists[listIdx].entryCount;
		}
	}

	if (alignTotal == 0) {
		logMessage(__func__, LOG_LEVEL_MESSAGE, "No detected ORF sequences, no alignment performed\n");
	}
	else {
		logMessage(__func__, LOG_LEVEL_MESSAGE, "Aligned %d out of %d total detected ORF sequences (%.2f%%)\n", successTotal, alignTotal, (float) successTotal / (float) alignTotal * 100);
	}
}

// Assembly:
movslq 0x258bc(%rip), %rax     # 0x30e68
testq %rax, %rax
jle 0xb5de
movq 0x258a0(%rip), %rdx     # 0x30e58
shlq $0x4, %rax
xorl %esi, %esi
xorl %r8d, %r8d
xorl %ecx, %ecx
movl 0x8(%rdx,%rsi), %r9d
addl %r9d, %ecx
addl %r9d, %r8d
addl 0xc(%rdx,%rsi), %r8d
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0xb5c3
jmp 0xb5e3
xorl %ecx, %ecx
xorl %r8d, %r8d
testb $0x8, 0x48(%rdi)
je 0xb614
movslq 0x2587c(%rip), %rax     # 0x30e6c
testq %rax, %rax
jle 0xb614
movq 0x25864(%rip), %rdx     # 0x30e60
shlq $0x4, %rax
xorl %esi, %esi
movl 0x8(%rdx,%rsi), %edi
addl %edi, %ecx
addl %edi, %r8d
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0xb602
testl %r8d, %r8d
je 0xb64c
cvtsi2ss %ecx, %xmm0
cvtsi2ss %r8d, %xmm1
divss %xmm1, %xmm0
mulss 0x1bca2(%rip), %xmm0    # 0x272d0
cvtss2sd %xmm0, %xmm0
leaq 0x1c229(%rip), %rdi     # 0x27862
leaq 0x1c269(%rip), %rdx     # 0x278a9
movl $0x3, %esi
movb $0x1, %al
jmp 0xde80
leaq 0x1c20f(%rip), %rdi     # 0x27862
leaq 0x1c21c(%rip), %rdx     # 0x27876
movl $0x3, %esi
xorl %eax, %eax
jmp 0xde80
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwashm.c
// Function: index_load_from_shm
bwaidx_t *index_load_from_shm(const char *hint)
{
	const char *name;
	uint8_t *shm, *shm_idx;
	uint16_t *cnt, i;
	char *p, path[PATH_MAX + 1];
	int shmid;
	int64_t l_mem;
	bwaidx_t *idx;

	if (hint == 0 || hint[0] == 0) return 0;
	for (name = hint + strlen(hint) - 1; name >= hint && *name != '/'; --name);
	++name;
	if ((shmid = shm_open("/bwactl", O_RDONLY, 0)) < 0) return 0;
	shm = mmap(0, BWA_CTL_SIZE, PROT_READ, MAP_SHARED, shmid, 0);
	cnt = (uint16_t*)shm;
	if (cnt[0] == 0) return 0;
	for (i = 0, p = (char*)(shm + 4); i < cnt[0]; ++i) {
		memcpy(&l_mem, p, 8); p += 8;
		if (strcmp(p, name) == 0) break;
		p += strlen(p) + 1;
	}
	if (i == cnt[0]) return 0;

	strcat(strcpy(path, "/bwaidx-"), name);
	if ((shmid = shm_open(path, O_RDONLY, 0)) < 0) return 0;
	shm_idx = mmap(0, l_mem, PROT_READ, MAP_SHARED, shmid, 0);
	idx = calloc(1, sizeof(bwaidx_t));
	bwa_mem2idx(l_mem, shm_idx, idx);
	idx->is_shm = 1;
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
testq %rdi, %rdi
je 0xc149
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0xc149
movq %rbx, %rdi
callq 0x3100
addq %rbx, %rax
decq %rax
movq %rax, %r14
cmpq %rbx, %rax
jb 0xc04b
leaq -0x1(%r14), %rax
cmpb $0x2f, (%r14)
jne 0xc039
leaq 0x1b922(%rip), %rdi     # 0x27974
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc14b
xorl %ebx, %ebx
movl $0x10000, %esi          # imm = 0x10000
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
movzwl (%rax), %ebp
testw %bp, %bp
je 0xc14b
movq %rax, %r15
incq %r14
addq $0x4, %r15
xorl %ebx, %ebx
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x34d0
testl %eax, %eax
je 0xc0c7
movq %r12, %rdi
callq 0x3100
leaq (%r12,%rax), %r15
incq %r15
decw %bp
jne 0xc09b
jmp 0xc14b
testw %bp, %bp
je 0xc149
movq (%r15), %r15
movabsq $0x2d7864696177622f, %rax # imm = 0x2D7864696177622F
movq %rsp, %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x36b0
xorl %ebx, %ebx
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc14b
xorl %edi, %edi
movq %r15, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
movq %rax, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x31b0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x13027
movl $0x1, 0x18(%rbx)
jmp 0xc14b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwashm.c
// Function: bwa_shm_test
int bwa_shm_test(const char *hint)
{
	int shmid;
	uint16_t *cnt, i;
	char *p, *shm;
	const char *name;

	if (hint == 0 || hint[0] == 0) return 0;
	for (name = hint + strlen(hint) - 1; name >= hint && *name != '/'; --name);
	++name;
	if ((shmid = shm_open("/bwactl", O_RDONLY, 0)) < 0) return 0;
	shm = mmap(0, BWA_CTL_SIZE, PROT_READ, MAP_SHARED, shmid, 0);
	cnt = (uint16_t*)shm;
	for (i = 0, p = shm + 4; i < cnt[0]; ++i) {
		if (strcmp(p + 8, name) == 0) return 1;
		p += strlen(p) + 9;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xc20d
movq %rdi, %r15
cmpb $0x0, (%rdi)
je 0xc20d
movq %r15, %rdi
callq 0x3100
addq %r15, %rax
decq %rax
movq %rax, %r14
cmpq %r15, %rax
jb 0xc19c
leaq -0x1(%r14), %rax
cmpb $0x2f, (%r14)
jne 0xc18a
leaq 0x1b7d1(%rip), %rdi     # 0x27974
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc20d
xorl %ebx, %ebx
movl $0x10000, %esi          # imm = 0x10000
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
movzwl (%rax), %ebp
testw %bp, %bp
je 0xc20d
movq %rax, %r15
incq %r14
addq $0x4, %r15
leaq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x34d0
testl %eax, %eax
je 0xc208
movq %r15, %rdi
callq 0x3100
addq %rax, %r15
addq $0x9, %r15
decw %bp
jne 0xc1e2
jmp 0xc20d
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwashm.c
// Function: bwa_shm_list
int bwa_shm_list(void)
{
	int shmid;
	uint16_t *cnt, i;
	char *p, *shm;
	if ((shmid = shm_open("/bwactl", O_RDONLY, 0)) < 0) return -1;
	shm = mmap(0, BWA_CTL_SIZE, PROT_READ, MAP_SHARED, shmid, 0);
	cnt = (uint16_t*)shm;
	for (i = 0, p = shm + 4; i < cnt[0]; ++i) {
		int64_t l_mem;
		memcpy(&l_mem, p, 8); p += 8;
		printf("%s\t%ld\n", p, (long)l_mem);
		p += strlen(p) + 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1b748(%rip), %rdi     # 0x27974
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc2a0
movl $0x10000, %esi          # imm = 0x10000
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
cmpw $0x0, (%rax)
je 0xc2a5
movq %rax, %r14
movq %rax, %r13
addq $0x4, %r13
xorl %ebx, %ebx
leaq 0x1b775(%rip), %r15     # 0x279e5
xorl %ebp, %ebp
movq (%r13), %rdx
leaq 0x8(%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3060
movq %r12, %rdi
callq 0x3100
addq %rax, %r13
addq $0x9, %r13
incl %ebp
cmpw (%r14), %bp
jb 0xc272
jmp 0xc2a5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
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_O3/ToniWestbrook[P]paladin/bwashm.c
// Function: bwa_shm_destroy
int bwa_shm_destroy(void)
{
	int shmid;
	uint16_t *cnt, i;
	char *p, *shm;
	char path[PATH_MAX + 1];

	if ((shmid = shm_open("/bwactl", O_RDONLY, 0)) < 0) return -1;
	shm = mmap(0, BWA_CTL_SIZE, PROT_READ, MAP_SHARED, shmid, 0);
	cnt = (uint16_t*)shm;
	for (i = 0, p = shm + 4; i < cnt[0]; ++i) {
		int64_t l_mem;
		memcpy(&l_mem, p, 8); p += 8;
		strcat(strcpy(path, "/bwaidx-"), p);
		shm_unlink(path);
		p += strlen(p) + 1;
	}
	munmap(shm, BWA_CTL_SIZE);
	shm_unlink("/bwactl");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x1b6a6(%rip), %rdi     # 0x27974
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc36e
movl $0x10000, %esi          # imm = 0x10000
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
movq %rax, %r14
cmpw $0x0, (%rax)
je 0xc351
movq %r14, %r13
addq $0x4, %r13
xorl %ebp, %ebp
movabsq $0x2d7864696177622f, %rbx # imm = 0x2D7864696177622F
movq %rsp, %r15
leaq 0x8(%r13), %r12
movq %rbx, (%rsp)
movb $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x36b0
movq %r15, %rdi
callq 0x3740
movq %r12, %rdi
callq 0x3100
addq %rax, %r13
addq $0x9, %r13
incl %ebp
cmpw (%r14), %bp
jb 0xc31a
movl $0x10000, %esi          # imm = 0x10000
movq %r14, %rdi
callq 0x3170
leaq 0x1b60f(%rip), %rdi     # 0x27974
callq 0x3740
xorl %eax, %eax
jmp 0xc373
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwashm.c
// Function: main_shm
int main_shm(int argc, char *argv[])
{
	int c, to_list = 0, to_drop = 0, ret = 0;
	char *tmpfn = 0;
	while ((c = getopt(argc, argv, "ldf:")) >= 0) {
		if (c == 'l') to_list = 1;
		else if (c == 'd') to_drop = 1;
		else if (c == 'f') tmpfn = optarg;
	}
	if (optind == argc && !to_list && !to_drop) {
		fprintf(stderr, "\nUsage: bwa shm [-d|-l] [-f tmpFile] [idxbase]\n\n");
		fprintf(stderr, "Options: -d       destroy all indices in shared memory\n");
		fprintf(stderr, "         -l       list names of indices in shared memory\n");
		fprintf(stderr, "         -f FILE  temporary file to reduce peak memory\n\n");
		return 1;
	}
	if (optind < argc && (to_list || to_drop)) {
		fprintf(stderr, "[E::%s] open -l or -d cannot be used when 'idxbase' is present\n", __func__);
		return 1;
	}
	if (optind < argc) {
		if (bwa_shm_test(argv[optind]) == 0) {
			bwaidx_t *idx;
			idx = index_load_from_disk(argv[optind], BWA_IDX_ALL);
			if (bwa_shm_stage(idx, argv[optind], tmpfn) < 0) {
				fprintf(stderr, "[E::%s] failed to stage the index in shared memory\n", __func__);
				ret = 1;
			}
			index_destroy(idx);
		} else fprintf(stderr, "[M::%s] index '%s' is already in shared memory\n", __func__, argv[optind]);
	}
	if (to_list) bwa_shm_list();
	if (to_drop) bwa_shm_destroy();
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1b651(%rip), %rdx     # 0x279ed
callq 0x3090
xorl %r13d, %r13d
testl %eax, %eax
js 0xc401
leaq 0x1b63e(%rip), %r15     # 0x279ed
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpl $0x6c, %eax
je 0xc3d8
cmpl $0x66, %eax
je 0xc3cc
cmpl $0x64, %eax
jne 0xc3de
movl $0x1, %r13d
jmp 0xc3de
movq 0x23be5(%rip), %rax     # 0x2ffb8
movq (%rax), %r14
jmp 0xc3de
movl $0x1, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3090
testl %eax, %eax
jns 0xc3b5
testl %r12d, %r12d
setne %al
testl %r13d, %r13d
setne %r12b
movl %eax, %r13d
jmp 0xc407
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x23bca(%rip), %rax     # 0x2ffd8
movslq (%rax), %rax
cmpl %ebp, %eax
setne %dl
movl %r13d, %ecx
orb %r12b, %cl
orb %cl, %dl
testb $0x1, %dl
je 0xc49b
cmpl %ebp, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0xc4a2
xorl %r15d, %r15d
cmpl %ebp, %eax
jge 0xc485
movq (%rbx,%rax,8), %rdi
callq 0xc15e
testl %eax, %eax
jne 0xc4bf
movq %r12, %rbp
movq 0x23b8b(%rip), %r15     # 0x2ffd8
movslq (%r15), %rax
movq (%rbx,%rax,8), %rdi
movl $0x7, %esi
callq 0x12e21
movq %rax, %r12
movslq (%r15), %rax
movq (%rbx,%rax,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xbd08
xorl %r15d, %r15d
testl %eax, %eax
js 0xc4c9
movq %r12, %rdi
callq 0x12fbd
movq %rbp, %r12
testb %r13b, %r13b
je 0xc48f
callq 0xc21a
testb %r12b, %r12b
je 0xc4ad
callq 0xc2b6
jmp 0xc4ad
callq 0x3f9f
jmp 0xc4a7
callq 0x4057
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x4008
jmp 0xc485
callq 0x4038
movl $0x1, %r15d
jmp 0xc47a
nop
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: logMessageRaw
void logMessageRaw(int passLevel, char * passFormat, ...) {
	va_list argList;
	char message[2048];

	// Exit if lesser verbosity requested
	if (passLevel > bwa_verbose) return;

	// Prepare message
	va_start(argList, passFormat);
	vsnprintf(message, 2048, passFormat, argList);
	va_end(argList);

	fprintf(stderr, "%s", message);
}

// Assembly:
pushq %rbx
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xdfbb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x22e7e(%rip), %rax     # 0x30e40
cmpl %edi, (%rax)
jge 0xdfcf
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbx
retq
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x8e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x800, %esi            # imm = 0x800
movq %rbx, %rdi
movq %r10, %rdx
callq 0x3190
movq 0x21fba(%rip), %rax     # 0x2ffd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3340
jmp 0xdfc6
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_xopen_core
FILE *err_xopen_core(const char *func, const char *fn, const char *mode)
{
	FILE *fp = 0;
	char * rwMessage = "reading writing";

	if (strcmp(fn, "-") == 0)
		return (strstr(mode, "r"))? stdin : stdout;
	if ((fp = fopen(fn, mode)) == 0) {
		if (mode[0] == 'w') rwMessage += 8;
		err_fatal(func, "Failed to open file '%s' for %s : %s", fn, rwMessage, strerror(errno));
	}
	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x2d, (%rsi)
jne 0xe03c
cmpb $0x0, 0x1(%rbx)
je 0xe052
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3380
testq %rax, %rax
je 0xe079
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movl $0x72, %esi
callq 0x30f0
testq %rax, %rax
jne 0xe06d
movq 0x21f3d(%rip), %rax     # 0x2ffa8
jmp 0xe074
movq 0x21f54(%rip), %rax     # 0x2ffc8
movq (%rax), %rax
jmp 0xe04c
cmpb $0x77, (%r15)
leaq 0x19ff6(%rip), %rax     # 0x2807a
leaq 0x19fe7(%rip), %r15     # 0x28072
cmoveq %rax, %r15
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19fe0(%rip), %rsi     # 0x28082
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xe0b5
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fatal
void err_fatal(const char *header, const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	fprintf(stderr, "[%s] ", header);
	vfprintf(stderr, fmt, args);
	fprintf(stderr, "\n");
	va_end(args);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xe117
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x21e92(%rip), %r15     # 0x2ffd0
movq (%r15), %rdi
leaq 0x19f7d(%rip), %rsi     # 0x280c5
movq %r10, %rdx
xorl %eax, %eax
callq 0x3500
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3480
movq (%r15), %rsi
movl $0xa, %edi
callq 0x3410
movl $0x1, %edi
callq 0x33c0
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_xzopen_core
gzFile err_xzopen_core(const char *func, const char *fn, const char *mode)
{
	gzFile fp;
	if (strcmp(fn, "-") == 0) {
		fp = gzdopen(fileno((strstr(mode, "r"))? stdin : stdout), mode);
		/* According to zlib.h, this is the only reason gzdopen can fail */
		if (!fp) err_fatal(func, "Out of memory");
		return fp;
	}
	if ((fp = gzopen(fn, mode)) == 0) {
		err_fatal(func, "Failed to open file '%s' : %s", fn, errno ? strerror(errno) : "Out of memory");
	}
	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x2d, (%rsi)
jne 0xe1de
cmpb $0x0, 0x1(%r14)
je 0xe1f4
movq %r14, %rdi
movq %r15, %rsi
callq 0x3550
testq %rax, %rax
je 0xe23e
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movl $0x72, %esi
callq 0x30f0
testq %rax, %rax
jne 0xe20f
movq 0x21d9b(%rip), %rax     # 0x2ffa8
jmp 0xe216
movq 0x21db2(%rip), %rax     # 0x2ffc8
movq (%rax), %rdi
callq 0x3300
movl %eax, %edi
movq %r15, %rsi
callq 0x36f0
testq %rax, %rax
jne 0xe1ee
leaq 0x16e4b(%rip), %rsi     # 0x2507f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe0b5
callq 0x3050
movl (%rax), %edi
testl %edi, %edi
jne 0xe252
leaq 0x16e2f(%rip), %rcx     # 0x2507f
jmp 0xe25a
callq 0x30c0
movq %rax, %rcx
leaq 0x19e46(%rip), %rsi     # 0x280a7
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xe0b5
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fatal_core
void err_fatal_core(const char *header, const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	fprintf(stderr, "[%s] ", header);
	vfprintf(stderr, fmt, args);
	fprintf(stderr, " Abort!\n");
	va_end(args);
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xe2d0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x21cd9(%rip), %r15     # 0x2ffd0
movq (%r15), %rdi
leaq 0x19dc4(%rip), %rsi     # 0x280c5
movq %r10, %rdx
xorl %eax, %eax
callq 0x3500
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3480
movq (%r15), %rcx
leaq 0x19db8(%rip), %rdi     # 0x280db
movl $0x8, %esi
movl $0x1, %edx
callq 0x3790
callq 0x3150
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fwrite
size_t err_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
	size_t ret = fwrite(ptr, size, nmemb, stream);
	if (ret != nmemb) 
		_err_fatal_simple("fwrite", strerror(errno));
	return ret;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
callq 0x3790
cmpq %rbx, %rax
jne 0xe397
movq %rbx, %rax
popq %rbx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19d3a(%rip), %rdi     # 0x280e4
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fread_noeof
size_t err_fread_noeof(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
	size_t ret = fread(ptr, size, nmemb, stream);
	if (ret != nmemb)
	{
		_err_fatal_simple("fread", ferror(stream) ? strerror(errno) : "Unexpected end of file");
	}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x3570
cmpq %r14, %rax
jne 0xe3d1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x3750
testl %eax, %eax
jne 0xe3e6
leaq 0x19d0d(%rip), %rsi     # 0x280f1
jmp 0xe3f5
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x19cef(%rip), %rdi     # 0x280eb
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_gzread
int err_gzread(gzFile file, void *ptr, unsigned int len)
{
	int ret = gzread(file, ptr, len);

	if (ret < 0)
	{
		int errnum = 0;
		const char *msg = gzerror(file, &errnum);
		_err_fatal_simple("gzread", Z_ERRNO == errnum ? strerror(errno) : msg);
	}

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3730
testl %eax, %eax
js 0xe419
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3040
cmpl $-0x1, (%r14)
jne 0xe442
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19cbf(%rip), %rdi     # 0x28108
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fseek
int err_fseek(FILE *stream, long offset, int whence)
{
	int ret = fseek(stream, offset, whence);
	if (0 != ret)
	{
		_err_fatal_simple("fseek", strerror(errno));
	}
	return ret;
}

// Assembly:
pushq %rax
callq 0x3330
testl %eax, %eax
jne 0xe45f
xorl %eax, %eax
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19c9d(%rip), %rdi     # 0x2810f
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_ftell
long err_ftell(FILE *stream)
{
	long ret = ftell(stream);
	if (-1 == ret)
	{
		_err_fatal_simple("ftell", strerror(errno));
	}
	return ret;
}

// Assembly:
pushq %rax
callq 0x3030
cmpq $-0x1, %rax
je 0xe488
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19c7a(%rip), %rdi     # 0x28115
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_printf
int err_printf(const char *format, ...) 
{
	va_list arg;
	int done;
	va_start(arg, format);
	done = vfprintf(stdout, format, arg);
	int saveErrno = errno;
	va_end(arg);
	if (done < 0) _err_fatal_simple("vfprintf(stdout)", strerror(saveErrno));
	return done;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xe502
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x21a7f(%rip), %rax     # 0x2ffa8
movq (%rax), %rdi
movq %r10, %rsi
callq 0x3480
movl %eax, %ebx
callq 0x3050
testl %ebx, %ebx
js 0xe54a
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
movl (%rax), %edi
callq 0x30c0
leaq 0x19bc3(%rip), %rdi     # 0x2811b
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fprintf
int err_fprintf(FILE *stream, const char *format, ...) 
{
	va_list arg;
	int done;
	va_start(arg, format);
	done = vfprintf(stream, format, arg);
	int saveErrno = errno;
	va_end(arg);
	if (done < 0) _err_fatal_simple("vfprintf", strerror(saveErrno));
	return done;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xe5b8
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r10, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x3480
movl %eax, %ebx
callq 0x3050
testl %ebx, %ebx
js 0xe5f3
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
movl (%rax), %edi
callq 0x30c0
leaq 0x19b2b(%rip), %rdi     # 0x2812c
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fputc
int err_fputc(int c, FILE *stream)
{
	int ret = putc(c, stream);
	if (EOF == ret)
	{
		_err_fatal_simple("fputc", strerror(errno));
	}

	return ret;
}

// Assembly:
pushq %rax
callq 0x3770
cmpl $-0x1, %eax
je 0xe616
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19b0c(%rip), %rdi     # 0x28135
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fputs
int err_fputs(const char *s, FILE *stream)
{
	int ret = fputs(s, stream);
	if (EOF == ret)
	{
		_err_fatal_simple("fputs", strerror(errno));
	}

	return ret;
}

// Assembly:
pushq %rax
callq 0x3340
cmpl $-0x1, %eax
je 0xe63e
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19aea(%rip), %rdi     # 0x2813b
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_puts
int err_puts(const char *s)
{
	int ret = puts(s);
	if (EOF == ret)
	{
		_err_fatal_simple("puts", strerror(errno));
	}

	return ret;
}

// Assembly:
pushq %rax
callq 0x3590
cmpl $-0x1, %eax
je 0xe666
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19ac3(%rip), %rdi     # 0x2813c
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_fflush
int err_fflush(FILE *stream) 
{
    int ret = fflush(stream);
    if (ret != 0) _err_fatal_simple("fflush", strerror(errno));

#ifdef FSYNC_ON_FLUSH
	/* Calling fflush() ensures that all the data has made it to the
	   kernel buffers, but this may not be sufficient for remote filesystems
	   (e.g. NFS, lustre) as an error may still occur while the kernel
	   is copying the buffered data to the file server.  To be sure of
	   catching these errors, we need to call fsync() on the file
	   descriptor, but only if it is a regular file.  */
	{
		struct stat sbuf;
		if (0 != fstat(fileno(stream), &sbuf))
			_err_fatal_simple("fstat", strerror(errno));
		
		if (S_ISREG(sbuf.st_mode))
		{
			if (0 != fsync(fileno(stream)))
				_err_fatal_simple("fsync", strerror(errno));
		}
	}
#endif
    return ret;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
callq 0x3370
testl %eax, %eax
jne 0xe6d9
movq %rbx, %rdi
callq 0x3300
movq %rsp, %rsi
movl %eax, %edi
callq 0x3640
testl %eax, %eax
jne 0xe6ee
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0xe6ce
movq %rbx, %rdi
callq 0x3300
movl %eax, %edi
callq 0x3290
testl %eax, %eax
jne 0xe703
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19a55(%rip), %rdi     # 0x28141
jmp 0xe716
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19a47(%rip), %rdi     # 0x28148
jmp 0xe716
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19a38(%rip), %rdi     # 0x2814e
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/utils.c
// Function: err_gzclose
int err_gzclose(gzFile file)
{
	int ret = gzclose(file);
	if (Z_OK != ret)
	{
		_err_fatal_simple("gzclose", Z_ERRNO == ret ? strerror(errno) : zError(ret));
	}

	return ret;
}

// Assembly:
pushq %rax
callq 0x3660
testl %eax, %eax
jne 0xe755
xorl %eax, %eax
popq %rcx
retq
cmpl $-0x1, %eax
jne 0xe768
callq 0x3050
movl (%rax), %edi
callq 0x30c0
jmp 0xe76f
movl %eax, %edi
callq 0x3430
leaq 0x199e5(%rip), %rdi     # 0x2815b
movq %rax, %rsi
callq 0xe337
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/kstring.c
// Function: ksprintf
int ksprintf(kstring_t *s, const char *fmt, ...)
{
	va_list ap;
	int l;
	va_start(ap, fmt);
	l = vsnprintf(s->s + s->l, s->m - s->l, fmt, ap);
	va_end(ap);
	if (l + 1 > s->m - s->l) {
		s->m = s->l + l + 2;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
		va_start(ap, fmt);
		l = vsnprintf(s->s + s->l, s->m - s->l, fmt, ap);
	}
	va_end(ap);
	s->l += l;
	return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0xec1a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %r15, 0x10(%rcx)
leaq 0x100(%rsp), %r12
movq %r12, 0x8(%rcx)
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %r13, (%rcx)
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r14, %rdx
callq 0x3190
leal 0x1(%rax), %ecx
movslq %ecx, %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
subq %rcx, %rsi
cmpq %rdx, %rsi
jae 0xecf3
cltq
addq %rcx, %rax
incq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x194c1(%rip), %rdx     # 0x28178
leaq 0x194c4(%rip), %r8      # 0x28182
movl $0x13, %ecx
callq 0x2324c
movq %rax, 0x10(%rbx)
movq %rsp, %rcx
movq %r13, (%rcx)
movq %r12, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r14, %rdx
callq 0x3190
cltq
addq %rax, (%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: getOccPerWord
void getOccPerWord(uint32_t passWord, bwtint_t retOcc[VALUE_DOMAIN], int64_t passCount) {
	ubyte_t * bytePtr;
	int64_t byteIdx;

	bytePtr = (ubyte_t *) & passWord;

	// Check each byte of word for occurrence of value
	for (byteIdx = (passCount - 1); byteIdx >= 0; byteIdx--) {
		retOcc[bytePtr[byteIdx]]++;
	}
}

// Assembly:
movl %edi, -0x4(%rsp)
testq %rdx, %rdx
jle 0xed82
incq %rdx
movzbl -0x6(%rsp,%rdx), %eax
incq (%rsi,%rax,8)
decq %rdx
cmpq $0x1, %rdx
ja 0xed70
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_cal_sa
void bwt_cal_sa(bwt_t *bwt, int intv) {
	bwtint_t isa, sa, i; // S(isa) = sa
	int intv_round = intv;

	// Sanity checking
	kv_roundup32(intv_round);
	xassert(intv_round == intv, "SA sample interval is not a power of 2.");
	xassert(bwt->bwt, "bwt_t::bwt is not initialized.");

	// Initialize Suffix Array
	if (bwt->sa) free(bwt->sa);
	bwt->sa_intv = intv;
	bwt->n_sa = (bwt->seq_len + intv) / intv;
	bwt->sa = (bwtint_t*)calloc(bwt->n_sa, sizeof(bwtint_t));

	// Calculate Suffix Array Value
	isa = 0; sa = bwt->seq_len;
	for (i = 0; i < bwt->seq_len; ++i) {
		if (isa % intv == 0) bwt->sa[isa/intv] = sa;
		--sa;
		isa = bwt_invPsi(bwt, isa);
	}
	if (isa % intv == 0) bwt->sa[isa/intv] = sa;

	// SA[0] is currently set to sequence length - set to maximum value
	bwt->sa[0] = (bwtint_t)-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %esi, %r14d
leal -0x1(%r14), %eax
movl %eax, %ecx
sarl %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x10, %ecx
orl %eax, %ecx
incl %ecx
cmpl %esi, %ecx
jne 0xef38
movq %rdi, %rbx
cmpq $0x0, 0x120(%rdi)
je 0xef4b
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0xede9
callq 0x3390
movl %r14d, 0x128(%rbx)
movslq %r14d, %rcx
movq 0x110(%rbx), %rax
addq %rcx, %rax
xorl %r15d, %r15d
xorl %edx, %edx
movq %rcx, 0x8(%rsp)
divq %rcx
movq %rax, 0x130(%rbx)
leaq 0x193da(%rip), %rdx     # 0x281f2
leaq 0x19381(%rip), %r8      # 0x281a0
movl $0x8, %esi
movq %rax, %rdi
movl $0x4a, %ecx
callq 0x2319c
movq %rax, 0x138(%rbx)
movq 0x110(%rbx), %r13
testq %r13, %r13
je 0xef06
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rsp)
testq %rdx, %rdx
jne 0xee67
movq 0x138(%rbx), %rcx
movq %r13, (%rcx,%rax,8)
decq %r13
cmpq %r14, (%rbx)
movq %r14, %rcx
sbbq $0x0, %rcx
leaq 0x7f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
andq $-0x80, %rax
leaq (%rax,%rax), %rdx
addq 0x120(%rbx), %rdx
addq %rax, %rdx
movq %rcx, %rsi
subq %rax, %rsi
andq $-0x4, %rsi
movl 0x100(%rsi,%rdx), %eax
shll $0x3, %ecx
notb %cl
andb $0x18, %cl
shrl %cl, %eax
movzbl %al, %r15d
shll $0x3, %r15d
movq 0x8(%rbx,%r15), %r12
movabsq $0x2020202020202020, %rax # imm = 0x2020202020202020
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
callq 0xf07c
addq 0x10(%rsp,%r15), %r12
cmpq %r14, (%rbx)
movl $0x0, %r14d
cmovneq %r12, %r14
incq %rbp
cmpq 0x110(%rbx), %rbp
jb 0xee4d
movq 0x138(%rbx), %rcx
movq %r13, %r15
jmp 0xef0c
movq %rax, %rcx
xorl %r14d, %r14d
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rsp)
testq %rdx, %rdx
jne 0xef1f
movq %r15, (%rcx,%rax,8)
movq $-0x1, (%rcx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19261(%rip), %rdi     # 0x281a0
leaq 0x19265(%rip), %rsi     # 0x281ab
callq 0xe360
leaq 0x1924e(%rip), %rdi     # 0x281a0
leaq 0x1927a(%rip), %rsi     # 0x281d3
callq 0xe360
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_sa
bwtint_t bwt_sa(const bwt_t *bwt, bwtint_t k)
{
	bwtint_t sa = 0, mask = bwt->sa_intv - 1;
	while (k & mask) {
		++sa;
		k = bwt_invPsi(bwt, k);
	}
	/* without setting bwt->sa[0] = -1, the following line should be
	   changed to (sa + bwt->sa[k/bwt->sa_intv]) % (bwt->seq_len + 1) */
	return sa + bwt->sa[k/bwt->sa_intv];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r15
movslq 0x128(%rdi), %rax
leaq -0x1(%rax), %r13
testq %rsi, %r13
je 0xf020
movq (%r15), %rax
xorl %r14d, %r14d
incq %r14
cmpq %rbx, %rax
movq %rbx, %rcx
sbbq $0x0, %rcx
leaq 0x7f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
andq $-0x80, %rax
leaq (%rax,%rax), %rdx
addq 0x120(%r15), %rdx
addq %rax, %rdx
movq %rcx, %rsi
subq %rax, %rsi
andq $-0x4, %rsi
movl 0x100(%rsi,%rdx), %eax
shll $0x3, %ecx
notb %cl
andb $0x18, %cl
shrl %cl, %eax
movzbl %al, %ebp
shll $0x3, %ebp
movq 0x8(%r15,%rbp), %r12
movabsq $0x2020202020202020, %rax # imm = 0x2020202020202020
movq %rax, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %rsp, %rdx
callq 0xf07c
addq (%rsp,%rbp), %r12
movq (%r15), %rax
cmpq %rbx, %rax
movl $0x0, %ebx
cmovneq %r12, %rbx
testq %r13, %rbx
jne 0xef8f
movl 0x128(%r15), %eax
jmp 0xf023
xorl %r14d, %r14d
movq 0x138(%r15), %rcx
movslq %eax, %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %rsi
addq (%rcx,%rax,8), %r14
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_match_exact
int bwt_match_exact(const bwt_t *bwt, int len, const ubyte_t *str, bwtint_t *sa_begin, bwtint_t *sa_end)
{
	bwtint_t k, l, ok, ol;
	int i;
	k = 0; l = bwt->seq_len;
	for (i = len - 1; i >= 0; --i) {
		ubyte_t c = str[i];
		if (c > 3) return 0; // no match
		bwt_2occ(bwt, k - 1, l, c, &ok, &ol);
		k = bwt->L2[c] + ok + 1;
		l = bwt->L2[c] + ol;
		if (k > l) break; // no match
	}
	if (k > l) return 0; // no match
	if (sa_begin) *sa_begin = k;
	if (sa_end)   *sa_end = l;
	return l - k + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rdi, %r12
movq 0x110(%rdi), %rdx
movl %esi, %r14d
xorl %esi, %esi
leaq 0x20(%rsp), %r13
leaq 0x18(%rsp), %rbp
testl %r14d, %r14d
jle 0xf5e4
movzbl -0x1(%r15,%r14), %ebx
cmpq $0x3, %rbx
ja 0xf5e9
decq %rsi
movq %r12, %rdi
movl %ebx, %ecx
movq %r13, %r8
movq %rbp, %r9
callq 0xf264
movq 0x8(%r12,%rbx,8), %rdx
movq 0x20(%rsp), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
addq 0x18(%rsp), %rdx
decq %r14
cmpq %rdx, %rsi
jbe 0xf5a2
cmpq %rsi, %rdx
jae 0xf5ed
xorl %edx, %edx
jmp 0xf60b
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xf5fa
movq %rsi, (%rax)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf607
movq %rdx, (%rax)
subl %esi, %edx
incl %edx
movl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_extend
void bwt_extend(const bwt_t *bwt, const bwtintv_t *ik, bwtintv_t ok[VALUE_DOMAIN], int is_back)
{
	bwtint_t tk[VALUE_DOMAIN], tl[VALUE_DOMAIN];
	int i, copyIdx;

	// Accumulate occurrences
	bwt_2occ4(bwt, ik->x[!is_back] - 1, ik->x[!is_back] - 1 + ik->x[2], tk, tl);
	for (i = 0; i != VALUE_DOMAIN; ++i) {
		ok[i].x[!is_back] = bwt->L2[i] + 1 + tk[i];
		ok[i].x[2] = tl[i] - tk[i];
	}

	// Copy values returned from occurrence accumulators
	ok[VALUE_DOMAIN - 1].x[is_back] = ik->x[is_back] + (ik->x[!is_back] <= bwt->primary && ik->x[!is_back] + ik->x[2] - 1 >= bwt->primary);

	for (copyIdx = VALUE_DOMAIN - 2 ; copyIdx >= 0 ; copyIdx--) {
		ok[copyIdx].x[is_back] = ok[copyIdx + 1].x[is_back] + ok[copyIdx + 1].x[2];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
sete %bpl
movl %ebp, %r13d
shll $0x3, %r13d
movq (%rsi,%r13), %rsi
decq %rsi
movq 0x10(%r14), %r12
addq %rsi, %r12
leaq 0x110(%rsp), %rdx
callq 0xf07c
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xf07c
addq %rbx, %r13
xorl %eax, %eax
movq 0x8(%r15,%rax), %rcx
movq 0x110(%rsp,%rax), %rdx
addq %rdx, %rcx
incq %rcx
movq %rcx, (%r13,%rax,4)
movq 0x10(%rsp,%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rbx,%rax,4)
addq $0x8, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0xf717
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rcx
movq (%r14,%rbp,8), %rdx
movq (%r15), %rsi
cmpq %rsi, %rdx
jbe 0xf761
xorl %edx, %edx
jmp 0xf773
movq 0x10(%r14), %rdi
addq %rdx, %rdi
decq %rdi
xorl %edx, %edx
cmpq %rsi, %rdi
setae %dl
addq %rcx, %rdx
leaq (%rbx,%rax,8), %rax
addq $0x3e0, %rax            # imm = 0x3E0
movq %rdx, (%rax)
xorl %ecx, %ecx
movq 0x3f0(%rbx,%rcx), %rdx
addq (%rax,%rcx), %rdx
movq %rdx, -0x20(%rax,%rcx)
addq $-0x20, %rcx
cmpq $-0x3e0, %rcx           # imm = 0xFC20
jne 0xf785
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_reverse_intvs
static void bwt_reverse_intvs(bwtintv_v *p)
{
	if (p->n > 1) {
		int j;
		for (j = 0; j < p->n>>1; ++j) {
			bwtintv_t tmp = p->a[p->n - 1 - j];
			p->a[p->n - 1 - j] = p->a[j];
			p->a[j] = tmp;
		}
	}
}

// Assembly:
movq (%rdi), %rdx
cmpq $0x2, %rdx
jb 0xfe30
movq $-0x20, %rax
xorl %ecx, %ecx
xorl %esi, %esi
movq 0x10(%rdi), %r8
shlq $0x5, %rdx
addq %r8, %rdx
movups (%rax,%rdx), %xmm0
movups 0x10(%rax,%rdx), %xmm1
movaps %xmm1, -0x18(%rsp)
movaps %xmm0, -0x28(%rsp)
movups (%r8,%rcx), %xmm0
movups 0x10(%r8,%rcx), %xmm1
movups %xmm0, (%rax,%rdx)
movups %xmm1, 0x10(%rax,%rdx)
movq 0x10(%rdi), %rdx
movaps -0x28(%rsp), %xmm0
movaps -0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rdx,%rcx)
movups %xmm0, (%rdx,%rcx)
incq %rsi
movq (%rdi), %rdx
movq %rdx, %r8
shrq %r8
addq $-0x20, %rax
addq $0x20, %rcx
cmpq %rsi, %r8
ja 0xfdce
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_seed_strategy1
int bwt_seed_strategy1(const bwt_t *bwt, int len, const uint8_t *q, int x, int min_len, int max_intv, bwtintv_t *mem)
{
	int i, c;
	bwtintv_t ik, ok[VALUE_DOMAIN];

	memset(mem, 0, sizeof(bwtintv_t));
	if (q[x] >= VALUE_DEFINED) return x + 1;
	//if (q[x] > 3) return x + 1;
	bwt_set_intv(bwt, q[x], ik); // the initial interval of a single base
	for (i = x + 1; i < len; ++i) { // forward search
		if (q[i] < VALUE_DEFINED) { // an amino acid
		c = VALUE_DEFINED - 1 - q[i]; // complement of q[i]
		bwt_extend(bwt, &ik, ok, 0);
		if (ok[c].x[2] < max_intv && i - x >= min_len) {
			*mem = ok[c];
			mem->info = (uint64_t)x<<32 | (i + 1);
			return i + 1;
		}
		ik = ok[c];
		} else return i + 1;
	}
	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movl %ecx, %ebx
movq %rdi, %r15
movq 0x480(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movslq %ecx, %rdi
movzbl (%rdx,%rdi), %eax
cmpq $0x16, %rax
jb 0xfe84
incl %ebx
jmp 0xff96
movq %rdx, %r14
movq 0x8(%r15,%rax,8), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x10(%r15,%rax,8), %rdx
subq %rcx, %rdx
movq %rdx, 0x30(%rsp)
movl $0x15, %ecx
subl %eax, %ecx
shll $0x3, %ecx
movq 0x8(%r15,%rcx), %rax
incq %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x38(%rsp)
leal 0x1(%rbx), %eax
cmpl %esi, %eax
jge 0xff69
movslq %r9d, %rcx
movq %rcx, 0x18(%rsp)
movslq %eax, %r13
movslq %r8d, %rax
movq %rdi, 0x8(%rsp)
addq %rdi, %rax
movq %rax, 0x10(%rsp)
addl $0x2, %ebx
movl %esi, 0x4(%rsp)
movl %esi, %ebp
negl %ebp
movzbl (%r14,%r13), %eax
cmpq $0x15, %rax
ja 0xff96
movl $0x15, %r12d
subl %eax, %r12d
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
callq 0xf6ba
shll $0x5, %r12d
leaq (%rsp,%r12), %rax
addq $0x40, %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x10(%rax)
jae 0xff3d
cmpq 0x10(%rsp), %r13
jge 0xff6d
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
incq %r13
leal (%rbx,%rbp), %eax
incl %eax
movl %ebx, %ecx
incl %ecx
movl %ecx, %ebx
cmpl $0x1, %eax
jne 0xfef3
movl 0x4(%rsp), %eax
movl %eax, %ebx
jmp 0xff96
movl %esi, %ebx
jmp 0xff96
movq 0x10(%rax), %rcx
movq 0x480(%rsp), %rdx
movq %rcx, 0x10(%rdx)
movups (%rax), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rsp), %rcx
shlq $0x20, %rcx
movslq %ebx, %rax
orq %rcx, %rax
movq %rax, 0x18(%rdx)
movl %ebx, %eax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_dump_bwt
void bwt_dump_bwt(const char *fn, const bwt_t *bwt) {
	FILE *fp;

	fp = xopen(fn, "wb");

	// Format: <primary><L2[1::]><bwt>
	// Sizes: 8, Domain * 8, BWTSize * 4
	err_fwrite(&bwt->primary, sizeof(bwtint_t), 1, fp);
	err_fwrite(bwt->L2+1, sizeof(bwtint_t), VALUE_DOMAIN, fp);
	err_fwrite(bwt->bwt, sizeof(uint32_t), bwt->bwt_size, fp);
	err_fflush(fp);
	err_fclose(fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x18248(%rip), %rdi     # 0x28203
leaq 0x179ba(%rip), %rdx     # 0x2797c
callq 0xe023
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0xe384
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe384
movq 0x118(%r14), %rdx
movq 0x120(%r14), %rdi
movl $0x4, %esi
movq %rbx, %rcx
callq 0xe384
movq %rbx, %rdi
callq 0xe681
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe71e
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_dump_sa
void bwt_dump_sa(const char *fn, const bwt_t *bwt) {
	FILE *fp;

	fp = xopen(fn, "wb");

	// Format: <primary><L2[1::]><SA Interval><Seq Length><SA[1::]>
	err_fwrite(&bwt->primary, sizeof(bwtint_t), 1, fp);
	err_fwrite(bwt->L2+1, sizeof(bwtint_t), VALUE_DOMAIN, fp);
	err_fwrite(&bwt->sa_intv, sizeof(bwtint_t), 1, fp);
	err_fwrite(&bwt->seq_len, sizeof(bwtint_t), 1, fp);
	err_fwrite(bwt->sa + 1, sizeof(bwtint_t), bwt->n_sa - 1, fp);
	err_fflush(fp);
	err_fclose(fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x181d8(%rip), %rdi     # 0x28210
leaq 0x1793d(%rip), %rdx     # 0x2797c
callq 0xe023
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0xe384
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe384
leaq 0x128(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe384
leaq 0x110(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe384
movq 0x130(%r14), %rdx
movq 0x138(%r14), %rdi
addq $0x8, %rdi
decq %rdx
movl $0x8, %esi
movq %rbx, %rcx
callq 0xe384
movq %rbx, %rdi
callq 0xe681
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe71e
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_restore_sa
void bwt_restore_sa(const char *fn, bwt_t *bwt) {
	char skipped[256];
	FILE *fp;
	bwtint_t primary;

	fp = xopen(fn, "rb");

	// Format: <primary><L2[1::]><SA Interval><Seq Length><SA[1::]>
	err_fread_noeof(&primary, sizeof(bwtint_t), 1, fp);
	xassert(primary == bwt->primary, "SA-BWT inconsistency: primary is not the same.");
	err_fread_noeof(skipped, sizeof(bwtint_t), VALUE_DOMAIN, fp); // skip
	err_fread_noeof(&bwt->sa_intv, sizeof(bwtint_t), 1, fp);
	err_fread_noeof(&primary, sizeof(bwtint_t), 1, fp);
	xassert(primary == bwt->seq_len, "SA-BWT inconsistency: seq_len is not the same.");

	bwt->n_sa = (bwt->seq_len + bwt->sa_intv) / bwt->sa_intv;
	bwt->sa = (bwtint_t*)calloc(bwt->n_sa, sizeof(bwtint_t));
	bwt->sa[0] = -1;

	fread_fix(fp, sizeof(bwtint_t) * (bwt->n_sa - 1), bwt->sa + 1);
	err_fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x18126(%rip), %rdi     # 0x2821c
leaq 0x1899b(%rip), %rdx     # 0x28a98
callq 0xe023
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0xe3b2
movq (%r15), %rax
cmpq (%r14), %rax
jne 0x101f9
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe3b2
leaq 0x128(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe3b2
leaq 0x8(%rsp), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0xe3b2
movq (%r15), %rax
cmpq 0x110(%r14), %rax
jne 0x1020c
movslq 0x128(%r14), %rcx
addq %rcx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x130(%r14)
leaq 0x18050(%rip), %rdx     # 0x281f2
leaq 0x18073(%rip), %r8      # 0x2821c
movl $0x8, %esi
movq %rax, %rdi
movl $0x1ea, %ecx            # imm = 0x1EA
callq 0x2319c
movq %rax, 0x138(%r14)
movq $-0x1, (%rax)
movq 0x130(%r14), %rcx
leaq -0x8(,%rcx,8), %rsi
leaq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x1021f
movq %rbx, %rdi
callq 0xe71e
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1801c(%rip), %rdi     # 0x2821c
leaq 0x18024(%rip), %rsi     # 0x2822b
callq 0xe360
leaq 0x18009(%rip), %rdi     # 0x2821c
leaq 0x18040(%rip), %rsi     # 0x2825a
callq 0xe360
// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/bwt.c
// Function: fread_fix
static bwtint_t fread_fix(FILE *fp, bwtint_t size, void *a)
{ // Mac/Darwin has a bug when reading data longer than 2GB. This function fixes this issue by reading data in small chunks
	const int bufsize = 0x1000000; // 16M block
	bwtint_t offset = 0;
	while (size) {
		int x = bufsize < size? bufsize : size;
		if ((x = err_fread_noeof(a + offset, 1, x, fp)) == 0) break;
		size -= x; offset += x;
	}
	return offset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x1000000, %r13d       # imm = 0x1000000
testq %r14, %r14
je 0x10268
cmpq %r13, %r14
movl $0x1000000, %edx        # imm = 0x1000000
cmovbq %r14, %rdx
leaq (%rbx,%r12), %rdi
movl $0x1, %esi
movq %r15, %rcx
callq 0xe3b2
cltq
subq %rax, %r14
addq %rax, %r12
testl %eax, %eax
jne 0x1023a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq