LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3New
struct trans3 *trans3New(struct dnaSeq *seq)
/* Create a new set of translated sequences. */
{
struct trans3 *t3;
int frame;
int lastPos = seq->size - 1;

AllocVar(t3);
t3->name = seq->name;
t3->seq = seq;
t3->end = seq->size;
for (frame=0; frame<3; ++frame)
    {
    /* Position and frame are the same except in the
     * very rare case where we are trying to translate 
     * something less than 3 bases.  In this case this
     * somewhat cryptic construction will force it to
     * return empty sequences for the missing frames
     * avoiding an assert in translateSeq. */
    int pos = frame;
    if (pos > lastPos) pos = lastPos;
    t3->trans[frame] = translateSeq(seq, pos, FALSE);
    }
return t3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x18(%rdi), %r15
leal -0x1(%r15), %ebp
movl $0x40, %edi
callq 0x2dff4
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, 0x10(%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x34(%r14)
xorl %r12d, %r12d
cmpq %r15, %r12
movl %ebp, %esi
cmovll %r12d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x24ff5
movq %rax, 0x18(%r14,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x15df6
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3Free
void trans3Free(struct trans3 **pT3)
/* Free a trans3 structure. */
{
struct trans3 *t3 = *pT3;
if (t3 != NULL)
    {
    freeDnaSeq(&t3->trans[0]);
    freeDnaSeq(&t3->trans[1]);
    freeDnaSeq(&t3->trans[2]);
    freez(pT3);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x15e5f
movq %rdi, %rbx
leaq 0x18(%r14), %rdi
callq 0x24db1
leaq 0x20(%r14), %rdi
callq 0x24db1
addq $0x28, %r14
movq %r14, %rdi
callq 0x24db1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3FreeList
void trans3FreeList(struct trans3 **pList)
/* Free a list of dynamically allocated trans3's */
{
struct trans3 *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    trans3Free(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x15e9a
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x15e23
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x15e85
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3Find
struct trans3 *trans3Find(struct hash *t3Hash, char *name, int start, int end)
/* Find trans3 in hash which corresponds to sequence of given name and includes
 * bases between start and end. */
{
struct trans3 *t3;
for (t3 = hashFindVal(t3Hash, name); t3 != NULL; t3 = t3->next)
    {
    if (t3->start <= start && t3->end >= end)
        return t3;
    }
internalErr();
return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
callq 0x293ad
testq %rax, %rax
je 0x15ed4
movq %rax, %rbx
cmpl %r14d, 0x30(%rbx)
jg 0x15ecc
cmpl %ebp, 0x34(%rbx)
jge 0x15ef0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x15ec1
leaq 0x77d30(%rip), %rdi     # 0x8dc0b
leaq 0x7868f(%rip), %rsi     # 0x8e571
xorl %ebx, %ebx
movl $0x47, %edx
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3Offset
void trans3Offset(struct trans3 *t3List, AA *aa, int *retOffset, int *retFrame)
/* Figure out offset of peptide in context of larger sequences. */
{
struct trans3 *t3;
int frame;
aaSeq *seq;

for (t3 = t3List; t3 != NULL; t3 = t3->next)
    {
    for (frame = 0; frame < 3; ++frame)
        {
	seq = t3->trans[frame];
	if (seq->dna <= aa && aa < seq->dna + seq->size)
	    {
	    *retOffset = aa - seq->dna + t3->start/3;
	    *retFrame = frame;
	    return;
	    }
	}
    }
internalErr();
}

// Assembly:
testq %rdi, %rdi
je 0x15f4a
xorl %eax, %eax
movq 0x18(%rdi,%rax,8), %r9
movq 0x10(%r9), %r8
cmpq %rsi, %r8
ja 0x15f19
movslq 0x18(%r9), %r9
addq %r8, %r9
cmpq %rsi, %r9
ja 0x15f27
incq %rax
cmpq $0x3, %rax
jne 0x15eff
movq (%rdi), %rdi
jmp 0x15ef8
subl %r8d, %esi
movslq 0x30(%rdi), %rdi
imulq $0x55555556, %rdi, %rdi # imm = 0x55555556
movq %rdi, %r8
shrq $0x3f, %r8
shrq $0x20, %rdi
addl %r8d, %edi
addl %esi, %edi
movl %edi, (%rdx)
movl %eax, (%rcx)
retq
leaq 0x77cba(%rip), %rdi     # 0x8dc0b
leaq 0x78619(%rip), %rsi     # 0x8e571
movl $0x5f, %edx
xorl %eax, %eax
jmp 0x26e94
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3GenoPos
int trans3GenoPos(char *pt, bioSeq *seq, struct trans3 *t3List, boolean isEnd)
/* Convert from position in one of three translated frames in
 * t3List to genomic offset. If t3List is NULL then just use seq
 * instead. */
{
int offset, frame;
if (t3List != NULL)
    {
    /* Special processing at end. The end coordinate is
     * not included.  In most cases this makes things
     * easier.  Here we have to move it back one
     * amino acid, so that in the edge case it will
     * be included in the block that's loaded.  Then
     * we move it back. */
    if (isEnd)
        pt -= 1;
    trans3Offset(t3List, pt, &offset, &frame);
    if (isEnd)
        offset += 1;
    return 3*offset + frame;
    }
else
   {
   return pt - seq->dna;
   }
}

// Assembly:
movq %rdi, %rax
testq %rdx, %rdx
je 0x15fb0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %r15d, %r15d
testl %ecx, %ecx
setne %r15b
subq %r15, %rax
leaq 0xc(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rdx, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x15ef8
addl (%rbx), %r15d
leal (%r15,%r15,2), %eax
addl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
subl 0x10(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/trans3.c
// Function: trans3Frame
int trans3Frame(char *pt, struct trans3 *t3List)
/* Figure out which frame pt is in or 0 if no frame. */
{
if (t3List == NULL)
    return 0;
else
    return 1 + trans3GenoPos(pt, NULL, t3List, FALSE)%3;
}

// Assembly:
testq %rsi, %rsi
je 0x16006
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
leaq 0x4(%rsp), %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x15ef8
movl (%rbx), %eax
leal (%rax,%rax,2), %eax
addl (%r14), %eax
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffAliSort
void ffAliSort(struct ffAli **pList, int (*compare )(const void *elem1,  const void *elem2))
/* Sort a doubly linked list of ffAlis. */
{
/* Get head of list and handle easy special empty case. */
struct ffAli *r = *pList;
if (r == NULL) return;

/* Since first pointer is "left", in order to reuse slSort, have
 * to jump through some minor hoops. First go to right end of list,
 * then sort it. */
while (r->right) r = r->right;
slSort(&r, compare);

/* We're sorted, but our right links are all broken.  Fix this. */
slReverse(&r);
r = ffMakeRightLinks(r);
*pList = r;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1607d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x16049
movq %rsp, %r14
movq %rcx, (%r14)
movq %r14, %rdi
callq 0x201c4
movq %r14, %rdi
callq 0x20173
movq (%r14), %rdi
callq 0x28293
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffExpandExactRight
void ffExpandExactRight(struct ffAli *ali, DNA *needleEnd, DNA *hayEnd)
/* Expand aligned segment to right as far as can exactly. */
{
DNA *nEnd = ali->nEnd;
DNA *hEnd = ali->hEnd;
while (nEnd < needleEnd && hEnd < hayEnd)
    {
    if (*nEnd != *hEnd)
        break;
    nEnd += 1;
    hEnd += 1;
    }
ali->nEnd = nEnd;
ali->hEnd = hEnd;
return;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rsi, %rax
setb %r8b
cmpq %rdx, %rcx
setb %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x160e1
movb (%rax), %r8b
cmpb (%rcx), %r8b
jne 0x160e1
incq %rax
incq %rcx
cmpq %rsi, %rax
jae 0x160e1
cmpq %rdx, %rcx
jb 0x160c9
movq %rax, 0x18(%rdi)
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffExpandExactLeft
void ffExpandExactLeft(struct ffAli *ali, DNA *needleStart, DNA *hayStart)
/* Expand aligned segment to left as far as can exactly. */
{
DNA *nStart = ali->nStart-1;
DNA *hStart = ali->hStart-1;
while (nStart >= needleStart && hStart >= hayStart)
    {
    if (*nStart != *hStart)
        break;
    nStart -= 1;
    hStart -= 1;
    }
ali->nStart = nStart + 1;
ali->hStart = hStart + 1;
return;
}

// Assembly:
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %r9
decq %r8
decq %r9
movq %r8, %rcx
movq %r9, %rax
cmpq %rsi, %r8
jb 0x16118
cmpq %rdx, %rax
jb 0x16118
movb (%rcx), %r10b
leaq -0x1(%rcx), %r8
leaq -0x1(%rax), %r9
cmpb (%rax), %r10b
je 0x160f8
incq %rcx
movq %rcx, 0x10(%rdi)
incq %rax
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffMergeClose
struct ffAli *ffMergeClose(struct ffAli *aliList, 
	DNA *needleStart, DNA *hayStart)
/* Remove overlapping areas needle in alignment. Assumes ali is sorted on
 * ascending nStart field. Also merge perfectly abutting neighbors or
 * ones that could be merged at the expense of just a few mismatches.*/
{
struct ffAli *mid, *ali;
int closeEnough = -3;

if (aliList == NULL)
    return NULL;
for (mid = aliList->right; mid != NULL; mid = mid->right)
    {
    for (ali = aliList; ali != mid; ali = ali->right)
	{
	char *nStart, *nEnd;
	int nOverlap;
	nStart = max(ali->nStart, mid->nStart);
	nEnd = min(ali->nEnd, mid->nStart);
	nOverlap = nEnd - nStart;
	/* Overlap or perfectly abut in needle, and needle/hay
	 * offset the same. */
	if (nOverlap >= closeEnough)
	    {
	    int aliDiag = (ali->nStart - needleStart) - (ali->hStart - hayStart);
	    int midDiag = (mid->nStart - needleStart) - (mid->hStart - hayStart);
	    if (aliDiag == midDiag)
		{
		/* Make mid encompass both, and make ali empty. */
		mid->nStart = min(ali->nStart, mid->nStart);
		mid->nEnd = max(ali->nEnd, mid->nEnd);
		mid->hStart = min(ali->hStart, mid->hStart);
		mid->hEnd = max(ali->hEnd, mid->hEnd);
		ali->hStart = ali->hEnd = mid->hStart;
		ali->nEnd = ali->nStart = mid->nStart;;
		}
	    }
	}
    }
aliList = ffRemoveEmptyAlis(aliList, TRUE);
return aliList;
}

// Assembly:
testq %rdi, %rdi
je 0x16209
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x161ff
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdi, %rax
je 0x161ec
movq %rdi, %rcx
movq 0x10(%rcx), %r9
movq 0x10(%rax), %r8
cmpq %r8, %r9
movl %r8d, %r11d
cmoval %r9d, %r11d
movq 0x18(%rcx), %r10
cmpq %r8, %r10
movl %r10d, %ebx
cmovael %r8d, %ebx
subl %r11d, %ebx
cmpl $-0x3, %ebx
jl 0x161df
movq 0x20(%rcx), %r11
leal (%rdx,%r9), %ebp
subl %esi, %ebp
subl %r11d, %ebp
movq 0x20(%rax), %rbx
leal (%r8,%rdx), %r14d
subl %ebx, %r14d
subl %esi, %r14d
cmpl %r14d, %ebp
jne 0x161df
cmpq %r8, %r9
cmovbq %r9, %r8
movq %r8, 0x10(%rax)
movq 0x18(%rax), %r9
cmpq %r9, %r10
cmovaq %r10, %r9
movq 0x28(%rax), %r10
cmpq %rbx, %r11
cmovbq %r11, %rbx
movq %r9, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq 0x28(%rcx), %r9
cmpq %r10, %r9
cmovaq %r9, %r10
movq %r10, 0x28(%rax)
movq %rbx, 0x28(%rcx)
movq %rbx, 0x20(%rcx)
movq %r8, 0x10(%rcx)
movq %r8, 0x18(%rcx)
movq 0x8(%rcx), %rcx
cmpq %rax, %rcx
jne 0x1614f
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x16143
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x1, %esi
jmp 0x1620c
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffRemoveEmptyAlis
struct ffAli *ffRemoveEmptyAlis(struct ffAli *ali, boolean doFree)
/* Remove empty blocks from list. Optionally free empties too. */
{
struct ffAli *leftAli;
struct ffAli *startAli;
struct ffAli *rightAli;

if (ali == NULL)
    return NULL;

/* Figure out left most non-empty ali. */
while (ali->left)
    ali = ali->left;
while (ali)
    {
    /* If current ali is empty, chuck it out. */
    if (ali->nEnd <= ali->nStart || ali->hEnd <= ali->hStart)
	{
	struct ffAli *empty = ali;
        ali = ali->right;
	if (doFree) freeMem(empty);
	}
    else
        break;
    }

if (ali == NULL)
    return NULL;

ali->left = NULL;

/* Get rid of empty middle alis. */
startAli = leftAli = ali;
ali = ali->right;
while (ali)
    {
    rightAli = ali->right;
    if (ali->nEnd <= ali->nStart || ali->hEnd <= ali->hStart)
        {
        leftAli->right = rightAli;
        if (rightAli != NULL)
            rightAli->left = leftAli;
	if (doFree) freeMem(ali);
        }
    else
        {
        leftAli = ali;
        }
    ali = rightAli;
    }
return startAli;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16251
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x1621a
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x16239
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
ja 0x16261
movq 0x8(%rbx), %r14
testl %ebp, %ebp
je 0x16249
movq %rbx, %rdi
callq 0x2e0a0
movq %r14, %rbx
testq %r14, %r14
jne 0x16225
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, (%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x16253
movq %rbx, %r15
movq %r14, %rdi
movq 0x8(%r14), %r14
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jbe 0x16294
movq 0x28(%rdi), %rax
cmpq 0x20(%rdi), %rax
jbe 0x16294
movq %rdi, %r15
jmp 0x162a9
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x162a0
movq %r15, (%r14)
testl %ebp, %ebp
je 0x162a9
callq 0x2e0a0
testq %r14, %r14
jne 0x16274
jmp 0x16253
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffScoreIntron
int ffScoreIntron(DNA a, DNA b, DNA y, DNA z, int orientation)
/* Return a better score the closer an intron is to
 * consensus. */
{
int score = 0;
int revScore = 0;

if (orientation >= 0)
    {
    if (a == 'g' || a == 'G') ++score;
    if (b == 't' || b == 'T') ++score;
    if (y == 'a' || y == 'A') ++score;
    if (z == 'g' || z == 'G') ++score;
    }

if (orientation <= 0)
    {
    if (a == 'c' || a == 'C') ++revScore;
    if (b == 't' || b == 'T') ++revScore;
    if (y == 'a' || y == 'A') ++revScore;
    if (z == 'c' || z == 'C') ++revScore;
    }

return score > revScore ? score : revScore;
}

// Assembly:
andb $-0x21, %dil
testl %r8d, %r8d
js 0x162f9
xorl %eax, %eax
cmpb $0x47, %dil
sete %al
andb $-0x21, %sil
leal 0x1(%rax), %r10d
cmpb $0x54, %sil
cmovnel %eax, %r10d
andb $-0x21, %dl
xorl %eax, %eax
cmpb $0x41, %dl
sete %al
andb $-0x21, %cl
xorl %r9d, %r9d
cmpb $0x47, %cl
sete %r9b
addl %eax, %r9d
addl %r10d, %r9d
xorl %eax, %eax
testl %r8d, %r8d
jne 0x1632e
jmp 0x16306
andb $-0x21, %sil
andb $-0x21, %dl
andb $-0x21, %cl
xorl %r9d, %r9d
xorl %eax, %eax
cmpb $0x43, %dil
sete %al
leal 0x1(%rax), %edi
cmpb $0x54, %sil
cmovnel %eax, %edi
xorl %esi, %esi
cmpb $0x41, %dl
sete %sil
xorl %eax, %eax
cmpb $0x43, %cl
sete %al
addl %esi, %eax
addl %edi, %eax
cmpl %eax, %r9d
cmoval %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffSlideOrientedIntrons
boolean ffSlideOrientedIntrons(struct ffAli *ali, int orient)
/* Slide introns (or spaces between aligned blocks)
 * to match consensus on given strand. */
{
struct ffAli *left = ali, *right;
boolean slid = FALSE;
if (left == NULL)
    return FALSE;
while((right = left->right) != NULL)
    {
    if (slideIntron(left, right, orient))
        slid = TRUE;
    left = right;
    }
return slid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, 0x1c(%rsp)
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x1653e
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1653e
movq $0x0, 0x8(%rsp)
movq %rdi, %r11
movq %rax, %rdi
movq 0x28(%r11), %r14
movq 0x20(%rax), %r10
movq %r10, %rax
subq %r14, %rax
cmpq $0x4, %rax
jl 0x16531
movq 0x10(%rdi), %r15
movq 0x18(%r11), %r12
movq %r15, %rax
subq %r12, %rax
cmpq $0x2, %rax
jg 0x16531
movq 0x10(%r11), %rax
movq %r10, 0x10(%rsp)
movq %r15, %r13
movq %r14, (%rsp)
movq %r12, %rbx
cmpq %rax, %r12
jbe 0x1641f
movq %rax, %rdx
subq %r12, %rdx
leaq (%r10,%rdx), %rcx
movq %rcx, 0x10(%rsp)
leaq (%r15,%rdx), %r13
addq %r14, %rdx
movq %rdx, (%rsp)
movq %r12, %rbx
movq %r14, %rcx
movq %r15, %rdx
movq %r10, %r9
movb -0x1(%rdx), %r8b
leaq -0x1(%r9), %rsi
cmpb $0x6e, -0x1(%rbx)
jne 0x163f8
cmpb $0x6e, %r8b
je 0x163fd
cmpb (%rsi), %r8b
jne 0x16413
decq %rbx
decq %rcx
decq %rdx
movq %rsi, %r9
cmpq %rax, %rbx
ja 0x163e4
movq %rax, %rbx
jmp 0x1641f
movq %r9, 0x10(%rsp)
movq %rdx, %r13
movq %rcx, (%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x58(%rsp)
cmpq %rax, %r13
jae 0x16531
movq %r12, 0x48(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rdi, 0x20(%rsp)
movq (%rsp), %rax
movb (%rax), %r15b
incq %r13
movq %r13, 0x50(%rsp)
movl $0x80000001, %r14d      # imm = 0x80000001
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r13, 0x60(%rsp)
movl %r15d, %eax
leaq (%rbx,%r12), %r13
movq (%rsp), %rcx
movb 0x1(%rcx,%r12), %r15b
movq 0x10(%rsp), %rcx
movsbl -0x2(%rcx,%r12), %edx
movsbl -0x1(%rcx,%r12), %ecx
movsbl %r15b, %esi
movsbl %al, %ebp
movl %ebp, %edi
movl 0x1c(%rsp), %r8d
callq 0x162b0
movb (%rbx,%r12), %cl
cmpb $0x6e, %cl
setne %dl
cmpb %bpl, %cl
setne %cl
cmpl %r14d, %eax
cmovleq 0x60(%rsp), %r13
cmovgl %eax, %r14d
testb %cl, %dl
jne 0x164d6
movq 0x50(%rsp), %rax
addq %r12, %rax
incq %r12
cmpq 0x58(%rsp), %rax
jb 0x1646a
testq %r13, %r13
je 0x1652c
movq 0x48(%rsp), %rdx
subq %rdx, %r13
testl %r13d, %r13d
movq 0x20(%rsp), %rdi
je 0x16531
movslq %r13d, %rax
addq %rax, %rdx
movq 0x38(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x30(%rsp), %rdx
addq %rax, %rdx
movq %rdx, 0x28(%rcx)
movq 0x28(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rdi)
movq 0x40(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x20(%rdi)
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x16531
movq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x16370
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffAliHelp.c
// Function: ffMergeNeedleAlis
struct ffAli *ffMergeNeedleAlis(struct ffAli *ali, boolean doFree)
/* Remove overlapping areas needle in alignment. Assumes ali is sorted on
 * ascending nStart field. Also merge perfectly abutting neighbors.*/
{
struct ffAli *a = NULL;
struct ffAli *leftA = NULL;
struct ffAli *rightA;

if (ali == NULL)
    return NULL;
rightA = ali;
for (;;)
    {
    /* Advance to next ali */
    leftA = a;
    a = rightA;
    if (a == NULL)
        break;
    rightA = a->right;
    

    /* See if can merge current alignment into left one. */
    if (leftA != NULL)
        {
        int overlap = leftA->nEnd - a->nStart;

        /* Deal with overlaps in needle */
        if (overlap > 0)
            {
            /* See if left encompasses current segment. */
            if (leftA->nStart <= a->nStart && leftA->nEnd >= a->nEnd)
                {
                /* Eliminate current segment. */
                leftA->right = rightA;
                if (rightA != NULL)
                    rightA->left = leftA;
		if (doFree) freeMem(a);
                a = leftA;
                }
            else
                {
                /* Remove overlapping area from current segment, leave
                 * it in left segment. */
                a->hStart += overlap;
                a->nStart += overlap;
                }
            }
        else if (overlap == 0 && leftA->hEnd == a->hStart)
            {
            /* Remove current segment from list. */
            leftA->right = rightA;
            if (rightA != NULL)
                rightA->left = leftA;
            /* Fold data from current segment into left segment */
            leftA->nEnd = a->nEnd;
            leftA->hEnd = a->hEnd;
	    if (doFree) freeMem(a); 
	    a = leftA;
            }
        }
    }
return ali;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1666f
movl %esi, %ebp
xorl %r15d, %r15d
movq %rbx, %r14
movq %r14, %rdi
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x16663
movq 0x18(%r15), %rdx
movq 0x10(%rdi), %rax
movq %rdx, %rcx
subq %rax, %rcx
testl %ecx, %ecx
jle 0x16621
cmpq %rax, 0x10(%r15)
ja 0x1660e
cmpq 0x18(%rdi), %rdx
jae 0x1664b
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, 0x20(%rdi)
addq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x16663
jne 0x16663
movq 0x28(%r15), %rax
cmpq 0x20(%rdi), %rax
jne 0x16663
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x16639
movq %r15, (%r14)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%r15)
movq 0x28(%rdi), %rax
movq %rax, 0x28(%r15)
jmp 0x16657
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x16657
movq %r15, (%r14)
testl %ebp, %ebp
je 0x16660
callq 0x2e0a0
movq %r15, %rdi
movq %rdi, %r15
testq %r14, %r14
jne 0x165e4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: aPenalty
int aPenalty(char *s, int size)
/* Penalty for polyA/polyT */
{
int aCount = 0, tCount = 0;
int i;
char c;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (c == 'a') ++aCount;
    if (c == 't') ++tCount;
    }
if (tCount > aCount) aCount = tCount;
if (aCount >= size)
    return aCount-1;
else if (aCount >= size*0.75)
    return aCount * 0.90;
else
    return 0;
}

// Assembly:
testl %esi, %esi
jle 0x16d3b
movl %esi, %edx
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movb (%rdi,%r8), %r9b
xorl %r10d, %r10d
cmpb $0x61, %r9b
sete %r10b
addl %r10d, %eax
xorl %r10d, %r10d
cmpb $0x74, %r9b
sete %r10b
addl %r10d, %ecx
incq %r8
cmpq %r8, %rdx
jne 0x16d11
jmp 0x16d3f
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
cmpl %esi, %eax
jge 0x16d6d
cvtsi2sd %eax, %xmm0
cvtsi2sd %esi, %xmm1
mulsd 0x77830(%rip), %xmm1    # 0x8e588
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jb 0x16d6f
mulsd 0x77828(%rip), %xmm0    # 0x8e590
cvttsd2si %xmm0, %eax
retq
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: bandExtBefore
static void bandExtBefore(struct axtScoreScheme *ss, struct ffAli *ff,
	int qGap, int tGap, struct ffAli **pExtraList)
/* Add in blocks from a banded extension before ff into the gap
 * and append results if any to *pExtraList. */
{
struct ffAli *ext;
int minGap = min(qGap, tGap);
int maxGap = minGap * 2;
if (minGap > 0)
    {
    if (qGap > maxGap) qGap = maxGap;
    if (tGap > maxGap) tGap = maxGap;
    ext = bandExtFf(NULL, ss, 3, ff, ff->nStart - qGap, ff->nStart, 
	    ff->hStart - tGap, ff->hStart, -1, maxGap);
    ffCat(pExtraList, &ext);
    }
}

// Assembly:
cmpl %ecx, %edx
movl %ecx, %r10d
cmovll %edx, %r10d
testl %r10d, %r10d
jle 0x1831a
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %rax
movq %rdi, %rsi
addl %r10d, %r10d
cmpl %edx, %r10d
cmovll %r10d, %edx
cmpl %ecx, %r10d
cmovll %r10d, %ecx
movslq %edx, %rdx
movq 0x10(%rax), %r9
movq 0x20(%rax), %r11
movq %r9, %r8
subq %rdx, %r8
movslq %ecx, %rcx
movq %r11, %r14
subq %rcx, %r14
xorl %edi, %edi
movl $0x3, %edx
movq %rax, %rcx
pushq %r10
pushq $-0x1
pushq %r11
pushq %r14
callq 0x198da
addq $0x20, %rsp
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1600c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: bandExtAfter
static void bandExtAfter(struct axtScoreScheme *ss, struct ffAli *ff,
	int qGap, int tGap, struct ffAli **pExtraList)
/* Add in blocks from a banded extension after ff into the gap
 * and append results if any to *pExtraList. */
{
struct ffAli *ext;
int minGap = min(qGap, tGap);
int maxGap = minGap * 2;
if (minGap > 0)
    {
    if (qGap > maxGap) qGap = maxGap;
    if (tGap > maxGap) tGap = maxGap;
    ext = bandExtFf(NULL, ss, 3, ff, ff->nEnd, ff->nEnd + qGap,
	    ff->hEnd, ff->hEnd + tGap, 1, maxGap);
    ffCat(pExtraList, &ext);
    }
}

// Assembly:
cmpl %ecx, %edx
movl %ecx, %r10d
cmovll %edx, %r10d
testl %r10d, %r10d
jle 0x1838b
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %rax
movq %rdi, %rsi
addl %r10d, %r10d
cmpl %edx, %r10d
cmovll %r10d, %edx
cmpl %ecx, %r10d
cmovll %r10d, %ecx
movslq %edx, %r9
movq 0x18(%rax), %r8
movq 0x28(%rax), %r11
addq %r8, %r9
movslq %ecx, %r14
addq %r11, %r14
xorl %edi, %edi
movl $0x3, %edx
movq %rax, %rcx
pushq %r10
pushq $0x1
pushq %r14
pushq %r11
callq 0x198da
addq $0x20, %rsp
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1600c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: extendGaplessLeft
static void extendGaplessLeft(int qMax, int tMax, int maxDrop, char **pStartQ, char **pStartT)
/* Extend startQ/startT as much to the left as possible allowing mismatches
 * but not gaps. */
{
int score = 0, bestScore = -1, bestPos = 0;
int last = -min(qMax, tMax);
int i;
char *q = *pStartQ, *t = *pStartT;

for (i=-1; i>=last; --i)
    {
    if (q[i] == t[i])
	{
	++score;
	if (score > bestScore)
	    {
	    bestScore = score;
	    bestPos = i;
	    }
	}
    else
	{
	score -= 3;
	if (bestScore - score >= maxDrop)
	    break;
	}
    }
*pStartQ = q+bestPos;
*pStartT = t+bestPos;
}

// Assembly:
cmpl %esi, %edi
cmovll %edi, %esi
movq (%rdx), %rdi
movq (%rcx), %rax
xorl %r8d, %r8d
testl %esi, %esi
jle 0x183ec
pushq %rbx
negl %esi
movslq %esi, %rsi
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %r11d, %r11d
movb -0x1(%rdi,%r10), %bl
cmpb -0x1(%rax,%r10), %bl
jne 0x183d1
leal -0x1(%r10), %ebx
cmpl %r9d, %r8d
cmovgel %ebx, %r11d
leal 0x1(%r8), %r8d
cmovgel %r8d, %r9d
jmp 0x183e0
addl $-0x3, %r8d
movl %r9d, %ebx
subl %r8d, %ebx
cmpl $0x8, %ebx
jg 0x183e8
decq %r10
cmpq %rsi, %r10
jg 0x183b0
movslq %r11d, %r8
popq %rbx
addq %r8, %rdi
movq %rdi, (%rdx)
addq %r8, %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: extendGaplessRight
static void extendGaplessRight(int qMax, int tMax, int maxDrop, char **pEndQ, char **pEndT)
/* Extend endQ/endT as much to the right as possible allowing mismatches
 * but not gaps. */
{
int last = min(qMax, tMax);
int i;
char *q = *pEndQ, *t = *pEndT;
int score = 0, bestScore = -1, bestPos = -1;

for (i=0; i<last; ++i)
    {
    if (q[i] == t[i])
	{
	++score;
	if (score > bestScore)
	    {
	    bestScore = score;
	    bestPos = i;
	    }
	}
    else
	{
	score -= 3;
	if (bestScore - score >= maxDrop)
	    break;
	}
    }
++bestPos;
*pEndQ = q+bestPos;
*pEndT = t+bestPos;
}

// Assembly:
cmpl %esi, %edi
cmovll %edi, %esi
movq (%rdx), %rdi
movq (%rcx), %rax
xorl %r8d, %r8d
testl %esi, %esi
jle 0x18455
pushq %rbx
movl %esi, %r9d
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movb (%rdi,%r10), %bl
cmpb (%rax,%r10), %bl
jne 0x18438
cmpl %r11d, %r8d
leal 0x1(%r8), %r8d
cmovgel %r8d, %r11d
cmovgel %r10d, %esi
jmp 0x18447
addl $-0x3, %r8d
movl %r11d, %ebx
subl %r8d, %ebx
cmpl $0x8, %ebx
jg 0x1844f
incq %r10
cmpq %r10, %r9
jne 0x1841d
incl %esi
movslq %esi, %r8
popq %rbx
addq %r8, %rdi
movq %rdi, (%rdx)
addq %r8, %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: addExtraHits
static void addExtraHits(struct gfHit *hitList, int hitSize, 
	struct dnaSeq *qSeq, struct dnaSeq *tSeq, struct ffAli **pExtraList)
/* Extend hits as far as possible, convert to ffAli, and add to extraList. */
{
struct gfHit *hit;
struct ffAli *ff;
char *qs = qSeq->dna, *ts = tSeq->dna;
char *qe = qs + qSeq->size,  *te = ts + tSeq->size;
for (hit = hitList; hit != NULL; hit = hit->next)
    {
    AllocVar(ff);
    ff->nStart = ff->nEnd = qs + hit->qStart;
    ff->hStart = ff->hEnd = ts + hit->tStart;
    ff->nEnd += hitSize;
    ff->hEnd += hitSize;
    ff->left = *pExtraList;
    ffExpandExactLeft(ff, qs, ts);
    ffExpandExactRight(ff, qe, te);
    *pExtraList = ff;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x18513
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %rax
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movslq %r9d, %rax
addq %r8, %rax
movq %rax, 0x8(%rsp)
movslq %esi, %r12
movl $0x38, %edi
callq 0x2dff4
movq %rax, %rbp
movl 0x8(%r15), %eax
addq %r14, %rax
movq %rax, 0x10(%rbp)
movl 0xc(%r15), %ecx
addq %rbx, %rcx
movq %rcx, 0x20(%rbp)
addq %r12, %rax
movq %rax, 0x18(%rbp)
addq %r12, %rcx
movq %rcx, 0x28(%rbp)
movq 0x50(%rsp), %r13
movq (%r13), %rax
movq %rax, (%rbp)
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x160ea
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x160aa
movq %rbp, (%r13)
movq (%r15), %r15
testq %r15, %r15
jne 0x1849b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: foldInExtras
static struct ffAli *foldInExtras(struct dnaSeq *qSeq, struct dnaSeq *tSeq,
	struct ffAli *ffList, struct ffAli *extraList)
/* Integrate extraList into ffList and return result. 
 * Frees bits of extraList that aren't used. */
{
if (extraList != NULL)
    {
    struct ssBundle *bun;
    struct ssFfItem *ffi;
    AllocVar(bun);
    bun->qSeq = qSeq;
    bun->genoSeq = tSeq;
    bun->avoidFuzzyFindKludge = TRUE;
    AllocVar(ffi);
    ffi->ff = ffList;
    slAddHead(&bun->ffList, ffi);
    AllocVar(ffi);
    ffi->ff = extraList;
    slAddHead(&bun->ffList, ffi);
    ssStitch(bun, ffCdna, 16, 1);
    if (bun->ffList != NULL)
	{
	ffList = bun->ffList->ff;
	bun->ffList->ff = NULL;
	}
    else
	{
        ffList = NULL;
	}
    ssBundleFree(&bun);
    }
return ffList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
testq %rcx, %rcx
je 0x185c3
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x48, %edi
callq 0x2dff4
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movl $0x1, 0x40(%rax)
movl $0x10, %edi
callq 0x2dff4
movq %rbx, 0x8(%rax)
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%r14)
movl $0x10, %edi
callq 0x2dff4
movq %r15, 0x8(%rax)
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
movl $0x10, %edx
movl $0x1, %ecx
callq 0x14f5d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x185b7
movq 0x8(%rax), %rbx
movq $0x0, 0x8(%rax)
jmp 0x185b9
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x149ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: trimGapPenalty
static int trimGapPenalty(int hGap, int nGap, char *iStart, char *iEnd, int orientation)
/* Calculate gap penalty for routine below. */
{
int penalty =  ffCalcGapPenalty(hGap, nGap, ffCdna);
if (hGap > 2 || nGap > 2)	/* Not just a local extension. */
				/* Score gap to favor introns. */
    {
    penalty <<= 1;
    if (nGap > 0)	/* Intron gaps are not in n side at all. */
	 penalty += 3;
    			/* Good splice sites give you bonus 2,
			 * bad give you penalty of six. */
    penalty += 6 - 2*ffScoreIntron(iStart[0], iStart[1], 
    	iEnd[-2], iEnd[-1], orientation);
    }
return penalty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movl %edi, %r13d
movl $0x1, %edx
callq 0x28548
movl %eax, %ebx
cmpl $0x3, %r13d
setl %al
cmpl $0x3, %r12d
setl %cl
testb %cl, %al
jne 0x1863b
leal (%rbx,%rbx), %eax
testl %r12d, %r12d
leal 0x3(%rbx,%rbx), %ebx
cmovlel %eax, %ebx
movsbl (%r15), %edi
movsbl 0x1(%r15), %esi
movsbl -0x2(%r14), %edx
movsbl -0x1(%r14), %ecx
movl %ebp, %r8d
callq 0x162b0
addl %eax, %eax
subl %eax, %ebx
addl $0x6, %ebx
movl %ebx, %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/jkOwnLib/patSpace.c
// Function: freePatSpace
void freePatSpace(struct patSpace **pPatSpace)
/* Free up a pattern space. */
{
struct patSpace *ps = *pPatSpace;
if (ps != NULL)
    {
    freeMem(ps->allocated);
    freez(pPatSpace);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1866a
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x2e0a0
movq %rbx, %rdi
popq %rbx
jmp 0x2e0b0
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/aliType.c
// Function: gfTypeFromName
enum gfType gfTypeFromName(char *name)
/* Return type from string. */
{
if (sameWord(name, "DNA")) return gftDna;
if (sameWord(name, "RNA")) return gftRna;
if (sameWord(name, "protein")) return gftProt;
if (sameWord(name, "prot")) return gftProt;
if (sameWord(name, "DNAX")) return gftDnaX;
if (sameWord(name, "RNAX")) return gftRnaX;
errAbort("Unknown sequence type '%s'", name);
return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x74c79(%rip), %rsi     # 0x8e763
callq 0x209d6
testl %eax, %eax
je 0x19b6c
leaq 0x74c6d(%rip), %rsi     # 0x8e767
movq %rbx, %rdi
callq 0x209d6
testl %eax, %eax
je 0x19b70
leaq 0x74c5e(%rip), %rsi     # 0x8e76b
movq %rbx, %rdi
callq 0x209d6
movl $0x2, %ebp
testl %eax, %eax
je 0x19b75
leaq 0x738b4(%rip), %rsi     # 0x8d3d9
movq %rbx, %rdi
callq 0x209d6
testl %eax, %eax
je 0x19b75
leaq 0x74c3b(%rip), %rsi     # 0x8e773
movq %rbx, %rdi
callq 0x209d6
testl %eax, %eax
je 0x19b7e
leaq 0x74c2d(%rip), %rsi     # 0x8e778
movq %rbx, %rdi
callq 0x209d6
testl %eax, %eax
je 0x19b85
leaq 0x74c2d(%rip), %rdi     # 0x8e78b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26e94
jmp 0x19b75
xorl %ebp, %ebp
jmp 0x19b75
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x3, %ebp
jmp 0x19b75
movl $0x4, %ebp
jmp 0x19b75
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtFree
void axtFree(struct axt **pEl)
/* Free an axt. */
{
struct axt *el = *pEl;
if (el != NULL)
    {
    freeMem(el->qName);
    freeMem(el->tName);
    freeMem(el->qSym);
    freeMem(el->tSym);
    freez(pEl);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x19bce
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x2e0a0
movq 0x20(%r14), %rdi
callq 0x2e0a0
movq 0x40(%r14), %rdi
callq 0x2e0a0
movq 0x48(%r14), %rdi
callq 0x2e0a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtFreeList
void axtFreeList(struct axt **pList)
/* Free a list of dynamically allocated axt's */
{
struct axt *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    axtFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x19c09
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x19b8c
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x19bf4
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtWrite
void axtWrite(struct axt *axt, FILE *f)
/* Output axt to axt file. */
{
static int ix = 0;
fprintf(f, "%d %s %d %d %s %d %d %c",
    ix++, axt->tName, axt->tStart+1, axt->tEnd, 
    axt->qName, axt->qStart+1, axt->qEnd, axt->qStrand);
fprintf(f, " %d", axt->score);
fputc('\n', f);
mustWrite(f, axt->tSym, axt->symCount);
fputc('\n', f);
mustWrite(f, axt->qSym, axt->symCount);
fputc('\n', f);
fputc('\n', f);
if ((strlen(axt->tSym) != strlen(axt->qSym)) || (axt->symCount > strlen(axt->tSym)))
    fprintf(stderr,"Symbol count %d != %d || %d > %d inconsistent in %s in "
        "record %d.\n",
        (int)strlen(axt->qSym), (int)strlen(axt->tSym), axt->symCount,
        (int)strlen(axt->tSym), axt->qName, ix);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0xa71c5(%rip), %edx     # 0xc0fa8
leal 0x1(%rdx), %eax
movl %eax, 0xa71bc(%rip)     # 0xc0fa8
movq 0x20(%rdi), %rcx
movl 0x28(%rdi), %r8d
incl %r8d
movl 0x2c(%rdi), %r9d
movl 0x10(%rdi), %r10d
incl %r10d
movl 0x14(%rdi), %r11d
movsbl 0x18(%rdi), %r15d
leaq 0x74a50(%rip), %rsi     # 0x8e862
movq %r14, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
pushq 0x8(%rbx)
callq 0x6a90
addq $0x20, %rsp
movl 0x34(%rbx), %edx
leaq 0x79e7e(%rip), %rsi     # 0x93cb1
movq %r14, %rdi
xorl %eax, %eax
callq 0x6a90
movl $0xa, %edi
movq %r14, %rsi
callq 0x6930
movq 0x48(%rbx), %rsi
movslq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x23138
movl $0xa, %edi
movq %r14, %rsi
callq 0x6930
movq 0x40(%rbx), %rsi
movslq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x23138
movl $0xa, %edi
movq %r14, %rsi
callq 0x6930
movl $0xa, %edi
movq %r14, %rsi
callq 0x6930
movq 0x48(%rbx), %rdi
callq 0x62d0
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x62d0
movl 0x38(%rbx), %r8d
cmpq %rax, %r14
jne 0x19ebd
movslq %r8d, %rcx
cmpq %rcx, %r14
jb 0x19ebd
popq %rbx
popq %r14
popq %r15
retq
movq 0xa5114(%rip), %rcx     # 0xbefd8
movq (%rcx), %rdi
movl 0xa70da(%rip), %r10d    # 0xc0fa8
leaq 0x749a5(%rip), %rsi     # 0x8e87a
movl %eax, %edx
movl %r14d, %ecx
movl %r14d, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x8(%rbx)
callq 0x6a90
addq $0x10, %rsp
jmp 0x19eb7
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtCmpQuery
int axtCmpQuery(const void *va, const void *vb)
/* Compare to sort based on query position. */
{
const struct axt *a = *((struct axt **)va);
const struct axt *b = *((struct axt **)vb);
int dif;
dif = strcmp(a->qName, b->qName);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x19f11
movl 0x10(%r14), %eax
subl 0x10(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtCmpTarget
int axtCmpTarget(const void *va, const void *vb)
/* Compare to sort based on target position. */
{
const struct axt *a = *((struct axt **)va);
const struct axt *b = *((struct axt **)vb);
int dif;
dif = strcmp(a->tName, b->tName);
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x19f3b
movl 0x28(%r14), %eax
subl 0x28(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtCmpTargetScoreDesc
int axtCmpTargetScoreDesc(const void *va, const void *vb)
/* Compare to sort based on target name and score descending. */
{
const struct axt *a = *((struct axt **)va);
const struct axt *b = *((struct axt **)vb);
int dif;
dif = strcmp(a->tName, b->tName);
if (dif == 0)
    dif = b->score - a->score;
return dif;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq (%rsi), %r14
movq 0x20(%rbx), %rdi
movq 0x20(%r14), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x19f72
movl 0x34(%r14), %eax
subl 0x34(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtCheck
boolean axtCheck(struct axt *axt, struct lineFile *lf)
/* Return FALSE if there's a problem with axt. */
{
int tSize = countNonDash(axt->tSym, axt->symCount);
int qSize = countNonDash(axt->qSym, axt->symCount);
if (tSize != axt->tEnd - axt->tStart)
    {
    warn("%d non-dashes, but %d bases to cover at line %d of %s", 
        tSize, axt->tEnd - axt->tStart, lf->lineIx, lf->fileName);
    return FALSE;
    }
if (qSize != axt->qEnd - axt->qStart)
    {
    warn("%d non-dashes, but %d bases to cover at line %d of %s", 
        tSize, axt->qEnd - axt->qStart, lf->lineIx, lf->fileName);
    return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movl 0x38(%r14), %esi
callq 0x256a6
movl %eax, %ebp
movq 0x40(%r14), %rdi
movl 0x38(%r14), %esi
callq 0x256a6
movl 0x2c(%r14), %edx
subl 0x28(%r14), %edx
cmpl %edx, %ebp
jne 0x19fbe
movl 0x14(%r14), %edx
subl 0x10(%r14), %edx
movl $0x1, %r14d
cmpl %edx, %eax
je 0x19fd8
movl 0x28(%rbx), %ecx
movq 0x8(%rbx), %r8
leaq 0x748f1(%rip), %rdi     # 0x8e8bd
xorl %r14d, %r14d
movl %ebp, %esi
xorl %eax, %eax
callq 0x26bea
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtScoreUngapped
int axtScoreUngapped(struct axtScoreScheme *ss, char *q, char *t, int size)
/* Score ungapped alignment. */
{
int score = 0;
int i;
for (i=0; i<size; ++i)
    score += ss->matrix[(int)q[i]][(int)t[i]];
return score;
}

// Assembly:
testl %ecx, %ecx
jle 0x1a00d
addq $0x8, %rdi
movl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
movsbq (%rsi,%r8), %r9
movsbq (%rdx,%r8), %r10
shlq $0xa, %r9
addq %rdi, %r9
addl (%r9,%r10,4), %eax
incq %r8
cmpq %r8, %rcx
jne 0x19fef
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtScoreSym
int axtScoreSym(struct axtScoreScheme *ss, int symCount, char *qSym, char *tSym)
/* Return score without setting up an axt structure. */
{
int i;
char q,t;
int score = 0;
boolean lastGap = FALSE;
int gapStart = ss->gapOpen;
int gapExt = ss->gapExtend;

dnaUtilOpen();
for (i=0; i<symCount; ++i)
    {
    q = qSym[i];
    t = tSym[i];
    if (q == '-' || t == '-')
        {
    if (lastGap)
        score -= gapExt;
    else
        {
        /* Use gapStart+gapExt to be consistent with blastz: */
        score -= (gapStart + gapExt);
        lastGap = TRUE;
        }
    }
    else
        {
    score += ss->matrix[(int)q][(int)t];
    lastGap = FALSE;
    }
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, 0x4(%rsp)
movq %rdi, %r15
movl 0x40008(%rdi), %r12d
movl 0x4000c(%rdi), %r13d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x25e47
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x1a0a3
addq $0x8, %r15
addl %r13d, %r12d
movl %eax, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
movsbq (%r14,%rcx), %rsi
cmpq $0x2d, %rsi
sete %r8b
movb (%rbx,%rcx), %dil
cmpb $0x2d, %dil
sete %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x1a081
testl %edx, %edx
je 0x1a093
subl %r13d, %ebp
jmp 0x1a096
movsbq %dil, %rdx
shlq $0xa, %rsi
addq %r15, %rsi
addl (%rsi,%rdx,4), %ebp
xorl %edx, %edx
jmp 0x1a09b
subl %r12d, %ebp
movl $0x1, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x1a056
movl %ebp, %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/axt.c
// Function: axtScoreSymFilterRepeats
int axtScoreSymFilterRepeats(struct axtScoreScheme *ss, int symCount, char *qSym, char *tSym)
/* Return score without setting up an axt structure. Do not penalize gaps if repeat masked (lowercase)*/
{
int i;
char q,t;
int score = 0;
boolean lastGap = FALSE;
int gapStart = ss->gapOpen;
int gapExt = ss->gapExtend;

dnaUtilOpen();
for (i=0; i<symCount; ++i)
    {
    q = qSym[i];
    t = tSym[i];
    if ((q == '-' || t == '-') && gapNotMasked(q,t))
        {
    if (lastGap)
        score -= gapExt;
    else
        {
        /* Use gapStart+gapExt to be consistent with blastz: */
        score -= (gapStart + gapExt);
        lastGap = TRUE;
        }
    }
    else
        {
    score += ss->matrix[(int)q][(int)t];
    lastGap = FALSE;
    }
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movl 0x40008(%rdi), %eax
movl %eax, 0x4(%rsp)
movl 0x4000c(%rdi), %r13d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x25e47
testl %r12d, %r12d
jle 0x1a1c0
addl %r13d, 0x4(%rsp)
addq $0x8, %r15
movl %r12d, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
movsbq (%r14,%rcx), %rsi
cmpq $0x2d, %rsi
sete %r8b
movsbq (%rbx,%rcx), %rdi
cmpq $0x2d, %rdi
sete %r9b
movl %r8d, %r10d
orb %r9b, %r10b
notb %r10b
andb %r9b, %r8b
orb %r10b, %r8b
testb $0x1, %r8b
jne 0x1a194
cmpb $0x2d, %dil
sete %r8b
cmpb $0x2d, %sil
sete %r10b
cmpb $0x61, %dil
setl %r11b
cmpb $0x61, %sil
setl %r9b
testb %r11b, %r10b
jne 0x1a1a2
andb %r8b, %r9b
jne 0x1a1a2
shlq $0xa, %rsi
addq %r15, %rsi
addl (%rsi,%rdi,4), %ebp
xorl %edx, %edx
jmp 0x1a1b4
testl %edx, %edx
je 0x1a1ab
subl %r13d, %ebp
jmp 0x1a1af
subl 0x4(%rsp), %ebp
movl $0x1, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x1a13b
movl %ebp, %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/axt.c
// Function: axtTransPosToQ
int axtTransPosToQ(struct axt *axt, int tPos)
/* Convert from t to q coordinates */
{
char *tSym = skipIgnoringDash(axt->tSym, tPos - axt->tStart, TRUE);
int symIx = tSym - axt->tSym;
int qPos = countNonDash(axt->qSym, symIx);
return qPos + axt->qStart;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
subl 0x28(%rbx), %esi
movl $0x1, %edx
callq 0x25672
subl 0x48(%rbx), %eax
movq 0x40(%rbx), %rdi
movl %eax, %esi
callq 0x256a6
addl 0x10(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeDefault
struct axtScoreScheme *axtScoreSchemeDefault()
/* Return default scoring scheme (after blastz).  Do NOT axtScoreSchemeFree
 * this. */
{
static struct axtScoreScheme *ss;
static struct axtScoreScheme *tt;

if (ss != NULL)
    return ss;
if (tt == NULL)
    AllocVar(tt);

/* Set up lower case elements of matrix. */
tt->matrix['a']['a'] = 91;
tt->matrix['a']['c'] = -114;
tt->matrix['a']['g'] = -31;
tt->matrix['a']['t'] = -123;

tt->matrix['c']['a'] = -114;
tt->matrix['c']['c'] = 100;
tt->matrix['c']['g'] = -125;
tt->matrix['c']['t'] = -31;

tt->matrix['g']['a'] = -31;
tt->matrix['g']['c'] = -125;
tt->matrix['g']['g'] = 100;
tt->matrix['g']['t'] = -114;

tt->matrix['t']['a'] = -123;
tt->matrix['t']['c'] = -31;
tt->matrix['t']['g'] = -114;
tt->matrix['t']['t'] = 91;

propagateCase(tt);
tt->gapOpen = 400;
tt->gapExtend = 30;

ss = tt;
return ss;
}

// Assembly:
pushq %rbx
movq 0xa6acd(%rip), %rbx     # 0xc0fc0
testq %rbx, %rbx
jne 0x1a5bd
movq 0xa6ac5(%rip), %rbx     # 0xc0fc8
testq %rbx, %rbx
jne 0x1a51c
movl $0x40018, %edi          # imm = 0x40018
callq 0x2dff4
movq %rax, %rbx
movq %rax, 0xa6aac(%rip)     # 0xc0fc8
movl $0x5b, %eax
movl %eax, 0x1858c(%rbx)
movl $0xffffff8e, %ecx       # imm = 0xFFFFFF8E
movl %ecx, 0x18594(%rbx)
movl $0xffffffe1, %edx       # imm = 0xFFFFFFE1
movl %edx, 0x185a4(%rbx)
movl $0xffffff85, %esi       # imm = 0xFFFFFF85
movl %esi, 0x185d8(%rbx)
movl %ecx, 0x18d8c(%rbx)
movl $0x64, %edi
movl %edi, 0x18d94(%rbx)
movl $0xffffff83, %r8d       # imm = 0xFFFFFF83
movl %r8d, 0x18da4(%rbx)
movl %edx, 0x18dd8(%rbx)
movl %edx, 0x19d8c(%rbx)
movl %r8d, 0x19d94(%rbx)
movl %edi, 0x19da4(%rbx)
movl %ecx, 0x19dd8(%rbx)
movl %esi, 0x1d18c(%rbx)
movl %edx, 0x1d194(%rbx)
movl %ecx, 0x1d1a4(%rbx)
movl %eax, 0x1d1d8(%rbx)
movq %rbx, %rdi
callq 0x1a5c2
movabsq $0x1e00000190, %rax     # imm = 0x1E00000190
movq %rax, 0x40008(%rbx)
movq %rbx, 0xa6a03(%rip)     # 0xc0fc0
movq %rbx, %rax
popq %rbx
retq