LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x11a3a
leaq 0x952c(%rip), %rdi      # 0x1af5f
xorl %eax, %eax
callq 0xb8d7
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 0x11a66
leaq 0x9516(%rip), %rdi      # 0x1af75
xorl %eax, %eax
callq 0xb8d7
leaq 0x3(%rsp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x33d0
cmpq $0x1, %rax
je 0x11a8b
leaq 0x9507(%rip), %rdi      # 0x1af8b
xorl %eax, %eax
callq 0xba00
leaq 0x4(%rsp), %rdx
movl %ebx, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3630
cmpl $-0x1, %eax
jne 0x11aaf
leaq 0x94f7(%rip), %rdi      # 0x1af9f
xorl %eax, %eax
callq 0xb8d7
movsbl 0x3(%rsp), %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x166a6(%rip)     # 0x281b0
je 0x11b17
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x1668c(%rip)     # 0x281b0
movq 0x1549d(%rip), %rax     # 0x26fc8
movq (%rax), %rdi
callq 0x3520
movq 0x154be(%rip), %r15     # 0x26ff8
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3670
movq (%r15), %rsi
movl $0xa, %edi
callq 0x33a0
movq (%r15), %rdi
callq 0x3520
callq 0x31b0
movl %eax, %ebp
callq 0x3750
testl %eax, %eax
js 0x11c40
movl %eax, %ebx
jne 0x11bec
movslq %ebp, %rcx
leaq 0x94e7(%rip), %rdx      # 0x1b066
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x20, %esi
xorl %eax, %eax
callq 0xa2ce
leaq 0x943c(%rip), %rax      # 0x1afd6
movq %rax, (%rsp)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x3240
testl %eax, %eax
jns 0x11bcd
leaq 0x94a4(%rip), %rdi      # 0x1b06a
xorl %eax, %eax
callq 0xb8d7
movq %rsp, %r14
movq (%r14), %rdi
movq %r14, %rsi
callq 0x3690
movq (%r14), %rsi
leaq 0x9491(%rip), %rdi      # 0x1b076
xorl %eax, %eax
callq 0xb8d7
leaq 0x20(%rsp), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x3610
testl %eax, %eax
js 0x11c56
movl 0x20(%rsp), %eax
movl %eax, %edx
andl $0x7f, %edx
je 0x11c2d
movl %edx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x11c34
movq (%r15), %rdi
leaq 0x93e1(%rip), %rsi      # 0x1b005
xorl %eax, %eax
callq 0x3470
jmp 0x11c34
testl $0xff00, %eax           # imm = 0xFF00
jne 0x11c64
movb $0x0, 0x16575(%rip)     # 0x281b0
jmp 0x11b0c
leaq 0x9384(%rip), %rdi      # 0x1afcb
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3640
leaq 0x9380(%rip), %rdi      # 0x1afdd
callq 0x3640
jmp 0x11c34
callq 0x380f
jmp 0x11c34
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0xa0fe
testl %eax, %eax
je 0x11d45
xorl %ebx, %ebx
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x32d0
movq (%r15), %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x3050
testl %eax, %eax
je 0x11d65
leaq 0x92e0(%rip), %rdi      # 0x1b019
movq %r14, %rsi
xorl %eax, %eax
callq 0xb632
jmp 0x11d6e
leaq 0x7cd7(%rip), %rsi      # 0x19a23
movq %r14, %rdi
callq 0x3480
movq %rax, (%rsp)
testq %rax, %rax
je 0x11d6c
movq %rsp, %rdi
callq 0x9bbc
movl $0x1, %ebx
jmp 0x11d6e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11e6d
movq %rdi, %rbx
movq (%r14), %r15
testq %r15, %r15
je 0x11e47
movq (%r15), %r12
movq 0x10(%r15), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x11e2f
movl $0x8, %r13d
callq 0xf129
movq 0x10(%r15), %rax
movq (%rax,%r13), %rdi
addq $0x8, %r13
testq %rdi, %rdi
jne 0x11e19
movq %rax, %rdi
callq 0xf129
movq %r15, %rdi
callq 0xf129
movq %r12, %r15
testq %r12, %r12
jne 0x11e04
leaq 0x10(%r14), %rdi
callq 0xf139
addq $0x28, %r14
movq %r14, %rdi
callq 0xf139
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf139
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11ef4
movq %rbx, %rdi
movl %r15d, %esi
callq 0x11f2c
movq %rax, %rbx
movq %rax, %rdi
testb $0x1, %r15b
jne 0x11ed7
addq $0x18, %rdi
callq 0x12606
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 0x1263a
movq %r15, %rdi
callq 0x121d5
jmp 0x11ee6
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12065
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11f05
testl %eax, %eax
jne 0x11f13
leaq 0x9292(%rip), %rdi      # 0x1b19e
xorl %eax, %eax
callq 0xb8d7
andl $0x12, %ebx
cmpl $0x10, %ebx
jne 0x11f2a
leaq 0x92be(%rip), %rdi      # 0x1b1e0
xorl %eax, %eax
popq %rbx
jmp 0xb8d7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x38, %edi
callq 0xf07d
movq %rax, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%r14)
movl %eax, 0x18(%r14)
movl %ebp, 0x14(%rsp)
movl %ebp, 0x1c(%r14)
movl $0x200, %edi            # imm = 0x200
callq 0xaf38
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rbx)
je 0x11fe5
xorl %r13d, %r13d
leaq 0x9954(%rip), %r15      # 0x1b8d4
leaq 0x92b6(%rip), %r12      # 0x1b23d
testq %r13, %r13
je 0x11f99
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xb18d
movq (%rbx,%r13,8), %rax
cmpq $0x0, (%rax)
je 0x11fd9
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x11fb7
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xb18d
movq 0x8(%rsp), %rdi
movq (%rbx,%r13,8), %rax
movq (%rax,%rbp), %rsi
callq 0xb18d
movq (%rbx,%r13,8), %rax
cmpq $0x0, 0x8(%rax,%rbp)
leaq 0x8(%rbp), %rbp
jne 0x11fa5
cmpq $0x0, 0x8(%rbx,%r13,8)
leaq 0x1(%r13), %r13
jne 0x11f87
leaq 0x8(%rsp), %rdi
callq 0xaf94
movq %rax, 0x10(%r14)
cmpq $0x0, (%rbx)
jne 0x12007
leaq 0x9225(%rip), %rdi      # 0x1b225
xorl %eax, %eax
callq 0xb8d7
testb $0x8, 0x14(%rsp)
je 0x12028
leaq 0x1559b(%rip), %rdi     # 0x275b0
movq %r14, %rsi
callq 0x1257c
movq %r14, %rdi
movq %rax, %rsi
callq 0x66cd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x12053
addq $0x8, %rbx
movq %r14, %rsi
callq 0x1257c
movq %r14, %rdi
movq %rax, %rsi
callq 0x66cd
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x12034
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_O1/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 0x120e8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12192
movl %eax, %r15d
jmp 0x120ee
movl $0x2, %r15d
movl %r15d, (%rsp)
movl %ebp, %edi
callq 0x11ef4
testb $0x1, %bpl
jne 0x12119
testq %r12, %r12
je 0x12144
movl %ebp, %esi
shrl $0x4, %esi
andl $0x1, %esi
movq %r12, %rdi
callq 0x12192
movl %eax, %r13d
jmp 0x1214f
testq %r12, %r12
je 0x1214c
movq %r12, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x35b0
movl %eax, %r13d
testl %eax, %eax
jns 0x1214f
leaq 0x940b(%rip), %rdi      # 0x1b543
movq %r12, %rsi
xorl %eax, %eax
callq 0xba00
jmp 0x1214f
movl $0x1, %r13d
jmp 0x1214f
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movl %r13d, (%r12)
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r15d, %ecx
callq 0x11e77
movq %rax, %r14
movq %r12, %rdi
callq 0x121d5
testq %rbx, %rbx
je 0x12180
movq %rsp, %rdi
callq 0x121d5
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_O1/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 0x121cc
leaq 0x9361(%rip), %rdi      # 0x1b523
movq %rbx, %rsi
xorl %eax, %eax
callq 0xba00
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12203
movq %rdi, %rbx
movl %ebp, %edi
callq 0x3350
testl %eax, %eax
jns 0x121fd
leaq 0x936e(%rip), %rdi      # 0x1b562
movl %ebp, %esi
xorl %eax, %eax
callq 0xba00
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11ef4
testb $0x2, %r15b
je 0x1223c
leaq 0x8e51(%rip), %rdi      # 0x1b086
xorl %eax, %eax
callq 0xb8d7
orl $0x8, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x11f2c
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x12065
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x12352
testb $0x1, 0x1c(%rbx)
leaq 0x7738(%rip), %rax      # 0x19a23
leaq 0xa55f(%rip), %r14      # 0x1c851
cmoveq %rax, %r14
cmpq $0x0, 0x30(%rbx)
je 0x1230b
leaq 0x8dbc(%rip), %rdi      # 0x1b0c0
xorl %eax, %eax
callq 0xb8d7
movl 0x18(%rbx), %edi
movq %r14, %rsi
callq 0x3580
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x12331
movq 0x10(%rbx), %rsi
leaq 0x8de1(%rip), %rdi      # 0x1b10b
xorl %eax, %eax
callq 0xba00
movl $0x10000, %edi          # imm = 0x10000
callq 0xee85
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_O1/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:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
jne 0x123a7
cmpq $0x0, 0x20(%rbx)
je 0x1237e
leaq 0x8daa(%rip), %rdi      # 0x1b121
xorl %eax, %eax
callq 0xb8d7
testb $0x2, 0x1c(%rbx)
je 0x12392
leaq 0x8de1(%rip), %rdi      # 0x1b16c
xorl %eax, %eax
callq 0xb8d7
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %edx
movl $0x1, %esi
callq 0xcea6
movq %rax, 0x30(%rbx)
movq 0x30(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r12
testq %r12, %r12
je 0x12565
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8d20(%rip), %r14      # 0x1b23e
leaq 0x90aa(%rip), %r15      # 0x1b5cf
testb $0x1, %al
je 0x12533
movq %r14, %rdi
xorl %eax, %eax
callq 0x3270
movq (%r12), %rsi
testq %rsi, %rsi
je 0x12557
addq $0x8, %r12
movq %r15, %rdi
xorl %eax, %eax
callq 0x3270
movq (%r12), %rsi
addq $0x8, %r12
testq %rsi, %rsi
jne 0x12540
addq $0x8, %rbx
movq (%rbx), %r12
movb $0x1, %al
testq %r12, %r12
jne 0x12525
leaq 0x90e1(%rip), %rdi      # 0x1b64d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0xf07d
movq %rax, %rbx
movq %r15, 0x8(%rax)
cmpq $0x0, (%r14)
je 0x125b3
xorl %r13d, %r13d
cmpq $0x0, 0x8(%r14,%r13,8)
leaq 0x1(%r13), %r13
jne 0x125a5
jmp 0x125b6
xorl %r13d, %r13d
movl %r13d, %r12d
leaq 0x8(,%r12,8), %rdi
callq 0xf07d
movq %rax, %r15
testl %r13d, %r13d
je 0x125e6
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
callq 0x647e
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x125d1
movq $0x0, (%r15,%r12,8)
movq %r15, 0x10(%rbx)
movl $0x0, 0x1c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1262a
leaq 0x8c1e(%rip), %rdi      # 0x1b241
xorl %eax, %eax
callq 0xba00
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movl 0x8(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineExec
static void pipelineExec(struct pipeline* pl, int stdinFd, int stdoutFd, int stderrFd,
                         void *otherEndBuf, size_t otherEndBufSize)
/* Fork the group leader, which then launches all all processes in a pipeline,
 * stdinFd and stdoutFd are the ends of the pipeline, stderrFd is applied to
 * all processes, including group leader */
{
assert(pl->groupLeader < 0);  // should not be set
if ((pl->groupLeader = fork()) < 0)
    errnoAbort("can't fork");
if (pl->groupLeader == 0)
    {
    groupLeaderRun(pl, stdinFd, stdoutFd, stderrFd, otherEndBuf, otherEndBufSize);
    exit(1); // doesn't return to here
    }
else
    {
    // parent also must also setpgid to prevent race condition
    if (setpgid(pl->groupLeader, pl->groupLeader) != 0)
        errnoAbort("error from parent setpgid(%d, %d)", pl->groupLeader, pl->groupLeader);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0xc(%rdi)
jns 0x126b8
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
callq 0x3750
movl %eax, 0xc(%rbx)
testl %eax, %eax
jns 0x12676
leaq 0x8c47(%rip), %rdi      # 0x1b2b6
xorl %eax, %eax
callq 0xba00
movl 0xc(%rbx), %edi
testl %edi, %edi
je 0x126d7
movl %edi, %esi
callq 0x36c0
testl %eax, %eax
je 0x126a9
movl 0xc(%rbx), %edx
leaq 0x8c2f(%rip), %rdi      # 0x1b2c1
movl %edx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xba00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8b94(%rip), %rdi      # 0x1b253
leaq 0x8ba1(%rip), %rsi      # 0x1b267
leaq 0x8ba5(%rip), %rcx      # 0x1b272
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x32e0
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movq %r15, %r8
movq %r14, %r9
callq 0x126ed
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: groupLeaderRun
static void groupLeaderRun(struct pipeline* pl, int stdinFd, int stdoutFd, int stderrFd,
                           void *otherEndBuf, size_t otherEndBufSize)
/* group leader process */
{
pl->groupLeader = getpid();
if (setpgid(pl->groupLeader, pl->groupLeader) != 0)
    errnoAbort("error from child setpgid(%d, %d)", pl->groupLeader, pl->groupLeader);
pipelineGroupExec(pl, stdinFd, stdoutFd, stderrFd, otherEndBuf, otherEndBufSize);

// only keep stderr open
close(STDIN_FILENO);
close(STDOUT_FILENO);
closeNonStdDescriptors();
groupWait(pl);
exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
callq 0x31b0
movl %eax, 0xc(%rbx)
movl %eax, %edi
movl %eax, %esi
callq 0x36c0
testl %eax, %eax
je 0x12731
movl 0xc(%rbx), %edx
leaq 0x8bbb(%rip), %rdi      # 0x1b2e3
movl %edx, %esi
xorl %eax, %eax
callq 0xba00
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movq %r15, %r8
movq %r14, %r9
callq 0x1276c
xorl %edi, %edi
callq 0x3350
movl $0x1, %edi
callq 0x3350
callq 0x12966
movq %rbx, %rdi
callq 0x129a3
xorl %edi, %edi
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineGroupExec
static void pipelineGroupExec(struct pipeline* pl, int stdinFd, int stdoutFd, int stderrFd,
                              void *otherEndBuf, size_t otherEndBufSize)
/* Start all processes in a pipeline, stdinFd and stdoutFd are the ends of
 * the pipeline, stderrFd is applied to all processed */
{
struct plProc *proc;
int prevStdoutFd = -1;
for (proc = pl->procs; proc != NULL; proc = proc->next)
    {
    prevStdoutFd = pipelineExecProc(pl, proc, prevStdoutFd,
                                    stdinFd, stdoutFd, stderrFd,
                                    otherEndBuf, otherEndBufSize);
    otherEndBuf = NULL;  /* only for first process (read pipes) */
    otherEndBufSize = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq (%rdi), %r12
testq %r12, %r12
je 0x12946
movq %r9, %rbx
movq %r8, %rbp
movl %esi, %r14d
movq %rdi, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, (%rsp)
cmpq %r12, (%r15)
movl %eax, %r13d
cmovel %r14d, %r13d
movl %r13d, 0x14(%rsp)
cmpq $0x0, (%r12)
je 0x127c8
leaq 0x4(%rsp), %rdi
callq 0x12606
movl %eax, 0xc(%rsp)
jmp 0x127d4
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3750
movl %eax, 0x18(%r12)
testl %eax, %eax
jns 0x127f0
leaq 0x8acd(%rip), %rdi      # 0x1b2b6
xorl %eax, %eax
callq 0xba00
cmpl $0x0, 0x18(%r12)
jne 0x128e2
movl 0x4(%rsp), %r14d
movl $0x1, %esi
movl $0xd, %edi
callq 0x3450
cmpq $-0x1, %rax
jne 0x12824
leaq 0x8ae7(%rip), %rdi      # 0x1b304
xorl %eax, %eax
callq 0xba00
callq 0x31b0
movl 0xc(%r15), %esi
movl %eax, %edi
callq 0x36c0
testl %eax, %eax
je 0x12851
callq 0x31b0
movl 0xc(%r15), %edx
leaq 0x8ad3(%rip), %rdi      # 0x1b31b
movl %eax, %esi
xorl %eax, %eax
callq 0xba00
testq %rbp, %rbp
je 0x1289c
xorl %edi, %edi
movl %r14d, %esi
movl 0x8(%rsp), %edx
callq 0x12b1b
movl $0x1, %edi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x31a0
testq %rax, %rax
js 0x128d0
cmpq %rbx, %rax
movl (%rsp), %r14d
je 0x12955
leaq 0x8acc(%rip), %rdi      # 0x1b359
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8d7
jmp 0x128e2
movl %r13d, %edi
movl %r14d, %esi
movl 0x8(%rsp), %edx
callq 0x12b1b
movq 0x10(%r12), %rsi
movq (%rsi), %rdi
callq 0x3690
movq 0x10(%r12), %rax
movq (%rax), %rsi
leaq 0x87af(%rip), %rdi      # 0x1b076
xorl %eax, %eax
callq 0xba00
jmp 0x128de
leaq 0x8a5f(%rip), %rdi      # 0x1b336
xorl %eax, %eax
callq 0xba00
movl (%rsp), %r14d
movl 0x1c(%r12), %esi
testl %esi, %esi
je 0x128fe
leaq 0x8afc(%rip), %rdi      # 0x1b3ee
movl $0x1, %edx
xorl %eax, %eax
callq 0xb8d7
movl $0x1, 0x1c(%r12)
incl 0x8(%r15)
cmpq %r12, (%r15)
je 0x1291a
leaq 0x14(%rsp), %rdi
callq 0x121d5
cmpq $0x0, (%r12)
je 0x1292b
leaq 0x4(%rsp), %rdi
callq 0x121d5
movq (%r12), %r12
movl $0x0, %ebx
movl $0x0, %ebp
testq %r12, %r12
movl 0xc(%rsp), %eax
jne 0x127a2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x3350
xorl %edi, %edi
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: closeNonStdDescriptors
static void closeNonStdDescriptors(void)
/* close non-standard file descriptors */
{
long maxFd = sysconf(_SC_OPEN_MAX);
if (maxFd < 0)
    maxFd = 4096;  // shouldn't really happen
int fd;
for (fd = STDERR_FILENO+1; fd < maxFd; fd++)
    close(fd);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x4, %edi
callq 0x3650
testq %rax, %rax
movl $0x1000, %r14d          # imm = 0x1000
cmovnsq %rax, %r14
cmpq $0x4, %r14
jl 0x1299b
movl $0x3, %ebx
movl %ebx, %edi
callq 0x3350
incq %rbx
cmpq %rbx, %r14
jne 0x1298c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: plProcSetup
static void plProcSetup(struct plProc* proc, int stdinFd, int stdoutFd, int stderrFd)
/* setup signal, error handling, and file descriptors after fork */
{
/* treat a closed pipe as an EOF rather than getting SIGPIPE */
struct sigaction sigAct;
ZeroVar(&sigAct);
sigAct.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &sigAct, NULL) != 0)
    errnoAbort("failed to set SIGPIPE to SIG_IGN");

/* child, first setup stdio files */
if (stdinFd != STDIN_FILENO)
    {
    if (dup2(stdinFd, STDIN_FILENO) < 0)
        errnoAbort("can't dup2 to stdin");
    }
    
if (stdoutFd != STDOUT_FILENO)
    {
    if (dup2(stdoutFd, STDOUT_FILENO) < 0)
        errnoAbort("can't dup2 to stdout");
    }
    
if (stderrFd != STDERR_FILENO)
    {
    if (dup2(stderrFd, STDERR_FILENO) < 0)
        errnoAbort("can't dup2 to stderr");
    }
closeNonStdDescriptors();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq %rsp, %r15
movl $0x98, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3300
movq $0x1, (%r15)
movl $0xd, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3140
testl %eax, %eax
je 0x12b69
leaq 0x882d(%rip), %rdi      # 0x1b38f
xorl %eax, %eax
callq 0xba00
testl %r14d, %r14d
je 0x12b8a
movl %r14d, %edi
xorl %esi, %esi
callq 0x3240
testl %eax, %eax
jns 0x12b8a
leaq 0x882d(%rip), %rdi      # 0x1b3b0
xorl %eax, %eax
callq 0xba00
cmpl $0x1, %ebp
je 0x12bad
movl %ebp, %edi
movl $0x1, %esi
callq 0x3240
testl %eax, %eax
jns 0x12bad
leaq 0x881e(%rip), %rdi      # 0x1b3c4
xorl %eax, %eax
callq 0xba00
cmpl $0x2, %ebx
je 0x12bd0
movl %ebx, %edi
movl $0x2, %esi
callq 0x3240
testl %eax, %eax
jns 0x12bd0
leaq 0x8810(%rip), %rdi      # 0x1b3d9
xorl %eax, %eax
callq 0xba00
callq 0x12966
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/pipeline.c
// Function: joinCmd
static char* joinCmd(char **cmd)
/* join an cmd vector into a space separated string */
{
struct dyString *str = dyStringNew(512);
int i;
for (i = 0; cmd[i] != NULL; i++)
    {
    if (i > 0)
        dyStringAppend(str, " ");
    dyStringAppend(str, cmd[i]);
    }
return dyStringCannibalize(&str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x200, %edi            # imm = 0x200
callq 0xaf38
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rbx)
je 0x12c3a
xorl %r15d, %r15d
leaq 0x8cc6(%rip), %r14      # 0x1b8d4
testq %r15, %r15
je 0x12c20
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xb18d
movq 0x8(%rsp), %rdi
movq (%rbx,%r15,8), %rsi
callq 0xb18d
cmpq $0x0, 0x8(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x12c0e
leaq 0x8(%rsp), %rdi
callq 0xaf94
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/verbose.c
// Function: verboseVa
void verboseVa(int verbosity, char *format, va_list args)
/* Log with at given verbosity vprintf formatted args. */
{
if (verbosity <= logVerbosity)
    {
    if (logFile == NULL)
        logFile = stderr;
    vfprintf(logFile, format, args);
    fflush(logFile);
    }
}

// Assembly:
cmpl %edi, 0x1496a(%rip)     # 0x275c0
jge 0x12c59
retq
cmpq $0x0, 0x15557(%rip)     # 0x281b8
jne 0x12c74
movq 0x1438e(%rip), %rax     # 0x26ff8
movq (%rax), %rax
movq %rax, 0x15544(%rip)     # 0x281b8
pushq %rax
movq 0x1553c(%rip), %rdi     # 0x281b8
callq 0x3670
movq 0x15530(%rip), %rdi     # 0x281b8
popq %rax
jmp 0x3520
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/verbose.c
// Function: verboseTime
void verboseTime(int verbosity, char *label, ...)
/* Print label and how long it's been since last call.  Start time can be
 * initialized with verboseTimeInit, otherwise the elapsed time will be
 * zero. */
{
assert(label != NULL);  // original version allowed this, but breaks some GCCs
if (lastTime < 0)
    verboseTimeInit();
long time = clock1000();
va_list args;
va_start(args, label);
verboseVa(verbosity, label, args);
verbose(verbosity, ": %ld millis\n", time - lastTime);
lastTime = time;
va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x12d7e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x12e0b
movq %rsi, %r14
movl %edi, %ebx
cmpq $0x0, 0x14834(%rip)     # 0x275c8
jns 0x12da4
xorl %eax, %eax
callq 0x10fde
movq %rax, 0x14824(%rip)     # 0x275c8
xorl %eax, %eax
callq 0x10fde
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movl %ebx, %edi
movq %r14, %rsi
callq 0x12c50
movq %r15, %rdx
subq 0x147e1(%rip), %rdx     # 0x275c8
leaq 0x889f(%rip), %rsi      # 0x1b68d
movl %ebx, %edi
xorl %eax, %eax
callq 0x12c8e
movq %r15, 0x147ca(%rip)     # 0x275c8
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8840(%rip), %rdi      # 0x1b652
leaq 0x8847(%rip), %rsi      # 0x1b660
leaq 0x884a(%rip), %rcx      # 0x1b66a
movl $0x34, %edx
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/verbose.c
// Function: verboseDotsEnabled
boolean verboseDotsEnabled()
/* check if outputting of happy dots are enabled.  They will be enabled if the
 * verbosity is > 0, stderr is a tty and we don't appear to be running an
 * emacs shell. */
{
if (!checkedDotsEnabled)
    {
    if (logFile == NULL)
        logFile = stderr;
    dotsEnabled = (logVerbosity > 0) && isatty(fileno(logFile));
    if (dotsEnabled)
        {
        /* check for an possible emacs shell */
        char *emacs = getenv("emacs");
        char *term = getenv("TERM");
        if ((emacs != NULL) && (emacs[0] == 't'))
            dotsEnabled = FALSE;
        else if ((term != NULL) && sameString(term, "dumb"))
            dotsEnabled = FALSE;
        }
    checkedDotsEnabled = TRUE;
    }
return dotsEnabled;
}

// Assembly:
cmpb $0x0, 0x1538f(%rip)     # 0x281c0
jne 0x12ecd
cmpq $0x0, 0x15379(%rip)     # 0x281b8
jne 0x12e52
movq 0x141b0(%rip), %rax     # 0x26ff8
movq (%rax), %rax
movq %rax, 0x15366(%rip)     # 0x281b8
pushq %rbx
cmpl $0x0, 0x14766(%rip)     # 0x275c0
jle 0x12ebb
movq 0x15355(%rip), %rdi     # 0x281b8
callq 0x34e0
movl %eax, %edi
callq 0x3130
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0x15348(%rip)     # 0x281c4
je 0x12ec5
leaq 0x8816(%rip), %rdi      # 0x1b69b
callq 0x3040
movq %rax, %rbx
leaq 0x922d(%rip), %rdi      # 0x1c0c1
callq 0x3040
testq %rbx, %rbx
je 0x12ea3
cmpb $0x74, (%rbx)
je 0x12ebb
testq %rax, %rax
je 0x12ec5
leaq 0x87f2(%rip), %rsi      # 0x1b6a1
movq %rax, %rdi
callq 0x3440
testl %eax, %eax
jne 0x12ec5
movl $0x0, 0x152ff(%rip)     # 0x281c4
movb $0x1, 0x152f4(%rip)     # 0x281c0
popq %rbx
movl 0x152f1(%rip), %eax     # 0x281c4
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/verbose.c
// Function: verboseSetLogFile
void verboseSetLogFile(char *name)
/* Set logFile for verbose messages overrides stderr. */
{
if (sameString(name, "stdout"))
    logFile = stdout;
else if (sameString(name, "stderr"))
    logFile = stderr;
else
    logFile = mustOpen(name, "w");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x84be(%rip), %rsi      # 0x1b3d2
callq 0x3440
testl %eax, %eax
je 0x12f41
leaq 0x84c3(%rip), %rsi      # 0x1b3e7
movq %rbx, %rdi
callq 0x3440
testl %eax, %eax
je 0x12f4a
leaq 0x6aec(%rip), %rsi      # 0x19a23
movq %rbx, %rdi
callq 0x9532
jmp 0x12f54
movq 0x14080(%rip), %rax     # 0x26fc8
jmp 0x12f51
movq 0x140a7(%rip), %rax     # 0x26ff8
movq (%rax), %rax
movq %rax, 0x1525d(%rip)     # 0x281b8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/wildcmp.c
// Function: globMatch
static boolean globMatch(const char *wildCard, const char *string, char single, char multi)
/* does a case sensitive wild card match with a string.
 * * matches any string or no character.
 * ? matches any single character.
 * anything else etc must match the character exactly. */
{
boolean matchStar = 0;
int starMatchSize;
char c;

for(;;)
    {
NEXT_WILD:
    c = *wildCard;
    if (c == 0)
	{
	if(matchStar)
	    {
	    while(*string++)
		;
	    return TRUE;
	    }
	else if(*string)
	    return FALSE;
	else
	    return TRUE;
	}
    else if (c == multi)
	{
	matchStar = TRUE;
	}
    else if (c == single)
	{
	if(*string == 0)
	    return FALSE; /* out of string, no match for ? */
	++string;
	}
    else
	{
	if(matchStar)
	    {
	    for(;;)
		{
		if(*string == 0) /* if out of string no match */
		    return FALSE;

		/* note matchStar is re-used here for substring
		 * after star match length */
		if((starMatchSize = subMatch(string,wildCard,single,multi)) != 0)
		    {
		    string += starMatchSize;
		    wildCard += starMatchSize;
		    matchStar = FALSE;
		    goto NEXT_WILD;
		    }
		++string;
		}
	    }

	/* default: they must be equal or no match */
	if(toupper(*string) != toupper(*wildCard))
	    return FALSE;
	++string;
	}
    ++wildCard;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rdi), %r13b
movb $0x1, %r12b
testb %r13b, %r13b
je 0x130b7
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
xorl %eax, %eax
cmpb %bpl, %r13b
jne 0x12fdf
movl $0x1, %eax
jmp 0x13081
cmpb %r14b, %r13b
jne 0x12ff5
cmpb $0x0, (%rbx)
je 0x130ad
incq %rbx
jmp 0x13081
testl %eax, %eax
je 0x13064
cmpb $0x0, (%rbx)
je 0x130ad
callq 0x3030
movq (%rax), %rax
movl $0x1, %edx
movsbq -0x1(%rbx,%rdx), %rsi
movl (%rax,%rsi,4), %esi
movsbq -0x1(%r15,%rdx), %rdi
cmpl (%rax,%rdi,4), %esi
jne 0x13052
movb (%r15,%rdx), %sil
testb %sil, %sil
setne %dil
cmpb %r14b, %sil
setne %r8b
andb %dil, %r8b
cmpb %bpl, %sil
setne %sil
movq %rdx, %rdi
incq %rdi
testb %r8b, %sil
cmovel %edx, %ecx
movq %rdi, %rdx
jne 0x1300f
jmp 0x13054
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x13093
cmpb $0x0, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
jne 0x1300a
jmp 0x130ad
callq 0x3030
movq (%rax), %rax
movsbq (%rbx), %rcx
movl (%rax,%rcx,4), %ecx
movsbq %r13b, %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x130ad
incq %rbx
xorl %eax, %eax
movb 0x1(%r15), %r13b
incq %r15
testb %r13b, %r13b
jne 0x12fd0
jmp 0x130b1
movslq %ecx, %rax
addq %rax, %rbx
movb (%r15,%rax), %r13b
addq %rax, %r15
xorl %eax, %eax
testb %r13b, %r13b
jne 0x12fd0
jmp 0x130b7
xorl %eax, %eax
jmp 0x130c9
testl %eax, %eax
sete %r12b
movl $0x1, %eax
testb %r12b, %r12b
je 0x130c9
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
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/cheapcgi.c
// Function: cgiServerNamePort
char *cgiServerNamePort()
/* Return name of server with port if different than 80 */
{
char *port = cgiServerPort();
char *name = cgiServerName();
struct dyString *result = newDyString(256);
char *defaultPort = "80";
if (cgiServerHttpsIsOn())
    defaultPort = "443";

if (name)
    {
    dyStringPrintf(result,"%s",name);
    if (differentString(port, defaultPort))
	dyStringPrintf(result,":%s",port);
    return dyStringCannibalize(&result);
    }
else
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x8518(%rip), %rdi      # 0x1b6f4
callq 0x3040
movq %rax, %rbx
testq %rax, %rax
leaq 0x8512(%rip), %r13      # 0x1b700
cmoveq %r13, %rbx
leaq 0x84ef(%rip), %rdi      # 0x1b6e8
callq 0x3040
movq %rax, %r14
movl $0x100, %edi            # imm = 0x100
callq 0xaf38
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x13198
testq %r14, %r14
je 0x1326f
testl %eax, %eax
leaq 0x84e3(%rip), %r12      # 0x1b709
cmoveq %r13, %r12
leaq 0x637b(%rip), %rsi      # 0x195ac
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb2d2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3440
testl %eax, %eax
je 0x13263
movq 0x8(%rsp), %rdi
leaq 0x930a(%rip), %rsi      # 0x1c563
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb2d2
leaq 0x8(%rsp), %rdi
callq 0xaf94
jmp 0x13271
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/cheapcgi.c
// Function: findCookieData
char *findCookieData(char *varName)
/* Get the string associated with varName from the cookie string. */
{
struct hashEl *hel;
char *firstResult;

/* make sure that the cookie hash table has been created */
parseCookies(&cookieHash, &cookieList);
if (cookieHash == NULL)
    return NULL;
/* Watch out for multiple cookies with the same name (hel is a list) --
 * warn if we find them. */
hel = hashLookup(cookieHash, varName);
if (hel == NULL)
    return NULL;
else
    firstResult = ((struct cgiVar *)hel->val)->val;
hel = hel->next;
while (hel != NULL)
    {
    char *val = ((struct cgiVar *)(hel->val))->val;
    if (sameString(varName, hel->name) && !sameString(firstResult, val))
	{
	/* This is too early to call warn -- it will mess up html output. */
	fprintf(stderr,
		"findCookieData: Duplicate cookie value from IP=%s: "
		"%s has both %s and %s\n",
		cgiRemoteAddr(),
		varName, firstResult, val);
	}
    hel = hel->next;
    }
return firstResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13574
movq 0x14d38(%rip), %rdi     # 0x281f8
testq %rdi, %rdi
je 0x1355f
movq %rbx, %rsi
callq 0xbd98
testq %rax, %rax
je 0x1355f
movq (%rax), %r15
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
testq %r15, %r15
je 0x13562
movq 0x13b07(%rip), %rbp     # 0x26ff8
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rax
movq 0x10(%rax), %r13
movq %rbx, %rdi
callq 0x3440
testl %eax, %eax
jne 0x13518
movq %r14, %rdi
movq %r13, %rsi
callq 0x3440
testl %eax, %eax
jne 0x13522
movq (%r15), %r15
testq %r15, %r15
jne 0x134f1
jmp 0x13562
movq (%rbp), %r12
leaq 0x81e0(%rip), %rdi      # 0x1b70d
callq 0x3040
testq %rax, %rax
leaq 0x7927(%rip), %rcx      # 0x1ae63
cmoveq %rcx, %rax
movq %r12, %rdi
leaq 0x8214(%rip), %rsi      # 0x1b75e
movq %rax, %rdx
movq %rbx, %rcx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x3470
jmp 0x13518
xorl %r14d, %r14d
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_O1/JimKent[P]linearSat/lib/cheapcgi.c
// Function: parseCookies
static void parseCookies(struct hash **retHash, struct cgiVar **retList)
/* parses any cookies and puts them into the given hash and list */
{
char* str;
char *namePt, *dataPt, *nextNamePt;
struct hash *hash;
struct cgiVar *list = NULL, *el;

/* don't build the hash table again */
if(haveCookiesHash == TRUE)
	return;

str = cloneString(getenv("HTTP_COOKIE"));
if(str == NULL) /* don't have a cookie */
	return;

hash = newHash(6);

namePt = str;
while (isNotEmpty(namePt))
    {
    dataPt = strchr(namePt, '=');
    if (dataPt == NULL)
	errAbort("Mangled Cookie input string: no = in '%s' (offset %d in complete cookie string: '%s')",
		 namePt, (int)(namePt - str), getenv("HTTP_COOKIE"));
    *dataPt++ = 0;
    nextNamePt = strchr(dataPt, ';');
    if (nextNamePt != NULL)
	{
         *nextNamePt++ = 0;
	 if (*nextNamePt == ' ')
	     nextNamePt++;
	}
    cgiDecode(dataPt,dataPt,strlen(dataPt));
    AllocVar(el);
    el->val = dataPt;
    slAddHead(&list, el);
    hashAddSaveName(hash, namePt, el, &el->name);
    namePt = nextNamePt;
    }

haveCookiesHash = TRUE;

slReverse(&list);
*retList = list;
*retHash = hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
cmpb $0x0, 0x24f52(%rip)     # 0x384e0
jne 0x136ba
leaq 0x8ac1(%rip), %rdi      # 0x1c05c
callq 0x3040
movq %rax, %rdi
callq 0x647e
testq %rax, %rax
je 0x136ba
movq %rax, %rbx
movl $0x6, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, %r14
leaq 0x8a9b(%rip), %r12      # 0x1c068
movq %rbx, %r13
cmpb $0x0, (%r13)
je 0x13697
movq %r13, %rdi
movl $0x3d, %esi
callq 0x3260
movq %rax, %rbp
testq %rax, %rax
jne 0x13615
movl %r13d, %r15d
subl %ebx, %r15d
leaq 0x8a5f(%rip), %rdi      # 0x1c05c
callq 0x3040
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8d7
movq %rbp, %rax
incq %rbp
movb $0x0, (%rax)
movq %rbp, %rdi
movl $0x3b, %esi
callq 0x3260
testq %rax, %rax
je 0x13648
leaq 0x1(%rax), %rcx
movb $0x0, (%rax)
movq %rax, %r15
addq $0x2, %r15
cmpb $0x20, 0x1(%rax)
cmovneq %rcx, %r15
jmp 0x1364b
xorl %r15d, %r15d
movq %rbp, %rdi
callq 0x3200
movq %rbp, %rdi
movq %rbp, %rsi
movl %eax, %edx
callq 0x13805
movl $0x20, %edi
callq 0xf07d
movq %rbp, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %rax, (%rsp)
leaq 0x8(%rax), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc1a7
movq %r15, %r13
testq %r15, %r15
jne 0x135d0
movb $0x1, 0x24e42(%rip)     # 0x384e0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x673b
movq (%rbx), %rax
movq %rax, 0x14b1d(%rip)     # 0x281d0
movq %r14, 0x14b3e(%rip)     # 0x281f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq