LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xad1f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0xac53
movq %rdx, (%rcx)
testq %rdx, %rdx
je 0xac5c
movq %rcx, 0x8(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %rbp
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %r13
testq %rcx, %rcx
je 0xace1
movl %r15d, %r8d
subl %r12d, %r8d
movq 0x20(%rcx), %rsi
subq 0x10(%rcx), %rsi
movq 0x8(%rcx), %rdx
leal -0x2(%r8), %r9d
cmpl %esi, %r9d
setg %r9b
leal 0x2(%r8), %r10d
cmpl %esi, %r10d
setl %r10b
orb %r9b, %r10b
je 0xaca9
movl %r8d, %esi
jmp 0xacd6
movq (%rcx), %r8
cmpq %rcx, (%rax)
jne 0xacb4
movq %rdx, (%rax)
testq %rdx, %rdx
je 0xacbc
movq %r8, (%rdx)
testq %r8, %r8
je 0xacc5
movq %rdx, 0x8(%r8)
movups %xmm0, (%rcx)
movq %rdi, (%rcx)
movq 0x18(%rcx), %r13
movq 0x28(%rcx), %rbp
movq %rcx, %rdi
movl %esi, %r8d
movq %rdx, %rcx
testq %rdx, %rdx
jne 0xac7d
callq 0x27f4d
movq %rax, %r14
movq (%rbx), %rdi
movl $0x40, %esi
callq 0x2bfa9
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %r13, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 -0x378(%rip), %rsi      # 0xa9b9
callq 0x1fd04
movq (%rbx), %rax
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0xad6b
movl $0x1, %edx
xorl %esi, %esi
movq %rax, %rcx
movq (%rax), %rax
movq %rsi, (%rcx)
testq %rax, %rax
je 0xad6d
leal 0x1(%rdx), %edi
movq %rcx, %rsi
cmpl %ebp, %edx
movl %edi, %edx
jl 0xad4f
jmp 0xad6d
xorl %ecx, %ecx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x10(%rsp)
movl %r8d, %r12d
movq %rdx, %r13
movq %rdi, %r14
movslq %esi, %r15
leaq (%rdi,%r15), %rbx
movslq %ecx, %rbp
addq %rdx, %rbp
movq %rbx, %rsi
movq %rbp, %rcx
callq 0xad77
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl %r12d, %esi
callq 0x28417
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x250f6
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %r12d, %r8d
callq 0xad77
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movl %r12d, %esi
callq 0x28417
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x250f6
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq %rcx, %rax
orq %rdx, %rax
jne 0xb286
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
jmp 0xb2d7
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rsi
movl 0xc(%rsp), %r8d
cmpl %r12d, %r8d
jle 0xb2b7
movq %rcx, (%rdi)
movl $0x0, (%rsi)
testq %rax, %rax
je 0xb2b0
movl %r8d, (%rax)
leaq 0x18(%rsp), %rdi
jmp 0xb2cd
movq %rdx, (%rdi)
movl $0x1, (%rsi)
testq %rax, %rax
je 0xb2c8
movl %r12d, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x27ea8
movl $0x1, %eax
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/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
testq %rdx, %rdx
je 0xc6c3
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r12d, %r12d
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl %ebp, %edi
callq 0x6aa0
movq %rax, %r15
testl %r15d, %r15d
js 0xc6d2
je 0xc6be
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %r15, %r12
cmpq %rbx, %r12
jb 0xc694
movl %r12d, %r15d
jmp 0xc6c6
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x812a7(%rip), %rdi     # 0x8d980
callq 0x6590
jmp 0xc6c6
// File: /workspace/github_c_makefile_star2_O1/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 0xc75d
movq %rdi, %rbx
movq 0x48(%r12), %rdi
callq 0x2dd41
movq 0x38(%r12), %rdi
callq 0x2dd41
movq 0x40(%r12), %rdi
callq 0x2dd41
movq 0x20(%r12), %r14
testq %r14, %r14
je 0xc74c
cmpl $0x0, 0x1c(%r12)
jle 0xc744
leaq 0x20(%r14), %r15
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x1b79b
incq %r13
movslq 0x1c(%r12), %rax
addq $0x28, %r15
cmpq %rax, %r13
jl 0xc72b
movq %r14, %rdi
callq 0x2dd41
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dd51
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x14, %eax
cmpl $0x2, %edi
jl 0xc785
incl %edi
movl $0x14, %eax
shll $0x2, %eax
leal (%rax,%rax,4), %eax
decl %edi
cmpl $0x2, %edi
jg 0xc778
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0xc7de
movl %esi, %ecx
xorl %edx, %edx
leaq 0xb31cf(%rip), %rsi     # 0xbf990
xorl %eax, %eax
movsbq (%rdi,%rdx), %r8
movl (%rsi,%r8,4), %r8d
testl %r8d, %r8d
js 0xc7e1
leal (%r8,%rax,4), %eax
incq %rdx
cmpq %rdx, %rcx
jne 0xc7c3
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0xc813
incl %esi
xorl %eax, %eax
leaq 0xb699a(%rip), %rcx     # 0xc3190
movsbq (%rdi), %rdx
movl (%rcx,%rdx,4), %edx
cmpl $0x13, %edx
ja 0xc816
incq %rdi
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,4), %eax
decl %esi
cmpl $0x1, %esi
jg 0xc7f6
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl (%rdi), %ebp
movslq 0x14(%rdi), %r15
testq %r15, %r15
jle 0xce84
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movl (%r14,%rdx,4), %esi
cmpl %ebp, %esi
cmovael %ecx, %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %r15
jne 0xce6f
jmp 0xce86
xorl %eax, %eax
movq 0x48(%rbx), %r12
testl %eax, %eax
jle 0xce9f
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2dbbc
movq %rax, 0x40(%rbx)
jmp 0xcea1
xorl %eax, %eax
testl %r15d, %r15d
jle 0xcec0
xorl %ecx, %ecx
movslq (%r14,%rcx,4), %rdx
cmpl %ebp, %edx
jae 0xceb8
movq %rax, (%r12,%rcx,8)
leaq (%rax,%rdx,4), %rax
incq %rcx
cmpq %rcx, %r15
jne 0xcea8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, 0x20(%rsp)
movq 0x10(%rsi), %r14
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %ebp
movslq 0x10(%rdi), %r12
movl 0x18(%rsi), %r13d
subl %ebp, %r13d
cmpb $0x0, 0x28(%rdi)
leaq -0x74d(%rip), %rax      # 0xc7b2
leaq -0x71f(%rip), %rbx      # 0xc7e7
cmoveq %rax, %rbx
movq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0xb4079(%rip)     # 0xc0f9c
jne 0xcf54
movl $0x2, 0xb2be5(%rip)     # 0xbfb14
movl $0x1, 0xb2be3(%rip)     # 0xbfb1c
movl $0x0, 0xb2c1d(%rip)     # 0xbfb60
movl $0x3, 0xb2bdf(%rip)     # 0xbfb2c
movb $0x1, 0xb4048(%rip)     # 0xc0f9c
testl %r13d, %r13d
js 0xcfa2
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq *%rbx
testl %eax, %eax
js 0xcf97
movl %eax, %eax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xcf97
movq 0x20(%rsp), %rdx
addl %r15d, %edx
movq 0x18(%rsp), %rsi
movq (%rsi,%rax,8), %rsi
leal 0x1(%rcx), %edi
movq 0x10(%rsp), %r8
movl %edi, (%r8,%rax,4)
movl %edx, (%rsi,%rcx,4)
addq %r12, %r14
addl %r12d, %r15d
cmpl %r13d, %r15d
jle 0xcf5c
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/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 0xcfe6
pushq %rbx
movl $0x1, %edi
movq %rax, %rsi
callq 0x31e3f
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x21c9f
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x255de
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
jmp 0x31eda
// File: /workspace/github_c_makefile_star2_O1/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 0xd01c
pushq %rbx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3e899
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x21c9f
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x255de
movq %rbx, %rax
popq %rbx
retq
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3e8a7
// File: /workspace/github_c_makefile_star2_O1/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
xorl %edi, %edi
xorl %r8d, %r8d
testl %ecx, %ecx
jle 0xd4eb
xorl %r9d, %r9d
testb $0x1, %r9b
movl %edi, %r10d
cmovel %esi, %r10d
leal (%r8,%r8,4), %r8d
leal (%r10,%r8,4), %r8d
incl %r9d
cmpl %r9d, %ecx
jne 0xd4cd
movslq %r8d, %r8
movl %eax, (%rdx,%r8,4)
incl %edi
cmpl $0x14, %edi
jne 0xd4c3
incl %esi
cmpl $0x14, %esi
jne 0xd4c1
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd52b
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
callq 0x250f6
movq %r14, %rdi
callq 0x15d78
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax,%r13,8), %rsi
callq 0xf1ba
incq %r13
cmpq $0x3, %r13
jne 0xd53b
movq %r15, %rdi
callq 0x15ddb
leaq 0x1(%r12), %rax
addq $0x18, %rbx
testq %r12, %r12
movq %rax, %r12
je 0xd519
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e973
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
cmpq %rax, %rbx
jl 0xd5bb
movq 0x8(%r14), %rdx
leaq 0x80691(%rip), %rdi     # 0x8dc38
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movslq %ecx, %rax
xorl %ecx, %ecx
leaq (%rax,%rax,4), %rbp
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
je 0xd607
movq 0x10(%r12), %rdi
movslq 0x18(%r12), %rsi
callq 0x250f6
movq %r12, %rdi
callq 0x15d78
movq %rax, (%rsp)
xorl %r12d, %r12d
movq (%r15,%r12,2), %rdi
movq 0x20(%rdi), %r13
movq (%rsp), %rax
movq 0x18(%rax,%r12,2), %rsi
movl (%r14,%r12), %edx
callq 0xcec9
movq %rbx, %rdi
callq 0x1f9f6
movq %rax, 0x8(%r13,%rbp,8)
movl (%r14,%r12), %eax
movl %eax, 0x18(%r13,%rbp,8)
movq (%rsp), %rax
movq 0x18(%rax,%r12,2), %rax
movl (%r14,%r12), %ecx
addl 0x18(%rax), %ecx
movl %ecx, (%r14,%r12)
movl %ecx, 0x1c(%r13,%rbp,8)
addq $0x4, %r12
cmpq $0xc, %r12
jne 0xd616
movq %rsp, %rdi
callq 0x15ddb
movq 0x10(%rsp), %rcx
leaq 0x1(%rcx), %rax
addq $0xc, %r14
addq $0x18, %r15
testq %rcx, %rcx
movq %rax, %rcx
movq 0x8(%rsp), %r12
je 0xd5ee
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/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
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0xdb52
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2dd51
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xdb3d
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb7b
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 0x7ff46(%rip), %rsi     # 0x8dae4
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x6a90
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0xdc95
cmpq $0x0, (%rdi)
je 0xdc95
callq 0x1fbec
movl %eax, %r14d
leal (,%r14,8), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x2da9d
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x2da9d
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xdc22
xorl %ecx, %ecx
movq (%rsp), %rdx
movq %rax, (%rdx,%rcx)
movq (%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0xdc0e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movl %r14d, %esi
callq 0xdc9f
movq $0x0, 0x8(%rsp)
testl %r14d, %r14d
jle 0xdc70
movl %r14d, %eax
xorl %ecx, %ecx
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq (%rsi,%rcx,8), %rsi
movq %rdx, (%rsi)
movq (%rsp), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, 0x8(%rsp)
incq %rcx
cmpq %rcx, %rax
jne 0xdc4b
movq %rsp, %rdi
callq 0x2dd51
leaq 0x10(%rsp), %rdi
callq 0x2dd51
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1fcb3
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe1c3
addq $0x20, %rsp
testq %rax, %rax
je 0xedab
movq %rax, %rcx
subl %ebx, 0xc(%rcx)
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0xeda0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq (%r13,%rbx,8), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
leaq 0xc(%rsp), %r9
callq 0xde09
movq %rax, (%r15,%rbx,8)
addl 0xc(%rsp), %ebp
incq %rbx
cmpq $0x3, %rbx
jne 0xede3
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_O1/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 $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %ecx, %ecx
leaq 0x4(%rsp), %r14
xorl %esi, %esi
movl %esi, (%rsp)
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
movq (%r15,%rbp,8), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r8
movq %r14, %r9
callq 0xde09
movq %rax, (%rbx,%rbp,8)
addl 0x4(%rsp), %r12d
incq %rbp
cmpq $0x3, %rbp
jne 0xee68
movl (%rsp), %esi
addl %r12d, %esi
movq 0x18(%rsp), %rcx
incq %rcx
addq $0x18, %rbx
cmpq $0x3, %rcx
jne 0xee4d
movq 0x8(%rsp), %rax
movl %esi, (%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/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), %rbx
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %ebp
movslq 0x10(%rdi), %r15
movl 0x18(%rsi), %r12d
subl %ebp, %r12d
movq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
subl 0x2c(%rdi), %ebp
cmpb $0x0, 0x28(%rdi)
leaq -0x2a45(%rip), %rax     # 0xc7b2
leaq -0x2a17(%rip), %r14     # 0xc7e7
cmoveq %rax, %r14
cmpb $0x0, 0xb1d93(%rip)     # 0xc0f9c
jne 0xf23a
movl $0x2, 0xb08ff(%rip)     # 0xbfb14
movl $0x1, 0xb08fd(%rip)     # 0xbfb1c
movl $0x0, 0xb0937(%rip)     # 0xbfb60
movl $0x3, 0xb08f9(%rip)     # 0xbfb2c
movb $0x1, 0xb1d62(%rip)     # 0xc0f9c
testl %r12d, %r12d
js 0xf273
xorl %r13d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
callq *%r14
testl %eax, %eax
js 0xf268
movl %eax, %eax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xf268
incl %ecx
movq 0x10(%rsp), %rdx
movl %ecx, (%rdx,%rax,4)
addq %r15, %rbx
addl %r15d, %r13d
cmpl %r12d, %r13d
jle 0xf242
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/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 0xf2c9
testl %ebp, %ebp
jle 0xf2c5
incl %ebp
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
je 0xf2f3
addq $0x28, %rbx
decl %ebp
cmpl $0x1, %ebp
jg 0xf2a6
xorl %ebx, %ebx
jmp 0xf2f3
incl %ebp
movq %rsp, %r15
decl %ebp
testl %ebp, %ebp
jle 0xf2c5
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2852a
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
jne 0xf2ce
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30(%rip), %r8         # 0xf871
movl $0x28, %ecx
movq %rax, %rdi
callq 0x6950
movq %rax, %rbx
testq %rax, %rax
jne 0xf868
movl 0xc(%rsp), %esi
leaq 0x7e4c1(%rip), %rdi     # 0x8dd22
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf92a
movl 0x8(%rax), %ecx
movl %ecx, 0xc(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rax), %ecx
movl %ecx, 0x1c(%rdi)
movl %ecx, 0x18(%rdi)
movq (%rax), %rax
testq %rax, %rax
je 0xf924
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
movl 0x18(%rdi), %r8d
movl 0x1c(%rdi), %r9d
movl 0x8(%rax), %r10d
cmpl %ecx, %r10d
jae 0xf8f4
movl %r10d, 0x8(%rdi)
movl %r10d, %ecx
cmpl %edx, %r10d
jbe 0xf900
movl %r10d, 0xc(%rdi)
movl %r10d, %edx
movl 0xc(%rax), %r10d
cmpl %r8d, %r10d
jae 0xf910
movl %r10d, 0x18(%rdi)
movl %r10d, %r8d
cmpl %r9d, %r10d
jbe 0xf91c
movl %r10d, 0x1c(%rdi)
movl %r10d, %r9d
movq (%rax), %rax
testq %rax, %rax
jne 0xf8e4
addl %esi, 0x1c(%rdi)
addl %esi, 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movl 0x18(%rdx), %esi
callq 0xf826
movq %rax, %r15
movl 0x1c(%rax), %ecx
movq 0x10(%rsp), %rax
cmpl 0x1c(%rax), %ecx
jae 0xfa4c
movq 0x28(%rax), %rbp
testq %rbp, %rbp
je 0xfa2e
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
movq %r12, 0x8(%rsp)
movq %r12, (%rsp)
movl 0x18(%r15), %eax
movq (%rbp), %rcx
movl 0xc(%rbp), %edx
cmpl %edx, %eax
ja 0xf9a4
cmpl 0x1c(%r15), %edx
jae 0xf9a4
incl %r12d
movq (%rsp), %rdx
movq %rdx, (%rbp)
movq %rbp, (%rsp)
jmp 0xf9b2
movq 0x8(%rsp), %rdx
movq %rdx, (%rbp)
movq %rbp, 0x8(%rsp)
movq %rcx, %rbp
testq %rcx, %rcx
jne 0xf982
movq %rsp, %rdi
callq 0x1fcb3
movq %r13, %rdi
callq 0x1fcb3
cmpl 0x4(%r14), %r12d
jge 0xf9da
movq $0x0, (%rsp)
jmp 0xfa0d
movl $0x38, %edi
callq 0x2dc95
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 0xf8b3
movq (%rbx), %rax
movq %rax, (%rbp)
movq %rbp, (%rbx)
movq 0x8(%rsp), %rbp
testq %rbp, %rbp
je 0xfa25
movl 0xc(%rbp), %esi
movq %r14, %rdi
callq 0xf826
movq %rax, %r15
testq %rbp, %rbp
jne 0xf972
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
testq %rax, %rax
je 0xfa59
leaq 0x10(%rsp), %rdi
callq 0x2dd51
jmp 0xfa59
movq %r15, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
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/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0xfad8
movq %rdi, %rbx
movq 0x10(%r15), %rdi
callq 0x2dd41
movq 0x28(%r15), %r12
testq %r12, %r12
je 0xfad0
movq %rsp, %r14
movq %r12, (%r14)
movq (%r12), %r12
movq %r14, %rdi
callq 0xfa88
movq %r12, (%rsp)
testq %r12, %r12
jne 0xfab3
movq $0x0, 0x28(%r15)
movq %rbx, %rdi
callq 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0xfb17
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0xfa88
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xfb02
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfb58
movq 0x38(%r14), %rax
xorl %ecx, %ecx
cmpq 0x38(%rbx), %rax
setne %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %ecx, %eax
testl %eax, %eax
jne 0xfb63
movl 0x20(%r14), %eax
subl 0x20(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: getHitsFromServer
struct gfHit *getHitsFromServer(int conn, struct lm *lm)
/* Read a lone line of hits from server. */
{
char *s, *line, *q, *t;
struct gfHit *hitList = NULL, *hit;
s = line = netRecieveLongString(conn);
for (;;)
    {
    if ((q = nextWord(&line)) == NULL)
	 break;
    if ((t = nextWord(&line)) == NULL)
	 internalErr();
    lmAllocVar(lm, hit);
    hit->qStart = sqlUnsigned(q);
    hit->tStart = sqlUnsigned(t);
    slAddHead(&hitList, hit);
    }
freez(&s);
slReverse(&hitList);
return hitList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq $0x0, (%rsp)
callq 0x30eb7
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rax, 0x10(%rsp)
callq 0x229cd
testq %rax, %rax
je 0xfc18
movq %rax, %r13
leaq 0x8(%rsp), %r14
leaq 0x7e209(%rip), %r12     # 0x8ddb8
movq %r14, %rdi
callq 0x229cd
movq %rax, %rbp
testq %rax, %rax
jne 0xfbd5
leaq 0x7dff5(%rip), %rdi     # 0x8dbbb
movq %r12, %rsi
movl $0xc7, %edx
xorl %eax, %eax
callq 0x26b6f
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2bfa9
movq %rax, %r15
movq %r13, %rdi
callq 0x3b838
movl %eax, 0x8(%r15)
movq %rbp, %rdi
callq 0x3b838
movl %eax, 0xc(%r15)
movq (%rsp), %rax
movq %rax, (%r15)
movq %r15, (%rsp)
movq %r14, %rdi
callq 0x229cd
movq %rax, %r13
testq %rax, %rax
jne 0xfbaf
leaq 0x10(%rsp), %rdi
callq 0x2dd51
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
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/gfBlatLib.c
// Function: gfRangesBundle
struct gfRange *gfRangesBundle(struct gfRange *exonList, int maxIntron)
/* Bundle a bunch of 'exons' into plausable 'genes'.  It's
 * not necessary to be precise here.  The main thing is to
 * group together exons that are close to each other in the
 * same target sequence. */
{
struct gfRange *geneList = NULL, *gene = NULL, *lastExon = NULL, *exon, *nextExon;

for (exon = exonList; exon != NULL; exon = nextExon)
    {
    nextExon = exon->next;
    if (lastExon == NULL || !sameString(lastExon->tName, exon->tName) 
	|| exon->t3  != lastExon->t3
        || exon->tStart - lastExon->tEnd > maxIntron)
	{
	AllocVar(gene);
	gene->tStart = exon->tStart;
	gene->tEnd = exon->tEnd;
	gene->tName = cloneString(exon->tName);
	gene->tSeq = exon->tSeq;
	gene->qStart = exon->qStart;
	gene->qEnd = exon->qEnd;
	gene->hitCount = exon->hitCount;
	gene->t3 = exon->t3;
	slAddHead(&gene->components, exon);
	slAddHead(&geneList, gene);
	}
    else
        {
	if (exon->qStart < gene->qStart) gene->qStart = exon->qStart;
	if (exon->qEnd > gene->qEnd) gene->qEnd = exon->qEnd;
	if (exon->tStart < gene->tStart) gene->tStart = exon->tStart;
	if (exon->tEnd > gene->tEnd) gene->tEnd = exon->tEnd;
	gene->hitCount += exon->hitCount;
	slAddTail(&gene->components, exon);
	}
    lastExon = exon;
    }
slReverse(&geneList);
return geneList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0xfd73
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %r14, %r12
movq (%r14), %r14
testq %r13, %r13
je 0xfca4
movq 0x10(%r13), %rdi
movq 0x10(%r12), %rsi
callq 0x6a50
testl %eax, %eax
jne 0xfca4
movq 0x38(%r12), %rax
cmpq 0x38(%r13), %rax
jne 0xfca4
movl 0x20(%r12), %eax
movl %eax, %ecx
subl 0x24(%r13), %ecx
cmpl %ebx, %ecx
jle 0xfd25
movl $0x48, %edi
callq 0x2dc95
movq %rax, %r15
movl 0x20(%r12), %eax
movl %eax, 0x20(%r15)
movl 0x24(%r12), %eax
movl %eax, 0x24(%r15)
movq 0x10(%r12), %rdi
callq 0x1f9f6
movq %rax, 0x10(%r15)
movq 0x18(%r12), %rax
movq %rax, 0x18(%r15)
movl 0x8(%r12), %eax
movl %eax, 0x8(%r15)
movl 0xc(%r12), %eax
movl %eax, 0xc(%r15)
movl 0x30(%r12), %eax
movl %eax, 0x30(%r15)
movq 0x38(%r12), %rax
movq %rax, 0x38(%r15)
movq 0x28(%r15), %rax
movq %rax, (%r12)
movq %r12, 0x28(%r15)
movq 0x8(%rsp), %rax
movq %rax, (%r15)
movq %r15, 0x8(%rsp)
movq %r12, %r13
testq %r14, %r14
jne 0xfc69
jmp 0xfd73
movl 0x8(%r12), %ecx
cmpl 0x8(%r15), %ecx
jge 0xfd34
movl %ecx, 0x8(%r15)
movl 0xc(%r12), %ecx
cmpl 0xc(%r15), %ecx
jle 0xfd43
movl %ecx, 0xc(%r15)
cmpl 0x20(%r15), %eax
jge 0xfd4d
movl %eax, 0x20(%r15)
movl 0x24(%r12), %eax
cmpl 0x24(%r15), %eax
jle 0xfd5c
movl %eax, 0x24(%r15)
movl 0x30(%r12), %eax
addl %eax, 0x30(%r15)
leaq 0x28(%r15), %rdi
movq %r12, %rsi
callq 0x1fc45
jmp 0xfd17
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: gfFileCacheFree
void gfFileCacheFree(struct hash **pCache)
/* Free up resources in cache. */
{
struct hash *cache = *pCache;
if (cache != NULL)
    {
    hashTraverseEls(cache, gfFileCacheFreeEl);
    hashFree(pCache);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfdbe
leaq 0x10(%rip), %rsi        # 0xfdc0
callq 0x292ea
movq %rbx, %rdi
popq %rbx
jmp 0x29565
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: gfFileCacheFreeEl
static void gfFileCacheFreeEl(struct hashEl *el)
/* Free up one file cache info. */
{
char *name = el->name;
if (nibIsFile(name))
    {
    struct nibInfo *nib = el->val;
    nibInfoFree(&nib);
    }
else
    {
    struct twoBitFile *tbf = el->val;
    twoBitClose(&tbf);
    }
el->val = NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3221b
testl %eax, %eax
je 0xfde8
movq 0x10(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3233c
jmp 0xfdf9
movq 0x10(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3df96
movq $0x0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: getTargetName
static void getTargetName(char *tSpec, boolean includeFile, char *targetName)
/* Put sequence name, optionally prefixed by file: in targetName. */
{
if (includeFile)
    {
    char seqName[128];
    char fileName[PATH_LEN];
    gfiGetSeqName(tSpec, seqName, fileName);
    safef(targetName, PATH_LEN, "%s:%s", fileName, seqName);
    }
else
    gfiGetSeqName(tSpec, targetName, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
movq %rdx, %rbx
testl %esi, %esi
je 0x10122
movq %rsp, %r14
leaq 0x80(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x1343f
leaq 0x828c9(%rip), %rdx     # 0x929c9
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x23c18
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rsi
xorl %edx, %edx
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r14
popq %r15
jmp 0x1343f