LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: lookupCodon
AA lookupCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].protCode;
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x949d9(%rip)     # 0xb5470
jne 0x20a9e
callq 0x218af
xorl %eax, %eax
leaq 0x949d9(%rip), %rcx     # 0xb5480
xorl %edx, %edx
cmpq $0x3, %rax
je 0x20ac3
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x20ad7
leal (%rsi,%rdx,4), %edx
incq %rax
jmp 0x20aa9
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x93b4f(%rip), %rcx     # 0xb4620
movb 0x8(%rax,%rcx), %al
jmp 0x20ad9
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: isKozak
boolean isKozak(char *dna, int dnaSize, int pos)
/* Return TRUE if it's a Kozak compatible start. */
{
if (lookupCodon(dna+pos) != 'M')
   {
   return FALSE;
   }
if (pos + 3 < dnaSize)
    {
    if (ntVal[(int)dna[pos+3]] == G_BASE_VAL)
        return TRUE;
    }
if (pos >= 3)
    {
    int c = ntVal[(int)dna[pos-3]];
    if (c == A_BASE_VAL || c == G_BASE_VAL)
        return TRUE;
    }
return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movslq %edx, %r15
addq %r15, %rdi
callq 0x20a8c
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x4d, %cl
jne 0x20b47
addq $0x3, %r15
leaq 0x94966(%rip), %rcx     # 0xb5480
pushq $0x1
popq %rax
cmpl %r14d, %r15d
jge 0x20b2d
movsbq (%rbx,%r15), %rdx
cmpl $0x3, (%rcx,%rdx,4)
je 0x20b47
cmpl $0x3, %ebp
jl 0x20b45
movl %ebp, %edx
movsbq -0x3(%rbx,%rdx), %rdx
movl (%rcx,%rdx,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
je 0x20b47
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: lookupMitoCodon
AA lookupMitoCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].mitoCode;
c = toupper(c);
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x948f7(%rip)     # 0xb5470
jne 0x20b80
callq 0x218af
xorl %eax, %eax
leaq 0x948f7(%rip), %rcx     # 0xb5480
xorl %edx, %edx
cmpq $0x3, %rax
je 0x20ba5
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x20bc6
leal (%rsi,%rdx,4), %edx
incq %rax
jmp 0x20b8b
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x93a6d(%rip), %rcx     # 0xb4620
movsbq 0x9(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x20bc8
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: lookupUniqCodon
AA lookupUniqCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].uniqCode;
c = toupper(c);
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9489b(%rip)     # 0xb5470
jne 0x20bdc
callq 0x218af
xorl %eax, %eax
leaq 0x9489b(%rip), %rcx     # 0xb5480
xorl %edx, %edx
cmpq $0x3, %rax
je 0x20c01
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x20c22
leal (%rsi,%rdx,4), %edx
incq %rax
jmp 0x20be7
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x93a11(%rip), %rcx     # 0xb4620
movsbq 0xa(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x20c24
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: codonVal
Codon codonVal(DNA *start)
/* Return value from 0-63 of codon starting at start. 
 * Returns -1 if not a codon. */
{
int v1,v2,v3;

if ((v1 = ntVal[(int)start[0]]) < 0)
    return -1;
if ((v2 = ntVal[(int)start[1]]) < 0)
    return -1;
if ((v3 = ntVal[(int)start[2]]) < 0)
    return -1;
return ((v1<<4) + (v2<<2) + v3);
}

// Assembly:
movsbq (%rdi), %rax
leaq 0x9484f(%rip), %rsi     # 0xb5480
movl (%rsi,%rax,4), %ecx
movb $-0x1, %al
testl %ecx, %ecx
js 0x20c5a
movsbq 0x1(%rdi), %rdx
movl (%rsi,%rdx,4), %edx
testl %edx, %edx
js 0x20c5a
movsbq 0x2(%rdi), %rdi
movl (%rsi,%rdi,4), %esi
testl %esi, %esi
js 0x20c5a
shll $0x4, %ecx
leal (%rcx,%rdx,4), %eax
addl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: dnaTranslateSome
void dnaTranslateSome(DNA *dna, char *out, int outSize)
/* Translate DNA upto a stop codon or until outSize-1 amino acids, 
 * whichever comes first. Output will be zero terminated. */
{
int i;
int dnaSize;
int protSize = 0;

outSize -= 1;  /* Room for terminal zero */
dnaSize = strlen(dna);
for (i=0; i<dnaSize-2; i+=3)
    {
    if (protSize >= outSize)
        break;
    if ((out[protSize++] = lookupCodon(dna+i)) == 0)
        break;
    }
out[protSize] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
decl %ebp
callq 0x62d0
addl $-0x2, %eax
movslq %eax, %r12
movslq %ebp, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %r12, %rbp
jge 0x20cdc
cmpq %r13, %r15
jge 0x20cdc
leaq (%r14,%rbp), %rdi
callq 0x20a8c
movb %al, (%rbx,%r15)
incq %r15
addq $0x3, %rbp
testb %al, %al
jne 0x20cba
movslq %r15d, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnautil.c
// Function: complement
void complement(DNA *dna, long length)
{
int i;

if (!inittedCompTable) initNtCompTable();
for (i=0; i<length; ++i)
    {
    *dna = ntCompTable[(int)*dna];
    ++dna;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x94b7d(%rip)     # 0xb5880
jne 0x20d0a
callq 0x21aad
xorl %eax, %eax
testq %rbx, %rbx
cmovleq %rax, %rbx
leaq 0x94b76(%rip), %rcx     # 0xb5890
cmpq %rax, %rbx
je 0x20d30
movsbq (%r14,%rax), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r14,%rax)
incq %rax
jmp 0x20d1a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d6d3
movl %r15d, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
pushq $0x2f
popq %rsi
movq %r14, %rdi
movq %rdx, -0x48(%rbp)
movq %r15, -0x38(%rbp)
movl %r15d, %ecx
callq 0x1e6d7
movl %eax, %r12d
movslq %ebx, %r14
movq %r14, %rdi
callq 0x28bb0
movq %rax, %r15
decl %r12d
movl %r12d, -0x2c(%rbp)
xorl %r13d, %r13d
movl -0x2c(%rbp), %eax
addl %r13d, %eax
js 0x20e61
movl %eax, %eax
movq -0x48(%rbp), %rcx
movq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x20ea6
testl %eax, %eax
je 0x20e39
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x20d38
subl $0x1, %r13d
jb 0x20e51
movq %r15, %rdi
movq %r14, %rsi
leaq 0x63329(%rip), %rdx     # 0x84175
callq 0x1fb92
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1fb92
jmp 0x20e02
leaq 0x5e87b(%rip), %rdi     # 0x7f6e3
movq -0x40(%rbp), %rsi
callq 0x1db41
testl %eax, %eax
je 0x20e94
movq %r15, %rdi
addq $0x2, %rdi
movq -0x38(%rbp), %rax
addl $-0x2, %eax
movslq %eax, %rdx
movq %r15, %rsi
callq 0x6c60
movw $0x2f2d, (%r15)         # imm = 0x2F2D
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x21578
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
pushq $0x1
popq %rax
leaq 0x94acb(%rip), %rdx     # 0xb5990
cmpq %rcx, %rbx
je 0x20eda
movsbq (%r14,%rcx), %rsi
incq %rcx
cmpb $0x0, (%rsi,%rdx)
jne 0x20ec5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %eax, %eax
movsbq (%rdi,%rax), %rcx
movsbq (%rsi,%rax), %rdx
cmpb %dl, %cl
jne 0x20efc
incq %rax
testb %cl, %cl
jne 0x20ee4
xorl %eax, %eax
retq
leaq 0x9457d(%rip), %rsi     # 0xb5480
movl (%rsi,%rcx,4), %eax
subl (%rsi,%rdx,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20f1f
movb $0x75, %cl
cmpl $0x74, %eax
je 0x20f21
testl %eax, %eax
jne 0x20f23
jmp 0x20f28
movb $0x55, %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x20f0a
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
testl %esi, %esi
jle 0x20f40
xorl %ecx, %ecx
cmpb $0x2d, (%rax)
leaq 0x1(%rax), %rax
setne %cl
subl %ecx, %esi
jmp 0x20f2c
testb %dl, %dl
je 0x20f57
decq %rax
movq %rax, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x2d, 0x1(%rcx)
movq %rax, %rcx
je 0x20f4a
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x20f76
xorl %edx, %edx
cmpb $0x2d, (%rdi,%rcx)
setne %dl
addl %edx, %eax
incq %rcx
jmp 0x20f61
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21578
xorl %eax, %eax
movsbq (%r14), %rcx
testq %rcx, %rcx
je 0x20fb0
incq %r14
cmpb $0x1, (%rbx,%rcx)
sbbq $-0x1, %rax
jmp 0x20f9a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21578
movsbq (%r15), %rax
testq %rax, %rax
je 0x20fe6
incq %r15
movb (%r14,%rax), %al
testb %al, %al
je 0x20fcb
movb %al, (%rbx)
incq %rbx
jmp 0x20fcb
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21b52
xorl %eax, %eax
leaq 0x94971(%rip), %rcx     # 0xb5990
pushq $0x6e
popq %rdx
movsbq (%r14,%rax), %rsi
testq %rsi, %rsi
je 0x21042
movzbl (%rsi,%rcx), %esi
movl %edx, %edi
testb %sil, %sil
je 0x21039
movl %esi, %edi
movb %dil, (%rbx,%rax)
incq %rax
jmp 0x21022
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x210ac
movsbq (%r14,%r15), %r12
callq 0x6790
movq (%rax), %rax
testb $0x1, 0x1(%rax,%r12,2)
je 0x210a7
movb $0x6e, (%r14,%r15)
incq %r15
jmp 0x21088
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x210f2
movsbq (%r14,%r15), %r12
callq 0x6790
movq (%rax), %rax
testb $0x2, 0x1(%rax,%r12,2)
je 0x210ed
movb $0x4e, (%r14,%r15)
incq %r15
jmp 0x210ce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x21, %esi
jl 0x21145
leaq 0x5e5aa(%rip), %rdi     # 0x7f6e6
movl %ebx, %esi
xorl %eax, %eax
callq 0x223fb
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
leaq 0x94b3d(%rip), %rdx     # 0xb5c90
xorl %eax, %eax
cmpq %rcx, %rbx
je 0x2116c
movsbq (%r14,%rcx), %rsi
movslq (%rdx,%rsi,4), %rsi
leaq (%rsi,%rax,4), %rax
incq %rcx
jmp 0x21155
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl $0xf, %ecx
leaq 0x94ea4(%rip), %r8      # 0xb6090
cmpq %rsi, %rax
je 0x21221
movl (%rdi,%rax,4), %r9d
movl %ecx, %r10d
testl %r10d, %r10d
js 0x21218
movl %r9d, %r11d
andl $0x3, %r11d
movb (%r11,%r8), %r11b
movl %r10d, %ebx
movb %r11b, (%rdx,%rbx)
shrl $0x2, %r9d
decl %r10d
jmp 0x211f8
addq $0x10, %rdx
incq %rax
jmp 0x211ec
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl $0x3, %ecx
leaq 0x94e59(%rip), %r8      # 0xb6090
cmpq %rsi, %rax
je 0x21270
movb (%rdi,%rax), %r9b
movl %ecx, %r10d
testl %r10d, %r10d
js 0x21267
movzbl %r9b, %r9d
movl %r9d, %r11d
andl $0x3, %r11d
movb (%r11,%r8), %r11b
movl %r10d, %ebx
movb %r11b, (%rdx,%rbx)
shrb $0x2, %r9b
decl %r10d
jmp 0x21243
addq $0x4, %rdx
incq %rax
jmp 0x21237
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x212ba
movzbl (%rdi), %ecx
cmpl $0x63, %ecx
je 0x212a5
cmpl $0x67, %ecx
jne 0x212ba
cmpb $0x74, 0x1(%rdi)
jne 0x212ba
cmpb $0x61, -0x2(%rsi)
jne 0x212ba
cmpb $0x67, -0x1(%rsi)
jne 0x212ba
pushq $0x1
popq %rax
retq
cmpb $0x74, 0x1(%rdi)
jne 0x212ba
cmpb $0x61, -0x2(%rsi)
jne 0x212ba
cmpb $0x63, -0x1(%rsi)
jne 0x212ba
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %r10d, %r10d
testl %edx, %edx
cmovlel %r10d, %edx
xorl %eax, %eax
cmpq %r10, %rdx
je 0x21315
movb (%rdi,%r10), %r11b
cmpb %r9b, %r11b
je 0x21310
movb (%rsi,%r10), %bl
cmpb %r9b, %bl
je 0x21310
cmpb %bl, %r11b
movl %r8d, %r11d
cmovel %ecx, %r11d
addl %r11d, %eax
incq %r10
jmp 0x212ec
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0xa
popq %r12
testl %ebp, %ebp
jle 0x2139c
cmpl %ebx, %ebp
movl %ebx, %eax
cmovll %ebp, %eax
movslq %eax, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1ed3f
movl %r12d, %edi
movq %r15, %rsi
callq 0x6930
addq %r13, %r14
subl %r13d, %ebp
jmp 0x2136d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r9d, %r11d
testl %eax, %eax
jle 0x21419
decq %rax
movl %eax, %ebx
movb (%rdi,%rbx), %bl
andb $-0x21, %bl
cmpb $0x4e, %bl
je 0x213ca
cmpl $0x14, %r9d
cmovgel %r10d, %r9d
cmpb $0x41, %bl
jne 0x21408
incl %r9d
cmpl %r11d, %r9d
jge 0x2140e
leal -0x8(%r11), %ebx
cmpl %ebx, %r9d
movl %eax, %ebx
cmovll %r8d, %ebx
testl %ecx, %ecx
cmovnel %ebx, %r8d
jmp 0x21414
addl $-0xa, %r9d
jmp 0x21414
movl %r9d, %r11d
movl %eax, %r8d
testl %r9d, %r9d
jns 0x213ca
xorl %eax, %eax
testl %r8d, %r8d
js 0x21449
movl %esi, %ecx
subl %r8d, %ecx
cmpl $0x3, %ecx
jl 0x21449
addl $-0x2, %ecx
testl %edx, %edx
je 0x21447
movslq %esi, %rax
subl %ecx, %esi
movslq %esi, %rdx
cmpq %rax, %rdx
jge 0x21447
movb $0x6e, (%rdi,%rdx)
incq %rdx
jmp 0x21439
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
pushq $-0x1
popq %rbx
pushq $0xa
popq %r8
pushq $0x14
popq %r9
movl %r8d, %r10d
cmpq %rax, %rsi
je 0x214c6
movb (%rdi,%rax), %r11b
andb $-0x21, %r11b
cmpb $0x4e, %r11b
je 0x214c1
cmpl $0x14, %r8d
cmovgel %r9d, %r8d
cmpb $0x54, %r11b
jne 0x214b1
incl %r8d
cmpl %r10d, %r8d
jge 0x214b7
leal -0x8(%r10), %r11d
cmpl %r11d, %r8d
movl %eax, %r11d
cmovll %ebx, %r11d
testl %ecx, %ecx
cmovnel %r11d, %ebx
jmp 0x214bc
addl $-0xa, %r8d
jmp 0x214bc
movl %r8d, %r10d
movl %eax, %ebx
testl %r8d, %r8d
js 0x214c6
incq %rax
jmp 0x21472
xorl %eax, %eax
testl %ebx, %ebx
js 0x214e3
cmpl $0x2, %ebx
jb 0x214e3
decl %ebx
testl %edx, %edx
je 0x214e1
movl %ebx, %edx
pushq $0x6e
popq %rsi
callq 0x63b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21578
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
leaq 0x94480(%rip), %rsi     # 0xb5990
xorl %ecx, %ecx
cmpq %rax, %rdx
je 0x21528
movsbq (%r14,%rax), %rdi
cmpb $0x1, (%rdi,%rsi)
sbbl $-0x1, %ecx
incq %rax
jmp 0x21512
cvtsi2sd %ebx, %xmm0
mulsd 0x5bffc(%rip), %xmm0    # 0x7d530
addsd 0x5c85c(%rip), %xmm0    # 0x7dd98
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_O2/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, 0x94b21(%rip)     # 0xb60a0
jne 0x2168e
pushq %r15
pushq %r14
pushq %rbx
callq 0x218af
xorl %eax, %eax
leaq 0x95c18(%rip), %rbx     # 0xb71b0
cmpq $0x400, %rax            # imm = 0x400
je 0x215aa
orl $-0x1, (%rax,%rbx)
addq $0x4, %rax
jmp 0x21598
leaq 0x93473(%rip), %r14     # 0xb4a24
xorl %r15d, %r15d
callq 0x6160
leaq 0x945d0(%rip), %rcx     # 0xb5b90
leaq 0x95fe9(%rip), %rdx     # 0xb75b0
cmpq $0x15, %r15
je 0x215f6
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
jmp 0x215c7
movb $0x58, %al
movb %al, 0x945ea(%rip)      # 0xb5be8
movb %al, 0x94604(%rip)      # 0xb5c08
callq 0x21b52
cmpb $0x0, 0x95fbc(%rip)     # 0xb75cc
jne 0x2167d
leaq 0x94477(%rip), %rdi     # 0xb5a90
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, 0x944c5(%rip)    # 0xb5af1
movb $0x41, 0x9449e(%rip)    # 0xb5ad1
movb $0x63, 0x944b9(%rip)    # 0xb5af3
movb $0x43, 0x94492(%rip)    # 0xb5ad3
movb $0x67, 0x944af(%rip)    # 0xb5af7
movb $0x47, 0x94488(%rip)    # 0xb5ad7
movw $0x7574, 0x944ac(%rip)  # imm = 0x7574
movw $0x5554, 0x94483(%rip)  # imm = 0x5554
movb $0x6e, %al
movb %al, 0x94495(%rip)      # 0xb5afe
movb $0x4e, 0x9446e(%rip)    # 0xb5ade
movb %al, 0x94447(%rip)      # 0xb5abd
movb $0x1, 0x95f4f(%rip)     # 0xb75cc
callq 0x21aad
movb $0x1, 0x94a17(%rip)     # 0xb60a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rdx
leaq 0x4(%rsp), %rbx
pushq $0x4
popq %rsi
pushq $0x3
popq %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1fb32
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x1df8a
pushq $0x16
popq %r15
leaq 0x9335e(%rip), %rsi     # 0xb4a25
decq %r15
je 0x216e9
leaq 0x10(%rsi), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6330
movq %r12, %rsi
testl %eax, %eax
jne 0x216c7
movb -0x11(%r12), %al
jmp 0x216eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x16
popq %rcx
leaq 0x932f3(%rip), %rdx     # 0xb4a15
decq %rcx
je 0x21758
movsbl 0xf(%rdx), %esi
addq $0x10, %rdx
cmpl %esi, %eax
jne 0x21722
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fb32
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
leaq 0x5e07e(%rip), %rdx     # 0x7f7dd
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1fab2
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
movq %rsi, %r15
movq %rdi, %r13
xorl %r14d, %r14d
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %r12d, %r12d
movb (%r13,%r12), %cl
testb %cl, %cl
je 0x217c6
cmpb (%r15,%r12), %cl
jne 0x217c6
incq %r12
addq %rax, %r14
jmp 0x217af
leaq (%r12,%r13), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x62d0
movq %rax, %rbp
movq %r15, %rdi
callq 0x62d0
movq %rax, %r9
movl %r9d, %r10d
movl %ebp, %r8d
movslq %ebp, %rdx
sarq $0x20, %r14
movslq %r9d, %rsi
leaq (%r15,%rsi), %rax
leaq (%rdx,%r13), %rcx
xorl %ebx, %ebx
leaq (%rdx,%rbx), %rdi
cmpq %r14, %rdi
jle 0x21822
leaq (%rsi,%rbx), %rdi
cmpq %r14, %rdi
jle 0x21822
movb -0x1(%rcx,%rbx), %dil
cmpb -0x1(%rax,%rbx), %dil
jne 0x21822
decq %rbx
jmp 0x217ff
testl %ebx, %ebx
movl %r8d, %r14d
je 0x21840
movq 0x8(%rsp), %rdx
addl %ebx, (%rdx)
leal (%rbx,%rbp), %r14d
leal (%r9,%rbx), %r10d
xorl %edx, %edx
movb %dl, (%rbx,%rcx)
movb %dl, (%rbx,%rax)
testq %r12, %r12
je 0x21890
movq (%rsp), %rax
addl %r12d, (%rax)
subl %r12d, %ebp
leal (%rbx,%rbp), %r14d
subl %r12d, %r9d
leal (%r9,%rbx), %eax
movl %eax, (%rsp)
leal (%rbx,%rbp), %eax
incl %eax
movslq %eax, %rdx
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r9, %r13
callq 0x6c60
addq %r15, %r12
leal (%rbx,%r13), %eax
incl %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c60
movl (%rsp), %r10d
movq 0x18(%rsp), %rax
movl %r14d, (%rax)
movq 0x20(%rsp), %rax
movl %r10d, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x95a6f(%rip)     # 0xb75c8
jne 0x21bca
pushq %rax
leaq 0x93e2d(%rip), %rdi     # 0xb5990
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, %al
movb %al, 0x93e5a(%rip)      # 0xb59d1
movb %al, 0x93e74(%rip)      # 0xb59f1
movb $0x63, %al
movb %al, 0x93e4e(%rip)      # 0xb59d3
movb %al, 0x93e68(%rip)      # 0xb59f3
movb $0x67, %al
movb %al, 0x93e44(%rip)      # 0xb59d7
movb %al, 0x93e5e(%rip)      # 0xb59f7
movw $0x7574, %ax            # imm = 0x7574
movw %ax, 0x93e40(%rip)      # 0xb59e4
movw %ax, 0x93e59(%rip)      # 0xb5a04
movb $0x6e, %al
movb %al, 0x93e2b(%rip)      # 0xb59de
movb %al, 0x93e45(%rip)      # 0xb59fe
movb %al, 0x93dfe(%rip)      # 0xb59bd
movb $0x1, 0x95a02(%rip)     # 0xb75c8
addq $0x8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
jne 0x226c4
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x94efa(%rip)     # 0xb75d0
je 0x22718
leaq 0x5d2bf(%rip), %rdi     # 0x7f99e
callq 0x6bb0
leaq 0x5d2cc(%rip), %rdi     # 0x7f9b7
callq 0x6bb0
movq 0x908b9(%rip), %r15     # 0xb2fb0
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x69e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x6930
movq (%r15), %rdi
callq 0x6870
movq 0x90891(%rip), %rax     # 0xb2fb0
movq (%rax), %rdi
callq 0x6870
movq 0x908aa(%rip), %r15     # 0xb2fd8
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x69e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x6930
movq (%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6870
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
xorl %r15d, %r15d
movq %r15, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x22b22
testq %rax, %rax
je 0x22ce1
movq %r15, (%rax)
movq %rax, %r15
jmp 0x22cc6
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rsp)
movq %rbx, %rdi
callq 0x22ca6
testq %rax, %rax
je 0x22d25
movq %r14, (%rax)
movq %rax, %r14
jmp 0x22d0b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r12
callq 0x2ed50
movq %rax, %r15
testl %r15d, %r15d
jns 0x22d8d
leaq 0x5ccfa(%rip), %rdi     # 0x7fa7d
movq %r12, %rsi
xorl %eax, %eax
callq 0x223fb
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x28ad7
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 0x22ddc
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x5ccb9(%rip), %rdi     # 0x7fa8b
movq %rax, %rsi
xorl %eax, %eax
callq 0x223fb
movl %ebp, %edi
callq 0x6e80
movb $0x0, (%r14,%r15)
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22d3d
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl (%rcx), %r13d
testl %r13d, %r13d
je 0x22ff9
movl %edi, %r15d
addl %r13d, %r13d
leaq 0x5cb73(%rip), %r12     # 0x7fb28
cmpl %ebp, %r13d
jae 0x22fd0
addl %r13d, %r13d
jne 0x22fb5
movl (%r14), %esi
movq %r12, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x223fb
jmp 0x22fb5
movl %r13d, %edi
callq 0x28ad7
movq %rax, %r12
movq (%rbx), %rsi
movslq %r15d, %rdx
movq %rax, %rdi
callq 0x6570
movq (%rbx), %rdi
callq 0x28c2d
movq %r12, (%rbx)
movl %r13d, (%r14)
jmp 0x23014
movl $0x10000, %ecx          # imm = 0x10000
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %ebp, %eax
jb 0x22ffe
movl %eax, (%r14)
movl %eax, %edi
callq 0x28ad7
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_O2/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 0x23062
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
testq %rsi, %rsi
je 0x2304d
leaq 0x5b137(%rip), %rsi     # 0x7e17a
movq %r15, %rdi
xorl %eax, %eax
callq 0x6a90
pushq $0x32
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x21354
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5abff(%rip), %rsi     # 0x7dc79
callq 0x1ec79
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x23023
movq %r12, %rdi
callq 0x66e0
testl %eax, %eax
je 0x230b7
leaq 0x5c24c(%rip), %rdi     # 0x7f2f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22504
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5aba8(%rip), %rsi     # 0x7dc79
callq 0x1ec79
movq %rax, %r14
testq %rbx, %rbx
je 0x230f6
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movq %r14, %rdi
callq 0x23023
movq (%rbx), %rbx
jmp 0x230d9
movq %r14, %rdi
callq 0x66e0
testl %eax, %eax
je 0x23117
leaq 0x5c1e8(%rip), %rdi     # 0x7f2f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22504
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x21578
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x92861(%rip), %rax     # 0xb5b90
pushq $0x58
popq %rcx
cmpq %r15, %rbx
je 0x23351
movsbq (%r14,%r15), %rdx
movzbl (%rax,%rdx), %edx
movl %ecx, %esi
testb %dl, %dl
je 0x23348
movl %edx, %esi
movb %sil, (%r14,%r15)
incq %r15
jmp 0x23332
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x21578
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x92618(%rip), %rax     # 0xb5990
pushq $0x6e
popq %rcx
cmpq %r15, %rbx
je 0x2339a
movsbq (%r14,%r15), %rdx
movzbl (%rax,%rdx), %edx
movl %ecx, %esi
testb %dl, %dl
je 0x23391
movl %edx, %esi
movb %sil, (%r14,%r15)
incq %r15
jmp 0x2337b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2311f
testl %eax, %eax
je 0x233d3
movl (%r15), %esi
movq (%r14), %rdi
testl %ebx, %ebx
je 0x233d7
callq 0x23357
jmp 0x233dc
xorl %eax, %eax
jmp 0x233df
callq 0x2330e
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2349a
movq %rax, %r14
pushq $0x12
popq %rdi
pushq $0x1
popq %rsi
callq 0x245c9
movq %rax, %r15
leaq 0x5c6a2(%rip), %r12     # 0x7faf2
testq %r14, %r14
je 0x2348b
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x24088
testq %rax, %rax
je 0x23477
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x223fb
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x242d0
movq (%r14), %r14
jmp 0x23450
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25467
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x23531
movq %rax, %rbx
movq %r12, %rdi
callq 0x25cd8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq