LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: cmpStringsWithEmbeddedNumbers
int cmpStringsWithEmbeddedNumbers(const char *a, const char *b)
/* Compare strings such as gene names that may have embedded numbers,
 * so that bmp4a comes before bmp14a */
{
for (;;)
   {
   /* Figure out number of digits at start, and do numerical comparison if there
    * are any.  If numbers agree step over numerical part, otherwise return difference. */
   int aNum = countLeadingDigits(a);
   int bNum = countLeadingDigits(b);
   if (aNum >= 0 && bNum >= 0)
       {
       int diff = atoi(a) - atoi(b);
       if (diff != 0)
           return diff;
       a += aNum;
       b += bNum;
       }

   /* Count number of non-digits at start. */
   int aNonNum = countLeadingNondigits(a);
   int bNonNum = countLeadingNondigits(b);

   // If different sizes of non-numerical part, then don't match, let strcmp sort out how
   if (aNonNum != bNonNum)
        return strcmp(a,b);
   // If no characters left then they are the same!
   else if (aNonNum == 0)
       return 0;
   // Non-numerical part is the same length and non-zero.  See if it is identical.  Return if not.
   else
       {
        int diff = memcmp(a,b,aNonNum);
       if (diff != 0)
            return diff;
       a += aNonNum;
       b += bNonNum;
       }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x8963
movl %eax, %ebp
movq %rbx, %rdi
callq 0x8963
testl %ebp, %ebp
js 0x6db5
movl %eax, %r15d
testl %eax, %eax
js 0x6db5
movq %r14, %rdi
callq 0x36a0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x36a0
subl %eax, %r12d
jne 0x6e07
movl %ebp, %eax
addq %rax, %r14
movl %r15d, %eax
addq %rax, %rbx
movq %r14, %rdi
callq 0x8990
movl %eax, %ebp
movq %rbx, %rdi
callq 0x8990
cmpl %eax, %ebp
jne 0x6dec
testl %ebp, %ebp
je 0x6dff
movslq %ebp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x33f0
testl %eax, %eax
jne 0x6e04
addq %r15, %r14
addq %r15, %rbx
jmp 0x6d75
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3440
xorl %r12d, %r12d
jmp 0x6e07
movl %eax, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: differentWord
int differentWord(char *s1, char *s2)
/* strcmp ignoring case - returns zero if strings are
 * the same (ignoring case) otherwise returns difference
 * between first non-matching characters. */
{
char c1, c2;
for (;;)
    {
    c1 = toupper(*s1++);
    c2 = toupper(*s2++);
    if (c1 != c2) /* Takes care of end of string in one but not the other too */
	return c2-c1;
    if (c1 == 0)  /* Take care of end of string in both. */
	return 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3030
movq (%rax), %rcx
xorl %edx, %edx
movsbq (%r14,%rdx), %rax
movl (%rcx,%rax,4), %esi
movsbq (%rbx,%rdx), %rax
movsbl (%rcx,%rax,4), %eax
movsbl %sil, %edi
subl %edi, %eax
jne 0x6e91
shll $0x18, %esi
incq %rdx
testl %esi, %esi
jne 0x6e6c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameStore
char *slNameStore(struct slName **pList, char *string)
/* Put string into list if it's not there already.
 * Return the version of string stored in list. */
{
struct slName *el;
for (el = *pList; el != NULL; el = el->next)
    {
    if (sameString(string, el->name))
	return el->name;
    }
el = newSlName(string);
slAddHead(pList, el);
return el->name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x6f7f
leaq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
jne 0x6f60
jmp 0x6f97
movq %r14, %rdi
callq 0x6cb2
movq %rax, %r15
movq (%rbx), %rax
movq %rax, (%r15)
movq %r15, (%rbx)
addq $0x8, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameCloneList
struct slName *slNameCloneList(struct slName *list)
/* Return clone of list. */
{
struct slName *el, *newEl, *newList = NULL;
for (el = list; el != NULL; el = el->next)
    {
    newEl = slNameNew(el->name);
    slAddHead(&newList, newEl);
    }
slReverse(&newList);
return newList;
}

// Assembly:
testq %rdi, %rdi
je 0x7021
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, %r14
leaq 0x8(%rbx), %rdi
callq 0x6cb2
movq %r14, (%rax)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x6fee
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x7007
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7023
xorl %ecx, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameListFromString
struct slName *slNameListFromString(char *s, char delimiter)
/* Return list of slNames gotten from parsing delimited string.
 * The final delimiter is optional. a,b,c  and a,b,c, are equivalent
 * for comma-delimited lists. */
{
char *e;
struct slName *list = NULL, *el;
while (s != NULL && s[0] != 0)
    {
    e = strchr(s, delimiter);
    if (e == NULL)
	el = slNameNew(s);
    else
	{
        el = slNameNewN(s, e-s);
	e += 1;
	}
    slAddHead(&list, el);
    s = e;
    }
slReverse(&list);
return list;
}

// Assembly:
testq %rdi, %rdi
je 0x708e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x7091
movsbl %sil, %ebp
xorl %r13d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3260
testq %rax, %rax
je 0x709d
movq %rax, %r15
subl %ebx, %eax
movslq %eax, %r12
leaq 0x10(%r12), %rdi
callq 0xee10
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x34a0
movq %r15, %rbx
incq %rbx
movq %r13, (%r14)
cmpb $0x0, 0x1(%r15)
movq %r14, %r13
jne 0x7046
jmp 0x7094
xorl %eax, %eax
retq
xorl %r14d, %r14d
testq %r14, %r14
jne 0x70ab
xorl %eax, %eax
jmp 0x70be
movq %rbx, %rdi
callq 0x6cb2
movq %rax, %r14
movq %r13, (%rax)
xorl %ecx, %ecx
movq %r14, %rax
movq (%r14), %r14
movq %rcx, (%rax)
movq %rax, %rcx
testq %r14, %r14
jne 0x70ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameListOfUniqueWords
struct slName *slNameListOfUniqueWords(char *text,boolean respectQuotes)
// Return list of unique words found by parsing string delimited by whitespace.
// If respectQuotes then ["Lucy and Ricky" 'Fred and Ethyl'] will yield 2 slNames no quotes
{
struct slName *list = NULL;
char *word = NULL;
while (text != NULL)
    {
    if (respectQuotes)
        {
        word = nextWordRespectingQuotes(&text);
        if (word != NULL)
            {
            if (word[0] == '"')
                stripChar(word, '"');
            else if (word[0] == '\'')
                stripChar(word, '\'');
            }
        }
    else
        word = nextWord(&text);
    if (word)
        slNameStore(&list, word);
    else
        break;
    }

slReverse(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x7199
movl %esi, %ebx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
testl %ebx, %ebx
je 0x7137
callq 0x71a5
testq %rax, %rax
je 0x717b
movzbl (%rax), %ecx
cmpl $0x22, %ecx
je 0x713e
cmpl $0x27, %ecx
jne 0x7164
movq %rax, %rdx
incq %rdx
movq %rax, %rsi
xorl %edi, %edi
cmpb $0x27, %cl
setne %dil
movb (%rdx), %cl
movb %cl, (%rsi,%rdi)
addq %rdi, %rsi
incq %rdx
testb %cl, %cl
jne 0x711d
jmp 0x715f
callq 0x7292
jmp 0x715f
movq %rax, %rdx
incq %rdx
movq %rax, %rsi
xorl %edi, %edi
cmpb $0x22, %cl
setne %dil
movb (%rdx), %cl
movb %cl, (%rsi,%rdi)
addq %rdi, %rsi
incq %rdx
testb %cl, %cl
jne 0x7147
testq %rax, %rax
je 0x717b
movq %r15, %rdi
movq %rax, %rsi
callq 0x6f4f
cmpq $0x0, 0x8(%rsp)
jne 0x70f6
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x7199
xorl %edx, %edx
movq %rcx, %rax
movq (%rcx), %rcx
movq %rdx, (%rax)
movq %rax, %rdx
testq %rcx, %rcx
jne 0x7186
jmp 0x719b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: nextWordRespectingQuotes
char *nextWordRespectingQuotes(char **pLine)
// return next word but respects single or double quotes surrounding sets of words.
{
char *s = *pLine, *e;
if (s == NULL || s[0] == 0)
    return NULL;
s = skipLeadingSpaces(s);
if (s[0] == 0)
    return NULL;
if (s[0] == '"')
    {
    e = skipBeyondDelimit(s+1,'"');
    if (e != NULL && !isspace(e[0]))
        e = skipToSpaces(s);
    }
else if (s[0] == '\'')
    {
    e = skipBeyondDelimit(s+1,'\'');
    if (e != NULL && !isspace(e[0]))
        e = skipToSpaces(s);
    }
else
    e = skipToSpaces(s);
if (e != NULL)
    *e++ = 0;
*pLine = e;
return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x7218
movsbq (%rbx), %r12
testq %r12, %r12
je 0x7218
movq %rdi, %r14
callq 0x37a0
movq (%rax), %r15
leaq 0x1(%rbx), %rdi
testb $0x20, 0x1(%r15,%r12,2)
je 0x71e8
movsbq (%rdi), %r12
incq %rdi
testb $0x20, 0x1(%r15,%r12,2)
jne 0x71d5
leaq -0x1(%rdi), %rbx
testb %r12b, %r12b
je 0x7218
movzbl %r12b, %eax
cmpl $0x27, %eax
je 0x721c
cmpl $0x22, %eax
jne 0x7247
movl $0x22, %esi
callq 0x3260
testq %rax, %rax
je 0x725c
movzbl 0x1(%rax), %ecx
incq %rax
cmpl $0x22, %ecx
je 0x720a
jmp 0x7237
xorl %ebx, %ebx
jmp 0x7261
movl $0x27, %esi
callq 0x3260
testq %rax, %rax
je 0x725c
movzbl 0x1(%rax), %ecx
incq %rax
cmpl $0x27, %ecx
je 0x722b
testl %ecx, %ecx
je 0x725c
movsbq %cl, %rcx
testb $0x20, 0x1(%r15,%rcx,2)
jne 0x7254
movq %rbx, %rdi
callq 0x8dcc
testq %rax, %rax
je 0x725c
movb $0x0, (%rax)
incq %rax
jmp 0x725e
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: stripChar
void stripChar(char *s, char c)
/* Remove all occurences of c from s. */
{
char *in = s, *out = s;
char b;

for (;;)
    {
    b = *out = *in++;
    if (b == 0)
       break;
    if (b != c)
       ++out;
    }
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x7291
leaq 0x1(%rdi), %rax
xorl %edx, %edx
cmpb %sil, %cl
setne %dl
movb (%rax), %cl
movb %cl, (%rdi,%rdx)
addq %rdx, %rdi
incq %rax
testb %cl, %cl
jne 0x727a
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: nextWord
char *nextWord(char **pLine)
/* Return next word in *pLine and advance *pLine to next
 * word. */
{
char *s = *pLine, *e;
if (s == NULL || s[0] == 0)
    return NULL;
s = skipLeadingSpaces(s);
if (s[0] == 0)
    return NULL;
e = skipToSpaces(s);
if (e != NULL)
    *e++ = 0;
*pLine = e;
return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x72d7
movsbq (%rbx), %r15
testq %r15, %r15
je 0x72d7
movq %rdi, %r14
callq 0x37a0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x72bf
xorl %eax, %eax
jmp 0x72d3
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x72bf
testb %cl, %cl
sete %al
testb %al, %al
je 0x72e2
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x8dcc
testq %rax, %rax
je 0x72fa
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x72fc
xorl %ecx, %ecx
movq %rcx, (%r14)
jmp 0x72d9
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameListFromStringArray
struct slName *slNameListFromStringArray(char *stringArray[], int arraySize)
/* Return list of slNames from an array of strings of length arraySize.
 * If a string in the array is NULL, the array will be treated as
 * NULL-terminated (shorter than arraySize). */
{
char *s;
struct slName *list = NULL, *el;
int i;
if (stringArray == NULL)
    return NULL;
for (i = 0;  i < arraySize;  i++)
    {
    s = stringArray[i];
    if (s == NULL)
	break;
    el = slNameNew(s);
    slAddHead(&list, el);
    }
slReverse(&list);
return list;
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x7342
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x7346
callq 0x6cb2
movq %r12, (%rax)
incq %r15
movq %rax, %r12
cmpq %r15, %r14
jne 0x7324
jmp 0x734e
xorl %ecx, %ecx
jmp 0x736c
movq %r12, %rax
testq %r12, %r12
je 0x7370
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x7350
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movq %rcx, %rax
retq
xorl %ecx, %ecx
jmp 0x7361
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/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;

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
movb %sil, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
testq %rdi, %rdi
je 0x73fc
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rdi, %r15
xorl %ebp, %ebp
movl %ecx, %r14d
leaq 0x8(%r15), %rdi
callq 0x3200
leal (%r14,%rax), %ecx
movq (%r15), %r15
incl %ebp
testq %r15, %r15
jne 0x7394
addl %ebp, %r14d
addl %eax, %r14d
movslq %r14d, %rdi
callq 0xec7f
movq %rax, %r14
testq %rbx, %rbx
je 0x73ee
leaq 0x6(%rsp), %r15
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x36b0
cmpq $0x0, (%rbx)
je 0x73ee
movq %r14, %rdi
movq %r15, %rsi
callq 0x36b0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x73c9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xec7f
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameLoadReal
struct slName *slNameLoadReal(char *fileName)
/* load file lines that are not blank or start with a '#' into a slName
 * list */
{
struct slName *lines = NULL;
char *line;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
while (lineFileNextReal(lf, &line))
    slSafeAddHead(&lines, slNameNew(line));
lineFileClose(&lf);
slReverse(&lines);
return lines;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %esi
callq 0xcef9
movq %rax, %r14
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xd937
testl %eax, %eax
je 0x7483
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
movq %rbx, %r12
movq 0x10(%rsp), %rdi
callq 0x6cb2
movq %rax, %rbx
movq %r12, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd937
testl %eax, %eax
jne 0x7442
leaq 0x8(%rsp), %rdi
callq 0xd560
xorl %ecx, %ecx
movq %rbx, %rax
movq (%rbx), %rbx
movq %rcx, (%rax)
movq %rax, %rcx
testq %rbx, %rbx
jne 0x7470
jmp 0x748f
leaq 0x8(%rsp), %rdi
callq 0xd560
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slNameIntersection
struct slName *slNameIntersection(struct slName *a, struct slName *b)
/* return intersection of two slName lists.  */
{
struct hash *hashA = newHash(0);
struct slName *el, *retval = NULL;

for (el = a; el != NULL; el = el->next)
    hashAddInt(hashA, el->name, 1);
for (el = b; el != NULL; el = el->next)
    if(hashLookup(hashA, el->name) != NULL)
        slNameAddHead(&retval, el->name);
hashFree(&hashA);
return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %r14
movq %rax, (%rsp)
testq %r15, %r15
je 0x74d7
leaq 0x8(%r15), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xc123
movq (%r15), %r15
jmp 0x74bc
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x7506
leaq 0x8(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xbb8c
testq %rax, %rax
je 0x7501
movq %r12, %rdi
callq 0x6cb2
movq %r15, (%rax)
movq %rax, %r15
movq (%rbx), %rbx
jmp 0x74da
movq %rsp, %rdi
callq 0xc51f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slRefFreeListAndVals
void slRefFreeListAndVals(struct slRef **pList)
/* Free up (with simple freeMem()) each val on list, and the list itself as well. */
{
struct slRef *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    freeMem(el->val);
    freeMem(el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x75db
movq (%r14), %r15
movq 0x8(%r14), %rdi
callq 0xeebc
movq %r14, %rdi
callq 0xeebc
movq %r15, %r14
testq %r15, %r15
jne 0x75bf
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: refListFromSlList
struct slRef *refListFromSlList(void *list)
/* Make a reference list that mirrors a singly-linked list. */
{
struct slList *el;
struct slRef *refList = NULL, *ref;
for (el= list; el != NULL; el = el->next)
    {
    ref = slRefNew(el);
    slAddHead(&refList, ref);
    }
slReverse(&refList);
return refList;
}

// Assembly:
testq %rdi, %rdi
je 0x762e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, %r14
movl $0x10, %edi
callq 0xee10
movq %rbx, 0x8(%rax)
movq %r14, (%rax)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x75f6
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x7614
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7630
xorl %ecx, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slPairNew
struct slPair *slPairNew(char *name, void *val)
/* Allocate new name/value pair. */
{
struct slPair *el;
AllocVar(el);
el->name = cloneString(name);
el->val = val;
return el;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xee10
movq %rax, %r15
movq %r14, %rdi
callq 0x6402
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slPairFree
void slPairFree(struct slPair **pEl)
/* Free up struct and name.  (Don't free up values.) */
{
struct slPair *el = *pEl;
if (el != NULL)
    {
    freeMem(el->name);
    freez(pEl);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x76c9
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0xeebc
movq %rbx, %rdi
popq %rbx
jmp 0xeecc
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slPairFreeList
void slPairFreeList(struct slPair **pList)
/* Free up list.  (Don't free up values.) */
{
struct slPair *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    slPairFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x76fd
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x76ab
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x76e8
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slPairFind
struct slPair *slPairFind(struct slPair *list, char *name)
/* Return list element of given name, or NULL if not found. */
{
struct slPair *el;
for (el = list; el != NULL; el = el->next)
    if (sameString(name, el->name))
        break;
return el;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x777d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0x777f
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x7765
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: skipLeadingSpaces
char *skipLeadingSpaces(char *s)
/* Return first non-white space. */
{
char c;
if (s == NULL) return NULL;
for (;;)
    {
    c = *s;
    if (!isspace(c))
	return s;
    ++s;
    }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7b32
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7b21
jmp 0x7b34
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: safecpy
void safecpy(char *buf, size_t bufSize, const char *src)
/* copy a string to a buffer, with bounds checking.*/
{
size_t slen = strlen(src);
if (slen > bufSize-1)
    errAbort("buffer overflow, size %lld, string size: %lld", (long long)bufSize, (long long)slen);
strcpy(buf, src);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x3200
leaq -0x1(%r15), %rcx
cmpq %rcx, %rax
jbe 0x7b6c
leaq 0x11d06(%rip), %rdi     # 0x19865
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x30e0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: differentStringNullOk
int differentStringNullOk(char *a, char *b)
/* Returns 0 if two strings (either of which may be NULL)
 * are the same.  Otherwise it returns a positive or negative
 * number depending on the alphabetical order of the two
 * strings.
 * This is basically a strcmp that can handle NULLs in
 * the input.  If used in a sort the NULLs will end
 * up before any of the cases with data.   */
{
if (a == b)
    return FALSE;
else if (a == NULL)
    return -1;
else if (b == NULL)
    return 1;
else
    return strcmp(a,b) != 0;
}

// Assembly:
cmpq %rsi, %rdi
je 0x8029
testq %rdi, %rdi
je 0x802c
testq %rsi, %rsi
je 0x8032
pushq %rax
callq 0x3440
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: startsWith
boolean startsWith(const char *start, const char *string)
/* Returns TRUE if string begins with start. */
{
char c;
int i;

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

// Assembly:
movb (%rdi), %cl
movl $0x1, %eax
testb %cl, %cl
je 0x8055
xorl %edx, %edx
cmpb %cl, (%rsi,%rdx)
jne 0x8056
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8045
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: startsWithWord
boolean startsWithWord(char *firstWord, char *line)
/* Return TRUE if first white-space-delimited word in line
 * is same as firstWord.  Comparison is case sensitive. */
{
int len = strlen(firstWord);
int i;
for (i=0; i<len; ++i)
   if (firstWord[i] != line[i])
       return FALSE;
char c = line[len];
return c == 0 || isspace(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3200
movq %rax, %rcx
testl %ecx, %ecx
jle 0x808d
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %esi, %esi
movb (%r14,%rsi), %dil
cmpb (%rbx,%rsi), %dil
jne 0x80b3
incq %rsi
cmpq %rsi, %rdx
jne 0x807b
movslq %ecx, %rax
movsbq (%rbx,%rax), %rbx
testq %rbx, %rbx
je 0x80ae
callq 0x37a0
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
shrl $0xd, %eax
andl $0x1, %eax
jmp 0x80b3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: startsWithWordByDelimiter
boolean startsWithWordByDelimiter(char *firstWord,char delimit, char *line)
/* Return TRUE if first word in line is same as firstWord as delimited by delimit.
   Comparison is case sensitive. Delimit of ' ' uses isspace() */
{
if (delimit == ' ')
    return startsWithWord(firstWord,line);
if (!startsWith(firstWord,line))
    return FALSE;
char c = line[strlen(firstWord)];
return (c == '\0' || c == delimit);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
cmpb $0x20, %bpl
jne 0x80d7
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8059
movb (%rdi), %cl
testb %cl, %cl
je 0x80f1
xorl %eax, %eax
xorl %edx, %edx
cmpb %cl, (%rbx,%rdx)
jne 0x8109
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x80e1
callq 0x3200
movb (%rbx,%rax), %al
testb %al, %al
sete %cl
cmpb %bpl, %al
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: findWordByDelimiter
char * findWordByDelimiter(char *word,char delimit, char *line)
/* Return pointer to first occurance of word in line broken by 'delimit' char
   Comparison is case sensitive. Delimit of ' ' uses isspace() */
{
int ix;
char *p=line;
while (p!=NULL && *p!='\0')
    {
    for (ix = 0;
         word[ix] != '\0' && word[ix] == *p;
         ix++,p++) ; // advance as long as they match
    if (ix == strlen(word))
        {
        if (*p=='\0'
        || *p==delimit
        || (delimit == ' ' && isspace(*p)))
            return p - ix; // matched and delimited
        }
    for (;   *p!='\0' && *p!=delimit && (delimit != ' ' || !isspace(*p)); p++)
        ;  // advance to next delimit
    if (*p!='\0')
        {
        p++;
        continue;  // delimited so start again after delimit
        }
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x81f2
movq %rdx, %rbx
movb (%rdx), %r13b
testb %r13b, %r13b
je 0x81f2
movl %esi, %ebp
movq %rdi, %r14
movb (%rdi), %r12b
callq 0x3200
movq %rax, (%rsp)
xorl %r15d, %r15d
testb %r12b, %r12b
je 0x816b
movl %r12d, %eax
movb (%rbx,%r15), %r13b
cmpb %r13b, %al
jne 0x8168
movb 0x1(%r14,%r15), %al
incq %r15
testb %al, %al
jne 0x814f
movb (%rbx,%r15), %r13b
addq %r15, %rbx
cmpq %r15, (%rsp)
jne 0x819c
testb %r13b, %r13b
je 0x8206
cmpb %bpl, %r13b
je 0x8206
cmpb $0x20, %bpl
jne 0x819c
callq 0x37a0
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8206
testb %r13b, %r13b
sete %al
cmpb %bpl, %r13b
sete %cl
orb %al, %cl
jne 0x81dd
cmpb $0x20, %bpl
jne 0x81c5
callq 0x37a0
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x81db
movb 0x1(%rbx), %r13b
incq %rbx
testb %r13b, %r13b
sete %al
je 0x81dd
cmpb %bpl, %r13b
jne 0x81ac
jmp 0x81dd
xorl %eax, %eax
xorb $0x1, %al
movzbl %al, %eax
movb (%rbx,%rax), %r13b
addq %rax, %rbx
testb %r13b, %r13b
jne 0x8144
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subq %r15, %rbx
jmp 0x81f4
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: rStringIn
char *rStringIn(char *needle, char *haystack)
/* Return last position of needle in haystack, or NULL if it's not there. */
{
int nSize = strlen(needle);
char *pos;
for (pos = haystack + strlen(haystack) - nSize; pos >= haystack; pos -= 1)
    {
    if (memcmp(needle, pos, nSize) == 0)
        return pos;
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3200
movq %rax, %r12
movq %rbx, %rdi
callq 0x3200
movq %rax, %r15
addq %rbx, %r15
movslq %r12d, %r12
subq %r12, %r15
cmpq %rbx, %r15
jb 0x8251
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3550
testl %eax, %eax
je 0x8254
decq %r15
jmp 0x8235
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: stringBetween
char *stringBetween(char *start, char *end, char *haystack)
/* Return string between start and end strings, or NULL if
 * none found.  The first such instance is returned.
 * String must be freed by caller. */
{
char *pos, *p;
int len;
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;
        return pos;
        }
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
movq %r15, %rsi
callq 0x3760
testq %rax, %rax
je 0x82cf
movq %rax, %rbx
movq %r15, %rdi
callq 0x3200
addq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3760
testq %rax, %rax
je 0x82cf
movq %rax, %r14
subq %rbx, %r14
leal 0x1(%r14), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0xec18
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x34a0
movslq %r14d, %rax
movb $0x0, (%r15,%rax)
jmp 0x82d2
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: endsWith
boolean endsWith(char *string, char *end)
/* Returns TRUE if string ends with end. */
{
int sLen, eLen, offset;
sLen = strlen(string);
eLen = strlen(end);
offset = sLen - eLen;
if (offset < 0)
    return FALSE;
return sameString(string+offset, end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %rbx, %rdi
callq 0x3200
subl %eax, %r15d
js 0x831d
movl %r15d, %eax
addq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3440
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x831f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: lastNonwhitespaceChar
char *lastNonwhitespaceChar(char *s)
// Return pointer to last character in string that is not whitespace.
{
if (s == NULL || s[0] == 0)
    return NULL;

char *sPos = s + (strlen(s) - 1);
for (;sPos >= s;sPos--)
    {
    if (!isspace(*sPos))
        return sPos;
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x83a3
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x83a3
movq %r14, %rdi
callq 0x3200
leaq (%rax,%r14), %r15
decq %r15
xorl %ebx, %ebx
cmpq %r14, %r15
jb 0x83a5
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
decq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8380
incq %r15
movq %r15, %rbx
jmp 0x83a5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: memMatch
char *memMatch(char *needle, int nLen, char *haystack, int hLen)
/* Returns first place where needle (of nLen chars) matches
 * haystack (of hLen chars) */
{
char c = *needle++;
nLen -= 1;
hLen -= nLen;
while (--hLen >= 0)
    {
    if (*haystack++ == c && memcmp(needle, haystack, nLen) == 0)
        {
        return haystack-1;
        }
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leal -0x1(%rsi), %eax
cmpl %eax, %ecx
jle 0x8417
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movb (%rdi), %r13b
incq %r14
movslq %eax, %r15
subl %esi, %ebp
addl $0x2, %ebp
leaq 0x1(%rbx), %r12
cmpb %r13b, (%rbx)
jne 0x840d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3550
testl %eax, %eax
je 0x8419
decl %ebp
movq %r12, %rbx
cmpl $0x1, %ebp
ja 0x83f2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: toggleCase
void toggleCase(char *s, int size)
/* toggle upper and lower case chars in string. */
{
char c;
int i;
for (i=0; i<size; ++i)
    {
    c = s[i];
    if (isupper(c))
        c = tolower(c);
    else if (islower(c))
        c = toupper(c);
    s[i] = c;
    }
}

// Assembly:
testl %esi, %esi
jle 0x84fe
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x37a0
movq %rax, %r14
movl %ebp, %r15d
xorl %r12d, %r12d
movb (%rbx,%r12), %al
movq (%r14), %rcx
movsbq %al, %r13
movzwl (%rcx,%r13,2), %ecx
btl $0x8, %ecx
jb 0x84d8
btl $0x9, %ecx
jae 0x84e4
callq 0x3030
jmp 0x84dd
callq 0x3790
movq (%rax), %rax
movb (%rax,%r13,4), %al
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x84b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: strUpper
char *strUpper(char *s)
/* Convert entire string to upper case. */
{
char c;
char *ss=s;
for (;;)
    {
    if ((c = *ss) == 0) break;
    *ss++ = toupper(c);
    }
return s;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x852e
callq 0x3030
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x8516
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: replaceChars
char *replaceChars(char *string, char *old, char *new)
/*
  Replaces the old with the new. The old and new string need not be of equal size
 Can take any length string.
 Return value needs to be freeMem'd.
*/
{
int numTimes = 0;
int oldLen = strlen(old);
int newLen = strlen(new);
int strLen = 0;
char *result = NULL;
char *ptr = strstr(string, old);
char *resultPtr = NULL;

while(NULL != ptr)
    {
    numTimes++;
    ptr += oldLen;
    ptr = strstr(ptr, old);
    }
strLen = max(strlen(string) + (numTimes * (newLen - oldLen)), strlen(string));
result = needMem(strLen + 1);

ptr = strstr(string, old);
resultPtr = result;
while(NULL != ptr)
    {
    strLen = ptr - string;
    strcpy(resultPtr, string);
    string = ptr + oldLen;

    resultPtr += strLen;
    strcpy(resultPtr, new);
    resultPtr += newLen;
    ptr = strstr(string, old);
    }

strcpy(resultPtr, string);
return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r13
movq %rsi, %rdi
callq 0x3200
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3200
movq %rax, %r15
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3760
testq %rax, %rax
je 0x8596
movslq %r12d, %r14
xorl %ebx, %ebx
addq %r14, %rax
incl %ebx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x3760
testq %rax, %rax
jne 0x857f
jmp 0x8598
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x3200
movq %r15, %r14
movl %r14d, %ecx
subl %r12d, %ecx
imull %ebx, %ecx
movslq %ecx, %rcx
addq %rax, %rcx
cmpq %rax, %rcx
cmovbeq %rax, %rcx
incl %ecx
movslq %ecx, %rdi
callq 0xee10
movq %rax, %r15
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3760
testq %rax, %rax
movq %r15, 0x10(%rsp)
je 0x8643
movq %rax, %rbx
movslq %r12d, %rax
movq %rax, 0x20(%rsp)
movq %r15, %rax
movq 0x8(%rsp), %r15
movslq %r14d, %rcx
movq %rcx, 0x18(%rsp)
movq %rbp, %r14
movq %rax, %rbp
movl %ebx, %r12d
subl %r13d, %r12d
movq %rbp, %rdi
movq %r13, %rsi
callq 0x30e0
movq %rbx, %r13
addq 0x20(%rsp), %r13
movslq %r12d, %r12
addq %rbp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x30e0
addq 0x18(%rsp), %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0x3760
movq %rax, %rbx
movq %r12, %rbp
testq %rax, %rax
jne 0x85fc
jmp 0x8646
movq %r15, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x30e0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: strSwapStrs
int strSwapStrs(char *string, int sz,char *oldStr, char *newStr)
/* Swaps all occurrences of the old with the new in string. Need not be same size
   Swaps in place but restricted by sz.  Returns count of swaps or -1 for sz failure. */
{
// WARNING: called at low level, so no errors allowed.
int count = 0;
char *p=NULL;
for(p=strstr(string,oldStr);p!=NULL;p=strstr(p+strlen(oldStr),oldStr))
    count++;
if (count == 0)
    return 0;
if((strlen(string)+(count*(strlen(newStr) - strlen(oldStr))))>=sz)
    return -1;
for(p=strstr(string,oldStr);p!=NULL;p=strstr(p+strlen(newStr),oldStr))
    {
    memmove(p+strlen(newStr),p+strlen(oldStr),strlen(p+strlen(oldStr))+1); // NULL at end is also moved!
    memcpy(p,newStr,strlen(newStr));
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq %rdx, %rsi
callq 0x3760
testq %rax, %rax
je 0x8769
movq %rax, %r15
movl %ebp, 0x4(%rsp)
movq %r14, %rdi
callq 0x3200
movq %rax, %r13
xorl %ebp, %ebp
movq %r15, %rax
addq %r13, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x3760
incq %rbp
testq %rax, %rax
jne 0x86a3
testq %r15, %r15
sete 0x3(%rsp)
movq %r12, %rdi
callq 0x3200
movq %rax, %r12
movq %rbx, %rdi
callq 0x3200
movq %rax, %r13
movq %r14, %rdi
callq 0x3200
subq %rax, %r13
imulq %rbp, %r13
addq %r12, %r13
movslq 0x4(%rsp), %rax
cmpq %rax, %r13
setae %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %ebp, %eax
orb 0x3(%rsp), %cl
jne 0x876b
movq %rbx, %rdi
callq 0x3200
leaq (%rax,%r15), %r12
movq %r14, %rdi
callq 0x3200
leaq (%rax,%r15), %r13
movq %r13, %rdi
callq 0x3200
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x35d0
movq %rbx, %rdi
callq 0x3200
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x34a0
movq %rbx, %rdi
callq 0x3200
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3760
movq %rax, %r15
testq %rax, %rax
jne 0x8702
movl %ebp, %eax
jmp 0x876b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: strLower
char *strLower(char *s)
/* Convert entire string to lower case */
{
char c;
char *ss=s;
for (;;)
    {
    if ((c = *ss) == 0) break;
    *ss++ = tolower(c);
    }
return s;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x87a9
callq 0x3790
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x8791
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: memSwapChar
char * memSwapChar(char *s, int len, char oldChar, char newChar)
/* Substitute newChar for oldChar throughout memory of given length. */
{
int ix=0;
for (;ix<len;ix++)
    {
    if (s[ix] == oldChar)
        s[ix] =  newChar;
    }
return s;
}

// Assembly:
movq %rdi, %rax
testl %esi, %esi
jle 0x87ce
movl %esi, %esi
xorl %edi, %edi
cmpb %dl, (%rax,%rdi)
jne 0x87c6
movb %cl, (%rax,%rdi)
incq %rdi
cmpq %rdi, %rsi
jne 0x87be
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: stripEnclosingChar
char *stripEnclosingChar(char *inout,char encloser)
// Removes enclosing char if found at both beg and end, preserving pointer
// Note: handles brackets '(','{' and '[' by complement at end
{
if (inout == NULL || strlen(inout) < 2 || *inout != encloser)
    return inout;

char *end = inout + (strlen(inout) - 1);
char closer = encloser;
switch (closer)
    {
    case '(': closer = ')'; break;
    case '{': closer = '}'; break;
    case '[': closer = ']'; break;
    default: break;
    }
if (*end  != closer)
    return inout;
*end = '\0';
return memmove(inout,inout+1,strlen(inout));  // use memmove to safely copy in place
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x883a
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3200
cmpq $0x2, %rax
jb 0x883a
cmpb %bpl, (%rbx)
jne 0x883a
movsbl %bpl, %ecx
cmpl $0x7b, %ecx
je 0x880d
cmpl $0x5b, %ecx
je 0x8808
cmpl $0x28, %ecx
jne 0x8810
movb $0x29, %bpl
jmp 0x8810
movb $0x5d, %bpl
jmp 0x8810
movb $0x7d, %bpl
cmpb %bpl, -0x1(%rbx,%rax)
jne 0x883a
movb $0x0, -0x1(%rbx,%rax)
leaq 0x1(%rbx), %r14
movq %rbx, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x35d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: stripString
void stripString(char *s, char *strip)
/* Remove all occurences of strip from s. */
{
char c, *in = s, *out = s;
int stripSize = strlen(strip);
char stripFirst = strip[0];

while ((c = *in) != 0)
    {
    c = *in;
    if (c == stripFirst)
        {
	if (startsWith(strip, in))
	    {
	    in += stripSize;
	    continue;
	    }
	}
    *out = c;
    ++out;
    ++in;
    }
*out = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %r15b
testb %r15b, %r15b
je 0x88a7
movq %rsi, %r14
movb (%rsi), %bpl
movq %rsi, %rdi
callq 0x3200
movslq %eax, %rcx
movq %rbx, %rax
cmpb %bpl, %r15b
jne 0x8893
movb (%r14), %dl
testb %dl, %dl
je 0x8887
xorl %esi, %esi
cmpb %dl, (%rbx,%rsi)
jne 0x8890
movb 0x1(%r14,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x8876
movb (%rbx,%rcx), %r15b
addq %rcx, %rbx
jmp 0x88a0
movl %ebp, %r15d
movb %r15b, (%rax)
incq %rax
movb 0x1(%rbx), %r15b
incq %rbx
testb %r15b, %r15b
jne 0x8868
jmp 0x88aa
movq %rbx, %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: countCase
int countCase(char *s,boolean upper)
// Count letters with case (upper or lower)
{
char a;
int count = 0;
while ((a = *s++) != 0)
    if (( upper && isupper(a))
    ||  (!upper && islower(a)))
        ++count;
return count;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x88ff
movl %esi, %ebx
movq %rdi, %r14
callq 0x37a0
movq (%rax), %rcx
incq %r14
xorl %eax, %eax
movsbq %bpl, %rdx
movzwl (%rcx,%rdx,2), %edx
testl %ebx, %ebx
je 0x88f7
btl $0x8, %edx
jae 0x88ea
incl %eax
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x88d6
jmp 0x8901
btl $0x9, %edx
jb 0x88e8
jmp 0x88ea
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: countChars
int countChars(char *s, char c)
/* Return number of characters c in string s. */
{
char a;
int count = 0;
while ((a = *s++) != 0)
    if (a == c)
        ++count;
return count;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x8925
incq %rdi
xorl %eax, %eax
xorl %edx, %edx
cmpb %sil, %cl
sete %dl
addl %edx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x8911
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: countCharsN
int countCharsN(char *s, char c, int size)
/* Return number of characters c in string s of given size. */
{
int i;
int count = 0;
for (i=0; i<size; ++i)
    if (s[i] == c)
        ++count;
return count;
}

// Assembly:
testl %edx, %edx
jle 0x8949
movl %edx, %ecx
xorl %edx, %edx
xorl %eax, %eax
xorl %r8d, %r8d
cmpb %sil, (%rdi,%rdx)
sete %r8b
addl %r8d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x8932
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: countLeadingNondigits
int countLeadingNondigits(const char *s)
/* Count number of leading non-digit characters in s. */
{
int count = 0;
char c;
while ((c = *s++) != 0)
   {
   if (isdigit(c))
       break;
   ++count;
   }
return count;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x89c2
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rcx
xorl %eax, %eax
movsbq %bpl, %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x89c4
movb 0x1(%rbx,%rax), %bpl
incq %rax
testb %bpl, %bpl
jne 0x89a8
jmp 0x89c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: countSeparatedItems
int countSeparatedItems(char *string, char separator)
/* Count number of items in string you would parse out with given
 * separator,  assuming final separator is optional. */
{
int count = 0;
char c, lastC = 0;
while ((c = *string++) != 0)
    {   
    if (c == separator)
       ++count;
    lastC = c;
    }
if (lastC != separator && lastC != 0)
    ++count;
return count;
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x89ed
incq %rdi
xorl %ecx, %ecx
movl %edx, %eax
xorl %edx, %edx
cmpb %sil, %al
sete %dl
addl %edx, %ecx
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x89d6
jmp 0x89f1
xorl %ecx, %ecx
xorl %eax, %eax
cmpb %sil, %al
setne %dl
testb %al, %al
setne %al
andb %dl, %al
movzbl %al, %eax
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: cmpWordsWithEmbeddedNumbers
int cmpWordsWithEmbeddedNumbers(const char *a, const char *b)
/* Case insensitive version of cmpStringsWithEmbeddedNumbers. */
{
char *A = cloneString(a);
char *B = cloneString(b);
int diff = cmpStringsWithEmbeddedNumbers(strUpper(A), strUpper(B));
freeMem(A);
freeMem(B);
return diff;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x6402
movq %rax, %rbx
movq %r14, %rdi
callq 0x6402
movq %rax, %r14
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x8a47
callq 0x3030
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x8a2f
movb (%r14), %bpl
testb %bpl, %bpl
je 0x8a72
callq 0x3030
movq %r14, %rcx
incq %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x8a5a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d67
movl %eax, %ebp
movq %rbx, %rdi
callq 0xeebc
movq %r14, %rdi
callq 0xeebc
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: chopString
int chopString(char *in, char *sep, char *outArray[], int outSize)
{
int recordCount = 0;

for (;;)
    {
    if (outArray != NULL && recordCount >= outSize)
	break;
    /* Skip initial separators. */
    in += strspn(in, sep);
    if (*in == 0)
	break;
    if (outArray != NULL)
	outArray[recordCount] = in;
    recordCount += 1;
    in += strcspn(in, sep);
    if (*in == 0)
	break;
    if (outArray != NULL)
	*in = 0;
    in += 1;
    }
return recordCount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
testq %rdx, %rdx
setne %al
testl %ecx, %ecx
setle %cl
xorl %r13d, %r13d
testb %cl, %al
jne 0x8b3b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3370
cmpb $0x0, (%r12,%rax)
je 0x8b3b
addq %rax, %r12
testq %r14, %r14
je 0x8b03
movq %r12, (%r14,%r13,8)
movq %r12, %rdi
movq %r15, %rsi
callq 0x33b0
cmpb $0x0, (%r12,%rax)
je 0x8b38
addq %rax, %r12
testq %r14, %r14
je 0x8b22
movb $0x0, (%r12)
leaq 0x1(%r13), %rax
testq %r14, %r14
sete %cl
incq %r12
cmpl %ebx, %eax
setl %dl
orb %cl, %dl
jne 0x8ae2
incl %r13d
movl %r13d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq