LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7ef8
movl %eax, %ebp
movq %rbx, %rdi
callq 0x7ef8
testl %ebp, %ebp
js 0x6793
movl %eax, %r15d
testl %eax, %eax
js 0x6793
movq %r14, %rdi
callq 0x36a0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x36a0
subl %eax, %r12d
jne 0x67e5
movl %ebp, %eax
addq %rax, %r14
movl %r15d, %eax
addq %rax, %rbx
movq %r14, %rdi
callq 0x7f19
movl %eax, %ebp
movq %rbx, %rdi
callq 0x7f19
cmpl %eax, %ebp
jne 0x67ca
testl %ebp, %ebp
je 0x67dd
movslq %ebp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x33f0
testl %eax, %eax
jne 0x67e2
addq %r15, %r14
addq %r15, %rbx
jmp 0x6753
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3440
xorl %r12d, %r12d
jmp 0x67e5
movl %eax, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6868
shll $0x18, %esi
incq %rdx
testl %esi, %esi
jne 0x6843
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6943
leaq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
jne 0x6924
jmp 0x695b
movq %r14, %rdi
callq 0x6692
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_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x69cc
leaq 0x8(%rbx), %rdi
callq 0x6692
movq %r14, (%rax)
movq (%rbx), %rbx
movq %rax, %r14
jmp 0x69b3
movq %rsp, %rbx
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
movq %r12, (%rsp)
testq %r14, %r14
je 0x6a3f
cmpb $0x0, (%r14)
je 0x6a3f
movq %r14, %rdi
movl %ebx, %esi
callq 0x3260
testq %rax, %rax
je 0x6a2c
movq %rax, %r15
movl %r15d, %esi
subl %r14d, %esi
movq %r14, %rdi
callq 0x66d1
incq %r15
movq %r15, %r14
jmp 0x6a37
movq %r14, %rdi
callq 0x6692
xorl %r14d, %r14d
movq %r12, (%rax)
movq %rax, %r12
jmp 0x69f5
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
testq %rdi, %rdi
je 0x6ac9
movq %r14, %rdi
testl %ebx, %ebx
je 0x6aaa
callq 0x6ae5
testq %rax, %rax
je 0x6ac9
movq %rax, %r12
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x6a9d
cmpl $0x27, %eax
jne 0x6ab7
movsbl %al, %esi
movq %r12, %rdi
callq 0x6b72
jmp 0x6ab7
callq 0x6b8e
movq %rax, %r12
testq %rax, %rax
je 0x6ac9
movq %r15, %rdi
movq %r12, %rsi
callq 0x6913
movq 0x10(%rsp), %rdi
jmp 0x6a77
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6b1d
cmpb $0x0, (%rdi)
je 0x6b1d
callq 0x722d
movq %rax, %rbx
movzbl (%rax), %eax
testl %eax, %eax
je 0x6b1d
cmpl $0x27, %eax
je 0x6b21
cmpl $0x22, %eax
jne 0x6b4a
movq %rbx, %rdi
incq %rdi
pushq $0x22
jmp 0x6b29
xorl %ebx, %ebx
jmp 0x6b69
movq %rbx, %rdi
incq %rdi
pushq $0x27
popq %rsi
callq 0x823c
testq %rax, %rax
je 0x6b63
movq %rax, %r15
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6b5a
movq %rbx, %rdi
callq 0x827c
movq %rax, %r15
testq %rax, %rax
je 0x6b63
movb $0x0, (%r15)
incq %r15
jmp 0x6b66
xorl %r15d, %r15d
movq %r15, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6bc7
cmpb $0x0, (%rdi)
je 0x6bc7
callq 0x722d
cmpb $0x0, (%rax)
je 0x6bc7
movq %rax, %rbx
movq %rax, %rdi
callq 0x827c
testq %rax, %rax
je 0x6bcb
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x6bcd
xorl %ebx, %ebx
jmp 0x6bd0
xorl %ecx, %ecx
movq %rcx, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6c28
movl %esi, %r14d
movq %rdi, %r15
testl %esi, %esi
cmovlel %ebx, %r14d
xorl %r12d, %r12d
cmpq %rbx, %r14
je 0x6c17
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
je 0x6c17
callq 0x6692
movq %r12, (%rax)
incq %rbx
movq %rax, %r12
jmp 0x6bf9
movq %rsp, %rbx
movq %r12, (%rbx)
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb %sil, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rdi, %r15
testq %r15, %r15
je 0x6c70
leaq 0x8(%r15), %rdi
callq 0x3200
addl %eax, %r14d
movq (%r15), %r15
incl %ebp
jmp 0x6c58
addl %r14d, %ebp
movslq %ebp, %rdi
callq 0xd6eb
movq %rax, %r14
leaq 0xe(%rsp), %r15
testq %rbx, %rbx
je 0x6cb3
movq %rbx, %r12
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x36b0
cmpq $0x0, (%rbx)
movl $0x0, %ebx
je 0x6c83
movq %r14, %rdi
movq %r15, %rsi
callq 0x36b0
movq (%r12), %rbx
jmp 0x6c83
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
pushq $0x1
popq %rsi
callq 0xbbad
movq %rax, %rbx
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc52c
testl %eax, %eax
je 0x6d05
movq 0x10(%rsp), %rdi
callq 0x6692
movq %r15, (%rax)
movq %rax, %r15
jmp 0x6ce4
leaq 0x18(%rsp), %rbx
movq %r15, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xc178
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0xb010
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x6d6a
leaq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xaf7f
movq (%r15), %r15
jmp 0x6d52
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x6d99
leaq 0x8(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xaaa4
testq %rax, %rax
je 0x6d94
movq %r12, %rdi
callq 0x6692
movq %r15, (%rax)
movq %rax, %r15
movq (%rbx), %rbx
jmp 0x6d6d
leaq 0x8(%rsp), %rdi
callq 0xb306
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: refAdd
void refAdd(struct slRef **pRefList, void *val)
/* Add reference to list. */
{
struct slRef *ref;
AllocVar(ref);
ref->val = val;
slAddHead(pRefList, ref);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0xd87c
movq %rbx, 0x8(%rax)
movq (%r14), %rcx
movq %rcx, (%rax)
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6e5a
movq (%r14), %r15
movq 0x8(%r14), %rdi
callq 0xd8f9
movq %r14, %rdi
callq 0xd8f9
movq %r15, %r14
jmp 0x6e3c
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x6e86
movq %rbx, %rdi
callq 0x6dc7
movq %r14, (%rax)
movq (%rbx), %rbx
movq %rax, %r14
jmp 0x6e6e
movq %rsp, %rbx
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
movq %rax, %r15
movq %r14, %rdi
callq 0x5ede
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6f06
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0xd8f9
movq %rbx, %rdi
popq %rbx
jmp 0xd909
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x6f32
movq (%r15), %r15
movq %r14, %rdi
callq 0x6ee8
jmp 0x6f1b
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x6f92
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0x6f92
movq (%rbx), %rbx
jmp 0x6f78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7252
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7241
jmp 0x7254
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x728c
leaq 0x105e6(%rip), %rdi     # 0x17865
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa61f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x30e0
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: slPairNameToString
char *slPairNameToString(struct slPair *list, char delimiter,boolean quoteIfSpaces)
// Return string created by joining all names (ignoring vals) with the delimiter.
// If requested, will wrap name in quotes if contain spaces: [name1,"name 2" ...]
{
int elCount = 0;
int count = 0;
struct slPair *pair = list;
for (; pair != NULL; pair = pair->next, elCount++)
    {
    assert(pair->name != NULL);
    count += strlen(pair->name);
    if (quoteIfSpaces && hasWhiteSpace(pair->name))
        count += 2;
    }
count += elCount;
if (count == 0)
    return NULL;

char *str = needMem(count+5); // A bit of slop

char *strPtr = str;
for (pair = list; pair != NULL; pair = pair->next, strPtr += strlen(strPtr))
    {
    if (pair != list)
        *strPtr++ = delimiter;
    if (hasWhiteSpace(pair->name))
        {
        if (quoteIfSpaces)
            sprintf(strPtr,"\"%s\"",pair->name);
        else
            {
            if (delimiter == ' ')  // if delimied by commas, this is entirely okay!
                warn("slPairListToString() Unexpected white space in name delimied by space: "
                     "[%s]\n", pair->name);
            sprintf(strPtr,"%s",pair->name); // warn but still make string
            }
        }
    else
        sprintf(strPtr,"%s",pair->name);
    }
return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, 0xc(%rsp)
movq %rdi, %rbp
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rdi, %r13
testq %r13, %r13
je 0x74e3
movq 0x8(%r13), %r15
testq %r15, %r15
je 0x758f
movq %r15, %rdi
callq 0x3200
addl %eax, %r14d
testl %ebx, %ebx
je 0x74da
movq %r15, %rdi
callq 0x729c
leal 0x2(%r14), %ecx
testl %eax, %eax
cmovel %r14d, %ecx
movl %ecx, %r14d
movq (%r13), %r13
decl %r12d
jmp 0x74a4
subl %r12d, %r14d
jne 0x74ef
xorl %eax, %eax
jmp 0x7580
addl $0x5, %r14d
movslq %r14d, %rdi
callq 0xd87c
movq %rax, %r15
movq %rbp, %r14
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %r13d
testq %r14, %r14
je 0x757b
cmpq %rbp, %r14
je 0x751b
movb %r13b, (%r15)
incq %r15
movq 0x8(%r14), %r12
movq %r12, %rdi
callq 0x729c
testl %eax, %eax
je 0x7560
testl %ebx, %ebx
je 0x7545
movq %r15, %rdi
leaq 0x116a1(%rip), %rsi     # 0x18bda
movq %r12, %rdx
xorl %eax, %eax
callq 0x36d0
jmp 0x756b
cmpb $0x20, %r13b
jne 0x7560
leaq 0xff66(%rip), %rdi      # 0x174b8
movq %r12, %rsi
xorl %eax, %eax
callq 0xa3aa
movq 0x8(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30e0
movq (%r14), %r14
movq %r15, %rdi
callq 0x3200
addq %rax, %r15
jmp 0x750b
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfeda(%rip), %rdi      # 0x17470
leaq 0xfe1c(%rip), %rsi      # 0x173b9
leaq 0xfedf(%rip), %rcx      # 0x17483
movl $0x4af, %edx            # imm = 0x4AF
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O2/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 0x769a
testq %rdi, %rdi
je 0x769d
testq %rsi, %rsi
je 0x76a1
pushq %rax
callq 0x3440
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
pushq $-0x1
jmp 0x76a3
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
testl %eax, %eax
movl %eax, %edx
cmovlel %ecx, %edx
cmpq %rcx, %rdx
je 0x76f2
movb (%r14,%rcx), %sil
leaq 0x1(%rcx), %rdi
cmpb (%rbx,%rcx), %sil
movq %rdi, %rcx
je 0x76d8
xorl %eax, %eax
jmp 0x7715
cltq
movsbq (%rbx,%rax), %rbx
testq %rbx, %rbx
je 0x7712
callq 0x37a0
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
shrl $0xd, %eax
andl $0x1, %eax
jmp 0x7715
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x20, %bpl
jne 0x773e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x76c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76a5
testl %eax, %eax
je 0x776a
movq %r14, %rdi
callq 0x3200
movb (%rbx,%rax), %al
testb %al, %al
sete %cl
cmpb %bpl, %al
sete %al
orb %cl, %al
movzbl %al, %eax
jmp 0x776c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
testq %r15, %r15
je 0x781e
cmpb $0x0, (%r15)
je 0x781e
xorl %r13d, %r13d
movb (%r14,%r13), %al
testb %al, %al
je 0x77ab
cmpb (%r15,%r13), %al
jne 0x77ab
incq %r13
jmp 0x7798
movq %r14, %rdi
callq 0x3200
leaq (%r15,%r13), %r12
cmpq %r13, %rax
jne 0x77e0
movsbq (%r12), %r13
testq %r13, %r13
je 0x7821
cmpb %bl, %r13b
je 0x7821
cmpb $0x20, %bl
jne 0x77e0
callq 0x37a0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0x7821
movsbq (%r12), %r15
testq %r15, %r15
sete %al
je 0x780e
cmpb %bl, %r15b
je 0x780e
cmpb $0x20, %bl
jne 0x7807
callq 0x37a0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x780c
incq %r12
jmp 0x77e0
xorl %eax, %eax
xorb $0x1, %al
movzbl %al, %eax
addq %rax, %r12
movq %r12, %r15
jmp 0x7782
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7874
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3550
testl %eax, %eax
je 0x7877
decq %r15
jmp 0x7858
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x78f2
movq %rax, %rbx
movq %r15, %rdi
callq 0x3200
addq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3760
testq %rax, %rax
je 0x78f2
movq %rax, %r14
subq %rbx, %r14
leal 0x1(%r14), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0xd684
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x34a0
movslq %r14d, %rax
movb $0x0, (%r15,%rax)
jmp 0x78f5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7940
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 0x7942
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x79c6
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x79c6
movq %r14, %rdi
callq 0x3200
leaq (%rax,%r14), %r15
decq %r15
xorl %ebx, %ebx
cmpq %r14, %r15
jb 0x79c8
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
decq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x79a3
incq %r15
movq %r15, %rbx
jmp 0x79c8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movb (%rdi), %bpl
incq %r15
decl %esi
subl %esi, %ebx
movslq %esi, %r12
testl %ebx, %ebx
jle 0x7a33
leaq 0x1(%r14), %r13
cmpb %bpl, (%r14)
jne 0x7a2c
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3550
testl %eax, %eax
je 0x7a36
decl %ebx
movq %r13, %r14
jmp 0x7a0d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x7b0e
movb (%r14,%r15), %bpl
callq 0x37a0
movq (%rax), %rax
movsbq %bpl, %r12
movzwl (%rax,%r12,2), %eax
btl $0x8, %eax
jb 0x7af9
btl $0x9, %eax
jae 0x7b05
callq 0x3030
jmp 0x7afe
callq 0x3790
movq (%rax), %rax
movb (%rax,%r12,4), %bpl
movb %bpl, (%r14,%r15)
incq %r15
jmp 0x7acc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movsbq (%r14), %r15
testq %r15, %r15
je 0x7b3f
callq 0x3030
movq (%rax), %rax
movb (%rax,%r15,4), %al
movb %al, (%r14)
incq %r14
jmp 0x7b22
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x3200
movq %rax, %r13
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x3200
movq %rax, %r12
movq %r15, %rdi
movq %r14, (%rsp)
movq %r14, %rsi
callq 0x3760
movslq %r13d, %rbx
movl %r12d, %r14d
subl %ebx, %r14d
xorl %ebp, %ebp
testq %rax, %rax
je 0x7bad
addq %rbx, %rax
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x3760
addl %r14d, %ebp
jmp 0x7b94
movq %r15, %rdi
callq 0x3200
movslq %ebp, %rcx
addq %rax, %rcx
cmpq %rax, %rcx
cmovbeq %rax, %rcx
incl %ecx
movslq %ecx, %rdi
callq 0xd87c
movq %rax, %r13
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x3760
movq %rax, %rbp
movslq %r12d, %r14
movq %r13, 0x8(%rsp)
testq %rbp, %rbp
je 0x7c2c
movl %ebp, %r12d
subl %r15d, %r12d
movq %r13, %rdi
movq %r15, %rsi
callq 0x30e0
addq %rbx, %rbp
movslq %r12d, %r12
addq %r13, %r12
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x30e0
addq %r14, %r12
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x3760
movq %rbp, %r15
movq %rax, %rbp
movq %r12, %r13
jmp 0x7be6
movq %r13, %rdi
movq %r15, %rsi
callq 0x30e0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdx, %r15
movl %esi, 0x4(%rsp)
movq %rdi, %r13
movq %rdx, %rsi
callq 0x3760
movq %rax, %rbp
xorl %ebx, %ebx
movq %rax, %r12
testq %r12, %r12
je 0x7c96
movq %r15, %rdi
callq 0x3200
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3760
movq %rax, %r12
incq %rbx
jmp 0x7c73
testl %ebx, %ebx
je 0x7d35
movq %r13, %rdi
callq 0x3200
movq %rax, %r12
movq %r14, %rdi
callq 0x3200
movq %rax, %r13
movq %r15, %rdi
callq 0x3200
subq %rax, %r13
imulq %rbx, %r13
addq %r12, %r13
movslq 0x4(%rsp), %rax
cmpq %rax, %r13
jae 0x7d39
testq %rbp, %rbp
je 0x7d3c
movq %r14, %rdi
callq 0x3200
leaq (%rax,%rbp), %r12
movq %r15, %rdi
callq 0x3200
leaq (%rax,%rbp), %r13
movq %r13, %rdi
callq 0x3200
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x35d0
movq %r14, %rdi
callq 0x3200
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x34a0
movq %r14, %rdi
callq 0x3200
addq %rax, %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3760
movq %rax, %rbp
jmp 0x7cd0
xorl %ebx, %ebx
jmp 0x7d3c
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %edi, %edi
testl %esi, %esi
cmovlel %edi, %esi
cmpq %rdi, %rsi
je 0x7d9a
cmpb %dl, (%rax,%rdi)
jne 0x7d95
movb %cl, (%rax,%rdi)
incq %rdi
jmp 0x7d88
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7e06
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3200
cmpq $0x2, %rax
jb 0x7e06
cmpb %bpl, (%rbx)
jne 0x7e06
movsbl %bpl, %ecx
cmpl $0x7b, %ecx
je 0x7dd9
cmpl $0x5b, %ecx
je 0x7dd4
cmpl $0x28, %ecx
jne 0x7ddc
movb $0x29, %bpl
jmp 0x7ddc
movb $0x5d, %bpl
jmp 0x7ddc
movb $0x7d, %bpl
cmpb %bpl, -0x1(%rbx,%rax)
jne 0x7e06
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_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3200
movb (%r14), %bpl
movslq %eax, %r12
movq %rbx, %r15
movb (%r15), %al
testb %al, %al
je 0x7e59
cmpb %bpl, %al
jne 0x7e4f
movq %r14, %rdi
movq %r15, %rsi
callq 0x76a5
testl %eax, %eax
je 0x7e4d
addq %r12, %r15
jmp 0x7e2d
movl %ebp, %eax
movb %al, (%rbx)
incq %rbx
incq %r15
jmp 0x7e2d
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
incq %r14
movsbq -0x1(%r14), %r15
testq %r15, %r15
je 0x7ea3
callq 0x37a0
movq (%rax), %rax
movzwl (%rax,%r15,2), %eax
testl %ebx, %ebx
je 0x7e99
btl $0x8, %eax
jae 0x7e73
jmp 0x7e9f
btl $0x9, %eax
jae 0x7e73
incl %ebp
jmp 0x7e73
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movb (%rdi), %cl
testb %cl, %cl
je 0x7ec7
incq %rdi
xorl %edx, %edx
cmpb %sil, %cl
sete %dl
addl %edx, %eax
jmp 0x7eb2
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x7ee9
xorl %r8d, %r8d
cmpb %sil, (%rdi,%rcx)
sete %r8b
addl %r8d, %eax
incq %rcx
jmp 0x7ed1
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
movsbq (%r14,%rbx), %r15
testq %r15, %r15
je 0x7f42
callq 0x37a0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
jne 0x7f42
incq %rbx
jmp 0x7f23
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %edx, %edx
movb (%rdi), %cl
testb %cl, %cl
je 0x7f65
incq %rdi
xorl %edx, %edx
cmpb %sil, %cl
sete %dl
addl %edx, %eax
movl %ecx, %edx
jmp 0x7f4e
cmpb %sil, %dl
setne %cl
testb %dl, %dl
setne %dl
andb %cl, %dl
movzbl %dl, %ecx
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x5ede
movq %rax, %r14
movq %rbx, %rdi
callq 0x5ede
movq %rax, %rbx
movq %r14, %rdi
callq 0x7b17
movq %rbx, %rdi
callq 0x7b17
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6745
movl %eax, %ebp
movq %r14, %rdi
callq 0xd8f9
movq %rbx, %rdi
callq 0xd8f9
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq %ecx, %r13
xorl %ebx, %ebx
testq %r14, %r14
sete %al
cmpq %r13, %rbx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x8050
movq %r12, %rdi
movq %r15, %rsi
callq 0x3370
cmpb $0x0, (%r12,%rax)
je 0x8050
addq %rax, %r12
testq %r14, %r14
je 0x8026
movq %r12, (%r14,%rbx,8)
movq %r12, %rdi
movq %r15, %rsi
callq 0x33b0
cmpb $0x0, (%r12,%rax)
je 0x804d
addq %rax, %r12
testq %r14, %r14
je 0x8045
movb $0x0, (%r12)
incq %r12
incq %rbx
jmp 0x7ff5
incq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: chopByWhite
int chopByWhite(char *in, char *outArray[], int outSize)
/* Like chopString, but specialized for white space separators. 
 * See the GOTCHA in chopString */
{
int recordCount = 0;
char c;
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;
    for (;;)
        {
        if ((c = *in) == 0)
            break;
        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
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r12
xorl %ebx, %ebx
testq %r14, %r14
sete %al
cmpq %r12, %rbx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x80df
callq 0x37a0
movq (%rax), %rdx
leaq -0x1(%r15), %rcx
incq %r15
movq %r15, %rdi
movq %rdi, %r15
movsbq 0x1(%rcx), %rsi
incq %rcx
incq %rdi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x8094
testb %sil, %sil
je 0x80df
testq %r14, %r14
je 0x80b7
movq %rcx, (%r14,%rbx,8)
incq %rbx
movsbq -0x1(%r15), %rcx
testq %rcx, %rcx
je 0x80df
movq (%rax), %rdx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x80d3
incq %r15
jmp 0x80ba
testq %r14, %r14
je 0x806f
movb $0x0, -0x1(%r15)
jmp 0x806f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: chopByChar
int chopByChar(char *in, char chopper, char *outArray[], int outSize)
/* Chop based on a single character. */
{
int i;
char c;
if (*in == 0)
    return 0;
for (i=0; (i<outSize) || (outArray==NULL); ++i)
    {
    if (outArray != NULL)
        outArray[i] = in;
    for (;;)
	{
	if ((c = *in++) == 0)
	    return i+1;
	else if (c == chopper)
	    {
            if (outArray != NULL)
                in[-1] = 0;
	    break;
	    }
	}
    }
return i;
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x8239
movslq %ecx, %rcx
xorl %eax, %eax
testq %rdx, %rdx
setne %r8b
cmpq %rcx, %rax
setge %r9b
testb %r9b, %r8b
jne 0x8238
testq %rdx, %rdx
je 0x8218
movq %rdi, (%rdx,%rax,8)
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x8236
incq %rdi
cmpb %sil, %r8b
jne 0x8218
testq %rdx, %rdx
je 0x8231
movb $0x0, -0x1(%rdi)
incq %rax
jmp 0x81fc
incl %eax
retq
xorl %eax, %eax
retq