LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: cleanUniprotReference
int cleanUniprotReference(int passReference, const char * passBase) {
	char * tempName;
	int indexed;
	IndexHeader newHeader;
	FILE * proHandle;

	logMessage(__func__, LOG_LEVEL_MESSAGE, "Cleaning UniProt reference...\n");

	// Check if reference has already been indexed
	tempName = malloc(strlen(passBase) + 5);
	sprintf(tempName, "%s.ann", passBase);
	indexed = (access(tempName, F_OK) != -1);

	// Begin reference-specific preparation
	switch (passReference) {
	case UNIPROT_REFERENCE_UNIREF90:
		cleanUniprotReferenceUniref(passBase, 0);
		if (indexed) cleanUniprotReferenceUniref(tempName, 1);
	}

	// If indexed, also fix protein header
	if (indexed) {
		sprintf(tempName, "%s.pro", passBase);
		proHandle = err_xopen_core(__func__, tempName, "w");

		newHeader.multiFrame = 1;
		newHeader.nucleotide = 0;
		newHeader.referenceType = passReference;
		writeIndexHeader(proHandle, newHeader);

		fclose(proHandle);
	}

	free(tempName);

	return indexed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2c498(%rip), %rdi     # 0x3932e
leaq 0x2c4a7(%rip), %rdx     # 0x39344
xorl %eax, %eax
movl %eax, -0x44(%rbp)
movb %al, -0x45(%rbp)
movl $0x3, %esi
callq 0x12510
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x5, %rdi
callq 0x3450
movq %rax, %rcx
movb -0x45(%rbp), %al
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2c486(%rip), %rsi     # 0x39363
callq 0x3070
movl -0x44(%rbp), %esi
movq -0x18(%rbp), %rdi
callq 0x3610
subl $-0x1, %eax
setne %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
subl $0x2, %eax
jne 0xcf25
jmp 0xcf04
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xcfc0
cmpl $0x0, -0x1c(%rbp)
je 0xcf23
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xcfc0
jmp 0xcf25
cmpl $0x0, -0x1c(%rbp)
je 0xcf9f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2a4c1(%rip), %rsi     # 0x373fb
movb $0x0, %al
callq 0x3070
movq -0x18(%rbp), %rsi
leaq 0x2c3e2(%rip), %rdi     # 0x3932e
leaq 0x2e3c5(%rip), %rdx     # 0x3b318
callq 0x12740
movq %rax, -0x40(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x4bf0
movq -0x40(%rbp), %rdi
callq 0x32e0
movq -0x18(%rbp), %rdi
callq 0x3380
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: downloadUniprotReference
const char * downloadUniprotReference(int passReference, const char * passProxy) {
	CURL * curlHandle;
	CURLcode curlResult;
	FILE * fileHandle;
	const char * retFile;

	curlHandle = curl_easy_init();
	fileHandle = err_xopen_core(__func__, downloadNames[passReference], "w");
	retFile = downloadNames[passReference];

	curl_easy_setopt(curlHandle, CURLOPT_URL, downloadURLs[passReference]);
	curl_easy_setopt(curlHandle, CURLOPT_WRITEDATA, fileHandle);
    if (passProxy) curl_easy_setopt(curlHandle, CURLOPT_PROXY, passProxy);

	logMessage(__func__, LOG_LEVEL_MESSAGE, "Downloading %s...\n", downloadURLs[passReference]);
	curlResult = curl_easy_perform(curlHandle);

	if (curlResult != CURLE_OK) {
		logMessage(__func__, LOG_LEVEL_ERROR, "%s\n", curl_easy_strerror(curlResult));
		unlink(downloadNames[passReference]);
		retFile = "";
	}

	curl_easy_cleanup(curlHandle);
	fclose(fileHandle);

	return retFile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3420
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x336bd(%rip), %rax     # 0x40af0
movq (%rax,%rcx,8), %rsi
leaq 0x2bf67(%rip), %rdi     # 0x393a5
leaq 0x2ded3(%rip), %rdx     # 0x3b318
callq 0x12740
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x33697(%rip), %rax     # 0x40af0
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x4(%rbp), %rcx
leaq 0x336a0(%rip), %rax     # 0x40b10
movq (%rax,%rcx,8), %rdx
movl $0x2712, %esi           # imm = 0x2712
movb $0x0, %al
callq 0x3340
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x2711, %esi           # imm = 0x2711
movb $0x0, %al
callq 0x3340
cmpq $0x0, -0x10(%rbp)
je 0xd4af
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2714, %esi           # imm = 0x2714
movb $0x0, %al
callq 0x3340
movslq -0x4(%rbp), %rcx
leaq 0x33656(%rip), %rax     # 0x40b10
movq (%rax,%rcx,8), %rcx
leaq 0x2bee0(%rip), %rdi     # 0x393a5
movl $0x3, %esi
leaq 0x2beed(%rip), %rdx     # 0x393be
movb $0x0, %al
callq 0x12510
movq -0x18(%rbp), %rdi
callq 0x3440
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xd52e
movl -0x1c(%rbp), %edi
callq 0x3500
movq %rax, %rcx
leaq 0x2bea9(%rip), %rdi     # 0x393a5
movl $0x1, %esi
leaq 0x2baae(%rip), %rdx     # 0x38fb6
movb $0x0, %al
callq 0x12510
movslq -0x4(%rbp), %rcx
leaq 0x335d6(%rip), %rax     # 0x40af0
movq (%rax,%rcx,8), %rdi
callq 0x3100
leaq 0x2cff4(%rip), %rax     # 0x3a51e
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33e0
movq -0x28(%rbp), %rdi
callq 0x32e0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: initCURLBuffer
void initCURLBuffer(CURLBuffer * passBuffer, int passCapacity) {
	passBuffer->buffer = calloc(1, passCapacity);
	passBuffer->capacity = passCapacity;
	passBuffer->size = 0;
	passBuffer->buffer[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rsi
movl $0x1, %edi
callq 0x31a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: receiveUniprotOutput
size_t receiveUniprotOutput(void * passString, size_t passSize, size_t passNum, void * retStream) {
	CURLBuffer * currentBuffer;

	currentBuffer = (CURLBuffer *) retStream;

	// Grow receive buffer if addition is greater than capacity
	if (currentBuffer->size + (int)(passSize * passNum) >= currentBuffer->capacity) {
		currentBuffer->buffer = realloc(currentBuffer->buffer, currentBuffer->capacity + UNIPROT_BUFFER_GROW);
		currentBuffer->capacity += UNIPROT_BUFFER_GROW;
	}

	// Concatenate results
	memcpy(currentBuffer->buffer + currentBuffer->size, passString, (int) (passSize * passNum));
	currentBuffer->size += (int) (passSize * passNum);
	currentBuffer->buffer[currentBuffer->size] = 0;

	return (size_t)(passSize * passNum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addl %ecx, %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0xd610
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x2faf080, %eax        # imm = 0x2FAF080
movslq %eax, %rsi
callq 0x35f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x2faf080, %ecx        # imm = 0x2FAF080
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movslq %eax, %rdx
callq 0x3250
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x3379e(%rip), %eax     # 0x40e58
jge 0xd712
movq 0x33785(%rip), %rax     # 0x40e48
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x3376a(%rip), %rax     # 0x40e48
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq 0x33755(%rip), %rcx     # 0x40e48
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addl 0xc(%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd6b1
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd776
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x3372b(%rip), %eax     # 0x40e5c
jge 0xd774
movq 0x33716(%rip), %rax     # 0x40e50
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x336fb(%rip), %rax     # 0x40e50
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd728
jmp 0xd776
cmpl $0x0, -0x14(%rbp)
jne 0xd798
leaq 0x2bf2f(%rip), %rdi     # 0x396b2
movl $0x3, %esi
leaq 0x2bf37(%rip), %rdx     # 0x396c6
movb $0x0, %al
callq 0x12510
jmp 0xd7d7
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
cvtsi2ssl -0x10(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movss 0x2b997(%rip), %xmm1    # 0x3914c
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2beee(%rip), %rdi     # 0x396b2
movl $0x3, %esi
leaq 0x2bf29(%rip), %rdx     # 0x396f9
movb $0x1, %al
callq 0x12510
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeabf
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xeacb
movl $0x0, -0x4(%rbp)
jmp 0xebe9
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x49(%rbp)
jb 0xeb0d
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xeb16
jmp 0xeb26
jmp 0xeb18
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xeaee
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
leaq 0x2ac9b(%rip), %rdi     # 0x397d4
xorl %edx, %edx
movl %edx, %esi
callq 0x3630
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0xeb56
movl $0x0, -0x4(%rbp)
jmp 0xebe9
movl -0x14(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x10000, %esi          # imm = 0x10000
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x36a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movw $0x0, -0x22(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movzwl -0x22(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xebe2
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x40(%rbp), %rsi
callq 0x34b0
cmpl $0x0, %eax
jne 0xebbf
movl $0x1, -0x4(%rbp)
jmp 0xebe9
movq -0x30(%rbp), %rdi
callq 0x30f0
addq $0x9, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0xeb91
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x2abc5(%rip), %rdi     # 0x397d4
xorl %edx, %edx
movl %edx, %esi
callq 0x3630
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0xec2c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeccd
movl -0x8(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x10000, %esi          # imm = 0x10000
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x36a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movw $0x0, -0x12(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xecc6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0x2aba9(%rip), %rdi     # 0x39845
movb $0x0, %al
callq 0x3060
movq -0x20(%rbp), %rdi
callq 0x30f0
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0xec67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
leaq 0x2aae2(%rip), %rdi     # 0x397d4
xorl %edx, %edx
movl %edx, %esi
callq 0x3630
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0xed0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xede2
movl -0x8(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x10000, %esi          # imm = 0x10000
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x36a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movw $0x0, -0x12(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xedc1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1038(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
leaq -0x1030(%rbp), %rdi
leaq 0x2aab0(%rip), %rsi     # 0x39831
callq 0x32b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3690
leaq -0x1030(%rbp), %rdi
callq 0x3720
movq -0x20(%rbp), %rdi
callq 0x30f0
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0xed4a
movq -0x28(%rbp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x3160
leaq 0x2a9fe(%rip), %rdi     # 0x397d4
callq 0x3720
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/main.c
// Function: renderMainUsage
int renderMainUsage() {
	fprintf(stderr, "\n");
	fprintf(stderr, "Program: PALADIN (Protein Alignment and Detection Interface)\n\n");
	fprintf(stderr, "Usage:   paladin <command> [options]\n\n");
	fprintf(stderr, "Command: index         index NT or AA sequences in FASTA format\n");
	fprintf(stderr, "         prepare       download and index protein reference\n");
	fprintf(stderr, "         align         align single end read sequences\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "         shm           manage indices in shared memory\n");
	fprintf(stderr, "         fa2pac        convert FASTA to PAC format\n");
	fprintf(stderr, "         pac2bwt       generate BWT from PAC\n");
	fprintf(stderr, "         bwtupdate     update .bwt to the new format\n");
	fprintf(stderr, "         bwt2sa        generate SA from BWT and Occ\n\n");
	fprintf(stderr, "         version       version and contact information\n");
	fprintf(stderr, "\n");
	fprintf(stderr,
"Note: To use PALADIN, first index the reference using the 'index' or 'prepare' command.\n"
"      Then align your reads using the 'align' command.\n\n");

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30bcd(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2819c(%rip), %rsi     # 0x375b1
movb $0x0, %al
callq 0x34e0
movq 0x30bb5(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a65d(%rip), %rsi     # 0x39a8a
movb $0x0, %al
callq 0x34e0
movq 0x30b9d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a684(%rip), %rsi     # 0x39ac9
movb $0x0, %al
callq 0x34e0
movq 0x30b85(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a693(%rip), %rsi     # 0x39af0
movb $0x0, %al
callq 0x34e0
movq 0x30b6d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a6bc(%rip), %rsi     # 0x39b31
movb $0x0, %al
callq 0x34e0
movq 0x30b55(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a6e1(%rip), %rsi     # 0x39b6e
movb $0x0, %al
callq 0x34e0
movq 0x30b3d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2810c(%rip), %rsi     # 0x375b1
movb $0x0, %al
callq 0x34e0
movq 0x30b25(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a6e9(%rip), %rsi     # 0x39ba6
movb $0x0, %al
callq 0x34e0
movq 0x30b0d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a709(%rip), %rsi     # 0x39bde
movb $0x0, %al
callq 0x34e0
movq 0x30af5(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a725(%rip), %rsi     # 0x39c12
movb $0x0, %al
callq 0x34e0
movq 0x30add(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a73b(%rip), %rsi     # 0x39c40
movb $0x0, %al
callq 0x34e0
movq 0x30ac5(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a759(%rip), %rsi     # 0x39c76
movb $0x0, %al
callq 0x34e0
movq 0x30aad(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a777(%rip), %rsi     # 0x39cac
movb $0x0, %al
callq 0x34e0
movq 0x30a95(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x28064(%rip), %rsi     # 0x375b1
movb $0x0, %al
callq 0x34e0
movq 0x30a7d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a77f(%rip), %rsi     # 0x39ce4
movb $0x0, %al
callq 0x34e0
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/main.c
// Function: renderVersion
int renderVersion() {
	fprintf(stderr, "\n");
	fprintf(stderr, "Program: PALADIN (Protein Alignment and Detection Interface)\n");

	fprintf(stderr, "Version: %s\n", PACKAGE_VERSION);
	fprintf(stderr, "Contact: Toni Westbrook (UNH) <anthony.westbrook@unh.edu>\n");
	fprintf(stderr, "Based on: BWA by Heng Li <lh3@sanger.ac.uk>\n\n");

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30a4d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2801c(%rip), %rsi     # 0x375b1
movb $0x0, %al
callq 0x34e0
movq 0x30a35(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a7c8(%rip), %rsi     # 0x39d75
movb $0x0, %al
callq 0x34e0
movq 0x30a1d(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a484(%rip), %rsi     # 0x39a49
leaq 0x27a7f(%rip), %rdx     # 0x3704b
movb $0x0, %al
callq 0x34e0
movq 0x309fe(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a7cf(%rip), %rsi     # 0x39db3
movb $0x0, %al
callq 0x34e0
movq 0x309e6(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x2a7f2(%rip), %rsi     # 0x39dee
movb $0x0, %al
callq 0x34e0
movl $0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/utils.c
// Function: logMessage
KSEQ_INIT2(, gzFile, err_gzread)

/*************
 * Reporting *
 *************/

void logMessage(const char * passFunction, int passLevel, char * passFormat, ...) {
	va_list argList;
	char message[2048];
	char prefix;

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

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

	switch (passLevel) {
		case LOG_LEVEL_ERROR: prefix = 'E'; break;
		case LOG_LEVEL_WARNING: prefix = 'W'; break;
		case LOG_LEVEL_MESSAGE: prefix = 'M'; break;
		case LOG_LEVEL_DEBUG: prefix = 'D'; break;
		default: prefix = 'U'; break;
	}

	fprintf(stderr, "[%c::%s] %s", prefix, passFunction, message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x900, %rsp            # imm = 0x900
testb %al, %al
je 0x12557
movaps %xmm0, -0x8c0(%rbp)
movaps %xmm1, -0x8b0(%rbp)
movaps %xmm2, -0x8a0(%rbp)
movaps %xmm3, -0x890(%rbp)
movaps %xmm4, -0x880(%rbp)
movaps %xmm5, -0x870(%rbp)
movaps %xmm6, -0x860(%rbp)
movaps %xmm7, -0x850(%rbp)
movq %r9, -0x8c8(%rbp)
movq %r8, -0x8d0(%rbp)
movq %rcx, -0x8d8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2e8af(%rip), %rcx     # 0x40e30
cmpl (%rcx), %eax
jle 0x1258a
jmp 0x12643
leaq -0x8f0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x830(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
leaq -0x30(%rbp), %rcx
callq 0x3180
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x8f8(%rbp)
subl $0x3, %eax
ja 0x12612
movq -0x8f8(%rbp), %rax
leaq 0x2787b(%rip), %rcx     # 0x39e60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x45, -0x831(%rbp)
jmp 0x12619
movb $0x57, -0x831(%rbp)
jmp 0x12619
movb $0x4d, -0x831(%rbp)
jmp 0x12619
movb $0x44, -0x831(%rbp)
jmp 0x12619
movb $0x55, -0x831(%rbp)
movq 0x2d9b8(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movsbl -0x831(%rbp), %edx
movq -0x8(%rbp), %rcx
leaq -0x830(%rbp), %r8
leaq 0x27892(%rip), %rsi     # 0x39ece
movb $0x0, %al
callq 0x34e0
addq $0x900, %rsp            # imm = 0x900
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x8e0, %rsp            # imm = 0x8E0
testb %al, %al
je 0x12697
movaps %xmm0, -0x8b0(%rbp)
movaps %xmm1, -0x8a0(%rbp)
movaps %xmm2, -0x890(%rbp)
movaps %xmm3, -0x880(%rbp)
movaps %xmm4, -0x870(%rbp)
movaps %xmm5, -0x860(%rbp)
movaps %xmm6, -0x850(%rbp)
movaps %xmm7, -0x840(%rbp)
movq %r9, -0x8b8(%rbp)
movq %r8, -0x8c0(%rbp)
movq %rcx, -0x8c8(%rbp)
movq %rdx, -0x8d0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
leaq 0x2e76c(%rip), %rcx     # 0x40e30
cmpl (%rcx), %eax
jle 0x126ca
jmp 0x1272a
leaq -0x30(%rbp), %rax
leaq -0x8e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x830(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x800, %esi            # imm = 0x800
callq 0x3180
leaq -0x30(%rbp), %rax
movq 0x2d8c6(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq -0x830(%rbp), %rdx
leaq 0x27807(%rip), %rsi     # 0x39f2a
movb $0x0, %al
callq 0x34e0
addq $0x8e0, %rsp            # imm = 0x8E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x27777(%rip), %rax     # 0x39eda
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x27fd4(%rip), %rsi     # 0x3a746
callq 0x34b0
cmpl $0x0, %eax
jne 0x127ba
movq -0x20(%rbp), %rdi
leaq 0x2657b(%rip), %rsi     # 0x38d02
callq 0x3080
cmpq $0x0, %rax
je 0x127a2
movq 0x2d837(%rip), %rax     # 0x3ffd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x127b0
movq 0x2d807(%rip), %rax     # 0x3ffb0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12832
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3370
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1282a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
jne 0x127e9
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %rax, %r8
leaq 0x276c7(%rip), %rsi     # 0x39eea
movb $0x0, %al
callq 0x12840
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x12878
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x2d711(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x27658(%rip), %rsi     # 0x39f2d
movb $0x0, %al
callq 0x34e0
movq 0x2d6f5(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3460
movq 0x2d6de(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x24cad(%rip), %rsi     # 0x375b1
movb $0x0, %al
callq 0x34e0
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x33b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x27d97(%rip), %rsi     # 0x3a746
callq 0x34b0
cmpl $0x0, %eax
jne 0x12a28
movq -0x20(%rbp), %rdi
leaq 0x2633e(%rip), %rsi     # 0x38d02
callq 0x3080
cmpq $0x0, %rax
je 0x129df
movq 0x2d5fa(%rip), %rax     # 0x3ffd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x129ed
movq 0x2d5ca(%rip), %rax     # 0x3ffb0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x32f0
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x36d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12a1e
movq -0x10(%rbp), %rdi
leaq 0x24668(%rip), %rsi     # 0x3707f
movb $0x0, %al
callq 0x12840
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12a9a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3530
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x12a92
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3050
cmpl $0x0, (%rax)
je 0x12a6b
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, -0x48(%rbp)
jmp 0x12a78
leaq 0x2460d(%rip), %rax     # 0x3707f
movq %rax, -0x48(%rbp)
jmp 0x12a78
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rcx
leaq 0x27484(%rip), %rsi     # 0x39f0f
movb $0x0, %al
callq 0x12840
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x12ae8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x2d4a1(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x273e8(%rip), %rsi     # 0x39f2d
movb $0x0, %al
callq 0x34e0
movq 0x2d485(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3460
movq 0x2d46e(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x273cf(%rip), %rsi     # 0x39f43
movb $0x0, %al
callq 0x34e0
leaq -0x30(%rbp), %rax
callq 0x3140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3770
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x12c66
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x272eb(%rip), %rdi     # 0x39f4c
callq 0x12b90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3550
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x12ce8
movq -0x20(%rbp), %rdi
callq 0x3730
cmpl $0x0, %eax
je 0x12ccb
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, -0x30(%rbp)
jmp 0x12cd8
leaq 0x27287(%rip), %rax     # 0x39f59
movq %rax, -0x30(%rbp)
jmp 0x12cd8
movq -0x30(%rbp), %rsi
leaq 0x27270(%rip), %rdi     # 0x39f53
callq 0x12b90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3710
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x12d78
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3040
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x1c(%rbp), %eax
jne 0x12d60
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, -0x30(%rbp)
jmp 0x12d68
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq 0x271fd(%rip), %rdi     # 0x39f70
callq 0x12b90
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3320
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
je 0x12dd8
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x271a4(%rip), %rdi     # 0x39f77
callq 0x12b90
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq -0x10(%rbp), %rax
jne 0x12e31
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x27151(%rip), %rdi     # 0x39f7d
callq 0x12b90
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x12e78
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2d0e6(%rip), %rax     # 0x3ffb0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3460
movl %eax, -0x24(%rbp)
callq 0x3050
movl (%rax), %eax
movl %eax, -0x28(%rbp)
leaq -0x20(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
jge 0x12f08
movl -0x28(%rbp), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x27080(%rip), %rdi     # 0x39f83
callq 0x12b90
movl -0x24(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x12f5b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3460
movl %eax, -0x34(%rbp)
callq 0x3050
movl (%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jge 0x12fe2
movl -0x38(%rbp), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26fb7(%rip), %rdi     # 0x39f94
callq 0x12b90
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3750
movl %eax, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %eax
jne 0x13033
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26f6f(%rip), %rdi     # 0x39f9d
callq 0x12b90
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3330
movl %eax, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %eax
jne 0x13085
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26f23(%rip), %rdi     # 0x39fa3
callq 0x12b90
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3570
movl %eax, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x130cd
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26edc(%rip), %rdi     # 0x39fa4
callq 0x12b90
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3360
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1311c
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26e92(%rip), %rdi     # 0x39fa9
callq 0x12b90
movq -0x8(%rbp), %rdi
callq 0x32f0
movl %eax, %edi
leaq -0xa0(%rbp), %rsi
callq 0x3620
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x13156
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26e5f(%rip), %rdi     # 0x39fb0
callq 0x12b90
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x1319d
movq -0x8(%rbp), %rdi
callq 0x32f0
movl %eax, %edi
callq 0x3280
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1319b
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x26e20(%rip), %rdi     # 0x39fb6
callq 0x12b90
jmp 0x1319d
movl -0xc(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3640
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
je 0x13257
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x1323b
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, -0x18(%rbp)
jmp 0x13247
movl -0xc(%rbp), %edi
callq 0x3410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x26d71(%rip), %rdi     # 0x39fc3
callq 0x12b90
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwt.c
// Function: unpackBWTValue
ubyte_t unpackBWTValue(const bwt_t * passBWT, int64_t passSeqIdx) {
	int64_t packShift;
	uint32_t * bwtValueStart;

	packShift = (8 * (sizeof(uint32_t) - 1)) - (8 * (passSeqIdx % sizeof(uint32_t)));

	bwtValueStart = getOccInterval(passBWT, passSeqIdx);
	bwtValueStart += sizeof(bwtint_t) / sizeof(uint32_t) * VALUE_DOMAIN;

	return (bwtValueStart[(passSeqIdx % 128) / sizeof(uint32_t)] >> packShift) & 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
andq $0x3, %rcx
shlq $0x3, %rcx
movl $0x18, %eax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13be0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x80, %ecx
cqto
idivq %rcx
movq -0x28(%rbp), %rax
shrq $0x2, %rdx
movl (%rax,%rdx,4), %eax
movq -0x18(%rbp), %rcx
shrl %cl, %eax
andl $0xff, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x13d04
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13cd3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwt.c
// Function: bwt_invPsi
static inline bwtint_t bwt_invPsi(const bwt_t *bwt, bwtint_t k) {
	bwtint_t x = k - (k > bwt->primary);

	x = unpackBWTValue(bwt, x);
	x = bwt->L2[x] + bwt_occ(bwt, k, x);

	return k == bwt->primary? 0 : x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
cmpq (%rdx), %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13c30
movzbl %al, %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movzbl %al, %edx
callq 0x14080
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x13fde
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x13fe6
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
subl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x14048
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f50
movq %rax, -0x10(%rbp)
jmp 0x1401b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq 0x128(%rdx), %rsi
xorl %edx, %edx
divq %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
addq (%rcx,%rdx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwt.c
// Function: _occ_aux
static inline int64_t __occ_aux(uint64_t y, int c) {
	unsigned char * bytePtr;
	int64_t count, byteIdx;

	bytePtr = (unsigned char *) &y;
	count = 0;

	for (byteIdx = 0 ; byteIdx < sizeof(y) ; byteIdx++) {
		if (bytePtr[byteIdx] == c) count++;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x14697
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0xc(%rbp), %eax
jne 0x14687
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14689
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14663
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)