LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, %rdi
callq 0x6082
cmpl $0x2, %eax
jl 0xeb18
movl %eax, %ebp
movl %eax, %r12d
leaq (,%r12,8), %rdi
callq 0xd684
movq %rax, %r14
testq %r15, %r15
je 0xeac3
movq %r15, (%rax)
movq (%r15), %r15
addq $0x8, %rax
jmp 0xeab2
pushq $0x4
popq %r15
subl $0x1, %r15d
jb 0xead9
movq %r14, %rdi
movl %ebp, %esi
callq 0xea2c
jmp 0xeac7
andq $0x0, 0x8(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0xeafd
movq (%r14,%rcx,8), %rdx
movq %rax, (%rdx)
movq (%r14,%rcx,8), %rax
movq %rax, 0x8(%rsp)
incq %rcx
jmp 0xeae3
movq %r14, %rdi
callq 0xd8f9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x613f
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/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 0x5ede
testq %rbx, %rbx
je 0xeb4c
movq %rax, %rcx
movzbl (%rbx), %edx
incq %rbx
movb %dl, (%rcx)
cmpl $0x2c, %edx
je 0xeb36
testl %edx, %edx
je 0xeb4e
incq %rcx
jmp 0xeb36
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x17a23(%rip), %eax     # 0x265a4
cmpl $-0xa, %eax
jne 0xeb8c
movl 0x17a14(%rip), %eax     # 0x265a0
leal -0x1(%rax), %ecx
movl %ecx, 0x17a0f(%rip)     # 0x265a4
cmpl $0x1, %eax
jg 0xebc2
pushq %rbx
movq 0x17456(%rip), %rbx     # 0x25ff8
movq (%rbx), %rsi
pushq $0x2e
popq %rdi
callq 0x3430
movq (%rbx), %rdi
callq 0x3520
movl 0x179e5(%rip), %eax     # 0x265a0
movl %eax, 0x179e3(%rip)     # 0x265a4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbq (%rbx), %r14
testq %r14, %r14
je 0xebeb
callq 0x37a0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0xebe6
movb $0x5f, (%rbx)
incq %rbx
jmp 0xebca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
callq 0x31b0
movl %eax, %ebx
leaq 0x9db1(%rip), %rdx      # 0x189c2
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movl %eax, %ecx
xorl %eax, %eax
callq 0x939d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xbb37
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xecb3
movq %rax, %r14
movq %rsp, %r15
leaq 0x9d89(%rip), %r12      # 0x189d2
movq %r14, %rdi
movq %r15, %rsi
callq 0xc52c
testl %eax, %eax
je 0xec89
movq (%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3760
testq %rax, %rax
je 0xec49
movq 0x17385(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
leaq 0x9d5c(%rip), %rsi      # 0x189d9
movl %ebx, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3470
leaq 0x8(%rsp), %rdi
callq 0xc178
movq 0x1735e(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
callq 0x3520
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1733e(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
leaq 0x9d23(%rip), %rsi      # 0x189e7
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x3470
jmp 0xec93
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rsi, %rsi
je 0xed37
movq %rsi, %r15
movq %rdi, %r14
callq 0x3200
movslq %eax, %r12
pushq $0x1
popq %r13
pushq $0x2c
popq %rbp
cmpb $0x0, (%r15)
je 0xed37
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3550
testl %eax, %eax
jne 0xed1f
movzbl (%r15,%r12), %eax
testl %eax, %eax
je 0xed34
cmpl $0x2c, %eax
je 0xed34
movq %r15, %rdi
movl %ebp, %esi
callq 0x3260
leaq 0x1(%rax), %r15
testq %rax, %rax
jne 0xecf9
jmp 0xed37
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x176fe(%rip), %rsi     # 0x26910
testq %rsi, %rsi
je 0xf238
movq %r14, %rdi
callq 0xf24f
testq %rax, %rax
je 0xf238
testb $0x40, 0x8(%rax)
je 0xf238
leaq 0x97f3(%rip), %rdi      # 0x18a24
xorl %eax, %eax
callq 0xa61f
movq %r14, %rdi
callq 0xf280
testq %rax, %rax
cmoveq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xf273
movq %r14, %rsi
callq 0x3440
testl %eax, %eax
je 0xf275
addq $0x10, %rbx
jmp 0xf259
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf280
testq %rax, %rax
je 0xf35d
movq %rax, %r15
cmpb $0x6f, (%rax)
jne 0xf2e0
cmpb $0x6e, 0x1(%r15)
jne 0xf2e0
cmpb $0x0, 0x2(%r15)
je 0xf35d
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r15, %rdi
callq 0x3490
movq %rax, %rbx
cmpb $0x0, (%r15)
je 0xf303
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf317
leaq 0x975e(%rip), %rdi      # 0x18a68
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa61f
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, %rbx
jl 0xf335
leaq 0x976a(%rip), %rdi      # 0x18a92
movq %r14, %rsi
movq %rbx, %rdx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jmp 0xf356
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
cmpq %rax, %rbx
jg 0xf35d
leaq 0x9780(%rip), %rdi      # 0x18acb
movq %r14, %rsi
movq %rbx, %rdx
movl $0x80000000, %ecx       # imm = 0x80000000
xorl %eax, %eax
callq 0xa61f
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf280
testq %rax, %rax
je 0xf3cf
movq %rax, %r15
cmpb $0x6f, (%rax)
jne 0xf398
cmpb $0x6e, 0x1(%r15)
jne 0xf398
cmpb $0x0, 0x2(%r15)
je 0xf3cf
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r15, %rdi
callq 0x3460
movq %rax, %rbx
cmpb $0x0, (%r15)
je 0xf3bb
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf3cf
leaq 0x9742(%rip), %rdi      # 0x18b04
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa61f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf280
testq %rax, %rax
je 0xf434
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3160
cvtsd2ss %xmm0, %xmm0
cmpb $0x0, (%r14)
movss %xmm0, 0xc(%rsp)
je 0xf420
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf434
leaq 0x9709(%rip), %rdi      # 0x18b30
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa61f
movss 0xc(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x174bc(%rip)     # 0x26910
jne 0xf464
leaq 0x96fb(%rip), %rdi      # 0x18b58
xorl %eax, %eax
callq 0xa61f
movq 0x1749d(%rip), %rdi     # 0x26908
movq %r14, %rsi
callq 0xaf0d
testq %rax, %rax
cmoveq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf280
testq %rax, %rax
je 0xf4d6
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3160
cmpb $0x0, (%r14)
movsd %xmm0, 0x8(%rsp)
je 0xf4c2
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf4d6
leaq 0x96ed(%rip), %rdi      # 0x18bb6
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa61f
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf57e
leaq 0x9800(%rip), %rdi      # 0x18d77
xorl %eax, %eax
callq 0xa721
movq 0x28(%rsp), %rax
imulq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32d0
movq 0x17379(%rip), %rcx     # 0x26920
movq (%rbx), %rax
testq %rcx, %rcx
jne 0xf5b9
movq %rax, 0x1736a(%rip)     # 0x26920
movq %rax, %rcx
subq %rcx, %rax
imulq $0x3e8, %rax, %rcx      # imm = 0x3E8
movq 0x8(%rsp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
addq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf611
subq $0x18, %rsp
movl $0x3e8, %ecx            # imm = 0x3E8
movl %edi, %eax
xorl %edx, %edx
divl %ecx
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
imull $0x3e8, %edx, %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_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
andq $0x0, (%rsp)
callq 0x31d0
testq %rax, %rax
je 0xf71c
movq %rax, %r14
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x35e0
testq %rax, %rax
je 0xf704
movq %rax, %r15
cmpb $0x2e, 0x13(%rax)
jne 0xf6d8
cmpb $0x0, 0x14(%r15)
je 0xf6ad
cmpb $0x2e, 0x14(%r15)
jne 0xf6d8
cmpb $0x0, 0x15(%r15)
je 0xf6ad
addq $0x13, %r15
testq %rbx, %rbx
je 0xf6f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x113f3
testl %eax, %eax
je 0xf6ad
movq %r15, %rdi
callq 0x6692
movq %r12, (%rax)
movq %rax, (%rsp)
movq %rax, %r12
jmp 0xf6ad
movq %r14, %rdi
callq 0x3380
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x67f1
movq (%rbx), %rax
jmp 0xf71e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, (%rsp)
orl $0x8, %edx
leaq 0x8(%rsp), %rdi
callq 0x3390
testl %eax, %eax
je 0xf75e
leaq 0x96a7(%rip), %rdi      # 0x18dfc
movl %eax, %esi
xorl %eax, %eax
callq 0xa61f
movq %rbx, %rdi
callq 0x31d0
testq %rax, %rax
je 0xf7f5
movq %rax, %rbx
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
callq 0x35e0
testq %rax, %rax
je 0xf7d3
movq %rax, %r15
cmpb $0x2e, 0x13(%rax)
jne 0xf7a5
cmpb $0x0, 0x14(%r15)
je 0xf77a
cmpb $0x2e, 0x14(%r15)
jne 0xf7a5
cmpb $0x0, 0x15(%r15)
je 0xf77a
addq $0x13, %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3540
testl %eax, %eax
jne 0xf77a
movq %r15, %rdi
callq 0x6692
movq %r12, (%rax)
movq %rax, (%rsp)
movq %rax, %r12
jmp 0xf77a
movq %rbx, %rdi
callq 0x3380
leaq 0x8(%rsp), %rdi
callq 0x31f0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x67f1
movq (%rbx), %rax
jmp 0xf7f7
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
testl %eax, %eax
js 0xf889
pushq $0x1
popq %rbp
jmp 0xf895
callq 0x30c0
xorl %ebp, %ebp
cmpl $0x11, (%rax)
jne 0xf89e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x842d(%rip), %rdi      # 0x17cd2
callq 0x3640
leaq 0x9563(%rip), %rdi      # 0x18e14
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
jmp 0xf895
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq 0x170a4(%rip), %rbx     # 0x26b30
testq %rbx, %rbx
jne 0xfb0e
leaq 0x93ce(%rip), %rdi      # 0x18e66
callq 0x3040
movq %rax, 0x1708c(%rip)     # 0x26b30
testq %rax, %rax
jne 0xfae8
leaq 0x93d7(%rip), %rdi      # 0x18e87
callq 0x3040
movq %rax, 0x17074(%rip)     # 0x26b30
testq %rax, %rax
jne 0xfae8
leaq 0x170f8(%rip), %rdi     # 0x26bc0
callq 0x32c0
testl %eax, %eax
leaq 0x1712b(%rip), %rcx     # 0x26c01
leaq 0x9393(%rip), %rax      # 0x18e70
cmovnsq %rcx, %rax
movq %rax, 0x17048(%rip)     # 0x26b30
leaq 0x17051(%rip), %rbx     # 0x26b40
movl $0x80, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30d0
movq %rbx, %rdi
callq 0x8c01
movq %rbx, 0x17022(%rip)     # 0x26b30
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
callq 0x31b0
movl %eax, %ebp
xorl %edi, %edi
callq 0x34d0
movq %rax, %r14
callq 0xfa84
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x30e0
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x3260
testq %rax, %rax
je 0xfb9e
movb $0x0, (%rax)
andl $0xfffff, %r14d         # imm = 0xFFFFF
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3200
pushq $0x2d
popq %rdx
pushq $0x5f
popq %r12
movq %r15, %rdi
movl %eax, %esi
movl %r12d, %ecx
callq 0x7d7e
movq %r15, %rdi
callq 0x3200
pushq $0x3a
popq %rdx
movq %r15, %rdi
movl %eax, %esi
movl %r12d, %ecx
callq 0x7d7e
movl %r14d, (%rsp)
leaq 0x171e7(%rip), %r14     # 0x26dd0
leaq 0x929c(%rip), %rdx      # 0x18e8c
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x939d
movq %r14, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7948
cmpb $0x2f, %al
leaq 0x8095(%rip), %rax      # 0x17cd2
leaq 0x92c3(%rip), %r12      # 0x18f07
cmoveq %rax, %r12
leaq 0x17381(%rip), %r13     # 0x26fd0
xorl %ebp, %ebp
movq %r14, %rdi
callq 0xfb53
movq %r13, %rdi
movl $0x200, %esi            # imm = 0x200
leaq 0x9230(%rip), %rdx      # 0x18e98
movq %r15, %rcx
movq %r12, %r8
leaq 0x1715b(%rip), %r9      # 0x26dd0
xorl %eax, %eax
pushq %rbx
pushq %rbp
callq 0x939d
popq %rcx
popq %rdx
movq %r13, %rdi
callq 0x91b9
incl %ebp
testl %eax, %eax
jne 0xfc51
leaq 0x1733b(%rip), %rax     # 0x26fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/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 0xfeba
leaq 0x907a(%rip), %rdi      # 0x18f2b
movl %ebx, %esi
xorl %eax, %eax
callq 0xa721
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfee0
leaq 0x907a(%rip), %rdi      # 0x18f53
xorl %eax, %eax
callq 0xa721
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/osunix.c
// Function: rawKeyIn
int rawKeyIn()
/* Read in an unbuffered, unechoed character from keyboard. */
{
struct termios attr;
tcflag_t old;
char c;

/* Set terminal to non-echoing non-buffered state. */
if (tcgetattr(STDIN_FILENO, &attr) != 0)
    errAbort("Couldn't do tcgetattr");
old = attr.c_lflag;
attr.c_lflag &= ~ICANON;
attr.c_lflag &= ~ECHO;
if (tcsetattr(STDIN_FILENO, TCSANOW, &attr) == -1)
    errAbort("Couldn't do tcsetattr");

/* Read one byte */
if (read(STDIN_FILENO,&c,1) != 1)
   errnoAbort("rawKeyIn: I/O error");

/* Put back terminal to how it was. */
attr.c_lflag = old;
if (tcsetattr(STDIN_FILENO, TCSANOW, &attr) == -1)
    errAbort("Couldn't do tcsetattr2");
return c;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x3620
testl %eax, %eax
je 0xff07
leaq 0x906c(%rip), %rdi      # 0x18f6c
xorl %eax, %eax
callq 0xa61f
leaq 0x4(%rsp), %rdx
movl 0xc(%rdx), %ebx
movl %ebx, %eax
andl $-0xb, %eax
movl %eax, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3630
cmpl $-0x1, %eax
jne 0xff33
leaq 0x9056(%rip), %rdi      # 0x18f82
xorl %eax, %eax
callq 0xa61f
leaq 0x3(%rsp), %rsi
pushq $0x1
popq %rdx
xorl %edi, %edi
callq 0x33d0
cmpq $0x1, %rax
je 0xff56
leaq 0x9049(%rip), %rdi      # 0x18f98
xorl %eax, %eax
callq 0xa721
leaq 0x4(%rsp), %rdx
movl %ebx, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3630
cmpl $-0x1, %eax
jne 0xff7a
leaq 0x9039(%rip), %rdi      # 0x18fac
xorl %eax, %eax
callq 0xa61f
movsbl 0x3(%rsp), %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/osunix.c
// Function: vaDumpStack
void vaDumpStack(char *format, va_list args)
/* debugging function to run the pstack program on the current process. In
 * prints a message, following by a new line, and then the stack track.  Just
 * prints errors to stderr rather than aborts. For debugging purposes
 * only.  */
{
static boolean inDumpStack = FALSE;  // don't allow re-entry if called from error handler
if (inDumpStack)
    return;
inDumpStack = TRUE;

fflush(stdout);  // clear buffer before forking
vfprintf(stderr, format, args);
fputc('\n', stderr);
fflush(stderr);
pid_t ppid = getpid();
pid_t pid = fork();
if (pid < 0)
    {
    perror("can't fork pstack");
    return;
    }
if (pid == 0)
    execPStack(ppid);
int wstat;
if (waitpid(pid, &wstat, 0) < 0)
    perror("waitpid on pstack failed");
else
    {
    if (WIFEXITED(wstat))
        {
        if (WEXITSTATUS(wstat) != 0)
            fprintf(stderr, "pstack failed\n");
        }
    else if (WIFSIGNALED(wstat))
        fprintf(stderr, "pstack signaled %d\n", WTERMSIG(wstat));
    }
inDumpStack = FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x171fb(%rip)     # 0x271d0
je 0xffe2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x171e1(%rip)     # 0x271d0
movq 0x15fd2(%rip), %rax     # 0x25fc8
movq (%rax), %rdi
callq 0x3520
movq 0x15ff3(%rip), %r15     # 0x25ff8
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3670
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x33a0
movq (%r15), %rdi
callq 0x3520
callq 0x31b0
movl %eax, %ebp
callq 0x3750
testl %eax, %eax
js 0x10103
movl %eax, %ebx
jne 0x100b0
movslq %ebp, %rcx
leaq 0x902b(%rip), %rdx      # 0x19073
leaq 0x20(%rsp), %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x939d
leaq 0x8f82(%rip), %rax      # 0x18fe3
movq %rax, (%rsp)
movq %r14, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
callq 0x3240
testl %eax, %eax
jns 0x1008d
leaq 0x8ff1(%rip), %rdi      # 0x19077
xorl %eax, %eax
callq 0xa61f
leaq 0x8f4f(%rip), %rdi      # 0x18fe3
movq %rsp, %r14
movq %r14, %rsi
callq 0x3690
movq (%r14), %rsi
leaq 0x8fda(%rip), %rdi      # 0x19083
xorl %eax, %eax
callq 0xa61f
leaq 0x20(%rsp), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x3610
testl %eax, %eax
js 0x10119
movl 0x20(%rsp), %eax
movl %eax, %edx
andl $0x7f, %edx
je 0x100f1
movl %edx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x100f7
movq (%r15), %rdi
leaq 0x8f2a(%rip), %rsi      # 0x19012
xorl %eax, %eax
callq 0x3470
jmp 0x100f7
testw $0xff00, %ax            # imm = 0xFF00
jne 0x10127
movb $0x0, 0x170d2(%rip)     # 0x271d0
jmp 0xffd7
leaq 0x8ece(%rip), %rdi      # 0x18fd8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3640
leaq 0x8eca(%rip), %rdi      # 0x18fea
callq 0x3640
jmp 0x100f7
movq (%r15), %rcx
leaq 0x8ed2(%rip), %rdi      # 0x19003
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x36f0
jmp 0x100f7
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/osunix.c
// Function: maybeTouchFile
boolean maybeTouchFile(char *fileName)
/* If file exists, set its access and mod times to now.  If it doesn't exist, create it.
 * Return FALSE if we have a problem doing so (e.g. when qateam is gdb'ing and code tries 
 * to touch some file owned by www). */
{
if (fileExists(fileName))
    {
    struct utimbuf ut;
    ut.actime = ut.modtime = clock1();
    int ret = utime(fileName, &ut);
    if (ret != 0)
	{
	warn("utime(%s) failed (ownership?)", fileName);
	return FALSE;
	}
    }
else
    {
    FILE *f = fopen(fileName, "w");
    if (f == NULL)
	return FALSE;
    else
	carefulClose(&f);
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x91b9
testl %eax, %eax
je 0x1020a
callq 0xf612
leaq 0x8(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3050
testl %eax, %eax
je 0x1022d
leaq 0x8e2a(%rip), %rdi      # 0x19026
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa3aa
jmp 0x10234
leaq 0x7822(%rip), %rsi      # 0x17a33
movq %rbx, %rdi
callq 0x3480
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10232
leaq 0x8(%rsp), %rdi
callq 0x8c9c
pushq $0x1
popq %rbp
jmp 0x10234
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineFree
void pipelineFree(struct pipeline **plPtr)
/* free a pipeline object */
{
struct pipeline *pl = *plPtr;
if (pl != NULL)
    {
    struct plProc *proc = pl->procs;
    while (proc != NULL)
        {
        struct plProc *delProc = proc;
        proc = proc->next;
        plProcFree(delProc);
        }
    freez(&pl->procName);
    freez(&pl->stdioBuf);
    freez(plPtr);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x10321
movq %rdi, %rbx
movq (%r14), %r15
testq %r15, %r15
je 0x102fb
movq (%r15), %r12
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi,%r13), %rax
testq %rax, %rax
je 0x102e9
movq %rax, %rdi
callq 0xd8f9
addq $0x8, %r13
jmp 0x102ce
callq 0xd8f9
movq %r15, %rdi
callq 0xd8f9
movq %r12, %r15
jmp 0x102c3
leaq 0x10(%r14), %rdi
callq 0xd909
addq $0x28, %r14
movq %r14, %rdi
callq 0xd909
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd909
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineOpenFd
struct pipeline *pipelineOpenFd(char ***cmds, unsigned opts,
                                int otherEndFd, int stderrFd)
/* Create a pipeline from an array of commands.  See pipeline.h for
 * full documentation. */
{
struct pipeline *pl;

checkOpts(opts);
pl = pipelineNew(cmds, opts);
if (opts & pipelineRead)
    pipelineStartRead(pl, otherEndFd, stderrFd, NULL, 0);
else
    pipelineStartWrite(pl, otherEndFd, stderrFd);
return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %edi
callq 0x103a8
movq %rbx, %rdi
movl %r15d, %esi
callq 0x103e0
movq %rax, %rbx
movq %rax, %rdi
testb $0x1, %r15b
jne 0x1038b
addq $0x18, %rdi
callq 0x10a82
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movl %eax, %esi
movl %r14d, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x10ab6
movq %r15, %rdi
callq 0x10660
jmp 0x1039a
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x104f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: checkOpts
static void checkOpts(unsigned opts)
/* check option set for consistency */
{
if (((opts & (pipelineRead|pipelineWrite)) == 0)
    || ((opts & (pipelineRead|pipelineWrite)) == (pipelineRead|pipelineWrite)))
    errAbort("must specify one of pipelineRead or pipelineWrite to pipelineOpen");
if ((opts & pipelineAppend) && ((opts & pipelineWrite) == 0))
    errAbort("pipelineAppend is valid only in conjunction with pipelineWrite");
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, %eax
andl $0x3, %eax
cmpl $0x3, %eax
je 0x103b9
testl %eax, %eax
jne 0x103c7
leaq 0x8deb(%rip), %rdi      # 0x191ab
xorl %eax, %eax
callq 0xa61f
andl $0x12, %ebx
cmpl $0x10, %ebx
jne 0x103de
leaq 0x8e17(%rip), %rdi      # 0x191ed
xorl %eax, %eax
popq %rbx
jmp 0xa61f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineNew
static struct pipeline* pipelineNew(char ***cmds, unsigned options)
/* create a new pipeline object. Doesn't start processes */
{
static char *memPseudoCmd[] = {"[mem]", NULL};
struct pipeline *pl;
int iCmd;

AllocVar(pl);
pl->groupLeader = -1;
pl->pipeFd = -1;
pl->options = options;
pl->procName = joinCmds(cmds);

if (cmds[0] == NULL)
    errAbort("no commands in pipeline");

if (options & pipelineMemInput)
    {
    /* add proc for forked process to write memory to pipeline */
    slAddTail(&pl->procs, plProcNew(memPseudoCmd, pl));
    }

for(iCmd = 0; cmds[iCmd] != NULL; iCmd++)
    slAddTail(&pl->procs, plProcNew(cmds[iCmd], pl));

return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0xd87c
movq %rax, %r14
orl $-0x1, 0xc(%rax)
orl $-0x1, 0x18(%rax)
movl %ebp, 0xc(%rsp)
movl %ebp, 0x1c(%rax)
movl $0x200, %edi            # imm = 0x200
callq 0x9df0
movq %rax, %r15
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x94b9(%rip), %r12      # 0x198e1
cmpq $0x0, (%rbx,%rbp,8)
je 0x1047e
testq %rbp, %rbp
je 0x10443
movq %r15, %rdi
leaq 0x8e0c(%rip), %rsi      # 0x1924a
callq 0x9ffe
xorl %r13d, %r13d
movq (%rbx,%rbp,8), %rax
movq (%rax,%r13), %rsi
testq %rsi, %rsi
je 0x10479
testq %r13, %r13
je 0x1046b
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ffe
movq (%rbx,%rbp,8), %rax
movq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x9ffe
addq $0x8, %r13
jmp 0x10446
incq %rbp
jmp 0x10428
leaq 0x10(%rsp), %rdi
callq 0x9e4a
movq %rax, 0x10(%r14)
cmpq $0x0, (%rbx)
jne 0x104a0
leaq 0x8d99(%rip), %rdi      # 0x19232
xorl %eax, %eax
callq 0xa61f
testb $0x8, 0xc(%rsp)
je 0x104da
leaq 0x16122(%rip), %rdi     # 0x265d0
movq %r14, %rsi
callq 0x109f8
movq %r14, %rdi
movq %rax, %rsi
callq 0x60da
jmp 0x104da
movq %r14, %rsi
callq 0x109f8
movq %r14, %rdi
movq %rax, %rsi
callq 0x60da
addq $0x8, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x104c3
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineOpen
struct pipeline *pipelineOpen(char ***cmds, unsigned opts,
                              char *otherEndFile, char *stderrFile)
/* Create a pipeline from an array of commands.  See pipeline.h for
 * full documentation */
{
int otherEndFd;
int stderrFd = (stderrFile == NULL) ? STDERR_FILENO : openWrite(stderrFile, FALSE);

checkOpts(opts);
boolean append = ((opts & pipelineAppend) != 0);
if (opts & pipelineRead)
    otherEndFd = (otherEndFile == NULL) ? STDIN_FILENO : openRead(otherEndFile);
else
    otherEndFd = (otherEndFile == NULL) ? STDOUT_FILENO : openWrite(otherEndFile, append);
struct pipeline *pl = pipelineOpenFd(cmds, opts, otherEndFd, stderrFd);
safeClose(&otherEndFd);
if (stderrFile != NULL)
    safeClose(&stderrFd);
return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
testq %rcx, %rcx
je 0x10577
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1061d
movl %eax, %r15d
jmp 0x1057b
pushq $0x2
popq %r15
movl %r15d, (%rsp)
movl %ebp, %edi
callq 0x103a8
testb $0x1, %bpl
jne 0x105a6
testq %r12, %r12
je 0x105d1
movl %ebp, %esi
shrl $0x4, %esi
andl $0x1, %esi
movq %r12, %rdi
callq 0x1061d
movl %eax, %r13d
jmp 0x105da
testq %r12, %r12
je 0x105d7
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x35b0
movl %eax, %r13d
testl %eax, %eax
jns 0x105da
leaq 0x8f8b(%rip), %rdi      # 0x19550
movq %r12, %rsi
xorl %eax, %eax
callq 0xa721
jmp 0x105da
pushq $0x1
popq %r13
jmp 0x105da
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movl %r13d, (%r12)
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r15d, %ecx
callq 0x1032b
movq %rax, %r14
movq %r12, %rdi
callq 0x10660
testq %rbx, %rbx
je 0x1060b
movq %rsp, %rdi
callq 0x10660
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: openWrite
static int openWrite(char *fname, boolean append)
/* open a file for write access */
{
int flags = O_WRONLY|O_CREAT;
if (append)
    flags |= O_APPEND;
else
    flags |= O_TRUNC;
int fd = open(fname, flags, 0666);
if (fd < 0)
    errnoAbort("can't open for write access: %s", fname);
return fd;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
testl %esi, %esi
setne %al
shll $0x9, %eax
addl $0x241, %eax            # imm = 0x241
movl %eax, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x35b0
movl %eax, %ebp
testl %eax, %eax
jns 0x10657
leaq 0x8ee3(%rip), %rdi      # 0x19530
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa721
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: safeClose
static void safeClose(int *fdPtr)
/* Close with error checking.  *fdPtr == -1 indicated already closed */
{
int fd = *fdPtr;
if (fd != -1)
    {
    if (close(fd) < 0)
        errnoAbort("close failed on fd %d", fd);
    *fdPtr = -1;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rdi), %ebp
cmpl $-0x1, %ebp
je 0x1068b
movq %rdi, %rbx
movl %ebp, %edi
callq 0x3350
testl %eax, %eax
jns 0x10688
leaq 0x8ef0(%rip), %rdi      # 0x1956f
movl %ebp, %esi
xorl %eax, %eax
callq 0xa721
orl $-0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineOpenMem
struct pipeline *pipelineOpenMem(char ***cmds, unsigned opts,
                                 void *otherEndBuf, size_t otherEndBufSize,
                                 int stderrFd)
/* Create a pipeline from an array of commands, with the pipeline input/output
 * in a memory buffer.  See pipeline.h for full documentation.  Currently only
 * input to a read pipeline is supported  */
{
struct pipeline *pl;
checkOpts(opts);
if (opts & pipelineWrite)
    errAbort("pipelineOpenMem only supports read pipelines at this time");
opts |= pipelineMemInput;

pl = pipelineNew(cmds, opts);
pipelineStartRead(pl, STDIN_FILENO, stderrFd, otherEndBuf, otherEndBufSize);
return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl %esi, %edi
callq 0x103a8
testb $0x2, %r15b
je 0x106c4
leaq 0x89d6(%rip), %rdi      # 0x19093
xorl %eax, %eax
callq 0xa61f
orl $0x8, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x103e0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x104f4
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineFile
FILE *pipelineFile(struct pipeline *pl)
/* Get a FILE object wrapped around the pipeline.  Do not close the FILE, is
 * owned by the pipeline object.  A FILE is created on first call to this
 * function.  Subsequent calls return the same FILE.*/
{
if (pl->pipeFh == NULL)
    {
    /* create FILE* on first access */
    char *mode = (pl->options & pipelineRead) ? "r" : "w";
    if (pl->pipeLf != NULL)
        errAbort("can't call pipelineFile after having associated a lineFile with a pipeline");
    pl->pipeFh = fdopen(pl->pipeFd, mode);
    if (pl->pipeFh == NULL)
        errnoAbort("fdopen failed for: %s", pl->procName);
    pl->stdioBuf = needLargeMem(FILE_BUF_SIZE);
    setvbuf(pl->pipeFh, pl->stdioBuf,  _IOFBF, FILE_BUF_SIZE);
    }
return pl->pipeFh;
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1075b
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1, 0x1c(%rdi)
leaq 0x72c6(%rip), %rax      # 0x17a33
leaq 0xa0bc(%rip), %r14      # 0x1a830
cmoveq %rax, %r14
cmpq $0x0, 0x30(%rdi)
je 0x1078d
leaq 0x8947(%rip), %rdi      # 0x190cd
xorl %eax, %eax
callq 0xa61f
movl 0x18(%rbx), %edi
movq %r14, %rsi
callq 0x3580
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x107b3
movq 0x10(%rbx), %rsi
leaq 0x896c(%rip), %rdi      # 0x19118
xorl %eax, %eax
callq 0xa721
movl $0x10000, %edi          # imm = 0x10000
callq 0xd684
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
movl $0x10000, %ecx          # imm = 0x10000
movq %rax, %rsi
xorl %edx, %edx
callq 0x3590
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineLineFile
struct lineFile *pipelineLineFile(struct pipeline *pl)
/* Get a lineFile object wrapped around the pipeline.  Do not close the
 * lineFile, is owned by the pipeline object.  A lineFile is created on first
 * call to this function.  Subsequent calls return the same object.*/
{
if (pl->pipeLf == NULL)
    {
    /* create line on first acess */
    if (pl->pipeFh != NULL)
        errAbort("can't call pipelineLineFile after having associated a FILE with a pipeline");
    if (pl->options & pipelineWrite)
        errAbort("can't associated a lineFile with a write pipeline");
    pl->pipeLf = lineFileAttach(pipelineDesc(pl), TRUE, pl->pipeFd);
    }
return pl->pipeLf;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x107ea
retq
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x10803
leaq 0x8932(%rip), %rdi      # 0x1912e
xorl %eax, %eax
callq 0xa61f
testb $0x2, 0x1c(%rbx)
je 0x10817
leaq 0x8969(%rip), %rdi      # 0x19179
xorl %eax, %eax
callq 0xa61f
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %edx
pushq $0x1
popq %rsi
callq 0xb940
movq %rax, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineDumpCmds
void pipelineDumpCmds(char ***cmds)
/* Dump out pipeline-formatted commands to stdout for debugging. */
{
char **cmd;
boolean first = TRUE;
while ((cmd = *cmds++) != NULL)
   {
   char *word;
   if (first)
      first = FALSE;
   else
      printf("| ");
   while ((word = *cmd++) != NULL)
       printf("%s ", word);
   }
printf("<BR>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x88a8(%rip), %r14      # 0x1924b
leaq 0x8c32(%rip), %r15      # 0x195dc
movq (%rbx), %r12
testq %r12, %r12
je 0x109e1
testb $0x1, %al
je 0x109c0
movq %r14, %rdi
xorl %eax, %eax
callq 0x3270
addq $0x8, %rbx
movq (%r12), %rsi
testq %rsi, %rsi
je 0x109dd
addq $0x8, %r12
movq %r15, %rdi
xorl %eax, %eax
callq 0x3270
jmp 0x109c4
movb $0x1, %al
jmp 0x109aa
leaq 0x8c72(%rip), %rdi      # 0x1965a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: plProcNew
static struct plProc* plProcNew(char **cmd, struct pipeline *pl)
/* create a new plProc object for a command. */
{
struct plProc* proc;
AllocVar(proc);
proc->pl = pl;
proc->cmd = cloneCmdVector(cmd);
proc->state = procStateNew;
return proc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0xd87c
movq %rax, %rbx
movq %r15, 0x8(%rax)
xorl %eax, %eax
movq %rax, %r12
incq %rax
cmpq $0x0, (%r14,%r12,8)
jne 0x10a1a
leaq 0x8(,%r12,8), %rax
movabsq $0x7fffffff8, %rdi      # imm = 0x7FFFFFFF8
andq %rax, %rdi
callq 0xd87c
movq %rax, %r15
movl %r12d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x10a60
movq (%r14,%rbp,8), %rdi
callq 0x5ede
movq %rax, (%r15,%rbp,8)
incq %rbp
jmp 0x10a49
movl %r12d, %eax
andq $0x0, (%r15,%rax,8)
movq %r15, 0x10(%rbx)
andl $0x0, 0x1c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/pipeline.c
// Function: pipeCreate
static int pipeCreate(int *writeFd)
/* create a pipe or die, return readFd */
{
int pipeFds[2];
if (pipe(pipeFds) < 0)
    errnoAbort("can't create pipe");
*writeFd = pipeFds[1];
return pipeFds[0];
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3360
testl %eax, %eax
jns 0x10aa6
leaq 0x87af(%rip), %rdi      # 0x1924e
xorl %eax, %eax
callq 0xa721
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movl 0x8(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq