LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
addq $0x8, %rdi
movb $0x1, %al
xorl %ecx, %ecx
leaq 0x745b9(%rip), %rdx     # 0x8eb90
movq %rcx, %rsi
shlq $0x4, %rsi
movb $0x1, %r8b
xorl %r9d, %r9d
movq %r9, %r10
orq %rcx, %r10
je 0x1a637
shlq $0x4, %r9
xorl %r10d, %r10d
leaq (%rdx,%r10,4), %rbx
movslq (%rdx,%r10,4), %r11
movslq (%rsi,%rbx), %rbx
shlq $0xa, %r11
addq %rdi, %r11
shlq $0xa, %rbx
addq %rdi, %rbx
xorl %r14d, %r14d
movslq (%r14,%rdx), %r15
movl (%r11,%r15,4), %ebp
leaq (%r9,%r14), %r15
movslq (%rdx,%r15), %r15
movl %ebp, (%rbx,%r15,4)
addq $0x4, %r14
cmpq $0x10, %r14
jne 0x1a610
incq %r10
cmpq $0x4, %r10
jne 0x1a5f3
movl $0x1, %r9d
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x1a5e4
movl $0x1, %ecx
testb $0x1, %al
movl $0x0, %eax
jne 0x1a5d7
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa6963(%rip), %r14     # 0xc0fd0
testq %r14, %r14
jne 0x1a730
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movl %edi, %r15d
movq 0xa6951(%rip), %r14     # 0xc0fd8
testq %r14, %r14
jne 0x1a6a0
movl $0x40018, %edi          # imm = 0x40018
callq 0x2dff4
movq %rax, %r14
movq %rax, 0xa6938(%rip)     # 0xc0fd8
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 0x1a5c2
movl %ebp, 0x40008(%r14)
movl %ebx, 0x4000c(%r14)
movq %r14, 0xa68a0(%rip)     # 0xc0fd0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa689d(%rip), %rax     # 0xc0fe0
testq %rax, %rax
je 0x1a749
retq
pushq %rax
movl $0x64, %edi
movl $0xc8, %esi
movl $0x12c, %edx            # imm = 0x12C
movl $0x12c, %ecx            # imm = 0x12C
callq 0x1a65e
movq %rax, 0xa6876(%rip)     # 0xc0fe0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa6872(%rip), %rax     # 0xc0fe8
testq %rax, %rax
je 0x1a77c
retq
pushq %rax
movl $0x64, %edi
movl $0x64, %esi
movl $0xc8, %edx
movl $0xc8, %ecx
callq 0x1a65e
movq %rax, 0xa684b(%rip)     # 0xc0fe8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a4eb
movq %rax, %rbx
leaq 0x752e1(%rip), %rsi     # 0x8faa7
movq %rsp, %rdx
movq %r15, %rdi
movl $0x20, %ecx
callq 0x22667
cmpl $0x10, %eax
jne 0x1a8f8
testq %rbx, %rbx
je 0x1a8f6
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 0x1a8f8
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_O3/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 0xa6407(%rip), %rax     # 0xc1000
testq %rax, %rax
je 0x1abff
retq
pushq %rax
movq 0xa6401(%rip), %rax     # 0xc1008
testq %rax, %rax
jne 0x1ac26
leaq 0xa51ad(%rip), %rdi     # 0xbfdc0
leaq 0x73d6b(%rip), %rsi     # 0x8e985
callq 0x1a909
movq %rax, 0xa63e2(%rip)     # 0xc1008
leaq 0x8(%rax), %rcx
xorl %edx, %edx
movdqa 0x73b8c(%rip), %xmm0    # 0x8e7c0
xorl %esi, %esi
movdqu (%rcx,%rsi,4), %xmm1
pshufd $0xf5, %xmm1, %xmm2     # xmm2 = xmm1[1,1,3,3]
pmuludq %xmm0, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pmuludq %xmm0, %xmm2
pshufd $0xe8, %xmm2, %xmm2     # xmm2 = xmm2[0,2,2,3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movdqu %xmm1, (%rcx,%rsi,4)
addq $0x4, %rsi
cmpq $0x80, %rsi
jne 0x1ac36
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x80, %rdx
jne 0x1ac34
movabsq $0x13000000d1, %rcx     # imm = 0x13000000D1
movq %rcx, 0x40008(%rax)
movq %rax, 0xa636d(%rip)     # 0xc1000
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3280a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a909
movq %rax, %rbx
movq (%r14), %rdi
callq 0x2e0a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b217
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 0x738a3(%rip), %rsi     # 0x8ea0b
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 0x7388e(%rip), %rsi     # 0x8ea4b
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6a90
movq 0x40010(%r14), %rdi
testq %rdi, %rdi
je 0x1b217
movl $0x20, %esi
callq 0x2235a
movq 0x40010(%r14), %rdi
movl $0x22, %esi
callq 0x2235a
movq 0x40010(%r14), %rdx
leaq 0x73869(%rip), %rsi     # 0x8ea68
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_O3/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 0x1b2ae
movq %rdi, %rbx
cmpb $0x2d, 0x18(%rdi)
jne 0x1b2a3
movl %esi, %ebp
leaq 0x10(%rbx), %r14
leaq 0x14(%rbx), %r15
leaq 0x28(%rbx), %rdi
leaq 0x2c(%rbx), %rsi
callq 0x25472
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x25472
movq 0x40(%rbx), %rdi
movslq 0x38(%rbx), %rsi
callq 0x25423
movq 0x48(%rbx), %rdi
movslq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25423
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x737c5(%rip), %rdi     # 0x8ea7a
leaq 0x737d2(%rip), %rsi     # 0x8ea8e
leaq 0x737d5(%rip), %rcx     # 0x8ea98
movl $0x399, %edx            # imm = 0x399
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x1b2eb
addq $0x8, %rdi
callq 0x19bd6
movq %rbx, %rdi
popq %rbx
jmp 0x2e0b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x1b320
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x1b2cd
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x1b30b
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, 0x20(%rsp)
movl 0x38(%rsi), %eax
testl %eax, %eax
js 0x1b440
movl 0x10(%rsi), %ebp
movl 0x28(%rsi), %r12d
xorl %r14d, %r14d
movq $-0x1, %r13
movq %rsi, 0x10(%rsp)
movl %eax, %ebx
callq 0x6790
movl %ebx, %r9d
movq 0x10(%rsp), %rdi
movq %rax, %r8
xorl %r10d, %r10d
xorl %r11d, %r11d
movq %rax, 0x18(%rsp)
movl %r14d, %eax
movq (%r8), %rcx
movq 0x40(%rdi), %rdx
movq 0x48(%rdi), %rsi
movsbq 0x1(%rdx,%r13), %rdx
movzwl (%rcx,%rdx,2), %r15d
shrl $0xa, %r15d
andl $0x1, %r15d
movsbq 0x1(%rsi,%r13), %rdx
movzwl (%rcx,%rdx,2), %ebx
shrl $0xa, %ebx
andl $0x1, %ebx
movl %r15d, %r14d
andl %ebx, %r14d
cmpl $0x1, %r14d
jne 0x1b3cb
testl %eax, %eax
cmovel %r12d, %r11d
cmovel %ebp, %r10d
jmp 0x1b42b
testl %eax, %eax
je 0x1b42b
movl %ebp, %eax
subl %r10d, %eax
movl %r12d, %ecx
subl %r11d, %ecx
cmpl %ecx, %eax
jne 0x1b44f
testl %eax, %eax
jle 0x1b42b
movl $0x28, %edi
movl %r10d, 0xc(%rsp)
movl %r11d, 0x8(%rsp)
callq 0x2dff4
movl 0x8(%rsp), %r11d
movl 0xc(%rsp), %r10d
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %rdi
movl %r10d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl %r11d, 0x8(%rax)
movl %r12d, 0xc(%rax)
movq 0x20(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, (%rax)
movq %rax, (%rdx)
movl 0x38(%rdi), %r9d
addl %r15d, %ebp
addl %ebx, %r12d
movslq %r9d, %rax
incq %r13
cmpq %rax, %r13
jl 0x1b382
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73667(%rip), %rdi     # 0x8eabd
leaq 0x73631(%rip), %rsi     # 0x8ea8e
leaq 0x7366f(%rip), %rcx     # 0x8ead3
movl $0x3db, %edx            # imm = 0x3DB
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movslq 0x38(%rdi), %r14
testq %r14, %r14
jle 0x1b7bb
movq %rdi, %rbx
callq 0x6100
movq (%rax), %rax
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
movsbq (%rcx,%rsi), %r8
movl (%rax,%r8,4), %r8d
movsbq (%rdx,%rsi), %r9
xorl %r10d, %r10d
cmpl (%rax,%r9,4), %r8d
sete %r10b
addl %r10d, %edi
incq %rsi
cmpq %rsi, %r14
jne 0x1b791
cvtsi2sd %edi, %xmm0
jmp 0x1b7bf
xorpd %xmm0, %xmm0
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movl %esi, 0x10(%rsp)
movq %rdi, %r10
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %rax
movq %rax, 0x8(%rsp)
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), %ebx
movl 0x34(%rdi), %r12d
leaq 0x732db(%rip), %rsi     # 0x8eb1d
movq %r13, %rdi
xorl %eax, %eax
pushq %r12
pushq %rbx
movq %r13, %rbx
pushq %r11
pushq 0x20(%r10)
callq 0x6a90
addq $0x20, %rsp
testl %ebp, %ebp
jle 0x1b940
movl 0x10(%rsp), %eax
cmpl %eax, %ebp
movl %ebp, 0x14(%rsp)
cmovll %ebp, %eax
movslq %eax, %r12
movq %rbx, %rdi
movq %r14, %r15
movq %r14, %rsi
movq %r12, %rdx
callq 0x23138
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
testl %r12d, %r12d
jle 0x1b8eb
callq 0x6100
movq %rax, %r13
xorl %ebp, %ebp
movq %rbx, %r14
movq (%r13), %rax
movsbq (%r15,%rbp), %rbx
movl (%rax,%rbx,4), %ecx
movq 0x8(%rsp), %rdx
movsbq (%rdx,%rbp), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x1b8d3
callq 0x6790
movq (%rax), %rax
movl $0x7c, %edi
testb $0x4, 0x1(%rax,%rbx,2)
jne 0x1b8d8
movl $0x20, %edi
movq %r14, %rbx
movq %r14, %rsi
callq 0x6930
incq %rbp
cmpq %rbp, %r12
jne 0x1b8a1
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
movq %rbx, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x23138
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
movq %r15, %r14
addq %r12, %r14
addq %r12, %r13
movq %r13, 0x8(%rsp)
movl 0x14(%rsp), %ebp
subl %r12d, %ebp
jg 0x1b864
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0xa56b9(%rip)     # 0xc1010
jne 0x1baa9
movb $0x1, 0xa56ac(%rip)     # 0xc1010
movdqa 0x72d14(%rip), %xmm0    # 0x8e680
movdqa 0x72d1c(%rip), %xmm1    # 0x8e690
movdqa 0x72024(%rip), %xmm2    # 0x8d9a0
xorl %eax, %eax
movdqa 0x7322a(%rip), %xmm3    # 0x8ebb0
movdqa 0x72022(%rip), %xmm4    # 0x8d9b0
movaps 0x7322b(%rip), %xmm5    # 0x8ebc0
movaps %xmm5, %xmm6
shufps $0xdd, %xmm5, %xmm6     # xmm6 = xmm6[1,3],xmm5[1,3]
leaq 0xa567d(%rip), %rcx     # 0xc1020
movdqa 0x72cf5(%rip), %xmm7    # 0x8e6a0
movdqa 0x7321c(%rip), %xmm8    # 0x8ebd0
movdqa %xmm2, %xmm9
pand %xmm3, %xmm9
movdqa %xmm2, %xmm10
psrld $0x1, %xmm10
pand %xmm3, %xmm10
paddd %xmm9, %xmm10
movdqa %xmm2, %xmm9
psrld $0x2, %xmm9
pand %xmm3, %xmm9
movdqa %xmm2, %xmm11
psrld $0x3, %xmm11
pand %xmm3, %xmm11
paddd %xmm9, %xmm11
paddd %xmm10, %xmm11
movdqa %xmm2, %xmm9
psrld $0x4, %xmm9
pand %xmm3, %xmm9
movdqa %xmm2, %xmm10
psrld $0x5, %xmm10
pand %xmm3, %xmm10
paddd %xmm9, %xmm10
movdqa %xmm2, %xmm9
psrld $0x6, %xmm9
pand %xmm3, %xmm9
paddd %xmm10, %xmm9
paddd %xmm11, %xmm9
movdqa %xmm1, %xmm10
pxor %xmm4, %xmm10
movdqa %xmm10, %xmm11
pcmpgtd %xmm5, %xmm11
movdqa %xmm0, %xmm12
pxor %xmm4, %xmm12
shufps $0xdd, %xmm12, %xmm10   # xmm10 = xmm10[1,3],xmm12[1,3]
pcmpgtd %xmm5, %xmm12
movdqa %xmm11, %xmm13
shufps $0x88, %xmm12, %xmm13   # xmm13 = xmm13[0,2],xmm12[0,2]
pcmpeqd %xmm6, %xmm10
pand %xmm13, %xmm10
shufps $0xdd, %xmm12, %xmm11   # xmm11 = xmm11[1,3],xmm12[1,3]
orps %xmm10, %xmm11
psubd %xmm11, %xmm9
movdqa %xmm9, (%rax,%rcx)
paddq %xmm7, %xmm1
paddq %xmm7, %xmm0
paddd %xmm8, %xmm2
addq $0x10, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x1b9b4
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bb50
addl $0x7, %edx
sarl $0x3, %edx
addl $0x7, %ecx
sarl $0x3, %ecx
movslq %edx, %rdx
movslq %ecx, %rcx
jmp 0x2c379
pushq %rax
leaq 0x73088(%rip), %rdi     # 0x8ebe0
leaq 0x7308c(%rip), %rsi     # 0x8ebeb
leaq 0x730b3(%rip), %rcx     # 0x8ec19
movl $0x5b, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x1bba2
movq %rsi, %rbx
addl $0x7, %edx
sarl $0x3, %edx
movslq %edx, %r14
movq %r14, %rsi
callq 0x2c325
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6570
leaq 0x73037(%rip), %rdi     # 0x8ebe0
leaq 0x7303b(%rip), %rsi     # 0x8ebeb
leaq 0x73094(%rip), %rcx     # 0x8ec4b
movl $0x64, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x1bc73
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rdx), %r14d
decl %r14d
movl %esi, %eax
sarl $0x3, %eax
movl %r14d, %ebp
sarl $0x3, %ebp
andl $0x7, %esi
andl $0x7, %r14d
leaq 0x7305e(%rip), %rcx     # 0x8ec7e
movb (%rsi,%rcx), %cl
cmpl %ebp, %eax
jne 0x1bc36
leaq 0x73058(%rip), %rdx     # 0x8ec86
andb (%r14,%rdx), %cl
movl %eax, %ebp
jmp 0x1bc69
movslq %eax, %rdx
orb %cl, (%rbx,%rdx)
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x1bc5e
leaq (%rbx,%rdx), %rdi
incq %rdi
movl %ebp, %edx
subl %eax, %edx
addl $-0x2, %edx
incq %rdx
movl $0xff, %esi
callq 0x63b0
leaq 0x73021(%rip), %rax     # 0x8ec86
movb (%r14,%rax), %cl
movslq %ebp, %rax
orb %cl, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bd04
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, 0xa5349(%rip)     # 0xc1010
jne 0x1bcce
callq 0x1b950
movslq %r12d, %rdx
movzbl (%rbx,%rdx), %ecx
leaq 0x72fa2(%rip), %rax     # 0x8ec7e
movzbl (%r14,%rax), %eax
andl %ecx, %eax
cmpl %ebp, %edx
jne 0x1bd07
leaq 0x72f98(%rip), %rcx     # 0x8ec86
movzbl (%r15,%rcx), %ecx
movzbl %al, %eax
andl %ecx, %eax
leaq 0xa5321(%rip), %rcx     # 0xc1020
movl (%rcx,%rax,4), %eax
jmp 0x1bd48
xorl %eax, %eax
retq
leaq 0xa5312(%rip), %rcx     # 0xc1020
movl (%rcx,%rax,4), %eax
incl %r12d
cmpl %ebp, %r12d
jge 0x1bd30
incq %rdx
movslq %ebp, %rsi
movzbl (%rbx,%rdx), %edi
addl (%rcx,%rdi,4), %eax
incq %rdx
cmpq %rdx, %rsi
jne 0x1bd1f
jmp 0x1bd33
movslq %ebp, %rsi
movzbl (%rbx,%rsi), %edx
leaq 0x72f48(%rip), %rsi     # 0x8ec86
movzbl (%r15,%rsi), %esi
andl %edx, %esi
addl (%rcx,%rsi,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitFind
int bitFind(Bits *b, int startIx, boolean val, int bitCount)
/* Find the index of the the next set bit. */
{
unsigned char notByteVal = val ? 0 : 0xff;
int iBit = startIx;
int endByte = ((bitCount-1)>>3);
int iByte;

/* scan initial byte */
while (((iBit & 7) != 0) && (iBit < bitCount))
    {
    if (bitReadOne(b, iBit) == val)
        return iBit;
    iBit++;
    }

/* scan byte at a time, if not already in last byte */
iByte = (iBit >> 3);
if (iByte < endByte)
    {
    while ((iByte < endByte) && (b[iByte] == notByteVal))
        iByte++;
    iBit = iByte << 3;
    }

/* scan last byte */
while (iBit < bitCount)
    {
    if (bitReadOne(b, iBit) == val)
        return iBit;
    iBit++;
    }
 return bitCount;  /* not found */
}

// Assembly:
movl %esi, %eax
movl %esi, %r8d
andl $0x7, %r8d
sete %sil
cmpl %ecx, %eax
setge %r9b
orb %sil, %r9b
jne 0x1bda4
leaq 0x72f06(%rip), %rsi     # 0x8ec76
movl %eax, %r9d
sarl $0x3, %r9d
movslq %r9d, %r9
movl %r8d, %r8d
movb (%r8,%rsi), %r8b
xorl %r10d, %r10d
testb %r8b, (%rdi,%r9)
setne %r10b
cmpl %edx, %r10d
je 0x1be2a
incl %eax
cmpl %ecx, %eax
jge 0x1bda4
movl %eax, %r8d
andl $0x7, %r8d
jne 0x1bd70
pushq %rbx
leal -0x1(%rcx), %esi
sarl $0x3, %esi
movl %eax, %r8d
sarl $0x3, %r8d
cmpl %esi, %r8d
jge 0x1bdf1
xorl %eax, %eax
testl %edx, %edx
movl $0xff, %r9d
cmovnel %eax, %r9d
movslq %r8d, %rbx
movslq %esi, %r10
leaq (%rdi,%rbx), %r11
subq %rbx, %r10
movzbl (%r11,%rax), %ebx
cmpl %ebx, %r9d
jne 0x1bde6
incq %rax
cmpq %rax, %r10
jne 0x1bdd2
jmp 0x1bdec
addl %eax, %r8d
movl %r8d, %esi
shll $0x3, %esi
movl %esi, %eax
cmpl %ecx, %eax
jge 0x1be27
leaq 0x72e7a(%rip), %rsi     # 0x8ec76
movl %eax, %r8d
sarl $0x3, %r8d
movslq %r8d, %r8
movl %eax, %r9d
andl $0x7, %r9d
movb (%r9,%rsi), %r9b
xorl %r10d, %r10d
testb %r9b, (%rdi,%r8)
setne %r10b
cmpl %edx, %r10d
je 0x1be29
incl %eax
cmpl %eax, %ecx
jne 0x1bdfc
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitClearRange
void bitClearRange(Bits *b, int startIx, int bitCount)
/* Clear 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] = 0x00;
b[endByte] &= ~rightMask[endBits];
}

// Assembly:
testl %edx, %edx
jle 0x1becf
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rdx), %r14d
decl %r14d
movl %esi, %eax
sarl $0x3, %eax
movl %r14d, %ebp
sarl $0x3, %ebp
andl $0x7, %esi
andl $0x7, %r14d
leaq 0x72e03(%rip), %rcx     # 0x8ec7e
movb (%rsi,%rcx), %cl
cmpl %ebp, %eax
jne 0x1be91
leaq 0x72dfd(%rip), %rdx     # 0x8ec86
andb (%r14,%rdx), %cl
movl %eax, %ebp
jmp 0x1bec3
notb %cl
movslq %eax, %rdx
andb %cl, (%rbx,%rdx)
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x1beb8
leaq (%rbx,%rdx), %rdi
incq %rdi
movl %ebp, %edx
subl %eax, %edx
addl $-0x2, %edx
incq %rdx
xorl %esi, %esi
callq 0x63b0
leaq 0x72dc7(%rip), %rax     # 0x8ec86
movb (%r14,%rax), %cl
notb %cl
movslq %ebp, %rax
andb %cl, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitAnd
void bitAnd(Bits *a, Bits *b, int bitCount)
/* And two bitmaps.  Put result in a. */
{
int byteCount = ((bitCount+7)>>3);
while (--byteCount >= 0)
    {
    *a = (*a & *b++);
    a++;
    }
}

// Assembly:
addl $0x7, %edx
sarl $0x3, %edx
testl %edx, %edx
jle 0x1beee
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
andb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
ja 0x1bede
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitAndCount
int bitAndCount(Bits *a, Bits *b, int bitCount)
// Without altering 2 bitmaps, count the AND bits.
{
int byteCount = ((bitCount+7)>>3);
int count = 0;
if (!inittedBitsInByte)
    bitsInByteInit();
while (--byteCount >= 0)
    count += bitsInByte[(*a++ & *b++)];

return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addl $0x7, %ebx
sarl $0x3, %ebx
cmpb $0x0, 0xa5107(%rip)     # 0xc1010
jne 0x1bf10
callq 0x1b950
testl %ebx, %ebx
jle 0x1bf3c
incl %ebx
xorl %ecx, %ecx
leaq 0xa5101(%rip), %rdx     # 0xc1020
xorl %eax, %eax
movzbl (%r15,%rcx), %esi
movzbl (%r14,%rcx), %edi
andl %esi, %edi
addl (%rdx,%rdi,4), %eax
decl %ebx
incq %rcx
cmpl $0x1, %ebx
ja 0x1bf21
jmp 0x1bf3e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitOr
void bitOr(Bits *a, Bits *b, int bitCount)
/* Or two bitmaps.  Put result in a. */
{
int byteCount = ((bitCount+7)>>3);
while (--byteCount >= 0)
    {
    *a = (*a | *b++);
    a++;
    }
}

// Assembly:
addl $0x7, %edx
sarl $0x3, %edx
testl %edx, %edx
jle 0x1bf62
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
orb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
ja 0x1bf52
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitOrCount
int bitOrCount(Bits *a, Bits *b, int bitCount)
// Without altering 2 bitmaps, count the OR'd bits.
{
int byteCount = ((bitCount+7)>>3);
int count = 0;
if (!inittedBitsInByte)
    bitsInByteInit();
while (--byteCount >= 0)
    count += bitsInByte[(*a++ | *b++)];

return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addl $0x7, %ebx
sarl $0x3, %ebx
cmpb $0x0, 0xa5093(%rip)     # 0xc1010
jne 0x1bf84
callq 0x1b950
testl %ebx, %ebx
jle 0x1bfb0
incl %ebx
xorl %ecx, %ecx
leaq 0xa508d(%rip), %rdx     # 0xc1020
xorl %eax, %eax
movb (%r14,%rcx), %sil
orb (%r15,%rcx), %sil
movzbl %sil, %esi
addl (%rdx,%rsi,4), %eax
decl %ebx
incq %rcx
cmpl $0x1, %ebx
ja 0x1bf95
jmp 0x1bfb2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitXor
void bitXor(Bits *a, Bits *b, int bitCount)
{
int byteCount = ((bitCount+7)>>3);
while (--byteCount >= 0)
    {
    *a = (*a ^ *b++);
    a++;
    }
}

// Assembly:
addl $0x7, %edx
sarl $0x3, %edx
testl %edx, %edx
jle 0x1bfd6
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
ja 0x1bfc6
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitNot
void bitNot(Bits *a, int bitCount)
/* Flip all bits in a. */
{
int byteCount = ((bitCount+7)>>3);
while (--byteCount >= 0)
    {
    *a = ~*a;
    a++;
    }
}

// Assembly:
addl $0x7, %esi
sarl $0x3, %esi
testl %esi, %esi
jle 0x1c044
incl %esi
notb (%rdi)
incq %rdi
decl %esi
cmpl $0x1, %esi
ja 0x1c038
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitReverseRange
void bitReverseRange(Bits *bits, int startIx, int bitCount)
// Reverses bits in range (e.g. 110010 becomes 010011)
{
if (bitCount <= 0)
    return;
int ixA = startIx;
int ixB = (startIx + bitCount - 1);
for ( ;ixA < ixB; ixA++, ixB--)
    {
    boolean bitA = bitReadOne(bits, ixA);
    boolean bitB = bitReadOne(bits, ixB);
    if (!bitA && bitB)
        {
        bitSetOne(  bits, ixA);
        bitClearOne(bits, ixB);
        }
    else if (bitA && !bitB)
        {
        bitClearOne(bits, ixA);
        bitSetOne(  bits, ixB);
        }
    }
}

// Assembly:
testl %edx, %edx
jle 0x1c0c5
leal (%rdx,%rsi), %eax
decl %eax
cmpl %esi, %eax
jle 0x1c0c5
pushq %rbx
leaq 0x72c1c(%rip), %rcx     # 0x8ec76
movl %esi, %edx
sarl $0x3, %edx
movslq %edx, %r9
movb (%rdi,%r9), %r10b
movl %esi, %edx
andl $0x7, %edx
movb (%rdx,%rcx), %r11b
movl %eax, %edx
sarl $0x3, %edx
movslq %edx, %rdx
movl %eax, %r8d
andl $0x7, %r8d
movb (%r8,%rcx), %r8b
movb (%rdi,%rdx), %bl
andb %r8b, %bl
testb %r10b, %r11b
jne 0x1c0a1
testb %bl, %bl
je 0x1c0a1
orb %r10b, %r11b
movb %r11b, (%rdi,%r9)
notb %r8b
andb (%rdi,%rdx), %r8b
jmp 0x1c0b8
testb %r10b, %r11b
je 0x1c0bc
testb %bl, %bl
jne 0x1c0bc
notb %r11b
andb %r11b, %r10b
movb %r10b, (%rdi,%r9)
orb (%rdi,%rdx), %r8b
movb %r8b, (%rdi,%rdx)
incl %esi
decl %eax
cmpl %eax, %esi
jl 0x1c05a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitPrint
void bitPrint(Bits *a, int startIx, int bitCount, FILE* out)
/* Print part or all of bit map as a string of 0s and 1s.  Mostly useful for
 * debugging */
{
int i;
for (i = startIx; i < bitCount; i++)
    {
    if (bitReadOne(a, i))
        fputc('1', out);
    else
        fputc('0', out);
    }
fputc('\n', out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
cmpl %edx, %esi
jge 0x1c115
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x72b92(%rip), %r12     # 0x8ec76
movl %r14d, %eax
sarl $0x3, %eax
cltq
movl %r14d, %ecx
andl $0x7, %ecx
movb (%rcx,%r12), %cl
andb (%r15,%rax), %cl
cmpb $0x1, %cl
movl $0x31, %edi
sbbl $0x0, %edi
movq %rbx, %rsi
callq 0x6930
incl %r14d
cmpl %r14d, %ebp
jne 0x1c0e4
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6930
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/bits.c
// Function: bitsOut
void bitsOut(FILE* out, Bits *bits, int startIx, int bitCount, boolean onlyOnes)
// Print part or all of bit map as a string of 0s and 1s.
// If onlyOnes, enclose result in [] and use ' ' instead of '0'.
{
if (onlyOnes)
    fputc('[', out);

int ix = startIx;
for ( ; ix < bitCount; ix++)
    {
    if (bitReadOne(bits, ix))
        fputc('1', out);
    else
        {
        if (onlyOnes)
            fputc(' ', out);
        else
            fputc('0', out);
        }
    }
if (onlyOnes)
    fputc(']', out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl %r8d, 0x4(%rsp)
testl %r8d, %r8d
je 0x1c158
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x6930
cmpl %r14d, %r15d
jge 0x1c1a7
xorl %r13d, %r13d
cmpl $0x0, 0x4(%rsp)
sete %r13b
shll $0x4, %r13d
orl $0x20, %r13d
leaq 0x72afe(%rip), %rbp     # 0x8ec76
movl %r15d, %eax
sarl $0x3, %eax
cltq
movl %r15d, %ecx
andl $0x7, %ecx
movb (%rcx,%rbp), %cl
movl %r13d, %edi
testb %cl, (%r12,%rax)
je 0x1c197
movl $0x31, %edi
movq %rbx, %rsi
callq 0x6930
incl %r15d
cmpl %r15d, %r14d
jne 0x1c178
cmpl $0x0, 0x4(%rsp)
je 0x1c1c9
movl $0x5d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6930
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/lib/bits.c
// Function: bitsIn
Bits *bitsIn(struct lm *lm,char *bitString, int len)
// Returns a bitmap from a string of 1s and 0s.  Any non-zero, non-blank char sets a bit.
// Returned bitmap is the size of len even if that is longer than the string.
// Optionally supply local memory.  Note does NOT handle enclosing []s printed with bitsOut().
{
if (bitString == NULL || len == 0)
    return NULL;

Bits *bits = NULL;
if (lm != NULL)
    bits = lmBitAlloc(lm,len);
else
    bits = bitAlloc(len);

int ix = 0;
for ( ;ix < len && bitString[ix] != '\0'; ix++)
    {
    if (bitString[ix] != '0' && bitString[ix] != ' ')
        bitSetOne(bits, ix);
    }
return bits;
}

// Assembly:
testq %rsi, %rsi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
je 0x1c1ea
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
leal 0x7(%r14), %eax
sarl $0x3, %eax
movslq %eax, %rsi
testq %rdi, %rdi
je 0x1c20a
callq 0x2c325
jmp 0x1c212
movq %rsi, %rdi
callq 0x2de63
testl %r14d, %r14d
jle 0x1c251
movl %r14d, %ecx
xorl %edx, %edx
leaq 0x72a53(%rip), %rsi     # 0x8ec76
movzbl (%rbx,%rdx), %edi
cmpl $0x20, %edi
je 0x1c249
cmpl $0x30, %edi
je 0x1c249
testl %edi, %edi
je 0x1c251
movl %edx, %edi
andl $0x7, %edi
movb (%rdi,%rsi), %dil
movl %edx, %r8d
shrl $0x3, %r8d
orb %dil, (%rax,%r8)
incq %rdx
cmpq %rdx, %rcx
jne 0x1c223
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/binRange.c
// Function: binFromRange
int binFromRange(int start, int end)
/* return bin that this start-end segment is in */
{
if (end <= BINRANGE_MAXEND_512M)
    return binFromRangeStandard(start, end);
else
    return binFromRangeExtended(start, end);
}

// Assembly:
pushq %rbx
movl %esi, %edx
movl %edi, %esi
leal -0x1(%rdx), %ebx
movl %edi, %eax
sarl $0x11, %eax
cmpl $0x20000000, %edx       # imm = 0x20000000
jg 0x1c313
sarl $0x11, %ebx
xorl %ecx, %ecx
cmpl %ebx, %eax
je 0x1c33d
sarl $0x3, %eax
sarl $0x3, %ebx
addq $0x4, %rcx
cmpl $0x14, %ecx
jne 0x1c2f7
leaq 0x72ab2(%rip), %rdi     # 0x8edc3
jmp 0x1c332
shrl $0x11, %ebx
xorl %ecx, %ecx
cmpl %ebx, %eax
je 0x1c349
sarl $0x3, %eax
shrl $0x3, %ebx
addq $0x4, %rcx
cmpl $0x18, %ecx
jne 0x1c318
leaq 0x72ac8(%rip), %rdi     # 0x8edfa
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x26e94
jmp 0x1c35b
leaq 0x72b0c(%rip), %rax     # 0x8ee50
addl (%rcx,%rax), %ebx
jmp 0x1c35b
leaq 0x72ae0(%rip), %rax     # 0x8ee30
movl (%rcx,%rax), %eax
addl %eax, %ebx
addl $0x1249, %ebx           # imm = 0x1249
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/binRange.c
// Function: binKeeperNew
struct binKeeper *binKeeperNew(int minPos, int maxPos)
/* Create new binKeeper that can cover range. */
{
int binCount;
struct binKeeper *bk;
if (minPos < 0 || maxPos < 0 || minPos > maxPos)
    errAbort("bad range %d,%d in binKeeperNew", minPos, maxPos);

binCount = binFromRangeBinKeeperExtended(maxPos-1, maxPos) + 1;
AllocVar(bk);
bk->minPos = minPos;
bk->maxPos = maxPos;
bk->binCount = binCount;
AllocArray(bk->binLists, binCount);
return bk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl %esi, %eax
orl %edi, %eax
setns %al
cmpl %esi, %edi
setle %cl
testb %al, %cl
jne 0x1c38d
leaq 0x729a9(%rip), %rdi     # 0x8ed2b
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x26e94
leal -0x1(%rbx), %edi
movl %ebx, %esi
callq 0x1c3d5
movl %eax, %r14d
leal 0x1(%r14), %r12d
movl $0x20, %edi
callq 0x2dff4
movq %rax, %r15
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movl %r12d, 0x10(%rax)
movslq %r14d, %rax
leaq 0x8(,%rax,8), %rdi
callq 0x2de63
movq %rax, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/binRange.c
// Function: binFromRangeBinKeeperExtended
static int binFromRangeBinKeeperExtended(int start, int end)
/* This is just like binFromRangeExtended() above, but it doesn't limit
 * the answers to the range from _binOffsetOldToExtended and up.
 *	It simply uses the whole new bin scheme as if it was the only
 *	one.
 */
{
int startBin = start, endBin = end-1, i;
startBin >>= _binFirstShift;
endBin >>= _binFirstShift;
for (i=0; i<ArraySize(binOffsetsExtended); ++i)
    {
    if (startBin == endBin)
	return binOffsetsExtended[i] + startBin;
    startBin >>= _binNextShift;
    endBin >>= _binNextShift;
    }
errAbort("start %d, end %d out of range in findBin (max is 2Gb)", start, end);
return 0;
}

// Assembly:
pushq %rbx
movl %esi, %edx
movl %edi, %esi
leal -0x1(%rdx), %ebx
movl %edi, %eax
sarl $0x11, %eax
sarl $0x11, %ebx
xorl %ecx, %ecx
cmpl %ebx, %eax
je 0x1c40c
sarl $0x3, %eax
sarl $0x3, %ebx
addq $0x4, %rcx
cmpl $0x18, %ecx
jne 0x1c3e7
leaq 0x729f9(%rip), %rdi     # 0x8edfa
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x26e94
jmp 0x1c416
leaq 0x72a1d(%rip), %rax     # 0x8ee30
addl (%rcx,%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/binRange.c
// Function: binKeeperFree
void binKeeperFree(struct binKeeper **pBk)
/* Free up a bin keeper. */
{
struct binKeeper *bk = *pBk;
if (bk != NULL)
    {
    int i;
    for (i=0; i<bk->binCount; ++i)
	slFreeList(&bk->binLists[i]);
    freeMem(bk->binLists);
    freez(pBk);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x1c472
movq %rdi, %rbx
cmpl $0x0, 0x10(%r14)
jle 0x1c456
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
addq %r15, %rdi
callq 0x20196
incq %r12
movslq 0x10(%r14), %rax
addq $0x8, %r15
cmpq %rax, %r12
jl 0x1c43a
movq 0x18(%r14), %rdi
callq 0x2e0a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/binRange.c
// Function: binKeeperAdd
void binKeeperAdd(struct binKeeper *bk, int start, int end, void *val)
/* Add item to binKeeper. */ 
{
int bin;
struct binElement *el;
if (start < bk->minPos || end > bk->maxPos || start > end)
    errAbort("(%d %d) out of range (%d %d) in binKeeperAdd", 
    	start, end, bk->minPos, bk->maxPos);
bin = binFromRangeBinKeeperExtended(start, end);
assert(bin < bk->binCount);
AllocVar(el);
el->start = start;
el->end = end;
el->val = val;
slAddHead(&bk->binLists[bin], el);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %r8d
cmpl %esi, %ecx
jg 0x1c4ac
cmpl %ebp, %r8d
setge %al
cmpl %ebp, %r15d
setle %dl
testb %al, %dl
jne 0x1c4bf
leaq 0x72898(%rip), %rdi     # 0x8ed4b
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x26e94
movl %r15d, %edi
movl %ebp, %esi
callq 0x1c3d5
cmpl 0x10(%r14), %eax
jge 0x1c502
movl %eax, %r12d
movl $0x18, %edi
callq 0x2dff4
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
movq 0x18(%r14), %rcx
movslq %r12d, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%rax)
movq %rax, (%rcx,%rdx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7286f(%rip), %rdi     # 0x8ed78
leaq 0x727b2(%rip), %rsi     # 0x8ecc2
leaq 0x72874(%rip), %rcx     # 0x8ed8b
movl $0xb4, %edx
callq 0x6460