LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x25ae0(%rip), %rax     # 0x30e68
testq %rax, %rax
jle 0xb3ba
movq 0x25ac4(%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 0xb39f
jmp 0xb3bf
xorl %ecx, %ecx
xorl %r8d, %r8d
testb $0x8, 0x48(%rdi)
je 0xb3f0
movslq 0x25aa0(%rip), %rax     # 0x30e6c
testq %rax, %rax
jle 0xb3f0
movq 0x25a88(%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 0xb3de
testl %r8d, %r8d
je 0xb428
cvtsi2ss %ecx, %xmm0
cvtsi2ss %r8d, %xmm1
divss %xmm1, %xmm0
mulss 0x1be5a(%rip), %xmm0    # 0x27264
cvtss2sd %xmm0, %xmm0
leaq 0x1c3cd(%rip), %rdi     # 0x277e2
leaq 0x1c40d(%rip), %rdx     # 0x27829
movl $0x3, %esi
movb $0x1, %al
jmp 0xdbeb
leaq 0x1c3b3(%rip), %rdi     # 0x277e2
leaq 0x1c3c0(%rip), %rdx     # 0x277f6
movl $0x3, %esi
xorl %eax, %eax
jmp 0xdbeb
// File: /workspace/github_c_makefile_star2_O1/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 0xbe55
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0xbe55
movq %r14, %rdi
callq 0x3100
addq %r14, %rax
decq %rax
movq %rax, %rbx
cmpq %r14, %rax
jb 0xbdd7
leaq -0x1(%rbx), %rax
cmpb $0x2f, (%rbx)
jne 0xbdc6
leaq 0x1bb16(%rip), %rdi     # 0x278f4
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xbe58
xorl %r14d, %r14d
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 0xbe58
incq %rbx
addq $0x4, %rax
xorl %r15d, %r15d
movq %rax, %r12
leaq 0x8(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34d0
testl %eax, %eax
je 0xbe4f
movq %r14, %rdi
callq 0x3100
addq %r14, %rax
incq %rax
incl %r15d
cmpw %r15w, %bp
jne 0xbe1f
movl %ebp, %r15d
cmpw %bp, %r15w
jne 0xbe6b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %r15
movabsq $0x2d7864696177622f, %rax # imm = 0x2D7864696177622F
movq %rsp, %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x36b0
xorl %r14d, %r14d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xbe58
xorl %edi, %edi
movq %r15, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x36c0
movq %rax, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x31b0
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12c63
movl $0x1, 0x18(%r14)
jmp 0xbe58
// File: /workspace/github_c_makefile_star2_O1/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 0xbf9d
movq %rdi, %r15
cmpb $0x0, (%rdi)
je 0xbf9d
movq %r15, %rdi
callq 0x3100
addq %r15, %rax
decq %rax
movq %rax, %r14
cmpq %r15, %rax
jb 0xbf2c
leaq -0x1(%r14), %rax
cmpb $0x2f, (%r14)
jne 0xbf1a
leaq 0x1b9c1(%rip), %rdi     # 0x278f4
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xbf9d
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 0xbf9d
movq %rax, %r15
incq %r14
addq $0x4, %r15
leaq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x34d0
testl %eax, %eax
je 0xbf98
movq %r15, %rdi
callq 0x3100
addq %rax, %r15
addq $0x9, %r15
decw %bp
jne 0xbf72
jmp 0xbf9d
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b938(%rip), %rdi     # 0x278f4
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc030
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 0xc035
movq %rax, %r14
movq %rax, %r13
addq $0x4, %r13
xorl %ebx, %ebx
leaq 0x1b965(%rip), %r15     # 0x27965
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 0xc002
jmp 0xc035
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_O1/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 0x1b896(%rip), %rdi     # 0x278f4
xorl %esi, %esi
xorl %edx, %edx
callq 0x3650
testl %eax, %eax
js 0xc0fe
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 0xc0e1
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 0xc0aa
movl $0x10000, %esi          # imm = 0x10000
movq %r14, %rdi
callq 0x3170
leaq 0x1b7ff(%rip), %rdi     # 0x278f4
callq 0x3740
xorl %eax, %eax
jmp 0xc103
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_O1/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 0x1b841(%rip), %rdx     # 0x2796d
callq 0x3090
xorl %r13d, %r13d
testl %eax, %eax
js 0xc191
leaq 0x1b82e(%rip), %r15     # 0x2796d
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpl $0x6c, %eax
je 0xc168
cmpl $0x66, %eax
je 0xc15c
cmpl $0x64, %eax
jne 0xc16e
movl $0x1, %r13d
jmp 0xc16e
movq 0x23e55(%rip), %rax     # 0x2ffb8
movq (%rax), %r14
jmp 0xc16e
movl $0x1, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3090
testl %eax, %eax
jns 0xc145
testl %r12d, %r12d
setne %al
testl %r13d, %r13d
setne %r12b
movl %eax, %r13d
jmp 0xc197
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x23e3a(%rip), %rax     # 0x2ffd8
movslq (%rax), %rax
cmpl %ebp, %eax
setne %dl
movl %r13d, %ecx
orb %r12b, %cl
orb %cl, %dl
testb $0x1, %dl
je 0xc22b
cmpl %ebp, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0xc232
xorl %r15d, %r15d
cmpl %ebp, %eax
jge 0xc215
movq (%rbx,%rax,8), %rdi
callq 0xbeee
testl %eax, %eax
jne 0xc24f
movq %r12, %rbp
movq 0x23dfb(%rip), %r15     # 0x2ffd8
movslq (%r15), %rax
movq (%rbx,%rax,8), %rdi
movl $0x7, %esi
callq 0x12a5d
movq %rax, %r12
movslq (%r15), %rax
movq (%rbx,%rax,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xbaa4
xorl %r15d, %r15d
testl %eax, %eax
js 0xc259
movq %r12, %rdi
callq 0x12bf9
movq %rbp, %r12
testb %r13b, %r13b
je 0xc21f
callq 0xbfaa
testb %r12b, %r12b
je 0xc23d
callq 0xc046
jmp 0xc23d
callq 0x3f9f
jmp 0xc237
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 0xc215
callq 0x4038
movl $0x1, %r15d
jmp 0xc20a
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xdd26
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 0x23113(%rip), %rax     # 0x30e40
cmpl %edi, (%rax)
jge 0xdd3a
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 0x2224f(%rip), %rax     # 0x2ffd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3340
jmp 0xdd31
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x1aabb(%rip), %rsi     # 0x2885e
movq %rbx, %rdi
callq 0x34d0
testl %eax, %eax
je 0xddfb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3380
testq %rax, %rax
jne 0xde20
cmpb $0x77, (%r15)
leaq 0x1a230(%rip), %rax     # 0x27ffa
leaq 0x1a221(%rip), %r15     # 0x27ff2
cmoveq %rax, %r15
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x1a21a(%rip), %rsi     # 0x28002
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xde26
movq %r15, %rdi
movl $0x72, %esi
callq 0x30f0
testq %rax, %rax
jne 0xde16
movq 0x22194(%rip), %rax     # 0x2ffa8
jmp 0xde1d
movq 0x221ab(%rip), %rax     # 0x2ffc8
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xde88
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 0x22121(%rip), %r15     # 0x2ffd0
movq (%r15), %rdi
leaq 0x1a18c(%rip), %rsi     # 0x28045
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_O1/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
leaq 0x1a914(%rip), %rsi     # 0x2885e
movq %r14, %rdi
callq 0x34d0
testl %eax, %eax
je 0xdf7a
movq %r14, %rdi
movq %r15, %rsi
callq 0x3550
testq %rax, %rax
jne 0xdfb3
callq 0x3050
movl (%rax), %edi
testl %edi, %edi
jne 0xdfca
leaq 0x17107(%rip), %rcx     # 0x2507f
jmp 0xdfd2
movq %r15, %rdi
movl $0x72, %esi
callq 0x30f0
testq %rax, %rax
jne 0xdf95
movq 0x22015(%rip), %rax     # 0x2ffa8
jmp 0xdf9c
movq 0x2202c(%rip), %rax     # 0x2ffc8
movq (%rax), %rdi
callq 0x3300
movl %eax, %edi
movq %r15, %rsi
callq 0x36f0
testq %rax, %rax
je 0xdfb9
popq %rbx
popq %r14
popq %r15
retq
leaq 0x170bf(%rip), %rsi     # 0x2507f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde26
callq 0x30c0
movq %rax, %rcx
leaq 0x1a04e(%rip), %rsi     # 0x28027
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xde26
// File: /workspace/github_c_makefile_star2_O1/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 0xe048
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 0x21f61(%rip), %r15     # 0x2ffd0
movq (%r15), %rdi
leaq 0x19fcc(%rip), %rsi     # 0x28045
movq %r10, %rdx
xorl %eax, %eax
callq 0x3500
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3480
movq (%r15), %rcx
leaq 0x19fc0(%rip), %rdi     # 0x2805b
movl $0x8, %esi
movl $0x1, %edx
callq 0x3790
callq 0x3150
// File: /workspace/github_c_makefile_star2_O1/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 0xe10c
popq %rbx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19f45(%rip), %rdi     # 0x28064
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe143
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x3750
testl %eax, %eax
jne 0xe158
leaq 0x19f1b(%rip), %rsi     # 0x28071
jmp 0xe167
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x19efd(%rip), %rdi     # 0x2806b
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe18b
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 0xe1b4
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19ecd(%rip), %rdi     # 0x28088
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe1d1
xorl %eax, %eax
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19eab(%rip), %rdi     # 0x2808f
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe1fa
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19e88(%rip), %rdi     # 0x28095
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe274
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 0x21d0d(%rip), %rax     # 0x2ffa8
movq (%rax), %rdi
movq %r10, %rsi
callq 0x3480
movl %eax, %ebx
callq 0x3050
testl %ebx, %ebx
js 0xe2bc
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
movl (%rax), %edi
callq 0x30c0
leaq 0x19dd1(%rip), %rdi     # 0x2809b
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe32a
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 0xe365
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
movl (%rax), %edi
callq 0x30c0
leaq 0x19d39(%rip), %rdi     # 0x280ac
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe388
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19d1a(%rip), %rdi     # 0x280b5
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe3b0
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19cf8(%rip), %rdi     # 0x280bb
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe3d8
popq %rcx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19cd1(%rip), %rdi     # 0x280bc
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe44b
movq %rbx, %rdi
callq 0x3300
movq %rsp, %rsi
movl %eax, %edi
callq 0x3640
testl %eax, %eax
jne 0xe460
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0xe440
movq %rbx, %rdi
callq 0x3300
movl %eax, %edi
callq 0x3290
testl %eax, %eax
jne 0xe475
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19c63(%rip), %rdi     # 0x280c1
jmp 0xe488
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19c55(%rip), %rdi     # 0x280c8
jmp 0xe488
callq 0x3050
movl (%rax), %edi
callq 0x30c0
leaq 0x19c46(%rip), %rdi     # 0x280ce
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe4c7
xorl %eax, %eax
popq %rcx
retq
cmpl $-0x1, %eax
jne 0xe4da
callq 0x3050
movl (%rax), %edi
callq 0x30c0
jmp 0xe4e1
movl %eax, %edi
callq 0x3430
leaq 0x19bf3(%rip), %rdi     # 0x280db
movq %rax, %rsi
callq 0xe0af
// File: /workspace/github_c_makefile_star2_O1/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 0xe982
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 0xea5b
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 0x196d9(%rip), %rdx     # 0x280f8
leaq 0x196dc(%rip), %r8      # 0x28102
movl $0x13, %ecx
callq 0x22d64
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_O1/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 0xeaea
incq %rdx
movzbl -0x6(%rsp,%rdx), %eax
incq (%rsi,%rax,8)
decq %rdx
cmpq $0x1, %rdx
jg 0xead8
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xec9c
movq %rdi, %rbx
cmpq $0x0, 0x120(%rdi)
je 0xecaf
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0xeb51
callq 0x3390
movl %r14d, 0x128(%rbx)
movslq %r14d, %rcx
movq 0x110(%rbx), %rax
addq %rcx, %rax
xorl %r14d, %r14d
xorl %edx, %edx
movq %rcx, 0x8(%rsp)
divq %rcx
movq %rax, 0x130(%rbx)
leaq 0x195dd(%rip), %rdx     # 0x2815d
leaq 0x19584(%rip), %r8      # 0x2810b
movl $0x8, %esi
movq %rax, %rdi
movl $0x4a, %ecx
callq 0x22cb4
movq %rax, 0x138(%rbx)
movq 0x110(%rbx), %r13
testq %r13, %r13
je 0xec62
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rsp)
testq %rdx, %rdx
jne 0xebcf
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 0xedd1
addq 0x10(%rsp,%r15), %r12
cmpq %r14, (%rbx)
movl $0x0, %r14d
cmovneq %r12, %r14
incq %rbp
cmpq 0x110(%rbx), %rbp
jb 0xebb5
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rsp)
testq %rdx, %rdx
jne 0xec7c
movq 0x138(%rbx), %rcx
movq %r13, (%rcx,%rax,8)
movq 0x138(%rbx), %rax
movq $-0x1, (%rax)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19468(%rip), %rdi     # 0x2810b
leaq 0x1946c(%rip), %rsi     # 0x28116
callq 0xe0d8
leaq 0x19455(%rip), %rdi     # 0x2810b
leaq 0x19481(%rip), %rsi     # 0x2813e
callq 0xe0d8
// File: /workspace/github_c_makefile_star2_O1/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), %r13
decq %r13
xorl %r14d, %r14d
testq %rsi, %r13
je 0xed74
incq %r14
cmpq %rbx, (%r15)
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 0xedd1
addq (%rsp,%rbp), %r12
cmpq %rbx, (%r15)
movl $0x0, %ebx
cmovneq %r12, %rbx
testq %r13, %rbx
jne 0xecef
movq 0x138(%r15), %rcx
movslq 0x128(%r15), %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_O1/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 0xf29f
movzbl -0x1(%r15,%r14), %ebx
movl $0x1, %eax
cmpq $0x3, %rbx
ja 0xf293
decq %rsi
movq %r12, %rdi
movl %ebx, %ecx
movq %r13, %r8
movq %rbp, %r9
callq 0xefc4
movq 0x8(%r12,%rbx,8), %rdx
movq 0x20(%rsp), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
addq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
seta %al
addl %eax, %eax
decq %r14
testl %eax, %eax
je 0xf24a
cmpl $0x2, %eax
jne 0xf2c8
xorl %eax, %eax
cmpq %rsi, %rdx
jb 0xf2ca
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xf2b3
movq %rsi, (%rax)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf2c0
movq %rdx, (%rax)
subl %esi, %edx
incl %edx
movl %edx, %eax
jmp 0xf2ca
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_match_exact_alt
int bwt_match_exact_alt(const bwt_t *bwt, int len, const ubyte_t *str, bwtint_t *k0, bwtint_t *l0)
{
	int i;
	bwtint_t k, l, ok, ol;
	k = *k0; l = *l0;
	for (i = len - 1; i >= 0; --i) {
		ubyte_t c = str[i];
		if (c > 3) return 0; // there is an N here. 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) return 0; // no match
	}
	*k0 = k; *l0 = l;
	return l - k + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, %eax
movq %rdi, %r12
movq %rcx, 0x8(%rsp)
movq (%rcx), %rsi
movq %r8, 0x10(%rsp)
movq (%r8), %rdx
movl %eax, %r13d
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
testl %r13d, %r13d
jle 0xf359
movzbl -0x1(%r15,%r13), %r14d
cmpq $0x3, %r14
jbe 0xf31e
xorl %eax, %eax
jmp 0xf350
decq %rsi
movq %r12, %rdi
movl %r14d, %ecx
leaq 0x20(%rsp), %r8
movq %rbp, %r9
callq 0xefc4
movq 0x8(%r12,%r14,8), %rdx
movq 0x20(%rsp), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
addq 0x18(%rsp), %rdx
cmpq %rdx, %rsi
setbe %al
decq %r13
testb %al, %al
jne 0xf309
jmp 0xf36f
movq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq 0x10(%rsp), %rax
movq %rdx, (%rax)
subl %esi, %edx
incl %edx
movl %edx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xedd1
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xedd1
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 0xf3dd
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rcx
movq (%r14,%rbp,8), %rdx
movq (%r15), %rsi
cmpq %rsi, %rdx
jbe 0xf427
xorl %edx, %edx
jmp 0xf439
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 0xf44b
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x2, (%rdi)
jb 0xfafd
movq (%rdi), %rdx
cmpq $0x2, %rdx
jb 0xfafd
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 0xfa9b
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfb51
incl %ebx
jmp 0xfc61
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
subq %rax, %rcx
movq 0x8(%r15,%rcx,8), %rax
incq %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x38(%rsp)
leal 0x1(%rbx), %eax
cmpl %esi, %eax
jge 0xfc34
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 0xfc61
movl $0x15, %r12d
subl %eax, %r12d
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
callq 0xf380
shlq $0x5, %r12
leaq (%rsp,%r12), %rax
addq $0x40, %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x10(%rax)
jae 0xfc08
cmpq 0x10(%rsp), %r13
jge 0xfc38
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 0xfbbe
movl 0x4(%rsp), %eax
movl %eax, %ebx
jmp 0xfc61
movl %esi, %ebx
jmp 0xfc61
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movq 0x480(%rsp), %rcx
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rdx
shlq $0x20, %rdx
movslq %ebx, %rax
orq %rdx, %rax
movq %rax, 0x18(%rcx)
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_O1/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 0x184e8(%rip), %rdi     # 0x2816e
leaq 0x17c6f(%rip), %rdx     # 0x278fc
callq 0xdd8e
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0xe0fc
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe0fc
movq 0x118(%r14), %rdx
movq 0x120(%r14), %rdi
movl $0x4, %esi
movq %rbx, %rcx
callq 0xe0fc
movq %rbx, %rdi
callq 0xe3f3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe490
// File: /workspace/github_c_makefile_star2_O1/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 0x18478(%rip), %rdi     # 0x2817b
leaq 0x17bf2(%rip), %rdx     # 0x278fc
callq 0xdd8e
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0xe0fc
leaq 0x10(%r14), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe0fc
leaq 0x128(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe0fc
leaq 0x110(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe0fc
movq 0x130(%r14), %rdx
movq 0x138(%r14), %rdi
addq $0x8, %rdi
decq %rdx
movl $0x8, %esi
movq %rbx, %rcx
callq 0xe0fc
movq %rbx, %rdi
callq 0xe3f3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe490
// File: /workspace/github_c_makefile_star2_O1/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 0x183c6(%rip), %rdi     # 0x28187
leaq 0x18be0(%rip), %rdx     # 0x289a8
callq 0xdd8e
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0xe127
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xfec4
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0xe127
leaq 0x128(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xe127
leaq 0x8(%rsp), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0xe127
movq 0x110(%r14), %rax
cmpq %rax, (%r15)
jne 0xfed7
movslq 0x128(%r14), %rcx
addq %rcx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x130(%r14)
leaq 0x182f0(%rip), %rdx     # 0x2815d
leaq 0x18313(%rip), %r8      # 0x28187
movl $0x8, %esi
movq %rax, %rdi
movl $0x1ea, %ecx            # imm = 0x1EA
callq 0x22cb4
movq %rax, 0x138(%r14)
movq $-0x1, (%rax)
movq 0x130(%r14), %rcx
leaq -0x8(,%rcx,8), %rsi
leaq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0xfeea
movq %rbx, %rdi
callq 0xe490
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
leaq 0x182bc(%rip), %rdi     # 0x28187
leaq 0x182c4(%rip), %rsi     # 0x28196
callq 0xe0d8
leaq 0x182a9(%rip), %rdi     # 0x28187
leaq 0x182e0(%rip), %rsi     # 0x281c5
callq 0xe0d8