LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: hashTwoColumnFile
struct hash *hashTwoColumnFile(char *fileName)
/* Given a two column file (key, value) return a hash. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[2];
struct hash *hash = hashNew(16);
while (lineFileRow(lf, row))
    {
    char *name = row[0];
    char *value = lmCloneString(hash->lm, row[1]);
    hashAdd(hash, name, value);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x10(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x137c0
cmpl $0x0, %eax
je 0x160a8
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x14d20
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x10900
jmp 0x16061
leaq -0x10(%rbp), %rdi
callq 0x12ea0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: readAllLines
struct slName *readAllLines(char *fileName)
/* Read all lines of file into a list.  (Removes trailing carriage return.) */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct slName *list = NULL, *el;
char *line;

while (lineFileNext(lf, &line, NULL))
     {
     el = newSlName(line);
     slAddHead(&list, el);
     }
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
cmpl $0x0, %eax
je 0x16118
movq -0x28(%rbp), %rdi
callq 0x8650
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x16130
jmp 0x160e6
leaq -0x18(%rbp), %rdi
callq 0x7bb0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: copyFile
void copyFile(char *source, char *dest)
/* Copy file from source to dest. */
{
int bufSize = 64*1024;
char *buf = needMem(bufSize);
int bytesRead;
int s, d;

s = open(source, O_RDONLY);
if (s < 0)
    errAbort("Couldn't open %s. %s\n", source, strerror(errno));
d = creat(dest, 0777);
if (d < 0)
    {
    close(s);
    errAbort("Couldn't open %s. %s\n", dest, strerror(errno));
    }
while ((bytesRead = read(s, buf, bufSize)) > 0)
    {
    if (write(d, buf, bytesRead) < 0)
        errAbort("Write error on %s. %s\n", dest, strerror(errno));
    }
close(s);
if (close(d) != 0)
    errnoAbort("close failed");
freeMem(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10000, -0x14(%rbp)   # imm = 0x10000
movslq -0x14(%rbp), %rdi
callq 0x152f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3580
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x161d3
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x30a0
movl (%rax), %edi
callq 0x36f0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0xf656(%rip), %rdi      # 0x25822
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x35c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x1621b
movl -0x28(%rbp), %edi
callq 0x3330
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x30a0
movl (%rax), %edi
callq 0x36f0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq 0xf60e(%rip), %rdi      # 0x25822
movb $0x0, %al
callq 0xfd50
jmp 0x1621d
movl -0x28(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x33a0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x16276
movl -0x2c(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3190
cmpq $0x0, %rax
jge 0x16274
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x30a0
movl (%rax), %edi
callq 0x36f0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0xf5cb(%rip), %rdi      # 0x25838
movb $0x0, %al
callq 0xfd50
jmp 0x1621d
movl -0x28(%rbp), %edi
callq 0x3330
movl -0x2c(%rbp), %edi
callq 0x3330
cmpl $0x0, %eax
je 0x16299
leaq 0xe477(%rip), %rdi      # 0x24709
movb $0x0, %al
callq 0xfed0
movq -0x20(%rbp), %rdi
callq 0x153e0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: copyOpenFile
void copyOpenFile(FILE *inFh, FILE *outFh)
/* copy an open stdio file */
{
int c;
while ((c = fgetc(inFh)) != EOF)
    fputc(c, outFh);
if (ferror(inFh))
    errnoAbort("file read failed");
if (ferror(outFh))
    errnoAbort("file write failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3320
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x162df
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3380
jmp 0x162c0
movq -0x8(%rbp), %rdi
callq 0x3100
cmpl $0x0, %eax
je 0x162fb
leaq 0xf55b(%rip), %rdi      # 0x2584f
movb $0x0, %al
callq 0xfed0
movq -0x10(%rbp), %rdi
callq 0x3100
cmpl $0x0, %eax
je 0x16317
leaq 0xf550(%rip), %rdi      # 0x25860
movb $0x0, %al
callq 0xfed0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: cpFile
void cpFile(int s, int d)
/* Copy from source file to dest until reach end of file. */
{
int bufSize = 64*1024, readSize;
char *buf = needMem(bufSize);

for (;;)
    {
    readSize = read(s, buf, bufSize);
    if (readSize > 0)
        mustWriteFd(d, buf, readSize);
    if (readSize <= 0)
        break;
    }
freeMem(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x10000, -0xc(%rbp)    # imm = 0x10000
movslq -0xc(%rbp), %rdi
callq 0x152f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x33a0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x1636b
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0xcbb0
cmpl $0x0, -0x10(%rbp)
jg 0x16373
jmp 0x16375
jmp 0x16342
movq -0x18(%rbp), %rdi
callq 0x153e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: parseQuotedStringNoEscapes
boolean parseQuotedStringNoEscapes( char *in, char *out, char **retNext)
/* Read quoted string from in (which should begin with first quote).
 * Write unquoted string to out, which may be the same as in.
 * Return pointer to character past end of string in *retNext. 
 * Return FALSE if can't find end.
 * Unlike parseQuotedString() do not treat backslash as an escape
 *	character, merely pass it on through.
 */
{
char c, *s = in;
int quoteChar = *s++;

for (;;)
   {
   c = *s++;
   if (c == 0)
       {
       warn("Unmatched %c", quoteChar);
       return FALSE;
       }
   else if (c == quoteChar)
       break;
   else
       *out++ = c;
   }
*out = 0;
if (retNext != NULL)
    *retNext = s;
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x16498
movl -0x34(%rbp), %esi
leaq 0xf3ea(%rip), %rdi      # 0x25872
movb $0x0, %al
callq 0xf8f0
movl $0x0, -0x4(%rbp)
jmp 0x164db
movsbl -0x21(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x164a3
jmp 0x164bb
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x164b9
jmp 0x16461
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x164d4
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: parseQuotedString
boolean parseQuotedString( char *in, char *out, char **retNext)
/* Read quoted string from in (which should begin with first quote).
 * Write unquoted string to out, which may be the same as in.
 * Return pointer to character past end of string in *retNext. 
 * Return FALSE if can't find end. */
{
char c, *s = in;
int quoteChar = *s++;
boolean escaped = FALSE;

for (;;)
   {
   c = *s++;
   if (c == 0)
       {
       warn("Unmatched %c", quoteChar);
       return FALSE;
       }
   if (escaped)
       {
       if (c == '\\' || c == quoteChar)
          *out++ = c;
       else
          {
	  *out++ = '\\';
	  *out++ = c;
	  }
       escaped = FALSE;
       }
   else
       {
       if (c == '\\')
           escaped = TRUE;
       else if (c == quoteChar)
           break;
       else
           *out++ = c;
       }
   }
*out = 0;
if (retNext != NULL)
    *retNext = s;
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x16562
movl -0x34(%rbp), %esi
leaq 0xf323(%rip), %rdi      # 0x25872
movb $0x0, %al
callq 0xf8f0
movl $0x0, -0x4(%rbp)
jmp 0x16619
cmpl $0x0, -0x38(%rbp)
je 0x165bf
movsbl -0x21(%rbp), %eax
cmpl $0x5c, %eax
je 0x1657a
movsbl -0x21(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x16590
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x165b6
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x5c, (%rax)
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl $0x0, -0x38(%rbp)
jmp 0x165f4
movsbl -0x21(%rbp), %eax
cmpl $0x5c, %eax
jne 0x165d1
movl $0x1, -0x38(%rbp)
jmp 0x165f2
movsbl -0x21(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x165dc
jmp 0x165f9
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x165f2
jmp 0x165f4
jmp 0x16528
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x16612
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: nextQuotedWord
char *nextQuotedWord(char **pLine)
/* Generalization of nextWord.  Returns next quoted
 * string or if no quotes next word.  Updates *pLine
 * to point past word that is returned. Does not return
 * quotes. */
{
char *line, c;
line = skipLeadingSpaces(*pLine);
if (line == NULL || line[0] == 0)
    return NULL;
c = *line;
if (c == '"' || c == '\'')
    {
    if (!parseQuotedString(line, line, pLine))
        return NULL;
    return line;
    }
else
    {
    return nextWord(pLine);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1665f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16669
movq $0x0, -0x8(%rbp)
jmp 0x166bb
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x22, %eax
je 0x16684
movsbl -0x19(%rbp), %eax
cmpl $0x27, %eax
jne 0x166ae
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x164f0
cmpl $0x0, %eax
jne 0x166a4
movq $0x0, -0x8(%rbp)
jmp 0x166bb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x166bb
movq -0x10(%rbp), %rdi
callq 0x9050
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: escCopy
void escCopy(char *in, char *out, char toEscape, char escape)
/* Copy in to out, escaping as needed.  Out better be big enough. 
 * (Worst case is strlen(in)*2 + 1.) */
{
char c;
for (;;)
    {
    c = *in++;
    if (c == toEscape)
        *out++ = escape;
    *out++ = c;
    if (c == 0)
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x13(%rbp)
movsbl -0x13(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1671a
movb -0x12(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movb -0x13(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movsbl -0x13(%rbp), %eax
cmpl $0x0, %eax
jne 0x16739
jmp 0x1673b
jmp 0x166e6
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: makeEscapedString
char *makeEscapedString(char *in, char toEscape)
/* Return string that is a copy of in, but with all
 * toEscape characters preceded by '\' 
 * When done freeMem result. */
{
int newSize = strlen(in) + countChars(in, toEscape);
char *out = needMem(newSize+1);
escCopy(in, out, toEscape, '\\');
return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0xb460
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x152f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x5c, %ecx
movsbl -0x9(%rbp), %edx
callq 0x166d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: makeQuotedString
char *makeQuotedString(char *in, char quoteChar)
/* Create a string surrounded by quoteChar, with internal
 * quoteChars escaped.  freeMem result when done. */
{
int newSize = 2 + strlen(in) + countChars(in, quoteChar);
char *out = needMem(newSize+1);
out[0] = quoteChar;
escCopy(in, out+1, quoteChar, '\\');
out[newSize-1] = quoteChar;
return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0xb460
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x152f0
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movl $0x5c, %ecx
movsbl -0x9(%rbp), %edx
callq 0x166d0
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: stringToSlNames
struct slName *stringToSlNames(char *string)
/* Convert string to a list of slNames separated by
 * white space, but allowing multiple words in quotes.
 * Quotes if any are stripped.  */
{
struct slName *list = NULL, *name;
char *dupe = cloneString(string);
char c, *s = dupe, *e;

for (;;)
    {
    if ((s = skipLeadingSpaces(s)) == NULL)
        break;
    if ((c = *s) == 0)
        break;
    if (c == '\'' || c == '"')
        {
	if (!parseQuotedString(s, s, &e))
	    errAbort("missing closing %c in %s", c, string);
	}
    else
        {
	e = skipToSpaces(s);
	if (e != NULL) *e++ = 0;
	}
    name = slNameNew(s);
    slAddHead(&list, name);
    s = e;
    }
freeMem(dupe);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9bb0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16a61
jmp 0x16b06
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x16a77
jmp 0x16b06
movsbl -0x21(%rbp), %eax
cmpl $0x27, %eax
je 0x16a89
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
jne 0x16ab7
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x164f0
cmpl $0x0, %eax
jne 0x16ab5
movsbl -0x21(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0xee7a(%rip), %rdi      # 0x25928
movb $0x0, %al
callq 0xfd50
jmp 0x16adf
movq -0x30(%rbp), %rdi
callq 0xbcd0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x16add
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
jmp 0x16adf
movq -0x30(%rbp), %rdi
callq 0x8650
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x16130
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x16a49
movq -0x20(%rbp), %rdi
callq 0x153e0
leaq -0x10(%rbp), %rdi
callq 0x7bb0
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: charSepToSlNames
struct slName *charSepToSlNames(char *string, char c)
/* Convert character-separated list of items to slName list. 
 * Note that the last occurence of c is optional.  (That
 * is for a comma-separated list a,b,c and a,b,c, are
 * equivalent. */
{
struct slName *list = NULL, *el;
char *s, *e;

s = string;
while (s != NULL && s[0] != 0)
    {
    e = strchr(s, c);
    if (e == NULL)
        {
	el = slNameNew(s);
	slAddHead(&list, el);
	break;
	}
    else
        {
	el = slNameNewN(s, e - s);
	slAddHead(&list, el);
	s = e+1;
	}
    }
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x16b6e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x16b77
jmp 0x16be3
movq -0x28(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x3250
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x16bab
movq -0x28(%rbp), %rdi
callq 0x8650
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x16130
jmp 0x16be3
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x86c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x16130
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x16b52
leaq -0x18(%rbp), %rdi
callq 0x7bb0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: sprintWithGreekByte
void sprintWithGreekByte(char *s, int slength, long long size)
/* Numbers formatted with PB, TB, GB, MB, KB, B */
{
char *greek[] = {"B", "KB", "MB", "GB", "TB", "PB"};
int i = 0;
long long d = 1;
while ((size/d) >= 1024)
    {
    ++i;
    d *= 1024;
    }
double result = ((double)size)/d;
if (result < 10)
    safef(s,slength,"%3.1f %s",((double)size)/d, greek[i]);
else
    safef(s,slength,"%3.0f %s",((double)size)/d, greek[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x1ae92(%rip), %rsi     # 0x31d90
movl $0x30, %edx
callq 0x3470
movl $0x0, -0x54(%rbp)
movq $0x1, -0x60(%rbp)
movq -0x18(%rbp), %rax
cqto
idivq -0x60(%rbp)
cmpq $0x400, %rax            # imm = 0x400
jl 0x16f40
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x60(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x60(%rbp)
jmp 0x16f17
cvtsi2sdq -0x18(%rbp), %xmm0
cvtsi2sdq -0x60(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0xe8b3(%rip), %xmm0     # 0x25810
ucomisd -0x68(%rbp), %xmm0
jbe 0x16f94
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cvtsi2sdq -0x18(%rbp), %xmm0
cvtsi2sdq -0x60(%rbp), %xmm1
divsd %xmm1, %xmm0
movslq -0x54(%rbp), %rax
movq -0x50(%rbp,%rax,8), %rcx
leaq 0xea1f(%rip), %rdx      # 0x259aa
movb $0x1, %al
callq 0xdc90
jmp 0x16fc2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cvtsi2sdq -0x18(%rbp), %xmm0
cvtsi2sdq -0x60(%rbp), %xmm1
divsd %xmm1, %xmm0
movslq -0x54(%rbp), %rax
movq -0x50(%rbp,%rax,8), %rcx
leaq 0xe9f8(%rip), %rdx      # 0x259b3
movb $0x1, %al
callq 0xdc90
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: shuffleArrayOfChars
void shuffleArrayOfChars(char *array, int arraySize)
/* Shuffle array of characters of given size given number of times. */
{
char c;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    c = array[i];
    array[i] = array[randIx];
    array[randIx] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x17047
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x3750
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
addl %edx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16fe6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: shuffleArrayOfPointers
void shuffleArrayOfPointers(void *pointerArray, int arraySize)
/* Shuffle array of pointers of given size given number of times. */
{
void **array = pointerArray, *pt;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    pt = array[i];
    array[i] = array[randIx];
    array[randIx] = pt;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x170d5
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x3750
movl -0xc(%rbp), %ecx
subl -0x24(%rbp), %ecx
cltd
idivl %ecx
movl -0x2c(%rbp), %eax
addl %edx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1706e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: shuffleList
void shuffleList(void *pList)
/* Randomize order of slList.  Usage:
 *     randomizeList(&list)
 * where list is a pointer to a structure that
 * begins with a next field. */
{
struct slList **pL = (struct slList **)pList;
struct slList *list = *pL;
int count;
count = slCount(list);
if (count > 1)
    {
    struct slList *el;
    struct slList **array;
    int i;
    array = needLargeMem(count * sizeof(*array));
    for (el = list, i=0; el != NULL; el = el->next, i++)
        array[i] = el;
    for (i=0; i<4; ++i)
        shuffleArrayOfPointers(array, count);
    list = NULL;
    for (i=0; i<count; ++i)
        {
        array[i]->next = list;
        list = array[i];
        }
    freeMem(array);
    slReverse(&list);
    *pL = list;       
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x78f0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jle 0x171e8
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x14ff0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x17162
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17135
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x17186
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x17050
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17169
movq $0x0, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x171cb
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x17195
movq -0x30(%rbp), %rdi
callq 0x153e0
leaq -0x18(%rbp), %rdi
callq 0x7bb0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: stripCommas
char *stripCommas(char *position)
/* make a new string with commas stripped out */
{
char *newPos = cloneString(position);
char *nPtr = newPos;

if (position == NULL)
    return NULL;
while((*nPtr = *position++))
    if (*nPtr != ',')
	nPtr++;

return newPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7530
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17222
movq $0x0, -0x8(%rbp)
jmp 0x17261
jmp 0x17224
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movb %al, (%rcx)
cmpb $0x0, %al
je 0x17259
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x17257
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17224
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: dotForUser
void dotForUser()
/* Write out a dot every _dotForUserMod times this is called. */
{
static int dot = -10;
/* Check to see if dot has been initialized. */
if(dot == - 10)
    dot = _dotForUserMod;

if (--dot <= 0)
    {
    putc('.', stderr);
    fflush(stderr);
    dot = _dotForUserMod;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0xa, 0x1b2c9(%rip)    # 0x32594
jne 0x172d9
movl 0x1b2bd(%rip), %eax     # 0x32590
movl %eax, 0x1b2bb(%rip)     # 0x32594
movl 0x1b2b5(%rip), %eax     # 0x32594
addl $-0x1, %eax
movl %eax, 0x1b2ac(%rip)     # 0x32594
cmpl $0x0, %eax
jg 0x1731c
movq 0x1acfc(%rip), %rax     # 0x31ff0
movq (%rax), %rsi
movl $0x2e, %edi
callq 0x3400
movq 0x1ace8(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
callq 0x3500
movl 0x1b27a(%rip), %eax     # 0x32590
movl %eax, 0x1b278(%rip)     # 0x32594
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: spaceToUnderbar
void spaceToUnderbar(char *s)
/* Convert white space to underbar. */
{
char c;
while ((c = *s) != 0)
    {
    if (isspace(c))
        *s = '_';
    ++s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1736f
callq 0x3760
movq (%rax), %rax
movsbl -0x9(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x17361
movq -0x8(%rbp), %rax
movb $0x5f, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1732c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: printVmPeak
void printVmPeak()
/* print to stderr peak Vm memory usage (if /proc/ business exists) */
{
pid_t pid = getpid();
char temp[256];
safef(temp, sizeof(temp), "/proc/%d/status", (int) pid);
struct lineFile *lf = lineFileMayOpen(temp, TRUE);
if (lf)
    {
    char *line;
    while (lineFileNextReal(lf, &line))
	{
	if (stringIn("VmPeak", line))
	    {
	    fprintf(stderr, "# pid=%d: %s\n", pid, line);
	    break;
	    }
	}
    lineFileClose(&lf);
    }
else
    fprintf(stderr, "# printVmPeak: %s - not available\n", temp);
fflush(stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
callq 0x31a0
movl %eax, -0x4(%rbp)
leaq -0x110(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl $0x100, %esi            # imm = 0x100
leaq 0xe641(%rip), %rdx      # 0x259ea
movb $0x0, %al
callq 0xdc90
leaq -0x110(%rbp), %rdi
movl $0x1, %esi
callq 0x12360
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x17439
jmp 0x173d4
movq -0x118(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x13510
cmpl $0x0, %eax
je 0x1742b
movq -0x120(%rbp), %rdi
leaq 0xe600(%rip), %rsi      # 0x259fa
callq 0x3730
cmpq $0x0, %rax
je 0x17429
movq 0x1abe4(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movq -0x120(%rbp), %rcx
leaq 0xe5e1(%rip), %rsi      # 0x25a01
movb $0x0, %al
callq 0x3440
jmp 0x1742b
jmp 0x173d4
leaq -0x118(%rbp), %rdi
callq 0x12ea0
jmp 0x17458
movq 0x1abb0(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
leaq -0x110(%rbp), %rdx
leaq 0xe5be(%rip), %rsi      # 0x25a0f
movb $0x0, %al
callq 0x3440
movq 0x1ab91(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
callq 0x3500
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: nameInCommaList
boolean nameInCommaList(char *name, char *commaList)
/* Return TRUE if name is in comma separated list. */
{
if (commaList == NULL)
    return FALSE;
int nameLen = strlen(name);
for (;;)
    {
    char c = *commaList;
    if (c == 0)
        return FALSE;
    if (memcmp(name, commaList, nameLen) == 0)
        {
	c = commaList[nameLen];
	if (c == 0 || c == ',')
	    return TRUE;
	}
    commaList = strchr(commaList, ',');
    if (commaList == NULL)
        return FALSE;
    commaList += 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17493
movl $0x0, -0x4(%rbp)
jmp 0x1752e
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x0, %eax
jne 0x174ba
movl $0x0, -0x4(%rbp)
jmp 0x1752e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x33c0
cmpl $0x0, %eax
jne 0x174fb
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x0, %eax
je 0x174f0
movsbl -0x1d(%rbp), %eax
cmpl $0x2c, %eax
jne 0x174f9
movl $0x1, -0x4(%rbp)
jmp 0x1752e
jmp 0x174fb
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x3250
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1751d
movl $0x0, -0x4(%rbp)
jmp 0x1752e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1749f
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: parseOptions
static struct hash *parseOptions(int *pArgc, char *argv[], boolean justFirst,
                                 struct optionSpec *optionSpecs)
/* Parse and optionally validate options */
{
int i, origArgc, newArgc = 1;
char **rdPt = argv+1, **wrPt = argv+1;
struct hash *hash = newHash(6);

origArgc = *pArgc;

/* parse arguments */
for (i=1; i<origArgc; ++i)
    {
    if (sameString(*rdPt, "--"))
        {
        rdPt++;
        i++;
        break;
        }
    if (!parseAnOption(hash, *rdPt, optionSpecs))
        {
        /* not an option */
        if (justFirst)
            break;
        *wrPt++ = *rdPt;
        newArgc++;
        }
    rdPt++;
    }

/* copy any remaining positional args */
for (; i<origArgc; ++i)
    {
    *wrPt++ = *rdPt++;
    newArgc++;
    }

*pArgc = newArgc;
*wrPt = NULL; 
return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl $0x6, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x17661
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0xe630(%rip), %rsi      # 0x25c13
callq 0x3410
cmpl $0x0, %eax
jne 0x17604
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17661
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x17cc0
cmpl $0x0, %eax
jne 0x17647
cmpl $0x0, -0x14(%rbp)
je 0x17625
jmp 0x17661
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x175c9
jmp 0x17663
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x176a3
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17663
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionVal
char *optionVal(char *name, char *defaultVal)
/* Return named option if in options hash, otherwise default. */
{
char *ret;
/* if a optionSpec was used, make sure this option is not a multi option */
if(optionSpecification != NULL) 
    {
    struct optionSpec *spec = matchingOption(name, optionSpecification);
    if(spec != NULL && (spec->flags & OPTION_MULTI))    
        errAbort("ERROR: optionVal cannot be used to get the value of an OPTION_MULTI");
    }

ret = optGet(name);
if (ret == NULL)
     ret = defaultVal;
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x1b0e8(%rip)     # 0x32910
je 0x17864
movq -0x8(%rbp), %rdi
movq 0x1b0db(%rip), %rsi     # 0x32910
callq 0x17890
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17862
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x17862
leaq 0xe1d7(%rip), %rdi      # 0x25a32
movb $0x0, %al
callq 0xfd50
jmp 0x17864
movq -0x8(%rbp), %rdi
callq 0x178f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17880
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: matchingOption
static struct optionSpec *matchingOption(char *name, struct optionSpec *optionSpecs)
/* Go through spec table and return spec that matches name, or NULL
 * if none. */
{
while (optionSpecs->name != NULL)
    {
    if (sameString(optionSpecs->name, name))
        return optionSpecs;
    optionSpecs += 1;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x178d7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3410
cmpl $0x0, %eax
jne 0x178c9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x178df
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x178a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionInt
int optionInt(char *name, int defaultVal)
/* Return integer value of named option, or default value
 * if not set. */
{
char *s = optGet(name);
char *valEnd;
long lval;
if (s == NULL)
    return defaultVal;
if (sameString(s,"on"))
    return defaultVal;
lval = strtol(s, &valEnd, 10);  // use strtol since strtoi does not exist
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid integer: \"%s\"", name, s);
if (lval > INT_MAX)
    errAbort("value of -%s is is too large: %ld, integer maximum is %d", name, lval, INT_MAX);
if (lval < INT_MIN)
    errAbort("value of -%s is is too small: %ld, integer minimum is %d", name, lval, INT_MIN);
return lval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1795e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17a13
movq -0x20(%rbp), %rdi
leaq 0xf6dd(%rip), %rsi      # 0x27046
callq 0x3410
cmpl $0x0, %eax
jne 0x1797e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17a13
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x3460
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x179ac
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x179c2
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xe0bb(%rip), %rdi      # 0x25a76
movb $0x0, %al
callq 0xfd50
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jle 0x179e7
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0xe0c5(%rip), %rdi      # 0x25aa0
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, %al
callq 0xfd50
cmpq $-0x80000000, -0x30(%rbp) # imm = 0x80000000
jge 0x17a0c
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0xe0d9(%rip), %rdi      # 0x25ad9
movl $0x80000000, %ecx       # imm = 0x80000000
movb $0x0, %al
callq 0xfd50
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionLongLong
long long optionLongLong(char *name, long long defaultVal)
/* Return long long value of named option, or default value
 * if not set. */
{
char *s = optGet(name);
char *valEnd;
long long val;
if (s == NULL)
    return defaultVal;
if (sameString(s,"on"))
    return defaultVal;
val = strtoll(s, &valEnd, 10);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid long long: \"%s\"", name, s);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17a4e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17ab9
movq -0x20(%rbp), %rdi
leaq 0xf5ed(%rip), %rsi      # 0x27046
callq 0x3410
cmpl $0x0, %eax
jne 0x17a6d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17ab9
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x3430
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17a9b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17ab1
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xe068(%rip), %rdi      # 0x25b12
movb $0x0, %al
callq 0xfd50
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionFloat
float optionFloat(char *name, float defaultVal)
/* Return floating point value or default value if not set. */
{
char *s = optGet(name);
char *valEnd;
float val;
if (s == NULL)
    return defaultVal;

val = strtod(s, &valEnd);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid float: \"%s\"", name, s);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17b01
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x17b4f
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3150
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17b2f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17b45
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xe000(%rip), %rdi      # 0x25b3e
movb $0x0, %al
callq 0xfd50
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionMultiVal
struct slName *optionMultiVal(char *name, struct slName *defaultVal)
/* Return named option if in options hash, otherwise default. */
{
struct slName *ret;
if(optionSpecification == NULL)
    errAbort("ERROR: optionMultiVal can only be used after optionInit is called "
             "with a non-NULL optionSpecs");

ret = hashFindVal(options, name);
if (ret == NULL)
     ret = defaultVal;
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x1ad98(%rip)     # 0x32910
jne 0x17b88
leaq 0xdfe5(%rip), %rdi      # 0x25b66
movb $0x0, %al
callq 0xfd50
movq 0x1ad79(%rip), %rdi     # 0x32908
movq -0x8(%rbp), %rsi
callq 0x10d00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17bab
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: optionDouble
double optionDouble(char *name, double defaultVal)
/* Return double value or default value if not set */
{
char *s = optGet(name);
char *valEnd;
double val;
if (s == NULL)
    return defaultVal;

val = strtod(s, &valEnd);
if ((*s == '\0') || (*valEnd != '\0'))
    errAbort("value of -%s is not a valid double: \"%s\"", name, s);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17bf1
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x17c3b
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3150
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17c1b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17c31
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xdf9a(%rip), %rdi      # 0x25bc4
movb $0x0, %al
callq 0xfd50
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/options.c
// Function: parseMultiOption
static void parseMultiOption(struct hash *hash, char *name, char* val, struct optionSpec *spec)
/* process multiple instances of an option, requres that the optionSpec of the option */
{
struct slName *valList;
switch (spec->flags & OPTION_TYPE_MASK)
    {
    case OPTION_STRING:
        valList = hashFindVal(hash, name);
        if (valList == NULL)   /* first multi option */
            {
            valList = newSlName(val);
            hashAdd(hash, name, valList);
            }
        else
            {
            struct slName *el = newSlName(val);
            slAddTail(valList, el); /* added next multi option */
            }
        break;
    default:
        errAbort("UNIMPLEMENTED: multiple instances of a non-string option is not currently implemented");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xb7, %eax
subl $0x2, %eax
jne 0x181cf
jmp 0x1817b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10d00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x181b3
movq -0x18(%rbp), %rdi
callq 0x8650
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10900
jmp 0x181cd
movq -0x18(%rbp), %rdi
callq 0x8650
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7a40
jmp 0x181dd
leaq 0xdb3c(%rip), %rdi      # 0x25d12
movb $0x0, %al
callq 0xfd50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/osunix.c
// Function: fileSize
off_t fileSize(char *pathname)
/* get file size for pathname. return -1 if not found */
{
struct stat mystat;
ZeroVar(&mystat);
if (stat(pathname,&mystat)==-1)
    {
    return -1;
    }
return mystat.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movl $0x90, %esi
callq 0x18250
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3240
cmpl $-0x1, %eax
jne 0x1822f
movq $-0x1, -0x8(%rbp)
jmp 0x18237
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/osunix.c
// Function: freeSpaceOnFileSystem
long long freeSpaceOnFileSystem(char *path)
/* Given a path to a file or directory on a file system,  return free space
 * in bytes. */
{
struct statvfs fi;
int err = statvfs(path,&fi);
if (err < 0)
    errnoAbort("freeSpaceOnFileSystem could not statvfs");
return (long long)fi.f_bsize * fi.f_bavail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3770
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jge 0x182b3
leaq 0xdadc(%rip), %rdi      # 0x25d88
movb $0x0, %al
callq 0xfed0
movq -0x78(%rbp), %rax
imulq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/osunix.c
// Function: clock1000
long clock1000()
/* A millisecond clock. */
{
struct timeval tv;
static long origSec;
gettimeofday(&tv, NULL);
if (origSec == 0)
    origSec = tv.tv_sec;
return (tv.tv_sec-origSec)*1000 + tv.tv_usec / 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32c0
cmpq $0x0, 0x1a633(%rip)     # 0x32920
jne 0x182fa
movq -0x10(%rbp), %rax
movq %rax, 0x1a626(%rip)     # 0x32920
movq -0x10(%rbp), %rax
subq 0x1a61b(%rip), %rax     # 0x32920
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop