LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: reverseComplementSlashSeparated
char *reverseComplementSlashSeparated(char *alleleStr)
/* Given a slash-separated series of sequences (a common representation of variant alleles),
 * returns a slash-sep series with the reverse complement of each sequence (if it is a
 * nucleotide sequence).
 * Special behavior to support dbSNP's variant allele conventions:
 * 1. Reverse the order of sequences (to maintain alphabetical ordering).
 * 2. If alleleStr begins with "-/", then after reversing, move "-/" back to the beginning. */
{
int len = strlen(alleleStr);
char choppyCopy[len+1];
safecpy(choppyCopy, sizeof(choppyCopy), alleleStr);
char *alleles[len];
int alCount = chopByChar(choppyCopy, '/', alleles, ArraySize(alleles));
char *outStr = needMem(len+1);
int i;
for (i = alCount-1;  i >= 0;  i--)
    {
    char *allele = alleles[i];
    int alLen = strlen(allele);
    if (isAllNt(allele, alLen))
        reverseComplement(allele, alLen);
    if (i != alCount-1)
        safecat(outStr, len+1, "/");
    safecat(outStr, len+1, allele);
    }
if (startsWith("-/", alleleStr))
    {
    // Keep "-/" at the beginning:
    memmove(outStr+2, outStr, len-2);
    outStr[0] = '-';
    outStr[1] = '/';
    }
return outStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
callq 0x62d0
movq %rax, %r15
leal 0x1(%rax), %ebx
movq %rsp, %r14
leaq 0xf(%rbx), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, -0x40(%rbp)
movq %r12, %rdx
callq 0x21264
movl %r15d, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
movq %r14, %rdi
movl $0x2f, %esi
movq %rdx, -0x50(%rbp)
movq %r15, -0x38(%rbp)
movl %r15d, %ecx
callq 0x2251a
movl %eax, %r14d
movslq %ebx, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2dc95
movq %rax, %r12
testl %r14d, %r14d
jle 0x25279
movq %r14, %r15
decl %r15d
leaq 0x9c77b(%rip), %r13     # 0xc1970
movq %r15, -0x48(%rbp)
movq %r12, %r14
movq -0x50(%rbp), %rax
movq (%rax,%r15,8), %rbx
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r12
callq 0x25b5c
testl %r12d, %r12d
jle 0x25237
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsbq (%rbx,%rcx), %rdx
cmpb $0x0, (%rdx,%r13)
je 0x25242
incq %rcx
cmpq %rcx, %rax
jne 0x25223
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x250f6
cmpq -0x48(%rbp), %r15
movq %r14, %r12
je 0x2525e
movq %r12, %rdi
movq -0x30(%rbp), %rsi
leaq 0x6ff34(%rip), %rdx     # 0x9518d
callq 0x23cf8
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x23cf8
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0x251f9
leaq 0x6b473(%rip), %rdi     # 0x906f3
movq -0x40(%rbp), %rsi
callq 0x217c8
testl %eax, %eax
je 0x252ad
movq %r12, %rdi
addq $0x2, %rdi
movq -0x38(%rbp), %rax
addl $-0x2, %eax
movslq %eax, %rdx
movq %r12, %rsi
callq 0x6c60
movw $0x2f2d, (%r12)         # imm = 0x2F2D
movq %r12, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: isAllNt
boolean isAllNt(char *seq, int size)
/* Return TRUE if all letters in seq are ACGTNU-. */
{
int i;
dnaUtilOpen();
for (i = 0;  i < size;  ++i)
    {
    if (ntChars[(int)seq[i]] == 0)
	return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x25b5c
movl $0x1, %eax
testl %ebp, %ebp
jle 0x252f7
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x9c690(%rip), %rsi     # 0xc1970
movsbq (%rbx,%rdx), %rdi
cmpb $0x0, (%rdi,%rsi)
je 0x252f5
incq %rdx
cmpq %rdx, %rcx
jne 0x252e0
jmp 0x252f7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: cmpDnaStrings
int cmpDnaStrings(DNA *a, DNA *b)
/* Compare using screwy non-alphabetical DNA order TCGA */
{
for (;;)
    {
    DNA aa = *a++;
    DNA bb = *b++;
    if (aa != bb)
        return ntVal[(int)aa] - ntVal[(int)bb];
    if (aa == 0)
	break;
    }
return 0;
}

// Assembly:
xorl %ecx, %ecx
leaq 0x9c159(%rip), %rdx     # 0xc1460
movsbq (%rdi,%rcx), %r9
movsbq (%rsi,%rcx), %r8
cmpb %r8b, %r9b
jne 0x25325
xorl %r8d, %r8d
testb %r9b, %r9b
sete %r8b
addl %r8d, %r8d
jmp 0x25333
movl (%rdx,%r9,4), %eax
subl (%rdx,%r8,4), %eax
movl $0x1, %r8d
incq %rcx
testl %r8d, %r8d
je 0x25307
cmpl $0x1, %r8d
je 0x25343
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: toRna
void toRna(DNA *dna)
{
DNA c;
for (;;)
    {
    c = *dna;
    if (c == 't')
	*dna = 'u';
    else if (c == 'T')
	*dna = 'U';
    else if (c == 0)
	break;
    ++dna;
    }
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x54, %eax
je 0x25359
movb $0x75, %cl
cmpl $0x74, %eax
je 0x2535b
testl %eax, %eax
jne 0x2535d
jmp 0x25362
movb $0x55, %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x25344
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: skipIgnoringDash
char *skipIgnoringDash(char *a, int size, bool skipTrailingDash)
/* Count size number of characters, and any 
 * dash characters. */
{
while (size > 0)
    {
    if (*a++ != '-')
        --size;
    }
if (skipTrailingDash)
    while (*a == '-')
       ++a;
return a;
}

// Assembly:
testl %esi, %esi
jle 0x2537e
leaq 0x1(%rdi), %rax
xorl %ecx, %ecx
cmpb $0x2d, (%rdi)
setne %cl
subl %ecx, %esi
movq %rax, %rdi
testl %esi, %esi
jg 0x25367
jmp 0x25381
movq %rdi, %rax
testb %dl, %dl
je 0x25398
decq %rax
movq %rax, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x2d, 0x1(%rcx)
movq %rax, %rcx
je 0x2538b
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: countNonDash
int countNonDash(char *a, int size)
/* Count number of non-dash characters. */
{
int count = 0;
int i;
for (i=0; i<size; ++i)
    if (a[i] != '-') 
        ++count;
return count;
}

// Assembly:
testl %esi, %esi
jle 0x253b8
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpb $0x2d, (%rdi,%rdx)
setne %sil
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x253a3
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: dnaOrAaFilteredSize
long dnaOrAaFilteredSize(char *raw, char filter[256])
/* Return how long DNA will be after non-DNA is filtered out. */
{
char c;
long count = 0;
dnaUtilOpen();
while ((c = *raw++) != 0)
    {
    if (filter[(int)c]) ++count;
    }
return count;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25b5c
movb (%r14), %cl
testb %cl, %cl
je 0x2540c
incq %r14
xorl %eax, %eax
movsbq %cl, %rcx
cmpb $0x1, (%rbx,%rcx)
sbbq $-0x1, %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x253f4
jmp 0x2540e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: dnaOrAaFilter
void dnaOrAaFilter(char *in, char *out, char filter[256])
/* Run chars through filter. */
{
char c;
dnaUtilOpen();
while ((c = *in++) != 0)
    {
    if ((c = filter[(int)c]) != 0) *out++ = c;
    }
*out++ = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x25b5c
movb (%r15), %al
testb %al, %al
je 0x2544e
incq %r15
movsbq %al, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x25444
movb %al, (%rbx)
incq %rbx
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x25433
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: dnaFilterToN
void dnaFilterToN(char *in, DNA *out)
/* Change all non-DNA characters to N. */
{
DNA c;
initNtChars();
while ((c = *in++) != 0)
    {
    if ((c = ntChars[(int)c]) != 0) *out++ = c;
    else *out++ = 'n';
    }
*out++ = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26156
movb (%r14), %dl
testb %dl, %dl
je 0x25513
incq %r14
leaq 0x9c47e(%rip), %rax     # 0xc1970
movl $0x6e, %ecx
movsbq %dl, %rdx
movzbl (%rdx,%rax), %edx
testb %dl, %dl
cmovel %ecx, %edx
movb %dl, (%rbx)
incq %rbx
movb (%r14), %dl
incq %r14
testb %dl, %dl
jne 0x254f7
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: upperToN
void upperToN(char *s, int size)
/* Turn upper case letters to N's. */
{
char c;
int i;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (isupper(c))
        s[i] = 'n';
    }
}

// Assembly:
testl %esi, %esi
jle 0x25614
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6790
movl %ebp, %ecx
xorl %edx, %edx
movsbq (%rbx,%rdx), %rsi
movq (%rax), %rdi
testb $0x1, 0x1(%rdi,%rsi,2)
je 0x25606
movb $0x6e, (%rbx,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x255f3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: lowerToN
void lowerToN(char *s, int size)
/* Turn lower case letters to N's. */
{
char c;
int i;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (islower(c))
        s[i] = 'N';
    }
}

// Assembly:
testl %esi, %esi
jle 0x2564b
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6790
movl %ebp, %ecx
xorl %edx, %edx
movsbq (%rbx,%rdx), %rsi
movq (%rax), %rdi
testb $0x2, 0x1(%rdi,%rsi,2)
je 0x2563d
movb $0x4e, (%rbx,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x2562a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: basesToBits64
bits64 basesToBits64(char *dna, int size)
/* Convert dna of given size (up to 32) to binary representation */
{
if (size > 32)
    errAbort("basesToBits64 called on %d bases, can only go up to 32", size);
bits64 result = 0;
int i;
for (i=0; i<size; ++i)
    {
    result <<= 2;
    result += ntValNoN[(int)dna[i]];
    }
return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x21, %esi
jl 0x25697
leaq 0x6b068(%rip), %rdi     # 0x906f6
movl %ebp, %esi
xorl %eax, %eax
callq 0x26b6f
testl %ebp, %ebp
jle 0x256bf
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x9c5ca(%rip), %rsi     # 0xc1c70
xorl %eax, %eax
movsbq (%rbx,%rdx), %rdi
movslq (%rsi,%rdi,4), %rdi
leaq (%rdi,%rax,4), %rax
incq %rdx
cmpq %rdx, %rcx
jne 0x256a8
jmp 0x256c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: unpackDna
void unpackDna(bits32 *tiles, int tileCount, DNA *out)
/* Unpack DNA. Expands to 16x tileCount in output. */
{
int i, j;
bits32 tile;

for (i=0; i<tileCount; ++i)
    {
    tile = tiles[i];
    for (j=15; j>=0; --j)
        {
        out[j] = valToNt[tile & 0x3];
        tile >>= 2;
        }
    out += 16;
    }
}

// Assembly:
testl %esi, %esi
jle 0x25770
movl %esi, %eax
xorl %ecx, %ecx
leaq 0x9c92f(%rip), %rsi     # 0xc2070
movl (%rdi,%rcx,4), %r8d
movl $0x10, %r9d
movl %r8d, %r10d
andl $0x3, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrl $0x2, %r8d
decq %r9
jne 0x2574b
addq $0x10, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0x25741
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: unpackDna4
void unpackDna4(UBYTE *tiles, int byteCount, DNA *out)
/* Unpack DNA. Expands to 4x byteCount in output. */
{
int i, j;
UBYTE tile;

for (i=0; i<byteCount; ++i)
    {
    tile = tiles[i];
    for (j=3; j>=0; --j)
        {
        out[j] = valToNt[tile & 0x3];
        tile >>= 2;
        }
    out += 4;
    }
}

// Assembly:
testl %esi, %esi
jle 0x257b3
movl %esi, %eax
xorl %ecx, %ecx
leaq 0x9c8f0(%rip), %rsi     # 0xc2070
movb (%rdi,%rcx), %r8b
movl $0x4, %r9d
movzbl %r8b, %r8d
movl %r8d, %r10d
andl $0x3, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrb $0x2, %r8b
decq %r9
jne 0x2578a
addq $0x4, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0x25780
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: intronOrientationMinSize
int intronOrientationMinSize(DNA *iStart, DNA *iEnd, int minIntronSize)
/* Given a gap in genome from iStart to iEnd, return 
 * Return 1 for GT/AG intron between left and right, -1 for CT/AC, 0 for no
 * intron.  Assumes DNA is lower cased. */
{
if (iEnd - iStart < minIntronSize)
    return 0;
if (iStart[0] == 'g' && iStart[1] == 't' && iEnd[-2] == 'a' && iEnd[-1] == 'g')
    {
    return 1;
    }
else if (iStart[0] == 'c' && iStart[1] == 't' && iEnd[-2] == 'a' && iEnd[-1] == 'c')
    {
    return -1;
    }
else
    return 0;
}

// Assembly:
movq %rsi, %rcx
subq %rdi, %rcx
movslq %edx, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jl 0x25806
movzbl (%rdi), %ecx
cmpl $0x63, %ecx
je 0x257ed
cmpl $0x67, %ecx
jne 0x25804
cmpb $0x74, 0x1(%rdi)
jne 0x257e8
cmpb $0x61, -0x2(%rsi)
jne 0x257e8
movl $0x1, %eax
cmpb $0x67, -0x1(%rsi)
je 0x25806
cmpb $0x63, %cl
jne 0x25804
cmpb $0x74, 0x1(%rdi)
jne 0x25804
cmpb $0x61, -0x2(%rsi)
jne 0x25804
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x63, -0x1(%rsi)
je 0x25806
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: dnaOrAaScoreMatch
int  dnaOrAaScoreMatch(char *a, char *b, int size, int matchScore, int mismatchScore, 
	char ignore)
/* Compare two sequences (without inserts or deletions) and score. */
{
int i;
int score = 0;
for (i=0; i<size; ++i)
    {
    char aa = a[i];
    char bb = b[i];
    if (aa == ignore || bb == ignore)
        continue;
    if (aa == bb)
        score += matchScore;
    else
        score += mismatchScore;
    }
return score;
}

// Assembly:
testl %edx, %edx
jle 0x25863
pushq %rbx
movl %edx, %edx
xorl %r10d, %r10d
xorl %eax, %eax
movb (%rdi,%r10), %r11b
cmpb %r9b, %r11b
je 0x25859
movb (%rsi,%r10), %bl
cmpb %r9b, %bl
je 0x25859
cmpb %bl, %r11b
movl %r8d, %r11d
cmovel %ecx, %r11d
addl %r11d, %eax
incq %r10
cmpq %r10, %rdx
jne 0x2583a
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: writeSeqWithBreaks
void writeSeqWithBreaks(FILE *f, char *letters, int letterCount, int maxPerLine)
/* Write out letters with newlines every maxLine. */
{
int lettersLeft = letterCount;
int lineSize;
while (lettersLeft > 0)
    {
    lineSize = lettersLeft;
    if (lineSize > maxPerLine)
        lineSize = maxPerLine;
    mustWrite(f, letters, lineSize);
    fputc('\n', f);
    letters += lineSize;
    lettersLeft -= lineSize;
    }
}

// Assembly:
testl %edx, %edx
jle 0x25945
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpl %ebx, %ebp
movl %ebx, %eax
cmovll %ebp, %eax
movslq %eax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x22e1e
movl $0xa, %edi
movq %r15, %rsi
callq 0x6930
addq %r12, %r14
subl %r12d, %ebp
jg 0x25910
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %esi, %eax
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xa, %r9d
movl $0x14, %r10d
movl $0xa, %r11d
testl %eax, %eax
jle 0x259c2
decq %rax
movl %eax, %ebx
movb (%rdi,%rbx), %bl
andb $-0x21, %bl
cmpb $0x4e, %bl
jne 0x25982
xorl %ebx, %ebx
jmp 0x259be
cmpl $0x14, %r9d
cmovgel %r10d, %r9d
cmpb $0x41, %bl
jne 0x259ac
incl %r9d
cmpl %r11d, %r9d
jge 0x259b2
leal -0x8(%r11), %ebx
cmpl %ebx, %r9d
movl %eax, %ebx
cmovll %r8d, %ebx
testl %ecx, %ecx
cmovnel %ebx, %r8d
jmp 0x259b8
addl $-0xa, %r9d
jmp 0x259b8
movl %r9d, %r11d
movl %eax, %r8d
movl %r9d, %ebx
shrl $0x1f, %ebx
testb %bl, %bl
je 0x2596a
xorl %eax, %eax
testl %r8d, %r8d
js 0x25a01
movl %esi, %ebx
subl %r8d, %ebx
cmpl $0x3, %ebx
jl 0x25a01
addl $-0x2, %ebx
testl %edx, %edx
je 0x259ff
movl %esi, %eax
subl %ebx, %eax
cltq
addq %rax, %rdi
leal 0x3(%r8), %edx
cmpl %edx, %esi
cmovgl %esi, %edx
subl %r8d, %edx
addl $-0x3, %edx
incq %rdx
movl $0x6e, %esi
callq 0x63b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testl %esi, %esi
jle 0x25aa3
movl %esi, %eax
decq %rax
movl $0xa, %r8d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0x14, %r9d
movl $0xa, %r10d
movb (%rdi,%rsi), %r11b
andb $-0x21, %r11b
cmpb $0x4e, %r11b
jne 0x25a52
xorl %r11d, %r11d
jmp 0x25a90
cmpl $0x14, %r10d
cmovgel %r9d, %r10d
cmpb $0x54, %r11b
jne 0x25a7e
incl %r10d
cmpl %r8d, %r10d
jge 0x25a84
leal -0x8(%r8), %r11d
cmpl %r11d, %r10d
movl %esi, %r11d
cmovll %ebx, %r11d
testl %ecx, %ecx
cmovnel %r11d, %ebx
jmp 0x25a89
addl $-0xa, %r10d
jmp 0x25a89
movl %r10d, %r8d
movl %esi, %ebx
movl %r10d, %r11d
shrl $0x1f, %r11d
testb %r11b, %r11b
jne 0x25aa8
leaq 0x1(%rsi), %r11
cmpq %rsi, %rax
movq %r11, %rsi
jne 0x25a3f
jmp 0x25aa8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %eax, %eax
testl %ebx, %ebx
js 0x25ac7
cmpl $0x2, %ebx
jl 0x25ac7
decl %ebx
testl %edx, %edx
je 0x25ac5
movl %ebx, %edx
movl $0x6e, %esi
callq 0x63b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x25b5c
testl %ebx, %ebx
jle 0x25b0a
movl %ebx, %eax
xorl %edx, %edx
leaq 0x9be7e(%rip), %rsi     # 0xc1970
xorl %ecx, %ecx
movsbq (%r14,%rdx), %rdi
cmpb $0x1, (%rdi,%rsi)
sbbl $-0x1, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x25af4
jmp 0x25b0c
xorl %ecx, %ecx
cvtsi2sd %ebx, %xmm0
mulsd 0x68a38(%rip), %xmm0    # 0x8e550
addsd 0x69288(%rip), %xmm0    # 0x8eda8
cvttsd2si %xmm0, %edx
xorl %eax, %eax
cmpl %edx, %ecx
setge %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, 0x9c51d(%rip)     # 0xc2080
jne 0x25c6e
pushq %r15
pushq %r14
pushq %rbx
callq 0x25e88
leaq 0x9d616(%rip), %rbx     # 0xc3190
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movl $0xff, %esi
callq 0x63b0
leaq 0x9ae91(%rip), %r14     # 0xc0a24
xorl %r15d, %r15d
callq 0x6160
leaq 0x9bfce(%rip), %rcx     # 0xc1b70
leaq 0x9d9e7(%rip), %rdx     # 0xc3590
movsbq (%r14), %rsi
movq (%rax), %rdi
movsbq (%rdi,%rsi,4), %rdi
movl %r15d, (%rbx,%rdi,4)
movl %r15d, (%rbx,%rsi,4)
movb %sil, (%rdi,%rcx)
movb %sil, (%rsi,%rcx)
movb %sil, (%r15,%rdx)
incq %r15
addq $0x10, %r14
cmpq $0x15, %r15
jne 0x25ba9
movb $0x58, %al
movb %al, 0x9bfea(%rip)      # 0xc1bc8
movb %al, 0x9c004(%rip)      # 0xc1be8
callq 0x26156
cmpb $0x0, 0x9d9bc(%rip)     # 0xc35ac
jne 0x25c5d
leaq 0x9be77(%rip), %rdi     # 0xc1a70
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, 0x9bec5(%rip)    # 0xc1ad1
movb $0x41, 0x9be9e(%rip)    # 0xc1ab1
movb $0x63, 0x9beb9(%rip)    # 0xc1ad3
movb $0x43, 0x9be92(%rip)    # 0xc1ab3
movb $0x67, 0x9beaf(%rip)    # 0xc1ad7
movb $0x47, 0x9be88(%rip)    # 0xc1ab7
movw $0x7574, 0x9beac(%rip)  # imm = 0x7574
movw $0x5554, 0x9be83(%rip)  # imm = 0x5554
movb $0x6e, %al
movb %al, 0x9be95(%rip)      # 0xc1ade
movb $0x4e, 0x9be6e(%rip)    # 0xc1abe
movb %al, 0x9be47(%rip)      # 0xc1a9d
movb $0x1, 0x9d94f(%rip)     # 0xc35ac
callq 0x260b1
movb $0x1, 0x9c417(%rip)     # 0xc2080
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rdx
leaq 0xc(%rsp), %rbx
movl $0x4, %esi
movl $0x3, %ecx
movq %rbx, %rdi
callq 0x23c98
movq %rbx, %rdi
movl $0x3, %esi
callq 0x21c6b
leaq 0x9ad7f(%rip), %r14     # 0xc0a25
movl $0x15, %r15d
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6330
testl %eax, %eax
je 0x25ccd
addq $0x10, %r14
decq %r15
jne 0x25cac
xorl %eax, %eax
jmp 0x25cd1
movb -0x1(%r14), %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
callq 0x6100
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movsbl (%rax,%rcx,4), %eax
leaq 0x9ad22(%rip), %rdx     # 0xc0a25
movl $0x15, %ecx
movsbl -0x1(%rdx), %esi
cmpl %esi, %eax
je 0x25d39
addq $0x10, %rdx
decq %rcx
jne 0x25d08
leaq 0x6aacd(%rip), %rdx     # 0x907ed
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23c18
movl $0x3, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23c98
movq (%r15), %rax
movsbq (%rbx), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: trimRefAlt
void trimRefAlt(char *ref, char *alt, uint *pStart, uint *pEnd, int *pRefLen, int *pAltLen)
/* If ref and alt have identical bases at beginning and/or end, trim those & update all params. */
{
int trimStart = 0;
while (ref[trimStart] != '\0' && alt[trimStart] != '\0' && ref[trimStart] == alt[trimStart])
    trimStart++;
int refLen = strlen(ref);
int altLen = strlen(alt);
int iR = refLen - 1, iA = altLen - 1, trimEnd = 0;
while (iR >= trimStart && iA >= trimStart && ref[iR] == alt[iA])
    {
    iR--;
    iA--;
    trimEnd++;
    }
if (trimEnd)
    {
    *pEnd -= trimEnd;
    refLen -= trimEnd;
    altLen -= trimEnd;
    ref[refLen] = '\0';
    alt[altLen] = '\0';
    }
if (trimStart)
    {
    *pStart += trimStart;
    refLen -= trimStart;
    altLen -= trimStart;
    memmove(ref, ref+trimStart, refLen+1);
    memmove(alt, alt+trimStart, altLen+1);
    }
*pRefLen = refLen;
*pAltLen = altLen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movb (%rdi), %al
xorl %r14d, %r14d
xorl %r12d, %r12d
testb %al, %al
je 0x25dab
cmpb (%r15,%r12), %al
jne 0x25da6
movb 0x1(%r13,%r12), %al
incq %r12
testb %al, %al
jne 0x25d94
movl %r12d, %ebp
jmp 0x25dad
xorl %ebp, %ebp
movq %r13, %rdi
callq 0x62d0
movq %rax, %rbx
movq %r15, %rdi
callq 0x62d0
movq %rax, %r8
cmpl %ebx, %ebp
setl %al
cmpl %r8d, %ebp
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x25e09
movslq %ebx, %rax
movslq %ebp, %rcx
movslq %r8d, %rdx
decq %rdx
decq %rax
xorl %r14d, %r14d
movb (%r13,%rax), %sil
cmpb (%r15,%rdx), %sil
jne 0x25e09
incl %r14d
cmpq %rcx, %rax
jle 0x25e09
leaq -0x1(%rdx), %rsi
decq %rax
cmpq %rcx, %rdx
movq %rsi, %rdx
jg 0x25de7
testl %r14d, %r14d
je 0x25e2d
movq 0x8(%rsp), %rax
subl %r14d, (%rax)
subl %r14d, %ebx
subl %r14d, %r8d
movslq %ebx, %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movslq %r8d, %rax
movb %cl, (%r15,%rax)
testl %ebp, %ebp
je 0x25e6a
leaq (%r12,%r13), %rsi
movq 0x10(%rsp), %rax
addl %ebp, (%rax)
subl %ebp, %ebx
subl %ebp, %r8d
leal 0x1(%rbx), %eax
movslq %eax, %rdx
movq %r13, %rdi
movq %r8, %r14
callq 0x6c60
addq %r15, %r12
leal 0x1(%r14), %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c60
movq %r14, %r8
movq 0x18(%rsp), %rax
movl %ebx, (%rax)
movq 0x20(%rsp), %rax
movl %r8d, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, 0x9d44b(%rip)     # 0xc35a8
jne 0x261ce
pushq %rax
leaq 0x9b809(%rip), %rdi     # 0xc1970
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, %al
movb %al, 0x9b836(%rip)      # 0xc19b1
movb %al, 0x9b850(%rip)      # 0xc19d1
movb $0x63, %al
movb %al, 0x9b82a(%rip)      # 0xc19b3
movb %al, 0x9b844(%rip)      # 0xc19d3
movb $0x67, %al
movb %al, 0x9b820(%rip)      # 0xc19b7
movb %al, 0x9b83a(%rip)      # 0xc19d7
movw $0x7574, %ax            # imm = 0x7574
movw %ax, 0x9b81c(%rip)      # 0xc19c4
movw %ax, 0x9b835(%rip)      # 0xc19e4
movb $0x6e, %al
movb %al, 0x9b807(%rip)      # 0xc19be
movb %al, 0x9b821(%rip)      # 0xc19de
movb %al, 0x9b7da(%rip)      # 0xc199d
movb $0x1, 0x9d3de(%rip)     # 0xc35a8
addq $0x8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq $0x0, 0x8(%rsp)
movq %rax, %rdi
movl $0x1, %edx
callq 0x27298
testq %rax, %rax
je 0x2747d
leaq 0x10(%rsp), %r14
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x27298
testq %rax, %rax
jne 0x2745c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq $0x0, (%rsp)
movq %rax, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x27298
testq %rax, %rax
je 0x274e2
leaq 0x8(%rsp), %rbx
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x27298
testq %rax, %rax
jne 0x274c3
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r12
callq 0x34368
movq %rax, %r15
testl %r15d, %r15d
jns 0x27556
leaq 0x69541(%rip), %rdi     # 0x90a8d
movq %r12, %rsi
xorl %eax, %eax
callq 0x26b6f
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x2dbbc
movq %rax, %r14
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x6d10
movl %eax, %ebp
movslq %r15d, %r15
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6aa0
testq %rax, %rax
jns 0x275a5
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x69500(%rip), %rdi     # 0x90a9b
movq %rax, %rsi
xorl %eax, %eax
callq 0x26b6f
movl %ebp, %edi
callq 0x6e80
movb $0x0, (%r14,%r15)
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movl %ebx, %esi
movl $0x1, %edx
callq 0x27298
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r15d
movl (%rcx), %r13d
testl %r13d, %r13d
je 0x277e1
movl %edi, %ebp
addl %r13d, %r13d
cmpl %r15d, %r13d
jae 0x277b8
leaq 0x6939a(%rip), %r12     # 0x90b38
addl %r13d, %r13d
jne 0x277b3
movl (%r14), %esi
movq %r12, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x26b6f
cmpl %r15d, %r13d
jb 0x2779e
movl %r13d, %edi
callq 0x2dbbc
movq %rax, %r15
movq (%rbx), %rsi
movslq %ebp, %rdx
movq %rax, %rdi
callq 0x6570
movq (%rbx), %rdi
callq 0x2dd41
movq %r15, (%rbx)
movl %r13d, (%r14)
jmp 0x277fd
movl $0x10000, %ecx          # imm = 0x10000
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %r15d, %eax
jb 0x277e6
movl %eax, (%r14)
movl %eax, %edi
callq 0x2dbbc
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
je 0x2784d
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
testq %rsi, %rsi
je 0x27836
leaq 0x6795e(%rip), %rsi     # 0x8f18a
movq %r15, %rdi
xorl %eax, %eax
callq 0x6a90
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x32, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x258fa
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x67424(%rip), %rsi     # 0x8ec89
callq 0x22d5a
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x2780c
movq %r12, %rdi
callq 0x66e0
testl %eax, %eax
je 0x278a2
leaq 0x68a71(%rip), %rdi     # 0x90301
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x26c9f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x673cd(%rip), %rsi     # 0x8ec89
callq 0x22d5a
movq %rax, %r14
testq %rbx, %rbx
je 0x278e1
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movq %r14, %rdi
callq 0x2780c
movq (%rbx), %rbx
jmp 0x278c4
movq %r14, %rdi
callq 0x66e0
testl %eax, %eax
je 0x27902
leaq 0x68a0d(%rip), %rdi     # 0x90301
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26c9f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x25b5c
testl %ebp, %ebp
jle 0x27b65
movl %ebp, %eax
xorl %ecx, %ecx
leaq 0x9a02c(%rip), %rdx     # 0xc1b70
movsbq (%rbx,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x58, %edi
testb %sil, %sil
je 0x27b59
movl %esi, %edi
movb %dil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x27b44
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x25b5c
testl %ebp, %ebp
jle 0x27bab
movl %ebp, %eax
xorl %ecx, %ecx
leaq 0x99de6(%rip), %rdx     # 0xc1970
movsbq (%rbx,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x6e, %edi
testb %sil, %sil
je 0x27b9f
movl %esi, %edi
movb %dil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x27b8a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %r9, %rax
movl %r8d, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq 0x20(%rsp), %r9
movq %rax, %r8
callq 0x2790a
testl %eax, %eax
je 0x27c1b
movl (%r15), %r15d
movq (%r14), %r14
xorl %eax, %eax
callq 0x25b5c
movl $0x1, %eax
testl %ebx, %ebx
je 0x27c1f
testl %r15d, %r15d
jle 0x27c4e
xorl %ecx, %ecx
leaq 0x99d78(%rip), %rdx     # 0xc1970
movsbq (%r14,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x6e, %edi
testb %sil, %sil
je 0x27c0d
movl %esi, %edi
movb %dil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x27bf8
jmp 0x27c4e
xorl %eax, %eax
jmp 0x27c4e
testl %r15d, %r15d
jle 0x27c4e
xorl %ecx, %ecx
leaq 0x99f43(%rip), %rdx     # 0xc1b70
movsbq (%r14,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x58, %edi
testb %sil, %sil
je 0x27c42
movl %esi, %edi
movb %dil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x27c2d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
xorl %edx, %edx
cmpl $0x2, %esi
sete %dl
movl %eax, %esi
callq 0x27d12
movq %rax, %r14
movl $0x12, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, %r15
testq %r14, %r14
je 0x27d03
leaq 0x68e38(%rip), %r12     # 0x90b02
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x28b2c
testq %rax, %rax
je 0x27cec
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26b6f
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x28dbe
movq (%r14), %r14
testq %r14, %r14
jne 0x27cca
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
xorl %esi, %esi
callq 0x2a1fc
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x27dad
movq %rax, %rbx
movq %r12, %rdi
callq 0x2ab48
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, 0x20(%rsp)
movq %rdi, %r12
movq $0x0, 0x18(%rsp)
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x24(%rsp), %r15
testl %ebp, %ebp
je 0x27e09
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
movq %r15, %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x2790a
jmp 0x27e2a
movq %rbx, (%rsp)
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
movq %r15, %rdx
leaq 0x10(%rsp), %rcx
movl 0x20(%rsp), %r8d
movq %r14, %r9
callq 0x27bb2
testl %eax, %eax
je 0x27e76
movl $0x28, %edi
callq 0x2dc95
movq %rax, %r13
movq 0x10(%rsp), %rdi
callq 0x1f9f6
movq %rax, 0x8(%r13)
movslq 0x24(%rsp), %rsi
movl %esi, 0x18(%r13)
movq 0x28(%rsp), %rdi
incq %rsi
callq 0x1f980
movq %rax, 0x10(%r13)
movq 0x18(%rsp), %rax
movq %rax, (%r13)
movq %r13, 0x18(%rsp)
jmp 0x27de8
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x1fcb3
movq %r14, %rdi
callq 0x2dd51
movl $0x0, (%rbx)
movq (%r15), %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x27edb
movq 0x8(%rsp), %rcx
movq %rcx, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x27ec2
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x1fcd6
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x27f36
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x27f36
xorl %ebx, %ebx
movq %rax, %r14
movq 0x28(%rdi), %rdi
movq 0x20(%rax), %rsi
callq 0x25807
addl %eax, %ebx
movq 0x8(%r14), %rax
movq %r14, %rdi
testq %rax, %rax
jne 0x27f18
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x27fd9
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rax
movl %eax, %ecx
subl %edx, %ecx
testl %ecx, %ecx
jle 0x27fc7
movq 0x20(%rdi), %r8
movl %ecx, %r9d
xorl %esi, %esi
movb (%rdx,%rsi), %r10b
cmpb (%r8,%rsi), %r10b
jne 0x27f9c
incq %rsi
cmpl %esi, %r9d
jne 0x27f88
movl %ecx, %esi
movl %esi, 0x30(%rdi)
testl %ecx, %ecx
jle 0x27fce
movq 0x28(%rdi), %rsi
xorl %edx, %edx
movq $-0x1, %r8
movb (%rax,%r8), %r9b
cmpb (%rsi,%r8), %r9b
jne 0x27fd0
incl %edx
decq %r8
cmpl %edx, %ecx
jne 0x27fb0
movl %ecx, %edx
jmp 0x27fd0
movl $0x0, 0x30(%rdi)
xorl %edx, %edx
movl %edx, 0x34(%rdi)
movq 0x8(%rdi), %rdi
jmp 0x27f6a
retq