LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x25399
movl %eax, %ebp
movq 0x40(%r14), %rdi
movl 0x38(%r14), %esi
callq 0x25399
movl 0x2c(%r14), %edx
subl 0x28(%r14), %edx
cmpl %edx, %ebp
jne 0x19d5f
movl 0x14(%r14), %edx
subl 0x10(%r14), %edx
movl $0x1, %r14d
cmpl %edx, %eax
je 0x19d79
movl 0x28(%rbx), %ecx
movq 0x8(%rbx), %r8
leaq 0x74ab0(%rip), %rdi     # 0x8e81d
xorl %r14d, %r14d
movl %ebp, %esi
xorl %eax, %eax
callq 0x268ca
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
jle 0x19dae
addq $0x8, %rdi
movl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
movsbq (%rsi,%r8), %r9
movsbq (%rdx,%r8), %r10
shlq $0xa, %r9
addq %rdi, %r9
addl (%r9,%r10,4), %eax
incq %r8
cmpq %r8, %rcx
jne 0x19d90
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x4(%rsp)
movq %rdi, %r15
movl 0x40008(%rdi), %r12d
movl 0x4000c(%rdi), %r13d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x25b5c
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x19e44
addq $0x8, %r15
addl %r13d, %r12d
movl %eax, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
movsbq (%r14,%rcx), %rsi
cmpq $0x2d, %rsi
sete %r8b
movb (%rbx,%rcx), %dil
cmpb $0x2d, %dil
sete %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x19e22
testl %edx, %edx
je 0x19e34
subl %r13d, %ebp
jmp 0x19e37
movsbq %dil, %rdx
shlq $0xa, %rsi
addq %r15, %rsi
addl (%rsi,%rdx,4), %ebp
xorl %edx, %edx
jmp 0x19e3c
subl %r12d, %ebp
movl $0x1, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x19df7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movl 0x40008(%rdi), %eax
movl %eax, 0x4(%rsp)
movl 0x4000c(%rdi), %r13d
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x25b5c
testl %r12d, %r12d
jle 0x19f61
addl %r13d, 0x4(%rsp)
addq $0x8, %r15
movl %r12d, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
movsbq (%r14,%rcx), %rsi
cmpq $0x2d, %rsi
sete %r8b
movsbq (%rbx,%rcx), %rdi
cmpq $0x2d, %rdi
sete %r9b
movl %r8d, %r10d
orb %r9b, %r10b
notb %r10b
andb %r9b, %r8b
orb %r10b, %r8b
testb $0x1, %r8b
jne 0x19f35
cmpb $0x2d, %dil
sete %r8b
cmpb $0x2d, %sil
sete %r10b
cmpb $0x61, %dil
setl %r11b
cmpb $0x61, %sil
setl %r9b
testb %r11b, %r10b
jne 0x19f43
andb %r8b, %r9b
jne 0x19f43
shlq $0xa, %rsi
addq %r15, %rsi
addl (%rsi,%rdi,4), %ebp
xorl %edx, %edx
jmp 0x19f55
testl %edx, %edx
je 0x19f4c
subl %r13d, %ebp
jmp 0x19f50
subl 0x4(%rsp), %ebp
movl $0x1, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x19edc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/axt.c
// Function: axtScoreDnaDefault
int axtScoreDnaDefault(struct axt *axt)
/* Score DNA-based axt using default scheme. */
{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeDefault();
return axtScore(axt, ss);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xa7006(%rip)     # 0xc0fb0
jne 0x19fb8
callq 0x1a28d
movq %rax, 0xa6ff8(%rip)     # 0xc0fb0
movq 0xa6ff1(%rip), %rdi     # 0xc0fb0
movl 0x38(%rbx), %esi
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %rcx
popq %rbx
jmp 0x19db1
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/axt.c
// Function: axtScoreProteinDefault
int axtScoreProteinDefault(struct axt *axt)
/* Score protein-based axt using default scheme. */
{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeProteinDefault();
return axtScore(axt, ss);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xa6fdc(%rip)     # 0xc0fb8
jne 0x19fea
callq 0x1a986
movq %rax, 0xa6fce(%rip)     # 0xc0fb8
movq 0xa6fc7(%rip), %rdi     # 0xc0fb8
movl 0x38(%rbx), %esi
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %rcx
popq %rbx
jmp 0x19db1
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edx
callq 0x25363
subl 0x48(%rbx), %eax
movq 0x40(%rbx), %rdi
movl %eax, %esi
callq 0x25399
addl 0x10(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6d2b(%rip), %rbx     # 0xc0fc0
testq %rbx, %rbx
jne 0x1a361
cmpq $0x0, 0xa6d22(%rip)     # 0xc0fc8
jne 0x1a2b9
movl $0x40018, %edi          # imm = 0x40018
callq 0x2dc95
movq %rax, 0xa6d0f(%rip)     # 0xc0fc8
movq 0xa6d08(%rip), %rbx     # 0xc0fc8
movl $0x5b, %eax
movl %eax, 0x1858c(%rbx)
movl $0xffffff8e, %ecx       # imm = 0xFFFFFF8E
movl %ecx, 0x18594(%rbx)
movl $0xffffffe1, %edx       # imm = 0xFFFFFFE1
movl %edx, 0x185a4(%rbx)
movl $0xffffff85, %esi       # imm = 0xFFFFFF85
movl %esi, 0x185d8(%rbx)
movl %ecx, 0x18d8c(%rbx)
movl $0x64, %edi
movl %edi, 0x18d94(%rbx)
movl $0xffffff83, %r8d       # imm = 0xFFFFFF83
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 0x1a366
movabsq $0x1e00000190, %rax     # imm = 0x1E00000190
movq %rax, 0x40008(%rbx)
movq %rbx, 0xa6c5f(%rip)     # 0xc0fc0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74789(%rip), %rcx     # 0x8eb00
movq %rax, %rdx
shlq $0x4, %rdx
movq %rcx, %rsi
xorl %r8d, %r8d
movl %r8d, %r9d
orl %eax, %r9d
je 0x1a3ce
xorl %r9d, %r9d
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
movslq (%rbx,%rcx), %r14
movl (%r10,%r14,4), %ebp
movslq (%rsi,%rbx), %r14
movl %ebp, (%r11,%r14,4)
addq $0x4, %rbx
cmpq $0x10, %rbx
jne 0x1a3ab
incq %r9
cmpq $0x4, %r9
jne 0x1a38f
leaq 0x1(%r8), %r9
addq $0x10, %rsi
testq %r8, %r8
movq %r9, %r8
je 0x1a384
leaq 0x1(%rax), %rdx
testq %rax, %rax
movq %rdx, %rax
je 0x1a377
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6bd2(%rip), %r12     # 0xc0fd0
testq %r12, %r12
jne 0x1a4d5
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movl %edi, %r14d
cmpq $0x0, 0xa6bbf(%rip)     # 0xc0fd8
jne 0x1a42c
movl $0x40018, %edi          # imm = 0x40018
callq 0x2dc95
movq %rax, 0xa6bac(%rip)     # 0xc0fd8
movq 0xa6ba5(%rip), %r12     # 0xc0fd8
movl %r14d, 0x1858c(%r12)
negl %r15d
movl %r15d, 0x18594(%r12)
movl %r15d, 0x185a4(%r12)
movl %r15d, 0x185d8(%r12)
movl %r15d, 0x18d8c(%r12)
movl %r14d, 0x18d94(%r12)
movl %r15d, 0x18da4(%r12)
movl %r15d, 0x18dd8(%r12)
movl %r15d, 0x19d8c(%r12)
movl %r15d, 0x19d94(%r12)
movl %r14d, 0x19da4(%r12)
movl %r15d, 0x19dd8(%r12)
movl %r15d, 0x1d18c(%r12)
movl %r15d, 0x1d194(%r12)
movl %r15d, 0x1d1a4(%r12)
movl %r14d, 0x1d1d8(%r12)
movq %r12, %rdi
callq 0x1a366
movl %ebp, 0x40008(%r12)
movl %ebx, 0x4000c(%r12)
movq %r12, 0xa6afb(%rip)     # 0xc0fd0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a28d
movq %rax, %rbx
leaq 0x75474(%rip), %rsi     # 0x8f9e7
movq %rsp, %rdx
movq %r15, %rdi
movl $0x20, %ecx
callq 0x22314
cmpl $0x10, %eax
jne 0x1a6a5
testq %rbx, %rbx
je 0x1a6a3
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 0x1a6a5
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_O1/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 0xa6673(%rip), %rax     # 0xc1000
testq %rax, %rax
je 0x1a993
retq
pushq %rax
cmpq $0x0, 0xa666c(%rip)     # 0xc1008
jne 0x1a9b8
leaq 0xa541b(%rip), %rdi     # 0xbfdc0
leaq 0x73f39(%rip), %rsi     # 0x8e8e5
callq 0x1a6b6
movq %rax, 0xa6650(%rip)     # 0xc1008
movq 0xa6649(%rip), %rax     # 0xc1008
addq $0x8, %rax
xorl %ecx, %ecx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
leal (%rsi,%rsi,8), %edi
leal (%rsi,%rdi,2), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq $0x80, %rdx
jne 0x1a9c7
incq %rcx
addq $0x400, %rax            # imm = 0x400
cmpq $0x80, %rcx
jne 0x1a9c5
movq 0xa6610(%rip), %rax     # 0xc1008
movabsq $0x13000000d1, %rcx     # imm = 0x13000000D1
movq %rcx, 0x40008(%rax)
movq %rax, 0xa65f0(%rip)     # 0xc1000
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32524
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a6b6
movq %rax, %rbx
movq (%r14), %rdi
callq 0x2dd41
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b00c
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 0x73a10(%rip), %rsi     # 0x8e96d
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 0x739fb(%rip), %rsi     # 0x8e9ad
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6a90
movq 0x40010(%r14), %rdi
testq %rdi, %rdi
je 0x1b00c
movl $0x20, %esi
callq 0x2200a
movq 0x40010(%r14), %rdi
movl $0x22, %esi
callq 0x2200a
movq 0x40010(%r14), %rdx
leaq 0x739d6(%rip), %rsi     # 0x8e9ca
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_O1/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
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movups %xmm1, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
cmpb $0x2d, 0x30(%rdi)
je 0x1b0a4
movq %rdi, %rbx
cmpb $0x2d, 0x18(%rdi)
jne 0x1b099
movl %esi, %ebp
leaq 0x10(%rbx), %r14
leaq 0x14(%rbx), %r15
leaq 0x28(%rbx), %rdi
leaq 0x2c(%rbx), %rsi
callq 0x25145
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x25145
movq 0x40(%rbx), %rdi
movslq 0x38(%rbx), %rsi
callq 0x250f6
movq 0x48(%rbx), %rdi
movslq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x250f6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73931(%rip), %rdi     # 0x8e9dc
leaq 0x7393e(%rip), %rsi     # 0x8e9f0
leaq 0x73941(%rip), %rcx     # 0x8e9fa
movl $0x399, %edx            # imm = 0x399
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/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 0x1b0e1
addq $0x8, %rdi
callq 0x1997a
movq %rbx, %rdi
popq %rbx
jmp 0x2dd51
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b116
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x1b0c3
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x1b101
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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)
cmpl $0x0, 0x38(%rsi)
js 0x1b22d
movl 0x10(%rsi), %ebp
movl 0x28(%rsi), %r12d
xorl %r15d, %r15d
movq $-0x1, %r13
movq %rsi, 0x10(%rsp)
callq 0x6790
movq 0x10(%rsp), %rdi
movq %rax, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %rax, 0x18(%rsp)
movl %r15d, %eax
movq (%r8), %rcx
movq 0x40(%rdi), %rdx
movq 0x48(%rdi), %rsi
movsbq 0x1(%rdx,%r13), %rdx
movzwl (%rcx,%rdx,2), %r14d
shrl $0xa, %r14d
andl $0x1, %r14d
movsbq 0x1(%rsi,%r13), %rdx
movzwl (%rcx,%rdx,2), %ebx
shrl $0xa, %ebx
andl $0x1, %ebx
movl %r14d, %r15d
andl %ebx, %r15d
cmpl $0x1, %r15d
jne 0x1b1bb
testl %eax, %eax
cmovel %r12d, %r10d
cmovel %ebp, %r9d
jmp 0x1b217
testl %eax, %eax
je 0x1b217
movl %ebp, %eax
subl %r9d, %eax
movl %r12d, %ecx
subl %r10d, %ecx
cmpl %ecx, %eax
jne 0x1b23c
testl %eax, %eax
jle 0x1b217
movl $0x28, %edi
movl %r9d, 0xc(%rsp)
movl %r10d, 0x8(%rsp)
callq 0x2dc95
movl 0x8(%rsp), %r10d
movl 0xc(%rsp), %r9d
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %rdi
movl %r9d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl %r10d, 0x8(%rax)
movl %r12d, 0xc(%rax)
movq 0x20(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, (%rax)
movq %rax, (%rdx)
addl %r14d, %ebp
addl %ebx, %r12d
movslq 0x38(%rdi), %rax
incq %r13
cmpq %rax, %r13
jl 0x1b172
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x737dc(%rip), %rdi     # 0x8ea1f
leaq 0x737a6(%rip), %rsi     # 0x8e9f0
leaq 0x737e4(%rip), %rcx     # 0x8ea35
movl $0x3db, %edx            # imm = 0x3DB
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/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 0x1b550
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 0x1b526
cvtsi2sd %edi, %xmm0
jmp 0x1b554
xorpd %xmm0, %xmm0
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x734a8(%rip), %rsi     # 0x8ea7f
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 0x1b6d5
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 0x22e1e
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
testl %r12d, %r12d
jle 0x1b680
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 0x1b668
callq 0x6790
movq (%rax), %rax
movl $0x7c, %edi
testb $0x4, 0x1(%rax,%rbx,2)
jne 0x1b66d
movl $0x20, %edi
movq %r14, %rbx
movq %r14, %rsi
callq 0x6930
incq %rbp
cmpq %rbp, %r12
jne 0x1b636
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
movq %rbx, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x22e1e
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 0x1b5f9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/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, 0xa5925(%rip)     # 0xc1010
jne 0x1b748
movb $0x1, 0xa591c(%rip)     # 0xc1010
leaq 0xa5925(%rip), %rax     # 0xc1020
xorl %ecx, %ecx
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
cmpq $0x100, %rcx            # imm = 0x100
jne 0x1b6fd
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b7ef
addl $0x7, %edx
sarl $0x3, %edx
addl $0x7, %ecx
sarl $0x3, %ecx
movslq %edx, %rdx
movslq %ecx, %rcx
jmp 0x2bff7
pushq %rax
leaq 0x73329(%rip), %rdi     # 0x8eb20
leaq 0x7332d(%rip), %rsi     # 0x8eb2b
leaq 0x73354(%rip), %rcx     # 0x8eb59
movl $0x5b, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/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 0x1b841
movq %rsi, %rbx
addl $0x7, %edx
sarl $0x3, %edx
movslq %edx, %r14
movq %r14, %rsi
callq 0x2bfa9
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6570
leaq 0x732d8(%rip), %rdi     # 0x8eb20
leaq 0x732dc(%rip), %rsi     # 0x8eb2b
leaq 0x73335(%rip), %rcx     # 0x8eb8b
movl $0x64, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/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 0x1b912
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 0x732ff(%rip), %rcx     # 0x8ebbe
movb (%rsi,%rcx), %cl
cmpl %ebp, %eax
jne 0x1b8d5
leaq 0x732f9(%rip), %rdx     # 0x8ebc6
andb (%r14,%rdx), %cl
movl %eax, %ebp
jmp 0x1b908
movslq %eax, %rdx
orb %cl, (%rbx,%rdx)
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x1b8fd
leaq (%rbx,%rdx), %rdi
incq %rdi
movl %ebp, %edx
subl %eax, %edx
addl $-0x2, %edx
incq %rdx
movl $0xff, %esi
callq 0x63b0
leaq 0x732c2(%rip), %rax     # 0x8ebc6
movb (%r14,%rax), %cl
movslq %ebp, %rax
orb %cl, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b9a3
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%rdx), %r15d
decl %r15d
movl %esi, %ebp
sarl $0x3, %ebp
movl %r15d, %r12d
sarl $0x3, %r12d
andl $0x7, %r14d
andl $0x7, %r15d
cmpb $0x0, 0xa56ab(%rip)     # 0xc1010
jne 0x1b96c
callq 0x1b6e4
movslq %ebp, %rcx
movzbl (%rbx,%rcx), %edx
leaq 0x73244(%rip), %rax     # 0x8ebbe
movzbl (%r14,%rax), %eax
andl %edx, %eax
cmpl %r12d, %ecx
jne 0x1b9a6
leaq 0x73239(%rip), %rcx     # 0x8ebc6
movzbl (%r15,%rcx), %ecx
movzbl %al, %eax
andl %ecx, %eax
leaq 0xa5682(%rip), %rcx     # 0xc1020
movl (%rcx,%rax,4), %eax
jmp 0x1b9e1
xorl %eax, %eax
retq
leaq 0xa5673(%rip), %rcx     # 0xc1020
movl (%rcx,%rax,4), %eax
incl %ebp
movslq %r12d, %rdx
cmpl %r12d, %ebp
jge 0x1b9cc
movslq %ebp, %rsi
movzbl (%rbx,%rsi), %edi
addl (%rcx,%rdi,4), %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x1b9bd
movzbl (%rbx,%rdx), %edx
leaq 0x731ef(%rip), %rsi     # 0x8ebc6
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_O1/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 0x1ba3d
leaq 0x731ad(%rip), %rsi     # 0x8ebb6
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 0x1bac3
incl %eax
cmpl %ecx, %eax
jge 0x1ba3d
movl %eax, %r8d
andl $0x7, %r8d
jne 0x1ba09
pushq %rbx
leal -0x1(%rcx), %esi
sarl $0x3, %esi
movl %eax, %r8d
sarl $0x3, %r8d
cmpl %esi, %r8d
jge 0x1ba8a
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 0x1ba7f
incq %rax
cmpq %rax, %r10
jne 0x1ba6b
jmp 0x1ba85
addl %eax, %r8d
movl %r8d, %esi
shll $0x3, %esi
movl %esi, %eax
cmpl %ecx, %eax
jge 0x1bac0
leaq 0x73121(%rip), %rsi     # 0x8ebb6
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 0x1bac2
incl %eax
cmpl %eax, %ecx
jne 0x1ba95
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bb68
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 0x730aa(%rip), %rcx     # 0x8ebbe
movb (%rsi,%rcx), %cl
cmpl %ebp, %eax
jne 0x1bb2a
leaq 0x730a4(%rip), %rdx     # 0x8ebc6
andb (%r14,%rdx), %cl
movl %eax, %ebp
jmp 0x1bb5c
notb %cl
movslq %eax, %rdx
andb %cl, (%rbx,%rdx)
leal 0x1(%rax), %ecx
cmpl %ebp, %ecx
jge 0x1bb51
leaq (%rbx,%rdx), %rdi
incq %rdi
movl %ebp, %edx
subl %eax, %edx
addl $-0x2, %edx
incq %rdx
xorl %esi, %esi
callq 0x63b0
leaq 0x7306e(%rip), %rax     # 0x8ebc6
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_O1/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 0x1bb87
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
andb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
jg 0x1bb77
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xa546e(%rip)     # 0xc1010
jne 0x1bba9
callq 0x1b6e4
testl %ebx, %ebx
jle 0x1bbd5
incl %ebx
xorl %ecx, %ecx
leaq 0xa5468(%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
jg 0x1bbba
jmp 0x1bbd7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bbfb
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
orb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
jg 0x1bbeb
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xa53fa(%rip)     # 0xc1010
jne 0x1bc1d
callq 0x1b6e4
testl %ebx, %ebx
jle 0x1bc49
incl %ebx
xorl %ecx, %ecx
leaq 0xa53f4(%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
jg 0x1bc2e
jmp 0x1bc4b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bc6f
incl %edx
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb %cl, (%rdi,%rax)
decl %edx
incq %rax
cmpl $0x1, %edx
jg 0x1bc5f
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bcdd
incl %esi
notb (%rdi)
incq %rdi
decl %esi
cmpl $0x1, %esi
jg 0x1bcd1
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bd5e
leal (%rdx,%rsi), %eax
decl %eax
cmpl %esi, %eax
jle 0x1bd5e
pushq %rbx
leaq 0x72ec3(%rip), %rcx     # 0x8ebb6
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 0x1bd3a
testb %bl, %bl
je 0x1bd3a
orb %r10b, %r11b
movb %r11b, (%rdi,%r9)
notb %r8b
andb (%rdi,%rdx), %r8b
jmp 0x1bd51
testb %r10b, %r11b
je 0x1bd55
testb %bl, %bl
jne 0x1bd55
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 0x1bcf3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bdae
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x72e39(%rip), %r12     # 0x8ebb6
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 0x1bd7d
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6930
// File: /workspace/github_c_makefile_star2_O1/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 0x1bdf1
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x6930
cmpl %r14d, %r15d
jge 0x1be40
xorl %r13d, %r13d
cmpl $0x0, 0x4(%rsp)
sete %r13b
shll $0x4, %r13d
orl $0x20, %r13d
leaq 0x72da5(%rip), %rbp     # 0x8ebb6
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 0x1be30
movl $0x31, %edi
movq %rbx, %rsi
callq 0x6930
incl %r15d
cmpl %r15d, %r14d
jne 0x1be11
cmpl $0x0, 0x4(%rsp)
je 0x1be62
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_O1/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 0x1be83
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 0x1bea3
callq 0x2bfa9
jmp 0x1beab
movq %rsi, %rdi
callq 0x2db04
testl %r14d, %r14d
jle 0x1beea
movl %r14d, %ecx
xorl %edx, %edx
leaq 0x72cfa(%rip), %rsi     # 0x8ebb6
movzbl (%rbx,%rdx), %edi
cmpl $0x20, %edi
je 0x1bee2
cmpl $0x30, %edi
je 0x1bee2
testl %edi, %edi
je 0x1beea
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 0x1bebc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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), %eax
movl %edi, %ebx
sarl $0x11, %ebx
cmpl $0x20000000, %edx       # imm = 0x20000000
jg 0x1bfab
sarl $0x11, %eax
xorl %ecx, %ecx
cmpl %eax, %ebx
je 0x1bfd5
sarl $0x3, %ebx
sarl $0x3, %eax
addq $0x4, %rcx
cmpl $0x14, %ecx
jne 0x1bf8f
leaq 0x72d5a(%rip), %rdi     # 0x8ed03
jmp 0x1bfca
shrl $0x11, %eax
xorl %ecx, %ecx
cmpl %eax, %ebx
je 0x1bfe1
sarl $0x3, %ebx
shrl $0x3, %eax
addq $0x4, %rcx
cmpl $0x18, %ecx
jne 0x1bfb0
leaq 0x72d70(%rip), %rdi     # 0x8ed3a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x26b6f
jmp 0x1bff3
leaq 0x72db4(%rip), %rax     # 0x8ed90
addl (%rcx,%rax), %ebx
jmp 0x1bff3
leaq 0x72d88(%rip), %rax     # 0x8ed70
movl (%rcx,%rax), %eax
addl %eax, %ebx
addl $0x1249, %ebx           # imm = 0x1249
movl %ebx, %eax
popq %rbx
retq