LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xe1ac(%rip), %rdi      # 0x17930
callq 0x3040
movq %rax, %r14
testq %rax, %rax
je 0x979f
movq %rsp, %rdi
pushq $0x64
popq %rsi
movq %r14, %rdx
callq 0x7259
leaq 0xe18a(%rip), %rdi      # 0x17930
leaq 0xe186(%rip), %rsi      # 0x17933
pushq $0x1
popq %rdx
callq 0x3190
callq 0x34b0
andl $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x3560
movq %rax, %rbx
leaq 0xe160(%rip), %rdi      # 0x17930
testq %r14, %r14
je 0x97e2
movq %rsp, %rsi
pushq $0x1
popq %rdx
callq 0x3190
jmp 0x97e7
callq 0x3680
callq 0x34b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: dateAddTo
char *dateAddTo(char *date,char *format,int addYears,int addMonths,int addDays)
/* Add years,months,days to a formatted date and returns the new date as a cloned string
*  format is a strptime/strftime format: %F = yyyy-mm-dd */
{
char *newDate = needMem(12);
struct tm tp;
if (strptime(date,format, &tp))
    {
    dateAdd(&tp,addYears,addMonths,addDays); // tp.tm_year only contains years since 1900
    strftime(newDate,12,format,&tp);
    }
return cloneString(newDate);  // newDate is never freed!
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
pushq $0xc
popq %rdi
callq 0xd87c
movq %rax, %r14
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x3730
testq %rax, %rax
je 0x9993
movq %r15, 0x8(%rsp)
leaq 0x10(%rsp), %r13
addl 0xc(%r13), %ebx
movl %ebx, 0xc(%r13)
addl 0x10(%r13), %r12d
movl %r12d, 0x10(%r13)
addl 0x14(%r13), %ebp
movl %ebp, 0x14(%r13)
pushq $0x1c
popq %rcx
movl %ebx, %r15d
cmpl $0xb, %r12d
ja 0x990a
testl %r15d, %r15d
jle 0x98ef
cmpl %ecx, %r15d
jle 0x997e
movq %r13, %rdi
callq 0x99aa
movl %ebx, %r15d
subl %eax, %r15d
jg 0x9921
movl %eax, %ecx
movl %ebx, %r15d
testl %ebx, %ebx
jg 0x98db
jmp 0x9961
jle 0x993d
movl %r12d, %eax
xorl %edx, %edx
pushq $0xc
popq %rsi
divl %esi
addl %eax, %ebp
movl %ebp, 0x24(%rsp)
movl %edx, %r12d
jmp 0x9957
movl %r15d, 0x1c(%rsp)
incl %r12d
movl %r12d, 0x20(%rsp)
movq %r13, %rdi
callq 0x99aa
movl %eax, %ecx
movl %r15d, %ebx
jmp 0x98db
negl %r12d
movl %r12d, %eax
xorl %edx, %edx
pushq $0xc
popq %r12
divl %r12d
notl %eax
addl %eax, %ebp
movl %ebp, 0x24(%rsp)
subl %edx, %r12d
movl %r12d, 0x20(%rsp)
jmp 0x98db
decl %r12d
movl %r12d, 0x20(%rsp)
movq %r13, %rdi
callq 0x99aa
movl %eax, %ecx
addl %eax, %ebx
movl %ebx, 0x1c(%rsp)
jmp 0x98d8
pushq $0xc
popq %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rdx
callq 0x35c0
movq %r14, %rdi
callq 0x5ede
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/common.c
// Function: daysOfMonth
static int daysOfMonth(struct tm *tp)
/* Returns the days of the month given the year */
{
int days=0;
switch(tp->tm_mon)
    {
    case 3:
    case 5:
    case 8:
    case 10:    days = 30;
                break;
    case 1:     days = 28;
                if ( (tp->tm_year % 4) == 0
                &&  ((tp->tm_year % 20) != 0 || (tp->tm_year % 100) == 0) )
                    days = 29;
                break;
    default:    days = 31;
                break;
    }
return days;
}

// Assembly:
movl 0x10(%rdi), %eax
cmpl $0xa, %eax
ja 0x99d1
movl $0x528, %ecx            # imm = 0x528
btl %eax, %ecx
jae 0x99c0
pushq $0x1e
popq %rax
retq
cmpl $0x1, %eax
jne 0x99d1
movl 0x14(%rdi), %ecx
testb $0x3, %cl
je 0x99d5
pushq $0x1c
jmp 0x99be
pushq $0x1f
jmp 0x99be
pushq $0x14
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
testl %edx, %edx
setne %sil
pushq $0x64
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
testl %edx, %edx
sete %al
orb %sil, %al
movzbl %al, %eax
orl $0x1c, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
leaq 0x8(%rax), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r14
testq %r14, %r14
je 0x9a3f
callq 0xd8f9
movq %r14, %rdi
jmp 0x9a2d
leaq 0x8(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9a71
callq 0x9a23
movq %rbx, %rdi
popq %rbx
jmp 0xd909
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x9aa5
movq %rdi, %rbx
movq (%r14), %r14
cmpq $0x0, (%r14)
je 0x9a96
movq 0x10(%r14), %rdi
callq 0xd8f9
jmp 0x9a82
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9a57
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
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_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
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_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
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_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
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_O2/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 0x9c56
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_O2/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 0x9c7a
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0xd8f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
callq 0x9c7b
cmpl $0x2, %eax
jl 0x9cc9
movl %eax, %r14d
leaq (,%r14,8), %rdi
callq 0xd684
movq %rax, %r15
xorl %eax, %eax
movq %rbx, %rcx
cmpq %rax, %r14
je 0x9cd5
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x9cb8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, 0x1cb7c(%rip)     # 0x26858
leaq 0x52(%rip), %rcx        # 0x9d35
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3120
leaq 0x8(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
xorl %eax, %eax
cmpq %rax, %r14
je 0x9d22
movq (%r15,%rax,8), %rcx
movq (%rbx), %rdx
movq %rcx, (%rbx)
movq %rbx, 0x8(%rcx)
movq %rdx, (%rcx)
movq %rcx, 0x8(%rdx)
incq %rax
jmp 0x9d03
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd8f9
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xd87c
movq %rax, %r14
testl %ebx, %ebx
movl $0x200, %r15d           # imm = 0x200
cmovnel %ebx, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0xd87c
movq %rax, 0x8(%r14)
movl %r15d, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e61
movq 0x8(%rax), %rbx
callq 0xd909
movq %rbx, %rax
popq %rbx
retq
leaq 0xdae0(%rip), %rdi      # 0x17948
leaq 0xdae4(%rip), %rsi      # 0x17953
leaq 0xdae8(%rip), %rcx      # 0x1795e
pushq $0x28
popq %rdx
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x9ea9
movq (%r15), %r15
movq %r14, %rdi
callq 0x9e2b
jmp 0x9e92
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f30
cvtsi2sd %r12d, %xmm0
mulsd 0xda25(%rip), %xmm0     # 0x17940
cvttsd2si %xmm0, %esi
leal (%r12,%r13), %eax
cmpl %esi, %eax
cmovgl %eax, %esi
movq %rbx, %rdi
callq 0x9ebd
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_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %esi
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jl 0x9f83
addl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x9ebd
movl 0x14(%r14), %eax
movq 0x8(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x14(%r14)
cltq
movb %bl, (%rcx,%rax)
movb $0x0, 0x1(%rcx,%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9fcf
leal (%r12,%r15), %esi
movq %rbx, %rdi
callq 0x9ebd
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_O2/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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movsbl %cl, %ebp
movb (%r14), %r12b
testb %r12b, %r12b
je 0xa05f
cmpb %bl, %r12b
jne 0xa04e
movq %r15, %rdi
movl %ebp, %esi
callq 0x9f5e
incq %r14
movsbl %r12b, %esi
movq %r15, %rdi
callq 0x9f5e
jmp 0xa037
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %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)
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, %ebp
subl %eax, %ebp
jg 0xa0af
addl %esi, %esi
movq %rbx, %rdi
callq 0x9ebd
movl 0x10(%rbx), %ebp
movl 0x14(%rbx), %eax
subl %eax, %ebp
movslq %eax, %rdi
addq 0x8(%rbx), %rdi
movslq %ebp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3170
testl %eax, %eax
js 0xa0cc
cmpl %ebp, %eax
jl 0xa0db
movl 0x10(%rbx), %esi
addl %esi, %esi
movq %rbx, %rdi
callq 0x9ebd
jmp 0xa080
addl %eax, 0x14(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
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 0xa1d2
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
leal (%rax,%rax,2), %edi
callq 0x9df0
movq %rax, %r14
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa068
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbp
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x3200
movq %rax, %rbx
movq %r14, %r15
movq %r14, %rdi
callq 0x3200
movq %rax, %r13
movq %rbp, %rdi
callq 0x3200
movq %rax, %r14
leal (%rax,%r13,2), %edi
callq 0x9df0
testq %rbp, %rbp
je 0xa2c8
movq %rax, %r12
movq %r14, (%rsp)
movslq %ebx, %r14
movq %rbp, 0x8(%rsp)
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x3760
testq %rax, %rax
je 0xa2b1
movq %rax, %rbx
movl %ebx, %edx
subl %ebp, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x9eec
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x9eec
addq %r14, %rbx
movq %rbx, %rbp
jmp 0xa277
movq 0x8(%rsp), %rdx
addl (%rsp), %edx
subl %ebp, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x9eec
jmp 0xa2cb
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x14(%rdi), %esi
cmpl %ebx, %esi
jge 0xa315
cmpl %ebx, 0x10(%r14)
jge 0xa2fe
addl %ebx, %esi
movq %r14, %rdi
callq 0x9ebd
movslq %ebx, %r15
movq 0x8(%r14), %rdi
addq %r15, %rdi
pushq $0x20
popq %rsi
movq %r15, %rdx
callq 0x3300
jmp 0xa318
movslq %ebx, %r15
movq 0x8(%r14), %rax
movb $0x0, (%rax,%r15)
movl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x5c
popq %r15
movl %ebp, %r12d
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x9f5e
movb (%r14), %r12b
testb %r12b, %r12b
je 0xa36b
incq %r14
cmpb %bpl, %r12b
jne 0xa342
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9f5e
jmp 0xa342
movsbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9f5e
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa49a
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 0x9df0
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x9ffe
leaq 0xd4a8(%rip), %rsi      # 0x1798c
movq %r15, %rdi
callq 0x9ffe
movq %r12, %rdi
callq 0x9e4a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa380
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa920
movslq 0xa8(%rax), %rcx
cmpq $0x13, %rcx
jge 0xa5fb
leaq 0x1(%rcx), %rdx
movl %edx, 0xa8(%rax)
movq %rbx, 0x10(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xa60e
leaq 0xd3cd(%rip), %rdi      # 0x179d4
xorl %eax, %eax
callq 0x1013e
leaq 0xd3d8(%rip), %rdi      # 0x179ed
pushq $0x13
popq %rsi
xorl %eax, %eax
callq 0xa61f
// File: /workspace/github_c_makefile_star2_O2/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 0xa920
movl 0xa8(%rax), %ecx
testl %ecx, %ecx
jle 0xa6b9
decl %ecx
movl %ecx, 0xa8(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xa6cc
leaq 0xd357(%rip), %rdi      # 0x17a1c
xorl %eax, %eax
callq 0x1013e
leaq 0xd362(%rip), %rdi      # 0x17a35
xorl %eax, %eax
callq 0xa61f
// File: /workspace/github_c_makefile_star2_O2/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 0xa920
movslq 0x110(%rax), %rcx
cmpq $0xb, %rcx
jge 0xa804
leaq 0x1(%rcx), %rdx
movl %edx, 0x110(%rax)
movq %rbx, 0xb8(%rax,%rcx,8)
popq %rbx
retq
cmpl $0x0, (%rax)
je 0xa817
leaq 0xd23d(%rip), %rdi      # 0x17a4d
xorl %eax, %eax
callq 0x1013e
leaq 0xd249(%rip), %rdi      # 0x17a67
pushq $0xb
popq %rsi
xorl %eax, %eax
callq 0xa61f
// File: /workspace/github_c_makefile_star2_O2/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 0xa920
movl 0x110(%rax), %ecx
testl %ecx, %ecx
jle 0xa842
decl %ecx
movl %ecx, 0x110(%rax)
popq %rax
retq
cmpl $0x0, (%rax)
je 0xa855
leaq 0xd248(%rip), %rdi      # 0x17a96
xorl %eax, %eax
callq 0x1013e
leaq 0xd254(%rip), %rdi      # 0x17ab0
xorl %eax, %eax
callq 0xa61f
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/errabort.c
// Function: defaultVaWarn
static void defaultVaWarn(char *format, va_list args)
/* Default error message handler. */
{
if (format != NULL) {
    fflush(stdout);
    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");
    }
}

// Assembly:
testq %rdi, %rdi
jne 0xa8e1
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b6d5(%rip), %rax     # 0x25fc8
movq (%rax), %rdi
callq 0x3520
movq 0x1b6f6(%rip), %r15     # 0x25ff8
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3670
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x33a0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq %rsi, %rdi
callq 0xaa78
andl 0x8(%r14), %eax
leaq (%r15,%rax,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xaadb
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3440
testl %eax, %eax
jne 0xaac3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab83
pushq $0x20
popq %rsi
callq 0xd418
jmp 0xab8b
pushq $0x20
popq %rdi
callq 0xd87c
movq %rax, %r14
movq %r12, %rdi
callq 0xaa78
movl %eax, 0x18(%r14)
andl 0x8(%rbx), %eax
movslq %eax, %rbp
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xabc9
leal 0x1(%r13), %eax
movslq %eax, %rsi
callq 0xd418
movq %rax, 0x8(%r14)
movslq %r13d, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x34a0
jmp 0xabd8
movq %r12, %rdi
movl %r13d, %esi
callq 0x5e7b
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 0xac1e
movslq 0x1c(%rbx), %rdi
cvtsi2ss %edi, %xmm0
mulss 0x30(%rbx), %xmm0
cvttss2si %xmm0, %ecx
cmpl %ecx, %eax
jl 0xac1e
callq 0xde04
movq %rbx, %rdi
movl %eax, %esi
callq 0xac30
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/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
pushq $0xc
popq %rcx
cmovnel %esi, %ecx
cmpl $0x1d, %ecx
jae 0xacf8
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movl 0x1c(%rdi), %r15d
movl %ecx, 0x18(%rdi)
pushq $0x1
popq %rdi
shll %cl, %edi
movl %edi, 0x1c(%rbx)
leal -0x1(%rdi), %eax
movl %eax, 0x8(%rbx)
shlq $0x3, %rdi
callq 0xd6eb
movq %rax, 0x10(%rbx)
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %r15, %rax
je 0xacae
movq (%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0xaca9
movq (%rcx), %rdx
movl 0x8(%rbx), %esi
andl 0x18(%rcx), %esi
movslq %esi, %rsi
movq 0x10(%rbx), %rdi
movq (%rdi,%rsi,8), %r8
movq %r8, (%rcx)
movq %rcx, (%rdi,%rsi,8)
movq %rdx, %rcx
jmp 0xac84
incq %rax
jmp 0xac7b
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jge 0xace1
movq 0x10(%rbx), %rdi
movq (%rdi,%r15), %rax
testq %rax, %rax
je 0xacd8
cmpq $0x0, (%rax)
je 0xacd8
addq %r15, %rdi
callq 0x613f
incq %r12
addq $0x8, %r15
jmp 0xacb4
movq %r14, %rdi
callq 0xd8f9
incl 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xcec4(%rip), %rdi      # 0x17bc3
leaq 0xcef1(%rip), %rsi      # 0x17bf7
leaq 0xcf13(%rip), %rcx      # 0x17c20
movl $0x17e, %edx            # imm = 0x17E
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rdi, %r14
movq 0x10(%rdi), %rbx
movq %rsi, %rdi
callq 0xaa78
andl 0x8(%r14), %eax
leaq (%rbx,%rax,8), %r13
xorl %ebx, %ebx
movq %r13, %r15
movq (%r15), %r15
testq %r15, %r15
je 0xadba
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x3440
testl %eax, %eax
jne 0xad7c
movq 0x10(%r15), %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x6326
testl %eax, %eax
je 0xadba
decl 0x28(%r14)
cmpq $0x0, 0x20(%r14)
jne 0xadba
movq %r15, %rdi
callq 0xade9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaaa4
movq %rax, %r14
testq %rax, %rax
jne 0xaee6
leaq 0xcca6(%rip), %rdi      # 0x17b82
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x10(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaaa4
movq %rax, %r14
testq %rax, %rax
jne 0xaf73
leaq 0xcc39(%rip), %rdi      # 0x17ba2
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x8(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaaa4
testq %rax, %rax
je 0xafa7
incq 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xad17
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashIntSum
long long hashIntSum(struct hash *hash)
/* Return sum of all the ints in a hash of ints. */
{
long long sum = 0;
int i;
struct hashEl *hel;
for (i=0; i<hash->size; ++i)
    {
    for (hel = hash->table[i]; hel != NULL; hel = hel->next)
	{
	int num = ptToInt(hel->val);
	sum += (long long)num;
	}
    }
return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jge 0xb001
leaq (,%r15,8), %r12
addq 0x10(%rbx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xaffc
movq 0x10(%r12), %rdi
callq 0xe32e
cltq
addq %rax, %r14
jmp 0xafe2
incq %r15
jmp 0xafcd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: newHashExt
struct hash *newHashExt(int powerOfTwoSize, boolean useLocalMem)
/* Returns new hash table. Uses local memory optionally. */
{
struct hash *hash = needMem(sizeof(*hash));
int memBlockPower = 16;
if (powerOfTwoSize == 0)
    powerOfTwoSize = 12;
assert(powerOfTwoSize <= hashMaxSize && powerOfTwoSize > 0);
hash->powerOfTwoSize = powerOfTwoSize;
hash->size = (1<<powerOfTwoSize);
/* Make size of memory block for allocator vary between
 * 256 bytes and 64k depending on size of table. */
if (powerOfTwoSize < 8)
    memBlockPower = 8;
else if (powerOfTwoSize < 16)
    memBlockPower = powerOfTwoSize;
if (useLocalMem) 
    hash->lm = lmInit(1<<memBlockPower);
hash->mask = hash->size-1;
AllocArray(hash->table, hash->size);
hash->autoExpand = TRUE;
hash->expansionFactor = defaultExpansionFactor;   /* Expand when elCount > size*expansionFactor */
return hash;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x38
popq %rdi
callq 0xd87c
testl %r14d, %r14d
pushq $0xc
popq %rcx
cmovnel %r14d, %ecx
cmpl $0x1d, %ecx
jae 0xb090
movq %rax, %rbx
pushq $0x1
popq %rdi
movl %edi, %eax
shll %cl, %eax
movl %ecx, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
testl %ebp, %ebp
je 0xb064
cmpl $0x10, %ecx
pushq $0x10
popq %rax
cmovbl %ecx, %eax
cmpl $0x9, %eax
pushq $0x8
popq %rcx
cmovael %eax, %ecx
shll %cl, %edi
callq 0xd324
movq %rax, 0x20(%rbx)
movl 0x1c(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xd6eb
movq %rax, 0x10(%rbx)
movabsq $0x3f80000000000001, %rax # imm = 0x3F80000000000001
movq %rax, 0x2c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xcb2c(%rip), %rdi      # 0x17bc3
leaq 0xcb59(%rip), %rsi      # 0x17bf7
leaq 0xcb59(%rip), %rcx      # 0x17bfe
movl $0x164, %edx            # imm = 0x164
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashFromSlNameList
struct hash *hashFromSlNameList(void *list)
/* Create a hash out of a list of slNames or any kind of list where the */
/* first field is the next pointer and the second is the name. */
{
struct hash *hash = NULL;
struct slName *namedList = list, *item;
if (!list)
    return NULL;
hash = newHash(0);
for (item = namedList; item != NULL; item = item->next)
    hashAdd(hash, item->name, item);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb0e1
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0xb010
movq %rax, %r14
testq %rbx, %rbx
je 0xb0e4
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xad17
movq (%rbx), %rbx
jmp 0xb0c8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashTraverseEls
void hashTraverseEls(struct hash *hash, void (*func)(struct hashEl *hel))
/* Apply func to every element of hash with hashEl as parameter. */
{
int i;
struct hashEl *hel;
for (i=0; i<hash->size; ++i)
    {
    for (hel = hash->table[i]; hel != NULL; hel = hel->next)
	func(hel);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movslq 0x1c(%r14), %rax
cmpq %rax, %r12
jge 0xb129
leaq (,%r12,8), %r15
addq 0x10(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xb124
movq %r15, %rdi
callq *%rbx
jmp 0xb115
incq %r12
jmp 0xb100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashTraverseVals
void hashTraverseVals(struct hash *hash, void (*func)(void *val))
/* Apply func to every element of hash with hashEl->val as parameter. */
{
int i;
struct hashEl *hel;
for (i=0; i<hash->size; ++i)
    {
    for (hel = hash->table[i]; hel != NULL; hel = hel->next)
	func(hel->val);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x1c(%r14), %rax
cmpq %rax, %r15
jge 0xb172
leaq (,%r15,8), %r12
addq 0x10(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xb16d
movq 0x10(%r12), %rdi
callq *%rbx
jmp 0xb15b
incq %r15
jmp 0xb146
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashElFindVal
void *hashElFindVal(struct hashEl *list, char *name)
/* Look up name in hashEl list and return val or NULL if not found. */
{
struct hashEl *el;
for (el = list; el != NULL; el = el->next)
    {
    if (strcmp(el->name, name) == 0)
        return el->val;
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0xb1cf
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3440
testl %eax, %eax
je 0xb1cb
movq (%r14), %r14
jmp 0xb1b1
movq 0x10(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashElListHash
struct hashEl *hashElListHash(struct hash *hash)
/* Return a list of all elements of hash.   Free return with hashElFreeList. */
{
int i;
struct hashEl *hel, *dupe, *list = NULL;
for (i=0; i<hash->size; ++i)
    {
    for (hel = hash->table[i]; hel != NULL; hel = hel->next)
	{
	dupe = CloneVar(hel);
	slAddHead(&list, dupe);
	}
    }
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r13d, %r13d
pushq $0x20
popq %r14
xorl %r15d, %r15d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r13
jge 0xb224
leaq (,%r13,8), %r12
addq 0x10(%rbx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xb21f
movq %r12, %rdi
movq %r14, %rsi
callq 0x5e54
movq %r15, (%rax)
movq %rax, %r15
jmp 0xb203
incq %r13
jmp 0xb1ee
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashFirst
struct hashCookie hashFirst(struct hash *hash)
/* Return an object to use by hashNext() to traverse the hash table.
 * The first call to hashNext will return the first entry in the table. */
{
struct hashCookie cookie;
cookie.hash = hash;
cookie.idx = 0;
cookie.nextEl = NULL;

/* find first entry */
for (cookie.idx = 0;
     (cookie.idx < hash->size) && (hash->table[cookie.idx] == NULL);
     cookie.idx++)
    continue;  /* empty body */
if (cookie.idx < hash->size)
    cookie.nextEl = hash->table[cookie.idx];
return cookie;
}

// Assembly:
movq %rdi, %rax
movq %rsi, (%rdi)
andq $0x0, 0x10(%rdi)
movl 0x1c(%rsi), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
cmpq %rcx, %rdx
je 0xb265
movq 0x10(%rsi), %rdi
cmpq $0x0, (%rdi,%rcx,8)
jne 0xb269
incq %rcx
jmp 0xb250
movl %edx, 0x8(%rax)
retq
movl %ecx, 0x8(%rax)
movq (%rdi,%rcx,8), %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/hash.c
// Function: hashNext
struct hashEl* hashNext(struct hashCookie *cookie)
/* Return the next entry in the hash table, or NULL if no more. Do not modify
 * hash table while this is being used. */
{
/* NOTE: if hashRemove were coded to track the previous entry during the
 * search and then use it to do the remove, it would be possible to
 * remove the entry returned by this method */
struct hashEl *retEl = cookie->nextEl;
if (retEl == NULL)
    return NULL;  /* no more */

/* find next entry */
cookie->nextEl = retEl->next;
if (cookie->nextEl == NULL)
    {
    for (cookie->idx++; (cookie->idx < cookie->hash->size)
             && (cookie->hash->table[cookie->idx] == NULL); cookie->idx++)
        continue;  /* empty body */
    if (cookie->idx < cookie->hash->size)
        cookie->nextEl = cookie->hash->table[cookie->idx];
    }
return retEl;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xb28a
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
testq %rcx, %rcx
je 0xb28b
retq
movslq 0x8(%rdi), %rcx
movq (%rdi), %rsi
movslq 0x1c(%rsi), %r8
movq %rcx, %rdx
shlq $0x20, %rdx
movq %rcx, %r9
incq %r9
movabsq $0x100000000, %r10      # imm = 0x100000000
cmpq %r8, %r9
jge 0xb2d6
movq 0x10(%rsi), %r11
incl %ecx
addq %r10, %rdx
cmpq $0x0, (%r11,%r9,8)
leaq 0x1(%r9), %r9
je 0xb2ad
movl %ecx, 0x8(%rdi)
sarq $0x1d, %rdx
movq (%r11,%rdx), %rcx
movq %rcx, 0x10(%rdi)
retq
incl %ecx
movl %ecx, 0x8(%rdi)
retq