LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/ffSeedExtend.c
// Function: addExtraHits
static void addExtraHits(struct gfHit *hitList, int hitSize, 
	struct dnaSeq *qSeq, struct dnaSeq *tSeq, struct ffAli **pExtraList)
/* Extend hits as far as possible, convert to ffAli, and add to extraList. */
{
struct gfHit *hit;
struct ffAli *ff;
char *qs = qSeq->dna, *ts = tSeq->dna;
char *qe = qs + qSeq->size,  *te = ts + tSeq->size;
for (hit = hitList; hit != NULL; hit = hit->next)
    {
    AllocVar(ff);
    ff->nStart = ff->nEnd = qs + hit->qStart;
    ff->hStart = ff->hEnd = ts + hit->tStart;
    ff->nEnd += hitSize;
    ff->hEnd += hitSize;
    ff->left = *pExtraList;
    ffExpandExactLeft(ff, qs, ts);
    ffExpandExactRight(ff, qe, te);
    *pExtraList = ff;
    }
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movl %edi, %r13d
pushq $0x1
popq %rdx
callq 0x2391e
movl %eax, %ebx
cmpl $0x3, %r13d
setl %al
cmpl $0x3, %r12d
setl %cl
testb %cl, %al
jne 0x15514
leal (%rbx,%rbx), %eax
testl %r12d, %r12d
leal 0x3(%rbx,%rbx), %ebx
cmovlel %eax, %ebx
movsbl (%r15), %edi
movsbl 0x1(%r15), %esi
movsbl -0x2(%r14), %edx
movsbl -0x1(%r14), %ecx
movl %ebp, %r8d
callq 0x133f5
addl %eax, %eax
subl %eax, %ebx
addl $0x6, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/patSpace.c
// Function: freePatSpace
void freePatSpace(struct patSpace **pPatSpace)
/* Free up a pattern space. */
{
struct patSpace *ps = *pPatSpace;
if (ps != NULL)
    {
    freeMem(ps->allocated);
    freez(pPatSpace);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x15546
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x28c2d
movq %rbx, %rdi
popq %rbx
jmp 0x28c3d
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/jkOwnLib/patSpace.c
// Function: newClump
static struct patClump *newClump(struct patSpace *ps, struct blockPos *first, struct blockPos *last)
/* Make new clump . */
{
struct dnaSeq *seq = first->seq;
int seqIx = first->seqIx;
int bacIx = first->bacIx;
int start = first->offset;
int end = last->offset+last->size;
int extraAtEnds = blockSize/2;
struct patClump *cl;

start -= extraAtEnds;
if (start < 0)
    start = 0;
end += extraAtEnds;
if (end >seq->size)
    end = seq->size;
AllocVar(cl);
cl->bacIx = bacIx;
cl->seqIx = seqIx;
cl->seq = seq;
cl->start = start;
cl->size = end-start;
return cl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rbx
movl 0x10(%rdi), %eax
movl 0x10(%rsi), %ecx
movl 0x14(%rsi), %edx
addl %edx, %ecx
addl $0x80, %ecx
movl 0x18(%rbx), %ebp
cmpl %ebp, %ecx
cmovll %ecx, %ebp
cmpl $0x81, %eax
movl $0x80, %r14d
cmovgel %eax, %r14d
addl $-0x80, %r14d
movq (%rdi), %xmm1
pxor %xmm0, %xmm0
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
movdqa %xmm1, (%rsp)
pushq $0x20
popq %rdi
callq 0x28bb0
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl %r14d, 0x18(%rax)
subl %r14d, %ebp
movl %ebp, 0x1c(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/aliType.c
// Function: gfTypeFromName
enum gfType gfTypeFromName(char *name)
/* Return type from string. */
{
if (sameWord(name, "DNA")) return gftDna;
if (sameWord(name, "RNA")) return gftRna;
if (sameWord(name, "protein")) return gftProt;
if (sameWord(name, "prot")) return gftProt;
if (sameWord(name, "DNAX")) return gftDnaX;
if (sameWord(name, "RNAX")) return gftRnaX;
errAbort("Unknown sequence type '%s'", name);
return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6702f(%rip), %rsi     # 0x7d6df
callq 0x1cd23
testl %eax, %eax
je 0x16730
leaq 0x67023(%rip), %rsi     # 0x7d6e3
movq %rbx, %rdi
callq 0x1cd23
testl %eax, %eax
je 0x16734
leaq 0x67014(%rip), %rsi     # 0x7d6e7
movq %rbx, %rdi
callq 0x1cd23
pushq $0x2
popq %rbp
testl %eax, %eax
je 0x16737
leaq 0x65cf0(%rip), %rsi     # 0x7c3d9
movq %rbx, %rdi
callq 0x1cd23
testl %eax, %eax
je 0x16737
leaq 0x66ff3(%rip), %rsi     # 0x7d6ef
movq %rbx, %rdi
callq 0x1cd23
testl %eax, %eax
je 0x16740
leaq 0x66fe5(%rip), %rsi     # 0x7d6f4
movq %rbx, %rdi
callq 0x1cd23
testl %eax, %eax
je 0x16744
leaq 0x66fe5(%rip), %rdi     # 0x7d707
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
jmp 0x16737
xorl %ebp, %ebp
jmp 0x16737
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x3
jmp 0x16736
pushq $0x4
jmp 0x16736
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtFree
void axtFree(struct axt **pEl)
/* Free an axt. */
{
struct axt *el = *pEl;
if (el != NULL)
    {
    freeMem(el->qName);
    freeMem(el->tName);
    freeMem(el->qSym);
    freeMem(el->tSym);
    freez(pEl);
    }
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x9e640(%rip), %edx     # 0xb4fc8
leal 0x1(%rdx), %eax
movl %eax, 0x9e637(%rip)     # 0xb4fc8
movq 0x20(%rdi), %rcx
movl 0x28(%rdi), %r8d
incl %r8d
movl 0x2c(%rdi), %r9d
movl 0x10(%rdi), %r10d
incl %r10d
movl 0x14(%rdi), %r11d
movsbl 0x18(%rdi), %r15d
leaq 0x66e03(%rip), %rsi     # 0x7d7ba
movq %r14, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
pushq 0x8(%rbx)
callq 0x6a90
addq $0x20, %rsp
movl 0x34(%rbx), %edx
leaq 0x6c1d9(%rip), %rsi     # 0x82bb1
movq %r14, %rdi
xorl %eax, %eax
callq 0x6a90
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %r14, %rsi
callq 0x6930
movq 0x48(%rbx), %rsi
movslq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x1ed3f
movl %ebp, %edi
movq %r14, %rsi
callq 0x6930
movq 0x40(%rbx), %rsi
movslq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x1ed3f
movl %ebp, %edi
movq %r14, %rsi
callq 0x6930
movl %ebp, %edi
movq %r14, %rsi
callq 0x6930
movq 0x48(%rbx), %rdi
callq 0x62d0
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x62d0
movl 0x38(%rbx), %r8d
cmpq %rax, %r14
jne 0x16a5e
movslq %r8d, %rcx
cmpq %rcx, %r14
jb 0x16a5e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x9c573(%rip), %rcx     # 0xb2fd8
movq (%rcx), %rdi
movl 0x9e559(%rip), %r10d    # 0xb4fc8
leaq 0x66d5c(%rip), %rsi     # 0x7d7d2
movl %eax, %edx
movl %r14d, %ecx
movl %r14d, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x8(%rbx)
callq 0x6a90
addq $0x18, %rsp
jmp 0x16a57
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtCmpQuery
int axtCmpQuery(const void *va, const void *vb)
/* Compare to sort based on query position. */
{
const struct axt *a = *((struct axt **)va);
const struct axt *b = *((struct axt **)vb);
int dif;
dif = strcmp(a->qName, b->qName);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl 0x4000c(%rdi), %ebp
movl 0x40008(%rdi), %eax
addl %ebp, %eax
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x21578
addq $0x8, %r12
testl %r15d, %r15d
cmovlel %r13d, %r15d
pushq $0x1
popq %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %r13, %r15
je 0x16c3e
movsbq (%r14,%r13), %rsi
cmpq $0x2d, %rsi
sete %r8b
movb (%rbx,%r13), %dil
cmpb $0x2d, %dil
sete %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x16c21
testl %edx, %edx
je 0x16c33
subl %ebp, %eax
jmp 0x16c37
movsbq %dil, %rdx
shlq $0xa, %rsi
addq %r12, %rsi
addl (%rsi,%rdx,4), %eax
xorl %edx, %edx
jmp 0x16c39
subl 0x4(%rsp), %eax
movl %ecx, %edx
incq %r13
jmp 0x16bf2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSymFilterRepeats
int axtScoreSymFilterRepeats(struct axtScoreScheme *ss, int symCount, char *qSym, char *tSym)
/* Return score without setting up an axt structure. Do not penalize gaps if repeat masked (lowercase)*/
{
int i;
char q,t;
int score = 0;
boolean lastGap = FALSE;
int gapStart = ss->gapOpen;
int gapExt = ss->gapExtend;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %esi, %r15d
movq %rdi, %r14
movl 0x4000c(%rdi), %eax
movl 0x40008(%rdi), %ecx
movl %eax, 0xc(%rsp)
addl %eax, %ecx
movl %ecx, 0x8(%rsp)
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x21578
addq $0x8, %r14
movq %r14, 0x10(%rsp)
testl %r15d, %r15d
cmovlel %ebx, %r15d
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq %rbx, %r15
je 0x16d43
movq 0x18(%rsp), %rax
movsbq (%rax,%rbx), %r13
cmpq $0x2d, %r13
sete %al
movq 0x20(%rsp), %rcx
movb (%rcx,%rbx), %cl
movsbq %cl, %r12
cmpb $0x2d, %r12b
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x16d23
movl %r13d, %edi
movl %r12d, %esi
callq 0x16c4d
testl %eax, %eax
je 0x16d23
testl %r14d, %r14d
je 0x16d36
subl 0xc(%rsp), %ebp
jmp 0x16d3a
shlq $0xa, %r13
addq 0x10(%rsp), %r13
addl (%r13,%r12,4), %ebp
xorl %r14d, %r14d
jmp 0x16d3e
subl 0x8(%rsp), %ebp
pushq $0x1
popq %r14
incq %rbx
jmp 0x16cd9
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtTransPosToQ
int axtTransPosToQ(struct axt *axt, int tPos)
/* Convert from t to q coordinates */
{
char *tSym = skipIgnoringDash(axt->tSym, tPos - axt->tStart, TRUE);
int symIx = tSym - axt->tSym;
int qPos = countNonDash(axt->qSym, symIx);
return qPos + axt->qStart;
}

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

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

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

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

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

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

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

ss = tt;
return ss;
}

// Assembly:
pushq %rbx
movq 0x9dfc8(%rip), %rbx     # 0xb4fe0
testq %rbx, %rbx
jne 0x170d6
movq 0x9dfc0(%rip), %rbx     # 0xb4fe8
testq %rbx, %rbx
jne 0x17041
movl $0x40018, %edi          # imm = 0x40018
callq 0x28bb0
movq %rax, %rbx
movq %rax, 0x9dfa7(%rip)     # 0xb4fe8
pushq $0x5b
popq %rax
movl %eax, 0x1858c(%rbx)
pushq $-0x72
popq %rcx
movl %ecx, 0x18594(%rbx)
pushq $-0x1f
popq %rdx
movl %edx, 0x185a4(%rbx)
pushq $-0x7b
popq %rsi
movl %esi, 0x185d8(%rbx)
movl %ecx, 0x18d8c(%rbx)
pushq $0x64
popq %rdi
movl %edi, 0x18d94(%rbx)
pushq $-0x7d
popq %r8
movl %r8d, 0x18da4(%rbx)
movl %edx, 0x18dd8(%rbx)
movl %edx, 0x19d8c(%rbx)
movl %r8d, 0x19d94(%rbx)
movl %edi, 0x19da4(%rbx)
movl %ecx, 0x19dd8(%rbx)
movl %esi, 0x1d18c(%rbx)
movl %edx, 0x1d194(%rbx)
movl %ecx, 0x1d1a4(%rbx)
movl %eax, 0x1d1d8(%rbx)
movq %rbx, %rdi
callq 0x170db
movabsq $0x1e00000190, %rax     # imm = 0x1E00000190
movq %rax, 0x40008(%rbx)
movq %rbx, 0x9df0a(%rip)     # 0xb4fe0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: propagateCase
static void propagateCase(struct axtScoreScheme *ss)
/* Propagate score matrix from lower case to mixed case
 * in matrix. */
{
static int twoCase[2][4] = {{'a', 'c', 'g', 't'},{'A','C','G','T'},};
int i1,i2,j1,j2;

/* Propagate to other case combinations. */
for (i1=0; i1<=1; ++i1)
    for (i2=0; i2<=1; ++i2)
       {
       if (i1 == 0 && i2 == 0)
           continue;
       for (j1=0; j1<4; ++j1)
       for (j2=0; j2<4; ++j2)
          {
          ss->matrix[twoCase[i1][j1]][twoCase[i2][j2]] = ss->matrix[twoCase[0][j1]][twoCase[0][j2]];
          }
       }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
addq $0x8, %rdi
xorl %eax, %eax
leaq 0x66a04(%rip), %rcx     # 0x7daf0
cmpq $0x2, %rax
je 0x17161
movq %rax, %rdx
shlq $0x4, %rdx
movq %rcx, %rsi
xorl %r8d, %r8d
cmpq $0x2, %r8
je 0x1715c
movl %r8d, %r9d
orl %eax, %r9d
je 0x17153
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x17153
leaq (%rcx,%r9,4), %r11
movslq (%rcx,%r9,4), %r10
movslq (%rdx,%r11), %r11
shlq $0xa, %r10
addq %rdi, %r10
shlq $0xa, %r11
addq %rdi, %r11
xorl %ebx, %ebx
cmpq $0x10, %rbx
je 0x1714e
movslq (%rbx,%rcx), %r14
movl (%r10,%r14,4), %ebp
movslq (%rsi,%rbx), %r14
movl %ebp, (%r11,%r14,4)
addq $0x4, %rbx
jmp 0x17132
incq %r9
jmp 0x17110
incq %r8
addq $0x10, %rsi
jmp 0x170ff
incq %rax
jmp 0x170ec
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeSimpleDna
struct axtScoreScheme *axtScoreSchemeSimpleDna(int match, int misMatch, int gapOpen, int gapExtend)
/* Return a relatively simple scoring scheme for DNA. */
{
static struct axtScoreScheme *ss;
static struct axtScoreScheme *tt;

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

/* Set up lower case elements of matrix. */
tt->matrix['a']['a'] = match;
tt->matrix['a']['c'] = -misMatch;
tt->matrix['a']['g'] = -misMatch;
tt->matrix['a']['t'] = -misMatch;

tt->matrix['c']['a'] = -misMatch;
tt->matrix['c']['c'] = match;
tt->matrix['c']['g'] = -misMatch;
tt->matrix['c']['t'] = -misMatch;

tt->matrix['g']['a'] = -misMatch;
tt->matrix['g']['c'] = -misMatch;
tt->matrix['g']['g'] = match;
tt->matrix['g']['t'] = -misMatch;

tt->matrix['t']['a'] = -misMatch;
tt->matrix['t']['c'] = -misMatch;
tt->matrix['t']['g'] = -misMatch;
tt->matrix['t']['t'] = match;

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

ss = tt;
return ss;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x9de7b(%rip), %r14     # 0xb4ff0
testq %r14, %r14
jne 0x17238
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movl %edi, %r15d
movq 0x9de69(%rip), %r14     # 0xb4ff8
testq %r14, %r14
jne 0x171a8
movl $0x40018, %edi          # imm = 0x40018
callq 0x28bb0
movq %rax, %r14
movq %rax, 0x9de50(%rip)     # 0xb4ff8
movl %r15d, 0x1858c(%r14)
negl %r12d
movl %r12d, 0x18594(%r14)
movl %r12d, 0x185a4(%r14)
movl %r12d, 0x185d8(%r14)
movl %r12d, 0x18d8c(%r14)
movl %r15d, 0x18d94(%r14)
movl %r12d, 0x18da4(%r14)
movl %r12d, 0x18dd8(%r14)
movl %r12d, 0x19d8c(%r14)
movl %r12d, 0x19d94(%r14)
movl %r15d, 0x19da4(%r14)
movl %r12d, 0x19dd8(%r14)
movl %r12d, 0x1d18c(%r14)
movl %r12d, 0x1d194(%r14)
movl %r12d, 0x1d1a4(%r14)
movl %r15d, 0x1d1d8(%r14)
movq %r14, %rdi
callq 0x170db
movl %ebp, 0x40008(%r14)
movl %ebx, 0x4000c(%r14)
movq %r14, 0x9ddb8(%rip)     # 0xb4ff0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeRnaDefault
struct axtScoreScheme *axtScoreSchemeRnaDefault()
/* Return default scoring scheme for RNA/DNA alignments
 * within the same species.  Do NOT axtScoreSchemeFree */
{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeSimpleDna(100, 200, 300, 300);
return ss;
}

// Assembly:
movq 0x9ddb5(%rip), %rax     # 0xb5000
testq %rax, %rax
je 0x17251
retq
pushq %rax
pushq $0x64
popq %rdi
movl $0xc8, %esi
movl $0x12c, %edx            # imm = 0x12C
movl $0x12c, %ecx            # imm = 0x12C
callq 0x17166
movq %rax, 0x9dd90(%rip)     # 0xb5000
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeRnaFill
struct axtScoreScheme *axtScoreSchemeRnaFill()
/* Return scoreing scheme a little more relaxed than 
 * RNA/DNA defaults for filling in gaps. */
{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeSimpleDna(100, 100, 200, 200);
return ss;
}

// Assembly:
movq 0x9dd8c(%rip), %rax     # 0xb5008
testq %rax, %rax
je 0x17282
retq
pushq %rax
pushq $0x64
popq %rdi
movl %edi, %esi
movl $0xc8, %edx
movl $0xc8, %ecx
callq 0x17166
movq %rax, 0x9dd6a(%rip)     # 0xb5008
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeFromBlastzMatrix
struct axtScoreScheme *axtScoreSchemeFromBlastzMatrix(char *text, int gapOpen, int gapExtend)
/* return scoring schema from a string in the following format */
/* 91,-90,-25,-100,-90,100,-100,-25,-25,-100,100,-90,-100,-25,-90,91 */
{
char *matrixDna[32];
struct axtScoreScheme *ss = axtScoreSchemeDefault();
int matrixSize = chopString(text, ",", matrixDna, 32);
if (matrixSize != 16)
    return ss;
if (ss == NULL)
    return NULL;
ss->gapOpen = gapOpen;
ss->gapExtend = gapExtend;
ss->matrix['a']['a'] = atoi(matrixDna[0]);
ss->matrix['a']['c'] = atoi(matrixDna[1]);
ss->matrix['a']['g'] = atoi(matrixDna[2]);
ss->matrix['a']['t'] = atoi(matrixDna[3]);

ss->matrix['c']['a'] = atoi(matrixDna[4]);
ss->matrix['c']['c'] = atoi(matrixDna[5]);
ss->matrix['c']['g'] = atoi(matrixDna[6]);
ss->matrix['c']['t'] = atoi(matrixDna[7]);

ss->matrix['g']['a'] = atoi(matrixDna[8]);
ss->matrix['g']['c'] = atoi(matrixDna[9]);
ss->matrix['g']['g'] = atoi(matrixDna[10]);
ss->matrix['g']['t'] = atoi(matrixDna[11]);

ss->matrix['t']['a'] = atoi(matrixDna[12]);
ss->matrix['t']['c'] = atoi(matrixDna[13]);
ss->matrix['t']['g'] = atoi(matrixDna[14]);
ss->matrix['t']['t'] = atoi(matrixDna[15]);
return ss;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0x17010
movq %rax, %rbx
leaq 0x67710(%rip), %rsi     # 0x7e9d7
movq %rsp, %rdx
pushq $0x20
popq %rcx
movq %r15, %rdi
callq 0x1e51d
cmpl $0x10, %eax
jne 0x173f7
testq %rbx, %rbx
je 0x173f5
movl %r14d, 0x40008(%rbx)
movl %ebp, 0x4000c(%rbx)
movq (%rsp), %rdi
callq 0x6bd0
movl %eax, 0x1858c(%rbx)
movq 0x8(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x18594(%rbx)
movq 0x10(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x185a4(%rbx)
movq 0x18(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x185d8(%rbx)
movq 0x20(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x18d8c(%rbx)
movq 0x28(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x18d94(%rbx)
movq 0x30(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x18da4(%rbx)
movq 0x38(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x18dd8(%rbx)
movq 0x40(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x19d8c(%rbx)
movq 0x48(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x19d94(%rbx)
movq 0x50(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x19da4(%rbx)
movq 0x58(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x19dd8(%rbx)
movq 0x60(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x1d18c(%rbx)
movq 0x68(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x1d194(%rbx)
movq 0x70(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x1d1a4(%rbx)
movq 0x78(%rsp), %rdi
callq 0x6bd0
movl %eax, 0x1d1d8(%rbx)
jmp 0x173f7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeProteinDefault
struct axtScoreScheme *axtScoreSchemeProteinDefault()
/* Returns default protein scoring scheme.  This is
 * scaled to be compatible with the blastz one. */
{
static struct axtScoreScheme *ss;
static struct axtScoreScheme *tt;
int i,j;

if (ss != NULL)
    return ss;
if (tt == NULL)
    tt = axtScoreSchemeFromProteinText(blosumText, "blosum62");

for (i=0; i<128; ++i)
    for (j=0; j<128; ++j)
        tt->matrix[i][j] *= 19;
tt->gapOpen = 11 * 19;
tt->gapExtend = 1 * 19;
ss = tt;
return ss;
}

// Assembly:
movq 0x9d955(%rip), %rax     # 0xb5020
testq %rax, %rax
je 0x176d1
retq
pushq %rax
movq 0x9d94f(%rip), %rax     # 0xb5028
testq %rax, %rax
jne 0x176f8
leaq 0x9c6db(%rip), %rdi     # 0xb3dc0
leaq 0x661f1(%rip), %rsi     # 0x7d8dd
callq 0x17408
movq %rax, 0x9d930(%rip)     # 0xb5028
leaq 0x8(%rax), %rcx
xorl %edx, %edx
cmpq $0x80, %rdx
je 0x1772a
xorl %esi, %esi
cmpq $0x80, %rsi
je 0x1771e
imull $0x13, (%rcx,%rsi,4), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
jmp 0x17709
incq %rdx
addq $0x400, %rcx            # imm = 0x400
jmp 0x176fe
movabsq $0x13000000d1, %rcx     # imm = 0x13000000D1
movq %rcx, 0x40008(%rax)
movq %rax, 0x9d8de(%rip)     # 0xb5020
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeProteinRead
struct axtScoreScheme *axtScoreSchemeProteinRead(char *fileName)
{
char *string;
struct axtScoreScheme *ss;

readInGulp(fileName, &string, NULL);
ss = axtScoreSchemeFromProteinText(string, fileName);
freeMem(string);

return ss;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d134
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x17408
movq %rax, %rbx
movq (%r14), %rdi
callq 0x28c2d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtScoreSchemeDnaWrite
void axtScoreSchemeDnaWrite(struct axtScoreScheme *ss, FILE *f, char *name)
/* output the score dna based score matrix in meta Data format to File f,
name should be set to the name of the program that is using the matrix */
{
if (ss == NULL)
    return;
if (f == NULL)
    return;
fprintf(f, "##matrix=%s 16 %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
        name,
    ss->matrix['a']['a'],
    ss->matrix['a']['c'],
    ss->matrix['a']['g'],
    ss->matrix['a']['t'],

    ss->matrix['c']['a'],
    ss->matrix['c']['c'],
    ss->matrix['c']['g'],
    ss->matrix['c']['t'],

    ss->matrix['g']['a'],
    ss->matrix['g']['c'],
    ss->matrix['g']['g'],
    ss->matrix['g']['t'],

    ss->matrix['t']['a'],
    ss->matrix['t']['c'],
    ss->matrix['t']['g'],
    ss->matrix['t']['t']);
fprintf(f, "##gapPenalties=%s O=%d E=%d\n", name, ss->gapOpen, ss->gapExtend);
if (ss->extra!=NULL)
    {
    stripChar(ss->extra,' ');
    stripChar(ss->extra,'"');
    fprintf(f, "##blastzParms=%s\n", ss->extra);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x17cc5
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1858c(%rdi), %ecx
movl 0x18594(%rdi), %r8d
movl 0x185a4(%rdi), %r9d
movl 0x185d8(%rdi), %eax
movq %rax, 0x40(%rsp)
movl 0x18d8c(%rdi), %eax
movq %rax, 0x38(%rsp)
movl 0x18d94(%rdi), %eax
movq %rax, 0x30(%rsp)
movl 0x18da4(%rdi), %eax
movq %rax, 0x28(%rsp)
movl 0x18dd8(%rdi), %eax
movq %rax, 0x20(%rsp)
movl 0x19d8c(%rdi), %eax
movq %rax, 0x18(%rsp)
movl 0x19d94(%rdi), %eax
movq %rax, 0x10(%rsp)
movl 0x19da4(%rdi), %eax
movq %rax, 0x8(%rsp)
movl 0x19dd8(%rdi), %r13d
movl 0x1d18c(%rdi), %ebp
movl 0x1d194(%rdi), %r10d
movl 0x1d1a4(%rdi), %r11d
movl 0x1d1d8(%rdi), %r12d
subq $0x8, %rsp
leaq 0x65d49(%rip), %rsi     # 0x7d963
movq %rbx, %rdi
xorl %eax, %eax
pushq %r12
pushq %r11
pushq %r10
pushq %rbp
pushq %r13
pushq 0x38(%rsp)
pushq 0x48(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
pushq 0x98(%rsp)
pushq 0xa8(%rsp)
callq 0x6a90
addq $0x70, %rsp
movl 0x40008(%r14), %ecx
movl 0x4000c(%r14), %r8d
leaq 0x65d34(%rip), %rsi     # 0x7d9a3
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6a90
movq 0x40010(%r14), %rdi
testq %rdi, %rdi
je 0x17cc5
pushq $0x20
popq %rsi
callq 0x1e2be
movq 0x40010(%r14), %rdi
pushq $0x22
popq %rsi
callq 0x1e2be
movq 0x40010(%r14), %rdx
leaq 0x65d13(%rip), %rsi     # 0x7d9c0
movq %rbx, %rdi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a90
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtSwap
void axtSwap(struct axt *axt, int tSize, int qSize)
/* Flip target and query on one axt. */
{
struct axt old = *axt;

/* Copy non-strand dependent stuff */
axt->qName = old.tName;
axt->tName = old.qName;
axt->qSym = old.tSym;
axt->tSym = old.qSym;
axt->qStart = old.tStart;
axt->qEnd = old.tEnd;
axt->tStart = old.qStart;
axt->tEnd = old.qEnd;

/* Copy strand dependent stuff. */
assert(axt->tStrand != '-');

if (axt->qStrand == '-')
    {
    /* axt's are really set up so that the target is on the
     * + strand and the query is on the minus strand.
     * Therefore we need to reverse complement both 
     * strands while swapping to preserve this. */
    reverseIntRange(&axt->tStart, &axt->tEnd, qSize);
    reverseIntRange(&axt->qStart, &axt->qEnd, tSize);
    reverseComplement(axt->qSym, axt->symCount);
    reverseComplement(axt->tSym, axt->symCount);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movups 0x8(%rdi), %xmm0
movups 0x20(%rdi), %xmm1
movups %xmm1, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
movdqu 0x40(%rdi), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x40(%rdi)
cmpb $0x2d, 0x30(%rdi)
je 0x17d5c
movq %rdi, %rbx
cmpb $0x2d, 0x18(%rdi)
jne 0x17d51
movl %esi, %ebp
leaq 0x10(%rbx), %r14
leaq 0x14(%rbx), %r15
leaq 0x28(%rbx), %rdi
leaq 0x2c(%rbx), %rsi
callq 0x20d61
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x20d61
movq 0x40(%rbx), %rdi
movslq 0x38(%rbx), %rsi
callq 0x20d38
movq 0x48(%rbx), %rdi
movslq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20d38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x65c6f(%rip), %rdi     # 0x7d9d2
leaq 0x65c7c(%rip), %rsi     # 0x7d9e6
leaq 0x65c7f(%rip), %rcx     # 0x7d9f0
movl $0x399, %edx            # imm = 0x399
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtBundleFree
void axtBundleFree(struct axtBundle **pObj)
/* Free a axtBundle. */
{
struct axtBundle *obj = *pObj;
if (obj != NULL)
    {
    axtFreeList(&obj->axtList);
    freez(pObj);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x17d99
addq $0x8, %rdi
callq 0x16792
movq %rbx, %rdi
popq %rbx
jmp 0x28c3d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtBundleFreeList
void axtBundleFreeList(struct axtBundle **pList)
/* Free a list of axtBundles. */
{
struct axtBundle *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x17dc6
movq (%r15), %r15
movq %r14, %rdi
callq 0x17d7b
jmp 0x17daf
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtAddBlocksToBoxInList
void axtAddBlocksToBoxInList(struct cBlock **pList, struct axt *axt)
/* Add blocks (gapless subalignments) from (non-NULL!) axt to block list. 
 * Note: list will be in reverse order of axt blocks. */
{
boolean thisIn, lastIn = FALSE;
int qPos = axt->qStart, tPos = axt->tStart;
int qStart = 0, tStart = 0;
int i;

for (i=0; i<=axt->symCount; ++i)
{
    int advanceQ = (isalpha(axt->qSym[i]) ? 1 : 0);
    int advanceT = (isalpha(axt->tSym[i]) ? 1 : 0);
    thisIn = (advanceQ && advanceT);
    if (thisIn)
    {
        if (!lastIn)
        {
            qStart = qPos;
            tStart = tPos;
        }
    }
    else
    {
        if (lastIn)
        {
            int size = qPos - qStart;
            assert(size == tPos - tStart);
            if (size > 0)
            {
                struct cBlock *b;
                AllocVar(b);
                b->qStart = qStart;
                b->qEnd = qPos;
                b->tStart = tStart;
                b->tEnd = tPos;
                slAddHead(pList, b);
            }
        }
    }
    lastIn = thisIn;
    qPos += advanceQ;
    tPos += advanceT;
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
movl 0x10(%rsi), %eax
movl %eax, 0x14(%rsp)
movl 0x28(%rsi), %esi
xorl %r13d, %r13d
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
xorl %r12d, %r12d
movq %r15, 0x20(%rsp)
movslq 0x38(%r15), %rax
cmpq %rax, %r13
jg 0x17eed
movl %r12d, %r14d
movl %esi, %ebx
callq 0x6790
movq (%rax), %rax
movq 0x40(%r15), %rcx
movq 0x48(%r15), %rdx
movsbq (%rcx,%r13), %rcx
movzwl (%rax,%rcx,2), %r15d
shrl $0xa, %r15d
andl $0x1, %r15d
movsbq (%rdx,%r13), %rcx
movzwl (%rax,%rcx,2), %ebp
shrl $0xa, %ebp
andl $0x1, %ebp
movl %r15d, %r12d
andl %ebp, %r12d
cmpl $0x1, %r12d
jne 0x17e81
testl %r14d, %r14d
movl %ebx, %esi
movl 0x10(%rsp), %eax
cmovel %ebx, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %r14d
movl 0xc(%rsp), %eax
cmovel %r14d, %eax
movl %eax, 0xc(%rsp)
jmp 0x17ed6
testl %r14d, %r14d
movl %ebx, %esi
je 0x17ed1
movl 0x14(%rsp), %r14d
movl %r14d, %eax
subl 0xc(%rsp), %eax
movl %esi, %ecx
subl 0x10(%rsp), %ecx
cmpl %ecx, %eax
jne 0x17efc
testl %eax, %eax
jle 0x17ed6
pushq $0x28
popq %rdi
callq 0x28bb0
movl %ebx, %esi
movl 0xc(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl %r14d, 0x14(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq 0x18(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, (%rax)
movq %rax, (%rdx)
jmp 0x17ed6
movl 0x14(%rsp), %r14d
addl %r15d, %r14d
movl %r14d, 0x14(%rsp)
addl %ebp, %esi
incq %r13
movq 0x20(%rsp), %r15
jmp 0x17e0f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x65b12(%rip), %rdi     # 0x7da15
leaq 0x65adc(%rip), %rsi     # 0x7d9e6
leaq 0x65b1a(%rip), %rcx     # 0x7da2b
movl $0x3db, %edx            # imm = 0x3DB
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtIdWithGaps
double axtIdWithGaps(struct axt *axt)
/* Return ratio of matching bases to total symbols in alignment. */
{
int i;
int matchCount = 0;
for (i=0; i<axt->symCount; ++i)
    {
    if (toupper(axt->qSym[i]) == toupper(axt->tSym[i]))
        ++matchCount;
    }
return (double)matchCount/axt->symCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %r15d
cmovgl %ebp, %r15d
xorl %r12d, %r12d
cmpq %r14, %r15
je 0x181c5
callq 0x6100
movq (%rax), %rax
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
movsbq (%rcx,%r14), %rcx
movl (%rax,%rcx,4), %ecx
movsbq (%rdx,%r14), %rdx
xorl %esi, %esi
cmpl (%rax,%rdx,4), %ecx
sete %sil
addl %esi, %r12d
incq %r14
jmp 0x18192
cvtsi2sd %r12d, %xmm0
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/axt.c
// Function: axtOutPretty
void axtOutPretty(struct axt *axt, int lineSize, FILE *f)
/* Output axt in pretty format. */
{
char *q = axt->qSym;
char *t = axt->tSym;
int size = axt->symCount;
int oneSize, sizeLeft = size;
int i;

fprintf(f, ">%s:%d%c%d %s:%d-%d %d\n", 
    axt->qName, axt->qStart, axt->qStrand, axt->qEnd,
    axt->tName, axt->tStart, axt->tEnd, axt->score);
while (sizeLeft > 0)
    {
    oneSize = sizeLeft;
    if (oneSize > lineSize)
        oneSize = lineSize;
    mustWrite(f, q, oneSize);
    fputc('\n', f);

    for (i=0; i<oneSize; ++i)
        {
    if (toupper(q[i]) == toupper(t[i]) && isalpha(q[i]))
        fputc('|', f);
    else
        fputc(' ', f);
    }
    fputc('\n', f);

    if (oneSize > lineSize)
        oneSize = lineSize;
    mustWrite(f, t, oneSize);
    fputc('\n', f);
    fputc('\n', f);
    sizeLeft -= oneSize;
    q += oneSize;
    t += oneSize;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, 0x8(%rsp)
movq %rdi, %r10
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %r15
movl 0x38(%rdi), %ebp
movq 0x8(%rdi), %rdx
movl 0x10(%rdi), %ecx
movsbl 0x18(%rdi), %r8d
movl 0x14(%rdi), %r9d
movl 0x28(%rdi), %r11d
movl 0x2c(%rdi), %r12d
movl 0x34(%rdi), %r13d
leaq 0x6582c(%rip), %rsi     # 0x7da75
movq %rbx, %rdi
xorl %eax, %eax
pushq %r13
pushq %r12
pushq %r11
pushq 0x20(%r10)
callq 0x6a90
movl %ebp, %ecx
addq $0x20, %rsp
pushq $0xa
popq %rbp
testl %ecx, %ecx
jle 0x18332
movl 0x8(%rsp), %eax
cmpl %eax, %ecx
movl %ecx, 0xc(%rsp)
cmovll %ecx, %eax
movslq %eax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1ed3f
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6930
testl %r13d, %r13d
movl $0x0, %r12d
movq %r13, 0x10(%rsp)
cmovgl %r13d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x182ec
callq 0x6100
movq (%rax), %rax
movsbq (%r14,%r13), %rbp
movl (%rax,%rbp,4), %ecx
movsbq (%r15,%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x182dc
callq 0x6790
movq (%rax), %rax
testb $0x4, 0x1(%rax,%rbp,2)
pushq $0x7c
popq %rdi
jne 0x182df
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x6930
incq %r13
jmp 0x182ab
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6930
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x1ed3f
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6930
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6930
movl 0xc(%rsp), %ecx
subl %r12d, %ecx
addq %r12, %r14
addq %r12, %r15
jmp 0x18266
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/bits.c
// Function: bitsInByteInit
void bitsInByteInit()
/* Initialize bitsInByte array. */
{
int i;

if (!inittedBitsInByte)
    {
    inittedBitsInByte = TRUE;
    for (i=0; i<256; ++i)
        {
	int count = 0;
	if (i&1)
	    count = 1;
	if (i&2)
	    ++count;
	if (i&4)
	    ++count;
	if (i&8)
	    ++count;
	if (i&0x10)
	    ++count;
	if (i&0x20)
	    ++count;
	if (i&0x40)
	    ++count;
	if (i&0x80)
	    ++count;
	bitsInByte[i] = count;
	}
    }
}

// Assembly:
cmpb $0x0, 0x9cce5(%rip)     # 0xb5030
je 0x1834e
retq
movb $0x1, 0x9ccdb(%rip)     # 0xb5030
leaq 0x9cce4(%rip), %rax     # 0xb5040
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x1834d
movl %ecx, %edx
andl $0x1, %edx
movl %ecx, %esi
shrl %esi
andl $0x1, %esi
btl $0x2, %ecx
adcl %edx, %esi
movl %ecx, %edx
shrl $0x3, %edx
andl $0x1, %edx
btl $0x4, %ecx
adcl %esi, %edx
movl %ecx, %esi
shrl $0x5, %esi
andl $0x1, %esi
btl $0x6, %ecx
adcl %edx, %esi
xorl %edx, %edx
cmpq $0x7f, %rcx
seta %dl
addl %esi, %edx
movl %edx, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x1835e
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/bits.c
// Function: lmBitRealloc
Bits *lmBitRealloc(struct lm *lm,Bits *b, int bitCount, int newBitCount)
// Resize a bit array.  If b is null, allocate a new array.  Must supply local memory.
{
assert(lm != NULL);
int byteCount = ((bitCount+7)>>3);
int newByteCount = ((newBitCount+7)>>3);
return lmAllocMoreMem(lm, b ,byteCount, newByteCount);
}

// Assembly:
testq %rdi, %rdi
je 0x1844f
addl $0x7, %edx
sarl $0x3, %edx
addl $0x7, %ecx
sarl $0x3, %ecx
movslq %edx, %rdx
movslq %ecx, %rcx
jmp 0x27048
pushq %rax
leaq 0x656b9(%rip), %rdi     # 0x7db10
leaq 0x656bd(%rip), %rsi     # 0x7db1b
leaq 0x656e4(%rip), %rcx     # 0x7db49
pushq $0x5b
popq %rdx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/bits.c
// Function: lmBitClone
Bits *lmBitClone(struct lm *lm,Bits* orig, int bitCount)
// Clone bits.  Must supply local memory.
{
assert(lm != NULL);
int byteCount = ((bitCount+7)>>3);
Bits* bits = lmAlloc(lm,byteCount);
memcpy(bits, orig, byteCount);
return bits;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1849f
movq %rsi, %rbx
addl $0x7, %edx
sarl $0x3, %edx
movslq %edx, %r14
movq %r14, %rsi
callq 0x26ff4
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6570
leaq 0x6566a(%rip), %rdi     # 0x7db10
leaq 0x6566e(%rip), %rsi     # 0x7db1b
leaq 0x656c7(%rip), %rcx     # 0x7db7b
pushq $0x64
popq %rdx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/bits.c
// Function: bitSetRange
void bitSetRange(Bits *b, int startIx, int bitCount)
/* Set a range of bits. */
{
if (bitCount <= 0)
    return;
int endIx = (startIx + bitCount - 1);
int startByte = (startIx>>3);
int endByte = (endIx>>3);
int startBits = (startIx&7);
int endBits = (endIx&7);
int i;

if (startByte == endByte)
    {
    b[startByte] |= (leftMask[startBits] & rightMask[endBits]);
    return;
    }
b[startByte] |= leftMask[startBits];
for (i = startByte+1; i<endByte; ++i)
    b[i] = 0xff;
b[endByte] |= rightMask[endBits];
}

// Assembly:
testl %edx, %edx
jle 0x1854d
leal (%rsi,%rdx), %eax
decl %eax
movl %esi, %ecx
sarl $0x3, %ecx
movl %eax, %r8d
sarl $0x3, %r8d
andl $0x7, %esi
andl $0x7, %eax
leaq 0x6569c(%rip), %rdx     # 0x7dbae
movb (%rsi,%rdx), %dl
cmpl %r8d, %ecx
jne 0x18529
leaq 0x65695(%rip), %rsi     # 0x7dbb6
andb (%rax,%rsi), %dl
movslq %ecx, %rcx
jmp 0x1854a
movslq %ecx, %rsi
orb %dl, (%rdi,%rsi)
movslq %r8d, %rcx
incq %rsi
cmpq %rcx, %rsi
jge 0x18540
movb $-0x1, (%rdi,%rsi)
jmp 0x18532
leaq 0x6566f(%rip), %rdx     # 0x7dbb6
movb (%rax,%rdx), %dl
orb %dl, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/bits.c
// Function: bitCountRange
int bitCountRange(Bits *b, int startIx, int bitCount)
/* Count number of bits set in range. */
{
if (bitCount <= 0)
    return 0;
int endIx = (startIx + bitCount - 1);
int startByte = (startIx>>3);
int endByte = (endIx>>3);
int startBits = (startIx&7);
int endBits = (endIx&7);
int i;
int count = 0;

if (!inittedBitsInByte)
    bitsInByteInit();
if (startByte == endByte)
    return bitsInByte[b[startByte] & leftMask[startBits] & rightMask[endBits]];
count = bitsInByte[b[startByte] & leftMask[startBits]];
for (i = startByte+1; i<endByte; ++i)
    count += bitsInByte[b[i]];
count += bitsInByte[b[endByte] & rightMask[endBits]];
return count;
}

// Assembly:
testl %edx, %edx
jle 0x185de
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%rdx), %r15d
decl %r15d
movl %esi, %r12d
sarl $0x3, %r12d
movl %r15d, %ebp
sarl $0x3, %ebp
andl $0x7, %r14d
andl $0x7, %r15d
cmpb $0x0, 0x9ca8f(%rip)     # 0xb5030
jne 0x185a8
callq 0x18344
movslq %r12d, %rcx
movzbl (%rbx,%rcx), %edx
leaq 0x655f8(%rip), %rax     # 0x7dbae
movzbl (%r14,%rax), %eax
andl %edx, %eax
cmpl %ebp, %ecx
jne 0x185e1
leaq 0x655ee(%rip), %rcx     # 0x7dbb6
movzbl (%r15,%rcx), %ecx
movzbl %al, %eax
andl %ecx, %eax
leaq 0x9ca67(%rip), %rcx     # 0xb5040
movl (%rcx,%rax,4), %eax
jmp 0x18614
xorl %eax, %eax
retq
leaq 0x9ca58(%rip), %rdx     # 0xb5040
movl (%rdx,%rax,4), %eax
movslq %ebp, %rsi
incq %rcx
cmpq %rsi, %rcx
jge 0x185ff
movzbl (%rbx,%rcx), %edi
addl (%rdx,%rdi,4), %eax
jmp 0x185ee
movzbl (%rbx,%rsi), %ecx
leaq 0x655ac(%rip), %rsi     # 0x7dbb6
movzbl (%r15,%rsi), %esi
andl %ecx, %esi
addl (%rdx,%rsi,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq