LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1a110
cmpl $0x0, -0x14(%rbp)
je 0x1a0ce
movl $0x0, -0x14(%rbp)
jmp 0x1a0dc
leaq 0xc18d(%rip), %rdi      # 0x26262
movb $0x0, %al
callq 0x3260
jmp 0x1a0de
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1a10e
movq -0x20(%rbp), %rsi
leaq 0xc4ee(%rip), %rdi      # 0x265f3
movb $0x0, %al
callq 0x3260
jmp 0x1a0de
jmp 0x1a0a3
leaq 0xc0a5(%rip), %rdi      # 0x261bc
movb $0x0, %al
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: joinCmds
static char* joinCmds(char ***cmds)
/* join an cmds vetor into a space and pipe separated string */
{
struct dyString *str = dyStringNew(512);
int i, j;
for (i = 0; cmds[i] != NULL; i++)
    {
    if (i > 0)
        dyStringAppend(str, " | ");
    for (j = 0; cmds[i][j] != NULL; j++)
        {
        if (j > 0)
            dyStringAppend(str, " ");
        dyStringAppend(str, cmds[i][j]);
        }
    }
return dyStringCannibalize(&str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xf030
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a1e6
cmpl $0x0, -0x14(%rbp)
jle 0x1a17a
movq -0x10(%rbp), %rdi
leaq 0xc0ec(%rip), %rsi      # 0x26261
callq 0xf3c0
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a1d6
cmpl $0x0, -0x18(%rbp)
jle 0x1a1ae
movq -0x10(%rbp), %rdi
leaq 0xc789(%rip), %rsi      # 0x26932
callq 0xf3c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xf3c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a181
jmp 0x1a1d8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a151
leaq -0x10(%rbp), %rdi
callq 0xf0d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x152f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1a260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: cloneCmdVector
static char** cloneCmdVector(char **cmd)
/* make a copy of the vector */
{
int i, cmdLen = 0;
for (i = 0; cmd[i] != NULL; i++)
    cmdLen++;
char **cmd2 = needMem((cmdLen+1)*sizeof(char*));

for (i = 0; i < cmdLen; i++)
    cmd2[i] = cloneString(cmd[i]);
cmd2[cmdLen] = NULL;
return cmd2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a29d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a27a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x152f0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1a2ed
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7530
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a2ba
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3340
cmpl $0x0, %eax
jge 0x1a338
leaq 0xbf34(%rip), %rdi      # 0x26265
movb $0x0, %al
callq 0xfed0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0x1a379
jmp 0x1a398
leaq 0xbef7(%rip), %rdi      # 0x26277
leaq 0xbf04(%rip), %rsi      # 0x2628b
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0xbf03(%rip), %rcx      # 0x26296
callq 0x32d0
callq 0x3720
movq -0x8(%rbp), %rcx
movl %eax, 0xc(%rcx)
cmpl $0x0, %eax
jge 0x1a3b7
leaq 0xbf2a(%rip), %rdi      # 0x262da
movb $0x0, %al
callq 0xfed0
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1a3e5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x1a430
movl $0x1, %edi
callq 0x36b0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x3690
cmpl $0x0, %eax
je 0x1a419
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0xbed3(%rip), %rdi      # 0x262e5
movb $0x0, %al
callq 0xfed0
jmp 0x1a41b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
callq 0x31a0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x3690
cmpl $0x0, %eax
je 0x1a48f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0xbe7f(%rip), %rdi      # 0x26307
movb $0x0, %al
callq 0xfed0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x1a4d0
xorl %edi, %edi
callq 0x3330
movl $0x1, %edi
callq 0x3330
callq 0x1a560
movq -0x8(%rbp), %rdi
callq 0x1a5b0
xorl %edi, %edi
callq 0x36b0
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1a552
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl -0x14(%rbp), %r9d
movq -0x20(%rbp), %r10
movq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1a5e0
movl %eax, -0x34(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1a4ff
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
callq 0x3620
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x1a585
movq $0x1000, -0x8(%rbp)     # imm = 0x1000
movl $0x3, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x1a5a9
movl -0xc(%rbp), %edi
callq 0x3330
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a58c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineExecProc
static int pipelineExecProc(struct pipeline* pl, struct plProc *proc,
                            int prevStdoutFd, int stdinFd, int stdoutFd, int stderrFd,
                            void *otherEndBuf, size_t otherEndBufSize)
/* start a process in the pipeline, return the stdout fd of the process */
{
/* determine stdin/stdout to use */
int procStdinFd, procStdoutFd;
if (proc == pl->procs)
    procStdinFd = stdinFd; /* first process in pipeline */
else
    procStdinFd = prevStdoutFd;
if (proc->next == NULL)
    procStdoutFd = stdoutFd; /* last process in pipeline */
else
    prevStdoutFd = pipeCreate(&procStdoutFd);

/* start process */
if ((proc->pid = fork()) < 0)
    errnoAbort("can't fork");
if (proc->pid == 0)
    execProcChild(pl, proc, procStdinFd, procStdoutFd, stderrFd, otherEndBuf, otherEndBufSize);

/* record that we did this */
plProcStateTrans(proc, procStateRun);
pl->numRunning++;

/* don't leave intermediate pipes open in parent */
if (proc != pl->procs)
    safeClose(&procStdinFd);
if (proc->next != NULL)
    safeClose(&procStdoutFd);

return prevStdoutFd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1a61b
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1a621
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1a633
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1a63f
leaq -0x28(%rbp), %rdi
callq 0x1a310
movl %eax, -0x14(%rbp)
callq 0x3720
movq -0x10(%rbp), %rcx
movl %eax, 0x18(%rcx)
cmpl $0x0, %eax
jge 0x1a65e
leaq 0xbc83(%rip), %rdi      # 0x262da
movb $0x0, %al
callq 0xfed0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1a68b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %rax
movq %rax, (%rsp)
callq 0x1a6e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1a7a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x1a6bc
leaq -0x24(%rbp), %rdi
callq 0x19ba0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a6cf
leaq -0x28(%rbp), %rdi
callq 0x19ba0
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: execProcChild
static void execProcChild(struct pipeline* pl, struct plProc *proc,
                          int procStdinFd, int procStdoutFd, int stderrFd,
                          void *otherEndBuf, size_t otherEndBufSize)
/* handle child process setup after fork.  This does not return */
{
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
    errnoAbort("error ignoring SIGPIPE");
if (setpgid(getpid(), pl->groupLeader) != 0)
    errnoAbort("error from setpgid(%d, %d)", getpid(), pl->groupLeader);

if (otherEndBuf != NULL)
    plProcMemWrite(proc, procStdoutFd, stderrFd, otherEndBuf, otherEndBufSize);
else
    plProcExecChild(proc, procStdinFd, procStdoutFd, stderrFd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0xd, %edi
movl $0x1, %esi
callq 0x3420
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x1a72b
leaq 0xbc04(%rip), %rdi      # 0x26328
movb $0x0, %al
callq 0xfed0
callq 0x31a0
movl %eax, %edi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x3690
cmpl $0x0, %eax
je 0x1a75f
callq 0x31a0
movl %eax, %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0xbbe7(%rip), %rdi      # 0x2633f
movb $0x0, %al
callq 0xfed0
cmpq $0x0, -0x28(%rbp)
je 0x1a77f
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x1a7f0
jmp 0x1a791
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x1a890
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: plProcMemWrite
static void plProcMemWrite(struct plProc* proc, int stdoutFd, int stderrFd, void *otherEndBuf, size_t otherEndBufSize)
/* implements child process to write memory buffer to pipeline after
 * fork */
{
plProcSetup(proc, STDIN_FILENO, stdoutFd, stderrFd);
ssize_t wrCnt = write(STDOUT_FILENO, otherEndBuf, otherEndBufSize);
if (wrCnt < 0)
    errnoAbort("pipeline input buffer write failed");
else if (wrCnt != otherEndBufSize)
    errAbort("pipeline input buffer short write %lld, expected %lld",
             (long long)wrCnt, (long long)otherEndBufSize);
else
    {
    close(STDOUT_FILENO);
    exit(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
xorl %esi, %esi
callq 0x1a8f0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
callq 0x3190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x1a848
leaq 0xbb1b(%rip), %rdi      # 0x2635a
movb $0x0, %al
callq 0xfed0
jmp 0x1a87d
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x1a86a
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xbb1c(%rip), %rdi      # 0x2637d
movb $0x0, %al
callq 0xfd50
jmp 0x1a87b
movl $0x1, %edi
callq 0x3330
xorl %edi, %edi
callq 0x36b0
jmp 0x1a87d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x98, %esi
callq 0x1a9d0
movl $0x1, %eax
movq %rax, -0xb0(%rbp)
movl $0xd, %edi
leaq -0xb0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3130
cmpl $0x0, %eax
je 0x1a94d
leaq 0xba6d(%rip), %rdi      # 0x263b3
movb $0x0, %al
callq 0xfed0
cmpl $0x0, -0xc(%rbp)
je 0x1a972
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x3230
cmpl $0x0, %eax
jge 0x1a970
leaq 0xba6b(%rip), %rdi      # 0x263d4
movb $0x0, %al
callq 0xfed0
jmp 0x1a972
cmpl $0x1, -0x10(%rbp)
je 0x1a99a
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x3230
cmpl $0x0, %eax
jge 0x1a998
leaq 0xba57(%rip), %rdi      # 0x263e8
movb $0x0, %al
callq 0xfed0
jmp 0x1a99a
cmpl $0x2, -0x14(%rbp)
je 0x1a9c2
movl -0x14(%rbp), %edi
movl $0x2, %esi
callq 0x3230
cmpl $0x0, %eax
jge 0x1a9c0
leaq 0xba44(%rip), %rdi      # 0x263fd
movb $0x0, %al
callq 0xfed0
jmp 0x1a9c2
callq 0x1a560
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: waitOnOne
static void waitOnOne(struct pipeline *pl)
/* wait on one process to finish */
{
int status;
pid_t pid = waitpid(-pl->groupLeader, &status, 0);
if (pid < 0)
    errnoAbort("waitpid failed");
plProcHandleTerminate(pipelineFindProc(pl, pid), status);
pl->numRunning--;
assert(pl->numRunning >= 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorl %edi, %edi
subl 0xc(%rax), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x35e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x1aa37
leaq 0xba05(%rip), %rdi      # 0x26435
movb $0x0, %al
callq 0xfed0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1abe0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1aa90
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x1aa67
jmp 0x1aa86
leaq 0xb9d6(%rip), %rdi      # 0x26444
leaq 0xb816(%rip), %rsi      # 0x2628b
movl $0x17c, %edx            # imm = 0x17C
leaq 0xb9d7(%rip), %rcx      # 0x26458
callq 0x32d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: plProcHandleTerminate
static void plProcHandleTerminate(struct plProc* proc, int status)
/* handle one of the processes terminating, save exit status */
{
proc->status = status;
if (WIFSIGNALED(proc->status))
    errAbort("process terminated on signal %d: \"%s\" in pipeline \"%s\"",
             WTERMSIG(proc->status), joinCmd(proc->cmd), proc->pl->procName);
assert(WIFEXITED(proc->status));

if (WEXITSTATUS(proc->status) != 0)
    {
    // only print an error message if aborting
    if (!(proc->pl->options & pipelineNoAbort))
        fprintf(stderr, "process exited with %d: \"%s\" in pipeline \"%s\"\n",
                WEXITSTATUS(proc->status), joinCmd(proc->cmd), proc->pl->procName);
    exit(WEXITSTATUS(proc->status));  // pass back exit code
    }
proc->pid = -1;
plProcStateTrans(proc, procStateDone);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1aafa
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1ac50
movl -0x10(%rbp), %esi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
leaq 0xb987(%rip), %rdi      # 0x2647a
movb $0x0, %al
callq 0xfd50
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x1ab0b
jmp 0x1ab2a
leaq 0xb99f(%rip), %rdi      # 0x264b1
leaq 0xb772(%rip), %rsi      # 0x2628b
movl $0xe7, %edx
leaq 0xb9a4(%rip), %rcx      # 0x264c9
callq 0x32d0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x1abb7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x1aba2
movq 0x17498(%rip), %rax     # 0x31ff0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1ac50
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
leaq 0xb95f(%rip), %rsi      # 0x264fa
movb $0x0, %al
callq 0x3440
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
andl $0xff00, %edi           # imm = 0xFF00
sarl $0x8, %edi
callq 0x36b0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1a7a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: pipelineFindProc
static struct plProc *pipelineFindProc(struct pipeline *pl, pid_t pid)
/* find a plProc by pid */
{
struct plProc *proc;
for (proc = pl->procs; proc != NULL; proc = proc->next)
    if (proc->pid == pid)
        return proc;
errAbort("pid not found in pipeline: %d", (int)pid);
return 0; // never reached
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ac26
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1ac17
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ac3f
jmp 0x1ac19
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1abfa
movl -0x14(%rbp), %esi
leaq 0xb8f9(%rip), %rdi      # 0x26529
movb $0x0, %al
callq 0xfd50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xf030
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1acb6
cmpl $0x0, -0x14(%rbp)
jle 0x1ac96
movq -0x10(%rbp), %rdi
leaq 0xbca1(%rip), %rsi      # 0x26932
callq 0xf3c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xf3c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ac71
leaq -0x10(%rbp), %rdi
callq 0xf0d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/pipeline.c
// Function: closePipelineFile
static void closePipelineFile(struct pipeline *pl)
/* close a pipeline with a FILE associated with it */
{
if (pl->options & pipelineWrite)
    {
    fflush(pl->pipeFh);
    if (ferror(pl->pipeFh))
        errAbort("write failed to pipeline: %s ", pl->procName);
    }
else if (ferror(pl->pipeFh))
    errAbort("read failed from pipeline: %s ", pl->procName);

if (fclose(pl->pipeFh) == EOF)
    errAbort("close failed on pipeline: %s ", pl->procName);
pl->pipeFh = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1ad22
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3100
cmpl $0x0, %eax
je 0x1ad20
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xb8a1(%rip), %rdi      # 0x265ba
movb $0x0, %al
callq 0xfd50
jmp 0x1ad4c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3100
cmpl $0x0, %eax
je 0x1ad4a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xb895(%rip), %rdi      # 0x265d8
movb $0x0, %al
callq 0xfd50
jmp 0x1ad4c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x31b0
cmpl $-0x1, %eax
jne 0x1ad74
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xb82f(%rip), %rdi      # 0x2659c
movb $0x0, %al
callq 0xfd50
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x17824(%rip), %eax     # 0x325d0
jg 0x1ade9
cmpq $0x0, 0x18422(%rip)     # 0x331d8
jne 0x1adc9
movq 0x17231(%rip), %rax     # 0x31ff0
movq (%rax), %rax
movq %rax, 0x1840f(%rip)     # 0x331d8
movq 0x18408(%rip), %rdi     # 0x331d8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3640
movq 0x183f4(%rip), %rdi     # 0x331d8
callq 0x3500
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1aee8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1af14
jmp 0x1af33
leaq 0xb756(%rip), %rdi      # 0x26671
leaq 0xb75d(%rip), %rsi      # 0x2667f
movl $0x34, %edx
leaq 0xb75b(%rip), %rcx      # 0x26689
callq 0x32d0
cmpq $0x0, 0x1769d(%rip)     # 0x325d8
jge 0x1af42
callq 0x1ae90
xorl %eax, %eax
movb %al, -0xe1(%rbp)
callq 0x182d0
movq %rax, -0x18(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1ad90
movb -0xe1(%rbp), %al
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rdx
movq 0x17640(%rip), %rcx     # 0x325d8
subq %rcx, %rdx
leaq 0xb70a(%rip), %rsi      # 0x266ac
callq 0x1adf0
movq -0x18(%rbp), %rax
movq %rax, 0x17626(%rip)     # 0x325d8
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x18211(%rip)     # 0x331e0
jne 0x1b0a4
cmpq $0x0, 0x181fb(%rip)     # 0x331d8
jne 0x1aff0
movq 0x1700a(%rip), %rax     # 0x31ff0
movq (%rax), %rax
movq %rax, 0x181e8(%rip)     # 0x331d8
xorl %eax, %eax
cmpl $0x0, 0x175d7(%rip)     # 0x325d0
movb %al, -0x11(%rbp)
jle 0x1b01a
movq 0x181d3(%rip), %rdi     # 0x331d8
callq 0x34b0
movl %eax, %edi
callq 0x3120
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x181bc(%rip)     # 0x331e4
cmpl $0x0, 0x181b5(%rip)     # 0x331e4
je 0x1b09a
leaq 0xb682(%rip), %rdi      # 0x266ba
callq 0x3030
movq %rax, -0x8(%rbp)
leaq 0xc0f7(%rip), %rdi      # 0x2713f
callq 0x3030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b070
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x1b070
movl $0x0, 0x18176(%rip)     # 0x331e4
jmp 0x1b098
cmpq $0x0, -0x10(%rbp)
je 0x1b096
movq -0x10(%rbp), %rdi
leaq 0xb63e(%rip), %rsi      # 0x266c0
callq 0x3410
cmpl $0x0, %eax
jne 0x1b096
movl $0x0, 0x1814e(%rip)     # 0x331e4
jmp 0x1b098
jmp 0x1b09a
movl $0x1, 0x1813c(%rip)     # 0x331e0
movl 0x1813a(%rip), %eax     # 0x331e4
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb2cf(%rip), %rsi      # 0x263f6
callq 0x3410
cmpl $0x0, %eax
jne 0x1b144
movq 0x16e88(%rip), %rax     # 0x31fc0
movq (%rax), %rax
movq %rax, 0x18096(%rip)     # 0x331d8
jmp 0x1b185
movq -0x8(%rbp), %rdi
leaq 0xb2bc(%rip), %rsi      # 0x2640b
callq 0x3410
cmpl $0x0, %eax
jne 0x1b16c
movq 0x16e90(%rip), %rax     # 0x31ff0
movq (%rax), %rax
movq %rax, 0x1806e(%rip)     # 0x331d8
jmp 0x1b183
movq -0x8(%rbp), %rdi
leaq 0x98de(%rip), %rsi      # 0x24a55
callq 0xc4f0
movq %rax, 0x18055(%rip)     # 0x331d8
jmp 0x1b185
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/wildcmp.c
// Function: anyWild
boolean anyWild(const char *string)
/* Return TRUE if any wild card characters in string. */
{
char c;
while ((c = *string++) != 0)
    {
    if (c == '?' || c == '*')
        return TRUE;
    }
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1b201
movsbl -0x11(%rbp), %eax
cmpl $0x3f, %eax
je 0x1b1f6
movsbl -0x11(%rbp), %eax
cmpl $0x2a, %eax
jne 0x1b1ff
movl $0x1, -0x4(%rbp)
jmp 0x1b208
jmp 0x1b1c8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/wildcmp.c
// Function: subMatch
static int subMatch(const char *str, const char *wild, char single, char multi)
/* Returns number of characters that match between str and wild up
 * to the next wildcard in wild (or up to end of string.). */
{
int len = 0;

for(;;)
    {
    if(toupper(*str++) != toupper(*wild++) )
        return(0);
    ++len;
    char c = *wild;
    if (c == 0 || c == single || c == multi)
       return len;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x30e0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x30e0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0x1b474
movl $0x0, -0x4(%rbp)
jmp 0x1b4b1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x1b4a7
movsbl -0x21(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x1b4a7
movsbl -0x21(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1b4af
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b4b1
jmp 0x1b431
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiServerPort
char *cgiServerPort()
/* Return port number of server, default 80 if not found */
{
char *port = getenv("SERVER_PORT");
if (port)
    return port;
else
    return "80";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb153(%rip), %rdi      # 0x26752
callq 0x3030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b619
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b624
leaq 0xb13e(%rip), %rax      # 0x2675e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiServerHttpsIsOn
boolean cgiServerHttpsIsOn()
/* Return true if HTTPS is on */
{
char *httpsIsOn = getenv("HTTPS");
if (httpsIsOn)
    return sameString(httpsIsOn, "on");
else
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb122(%rip), %rdi      # 0x26761
callq 0x3030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b66f
movq -0x10(%rbp), %rdi
leaq 0xb9ec(%rip), %rsi      # 0x27046
callq 0x3410
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1b676
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x1b5f0
movq %rax, -0x10(%rbp)
callq 0x1b5d0
movq %rax, -0x18(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0xf030
movq %rax, -0x20(%rbp)
leaq 0xb0af(%rip), %rax      # 0x2675e
movq %rax, -0x28(%rbp)
callq 0x1b630
cmpl $0x0, %eax
je 0x1b6c8
leaq 0xb0a3(%rip), %rax      # 0x26767
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b71c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8ece(%rip), %rsi      # 0x245ac
movb $0x0, %al
callq 0xf550
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3410
cmpl $0x0, %eax
je 0x1b70d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xbe54(%rip), %rsi      # 0x2755a
movb $0x0, %al
callq 0xf550
leaq -0x20(%rbp), %rdi
callq 0xf0d0
movq %rax, -0x8(%rbp)
jmp 0x1b724
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiRemoteAddr
char *cgiRemoteAddr()
/* Return IP address of client (or "unknown"). */
{
static char *dunno = "unknown";
char *remoteAddr = getenv("REMOTE_ADDR");
if (remoteAddr == NULL)
    remoteAddr = dunno;
return remoteAddr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb02c(%rip), %rdi      # 0x2676b
callq 0x3030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1b75a
movq 0x16e8a(%rip), %rax     # 0x325e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1775d(%rip), %rdi     # 0x33220
leaq 0x17726(%rip), %rsi     # 0x331f0
callq 0x1bbc0
cmpq $0x0, 0x17749(%rip)     # 0x33220
jne 0x1bae6
movq $0x0, -0x8(%rbp)
jmp 0x1bbb1
movq 0x17733(%rip), %rdi     # 0x33220
movq -0x10(%rbp), %rsi
callq 0x104b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1bb0e
movq $0x0, -0x8(%rbp)
jmp 0x1bbb1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1bba9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3410
cmpl $0x0, %eax
jne 0x1bb9c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3410
cmpl $0x0, %eax
je 0x1bb9c
movq 0x16481(%rip), %rax     # 0x31ff0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1b730
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0xac27(%rip), %rsi      # 0x267bc
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1bb29
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiDecode
void cgiDecode(char *in, char *out, int inLength)
/* Decode from cgi pluses-for-spaces format to normal.
 * Out will be a little shorter than in typically, and
 * can be the same buffer. */
{
char c;
int i;
for (i=0; i<inLength;++i)
    {
    c = *in++;
    if (c == '+')
	*out++ = ' ';
    else if (c == '%')
	{
	int code;
        if (sscanf(in, "%2x", &code) != 1)
	    code = '?';
	in += 2;
	i += 2;
	*out++ = code;
	}
    else
	*out++ = c;
    }
*out++ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c035
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x2b, %eax
jne 0x1bfb7
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0x1c025
movsbl -0x15(%rbp), %eax
cmpl $0x25, %eax
jne 0x1c00f
movq -0x8(%rbp), %rdi
leaq 0xa882(%rip), %rsi      # 0x2684d
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x3510
cmpl $0x1, %eax
je 0x1bfe2
movl $0x3f, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1c023
movb -0x15(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1c025
jmp 0x1c027
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bf7a
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiParseInput
boolean cgiParseInput(char *input, struct hash **retHash,
        struct cgiVar **retList)
/* Parse cgi-style input into a hash table and list.  This will alter
 * the input data.  The hash table will contain references back
 * into input, so please don't free input until you're done with
 * the hash. Prints message and returns FALSE if there's an error.
 * To clean up - slFreeList, hashFree, and only then free input. */
{
boolean ok = TRUE;
int status = setjmp(cgiParseRecover);
if (status == 0)    /* Always true except after long jump. */
    {
    pushAbortHandler(cgiParseAbort);
    cgiParseInputAbort(input, retHash, retList);
    }
else    /* They long jumped here because of an error. */
    {
    ok = FALSE;
    }
popAbortHandler();
return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
leaq 0x1717e(%rip), %rdi     # 0x33230
callq 0x33e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x1c0df
leaq 0x3569(%rip), %rdi      # 0x1f630
callq 0xffc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1bda0
jmp 0x1c0e6
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x10040
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: initSigHandlers
void initSigHandlers(boolean dumpStack)
/* set handler for various terminal signals for logging purposes.
 * if dumpStack is TRUE, attempt to dump the stack. */
{
if (cgiIsOnWeb())
    {
    // SIGKILL is not trappable or ignorable
    signal(SIGTERM, catchSignal);
    signal(SIGHUP, catchSignal);
    signal(SIGABRT, catchSignal);
    signal(SIGSEGV, catchSignal);
    signal(SIGFPE, catchSignal);
    signal(SIGBUS, catchSignal);
    dumpStackOnSignal = dumpStack;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1b530
cmpl $0x0, %eax
je 0x1c184
movl $0xf, %edi
leaq 0x6f(%rip), %rsi        # 0x1c190
callq 0x3420
movl $0x1, %edi
leaq 0x5e(%rip), %rsi        # 0x1c190
callq 0x3420
movl $0x6, %edi
leaq 0x4d(%rip), %rsi        # 0x1c190
callq 0x3420
movl $0xb, %edi
leaq 0x3c(%rip), %rsi        # 0x1c190
callq 0x3420
movl $0x8, %edi
leaq 0x2b(%rip), %rsi        # 0x1c190
callq 0x3420
movl $0x7, %edi
leaq 0x1a(%rip), %rsi        # 0x1c190
callq 0x3420
movl -0x4(%rbp), %eax
movl %eax, 0x17174(%rip)     # 0x332f8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: catchSignal
static void catchSignal(int sigNum)
/* handler for various terminal signals for logging purposes */
{
char *sig = NULL;
switch (sigNum)
    {
    case SIGTERM:  // after timing out for not producing any stdout or stderr output for too long,
		   //  apache gives you 3 seconds to clean up and exit or it then sends SIGKILL.
      sig = "SIGTERM";
      break;
    case SIGHUP:   // apache sends this when it is doing a graceful restart or a log rotate.
      sig = "SIGHUP";
      break;
    case SIGABRT:
      sig = "SIGABRT";
      break;
    case SIGSEGV:
      sig = "SIGSEGV";
      break;
    case SIGFPE:
      sig = "SIGFPE";
      break;
    case SIGBUS:
      sig = "SIGBUS";
      break;
    }
    logCgiToStderr();

    // apache closes STDERR on the CGI before it sends the SIGTERM and SIGKILL signals
    //  which means that stderr output after that point will not be visible in error_log.
    fprintf(stderr, "Received signal %s\n", sig);
    if (dumpStackOnSignal)
        dumpStack("Stack for signal %s\n", sig);

if (sigNum == SIGTERM || sigNum == SIGHUP) 
    exit(1);   // so that atexit cleanup get called

raise(SIGKILL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xe, %eax
ja 0x1c213
movq -0x18(%rbp), %rax
leaq 0xa50a(%rip), %rcx      # 0x266c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xaf6e(%rip), %rax      # 0x2713c
movq %rax, -0x10(%rbp)
jmp 0x1c213
leaq 0xaf69(%rip), %rax      # 0x27144
movq %rax, -0x10(%rbp)
jmp 0x1c213
leaq 0xaf63(%rip), %rax      # 0x2714b
movq %rax, -0x10(%rbp)
jmp 0x1c213
leaq 0xaf5e(%rip), %rax      # 0x27153
movq %rax, -0x10(%rbp)
jmp 0x1c213
leaq 0xaf59(%rip), %rax      # 0x2715b
movq %rax, -0x10(%rbp)
jmp 0x1c213
leaq 0xaf53(%rip), %rax      # 0x27162
movq %rax, -0x10(%rbp)
callq 0x1f340
movq 0x15dd1(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xaf3c(%rip), %rsi      # 0x27169
movb $0x0, %al
callq 0x3440
cmpl $0x0, 0x170bd(%rip)     # 0x332f8
je 0x1c24f
movq -0x10(%rbp), %rsi
leaq 0xaf35(%rip), %rdi      # 0x2717d
movb $0x0, %al
callq 0x194b0
cmpl $0xf, -0x4(%rbp)
je 0x1c25b
cmpl $0x1, -0x4(%rbp)
jne 0x1c265
movl $0x1, %edi
callq 0x36b0
movl $0x9, %edi
callq 0x3050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: findVarData
static char *findVarData(char *varName)
/* Get the string associated with varName from the query string. */
{
struct cgiVar *var;

initCgiInput();
if ((var = hashFindVal(inputHash, varName)) == NULL)
    return NULL;
return var->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1f650
movq 0x16ae0(%rip), %rdi     # 0x33308
movq -0x10(%rbp), %rsi
callq 0x10d00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1c845
movq $0x0, -0x8(%rbp)
jmp 0x1c851
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)