LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/supStitch.c
// Function: trans3Offsets
static void trans3Offsets(struct trans3 *t3List, AA *startP, AA *endP,
	int *retStart, int *retEnd)
/* 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 <= startP && startP < seq->dna + seq->size)
	    {
	    *retStart = 3*(startP - seq->dna)+frame + t3->start;
	    *retEnd = 3*(endP - seq->dna)+frame + t3->start;
	    return;
	    }
	}
    }
internalErr();
}

// Assembly:
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x14da9
leal (%rdx,%rdx,2), %eax
negl %eax
leal (%rsi,%rsi,2), %edx
negl %edx
movl $0x3, %r11d
movl %edx, %r10d
movl %eax, %r9d
movq (%rdi,%r11,8), %r14
movq 0x10(%r14), %rbx
cmpq %rsi, %rbx
ja 0x14d92
movslq 0x18(%r14), %r14
addq %rbx, %r14
cmpq %rsi, %r14
ja 0x14dc6
decl %r9d
decl %r10d
incq %r11
cmpq $0x6, %r11
jne 0x14d79
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x14d6d
leaq 0x78e0b(%rip), %rdi     # 0x8dbbb
leaq 0x796ec(%rip), %rsi     # 0x8e4a3
movl $0xbc, %edx
xorl %eax, %eax
popq %rbx
popq %r14
jmp 0x26b6f
movl 0x30(%rdi), %eax
leal (%rbx,%rbx,2), %edx
subl %edx, %eax
subl %r10d, %eax
movl %eax, (%rcx)
movl 0x30(%rdi), %eax
subl %edx, %eax
subl %r9d, %eax
movl %eax, (%r8)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/supStitch.c
// Function: cutAtBigIntrons
struct ffAli *cutAtBigIntrons(struct ffAli *ffList, int maxIntron, 
	int *pScore, enum ffStringency stringency, 
	boolean isProt, bioSeq *tSeq, struct trans3 *t3List,
	struct ffAli **returnLeftovers)
/* Return ffList up to the first intron that's too big.
 * Put the rest of the blocks back onto the leftovers list. */
{
struct ffAli *prevFf, *ff, *cutFf = NULL;
prevFf = ffList;
for (ff = prevFf->right; ff != NULL; ff = ff->right)
    {
    int nhStart = trans3GenoPos(    ff->hStart, tSeq, t3List, FALSE);
    int ohEnd   = trans3GenoPos(prevFf->hEnd  , tSeq, t3List, TRUE);
    int dt = nhStart - ohEnd;
    if (dt > maxIntron)
        {
	cutFf = prevFf;
	break;
	}
    prevFf = ff;
    }
if (cutFf != NULL)
    {
    ff = cutFf->right;
    cutFf->right = NULL;
    ff->left = NULL;
    ffCat(returnLeftovers, &ff);
    if (isProt)
	*pScore = ffScoreProtein(ffList, stringency);
    else
	*pScore = ffScore(ffList, stringency);
    }
return ffList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movl %r8d, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movl %esi, %r12d
movq %rdi, %r15
movq 0x60(%rsp), %r14
xorl %ebx, %ebx
movq %rdi, %rax
movq %rdi, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x14e68
movq 0x20(%rax), %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x15f1c
movl %eax, %ebp
movq 0x28(%r15), %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x15f1c
subl %eax, %ebp
movq 0x10(%rsp), %rax
movq %r15, %rcx
cmpl %r12d, %ebp
jg 0x14e60
movq %rbx, %r15
movq %rax, %rcx
movq %r15, %rbx
movq %rcx, %r15
jle 0x14e16
testq %rbx, %rbx
movq 0x20(%rsp), %r14
je 0x14eb9
movq 0x8(%rbx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rcx, (%rax)
movq 0x68(%rsp), %rdi
callq 0x15fc0
cmpl $0x0, 0xc(%rsp)
je 0x14ea6
movq %r14, %rdi
movl 0x8(%rsp), %esi
callq 0x28495
jmp 0x14eb2
movq %r14, %rdi
movl 0x8(%rsp), %esi
callq 0x28417
movq 0x18(%rsp), %rcx
movl %eax, (%rcx)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/supStitch.c
// Function: ssConnectCost
static int ssConnectCost(struct cBlock *a, struct cBlock *b, void *data)
/* Calculate connection cost - including gap score
 * and overlap adjustments if any. */
{
struct ffAli *aFf = a->data, *bFf = b->data;
int overlapAdjustment = 0;
int overlap = findOverlap(a, b);
int dq = b->qStart - a->qEnd;
int dt = b->tStart - a->tEnd;

if (overlap > 0)
    {
    int aSize = aFf->hEnd - aFf->hStart;
    int bSize = bFf->hEnd - bFf->hStart;
    if (overlap >= bSize || overlap >= aSize)
	{
	/* Give stiff overlap adjustment for case where
	 * one block completely enclosed in the other on
	 * either sequence. This will make it never happen. */
	overlapAdjustment = a->score + b->score;
	}
    else
        {
	/* More normal case - partial overlap on one or both strands. */
	int crossover = findCrossover(aFf, bFf, overlap, ssIsProt);
	int remain = overlap - crossover;
	overlapAdjustment =
	    bioScoreMatch(ssIsProt, aFf->nEnd - remain, aFf->hEnd - remain, 
	    	remain)
	  + bioScoreMatch(ssIsProt, bFf->nStart, bFf->hStart, 
	  	crossover);
	dq -= overlap;
	dt -= overlap;
	}
    }
return overlapAdjustment + ssGapCost(dq, dt, data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %ebx
movl 0x10(%rsi), %r13d
subl 0x14(%rdi), %r13d
subl 0xc(%rdi), %ebx
cmpl %ebx, %r13d
movl %ebx, %r15d
cmovll %r13d, %r15d
xorl %ebp, %ebp
testl %r15d, %r15d
js 0x15bb4
xorl %r14d, %r14d
jmp 0x15c4b
movq 0x20(%rsi), %r14
movl %r15d, %r12d
negl %r12d
movl 0x28(%r14), %eax
subl 0x20(%r14), %eax
cmpl %eax, %r12d
jge 0x15c43
movq 0x20(%rdi), %rdx
movl 0x28(%rdx), %eax
subl 0x20(%rdx), %eax
cmpl %eax, %r12d
jge 0x15c43
movl 0xab3c4(%rip), %ecx     # 0xc0fa4
movq %rdx, %rdi
movq %r14, %rsi
movq %rdx, 0x10(%rsp)
movl %r12d, %edx
callq 0x15c93
movl %eax, 0xc(%rsp)
subl %eax, %r12d
movl 0xab3a4(%rip), %edi     # 0xc0fa4
movslq %r12d, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdx
subq %rcx, %rsi
subq %rcx, %rdx
callq 0x15b3f
movl %eax, %r12d
movl 0xab380(%rip), %edi     # 0xc0fa4
movq 0x10(%r14), %rsi
movq 0x20(%r14), %rdx
movl 0xc(%rsp), %ecx
callq 0x15b3f
movl %eax, %r14d
addl %r12d, %r14d
addl %r15d, %r13d
addl %r15d, %ebx
jmp 0x15c4b
movl 0x18(%rsi), %r14d
addl 0x18(%rdi), %r14d
testl %ebx, %ebx
cmovlel %ebp, %ebx
testl %r13d, %r13d
cmovgl %r13d, %ebp
movl 0xab343(%rip), %edx     # 0xc0fa0
movl %ebx, %edi
movl %ebp, %esi
callq 0x28204
addl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/supStitch.c
// Function: findCrossover
static int findCrossover(struct ffAli *left, struct ffAli *right, int overlap, boolean isProt)
/* Find ideal crossover point of overlapping blocks.  That is
 * the point where we should start using the right block rather
 * than the left block.  This point is an offset from the start
 * of the overlapping region (which is the same as the start of the
 * right block). */
{
int bestPos = 0;
char *nStart = right->nStart;
char *lhStart = left->hEnd - overlap;
char *rhStart = right->hStart;
int i;
int (*scoreMatch)(char a, char b);
int score, bestScore;

if (isProt)
    {
    scoreMatch = aaScore2;
    score = bestScore = aaScoreMatch(nStart, rhStart, overlap);
    }
else
    {
    scoreMatch = dnaScore2;
    score = bestScore = dnaScoreMatch(nStart, rhStart, overlap);
    }

for (i=0; i<overlap; ++i)
    {
    char n = nStart[i];
    score += scoreMatch(lhStart[i], n);
    score -= scoreMatch(rhStart[i], n);
    if (score > bestScore)
	{
	bestScore = score;
	bestPos = i+1;
	}
    }
return bestPos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq 0x10(%rsi), %r12
movq 0x20(%rsi), %rbx
movq 0x28(%rdi), %r13
movq %r12, %rdi
movq %rbx, %rsi
testl %ecx, %ecx
je 0x15cca
callq 0x258bd
movl %eax, %edx
leaq 0xfbd8(%rip), %rax      # 0x258a0
jmp 0x15cd8
callq 0x25866
movl %eax, %edx
leaq 0xfb39(%rip), %rax      # 0x25811
testl %r15d, %r15d
jle 0x15d61
movl %r15d, %ecx
movq %rcx, 0x20(%rsp)
subq %rcx, %r13
movq %rbx, 0x18(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movl %edx, %ebp
movq %rax, 0x10(%rsp)
movq %r12, 0x30(%rsp)
movq %r13, 0x28(%rsp)
movq 0x10(%rsp), %r14
movl %edx, 0xc(%rsp)
movq 0x30(%rsp), %rax
movsbl (%rax,%rbx), %r12d
movsbl (%r13,%rbx), %edi
movl %r12d, %esi
callq *%r14
movl %eax, %r13d
addl %ebp, %r13d
movq 0x18(%rsp), %rax
movsbl (%rax,%rbx), %edi
movl %r12d, %esi
callq *%r14
movl 0xc(%rsp), %edx
subl %eax, %r13d
incq %rbx
cmpl %edx, %r13d
cmovgl %r13d, %edx
cmovgl %ebx, %r15d
movl %r13d, %ebp
movq 0x28(%rsp), %r13
cmpq %rbx, 0x20(%rsp)
jne 0x15d0c
jmp 0x15d64
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2dc95
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 0x24cee
movq %rax, 0x18(%r14,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x15dae
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15e17
movq %rdi, %rbx
leaq 0x18(%r14), %rdi
callq 0x24ab1
leaq 0x20(%r14), %rdi
callq 0x24ab1
addq $0x28, %r14
movq %r14, %rdi
callq 0x24ab1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15e52
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x15ddb
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x15e3d
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x29029
testq %rax, %rax
je 0x15e8c
movq %rax, %rbx
cmpl %r14d, 0x30(%rbx)
jg 0x15e84
cmpl %ebp, 0x34(%rbx)
jge 0x15ea8
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x15e79
leaq 0x77d28(%rip), %rdi     # 0x8dbbb
leaq 0x78697(%rip), %rsi     # 0x8e531
xorl %ebx, %ebx
movl $0x47, %edx
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15f02
xorl %eax, %eax
movq 0x18(%rdi,%rax,8), %r9
movq 0x10(%r9), %r8
cmpq %rsi, %r8
ja 0x15ed1
movslq 0x18(%r9), %r9
addq %r8, %r9
cmpq %rsi, %r9
ja 0x15edf
incq %rax
cmpq $0x3, %rax
jne 0x15eb7
movq (%rdi), %rdi
jmp 0x15eb0
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 0x77cb2(%rip), %rdi     # 0x8dbbb
leaq 0x78621(%rip), %rsi     # 0x8e531
movl $0x5f, %edx
xorl %eax, %eax
jmp 0x26b6f
// File: /workspace/github_c_makefile_star2_O1/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 0x15f66
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
xorl %ecx, %ecx
testl %ebx, %ebx
setne %cl
subq %rcx, %rax
leaq 0x8(%rsp), %r8
leaq 0xc(%rsp), %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %r8, %rdx
callq 0x15eb0
testl %ebx, %ebx
je 0x15f55
incl 0x8(%rsp)
movl 0x8(%rsp), %eax
leal (%rax,%rax,2), %eax
addl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
subl 0x10(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15fbc
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 0x15eb0
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
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x16035
movq %rdi, %rbx
movq (%rsp), %rcx
movq %rcx, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x16005
movq %rsp, %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x1fd04
movq %r14, %rdi
callq 0x1fcb3
movq (%r14), %rdi
callq 0x27f4d
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x160a0
movb (%rax), %r8b
cmpb (%rcx), %r8b
jne 0x160a0
incq %rax
incq %rcx
cmpq %rsi, %rax
jae 0x160a0
cmpq %rdx, %rcx
jb 0x16088
movq %rax, 0x18(%rdi)
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x160d7
cmpq %rdx, %rax
jb 0x160d7
movb (%rcx), %r10b
leaq -0x1(%rcx), %r8
leaq -0x1(%rax), %r9
cmpb (%rax), %r10b
je 0x160b7
incq %rcx
movq %rcx, 0x10(%rdi)
incq %rax
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x161c8
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x161be
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdi, %rax
je 0x161ab
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 0x1619e
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 0x1619e
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 0x1610e
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x16102
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x1, %esi
jmp 0x161cb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16210
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x161d9
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x161f8
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
ja 0x16220
movq 0x8(%rbx), %r14
testl %ebp, %ebp
je 0x16208
movq %rbx, %rdi
callq 0x2dd41
movq %r14, %rbx
testq %r14, %r14
jne 0x161e4
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 0x16212
movq %rbx, %r15
movq %r14, %rdi
movq 0x8(%r14), %r14
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jbe 0x16253
movq 0x28(%rdi), %rax
cmpq 0x20(%rdi), %rax
jbe 0x16253
movq %rdi, %r15
jmp 0x16268
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x1625f
movq %r15, (%r14)
testl %ebp, %ebp
je 0x16268
callq 0x2dd41
testq %r14, %r14
jne 0x16233
jmp 0x16212
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
movl $0x0, %r9d
testl %r8d, %r8d
js 0x162ca
pushq %rbx
movl %edi, %r9d
andb $-0x21, %r9b
xorl %r10d, %r10d
cmpb $0x47, %r9b
sete %r10b
movl %esi, %r9d
andb $-0x21, %r9b
leal 0x1(%r10), %r11d
cmpb $0x54, %r9b
cmovnel %r10d, %r11d
movl %edx, %r9d
andb $-0x21, %r9b
xorl %r10d, %r10d
cmpb $0x41, %r9b
sete %r10b
movl %ecx, %ebx
andb $-0x21, %bl
xorl %r9d, %r9d
cmpb $0x47, %bl
sete %r9b
addl %r10d, %r9d
addl %r11d, %r9d
popq %rbx
testl %r8d, %r8d
jg 0x16305
andb $-0x21, %dil
xorl %eax, %eax
cmpb $0x43, %dil
sete %al
andb $-0x21, %sil
leal 0x1(%rax), %edi
cmpb $0x54, %sil
cmovnel %eax, %edi
andb $-0x21, %dl
xorl %esi, %esi
cmpb $0x41, %dl
sete %sil
andb $-0x21, %cl
xorl %eax, %eax
cmpb $0x43, %cl
sete %al
addl %esi, %eax
addl %edi, %eax
cmpl %eax, %r9d
cmovgl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x24(%rsp)
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x1650c
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1650c
movq $0x0, 0x8(%rsp)
movq %rdi, %rcx
movq %rax, %rdi
movq 0x28(%rcx), %r11
movq 0x20(%rax), %r10
movq %r10, %rax
subq %r11, %rax
cmpq $0x4, %rax
jl 0x164ff
movq 0x10(%rdi), %r14
movq 0x18(%rcx), %r15
movq %r14, %rax
subq %r15, %rax
cmpq $0x2, %rax
jg 0x164ff
movq %rcx, 0x40(%rsp)
movq 0x10(%rcx), %rax
movq %r10, 0x18(%rsp)
movq %r14, %rbp
movq %r11, 0x10(%rsp)
movq %r15, %rbx
cmpq %rax, %r15
jbe 0x163fe
movq %rax, %rdx
subq %r15, %rdx
leaq (%r10,%rdx), %rcx
movq %rcx, 0x18(%rsp)
leaq (%r14,%rdx), %rbp
addq %r11, %rdx
movq %rdx, 0x10(%rsp)
movq %r15, %rbx
movq %r11, %rcx
movq %r14, %rdx
movq %r10, %r9
movb -0x1(%rdx), %r8b
leaq -0x1(%r9), %rsi
cmpb $0x6e, -0x1(%rbx)
jne 0x163d6
cmpb $0x6e, %r8b
je 0x163db
cmpb (%rsi), %r8b
jne 0x163f1
decq %rbx
decq %rcx
decq %rdx
movq %rsi, %r9
cmpq %rax, %rbx
ja 0x163c2
movq %rax, %rbx
jmp 0x163fe
movq %r9, 0x18(%rsp)
movq %rdx, %rbp
movq %rcx, 0x10(%rsp)
movq %r15, 0x50(%rsp)
movq %r14, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x48(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x58(%rsp)
cmpq %rax, %rbp
jae 0x164a1
incq %rbp
movl $0x80000001, %r13d      # imm = 0x80000001
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rbp, %r15
movq %r14, 0x60(%rsp)
leaq (%rbx,%r12), %r14
movq 0x10(%rsp), %rax
movsbl (%rax,%r12), %ebp
movsbl 0x1(%rax,%r12), %esi
movq 0x18(%rsp), %rax
movsbl -0x2(%rax,%r12), %edx
movsbl -0x1(%rax,%r12), %ecx
movl %ebp, %edi
movl 0x24(%rsp), %r8d
callq 0x1626f
movb (%rbx,%r12), %cl
cmpb $0x6e, %cl
setne %dl
cmpb %bpl, %cl
setne %cl
cmpl %r13d, %eax
cmovleq 0x60(%rsp), %r14
cmovgl %eax, %r13d
testb %cl, %dl
jne 0x164a4
movq %r15, %rbp
leaq (%r15,%r12), %rax
incq %r12
cmpq 0x58(%rsp), %rax
jb 0x16434
jmp 0x164a4
xorl %r14d, %r14d
testq %r14, %r14
je 0x164fa
movq 0x50(%rsp), %rdx
subq %rdx, %r14
testl %r14d, %r14d
movq 0x28(%rsp), %rdi
je 0x164ff
movslq %r14d, %rax
addq %rax, %rdx
movq 0x40(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x38(%rsp), %rdx
addq %rax, %rdx
movq %rdx, 0x28(%rcx)
movq 0x30(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rdi)
movq 0x48(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x20(%rdi)
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x164ff
movq 0x28(%rsp), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x16347
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_O1/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
testq %rdi, %rdi
je 0x1663b
movl %esi, %ebp
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rdi, %r14
movq %r14, %rdi
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x1662d
movq 0x18(%r15), %rdx
movq 0x10(%rdi), %rax
movq %rdx, %rcx
subq %rax, %rcx
testl %ecx, %ecx
jle 0x165eb
cmpq %rax, 0x10(%r15)
ja 0x165d8
cmpq 0x18(%rdi), %rdx
jae 0x16615
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, 0x20(%rdi)
addq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x1662d
jne 0x1662d
movq 0x28(%r15), %rax
cmpq 0x20(%rdi), %rax
jne 0x1662d
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x16603
movq %r15, (%r14)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%r15)
movq 0x28(%rdi), %rax
movq %rax, 0x28(%r15)
jmp 0x16621
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x16621
movq %r15, (%r14)
testl %ebp, %ebp
je 0x1662a
callq 0x2dd41
movq %r15, %rdi
movq %rdi, %r15
testq %r14, %r14
jne 0x165ae
jmp 0x1663d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x16cd2
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 0x16ca8
jmp 0x16cd6
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
cmpl %esi, %eax
jge 0x16d04
cvtsi2sd %eax, %xmm0
cvtsi2sd %esi, %xmm1
mulsd 0x77859(%rip), %xmm1    # 0x8e548
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jb 0x16d06
mulsd 0x77851(%rip), %xmm0    # 0x8e550
cvttsd2si %xmm0, %eax
retq
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18195
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 0x196ee
addq $0x20, %rsp
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x15fc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18206
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 0x196ee
addq $0x20, %rsp
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x15fc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18267
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 0x1824c
leal -0x1(%r10), %ebx
cmpl %r9d, %r8d
cmovgel %ebx, %r11d
leal 0x1(%r8), %r8d
cmovgel %r8d, %r9d
jmp 0x1825b
addl $-0x3, %r8d
movl %r9d, %ebx
subl %r8d, %ebx
cmpl $0x8, %ebx
jg 0x18263
decq %r10
cmpq %rsi, %r10
jg 0x1822b
movslq %r11d, %r8
popq %rbx
addq %r8, %rdi
movq %rdi, (%rdx)
addq %r8, %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x182d0
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 0x182b3
cmpl %r11d, %r8d
leal 0x1(%r8), %r8d
cmovgel %r8d, %r11d
cmovgel %r10d, %esi
jmp 0x182c2
addl $-0x3, %r8d
movl %r11d, %ebx
subl %r8d, %ebx
cmpl $0x8, %ebx
jg 0x182ca
incq %r10
cmpq %r10, %r9
jne 0x18298
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_O1/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 0x18392
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %r15
movq 0x10(%rcx), %r12
movslq 0x18(%rdx), %rax
addq %r15, %rax
movq %rax, 0x10(%rsp)
movslq 0x18(%rcx), %rax
addq %r12, %rax
movq %rax, 0x8(%rsp)
movslq %esi, %rbp
movl $0x38, %edi
callq 0x2dc95
movq %rax, %r13
movl 0x8(%r14), %eax
addq %r15, %rax
movq %rax, 0x18(%r13)
movq %rax, 0x10(%r13)
movl 0xc(%r14), %ecx
addq %r12, %rcx
movq %rcx, 0x20(%r13)
addq %rbp, %rax
movq %rax, 0x18(%r13)
addq %rbp, %rcx
movq %rcx, 0x28(%r13)
movq (%rbx), %rax
movq %rax, (%r13)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x160a9
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x16069
movq %r13, (%rbx)
movq (%r14), %r14
testq %r14, %r14
jne 0x1831d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rcx, %rcx
je 0x18444
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x48, %edi
callq 0x2dc95
movq %rax, (%rsp)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x1, 0x40(%rax)
movl $0x10, %edi
callq 0x2dc95
movq %rbx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rcx)
movl $0x10, %edi
callq 0x2dc95
movq %r14, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rcx)
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
movl $0x1, %ecx
callq 0x14ecb
movq (%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1843a
movq 0x8(%rax), %rbx
movq $0x0, 0x8(%rax)
jmp 0x1843c
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x14940
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x28204
movl %eax, %ebx
cmpl $0x3, %r13d
setl %al
cmpl $0x3, %r12d
setl %cl
testb %cl, %al
jne 0x184ba
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 0x1626f
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x184ea
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x2dd41
movq %rbx, %rdi
popq %rbx
jmp 0x2dd51
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74e59(%rip), %rsi     # 0x8e6e7
callq 0x2054a
testl %eax, %eax
je 0x19910
leaq 0x74e4d(%rip), %rsi     # 0x8e6eb
movq %rbx, %rdi
callq 0x2054a
testl %eax, %eax
je 0x19914
leaq 0x74e3e(%rip), %rsi     # 0x8e6ef
movq %rbx, %rdi
callq 0x2054a
movl $0x2, %ebp
testl %eax, %eax
je 0x19919
leaq 0x73b10(%rip), %rsi     # 0x8d3d9
movq %rbx, %rdi
callq 0x2054a
testl %eax, %eax
je 0x19919
leaq 0x74e1b(%rip), %rsi     # 0x8e6f7
movq %rbx, %rdi
callq 0x2054a
testl %eax, %eax
je 0x19922
leaq 0x74e0d(%rip), %rsi     # 0x8e6fc
movq %rbx, %rdi
callq 0x2054a
testl %eax, %eax
je 0x19929
leaq 0x74e0d(%rip), %rdi     # 0x8e70f
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
jmp 0x19919
xorl %ebp, %ebp
jmp 0x19919
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x3, %ebp
jmp 0x19919
movl $0x4, %ebp
jmp 0x19919
// File: /workspace/github_c_makefile_star2_O1/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 0x19972
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x2dd41
movq 0x20(%r14), %rdi
callq 0x2dd41
movq 0x40(%r14), %rdi
callq 0x2dd41
movq 0x48(%r14), %rdi
callq 0x2dd41
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x199ad
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x19930
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x19998
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa7425(%rip), %edx     # 0xc0fa8
leal 0x1(%rdx), %eax
movl %eax, 0xa741c(%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 0x74c10(%rip), %rsi     # 0x8e7c2
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 0x7a011(%rip), %rsi     # 0x93be4
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 0x22e1e
movl $0xa, %edi
movq %r14, %rsi
callq 0x6930
movq 0x40(%rbx), %rsi
movslq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x22e1e
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
cmpq %rax, %r14
jne 0x19c5a
movslq 0x38(%rbx), %rcx
cmpq %rcx, %r14
jb 0x19c5a
popq %rbx
popq %r14
popq %r15
retq
movq 0xa5377(%rip), %rcx     # 0xbefd8
movq (%rcx), %rdi
movl 0x38(%rbx), %r8d
movl 0xa7339(%rip), %r10d    # 0xc0fa8
leaq 0x74b64(%rip), %rsi     # 0x8e7da
movl %eax, %edx
movl %r14d, %ecx
movl %r14d, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x8(%rbx)
callq 0x6a90
addq $0x10, %rsp
jmp 0x19c54
// File: /workspace/github_c_makefile_star2_O1/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 0x19cb2
movl 0x10(%r14), %eax
subl 0x10(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19cdc
movl 0x28(%r14), %eax
subl 0x28(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19d13
movl 0x34(%r14), %eax
subl 0x34(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq