LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xc5af
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 0xc5be
je 0xc5aa
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %r15, %r12
cmpq %rbx, %r12
jb 0xc580
movl %r12d, %r15d
jmp 0xc5b2
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8140b(%rip), %rdi     # 0x8d9d0
callq 0x6590
jmp 0xc5b2
// File: /workspace/github_c_makefile_star2_O3/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 0xc649
movq %rdi, %rbx
movq 0x48(%r12), %rdi
callq 0x2e0a0
movq 0x38(%r12), %rdi
callq 0x2e0a0
movq 0x40(%r12), %rdi
callq 0x2e0a0
movq 0x20(%r12), %r14
testq %r14, %r14
je 0xc638
cmpl $0x0, 0x1c(%r12)
jle 0xc630
leaq 0x20(%r14), %r15
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x1bafc
incq %r13
movslq 0x1c(%r12), %rax
addq $0x28, %r15
cmpq %rax, %r13
jl 0xc617
movq %r14, %rdi
callq 0x2e0a0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2e0b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc708
leal 0x2(%rdi), %eax
andl $-0x4, %eax
addl $-0x2, %edi
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa 0x81305(%rip), %xmm1    # 0x8d980
movl $0x4, %ecx
movdqa 0x81308(%rip), %xmm3    # 0x8d990
movdqa %xmm1, %xmm2
pmuludq %xmm3, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pshufd $0xf5, %xmm2, %xmm4     # xmm4 = xmm2[1,1,3,3]
pmuludq %xmm3, %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movl %ecx, %edx
addl $-0x4, %ecx
addl %eax, %edx
addl $-0x4, %edx
cmpl $0x4, %edx
jne 0xc688
negl %ecx
movd %ecx, %xmm3
pshufd $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
por 0x812d7(%rip), %xmm3    # 0x8d9a0
movdqa 0x812df(%rip), %xmm4    # 0x8d9b0
pxor %xmm4, %xmm0
pxor %xmm4, %xmm3
pcmpgtd %xmm0, %xmm3
pand %xmm3, %xmm2
pandn %xmm1, %xmm3
por %xmm2, %xmm3
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
pshufd $0xff, %xmm3, %xmm1     # xmm1 = xmm3[3,3,3,3]
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
pmuludq %xmm1, %xmm2
pmuludq %xmm3, %xmm0
pmuludq %xmm2, %xmm0
movd %xmm0, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc761
movl %esi, %ecx
xorl %edx, %edx
leaq 0xb324c(%rip), %rsi     # 0xbf990
xorl %eax, %eax
movsbq (%rdi,%rdx), %r8
movl (%rsi,%r8,4), %r8d
testl %r8d, %r8d
js 0xc764
leal (%r8,%rax,4), %eax
incq %rdx
cmpq %rdx, %rcx
jne 0xc746
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc796
incl %esi
xorl %eax, %eax
leaq 0xb6a17(%rip), %rcx     # 0xc3190
movsbq (%rdi), %rdx
movl (%rcx,%rdx,4), %edx
cmpl $0x13, %edx
ja 0xc799
incq %rdi
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,4), %eax
decl %esi
cmpl $0x1, %esi
jg 0xc779
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0x14(%rdi), %r14
testq %r14, %r14
jle 0xcf30
movq %rdi, %rbx
movq 0x38(%rdi), %r15
movq 0x48(%rdi), %r12
movl (%rdi), %ebp
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movl (%r15,%rdx,4), %esi
cmpl %ebp, %esi
cmovael %ecx, %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %r14
jne 0xcee7
testl %eax, %eax
jle 0xcf0f
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2df1b
movq %rax, 0x40(%rbx)
jmp 0xcf11
xorl %eax, %eax
testl %r14d, %r14d
jle 0xcf30
xorl %ecx, %ecx
movslq (%r15,%rcx,4), %rdx
cmpl %ebp, %edx
jae 0xcf28
movq %rax, (%r12,%rcx,8)
leaq (%rax,%rdx,4), %rax
incq %rcx
cmpq %rcx, %r14
jne 0xcf18
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rcx, 0x20(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %r15d
movslq 0x10(%rdi), %r13
subl %r15d, %ebp
cmpb $0x0, 0x28(%rdi)
leaq -0x838(%rip), %rax      # 0xc735
leaq -0x80a(%rip), %rbx      # 0xc76a
cmoveq %rax, %rbx
movq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0xb400b(%rip)     # 0xc0f9c
jne 0xcfc2
movl $0x2, 0xb2b77(%rip)     # 0xbfb14
movl $0x1, 0xb2b75(%rip)     # 0xbfb1c
movl $0x0, 0xb2baf(%rip)     # 0xbfb60
movl $0x3, 0xb2b71(%rip)     # 0xbfb2c
movb $0x1, 0xb3fda(%rip)     # 0xc0f9c
testl %ebp, %ebp
js 0xd010
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq *%rbx
testl %eax, %eax
js 0xd005
movl %eax, %eax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xd005
movq 0x20(%rsp), %rdx
addl %r12d, %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 %r13, %r14
addl %r13d, %r12d
cmpl %ebp, %r12d
jle 0xcfc9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/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 0xd054
pushq %rbx
movl $0x1, %edi
movq %rax, %rsi
callq 0x32118
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x21ffe
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x258eb
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
jmp 0x321b6
// File: /workspace/github_c_makefile_star2_O3/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 0xd08a
pushq %rbx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3ebfd
movq %rax, %rbx
movq 0x10(%rax), %rdi
movl 0x18(%rax), %esi
callq 0x21ffe
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x258eb
movq %rbx, %rax
popq %rbx
retq
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3ec0b
// File: /workspace/github_c_makefile_star2_O3/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 0xd579
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 0xd55b
movslq %r8d, %r8
movl %eax, (%rdx,%r8,4)
incl %edi
cmpl $0x14, %edi
jne 0xd551
incl %esi
cmpl $0x14, %esi
jne 0xd54f
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %bpl
xorl %r12d, %r12d
movq %rsp, %r15
testb $0x1, %bpl
jne 0xd5b9
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
callq 0x25423
movq %r14, %rdi
callq 0x15dc0
movq %rax, (%rsp)
leaq (%r12,%r12,2), %rax
leaq (%rbx,%rax,8), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
movq (%rsp), %rax
movq 0x18(%rax,%r13,8), %rax
movq 0x10(%rax), %rsi
movl 0x18(%rax), %edx
callq 0xf2da
incq %r13
cmpq $0x3, %r13
jne 0xd5d0
movq %r15, %rdi
callq 0x15e23
movl $0x1, %r12d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0xd5a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/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 0x3ecd7
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
cmpq %rax, %rbx
jl 0xd657
movq 0x8(%r14), %rdx
leaq 0x80645(%rip), %rdi     # 0x8dc88
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movq %r8, %rbx
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movslq %ecx, %rax
movb $0x1, %cl
xorl %r14d, %r14d
leaq (%rax,%rax,4), %r13
movl %ecx, 0x4(%rsp)
testb $0x1, %cl
jne 0xd6a9
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x18(%rax), %rsi
callq 0x25423
movq 0x8(%rsp), %rdi
callq 0x15dc0
movq %rax, 0x10(%rsp)
leaq (%r14,%r14,2), %rcx
movq 0x20(%rsp), %rdx
leaq (%rdx,%rcx,4), %r14
movq 0x18(%rsp), %rdx
leaq (%rdx,%rcx,8), %r15
xorl %r12d, %r12d
movq (%r15,%r12,2), %rdi
movq 0x20(%rdi), %rbp
movq 0x18(%rax,%r12,2), %rax
movl (%r14,%r12), %ecx
movq 0x10(%rax), %rsi
movl 0x18(%rax), %edx
callq 0xcf39
movq %rbx, %rdi
callq 0x1feba
movq %rax, 0x8(%rbp,%r13,8)
movl (%r14,%r12), %ecx
movl %ecx, 0x18(%rbp,%r13,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax,%r12,2), %rdx
addl 0x18(%rdx), %ecx
movl %ecx, (%r14,%r12)
movl %ecx, 0x1c(%rbp,%r13,8)
addq $0x4, %r12
cmpq $0xc, %r12
jne 0xd6d1
leaq 0x10(%rsp), %rdi
callq 0x15e23
movl $0x1, %r14d
testb $0x1, 0x4(%rsp)
movl $0x0, %ecx
jne 0xd68e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/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 0xdc17
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2e0b0
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xdc02
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdc40
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 0x7fed1(%rip), %rsi     # 0x8db34
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x6a90
addq $0x10, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdd45
cmpq $0x0, (%r12)
je 0xdd45
movq %rdi, %rbx
movq %r12, %rdi
callq 0x200ac
movl %eax, %r15d
leal (,%r15,8), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x2ddfc
movq %rax, %r14
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x2ddfc
movq %rax, (%rsp)
movq %r14, %rax
movq %r12, (%rax)
movq (%r12), %r12
addq $0x8, %rax
testq %r12, %r12
jne 0xdcd0
movq %rsp, %rdx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %esi
callq 0xdd53
movq $0x0, 0x8(%rsp)
testl %r15d, %r15d
jle 0xdd20
movl %r15d, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movq %rcx, (%rsi)
movq (%r14,%rdx,8), %rcx
movq %rcx, 0x8(%rsp)
incq %rdx
cmpq %rdx, %rax
jne 0xdd08
leaq 0x10(%rsp), %rdi
callq 0x2e0b0
movq %rsp, %rdi
callq 0x2e0b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x20173
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_O3/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 0xe287
addq $0x20, %rsp
testq %rax, %rax
je 0xeeb2
movq %rax, %rcx
subl %ebx, 0xc(%rcx)
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0xeea7
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdedb
movq %rax, (%r15,%rbx,8)
addl 0xc(%rsp), %ebp
incq %rbx
cmpq $0x3, %rbx
jne 0xeeea
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_O3/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 0xdedb
movq %rax, (%rbx,%rbp,8)
addl 0x4(%rsp), %r12d
incq %rbp
cmpq $0x3, %rbp
jne 0xef6f
movl (%rsp), %esi
addl %r12d, %esi
movq 0x18(%rsp), %rcx
incq %rcx
addq $0x18, %rbx
cmpq $0x3, %rcx
jne 0xef54
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_O3/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
movl %edx, %ebx
movq %rsi, %r14
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rdi), %ebp
movslq 0x10(%rdi), %r12
subl %ebp, %ebx
movq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
subl 0x2c(%rdi), %ebp
cmpb $0x0, 0x28(%rdi)
leaq -0x2bde(%rip), %rax     # 0xc735
leaq -0x2bb0(%rip), %r15     # 0xc76a
cmoveq %rax, %r15
cmpb $0x0, 0xb1c77(%rip)     # 0xc0f9c
jne 0xf356
movl $0x2, 0xb07e3(%rip)     # 0xbfb14
movl $0x1, 0xb07e1(%rip)     # 0xbfb1c
movl $0x0, 0xb081b(%rip)     # 0xbfb60
movl $0x3, 0xb07dd(%rip)     # 0xbfb2c
movb $0x1, 0xb1c46(%rip)     # 0xc0f9c
testl %ebx, %ebx
js 0xf38e
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %esi
callq *%r15
testl %eax, %eax
js 0xf383
movl %eax, %eax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
cmpl 0xc(%rsp), %ecx
jae 0xf383
incl %ecx
movq 0x10(%rsp), %rdx
movl %ecx, (%rdx,%rax,4)
addq %r12, %r14
addl %r12d, %r13d
cmpl %ebx, %r13d
jle 0xf35d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/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 0xf3e4
testl %ebp, %ebp
jle 0xf3e0
incl %ebp
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
je 0xf40e
addq $0x28, %rbx
decl %ebp
cmpl $0x1, %ebp
jg 0xf3c1
xorl %ebx, %ebx
jmp 0xf40e
incl %ebp
movq %rsp, %r15
decl %ebp
testl %ebp, %ebp
jle 0xf3e0
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x288ae
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
jne 0xf3e9
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %edx, (%rax)
movslq %edi, %rdx
leaq 0x30(%rip), %r8         # 0xf9a7
movl $0x28, %ecx
movq %rax, %rdi
callq 0x6950
movq %rax, %rbx
testq %rax, %rax
jne 0xf99e
movl 0xc(%rsp), %esi
leaq 0x7e3db(%rip), %rdi     # 0x8dd72
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rdx
testq %rdx, %rdx
je 0xfa4c
movl 0x8(%rdx), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rdx), %ecx
movl %ecx, 0x18(%rdi)
movq (%rdx), %rdx
testq %rdx, %rdx
je 0xfa42
movl %ecx, %r8d
movl %eax, %r9d
movl 0x8(%rdx), %r10d
cmpl %r9d, %r10d
jae 0xfa1c
movl %r10d, 0x8(%rdi)
movl %r10d, %r9d
cmpl %eax, %r10d
cmoval %r10d, %eax
movl 0xc(%rdx), %r10d
cmpl %r8d, %r10d
jae 0xfa33
movl %r10d, 0x18(%rdi)
movl %r10d, %r8d
cmpl %ecx, %r10d
cmoval %r10d, %ecx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0xfa0c
addl %esi, %ecx
movl %ecx, 0x1c(%rdi)
addl %esi, %eax
movl %eax, 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movl 0x18(%rdx), %edx
movl 0x1c(%rdi), %edi
movq 0x20(%r14), %rsi
callq 0xf961
movq %rax, %r13
movl 0x1c(%rax), %eax
cmpl 0x1c(%r15), %eax
jae 0xfb57
movq 0x28(%r15), %rbp
testq %rbp, %rbp
je 0xfb6b
leaq 0x8(%rsp), %r12
xorl %r15d, %r15d
movq %r15, 0x8(%rsp)
movq %r15, (%rsp)
movl 0x18(%r13), %eax
movq (%rbp), %rcx
movl 0xc(%rbp), %edx
cmpl %edx, %eax
ja 0xfacc
cmpl 0x1c(%r13), %edx
jae 0xfacc
incl %r15d
movq (%rsp), %rdx
movq %rdx, (%rbp)
movq %rbp, (%rsp)
jmp 0xfada
movq 0x8(%rsp), %rdx
movq %rdx, (%rbp)
movq %rbp, 0x8(%rsp)
movq %rcx, %rbp
testq %rcx, %rcx
jne 0xfaaa
movq %rsp, %rdi
callq 0x20173
movq %r12, %rdi
callq 0x20173
cmpl 0x4(%r14), %r15d
jge 0xfb02
movq $0x0, (%rsp)
jmp 0xfb35
movl $0x38, %edi
callq 0x2dff4
movq %rax, %rbp
movq (%rsp), %rax
movq %rax, 0x28(%rbp)
movl %r15d, 0x20(%rbp)
movq %r13, 0x10(%rbp)
movl 0xc(%r14), %esi
movq %rbp, %rdi
callq 0xf9e9
movq (%rbx), %rax
movq %rax, (%rbp)
movq %rbp, (%rbx)
movq 0x8(%rsp), %rbp
testq %rbp, %rbp
je 0xfb66
movl 0xc(%rbp), %edx
movl 0x1c(%r14), %edi
movq 0x20(%r14), %rsi
callq 0xf961
movq %rax, %r13
jmp 0xfa9a
movq %r13, 0x10(%r15)
movq (%rbx), %rax
movq %rax, (%r15)
movq %r15, (%rbx)
jmp 0xfb7d
movq 0x10(%rsp), %r15
movq $0x0, 0x28(%r15)
leaq 0x10(%rsp), %rdi
callq 0x2e0b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/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 0xfbfc
movq %rdi, %rbx
movq 0x10(%r15), %rdi
callq 0x2e0a0
movq 0x28(%r15), %r12
testq %r12, %r12
je 0xfbf4
movq %rsp, %r14
movq %r12, (%r14)
movq (%r12), %r12
movq %r14, %rdi
callq 0xfbac
movq %r12, (%rsp)
testq %r12, %r12
jne 0xfbd7
movq $0x0, 0x28(%r15)
movq %rbx, %rdi
callq 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfc3b
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0xfbac
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xfc26
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
je 0xfc6f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x38(%rbx), %rax
cmpq %rax, 0x38(%r14)
js 0xfc89
movl $0x1, %eax
jne 0xfc67
movl 0x20(%r14), %eax
subl 0x20(%rbx), %eax
jmp 0xfc67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xfc67
// File: /workspace/github_c_makefile_star2_O3/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 0x311dd
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rax, 0x10(%rsp)
callq 0x22cf1
testq %rax, %rax
je 0xfd3c
movq %rax, %r13
leaq 0x8(%rsp), %r14
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22cf1
movq %rax, %rbp
testq %rax, %rax
jne 0xfcfa
leaq 0x7df24(%rip), %rdi     # 0x8dc0b
leaq 0x7e10a(%rip), %rsi     # 0x8ddf8
movl $0xc7, %edx
xorl %eax, %eax
callq 0x26e94
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2c325
movq %rax, %r15
movq %r13, %rdi
callq 0x3bc10
movl %eax, 0x8(%r15)
movq %rbp, %rdi
callq 0x3bc10
movl %eax, 0xc(%r15)
movq %r12, (%r15)
movq %r15, (%rsp)
movq %r14, %rdi
callq 0x22cf1
movq %rax, %r13
movq %r15, %r12
testq %rax, %rax
jne 0xfcd0
leaq 0x10(%rsp), %rdi
callq 0x2e0b0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x20173
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_O3/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 0xfe7d
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r14, %r15
movq (%r14), %r14
testq %r12, %r12
je 0xfdc4
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
callq 0x6a50
testl %eax, %eax
jne 0xfdc4
movq 0x38(%r15), %rax
cmpq 0x38(%r12), %rax
jne 0xfdc4
movl 0x20(%r15), %eax
movl %eax, %ecx
subl 0x24(%r12), %ecx
cmpl %ebx, %ecx
jle 0xfe33
movl $0x48, %edi
callq 0x2dff4
movq %rax, %r12
movq 0x20(%r15), %rax
movq %rax, 0x20(%r12)
movq 0x10(%r15), %rdi
callq 0x1feba
movq %rax, 0x10(%r12)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r12)
movq 0x8(%r15), %rax
movq %rax, 0x8(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x30(%r12)
movq 0x38(%r15), %rax
movq %rax, 0x38(%r12)
movq 0x28(%r12), %rax
movq %rax, (%r15)
movq %r15, 0x28(%r12)
movq %r13, (%r12)
movq %r12, 0x8(%rsp)
movq %r12, %r13
movq %r15, %r12
testq %r14, %r14
jne 0xfd8d
jmp 0xfe7d
movl 0x8(%r15), %ecx
cmpl 0x8(%r13), %ecx
jge 0xfe41
movl %ecx, 0x8(%r13)
movl 0xc(%r15), %ecx
cmpl 0xc(%r13), %ecx
jle 0xfe4f
movl %ecx, 0xc(%r13)
cmpl 0x20(%r13), %eax
jge 0xfe59
movl %eax, 0x20(%r13)
movl 0x24(%r15), %eax
cmpl 0x24(%r13), %eax
jle 0xfe67
movl %eax, 0x24(%r13)
movl 0x30(%r15), %eax
addl %eax, 0x30(%r13)
leaq 0x28(%r13), %rdi
movq %r15, %rsi
callq 0x20105
jmp 0xfe25
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/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 0xfec8
leaq 0x10(%rip), %rsi        # 0xfeca
callq 0x29679
movq %rbx, %rdi
popq %rbx
jmp 0x298bd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x324f7
testl %eax, %eax
je 0xfef2
movq 0x10(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x32618
jmp 0xff03
movq 0x10(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3e30e
movq $0x0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10245
movq %rsp, %r14
leaq 0x80(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x13599
leaq 0x82896(%rip), %rdx     # 0x92ab9
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x23f33
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 0x13599
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: alignComponents
static boolean alignComponents(struct gfRange *combined, struct ssBundle *bun, 
	enum ffStringency stringency)
/* Align each piece of combined->components and put result in
 * bun->ffList. */
{
struct gfRange *range;
struct dnaSeq *qSeq = bun->qSeq, *tSeq = bun->genoSeq;
struct ssFfItem *ffi;
struct ffAli *ali;
int qStart, qEnd, tStart, tEnd;
int extra = 250;
boolean gotAny = FALSE;

for (range = combined->components; range != NULL; range = range->next)
    {
    /* Expand to include some extra sequence around range. */
    qStart = range->qStart - extra;
    tStart = range->tStart - extra;
    qEnd = range->qEnd + extra;
    tEnd = range->tEnd + extra;
    if (range == combined->components)
	{
        qStart -= extra;
	tStart -= extra;
	}
    if (range->next == NULL)
        {
	qEnd += extra;
	tEnd += extra;
	}
    if (qStart < combined->qStart) qStart = combined->qStart;
    if (tStart < combined->tStart) tStart = combined->tStart;
    if (qEnd > combined->qEnd) qEnd = combined->qEnd;
    if (tEnd > combined->tEnd) tEnd = combined->tEnd;
    ali = ffFind(qSeq->dna + qStart,
                 qSeq->dna + qEnd,
		 tSeq->dna + tStart - combined->tStart,
		 tSeq->dna + tEnd - combined->tStart,
		 stringency);
    if (ali != NULL)
        {
	AllocVar(ffi);
	ffi->ff = ali;
	slAddHead(&bun->ffList, ffi);
	gotAny = TRUE;
	}
    }
return gotAny;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r12
testq %r12, %r12
je 0x10343
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %rbp
movl $0xfffffe0c, %eax       # imm = 0xFFFFFE0C
cmpq 0x28(%r14), %r12
je 0x10291
movl $0xffffff06, %eax       # imm = 0xFFFFFF06
cmpq $0x0, (%r12)
movl $0x1f4, %ecx            # imm = 0x1F4
je 0x102a2
movl $0xfa, %ecx
movl 0x8(%r12), %edx
addl %eax, %edx
movl 0x8(%r14), %esi
cmpl %esi, %edx
jg 0x102b3
movl %esi, %edx
addl 0x20(%r12), %eax
movslq 0x20(%r14), %r8
cmpl %r8d, %eax
jg 0x102c4
movl %r8d, %eax
movl 0xc(%r12), %esi
addl %ecx, %esi
movl 0xc(%r14), %edi
cmpl %edi, %esi
jl 0x102d5
movl %edi, %esi
addl 0x24(%r12), %ecx
movl 0x24(%r14), %edi
cmpl %edi, %ecx
jl 0x102e4
movl %edi, %ecx
movq 0x10(%r13), %r9
movslq %edx, %rdi
addq %r9, %rdi
movslq %esi, %rsi
addq %r9, %rsi
movq 0x10(%rbp), %r9
movslq %eax, %rdx
addq %r9, %rdx
subq %r8, %rdx
movslq %ecx, %rcx
addq %r9, %rcx
subq %r8, %rcx
movl $0x1, %r8d
callq 0xacd1
testq %rax, %rax
je 0x10336
movq %rax, %r15
movl $0x10, %edi
callq 0x2dff4
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movq (%r12), %r12
testq %r12, %r12
jne 0x10281
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: saveAlignments
static void saveAlignments(char *chromName, int chromSize, int chromOffset, 
	struct ssBundle *bun, struct hash *t3Hash, 
	boolean qIsRc, boolean tIsRc,
	enum ffStringency stringency, int minMatch, struct gfOutput *out)
/* Save significant alignments to file in .psl format. */
{
struct dnaSeq *tSeq = bun->genoSeq, *qSeq = bun->qSeq;
struct ssFfItem *ffi;
for (ffi = bun->ffList; ffi != NULL; ffi = ffi->next)
    {
    struct ffAli *ff = ffi->ff;
    struct trans3 *t3List = NULL;
    int score;
    if (t3Hash != NULL)
	t3List = hashMustFindVal(t3Hash, tSeq->name);
    score = scoreAli(ff, bun->isProt, stringency, tSeq, t3List);
    if (score >= minMatch)
	{
	out->out(chromName, chromSize, chromOffset, ff, tSeq, t3Hash, qSeq, 
	    qIsRc, tIsRc, stringency, minMatch, out);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x20(%rsp)
movl %edx, 0x4(%rsp)
movl %esi, (%rsp)
movq %rdi, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x104e2
movq %r8, %rbx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %r13
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x8(%rcx), %r12
testq %rbx, %rbx
je 0x103bc
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x29361
movq %rax, %rbp
jmp 0x103be
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
leaq 0x157fa(%rip), %rax     # 0x25bc8
jne 0x103d7
leaq 0x1579a(%rip), %rax     # 0x25b71
testq %r12, %r12
movq %r12, 0x30(%rsp)
je 0x10470
movq 0x8(%r12), %r14
movq 0x10(%r12), %rdi
movq 0x20(%r12), %rsi
movl 0x18(%r12), %edx
subl %edi, %edx
movq %rax, 0x40(%rsp)
callq *%rax
movl %eax, %r15d
testq %r14, %r14
je 0x10473
movq %r14, %rbx
movq 0x20(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x15f64
movl %eax, %r14d
movq 0x28(%r12), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl $0x1, %ecx
callq 0x15f64
subl %eax, %r14d
movl 0x10(%rbx), %esi
subl 0x18(%r12), %esi
movl %r14d, %edi
movl 0x88(%rsp), %edx
callq 0x28548
subl %eax, %r15d
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
movl 0x18(%rbx), %edx
subl %edi, %edx
callq *0x40(%rsp)
addl %eax, %r15d
movq %rbx, %r12
jmp 0x10405
xorl %r15d, %r15d
movl 0x90(%rsp), %eax
cmpl %eax, %r15d
movq 0x28(%rsp), %rbx
movl 0x88(%rsp), %r11d
jl 0x104d1
movq 0x18(%rsp), %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x30(%rsp), %rcx
movq %r13, %r8
movq %rbx, %r9
movq 0x98(%rsp), %rax
pushq %rax
movl 0x98(%rsp), %r10d
pushq %r10
pushq %r11
movl 0x98(%rsp), %r10d
pushq %r10
pushq 0x40(%rsp)
pushq 0x38(%rsp)
callq *0x10(%rax)
addq $0x30, %rsp
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x1039d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/gfBlatLib.c
// Function: clumpTargetName
char *clumpTargetName(struct gfClump *clump)
/* Return target name of clump - whether it is in memory or on disk. */
{
struct gfSeqSource *target = clump->target;
char *name;
if (target->seq != NULL)
    name = target->seq->name;
else
    name = target->fileName;
if (name == NULL)
    internalErr();
return name;
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
cmoveq %rax, %rcx
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
jne 0x10524
leaq 0x7d6fa(%rip), %rdi     # 0x8dc0b
leaq 0x7d8e0(%rip), %rsi     # 0x8ddf8
movl $0x251, %edx            # imm = 0x251
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
popq %rbx
retq