LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: findTailPolyAMaybeMask
static int findTailPolyAMaybeMask(DNA *dna, int size, boolean doMask,
				  boolean loose)
/* Identify PolyA at end; mask to 'n' if specified.  This allows a few 
 * non-A's as noise to be trimmed too.  Returns number of bases trimmed.  
 * Leaves first two bases of PolyA in case there's a taa stop codon. */
{
int i;
int score = 10;
int bestScore = 10;
int bestPos = -1;
int trimSize = 0;

for (i=size-1; i>=0; --i)
    {
    DNA b = dna[i];
    if (b == 'n' || b == 'N')
        continue;
    if (score > 20) score = 20;
    if (b == 'a' || b == 'A')
	{
        score += 1;
	if (score >= bestScore)
	    {
	    bestScore = score;
	    bestPos = i;
	    }
	else if (loose && score >= (bestScore - 8))
	    {
	    /* If loose, keep extending even if score isn't back up to best. */
	    bestPos = i;
	    }
	}
    else
	{
        score -= 10;
	}
    if (score < 0)
	{
        break;
	}
    }
if (bestPos >= 0)
    {
    trimSize = size - bestPos - 2;	// Leave two for aa in taa stop codon
    if (trimSize > 0)
        {
	if (doMask)
	    for (i=size - trimSize; i<size; ++i)
		dna[i] = 'n';
	}
    else
        trimSize = 0;
    }
return trimSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xa, -0x1c(%rbp)
movl $0xa, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x3428e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x6e, %eax
je 0x34210
movsbl -0x29(%rbp), %eax
cmpl $0x4e, %eax
jne 0x34212
jmp 0x34280
cmpl $0x14, -0x1c(%rbp)
jle 0x3421f
movl $0x14, -0x1c(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x61, %eax
je 0x34231
movsbl -0x29(%rbp), %eax
cmpl $0x41, %eax
jne 0x3426d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x34250
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3426b
cmpl $0x0, -0x14(%rbp)
je 0x34269
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x8, %ecx
cmpl %ecx, %eax
jl 0x34269
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3426b
jmp 0x34276
movl -0x1c(%rbp), %eax
subl $0xa, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x3427e
jmp 0x3428e
jmp 0x34280
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x341e6
cmpl $0x0, -0x24(%rbp)
jl 0x342e1
movl -0xc(%rbp), %eax
subl -0x24(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x342d8
cmpl $0x0, -0x10(%rbp)
je 0x342d6
movl -0xc(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x342d4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x6e, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x342b5
jmp 0x342d6
jmp 0x342df
movl $0x0, -0x28(%rbp)
jmp 0x342e1
movl -0x28(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: findHeadPolyTMaybeMask
static int findHeadPolyTMaybeMask(DNA *dna, int size, boolean doMask,
				  boolean loose)
/* Return size of PolyT at start (if present); mask to 'n' if specified.  
 * This allows a few non-T's as noise to be trimmed too, but skips last
 * two tt for revcomp'd taa stop codon. */
{
int i;
int score = 10;
int bestScore = 10;
int bestPos = -1;
int trimSize = 0;

for (i=0; i<size; ++i)
    {
    DNA b = dna[i];
    if (b == 'n' || b == 'N')
        continue;
    if (score > 20) score = 20;
    if (b == 't' || b == 'T')
	{
        score += 1;
	if (score >= bestScore)
	    {
	    bestScore = score;
	    bestPos = i;
	    }
	else if (loose && score >= (bestScore - 8))
	    {
	    /* If loose, keep extending even if score isn't back up to best. */
	    bestPos = i;
	    }
	}
    else
	{
        score -= 10;
	}
    if (score < 0)
	{
        break;
	}
    }
if (bestPos >= 0)
    {
    trimSize = bestPos+1 - 2;	// Leave two for aa in taa stop codon
    if (trimSize > 0)
	{
	if (doMask)
	    memset(dna, 'n', trimSize);
	}
    else
        trimSize = 0;
    }
return trimSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xa, -0x1c(%rbp)
movl $0xa, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x34432
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x6e, %eax
je 0x343b4
movsbl -0x29(%rbp), %eax
cmpl $0x4e, %eax
jne 0x343b6
jmp 0x34424
cmpl $0x14, -0x1c(%rbp)
jle 0x343c3
movl $0x14, -0x1c(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x74, %eax
je 0x343d5
movsbl -0x29(%rbp), %eax
cmpl $0x54, %eax
jne 0x34411
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x343f4
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3440f
cmpl $0x0, -0x14(%rbp)
je 0x3440d
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x8, %ecx
cmpl %ecx, %eax
jl 0x3440d
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3440f
jmp 0x3441a
movl -0x1c(%rbp), %eax
subl $0xa, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x34422
jmp 0x34432
jmp 0x34424
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x34388
cmpl $0x0, -0x24(%rbp)
jl 0x3446d
movl -0x24(%rbp), %eax
addl $0x1, %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x34464
cmpl $0x0, -0x10(%rbp)
je 0x34462
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rdx
movl $0x6e, %esi
callq 0x63a0
jmp 0x3446b
movl $0x0, -0x28(%rbp)
jmp 0x3446d
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: isDna
boolean isDna(char *poly, int size)
/* Return TRUE if letters in poly are at least 90% ACGTNU- */
{
int i;
int dnaCount = 0;

dnaUtilOpen();
for (i=0; i<size; ++i)
    {
    if (ntChars[(int)poly[i]])
	dnaCount += 1;
    }
return (dnaCount >= round(0.9 * size));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x34580
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3450c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0xd38c0(%rip), %rax     # 0x107db0
cmpb $0x0, (%rax,%rcx)
je 0x344ff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x34501
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x344d2
movl -0x14(%rbp), %eax
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0xa3f6c(%rip), %xmm1    # 0xd8488
mulsd %xmm1, %xmm0
movsd 0xa4710(%rip), %xmm1    # 0xd8c38
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: dnaUtilOpen
void dnaUtilOpen()
/* Initialize stuff herein. */
{
static boolean opened = FALSE;
if (!opened)
    {
    checkSizeTypes();
    initNtVal();
    initAaVal();
    initNtChars();
    initNtMixedCaseChars();
    initNtCompTable();
    opened = TRUE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xd3f35(%rip)     # 0x1084c0
jne 0x345b5
callq 0x34e90
callq 0x34900
callq 0x34ea0
callq 0x34e00
callq 0x34f90
callq 0x34cc0
movl $0x1, 0xd3f0b(%rip)     # 0x1084c0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: aaAbbrToLetter
char aaAbbrToLetter(char *abbr)
/* Convert an AA abbreviation such as "Ala", "Asp" etc., to its single letter code
 * such as "A", "D" etc.  Return the null char '\0' if abbr is not found. */
{
// Lowercase for comparison.
char abbrLC[4];
safencpy(abbrLC, sizeof(abbrLC), abbr, 3);
toLowerN(abbrLC, 3);
int ix;
for (ix = 0;  ix < ArraySize(aminoAcidTable);  ix++)
    {
    if (sameStringN(abbrLC, aminoAcidTable[ix].abbreviation, 3))
        return aminoAcidTable[ix].letter;
    }
return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x4, %esi
movl $0x3, %ecx
callq 0x31130
leaq -0x14(%rbp), %rdi
movl $0x3, %esi
callq 0x2dc90
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x15, %rax
jae 0x34652
leaq -0x14(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq 0xd253f(%rip), %rsi     # 0x106b50
shlq $0x4, %rax
addq %rax, %rsi
addq $0x5, %rsi
movl $0x3, %edx
callq 0x6320
cmpl $0x0, %eax
jne 0x34645
movslq -0x18(%rbp), %rcx
leaq 0xd251a(%rip), %rax     # 0x106b50
shlq $0x4, %rcx
addq %rcx, %rax
movb 0x4(%rax), %al
movb %al, -0x1(%rbp)
jmp 0x34656
jmp 0x34647
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x345f8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: aaToAbbr
void aaToAbbr(char aa, char *abbrBuf, size_t abbrBufSize)
/* Convert an AA single letter such as "A", "D" etc. to its abbreviation such as "Ala", "Asp" etc.
 * abbrBufSize must be at least 4.  If aa is not found, "?%c?",aa is written into abbrBuf. */
{
// Uppercase for comparison.
char aaUC = toupper(aa);
int ix;
for (ix = 0;  ix < ArraySize(aminoAcidTable);  ix++)
    {
    if (aaUC == aminoAcidTable[ix].letter)
        {
        // safencpy(...3) is required here because aminoAcidTable.abbreviation is char[3] not [4]
        safencpy(abbrBuf, abbrBufSize, aminoAcidTable[ix].abbreviation, 3);
        abbrBuf[0] = toupper(abbrBuf[0]);
        return;
        }
    }
safef(abbrBuf, abbrBufSize, "?%c?", aa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x6de0
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0x15, %rax
jae 0x346fc
movsbl -0x19(%rbp), %eax
movslq -0x20(%rbp), %rdx
leaq 0xd24ae(%rip), %rcx     # 0x106b50
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x346ef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rax
leaq 0xd248c(%rip), %rdx     # 0x106b50
shlq $0x4, %rax
addq %rax, %rdx
addq $0x5, %rdx
movl $0x3, %ecx
callq 0x31130
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x6de0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x34718
jmp 0x346f1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x34689
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
movsbl -0x1(%rbp), %ecx
leaq 0xa5f54(%rip), %rdx     # 0xda665
movb $0x0, %al
callq 0x31090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: initNtCompTable
static void initNtCompTable()
{
zeroBytes(ntCompTable, sizeof(ntCompTable));
ntCompTable[' '] = ' ';
ntCompTable['-'] = '-';
ntCompTable['='] = '=';
ntCompTable['a'] = 't';
ntCompTable['c'] = 'g';
ntCompTable['g'] = 'c';
ntCompTable['t'] = 'a';
ntCompTable['u'] = 'a';
ntCompTable['n'] = 'n';
ntCompTable['-'] = '-';
ntCompTable['.'] = '.';
ntCompTable['A'] = 'T';
ntCompTable['C'] = 'G';
ntCompTable['G'] = 'C';
ntCompTable['T'] = 'A';
ntCompTable['U'] = 'A';
ntCompTable['N'] = 'N';
ntCompTable['R'] = 'Y';
ntCompTable['Y'] = 'R';
ntCompTable['M'] = 'K';
ntCompTable['K'] = 'M';
ntCompTable['S'] = 'S';
ntCompTable['W'] = 'W';
ntCompTable['V'] = 'B';
ntCompTable['H'] = 'D';
ntCompTable['D'] = 'H';
ntCompTable['B'] = 'V';
ntCompTable['X'] = 'N';
ntCompTable['r'] = 'y';
ntCompTable['y'] = 'r';
ntCompTable['s'] = 's';
ntCompTable['w'] = 'w';
ntCompTable['m'] = 'k';
ntCompTable['k'] = 'm';
ntCompTable['v'] = 'b';
ntCompTable['h'] = 'd';
ntCompTable['d'] = 'h';
ntCompTable['b'] = 'v';
ntCompTable['x'] = 'n';
ntCompTable['('] = ')';
ntCompTable[')'] = '(';
inittedCompTable = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd2fe5(%rip), %rdi     # 0x107cb0
movl $0x100, %esi            # imm = 0x100
callq 0x33b60
movb $0x20, 0xd2ff4(%rip)    # 0x107cd0
movb $0x2d, 0xd2ffa(%rip)    # 0x107cdd
movb $0x3d, 0xd3003(%rip)    # 0x107ced
movb $0x74, 0xd3020(%rip)    # 0x107d11
movb $0x67, 0xd301b(%rip)    # 0x107d13
movb $0x63, 0xd3018(%rip)    # 0x107d17
movb $0x61, 0xd301e(%rip)    # 0x107d24
movb $0x61, 0xd3018(%rip)    # 0x107d25
movb $0x6e, 0xd300a(%rip)    # 0x107d1e
movb $0x2d, 0xd2fc2(%rip)    # 0x107cdd
movb $0x2e, 0xd2fbc(%rip)    # 0x107cde
movb $0x54, 0xd2fc8(%rip)    # 0x107cf1
movb $0x47, 0xd2fc3(%rip)    # 0x107cf3
movb $0x43, 0xd2fc0(%rip)    # 0x107cf7
movb $0x41, 0xd2fc6(%rip)    # 0x107d04
movb $0x41, 0xd2fc0(%rip)    # 0x107d05
movb $0x4e, 0xd2fb2(%rip)    # 0x107cfe
movb $0x59, 0xd2faf(%rip)    # 0x107d02
movb $0x52, 0xd2faf(%rip)    # 0x107d09
movb $0x4b, 0xd2f9c(%rip)    # 0x107cfd
movb $0x4d, 0xd2f93(%rip)    # 0x107cfb
movb $0x53, 0xd2f94(%rip)    # 0x107d03
movb $0x57, 0xd2f91(%rip)    # 0x107d07
movb $0x42, 0xd2f89(%rip)    # 0x107d06
movb $0x44, 0xd2f74(%rip)    # 0x107cf8
movb $0x48, 0xd2f69(%rip)    # 0x107cf4
movb $0x56, 0xd2f60(%rip)    # 0x107cf2
movb $0x4e, 0xd2f6f(%rip)    # 0x107d08
movb $0x79, 0xd2f82(%rip)    # 0x107d22
movb $0x72, 0xd2f82(%rip)    # 0x107d29
movb $0x73, 0xd2f75(%rip)    # 0x107d23
movb $0x77, 0xd2f72(%rip)    # 0x107d27
movb $0x6b, 0xd2f61(%rip)    # 0x107d1d
movb $0x6d, 0xd2f58(%rip)    # 0x107d1b
movb $0x62, 0xd2f5c(%rip)    # 0x107d26
movb $0x64, 0xd2f47(%rip)    # 0x107d18
movb $0x68, 0xd2f3c(%rip)    # 0x107d14
movb $0x76, 0xd2f33(%rip)    # 0x107d12
movb $0x6e, 0xd2f42(%rip)    # 0x107d28
movb $0x29, 0xd2eeb(%rip)    # 0x107cd8
movb $0x28, 0xd2ee5(%rip)    # 0x107cd9
movl $0x1, 0xd2ea2(%rip)     # 0x107ca0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: initNtChars
static void initNtChars()
{
static boolean initted = FALSE;

if (!initted)
    {
    zeroBytes(ntChars, sizeof(ntChars));
    ntChars['a'] = ntChars['A'] = 'a';
    ntChars['c'] = ntChars['C'] = 'c';
    ntChars['g'] = ntChars['G'] = 'g';
    ntChars['t'] = ntChars['T'] = 't';
    ntChars['n'] = ntChars['N'] = 'n';
    ntChars['u'] = ntChars['U'] = 'u';
    ntChars['-'] = 'n';
    initted = TRUE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xd4bdd(%rip)     # 0x1099e8
jne 0x34e83
leaq 0xd2f9c(%rip), %rdi     # 0x107db0
movl $0x100, %esi            # imm = 0x100
callq 0x33b60
movb $0x61, 0xd2fcc(%rip)    # 0x107df1
movb $0x61, 0xd2fe5(%rip)    # 0x107e11
movb $0x63, 0xd2fc0(%rip)    # 0x107df3
movb $0x63, 0xd2fd9(%rip)    # 0x107e13
movb $0x67, 0xd2fb6(%rip)    # 0x107df7
movb $0x67, 0xd2fcf(%rip)    # 0x107e17
movb $0x74, 0xd2fb5(%rip)    # 0x107e04
movb $0x74, 0xd2fce(%rip)    # 0x107e24
movb $0x6e, 0xd2fa1(%rip)    # 0x107dfe
movb $0x6e, 0xd2fba(%rip)    # 0x107e1e
movb $0x75, 0xd2f9a(%rip)    # 0x107e05
movb $0x75, 0xd2fb3(%rip)    # 0x107e25
movb $0x6e, 0xd2f64(%rip)    # 0x107ddd
movl $0x1, 0xd4b65(%rip)     # 0x1099e8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: initAaVal
static void initAaVal()
/* Initialize aaVal and valToAa tables. */
{
int i;
char c, lowc;

for (i=0; i<ArraySize(aaVal); ++i)
    aaVal[i] = -1;
for (i=0; i<ArraySize(aminoAcidTable); ++i)
    {
    c = aminoAcidTable[i].letter;
    lowc = tolower(c);
    aaVal[(int)c] = aaVal[(int)lowc] = i;
    aaChars[(int)c] = aaChars[(int)lowc] = c;
    valToAa[i] = c;
    }
aaChars['x'] = aaChars['X'] = 'X';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x34ed8
movslq -0x4(%rbp), %rcx
leaq 0xd470a(%rip), %rax     # 0x1095d0
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x34eaf
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x15, %rax
jae 0x34f7a
movslq -0x4(%rbp), %rcx
leaq 0xd1c58(%rip), %rax     # 0x106b50
shlq $0x4, %rcx
addq %rcx, %rax
movb 0x4(%rax), %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x6ab0
movb %al, -0x6(%rbp)
movl -0x4(%rbp), %edx
movsbl -0x6(%rbp), %eax
movslq %eax, %rcx
leaq 0xd46ae(%rip), %rax     # 0x1095d0
movl %edx, (%rax,%rcx,4)
movsbl -0x5(%rbp), %eax
movslq %eax, %rcx
leaq 0xd469d(%rip), %rax     # 0x1095d0
movl %edx, (%rax,%rcx,4)
movb -0x5(%rbp), %dl
movsbl -0x6(%rbp), %eax
movslq %eax, %rcx
leaq 0xd3069(%rip), %rax     # 0x107fb0
movb %dl, (%rax,%rcx)
movsbl -0x5(%rbp), %eax
movslq %eax, %rcx
leaq 0xd3058(%rip), %rax     # 0x107fb0
movb %dl, (%rax,%rcx)
movb -0x5(%rbp), %dl
movslq -0x4(%rbp), %rcx
leaq 0xd4a67(%rip), %rax     # 0x1099d0
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x34edf
movb $0x58, 0xd3087(%rip)    # 0x108008
movb $0x58, 0xd30a0(%rip)    # 0x108028
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/dnautil.c
// Function: initNtMixedCaseChars
static void initNtMixedCaseChars()
{
static boolean initted = FALSE;

if (!initted)
    {
    zeroBytes(ntMixedCaseChars, sizeof(ntMixedCaseChars));
    ntMixedCaseChars['a'] = 'a';
    ntMixedCaseChars['A'] = 'A';
    ntMixedCaseChars['c'] = 'c';
    ntMixedCaseChars['C'] = 'C';
    ntMixedCaseChars['g'] = 'g';
    ntMixedCaseChars['G'] = 'G';
    ntMixedCaseChars['t'] = 't';
    ntMixedCaseChars['T'] = 'T';
    ntMixedCaseChars['n'] = 'n';
    ntMixedCaseChars['N'] = 'N';
    ntMixedCaseChars['u'] = 'u';
    ntMixedCaseChars['U'] = 'U';
    ntMixedCaseChars['-'] = 'n';
    initted = TRUE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xd4a51(%rip)     # 0x1099ec
jne 0x35013
leaq 0xd2f0c(%rip), %rdi     # 0x107eb0
movl $0x100, %esi            # imm = 0x100
callq 0x33b60
movb $0x61, 0xd2f5c(%rip)    # 0x107f11
movb $0x41, 0xd2f35(%rip)    # 0x107ef1
movb $0x63, 0xd2f50(%rip)    # 0x107f13
movb $0x43, 0xd2f29(%rip)    # 0x107ef3
movb $0x67, 0xd2f46(%rip)    # 0x107f17
movb $0x47, 0xd2f1f(%rip)    # 0x107ef7
movb $0x74, 0xd2f45(%rip)    # 0x107f24
movb $0x54, 0xd2f1e(%rip)    # 0x107f04
movb $0x6e, 0xd2f31(%rip)    # 0x107f1e
movb $0x4e, 0xd2f0a(%rip)    # 0x107efe
movb $0x75, 0xd2f2a(%rip)    # 0x107f25
movb $0x55, 0xd2f03(%rip)    # 0x107f05
movb $0x6e, 0xd2ed4(%rip)    # 0x107edd
movl $0x1, 0xd49d9(%rip)     # 0x1099ec
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/errabort.c
// Function: defaultVaWarn
static void defaultVaWarn(char *format, va_list args)
/* Default error message handler. */
{
if (format != NULL) {
    if (doContentType)
        {
        puts("Content-type: text/html\n");
        puts("Error: ");
        vfprintf(stdout, format, args);
        fprintf(stdout, "\n");
        fflush(stdout);
        }

    fflush(stdout);
    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");
    fflush(stderr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x362a7
cmpl $0x0, 0xd37ee(%rip)     # 0x1099f0
je 0x3625a
leaq 0xa464d(%rip), %rdi     # 0xda858
callq 0x6bb0
leaq 0xa465a(%rip), %rdi     # 0xda871
callq 0x6bb0
movq 0xced8d(%rip), %rax     # 0x104fb0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x69d0
movq 0xced76(%rip), %rax     # 0x104fb0
movq (%rax), %rdi
leaq 0xa2dd5(%rip), %rsi     # 0xd9019
movb $0x0, %al
callq 0x6a80
movq 0xced5e(%rip), %rax     # 0x104fb0
movq (%rax), %rdi
callq 0x6850
movq 0xced4f(%rip), %rax     # 0x104fb0
movq (%rax), %rdi
callq 0x6850
movq 0xced60(%rip), %rax     # 0x104fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x69d0
movq 0xced49(%rip), %rax     # 0x104fd0
movq (%rax), %rdi
leaq 0xa2d88(%rip), %rsi     # 0xd9019
movb $0x0, %al
callq 0x6a80
movq 0xced31(%rip), %rax     # 0x104fd0
movq (%rax), %rdi
callq 0x6850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faSeqListFromMemText
bioSeq *faSeqListFromMemText(char *text, boolean isDna)
/* Convert fa's in memory into list of dnaSeqs. */
{
bioSeq *seqList = NULL, *seq;
while ((seq = faNextSeqFromMemText(&text, isDna)) != NULL)
    {
    slAddHead(&seqList, seq);
    }
slReverse(&seqList);
return seqList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %esi
leaq -0x8(%rbp), %rdi
callq 0x368e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x36bbc
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x36bd0
jmp 0x36b97
leaq -0x18(%rbp), %rdi
callq 0x2aad0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faSeqListFromMemTextRaw
bioSeq *faSeqListFromMemTextRaw(char *text)
/* Convert fa's in memory into list of dnaSeqs without
 * converting chars to N's. */
{
bioSeq *seqList = NULL, *seq;
while ((seq = faNextSeqFromMemTextRaw(&text)) != NULL)
    {
    slAddHead(&seqList, seq);
    }
slReverse(&seqList);
return seqList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x36b50
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x36c46
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x36bd0
jmp 0x36c24
leaq -0x10(%rbp), %rdi
callq 0x2aad0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faReadSeq
struct dnaSeq *faReadSeq(char *fileName, boolean isDna)
/* Open fa file and read a single sequence from it. */
{
int maxSize = fileSize(fileName);
int fd;
DNA *s;

if (maxSize < 0)
    errAbort("can't open %s", fileName);
s = needHugeMem(maxSize+1);
fd = open(fileName, O_RDONLY);
if (read(fd, s, maxSize) < 0)
    errAbort("faReadSeq: read failed: %s", strerror(errno));
close(fd);
s[maxSize] = 0;
return faSeqFromMemText(s, isDna);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4a3e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x36ce3
movq -0x8(%rbp), %rsi
leaq 0xa3c5b(%rip), %rdi     # 0xda937
movb $0x0, %al
callq 0x35d40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x40af0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6d10
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x6a90
cmpq $0x0, %rax
jge 0x36d38
callq 0x6060
movl (%rax), %edi
callq 0x6220
movq %rax, %rsi
leaq 0xa3c14(%rip), %rdi     # 0xda945
movb $0x0, %al
callq 0x35d40
movl -0x14(%rbp), %edi
callq 0x6e90
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x36c60
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: expandFaFastBuf
static void expandFaFastBuf(int bufPos, int minExp, DNA **faFastBuf, unsigned *faFastBufSize)
/* Make faFastBuf bigger. */
{
    if (*faFastBufSize == 0)
    {
        *faFastBufSize = 64 * 1024;
        while (minExp > *faFastBufSize)
            *faFastBufSize <<= 1;
        *faFastBuf = needHugeMem(*faFastBufSize);
    }
    else
    {
        DNA *newBuf;
        unsigned newBufSize = *faFastBufSize + *faFastBufSize;
        while (newBufSize < minExp)
        {
            newBufSize <<= 1;
            if (newBufSize <= 0)
                errAbort("expandFaFastBuf: integer overflow when trying to "
                         "increase buffer size from %u to a min of %u.",
                         *faFastBufSize, minExp);
        }
        newBuf = needHugeMem(newBufSize);
        memcpy(newBuf, *faFastBuf, bufPos);
        freeMem(*faFastBuf);
        *faFastBuf = newBuf;
        *faFastBufSize = newBufSize;
    }
}

// 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 -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3703c
movq -0x18(%rbp), %rax
movl $0x10000, (%rax)        # imm = 0x10000
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x37020
movq -0x18(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
jmp 0x37009
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
callq 0x40af0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x370bc
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
addl (%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x3707a
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
ja 0x37078
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x8(%rbp), %edx
leaq 0xa3971(%rip), %rdi     # 0xda9e2
movb $0x0, %al
callq 0x35d40
jmp 0x3704b
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x40af0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x4(%rbp), %rdx
callq 0x6570
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x40d40
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faWriteNext
void faWriteNext(FILE *f, char *startLine, DNA *dna, int dnaSize)
/* Write next sequence to fa file. */
{
if (dnaSize == 0)
    return;
if (startLine != NULL)
    fprintf(f, ">%s\n", startLine);
writeSeqWithBreaks(f, dna, dnaSize, 50);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x370ef
jmp 0x37121
cmpq $0x0, -0x10(%rbp)
je 0x3710c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa1efd(%rip), %rsi     # 0xd9002
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl $0x32, %ecx
callq 0x34100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faWrite
void faWrite(char *fileName, char *startLine, DNA *dna, int dnaSize)
/* Write out FA file or die trying. */
{
FILE *f = mustOpen(fileName, "w");
faWriteNext(f, startLine, dna, dnaSize);
if (fclose(f) != 0)
    errnoAbort("fclose failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa19fc(%rip), %rsi     # 0xd8b4e
callq 0x2f780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x370d0
movq -0x28(%rbp), %rdi
callq 0x66e0
cmpl $0x0, %eax
je 0x3718b
leaq 0xa2ff5(%rip), %rdi     # 0xda179
movb $0x0, %al
callq 0x35ee0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faWriteAll
void faWriteAll(char *fileName, bioSeq *seqList)
/* Write out all sequences in list to file. */
{
FILE *f = mustOpen(fileName, "w");
bioSeq *seq;

for (seq=seqList; seq != NULL; seq = seq->next)
    faWriteNext(f, seq->name, seq->dna, seq->size);
if (fclose(f) != 0)
    errnoAbort("fclose failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa1993(%rip), %rsi     # 0xd8b4e
callq 0x2f780
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x37200
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
callq 0x370d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x371cc
movq -0x18(%rbp), %rdi
callq 0x66e0
cmpl $0x0, %eax
je 0x3721c
leaq 0xa2f64(%rip), %rdi     # 0xda179
movb $0x0, %al
callq 0x35ee0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faToProtein
void faToProtein(char *poly, int size)
/* Convert possibly mixed-case protein to upper case.  Also
 * convert any strange characters to 'X'.  Does not change size.
 * of sequence. */
{
int i;
char c;
dnaUtilOpen();
for (i=0; i<size; ++i)
    {
    if ((c = aaChars[(int)poly[i]]) == 0)
	c = 'X';
    poly[i] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, %al
callq 0x34580
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x37536
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0xd0aa5(%rip), %rax     # 0x107fb0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x3751d
movb $0x58, -0x11(%rbp)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x374ed
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faToDna
void faToDna(char *poly, int size)
/* Convert possibly mixed-case DNA to lower case.  Also turn
 * any strange characters to 'n'.  Does not change size.
 * of sequence. */
{
int i;
char c;
dnaUtilOpen();
for (i=0; i<size; ++i)
    {
    if ((c = ntChars[(int)poly[i]]) == 0)
	c = 'n';
    poly[i] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, %al
callq 0x34580
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x375a6
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0xd0835(%rip), %rax     # 0x107db0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x3758d
movb $0x6e, -0x11(%rbp)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3755d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faSomeSpeedReadNext
boolean faSomeSpeedReadNext(struct lineFile *lf, DNA **retDna, int *retSize, char **retName, boolean isDna,
                            DNA **faFastBuf, unsigned *faFastBufSize)
/* Read in DNA or Peptide FA record. */
{
    char *poly;
    int size;

    if (!faMixedSpeedReadNext(lf, retDna, retSize, retName, faFastBuf, faFastBufSize))
        return FALSE;
    size = *retSize;
    poly = *retDna;
    if (isDna)
        faToDna(poly, size);
    else
        faToProtein(poly, size);
    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x37230
cmpl $0x0, %eax
jne 0x375ff
movl $0x0, -0x4(%rbp)
jmp 0x3763a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x37627
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x37540
jmp 0x37633
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x374d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faReadAllIntoHash
struct hash *faReadAllIntoHash(char *fileName, enum dnaCase dnaCase, DNA **faFastBuf, unsigned *faFastBufSize)
/* Return hash of all sequences in FA file.  */
{
boolean isDna = (dnaCase == dnaLower);
boolean isMixed = (dnaCase == dnaMixed);
struct dnaSeq *seqList = faReadAllSeqMixable(fileName, isDna, isMixed, faFastBuf, faFastBufSize);
struct hash *hash = hashNew(18);
struct dnaSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
    {
    if (hashLookup(hash, seq->name))
        errAbort("%s duplicated in %s", seq->name, fileName);
    hashAdd(hash, seq->name, seq);
    }
return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
cmpl $0x2, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x377c0
movq %rax, -0x30(%rbp)
movl $0x12, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x377b5
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x38e20
cmpq $0x0, %rax
je 0x37793
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rdx
leaq 0xa3220(%rip), %rdi     # 0xda9ac
movb $0x0, %al
callq 0x35d40
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x39230
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x3775b
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faReadAllSeqMixable
static struct dnaSeq *faReadAllSeqMixable(char *fileName, boolean isDna, boolean mixed,
                                          DNA **faFastBuf, unsigned *faFastBufSize)
/* Return list of all sequences in FA file. 
 * Mixed case parameter overrides isDna.  If mixed is false then
 * will return DNA in lower case and non-DNA in upper case. */
{
struct lineFile *lf = lineFileOpen(fileName, FALSE);
struct dnaSeq *seqList = faReadAllMixableInLf(lf, isDna, mixed, faFastBuf, faFastBufSize);
lineFileClose(&lf);
return seqList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3b290
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x37940
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3c110
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/fa.c
// Function: faReadAllMixableInLf
static struct dnaSeq *faReadAllMixableInLf(struct lineFile *lf,
        boolean isDna, boolean mixed, DNA **faFastBuf, unsigned *faFastBufSize)
/* Return list of all sequences from open fa file.
 * Mixed case parameter overrides isDna.  If mixed is false then
 * will return DNA in lower case and non-DNA in upper case. */
{
    struct dnaSeq *seqList = NULL, *seq;
    DNA *dna;
    char buf[512];
    char *name=buf;
    int size;
    boolean ok;

    for (;;)
    {
        if (mixed)
            ok = faMixedSpeedReadNext(lf, &dna, &size, &name, faFastBuf, faFastBufSize);
        else
            ok = faSomeSpeedReadNext(lf, &dna, &size, &name, isDna, faFastBuf, faFastBufSize);
        if (!ok)
            break;
        AllocVar(seq);
        seq->name = cloneString(name);
        seq->size = size;
        seq->dna = cloneMem(dna, size+1);
        slAddHead(&seqList, seq);
    }
    slReverse(&seqList);
    faFreeFastBuf(faFastBuf, faFastBufSize);
    return seqList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x240(%rbp), %rax
movq %rax, -0x248(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x379a4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq -0x38(%rbp), %rsi
leaq -0x24c(%rbp), %rdx
leaq -0x248(%rbp), %rcx
callq 0x37230
movl %eax, -0x250(%rbp)
jmp 0x379d5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %rax
leaq -0x38(%rbp), %rsi
leaq -0x24c(%rbp), %rdx
leaq -0x248(%rbp), %rcx
movq %rax, (%rsp)
callq 0x375b0
movl %eax, -0x250(%rbp)
cmpl $0x0, -0x250(%rbp)
jne 0x379e0
jmp 0x37a44
movl $0x28, %edi
callq 0x40c50
movq %rax, -0x30(%rbp)
movq -0x248(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x38(%rbp), %rdi
movl -0x24c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2a360
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x36bd0
jmp 0x37973
leaq -0x28(%rbp), %rdi
callq 0x2aad0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36da0
movq -0x28(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffFreeAli
void ffFreeAli(struct ffAli **pAli)
/* Dispose of memory gotten from fuzzyFind(). */
{
struct ffAli *ali = *pAli;
if (ali != NULL)
    {
    while (ali->right)
        ali = ali->right;
    slFreeList(&ali);
    }
*pAli = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37ab2
jmp 0x37a90
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37aa9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x37a90
leaq -0x10(%rbp), %rdi
callq 0x2ab30
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffIntronOrientation
int ffIntronOrientation(struct ffAli *ali)
/* Return + for positive orientation overall, - for negative,
 * 0 if can't tell. */
{
struct ffAli *left = ali, *right;
int orient = 0;

if (left != NULL)
    {
    while((right = left->right) != NULL)
	{
	orient += intronOrientation(left->hEnd, right->hStart);
	left = right;
	}
    }
return orient;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37b7d
jmp 0x37b44
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x37b7b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x33f10
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x37b44
jmp 0x37b7d
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffMakeRightLinks
struct ffAli *ffMakeRightLinks(struct ffAli *rightMost)
/* Given a pointer to the rightmost block in an alignment
 * which has all of the left pointers filled in, fill in
 * the right pointers and return the leftmost block. */
{
struct ffAli *ff, *last = NULL;

for (ff = rightMost; ff != NULL; ff = ff->left)
    {
    ff->right = last;
    last = ff;
    }
return last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37c00
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x37bd8
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffCountGoodEnds
void ffCountGoodEnds(struct ffAli *aliList)
/* Fill in the goodEnd and badEnd scores. */
{
struct ffAli *ali;
for (ali = aliList; ali != NULL; ali = ali->right)
    {
    ali->startGood = countGoodStart(ali);
    ali->endGood = countGoodEnd(ali);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37c5d
movq -0x10(%rbp), %rdi
callq 0x37c70
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x37d00
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x37c24
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: countGoodStart
static int countGoodStart(struct ffAli *ali)
/* Return number of perfect matchers at start. */
{
DNA *n = ali->nStart;
DNA *h = ali->hStart;
int count = ali->nEnd - ali->nStart;
int i;
for (i=0; i<count; ++i)
    {
    if (*n++ != *h++)
        break;
    }
return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x37cec
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x37cdf
jmp 0x37cec
jmp 0x37ce1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x37cad
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: countGoodEnd
static int countGoodEnd(struct ffAli *ali)
/* Return number of perfect matchers at start. */
{
DNA *n = ali->nEnd;
DNA *h = ali->hEnd;
int count = ali->nEnd - ali->nStart;
int i;
for (i=0; i<count; ++i)
    {
    if (*--n != *--h)
        break;
    }
return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x37d7e
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl -0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl -0x1(%rcx), %ecx
cmpl %ecx, %eax
je 0x37d71
jmp 0x37d7e
jmp 0x37d73
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x37d3d
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffAliCount
int ffAliCount(struct ffAli *d)
/* How many blocks in alignment? */
{
int acc = 0;
while (d != NULL)
    {
    ++acc;
    d = d->right;
    }
return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x37dbd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x37d9f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffAli.c
// Function: ffAliFromSym
struct ffAli *ffAliFromSym(int symCount, char *nSym, char *hSym,
	struct lm *lm, char *nStart, char *hStart)
/* Convert symbol representation of alignments (letters plus '-')
 * to ffAli representation.  If lm is nonNULL, ffAli result 
 * will be lmAlloced, else it will be needMemed. This routine
 * depends on nSym/hSym being zero terminated. */
{
struct ffAli *ffList = NULL, *ff = NULL;
char n, h;
int i;

for (i=0; i<=symCount; ++i)
    {
    boolean isGap;
    n = nSym[i];
    h = hSym[i];
    isGap = (n == '-' || n == 0 || h == '-' || h == 0);
    if (isGap)
	{
	if (ff != NULL)
	    {
	    ff->nEnd = nStart;
	    ff->hEnd = hStart;
	    ff->left = ffList;
	    ffList = ff;
	    ff = NULL;
	    }
	}
    else
	{
	if (ff == NULL)
	    {
	    if (lm != NULL)
		{
		lmAllocVar(lm, ff);
		}
	    else
		{
		AllocVar(ff);
		}
	    ff->nStart = nStart;
	    ff->hStart = hStart;
	    }
	}
    if (n != '-')
	{
	++nStart;
	}
    if (h != '-')
	{
	++hStart;
	}
    }
ffList = ffMakeRightLinks(ffList);
return ffList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x37f36
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x41(%rbp)
movq -0x18(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x42(%rbp)
movsbl -0x41(%rbp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x4d(%rbp)
je 0x37e65
movsbl -0x41(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x4d(%rbp)
je 0x37e65
movsbl -0x42(%rbp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x4d(%rbp)
je 0x37e65
movsbl -0x42(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x37eb2
cmpq $0x0, -0x40(%rbp)
je 0x37eb0
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x37efc
cmpq $0x0, -0x40(%rbp)
jne 0x37efa
cmpq $0x0, -0x20(%rbp)
je 0x37ed4
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0x3de60
movq %rax, -0x40(%rbp)
jmp 0x37ee2
movl $0x38, %edi
callq 0x40c50
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x37efc
movsbl -0x41(%rbp), %eax
cmpl $0x2d, %eax
je 0x37f11
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movsbl -0x42(%rbp), %eax
cmpl $0x2d, %eax
je 0x37f26
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x37f28
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x37e06
movq -0x38(%rbp), %rdi
callq 0x37bc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreMatch
int ffScoreMatch(DNA *a, DNA *b, int size)
/* Compare two pieces of DNA base by base. Total mismatches are
 * subtracted from total matches and returned as score. 'N's 
 * neither hurt nor help score. */
{
int i;
int score = 0;
for (i=0; i<size; ++i)
    {
    DNA aa = a[i];
    DNA bb = b[i];
    if (aa == 'n' || bb == 'n')
        continue;
    if (aa == bb)
        ++score;
    else
        score -= 1;
    }
return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x37ff2
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1e(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x6e, %eax
je 0x37fc3
movsbl -0x1e(%rbp), %eax
cmpl $0x6e, %eax
jne 0x37fc5
jmp 0x37fe7
movsbl -0x1d(%rbp), %eax
movsbl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jne 0x37fdc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37fe5
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37fe7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x37f8d
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)