LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xa34f
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 0x10dba
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 0xa3c7
movq 0x1cc43(%rip), %r15     # 0x26fc8
movq (%r15), %rcx
leaq 0xf572(%rip), %rdi      # 0x19901
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 0x1d477(%rip), %rdx     # 0x27830
leaq 0xf557(%rip), %rsi      # 0x19917
xorl %eax, %eax
callq 0x3470
movq %rbx, 0x1d462(%rip)     # 0x27830
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa436
leaq (%rsp,%rax), %rdi
movq %rsp, %rbx
movl $0x2f, %esi
callq 0x3260
testq %rax, %rax
je 0xa436
movq %rax, %r14
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x110db
movb $0x2f, (%r14)
movq %r14, %rdi
incq %rdi
cmpb $0x0, 0x1(%r14)
jne 0xa408
movq %rsp, %rdi
callq 0x110db
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf411(%rip), %rdi      # 0x19930
callq 0x3040
movq %rax, %r14
testq %rax, %rax
je 0xa53c
movq %rsp, %rdi
movl $0x64, %esi
movq %r14, %rdx
callq 0x7b39
leaq 0xf3ed(%rip), %rdi      # 0x19930
leaq 0xf3e9(%rip), %rsi      # 0x19933
movl $0x1, %edx
callq 0x3190
callq 0x34b0
movl $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x3560
movq %rax, %rbx
leaq 0xf3be(%rip), %rdi      # 0x19930
testq %r14, %r14
je 0xa586
movq %rsp, %rsi
movl $0x1, %edx
callq 0x3190
jmp 0xa58b
callq 0x3680
callq 0x34b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee10
leaq 0x8(%rax), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa93e
movq %rax, %r14
callq 0xeebc
movq (%r14), %rax
movq %r14, %rdi
jmp 0xa929
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_O3/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 0xa973
callq 0xa91c
movq %rbx, %rdi
popq %rbx
jmp 0xeecc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa9aa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rax), %r14
cmpq $0x0, (%r14)
je 0xa99b
movq 0x10(%r14), %rdi
callq 0xeebc
movq (%r14), %r14
jmp 0xa987
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa959
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee10
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_O3/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 0xee10
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_O3/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 0xee10
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_O3/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 0xee10
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_O3/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 0xab3b
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_O3/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 0xab5c
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_O3/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 0xab80
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0xeebc
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x65f4
cmpl $0x3, %eax
jl 0xac43
movl %eax, %ebp
decl %ebp
movl %ebp, %r12d
leaq (,%r12,8), %rdi
callq 0xec18
movq %rax, %r14
xorl %eax, %eax
movq %rbx, %rcx
movq (%rcx), %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xabc9
movq %r15, 0x1cc59(%rip)     # 0x27838
leaq 0x66(%rip), %rcx        # 0xac4c
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 0xac16
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xeebc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xacba
xorl %edx, %edx
movq 0x10(%rcx), %rax
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
cmpq $0x0, 0x8(%rcx)
movq %rax, %rdx
jne 0xaca4
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee10
movq %rax, %r14
testl %ebx, %ebx
movl $0x200, %r15d           # imm = 0x200
cmovnel %ebx, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0xee10
movq %rax, 0x8(%r14)
movl %r15d, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xad87
movq 0x8(%rax), %rbx
callq 0xeecc
movq %rbx, %rax
popq %rbx
retq
leaq 0xebba(%rip), %rdi      # 0x19948
leaq 0xebbe(%rip), %rsi      # 0x19953
leaq 0xebc2(%rip), %rcx      # 0x1995e
movl $0x28, %edx
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O3/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 0xadd9
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0xad51
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0xadc4
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
movslq 0x14(%rdi), %r12
movslq %edx, %r15
leaq (%r12,%r15), %rbp
cmpl 0x10(%rdi), %ebp
jle 0xae81
cvtsi2sd %r12d, %xmm0
mulsd 0xeaf7(%rip), %xmm0     # 0x19940
cvttsd2si %xmm0, %r14d
leal (%r12,%rbp), %eax
cmpl %r14d, %eax
cmovgl %eax, %r14d
movq 0x8(%rbx), %rdi
movq %rsi, %r13
leaq 0x1(%r12), %rsi
leal 0x1(%r14), %eax
movslq %eax, %rdx
callq 0xee7e
movq %r13, %rsi
movq %rax, %r13
movq %rax, 0x8(%rbx)
movl %r14d, 0x10(%rbx)
jmp 0xae85
movq 0x8(%rbx), %r13
addq %r13, %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x34a0
movl %ebp, 0x14(%rbx)
movb $0x0, (%r13,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x14(%rdi), %ecx
movslq 0x10(%rdi), %rdx
cmpl %edx, %ecx
jge 0xaec5
movq 0x8(%r14), %rax
jmp 0xaeed
movslq %ecx, %rsi
leal 0x100(%rdx), %ebp
movq 0x8(%r14), %rdi
incq %rsi
addq $0x101, %rdx            # imm = 0x101
callq 0xee7e
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
movl 0x14(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x14(%r14)
movslq %ecx, %rcx
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_O3/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), %r13
cmpl 0x10(%rdi), %r13d
jle 0xaf55
leal (%r15,%r13), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x1(%r15), %rsi
leal (%r15,%r13), %eax
incl %eax
movslq %eax, %rdx
callq 0xee7e
movq %rax, %r12
movq %rax, 0x8(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rbx)
jmp 0xaf59
movq 0x8(%rbx), %r12
addq %r12, %r15
movzbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3300
movl %r13d, 0x14(%rbx)
movb $0x0, (%r12,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xafed
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
incq %r14
movsbl %cl, %ebp
cmpb %bl, %r12b
jne 0xafd6
movq %r15, %rdi
movl %ebp, %esi
callq 0xaeab
movsbl %r12b, %esi
movq %r15, %rdi
callq 0xaeab
movb (%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0xafc7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movslq 0x10(%rbx), %r13
movl 0x14(%rbx), %ecx
movl %r13d, %ebp
movq 0x8(%rbx), %rax
subl %ecx, %ebp
jg 0xb05d
movslq %ecx, %rsi
incq %rsi
leaq 0x1(,%r13,2), %rdx
addq %r13, %r13
movq %rax, %rdi
callq 0xee7e
movq %rax, 0x8(%rbx)
movl %r13d, 0x10(%rbx)
movl 0x14(%rbx), %ecx
subl %ecx, %r13d
movl %r13d, %ebp
movslq %ecx, %rdi
addq %rax, %rdi
movslq %ebp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3170
testl %eax, %eax
js 0xb079
cmpl %ebp, %eax
jl 0xb0a5
movslq 0x10(%rbx), %r13
movq 0x8(%rbx), %rdi
movslq 0x14(%rbx), %rsi
incq %rsi
leaq 0x1(,%r13,2), %rdx
addq %r13, %r13
callq 0xee7e
movq %rax, 0x8(%rbx)
movl %r13d, 0x10(%rbx)
jmp 0xb010
addl %eax, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb1a6
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 0xee10
movq %rax, %r15
testl %r14d, %r14d
movl $0x200, %r14d           # imm = 0x200
cmovnel %ebp, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0xee10
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 0xaff6
movq %r15, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee10
movq %rax, %r12
testl %ebx, %ebx
movl $0x200, %r14d           # imm = 0x200
cmovnel %ebx, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0xee10
movq %rax, 0x8(%r12)
movl %r14d, 0x10(%r12)
testq %rbp, %rbp
je 0xb30d
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x3760
movq %rbp, %rbx
movq %rbp, 0x8(%rsp)
testq %rax, %rax
je 0xb2f5
movq %rax, %rbp
movslq 0x18(%rsp), %r14
movq 0x8(%rsp), %rbx
movl %ebp, %edx
subl %ebx, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xae1e
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xae1e
movq %rbp, %rbx
addq %r14, %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x3760
movq %rax, %rbp
testq %rax, %rax
jne 0xb2bd
movq 0x8(%rsp), %rdx
addl 0x20(%rsp), %edx
subl %ebx, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xae1e
jmp 0xb310
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_O3/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
cmpl %esi, %eax
jge 0xb362
cmpl %ebx, 0x10(%r14)
jge 0xb367
movq 0x8(%r14), %rdi
movq %rax, %rsi
incq %rsi
leal (%rax,%rbx), %ebp
addl %ebx, %eax
incl %eax
movslq %eax, %rdx
callq 0xee7e
movq %rax, %rdi
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
jmp 0xb36b
movslq %ebx, %r15
jmp 0xb37e
movq 0x8(%r14), %rdi
movslq %ebx, %r15
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_O3/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 0xaeab
movb (%r14), %r15b
testb %r15b, %r15b
je 0xb3de
incq %r14
cmpb %bpl, %r15b
jne 0xb3c7
movq %rbx, %rdi
movl $0x5c, %esi
callq 0xaeab
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0xaeab
movb (%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0xb3b5
movsbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaeab
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0xe8, %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 0xb528
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 0x110(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
movl $0xff, %edi
callq 0xad14
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0xaf83
leaq 0xe41a(%rip), %rsi      # 0x1998c
movq %r15, %rdi
callq 0xaf83
movq %r12, %rdi
callq 0xad70
movq %rax, %r14
callq 0xb9de
movslq 0xa8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax,%rcx,8)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb60d
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 0xe38e(%rip), %rsi      # 0x199ce
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x36d0
callq 0xb9de
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_O3/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 0xb9de
movslq 0xa8(%rax), %rcx
cmpq $0x13, %rcx
jge 0xb6a2
leaq 0x1(%rcx), %rdx
movl %edx, 0xa8(%rax)
movq %rbx, 0x10(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xb6b5
leaq 0xe326(%rip), %rdi      # 0x199d4
xorl %eax, %eax
callq 0x119cf
leaq 0xe331(%rip), %rdi      # 0x199ed
movl $0x13, %esi
xorl %eax, %eax
callq 0xb6c8
// File: /workspace/github_c_makefile_star2_O3/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 0xb9de
movl 0xa8(%rax), %ecx
testl %ecx, %ecx
jle 0xb762
decl %ecx
movl %ecx, 0xa8(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xb775
leaq 0xe2ae(%rip), %rdi      # 0x19a1c
xorl %eax, %eax
callq 0x119cf
leaq 0xe2b9(%rip), %rdi      # 0x19a35
xorl %eax, %eax
callq 0xb6c8
// File: /workspace/github_c_makefile_star2_O3/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 0xb9de
movl $0x1, 0x4(%rax)
callq 0xb9de
movslq 0xa8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax,%rcx,8)
callq 0xb9de
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_O3/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 0xb9de
movslq 0x110(%rax), %rcx
cmpq $0xb, %rcx
jge 0xb8d7
leaq 0x1(%rcx), %rdx
movl %edx, 0x110(%rax)
movq %rbx, 0xb8(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xb8ea
leaq 0xe16a(%rip), %rdi      # 0x19a4d
xorl %eax, %eax
callq 0x119cf
leaq 0xe176(%rip), %rdi      # 0x19a67
movl $0xb, %esi
xorl %eax, %eax
callq 0xb6c8
// File: /workspace/github_c_makefile_star2_O3/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 0xb9de
movl 0x110(%rax), %ecx
testl %ecx, %ecx
jle 0xb917
decl %ecx
movl %ecx, 0x110(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xb92a
leaq 0xe173(%rip), %rdi      # 0x19a96
xorl %eax, %eax
callq 0x119cf
leaq 0xe17f(%rip), %rdi      # 0x19ab0
xorl %eax, %eax
callq 0xb6c8
// File: /workspace/github_c_makefile_star2_O3/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 0xde9a(%rip), %rdx      # 0x1988e
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x32a0
movb $0x0, 0x3f(%r14)
leaq 0x1be2b(%rip), %rsi     # 0x27840
movq %r14, %rdi
callq 0x3440
testl %eax, %eax
je 0xbaf3
leaq 0x1be54(%rip), %rdi     # 0x27880
callq 0x3770
leaq 0x1be08(%rip), %rdi     # 0x27840
leaq 0xde4f(%rip), %rdx      # 0x1988e
movl $0x40, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x32a0
movb $0x0, 0x1be2a(%rip)     # 0x2787f
movq 0x1be4c(%rip), %rdi     # 0x278a8
testq %rdi, %rdi
jne 0xba77
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %rdi
movq %rax, 0x1be31(%rip)     # 0x278a8
movq %rsp, %rsi
callq 0xbb8c
movq %rax, %rbx
testq %rax, %rax
jne 0xbad4
movl $0x118, %edi            # imm = 0x118
callq 0xee10
movq $0x0, (%rax)
xorl %ecx, %ecx
movl %ecx, 0xa8(%rax)
leaq -0xda(%rip), %rdx       # 0xb9cd
movq %rdx, 0x8(%rax)
movl %ecx, 0x110(%rax)
leaq 0x5b(%rip), %rcx        # 0xbb13
movq %rcx, 0xb0(%rax)
movq 0x1bde2(%rip), %rdi     # 0x278a8
movq %rsp, %rsi
movq %rax, %rdx
callq 0xbe46
movq %rax, %rbx
movb $0x0, 0x1bd65(%rip)     # 0x27840
leaq 0x1bd9e(%rip), %rdi     # 0x27880
callq 0x3500
movq 0x10(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0xdff4(%rip), %rsi      # 0x19aee
movl $0x3c, %edx
movl $0x2, %edi
callq 0x31a0
movl $0x1, %edi
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O3/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 0xbb65
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 0xbb53
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbb89
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 0xbb75
addl %edx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbbbb
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 0xbba5
jmp 0xbbbd
xorl %ecx, %ecx
andl 0x8(%rdi), %ecx
leaq (%rax,%rcx,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xbbdc
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3440
testl %eax, %eax
jne 0xbbc4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashAddN
struct hashEl *hashAddN(struct hash *hash, char *name, int nameSize, void *val)
/* Add name of given size to hash (no need to be zero terminated) */
{
struct hashEl *el;
if (hash->lm) 
    el = lmAlloc(hash->lm, sizeof(*el));
else
    AllocVar(el);
el->hashVal = hashString(name);
int hashVal = el->hashVal & hash->mask;
if (hash->lm)
    {
    el->name = lmAlloc(hash->lm, nameSize+1);
    memcpy(el->name, name, nameSize);
    }
else
    el->name = cloneStringZ(name, nameSize);
el->val = val;
el->next = hash->table[hashVal];
hash->table[hashVal] = el;
hash->elCount += 1;
if (hash->autoExpand && hash->elCount > (int)(hash->size * hash->expansionFactor))
    {
    /* double the size */
    hashResize(hash, digitsBaseTwo(hash->size));
    }
return el;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xbc88
movl $0x20, %esi
callq 0xe995
jmp 0xbc92
movl $0x20, %edi
callq 0xee10
movq %rax, %r14
movb (%r12), %dl
testb %dl, %dl
je 0xbcb7
leaq 0x1(%r12), %rcx
xorl %eax, %eax
movsbl %dl, %edx
leal (%rax,%rax,8), %eax
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xbca4
jmp 0xbcb9
xorl %eax, %eax
movl %eax, 0x18(%r14)
andl 0x8(%rbx), %eax
movslq %eax, %rbp
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xbcec
leal 0x1(%r13), %eax
movslq %eax, %rsi
callq 0xe995
movq %rax, 0x8(%r14)
movslq %r13d, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x34a0
jmp 0xbcfb
movq %r12, %rdi
movl %r13d, %esi
callq 0x63b3
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %rcx
movq %rcx, (%r14)
movq %r14, (%rax,%rbp,8)
movl 0x28(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%rbx)
cmpl $0x0, 0x2c(%rbx)
je 0xbd41
movslq 0x1c(%rbx), %rdi
cvtsi2ss %edi, %xmm0
mulss 0x30(%rbx), %xmm0
cvttss2si %xmm0, %ecx
cmpl %ecx, %eax
jl 0xbd41
callq 0xf409
movq %rbx, %rdi
movl %eax, %esi
callq 0xbd53
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashResize
void hashResize(struct hash *hash, int powerOfTwoSize)
/* Resize the hash to a new size */
{
int oldHashSize = hash->size;
struct hashEl **oldTable = hash->table;

if (powerOfTwoSize == 0)
    powerOfTwoSize = 12;
assert(powerOfTwoSize <= hashMaxSize && powerOfTwoSize > 0);
hash->powerOfTwoSize = powerOfTwoSize;
hash->size = (1<<powerOfTwoSize);
hash->mask = hash->size-1;

AllocArray(hash->table, hash->size);

int i;
struct hashEl *hel, *next;
for (i=0; i<oldHashSize; ++i)
    {
    for (hel = oldTable[i]; hel != NULL; hel = next)
	{
	next = hel->next;
	int hashVal = hel->hashVal & hash->mask;
	hel->next = hash->table[hashVal];
	hash->table[hashVal] = hel;
	}
    }
/* restore original list order */
for (i=0; i<hash->size; ++i)
    {
    struct hashEl *hel = hash->table[i];
    if (hel != NULL && hel->next != NULL)	    
	slReverse(&hash->table[i]);
    }
freeMem(oldTable);
hash->numResizes++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
movl $0xc, %ecx
cmovnel %esi, %ecx
cmpl $0x1d, %ecx
jae 0xbe27
movq %rdi, %rbx
movl 0x1c(%rdi), %r15d
movq 0x10(%rdi), %r14
movl %ecx, 0x18(%rdi)
movl $0x1, %edi
shll %cl, %edi
movl %edi, 0x1c(%rbx)
leal -0x1(%rdi), %eax
movl %eax, 0x8(%rbx)
shlq $0x3, %rdi
callq 0xec7f
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0xbdd6
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0xbdce
movslq 0x8(%rbx), %rdx
movq (%rcx), %rsi
movslq 0x18(%rcx), %rdi
andq %rdx, %rdi
movq 0x10(%rbx), %r8
movq (%r8,%rdi,8), %r9
movq %r9, (%rcx)
movq %rcx, (%r8,%rdi,8)
movq %rsi, %rcx
testq %rsi, %rsi
jne 0xbdad
incq %rax
cmpq %r15, %rax
jne 0xbda0
movl 0x1c(%rbx), %eax
testl %eax, %eax
jle 0xbe10
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
movq (%rdi,%r15), %rcx
testq %rcx, %rcx
je 0xbe01
cmpq $0x0, (%rcx)
je 0xbe01
addq %r15, %rdi
callq 0x66bb
movl 0x1c(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x8, %r15
cmpq %rcx, %r12
jl 0xbde3
movq %r14, %rdi
callq 0xeebc
incl 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xdd95(%rip), %rdi      # 0x19bc3
leaq 0xddc2(%rip), %rsi      # 0x19bf7
leaq 0xdde4(%rip), %rcx      # 0x19c20
movl $0x17e, %edx            # imm = 0x17E
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashRemove
void *hashRemove(struct hash *hash, char *name)
/* Remove item of the given name from hash table. 
 * Returns value of removed item, or NULL if not in the table.
 * If their are multiple entries for name, the last one added
 * is removed (LIFO behavior).
 */
{
struct hashEl *hel;
void *ret;
struct hashEl **pBucket = &hash->table[hashString(name)&hash->mask];
for (hel = *pBucket; hel != NULL; hel = hel->next)
    if (sameString(hel->name, name))
        break;
if (hel == NULL)
    return NULL;
ret = hel->val;
if (slRemoveEl(pBucket, hel))
    {
    hash->elCount -= 1;
    if (!hash->lm)
	freeHashEl(hel);
    }
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movb (%rsi), %sil
testb %sil, %sil
je 0xbeba
leaq 0x1(%r14), %rdx
xorl %ecx, %ecx
movsbl %sil, %esi
leal (%rcx,%rcx,8), %ecx
addl %esi, %ecx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0xbea4
jmp 0xbebc
xorl %ecx, %ecx
andl 0x8(%rbx), %ecx
leaq (%rax,%rcx,8), %r13
xorl %r15d, %r15d
movq %r13, %r12
movq (%r12), %r12
testq %r12, %r12
je 0xbf13
movq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x3440
testl %eax, %eax
jne 0xbec9
movq 0x10(%r12), %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0x68cd
testl %eax, %eax
je 0xbf13
decl 0x28(%rbx)
cmpq $0x0, 0x20(%rbx)
jne 0xbf13
movq 0x8(%r12), %rdi
callq 0xeebc
movq %r12, %rdi
callq 0xeebc
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashMustFindVal
void *hashMustFindVal(struct hash *hash, char *name)
/* Lookup name in hash and return val.  Abort if not found. */
{
struct hashEl *hel = hashLookup(hash, name);
if (hel == NULL)
    errAbort("hashMustFindVal: '%s' not found", name);
return hel->val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xbb8c
movq %rax, %r14
testq %rax, %rax
jne 0xc08a
leaq 0xdb02(%rip), %rdi      # 0x19b82
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq 0x10(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashMustFindName
char *hashMustFindName(struct hash *hash, char *name)
/* Return name as stored in hash table (in hel->name). 
 * Abort if not found. */
{
struct hashEl *hel = hashLookup(hash, name);
if (hel == NULL)
    errAbort("hashMustFindName: '%s' not found", name);
return hel->name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xbb8c
movq %rax, %r14
testq %rax, %rax
jne 0xc117
leaq 0xda95(%rip), %rdi      # 0x19ba2
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq 0x8(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/hash.c
// Function: hashIncInt
void hashIncInt(struct hash *hash, char *name)
/* Increment integer value in hash */
{
struct hashEl *hel = hashLookup(hash, name);
if (hel == NULL)
  {
  hashAddInt(hash, name, 1);
  }
else
  {
  hel->val = ((char *)hel->val)+1;
  /* The much simpler ++hel->val works for gnu C, but really adding one to a void pointer
   * I think is not well defined. */
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbb8c
testq %rax, %rax
je 0xc16e
incq 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x3200
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc5c