LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x25b6e
pushq %rbx
movl %edx, %edx
xorl %r10d, %r10d
xorl %eax, %eax
movb (%rdi,%r10), %r11b
cmpb %r9b, %r11b
je 0x25b64
movb (%rsi,%r10), %bl
cmpb %r9b, %bl
je 0x25b64
cmpb %bl, %r11b
movl %r8d, %r11d
cmovel %ecx, %r11d
addl %r11d, %eax
incq %r10
cmpq %r10, %rdx
jne 0x25b45
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25c50
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 0x23138
movl $0xa, %edi
movq %r15, %rsi
callq 0x6930
addq %r12, %r14
subl %r12d, %ebp
jg 0x25c1b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25cc4
decq %rax
movl %eax, %ebx
movb (%rdi,%rbx), %bl
andb $-0x21, %bl
cmpb $0x4e, %bl
je 0x25c75
cmpl $0x14, %r9d
cmovgel %r10d, %r9d
cmpb $0x41, %bl
jne 0x25cb3
incl %r9d
cmpl %r11d, %r9d
jge 0x25cb9
leal -0x8(%r11), %ebx
cmpl %ebx, %r9d
movl %eax, %ebx
cmovll %r8d, %ebx
testl %ecx, %ecx
cmovnel %ebx, %r8d
jmp 0x25cbf
addl $-0xa, %r9d
jmp 0x25cbf
movl %r9d, %r11d
movl %eax, %r8d
testl %r9d, %r9d
jns 0x25c75
xorl %eax, %eax
testl %r8d, %r8d
js 0x25d03
movl %esi, %ebx
subl %r8d, %ebx
cmpl $0x3, %ebx
jl 0x25d03
addl $-0x2, %ebx
testl %edx, %edx
je 0x25d01
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_O3/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 0x25e47
testl %ebx, %ebx
jle 0x25df5
movl %ebx, %eax
xorl %edx, %edx
leaq 0x9bb93(%rip), %rsi     # 0xc1970
xorl %ecx, %ecx
movsbq (%r14,%rdx), %rdi
cmpb $0x1, (%rdi,%rsi)
sbbl $-0x1, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x25ddf
jmp 0x25df7
xorl %ecx, %ecx
cvtsi2sd %ebx, %xmm0
mulsd 0x6878d(%rip), %xmm0    # 0x8e590
addsd 0x6905d(%rip), %xmm0    # 0x8ee68
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_O3/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, 0x9c232(%rip)     # 0xc2080
jne 0x25f59
pushq %r15
pushq %r14
pushq %rbx
callq 0x2616b
leaq 0x9d32b(%rip), %rbx     # 0xc3190
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movl $0xff, %esi
callq 0x63b0
leaq 0x9aba6(%rip), %r14     # 0xc0a24
xorl %r15d, %r15d
callq 0x6160
leaq 0x9bce3(%rip), %rcx     # 0xc1b70
leaq 0x9d6fc(%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 0x25e94
movb $0x58, %al
movb %al, 0x9bcff(%rip)      # 0xc1bc8
movb %al, 0x9bd19(%rip)      # 0xc1be8
callq 0x26464
cmpb $0x0, 0x9d6d1(%rip)     # 0xc35ac
jne 0x25f48
leaq 0x9bb8c(%rip), %rdi     # 0xc1a70
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, 0x9bbda(%rip)    # 0xc1ad1
movb $0x41, 0x9bbb3(%rip)    # 0xc1ab1
movb $0x63, 0x9bbce(%rip)    # 0xc1ad3
movb $0x43, 0x9bba7(%rip)    # 0xc1ab3
movb $0x67, 0x9bbc4(%rip)    # 0xc1ad7
movb $0x47, 0x9bb9d(%rip)    # 0xc1ab7
movw $0x7574, 0x9bbc1(%rip)  # imm = 0x7574
movw $0x5554, 0x9bb98(%rip)  # imm = 0x5554
movb $0x6e, %al
movb %al, 0x9bbaa(%rip)      # 0xc1ade
movb $0x4e, 0x9bb83(%rip)    # 0xc1abe
movb %al, 0x9bb5c(%rip)      # 0xc1a9d
movb $0x1, 0x9d664(%rip)     # 0xc35ac
callq 0x263bf
movb $0x1, 0x9c12c(%rip)     # 0xc2080
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23fb3
movq %rbx, %rdi
movl $0x3, %esi
callq 0x21fca
leaq 0x9aa94(%rip), %r14     # 0xc0a25
movl $0x15, %r15d
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6330
testl %eax, %eax
je 0x25fb8
addq $0x10, %r14
decq %r15
jne 0x25f97
xorl %eax, %eax
jmp 0x25fbc
movb -0x1(%r14), %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9aa37(%rip), %rdx     # 0xc0a25
movl $0x15, %ecx
movsbl -0x1(%rdx), %esi
cmpl %esi, %eax
je 0x26024
addq $0x10, %rdx
decq %rcx
jne 0x25ff3
leaq 0x6a8d3(%rip), %rdx     # 0x908de
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f33
movl $0x3, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23fb3
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_O3/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 %r12d, %r12d
testb %al, %al
je 0x26093
cmpb (%r15,%r12), %al
jne 0x2608e
movb 0x1(%r13,%r12), %al
incq %r12
testb %al, %al
jne 0x2607c
movl %r12d, %r14d
jmp 0x26096
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x62d0
movq %rax, %rbp
movq %r15, %rdi
callq 0x62d0
movq %rax, %rbx
cmpl %ebp, %r14d
setl %al
cmpl %ebx, %r14d
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x26115
movslq %ebp, %rcx
movslq %r14d, %rdx
movslq %ebx, %rsi
decq %rsi
decq %rcx
xorl %eax, %eax
movb (%r13,%rcx), %dil
cmpb (%r15,%rsi), %dil
jne 0x260f3
decl %eax
cmpq %rdx, %rcx
jle 0x260f7
leaq -0x1(%rsi), %rdi
decq %rcx
cmpq %rdx, %rsi
movq %rdi, %rsi
jg 0x260d0
jmp 0x260f7
testl %eax, %eax
je 0x26115
negl %eax
movq 0x8(%rsp), %rcx
subl %eax, (%rcx)
subl %eax, %ebp
subl %eax, %ebx
movslq %ebp, %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movslq %ebx, %rax
movb %cl, (%r15,%rax)
testl %r14d, %r14d
je 0x2614e
leaq (%r12,%r13), %rsi
movq 0x10(%rsp), %rax
addl %r14d, (%rax)
subl %r14d, %ebp
subl %r14d, %ebx
leal 0x1(%rbp), %eax
movslq %eax, %rdx
movq %r13, %rdi
callq 0x6c60
addq %r15, %r12
leal 0x1(%rbx), %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c60
movq 0x18(%rsp), %rax
movl %ebp, (%rax)
movq 0x20(%rsp), %rax
movl %ebx, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9d13d(%rip)     # 0xc35a8
jne 0x264dc
pushq %rax
leaq 0x9b4fb(%rip), %rdi     # 0xc1970
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x63b0
movb $0x61, %al
movb %al, 0x9b528(%rip)      # 0xc19b1
movb %al, 0x9b542(%rip)      # 0xc19d1
movb $0x63, %al
movb %al, 0x9b51c(%rip)      # 0xc19b3
movb %al, 0x9b536(%rip)      # 0xc19d3
movb $0x67, %al
movb %al, 0x9b512(%rip)      # 0xc19b7
movb %al, 0x9b52c(%rip)      # 0xc19d7
movw $0x7574, %ax            # imm = 0x7574
movw %ax, 0x9b50e(%rip)      # 0xc19c4
movw %ax, 0x9b527(%rip)      # 0xc19e4
movb $0x6e, %al
movb %al, 0x9b4f9(%rip)      # 0xc19be
movb %al, 0x9b513(%rip)      # 0xc19de
movb %al, 0x9b4cc(%rip)      # 0xc199d
movb $0x1, 0x9d0d0(%rip)     # 0xc35a8
addq $0x8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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), %rax
movq %rdi, (%rax)
movq $0x0, (%rsp)
movq %rax, %rdi
movl $0x1, %edx
callq 0x275c0
testq %rax, %rax
je 0x277b2
movq %rax, %r14
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movq %rcx, (%r14)
movq %r14, (%rsp)
movq %r15, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x275c0
movq %r14, %rcx
movq %rax, %r14
testq %rax, %rax
jne 0x27791
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rax
movq %rdi, (%rax)
movq $0x0, 0x8(%rsp)
movq %rax, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x275c0
testq %rax, %rax
je 0x27822
movq %rax, %rbx
xorl %ecx, %ecx
leaq 0x10(%rsp), %r14
movq %rcx, (%rbx)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x275c0
movq %rbx, %rcx
movq %rax, %rbx
testq %rax, %rax
jne 0x27800
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x34694
movq %rax, %r15
testl %r15d, %r15d
jns 0x2789a
leaq 0x692ed(%rip), %rdi     # 0x90b7d
movq %r12, %rsi
xorl %eax, %eax
callq 0x26e94
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x2df1b
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 0x278e9
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x692ac(%rip), %rdi     # 0x90b8b
movq %rax, %rsi
xorl %eax, %eax
callq 0x26e94
movl %ebp, %edi
callq 0x6e80
movb $0x0, (%r14,%r15)
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movl %ebx, %esi
movl $0x1, %edx
callq 0x275c0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27b25
movl %edi, %ebp
addl %r13d, %r13d
cmpl %r15d, %r13d
jae 0x27afc
leaq 0x69146(%rip), %r12     # 0x90c28
addl %r13d, %r13d
jne 0x27af7
movl (%r14), %esi
movq %r12, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x26e94
cmpl %r15d, %r13d
jb 0x27ae2
movl %r13d, %edi
callq 0x2df1b
movq %rax, %r15
movq (%rbx), %rsi
movslq %ebp, %rdx
movq %rax, %rdi
callq 0x6570
movq (%rbx), %rdi
callq 0x2e0a0
movq %r15, (%rbx)
movl %r13d, (%r14)
jmp 0x27b41
movl $0x10000, %ecx          # imm = 0x10000
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %r15d, %eax
jb 0x27b2a
movl %eax, (%r14)
movl %eax, %edi
callq 0x2df1b
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_O3/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 0x27b91
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
testq %rsi, %rsi
je 0x27b7a
leaq 0x676da(%rip), %rsi     # 0x8f24a
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 0x25c05
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x671a0(%rip), %rsi     # 0x8ed49
callq 0x23072
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x27b50
movq %r12, %rdi
callq 0x66e0
testl %eax, %eax
je 0x27be6
leaq 0x687ed(%rip), %rdi     # 0x903c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x26fc7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x67149(%rip), %rsi     # 0x8ed49
callq 0x23072
movq %rax, %r14
testq %rbx, %rbx
je 0x27c25
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movq %r14, %rdi
callq 0x27b50
movq (%rbx), %rbx
jmp 0x27c08
movq %r14, %rdi
callq 0x66e0
testl %eax, %eax
je 0x27c46
leaq 0x68789(%rip), %rdi     # 0x903c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26fc7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25e47
testl %ebp, %ebp
jle 0x27eb6
movl %ebp, %eax
xorl %ecx, %ecx
leaq 0x99cdb(%rip), %rdx     # 0xc1b70
movsbq (%rbx,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x58, %edi
testb %sil, %sil
je 0x27eaa
movl %esi, %edi
movb %dil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x27e95
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25e47
testl %ebp, %ebp
jle 0x27efc
movl %ebp, %eax
xorl %ecx, %ecx
leaq 0x99a95(%rip), %rdx     # 0xc1970
movsbq (%rbx,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x6e, %edi
testb %sil, %sil
je 0x27ef0
movl %esi, %edi
movb %dil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x27edb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27c4e
testl %eax, %eax
je 0x27f6c
movl (%r15), %r15d
movq (%r14), %r14
xorl %eax, %eax
callq 0x25e47
movl $0x1, %eax
testl %ebx, %ebx
je 0x27f70
testl %r15d, %r15d
jle 0x27f9f
xorl %ecx, %ecx
leaq 0x99a27(%rip), %rdx     # 0xc1970
movsbq (%r14,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x6e, %edi
testb %sil, %sil
je 0x27f5e
movl %esi, %edi
movb %dil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x27f49
jmp 0x27f9f
xorl %eax, %eax
jmp 0x27f9f
testl %r15d, %r15d
jle 0x27f9f
xorl %ecx, %ecx
leaq 0x99bf2(%rip), %rdx     # 0xc1b70
movsbq (%r14,%rcx), %rsi
movzbl (%rdx,%rsi), %esi
movl $0x58, %edi
testb %sil, %sil
je 0x27f93
movl %esi, %edi
movb %dil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x27f7e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x28063
movq %rax, %r14
movl $0x12, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r15
testq %r14, %r14
je 0x28054
leaq 0x68bd7(%rip), %r12     # 0x90bf2
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x28eb0
testq %rax, %rax
je 0x2803d
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26e94
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x29142
movq (%r14), %r14
testq %r14, %r14
jne 0x2801b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a550
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x280fe
movq %rax, %rbx
movq %r12, %rdi
callq 0x2ae73
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1c(%rsp)
movq %rdi, %r12
movq $0x0, 0x28(%rsp)
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
xorl %r13d, %r13d
testl %ebp, %ebp
je 0x2815a
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x27c4e
jmp 0x2817d
movq %rbx, (%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %r8d
movq %r14, %r9
callq 0x27f03
testl %eax, %eax
je 0x281c6
movl $0x28, %edi
callq 0x2dff4
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x1feba
movq %rax, 0x8(%r15)
movslq 0xc(%rsp), %rsi
movl %esi, 0x18(%r15)
movq 0x20(%rsp), %rdi
incq %rsi
callq 0x1fe44
movq %rax, 0x10(%r15)
movq %r13, (%r15)
movq %r15, 0x28(%rsp)
movq %r15, %r13
jmp 0x28137
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x20173
movq %r14, %rdi
callq 0x2e0b0
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_O3/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
testq %rax, %rax
je 0x28221
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x28208
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
callq 0x20196
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2827c
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2827c
xorl %ebx, %ebx
movq %rax, %r14
movq 0x28(%rdi), %rdi
movq 0x20(%rax), %rsi
callq 0x25b12
addl %eax, %ebx
movq 0x8(%r14), %rax
movq %r14, %rdi
testq %rax, %rax
jne 0x2825e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2831b
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rax
movl %eax, %ecx
subl %edx, %ecx
testl %ecx, %ecx
jle 0x28309
movq 0x20(%rdi), %r8
movl %ecx, %r9d
xorl %esi, %esi
movb (%rdx,%rsi), %r10b
cmpb (%r8,%rsi), %r10b
jne 0x282e2
incq %rsi
cmpl %esi, %r9d
jne 0x282ce
movl %ecx, %esi
movl %esi, 0x30(%rdi)
movq 0x28(%rdi), %rsi
xorl %edx, %edx
movq $-0x1, %r8
movb (%rax,%r8), %r9b
cmpb (%rsi,%r8), %r9b
jne 0x28312
incl %edx
decq %r8
cmpl %edx, %ecx
jne 0x282f2
movl %ecx, %edx
jmp 0x28312
movl $0x0, 0x30(%rdi)
xorl %edx, %edx
movl %edx, 0x34(%rdi)
movq 0x8(%rdi), %rdi
jmp 0x282b0
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffAli.c
// Function: ffAliFromSym
struct ffAli *ffAliFromSym(int symCount, char *nSym, char *hSym,
	struct lm *lm, char *nStart, char *hStart)
/* Convert symbol representation of alignments (letters plus '-')
 * to ffAli representation.  If lm is nonNULL, ffAli result 
 * will be lmAlloced, else it will be needMemed. This routine
 * depends on nSym/hSym being zero terminated. */
{
struct ffAli *ffList = NULL, *ff = NULL;
char n, h;
int i;

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

// Assembly:
testl %edi, %edi
js 0x28429
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
incl %edi
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r8d, %r8d
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movzbl (%rsi,%r12), %r13d
movb (%rdx,%r12), %bpl
cmpb $0x2d, %bpl
je 0x28390
testl %r13d, %r13d
je 0x28390
cmpl $0x2d, %r13d
je 0x28390
testb %bpl, %bpl
je 0x28390
testq %r8, %r8
je 0x283d2
movq %r8, %rax
jmp 0x283a9
testq %r8, %r8
jne 0x28399
xorl %eax, %eax
jmp 0x283a9
movq %r14, 0x18(%r8)
movq %rbx, 0x28(%r8)
movq %r15, (%r8)
xorl %eax, %eax
movq %r8, %r15
xorl %r8d, %r8d
cmpb $0x2d, %bpl
setne %r8b
xorl %r9d, %r9d
cmpl $0x2d, %r13d
setne %r9b
addq %r9, %r14
addq %r8, %rbx
incq %r12
movq %rax, %r8
cmpq %r12, %rdi
jne 0x28367
jmp 0x2840e
testq %rcx, %rcx
je 0x283e6
movl $0x38, %esi
movq %rcx, %rdi
callq 0x2c325
jmp 0x283f0
movl $0x38, %edi
callq 0x2dff4
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
jmp 0x283a9
testq %r15, %r15
je 0x2842c
xorl %ecx, %ecx
movq %r15, %rax
movq %rcx, 0x8(%r15)
movq (%r15), %r15
movq %rax, %rcx
testq %r15, %r15
jne 0x28415
jmp 0x2842e
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreMatch
int ffScoreMatch(DNA *a, DNA *b, int size)
/* Compare two pieces of DNA base by base. Total mismatches are
 * subtracted from total matches and returned as score. 'N's 
 * neither hurt nor help score. */
{
int i;
int score = 0;
for (i=0; i<size; ++i)
    {
    DNA aa = a[i];
    DNA bb = b[i];
    if (aa == 'n' || bb == 'n')
        continue;
    if (aa == bb)
        ++score;
    else
        score -= 1;
    }
return score;
}

// Assembly:
testl %edx, %edx
jle 0x28487
movl %edx, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
xorl %eax, %eax
movb (%rdi,%r8), %r9b
movb (%rsi,%r8), %r10b
xorl %r11d, %r11d
cmpb %r10b, %r9b
sete %r11b
cmpb $0x6e, %r10b
leal -0x1(%r11,%r11), %r10d
cmovel %edx, %r10d
cmpb $0x6e, %r9b
cmovel %edx, %r10d
addl %r10d, %eax
incq %r8
cmpq %r8, %rcx
jne 0x28454
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcCdnaGapPenalty
int ffCalcCdnaGapPenalty(int hGap, int nGap)
/* Return gap penalty for given h and n gaps. */
{
int acc = 2;
if (hGap > 400000)	/* Discourage really long introns. */
    {
    acc += (hGap - 400000)/3000;
    if (hGap > ffIntronMax)
        acc += (hGap - ffIntronMax)/2000;
    }
if (hGap < 0)   /* Discourage jumping back in haystack. */
    {
    hGap = -8*hGap;
    if (hGap > 48)
        hGap = (hGap*hGap);
    }
if (nGap < 0)   /* Jumping back in needle gets rid of previous alignment. */
    {
    acc += -nGap;
    nGap = 0;
    }
acc += digitsBaseTwo(hGap)/2;
if (nGap != 0)
    {
    acc += digitsBaseTwo(nGap);
    }
else
    {
    if (hGap > 30)
	acc -= 1;
    }
return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
cmpl $0x61a81, %edi          # imm = 0x61A81
jl 0x284dd
leal -0x61a80(%r14), %eax
imulq $0x57619f1, %rax, %r15  # imm = 0x57619F1
shrq $0x26, %r15
addl $0x2, %r15d
movl %r14d, %eax
subl 0x986b3(%rip), %eax     # 0xc0b70
jle 0x28504
cltq
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
addl %r15d, %eax
movl %eax, %r15d
jmp 0x28504
movl $0x2, %r15d
testl %r14d, %r14d
jns 0x28504
leal (,%r14,8), %eax
negl %eax
cmpl $-0x6, %r14d
movl $0x1, %r14d
cmovbl %eax, %r14d
imull %eax, %r14d
movl %r14d, %edi
callq 0x32789
movl %eax, %ebp
testl %ebx, %ebx
jle 0x2851b
movl %ebx, %edi
callq 0x32789
jmp 0x28524
xorl %eax, %eax
cmpl $0x1f, %r14d
adcl $-0x1, %eax
movl %ebx, %ecx
sarl $0x1f, %ecx
andl %ebx, %ecx
subl %ecx, %r15d
addl %eax, %r15d
movl %ebp, %eax
shrl $0x1f, %eax
addl %ebp, %eax
sarl %eax
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcGapPenalty
int ffCalcGapPenalty(int hGap, int nGap, enum ffStringency stringency)
/* Return gap penalty for given h and n gaps. */
{
switch (stringency)
    {
    case ffCdna:
	return ffCalcCdnaGapPenalty(hGap, nGap);
    case ffTight:
	return calcTightGap(hGap,nGap);
    case ffLoose:
	return calcLooseGap(hGap,nGap);
    default:
        errAbort("Unknown stringency type %d", stringency);
	return 0;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %edx
je 0x285a3
cmpl $0x2, %edx
je 0x28569
cmpl $0x1, %edx
jne 0x28604
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2848a
movl %esi, %eax
orl %edi, %eax
je 0x28618
cmpl %esi, %edi
movl %esi, %eax
cmovll %edi, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
leal (,%rdi,8), %eax
negl %eax
testl %edi, %edi
cmovnsl %edi, %eax
leal (%rsi,%rsi), %edx
negl %edx
testl %esi, %esi
cmovnsl %esi, %edx
subl %ecx, %eax
leal (%rax,%rdx), %ebx
addl $0x8, %ebx
jmp 0x2861a
movl %esi, %eax
orl %edi, %eax
je 0x28618
cmpl %esi, %edi
movl %esi, %eax
cmovll %edi, %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
leal (,%rdi,8), %eax
negl %eax
testl %edi, %edi
cmovnsl %edi, %eax
leal (%rsi,%rsi), %ebp
negl %ebp
testl %esi, %esi
cmovnsl %esi, %ebp
subl %ebx, %eax
incl %eax
cvtsi2sd %eax, %xmm0
callq 0x6550
movsd %xmm0, (%rsp)
subl %ebx, %ebp
incl %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
callq 0x6550
addsd (%rsp), %xmm0
addsd 0x6868a(%rip), %xmm0    # 0x90c88
cvttsd2si %xmm0, %ebx
jmp 0x2861a
leaq 0x68685(%rip), %rdi     # 0x90c90
xorl %ebx, %ebx
movl %edx, %esi
xorl %eax, %eax
callq 0x26e94
jmp 0x2861a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreSomeAlis
int ffScoreSomeAlis(struct ffAli *ali, int count, enum ffStringency stringency)
/* Figure out score of count alis. */
{
int score = 0;
int oneScore;

while (--count >= 0)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = dnaScoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (count > 0)  /* Calculate gap penalty */
        score -= ffGapPenalty(ali, right,stringency);
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x286c8
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl 0x28(%rdi), %edx
movq 0x20(%rdi), %rdi
subl %edi, %edx
movq 0x8(%r15), %r12
movq 0x10(%r15), %rsi
callq 0x25b71
movl %eax, %r14d
cmpl $0x1, %ebp
je 0x286cb
decl %ebp
movq %r12, %r13
movl 0x10(%r12), %esi
movl 0x20(%r12), %edi
subl 0x28(%r15), %edi
subl 0x18(%r15), %esi
movl %ebx, %edx
callq 0x28548
subl %eax, %r14d
movl 0x28(%r12), %edx
movq 0x20(%r12), %rdi
subl %edi, %edx
movq 0x8(%r12), %r12
movq 0x10(%r13), %rsi
callq 0x25b71
addl %eax, %r14d
movq %r13, %r15
decl %ebp
jne 0x28683
jmp 0x286cb
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreSomething
int ffScoreSomething(struct ffAli *ali, enum ffStringency stringency,
   boolean isProt)
/* Score alignment. */
{
int score = 0;
int oneScore;
int (*scoreMatch)(char *a, char *b, int size);

if (ali == NULL)
    return -0x7FFFFFFF;
scoreMatch = (isProt ? aaScoreMatch : dnaScoreMatch );
while (ali->left != NULL) ali = ali->left;
while (ali != NULL)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = scoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (right)  /* Calculate gap penalty */
        {
        score -= ffGapPenalty(ali, right, stringency);
        }
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28707
movl %esi, %ebx
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x286ef
testl %edx, %edx
jne 0x2871d
leaq -0x2b94(%rip), %r14     # 0x25b71
jmp 0x28724
movl $0x80000001, %ebp       # imm = 0x80000001
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2b5c(%rip), %r14     # 0x25bc8
movl 0x28(%r15), %edx
movq 0x20(%r15), %rdi
subl %edi, %edx
movq 0x8(%r15), %r12
movq 0x10(%r15), %rsi
callq *%r14
movl %eax, %ebp
testq %r12, %r12
je 0x2870c
movq %r12, %r13
movl 0x10(%r12), %esi
movl 0x20(%r12), %edi
subl 0x28(%r15), %edi
subl 0x18(%r15), %esi
movl %ebx, %edx
callq 0x28548
subl %eax, %ebp
movl 0x28(%r12), %edx
movq 0x20(%r12), %rdi
subl %edi, %edx
movq 0x8(%r12), %r12
movq 0x10(%r13), %rsi
callq *%r14
addl %eax, %ebp
movq %r13, %r15
jmp 0x2873b
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/filePath.c
// Function: splitPath
void splitPath(char *path, char dir[PATH_LEN], char name[FILENAME_LEN],
	       char extension[FILEEXT_LEN])
/* Split a full path into components.  The dir component will include the
 * trailing / if any.  The extension component will include the starting
 * . if any.   Pass in NULL for dir, name, or extension if you don't care about
 * that part. */
{
char *dirStart, *nameStart, *extStart, *extEnd;
int dirSize, nameSize, extSize;

undosPath(path);
dirStart = path;
nameStart = strrchr(path,'/');
if (nameStart == NULL)
    nameStart = path;
else
    nameStart += 1;
extStart = strrchr(nameStart, '.');
if (extStart == NULL)
    extStart = nameStart + strlen(nameStart);
extEnd = extStart + strlen(extStart);
if ((dirSize = (nameStart - dirStart)) >= PATH_LEN)
    errAbort("Directory too long in %s", path);
if ((nameSize = (extStart - nameStart)) >= FILENAME_LEN)
    errAbort("Name too long in %s", path);
if ((extSize = (extEnd - extStart)) >= FILEEXT_LEN)
    errAbort("Extension too long in %s", path);
if (dir != NULL)
    {
    memcpy(dir, dirStart, dirSize);
    dir[dirSize] = 0;
    }
if (name != NULL)
    {
    memcpy(name, nameStart, nameSize);
    name[nameSize] = 0;
    }
if (extension != NULL)
    {
    memcpy(extension, extStart, extSize);
    extension[extSize] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
callq 0x62d0
movq %r12, %rdi
movl %eax, %esi
movl $0x5c, %edx
movl $0x2f, %ecx
callq 0x2233e
movq %r12, %rdi
movl $0x2f, %esi
callq 0x67c0
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r12, %r13
movq %r13, %rdi
movl $0x2e, %esi
callq 0x67c0
movq %rax, %r15
testq %rax, %rax
jne 0x28922
movq %r13, %rdi
callq 0x62d0
movq %rax, %r15
addq %r13, %r15
movq %r15, %rdi
callq 0x62d0
movq %rax, %rbx
movq %r13, %r14
subq %r12, %r14
cmpl $0x200, %r14d           # imm = 0x200
jl 0x2894d
leaq 0x68368(%rip), %rdi     # 0x90cab
movq %r12, %rsi
xorl %eax, %eax
callq 0x26e94
movq %r15, %rbp
subq %r13, %rbp
cmpl $0x80, %ebp
jl 0x2896c
leaq 0x68362(%rip), %rdi     # 0x90cc4
movq %r12, %rsi
xorl %eax, %eax
callq 0x26e94
cmpl $0x40, %ebx
jl 0x28982
leaq 0x68360(%rip), %rdi     # 0x90cd8
movq %r12, %rsi
xorl %eax, %eax
callq 0x26e94
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x289ac
movslq %r14d, %r14
movq %rbx, 0x8(%rsp)
movq %rdi, %rbx
movq %r12, %rsi
movq %r14, %rdx
callq 0x6570
movb $0x0, (%rbx,%r14)
movq 0x8(%rsp), %rbx
movq 0x18(%rsp), %r12
testq %r12, %r12
je 0x289cc
movslq %ebp, %r14
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x6570
movb $0x0, (%r12,%r14)
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0x289ec
movslq %ebx, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6570
movb $0x0, (%r14,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/filePath.c
// Function: expandRelativePath
char *expandRelativePath(char *baseDir, char *relPath)
/* Expand relative path to more absolute one. */
{
if (relPath[0] == '/')
   // hey, it's absolute actually... 
   return cloneString(relPath);

char *e = baseDir + strlen(baseDir);
int slashCount;
char *rel = relPath;
char *result;
int size, baseSize;
undosPath(baseDir);
undosPath(relPath);
slashCount = countChars(baseDir, '/');
if (baseDir[0] == 0)
    slashCount = -1;
while (startsWith("../", rel))
    {
    if (slashCount < 0)
        {
	warn("More ..'s in \"%s\" than directories in \"%s\"", relPath, baseDir);
	return NULL;
	}
    else if (slashCount == 0)
        e = baseDir;
    else
        e = findSlashBefore(baseDir, e);
    slashCount -= 1;
    rel += 3;
    }
baseSize = e - baseDir;
size = strlen(rel) + 1;
if (baseSize > 0)
    size += baseSize + 1;
if (baseSize > 0)
    {
    result = needMem(size);
    memcpy(result, baseDir, baseSize);
    result[baseSize] = '/';
    strcpy(result + baseSize + 1, rel);
    }
else
    result = cloneString(rel);
return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x2f, (%rsi)
jne 0x28a16
movq %r14, %rdi
jmp 0x28b5d
movq %rdi, %rbx
callq 0x62d0
leaq (%rbx,%rax), %r12
movq %rbx, %rdi
movl %eax, %esi
movl $0x5c, %edx
movl $0x2f, %ecx
callq 0x2233e
movq %r14, %rdi
callq 0x62d0
movq %r14, %rdi
movl %eax, %esi
movl $0x5c, %edx
movl $0x2f, %ecx
callq 0x2233e
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x224b3
movl %eax, %ebp
movb (%rbx), %r15b
leaq 0x6ab4b(%rip), %rdi     # 0x935b6
movq %r14, %rsi
callq 0x21b23
testl %eax, %eax
je 0x28ade
movq %r14, %rax
xorl %r14d, %r14d
cmpb $0x1, %r15b
sbbl %r14d, %r14d
orl %ebp, %r14d
leaq 0x6ab28(%rip), %r13     # 0x935b6
movq %rax, (%rsp)
movq %rax, %r15
testl %r14d, %r14d
js 0x28b30
movq %rbx, %rbp
subl $0x1, %r14d
jb 0x28ac6
decq %r12
cmpq %rbx, %r12
jb 0x28ac3
leaq -0x1(%r12), %rbp
cmpb $0x2f, (%r12)
movq %rbp, %r12
jne 0x28aaa
incq %rbp
jmp 0x28ac6
movq %rbx, %rbp
addq $0x3, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x21b23
movq %rbp, %r12
testl %eax, %eax
jne 0x28a95
jmp 0x28ae4
movq %r12, %rbp
movq %r14, %r15
subq %rbx, %rbp
testl %ebp, %ebp
jle 0x28b5a
movq %r15, %rdi
callq 0x62d0
addl %ebp, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2dff4
movq %rax, %r13
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %rax, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x6570
leaq 0x1(,%rbp), %rdi
addq %r13, %rdi
movb $0x2f, -0x1(%rdi)
movq %r15, %rsi
callq 0x6680
jmp 0x28b48
leaq 0x681ba(%rip), %rdi     # 0x90cf1
xorl %r13d, %r13d
movq (%rsp), %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26bea
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1feba
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/filePath.c
// Function: mustExpandRelativePath
char *mustExpandRelativePath(char *dir, char* relPath)
/* Given a dir and relative path, expand path.
 * Handy for processing symlinks. errAbort if expand fails.
 * Result should be freeMem'd.*/
{
char *path = expandRelativePath(dir, relPath);
verbose(3, "dir=%s\nrelPath=%s\npath=%s\n", dir, relPath, path);
if (!path)
    errAbort("Too many .. in path %s to make relative to submitDir %s\n", relPath, dir);
return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x289fb
movq %rax, %r15
leaq 0x68192(%rip), %rsi     # 0x90d1c
movl $0x3, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x427e5
testq %r15, %r15
jne 0x28bb8
leaq 0x6818c(%rip), %rdi     # 0x90d37
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26e94
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq