LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x21188
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x21174
movq (%rdi), %rdi
xorl %eax, %eax
callq *%rbx
jmp 0x21179
callq 0x2e0b0
movq (%r14), %r14
testq %r14, %r14
jne 0x21162
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21b8b
xorl %edx, %edx
sarl $0x18, %esi
movsbq (%rbx,%rdx), %rdi
cmpl %esi, (%rcx,%rdi,4)
jne 0x21b89
movsbq 0x1(%r14,%rdx), %rsi
incq %rdx
movl (%rcx,%rsi,4), %esi
shll $0x18, %esi
jne 0x21b69
jmp 0x21b8b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21e1b
cmpb $0x0, (%rdi)
je 0x21e1b
movq %rdx, %rbx
movq %rsi, %r14
movq %r12, %rsi
callq 0x6180
testq %rax, %rax
je 0x21e20
movq %rax, %r15
movq %r12, %rdi
callq 0x62d0
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6180
testq %rax, %rax
je 0x21e20
movq %rax, %r14
movq %rax, %rbp
subq %r15, %rbp
leal 0x1(%rbp), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x2ddfc
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6570
movslq %ebp, %rax
movb $0x0, (%r12,%rax)
jmp 0x21e26
xorl %r12d, %r12d
jmp 0x21e29
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_O3/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 0x220c2
movb (%rdi), %al
testb %al, %al
je 0x220c2
incq %rdi
cmpb %sil, %al
jne 0x220b9
movb %dl, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x220b1
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
setne %al
testl %edx, %edx
setle %cl
xorl %r15d, %r15d
testb %cl, %al
jne 0x22853
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
callq 0x6790
movq (%rax), %rsi
leaq -0x1(%r12), %rdx
incq %r12
movq %r12, %rdi
movq %rdi, %r12
movsbq 0x1(%rdx), %rcx
incq %rdx
incq %rdi
testb $0x20, 0x1(%rsi,%rcx,2)
jne 0x227d8
testb %cl, %cl
je 0x22853
testq %r14, %r14
je 0x22805
movq %rdx, (%r14,%r15,8)
movb (%rdx), %cl
incq %r15
testb %cl, %cl
jne 0x22808
jmp 0x22853
incq %r15
xorl %edx, %edx
testl %edx, %edx
je 0x22816
cmpb $0x22, %cl
setne %dl
jmp 0x2282a
cmpb $0x22, %cl
sete %dl
movq (%rax), %rsi
movsbq %cl, %rcx
testb $0x20, 0x1(%rsi,%rcx,2)
jne 0x2283a
movzbl %dl, %edx
movb (%r12), %cl
incq %r12
testb %cl, %cl
jne 0x2280a
jmp 0x22853
testq %r14, %r14
je 0x22845
movb $0x0, -0x1(%r12)
testq %r14, %r14
je 0x227ca
cmpl %ebx, %r15d
jl 0x227ca
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x229ab
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 0x229ad
movb $0x0, (%rdx)
incl %eax
decq %rdx
cmpl %eax, %ebx
jne 0x2298d
movl %ebx, %eax
jmp 0x229ad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22a2b
callq 0x6790
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x8, 0x1(%rdx,%rsi,2)
je 0x22a20
movb %bpl, (%rbx)
incq %rbx
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x22a0c
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22c78
movl $0x20, %esi
callq 0x6270
testq %rax, %rax
je 0x22c78
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r15
incl %eax
movslq %eax, %rdi
callq 0x2dff4
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6570
movq %r14, %rax
addq %r15, %rax
jmp 0x22c85
movl $0x1, %edi
callq 0x2dff4
movq %rax, %r14
movb $0x0, (%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22dec
movl %esi, %ebp
movq %rdi, %rbx
movb (%rdi), %r15b
testb %r15b, %r15b
sete %al
cmpb %bpl, %r15b
sete %cl
orb %al, %cl
je 0x22df9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
cmpb $0x20, %bpl
jne 0x22e15
callq 0x6790
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x22e29
movb 0x1(%rbx,%r14), %r15b
incq %r14
testb %r15b, %r15b
je 0x22e2e
cmpb %bpl, %r15b
jne 0x22dfc
jmp 0x22e2e
testl %r14d, %r14d
je 0x22dec
leal 0x2(%r14), %edi
callq 0x2dff4
movl %r14d, %edx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6570
// File: /workspace/github_c_makefile_star2_O3/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 0x22e8e
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x22e8e
movl %esi, %ebx
callq 0x6790
movq (%rax), %rax
decq %r14
movsbq 0x1(%r14), %rcx
incq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x22e6d
movsbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22dc8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
jle 0x23019
movq %rdx, %r15
movl %ecx, %r12d
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x209d6
testl %eax, %eax
je 0x22ff2
incq %r13
cmpq %r13, %r12
jne 0x22fd4
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x209d6
testl %eax, %eax
je 0x23032
incq %rbp
cmpq %rbp, %r12
jne 0x22ff7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %r13d, %r13d
jns 0x23044
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a50
testl %r13d, %r13d
js 0x2303f
subl %ebp, %r13d
movl %r13d, %eax
jmp 0x23044
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/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, %r15
movq %rdi, %rbx
leaq 0x70a72(%rip), %rsi     # 0x93af9
callq 0x6a50
testl %eax, %eax
je 0x230de
leaq 0x70a76(%rip), %rsi     # 0x93b0d
movq %rbx, %rdi
callq 0x6a50
testl %eax, %eax
je 0x230e7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6800
movq %rax, %r12
testq %rax, %rax
jne 0x230f1
leaq 0x75397(%rip), %r14     # 0x98454
testq %r15, %r15
je 0x23110
movzbl (%r15), %eax
cmpl $0x61, %eax
je 0x23109
cmpl $0x72, %eax
je 0x23100
cmpl $0x77, %eax
jne 0x23110
leaq 0x6d0c5(%rip), %r14     # 0x901a1
jmp 0x23110
movq 0x9beeb(%rip), %rax     # 0xbefd0
jmp 0x230ee
movq 0x9bec2(%rip), %rax     # 0xbefb0
movq (%rax), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6d091(%rip), %r14     # 0x90198
jmp 0x23110
leaq 0x6d09b(%rip), %r14     # 0x901ab
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x6d093(%rip), %rdi     # 0x901b6
xorl %r12d, %r12d
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x26e94
jmp 0x230f1
// File: /workspace/github_c_makefile_star2_O3/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 0x23715
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x23715
movq 0x9b908(%rip), %rax     # 0xbefd0
cmpq (%rax), %rdi
sete %cl
movq 0x9b8db(%rip), %rax     # 0xbefb0
movq (%rax), %rax
cmpq %rax, %rdi
sete %dl
orb %cl, %dl
je 0x236ee
cmpq %rax, %rdi
jne 0x2370e
callq 0x6870
jmp 0x2370e
callq 0x66e0
testl %eax, %eax
je 0x23709
leaq 0x6ccc3(%rip), %rdi     # 0x903c1
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x26d76
jmp 0x2370e
movl $0x1, %ebp
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24119
leaq 0x6c46e(%rip), %rdi     # 0x9057a
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x26e94
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_O3/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 0x24341
movzwl (%rcx,%r14,2), %edx
andl $0x400, %edx            # imm = 0x400
je 0x24365
incq %rbx
movsbq (%rbx), %rdx
testq %rdx, %rdx
je 0x24360
incq %rbx
cmpb $0x5f, %dl
je 0x24344
movzwl (%rcx,%rdx,2), %edx
andl $0x8, %edx
jne 0x24344
jmp 0x24365
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x24498
movq %rdi, %r14
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x24498
callq 0x6790
movq (%rax), %rax
incq %r14
movsbq %bpl, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x24498
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x2447d
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24c77
movq (%rdi), %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2dff4
movq %rax, %r15
testq %r12, %r12
je 0x24d26
movq %r12, %rdi
callq 0x1feba
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_O3/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 0x1fe44
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x1feba
movq %rax, 0x8(%rbx)
movslq 0x18(%rbx), %rdi
incq %rdi
callq 0x2df1b
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 0x24da6
movl 0x18(%rbx), %esi
callq 0x1bacf
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24ded
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x2e0a0
movq 0x10(%r14), %rdi
callq 0x2e0a0
addq $0x20, %r14
movq %r14, %rdi
callq 0x1bafc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24e28
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x24db1
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x24e13
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24e5a
movq (%rdi), %rax
testq %rax, %rax
je 0x24e5a
movq 0x10(%rax), %rbx
movq $0x0, 0x10(%rax)
callq 0x24db1
jmp 0x24e5c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24e9a
movq 0x10(%rdi), %r15
callq 0x6790
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%r15,%rcx), %rdx
testb $0x2, 0x1(%rax,%rdx,2)
je 0x24e98
incq %rcx
cmpq %rcx, %r14
jne 0x24e82
jmp 0x24e9a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24fb7
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 0x2dff4
movq %rax, %rbp
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %r14, %rdi
shrq $0x21, %rdi
incl %edi
movq %rdi, 0x18(%rsp)
callq 0x2ddfc
movq %rax, %r12
movl 0x8(%rsp), %eax
movq %rbp, 0x20(%rsp)
movq %r12, 0x10(%rbp)
cmpl %r13d, %eax
jge 0x24f34
movb $0x0, (%r12)
xorl %r13d, %r13d
jmp 0x24f8f
movq %r15, 0x10(%rsp)
movslq %r13d, %r14
movslq %eax, %rbp
xorl %r13d, %r13d
cmpl $0x0, 0xc(%rsp)
setne %r15b
leaq (%rbx,%r14), %rdi
callq 0x2512c
testb %al, %al
sete %cl
testb %r15b, %cl
jne 0x24f7b
testb %al, %al
movzbl %al, %eax
movl $0x5a, %ecx
cmovel %ecx, %eax
movb %al, (%r12,%r13)
addq $0x3, %r14
incq %r13
cmpq %rbp, %r14
jle 0x24f42
addq %r13, %r12
movb $0x0, (%r12)
cmpl 0x18(%rsp), %r13d
movq 0x10(%rsp), %r15
ja 0x24fd6
movq 0x20(%rsp), %rbx
movl %r13d, 0x18(%rbx)
movq 0x8(%r15), %rdi
callq 0x1feba
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6b63e(%rip), %rdi     # 0x905fc
leaq 0x6b64d(%rip), %rsi     # 0x90612
leaq 0x6b653(%rip), %rcx     # 0x9061f
movl $0x6e, %edx
callq 0x6460
leaq 0x6b689(%rip), %rdi     # 0x90666
leaq 0x6b62e(%rip), %rsi     # 0x90612
leaq 0x6b634(%rip), %rcx     # 0x9061f
movl $0x83, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x25024
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_O3/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 0x25050
movl %esi, %eax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rbx
movq 0x10(%rbx), %rsi
cmpq %rdx, %rsi
ja 0x25048
movslq 0x18(%rbx), %r8
addq %r8, %rsi
cmpq %rdx, %rsi
ja 0x2506c
incq %rcx
cmpq %rcx, %rax
jne 0x2502f
leaq 0x68bb4(%rip), %rdi     # 0x8dc0b
leaq 0x6b5b4(%rip), %rsi     # 0x90612
xorl %ebx, %ebx
movl $0xaa, %edx
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1baaa
movq %rax, %r14
testq %rbx, %rbx
jle 0x250c0
xorl %r15d, %r15d
callq 0x6790
movq %rax, %r12
movq (%r12), %rax
movsbq (%r13,%r15), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x250b8
movq %r14, %rdi
movl %r15d, %esi
callq 0x1bbc1
incq %r15
cmpq %r15, %rbx
jne 0x2509c
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x200ac
incl %eax
movslq %eax, %rdi
callq 0x32789
movl %eax, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r14
testq %rbx, %rbx
je 0x2510b
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x29254
movq (%rbx), %rbx
jmp 0x250f2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9c319(%rip)     # 0xc1450
jne 0x2513e
callq 0x2616b
xorl %eax, %eax
leaq 0x9c319(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x25175
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x25149
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b4b1(%rip), %rcx     # 0xc0620
movb 0x8(%rax,%rcx), %al
jmp 0x25177
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2512c
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x4d, %cl
jne 0x251f3
addq $0x3, %r15
cmpl %r14d, %r15d
jge 0x251cd
movsbq (%rbx,%r15), %rcx
leaq 0x9c29e(%rip), %rdx     # 0xc1460
movl $0x1, %eax
cmpl $0x3, (%rdx,%rcx,4)
je 0x251f3
cmpl $0x3, %ebp
jl 0x251f1
movl %ebp, %eax
movsbq -0x3(%rbx,%rax), %rax
leaq 0x9c27f(%rip), %rcx     # 0xc1460
movl (%rcx,%rax,4), %ecx
andl $-0x2, %ecx
movl $0x1, %eax
cmpl $0x2, %ecx
je 0x251f3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9c22b(%rip)     # 0xc1450
jne 0x2522c
callq 0x2616b
xorl %eax, %eax
leaq 0x9c22b(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x25270
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x25237
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b3c3(%rip), %rcx     # 0xc0620
movsbq 0x9(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x25272
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9c1d1(%rip)     # 0xc1450
jne 0x25286
callq 0x2616b
xorl %eax, %eax
leaq 0x9c1d1(%rip), %rcx     # 0xc1460
xorl %edx, %edx
movsbq (%rbx,%rax), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
js 0x252ca
leal (%rsi,%rdx,4), %edx
incq %rax
cmpq $0x3, %rax
jne 0x25291
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x9b369(%rip), %rcx     # 0xc0620
movsbq 0xa(%rax,%rcx), %rbx
callq 0x6100
movq (%rax), %rax
movb (%rax,%rbx,4), %al
jmp 0x252cc
movb $0x58, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9c187(%rip), %rsi     # 0xc1460
movl (%rsi,%rax,4), %ecx
movb $-0x1, %al
testl %ecx, %ecx
js 0x25302
movsbq 0x1(%rdi), %rdx
movl (%rsi,%rdx,4), %edx
testl %edx, %edx
js 0x25302
movsbq 0x2(%rdi), %rdi
movl (%rsi,%rdi,4), %esi
testl %esi, %esi
js 0x25302
shll $0x4, %ecx
leal (%rcx,%rdx,4), %eax
addl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movq %rsi, (%rsp)
movq %rdi, %r15
callq 0x62d0
movq %rax, %r12
cmpl $0x3, %r12d
setl %al
cmpl $0x2, %r14d
setl %cl
orb %al, %cl
jne 0x253c6
addl $-0x2, %r12d
movabsq $0x100000000, %rax      # imm = 0x100000000
decl %r14d
movl $0x3, %ebp
movl $0x1, %ebx
movq %rax, %r13
movq %r15, %rdi
callq 0x2512c
movq (%rsp), %rcx
movb %al, -0x1(%rcx,%rbx)
testb %al, %al
je 0x253c0
cmpl %ebp, %r12d
jle 0x253c0
addq $0x3, %r15
addl $0x3, %ebp
leaq 0x1(%rbx), %rcx
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %r13, %rax
cmpq %r14, %rbx
movq %rcx, %rbx
jb 0x25384
sarq $0x20, %r13
jmp 0x253c9
xorl %r13d, %r13d
movq (%rsp), %rax
movb $0x0, (%rax,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/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, 0x9c46e(%rip)     # 0xc1860
jne 0x253f9
callq 0x263bf
testq %rbx, %rbx
jle 0x2541b
xorl %eax, %eax
leaq 0x9c469(%rip), %rcx     # 0xc1870
movsbq (%r14,%rax), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r14,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x25407
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: reverseComplementSlashSeparated
char *reverseComplementSlashSeparated(char *alleleStr)
/* Given a slash-separated series of sequences (a common representation of variant alleles),
 * returns a slash-sep series with the reverse complement of each sequence (if it is a
 * nucleotide sequence).
 * Special behavior to support dbSNP's variant allele conventions:
 * 1. Reverse the order of sequences (to maintain alphabetical ordering).
 * 2. If alleleStr begins with "-/", then after reversing, move "-/" back to the beginning. */
{
int len = strlen(alleleStr);
char choppyCopy[len+1];
safecpy(choppyCopy, sizeof(choppyCopy), alleleStr);
char *alleles[len];
int alCount = chopByChar(choppyCopy, '/', alleles, ArraySize(alleles));
char *outStr = needMem(len+1);
int i;
for (i = alCount-1;  i >= 0;  i--)
    {
    char *allele = alleles[i];
    int alLen = strlen(allele);
    if (isAllNt(allele, alLen))
        reverseComplement(allele, alLen);
    if (i != alCount-1)
        safecat(outStr, len+1, "/");
    safecat(outStr, len+1, allele);
    }
if (startsWith("-/", alleleStr))
    {
    // Keep "-/" at the beginning:
    memmove(outStr+2, outStr, len-2);
    outStr[0] = '-';
    outStr[1] = '/';
    }
return outStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
callq 0x62d0
movq %rax, %r15
leal 0x1(%rax), %ebx
movq %rsp, %r14
leaq 0xf(%rbx), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, -0x40(%rbp)
movq %r12, %rdx
callq 0x21600
movl %r15d, %eax
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
movq %r14, %rdi
movl $0x2f, %esi
movq %rdx, -0x50(%rbp)
movq %r15, -0x38(%rbp)
movl %r15d, %ecx
callq 0x22862
movl %eax, %r14d
movslq %ebx, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2dff4
movq %rax, %r12
testl %r14d, %r14d
jle 0x255a6
movq %r14, %r15
decl %r15d
leaq 0x9c44e(%rip), %r13     # 0xc1970
movq %r15, -0x48(%rbp)
movq %r12, %r14
movq -0x50(%rbp), %rax
movq (%rax,%r15,8), %rbx
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r12
callq 0x25e47
testl %r12d, %r12d
jle 0x25564
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsbq (%rbx,%rcx), %rdx
cmpb $0x0, (%rdx,%r13)
je 0x2556f
incq %rcx
cmpq %rcx, %rax
jne 0x25550
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x25423
cmpq -0x48(%rbp), %r15
movq %r14, %r12
je 0x2558b
movq %r12, %rdi
movq -0x30(%rbp), %rsi
leaq 0x6fcef(%rip), %rdx     # 0x95275
callq 0x24013
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x24013
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0x25526
leaq 0x6b237(%rip), %rdi     # 0x907e4
movq -0x40(%rbp), %rsi
callq 0x21b23
testl %eax, %eax
je 0x255da
movq %r12, %rdi
addq $0x2, %rdi
movq -0x38(%rbp), %rax
addl $-0x2, %eax
movslq %eax, %rdx
movq %r12, %rsi
callq 0x6c60
movw $0x2f2d, (%r12)         # imm = 0x2F2D
movq %r12, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: isAllNt
boolean isAllNt(char *seq, int size)
/* Return TRUE if all letters in seq are ACGTNU-. */
{
int i;
dnaUtilOpen();
for (i = 0;  i < size;  ++i)
    {
    if (ntChars[(int)seq[i]] == 0)
	return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x25e47
movl $0x1, %eax
testl %ebp, %ebp
jle 0x25624
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x9c363(%rip), %rsi     # 0xc1970
movsbq (%rbx,%rdx), %rdi
cmpb $0x0, (%rdi,%rsi)
je 0x25622
incq %rdx
cmpq %rdx, %rcx
jne 0x2560d
jmp 0x25624
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: cmpDnaStrings
int cmpDnaStrings(DNA *a, DNA *b)
/* Compare using screwy non-alphabetical DNA order TCGA */
{
for (;;)
    {
    DNA aa = *a++;
    DNA bb = *b++;
    if (aa != bb)
        return ntVal[(int)aa] - ntVal[(int)bb];
    if (aa == 0)
	break;
    }
return 0;
}

// Assembly:
xorl %eax, %eax
movsbq (%rdi,%rax), %rcx
movsbq (%rsi,%rax), %rdx
cmpb %dl, %cl
jne 0x25645
incq %rax
testb %cl, %cl
jne 0x2562d
xorl %eax, %eax
retq
leaq 0x9be14(%rip), %rsi     # 0xc1460
movl (%rsi,%rcx,4), %eax
subl (%rsi,%rdx,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: toRna
void toRna(DNA *dna)
{
DNA c;
for (;;)
    {
    c = *dna;
    if (c == 't')
	*dna = 'u';
    else if (c == 'T')
	*dna = 'U';
    else if (c == 0)
	break;
    ++dna;
    }
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x54, %eax
je 0x25668
movb $0x75, %cl
cmpl $0x74, %eax
je 0x2566a
testl %eax, %eax
jne 0x2566c
jmp 0x25671
movb $0x55, %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x25653
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: skipIgnoringDash
char *skipIgnoringDash(char *a, int size, bool skipTrailingDash)
/* Count size number of characters, and any 
 * dash characters. */
{
while (size > 0)
    {
    if (*a++ != '-')
        --size;
    }
if (skipTrailingDash)
    while (*a == '-')
       ++a;
return a;
}

// Assembly:
testl %esi, %esi
jle 0x2568b
xorl %ecx, %ecx
cmpb $0x2d, (%rdi)
leaq 0x1(%rdi), %rax
setne %cl
movq %rax, %rdi
subl %ecx, %esi
jne 0x25676
jmp 0x2568e
movq %rdi, %rax
testb %dl, %dl
je 0x256a5
decq %rax
movq %rax, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x2d, 0x1(%rcx)
movq %rax, %rcx
je 0x25698
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: countNonDash
int countNonDash(char *a, int size)
/* Count number of non-dash characters. */
{
int count = 0;
int i;
for (i=0; i<size; ++i)
    if (a[i] != '-') 
        ++count;
return count;
}

// Assembly:
testl %esi, %esi
jle 0x256c5
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpb $0x2d, (%rdi,%rdx)
setne %sil
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x256b0
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: dnaOrAaFilteredSize
long dnaOrAaFilteredSize(char *raw, char filter[256])
/* Return how long DNA will be after non-DNA is filtered out. */
{
char c;
long count = 0;
dnaUtilOpen();
while ((c = *raw++) != 0)
    {
    if (filter[(int)c]) ++count;
    }
return count;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25e47
movb (%r14), %cl
testb %cl, %cl
je 0x25719
incq %r14
xorl %eax, %eax
movsbq %cl, %rcx
cmpb $0x1, (%rbx,%rcx)
sbbq $-0x1, %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x25701
jmp 0x2571b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: dnaOrAaFilter
void dnaOrAaFilter(char *in, char *out, char filter[256])
/* Run chars through filter. */
{
char c;
dnaUtilOpen();
while ((c = *in++) != 0)
    {
    if ((c = filter[(int)c]) != 0) *out++ = c;
    }
*out++ = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x25e47
movb (%r15), %al
testb %al, %al
je 0x2575b
incq %r15
movsbq %al, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x25751
movb %al, (%rbx)
incq %rbx
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x25740
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: dnaFilterToN
void dnaFilterToN(char *in, DNA *out)
/* Change all non-DNA characters to N. */
{
DNA c;
initNtChars();
while ((c = *in++) != 0)
    {
    if ((c = ntChars[(int)c]) != 0) *out++ = c;
    else *out++ = 'n';
    }
*out++ = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26464
movb (%r14), %dl
testb %dl, %dl
je 0x25820
incq %r14
leaq 0x9c171(%rip), %rax     # 0xc1970
movl $0x6e, %ecx
movsbq %dl, %rdx
movzbl (%rdx,%rax), %edx
testb %dl, %dl
cmovel %ecx, %edx
movb %dl, (%rbx)
incq %rbx
movb (%r14), %dl
incq %r14
testb %dl, %dl
jne 0x25804
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: upperToN
void upperToN(char *s, int size)
/* Turn upper case letters to N's. */
{
char c;
int i;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (isupper(c))
        s[i] = 'n';
    }
}

// Assembly:
testl %esi, %esi
jle 0x25921
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6790
movl %ebp, %ecx
xorl %edx, %edx
movsbq (%rbx,%rdx), %rsi
movq (%rax), %rdi
testb $0x1, 0x1(%rdi,%rsi,2)
je 0x25913
movb $0x6e, (%rbx,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x25900
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: lowerToN
void lowerToN(char *s, int size)
/* Turn lower case letters to N's. */
{
char c;
int i;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (islower(c))
        s[i] = 'N';
    }
}

// Assembly:
testl %esi, %esi
jle 0x25958
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6790
movl %ebp, %ecx
xorl %edx, %edx
movsbq (%rbx,%rdx), %rsi
movq (%rax), %rdi
testb $0x2, 0x1(%rdi,%rsi,2)
je 0x2594a
movb $0x4e, (%rbx,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x25937
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: basesToBits64
bits64 basesToBits64(char *dna, int size)
/* Convert dna of given size (up to 32) to binary representation */
{
if (size > 32)
    errAbort("basesToBits64 called on %d bases, can only go up to 32", size);
bits64 result = 0;
int i;
for (i=0; i<size; ++i)
    {
    result <<= 2;
    result += ntValNoN[(int)dna[i]];
    }
return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x21, %esi
jl 0x259a6
leaq 0x6ae4c(%rip), %rdi     # 0x907e7
movl %ebp, %esi
xorl %eax, %eax
callq 0x26e94
jmp 0x259aa
testl %ebp, %ebp
jle 0x259d3
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x9c2bb(%rip), %rsi     # 0xc1c70
xorl %eax, %eax
movsbq (%rbx,%rdx), %rdi
movslq (%rsi,%rdi,4), %rdi
leaq (%rdi,%rax,4), %rax
incq %rdx
cmpq %rdx, %rcx
jne 0x259b7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x259cc
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: unpackDna
void unpackDna(bits32 *tiles, int tileCount, DNA *out)
/* Unpack DNA. Expands to 16x tileCount in output. */
{
int i, j;
bits32 tile;

for (i=0; i<tileCount; ++i)
    {
    tile = tiles[i];
    for (j=15; j>=0; --j)
        {
        out[j] = valToNt[tile & 0x3];
        tile >>= 2;
        }
    out += 16;
    }
}

// Assembly:
testl %esi, %esi
jle 0x25a7f
movl %esi, %eax
xorl %ecx, %ecx
leaq 0x9c620(%rip), %rsi     # 0xc2070
movl (%rdi,%rcx,4), %r8d
movl $0x10, %r9d
movl %r8d, %r10d
andl $0x3, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrl $0x2, %r8d
decq %r9
jne 0x25a5a
addq $0x10, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0x25a50
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: unpackDna4
void unpackDna4(UBYTE *tiles, int byteCount, DNA *out)
/* Unpack DNA. Expands to 4x byteCount in output. */
{
int i, j;
UBYTE tile;

for (i=0; i<byteCount; ++i)
    {
    tile = tiles[i];
    for (j=3; j>=0; --j)
        {
        out[j] = valToNt[tile & 0x3];
        tile >>= 2;
        }
    out += 4;
    }
}

// Assembly:
testl %esi, %esi
jle 0x25ac2
movl %esi, %eax
xorl %ecx, %ecx
leaq 0x9c5e1(%rip), %rsi     # 0xc2070
movb (%rdi,%rcx), %r8b
movl $0x4, %r9d
movzbl %r8b, %r8d
movl %r8d, %r10d
andl $0x3, %r10d
movb (%r10,%rsi), %r10b
movb %r10b, -0x1(%rdx,%r9)
shrb $0x2, %r8b
decq %r9
jne 0x25a99
addq $0x4, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0x25a8f
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/dnautil.c
// Function: intronOrientationMinSize
int intronOrientationMinSize(DNA *iStart, DNA *iEnd, int minIntronSize)
/* Given a gap in genome from iStart to iEnd, return 
 * Return 1 for GT/AG intron between left and right, -1 for CT/AC, 0 for no
 * intron.  Assumes DNA is lower cased. */
{
if (iEnd - iStart < minIntronSize)
    return 0;
if (iStart[0] == 'g' && iStart[1] == 't' && iEnd[-2] == 'a' && iEnd[-1] == 'g')
    {
    return 1;
    }
else if (iStart[0] == 'c' && iStart[1] == 't' && iEnd[-2] == 'a' && iEnd[-1] == 'c')
    {
    return -1;
    }
else
    return 0;
}

// Assembly:
movq %rsi, %rcx
subq %rdi, %rcx
movslq %edx, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jl 0x25af7
movzbl (%rdi), %eax
cmpl $0x63, %eax
je 0x25af8
cmpl $0x67, %eax
jne 0x25b0f
cmpb $0x74, 0x1(%rdi)
jne 0x25b0f
cmpb $0x61, -0x2(%rsi)
jne 0x25b0f
movl $0x1, %eax
cmpb $0x67, -0x1(%rsi)
jne 0x25b0f
retq
cmpb $0x74, 0x1(%rdi)
jne 0x25b0f
cmpb $0x61, -0x2(%rsi)
jne 0x25b0f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x63, -0x1(%rsi)
je 0x25af7
xorl %eax, %eax
retq