LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/obscure.c
// Function: hashWordsInFile
struct hash *hashWordsInFile(char *fileName, int hashSize)
/* Create a hash of space delimited words in file. */
{
struct hash *hash = newHash(hashSize);
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line, *word;
while (lineFileNext(lf, &line, NULL))
    {
    while ((word = nextWord(&line)) != NULL)
        hashAdd(hash, word, NULL);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, %rbx
movq %r14, %rdi
movl $0x1, %esi
callq 0xd12a
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd274
testl %eax, %eax
je 0xf8b6
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7371
testq %rax, %rax
je 0xf8a3
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xc04f
jmp 0xf887
movq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd274
testl %eax, %eax
jne 0xf887
leaq 0x8(%rsp), %rdi
callq 0xd800
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/obscure.c
// Function: hashNameIntFile
struct hash *hashNameIntFile(char *fileName)
/* Given a two column file (name, integer value) return a
 * hash keyed by name with integer values */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[2];
struct hash *hash = hashNew(16);
while (lineFileRow(lf, row))
    hashAddInt(hash, row[0], lineFileNeedNum(lf, row, 1));
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x1, %esi
callq 0xd12a
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x2, %edx
callq 0xde2c
testl %eax, %eax
je 0xf94c
leaq 0x10(%rsp), %r14
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xdf2c
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0xc32c
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0xde2c
testl %eax, %eax
jne 0xf912
leaq 0x8(%rsp), %rdi
callq 0xd800
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x1, %esi
callq 0xd12a
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x2, %edx
callq 0xde2c
testl %eax, %eax
je 0xf9e1
leaq 0x10(%rsp), %r14
movq 0x20(%rbx), %rdi
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rsi
callq 0xece2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc04f
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0xde2c
testl %eax, %eax
jne 0xf9aa
leaq 0x8(%rsp), %rdi
callq 0xd800
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movl $0x1, %esi
callq 0xd12a
movq %rax, %rbx
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd274
testl %eax, %eax
je 0xfa55
leaq 0x10(%rsp), %r14
movq 0x10(%rsp), %rdi
callq 0x6d49
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd274
testl %eax, %eax
jne 0xfa2d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x673b
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10000, %edi          # imm = 0x10000
callq 0xf07d
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x35b0
movl %eax, %ebp
testl %eax, %eax
jns 0xfaba
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xad3d(%rip), %rdi      # 0x1a7ea
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x35f0
movl %eax, %r15d
testl %eax, %eax
jns 0xfaf5
movl %ebp, %edi
callq 0x3350
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xad02(%rip), %rdi      # 0x1a7ea
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d7
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x33d0
testl %eax, %eax
jle 0xfb56
leaq 0xacf1(%rip), %r12      # 0x1a800
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %r15d, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31a0
testq %rax, %rax
jns 0xfb43
callq 0x30c0
movl (%rax), %edi
callq 0x3720
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d7
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x33d0
testl %eax, %eax
jg 0xfb0f
movl %ebp, %edi
callq 0x3350
movl %r15d, %edi
callq 0x3350
testl %eax, %eax
je 0xfb77
leaq 0x9b99(%rip), %rdi      # 0x19709
xorl %eax, %eax
callq 0xba00
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf129
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3340
cmpl $-0x1, %eax
je 0xfbaa
movl %eax, %edi
movq %rbx, %rsi
callq 0x33a0
movq %r14, %rdi
jmp 0xfb91
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0xfbc4
leaq 0xac5a(%rip), %rdi      # 0x1a817
xorl %eax, %eax
callq 0xba00
movq %rbx, %rdi
callq 0x3110
testl %eax, %eax
je 0xfbe5
leaq 0xac51(%rip), %rdi      # 0x1a828
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba00
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x10000, %edi          # imm = 0x10000
callq 0xf07d
movq %rax, %r14
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %r14, %rsi
callq 0x33d0
movq %rax, %r15
testl %r15d, %r15d
jle 0xfc2f
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %ebx, %edi
movq %r14, %rsi
callq 0x99d1
testl %r15d, %r15d
jg 0xfc05
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf129
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rsi, %rax
movsbl (%rdi), %esi
movb 0x1(%rdi), %cl
testb %cl, %cl
je 0xfd0c
addq $0x2, %rdi
xorl %r8d, %r8d
testl %r8d, %r8d
je 0xfce7
cmpb $0x5c, %cl
sete %r8b
cmpb %sil, %cl
sete %r10b
orb %r8b, %r10b
leaq 0x1(%rax), %r9
testb %r10b, %r10b
jne 0xfcfb
movb $0x5c, (%rax)
movq %rax, %r8
addq $0x2, %r8
movq %r9, %rax
movq %r8, %r9
jmp 0xfcfb
movl $0x1, %r8d
cmpb $0x5c, %cl
je 0xfd03
cmpb %sil, %cl
je 0xfd20
leaq 0x1(%rax), %r9
movb %cl, (%rax)
xorl %r8d, %r8d
movq %r9, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xfcb6
leaq 0xab27(%rip), %rdi      # 0x1a83a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xb632
movl %ebx, %eax
popq %rbx
retq
movb $0x0, (%rax)
movl $0x1, %ebx
testq %rdx, %rdx
je 0xfd1c
movq %rdi, (%rdx)
jmp 0xfd1c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x7cb1
testq %rax, %rax
je 0xfd72
movq %rax, %rbx
movzbl (%rax), %eax
testl %eax, %eax
je 0xfd72
cmpl $0x27, %eax
je 0xfd5a
cmpl $0x22, %eax
jne 0xfd7f
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xfca1
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0xfd74
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7371
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x8aea
addl %r15d, %eax
incl %eax
movslq %eax, %rdi
callq 0xf07d
movq %rax, %rcx
movb (%r14), %dl
cmpb %bl, %dl
jne 0xfddf
movb $0x5c, (%rcx)
incq %rcx
incq %r14
movb %dl, (%rcx)
incq %rcx
testb %dl, %dl
jne 0xfdd2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x8aea
leal (%r15,%rax), %ebp
addl $0x2, %ebp
addl %r15d, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0xf07d
movb %bl, (%rax)
movq %rax, %rcx
movb (%r14), %dl
cmpb %bl, %dl
jne 0xfe3a
movb $0x5c, 0x1(%rcx)
addq $0x2, %rcx
jmp 0xfe3d
incq %rcx
incq %r14
movb %dl, (%rcx)
testb %dl, %dl
jne 0xfe29
movslq %ebp, %rcx
movb %bl, -0x1(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/obscure.c
// Function: hashThisEqThatLine
struct hash *hashThisEqThatLine(char *line, int lineIx, boolean firstStartsWithLetter)
/* Return a symbol table from a line of form:
 *   1-this1=val1 2-this='quoted val2' var3="another val" 
 * If firstStartsWithLetter is true, then the left side of the equals must start with
 * a letter. */
{
char *dupe = cloneString(line);
char *s = dupe, c;
char *var, *val;
struct hash *hash = newHash(8);

for (;;)
    {
    if ((var = skipLeadingSpaces(s)) == NULL)
        break;

    if ((c = *var) == 0)
        break;
    if (firstStartsWithLetter && !isalpha(c))
	errAbort("line %d of custom input: variable needs to start with letter '%s'", lineIx, var);
    val = strchr(var, '=');
    if (val == NULL)
        {
        errAbort("line %d of var %s in custom input: %s \n missing = in var/val pair", lineIx, var, line);
        }
    *val++ = 0;
    c = *val;
    if (c == '\'' || c == '"')
        {
	if (!parseQuotedString(val, val, &s))
	    errAbort("line %d of input: missing closing %c", lineIx, c);
	}
    else
	{
	s = skipToSpaces(val);
	if (s != NULL) *s++ = 0;
	}
    hashAdd(hash, var, cloneString(val));
    }
freez(&dupe);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
callq 0x647e
movq %rax, 0x10(%rsp)
movq %rax, (%rsp)
movl $0x8, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, %r15
movq (%rsp), %rdi
callq 0x7cb1
testq %rax, %rax
je 0xff91
movq %rax, %r12
movsbq (%r12), %r14
testq %r14, %r14
je 0xff91
testl %ebx, %ebx
je 0xfed9
callq 0x37a0
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r14,2)
jne 0xfed9
leaq 0xa97a(%rip), %rdi      # 0x1a847
movl %ebp, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %r12, %rdi
movl $0x3d, %esi
callq 0x3260
movq %rax, %r13
testq %rax, %rax
jne 0xff06
leaq 0xa994(%rip), %rdi      # 0x1a889
movl %ebp, %esi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0xb8d7
movq %r13, %rax
incq %r13
movb $0x0, (%rax)
movzbl 0x1(%rax), %r14d
cmpl $0x27, %r14d
je 0xff20
cmpl $0x22, %r14d
jne 0xff48
movq %r13, %rdi
movq %r13, %rsi
movq %rsp, %rdx
callq 0xfca1
testl %eax, %eax
jne 0xff66
movsbl %r14b, %edx
leaq 0xa98e(%rip), %rdi      # 0x1a8cb
movl %ebp, %esi
xorl %eax, %eax
callq 0xb8d7
jmp 0xff66
movq %r13, %rdi
callq 0x8fa0
movq %rax, (%rsp)
testq %rax, %rax
je 0xff66
movq %rax, %rcx
incq %rcx
movq %rcx, (%rsp)
movb $0x0, (%rax)
movq %r13, %rdi
callq 0x647e
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc04f
movq (%rsp), %rdi
callq 0x7cb1
movq %rax, %r12
testq %rax, %rax
jne 0xfea4
leaq 0x10(%rsp), %rdi
callq 0xf139
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
callq 0x647e
movq %rax, %r14
movq %rax, %rdi
callq 0x7cb1
testq %rax, %rax
je 0x10078
movq %rax, %r13
leaq 0x8(%rsp), %r15
leaq 0xa8f7(%rip), %r12      # 0x1a8f0
movzbl (%r13), %ebp
cmpl $0x22, %ebp
je 0x1002e
cmpl $0x27, %ebp
je 0x1002e
testl %ebp, %ebp
je 0x10078
movq %r13, %rdi
callq 0x8fa0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10051
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, (%rax)
jmp 0x10051
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xfca1
testl %eax, %eax
jne 0x10051
movsbl %bpl, %esi
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %r13, %rdi
callq 0x6d49
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7cb1
movq %rax, %r13
testq %rax, %rax
jne 0xfff9
movq %r14, %rdi
callq 0xf129
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x673b
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x10111
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x10111
movsbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3260
testq %rax, %rax
je 0x100fc
movq %rax, %r14
movl %r14d, %esi
subl %ebx, %esi
movq %rbx, %rdi
callq 0x6d8a
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rbx
incq %rbx
cmpb $0x0, 0x1(%r14)
jne 0x100c1
jmp 0x10111
movq %rbx, %rdi
callq 0x6d49
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x673b
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdx, %rcx
cmpq $0x400, %rdx            # imm = 0x400
jl 0x1039d
movl $0x1, %r9d
xorl %r8d, %r8d
shlq $0xa, %r9
movq %rcx, %rax
xorl %edx, %edx
divq %r9
incq %r8
cmpq $0x3ff, %rax            # imm = 0x3FF
jg 0x1037f
cvtsi2sd %r9, %xmm1
jmp 0x103a8
movsd 0x7c6b(%rip), %xmm1     # 0x18010
xorl %r8d, %r8d
cvtsi2sd %rcx, %xmm0
divsd %xmm1, %xmm0
leaq 0xa644(%rip), %rax      # 0x1a9fc
movslq (%rax,%r8,4), %rcx
addq %rax, %rcx
movsd 0xa411(%rip), %xmm1     # 0x1a7d8
ucomisd %xmm0, %xmm1
leaq 0xa5a0(%rip), %rax      # 0x1a972
leaq 0xa5a2(%rip), %rdx      # 0x1a97b
cmovaq %rax, %rdx
movb $0x1, %al
jmp 0xa2ce
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x10417
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
callq 0x3780
cltd
idivl %r14d
movb (%rbx), %al
movslq %edx, %rcx
movb (%rbx,%rcx), %dl
movb %dl, (%rbx)
movb %al, (%rbx,%rcx)
incq %rbx
decq %r14
jne 0x103f2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x10456
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
callq 0x3780
cltd
idivl %r14d
movq (%rbx,%r15,8), %rax
movslq %edx, %rcx
addq %r15, %rcx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%r15,8)
movq %rax, (%rbx,%rcx,8)
incq %r15
decq %r14
jne 0x1042a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, (%rsp)
callq 0x6674
cmpl $0x2, %eax
jl 0x104ff
movl %eax, %ebp
movl %eax, %edi
shlq $0x3, %rdi
callq 0xee85
movq %rax, %r14
movq (%rsp), %rax
testq %rax, %rax
je 0x104a1
movq %r14, %rcx
movq %rax, (%rcx)
movq (%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x10492
movl $0x4, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x10418
decl %r15d
jne 0x104a7
movq $0x0, (%rsp)
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
xorl %ecx, %ecx
movq (%rsp), %rdx
movq (%r14,%rcx,8), %rsi
movq %rdx, (%rsi)
movq (%r14,%rcx,8), %rdx
movq %rdx, (%rsp)
incq %rcx
cmpq %rcx, %rax
jne 0x104cb
movq %r14, %rdi
callq 0xf129
movq %rsp, %r14
movq %r14, %rdi
callq 0x673b
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x647e
testq %rbx, %rbx
je 0x10531
movq %rax, %rcx
movzbl (%rbx), %edx
incq %rbx
movb %dl, (%rcx)
cmpl $0x2c, %edx
je 0x1051b
testl %edx, %edx
je 0x10533
incq %rcx
jmp 0x1051b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $-0xa, 0x1703d(%rip)    # 0x275a4
jne 0x10575
movl 0x17031(%rip), %eax     # 0x275a0
movl %eax, 0x1702f(%rip)     # 0x275a4
movl 0x17029(%rip), %eax     # 0x275a4
leal -0x1(%rax), %ecx
movl %ecx, 0x17020(%rip)     # 0x275a4
cmpl $0x1, %eax
jg 0x105b3
pushq %rbx
movq 0x16a67(%rip), %rbx     # 0x26ff8
movq (%rbx), %rsi
movl $0x2e, %edi
callq 0x3430
movq (%rbx), %rdi
callq 0x3520
movl 0x16ff4(%rip), %eax     # 0x275a0
movl %eax, 0x16ff2(%rip)     # 0x275a4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x105e7
movq %rdi, %rbx
callq 0x37a0
incq %rbx
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x105dc
movb $0x5f, -0x1(%rbx)
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x105ca
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
callq 0x31b0
movl %eax, %ebx
leaq 0xa3a8(%rip), %rdx      # 0x1a9b2
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movl %eax, %ecx
xorl %eax, %eax
callq 0xa2ce
movq %r14, %rdi
movl $0x1, %esi
callq 0xd0a8
movq %rax, (%rsp)
testq %rax, %rax
je 0x106aa
leaq 0x8(%rsp), %r14
leaq 0xa380(%rip), %r15      # 0x1a9c2
movq (%rsp), %rdi
movq %r14, %rsi
callq 0xdbed
testl %eax, %eax
je 0x10684
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3760
testq %rax, %rax
je 0x10642
movq 0x1698a(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0xa351(%rip), %rsi      # 0x1a9c9
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3470
movq %rsp, %rdi
callq 0xd800
movq 0x16965(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
callq 0x3520
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x16947(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0xa31c(%rip), %rsi      # 0x1a9d7
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x3470
jmp 0x1068c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1073b
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3200
movslq %eax, %r15
cmpb $0x0, (%r14)
je 0x10731
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3550
testl %eax, %eax
je 0x10717
movq %r14, %rdi
movl $0x2c, %esi
callq 0x3260
testq %rax, %rax
je 0x1072e
movq %rax, %r14
incq %r14
movb $0x1, %al
jmp 0x10735
movzbl (%r14,%r15), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x10727
cmpl $0x2c, %ecx
jne 0x106fb
movl $0x1, %ebp
jmp 0x10735
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %eax, %eax
testb %al, %al
jne 0x106e3
jmp 0x1073d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x16c84(%rip), %r15     # 0x278f0
testq %r15, %r15
je 0x10cac
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10c8f
movq %r14, %rsi
callq 0x3440
testl %eax, %eax
je 0x10c92
movq 0x10(%r15), %rdi
addq $0x10, %r15
jmp 0x10c74
xorl %r15d, %r15d
testq %r15, %r15
je 0x10cac
testb $0x40, 0x8(%r15)
je 0x10cac
leaq 0x9d6f(%rip), %rdi      # 0x1aa14
xorl %eax, %eax
callq 0xb8d7
movq %r14, %rdi
callq 0x10cc1
testq %rax, %rax
cmoveq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x10cc1
testq %rax, %rax
je 0x10da7
movq %rax, %r15
leaq 0xb2b5(%rip), %rsi      # 0x1bfc8
movq %rax, %rdi
callq 0x3440
testl %eax, %eax
je 0x10da7
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl $0xa, %edx
callq 0x3490
movq %rax, %rbx
cmpb $0x0, (%r15)
je 0x10d48
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10d5c
leaq 0x9d09(%rip), %rdi      # 0x1aa58
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb8d7
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jl 0x10d7f
leaq 0x9d15(%rip), %rdi      # 0x1aa82
movq %r14, %rsi
movq %rbx, %rdx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
callq 0xb8d7
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
cmpq %rax, %rbx
jg 0x10da7
leaq 0x9d26(%rip), %rdi      # 0x1aabb
movq %r14, %rsi
movq %rbx, %rdx
movl $0x80000000, %ecx       # imm = 0x80000000
xorl %eax, %eax
callq 0xb8d7
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10cc1
testq %rax, %rax
je 0x10e1b
movq %rax, %r15
leaq 0xb1f2(%rip), %rsi      # 0x1bfc8
movq %rax, %rdi
callq 0x3440
testl %eax, %eax
je 0x10e1b
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl $0xa, %edx
callq 0x3460
movq %rax, %rbx
cmpb $0x0, (%r15)
je 0x10e07
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10e1b
leaq 0x9ce6(%rip), %rdi      # 0x1aaf4
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
callq 0x10cc1
testq %rax, %rax
je 0x10e80
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3160
cvtsd2ss %xmm0, %xmm0
cmpb $0x0, (%r14)
movss %xmm0, 0xc(%rsp)
je 0x10e6c
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10e80
leaq 0x9cad(%rip), %rdi      # 0x1ab20
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb8d7
movss 0xc(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x16a50(%rip)     # 0x278f0
jne 0x10eb0
leaq 0x9c9f(%rip), %rdi      # 0x1ab48
xorl %eax, %eax
callq 0xb8d7
movq 0x16a31(%rip), %rdi     # 0x278e8
movq %r14, %rsi
callq 0xc2ba
testq %rax, %rax
cmoveq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x10cc1
testq %rax, %rax
je 0x10f22
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3160
cmpb $0x0, (%r14)
movsd %xmm0, 0x8(%rsp)
je 0x10f0e
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10f22
leaq 0x9c91(%rip), %rdi      # 0x1aba6
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb8d7
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x78, %rsp
leaq 0x8(%rsp), %rsi
callq 0x37b0
testl %eax, %eax
jns 0x10fce
leaq 0x9da3(%rip), %rdi      # 0x1ad6a
xorl %eax, %eax
callq 0xba00
movq 0x28(%rsp), %rax
imulq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x32d0
cmpq $0x0, 0x1690a(%rip)     # 0x27900
jne 0x11004
movq 0x8(%rsp), %rax
movq %rax, 0x168fc(%rip)     # 0x27900
movq 0x8(%rsp), %rcx
subq 0x168f0(%rip), %rcx     # 0x27900
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x10(%rsp)
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rdx, %rax
addq %rcx, %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: sleep1000
void sleep1000(int milli)
/* Sleep for given number of 1000ths of second */
{
if (milli > 0)
    {
    struct timeval tv;
    tv.tv_sec = milli/1000;
    tv.tv_usec = (milli%1000)*1000;
    select(0, NULL, NULL, NULL, &tv);
    }
}

// Assembly:
testl %edi, %edi
jle 0x1107c
subq $0x18, %rsp
movl %edi, %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %edi
imull $0x3e8, %edi, %eax      # imm = 0x3E8
movq %rax, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x34f0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: listDir
struct slName *listDir(char *dir, char *pattern)
/* Return an alphabetized list of all files that match 
 * the wildcard pattern in directory. */
{
struct slName *list = NULL, *name;
struct dirent *de;
DIR *d;

if ((d = opendir(dir)) == NULL)
    return NULL;
while ((de = readdir(d)) != NULL)
    {
    char *fileName = de->d_name;
    if (differentString(fileName, ".") && differentString(fileName, ".."))
	{
	if (pattern == NULL || wildMatch(pattern, fileName))
	    {
	    name = newSlName(fileName);
	    slAddHead(&list, name);
	    }
	}
    }
closedir(d);
slNameSort(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq $0x0, 0x8(%rsp)
callq 0x31d0
testq %rax, %rax
je 0x111b5
movq %rax, %r14
movq %rax, %rdi
callq 0x35e0
testq %rax, %rax
je 0x1119b
movq %rax, %r13
leaq 0x8883(%rip), %r15      # 0x199bc
leaq 0x9f23(%rip), %r12      # 0x1b063
addq $0x13, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
je 0x1118b
movq %r13, %rdi
movq %r12, %rsi
callq 0x3440
testl %eax, %eax
je 0x1118b
testq %rbx, %rbx
je 0x11176
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12f9d
testl %eax, %eax
je 0x1118b
movq %r13, %rdi
callq 0x6d49
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x35e0
movq %rax, %r13
testq %rax, %rax
jne 0x11140
movq %r14, %rdi
callq 0x3380
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6ed3
movq (%rbx), %rax
jmp 0x111b7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: listDirRegEx
struct slName *listDirRegEx(char *dir, char *regEx, int flags)
/* Return an alphabetized list of all files that match 
 * the regular expression pattern in directory.
 * See REGCOMP(3) for flags (e.g. REG_ICASE)  */
{
struct slName *list = NULL, *name;
struct dirent *de;
DIR *d;
regex_t re;
int err = regcomp(&re, regEx, flags | REG_NOSUB);
if(err)
    errAbort("regcomp failed; err: %d", err);

if ((d = opendir(dir)) == NULL)
    return NULL;
while ((de = readdir(d)) != NULL)
    {
    char *fileName = de->d_name;
    if (differentString(fileName, ".") && differentString(fileName, ".."))
	{
	if (!regexec(&re, fileName, 0, NULL, 0))
	    {
	    name = newSlName(fileName);
	    slAddHead(&list, name);
	    }
	}
    }
closedir(d);
regfree(&re);
slNameSort(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
orl $0x8, %edx
leaq 0x10(%rsp), %rdi
callq 0x3390
testl %eax, %eax
je 0x111ff
leaq 0x9bf9(%rip), %rdi      # 0x1adef
movl %eax, %esi
xorl %eax, %eax
callq 0xb8d7
movq %rbx, %rdi
callq 0x31d0
testq %rax, %rax
je 0x112b7
movq %rax, %rbx
movq %rax, %rdi
callq 0x35e0
testq %rax, %rax
je 0x11293
movq %rax, %r13
leaq 0x8792(%rip), %r14      # 0x199bc
leaq 0x9e32(%rip), %r15      # 0x1b063
leaq 0x10(%rsp), %r12
addq $0x13, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3440
testl %eax, %eax
je 0x11283
movq %r13, %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
je 0x11283
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3540
testl %eax, %eax
jne 0x11283
movq %r13, %rdi
callq 0x6d49
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x35e0
movq %rax, %r13
testq %rax, %rax
jne 0x11236
movq %rbx, %rdi
callq 0x3380
leaq 0x10(%rsp), %rdi
callq 0x31f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6ed3
movq (%rbx), %rax
jmp 0x112b9
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: newFileInfo
struct fileInfo *newFileInfo(char *name, off_t size, bool isDir, int statErrno, 
	time_t lastAccess)
/* Return a new fileInfo. */
{
int len = strlen(name);
struct fileInfo *fi = needMem(sizeof(*fi) + len);
fi->size = size;
fi->isDir = isDir;
fi->statErrno = statErrno;
fi->lastAccess = lastAccess;
strcpy(fi->name, name);
return fi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x3200
movslq %eax, %rdi
addq $0x28, %rdi
callq 0xf07d
movq %rax, %r13
movq %r15, 0x8(%rax)
movb %r14b, 0x10(%rax)
movl %ebp, 0x14(%rax)
movq %rbx, 0x18(%rax)
leaq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0x30e0
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: makeDir
boolean makeDir(char *dirName)
/* Make dir.  Returns TRUE on success.  Returns FALSE
 * if failed because directory exists.  Prints error
 * message and aborts on other error. */
{
int err;
if ((err = mkdir(dirName, 0777)) < 0)
    {
    if (errno != EEXIST)
	{
	perror("");
	errAbort("Couldn't make directory %s", dirName);
	}
    return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x30f0
movl $0x1, %ebp
testl %eax, %eax
jns 0x11359
callq 0x30c0
xorl %ebp, %ebp
cmpl $0x11, (%rax)
jne 0x11362
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8959(%rip), %rdi      # 0x19cc2
callq 0x3640
leaq 0x9a92(%rip), %rdi      # 0x1ae07
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb8d7
jmp 0x11359
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: getHost
char *getHost()
/* Return host name. */
{
static char *hostName = NULL;
static char buf[128];
if (hostName == NULL)
    {
    hostName = getenv("HTTP_HOST");
    if (hostName == NULL)
        {
	hostName = getenv("HOST");
	if (hostName == NULL)
	    {
	    if (hostName == NULL)
		{
		static struct utsname unamebuf;
		if (uname(&unamebuf) >= 0)
		    hostName = unamebuf.nodename;
		else
		    hostName = "unknown";
		}
	    }
        }
    strncpy(buf, hostName, sizeof(buf));
    chopSuffix(buf);
    hostName = buf;
    }
return hostName;
}

// Assembly:
cmpq $0x0, 0x16571(%rip)     # 0x27b10
jne 0x11628
pushq %rbx
leaq 0x98ac(%rip), %rdi      # 0x1ae59
callq 0x3040
movq %rax, 0x16557(%rip)     # 0x27b10
testq %rax, %rax
jne 0x115fd
leaq 0x98b5(%rip), %rdi      # 0x1ae7a
callq 0x3040
movq %rax, 0x1653f(%rip)     # 0x27b10
testq %rax, %rax
jne 0x115fd
leaq 0x165c3(%rip), %rdi     # 0x27ba0
callq 0x32c0
testl %eax, %eax
leaq 0x165f6(%rip), %rax     # 0x27be1
leaq 0x9871(%rip), %rcx      # 0x1ae63
cmovnsq %rax, %rcx
movq %rcx, 0x16513(%rip)     # 0x27b10
movq 0x1650c(%rip), %rsi     # 0x27b10
leaq 0x16515(%rip), %rbx     # 0x27b20
movl $0x80, %edx
movq %rbx, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x9b01
movq %rbx, 0x164e9(%rip)     # 0x27b10
popq %rbx
movq 0x164e1(%rip), %rax     # 0x27b10
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: semiUniqName
char *semiUniqName(char *base)
/* Figure out a name likely to be unique.
 * Name will have no periods.  Returns a static
 * buffer, so best to clone result unless using
 * immediately. */
{
int pid = getpid();
int num = time(NULL)&0xFFFFF;
char host[512];
strcpy(host, getHost());
char *s = strchr(host, '.');
if (s != NULL)
     *s = 0;
subChar(host, '-', '_');
subChar(host, ':', '_');
static char name[PATH_LEN];
safef(name, sizeof(name), "%s_%s_%x_%x",
	base, host, pid, num);
return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
callq 0x31b0
movl %eax, %ebp
xorl %edi, %edi
callq 0x34d0
movq %rax, %r14
callq 0x11597
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x30e0
movq %r15, %rdi
movl $0x2e, %esi
callq 0x3260
testq %rax, %rax
je 0x116bb
movb $0x0, (%rax)
andl $0xfffff, %r14d         # imm = 0xFFFFF
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3200
movq %r15, %rdi
movl %eax, %esi
movl $0x2d, %edx
movl $0x5f, %ecx
callq 0x899a
movq %r15, %rdi
callq 0x3200
movq %r15, %rdi
movl %eax, %esi
movl $0x3a, %edx
movl $0x5f, %ecx
callq 0x899a
movl %r14d, (%rsp)
leaq 0x166a6(%rip), %r14     # 0x27db0
leaq 0x976e(%rip), %rdx      # 0x1ae7f
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0xa2ce
movq %r14, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: rTempName
char *rTempName(char *dir, char *base, char *suffix)
/* Make a temp name that's almost certainly unique. */
{
char *x;
static char fileName[PATH_LEN];
int i;
char *lastSlash = (lastChar(dir) == '/' ? "" : "/");
for (i=0;;++i)
    {
    x = semiUniqName(base);
    safef(fileName, sizeof(fileName), "%s%s%s%d%s",
    	dir, lastSlash, x, i, suffix);
    if (!fileExists(fileName))
        break;
    }
return fileName;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x84fd
cmpb $0x2f, %al
leaq 0x8566(%rip), %rax      # 0x19cc2
leaq 0x9797(%rip), %r12      # 0x1aefa
cmoveq %rax, %r12
leaq 0x16842(%rip), %r13     # 0x27fb0
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x11670
movq %r13, %rdi
movl $0x200, %esi            # imm = 0x200
leaq 0x9704(%rip), %rdx      # 0x1ae8b
movq %r15, %rcx
movq %r12, %r8
leaq 0x1661c(%rip), %r9      # 0x27db0
xorl %eax, %eax
pushq %rbx
pushq %rbp
callq 0xa2ce
addq $0x10, %rsp
movq %r13, %rdi
callq 0xa0fe
incl %ebp
testl %eax, %eax
jne 0x11770
leaq 0x167fa(%rip), %rax     # 0x27fb0
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/osunix.c
// Function: getUser
char *getUser()
/* Get user name */
{
uid_t uid = geteuid();
struct passwd *pw = getpwuid(uid);
if (pw == NULL)
    errnoAbort("getUser: can't get user name for uid %d", (int)uid);
return pw->pw_name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3310
movl %eax, %ebx
movl %eax, %edi
callq 0x31e0
movq %rax, %r14
testq %rax, %rax
jne 0x119ed
leaq 0x953a(%rip), %rdi      # 0x1af1e
movl %ebx, %esi
xorl %eax, %eax
callq 0xba00
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/osunix.c
// Function: mustFork
int mustFork()
/* Fork or abort. */
{
int childId = fork();
if (childId == -1)
    errnoAbort("mustFork: Unable to fork");
return childId;
}

// Assembly:
pushq %rbx
callq 0x3750
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x11a13
leaq 0x953a(%rip), %rdi      # 0x1af46
xorl %eax, %eax
callq 0xba00
movl %ebx, %eax
popq %rbx
retq