LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/chainBlock.c
// Function: updateScoresOnWay
static void updateScoresOnWay(struct kdBranch *branch, 
	int dim, struct kdLeaf *leaf)
/* Traverse kd-tree to find leaf.  Update all maxScores on the way
 * to reflect leaf->totalScore. */
{
int newDim = 1-dim;
int dimCoord = (dim == 0 ? leaf->cb->qStart : leaf->cb->tStart);
if (branch->maxScore < leaf->totalScore) branch->maxScore = leaf->totalScore;
if (branch->leaf == NULL)
    {
    if (dimCoord <= branch->cutCoord)
	updateScoresOnWay(branch->lo, newDim, leaf);
    if (dimCoord >= branch->cutCoord)
	updateScoresOnWay(branch->hi, newDim, leaf);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
sete %al
movq 0x8(%rbx), %rcx
movl 0x8(%rcx,%rax,8), %r15d
movsd 0x18(%rbx), %xmm0
ucomisd 0x20(%r14), %xmm0
jbe 0x1f943
movsd %xmm0, 0x20(%r14)
cmpq $0x0, 0x10(%r14)
jne 0x1f972
movl $0x1, %ebp
subl %esi, %ebp
cmpl 0x18(%r14), %r15d
jg 0x1f964
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1f913
cmpl 0x18(%r14), %r15d
jl 0x1f972
movq 0x8(%r14), %r14
movl %ebp, %esi
jmp 0x1f920
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: doubleBoxWhiskerCalc
void doubleBoxWhiskerCalc(int count, double *array, double *retMin,
                          double *retQ1, double *retMedian, double *retQ3, double *retMax)
/* Calculate what you need to draw a box and whiskers plot from an array of doubles. */
{
if (count <= 0)
    errAbort("doubleBoxWhiskerCalc needs a positive number, not %d for count", count);
if (count == 1)
    {
    *retMin = *retQ1 = *retMedian = *retQ3 = *retMax = array[0];
    return;
    }
doubleSort(count, array);
double min = array[0];
double max = array[count-1];
double median;
int halfCount = count>>1;
if ((count&1) == 1)
    median = array[halfCount];
else
    {
    median = (array[halfCount] + array[halfCount-1]) * 0.5;
    }
double q1, q3;
if (count <= 3)
    {
    q1 = 0.5 * (median + min);
    q3 = 0.5 * (median + max);
    }
else
    {
    int q1Ix = count/4;
    int q3Ix = count - 1 - q1Ix;
    verbose(4, "count %d, q1Ix %d, q3Ix %d\n", count, q1Ix, q3Ix);
    q1 = array[q1Ix];
    q3 = array[q3Ix];
    }
*retMin = min;
*retQ1 = q1;
*retMedian = median;
*retQ3 = q3;
*retMax = max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebp
testl %edi, %edi
jg 0x2004b
leaq 0x6fd08(%rip), %rdi     # 0x8fd4a
movl %ebp, %esi
xorl %eax, %eax
callq 0x26b6f
movq 0x60(%rsp), %rax
cmpl $0x1, %ebp
jne 0x20078
movsd (%r13), %xmm0
movsd %xmm0, (%rax)
movsd %xmm0, (%rbx)
movsd %xmm0, (%r14)
movsd %xmm0, (%r15)
movsd %xmm0, (%r12)
jmp 0x20176
jle 0x20090
movl %ebp, %esi
leaq -0xd6(%rip), %rcx       # 0x1ffad
movl $0x8, %edx
movq %r13, %rdi
callq 0x6e40
movslq %ebp, %rax
movl %ebp, %ecx
sarl %ecx
movslq %ecx, %rcx
movsd (%r13,%rcx,8), %xmm3
testb $0x1, %bpl
jne 0x200b6
addsd -0x8(%r13,%rcx,8), %xmm3
mulsd 0x6ecf2(%rip), %xmm3    # 0x8eda8
movsd (%r13), %xmm5
movsd -0x8(%r13,%rax,8), %xmm4
cmpl $0x3, %ebp
jg 0x200ea
movapd %xmm5, %xmm0
addsd %xmm3, %xmm0
movsd 0x6ecd0(%rip), %xmm2    # 0x8eda8
mulsd %xmm2, %xmm0
movapd %xmm4, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
jmp 0x20159
movq %rbx, 0x20(%rsp)
leal -0x1(%rbp), %ebx
movq %r14, 0x18(%rsp)
movl %ebp, %r14d
shrl $0x2, %r14d
subl %r14d, %ebx
leaq 0x6fc81(%rip), %rsi     # 0x8fd89
movl $0x4, %edi
movl %ebp, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
movsd %xmm3, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm5, (%rsp)
callq 0x4246e
movsd (%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm3
movsd (%r13,%r14,8), %xmm0
movq 0x18(%rsp), %r14
movslq %ebx, %rax
movq 0x20(%rsp), %rbx
movsd (%r13,%rax,8), %xmm1
movq 0x60(%rsp), %rax
movsd %xmm5, (%r12)
movsd %xmm0, (%r15)
movsd %xmm3, (%r14)
movsd %xmm1, (%rbx)
movsd %xmm4, (%rax)
addq $0x28, %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/common.c
// Function: slNameListFromCommaEscaped
struct slName *slNameListFromCommaEscaped(char *s)
/* Return list of slNames gotten from parsing comma delimited string.
 * The final comma is optional. a,b,c  and a,b,c, are equivalent
 * for comma-delimited lists. To escape commas, put two in a row, 
 * which eliminates the possibility for null names 
 * (eg.  a,,b,c will parse to two elements a,b and c). */
{
if (s == NULL)
    return NULL;

struct slName *list = NULL;
char buffer[strlen(s) + 1], *ptr = buffer;

for (; *s != 0; s++)
    {
    *ptr++ = *s;
    if (*s == ',')
        {
        if (s[1] != ',') // if next character not also a ,
            {
            // we found the delimeter, add the string to the list
            slAddHead(&list, slNameNewN(buffer, ptr - buffer - 1));
            ptr = buffer;   // start a new buffer
            }
        else
            s++; // skip the quoting comma and continue
        }
    }

if (ptr > buffer)  // is there something in the buffer
    slAddHead(&list, slNameNewN(buffer, ptr - buffer)); // add it to the list

slReverse(&list);
return list;
}

// Assembly:
testq %rdi, %rdi
je 0x20868
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x62d0
movq %rsp, -0x30(%rbp)
movq %rsp, %rbx
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movb (%r14), %cl
testb %cl, %cl
je 0x2086b
movq %rbx, %rax
notq %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movq %rbx, %rax
movb %cl, (%rax)
incq %rax
cmpb $0x2c, (%r14)
jne 0x2085b
cmpb $0x2c, 0x1(%r14)
jne 0x20830
incq %r14
jmp 0x2085b
addl -0x38(%rbp), %eax
movslq %eax, %r15
leaq 0x10(%r15), %rdi
callq 0x2dc95
movq %rax, %r13
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6570
movq %r12, (%r13)
movq %r13, %r12
movq %rbx, %rax
movb 0x1(%r14), %cl
incq %r14
testb %cl, %cl
jne 0x20819
jmp 0x20871
xorl %eax, %eax
retq
xorl %r12d, %r12d
movq %rbx, %rax
cmpq %rbx, %rax
jbe 0x2089c
subl %ebx, %eax
movslq %eax, %r14
leaq 0x10(%r14), %rdi
callq 0x2dc95
movq %rax, %r15
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6570
movq %r12, (%r15)
movq %r15, %r12
movq -0x30(%rbp), %rdx
testq %r12, %r12
je 0x208bb
xorl %ecx, %ecx
movq %r12, %rax
movq (%r12), %r12
movq %rcx, (%rax)
movq %rax, %rcx
testq %r12, %r12
jne 0x208a7
jmp 0x208bd
xorl %eax, %eax
movq %rdx, %rsp
leaq -0x28(%rbp), %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/common.c
// Function: slNameListToString
char *slNameListToString(struct slName *list, char delimiter)
/* Return string created by joining all names with the delimiter. */
{
struct slName *el;
int elCount = 0;
int len = 0;
char del[2];
char *s;

if (list == NULL)
    return cloneString("");

del[0] = delimiter;
del[1] = '\0';

for (el = list; el != NULL; el = el->next, elCount++)
	len += strlen(el->name);
len += elCount;

AllocArray(s, len);

for (el = list; el != NULL; el = el->next)
	{
	strcat(s, el->name);
	if (el->next != NULL)
		strcat(s, del);
	}
return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x209b7
movq %rdi, %rbx
movb %sil, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
xorl %ecx, %ecx
xorl %ebp, %ebp
movq %rdi, %r15
movl %ecx, %r14d
leaq 0x8(%r15), %rdi
callq 0x62d0
leal (%r14,%rax), %ecx
movq (%r15), %r15
incl %ebp
testq %r15, %r15
jne 0x20960
addl %ebp, %r14d
addl %eax, %r14d
movslq %r14d, %rdi
callq 0x2db04
movq %rax, %r14
leaq 0x6(%rsp), %r15
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6d60
cmpq $0x0, (%rbx)
je 0x209ad
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d60
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x20990
jmp 0x209c7
movl $0x1, %edi
callq 0x2dc95
movq %rax, %r14
movb $0x0, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: slPairFreeValsExt
void slPairFreeValsExt(struct slPair *list, void (*freeFunc)())
/* Free up all values on list using freeFunc.
 * freeFunc should take a simple pointer to free an item, and can be NULL. */
{
struct slPair *el;
for (el = list; el != NULL; el = el->next)
    {
    if (freeFunc)
        freeFunc(el->val);
    else
        freez(&el->val);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x20d0f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x20cfb
movq (%rdi), %rdi
xorl %eax, %eax
callq *%rbx
jmp 0x20d00
callq 0x2dd51
movq (%r14), %r14
testq %r14, %r14
jne 0x20ce9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: startsWithNoCase
boolean startsWithNoCase(const char *start, const char *string)
/* Returns TRUE if string begins with start, case-insensitive. */
{
char c;
int i;

for (i=0; ;i += 1)
    {
    if ((c = tolower(start[i])) == 0)
        return TRUE;
    if (tolower(string[i]) != c)
        return FALSE;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6160
movq (%rax), %rcx
movsbq (%r14), %rax
movl (%rcx,%rax,4), %esi
shll $0x18, %esi
movl $0x1, %eax
je 0x21830
xorl %edx, %edx
sarl $0x18, %esi
movsbq (%rbx,%rdx), %rdi
cmpl %esi, (%rcx,%rdi,4)
jne 0x2182e
movsbq 0x1(%r14,%rdx), %rsi
incq %rdx
movl (%rcx,%rsi,4), %esi
shll $0x18, %esi
jne 0x2180e
jmp 0x21830
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: nextStringBetween
char *nextStringBetween(char *start, char *end, char **pHaystack)
/* Return next string that occurs between start and end strings
 * starting seach at *pHaystack.  This will update *pHaystack to after 
 * end, so it can be called repeatedly. Returns NULL when
 * no more to be found*/
{
char *pos, *p;
int len;
char *haystack = *pHaystack;
if (isEmpty(haystack))
    return NULL;
if ((p = stringIn(start, haystack)) != NULL)
    {
    pos = p + strlen(start);
    if ((p = stringIn(end, pos)) != NULL)
        {
        len = p - pos;
        pos = cloneMem(pos, len + 1);
        pos[len] = 0;
	*pHaystack = p;
        return pos;
        }
    }
*pHaystack = NULL;
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x21abc
cmpb $0x0, (%rdi)
je 0x21abc
movq %rdx, %rbx
movq %rsi, %r14
movq %r12, %rsi
callq 0x6180
testq %rax, %rax
je 0x21ac1
movq %rax, %r15
movq %r12, %rdi
callq 0x62d0
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6180
testq %rax, %rax
je 0x21ac1
movq %rax, %r14
movq %rax, %rbp
subq %r15, %rbp
leal 0x1(%rbp), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x2da9d
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6570
movslq %ebp, %rax
movb $0x0, (%r12,%rax)
jmp 0x21ac7
xorl %r12d, %r12d
jmp 0x21aca
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r14, (%rbx)
movq %r12, %rax
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/common.c
// Function: replaceChar
void replaceChar(char *s, char oldc, char newc)
/* Repace one char with another. Modifies original string. */
{
if (!s)
    return;
char c;
while((c=*s))
    {
    if (c == oldc)
       *s = newc;	
    ++s;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x21d63
movb (%rdi), %al
testb %al, %al
je 0x21d63
incq %rdi
cmpb %sil, %al
jne 0x21d5a
movb %dl, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x21d52
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: chopByWhiteRespectDoubleQuotes
int chopByWhiteRespectDoubleQuotes(char *in, char *outArray[], int outSize)
// NOTE: this routine does not do what this comment says.  It did not ever remove quotes due to
// a coding error so I took out the code that pretended to be doing this.
/* Like chopString, but specialized for white space separators.
 * Further, any doubleQuotes (") are respected.
 * If doubleQuote is encloses whole string, then they are removed:
 *   "Fred and Ethyl" results in word [Fred and Ethyl]
 * If doubleQuotes exist inside string they are retained:
 *   Fred" and Ethyl" results in word [Fred" and Ethyl"]
 * Special note "" is a valid, though empty word. */
{
int recordCount = 0;
char c;
boolean quoting = FALSE;
for (;;)
    {
    if (outArray != NULL && recordCount >= outSize)
        break;

    /* Skip initial separators. */
    while (isspace(*in)) ++in;
    if (*in == 0)
        break;

    /* Store start of word and look for end of word. */
    if (outArray != NULL)
        outArray[recordCount] = in;
    recordCount += 1;
    quoting = FALSE;
    for (;;)
        {
        if ((c = *in) == 0)
            break;
        if (quoting)
            {
            if (c == '"')
                quoting = FALSE;
            }
        else
            {
            quoting = (c == '"');
            if (isspace(c))
                break;
            }
        ++in;
        }
    if (*in == 0)
        break;

    /* Tag end of word with zero. */
    if (outArray != NULL)
        *in = 0;
    /* And skip over the zero. */
    in += 1;
    }
return recordCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
setne %al
testl %edx, %edx
setle %cl
xorl %ebx, %ebx
testb %cl, %al
jne 0x2250d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
callq 0x6790
movq (%rax), %rdx
leaq -0x1(%r15), %rcx
incq %r15
movq %r15, %rdi
movq %rdi, %r15
movsbq 0x1(%rcx), %rsi
incq %rcx
incq %rdi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x22485
testb %sil, %sil
je 0x2250d
testq %r14, %r14
je 0x224a8
movq %rcx, (%r14,%rbx,8)
incq %rbx
movb (%rcx), %cl
testb %cl, %cl
sete %dl
je 0x2250d
xorl %esi, %esi
testl %esi, %esi
je 0x224c3
cmpb $0x22, %cl
setne %sil
jmp 0x224d8
cmpb $0x22, %cl
sete %sil
movq (%rax), %rdi
movsbq %cl, %rcx
testb $0x20, 0x1(%rdi,%rcx,2)
jne 0x224eb
movzbl %sil, %esi
movb (%r15), %cl
incq %r15
testb %cl, %cl
sete %dl
jne 0x224b6
jmp 0x2250d
testb $0x1, %dl
jne 0x2250d
testq %r14, %r14
je 0x224fa
movb $0x0, -0x1(%r15)
testq %r14, %r14
sete %cl
cmpl %ebp, %ebx
setl %dl
orb %cl, %dl
jne 0x22478
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: eraseTrailingSpaces
int eraseTrailingSpaces(char *s)
/* Replace trailing white space with zeroes. Returns number of
 * spaces erased. */
{
int len = strlen(s);
int i;
char c;
int erased = 0;

for (i=len-1; i>=0; --i)
    {
    c = s[i];
    if (isspace(c))
	{
	s[i] = 0;
	++erased;
	}
    else
	break;
    }
return erased;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x62d0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x22669
callq 0x6790
movq %rax, %rcx
movl %ebx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%rax,%r14), %rdx
decq %rdx
xorl %eax, %eax
movsbq (%rdx), %rsi
movq (%rcx), %rdi
testb $0x20, 0x1(%rdi,%rsi,2)
je 0x2266b
movb $0x0, (%rdx)
incl %eax
decq %rdx
cmpl %eax, %ebx
jne 0x2264b
movl %ebx, %eax
jmp 0x2266b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: eraseNonDigits
void eraseNonDigits(char *s)
{
char *in, *out;
char c;

in = out = s;
for (;;)
    {
    c = *in++;
    if (c == 0)
        break;
    if (isdigit(c))
        *out++ = c;
    }
*out = 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x226e9
callq 0x6790
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x8, 0x1(%rdx,%rsi,2)
je 0x226de
movb %bpl, (%rbx)
incq %rbx
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x226ca
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: cloneNotFirstWord
char *cloneNotFirstWord(char *s)
/* return part of string after first space, not changing s. Result has to be freed. */
{
if (s==NULL)
    return cloneString("");
char* spcPos = stringIn(" ", s);
if (spcPos==NULL)
    return cloneString("");
return cloneString(spcPos+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2293d
movl $0x20, %esi
callq 0x6270
testq %rax, %rax
je 0x2293d
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r15
incl %eax
movslq %eax, %rdi
callq 0x2dc95
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6570
movq %r14, %rax
addq %r15, %rax
jmp 0x2294a
movl $0x1, %edi
callq 0x2dc95
movq %rax, %r14
movb $0x0, (%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: cloneFirstWordByDelimiterNoSkip
char *cloneFirstWordByDelimiterNoSkip(char *line,char delimit)
/* Returns a cloned first word, not harming the memory passed in. Does not skip leading white space.*/
{
if (line == NULL || *line == 0)
    return NULL;
int size=0;
char *e;
for (e=line;*e!=0;e++)
    {
    if (*e==delimit)
        break;
    else if (delimit == ' ' && isspace(*e))
        break;
    size++;
    }
if (size == 0)
    return NULL;
char *new = needMem(size + 2); // Null terminated by 2
memcpy(new, line, size);
return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x22b14
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x22b14
movl %esi, %ebp
movb (%rbx), %r15b
testb %r15b, %r15b
sete %al
cmpb %bpl, %r15b
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x22aee
xorl %r14d, %r14d
cmpb $0x20, %bpl
jne 0x22adc
callq 0x6790
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x22aee
movb 0x1(%rbx,%r14), %r15b
incq %r14
testb %r15b, %r15b
je 0x22aee
cmpb %bpl, %r15b
jne 0x22ac3
testl %r14d, %r14d
je 0x22b14
leal 0x2(%r14), %edi
callq 0x2dc95
movl %r14d, %edx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6570
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: cloneFirstWordByDelimiter
char *cloneFirstWordByDelimiter(char *line,char delimit)
/* Returns a cloned first word, not harming the memory passed in. Skips over leading white space. */
{
if (line == NULL || *line == 0)
    return NULL;
line = skipLeadingSpaces(line);
return cloneFirstWordByDelimiterNoSkip(line, delimit);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x22b60
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x22b60
movl %esi, %ebx
callq 0x6790
movq (%rax), %rax
decq %r14
movsbq 0x1(%r14), %rcx
incq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x22b3f
movsbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22a94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: cmpStringOrder
int cmpStringOrder(char *a, char *b, char **orderFields, int orderCount)
/* Compare two strings to sort in same order as orderedFields.  If strings are
 * not in order, will sort them to be after all ordered fields, alphabetically */
{
int aIx = stringArrayIx(a, orderFields, orderCount);
int bIx = stringArrayIx(b, orderFields, orderCount);
if (aIx < 0)	// A not in list?
    {
    if (bIx < 0)	// Neither in list, be alphabetical
	return(strcmp(a, b));
    else		// Only b in list, move a towards end
	return 1;
    }
else if (bIx < 0)	// Only a in list, move b towards end
    return -1;
else
    return aIx - bIx;   // Both in ordered list, just subtract indexes to sort
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x22cce
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x2054a
testl %eax, %eax
je 0x22cce
incq %r13
cmpq %r13, %r12
jne 0x22cb0
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %ebp, %ebp
jle 0x22cec
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x2054a
testl %eax, %eax
je 0x22cf3
incq %rbp
cmpq %rbp, %r12
jne 0x22cd4
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x22cf5
movl %ebp, %ecx
testl %r13d, %r13d
js 0x22d0a
subl %ecx, %r13d
testl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r13d, %eax
jmp 0x22d13
movl $0x1, %eax
testl %ecx, %ecx
js 0x22d22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a50
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: mustOpen
FILE *mustOpen(char *fileName, char *mode)
/* Open a file - or squawk and die. */
{
FILE *f;

if (sameString(fileName, "stdin"))
    return stdin;
if (sameString(fileName, "stdout"))
    return stdout;
if ((f = fopen(fileName, mode)) == NULL)
    {
    char *modeName = "";
    if (mode)
        {
        if (mode[0] == 'r')
            modeName = " to read";
        else if (mode[0] == 'w')
            modeName = " to write";
        else if (mode[0] == 'a')
            modeName = " to append";
        }
    errAbort("mustOpen: Can't open %s%s: %s", fileName, modeName, strerror(errno));
    }
return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x70cbd(%rip), %rsi     # 0x93a2c
callq 0x6a50
testl %eax, %eax
je 0x22dc7
leaq 0x70cc1(%rip), %rsi     # 0x93a40
movq %rbx, %rdi
callq 0x6a50
testl %eax, %eax
je 0x22dd0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6800
movq %rax, %r14
testq %rax, %rax
jne 0x22dda
leaq 0x755bb(%rip), %r15     # 0x98360
testq %r12, %r12
je 0x22df9
movzbl (%r12), %eax
cmpl $0x61, %eax
je 0x22df2
cmpl $0x72, %eax
je 0x22de9
cmpl $0x77, %eax
jne 0x22df9
leaq 0x6d31c(%rip), %r15     # 0x900e1
jmp 0x22df9
movq 0x9c202(%rip), %rax     # 0xbefd0
jmp 0x22dd7
movq 0x9c1d9(%rip), %rax     # 0xbefb0
movq (%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6d2e8(%rip), %r15     # 0x900d8
jmp 0x22df9
leaq 0x6d2f2(%rip), %r15     # 0x900eb
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x6d2ea(%rip), %rdi     # 0x900f6
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x26b6f
jmp 0x22dda
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: carefulCloseWarn
boolean carefulCloseWarn(FILE **pFile)
/* Close file if open and null out handle to it.
 * Return FALSE and print a warning message if there
 * is a problem.*/
{
FILE *f;
boolean ok = TRUE;
if ((pFile != NULL) && ((f = *pFile) != NULL))
    {
    if (f != stdin && f != stdout)
        {
        if (fclose(f) != 0)
	    {
            errnoWarn("fclose failed");
	    ok = FALSE;
	    }
        }
    else if (f == stdout)
        {
        // One expects close() to actually flush the file and close it.  If
        // the file was opened using the magic name "stdout" and then does a
        // setvbuf(), writes to file, calls carefulClose, then frees the
        // buffer, the FILE object points to invalid memory.  Then the exit()
        // I/O cleanup causes the invalid memory to be written to the file,
        // possible outputting corruption data.  If would be consistent with
        // stdio behavior to have "stdout" magic name open "/dev/stdout".
        fflush(f);
        }
    *pFile = NULL;
    }
return ok;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x1, %ebp
testq %rdi, %rdi
je 0x233f7
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x233f7
movq 0x9bc26(%rip), %rax     # 0xbefd0
cmpq (%rax), %rdi
sete %cl
movq 0x9bbf9(%rip), %rax     # 0xbefb0
movq (%rax), %rax
cmpq %rax, %rdi
sete %dl
orb %cl, %dl
je 0x233d0
cmpq %rax, %rdi
jne 0x233f0
callq 0x6870
jmp 0x233f0
callq 0x66e0
testl %eax, %eax
je 0x233eb
leaq 0x6cf21(%rip), %rdi     # 0x90301
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x26a4e
jmp 0x233f0
movl $0x1, %ebp
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: vatruncatef
int vatruncatef(char *buf, int size, char *format, va_list args)
/* Like vasafef, but truncates the formatted string instead of barfing on
 * overflow. */
{
char *truncStr = " [truncated]";
int sz = vsnprintf(buf, size, format, args);
/* note that some version return -1 if too small */
if ((sz < 0) || (sz >= size))
    strncpy(buf + size - 1 - strlen(truncStr), truncStr, strlen(truncStr));
buf[size-1] = 0;
return sz;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq %r14, %rsi
callq 0x6440
testl %eax, %eax
setns %cl
cmpl %r14d, %eax
setl %dl
testb %dl, %cl
jne 0x23af8
movabsq $0x61636e7572745b20, %rcx # imm = 0x61636E7572745B20
movq %rcx, -0xd(%rbx,%r14)
movl $0x5d646574, -0x5(%rbx,%r14) # imm = 0x5D646574
movb $0x0, -0x1(%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: truncatef
void truncatef(char *buf, int size, char *format, ...)
/* Like safef, but truncates the formatted string instead of barfing on
 * overflow. */
{
va_list args;
va_start(args, format);
vatruncatef(buf, size, format, args);  // ignore returned size
va_end(args);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x23b5f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movslq %esi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6440
testl %eax, %eax
setns %cl
cmpl %r14d, %eax
setl %al
testb %al, %cl
jne 0x23bb4
movabsq $0x61636e7572745b20, %rax # imm = 0x61636E7572745B20
movq %rax, -0xd(%rbx,%r14)
movl $0x5d646574, -0x5(%rbx,%r14) # imm = 0x5D646574
movb $0x0, -0x1(%rbx,%r14)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: safememset
void safememset(char *buf, size_t bufSize, const char c, size_t n)
/* Append a character to a buffer repeatedly, n times with bounds checking.*/
{
size_t blen = strlen(buf);
if (blen+n+1 > bufSize)
    errAbort("buffer overflow, size %lld, new string size: %lld", (long long)bufSize, (long long)(blen+n));
memset(buf+blen, c, n);
buf[blen+n] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
callq 0x62d0
movq %rax, %r12
leaq (%rax,%r14), %r15
addq %r14, %rax
incq %rax
cmpq %r13, %rax
jbe 0x23dfe
leaq 0x6c6c9(%rip), %rdi     # 0x904ba
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x26b6f
addq %rbx, %r12
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x63b0
movb $0x0, (%rbx,%r15)
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/common.c
// Function: isSymbolString
boolean isSymbolString(char *s)
/* Return TRUE if s can be used as a symbol in the C language */
{
char c = *s++;
if (!isalpha(c) && (c != '_'))
    return FALSE;
while ((c = *s++) != 0)
    {
    if (!(isalnum(c) || (c == '_')))
	return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbq (%rdi), %r14
callq 0x6790
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x5f, %r14
je 0x24029
movzwl (%rcx,%r14,2), %edx
andl $0x400, %edx            # imm = 0x400
je 0x2404d
incq %rbx
movsbq (%rbx), %rdx
testq %rdx, %rdx
je 0x24048
incq %rbx
cmpb $0x5f, %dl
je 0x2402c
movzwl (%rcx,%rdx,2), %edx
andl $0x8, %edx
jne 0x2402c
jmp 0x2404d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/common.c
// Function: isAllDigits
boolean isAllDigits(char *s)
/* Return TRUE if string is non-empty and contains only digits (i.e. is a nonnegative integer). */
{
if (isEmpty(s))
    return FALSE;
char c;
while ((c = *s++) != 0)
    if (!isdigit(c))
        return FALSE;
return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2417b
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x2417b
movsbq (%r14), %r15
testq %r15, %r15
je 0x24176
incq %r14
callq 0x6790
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
jne 0x24158
jmp 0x2417b
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dlist.c
// Function: dlGetAfterTail
struct dlNode *dlGetAfterTail(struct dlList *list)
/* Get the node after the tail of the list */
{
if (dlEmpty(list))
    return list->tail;
else
    return list->tail->next;
}

// Assembly:
movq (%rdi), %rax
addq $0x10, %rdi
cmpq $0x0, (%rax)
je 0x24977
movq (%rdi), %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: newDnaSeq
struct dnaSeq *newDnaSeq(DNA *dna, int size, char *name)
/* Create a new DNA seq. */
{
struct dnaSeq *seq;

seq = needMem(sizeof(*seq));
if (name != NULL)
    seq->name = cloneString(name);
seq->dna = dna;
seq->size = size;
seq->mask = NULL;
return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl $0x28, %edi
callq 0x2dc95
movq %rax, %r15
testq %r12, %r12
je 0x24a26
movq %r12, %rdi
callq 0x1f9f6
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movl %ebx, 0x18(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: cloneDnaSeq
struct dnaSeq *cloneDnaSeq(struct dnaSeq *orig)
/* Duplicate dna sequence in RAM. */
{
struct dnaSeq *seq = CloneVar(orig);
seq->name = cloneString(seq->name);
seq->dna = needHugeMem(seq->size+1);
memcpy(seq->dna, orig->dna, seq->size+1);
seq->mask = NULL;
if (orig->mask != NULL)
    {
    seq->mask = bitClone(orig->mask, seq->size);
    }
return seq;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x28, %esi
callq 0x1f980
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x1f9f6
movq %rax, 0x8(%rbx)
movslq 0x18(%rbx), %rdi
incq %rdi
callq 0x2dbbc
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rsi
movslq 0x18(%rbx), %rdx
incq %rdx
movq %rax, %rdi
callq 0x6570
movq $0x0, 0x20(%rbx)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x24aa6
movl 0x18(%rbx), %esi
callq 0x1b76e
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: freeDnaSeq
void freeDnaSeq(struct dnaSeq **pSeq)
/* Free up DNA seq. (And unlink underlying resource node.) */
{
struct dnaSeq *seq = *pSeq;
if (seq == NULL)
    return;
freeMem(seq->name);
freeMem(seq->dna);
bitFree(&seq->mask);
freez(pSeq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x24aed
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x2dd41
movq 0x10(%r14), %rdi
callq 0x2dd41
addq $0x20, %r14
movq %r14, %rdi
callq 0x1b79b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: freeDnaSeqList
void freeDnaSeqList(struct dnaSeq **pSeqList)
/* Free up list of DNA sequences. */
{
struct dnaSeq *seq, *next;

for (seq = *pSeqList; seq != NULL; seq = next)
    {
    next = seq->next;
    freeDnaSeq(&seq);
    }
*pSeqList = 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 0x24b28
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x24ab1
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x24b13
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: dnaSeqCannibalize
char *dnaSeqCannibalize(struct dnaSeq **pSeq)
/* Return the already-allocated dna string and free the dnaSeq container. */
{
char *seq = NULL;
if (pSeq && *pSeq)
    {
    struct dnaSeq *dnaSeq = *pSeq;
    seq = dnaSeq->dna;
    dnaSeq->dna = NULL;
    freeDnaSeq(pSeq);
    }
return seq;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x24b5a
movq (%rdi), %rax
testq %rax, %rax
je 0x24b5a
movq 0x10(%rax), %rbx
movq $0x0, 0x10(%rax)
callq 0x24ab1
jmp 0x24b5c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: seqIsLower
boolean seqIsLower(bioSeq *seq)
/* Return TRUE if sequence is all lower case. */
{
int size = seq->size, i;
char *poly = seq->dna;
for (i=0; i<size; ++i)
    if (!islower(poly[i]))
        return FALSE;
return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x18(%rdi), %r14
movl $0x1, %ebx
testq %r14, %r14
jle 0x24b9a
movq 0x10(%rdi), %r15
callq 0x6790
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%r15,%rcx), %rdx
testb $0x2, 0x1(%rax,%rdx,2)
je 0x24b98
incq %rcx
cmpq %rcx, %r14
jne 0x24b82
jmp 0x24b9a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: translateSeqN
aaSeq *translateSeqN(struct dnaSeq *inSeq, unsigned offset, unsigned inSize, boolean stop)
/* Return a translated sequence.  Offset is position of first base to
 * translate. If size is 0 then use length of inSeq. */
{
aaSeq *seq;
DNA *dna = inSeq->dna;
AA *pep, aa;
int i, lastCodon;
int actualSize = 0;

assert(offset <= inSeq->size);
if ((inSize == 0) || (inSize > (inSeq->size - offset)))
    inSize = inSeq->size - offset;
lastCodon = offset + inSize - 3;

AllocVar(seq);
seq->dna = pep = needLargeMem(inSize/3+1);
for (i=offset; i <= lastCodon; i += 3)
    {
    aa = lookupCodon(dna+i);
    if (aa == 0)
	{
        if (stop)
	    break;
	else
	    aa = 'Z';
	}
    *pep++ = aa;
    ++actualSize;
    }
*pep = 0;
assert(actualSize <= inSize/3+1);
seq->size = actualSize;
seq->name = cloneString(inSeq->name);
return seq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0xc(%rsp)
movl 0x18(%rdi), %r14d
subl %esi, %r14d
jb 0x24cb0
movl %esi, %r13d
movq %rdi, %r15
movq 0x10(%rdi), %rbx
leal -0x1(%rdx), %eax
cmpl %r14d, %eax
cmovbl %edx, %r14d
leal (%r14,%r13), %eax
addl $-0x3, %eax
movl %eax, 0x8(%rsp)
movl $0x28, %edi
callq 0x2dc95
movq %rax, %rbp
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %r14, %rdi
shrq $0x21, %rdi
incl %edi
movq %rdi, 0x20(%rsp)
callq 0x2da9d
movq %rax, %r12
movl 0x8(%rsp), %eax
movq %rbp, 0x18(%rsp)
movq %r12, 0x10(%rbp)
xorl %r14d, %r14d
cmpl %r13d, %eax
jl 0x24c7c
movq %r15, 0x10(%rsp)
movslq %r13d, %r13
movslq %eax, %rbp
xorl %r14d, %r14d
cmpl $0x0, 0xc(%rsp)
setne %r15b
leaq (%rbx,%r13), %rdi
callq 0x24e24
testb %al, %al
sete %cl
testb %r15b, %cl
jne 0x24c74
testb %al, %al
movzbl %al, %eax
movl $0x5a, %ecx
cmovel %ecx, %eax
movb %al, (%r12,%r14)
addq $0x3, %r13
incq %r14
cmpq %rbp, %r13
jle 0x24c3b
addq %r14, %r12
movq 0x10(%rsp), %r15
movb $0x0, (%r12)
cmpl 0x20(%rsp), %r14d
ja 0x24ccf
movq 0x18(%rsp), %rbx
movl %r14d, 0x18(%rbx)
movq 0x8(%r15), %rdi
callq 0x1f9f6
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6b885(%rip), %rdi     # 0x9053c
leaq 0x6b894(%rip), %rsi     # 0x90552
leaq 0x6b89a(%rip), %rcx     # 0x9055f
movl $0x6e, %edx
callq 0x6460
leaq 0x6b8d0(%rip), %rdi     # 0x905a6
leaq 0x6b875(%rip), %rsi     # 0x90552
leaq 0x6b87b(%rip), %rcx     # 0x9055f
movl $0x83, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: aaSeqZToX
void aaSeqZToX(aaSeq *aa)
/* If seq has a 'Z' for stop codon, possibly followed by other bases, change the 'Z' to an X
 * (compatible with dnautil's aminoAcidTable) and truncate there. */
{
char *p = strchr(aa->dna, 'Z');
if (p)
    {
    *p++ = 'X';
    *p = '\0';
    aa->size = p - aa->dna;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl $0x5a, %esi
callq 0x6270
testq %rax, %rax
je 0x24d1d
movw $0x58, (%rax)
movl 0x10(%rbx), %ecx
subl %ecx, %eax
incl %eax
movl %eax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: whichSeqIn
bioSeq *whichSeqIn(bioSeq **seqs, int seqCount, char *letters)
/* Figure out which if any sequence letters is in. */
{
aaSeq *seq;
int i;

for (i=0; i<seqCount; ++i)
    {
    seq = seqs[i];
    if (seq->dna <= letters && letters < seq->dna + seq->size)
        return seq;
    }
internalErr();
return NULL;
}

// Assembly:
pushq %rbx
testl %esi, %esi
jle 0x24d49
movl %esi, %eax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rbx
movq 0x10(%rbx), %rsi
cmpq %rdx, %rsi
ja 0x24d41
movslq 0x18(%rbx), %r8
addq %r8, %rsi
cmpq %rdx, %rsi
ja 0x24d65
incq %rcx
cmpq %rcx, %rax
jne 0x24d28
leaq 0x68e6b(%rip), %rdi     # 0x8dbbb
leaq 0x6b7fb(%rip), %rsi     # 0x90552
xorl %ebx, %ebx
movl $0xaa, %edx
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: maskFromUpperCaseSeq
Bits *maskFromUpperCaseSeq(bioSeq *seq)
/* Allocate a mask for sequence and fill it in based on
 * sequence case. */
{
int size = seq->size, i;
char *poly = seq->dna;
Bits *b = bitAlloc(size);
for (i=0; i<size; ++i)
    {
    if (isupper(poly[i]))
        bitSetOne(b, i);
    }
return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x18(%rdi), %rbx
movq 0x10(%rdi), %r13
movl %ebx, %edi
callq 0x1b749
movq %rax, %r14
testq %rbx, %rbx
jle 0x24db9
xorl %r15d, %r15d
callq 0x6790
movq %rax, %r12
movq (%r12), %rax
movsbq (%r13,%r15), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x24db1
movq %r14, %rdi
movl %r15d, %esi
callq 0x1b860
incq %r15
cmpq %r15, %rbx
jne 0x24d95
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnaseq.c
// Function: dnaSeqHash
struct hash *dnaSeqHash(struct dnaSeq *seqList)
/* Return hash of sequences keyed by name. */
{
int size = slCount(seqList)+1;
int sizeLog2 = digitsBaseTwo(size);
struct hash *hash = hashNew(sizeLog2);
struct dnaSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
    hashAddUnique(hash, seq->name, seq);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1fbec
incl %eax
movslq %eax, %rdi
callq 0x324a3
movl %eax, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, %r14
testq %rbx, %rbx
je 0x24e04
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x28ed0
movq (%rbx), %rbx
jmp 0x24deb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: lookupCodon
AA lookupCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].protCode;
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9c621(%rip)     # 0xc1450
jne 0x24e36
callq 0x25e88
xorl %eax, %eax
leaq 0x9c621(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x24e6d
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x24e41
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b7b9(%rip), %rcx     # 0xc0620
movb 0x8(%rax,%rcx), %al
jmp 0x24e6f
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: isKozak
boolean isKozak(char *dna, int dnaSize, int pos)
/* Return TRUE if it's a Kozak compatible start. */
{
if (lookupCodon(dna+pos) != 'M')
   {
   return FALSE;
   }
if (pos + 3 < dnaSize)
    {
    if (ntVal[(int)dna[pos+3]] == G_BASE_VAL)
        return TRUE;
    }
if (pos >= 3)
    {
    int c = ntVal[(int)dna[pos-3]];
    if (c == A_BASE_VAL || c == G_BASE_VAL)
        return TRUE;
    }
return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movslq %edx, %r15
addq %r15, %rdi
callq 0x24e24
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x4d, %cl
jne 0x24eeb
addq $0x3, %r15
cmpl %r14d, %r15d
jge 0x24ec5
movsbq (%rbx,%r15), %rcx
leaq 0x9c5a6(%rip), %rdx     # 0xc1460
movl $0x1, %eax
cmpl $0x3, (%rdx,%rcx,4)
je 0x24eeb
cmpl $0x3, %ebp
jl 0x24ee9
movl %ebp, %eax
movsbq -0x3(%rbx,%rax), %rax
leaq 0x9c587(%rip), %rcx     # 0xc1460
movl (%rcx,%rax,4), %ecx
andl $-0x2, %ecx
movl $0x1, %eax
cmpl $0x2, %ecx
je 0x24eeb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: lookupMitoCodon
AA lookupMitoCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].mitoCode;
c = toupper(c);
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9c533(%rip)     # 0xc1450
jne 0x24f24
callq 0x25e88
xorl %eax, %eax
leaq 0x9c533(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x24f68
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x24f2f
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b6cb(%rip), %rcx     # 0xc0620
movsbq 0x9(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x24f6a
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: lookupUniqCodon
AA lookupUniqCodon(DNA *dna)
{
int ix;
int i;
char c;

if (!inittedNtVal)
    initNtVal();
ix = 0;
for (i=0; i<3; ++i)
    {
    int bv = ntVal[(int)dna[i]];
    if (bv<0)
	return 'X';
    ix = (ix<<2) + bv;
    }
c = codonTable[ix].uniqCode;
c = toupper(c);
return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9c4d9(%rip)     # 0xc1450
jne 0x24f7e
callq 0x25e88
xorl %eax, %eax
leaq 0x9c4d9(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x24fc2
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x24f89
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b671(%rip), %rcx     # 0xc0620
movsbq 0xa(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x24fc4
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: codonVal
Codon codonVal(DNA *start)
/* Return value from 0-63 of codon starting at start. 
 * Returns -1 if not a codon. */
{
int v1,v2,v3;

if ((v1 = ntVal[(int)start[0]]) < 0)
    return -1;
if ((v2 = ntVal[(int)start[1]]) < 0)
    return -1;
if ((v3 = ntVal[(int)start[2]]) < 0)
    return -1;
return ((v1<<4) + (v2<<2) + v3);
}

// Assembly:
movsbq (%rdi), %rax
leaq 0x9c48f(%rip), %rsi     # 0xc1460
movl (%rsi,%rax,4), %ecx
movb $-0x1, %al
testl %ecx, %ecx
js 0x24ffa
movsbq 0x1(%rdi), %rdx
movl (%rsi,%rdx,4), %edx
testl %edx, %edx
js 0x24ffa
movsbq 0x2(%rdi), %rdi
movl (%rsi,%rdi,4), %esi
testl %esi, %esi
js 0x24ffa
shll $0x4, %ecx
leal (%rcx,%rdx,4), %eax
addl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: dnaTranslateSome
void dnaTranslateSome(DNA *dna, char *out, int outSize)
/* Translate DNA upto a stop codon or until outSize-1 amino acids, 
 * whichever comes first. Output will be zero terminated. */
{
int i;
int dnaSize;
int protSize = 0;

outSize -= 1;  /* Room for terminal zero */
dnaSize = strlen(dna);
for (i=0; i<dnaSize-2; i+=3)
    {
    if (protSize >= outSize)
        break;
    if ((out[protSize++] = lookupCodon(dna+i)) == 0)
        break;
    }
out[protSize] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x62d0
movq %rax, %r15
cmpl $0x3, %r15d
setl %al
cmpl $0x2, %ebp
setl %cl
orb %al, %cl
jne 0x2509d
addl $-0x2, %r15d
decl %ebp
movslq %ebp, %r13
movl $0x3, %ebp
movl $0x1, %eax
movq %rax, %r12
movq %r14, %rdi
callq 0x24e24
movb %al, -0x1(%rbx,%r12)
testb %al, %al
je 0x250a0
cmpl %ebp, %r15d
jle 0x250a0
addq $0x3, %r14
addl $0x3, %ebp
leaq 0x1(%r12), %rax
cmpq %r13, %r12
jl 0x25071
jmp 0x250a0
xorl %r12d, %r12d
movb $0x0, (%rbx,%r12)
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/dnautil.c
// Function: complement
void complement(DNA *dna, long length)
{
int i;

if (!inittedCompTable) initNtCompTable();
for (i=0; i<length; ++i)
    {
    *dna = ntCompTable[(int)*dna];
    ++dna;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x9c79b(%rip)     # 0xc1860
jne 0x250cc
callq 0x260b1
testq %rbx, %rbx
jle 0x250ee
xorl %eax, %eax
leaq 0x9c796(%rip), %rcx     # 0xc1870
movsbq (%r14,%rax), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r14,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x250da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/dnautil.c
// Function: reverseIntRange
void reverseIntRange(int *pStart, int *pEnd, int size)
{
int temp;
temp = *pStart;
*pStart = size - *pEnd;
*pEnd = size - temp;
}

// Assembly:
movl %edx, %eax
subl (%rsi), %eax
subl (%rdi), %edx
movl %eax, (%rdi)
movl %edx, (%rsi)
retq