LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/TerminalIo.cpp
// Function: t2::TerminalIoInit()
void TerminalIoInit(void)
{
	int i;
	for (i = 0; i < kLineBufCount; ++i)
	{
		s_FreeLinebufs[i] = &s_Linebufs[i];
		s_Linebufs[i].m_Data = &s_BufferData[i][0];
		s_Linebufs[i].m_Data = &s_BufferData[i][0];
	}
	s_FreeLinebufCount = kLineBufCount;
	s_QueuedLinebufCount = 0;


  MutexInit(&s_LineLock);
  CondInit(&s_CanPrint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x22184
movslq -0x4(%rbp), %rax
leaq 0xd5d0(%rip), %rdx      # 0x2f6e0
imulq $0x18, %rax, %rax
addq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0xdbbe(%rip), %rax      # 0x2fce0
movq %rdx, (%rax,%rcx,8)
movslq -0x4(%rbp), %rax
leaq 0xddaf(%rip), %rcx      # 0x2fee0
shlq $0xd, %rax
addq %rax, %rcx
movslq -0x4(%rbp), %rdx
leaq 0xd59d(%rip), %rax      # 0x2f6e0
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movslq -0x4(%rbp), %rax
leaq 0xdd87(%rip), %rcx      # 0x2fee0
shlq $0xd, %rax
addq %rax, %rcx
movslq -0x4(%rbp), %rdx
leaq 0xd575(%rip), %rax      # 0x2f6e0
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x220ff
movl $0x40, 0x8dd52(%rip)    # 0xafee0
movl $0x0, 0x8dd4c(%rip)     # 0xafee4
leaq 0x8dd49(%rip), %rdi     # 0xafee8
callq 0x6810
leaq 0x8dd65(%rip), %rdi     # 0xaff10
callq 0x6850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/TerminalIo.cpp
// Function: t2::AllocLineBuffer()
static LineBuffer* AllocLineBuffer(void)
{
	assert(s_FreeLinebufCount + s_QueuedLinebufCount == kLineBufCount);

	if (s_FreeLinebufCount) {
		return s_FreeLinebufs[--s_FreeLinebufCount];
	}
	else
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x8db02(%rip), %eax     # 0xafee0
addl 0x8db00(%rip), %eax     # 0xafee4
cmpl $0x40, %eax
jne 0x223eb
jmp 0x2240a
leaq 0x3385(%rip), %rdi      # 0x25777
leaq 0x3331(%rip), %rsi      # 0x2572a
movl $0x98, %edx
leaq 0x33ad(%rip), %rcx      # 0x257b2
callq 0x3230
cmpl $0x0, 0x8dacf(%rip)     # 0xafee0
je 0x22436
movl 0x8dac7(%rip), %eax     # 0xafee0
addl $-0x1, %eax
movl %eax, 0x8dabe(%rip)     # 0xafee0
movslq %eax, %rcx
leaq 0xd8b4(%rip), %rax      # 0x2fce0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x2243e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/TerminalIo.cpp
// Function: t2::TerminalIoJobExit(int)
void TerminalIoJobExit(int job_id)
{
	/* Find any queued buffers for this job and flush them. */
	MutexLock(&s_LineLock);

	TTY_PRINTF(("exit job %d\n", job_id));

	if (job_id != s_PrintingJobIndex) {
		/* Wait until we can grab the TTY */
		while (-1 != s_PrintingJobIndex) {
			CondWait(&s_CanPrint, &s_LineLock);
		}
	}

	s_PrintingJobIndex = job_id;

	FlushOutputQueue(job_id);

	s_PrintingJobIndex = -1;

	MutexUnlock(&s_LineLock);

	CondBroadcast(&s_CanPrint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x8d8b6(%rip), %rdi     # 0xafee8
callq 0x69b0
jmp 0x22639
movl -0x4(%rbp), %eax
cmpl 0xcd26(%rip), %eax      # 0x2f368
je 0x2266a
jmp 0x22646
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0xcd17(%rip), %eax      # 0x2f368
je 0x22668
leaq 0x8d8b6(%rip), %rdi     # 0xaff10
leaq 0x8d887(%rip), %rsi     # 0xafee8
callq 0x6b80
jmp 0x22646
jmp 0x2266a
movl -0x4(%rbp), %eax
movl %eax, 0xccf5(%rip)      # 0x2f368
movl -0x4(%rbp), %edi
callq 0x22450
movl $0xffffffff, 0xcce3(%rip) # imm = 0xFFFFFFFF
leaq 0x8d85c(%rip), %rdi     # 0xafee8
callq 0x69f0
leaq 0x8d878(%rip), %rdi     # 0xaff10
callq 0x6a30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/TerminalIo.cpp
// Function: t2::TerminalIoPrintf(int, int, char const*, ...)
void TerminalIoPrintf(int job_id, int sort_key, const char *format, ...)
{
	char buffer[16384];
	va_list a;
	va_start(a, format);
	vsnprintf(buffer, sizeof(buffer), format, a);
	buffer[sizeof(buffer)-1] = '\0';
	TerminalIoEmit(job_id, 0, sort_key, buffer, (int) strlen(buffer));
	va_end(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40f0, %rsp           # imm = 0x40F0
testb %al, %al
je 0x226f7
movaps %xmm0, -0x40b0(%rbp)
movaps %xmm1, -0x40a0(%rbp)
movaps %xmm2, -0x4090(%rbp)
movaps %xmm3, -0x4080(%rbp)
movaps %xmm4, -0x4070(%rbp)
movaps %xmm5, -0x4060(%rbp)
movaps %xmm6, -0x4050(%rbp)
movaps %xmm7, -0x4040(%rbp)
movq %r9, -0x40b8(%rbp)
movq %r8, -0x40c0(%rbp)
movq %rcx, -0x40c8(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x40e0(%rbp), %rax
movq %rax, -0x4020(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x4028(%rbp)
movl $0x30, -0x402c(%rbp)
movl $0x18, -0x4030(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x4010(%rbp), %rdi
movq %rdi, -0x40e8(%rbp)
movl $0x4000, %esi           # imm = 0x4000
leaq -0x4030(%rbp), %rcx
callq 0x3210
movq -0x40e8(%rbp), %rdi
movb $0x0, -0x11(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40f0(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x40ec(%rbp)
callq 0x3150
movl -0x40f0(%rbp), %edi
movl -0x40ec(%rbp), %edx
movq -0x40e8(%rbp), %rcx
movl %eax, %r8d
xorl %esi, %esi
callq 0x221e0
addq $0x40f0, %rsp           # imm = 0x40F0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/is.c
// Function: is_sa
int64_t is_sa(const ubyte_t *T, int64_t *SA, int64_t n)
{
	if ((T == NULL) || (SA == NULL) || (n < 0)) return -1;
	SA[0] = n;
	if (n <= 1) {
		if (n == 1) SA[1] = 0;
		return 0;
	}
	return sais_main(T, SA+1, 0, n, 256, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38b9
cmpq $0x0, -0x18(%rbp)
je 0x38b9
cmpq $0x0, -0x20(%rbp)
jge 0x38c3
movq $-0x1, -0x8(%rbp)
jmp 0x391b
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x1, -0x20(%rbp)
jg 0x38f2
cmpq $0x1, -0x20(%rbp)
jne 0x38e8
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x391b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
movl $0x100, %r8d            # imm = 0x100
movl $0x1, %r9d
callq 0x3930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/is.c
// Function: is_bwt
int64_t is_bwt(ubyte_t *T, int64_t n)
{
	int64_t *SA, i, primary = 0;
	SA = (int64_t *)calloc(n+1, sizeof(int64_t));

	if (is_sa(T, SA, n)) return -1;

	for (i = 0; i <= n; ++i) {
		if (SA[i] == 0) primary = i;
		else SA[i] = T[SA[i] - 1];
	}
	for (i = 0; i < primary; ++i) T[i] = SA[i];
	for (; i < n; ++i) T[i] = SA[i + 1];
	free(SA);
	return primary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x8, %esi
leaq 0x32b08(%rip), %rdx     # 0x37004
movl $0xd4, %ecx
leaq 0x32b01(%rip), %r8      # 0x37009
callq 0x31bf0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3890
cmpq $0x0, %rax
je 0x4535
movq $-0x1, -0x8(%rbp)
jmp 0x4614
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x4596
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4560
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4586
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4588
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x453d
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x45cf
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x459e
jmp 0x45d1
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4603
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x45d1
movq -0x20(%rbp), %rdi
callq 0x3380
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/is.c
// Function: getBuckets
static void getBuckets(const int64_t *C, int64_t *B, int64_t k, int64_t end)
{
	int64_t i, sum = 0;
	if (end) {
		for (i = 0; i < k; ++i) {
			sum += C[i];
			B[i] = sum;
		}
	} else {
		for (i = 0; i < k; ++i) {
			sum += C[i];
			B[i] = sum - C[i];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4739
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4737
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x46fb
jmp 0x478b
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x4789
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4741
jmp 0x478b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: writeIndexHeader
void writeIndexHeader(FILE * passFilePtr, IndexHeader passHeader) {
	fprintf(passFilePtr, ">VER=%s:NT=%d:MF=%d:RT=%d\n", PACKAGE_VERSION,
														passHeader.nucleotide,
														passHeader.multiFrame,
														passHeader.referenceType);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
leaq 0x3241b(%rip), %rsi     # 0x37030
leaq 0x3242f(%rip), %rdx     # 0x3704b
movb $0x0, %al
callq 0x34e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: getIndexHeader
IndexHeader getIndexHeader(char * passFile) {
	FILE * filePtr;
	IndexHeader retHeader;

	// Open file and read header information
	filePtr = fopen(passFile, "r");

    if (filePtr == NULL) {
    	logMessage(__func__, LOG_LEVEL_ERROR, "Failed to open file '%s' : %s\n", passFile, errno ? strerror(errno) : "Out of memory");
    	exit(EXIT_FAILURE);
    }

	if (fscanf(filePtr, ">VER=%d.%d.%d:NT=%d:MF=%d:RT=%d", &(retHeader.version[0]),
														   &(retHeader.version[1]),
														   &(retHeader.version[2]),
														   &(retHeader.nucleotide),
														   &(retHeader.multiFrame),
														   &(retHeader.referenceType)) != 6) {
		logMessage(__func__, LOG_LEVEL_ERROR, "Failed to parse file '%s'\n", passFile);
    	exit(EXIT_FAILURE);
	}
	fclose(filePtr);

	return retHeader;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x340b3(%rip), %rsi     # 0x38d02
callq 0x3370
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cbc
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3050
cmpl $0x0, (%rax)
je 0x4c83
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, -0x30(%rbp)
jmp 0x4c90
leaq 0x323f5(%rip), %rax     # 0x3707f
movq %rax, -0x30(%rbp)
jmp 0x4c90
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0x323b2(%rip), %rdi     # 0x37051
movl $0x1, %esi
leaq 0x323b5(%rip), %rdx     # 0x37060
movb $0x0, %al
callq 0x12510
movl $0x1, %edi
callq 0x33b0
movq -0x20(%rbp), %r9
movq -0x10(%rbp), %rdi
movq %r9, %rdx
addq $0xc, %rdx
movq %r9, %rcx
addq $0xc, %rcx
addq $0x4, %rcx
movq %r9, %r8
addq $0xc, %r8
addq $0x8, %r8
movq %r9, %r10
addq $0x4, %r10
movq %r9, %rax
addq $0x8, %rax
leaq 0x32397(%rip), %rsi     # 0x3708d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x3700
cmpl $0x6, %eax
je 0x4d33
movq -0x8(%rbp), %rcx
leaq 0x3233b(%rip), %rdi     # 0x37051
movl $0x1, %esi
leaq 0x3238b(%rip), %rdx     # 0x370ad
movb $0x0, %al
callq 0x12510
movl $0x1, %edi
callq 0x33b0
movq -0x10(%rbp), %rdi
callq 0x32e0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: getIndexCompatible
int getIndexCompatible(IndexHeader passHeader) {
	// Check if index newer than current version
	while (1) {
		if (passHeader.version[0] < PACKAGE_VERSION_MAJOR) break;
		if (passHeader.version[0] > PACKAGE_VERSION_MAJOR) return INDEX_COMPATBILITY_FUTURE;
		if (passHeader.version[1] < PACKAGE_VERSION_MINOR) break;
		if (passHeader.version[1] > PACKAGE_VERSION_MINOR) return INDEX_COMPATBILITY_FUTURE;
		if (passHeader.version[2] < PACKAGE_VERSION_REV) break;
		if (passHeader.version[2] > PACKAGE_VERSION_REV) return INDEX_COMPATBILITY_FUTURE;
		break;
	}

	// Check if reference new enough to be supported (1.1.0 for current version)
	while (1) {
		if (passHeader.version[0] < 1) return INDEX_COMPATIBILITY_NONE;
		if (passHeader.version[0] > 1) break;
		if (passHeader.version[1] < 1) return INDEX_COMPATIBILITY_NONE;
		if (passHeader.version[1] > 1) break;
		if (passHeader.version[2] < 0) return INDEX_COMPATIBILITY_NONE;
		if (passHeader.version[2] > 0) break;
		break;
	}

	return INDEX_COMPATIBLITY_FULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jge 0x4d68
jmp 0x4dc1
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jle 0x4d7e
movl $0x2, -0x4(%rbp)
jmp 0x4e29
movq -0x10(%rbp), %rax
cmpl $0x6, 0x10(%rax)
jge 0x4d8a
jmp 0x4dc1
movq -0x10(%rbp), %rax
cmpl $0x6, 0x10(%rax)
jle 0x4da0
movl $0x2, -0x4(%rbp)
jmp 0x4e29
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x4dac
jmp 0x4dc1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4dbf
movl $0x2, -0x4(%rbp)
jmp 0x4e29
jmp 0x4dc1
jmp 0x4dc3
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jge 0x4dd6
movl $0x0, -0x4(%rbp)
jmp 0x4e29
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jle 0x4de2
jmp 0x4e22
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jge 0x4df5
movl $0x0, -0x4(%rbp)
jmp 0x4e29
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x4e01
jmp 0x4e22
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x4e14
movl $0x0, -0x4(%rbp)
jmp 0x4e29
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4e20
jmp 0x4e22
jmp 0x4e22
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: bwa_seq_len
int64_t bwa_seq_len(const char *fn_pac) {
	FILE *fp;
	int64_t pac_len;
	ubyte_t c;

	fp = xopen(fn_pac, "rb");
	err_fseek(fp, -1, SEEK_END);
	pac_len = err_ftell(fp);
	err_fread_noeof(&c, 1, 1, fp);
	err_fclose(fp);
	return pac_len - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x321d1(%rip), %rdi     # 0x370c8
leaq 0x35992(%rip), %rdx     # 0x3a890
callq 0x12740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
movl $0x2, %edx
callq 0x12d90
movq -0x10(%rbp), %rdi
callq 0x12df0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x12c70
movq -0x10(%rbp), %rdi
callq 0x131b0
movq -0x18(%rbp), %rax
subq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: command_pac2bwt
int command_pac2bwt(int argc, char *argv[]) {
	bwt_t *bwt;
	int c;
	while ((c = getopt(argc, argv, "d")) >= 0) {
		switch (c) {
		default: return 1;
		}
	}
	if (optind + 2 > argc) {
		fprintf(stderr, "Usage: paladin pac2bwt <in.pac> <out.bwt>\n");
		return 1;
	}
	bwt = bwt_pac2bwt(argv[optind]);
	bwt_dump_bwt(argv[optind+1], bwt);
	bwt_destroy(bwt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x32573(%rip), %rdx     # 0x37760
callq 0x3090
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x5203
movl $0x1, -0x4(%rbp)
jmp 0x5280
movq 0x3add6(%rip), %rax     # 0x3ffe0
movl (%rax), %eax
addl $0x2, %eax
cmpl -0x8(%rbp), %eax
jle 0x5235
movq 0x3adbd(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x31ec6(%rip), %rsi     # 0x370eb
movb $0x0, %al
callq 0x34e0
movl $0x1, -0x4(%rbp)
jmp 0x5280
movq -0x10(%rbp), %rax
movq 0x3ada0(%rip), %rcx     # 0x3ffe0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4f60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x3ad85(%rip), %rcx     # 0x3ffe0
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x15a40
movq -0x18(%rbp), %rdi
callq 0x15f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: command_bwtupdate
int command_bwtupdate(int argc, char *argv[]) {
	bwt_t *bwt;
	if (argc < 2) {
		fprintf(stderr, "Usage: paladin bwtupdate <the.bwt>\n");
		return 1;
	}
	bwt = bwt_restore_bwt(argv[1]);
	bwt_bwtupdate_core(bwt);
	bwt_dump_bwt(argv[1], bwt);
	bwt_destroy(bwt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x54e6
movq 0x3ab0c(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
leaq 0x31c69(%rip), %rsi     # 0x3713f
movb $0x0, %al
callq 0x34e0
movl $0x1, -0x4(%rbp)
jmp 0x5521
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x15e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15a40
movq -0x18(%rbp), %rdi
callq 0x15f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwtindex.c
// Function: command_bwt2sa
int command_bwt2sa(int argc, char *argv[]) {
	bwt_t *bwt;
	int c, sa_intv = 32;
	while ((c = getopt(argc, argv, "i:")) >= 0) {
		switch (c) {
		case 'i': sa_intv = atoi(optarg); break;
		default: return 1;
		}
	}
	if (optind + 2 > argc) {
		fprintf(stderr, "Usage: paladin bwt2sa [-i %d] <in.bwt> <out.sa>\n", sa_intv);
		return 1;
	}
	bwt = bwt_restore_bwt(argv[optind]);
	bwt_cal_sa(bwt, sa_intv);
	bwt_dump_sa(argv[optind+1], bwt);
	bwt_destroy(bwt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x35798(%rip), %rdx     # 0x3acec
callq 0x3090
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x558d
movl -0x1c(%rbp), %eax
subl $0x69, %eax
jne 0x557f
jmp 0x556b
movq 0x3aa4e(%rip), %rax     # 0x3ffc0
movq (%rax), %rdi
callq 0x3590
movl %eax, -0x20(%rbp)
jmp 0x558b
movl $0x1, -0x4(%rbp)
jmp 0x5619
jmp 0x5546
movq 0x3aa4c(%rip), %rax     # 0x3ffe0
movl (%rax), %eax
addl $0x2, %eax
cmpl -0x8(%rbp), %eax
jle 0x55c2
movq 0x3aa33(%rip), %rax     # 0x3ffd8
movq (%rax), %rdi
movl -0x20(%rbp), %edx
leaq 0x31bb1(%rip), %rsi     # 0x37163
movb $0x0, %al
callq 0x34e0
movl $0x1, -0x4(%rbp)
jmp 0x5619
movq -0x10(%rbp), %rax
movq 0x3aa13(%rip), %rcx     # 0x3ffe0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x13d10
movq -0x10(%rbp), %rax
movq 0x3a9ec(%rip), %rcx     # 0x3ffe0
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ae0
movq -0x18(%rbp), %rdi
callq 0x15f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/kopen.c
// Function: kclose
int kclose(void *a)
{
	koaux_t *aux = (koaux_t*)a;
	if (aux->type == KO_PIPE) {
		int status;
		pid_t pid;
		pid = waitpid(aux->pid, &status, WNOHANG);
		if (pid != aux->pid) kill(aux->pid, 15);
	}
	free(aux);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7174
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x14(%rbp), %rsi
movl $0x1, %edx
callq 0x3230
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x7172
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movl $0xf, %esi
callq 0x34d0
jmp 0x7174
movq -0x10(%rbp), %rdi
callq 0x3380
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/kopen.c
// Function: socket_connect
static int socket_connect(const char *host, const char *port)
{
#define __err_connect(func) do { perror(func); freeaddrinfo(res); return -1; } while (0)

	int on = 1, fd;
	struct linger lng = { 0, 0 };
	struct addrinfo hints, *res = 0;
	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	if (getaddrinfo(host, port, &hints, &res) != 0) __err_connect("getaddrinfo");
	if ((fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) __err_connect("socket");
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) __err_connect("setsockopt");
	if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &lng, sizeof(lng)) == -1) __err_connect("setsockopt");
	if (connect(fd, res->ai_addr, res->ai_addrlen) != 0) __err_connect("connect");
	freeaddrinfo(res);
	return fd;
#undef __err_connect
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3130
movq $0x0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3130
movl $0x0, -0x54(%rbp)
movl $0x1, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x3400
cmpl $0x0, %eax
je 0x721a
jmp 0x71f9
leaq 0x304e5(%rip), %rdi     # 0x376e5
callq 0x3270
movq -0x60(%rbp), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x732f
movq -0x60(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x60(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x60(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x30b0
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
jne 0x725f
jmp 0x723e
leaq 0x304ac(%rip), %rdi     # 0x376f1
callq 0x3270
movq -0x60(%rbp), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x732f
movl -0x20(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x1c(%rbp), %rcx
movl $0x4, %r8d
callq 0x36b0
cmpl $-0x1, %eax
jne 0x72a3
jmp 0x7282
leaq 0x3046f(%rip), %rdi     # 0x376f8
callq 0x3270
movq -0x60(%rbp), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x732f
movl -0x20(%rbp), %edi
movl $0x1, %esi
movl $0xd, %edx
leaq -0x28(%rbp), %rcx
movl $0x8, %r8d
callq 0x36b0
cmpl $-0x1, %eax
jne 0x72e4
jmp 0x72c6
leaq 0x3042b(%rip), %rdi     # 0x376f8
callq 0x3270
movq -0x60(%rbp), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x732f
movl -0x20(%rbp), %edi
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x60(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x3260
cmpl $0x0, %eax
je 0x7320
jmp 0x7302
leaq 0x303fa(%rip), %rdi     # 0x37703
callq 0x3270
movq -0x60(%rbp), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x732f
movq -0x60(%rbp), %rdi
callq 0x3430
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/kopen.c
// Function: write_bytes
static int write_bytes(int fd, const char *buf, size_t len)
{
	ssize_t bytes;
	do {
		bytes = write(fd, buf, len);
		if (bytes >= 0) {
			len -= bytes;
		} else if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
			return -1;
		}
	} while (len > 0);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x737f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x73a8
callq 0x3050
cmpl $0xb, (%rax)
je 0x73a6
callq 0x3050
cmpl $0xb, (%rax)
je 0x73a6
callq 0x3050
cmpl $0x4, (%rax)
je 0x73a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73b8
jmp 0x73a8
jmp 0x73aa
cmpq $0x0, -0x18(%rbp)
ja 0x7353
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/kopen.c
// Function: socket_wait
static int socket_wait(int fd, int is_read)
{
	fd_set fds, *fdr = 0, *fdw = 0;
	struct timeval tv;
	int ret;
	tv.tv_sec = 5; tv.tv_usec = 0; // 5 seconds time out
	FD_ZERO(&fds);
	FD_SET(fd, &fds);
	if (is_read) fdr = &fds;
	else fdw = &fds;
	ret = select(fd+1, fdr, fdw, 0, &tv);
	if (ret == -1) perror("select");
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x5, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpq $0x10, %rax
jae 0x76c7
movq -0xb8(%rbp), %rax
movl -0xb0(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0x7695
jmp 0x76c9
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x4(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
cmpl $0x0, -0x8(%rbp)
je 0x7716
leaq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x7724
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
callq 0x32c0
movl %eax, -0xac(%rbp)
cmpl $-0x1, -0xac(%rbp)
jne 0x7763
leaq 0x30022(%rip), %rdi     # 0x37780
callq 0x3270
movl -0xac(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/align.c
// Function: update_a
static void update_a(mem_opt_t *opt, const mem_opt_t *opt0) {
	if (opt0->a) { // matching score is changed
		if (!opt0->b) opt->b *= opt->a;
		if (!opt0->T) opt->T *= opt->a;
		if (!opt0->o_del) opt->o_del *= opt->a;
		if (!opt0->e_del) opt->e_del *= opt->a;
		if (!opt0->o_ins) opt->o_ins *= opt->a;
		if (!opt0->e_ins) opt->e_ins *= opt->a;
		if (!opt0->zdrop) opt->zdrop *= opt->a;
		if (!opt0->pen_clip5) opt->pen_clip5 *= opt->a;
		if (!opt0->pen_clip3) opt->pen_clip3 *= opt->a;
		if (!opt0->pen_unpaired) opt->pen_unpaired *= opt->a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9cf9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x9c04
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x9c1f
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x44(%rax), %ecx
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x9c3a
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x9c55
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x9c70
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x9c8b
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x9ca6
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x9cc1
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x9cdc
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x9cf7
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
jmp 0x9cf9
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/translations.c
// Function: renderTranslations
void renderTranslations() {
    char * transName;
    int transIdx;

    printf("\nThe following genetic code translation tables are available to PALADIN.\n"
           "Multiple codes may be specified by a comma-delimited list with no spaces.\n"
           "If no translation codes are specified, code 1 is used.\n"
           "Details may be found at http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi\n\n"); 

    for (transIdx = 0 ; transIdx < TRANSLATION_COUNT ; transIdx++) {
        if ((transName = (char *) translationNames[transIdx])[0] != 0) {
            printf("%d. %s\n", transIdx + 1, transName); 
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2eaa7(%rip), %rdi     # 0x38e96
movb $0x0, %al
callq 0x3060
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0xa443
movslq -0xc(%rbp), %rcx
leaq 0x36612(%rip), %rax     # 0x40a20
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa436
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq -0x8(%rbp), %rdx
leaq 0x2eb83(%rip), %rdi     # 0x38fb2
movb $0x0, %al
callq 0x3060
jmp 0xa438
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa3fd
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/protein.c
// Function: encodeCodon
unsigned char encodeCodon(char * passSequence, int passStrand) {
	unsigned char retCodon;
	int relIdx, absIdx;

	retCodon = 0;

	for (relIdx = 0 ; relIdx < 3 ; relIdx++) {
		// Calculate absolute index from relative
		absIdx = relIdx;
		if (passStrand < 0) absIdx = absIdx * -1;

		// If this codon has any ambiguous nucleotides, signal with 0xFF
		if (nst_nt4_table[(int) passSequence[absIdx]] > 3) {
			return 0xFF;
		}

		retCodon = (retCodon << 2) | nst_nt4_table[(int) passSequence[absIdx]];
	}

	// Complement if reverse strand
	if (passStrand < 0) retCodon ^= 0x3F;

	return retCodon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xa4d5
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xa47f
imull $-0x1, -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x3669b(%rip), %rax     # 0x40b30
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jle 0xa4a4
movb $-0x1, -0x1(%rbp)
jmp 0xa4eb
movzbl -0x15(%rbp), %eax
shll $0x2, %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x3666f(%rip), %rcx     # 0x40b30
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa466
cmpl $0x0, -0x14(%rbp)
jge 0xa4e5
movzbl -0x15(%rbp), %eax
xorl $0x3f, %eax
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/protein.c
// Function: getLastAlignedPos
long getLastAlignedPos(long passLength, int passFrame) {
	long retPos;

	if (passFrame < 3) {
		// Forward frame
		retPos = passLength - (passLength % 3) - 1 + (passFrame % 3);
		if (retPos >= passLength) retPos -= 3;
	}
	else {
		// Reverse frame
		retPos = (passLength % 3) - (passFrame % 3);
		if (retPos < 0) retPos += 3;
	}

	return retPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xa6e7
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq -0x28(%rbp), %rax
subq %rdx, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jl 0xa6e5
movq -0x18(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0xa728
movq -0x8(%rbp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq %rdx, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, %eax
movq -0x30(%rbp), %rdx
cltq
subq %rax, %rdx
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0xa726
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0xa728
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/protein.c
// Function: getLastAlignedOrfPos
long getLastAlignedOrfPos(long passLength, int passFrame, mem_opt_t * passOptions) {
	long retValue;

	if (passOptions->min_orf_percent) {
		// Minimum ORF length specified as a read length percentage
		retValue = getLastAlignedPos(passOptions->min_orf_percent * passLength, passFrame);
	}
	else {
		// Minimum ORF length specified as constant value, check for adjustment
		if ((passOptions->proteinFlag & ALIGN_FLAG_ADJUST_ORF) && (passLength < passOptions->min_orf_len)) {
			retValue = getLastAlignedPos(passLength, passFrame);
		}
		else {
			retValue = getLastAlignedPos(passOptions->min_orf_len, passFrame);
		}
	}


	return retValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss 0x6c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xa758
jp 0xa758
jmp 0xa77e
movq -0x18(%rbp), %rax
movss 0x6c(%rax), %xmm0
cvtsi2ssq -0x8(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rdi
movl -0xc(%rbp), %esi
callq 0xa680
movq %rax, -0x20(%rbp)
jmp 0xa7c6
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa7b0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x68(%rcx), %rcx
cmpq %rcx, %rax
jge 0xa7b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa680
movq %rax, -0x20(%rbp)
jmp 0xa7c4
movq -0x18(%rbp), %rax
movslq 0x68(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xa680
movq %rax, -0x20(%rbp)
jmp 0xa7c6
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/protein.c
// Function: addORFHistory
void addORFHistory(long * passHistory[2][6], long passHistorySize[6], unsigned long passIdx ) {
	int copyIdx;
	long * tempHistory;

	if (passHistorySize[passIdx] == 0) {
		// New array
		passHistory[0][passIdx] = malloc(sizeof(long));
		passHistory[1][passIdx] = malloc(sizeof(long));
	}
	else {
		// If array has existing items, resize, copy, and free old
		for (copyIdx = 0 ; copyIdx < 2 ; copyIdx++) {
			tempHistory = passHistory[copyIdx][passIdx];
			passHistory[copyIdx][passIdx] = malloc((passHistorySize[passIdx] + 1) * sizeof(long));
			memcpy(passHistory[copyIdx][passIdx], tempHistory, passHistorySize[passIdx] * sizeof(long));
			free(tempHistory);
		}
	}

	// Update size
	passHistorySize[passIdx]++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa851
movl $0x8, %edi
leaq 0x2e7bb(%rip), %rsi     # 0x38fba
movl $0x9e, %edx
leaq 0x2e7c5(%rip), %rcx     # 0x38fd0
callq 0x31ca0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x8, %edi
leaq 0x2e78f(%rip), %rsi     # 0x38fba
movl $0x9f, %edx
leaq 0x2e799(%rip), %rcx     # 0x38fd0
callq 0x31ca0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
jmp 0xa90c
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0xa90a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
leaq 0x2e722(%rip), %rsi     # 0x38fba
movl $0xa5, %edx
leaq 0x2e72c(%rip), %rcx     # 0x38fd0
callq 0x31ca0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
shlq $0x3, %rdx
callq 0x3250
movq -0x28(%rbp), %rdi
callq 0x3380
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa858
jmp 0xa90c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/protein.c
// Function: writeIndexDirectProtein
int writeIndexDirectProtein(const char * passPrefix, const char * passProName, IndexHeader passHeader) {
	FILE * outputPtr;

	outputPtr = err_xopen_core(__func__, passProName, "w");

	// Write index type header
	passHeader.nucleotide = 0;
	writeIndexHeader(outputPtr, passHeader);

	// Close file
	fflush(outputPtr);
	err_fclose(outputPtr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x2d965(%rip), %rdi     # 0x39038
leaq 0x2fc3e(%rip), %rdx     # 0x3b318
callq 0x12740
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
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 -0x18(%rbp), %rdi
callq 0x3360
movq -0x18(%rbp), %rdi
callq 0x131b0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: prepareUniprotReport
void prepareUniprotReport(int passType, int passPrimary, UniprotList * passLists, CURLBuffer * passBuffer, const char * passProxy) {
	UniprotList * globalLists;

	// Aggregate and sort lists by value
	prepareUniprotLists(passLists, passPrimary);

	// Do not process if no results
	globalLists = getGlobalLists(passPrimary);
	if (globalLists[0].entryCount == 0) return;

	// Report specific preparation
	if (passType == OUTPUT_TYPE_UNIPROT_FULL) {
		// Submit entries to UniProt and retrieve full information
		retrieveUniprotOnline(passLists + UNIPROT_LIST_FULL, passBuffer, passProxy);
		joinOnlineLists(passLists + UNIPROT_LIST_FULL, passBuffer->buffer);
	}

	// Sort aggregated lists by count
	qsort(passLists[UNIPROT_LIST_FULL].entries, passLists[UNIPROT_LIST_FULL].entryCount, sizeof(UniprotEntry), uniprotEntryCompareID);
	qsort(passLists[UNIPROT_LIST_GENES].entries, passLists[UNIPROT_LIST_GENES].entryCount, sizeof(UniprotEntry), uniprotEntryCompareGene);
	qsort(passLists[UNIPROT_LIST_ORGANISM].entries, passLists[UNIPROT_LIST_ORGANISM].entryCount, sizeof(UniprotEntry), uniprotEntryCompareOrganism);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xbef0
movl -0x8(%rbp), %edi
callq 0xbdc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xbe61
jmp 0xbeea
cmpl $0x1, -0x4(%rbp)
jne 0xbe88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xc650
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
movl $0x28, %edx
leaq 0x9cd(%rip), %rcx       # 0xc870
callq 0x3740
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rsi
movl $0x28, %edx
leaq 0xa1c(%rip), %rcx       # 0xc8e0
callq 0x3740
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
movl $0x28, %edx
leaq 0xa6b(%rip), %rcx       # 0xc950
callq 0x3740
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: uniprotEntryCompareID
int uniprotEntryCompareID (const void * passEntry1, const void * passEntry2) {
	int compVal = 0;

	if (((compVal = ((UniprotEntry *)passEntry2)->numOccurrence - ((UniprotEntry *)passEntry1)->numOccurrence)) != 0) {
		return compVal;
	}

	if ((compVal = strcmp(((UniprotEntry *)passEntry1)->id, ((UniprotEntry *)passEntry2)->id)) != 0) {
		return compVal;
	}

	return compVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc8a5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc8ce
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x34b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc8c8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc8ce
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: uniprotEntryCompareGene
int uniprotEntryCompareGene (const void * passEntry1, const void * passEntry2) {
	int compVal = 0;

	if (((compVal = ((UniprotEntry *)passEntry2)->numOccurrence - ((UniprotEntry *)passEntry1)->numOccurrence)) != 0) {
		return compVal;
	}

	if ((compVal = strcmp(((UniprotEntry *)passEntry1)->gene, ((UniprotEntry *)passEntry2)->gene)) != 0) {
		return compVal;
	}

	return compVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc915
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc940
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x34b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc93a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc940
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: uniprotEntryCompareOrganism
int uniprotEntryCompareOrganism (const void * passEntry1, const void * passEntry2) {
	int compVal = 0;

	if (((compVal = ((UniprotEntry *)passEntry2)->numOccurrence - ((UniprotEntry *)passEntry1)->numOccurrence)) != 0) {
		return compVal;
	}

	if ((compVal = strcmp(((UniprotEntry *)passEntry1)->organism, ((UniprotEntry *)passEntry2)->organism)) != 0) {
		return compVal;
	}

	return compVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc985
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc9b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x34b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc9aa
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc9b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/uniprot.c
// Function: cleanUniprotLists
void cleanUniprotLists(UniprotList * passLists, int passPrimary) {
	UniprotList * globalLists;
	int listIdx, entryIdx;

	globalLists = getGlobalLists(passPrimary);

	// Global list 0 contains pointers to all allocated strings, so delete from there. Do not repeat with other lists
	for (entryIdx = 0 ; entryIdx < globalLists[0].entryCount ; entryIdx++) {
		free(globalLists[0].entries[entryIdx].id);
		free(globalLists[0].entries[entryIdx].gene);
		free(globalLists[0].entries[entryIdx].organism);
	}

	free(globalLists[0].entries);
	free(globalLists);

	// Free local lists
	for (listIdx = 0 ; listIdx < 3 ; listIdx++) {
		free(passLists[listIdx].entries);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xbdc0
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xce29
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3380
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x3380
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x3380
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcdc2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3380
movq -0x18(%rbp), %rdi
callq 0x3380
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xce6d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3380
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xce45
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)