LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: countCase
int countCase(char *s,boolean upper)
// Count letters with case (upper or lower)
{
char a;
int count = 0;
while ((a = *s++) != 0)
    if (( upper && isupper(a))
    ||  (!upper && islower(a)))
        ++count;
return count;
}

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x647e
movq %rax, %rbx
movq %r14, %rdi
callq 0x647e
movq %rax, %r14
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x8c2b
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 0x8c13
movb (%r14), %bpl
testb %bpl, %bpl
je 0x8c56
callq 0x3030
movq %r14, %rcx
incq %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x8c3e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6dfe
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf129
movq %r14, %rdi
callq 0xf129
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: chopString
int chopString(char *in, char *sep, char *outArray[], int outSize)
{
int recordCount = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
testq %rdx, %rdx
setne %al
testl %ecx, %ecx
setle %cl
xorl %r15d, %r15d
testb %cl, %al
jne 0x8d2a
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, %eax
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0x3370
cmpb $0x0, (%r13,%rax)
je 0x8d27
addq %rax, %r13
testq %r14, %r14
je 0x8cec
movq %r13, -0x8(%r14,%r15,8)
movq %r13, %rdi
movq %r12, %rsi
callq 0x33b0
cmpb $0x0, (%r13,%rax)
je 0x8d2a
addq %rax, %r13
testq %r14, %r14
je 0x8d0c
movb $0x0, (%r13)
testq %r14, %r14
sete %al
incq %r13
cmpl %ebx, %r15d
setl %cl
orb %al, %cl
leaq 0x1(%r15), %rax
testb %cl, %cl
jne 0x8cc9
jmp 0x8d2a
decq %r15
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
setne %al
testl %edx, %edx
setle %cl
xorl %ebx, %ebx
testb %cl, %al
jne 0x8dca
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
callq 0x37a0
movq (%rax), %rcx
decq %r15
movsbq 0x1(%r15), %rdx
incq %r15
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x8d64
testb %dl, %dl
je 0x8dca
testq %r14, %r14
je 0x8d80
movq %r15, (%r14,%rbx,8)
incq %rbx
movsbq (%r15), %rsi
testq %rsi, %rsi
sete %cl
je 0x8dca
movq (%rax), %rdx
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x8dab
movsbq 0x1(%r15), %rsi
testq %rsi, %rsi
sete %cl
je 0x8dca
incq %r15
jmp 0x8d92
testb %cl, %cl
jne 0x8dca
testq %r14, %r14
je 0x8db8
movb $0x0, (%r15)
testq %r14, %r14
sete %cl
incq %r15
cmpl %ebp, %ebx
setl %dl
orb %cl, %dl
jne 0x8d5e
movl %ebx, %eax
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: 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:
xorl %eax, %eax
cmpb $0x0, (%rdi)
je 0x8f2e
testq %rdx, %rdx
setne %r8b
testl %ecx, %ecx
setle %r9b
testb %r9b, %r8b
jne 0x8f2e
xorl %eax, %eax
testq %rdx, %rdx
je 0x8efc
movq %rdi, (%rdx,%rax,8)
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x8f2c
incq %rdi
cmpb %sil, %r8b
jne 0x8efc
testq %rdx, %rdx
je 0x8f15
movb $0x0, -0x1(%rdi)
testq %rdx, %rdx
sete %r8b
incq %rax
cmpl %ecx, %eax
setl %r9b
orb %r8b, %r9b
jne 0x8ef3
jmp 0x8f2e
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: skipBeyondDelimit
char *skipBeyondDelimit(char *s,char delimit)
/* Returns NULL or pointer to first char beyond one (or more contiguous) delimit char.
   If delimit is ' ' then skips beyond first patch of whitespace. */
{
if (s != NULL)
    {
    char *beyond = NULL;
    if (delimit == ' ')
        return skipLeadingSpaces(skipToSpaces(s));
    else
        beyond = strchr(s,delimit);
    if (beyond != NULL)
        {
        for (beyond++;*beyond == delimit;beyond++) ;
        if (*beyond != '\0')
            return beyond;
        }
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8f94
movl %esi, %ebp
cmpb $0x20, %bpl
jne 0x8f68
callq 0x8fa0
testq %rax, %rax
je 0x8f8c
movq %rax, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8f57
jmp 0x8f8e
movsbl %bpl, %esi
callq 0x3260
testq %rax, %rax
je 0x8f88
movq %rax, %rbx
movb 0x1(%rbx), %al
incq %rbx
cmpb %bpl, %al
je 0x8f79
testb %al, %al
jne 0x8f8e
movb $0x1, %al
jmp 0x8f90
xorl %ebx, %ebx
xorl %eax, %eax
testb %al, %al
je 0x8f96
xorl %ebx, %ebx
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: skipToSpaces
char *skipToSpaces(char *s)
/* Return first white space or NULL if none.. */
{
char c;
if (s == NULL)
    return NULL;
for (;;)
    {
    c = *s;
    if (c == 0)
        return NULL;
    if (isspace(c))
	return s;
    ++s;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8fd2
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x8fd2
callq 0x37a0
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8fd4
movb 0x1(%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x8fbb
xorl %ebx, %ebx
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: eraseTrailingSpaces
void eraseTrailingSpaces(char *s)
/* Replace trailing white space with zeroes. */
{
int len = strlen(s);
int i;
char c;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3200
movq %rax, %r14
testl %r14d, %r14d
jle 0x9020
callq 0x37a0
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
incq %r14
movsbq -0x2(%rbx,%r14), %rcx
movq (%rax), %rdx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x9020
movb $0x0, -0x2(%rbx,%r14)
decq %r14
cmpq $0x1, %r14
jg 0x9001
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: eraseWhiteSpace
void eraseWhiteSpace(char *s)
{
char *in, *out;
char c;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x905e
callq 0x37a0
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x9053
movb %bpl, (%rbx)
incq %rbx
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x903f
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: eraseNonAlphaNum
void eraseNonAlphaNum(char *s)
{
char *in, *out;
char c;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x909d
callq 0x37a0
leaq 0x1(%rbx), %rcx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x8, (%rdx,%rsi,2)
je 0x9092
movb %bpl, (%rbx)
incq %rbx
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x907f
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: trimSpaces
char *trimSpaces(char *s)
/* Remove leading and trailing white space. */
{
if (s != NULL)
    {
    s = skipLeadingSpaces(s);
    eraseTrailingSpaces(s);
    }
return s;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x90d4
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x90bb
movq %rbx, %rdi
callq 0x8fde
jmp 0x90d6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: cloneFirstWord
char *cloneFirstWord(char *line)
/* Clone first word in line */
{
char *startFirstWord = skipLeadingSpaces(line);
if (startFirstWord == NULL)
    return NULL;
char *endFirstWord = skipToSpaces(startFirstWord);
if (endFirstWord == NULL)
    return cloneString(startFirstWord);
else
    return cloneStringZ(startFirstWord, endFirstWord - startFirstWord);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x91c2
movq %rdi, %rbx
callq 0x37a0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x91b1
jmp 0x91c4
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x9213
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %rbx, %rdi
callq 0x8fa0
testq %rax, %rax
je 0x9218
movq %rax, %r15
subq %rbx, %r15
movq %rbx, %rdi
callq 0x3200
movq %rax, %r12
movq %r15, %rdi
shlq $0x20, %rdi
addq %r14, %rdi
sarq $0x20, %rdi
callq 0xf07d
movq %rax, %r14
cmpl %r15d, %r12d
cmovgel %r15d, %r12d
movslq %r12d, %r15
jmp 0x923c
xorl %r14d, %r14d
jmp 0x9253
movq %rbx, %rdi
callq 0x3200
movq %rax, %r15
movq %rax, %rdi
shlq $0x20, %rdi
addq %r14, %rdi
sarq $0x20, %rdi
callq 0xf07d
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x34a0
movq %r14, %rax
addq %r15, %rax
movb $0x0, (%rax)
movq %r14, %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: lastWordInLine
char *lastWordInLine(char *line)
/* Returns last word in line if any (white space separated).
 * Returns NULL if string is empty.  Removes any terminating white space
 * from line. */
{
char *s = line;
char *word = NULL, *wordEnd = NULL;
for (;;)
    {
    s = skipLeadingSpaces(s);
    if (s == NULL || s[0] == 0)
	break;
    word = s;
    s = wordEnd = skipToSpaces(s);
    if (s == NULL)
        break;
    }
if (wordEnd != NULL)
    *wordEnd = 0;
return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
testq %r15, %r15
je 0x9296
callq 0x37a0
movq (%rax), %rax
decq %r15
movq %r15, %r14
movsbq 0x1(%r14), %rcx
incq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x9285
jmp 0x9299
xorl %r14d, %r14d
testq %r14, %r14
je 0x92c0
cmpb $0x0, (%r14)
je 0x92c0
movq %r14, %rdi
callq 0x8fa0
movq %rax, %r15
movq %r14, %rbx
movq %rax, %r12
testq %rax, %rax
jne 0x9272
movq %r14, %rbx
xorl %r12d, %r12d
testq %r12, %r12
je 0x92ca
movb $0x0, (%r12)
movq %rbx, %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: nextTabWord
char *nextTabWord(char **pLine)
/* Return next tab-separated word. */
{
char *s = *pLine;
char *e;
if (s == NULL || *s == '\n' || *s == 0)
    {
    *pLine = NULL;
    return NULL;
    }
e = strchr(s, '\t');
if (e == NULL)
    {
    e = strchr(s, '\n');
    if (e != NULL)
        *e = 0;
    *pLine = NULL;
    }
else
    {
    *e++ = 0;
    *pLine = e;
    }
return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x9316
movzbl (%r14), %edx
xorl %ecx, %ecx
testl %edx, %edx
je 0x9318
movl $0x0, %eax
cmpl $0xa, %edx
je 0x9336
movq %r14, %rdi
movl $0x9, %esi
callq 0x3260
testq %rax, %rax
je 0x931c
movq %rax, %rcx
incq %rcx
jmp 0x9330
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x9336
movq %r14, %rdi
movl $0xa, %esi
callq 0x3260
xorl %ecx, %ecx
testq %rax, %rax
je 0x9333
movb $0x0, (%rax)
movq %r14, %rax
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: cloneFirstWordByDelimiter
char *cloneFirstWordByDelimiter(char *line,char delimit)
/* Returns a cloned first word, not harming the memory passed in */
{
if (line == NULL || *line == 0)
    return NULL;
line = skipLeadingSpaces(line);
if (*line == 0)
    return NULL;
int size=0;
char *e;
for (e=line;*e!=0;e++)
    {
    if (*e==delimit)
        break;
    else if (delimit == ' ' && isspace(*e))
        break;
    size++;
    }
if (size == 0)
    return NULL;
char *new = needMem(size + 2); // Null terminated by 2
memcpy(new, line, size);
return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x93e8
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x93e8
movl %esi, %ebx
callq 0x37a0
movq (%rax), %rax
movsbq (%r14), %rcx
incq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x9368
cmpb $0x0, -0x1(%r14)
je 0x93e8
leaq -0x1(%r14), %r15
movb (%r15), %bpl
testb %bpl, %bpl
sete %al
cmpb %bl, %bpl
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x93c3
xorl %r12d, %r12d
cmpb $0x20, %bl
jne 0x93b2
callq 0x37a0
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x93c3
movb (%r14,%r12), %bpl
incq %r12
testb %bpl, %bpl
je 0x93c3
cmpb %bl, %bpl
jne 0x939a
testl %r12d, %r12d
je 0x93e8
leal 0x2(%r12), %edi
callq 0xf07d
movl %r12d, %edx
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34a0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: cloneNextWordByDelimiter
char *cloneNextWordByDelimiter(char **line,char delimit)
/* Returns a cloned first word, advancing the line pointer but not harming memory passed in */
{
char *new = cloneFirstWordByDelimiter(*line,delimit);
if (new != NULL)
    {
    *line = skipLeadingSpaces(*line);
    *line += strlen(new);
    if ( **line != 0)
        (*line)++;
    }
return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9341
movq %rax, %r14
testq %rax, %rax
je 0x9451
movq (%rbx), %r15
testq %r15, %r15
je 0x942f
callq 0x37a0
movq (%rax), %rax
decq %r15
movsbq 0x1(%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x941e
jmp 0x9432
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %r14, %rdi
callq 0x3200
leaq (%r15,%rax), %rcx
movq %rcx, (%rbx)
cmpb $0x0, (%r15,%rax)
je 0x9451
incq %rcx
movq %rcx, (%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: cntStringsInList
int cntStringsInList(char *pStrings)
/* returns count of strings in a
   list of strings dilimited by 1 null and terminated by 2 nulls. */
{
int cnt=0;
char *p = pStrings;
while (nextStringInList(&p) != NULL)
    cnt++;
return cnt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movb $0x1, %al
testq %r14, %r14
je 0x94bc
cmpb $0x0, (%r14)
je 0x94bc
movq %r14, %rdi
callq 0x3200
addq %rax, %r14
incq %r14
xorl %eax, %eax
incl %ebx
testb %al, %al
je 0x949f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: stringArrayIx
int stringArrayIx(char *string, char *array[], int arraySize)

/* Return index of string in array or -1 if not there. */
{
int i;
for (i=0; i<arraySize; ++i)
    if (!differentWord(array[i], string))
        return i;
return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x9507
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movq %r15, %rsi
callq 0x6f18
testl %eax, %eax
je 0x9504
incq %r12
cmpq %r12, %r13
jne 0x94ea
jmp 0x9507
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustOpen
FILE *mustOpen(char *fileName, char *mode)
/* Open a file - or squawk and die. */
{
FILE *f;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x11e77(%rip), %rsi     # 0x1b3be
callq 0x3440
testl %eax, %eax
je 0x959f
leaq 0x11e7b(%rip), %rsi     # 0x1b3d2
movq %rbx, %rdi
callq 0x3440
testl %eax, %eax
je 0x95a8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3480
movq %rax, %r14
testq %rax, %rax
jne 0x95b2
leaq 0x10745(%rip), %r15     # 0x19cc2
testq %r12, %r12
je 0x95d1
movzbl (%r12), %eax
cmpl $0x61, %eax
je 0x95ca
cmpl $0x72, %eax
je 0x95c1
cmpl $0x77, %eax
jne 0x95d1
leaq 0xff61(%rip), %r15      # 0x194fe
jmp 0x95d1
movq 0x1da2a(%rip), %rax     # 0x26fd0
jmp 0x95af
movq 0x1da19(%rip), %rax     # 0x26fc8
movq (%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xff2d(%rip), %r15      # 0x194f5
jmp 0x95d1
leaq 0xff37(%rip), %r15      # 0x19508
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xff2f(%rip), %rdi      # 0x19513
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8d7
jmp 0x95b2
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustRead
void mustRead(FILE *file, void *buf, size_t size)
/* Read size bytes from a file or squawk and die. */
{
if (size != 0 && fread(buf, size, 1, file) != 1)
    {
    if (ferror(file))
	errAbort("Error reading %lld bytes: %s", (long long)size, strerror(ferror(file)));
    else
	errAbort("End of file reading %lld bytes", (long long)size);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x9678
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, %edx
movq %rsi, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x3150
cmpq $0x1, %rax
jne 0x9680
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x96ae
movl %eax, %edi
callq 0x3720
leaq 0xfeab(%rip), %rdi      # 0x19545
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb8d7
leaq 0xfead(%rip), %rdi      # 0x19562
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb8d7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: writeString
void writeString(FILE *f, char *s)
/* Write a 255 or less character string to a file.
 * This will write the length of the string in the first
 * byte then the string itself. */
{
UBYTE bLen;
int len = strlen(s);

if (len > 255)
    {
    warn("String too long in writeString (%d chars):\n%s", len, s);
    len = 255;
    }
bLen = len;
writeOne(f, bLen);
mustWrite(f, s, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3200
movq %rax, %r15
cmpl $0x100, %r15d           # imm = 0x100
jl 0x9703
leaq 0xfe91(%rip), %rdi      # 0x19581
movl %r15d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb632
movl $0xff, %r15d
leaq 0xf(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95f6
movslq %r15d, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x95f6
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readString
char *readString(FILE *f)
/* Read a string (written with writeString) into
 * memory.  freeMem the result when done. */
{
UBYTE bLen;
int len;
char *s;

if (!readOne(f, bLen))
    return NULL;
len = bLen;
s = needMem(len+1);
if (len > 0)
    mustRead(f, s, len);
return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3150
cmpq $0x1, %rax
jne 0x977f
movzbl 0xf(%rsp), %r15d
leaq 0x1(%r15), %rdi
callq 0xf07d
movq %rax, %r14
testq %r15, %r15
je 0x9782
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9650
jmp 0x9782
xorl %r14d, %r14d
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: mustReadString
char *mustReadString(FILE *f)
/* Read a string.  Squawk and die at EOF or if any problem. */
{
char *s = readString(f);
if (s == NULL)
    errAbort("Couldn't read string");
return s;
}

// Assembly:
pushq %rbx
callq 0x972f
movq %rax, %rbx
testq %rax, %rax
jne 0x97ab
leaq 0xfe0b(%rip), %rdi      # 0x195af
xorl %eax, %eax
callq 0xb8d7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fastReadString
boolean fastReadString(FILE *f, char buf[256])
/* Read a string into buffer, which must be long enough
 * to hold it.  String is in 'writeString' format. */
{
UBYTE bLen;
int len;
if (!readOne(f, bLen))
    return FALSE;
if ((len = bLen)> 0)
    mustRead(f, buf, len);
buf[len] = 0;
return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x3150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
jne 0x9804
movzbl 0xf(%rsp), %r15d
testq %r15, %r15
je 0x97fa
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9650
movb $0x0, (%rbx,%r15)
movl $0x1, %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: msbFirstWriteBits64
void msbFirstWriteBits64(FILE *f, bits64 x)
/* Write out 64 bit number in manner that is portable across architectures */
{
int i;
UBYTE buf[8];
for (i=7; i>=0; --i)
    {
    buf[i] = (UBYTE)(x&0xff);
    x >>= 8;
    }
mustWrite(f, buf, 8);
}

// Assembly:
pushq %rax
movl $0x8, %eax
movb %sil, -0x1(%rsp,%rax)
shrq $0x8, %rsi
decq %rax
jne 0x9814
movq %rsp, %rsi
movl $0x8, %edx
callq 0x95f6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: msbFirstReadBits64
bits64 msbFirstReadBits64(FILE *f)
/* Write out 64 bit number in manner that is portable across architectures */
{
int i;
UBYTE buf[8];
bits64 x = 0;
mustRead(f, buf, 8);
for (i=0; i<8; ++i)
    {
    x <<= 8;
    x |= buf[i];
    }
return x;
}

// Assembly:
pushq %rax
movq %rsp, %rsi
movl $0x8, %edx
callq 0x9650
xorl %ecx, %ecx
xorl %eax, %eax
movq %rax, %rdx
shlq $0x8, %rdx
movzbl (%rsp,%rcx), %eax
orq %rdx, %rax
incq %rcx
cmpq $0x8, %rcx
jne 0x9843
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustGetLine
void mustGetLine(FILE *file, char *buf, int charCount)
/* Read at most charCount-1 bytes from file, but stop after newline if one is
 * encountered.  The string in buf is '\0'-terminated.  (See man 3 fgets.)
 * Die if there is an error. */
{
char *success = fgets(buf, charCount, file);
if (success == NULL && charCount > 0)
    buf[0] = '\0';
if (ferror(file))
    errAbort("mustGetLine: fgets failed: %s", strerror(ferror(file)));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x3400
testl %ebp, %ebp
jle 0x9882
testq %rax, %rax
jne 0x9882
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x3110
testl %eax, %eax
je 0x98aa
movl %eax, %edi
callq 0x3720
leaq 0xfd28(%rip), %rdi      # 0x195c4
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xb8d7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustOpenFd
int mustOpenFd(char *fileName, int flags)
/* Open a file descriptor (see man 2 open) or squawk and die. */
{
if (sameString(fileName, "stdin"))
    return STDIN_FILENO;
if (sameString(fileName, "stdout"))
    return STDOUT_FILENO;
// mode is necessary when O_CREAT is given, ignored otherwise
int mode = 00664;
int fd = open(fileName, flags, mode);
if (fd < 0)
    {
    char *modeName = "";
    if ((flags & (O_WRONLY | O_CREAT | O_TRUNC)) == (O_WRONLY | O_CREAT | O_TRUNC))
	modeName = " to create and truncate";
    else if ((flags & (O_WRONLY | O_CREAT)) == (O_WRONLY | O_CREAT))
	modeName = " to create";
    else if ((flags & O_WRONLY) == O_WRONLY)
	modeName = " to write";
    else if ((flags & O_RDWR) == O_RDWR)
	modeName = " to append";
    else
	modeName = " to read";
    errnoAbort("Can't open %s%s", fileName, modeName);
    }
return fd;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x11afe(%rip), %rsi     # 0x1b3be
callq 0x3440
testl %eax, %eax
je 0x9909
leaq 0x11b02(%rip), %rsi     # 0x1b3d2
movq %rbx, %rdi
callq 0x3440
testl %eax, %eax
je 0x990d
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1b4, %edx            # imm = 0x1B4
xorl %eax, %eax
callq 0x35b0
movl %eax, %ebp
testl %eax, %eax
jns 0x9957
movl %r14d, %eax
notl %eax
testl $0x241, %eax            # imm = 0x241
jne 0x9914
leaq 0xfcdb(%rip), %rdx      # 0x195e2
jmp 0x9946
xorl %ebp, %ebp
jmp 0x9957
movl $0x1, %ebp
jmp 0x9957
testb $0x41, %al
jne 0x9921
leaq 0xfcdb(%rip), %rdx      # 0x195fa
jmp 0x9946
testb $0x1, %r14b
jne 0x993f
testb $0x2, %r14b
leaq 0xfbc3(%rip), %rax      # 0x194f5
leaq 0xfbcf(%rip), %rdx      # 0x19508
cmoveq %rax, %rdx
jmp 0x9946
leaq 0xfbb8(%rip), %rdx      # 0x194fe
leaq 0xfcb8(%rip), %rdi      # 0x19605
movq %rbx, %rsi
xorl %eax, %eax
callq 0xba00
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustReadFd
void mustReadFd(int fd, void *buf, size_t size)
/* Read size bytes from a file or squawk and die. */
{
ssize_t actualSize;
char *cbuf = buf;
// using a loop because linux was not returning all data in a single request when request size exceeded 2GB.
while (size > 0)
    {
    actualSize = read(fd, cbuf, size);
    if (actualSize < 0)
	errnoAbort("Error reading %lld bytes", (long long)size);
    if (actualSize == 0)
	errAbort("End of file reading %llu bytes (got %lld)", (unsigned long long)size, (long long)actualSize);
    cbuf += actualSize;
    size -= actualSize;
    }
}

// Assembly:
testq %rdx, %rdx
je 0x99d0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0xfc98(%rip), %r15      # 0x19615
leaq 0xfcaa(%rip), %r12      # 0x1962e
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33d0
movq %rax, %r13
testq %rax, %rax
jns 0x99a6
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xba00
testq %r13, %r13
jne 0x99ba
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0xb8d7
addq %r13, %r14
subq %r13, %rbx
jne 0x9984
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: mustWriteFd
void mustWriteFd(int fd, void *buf, size_t size)
/* Write size bytes to file descriptor fd or die.  (See man 2 write.) */
{
ssize_t result = write(fd, buf, size);
if (result < size)
    {
    if (result < 0)
	errnoAbort("mustWriteFd: write failed");
    else 
        errAbort("mustWriteFd only wrote %lld of %lld bytes. Likely the disk is full.",
	    (long long)result, (long long)size);
    }
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
callq 0x31a0
cmpq %rbx, %rax
jae 0x99f9
testq %rax, %rax
js 0x99fb
leaq 0xfc87(%rip), %rdi      # 0x19672
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0xb8d7
popq %rbx
retq
leaq 0xfc56(%rip), %rdi      # 0x19658
xorl %eax, %eax
popq %rbx
jmp 0xba00
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustLseek
off_t mustLseek(int fd, off_t offset, int whence)
/* Seek to given offset, relative to whence (see man lseek) in file descriptor fd or errAbort.
 * Return final offset (e.g. if this is just an (fd, 0, SEEK_CUR) query for current position). */
{
off_t ret = lseek(fd, offset, whence);
if (ret < 0)
    errnoAbort("lseek(%d, %lld, %s (%d)) failed", fd, (long long)offset,
	       ((whence == SEEK_SET) ? "SEEK_SET" : (whence == SEEK_CUR) ? "SEEK_CUR" :
		(whence == SEEK_END) ? "SEEK_END" : "invalid 'whence' value"), whence);
return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
callq 0x3700
movq %rax, %r15
testq %rax, %rax
jns 0x9a6b
testl %ebx, %ebx
je 0x9a37
cmpl $0x1, %ebx
jne 0x9a40
leaq 0xfcaa(%rip), %rcx      # 0x196df
jmp 0x9a55
leaq 0xfc98(%rip), %rcx      # 0x196d6
jmp 0x9a55
cmpl $0x2, %ebx
leaq 0xfc9e(%rip), %rax      # 0x196e8
leaq 0xfca0(%rip), %rcx      # 0x196f1
cmoveq %rax, %rcx
leaq 0xfc5a(%rip), %rdi      # 0x196b6
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xba00
movq %r15, %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: mustCloseFd
void mustCloseFd(int *pFd)
/* Close file descriptor *pFd if >= 0, abort if there's an error, set *pFd = -1. */
{
if (pFd != NULL && *pFd >= 0)
    {
    if (close(*pFd) < 0)
	errnoAbort("close failed");
    *pFd = -1;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x9aa6
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
js 0x9aa5
callq 0x3350
testl %eax, %eax
jns 0x9a9f
leaq 0xfc71(%rip), %rdi      # 0x19709
xorl %eax, %eax
callq 0xba00
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: addSuffix
char *addSuffix(char *head, char *suffix)
/* Return a needMem'd string containing "headsuffix". Should be free'd
 when finished. */
{
char *ret = NULL;
int size = strlen(head) + strlen(suffix) +1;
ret = needMem(sizeof(char)*size);
snprintf(ret, size, "%s%s", head, suffix);
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %rbx, %rdi
callq 0x3200
addl %r15d, %eax
incl %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0xf07d
movq %rax, %r12
leaq 0x106b8(%rip), %rdx     # 0x1a197
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x32a0
movq %r12, %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: carefulCloseWarn
boolean carefulCloseWarn(FILE **pFile)
/* Close file if open and null out handle to it.
 * Return FALSE and print a warning message if there
 * is a problem.*/
{
FILE *f;
boolean ok = TRUE;
if ((pFile != NULL) && ((f = *pFile) != NULL))
    {
    if (f != stdin && f != stdout)
        {
        if (fclose(f) != 0)
	    {
            errnoWarn("fclose failed");
	    ok = FALSE;
	    }
        }
    *pFile = NULL;
    }
return ok;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x1, %ebp
testq %rdi, %rdi
je 0x9bb3
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9bb3
movq 0x1d44e(%rip), %rax     # 0x26fd0
cmpq (%rax), %rdi
je 0x9bac
movq 0x1d43a(%rip), %rax     # 0x26fc8
cmpq (%rax), %rdi
je 0x9bac
callq 0x31c0
testl %eax, %eax
je 0x9bac
leaq 0xfb65(%rip), %rdi      # 0x19708
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xb7b6
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: firstWordInFile
char *firstWordInFile(char *fileName, char *wordBuf, int wordBufSize)
/* Read the first word in file into wordBuf. */
{
FILE *f = mustOpen(fileName, "r");
mustGetLine(f, wordBuf, wordBufSize);
fclose(f);
return trimSpaces(wordBuf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
leaq 0x12c70(%rip), %rsi     # 0x1c851
callq 0x9532
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x985c
movq %r15, %rdi
callq 0x31c0
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x90a7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fileOffsetSizeMerge
struct fileOffsetSize *fileOffsetSizeMerge(struct fileOffsetSize *inList)
/* Returns a new list which is inList transformed to have adjacent blocks
 * merged.  Best to use this with a sorted list. */
{
struct fileOffsetSize *newList = NULL, *newEl = NULL, *oldEl, *nextOld;

for (oldEl = inList; oldEl != NULL; oldEl = nextOld)
    {
    nextOld = oldEl->next;
    if (nextOld != NULL && nextOld->offset < oldEl->offset)
        errAbort("Unsorted inList in fileOffsetSizeMerge %llu %llu", oldEl->offset, nextOld->offset);
    if (newEl == NULL || newEl->offset + newEl->size < oldEl->offset)
        {
	newEl = CloneVar(oldEl);
	slAddHead(&newList, newEl);
	}
    else
        {
	newEl->size = oldEl->offset + oldEl->size - newEl->offset;
	}
    }
slReverse(&newList);
return newList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9cc2
movq %rdi, %r15
leaq 0xfacb(%rip), %rbx      # 0x19716
xorl %r14d, %r14d
xorl %r12d, %r12d
movq (%r15), %r13
testq %r13, %r13
je 0x9c70
movq 0x8(%r13), %rdx
movq 0x8(%r15), %rsi
cmpq %rsi, %rdx
jae 0x9c70
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb8d7
testq %r14, %r14
je 0x9c89
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
addq %rax, %rdx
movq 0x8(%r15), %rcx
cmpq %rcx, %rdx
jae 0x9cad
movl $0x18, %edi
callq 0xee85
movq %rax, %r14
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
movq %r12, (%r14)
movq %r14, %r12
jmp 0x9cb8
subq %rax, %rcx
addq 0x10(%r15), %rcx
movq %rcx, 0x10(%r14)
movq %r13, %r15
testq %r13, %r13
jne 0x9c51
jmp 0x9cc5
xorl %r12d, %r12d
testq %r12, %r12
je 0x9ce0
xorl %ecx, %ecx
movq %r12, %rax
movq (%r12), %r12
movq %rcx, (%rax)
movq %rax, %rcx
testq %r12, %r12
jne 0x9ccc
jmp 0x9ce2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mustSystem
void mustSystem(char *cmd)
/* Execute cmd using "sh -c" or die.  (See man 3 system.) fail on errors */
{
if (cmd == NULL) // don't allow (system() supports testing for shell this way)
    errAbort("mustSystem: called with NULL command.");
int status = system(cmd);
if (status == -1)
    errnoAbort("error starting command: %s", cmd);
else if (WIFSIGNALED(status))
    errAbort("command terminated by signal %d: %s", WTERMSIG(status), cmd);
else if (WIFEXITED(status))
    {
    if (WEXITSTATUS(status) != 0)
        errAbort("command exited with %d: %s", WEXITSTATUS(status), cmd);
    }
else
    errAbort("bug: invalid exit status for command: %s", cmd);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x9d23
leaq 0xfa2b(%rip), %rdi      # 0x19747
xorl %eax, %eax
callq 0xb8d7
movq %rbx, %rdi
callq 0x3230
cmpl $-0x1, %eax
je 0x9d5a
movl %eax, %esi
andl $0x7f, %esi
movl %esi, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jl 0x9d6c
leaq 0xfa39(%rip), %rdi      # 0x19788
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0xb8d7
leaq 0xfa0c(%rip), %rdi      # 0x1976d
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0xba00
testl %esi, %esi
je 0x9d82
leaq 0xfa50(%rip), %rdi      # 0x197c7
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0xb8d7
shrl $0x8, %eax
andl $0xff, %eax
je 0x9d97
leaq 0xfa19(%rip), %rdi      # 0x197ac
movl %eax, %esi
jmp 0x9d4f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: roundingScale
int roundingScale(int a, int p, int q)
/* returns rounded a*p/q */
{
if (a > 100000 || p > 100000)
    {
    double x = a;
    x *= p;
    x /= q;
    return round(x);
    }
else
    return (a*p + q/2)/q;
}

// Assembly:
movl %edx, %ecx
movl $0x186a1, %eax          # imm = 0x186A1
cmpl %eax, %edi
setl %dl
cmpl %eax, %esi
setl %al
testb %al, %dl
jne 0x9dd2
cvtsi2sd %edi, %xmm0
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
addsd 0xe23b(%rip), %xmm1     # 0x18008
cvttsd2si %xmm1, %eax
retq
imull %edi, %esi
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
addl %esi, %eax
cltd
idivl %ecx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readBits64
bits64 readBits64(FILE *f, boolean isSwapped)
/* Read and optionally byte-swap 64 bit entity. */
{
bits64 val;
mustReadOne(f, val);
if (isSwapped)
    val = byteSwap64(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x9650
testl %ebx, %ebx
je 0x9e3d
movq 0x8(%rsp), %rax
bswapq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fdReadBits64
bits64 fdReadBits64(int fd, boolean isSwapped)
/* Read and optionally byte-swap 64 bit entity. */
{
bits64 val;
mustReadOneFd(fd, val);
if (isSwapped)
    val = byteSwap64(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x995e
testl %ebx, %ebx
je 0x9e6f
movq 0x8(%rsp), %rax
bswapq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readBits32
bits32 readBits32(FILE *f, boolean isSwapped)
/* Read and optionally byte-swap 32 bit entity. */
{
bits32 val;
mustReadOne(f, val);
if (isSwapped)
    val = byteSwap32(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x9650
testl %ebx, %ebx
je 0x9ebd
movl 0xc(%rsp), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fdReadBits32
bits32 fdReadBits32(int fd, boolean isSwapped)
/* Read and optionally byte-swap 32 bit entity. */
{
bits32 val;
mustReadOneFd(fd, val);
if (isSwapped)
    val = byteSwap32(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x995e
testl %ebx, %ebx
je 0x9eeb
movl 0xc(%rsp), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readBits16
bits16 readBits16(FILE *f, boolean isSwapped)
/* Read and optionally byte-swap 16 bit entity. */
{
bits16 val;
mustReadOne(f, val);
if (isSwapped)
    val = byteSwap16(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xe(%rsp), %rsi
movl $0x2, %edx
callq 0x9650
testl %ebx, %ebx
je 0x9f32
rolw $0x8, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fdReadBits16
bits16 fdReadBits16(int fd, boolean isSwapped)
/* Read and optionally byte-swap 16 bit entity. */
{
bits16 val;
mustReadOneFd(fd, val);
if (isSwapped)
    val = byteSwap16(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xe(%rsp), %rsi
movl $0x2, %edx
callq 0x995e
testl %ebx, %ebx
je 0x9f5d
rolw $0x8, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readDouble
double readDouble(FILE *f, boolean isSwapped)
/* Read and optionally byte-swap double-precision floating point entity. */
{
double val;
mustReadOne(f, val);
if (isSwapped)
    val = byteSwapDouble(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x9650
testl %ebx, %ebx
je 0x9fb6
movq 0x8(%rsp), %rax
bswapq %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: memReadDouble
double memReadDouble(char **pPt, boolean isSwapped)
/* Read and optionally byte-swap double-precision floating point entity
 * from memory buffer pointed to by *pPt, and advance *pPt past read area. */
{
double val;
memcpy(&val, *pPt, sizeof(val));
if (isSwapped)
    val = byteSwapDouble(val);
*pPt += sizeof(val);
return val;
}

// Assembly:
movq (%rdi), %rax
movq (%rax), %xmm0
testl %esi, %esi
je 0x9fda
movq %xmm0, %rcx
bswapq %rcx
movq %rcx, %xmm0
addq $0x8, %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readFloat
float readFloat(FILE *f, boolean isSwapped)
/* Read and optionally byte-swap single-precision floating point entity. */
{
float val;
mustReadOne(f, val);
if (isSwapped)
    val = byteSwapFloat(val);
return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x9650
testl %ebx, %ebx
je 0xa011
movl 0xc(%rsp), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: memReadFloat
float memReadFloat(char **pPt, boolean isSwapped)
/* Read and optionally byte-swap single-precision floating point entity
 * from memory buffer pointed to by *pPt, and advance *pPt past read area. */
{
float val;
memcpy(&val, *pPt, sizeof(val));
if (isSwapped)
    val = byteSwapFloat(val);
*pPt += sizeof(val);
return val;
}

// Assembly:
movq (%rdi), %rax
movd (%rax), %xmm0
testl %esi, %esi
je 0xa032
movd %xmm0, %ecx
bswapl %ecx
movd %ecx, %xmm0
addq $0x4, %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: readLine
char* readLine(FILE* fh)
/* Read a line of any size into dynamic memory, return null on EOF */
{
int bufCapacity = 256;
int bufSize = 0;
char* buf = needMem(bufCapacity);
int ch;

/* loop until EOF of EOLN */
while (((ch = getc(fh)) != EOF) && (ch != '\n'))
    {
    /* expand if almost full, always keep one extra char for
     * zero termination */
    if (bufSize >= bufCapacity-2)
        {
        bufCapacity *= 2;
        buf = realloc(buf, bufCapacity);
        if (buf == NULL)
            {
            errAbort("Out of memory in readline - request size %d bytes", bufCapacity);
            }
        }
    buf[bufSize++] = ch;
    }

/* only return EOF if no data was read */
if ((ch == EOF) && (bufSize == 0))
    {
    freeMem(buf);
    return NULL;
    }
buf[bufSize] = '\0';
return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movl $0x100, %edi            # imm = 0x100
callq 0xf07d
movq %rax, %rbx
movl $0x100, %r14d           # imm = 0x100
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x3740
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xa0bb
cmpl $0xa, %ebp
je 0xa0bb
leal -0x2(%r14), %eax
cltq
cmpq %rax, %r12
jl 0xa0b2
addl %r14d, %r14d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x3570
testq %rax, %rax
je 0xa0ed
movq %rax, %rbx
movb %bpl, (%rbx,%r12)
incq %r12
jmp 0xa07d
cmpl $-0x1, %ebp
sete %al
testq %r12, %r12
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa0da
movq %rbx, %rdi
callq 0xf129
xorl %ebx, %ebx
jmp 0xa0e1
movl %r12d, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf6fc(%rip), %rdi      # 0x197f0
movl %r14d, %esi
xorl %eax, %eax
callq 0xb8d7