LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x33710
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x33710
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x28(%rdx), %ecx
cmpl %ecx, %eax
je 0x2117a
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edx
movq -0x10(%rbp), %rax
subl 0x28(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0xb75c9(%rip), %rdi     # 0xd8733
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x211cd
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x10(%rdx), %ecx
cmpl %ecx, %eax
je 0x211c6
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x10(%rbp), %rax
subl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0xb757d(%rip), %rdi     # 0xd8733
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x211cd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2124a
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21201
movl -0x20(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x40008(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x4000c(%rax), %eax
movl %eax, -0x38(%rbp)
movb $0x0, %al
callq 0x34580
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2133e
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x26(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
je 0x212d7
movsbl -0x26(%rbp), %eax
cmpl $0x2d, %eax
jne 0x21301
cmpl $0x0, -0x30(%rbp)
je 0x212ea
movl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x212ff
movl -0x34(%rbp), %ecx
addl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x2132e
movq -0x8(%rbp), %rax
addq $0x8, %rax
movsbl -0x25(%rbp), %ecx
movslq %ecx, %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movsbl -0x26(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
jmp 0x21330
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2129d
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/axt.c
// Function: gapNotMasked
boolean gapNotMasked(char q, char t)
/* return true if gap on one side and upper case on other side */
{
if (q=='-' && t=='-')
    return FALSE;
if (q=='-' && t<'a')
    return TRUE;
if (t=='-' && q<'a')
    return TRUE;
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
jne 0x2137b
movsbl -0x6(%rbp), %eax
cmpl $0x2d, %eax
jne 0x2137b
movl $0x0, -0x4(%rbp)
jmp 0x213b8
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
jne 0x21396
movsbl -0x6(%rbp), %eax
cmpl $0x61, %eax
jge 0x21396
movl $0x1, -0x4(%rbp)
jmp 0x213b8
movsbl -0x6(%rbp), %eax
cmpl $0x2d, %eax
jne 0x213b1
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jge 0x213b1
movl $0x1, -0x4(%rbp)
jmp 0x213b8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x40008(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x4000c(%rax), %eax
movl %eax, -0x38(%rbp)
movb $0x0, %al
callq 0x34580
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x214c2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x26(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
je 0x21447
movsbl -0x26(%rbp), %eax
cmpl $0x2d, %eax
jne 0x21485
movb -0x25(%rbp), %al
movsbl %al, %edi
movsbl -0x26(%rbp), %esi
callq 0x21350
cmpl $0x0, %eax
je 0x21485
cmpl $0x0, -0x30(%rbp)
je 0x2146e
movl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21483
movl -0x34(%rbp), %ecx
addl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x214b2
movq -0x8(%rbp), %rax
addq $0x8, %rax
movsbl -0x25(%rbp), %ecx
movslq %ecx, %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movsbl -0x26(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
jmp 0x214b4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2140d
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
subl 0x28(%rax), %esi
movl $0x1, %edx
callq 0x336a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x33710
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x10(%rcx), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xe5a20(%rip)     # 0x107400
je 0x219f2
movq 0xe5a17(%rip), %rax     # 0x107400
movq %rax, -0x8(%rbp)
jmp 0x21b64
cmpq $0x0, 0xe5a0e(%rip)     # 0x107408
jne 0x21a0d
movl $0x40018, %edi          # imm = 0x40018
callq 0x40c50
movq %rax, 0xe59fb(%rip)     # 0x107408
movq 0xe59f4(%rip), %rax     # 0x107408
movl $0x5b, 0x1858c(%rax)
movq 0xe59e3(%rip), %rax     # 0x107408
movl $0xffffff8e, 0x18594(%rax) # imm = 0xFFFFFF8E
movq 0xe59d2(%rip), %rax     # 0x107408
movl $0xffffffe1, 0x185a4(%rax) # imm = 0xFFFFFFE1
movq 0xe59c1(%rip), %rax     # 0x107408
movl $0xffffff85, 0x185d8(%rax) # imm = 0xFFFFFF85
movq 0xe59b0(%rip), %rax     # 0x107408
movl $0xffffff8e, 0x18d8c(%rax) # imm = 0xFFFFFF8E
movq 0xe599f(%rip), %rax     # 0x107408
movl $0x64, 0x18d94(%rax)
movq 0xe598e(%rip), %rax     # 0x107408
movl $0xffffff83, 0x18da4(%rax) # imm = 0xFFFFFF83
movq 0xe597d(%rip), %rax     # 0x107408
movl $0xffffffe1, 0x18dd8(%rax) # imm = 0xFFFFFFE1
movq 0xe596c(%rip), %rax     # 0x107408
movl $0xffffffe1, 0x19d8c(%rax) # imm = 0xFFFFFFE1
movq 0xe595b(%rip), %rax     # 0x107408
movl $0xffffff83, 0x19d94(%rax) # imm = 0xFFFFFF83
movq 0xe594a(%rip), %rax     # 0x107408
movl $0x64, 0x19da4(%rax)
movq 0xe5939(%rip), %rax     # 0x107408
movl $0xffffff8e, 0x19dd8(%rax) # imm = 0xFFFFFF8E
movq 0xe5928(%rip), %rax     # 0x107408
movl $0xffffff85, 0x1d18c(%rax) # imm = 0xFFFFFF85
movq 0xe5917(%rip), %rax     # 0x107408
movl $0xffffffe1, 0x1d194(%rax) # imm = 0xFFFFFFE1
movq 0xe5906(%rip), %rax     # 0x107408
movl $0xffffff8e, 0x1d1a4(%rax) # imm = 0xFFFFFF8E
movq 0xe58f5(%rip), %rax     # 0x107408
movl $0x5b, 0x1d1d8(%rax)
movq 0xe58e4(%rip), %rdi     # 0x107408
callq 0x21b70
movq 0xe58d8(%rip), %rax     # 0x107408
movl $0x190, 0x40008(%rax)   # imm = 0x190
movq 0xe58c7(%rip), %rax     # 0x107408
movl $0x1e, 0x4000c(%rax)
movq 0xe58b6(%rip), %rax     # 0x107408
movq %rax, 0xe58a7(%rip)     # 0x107400
movq 0xe58a0(%rip), %rax     # 0x107400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x21c81
movl $0x0, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jg 0x21c71
cmpl $0x0, -0xc(%rbp)
jne 0x21bab
cmpl $0x0, -0x10(%rbp)
jne 0x21bab
jmp 0x21c63
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x21c61
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x21c51
movq -0x8(%rbp), %rax
addq $0x8, %rax
movslq -0x14(%rbp), %rdx
leaq 0xe4ae0(%rip), %rcx     # 0x1066c0
movslq (%rcx,%rdx,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rdx
leaq 0xe4aca(%rip), %rcx     # 0x1066c0
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x8, %rax
movslq -0xc(%rbp), %rsi
leaq 0xe4ab0(%rip), %rcx     # 0x1066c0
shlq $0x4, %rsi
addq %rsi, %rcx
movslq -0x14(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rsi
leaq 0xe4a8f(%rip), %rcx     # 0x1066c0
shlq $0x4, %rsi
addq %rsi, %rcx
movslq -0x18(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x21bc3
jmp 0x21c53
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x21bb2
jmp 0x21c63
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x21b90
jmp 0x21c73
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21b7f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xe4eb0(%rip)     # 0x107440
je 0x225a2
movq 0xe4ea7(%rip), %rax     # 0x107440
movq %rax, -0x8(%rbp)
jmp 0x2265a
cmpq $0x0, 0xe4e9e(%rip)     # 0x107448
jne 0x225c6
leaq 0xe38ad(%rip), %rdi     # 0x105e60
leaq 0xb6241(%rip), %rsi     # 0xd87fb
callq 0x22120
movq %rax, 0xe4e82(%rip)     # 0x107448
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x2261f
movl $0x0, -0x10(%rbp)
cmpl $0x80, -0x10(%rbp)
jge 0x22612
movq 0xe4e5b(%rip), %rax     # 0x107448
addq $0x8, %rax
movslq -0xc(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imull $0x13, (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x225dd
jmp 0x22614
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x225cd
movq 0xe4e22(%rip), %rax     # 0x107448
movl $0xd1, 0x40008(%rax)
movq 0xe4e11(%rip), %rax     # 0x107448
movl $0x13, 0x4000c(%rax)
movq 0xe4e00(%rip), %rax     # 0x107448
movq %rax, 0xe4df1(%rip)     # 0x107440
movq 0xe4dea(%rip), %rax     # 0x107440
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x476d0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x22120
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40d40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movl $0x58, %edx
callq 0x6570
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x40(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x3c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x58(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x54(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x2d, %eax
je 0x22f2b
jmp 0x22f4a
leaq 0xb59c0(%rip), %rdi     # 0xd88f2
leaq 0xb59cd(%rip), %rsi     # 0xd8906
movl $0x399, %edx            # imm = 0x399
leaq 0xb59cb(%rip), %rcx     # 0xd8910
callq 0x6450
movq -0x8(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x2d, %eax
jne 0x22fb1
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
movl -0x10(%rbp), %edx
callq 0x33350
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x14, %rsi
movl -0xc(%rbp), %edx
callq 0x33350
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rsi
callq 0x33300
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rsi
callq 0x33300
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x22ff4
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x20ad0
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2303c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22fc0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x23017
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/axt.c
// Function: axtIdWithGaps
double axtIdWithGaps(struct axt *axt)
/* Return ratio of matching bases to total symbols in alignment. */
{
int i;
int matchCount = 0;
for (i=0; i<axt->symCount; ++i)
    {
    if (toupper(axt->qSym[i]) == toupper(axt->tSym[i]))
        ++matchCount;
    }
return (double)matchCount/axt->symCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x23652
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6de0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6de0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jne 0x23645
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23647
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x235fa
cvtsi2sdl -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x38(%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xe3b45(%rip)     # 0x107450
jne 0x239f7
movl $0x1, 0xe3b35(%rip)     # 0x107450
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x239f5
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x23948
movl $0x1, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2395c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x23970
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x23984
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x23998
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x239ac
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x239c0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x239d6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0xe3a7c(%rip), %rax     # 0x107460
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x23922
jmp 0x239f7
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/bits.c
// Function: bitClone
Bits *bitClone(Bits* orig, int bitCount)
/* Clone bits. */
{
int byteCount = ((bitCount+7)>>3);
Bits* bits = needLargeZeroedMem(byteCount);
memcpy(bits, orig, byteCount);
return bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
callq 0x409d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x6570
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23b6f
jmp 0x23b8e
leaq 0xb4e87(%rip), %rdi     # 0xd89fd
leaq 0xb4e8b(%rip), %rsi     # 0xd8a08
movl $0x5b, %edx
leaq 0xb4ead(%rip), %rcx     # 0xd8a36
callq 0x6450
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movslq -0x20(%rbp), %rcx
callq 0x3df10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23bec
jmp 0x23c0b
leaq 0xb4e0a(%rip), %rdi     # 0xd89fd
leaq 0xb4e0e(%rip), %rsi     # 0xd8a08
movl $0x64, %edx
leaq 0xb4e62(%rip), %rcx     # 0xd8a68
callq 0x6450
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x3de60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x6570
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x23ce9
jmp 0x23dbc
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x23d54
movslq -0x20(%rbp), %rcx
leaq 0xe29bc(%rip), %rax     # 0x1066e8
movzbl (%rax,%rcx), %esi
movslq -0x24(%rbp), %rcx
leaq 0xe29b5(%rip), %rax     # 0x1066f0
movzbl (%rax,%rcx), %eax
andl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x23dbc
movslq -0x20(%rbp), %rcx
leaq 0xe2989(%rip), %rax     # 0x1066e8
movzbl (%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x23d9c
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23d7d
movslq -0x24(%rbp), %rcx
leaq 0xe2949(%rip), %rax     # 0x1066f0
movzbl (%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x23e24
movl $0x0, -0x4(%rbp)
jmp 0x23f51
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x0, 0xe35ee(%rip)     # 0x107450
jne 0x23e69
callq 0x23900
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x23eb4
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x28(%rbp), %rdx
leaq 0xe2860(%rip), %rcx     # 0x1066e8
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movslq -0x2c(%rbp), %rdx
leaq 0xe2857(%rip), %rcx     # 0x1066f0
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movslq %eax, %rcx
leaq 0xe35b7(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x23f51
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x28(%rbp), %rdx
leaq 0xe281d(%rip), %rcx     # 0x1066e8
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movslq %eax, %rcx
leaq 0xe3585(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x23f1b
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xe3559(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x23eea
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x2c(%rbp), %rdx
leaq 0xe27be(%rip), %rcx     # 0x1066f0
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movslq %eax, %rcx
leaq 0xe351e(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x18(%rbp), %edx
movl $0xff, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
sarl $0x3, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %ecx
andl $0x7, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2d(%rbp)
je 0x23fb6
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x23fbf
jmp 0x23fe6
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x23dc0
cmpl -0x18(%rbp), %eax
jne 0x23fdb
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2406f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x23f9a
movl -0x24(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2403b
jmp 0x23ff9
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x28(%rbp), %ecx
movb %al, -0x2e(%rbp)
jge 0x2401e
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
testb $0x1, %al
jne 0x24027
jmp 0x24032
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x23ff9
movl -0x2c(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x24(%rbp)
jmp 0x2403d
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x24069
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x23dc0
cmpl -0x18(%rbp), %eax
jne 0x2405e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2406f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2403d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x24159
jmp 0x24235
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x241c7
movslq -0x20(%rbp), %rcx
leaq 0xe254c(%rip), %rax     # 0x1066e8
movzbl (%rax,%rcx), %esi
movslq -0x24(%rbp), %rcx
leaq 0xe2545(%rip), %rax     # 0x1066f0
movzbl (%rax,%rcx), %eax
andl %eax, %esi
xorl $-0x1, %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x24235
movslq -0x20(%rbp), %rcx
leaq 0xe2516(%rip), %rax     # 0x1066e8
movzbl (%rax,%rcx), %esi
xorl $-0x1, %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x24212
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x241f3
movslq -0x24(%rbp), %rcx
leaq 0xe24d3(%rip), %rax     # 0x1066f0
movzbl (%rax,%rcx), %esi
xorl $-0x1, %esi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x2429a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
andl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2425b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, 0xe3183(%rip)     # 0x107450
jne 0x242d4
callq 0x23900
jmp 0x242d6
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x2431f
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
andl %ecx, %eax
movslq %eax, %rcx
leaq 0xe314c(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x242d6
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x2438a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2434b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, 0xe3093(%rip)     # 0x107450
jne 0x243c4
callq 0x23900
jmp 0x243c6
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x2440f
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
orl %ecx, %eax
movslq %eax, %rcx
leaq 0xe305c(%rip), %rax     # 0x107460
movl (%rax,%rcx,4), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x243c6
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x2447a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2443b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x7, %eax
sarl $0x3, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jl 0x24555
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x24527
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x2457d
jmp 0x2461e
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2461e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x23dc0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x23dc0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x245df
cmpl $0x0, -0x20(%rbp)
je 0x245df
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x23c50
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x23c90
jmp 0x24605
cmpl $0x0, -0x1c(%rbp)
je 0x24603
cmpl $0x0, -0x20(%rbp)
jne 0x24603
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x23c90
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x23c50
jmp 0x24605
jmp 0x24607
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2458f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x24690
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x23dc0
cmpl $0x0, %eax
je 0x24675
movq -0x18(%rbp), %rsi
movl $0x31, %edi
callq 0x6910
jmp 0x24683
movq -0x18(%rbp), %rsi
movl $0x30, %edi
callq 0x6910
jmp 0x24685
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2464c
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x6910
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x246de
movq -0x8(%rbp), %rsi
movl $0x5b, %edi
callq 0x6910
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x24740
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x23dc0
cmpl $0x0, %eax
je 0x2470d
movq -0x8(%rbp), %rsi
movl $0x31, %edi
callq 0x6910
jmp 0x24733
cmpl $0x0, -0x1c(%rbp)
je 0x24723
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x6910
jmp 0x24731
movq -0x8(%rbp), %rsi
movl $0x30, %edi
callq 0x6910
jmp 0x24733
jmp 0x24735
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x246e4
cmpl $0x0, -0x1c(%rbp)
je 0x24754
movq -0x8(%rbp), %rsi
movl $0x5d, %edi
callq 0x6910
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24780
cmpl $0x0, -0x1c(%rbp)
jne 0x2478d
movq $0x0, -0x8(%rbp)
jmp 0x2482f
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x247ae
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x23af0
movq %rax, -0x28(%rbp)
jmp 0x247ba
movl -0x1c(%rbp), %edi
callq 0x23a00
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x247e3
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x247ec
jmp 0x24827
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
je 0x2481a
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x2481a
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x23c50
jmp 0x2481c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x247c1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)