LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: slDoubleCmp
int slDoubleCmp(const void *va, const void *vb)
/* Compare two slDoubles. */
{
const struct slDouble *a = *((struct slDouble **)va);
const struct slDouble *b = *((struct slDouble **)vb);
double diff = a->val - b->val;
if (diff < 0)
    return -1;
else if (diff > 0)
    return 1;
else
    return 0;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
movsd 0x8(%rax), %xmm0
subsd 0x8(%rcx), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
ucomisd %xmm0, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: slDoubleMedian
double slDoubleMedian(struct slDouble *list)
/* Return median value on list. */
{
int i,count = slCount(list);
struct slDouble *el;
double *array, median;
if (count == 0)
    errAbort("Can't take median of empty list");
AllocArray(array,count);
for (i=0, el=list; i<count; ++i, el=el->next)
    array[i] = el->val;
median = doubleMedian(count, array);
freeMem(array);
return median;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x6bb8
movq %rbx, %rax
incl %ebp
movq (%rax), %rax
testq %rax, %rax
jne 0x6bae
testl %ebp, %ebp
jne 0x6bca
leaq 0x12604(%rip), %rdi     # 0x191c7
xorl %eax, %eax
callq 0xb8d7
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0xeeec
movq %rax, %r14
testl %ebp, %ebp
jle 0x6bf7
movl %ebp, %eax
xorl %ecx, %ecx
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
movq (%rbx), %rbx
cmpq %rcx, %rax
jne 0x6be1
movl %ebp, %edi
movq %r14, %rsi
callq 0x6a3a
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xf129
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: slDoubleBoxWhiskerCalc
void slDoubleBoxWhiskerCalc(struct slDouble *list, double *retMin,
                            double *retQ1, double *retMedian, double *retQ3, double *retMax)
/* Calculate what you need to draw a box and whiskers plot from a list of slDoubles. */
{
int i,count = slCount(list);
struct slDouble *el;
double *array;
if (count == 0)
    errAbort("Can't take do slDoubleBoxWhiskerCalc of empty list");
AllocArray(array,count);
for (i=0, el=list; i<count; ++i, el=el->next)
    array[i] = el->val;
doubleBoxWhiskerCalc(count, array, retMin, retQ1, retMedian, retQ3, retMax);
freeMem(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6c56
movq %rbp, %rax
incl %ebx
movq (%rax), %rax
testq %rax, %rax
jne 0x6c4c
testl %ebx, %ebx
jne 0x6c68
leaq 0x12586(%rip), %rdi     # 0x191e7
xorl %eax, %eax
callq 0xb8d7
movslq %ebx, %rdi
shlq $0x3, %rdi
callq 0xeeec
movq %rax, %r14
testl %ebx, %ebx
jle 0x6c96
movl %ebx, %eax
xorl %ecx, %ecx
movsd 0x8(%rbp), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
movq (%rbp), %rbp
cmpq %rcx, %rax
jne 0x6c7f
movq %r12, (%rsp)
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x6a83
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf129
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: intMedian
int intMedian(int count, int *array)
/* Return median value in array.  This will sort
 * the array as a side effect. */
{
int median;
intSort(count, array);
if ((count&1) == 1)
    median = array[count>>1];
else
    {
    count >>= 1;
    median = (array[count] + array[count-1]) * 0.5;
    }
return median;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jl 0x6d1e
movl %ebp, %esi
leaq -0x28(%rip), %rcx       # 0x6ce9
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3120
movl %ebp, %eax
sarl %eax
movslq %eax, %rcx
movl (%rbx,%rcx,4), %eax
testb $0x1, %bpl
jne 0x6d42
addl -0x4(%rbx,%rcx,4), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x112ca(%rip), %xmm0    # 0x18008
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: newSlName
struct slName *newSlName(char *name)
/* Return a new name. */
{
struct slName *sn;
if (name != NULL)
    {
    int len = strlen(name);
    sn = needMem(sizeof(*sn)+len);
    strcpy(sn->name, name);
    return sn;
    }
else
    {
    AllocVar(sn);
    }
return sn;
}

// Assembly:
testq %rdi, %rdi
je 0x6d80
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3200
movslq %eax, %rdi
addq $0x10, %rdi
callq 0xf07d
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x30e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
jmp 0xf07d
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x8b47
movl %eax, %r15d
movq %rbx, %rdi
callq 0x8b47
testl %r15d, %r15d
js 0x6e5d
movl %eax, %r12d
testl %eax, %eax
js 0x6e5d
movq %r14, %rdi
callq 0x36a0
movl %eax, %r13d
movq %rbx, %rdi
callq 0x36a0
xorl %ecx, %ecx
cmpl %eax, %r13d
cmovnel %ecx, %r12d
cmovnel %ecx, %r15d
addq %r12, %rbx
addq %r15, %r14
subl %eax, %r13d
cmovnel %r13d, %ebp
jne 0x6eba
movq %r14, %rdi
callq 0x8b74
movl %eax, %r12d
movq %rbx, %rdi
callq 0x8b74
cmpl %eax, %r12d
jne 0x6e98
testl %r12d, %r12d
je 0x6ea9
movl %eax, %r15d
movslq %r12d, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x33f0
testl %eax, %eax
je 0x6eaf
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0x6eba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3440
movl %eax, %ebp
xorl %ecx, %ecx
jmp 0x6eba
xorl %ecx, %ecx
xorl %ebp, %ebp
jmp 0x6eba
addq %r12, %r14
movslq %r15d, %rax
addq %rax, %rbx
movb $0x1, %cl
testb %cl, %cl
jne 0x6e0f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6f51
shll $0x18, %esi
incq %rdx
testl %esi, %esi
jne 0x6f2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x703f
leaq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
jne 0x7020
jmp 0x7057
movq %r14, %rdi
callq 0x6d49
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_O1/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
testq %rdi, %rdi
je 0x70c8
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x8(%rbx), %rdi
callq 0x6d49
movq %r14, (%rax)
movq (%rbx), %rbx
movq %rax, %r14
testq %rbx, %rbx
jne 0x70af
jmp 0x70ca
xorl %eax, %eax
testq %rax, %rax
je 0x70e4
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x70d1
jmp 0x70e6
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7166
movq %rdi, %r14
movsbl %sil, %ebx
xorl %ebp, %ebp
cmpb $0x0, (%r14)
je 0x716b
movq %r14, %rdi
movl %ebx, %esi
callq 0x3260
testq %rax, %rax
je 0x714b
movq %rax, %r12
subl %r14d, %eax
movslq %eax, %r13
leaq 0x10(%r13), %rdi
callq 0xf07d
movq %rax, %r15
leaq 0x8(%rax), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x34a0
incq %r12
movq %r12, %r14
jmp 0x7159
movq %r14, %rdi
callq 0x6d49
movq %rax, %r15
xorl %r14d, %r14d
movq %rbp, (%r15)
movq %r15, %rbp
testq %r14, %r14
jne 0x710a
jmp 0x716e
xorl %r15d, %r15d
jmp 0x716e
movq %rbp, %r15
testq %r15, %r15
je 0x7188
xorl %ecx, %ecx
movq %r15, %rax
movq (%r15), %r15
movq %rcx, (%rax)
movq %rax, %rcx
testq %r15, %r15
jne 0x7175
jmp 0x718a
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_O1/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 0x724b
movl %esi, %ebx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
testl %ebx, %ebx
je 0x7203
callq 0x7275
testq %rax, %rax
je 0x720a
movzbl (%rax), %ecx
cmpl $0x22, %ecx
je 0x720e
cmpl $0x27, %ecx
jne 0x722f
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 0x71e9
jmp 0x722f
callq 0x7371
jmp 0x722f
xorl %eax, %eax
jmp 0x722f
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 0x7217
testq %rax, %rax
je 0x724b
movq %r15, %rdi
movq %rax, %rsi
callq 0x700f
cmpq $0x0, 0x8(%rsp)
jne 0x71c2
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x7269
xorl %edx, %edx
movq %rcx, %rax
movq (%rcx), %rcx
movq %rdx, (%rax)
movq %rax, %rdx
testq %rcx, %rcx
jne 0x7256
jmp 0x726b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r15
testq %r15, %r15
je 0x72dc
cmpb $0x0, (%r15)
je 0x72dc
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7293
movzbl -0x1(%r15), %eax
testl %eax, %eax
je 0x72dc
leaq -0x1(%r15), %r14
cmpl $0x27, %eax
je 0x72e1
cmpl $0x22, %eax
jne 0x7322
movq %r15, %rdi
movl $0x22, %esi
callq 0x3260
testq %rax, %rax
je 0x7307
movq %rax, %r15
movzbl 0x1(%r15), %eax
incq %r15
cmpl $0x22, %eax
je 0x72cd
jmp 0x7303
xorl %r14d, %r14d
jmp 0x7346
movq %r15, %rdi
movl $0x27, %esi
callq 0x3260
testq %rax, %rax
je 0x7307
movq %rax, %r15
movzbl 0x1(%r15), %eax
incq %r15
cmpl $0x27, %eax
je 0x72f6
testl %eax, %eax
jne 0x730a
xorl %r15d, %r15d
testq %r15, %r15
je 0x732f
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7332
movq %r14, %rdi
callq 0x8fa0
movq %rax, %r15
jmp 0x7332
xorl %r15d, %r15d
testq %r15, %r15
je 0x7340
movb $0x0, (%r15)
incq %r15
jmp 0x7343
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7370
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 0x7359
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rbx
testq %rbx, %rbx
je 0x73bc
cmpb $0x0, (%rbx)
je 0x73bc
movq %rdi, %r14
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7390
cmpb $0x0, (%rbx)
je 0x73bc
movq %rbx, %rdi
callq 0x8fa0
testq %rax, %rax
je 0x73c0
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x73c2
xorl %ebx, %ebx
jmp 0x73c5
xorl %ecx, %ecx
movq %rcx, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
je 0x740b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x740f
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x7413
callq 0x6d49
movq %r12, (%rax)
incq %r15
movq %rax, %r12
cmpq %r15, %r14
jne 0x73ed
jmp 0x7416
xorl %ecx, %ecx
jmp 0x743d
xorl %eax, %eax
jmp 0x7416
movq %r12, %rax
testq %rax, %rax
je 0x7430
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x741d
jmp 0x7432
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
movb %sil, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
xorl %edi, %edi
testq %rbx, %rbx
je 0x7484
movq %rbx, %r15
xorl %ebp, %ebp
movl %edi, %r14d
leaq 0x8(%r15), %rdi
callq 0x3200
leal (%r14,%rax), %edi
movq (%r15), %r15
incl %ebp
testq %r15, %r15
jne 0x7461
addl %ebp, %r14d
addl %eax, %r14d
movslq %r14d, %rdi
callq 0xeeec
movq %rax, %r14
testq %rbx, %rbx
je 0x74bb
leaq 0x6(%rsp), %r15
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x36b0
cmpq $0x0, (%rbx)
je 0x74b3
movq %r14, %rdi
movq %r15, %rsi
callq 0x36b0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x7496
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x10, %rsp
movl $0x1, %esi
callq 0xd12a
movq %rax, (%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xdbed
testl %eax, %eax
je 0x751e
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rdi
callq 0x6d49
movq %rax, %rbx
movq %r15, (%rax)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0xdbed
movq %rbx, %r15
testl %eax, %eax
jne 0x74f9
jmp 0x7520
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0xd800
testq %rbx, %rbx
je 0x7542
xorl %ecx, %ecx
movq %rbx, %rax
movq (%rbx), %rbx
movq %rcx, (%rax)
movq %rax, %rcx
testq %rbx, %rbx
jne 0x752f
jmp 0x7544
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x758b
movq 0x8(%rsp), %rdi
leaq 0x8(%r14), %rsi
movl $0x1, %edx
callq 0xc32c
movq (%r14), %r14
jmp 0x756e
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x75bc
movq 0x8(%rsp), %rdi
leaq 0x8(%rbx), %r15
movq %r15, %rsi
callq 0xbd98
testq %rax, %rax
je 0x75b7
movq %r15, %rdi
callq 0x6d49
movq %r14, (%rax)
movq %rax, %r14
movq (%rbx), %rbx
jmp 0x758e
leaq 0x8(%rsp), %rdi
callq 0xc757
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0xf07d
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_O1/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 0x7691
movq (%r14), %r15
movq 0x8(%r14), %rdi
callq 0xf129
movq %r14, %rdi
callq 0xf129
movq %r15, %r14
testq %r15, %r15
jne 0x7675
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x76cb
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x10, %edi
callq 0xf07d
movq %rbx, 0x8(%rax)
movq %r14, (%rax)
movq (%rbx), %rbx
movq %rax, %r14
testq %rbx, %rbx
jne 0x76ad
jmp 0x76cd
xorl %eax, %eax
testq %rax, %rax
je 0x76e7
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x76d4
jmp 0x76e9
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf07d
movq %rax, %r15
movq %r14, %rdi
callq 0x647e
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7789
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0xf129
movq %rbx, %rdi
popq %rbx
jmp 0xf139
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x77bd
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x776b
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x77a8
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
testq %rdi, %rdi
je 0x783d
movq %rsi, %r14
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0x783d
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x7825
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: slPairFindVal
void *slPairFindVal(struct slPair *list, char *name)
/* Return value associated with name in list, or NULL if not found. */
{
struct slPair *el = slPairFind(list, name);
if (el == NULL)
    return NULL;
return el->val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x786f
movq %rsi, %r14
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0x786f
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x7857
testq %rbx, %rbx
je 0x787a
movq 0x10(%rbx), %rax
jmp 0x787c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7cd6
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7cc5
jmp 0x7cd8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7d10
leaq 0x11b52(%rip), %rdi     # 0x19855
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x30e0
// File: /workspace/github_c_makefile_star2_O1/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 0x8205
testq %rdi, %rdi
je 0x8208
testq %rsi, %rsi
je 0x820e
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_O1/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 0x8231
xorl %edx, %edx
cmpb %cl, (%rsi,%rdx)
jne 0x8232
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8221
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8269
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %esi, %esi
movb (%r14,%rsi), %dil
cmpb (%rbx,%rsi), %dil
jne 0x828f
incq %rsi
cmpq %rsi, %rdx
jne 0x8257
movslq %ecx, %rax
movsbq (%rbx,%rax), %rbx
testq %rbx, %rbx
je 0x828a
callq 0x37a0
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
shrl $0xd, %eax
andl $0x1, %eax
jmp 0x828f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x82b3
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8235
movb (%rdi), %cl
testb %cl, %cl
je 0x82cd
xorl %eax, %eax
xorl %edx, %edx
cmpb %cl, (%rbx,%rdx)
jne 0x82e5
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x82bd
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_O1/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 0x83ca
movq %rdx, %rbx
cmpb $0x0, (%rdx)
je 0x83ca
movl %esi, %ebp
movq %rdi, %r14
movb (%rdi), %r12b
callq 0x3200
movq %rax, (%rsp)
xorl %r13d, %r13d
testb %r12b, %r12b
je 0x833d
movl %r12d, %eax
cmpb (%rbx,%r13), %al
jne 0x833a
movb 0x1(%r14,%r13), %al
incq %r13
testb %al, %al
jne 0x8328
addq %r13, %rbx
cmpq %r13, (%rsp)
jne 0x836f
movsbq (%rbx), %r15
testq %r15, %r15
je 0x83de
cmpb %bpl, %r15b
je 0x83de
cmpb $0x20, %bpl
jne 0x836f
callq 0x37a0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x83de
movb (%rbx), %r15b
testb %r15b, %r15b
sete %r13b
cmpb %bpl, %r15b
sete %al
orb %r13b, %al
jne 0x83b2
cmpb $0x20, %bpl
jne 0x839d
callq 0x37a0
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x83b2
movb 0x1(%rbx), %r15b
incq %rbx
testb %r15b, %r15b
sete %r13b
je 0x83b2
cmpb %bpl, %r15b
jne 0x8384
notb %r13b
movzbl %r13b, %eax
andl $0x1, %eax
cmpb $0x0, (%rbx,%rax)
leaq (%rbx,%rax), %rbx
jne 0x831d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subq %r13, %rbx
jmp 0x83cc
// File: /workspace/github_c_makefile_star2_O1/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 0x8429
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3550
testl %eax, %eax
je 0x842c
decq %r15
jmp 0x840d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x84a7
movq %rax, %rbx
movq %r15, %rdi
callq 0x3200
addq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3760
testq %rax, %rax
je 0x84a7
movq %rax, %r14
subq %rbx, %r14
leal 0x1(%r14), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0xee85
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x34a0
movslq %r14d, %rax
movb $0x0, (%r15,%rax)
jmp 0x84aa
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x84f5
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 0x84f7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x857b
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x857b
movq %r14, %rdi
callq 0x3200
leaq (%rax,%r14), %r15
decq %r15
xorl %ebx, %ebx
cmpq %r14, %r15
jb 0x857d
callq 0x37a0
movq (%rax), %rax
movsbq (%r15), %rcx
decq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8558
incq %r15
movq %r15, %rbx
jmp 0x857d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x85ef
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 0x85e5
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3550
testl %eax, %eax
je 0x85f1
decl %ebp
movq %r12, %rbx
cmpl $0x1, %ebp
jg 0x85ca
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_O1/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 0x86d6
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 0x86b0
btl $0x9, %ecx
jae 0x86bc
callq 0x3030
jmp 0x86b5
callq 0x3790
movq (%rax), %rax
movb (%rax,%r13,4), %al
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x868d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8706
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 0x86ee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x876e
movslq %r12d, %r14
xorl %ebx, %ebx
addq %r14, %rax
incl %ebx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x3760
testq %rax, %rax
jne 0x8757
jmp 0x8770
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 0xf07d
movq %rax, %r15
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3760
testq %rax, %rax
movq %r15, 0x10(%rsp)
je 0x881b
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 0x87d4
jmp 0x881e
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_O1/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, %rsi
callq 0x3760
movq %rax, %r15
xorl %r12d, %r12d
movl $0x0, %r13d
testq %rax, %rax
je 0x889a
movq %r14, %rdi
callq 0x3200
movq %rax, %rbp
xorl %r13d, %r13d
movq %r15, %rax
incl %r13d
addq %rbp, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x3760
testq %rax, %rax
jne 0x8884
testl %r13d, %r13d
je 0x894f
movq 0x8(%rsp), %rdi
callq 0x3200
movq %rax, 0x8(%rsp)
movl %r13d, %r12d
movq %rbx, %rdi
callq 0x3200
movq %rax, %rbp
movq %r14, %rdi
callq 0x3200
subq %rax, %rbp
imulq %r12, %rbp
addq 0x8(%rsp), %rbp
movslq 0x14(%rsp), %rax
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpq %rax, %rbp
jae 0x894f
testq %r15, %r15
je 0x894c
movq %rbx, %rdi
callq 0x3200
leaq (%rax,%r15), %r12
movq %r14, %rdi
callq 0x3200
leaq (%rax,%r15), %rbp
movq %rbp, %rdi
callq 0x3200
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %rbp, %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 0x88e9
movl %r13d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8990
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 0x8978
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x89b5
movl %esi, %esi
xorl %edi, %edi
cmpb %dl, (%rax,%rdi)
jne 0x89ad
movb %cl, (%rax,%rdi)
incq %rdi
cmpq %rdi, %rsi
jne 0x89a5
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8a21
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3200
cmpq $0x2, %rax
jb 0x8a21
cmpb %bpl, (%rbx)
jne 0x8a21
movsbl %bpl, %ecx
cmpl $0x7b, %ecx
je 0x89f4
cmpl $0x5b, %ecx
je 0x89ef
cmpl $0x28, %ecx
jne 0x89f7
movb $0x29, %bpl
jmp 0x89f7
movb $0x5d, %bpl
jmp 0x89f7
movb $0x7d, %bpl
cmpb %bpl, -0x1(%rbx,%rax)
jne 0x8a21
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_O1/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 0x8a8b
movq %rsi, %r14
movb (%rsi), %bpl
movq %rsi, %rdi
callq 0x3200
movslq %eax, %rcx
movq %rbx, %rax
cmpb %bpl, %r15b
jne 0x8a77
movb (%r14), %dl
testb %dl, %dl
je 0x8a6e
xorl %esi, %esi
cmpb %dl, (%rbx,%rsi)
jne 0x8a77
movb 0x1(%r14,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x8a5d
movb (%rbx,%rcx), %r15b
addq %rcx, %rbx
jmp 0x8a84
movb %r15b, (%rax)
incq %rax
movb 0x1(%rbx), %r15b
incq %rbx
testb %r15b, %r15b
jne 0x8a4f
jmp 0x8a8e
movq %rbx, %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq