LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: fileExists
boolean fileExists(char *fileName)
/* Return TRUE if file exists (may replace this with non-
 * portable faster way some day). */
{
/* To make piping easier stdin and stdout always exist. */
if (sameString(fileName, "stdin")) return TRUE;
if (sameString(fileName, "stdout")) return TRUE;

return fileSize(fileName) != -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x112b2(%rip), %rsi     # 0x1b3be
callq 0x3440
movl $0x1, %ebx
testl %eax, %eax
je 0xa13e
leaq 0x112b1(%rip), %rsi     # 0x1b3d2
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0xa13e
movq %r14, %rdi
callq 0x10f64
xorl %ebx, %ebx
cmpq $-0x1, %rax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: strstrNoCase
char *strstrNoCase(char *haystack, char *needle)
/*
  A case-insensitive strstr function
Will also robustly handle null strings
param haystack - The string to be searched
param needle - The string to look for in the haystack string

return - The position of the first occurence of the desired substring
or -1 if it is not found
 */
{
char *haystackCopy = NULL;
char *needleCopy = NULL;
int index = 0;
int haystackLen = 0;
int needleLen = 0;
char *p, *q;

if (NULL == haystack || NULL == needle)
    {
    return NULL;
    }

haystackLen = strlen(haystack);
needleLen = strlen(needle);

haystackCopy = (char*) needMem(haystackLen + 1);
needleCopy = (char*) needMem(needleLen + 1);

for(index = 0; index < haystackLen;  index++)
    {
    haystackCopy[index] = tolower(haystack[index]);
    }
haystackCopy[haystackLen] = 0; /* Null terminate */

for(index = 0; index < needleLen;  index++)
    {
    needleCopy[index] = tolower(needle[index]);
    }
needleCopy[needleLen] = 0; /* Null terminate */

p=strstr(haystackCopy, needleCopy);
q=haystackCopy;

freeMem(haystackCopy);
freeMem(needleCopy);

if(p==NULL) return NULL;

return p-q+haystack;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa267
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3200
movq %rax, %rbp
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
movq %rbp, %rax
shlq $0x20, %rax
movabsq $0x100000000, %r13      # imm = 0x100000000
movq %rax, 0x8(%rsp)
leaq (%rax,%r13), %rdi
sarq $0x20, %rdi
callq 0xf07d
movq %rax, %r15
movq %r12, %rax
shlq $0x20, %rax
movq %rax, 0x10(%rsp)
addq %rax, %r13
sarq $0x20, %r13
movq %r13, %rdi
callq 0xf07d
movq %rax, %r13
testl %ebp, %ebp
jle 0xa1f4
callq 0x3790
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq (%rbx,%rcx), %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rbp
jne 0xa1dd
movq 0x8(%rsp), %rax
sarq $0x20, %rax
movb $0x0, (%r15,%rax)
testl %r12d, %r12d
jle 0xa22d
callq 0x3790
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq (%r14,%rcx), %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, (%r13,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0xa215
movq 0x10(%rsp), %rax
sarq $0x20, %rax
movb $0x0, (%r13,%rax)
movq %r15, %rdi
movq %r13, %rsi
callq 0x3760
movq %rax, %r14
movq %r15, %rdi
callq 0xf129
movq %r13, %rdi
callq 0xf129
testq %r14, %r14
je 0xa267
subq %r15, %r14
addq %r14, %rbx
jmp 0xa269
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: vasafef
int vasafef(char* buffer, int bufSize, char *format, va_list args)
/* Format string to buffer, vsprintf style, only with buffer overflow
 * checking.  The resulting string is always terminated with zero byte. */
{
int sz = vsnprintf(buffer, bufSize, format, args);
/* note that some version return -1 if too small */
if ((sz < 0) || (sz >= bufSize))
    {
    buffer[bufSize-1] = (char) 0;
    errAbort("buffer overflow, size %d, format: %s, buffer: '%s'", bufSize, format, buffer);
    }
return sz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r15
movq %r15, %rsi
callq 0x3170
movl %eax, %ebp
testl %eax, %eax
setns %al
cmpl %r15d, %ebp
setl %cl
testb %cl, %al
jne 0xa2c1
movb $0x0, -0x1(%r14,%r15)
leaq 0xf571(%rip), %rdi      # 0x19822
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8d7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: safencpy
void safencpy(char *buf, size_t bufSize, const char *src, size_t n)
/* copy n characters from a string to a buffer, with bounds checking.
 * Unlike strncpy, always null terminates the result */
{
if (n > bufSize-1)
    errAbort("buffer overflow, size %lld, substring size: %lld", (long long)bufSize, (long long)n);
// strlen(src) can take a long time when src is for example a pointer into a chromosome sequence.
// Instead of setting slen to max(strlen(src), n), just stop counting length at n.
size_t slen = 0;
while (src[slen] != '\0' && slen < n)
    slen++;
strncpy(buf, src, n);
buf[slen] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x1(%rsi), %rax
cmpq %rcx, %rax
jae 0xa379
leaq 0xf514(%rip), %rdi      # 0x19883
movq %r14, %rdx
xorl %eax, %eax
callq 0xb8d7
xorl %eax, %eax
leaq 0x1(%rax), %r12
cmpq %r14, %rax
jae 0xa38e
cmpb $0x0, (%r15,%rax)
movq %r12, %rax
jne 0xa37b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x30d0
movb $0x0, -0x1(%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: safecat
void safecat(char *buf, size_t bufSize, const char *src)
/* Append  a string to a buffer, with bounds checking.*/
{
size_t blen = strlen(buf);
size_t slen = strlen(src);
if (blen+slen > bufSize-1)
    errAbort("buffer overflow, size %lld, new string size: %lld", (long long)bufSize, (long long)(blen+slen));
strcat(buf, src);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3200
movq %rax, %r12
movq %rbx, %rdi
callq 0x3200
addq %r12, %rax
leaq -0x1(%r15), %rcx
cmpq %rcx, %rax
jbe 0xa3ef
leaq 0xf4d2(%rip), %rdi      # 0x198b4
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36b0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: safencat
void safencat(char *buf, size_t bufSize, const char *src, size_t n)
/* append n characters from a string to a buffer, with bounds checking. */
{
size_t blen = strlen(buf);
if (blen+n > bufSize-1)
    errAbort("buffer overflow, size %lld, new string size: %lld", (long long)bufSize, (long long)(blen+n));
size_t slen = strlen(src);
if (slen > n)
    slen = n;
strncat(buf, src, n);
buf[blen+slen] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x3200
movq %rax, %r12
leaq (%rax,%r14), %rdx
leaq -0x1(%r13), %rax
cmpq %rax, %rdx
jbe 0xa440
leaq 0xf47e(%rip), %rdi      # 0x198b4
movq %r13, %rsi
xorl %eax, %eax
callq 0xb8d7
movq %r15, %rdi
callq 0x3200
movq %rax, %r13
cmpq %r14, %rax
cmovaeq %r14, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3330
addq %rbx, %r12
movb $0x0, (%r13,%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: uglyTime
void uglyTime(char *label, ...)
/* Print label and how long it's been since last call.  Call with
 * a NULL label to initialize. */
{
static long lastTime = 0;
long time = clock1000();
va_list args;
va_start(args, label);
if (label != NULL)
    {
    fprintf(stdout, "<span class='timing'>");
    vfprintf(stdout, label, args);
    fprintf(stdout, ": %ld millis<BR></span>\n", time - lastTime);
    }
lastTime = time;
va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0xa556
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)
xorl %eax, %eax
callq 0x10fde
movq %rax, %rbx
movq %r15, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
testq %r14, %r14
je 0xa5ce
movq 0x1ca3c(%rip), %r15     # 0x26fc8
movq (%r15), %rcx
leaq 0xf35b(%rip), %rdi      # 0x198f1
movl $0x15, %esi
movl $0x1, %edx
callq 0x36f0
movq (%r15), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x3670
movq (%r15), %rdi
movq %rbx, %rdx
subq 0x1d270(%rip), %rdx     # 0x27830
leaq 0xf340(%rip), %rsi      # 0x19907
xorl %eax, %eax
callq 0x3470
movq %rbx, 0x1d25b(%rip)     # 0x27830
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: makeDirs
void makeDirs(char* path)
/* make a directory, including parent directories */
{
char pathBuf[PATH_LEN];
char* next = pathBuf;

strcpy(pathBuf, path);
if (*next == '/')
    next++;

while((*next != '\0')
      && (next = strchr(next, '/')) != NULL)
    {
    *next = '\0';
    makeDir(pathBuf);
    *next = '/';
    next++;
    }
makeDir(pathBuf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x30e0
xorl %eax, %eax
cmpb $0x2f, (%rbx)
sete %al
cmpb $0x0, (%rsp,%rax)
je 0xa63d
leaq (%rsp,%rax), %rdi
movq %rsp, %rbx
movl $0x2f, %esi
callq 0x3260
testq %rax, %rax
je 0xa63d
movq %rax, %r14
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x11334
movb $0x2f, (%r14)
movq %r14, %rdi
incq %rdi
cmpb $0x0, 0x1(%r14)
jne 0xa60f
movq %rsp, %rdi
callq 0x11334
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/common.c
// Function: mktimeFromUtc
time_t mktimeFromUtc (struct tm *t)
/* Return time_t for tm in UTC (GMT)
 * Useful for stuff like converting to time_t the
 * last-modified HTTP response header
 * which is always GMT. Returns -1 on failure of mktime */
{
    time_t time;
    char *tz;
    char save_tz[100];
    tz=getenv("TZ");
    if (tz)
        safecpy(save_tz, sizeof(save_tz), tz);
    setenv("TZ", "GMT0", 1);
    tzset();
    t->tm_isdst = 0;
    time=mktime(t);
    if (tz)
        setenv("TZ", save_tz, 1);
    else
        unsetenv("TZ");
    tzset();
    return (time);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0xf1fa(%rip), %rdi      # 0x19920
callq 0x3040
movq %rax, %r14
testq %rax, %rax
je 0xa743
movq %rsp, %rdi
movl $0x64, %esi
movq %r14, %rdx
callq 0x7cdd
leaq 0xf1d6(%rip), %rdi      # 0x19920
leaq 0xf1d2(%rip), %rsi      # 0x19923
movl $0x1, %edx
callq 0x3190
callq 0x34b0
movl $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x3560
movq %rax, %rbx
leaq 0xf1a7(%rip), %rdi      # 0x19920
testq %r14, %r14
je 0xa78d
movq %rsp, %rsi
movl $0x1, %edx
callq 0x3190
jmp 0xa792
callq 0x3680
callq 0x34b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: newDlList
struct dlList *newDlList()
/* Return a new doubly linked list. */
{
struct dlList *dl;
AllocVar(dl);
dl->head = (struct dlNode *)(&dl->nullMiddle);
dl->tail = (struct dlNode *)(&dl->head);
return dl;
}

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0xf07d
leaq 0x8(%rax), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlListReset
void dlListReset(struct dlList *dl)
/* Reset a list to the empty state (does not free values)  */
{
struct dlNode *node, *next;
for (node = dl->head; node->next != NULL; node = next)
    {
    next = node->next;
    freeMem(node);
    }
dl->head = (struct dlNode *)(&dl->nullMiddle);
dl->nullMiddle = NULL;
dl->tail = (struct dlNode *)(&dl->head);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0xab62
movq %rax, %r14
callq 0xf129
movq (%r14), %rax
movq %r14, %rdi
jmp 0xab4d
leaq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: freeDlList
void freeDlList(struct dlList **pList)
/* Free up a doubly linked list and it's nodes (but not the node values). */
{
struct dlList *list = *pList;
if (list != NULL)
    {
    dlListReset(list);
    freez(pList);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xab97
callq 0xab40
movq %rbx, %rdi
popq %rbx
jmp 0xf139
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: freeDlListAndVals
void freeDlListAndVals(struct dlList **pList)
/* Free all values in doubly linked list and the list itself.  (Just calls
 * freeMem on all values. */
{
struct dlList *list = *pList;
if (list != NULL)
    {
    struct dlNode *node;
    for (node = list->head; node->next != NULL; node = node->next)
        freeMem(node->val);
    freeDlList(pList);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xabce
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rax), %r14
cmpq $0x0, (%r14)
je 0xabbf
movq 0x10(%r14), %rdi
callq 0xf129
movq (%r14), %r14
jmp 0xabab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xab7d
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlAddValBefore
struct dlNode *dlAddValBefore(struct dlNode *anchor, void *val)
/* Create a node containing val and add to list before anchor member. */
{
struct dlNode *node = AllocA(struct dlNode);
node->val = val;
dlAddBefore(anchor, node);
return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xf07d
movq %rbx, 0x10(%rax)
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlAddValAfter
struct dlNode *dlAddValAfter(struct dlNode *anchor, void *val)
/* Create a node containing val and add to list after anchor member. */
{
struct dlNode *node = AllocA(struct dlNode);
node->val = val;
dlAddAfter(anchor, node);
return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xf07d
movq %rbx, 0x10(%rax)
movq (%r14), %rcx
movq %rax, (%r14)
movq %r14, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlAddValHead
struct dlNode *dlAddValHead(struct dlList *list, void *val)
/* Create a node containing val and add to head of list. */
{
struct dlNode *node = AllocA(struct dlNode);
node->val = val;
dlAddHead(list, node);
return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xf07d
movq %rbx, 0x10(%rax)
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlAddValTail
struct dlNode *dlAddValTail(struct dlList *list, void *val)
/* Create a node containing val and add to tail of list. */
{
struct dlNode *node = AllocA(struct dlNode);
node->val = val;
dlAddTail(list, node);
return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xf07d
movq %rbx, 0x10(%rax)
movq 0x10(%r14), %rcx
movq (%rcx), %rdx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlPopHead
struct dlNode *dlPopHead(struct dlList *list)
/* Remove first node from list and return it. */
{
struct dlNode *node = list->head;
if (node->next == NULL)
    return NULL;
dlRemove(node);
return node;
}

// Assembly:
movq (%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0xad5f
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlPopTail
struct dlNode *dlPopTail(struct dlList *list)
/* Remove last node from list and return it. */
{
struct dlNode *node = list->tail;
if (node->prev == NULL)
    return NULL;
dlRemove(node);
return node;
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xad80
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, 0x8(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlDelete
void dlDelete(struct dlNode **nodePtr)
/* Removes a node from list and frees it. */
{
struct dlNode *node = *nodePtr;
if (node != NULL)
    {
    dlRemove(node);
    freeMem(node);
    }
}

// Assembly:
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xada4
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0xf129
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlSort
void dlSort(struct dlList *list, 
	int (*compare )(const void *elem1,  const void *elem2))
/* Sort a singly linked list with Qsort and a temporary array. 
 * The arguments to the compare function in real, non-void, life
 * are pointers to pointers of the type that is in the val field of 
 * the nodes of the list. */
{
int len = dlCount(list);

if (len > 1)
    {
    /* Move val's onto an array, sort, and then put back into list. */
    struct dlSorter *sorter = needLargeMem(len * sizeof(sorter[0])), *s;
    struct dlNode *node;
    int i;

    for (i=0, node = list->head; i<len; ++i, node = node->next)
	{
	s = &sorter[i];
	s->node = node;
	}
    compareFunc = compare;
    qsort(sorter, len, sizeof(sorter[0]), dlNodeCmp);
    dlListInit(list);
    for (i=0; i<len; ++i)
	dlAddTail(list, sorter[i].node);
    freeMem(sorter);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6674
cmpl $0x3, %eax
jl 0xae67
movl %eax, %ebp
decl %ebp
movl %ebp, %r12d
leaq (,%r12,8), %rdi
callq 0xee85
movq %rax, %r14
xorl %eax, %eax
movq %rbx, %rcx
movq (%rcx), %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xaded
movq %r15, 0x1ca35(%rip)     # 0x27838
leaq 0x66(%rip), %rcx        # 0xae70
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3120
leaq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq (%rbx), %rsi
movq %rdx, (%rbx)
movq %rbx, 0x8(%rdx)
movq %rsi, (%rdx)
movq %rdx, 0x8(%rsi)
incq %rcx
cmpq %rcx, %rax
jne 0xae3a
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf129
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dlist.c
// Function: dlListToSlList
void *dlListToSlList(struct dlList *dList)
/* Return slList from dlList. */
{
struct slList *list = NULL, *el;
struct dlNode *node;

for (node = dList->tail; node->prev != NULL; node = node->prev)
    {
    el = node->val;
    slAddHead(&list, el);
    }
return list;
}

// Assembly:
movq 0x10(%rdi), %rcx
cmpq $0x0, 0x8(%rcx)
je 0xaede
xorl %edx, %edx
movq 0x10(%rcx), %rax
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
cmpq $0x0, 0x8(%rcx)
movq %rax, %rdx
jne 0xaec8
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: newDyString
struct dyString *newDyString(int initialBufSize)
/* Allocate dynamic string with initial buffer size.  (Pass zero for default) */
{
struct dyString *ds;
AllocVar(ds);
if (initialBufSize == 0)
    initialBufSize = 512;
ds->string = needMem(initialBufSize+1);
ds->bufSize = initialBufSize;
return ds;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl $0x18, %edi
callq 0xf07d
movq %rax, %r14
testl %ebx, %ebx
movl $0x200, %r15d           # imm = 0x200
cmovnel %ebx, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0xf07d
movq %rax, 0x8(%r14)
movl %r15d, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringCannibalize
char *dyStringCannibalize(struct dyString **pDy)
/* Kill dyString, but return the string it is wrapping
 * (formerly dy->string).  This should be free'd at your
 * convenience. */
{
char *s;
struct dyString *ds = *pDy;
assert(ds != NULL);
s = ds->string;
freez(pDy);
return s;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xafab
movq 0x8(%rax), %rbx
callq 0xf139
movq %rbx, %rax
popq %rbx
retq
leaq 0xe986(%rip), %rdi      # 0x19938
leaq 0xe98a(%rip), %rsi      # 0x19943
leaq 0xe98e(%rip), %rcx      # 0x1994e
movl $0x28, %edx
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: freeDyStringList
void freeDyStringList(struct dyString **pDs)
/* free up a list of dyStrings */
{
struct dyString *ds, *next;
for(ds = *pDs; ds != NULL; ds = next)
    {
    next = ds->next;
    freeDyString(&ds);
    }
*pDs = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0xaffd
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0xaf75
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xafe8
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringAppendN
void dyStringAppendN(struct dyString *ds, char *string, int stringSize)
/* Append string of given size to end of string. */
{
int oldSize = ds->stringSize;
int newSize = oldSize + stringSize;
char *buf;
if (newSize > ds->bufSize)
    {
    int newAllocSize = newSize + oldSize;
    int oldSizeTimesOneAndAHalf = oldSize * 1.5;
    if (newAllocSize < oldSizeTimesOneAndAHalf)
        newAllocSize = oldSizeTimesOneAndAHalf;
    dyStringExpandBuf(ds,newAllocSize);
    }
buf = ds->string;
memcpy(buf+oldSize, string, stringSize);
ds->stringSize = newSize;
buf[newSize] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x14(%rdi), %r12
movslq %edx, %r15
leaq (%r12,%r15), %r13
cmpl 0x10(%rdi), %r13d
jle 0xb099
cvtsi2sd %r12d, %xmm0
mulsd 0xe8bf(%rip), %xmm0     # 0x19930
cvttsd2si %xmm0, %ebp
leal (%r12,%r13), %eax
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq 0x8(%rbx), %rdi
leaq 0x1(%r12), %rsi
leal 0x1(%rbp), %eax
movslq %eax, %rdx
callq 0xf0eb
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
movq 0x8(%rbx), %rbp
addq %rbp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x34a0
movl %r13d, 0x14(%rbx)
movb $0x0, (%rbp,%r13)
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/dystring.c
// Function: dyStringAppendC
char dyStringAppendC(struct dyString *ds, char c)
/* Append char to end of string. */
{
char *s;
if (ds->stringSize >= ds->bufSize)
     dyStringExpandBuf(ds, ds->bufSize+256);
s = ds->string + ds->stringSize++;
*s++ = c;
*s = 0;
return c;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq 0x14(%rdi), %rsi
movslq 0x10(%rdi), %rdx
cmpl %edx, %esi
jl 0xb0fd
leal 0x100(%rdx), %ebp
movq 0x8(%r14), %rdi
incq %rsi
addq $0x101, %rdx            # imm = 0x101
callq 0xf0eb
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
movq 0x8(%r14), %rax
movslq 0x14(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x14(%r14)
movb %bl, (%rax,%rcx)
movb $0x0, 0x1(%rax,%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringAppendMultiC
void dyStringAppendMultiC(struct dyString *ds, char c, int n)
/* Append N copies of char to end of string. */
{
int oldSize = ds->stringSize;
int newSize = oldSize + n;
int newAllocSize = newSize + oldSize;
char *buf;
if (newSize > ds->bufSize)
    dyStringExpandBuf(ds,newAllocSize);
buf = ds->string;
memset(buf+oldSize, c, n);
ds->stringSize = newSize;
buf[newSize] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x14(%rdi), %r15
movslq %edx, %r14
leaq (%r15,%r14), %r12
cmpl 0x10(%rdi), %r12d
jle 0xb15e
leal (%r12,%r15), %r13d
movq 0x8(%rbx), %rdi
leaq 0x1(%r15), %rsi
leal (%r12,%r15), %eax
incl %eax
movslq %eax, %rdx
callq 0xf0eb
movq %rax, 0x8(%rbx)
movl %r13d, 0x10(%rbx)
movq 0x8(%rbx), %r13
addq %r13, %r15
movzbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3300
movl %r12d, 0x14(%rbx)
movb $0x0, (%r13,%r12)
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/dystring.c
// Function: dyStringAppendEscapeQuotes
void dyStringAppendEscapeQuotes(struct dyString *dy, char *string,
	char quot, char esc)
/* Append escaped-for-quotation version of string to dy. */
{
char c;
char *s = string;
while ((c = *s++) != 0)
     {
     if (c == quot)
         dyStringAppendC(dy, esc);
     dyStringAppendC(dy, c);
     }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb (%rsi), %r12b
testb %r12b, %r12b
je 0xb1f7
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
incq %r14
movsbl %cl, %ebp
cmpb %bl, %r12b
jne 0xb1e0
movq %r15, %rdi
movl %ebp, %esi
callq 0xb0c7
movsbl %r12b, %esi
movq %r15, %rdi
callq 0xb0c7
movb (%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0xb1d1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringVaPrintf
void dyStringVaPrintf(struct dyString *ds, char *format, va_list args)
/* VarArgs Printf to end of dyString. */
{
/* attempt to format the string in the current space.  If there
 * is not enough room, increase the buffer size and try again */
int avail, sz;
while (TRUE)
    {
    va_list argscp;
    va_copy(argscp, args);
    avail = ds->bufSize - ds->stringSize;
    if (avail <= 0)
        {
	/* Don't pass zero sized buffers to vsnprintf, because who knows
	 * if the library function will handle it. */
        dyStringExpandBuf(ds, ds->bufSize+ds->bufSize);
	avail = ds->bufSize - ds->stringSize;
	}
    sz = vsnprintf(ds->string + ds->stringSize, avail, format, argscp);
    va_end(argscp);

    /* note that some version return -1 if too small */
    if ((sz < 0) || (sz >= avail))
        dyStringExpandBuf(ds, ds->bufSize+ds->bufSize);
    else
        {
        ds->stringSize += sz;
        break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, (%rsp)
movslq 0x10(%r15), %r13
movslq 0x14(%r15), %rsi
movl %r13d, %eax
subl %esi, %eax
jg 0xb25f
movq 0x8(%r15), %rdi
incq %rsi
leaq 0x1(,%r13,2), %rdx
addq %r13, %r13
callq 0xf0eb
movq %rax, 0x8(%r15)
movl %r13d, 0x10(%r15)
subl 0x14(%r15), %r13d
movl %r13d, %eax
movslq 0x14(%r15), %rdi
addq 0x8(%r15), %rdi
movslq %eax, %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x3170
testl %eax, %eax
sets %cl
cmpl %r13d, %eax
setge %bpl
orb %cl, %bpl
cmpb $0x1, %bpl
jne 0xb2b6
movslq 0x10(%r15), %r13
movq 0x8(%r15), %rdi
movslq 0x14(%r15), %rsi
incq %rsi
leaq 0x1(,%r13,2), %rdx
addq %r13, %r13
callq 0xf0eb
movq %rax, 0x8(%r15)
movl %r13d, 0x10(%r15)
jmp 0xb2ba
addl %eax, 0x14(%r15)
testb %bpl, %bpl
jne 0xb21a
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/dystring.c
// Function: dyStringCreate
struct dyString *dyStringCreate(char *format, ...)
/*  Create a dyString with a printf style initial content */
{
int len = strlen(format) * 3;
struct dyString *ds = newDyString(len);
va_list args;
va_start(args, format);
dyStringVaPrintf(ds, format, args);
va_end(args);
return ds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0xb3c1
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)
callq 0x3200
movq %rax, %r14
leal (%rax,%rax,2), %ebp
movl $0x18, %edi
callq 0xf07d
movq %rax, %r15
testl %r14d, %r14d
movl $0x200, %r14d           # imm = 0x200
cmovnel %ebp, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0xf07d
movq %rax, 0x8(%r15)
movl %r14d, 0x10(%r15)
movq %rsp, %rdx
movq %r12, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb200
movq %r15, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringSub
struct dyString * dyStringSub(char *orig, char *in, char *out)
/* Make up a duplicate of orig with all occurences of in substituted
 * with out. */
{
int inLen = strlen(in), outLen = strlen(out), origLen = strlen(orig);
struct dyString *dy = newDyString(origLen + 2*outLen);
char *s, *e;

if (orig == NULL) return NULL;
for (s = orig; ;)
    {
    e = stringIn(in, s);
    if (e == NULL)
	{
        e = orig + origLen;
	dyStringAppendN(dy, s, e - s);
	break;
	}
    else
        {
	dyStringAppendN(dy, s, e - s);
	dyStringAppendN(dy, out, outLen);
	s = e + inLen;
	}
    }
return dy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %rbp
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x3200
movq %rax, 0x18(%rsp)
movq %rbx, %r15
movq %rbx, %rdi
callq 0x3200
movq %rax, %r13
movq %rbp, %rdi
callq 0x3200
movq %rax, 0x20(%rsp)
leal (%rax,%r13,2), %ebx
movl $0x18, %edi
callq 0xf07d
movq %rax, %r12
testl %ebx, %ebx
movl $0x200, %r14d           # imm = 0x200
cmovnel %ebx, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0xf07d
movq %rax, 0x8(%r12)
movl %r14d, 0x10(%r12)
testq %rbp, %rbp
je 0xb528
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x3760
movq %rbp, %rbx
movq %rbp, 0x8(%rsp)
testq %rax, %rax
je 0xb510
movq %rax, %rbp
movslq 0x18(%rsp), %r14
movq 0x8(%rsp), %rbx
movl %ebp, %edx
subl %ebx, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb042
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xb042
movq %rbp, %rbx
addq %r14, %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x3760
movq %rax, %rbp
testq %rax, %rax
jne 0xb4d8
movq 0x8(%rsp), %rdx
addl 0x20(%rsp), %edx
subl %ebx, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb042
jmp 0xb52b
xorl %r12d, %r12d
movq %r12, %rax
addq $0x28, %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/dystring.c
// Function: dyStringResize
void dyStringResize(struct dyString *ds, int newSize)
/* resize a string, if the string expands, blanks are appended */
{
int oldSize = ds->stringSize;
if (newSize > oldSize)
    {
    /* grow */
    if (newSize > ds->bufSize)
        dyStringExpandBuf(ds, newSize + ds->stringSize);
    memset(ds->string+newSize, ' ', newSize);
    }
ds->string[newSize] = '\0';
ds->stringSize = newSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x14(%rdi), %rax
movslq %esi, %r15
cmpl %esi, %eax
jge 0xb58f
cmpl %ebx, 0x10(%r14)
jge 0xb57b
movq 0x8(%r14), %rdi
movq %rax, %rsi
incq %rsi
leal (%rax,%rbx), %ebp
addl %ebx, %eax
incl %eax
movslq %eax, %rdx
callq 0xf0eb
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
movq 0x8(%r14), %rdi
addq %r15, %rdi
movl $0x20, %esi
movq %r15, %rdx
callq 0x3300
movq 0x8(%r14), %rax
movb $0x0, (%rax,%r15)
movl %ebx, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/dystring.c
// Function: dyStringQuoteString
void dyStringQuoteString(struct dyString *dy, char quotChar, char *text)
/* Append quotChar-quoted text (with any internal occurrences of quotChar
 * \-escaped) onto end of dy. */
{
char c;

dyStringAppendC(dy, quotChar);
while ((c = *text++) != 0)
    {
    if (c == quotChar)
        dyStringAppendC(dy, '\\');
    dyStringAppendC(dy, c);
    }
dyStringAppendC(dy, quotChar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xb0c7
movb (%r14), %r15b
testb %r15b, %r15b
je 0xb5ef
incq %r14
cmpb %bpl, %r15b
jne 0xb5d8
movq %rbx, %rdi
movl $0x5c, %esi
callq 0xb0c7
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0xb0c7
movb (%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0xb5c6
movsbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb0c7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: warnWithBackTrace
void warnWithBackTrace(char *format, ...)
/* Issue a warning message and append backtrace. */
{
va_list args;
va_start(args, format);
struct dyString *dy = newDyString(255);
dyStringAppend(dy, format);

#define STACK_LIMIT 20
char **strings = NULL;
int count = 0;

// developer: this is an occasionally useful means of getting stack info without crashing
// however, it is not supported on cygwin.  Conditionally compile this in when desired.
// The define is at top to include execinfo.h
#ifdef BACKTRACE_EXISTS
void *buffer[STACK_LIMIT];
count = backtrace(buffer, STACK_LIMIT);
strings = backtrace_symbols(buffer, count);
#endif///def BACKTRACE_EXISTS

if (strings == NULL)
    dyStringAppend(dy,"\nno backtrace_symbols available in errabort::warnWithBackTrace().");
else
    {
    int ix = 1;
    dyStringAppend(dy,"\nBACKTRACE (use on cmdLine):");
    if (strings[1] != NULL)
        {
        strSwapChar(strings[1],' ','\0');
        dyStringPrintf(dy,"\naddr2line -Cfise %s",strings[1]);
        strings[1] += strlen(strings[1]) + 1;
        }
    for (; ix < count && strings[ix] != NULL; ix++)
        {
        strings[ix] = skipBeyondDelimit(strings[ix],'[');
        strSwapChar(strings[ix],']','\0');
        dyStringPrintf(dy," %s",strings[ix]);
        }

    free(strings);
    }
vaWarn(dyStringCannibalize(&dy), args);
va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %r14
leaq 0x30(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xb73a
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %rbx
movq %rdi, 0x10(%rbx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
movl $0xff, %edi
callq 0xaf38
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0xb18d
movq (%r15), %rdi
leaq 0xe1f9(%rip), %rsi      # 0x1997c
callq 0xb18d
movq %r15, %rdi
callq 0xaf94
movq %rax, %r14
callq 0xbbea
movslq 0xa8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax,%rcx,8)
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: errnoWarn
void errnoWarn(char *format, ...)
/* Prints error message from UNIX errno first, then does rest of warning. */
{
char fbuf[512];
va_list args;
va_start(args, format);
sprintf(fbuf, "%s\n%s", strerror(errno), format);
vaWarn(fbuf, args);
va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xb819
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)
movq %rsp, %rbx
movq %rdi, 0x10(%rbx)
leaq 0x2f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xe172(%rip), %rsi      # 0x199be
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x36d0
callq 0xbbea
movslq 0xa8(%rax), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rax,%rcx,8)
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: pushWarnHandler
void pushWarnHandler(WarnHandler handler)
/* Set abort handler */
{
struct perThreadAbortVars *ptav = getThreadVars();
if (ptav->warnIx >= maxWarnHandlers-1)
    {
    if (ptav->debugPushPopErr)
        dumpStack("pushWarnHandler overflow");
    errAbort("Too many pushWarnHandlers, can only handle %d\n", maxWarnHandlers-1);
    }
ptav->warnArray[++ptav->warnIx] = handler;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbbea
cmpl $0x13, 0xa8(%rax)
jge 0xb8b1
movslq 0xa8(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0xa8(%rax)
movq %rbx, 0x10(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xb8c4
leaq 0xe107(%rip), %rdi      # 0x199c4
xorl %eax, %eax
callq 0x11c6b
leaq 0xe112(%rip), %rdi      # 0x199dd
movl $0x13, %esi
xorl %eax, %eax
callq 0xb8d7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: popWarnHandler
void popWarnHandler()
/* Revert to old warn handler. */
{
struct perThreadAbortVars *ptav = getThreadVars();
if (ptav->warnIx <= 0)
    {
    if (ptav->debugPushPopErr)
        dumpStack("popWarnHandler underflow");
    errAbort("Too few popWarnHandlers");
    }
--ptav->warnIx;
}

// Assembly:
pushq %rax
callq 0xbbea
cmpl $0x0, 0xa8(%rax)
jle 0xb96e
decl 0xa8(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xb981
leaq 0xe092(%rip), %rdi      # 0x19a0c
xorl %eax, %eax
callq 0x11c6b
leaq 0xe09d(%rip), %rdi      # 0x19a25
xorl %eax, %eax
callq 0xb8d7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: vaErrAbort
void vaErrAbort(char *format, va_list args)
/* Abort function, with optional (vprintf formatted) error message. */
{
/* flag is needed because both errAbort and warn generate message
 * using the warn handler, however sometimes one needed to know
 * (like when logging), if it's an error or a warning.  This is far from
 * perfect, as this isn't cleared if the error handler continues,
 * as with an exception mechanism. */
struct perThreadAbortVars *ptav = getThreadVars();
ptav->errAbortInProgress = TRUE;
vaWarn(format, args);
noWarnAbort();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbbea
movl $0x1, 0x4(%rax)
callq 0xbbea
movslq 0xa8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax,%rcx,8)
callq 0xbbea
movq %rax, %rcx
movslq 0x110(%rax), %rdx
xorl %eax, %eax
callq *0xb0(%rcx,%rdx,8)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: pushAbortHandler
void pushAbortHandler(AbortHandler handler)
/* Set abort handler */
{
struct perThreadAbortVars *ptav = getThreadVars();
if (ptav->abortIx >= maxAbortHandlers-1)
    {
    if (ptav->debugPushPopErr)
        dumpStack("pushAbortHandler overflow");
    errAbort("Too many pushAbortHandlers, can only handle %d", maxAbortHandlers-1);
    }
ptav->abortArray[++ptav->abortIx] = handler;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbbea
cmpl $0xb, 0x110(%rax)
jge 0xbae6
movslq 0x110(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x110(%rax)
movq %rbx, 0xb8(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xbaf9
leaq 0xdf4b(%rip), %rdi      # 0x19a3d
xorl %eax, %eax
callq 0x11c6b
leaq 0xdf57(%rip), %rdi      # 0x19a57
movl $0xb, %esi
xorl %eax, %eax
callq 0xb8d7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: popAbortHandler
void popAbortHandler()
/* Revert to old abort handler. */
{
struct perThreadAbortVars *ptav = getThreadVars();
if (ptav->abortIx <= 0)
    {
    if (ptav->debugPushPopErr)
        dumpStack("popAbortHandler underflow");
    errAbort("Too many popAbortHandlers\n");
    }
--ptav->abortIx;
}

// Assembly:
pushq %rax
callq 0xbbea
cmpl $0x0, 0x110(%rax)
jle 0xbb23
decl 0x110(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xbb36
leaq 0xdf57(%rip), %rdi      # 0x19a86
xorl %eax, %eax
callq 0x11c6b
leaq 0xdf63(%rip), %rdi      # 0x19aa0
xorl %eax, %eax
callq 0xb8d7
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/errabort.c
// Function: getThreadVars
static struct perThreadAbortVars *getThreadVars()
/* Return a pointer to the perThreadAbortVars for the current pthread. */
{
pthread_t pid = pthread_self(); //  can be a pointer or a number
// Don't safef, theoretically that could abort.
char pidStr[64];
snprintf(pidStr, sizeof(pidStr), "%lld",  ptrToLL(pid));
pidStr[ArraySize(pidStr)-1] = '\0';

static char pidInUse[64] = "";  // use a string since there is no known unused value for pthread_t variable
if (sameString(pidStr, pidInUse)) // avoid deadlock on self
    {  // this only happens when it has aborted already due to out of memory
       // which should be a rare occurrence.
    char *errMsg = "errAbort re-entered due to out-of-memory condition. Exiting.";
    write(STDERR_FILENO, errMsg, strlen(errMsg)); 
    exit(1);
    }

static pthread_mutex_t ptavMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock( &ptavMutex );
snprintf(pidInUse, sizeof(pidInUse), "%lld",  ptrToLL(pid));
pidInUse[ArraySize(pidInUse)-1] = '\0';

static struct hash *perThreadVars = NULL;
if (perThreadVars == NULL)
    perThreadVars = hashNew(0);
struct hashEl *hel = hashLookup(perThreadVars, pidStr);
if (hel == NULL)
    {
    // if it is the first time, initialization the perThreadAbortVars
    struct perThreadAbortVars *ptav;
    AllocVar(ptav);
    ptav->debugPushPopErr = FALSE;
    ptav->errAbortInProgress = FALSE;
    ptav->warnIx = 0;
    ptav->warnArray[0] = defaultVaWarn;
    ptav->abortIx = 0;
    ptav->abortArray[0] = defaultAbort;
    hel = hashAdd(perThreadVars, pidStr, ptav);
    }
pidInUse[0] = '\0';
pthread_mutex_unlock( &ptavMutex );
return (struct perThreadAbortVars *)(hel->val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0x3600
movq %rax, %rbx
leaq 0xdc7e(%rip), %rdx      # 0x1987e
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x32a0
movb $0x0, 0x3f(%r14)
leaq 0x1bc1f(%rip), %rsi     # 0x27840
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0xbd01
leaq 0x1bc48(%rip), %rdi     # 0x27880
callq 0x3770
leaq 0x1bbfc(%rip), %rdi     # 0x27840
leaq 0xdc33(%rip), %rdx      # 0x1987e
movl $0x40, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x32a0
movb $0x0, 0x1bc1e(%rip)     # 0x2787f
cmpq $0x0, 0x1bc3f(%rip)     # 0x278a8
jne 0xbc7e
xorl %edi, %edi
movl $0x1, %esi
callq 0xc3f1
movq %rax, 0x1bc2a(%rip)     # 0x278a8
movq 0x1bc23(%rip), %rdi     # 0x278a8
movq %rsp, %rsi
callq 0xbd98
movq %rax, %rbx
testq %rax, %rax
jne 0xbce2
movl $0x118, %edi            # imm = 0x118
callq 0xf07d
movq $0x0, (%rax)
xorl %ecx, %ecx
movl %ecx, 0xa8(%rax)
leaq -0xdc(%rip), %rdx       # 0xbbd9
movq %rdx, 0x8(%rax)
movl %ecx, 0x110(%rax)
leaq 0x5b(%rip), %rcx        # 0xbd21
movq %rcx, 0xb0(%rax)
movq 0x1bbd4(%rip), %rdi     # 0x278a8
movq %rsp, %rsi
movq %rax, %rdx
callq 0xc04f
movq %rax, %rbx
movb $0x0, 0x1bb57(%rip)     # 0x27840
leaq 0x1bb90(%rip), %rdi     # 0x27880
callq 0x3500
movq 0x10(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0xddd6(%rip), %rsi      # 0x19ade
movl $0x3c, %edx
movl $0x2, %edi
callq 0x31a0
movl $0x1, %edi
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/hash.c
// Function: hashString
bits32 hashString(char *string)
/* Compute a hash value of a string. */
{
char *keyStr = string;
unsigned int result = 0;
int c;

while ((c = *keyStr++) != '\0')
    {
    result += (result<<3) + c;
    }
return result;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0xbd71
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
leal (%rax,%rax,8), %eax
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xbd5f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/hash.c
// Function: hashCrc
bits32 hashCrc(char *string)
/* Returns a CRC value on string. */
{
unsigned char *us = (unsigned char *)string;
unsigned char c;
bits32 shiftAcc = 0;
bits32 addAcc = 0;

while ((c = *us++) != 0)
    {
    shiftAcc <<= 2;
    shiftAcc += c;
    addAcc += c;
    }
return shiftAcc + addAcc;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0xbd95
incq %rdi
xorl %eax, %eax
xorl %edx, %edx
movzbl %cl, %ecx
leal (%rcx,%rdx,4), %edx
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xbd81
addl %edx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/JimKent[P]linearSat/lib/hash.c
// Function: hashLookup
struct hashEl *hashLookup(struct hash *hash, char *name)
/* Looks for name in hash table. Returns associated element,
 * if found, or NULL if not.  If there are multiple entries
 * for name, the last one added is returned (LIFO behavior).
 */
{
struct hashEl *el = hash->table[hashString(name)&hash->mask];
while (el != NULL)
    {
    if (strcmp(el->name, name) == 0)
        break;
    el = el->next;
    }
return el;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rax
movb (%rsi), %sil
testb %sil, %sil
je 0xbdc7
leaq 0x1(%rbx), %rdx
xorl %ecx, %ecx
movsbl %sil, %esi
leal (%rcx,%rcx,8), %ecx
addl %esi, %ecx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0xbdb1
jmp 0xbdc9
xorl %ecx, %ecx
andl 0x8(%rdi), %ecx
leaq (%rax,%rcx,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xbde8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3440
testl %eax, %eax
jne 0xbdd0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq