LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: findAliBetween
struct ffAli *findAliBetween(DNA *tile, int tileSize, DNA *ns, DNA *ne, DNA *hs, DNA *he, struct lm **ffMemPool)
{
    DNA *match;
    DNA *tileEnd = tile + tileSize;
    int tries = 0;

    for (;;)
    {
        if ((match = matchInMem(tile, tileEnd, hs, he)) == NULL)
            return NULL;
        if (matchInMem(tile, tileEnd, match+1, he) == NULL)
        {
            /* Got exactly one match, whoopie! */
            struct ffAli *ali = ffNeedMem(sizeof(*ali), ffMemPool);
            ali->nStart = tile;
            ali->nEnd = tileEnd;
            ali->hStart = match;
            ali->hEnd = match + (tileEnd-tile);
            ffExpandExactLeft(ali, ns, hs);
            ffExpandExactRight(ali, ne, he);
            return ali;
        }

        /* Got more than one match.  Expand tile to make it more specific.
         * In general first add base to start, then base to beginning.  If
         * at beginning or end already are constrained.  If already spanning
         * full needle, can't expand, so you're done. */
        if (tile <= ns)
        {
            if (tileEnd >= ne)
                return NULL;
            ++tileEnd;
        }
        else if (tile >= tileEnd)
        {
            --tile;
        }
        else if (tries & 1)
        {
            ++tileEnd;
        }
        else
        {
            --tile;
        }
        ++tries;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
movslq %esi, %rbp
addq %rdi, %rbp
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x8ccd
testq %rax, %rax
je 0x8daf
movq %rax, %r14
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0x8ccd
testq %rax, %rax
je 0x8db4
cmpq 0x10(%rsp), %r15
jbe 0x8da0
cmpq %rbp, %r15
jae 0x8d9b
testb $0x1, %r13b
jne 0x8da7
decq %r15
jmp 0x8daa
cmpq 0x8(%rsp), %rbp
jae 0x8daf
incq %rbp
incl %r13d
jmp 0x8d59
xorl %r13d, %r13d
jmp 0x8dfa
pushq $0x38
popq %rdi
movq 0x50(%rsp), %rsi
callq 0x8e0c
movq %rax, %r13
movq %r15, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r14, 0x20(%rax)
subq %r15, %rbp
addq %r14, %rbp
movq %rbp, 0x28(%rax)
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x13242
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x13217
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: evalExactAli
double evalExactAli(struct ffAli *ali, DNA *ns, DNA *ne, DNA *hs, DNA *he, int numTiles,
    double freq[4])
{
int haySize = he-hs;
double prob = 1.0;
double allPossibles = haySize*numTiles;

for (;ali != NULL;ali=ali->right)
    {
    double p = oligoProb(ali->nStart, ali->nEnd - ali->nStart, freq) * allPossibles;
    if (p < 1.0)
        prob *= p;
    }
return prob;
}

// Assembly:
movq 0x8(%rsp), %rax
subl %ecx, %r8d
imull %r9d, %r8d
cvtsi2sd %r8d, %xmm1
movsd 0x73a45(%rip), %xmm2    # 0x7c878
xorl %ecx, %ecx
leaq 0xac644(%rip), %rdx     # 0xb5480
movapd %xmm2, %xmm0
testq %rdi, %rdi
je 0x8ea3
movq 0x10(%rdi), %rsi
movl 0x18(%rdi), %r8d
subl %esi, %r8d
testl %r8d, %r8d
cmovlel %ecx, %r8d
xorl %r9d, %r9d
movapd %xmm2, %xmm3
cmpq %r9, %r8
je 0x8e7c
movsbq (%rsi,%r9), %r10
movslq (%rdx,%r10,4), %r10
testq %r10, %r10
js 0x8e77
mulsd (%rax,%r10,8), %xmm3
incq %r9
jmp 0x8e5e
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm4
andnpd %xmm0, %xmm3
orpd %xmm4, %xmm3
movq 0x8(%rdi), %rdi
movapd %xmm3, %xmm0
jmp 0x8e40
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: canAdd
boolean canAdd(struct protoGene *a, struct protoGene *b)
/* Can b fit into a?  It can if it doesn't overlap
 * by more than 1/4 with what's already there. */
{
struct ffAli *pa;
DNA *bnEnd = b->nEnd;
DNA *bnStart = b->nStart;
DNA *bhEnd = b->hEnd;
DNA *bhStart = b->hStart;
int bSize = bnEnd - bnStart;
int maxOverlap;
for (pa = a->hits; pa != NULL; pa = pa->right)
    {
    int aSize = pa->nEnd - pa->nStart;
    DNA *start = (bnStart > pa->nStart ? bnStart : pa->nStart);
    DNA *end = (bnEnd < pa->nEnd ? bnEnd : pa->nEnd);
    maxOverlap = (aSize < bSize ? aSize : bSize) / 4;
    if (maxOverlap < 2) maxOverlap = 2;
    if (end - start >= maxOverlap)
       return FALSE;
    start = (bhStart > pa->hStart ? bhStart : pa->hStart);
    end = (bhEnd < pa->hEnd ? bhEnd : pa->hEnd);
    if (end - start >= maxOverlap)
        return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsi), %r8
movq 0x28(%rsi), %r9
movq 0x18(%rsi), %r10
movq 0x20(%rsi), %rsi
movl %r8d, %r11d
subl %r9d, %r11d
addq $0x10, %rdi
movl $0x1, %ebx
movl $0x4, %ebp
movl $0x2, %r14d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x8f96
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
movl %r12d, %eax
subl %r15d, %eax
cmpq %r15, %r9
cmovaq %r9, %r15
cmpq %r12, %r8
cmovbq %r8, %r12
cmpl %r11d, %eax
cmovgel %r11d, %eax
cltd
idivl %ebp
movl %eax, %ecx
cmpl $0x3, %eax
cmovll %r14d, %ecx
subq %r15, %r12
xorl %eax, %eax
cmpq %rcx, %r12
jge 0x8f98
movq 0x20(%rdi), %rdx
cmpq %rdx, %r10
cmovaq %r10, %rdx
movq 0x28(%rdi), %r15
cmpq %r15, %rsi
cmovbq %rsi, %r15
subq %rdx, %r15
addq $0x8, %rdi
cmpq %rcx, %r15
jl 0x8f31
jmp 0x8f98
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: bestMerger
boolean bestMerger(struct protoGene *list, enum ffStringency stringency,
    DNA *ns, DNA *hs, struct protoGene **retA, struct protoGene **retB)
/* Figure out best scoring merger in list. */
{
int bestScore = -0x7fffffff;
int score;
struct protoGene *bestA = NULL, *bestB = NULL;
struct protoGene *a, *b;
boolean isCdna = (stringency == ffCdna);

if (list == NULL)
    return FALSE;

for (a = list; a != NULL; a = a->right)
    {
    for (b = a->right; b != NULL; b = b->right)
        {
        if (canAdd(a,b))
            {
            int hGap = b->hStart - a->hEnd;
            int nGap = b->nStart - a->nEnd;
            if (hGap < 0)
                {
                hGap = -8*hGap;
                if (!isCdna || hGap < 32)
                    hGap = (hGap*hGap);
                }
            if (nGap < 0)
                nGap = -8*nGap;
            score = -hGap - nGap*nGap;
            if (score > bestScore)
                {
                bestA = a;
                bestB = b;
                bestScore = score;
                }
            }
        }
    }
*retA = bestA;
*retB = bestB;
return bestA != NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x9085
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
movq %r8, (%rsp)
movq %r9, 0x8(%rsp)
movl $0x80000001, %ebx       # imm = 0x80000001
xorl %r13d, %r13d
xorl %r14d, %r14d
testq %r15, %r15
je 0x905f
leaq 0x8(%r15), %r12
movq %r12, 0x10(%rsp)
movq (%r12), %r12
testq %r12, %r12
je 0x9052
movq %r15, %rdi
movq %r12, %rsi
callq 0x8eff
testl %eax, %eax
je 0x904c
movl 0x18(%r12), %eax
subl 0x20(%r15), %eax
jns 0x9021
leal (,%rax,8), %ecx
negl %ecx
cmpl $-0x3, %eax
pushq $0x1
popq %rax
cmovael %ecx, %eax
cmpl $0x1, %ebp
cmovnel %ecx, %eax
imull %ecx, %eax
movl 0x28(%r12), %ecx
subl 0x30(%r15), %ecx
leal (,%rcx,8), %edx
negl %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
imull %edx, %edx
addl %eax, %edx
negl %edx
cmpl %edx, %ebx
cmovlel %edx, %ebx
cmovlq %r15, %r13
cmovlq %r12, %r14
addq $0x8, %r12
jmp 0x8fe3
movq 0x10(%rsp), %rax
movq (%rax), %r15
jmp 0x8fd1
movq (%rsp), %rax
movq %r13, (%rax)
movq 0x8(%rsp), %rax
movq %r14, (%rax)
xorl %eax, %eax
testq %r13, %r13
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: mergeProtoGenes
void mergeProtoGenes(struct protoGene **pList, struct protoGene *a, struct protoGene *b)
/* Absorb protoGene b into protoGene a. */
{
ffUnlink((struct ffAli**)pList, (struct ffAli *)b);
ffCat(&a->hits, &b->hits);
if (a->hStart > b->hStart)
    a->hStart = b->hStart;
if (a->nStart > b->nStart)
    a->nStart = b->nStart;
if (a->hEnd < b->hEnd)
    a->hEnd = b->hEnd;
if (a->nEnd < b->nEnd)
    a->nEnd = b->nEnd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdx, %rsi
callq 0x8ea4
leaq 0x10(%rbx), %rdi
leaq 0x10(%r14), %rsi
callq 0x1317c
movq 0x18(%r14), %rax
cmpq %rax, 0x18(%rbx)
jbe 0x90b5
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rbx)
jbe 0x90c3
movq %rax, 0x28(%rbx)
movq 0x20(%r14), %rax
cmpq %rax, 0x20(%rbx)
jae 0x90d1
movq %rax, 0x20(%rbx)
movq 0x30(%r14), %rax
cmpq %rax, 0x30(%rbx)
jae 0x90df
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: lumpHits
struct protoGene *lumpHits(struct ffAli **pHitList, DNA *ns, DNA *hs, struct lm **ffMemPool)
/* Lump together as many hits as can. Criteria - they must be close
 * to same "diagonal." That is the distance between them must be
 * nearly the same in the needle and the haystack. */
{
    struct protoGene proto;
    struct protoGene *retProto;
    struct ffAli *ali, *nextAli;
    int dif, lastDif;
    int lumpCount = 1;

    if ((ali = *pHitList) == NULL)
        return NULL;

    /* Move first hit onto our crude exon. */
    nextAli = ali->right;
    proto.left = proto.right = NULL;
    unlinkAli(pHitList, ali);
    proto.hits = ali;
    proto.hStart = ali->hStart;
    proto.hEnd = ali->hEnd;
    proto.nStart = ali->nStart;
    proto.nEnd = ali->nEnd;
    lastDif = ali->hStart - ali->nStart;

    /* Go through rest of list and put others that are close to
     * on the same diagonal onto this exon. */
    while ((ali = nextAli) != NULL)
    {
        nextAli = ali->right;
        dif = ali->hStart - ali->nStart;
        if (lastDif - 2 <= dif && dif <= lastDif + 2)
        {
            lastDif = dif;
            unlinkAli(pHitList, ali);
            ali->left = proto.hits;
            proto.hits = ali;
            proto.hEnd = ali->hEnd;
            proto.nEnd = ali->nEnd;
            ++lumpCount;
        }
    }
    proto.hits = ffMakeRightLinks(proto.hits);
    retProto = ffNeedMem(sizeof(*retProto), ffMemPool);
    memcpy(retProto, &proto, sizeof(*retProto));
    return retProto;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x9205
movq %rdi, %r15
movq %rcx, 0x10(%rsp)
movq 0x8(%r14), %rbx
movq %r14, %rsi
callq 0x8ea4
movq 0x10(%r14), %rax
movq 0x20(%r14), %r13
movq %r13, (%rsp)
movq %rax, 0x8(%rsp)
subl %eax, %r13d
movq 0x18(%r14), %rdi
movq 0x28(%r14), %rbp
leal -0x2(%r13), %eax
movl %r13d, %ecx
addl $0x2, %ecx
testq %rbx, %rbx
je 0x91c5
movq %rbx, %r12
movq 0x8(%rbx), %rbx
movq 0x20(%r12), %r13
subq 0x10(%r12), %r13
cmpl %r13d, %eax
setg %dl
cmpl %r13d, %ecx
setl %sil
orb %dl, %sil
jne 0x9189
movq %r15, %rdi
movq %r12, %rsi
callq 0x8ea4
movq %r14, (%r12)
movq %r12, %r14
jmp 0x9177
movq %rdi, %rbx
movq %r14, %rdi
callq 0x236b0
movq %rax, %r14
pushq $0x40
popq %rdi
movq 0x10(%rsp), %rsi
callq 0x8e0c
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq %rbx, 0x30(%rax)
jmp 0x9207
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: thinProtoList
void thinProtoList(struct protoGene **pList, int maxToTake)
/* Reduce list to only top scoring members.  At this
 * point protoList is singly linked on left. */
{
struct protoGene *newList = NULL, *pg, *next;
int i;

slSort(pList, cmpProtoScore);
for (pg=*pList, i=0; pg != NULL && i < maxToTake; pg = next, ++i)
    {
    next = pg->left;
    pg->left = newList;
    newList = pg;
    }
*pList = newList;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq -0x333(%rip), %rsi      # 0x8ef2
callq 0x1c5ab
movq (%rbx), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x924a
cmpl %ebp, %ecx
jge 0x924a
movq %rdx, %rsi
movq (%rdx), %rdx
movq %rax, (%rsi)
incl %ecx
movq %rsi, %rax
jmp 0x9231
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: ffFindAndScore
boolean ffFindAndScore(DNA *needle, int needleSize, DNA *haystack, int haySize,
    enum ffStringency stringency, struct ffAli **pAli, boolean *pRcNeedle, int *pScore)
/* Return TRUE if find an allignment using needle, or reverse complement of 
 * needle to search haystack. DNA must be lower case. If pScore is non-NULL returns
 * score of alignment. */
{
int fScore, rScore;
struct ffAli *fAli, *rAli;

/* Get forward alignment and score it. */
fAli = ffFind(needle, needle+needleSize, haystack, haystack+haySize, stringency);
fScore = ffScore(fAli,stringency);

/* Get reverse alignment and score it. */
reverseComplement(needle, needleSize);
rAli = ffFind(needle, needle+needleSize, haystack, haystack+haySize, stringency);
rScore = ffScore(rAli,stringency);
reverseComplement(needle, needleSize);

/* If no good alignment on either strand return FALSE. */
if (fAli == NULL && rAli == NULL)
    {
    *pAli = NULL;
    return FALSE;
    }

/* Return TRUE with best alignment.  Free the other one. */
if (fScore > rScore)
    {
    *pAli = fAli;
    *pRcNeedle = FALSE;
    if (pScore != NULL)
        *pScore = fScore;
    ffFreeAli(&rAli);
    }   
else
    {
    *pAli = rAli;
    *pRcNeedle = TRUE;
    if (pScore != NULL)
        *pScore = rScore;
    ffFreeAli(&fAli);
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, %r13d
movq %rdx, %rbx
movq %rdi, %r15
movslq %esi, %r12
leaq (%rdi,%r12), %rsi
movq %rsi, 0x10(%rsp)
movslq %ecx, %rbp
addq %rdx, %rbp
movq %rbp, %rcx
callq 0x9254
movq %rax, %r14
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl %r13d, %esi
callq 0x23afc
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x20d38
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movl %r13d, %r8d
callq 0x9254
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movl %r13d, %esi
callq 0x23afc
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x20d38
movq %r14, %rax
orq %rbx, %rax
jne 0x96e2
movq 0x8(%rsp), %rax
andq $0x0, (%rax)
xorl %eax, %eax
jmp 0x972c
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rcx
movl 0x4(%rsp), %esi
cmpl %r13d, %esi
jle 0x970e
movq %r14, (%rdx)
andl $0x0, (%rcx)
testq %rax, %rax
je 0x9707
movl %esi, (%rax)
leaq 0x18(%rsp), %rdi
jmp 0x9724
movq %rbx, (%rdx)
movl $0x1, (%rcx)
testq %rax, %rax
je 0x971f
movl %r13d, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x23624
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfReadMulti
int gfReadMulti(int sd, void *vBuf, size_t size)
/* Read in until all is read or there is an error. */
{
char *buf = vBuf;
size_t totalRead = 0;
int oneRead;

while (totalRead < size)
    {
    oneRead = read(sd, buf + totalRead, size - totalRead);
    if (oneRead < 0)
        {
	perror("Couldn't finish large read");
	return oneRead;
	}
    else if (oneRead == 0)
    /* Avoid an infinite loop when the client closed the socket. */
        break;
    totalRead += oneRead;
    }
return totalRead;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r12d, %r12d
movq %rbx, %rdx
subq %r12, %rdx
jbe 0xa8da
leaq (%r14,%r12), %rsi
movl %ebp, %edi
callq 0x6aa0
movq %rax, %r15
testl %r15d, %r15d
js 0xa8e9
je 0xa8da
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %r15, %r12
jmp 0xa8b1
movl %r12d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x72070(%rip), %rdi     # 0x7c960
callq 0x6590
jmp 0xa8dd
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: genoFindFree
void genoFindFree(struct genoFind **pGenoFind)
/* Free up a genoFind index. */
{
struct genoFind *gf = *pGenoFind;
int i;
struct gfSeqSource *sources;
if (gf != NULL)
    {
    freeMem(gf->lists);
    freeMem(gf->listSizes);
    freeMem(gf->allocated);
    if ((sources = gf->sources) != NULL)
	{
	for (i=0; i<gf->sourceCount; ++i)
	    bitFree(&sources[i].maskedBits);
	freeMem(sources);
	}
    freez(pGenoFind);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0xa96e
movq %rdi, %rbx
movq 0x48(%r12), %rdi
callq 0x28c2d
movq 0x38(%r12), %rdi
callq 0x28c2d
movq 0x40(%r12), %rdi
callq 0x28c2d
movq 0x20(%r12), %r14
testq %r14, %r14
je 0xa95d
leaq 0x20(%r14), %r15
xorl %r13d, %r13d
movslq 0x1c(%r12), %rax
cmpq %rax, %r13
jge 0xa955
movq %r15, %rdi
callq 0x183fd
incq %r13
addq $0x28, %r15
jmp 0xa93a
movq %r14, %rdi
callq 0x28c2d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x28c3d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfPowerOf20
int gfPowerOf20(int n)
/* Return a 20 to the n */
{
int res = 20;
while (--n > 0)
    res *= 20;
return res;
}

// Assembly:
pushq $0x14
popq %rax
cmpl $0x2, %edi
jl 0xa987
decl %edi
imull $0x14, %eax, %eax
jmp 0xa97b
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfDnaTile
int gfDnaTile(DNA *dna, int n)
/* Make a packed DNA n-mer. */
{
int tile = 0;
int i, c;
for (i=0; i<n; ++i)
    {
    tile <<= 2;
    if ((c = ntLookup[(int)dna[i]]) < 0)
        return -1;
    tile += c;
    }
return tile;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
leaq 0xa8fce(%rip), %r8      # 0xb3990
pushq $-0x1
popq %rdx
xorl %eax, %eax
cmpq %rcx, %rsi
je 0xa9e5
movsbq (%rdi,%rcx), %r9
movl (%r8,%r9,4), %r9d
testl %r9d, %r9d
js 0xa9e3
leal (%r9,%rax,4), %eax
incq %rcx
jmp 0xa9c7
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfPepTile
int gfPepTile(AA *pep, int n)
/* Make up packed representation of translated protein. */
{
int tile = 0;
int aa;
while (--n >= 0)
    {
    tile *= 20;
    aa = aaVal[(int)(*pep++)];
    if (aa < 0 || aa > 19)
        return -1;
    tile += aa;
    }
return tile;
}

// Assembly:
xorl %eax, %eax
leaq 0xac7c1(%rip), %rdx     # 0xb71b0
pushq $-0x1
popq %rcx
testl %esi, %esi
jle 0xaa16
movsbq (%rdi), %r8
movl (%rdx,%r8,4), %r8d
cmpl $0x13, %r8d
ja 0xaa14
incq %rdi
imull $0x14, %eax, %eax
addl %eax, %r8d
decl %esi
movl %r8d, %eax
jmp 0xa9f2
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfAllocLists
static int gfAllocLists(struct genoFind *gf)
/* Allocate index lists and set up list pointers. 
 * Returns size of all lists. */
{
int oneCount;
int count = 0;
int i;
bits32 *listSizes = gf->listSizes;
bits32 **lists = gf->lists;
bits32 *allocated = NULL;
bits32 maxPat = gf->maxPat;
int size;
int usedCount = 0, overusedCount = 0;
int tileSpaceSize = gf->tileSpaceSize;

for (i=0; i<tileSpaceSize; ++i)
    {
    /* If pattern is too much used it's no good to us, ignore. */
    if ((oneCount = listSizes[i]) < maxPat)
        {
        count += oneCount;
        usedCount += 1;
        }
    else
        {
        overusedCount += 1;
        }
    }
if (count > 0)
    gf->allocated = allocated = needHugeMem(count*sizeof(allocated[0]));
for (i=0; i<tileSpaceSize; ++i)
    {
    if ((size = listSizes[i]) < maxPat)
        {
        lists[i] = allocated;
        allocated += size;
        }
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq 0x48(%rdi), %r15
movl (%rdi), %ebp
movl 0x14(%rdi), %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %rdx, %r12
je 0xaf8a
movl (%r14,%rdx,4), %esi
cmpl %ebp, %esi
cmovael %eax, %esi
addl %esi, %ecx
incq %rdx
jmp 0xaf75
testl %ecx, %ecx
jle 0xaf9f
movl %ecx, %edi
shlq $0x2, %rdi
callq 0x28ad7
movq %rax, 0x40(%rbx)
jmp 0xafa1
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0xafbd
movslq (%r14,%rcx,4), %rdx
cmpl %ebp, %edx
jae 0xafb8
movq %rax, (%r15,%rcx,8)
leaq (%rax,%rdx,4), %rax
incq %rcx
jmp 0xafa3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfAddSeq
static void gfAddSeq(struct genoFind *gf, bioSeq *seq, bits32 offset)
/* Add all N-mers in seq.  Done after gfCountSeq. */
{
char *poly = seq->dna;
int tileSize = gf->tileSize;
int stepSize = gf->stepSize;
int i, lastTile = seq->size - tileSize;
int (*makeTile)(char *poly, int n) = (gf->isPep ? gfPepTile : gfDnaTile);
int maxPat = gf->maxPat;
int tile;
bits32 *listSizes = gf->listSizes;
bits32 **lists = gf->lists;

initNtLookup();
for (i=0; i<=lastTile; i += stepSize)
    {
    tile = makeTile(poly, tileSize);
    if (tile >= 0)
        {
	if (listSizes[tile] < maxPat)
	    {
	    lists[tile][listSizes[tile]++] = offset;
	    }
	}
    offset += stepSize;
    poly += stepSize;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsp)
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %ebx
movslq 0x10(%rdi), %r12
movl 0x18(%rsi), %r13d
subl %ebx, %r13d
cmpb $0x0, 0x28(%rdi)
leaq -0x66f(%rip), %rax      # 0xa9b4
leaq -0x644(%rip), %rbp      # 0xa9e6
cmoveq %rax, %rbp
movq 0x38(%rdi), %r15
movq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0xd4c6
movl %r14d, %eax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
cmpl %r13d, %r14d
jg 0xb08d
movq 0x20(%rsp), %rax
leaq (%rax,%r14), %rdi
movl %ebx, %esi
callq *%rbp
testl %eax, %eax
js 0xb088
movl %eax, %eax
movl (%r15,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xb088
movq 0x10(%rsp), %rdx
addq %r14, %rdx
movq 0x18(%rsp), %rsi
movq (%rsi,%rax,8), %rsi
leal 0x1(%rcx), %edi
movl %edi, (%r15,%rax,4)
movl %edx, (%rsi,%rcx,4)
addq %r12, %r14
jmp 0xb04b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: readMaskedNib
struct dnaSeq *readMaskedNib(char *fileName, boolean mask)
/* Read nib, optionally turning masked bits to N's. 
 * Result is lower case where not masked. */
{
struct dnaSeq *seq;
if (mask)
    {
    seq = nibLoadAllMasked(NIB_MASK_MIXED, fileName);
    toggleCase(seq->dna, seq->size);
    upperToN(seq->dna, seq->size);
    }
else
    seq = nibLoadAll(fileName);
return seq;
}

// Assembly:
movq %rdi, %rax
testl %esi, %esi
je 0xb0f3
pushq %rbx
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x2ca98
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x1dfc1
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x21072
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
jmp 0x2cb36
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: readMaskedTwoBit
struct dnaSeq *readMaskedTwoBit(struct twoBitFile *tbf, char *seqName,
	boolean mask)
/* Read seq from twoBitFile, optionally turning masked bits to N's. 
 * Result is lower case where not masked. */
{
struct dnaSeq *seq;
if (mask)
    {
    seq = twoBitReadSeqFrag(tbf, seqName, 0, 0);
    toggleCase(seq->dna, seq->size);
    upperToN(seq->dna, seq->size);
    }
else
    seq = twoBitReadSeqFragLower(tbf, seqName, 0, 0);
return seq;
}

// Assembly:
testl %edx, %edx
je 0xb129
pushq %rbx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x38bcf
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x1dfc1
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x21072
movq %rbx, %rax
popq %rbx
retq
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x38bdb
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: maskSimplePepRepeat
static void maskSimplePepRepeat(struct genoFind *gf)
/* Remove tiles from index that represent repeats
 * of period one and two. */
{
int i;
int tileSize = gf->tileSize;
int maxPat = gf->maxPat;
bits32 *listSizes = gf->listSizes;

for (i=0; i<20; ++i)
    {
    int j, k;
    for (j=0; j<20; ++j)
	{
	int tile = 0;
	for (k=0; k<tileSize; ++k)
	    {
	    tile *= 20;
	    if (k&1)
		tile += j;
	    else
	        tile += i;
	    }
	listSizes[tile] = maxPat;
	}
    }
}

// Assembly:
movl (%rdi), %eax
movl 0xc(%rdi), %ecx
movq 0x38(%rdi), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpl $0x14, %esi
je 0xb53f
xorl %edi, %edi
cmpl $0x14, %edi
je 0xb53b
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl %r8d, %ecx
je 0xb530
imull $0x14, %r9d, %r10d
testb $0x1, %r8b
movl %edi, %r9d
cmovel %esi, %r9d
addl %r10d, %r9d
incl %r8d
jmp 0xb514
movslq %r9d, %r8
movl %eax, (%rdx,%r8,4)
incl %edi
jmp 0xb509
incl %esi
jmp 0xb502
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: transCountBothStrands
static void transCountBothStrands(struct dnaSeq *seq, 
    struct genoFind *transGf[2][3])
/* Count (unmasked) tiles in both strand of sequence. 
 * As a side effect this will reverse-complement seq. */
{
int isRc, frame;
struct trans3 *t3;
for (isRc=0; isRc <= 1; ++isRc)
    {
    if (isRc)
	reverseComplement(seq->dna, seq->size);
    t3 = trans3New(seq);
    for (frame = 0; frame < 3; ++frame)
	{
	struct genoFind *gf = transGf[isRc][frame];
	gfCountSeq(gf, t3->trans[frame]);
	}
    trans3Free(&t3);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
testq %r12, %r12
je 0xb573
cmpq $0x2, %r12
je 0xb5b2
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
callq 0x20d38
movq %r14, %rdi
callq 0x12f80
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0xb5a1
movq (%rbx,%r13,8), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax,%r13,8), %rsi
callq 0xcf26
incq %r13
jmp 0xb583
movq %r15, %rdi
callq 0x12fe3
incq %r12
addq $0x18, %rbx
jmp 0xb55b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: twoBitCheckTotalSize
static long long twoBitCheckTotalSize(struct twoBitFile *tbf)
/* Return total size of sequence in two bit file.  Squawk and
 * die if it's more than 4 gig. */
{
long long totalSize = twoBitTotalSize(tbf);
if (totalSize > maxTotalBases())
    errAbort("Sorry, can only index up to %lld bases, %s has %lld",
	maxTotalBases(),  tbf->fileName, totalSize);
return totalSize;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x38ca5
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
cmpq %rax, %rbx
jl 0xb5fd
movq 0x8(%r14), %rdx
leaq 0x7162f(%rip), %rdi     # 0x7cc18
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rbx, %rcx
xorl %eax, %eax
callq 0x223fb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: transIndexBothStrands
static void transIndexBothStrands(struct dnaSeq *seq, 
    struct genoFind *transGf[2][3], bits32 offset[2][3],
    int sourceIx, char *fileName)
/* Add unmasked tiles on both strands of sequence to
 * index.  As a side effect this will reverse-complement seq. */
{
int isRc, frame;
struct trans3 *t3;
struct gfSeqSource *ss;
for (isRc=0; isRc <= 1; ++isRc)
    {
    if (isRc)
	{
	reverseComplement(seq->dna, seq->size);
	}
    t3 = trans3New(seq);
    for (frame = 0; frame < 3; ++frame)
	{
	struct genoFind *gf = transGf[isRc][frame];
	ss = gf->sources + sourceIx;
	gfAddSeq(gf, t3->trans[frame], offset[isRc][frame]);
	ss->fileName = cloneString(fileName);
	ss->start = offset[isRc][frame];
	offset[isRc][frame] += t3->trans[frame]->size;
	ss->end = offset[isRc][frame];
	}
    trans3Free(&t3);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
movslq %ecx, %rax
xorl %r12d, %r12d
imulq $0x28, %rax, %r13
testq %r12, %r12
je 0xb64d
cmpq $0x2, %r12
je 0xb6d0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x18(%rax), %rsi
callq 0x20d38
movq %r12, 0x10(%rsp)
movq (%rsp), %rdi
callq 0x12f80
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
cmpq $0xc, %r12
je 0xb6b1
movq (%r15,%r12,2), %rdi
movq 0x20(%rdi), %rbp
movq 0x18(%rax,%r12,2), %rsi
movl (%r14,%r12), %edx
callq 0xafea
movq %rbx, %rdi
callq 0x1c306
movq %rax, 0x8(%rbp,%r13)
movl (%r14,%r12), %ecx
movl %ecx, 0x18(%rbp,%r13)
movq 0x8(%rsp), %rax
movq 0x18(%rax,%r12,2), %rdx
addl 0x18(%rdx), %ecx
movl %ecx, (%r14,%r12)
movl %ecx, 0x1c(%rbp,%r13)
addq $0x4, %r12
jmp 0xb663
leaq 0x8(%rsp), %rdi
callq 0x12fe3
movq 0x10(%rsp), %r12
incq %r12
addq $0xc, %r14
addq $0x18, %r15
jmp 0xb62d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfClumpFreeList
void gfClumpFreeList(struct gfClump **pList)
/* Free a list of dynamically allocated gfClump's */
{
struct gfClump *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0xba89
movq (%r15), %r15
movq %r14, %rdi
callq 0xba53
jmp 0xba72
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfClumpDump
void gfClumpDump(struct genoFind *gf, struct gfClump *clump, FILE *f)
/* Print out info on clump */
{
struct gfSeqSource *ss = clump->target;
char *name = ss->fileName;

if (name == NULL) name = ss->seq->name;
fprintf(f, "%u-%u %s %u-%u, hits %d\n", 
	clump->qStart, clump->qEnd, name,
	clump->tStart - ss->start, clump->tEnd - ss->start,
	clump->hitCount);
#ifdef SOMETIMES
for (hit = clump->hitList; hit != NULL; hit = hit->next)
    fprintf(f, "   q %d, t %d, diag %d\n", hit->qStart, hit->tStart, hit->diagonal);
#endif
}

// Assembly:
movq %rdx, %rdi
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r8
testq %r8, %r8
jne 0xbaaf
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %r8
pushq %rax
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
movl 0x18(%rsi), %r9d
movl 0x18(%rax), %eax
subl %eax, %r9d
movl 0x1c(%rsi), %r10d
subl %eax, %r10d
movl 0x20(%rsi), %r11d
leaq 0x70ff2(%rip), %rsi     # 0x7cac4
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x6a90
popq %rcx
popq %rdx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfHitSortDiagonal
void gfHitSortDiagonal(struct gfHit **pList)
/* Sort a singly linked list with Qsort and a temporary array. */
{
    struct gfHit *list = *pList;
    if (list != NULL && list->next != NULL)
    {
        int count = slCount(list);
        struct gfHit *el;
        struct gfHit **array;
        int i;
        int byteSize = count*sizeof(*array);
        /* Some variables used by recursive function gfHitSort2
         * across all incarnations. */
        struct gfHit **nosTemp, *nosSwap;

        array = needLargeMem(byteSize);
        nosTemp = needLargeMem(byteSize);
        for (el = list, i=0; el != NULL; el = el->next, i++)
            array[i] = el;
        gfHitSort2(array, count, &nosTemp, &nosSwap);
        list = NULL;
        for (i=0; i<count; ++i)
        {
            array[i]->next = list;
            list = array[i];
        }
        freez(&array);
        freez(&nosTemp);
        slReverse(&list);
        *pList = list;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %r12
testq %r12, %r12
je 0xbbb2
cmpq $0x0, (%r12)
je 0xbbb2
movq %rdi, %rbx
movq %r12, %rdi
callq 0x1c4aa
movl %eax, %r14d
leal (,%r14,8), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x289b8
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x289b8
movq %rax, (%rsp)
movq %r15, %rax
testq %r12, %r12
je 0xbb4f
movq %r12, (%rax)
movq (%r12), %r12
addq $0x8, %rax
jmp 0xbb3d
movq %rsp, %rdx
leaq 0x18(%rsp), %rcx
movq %r15, %rdi
movl %r14d, %esi
callq 0xbbc0
andq $0x0, 0x8(%rsp)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0xbb8d
movq (%r15,%rcx,8), %rdx
movq %rax, (%rdx)
movq (%r15,%rcx,8), %rax
movq %rax, 0x8(%rsp)
incq %rcx
jmp 0xbb73
leaq 0x10(%rsp), %rdi
callq 0x28c3d
movq %rsp, %rdi
callq 0x28c3d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1c567
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfFindHitsInRegion
struct gfHit *gfFindHitsInRegion(struct genoFind *gf, bioSeq *seq, 
	Bits *qMaskBits, int qMaskOffset, struct lm *lm, 
	struct gfSeqSource *target, int tMin, int tMax)
/* Find hits restricted to one particular region. 
 * The hits returned by this will be in target sequence
 * coordinates rather than concatenated whole genome
 * coordinates as hits inside of clumps usually are.  */
{
int targetStart;
struct gfHit *hitList, *hit;
int hitCount;

targetStart = target->start;
hitList =  gfFindHitsWithQmask(gf, seq, qMaskBits, qMaskOffset, lm,
	&hitCount, target, tMin + targetStart, tMax + targetStart);
for (hit = hitList; hit != NULL; hit = hit->next)
    hit->tStart -= targetStart;
return hitList;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movl 0x18(%r9), %ebx
movl 0x20(%rsp), %r10d
addl %ebx, %r10d
movl 0x28(%rsp), %r11d
addl %ebx, %r11d
subq $0x8, %rsp
leaq 0x14(%rsp), %r9
pushq %r11
pushq %r10
pushq %rax
callq 0xc091
addq $0x20, %rsp
movq %rax, %rcx
testq %rcx, %rcx
je 0xcb67
subl %ebx, 0xc(%rcx)
movq (%rcx), %rcx
jmp 0xcb5a
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfTransFindClumps
void gfTransFindClumps(struct genoFind *gfs[3], aaSeq *seq, struct gfClump *clumps[3], struct lm *lm, int *retHitCount)
/* Find clumps associated with one sequence in three translated reading frames. */
{
int frame;
int oneHit;
int hitCount = 0;
for (frame = 0; frame < 3; ++frame)
    {
    clumps[frame] = gfFindClumps(gfs[frame], seq, lm, &oneHit);
    hitCount += oneHit;
    }
*retHitCount = hitCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq $0x3, %rbx
je 0xcbc7
movq (%r13,%rbx,8), %rdi
movq %r12, %rsi
movq %r14, %rdx
leaq 0xc(%rsp), %rcx
callq 0xcb6d
movq %rax, (%r15,%rbx,8)
addl 0xc(%rsp), %ebp
incq %rbx
jmp 0xcb9f
movq 0x10(%rsp), %rax
movl %ebp, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfTransTransFindClumps
void gfTransTransFindClumps(struct genoFind *gfs[3], aaSeq *seqs[3], 
	struct gfClump *clumps[3][3], struct lm *lm, int *retHitCount)
/* Find clumps associated with three sequences in three translated 
 * reading frames. Used for translated/translated protein comparisons. */
{
int qFrame;
int oneHit;
int hitCount = 0;

for (qFrame = 0; qFrame<3; ++qFrame)
    {
    gfTransFindClumps(gfs, seqs[qFrame], clumps[qFrame], lm, &oneHit);
    hitCount += oneHit;
    }
*retHitCount = hitCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq $0x3, %rbx
je 0xcc2a
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
leaq 0xc(%rsp), %r8
callq 0xcb7c
addl 0xc(%rsp), %ebp
incq %rbx
addq $0x18, %r15
jmp 0xcc00
movq 0x10(%rsp), %rax
movl %ebp, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfCountSeq
static void gfCountSeq(struct genoFind *gf, bioSeq *seq)
/* Add all N-mers in seq. */
{
char *poly = seq->dna;
int tileSize = gf->tileSize;
int stepSize = gf->stepSize;
int tileHeadSize = gf->tileSize - gf->segSize;
int maxPat = gf->maxPat;
int tile;
bits32 *listSizes = gf->listSizes;
int i, lastTile = seq->size - tileSize;
int (*makeTile)(char *poly, int n) = (gf->isPep ? gfPepTile : gfDnaTile);

initNtLookup();
for (i=0; i<=lastTile; i += stepSize)
    {
    if ((tile = makeTile(poly, tileHeadSize)) >= 0)
	{
        if (listSizes[tile] < maxPat)
	    {
	    listSizes[tile] += 1;
	    }
	}
    poly += stepSize;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %ebx
movl 0x18(%rsi), %r15d
subl %ebx, %r15d
subl 0x2c(%rdi), %ebx
movslq 0x10(%rdi), %r12
movq 0x38(%rdi), %r13
cmpb $0x0, 0x28(%rdi)
leaq -0x25af(%rip), %rax     # 0xa9b4
leaq -0x2584(%rip), %rbp     # 0xa9e6
cmoveq %rax, %rbp
callq 0xd4c6
xorl %r14d, %r14d
cmpl %r15d, %r14d
jg 0xcfa5
movq 0x10(%rsp), %rax
leaq (%rax,%r14), %rdi
movl %ebx, %esi
callq *%rbp
testl %eax, %eax
js 0xcfa0
movl %eax, %eax
movl (%r13,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xcfa0
incl %ecx
movl %ecx, (%r13,%rax,4)
addq %r12, %r14
jmp 0xcf76
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: gfFindNamedSource
struct gfSeqSource *gfFindNamedSource(struct genoFind *gf, char *name)
/* Find target of given name.  Return NULL if none. */
{
struct gfSeqSource *source = gf->sources;
int count = gf->sourceCount;

if (source->seq == NULL)	/* Use first source to see if seq or file. */
    {
    char rootName[256];
    while (--count >= 0)
	{
	splitPath(source->fileName, NULL, rootName, NULL);
	if (sameString(name, rootName))
	     return source;
	}
    }
else
    {
    while (--count >= 0)
	{
	if (sameString(source->seq->name, name))
	    return source;
	source += 1;
	}
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq 0x20(%rdi), %rbx
movl 0x1c(%rdi), %ebp
cmpq $0x0, 0x10(%rbx)
je 0xcff2
testl %ebp, %ebp
jle 0xd01e
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
je 0xd020
addq $0x28, %rbx
decl %ebp
jmp 0xcfd2
incl %ebp
movq %rsp, %r15
decl %ebp
testl %ebp, %ebp
jle 0xd01e
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x23b2e
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
jne 0xcff7
jmp 0xd020
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: findSource
static struct gfSeqSource *findSource(struct genoFind *gf, bits32 targetPos)
/* Find source given target position. */
{
struct gfSeqSource *ss =  bsearch(&targetPos, gf->sources, gf->sourceCount, 
	sizeof(gf->sources[0]), bCmpSeqSource);
if (ss == NULL)
    errAbort("Couldn't find source for %d", targetPos);
return ss;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq 0x20(%rdi), %rsi
movslq 0x1c(%rdi), %rdx
leaq 0x2e(%rip), %r8         # 0xd545
pushq $0x28
popq %rcx
movq %rax, %rdi
callq 0x6950
movq %rax, %rbx
testq %rax, %rax
jne 0xd53c
movl 0xc(%rsp), %esi
leaq 0x6f7cd(%rip), %rdi     # 0x7cd02
xorl %eax, %eax
callq 0x223fb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: findClumpBounds
static void findClumpBounds(struct gfClump *clump, int tileSize)
/* Figure out qStart/qEnd tStart/tEnd from hitList */
{
struct gfHit *hit;
int x;
hit = clump->hitList;
if (hit == NULL)
    return;
clump->qStart = clump->qEnd = hit->qStart;
clump->tStart = clump->tEnd = hit->tStart;
for (hit = hit->next; hit != NULL; hit = hit->next)
    {
    x = hit->qStart;
    if (x < clump->qStart) clump->qStart = x;
    if (x > clump->qEnd) clump->qEnd = x;
    x = hit->tStart;
    if (x < clump->tStart) clump->tStart = x;
    if (x > clump->tEnd) clump->tEnd = x;
    }
clump->tEnd += tileSize;
clump->qEnd += tileSize;
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xd5eb
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rax), %edx
movl %edx, 0x18(%rdi)
movl %edx, %r8d
movl %ecx, %r9d
movq (%rax), %rax
testq %rax, %rax
je 0xd5e1
movl 0x8(%rax), %r10d
cmpl %r9d, %r10d
jae 0xd5b7
movl %r10d, 0x8(%rdi)
movl %r10d, %r9d
cmpl %ecx, %r10d
jbe 0xd5c3
movl %r10d, 0xc(%rdi)
movl %r10d, %ecx
movl 0xc(%rax), %r10d
cmpl %r8d, %r10d
jae 0xd5d3
movl %r10d, 0x18(%rdi)
movl %r10d, %r8d
cmpl %edx, %r10d
jbe 0xd59f
movl %r10d, 0x1c(%rdi)
movl %r10d, %edx
jmp 0xd59f
addl %esi, %edx
movl %edx, 0x1c(%rdi)
addl %esi, %ecx
movl %ecx, 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/genoFind.c
// Function: targetClump
static void targetClump(struct genoFind *gf, struct gfClump **pClumpList, struct gfClump *clump)
/* Add target sequence to clump.  If clump had multiple targets split it into
 * multiple clumps, one per target.  Add clump(s) to list. */
{
struct gfSeqSource *ss = findSource(gf, clump->tStart);
if (ss->end >= clump->tEnd)
    {
    /* Usual simple case: all of clump hits single target. */
    clump->target = ss;
    slAddHead(pClumpList, clump);
    }
else
    {
    /* If we've gotten here, then the clump is split across multiple targets.
     * We'll have to split it into multiple clumps... */
    struct gfHit *hit, *nextHit, *inList, *outList, *oldList = clump->hitList;
    int hCount;

    while (oldList != NULL)
        {
	inList = outList = NULL;
	hCount = 0;
	for (hit = oldList; hit != NULL; hit = nextHit)
	    {
	    nextHit = hit->next;
	    if (ss->start <= hit->tStart  && hit->tStart < ss->end)
	        {
		++hCount;
		slAddHead(&inList, hit);
		}
	    else
	        {
		slAddHead(&outList, hit);
		}
	    }
	slReverse(&inList);
	slReverse(&outList);
	if (hCount >= gf->minMatch)
	    {
	    struct gfClump *newClump;
	    AllocVar(newClump);
	    newClump->hitList = inList;
	    newClump->hitCount = hCount;
	    newClump->target = ss;
	    findClumpBounds(newClump, gf->tileSize);
	    slAddHead(pClumpList, newClump);
	    }
	else
	    {
	    inList = NULL;
	    }
	oldList = outList;
	if (oldList != NULL)
	    {
	    ss = findSource(gf, oldList->tStart);
	    }
	}
    clump->hitList = NULL;	/* We ate up the hit list. */
    gfClumpFree(&clump);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movl 0x18(%rdx), %esi
callq 0xd4fc
movq %rax, %r15
movl 0x1c(%rax), %eax
cmpl 0x1c(%r12), %eax
jae 0xd6ec
movq 0x28(%r12), %rbp
leaq 0x8(%rsp), %r13
testq %rbp, %rbp
je 0xd6fd
andq $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
movl 0x18(%r15), %eax
xorl %r12d, %r12d
movq %rbp, %rcx
testq %rbp, %rbp
je 0xd67d
movq (%rcx), %rbp
movl 0xc(%rcx), %edx
cmpl %edx, %eax
ja 0xd65e
cmpl 0x1c(%r15), %edx
jb 0xd66d
movq 0x8(%rsp), %rdx
movq %rdx, (%rcx)
movq %rcx, 0x8(%rsp)
jmp 0xd646
incl %r12d
movq (%rsp), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rsp)
jmp 0xd646
movq %rsp, %rdi
callq 0x1c567
movq %r13, %rdi
callq 0x1c567
cmpl 0x4(%r14), %r12d
jge 0xd69a
andq $0x0, (%rsp)
jmp 0xd6cb
pushq $0x38
popq %rdi
callq 0x28bb0
movq %rax, %rbp
movq (%rsp), %rax
movq %rax, 0x28(%rbp)
movl %r12d, 0x20(%rbp)
movq %r15, 0x10(%rbp)
movl 0xc(%r14), %esi
movq %rbp, %rdi
callq 0xd584
movq (%rbx), %rax
movq %rax, (%rbp)
movq %rbp, (%rbx)
movq 0x8(%rsp), %rbp
testq %rbp, %rbp
je 0xd62b
movl 0xc(%rbp), %esi
movq %r14, %rdi
callq 0xd4fc
movq %rax, %r15
jmp 0xd62b
movq %r15, 0x10(%r12)
movq (%rbx), %rax
movq %rax, (%r12)
movq %r12, (%rbx)
jmp 0xd70f
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, 0x28(%rax)
callq 0xba53
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: gfRangeFree
void gfRangeFree(struct gfRange **pEl)
/* Free a single dynamically allocated gfRange such as created
 * with gfRangeLoad(). */
{
struct gfRange *el;

if ((el = *pEl) == NULL) return;
freeMem(el->tName);
if (el->components != NULL)
    gfRangeFreeList(&el->components);
freez(pEl);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0xd776
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x28c2d
cmpq $0x0, 0x28(%r14)
je 0xd767
addq $0x28, %r14
movq %r14, %rdi
callq 0xd77e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: gfRangeFreeList
void gfRangeFreeList(struct gfRange **pList)
/* Free a list of dynamically allocated gfRange's */
{
struct gfRange *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0xd7a9
movq (%r15), %r15
movq %r14, %rdi
callq 0xd73c
jmp 0xd792
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: gfRangeCmpTarget
int gfRangeCmpTarget(const void *va, const void *vb)
/* Compare to sort based on target position. */
{
const struct gfRange *a = *((struct gfRange **)va);
const struct gfRange *b = *((struct gfRange **)vb);
int diff;

diff = strcmp(a->tName, b->tName);
if (diff == 0)
    {
    long lDiff = a->t3 - b->t3;
    if (lDiff < 0)
       diff = -1;
    else if (lDiff > 0)
       diff = 1;
    else
       diff = 0;
#ifdef SOLARIS_WORKAROUND_COMPILER_BUG_BUT_FAILS_IN_64_BIT
    diff = (unsigned long)(a->t3) - (unsigned long)(b->t3);	/* Casts needed for Solaris.  Thanks Darren Platt! */
#endif /* SOLARIS_WORKAROUND_COMPILER_BUG_BUT_FAILS_IN_64_BIT */
    }
if (diff == 0)
    diff = a->tStart - b->tStart;
return diff;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0xd7ee
movq 0x38(%rbx), %rax
cmpq %rax, 0x38(%r14)
js 0xd7e2
je 0xd7e7
pushq $0x1
jmp 0xd7e4
pushq $-0x1
popq %rax
jmp 0xd7ee
movl 0x20(%r14), %eax
subl 0x20(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq