LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/localmem.c
// Function: lmAllocMoreMem
void *lmAllocMoreMem(struct lm *lm, void *pt, size_t oldSize, size_t newSize)
/* Adjust memory size on a block, possibly relocating it.  If block is grown,
 * new memory is zeroed. */
{
struct lmBlock *mb = lm->blocks;
// rare case that pointer is to last lm alloc, but still try.
// Note this is the one place where the pointer gets reused and it is known to be in this lm
if ((char *)pt + oldSize == mb->free
&&  (char *)pt + newSize <= mb->end)
    {
    if (newSize > oldSize) // only move the free pointer on more mem
        mb->free = pt + newSize;
    return pt;
    }
void *new = lmAlloc(lm, newSize);
memcpy(new, pt, oldSize);
return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %rax
addq %rsi, %rdx
cmpq 0x8(%rax), %rdx
jne 0xd48c
leaq (%rbx,%rcx), %rdx
cmpq 0x10(%rax), %rdx
jbe 0xd4a9
movq %rcx, %rsi
callq 0xd418
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34a0
cmpq %r14, %rcx
jbe 0xd4b2
movq %rdx, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/localmem.c
// Function: lmCloneFirstWord
char *lmCloneFirstWord(struct lm *lm, char *line)
/* Clone first word in line */
{
char *startFirstWord = skipLeadingSpaces(line);
if (startFirstWord == NULL)
    return NULL;
char *endFirstWord = skipToSpaces(startFirstWord);
if (endFirstWord == NULL)
    return lmCloneString(lm, startFirstWord);
else
    return lmCloneStringZ(lm, startFirstWord, endFirstWord - startFirstWord);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x722d
testq %rax, %rax
je 0xd580
movq %rax, %r14
movq %rax, %rdi
callq 0x827c
testq %rax, %rax
je 0xd58a
subl %r14d, %eax
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd517
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/localmem.c
// Function: lmCloneSomeWord
char *lmCloneSomeWord(struct lm *lm, char *line, int wordIx)
/* Return a clone of the given space-delimited word within line.  Returns NULL if
 * not that many words in line. */
{
if (wordIx < 0)
    return NULL;
int i;
for (i=0; i<wordIx; ++i)
    {
    line = skipLeadingSpaces(line);
    line = skipToSpaces(line);
    if (line == NULL)
        return NULL;
    }
return lmCloneFirstWord(lm, line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0xd5c7
movl %edx, %ebx
movq %rsi, %rax
movq %rdi, %r14
incl %ebx
decl %ebx
je 0xd5d1
movq %rax, %rdi
callq 0x722d
movq %rax, %rdi
callq 0x827c
testq %rax, %rax
jne 0xd5ae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd545
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/localmem.c
// Function: lmSlName
struct slName *lmSlName(struct lm *lm, char *name)
/* Return slName in memory. */
{
struct slName *n;
int size = sizeof(*n) + strlen(name) + 1;
n = lmAlloc(lm, size);
strcpy(n->name, name);
return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3200
addl $0x11, %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0xd418
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x30e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: popMemHandler
struct memHandler *popMemHandler()
/* Removes top element from memHandler stack and returns it. */
{
struct memHandler *oldHandler = mhStack;
if (mhStack == &defaultMemHandler)
    errAbort("Too many popMemHandlers()");
mhStack = mhStack->next;
return oldHandler;
}

// Assembly:
pushq %rbx
movq 0x18f0e(%rip), %rbx     # 0x26548
leaq 0x18f0f(%rip), %rcx     # 0x26550
movq %rbx, %rax
cmpq %rcx, %rbx
jne 0xd65e
leaq 0xae07(%rip), %rdi      # 0x18457
xorl %eax, %eax
callq 0xa61f
movq 0x18eea(%rip), %rax     # 0x26548
movq (%rax), %rax
movq %rax, 0x18ee0(%rip)     # 0x26548
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needLargeMem
void *needLargeMem(size_t size)
/* This calls abort if the memory allocation fails. The memory is
 * not initialized to zero. */
{
void *pt;
if (size == 0 || size >= maxAlloc)
    errAbort("needLargeMem: trying to allocate %llu bytes (limit: %llu)",
         (unsigned long long)size, (unsigned long long)maxAlloc);
if ((pt = mhStack->alloc(size)) == NULL)
    errAbort("needLargeMem: Out of memory - request size %llu bytes, errno: %d\n",
             (unsigned long long)size, errno);
return pt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
movq 0x18ed8(%rip), %rdx     # 0x26570
cmpq %rdi, %rdx
seta %cl
testb %cl, %al
jne 0xd6b3
leaq 0xadc8(%rip), %rdi      # 0x18471
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x18e8e(%rip), %rax     # 0x26548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xd6e0
callq 0x30c0
movl (%rax), %edx
leaq 0xadd5(%rip), %rdi      # 0x184ab
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needLargeMemResize
void *needLargeMemResize(void* vp, size_t size)
/* Adjust memory size on a block, possibly relocating it.  If vp is NULL,
 * a new memory block is allocated.  Memory not initted. */
{
void *pt;
if (size == 0 || size >= maxAlloc)
    errAbort("needLargeMemResize: trying to allocate %llu bytes (limit: %llu)",
         (unsigned long long)size, (unsigned long long)maxAlloc);
if ((pt = mhStack->realloc(vp, size)) == NULL)
    errAbort("needLargeMemResize: Out of memory - request size %llu bytes, errno: %d\n",
             (unsigned long long)size, errno);
return pt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
setne %al
movq 0x18e57(%rip), %rdx     # 0x26570
cmpq %rsi, %rdx
seta %cl
testb %cl, %al
jne 0xd734
leaq 0xadc3(%rip), %rdi      # 0x184ed
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x18e0d(%rip), %rax     # 0x26548
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xd764
callq 0x30c0
movl (%rax), %edx
leaq 0xadd3(%rip), %rdi      # 0x1852d
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needLargeZeroedMemResize
void *needLargeZeroedMemResize(void* vp, size_t oldSize, size_t newSize)
/* Adjust memory size on a block, possibly relocating it.  If vp is NULL, a
 * new memory block is allocated.  If block is grown, new memory is zeroed. */
{
void *v = needLargeMemResize(vp, newSize);
if (newSize > oldSize)
    memset(((char*)v)+oldSize, 0, newSize-oldSize);
return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdx, %rsi
callq 0xd702
movq %rax, %r14
subq %r15, %rbx
jbe 0xd79a
movq %r14, %rdi
addq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3300
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needHugeMem
void *needHugeMem(size_t size)
/* No checking on size.  Memory not initted. */
{
void *pt;
if (size == 0)
    errAbort("needHugeMem: trying to allocate 0 bytes");
if ((pt = mhStack->alloc(size)) == NULL)
    errAbort("needHugeMem: Out of huge memory - request size %llu bytes, errno: %d\n",
             (unsigned long long)size, errno);
return pt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0xd7bd
leaq 0xadbf(%rip), %rdi      # 0x18575
xorl %eax, %eax
callq 0xa61f
movq 0x18d84(%rip), %rax     # 0x26548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xd7ea
callq 0x30c0
movl (%rax), %edx
leaq 0xadbd(%rip), %rdi      # 0x1859d
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needHugeMemResize
void *needHugeMemResize(void* vp, size_t size)
/* Adjust memory size on a block, possibly relocating it.  If vp is NULL,
 * a new memory block is allocated.  No checking on size.  Memory not
 * initted. */
{
void *pt;
if ((pt = mhStack->realloc(vp, size)) == NULL)
    errAbort("needHugeMemResize: Out of memory - request resize %llu bytes, errno: %d\n",
	(unsigned long long)size, errno);
return pt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18d2e(%rip), %rax     # 0x26548
callq *0x18(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xd83d
callq 0x30c0
movl (%rax), %edx
leaq 0xadb0(%rip), %rdi      # 0x185e3
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needHugeZeroedMemResize
void *needHugeZeroedMemResize(void* vp, size_t oldSize, size_t newSize)
/* Adjust memory size on a block, possibly relocating it.  If vp is NULL, a
 * new memory block is allocated.  No checking on size.  If block is grown,
 * new memory is zeroed. */
{
void *v;
v = needHugeMemResize(vp, newSize);
if (newSize > oldSize)
    memset(((char*)v)+oldSize, 0, newSize-oldSize);
return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdx, %rsi
callq 0xd80c
movq %rax, %r14
subq %r15, %rbx
jbe 0xd873
movq %r14, %rdi
addq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3300
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: needMem
void *needMem(size_t size)
/* Need mem calls abort if the memory allocation fails. The memory
 * is initialized to zero. */
{
void *pt;
if (size == 0 || size > NEEDMEM_LIMIT)
    errAbort("needMem: trying to allocate %llu bytes (limit: %llu)",
         (unsigned long long)size, (unsigned long long)NEEDMEM_LIMIT);
if ((pt = mhStack->alloc(size)) == NULL)
    errAbort("needMem: Out of memory - request size %llu bytes, errno: %d\n",
             (unsigned long long)size, errno);
memset(pt, 0, size);
return pt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0x1dcd6501, %rax      # imm = 0xE2329AFF
leaq (%rdi,%rax), %rcx
cmpq %rax, %rcx
ja 0xd8a9
leaq 0xad92(%rip), %rdi      # 0x1862c
movl $0x1dcd6500, %edx       # imm = 0x1DCD6500
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x18c98(%rip), %rax     # 0x26548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xd8d6
callq 0x30c0
movl (%rax), %edx
leaq 0xad95(%rip), %rdi      # 0x18661
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: freez
void freez(void *vpt)
/* Pass address of pointer.  Will free pointer and set it 
 * to NULL. */
{
void **ppt = (void **)vpt;
void *pt = *ppt;
*ppt = NULL;
freeMem(pt);
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
andq $0x0, (%rax)
testq %rdi, %rdi
je 0xd922
movq 0x18c29(%rip), %rax     # 0x26548
jmpq *0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: carefulCheckHeap
void carefulCheckHeap()
/* Walk through allocated memory and make sure that all cookies are
 * in place. */
{
int maxPieces = 10000000;    /* Assume no more than this many pieces allocated. */
struct carefulMemBlock *cmb;
char *pEndCookie;
size_t size;

if (carefulParent == NULL)
    return;

for (cmb = (struct carefulMemBlock *)(cmbAllocedList->head); cmb->next != NULL; cmb = cmb->next)
    {
    size = cmb->size;
    pEndCookie = (((char *)(cmb+1)) + size);
    if (cmb->startCookie != cmbStartCookie)
        errAbort("Bad start cookie %x checking %llx\n", cmb->startCookie,
                 ptrToLL(cmb+1));
    if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
        errAbort("Bad end cookie %x%x%x%x checking %llx\n", 
                 pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
                 ptrToLL(cmb+1));
    if (--maxPieces == 0)
        errAbort("Loop or more than 10000000 pieces in memory list");
    }
}

// Assembly:
cmpq $0x0, 0x18fa5(%rip)     # 0x268d0
je 0xd9da
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xff676981, %ebp       # imm = 0xFF676981
movq 0x18f90(%rip), %r12     # 0x268d8
leaq 0xad99(%rip), %rbx      # 0x186e8
leaq 0xad6b(%rip), %r14      # 0x186c1
leaq 0xad41(%rip), %r15      # 0x1869e
movq (%r12), %r12
cmpq $0x0, (%r12)
je 0xd9cc
movslq 0x10(%r12), %r13
movl 0x14(%r12), %esi
cmpl 0x18c00(%rip), %esi     # 0x26578
je 0xd989
leaq 0x1(%r12), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0xa61f
leaq (%r12,%r13), %rax
addq $0x18, %rax
movl (%rax), %ecx
cmpl 0x18be3(%rip), %ecx     # 0x2657c
je 0xd9ba
movsbl (%rax), %esi
movsbl 0x1(%rax), %edx
movsbl 0x2(%rax), %ecx
movsbl 0x3(%rax), %r8d
leaq 0x1(%r12), %r9
movq %r14, %rdi
xorl %eax, %eax
callq 0xa61f
testl %ebp, %ebp
jne 0xd9c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa61f
incl %ebp
jmp 0xd95d
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/memalloc.c
// Function: memTrackerStart
void memTrackerStart()
/* Push memory handler that will track blocks allocated so that
 * they can be automatically released with memTrackerEnd().  You
 * can have memTrackerStart one after the other, but memTrackerStart/End
 * need to nest. */
{
struct memTracker *mt;

if (memTracker != NULL)
     errAbort("multiple memTrackerStart calls");
AllocVar(mt);
AllocVar(mt->handler);
mt->handler->alloc = memTrackerAlloc;
mt->handler->free = memTrackerFree;
mt->handler->realloc = memTrackerRealloc;
mt->list = dlListNew();
mt->parent = pushMemHandler(mt->handler);
memTracker = mt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x18ea4(%rip)     # 0x268e8
je 0xda54
leaq 0xaccc(%rip), %rdi      # 0x18719
xorl %eax, %eax
callq 0xa61f
pushq $0x20
popq %rbx
movq %rbx, %rdi
callq 0xd87c
movq %rax, %r14
movq %rbx, %rdi
callq 0xd87c
movq %rax, 0x18(%r14)
leaq 0x4d(%rip), %rcx        # 0xdac2
movq %rcx, 0x8(%rax)
leaq 0x7d(%rip), %rcx        # 0xdafd
movq %rcx, 0x10(%rax)
leaq 0x94(%rip), %rcx        # 0xdb1f
movq %rcx, 0x18(%rax)
xorl %eax, %eax
callq 0x9a0d
movq %rax, 0x8(%r14)
movq 0x18(%r14), %rax
movq 0x18aa3(%rip), %rcx     # 0x26548
movq %rcx, (%rax)
movq %rax, 0x18a99(%rip)     # 0x26548
movq %rcx, 0x10(%r14)
movq %r14, 0x18e2e(%rip)     # 0x268e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: memTrackerAlloc
static void *memTrackerAlloc(size_t size)
/* Allocate extra memory for cookies and list node, and then
 * return memory block. */
{
struct dlNode *node;

size += sizeof (*node);
node = memTracker->parent->alloc(size);
if (node == NULL)
    return node;
dlAddTail(memTracker->list, node);
return (void*)(node+1);
}

// Assembly:
pushq %rbx
addq $0x18, %rdi
movq 0x18e1a(%rip), %rax     # 0x268e8
movq 0x10(%rax), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xdaf6
movq %rax, %rbx
movq 0x18e04(%rip), %rax     # 0x268e8
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x9af7
addq $0x18, %rbx
jmp 0xdaf8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: memTrackerRealloc
static void *memTrackerRealloc(void *vpt, size_t size)
/* Resize a memory block from memTrackerAlloc. */
{
if (vpt == NULL)
    return memTrackerAlloc(size);
else
    {
    struct dlNode *node = ((struct dlNode *)vpt)-1;
    size += sizeof(*node);
    dlRemove(node);
    node = memTracker->parent->realloc(node, size);
    if (node == NULL)
        return node;
    dlAddTail(memTracker->list, node);
    return (void*)(node+1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xdb73
movq %rdi, %r14
addq $-0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
callq 0x9bd2
movq 0x18da3(%rip), %rax     # 0x268e8
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
testq %rax, %rax
je 0xdb82
movq %rax, %rbx
movq 0x18d87(%rip), %rax     # 0x268e8
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x9af7
addq $0x18, %rbx
jmp 0xdb84
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdac2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: memTrackerEnd
void memTrackerEnd()
/* Free any remaining blocks and pop tracker memory handler. */
{
struct memTracker *mt = memTracker;
if (mt == NULL)
    errAbort("memTrackerEnd without memTrackerStart");
memTracker = NULL;
popMemHandler();
dlListFree(&mt->list);
freeMem(mt->handler);
freeMem(mt);
}

// Assembly:
pushq %rbx
movq 0x18d51(%rip), %rbx     # 0x268e8
testq %rbx, %rbx
jne 0xdbaa
leaq 0xab95(%rip), %rdi      # 0x18738
xorl %eax, %eax
callq 0xa61f
andq $0x0, 0x18d36(%rip)     # 0x268e8
callq 0xd632
leaq 0x8(%rbx), %rdi
callq 0x9a57
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xdbd3
movq 0x18978(%rip), %rax     # 0x26548
callq *0x10(%rax)
movq 0x1896e(%rip), %rax     # 0x26548
movq %rbx, %rdi
popq %rbx
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: carefulAlloc
static void *carefulAlloc(size_t size)
/* Allocate extra memory for cookies and list node, and then
 * return memory block. */
{
struct carefulMemBlock *cmb;
char *pEndCookie;
size_t newAlloced = size + carefulAlloced;
size_t aliSize;

if (newAlloced > carefulMaxToAlloc)
    {
    char maxAlloc[32];
    char allocRequest[32];
    sprintLongWithCommas(maxAlloc, (long long)carefulMaxToAlloc);
    sprintLongWithCommas(allocRequest, (long long)newAlloced);
    errAbort("carefulAlloc: Allocated too much memory - more than %s bytes (%s)",
	maxAlloc, allocRequest);
    }
carefulAlloced = newAlloced;
aliSize = ((size + sizeof(*cmb) + 4 + carefulAlignAdd)&carefulAlignMask);
cmb = carefulParent->alloc(aliSize);
cmb->size = size;
cmb->startCookie = cmbStartCookie;
pEndCookie = (char *)(cmb+1);
pEndCookie += size;
memcpy(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie));
dlAddHead(cmbAllocedList, (struct dlNode *)cmb);
return (void *)(cmb+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x18cdb(%rip), %r14     # 0x268e0
addq %rdi, %r14
movq 0x18ce1(%rip), %rsi     # 0x268f0
cmpq %rsi, %r14
jbe 0xdc43
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xe7ce
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xe7ce
leaq 0xab28(%rip), %rdi      # 0x1875e
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xa61f
movq %r14, 0x18c96(%rip)     # 0x268e0
leaq 0x7(%rbx), %rax
cmpb $0x0, 0x18ca3(%rip)     # 0x268f8
cmoveq %rbx, %rax
addq $0x1c, %rax
movzbl 0x18c9c(%rip), %ecx     # 0x26900
xorl $0x1, %ecx
leaq -0x8(,%rcx,8), %rdi
andq %rax, %rdi
movq 0x18c57(%rip), %rax     # 0x268d0
callq *0x8(%rax)
movl %ebx, 0x10(%rax)
movl 0x188f3(%rip), %ecx     # 0x26578
movl %ecx, 0x14(%rax)
leaq 0x18(%rax), %r14
movl 0x188ea(%rip), %ecx     # 0x2657c
movl %ecx, 0x18(%rax,%rbx)
movq 0x18c3b(%rip), %rdi     # 0x268d8
movq %rax, %rsi
callq 0x9ae1
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: carefulFree
static void carefulFree(void *vpt)
/* Check cookies and free. */
{
struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
size_t size = cmb->size;
char *pEndCookie;

carefulAlloced -= size;
pEndCookie = (((char *)(cmb+1)) + size);
if (cmb->startCookie != cmbStartCookie)
    errAbort("Bad start cookie %x freeing %llx\n", cmb->startCookie,
             ptrToLL(vpt));
if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
    errAbort("Bad end cookie %x%x%x%x freeing %llx\n", 
        pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
             ptrToLL(vpt));
dlRemove((struct dlNode *)cmb);
carefulParent->free(cmb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq -0x8(%rdi), %r14
subq %r14, 0x18c1a(%rip)     # 0x268e0
addq %rdi, %r14
movl -0x4(%rdi), %esi
cmpl 0x188a6(%rip), %esi     # 0x26578
je 0xdce5
leaq 0xaac5(%rip), %rdi      # 0x187a0
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa61f
movl (%r14), %eax
cmpl 0x1888e(%rip), %eax     # 0x2657c
je 0xdd14
movsbl (%r14), %esi
movsbl 0x1(%r14), %edx
movsbl 0x2(%r14), %ecx
movsbl 0x3(%r14), %r8d
leaq 0xaab8(%rip), %rdi      # 0x187c2
movq %rbx, %r9
xorl %eax, %eax
callq 0xa61f
addq $-0x18, %rbx
movq %rbx, %rdi
callq 0x9bd2
movq 0x18ba9(%rip), %rax     # 0x268d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/memalloc.c
// Function: carefulRealloc
static void *carefulRealloc(void *vpt, size_t size)
/* realloc a careful memblock block. */
{
unsigned char* newBlk = carefulAlloc(size);
if (vpt != NULL)
    {
    struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
    memcpy(newBlk, vpt, cmb->size);
    carefulFree(vpt);
    }
return newBlk;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xdbf0
movq %rax, %r14
testq %rbx, %rbx
je 0xdd62
movslq -0x8(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34a0
movq %rbx, %rdi
callq 0xdcb4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: incCounterFile
long incCounterFile(char *fileName)
/* Increment a 32 bit value on disk. */
{
long val = 0;
FILE *f = fopen(fileName, "r+b");
if (f != NULL)
    {
    mustReadOne(f, val);
    rewind(f);
    }
else
    {
    f = fopen(fileName, "wb");
    }
++val;
if (f != NULL)
    {
    fwrite(&val, sizeof(val), 1, f);
    if (fclose(f) != 0)
        errnoAbort("fclose failed");
    }
return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
andq $0x0, (%rsp)
leaq 0xaa6d(%rip), %rsi      # 0x187f0
callq 0x3480
testq %rax, %rax
je 0xddae
movq %rax, %rbx
movq %rsp, %r14
pushq $0x8
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x8763
movq %rbx, %rdi
callq 0x3280
incq (%r14)
jmp 0xddcd
leaq 0xaa3f(%rip), %rsi      # 0x187f4
movq %r14, %rdi
callq 0x3480
movq %rax, %rbx
movq $0x1, (%rsp)
testq %rax, %rax
je 0xddf8
movq %rsp, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x36f0
movq %rbx, %rdi
callq 0x31c0
testl %eax, %eax
je 0xddf8
leaq 0x9927(%rip), %rdi      # 0x17718
xorl %eax, %eax
callq 0xa721
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: digitsBaseTen
int digitsBaseTen(int x)
/* Return number of digits base 10. */
{
int digCount = 1;
if (x < 0)
    {
    digCount = 2;
    x = -x;
    }
while (x >= 10)
    {
    digCount += 1;
    x /= 10;
    }
return digCount;
}

// Assembly:
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
shrl $0x1f, %edi
incl %edi
pushq $0xa
popq %rcx
cmpl $0xa, %eax
jb 0xde2f
incl %edi
xorl %edx, %edx
divl %ecx
jmp 0xde22
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: readInGulp
void readInGulp(char *fileName, char **retBuf, size_t *retSize)
/* Read whole file in one big gulp. */
{
size_t size = (size_t)fileSize(fileName);
char *buf;
FILE *f = mustOpen(fileName, "rb");
*retBuf = buf = needLargeMem(size+1);
mustRead(f, buf, size);
buf[size] = 0;      /* Just in case it needs zero termination. */
fclose(f);
if (retSize != NULL)
    *retSize = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0xf518
movq %rax, %r14
leaq 0xa962(%rip), %rsi      # 0x187f7
movq %r12, %rdi
callq 0x8645
movq %rax, %r12
leaq 0x1(%r14), %rdi
callq 0xd684
movq %rax, %r13
movq %rax, (%r15)
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x8763
movb $0x0, (%r13,%r14)
movq %r12, %rdi
callq 0x31c0
testq %rbx, %rbx
je 0xded3
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: readAllWords
void readAllWords(char *fileName, char ***retWords, int *retWordCount, char **retBuf)
/* Read in whole file and break it into words. You need to freeMem both
 * *retWordCount and *retBuf when done. */
{
int wordCount;
char *buf = NULL;
char **words = NULL;
size_t bufSize;

readInGulp(fileName, &buf, &bufSize);
wordCount = chopByWhite(buf, NULL, 0);
if (wordCount != 0)
    {
    words = needMem(wordCount * sizeof(words[0]));
    chopByWhite(buf, words, wordCount);
    }
*retWords = words;
*retWordCount = wordCount;
*retBuf = buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0xde74
movq (%r12), %r12
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x805c
movl %eax, %ebp
testl %eax, %eax
je 0xdf40
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0xd87c
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x805c
movq %r13, (%r15)
movl %ebp, (%r14)
movq %r12, (%rbx)
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/obscure.c
// Function: countWordsInFile
int countWordsInFile(char *fileName)
/* Count number of words in file. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line;
int wordCount = 0;
while (lineFileNext(lf, &line, NULL))
    wordCount += chopByWhite(line, NULL, 0);
lineFileClose(&lf);
return wordCount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rsi
callq 0xbbad
movq %rax, %r14
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbcea
testl %eax, %eax
je 0xdf98
movq (%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x805c
addl %eax, %ebx
jmp 0xdf76
leaq 0x8(%rsp), %rdi
callq 0xc178
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: hashWordsInFile
struct hash *hashWordsInFile(char *fileName, int hashSize)
/* Create a hash of space delimited words in file. */
{
struct hash *hash = newHash(hashSize);
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line, *word;
while (lineFileNext(lf, &line, NULL))
    {
    while ((word = nextWord(&line)) != NULL)
        hashAdd(hash, word, NULL);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbp
movl %esi, %edi
movl %ebp, %esi
callq 0xb010
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0xbbad
movq %rax, %r14
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbcea
testl %eax, %eax
jne 0xe001
jmp 0xe010
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xad17
movq %r15, %rdi
callq 0x6b8e
testq %rax, %rax
jne 0xdff4
jmp 0xdfe1
leaq 0x8(%rsp), %rdi
callq 0xc178
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: hashNameIntFile
struct hash *hashNameIntFile(char *fileName)
/* Given a two column file (name, integer value) return a
 * hash keyed by name with integer values */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[2];
struct hash *hash = hashNew(16);
while (lineFileRow(lf, row))
    hashAddInt(hash, row[0], lineFileNeedNum(lf, row, 1));
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0xbbad
movq %rax, %r14
movq %rax, 0x8(%rsp)
pushq $0x10
popq %rdi
movl %ebx, %esi
callq 0xb010
movq %rax, %r15
leaq 0x10(%rsp), %r12
pushq $0x2
popq %rbp
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xc710
testl %eax, %eax
je 0xe08f
movq 0x10(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xc7ee
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0xaf7f
jmp 0xe05d
leaq 0x8(%rsp), %rdi
callq 0xc178
movq %r15, %rax
addq $0x28, %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/obscure.c
// Function: hashTwoColumnFile
struct hash *hashTwoColumnFile(char *fileName)
/* Given a two column file (key, value) return a hash. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[2];
struct hash *hash = hashNew(16);
while (lineFileRow(lf, row))
    {
    char *name = row[0];
    char *value = lmCloneString(hash->lm, row[1]);
    hashAdd(hash, name, value);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xbbad
movq %rax, %rbx
movq %rax, 0x8(%rsp)
pushq $0x10
popq %rdi
movl %ebp, %esi
callq 0xb010
movq %rax, %r14
leaq 0x10(%rsp), %r15
pushq $0x2
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xc710
testl %eax, %eax
je 0xe112
movq 0x20(%r14), %rdi
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rsi
callq 0xd517
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xad17
jmp 0xe0de
leaq 0x8(%rsp), %rdi
callq 0xc178
movq %r14, %rax
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/obscure.c
// Function: readAllLines
struct slName *readAllLines(char *fileName)
/* Read all lines of file into a list.  (Removes trailing carriage return.) */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct slName *list = NULL, *el;
char *line;

while (lineFileNext(lf, &line, NULL))
     {
     el = newSlName(line);
     slAddHead(&list, el);
     }
slReverse(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rsi
callq 0xbbad
andq $0x0, (%rsp)
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xbcea
testl %eax, %eax
je 0xe174
movq 0x8(%rsp), %rdi
callq 0x6692
movq %r15, (%rax)
movq %rax, (%rsp)
movq %rax, %r15
jmp 0xe14d
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: copyFile
void copyFile(char *source, char *dest)
/* Copy file from source to dest. */
{
int bufSize = 64*1024;
char *buf = needMem(bufSize);
int bytesRead;
int s, d;

s = open(source, O_RDONLY);
if (s < 0)
    errAbort("Couldn't open %s. %s\n", source, strerror(errno));
d = creat(dest, 0777);
if (d < 0)
    {
    close(s);
    errAbort("Couldn't open %s. %s\n", dest, strerror(errno));
    }
while ((bytesRead = read(s, buf, bufSize)) > 0)
    {
    if (write(d, buf, bytesRead) < 0)
        errAbort("Write error on %s. %s\n", dest, strerror(errno));
    }
close(s);
if (close(d) != 0)
    errnoAbort("close failed");
freeMem(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10000, %edi          # imm = 0x10000
callq 0xd87c
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x35b0
movl %eax, %ebp
testl %eax, %eax
jns 0xe1d9
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xa62e(%rip), %rdi      # 0x187fa
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa61f
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x35f0
movl %eax, %r15d
testl %eax, %eax
jns 0xe217
movl %ebp, %edi
callq 0x3350
leaq 0xa5ff(%rip), %r12      # 0x187fa
callq 0x30c0
movl (%rax), %edi
callq 0x3720
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa61f
leaq 0xa5f2(%rip), %r12      # 0x18810
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x33d0
testl %eax, %eax
jle 0xe24b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %r15d, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31a0
testq %rax, %rax
jns 0xe21e
jmp 0xe1fb
movl %ebp, %edi
callq 0x3350
movl %r15d, %edi
callq 0x3350
testl %eax, %eax
je 0xe26c
leaq 0x94b4(%rip), %rdi      # 0x17719
xorl %eax, %eax
callq 0xa721
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd8f9
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: copyOpenFile
void copyOpenFile(FILE *inFh, FILE *outFh)
/* copy an open stdio file */
{
int c;
while ((c = fgetc(inFh)) != EOF)
    fputc(c, outFh);
if (ferror(inFh))
    errnoAbort("file read failed");
if (ferror(outFh))
    errnoAbort("file write failed");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x3340
cmpl $-0x1, %eax
je 0xe29f
movl %eax, %edi
movq %rbx, %rsi
callq 0x33a0
jmp 0xe286
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0xe2b9
leaq 0xa575(%rip), %rdi      # 0x18827
xorl %eax, %eax
callq 0xa721
movq %rbx, %rdi
callq 0x3110
testl %eax, %eax
je 0xe2da
leaq 0xa56c(%rip), %rdi      # 0x18838
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa721
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: cpFile
void cpFile(int s, int d)
/* Copy from source file to dest until reach end of file. */
{
int bufSize = 64*1024, readSize;
char *buf = needMem(bufSize);

for (;;)
    {
    readSize = read(s, buf, bufSize);
    if (readSize > 0)
        mustWriteFd(d, buf, readSize);
    if (readSize <= 0)
        break;
    }
freeMem(buf);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x10000, %edi          # imm = 0x10000
callq 0xd87c
movq %rax, %r14
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %r14, %rsi
callq 0x33d0
testl %eax, %eax
jle 0xe31e
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8ad4
jmp 0xe2f7
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd8f9
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: parseQuotedString
boolean parseQuotedString( char *in, char *out, char **retNext)
/* Read quoted string from in (which should begin with first quote).
 * Write unquoted string to out, which may be the same as in.
 * Return pointer to character past end of string in *retNext. 
 * Return FALSE if can't find end. */
{
char c, *s = in;
int quoteChar = *s++;
boolean escaped = FALSE;

for (;;)
   {
   c = *s++;
   if (c == 0)
       {
       warn("Unmatched %c", quoteChar);
       return FALSE;
       }
   if (escaped)
       {
       if (c == '\\' || c == quoteChar)
          *out++ = c;
       else
          {
	  *out++ = '\\';
	  *out++ = c;
	  }
       escaped = FALSE;
       }
   else
       {
       if (c == '\\')
           escaped = TRUE;
       else if (c == quoteChar)
           break;
       else
           *out++ = c;
       }
   }
*out = 0;
if (retNext != NULL)
    *retNext = s;
return TRUE;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movsbl (%rdi), %esi
incq %rdi
movb $0x1, %r9b
movq %rdi, %r8
movb (%r8), %cl
testb %cl, %cl
je 0xe3ea
movq %r8, %rdi
testb $0x1, %r9b
je 0xe3b6
leaq 0x1(%rdi), %r8
xorl %r9d, %r9d
cmpb $0x5c, %cl
je 0xe38f
cmpb %sil, %cl
je 0xe3fe
leaq 0x1(%rax), %r8
jmp 0xe3e0
cmpb $0x5c, %cl
sete %r8b
cmpb %sil, %cl
sete %r9b
orb %r8b, %r9b
leaq 0x1(%rax), %r8
testb %r9b, %r9b
jne 0xe3e0
movb $0x5c, (%rax)
movq %rax, %r9
addq $0x2, %r9
movq %r8, %rax
movq %r9, %r8
movb %cl, (%rax)
incq %rdi
movq %r8, %rax
jmp 0xe389
leaq 0xa459(%rip), %rdi      # 0x1884a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xa3aa
movl %ebx, %eax
popq %rbx
retq
movb $0x0, (%rax)
pushq $0x1
popq %rbx
testq %rdx, %rdx
je 0xe3fa
movq %r8, (%rdx)
jmp 0xe3fa
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: nextQuotedWord
char *nextQuotedWord(char **pLine)
/* Generalization of nextWord.  Returns next quoted
 * string or if no quotes next word.  Updates *pLine
 * to point past word that is returned. Does not return
 * quotes. */
{
char *line, c;
line = skipLeadingSpaces(*pLine);
if (line == NULL || line[0] == 0)
    return NULL;
c = *line;
if (c == '"' || c == '\'')
    {
    if (!parseQuotedString(line, line, pLine))
        return NULL;
    return line;
    }
else
    {
    return nextWord(pLine);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x722d
testq %rax, %rax
je 0xe44e
movq %rax, %rbx
movzbl (%rax), %eax
testl %eax, %eax
je 0xe44e
cmpl $0x27, %eax
je 0xe436
cmpl $0x22, %eax
jne 0xe45b
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe37f
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0xe450
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b8e
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: makeEscapedString
char *makeEscapedString(char *in, char toEscape)
/* Return string that is a copy of in, but with all
 * toEscape characters preceded by '\' 
 * When done freeMem result. */
{
int newSize = strlen(in) + countChars(in, toEscape);
char *out = needMem(newSize+1);
escCopy(in, out, toEscape, '\\');
return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x7eb0
addl %r15d, %eax
incl %eax
movslq %eax, %rdi
callq 0xd87c
movq %rax, %r15
pushq $0x5c
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0xe46a
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: makeQuotedString
char *makeQuotedString(char *in, char quoteChar)
/* Create a string surrounded by quoteChar, with internal
 * quoteChars escaped.  freeMem result when done. */
{
int newSize = 2 + strlen(in) + countChars(in, quoteChar);
char *out = needMem(newSize+1);
out[0] = quoteChar;
escCopy(in, out+1, quoteChar, '\\');
out[newSize-1] = quoteChar;
return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3200
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x7eb0
leal (%r15,%rax), %ebp
addl $0x2, %ebp
addl %r15d, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0xd87c
movq %rax, %r15
movb %bl, (%rax)
leaq 0x1(%rax), %rsi
pushq $0x5c
popq %rcx
movq %r14, %rdi
movl %ebx, %edx
callq 0xe46a
movslq %ebp, %rax
movb %bl, -0x1(%r15,%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: hashThisEqThatLine
struct hash *hashThisEqThatLine(char *line, int lineIx, boolean firstStartsWithLetter)
/* Return a symbol table from a line of form:
 *   1-this1=val1 2-this='quoted val2' var3="another val" 
 * If firstStartsWithLetter is true, then the left side of the equals must start with
 * a letter. */
{
char *dupe = cloneString(line);
char *s = dupe, c;
char *var, *val;
struct hash *hash = newHash(8);

for (;;)
    {
    if ((var = skipLeadingSpaces(s)) == NULL)
        break;

    if ((c = *var) == 0)
        break;
    if (firstStartsWithLetter && !isalpha(c))
	errAbort("line %d of custom input: variable needs to start with letter '%s'", lineIx, var);
    val = strchr(var, '=');
    if (val == NULL)
        {
        errAbort("line %d of var %s in custom input: %s \n missing = in var/val pair", lineIx, var, line);
        }
    *val++ = 0;
    c = *val;
    if (c == '\'' || c == '"')
        {
	if (!parseQuotedString(val, val, &s))
	    errAbort("line %d of input: missing closing %c", lineIx, c);
	}
    else
	{
	s = skipToSpaces(val);
	if (s != NULL) *s++ = 0;
	}
    hashAdd(hash, var, cloneString(val));
    }
freez(&dupe);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
callq 0x5ede
movq %rax, %r14
movq %rax, 0x10(%rsp)
movq %rsp, %rax
movq %r14, (%rax)
pushq $0x8
popq %rdi
pushq $0x1
popq %rsi
callq 0xb010
movq %rax, %r12
movq %r14, %rdi
callq 0x722d
testq %rax, %rax
je 0xe650
movq %rax, %r15
movsbq (%rax), %r14
testq %r14, %r14
je 0xe650
testl %ebx, %ebx
je 0xe5a6
callq 0x37a0
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r14,2)
jne 0xe5a6
leaq 0xa2bd(%rip), %rdi      # 0x18857
movl %ebp, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa61f
movq %r15, %rdi
pushq $0x3d
popq %rsi
callq 0x3260
movq %rax, %r14
testq %rax, %rax
jne 0xe5d1
leaq 0xa2d9(%rip), %rdi      # 0x18899
movl %ebp, %esi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0xa61f
movq %r14, %rax
incq %r14
movb $0x0, (%rax)
movzbl 0x1(%rax), %r13d
cmpl $0x27, %r13d
je 0xe5eb
cmpl $0x22, %r13d
jne 0xe613
movq %r14, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq 0xe37f
testl %eax, %eax
jne 0xe631
movsbl %r13b, %edx
leaq 0xa2d3(%rip), %rdi      # 0x188db
movl %ebp, %esi
xorl %eax, %eax
callq 0xa61f
jmp 0xe631
movq %r14, %rdi
callq 0x827c
movq %rax, (%rsp)
testq %rax, %rax
je 0xe631
movq %rax, %rcx
incq %rcx
movq %rcx, (%rsp)
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x5ede
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xad17
movq (%rsp), %r14
jmp 0xe55e
leaq 0x10(%rsp), %rdi
callq 0xd909
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/obscure.c
// Function: stringToSlNames
struct slName *stringToSlNames(char *string)
/* Convert string to a list of slNames separated by
 * white space, but allowing multiple words in quotes.
 * Quotes if any are stripped.  */
{
struct slName *list = NULL, *name;
char *dupe = cloneString(string);
char c, *s = dupe, *e;

for (;;)
    {
    if ((s = skipLeadingSpaces(s)) == NULL)
        break;
    if ((c = *s) == 0)
        break;
    if (c == '\'' || c == '"')
        {
	if (!parseQuotedString(s, s, &e))
	    errAbort("missing closing %c in %s", c, string);
	}
    else
        {
	e = skipToSpaces(s);
	if (e != NULL) *e++ = 0;
	}
    name = slNameNew(s);
    slAddHead(&list, name);
    s = e;
    }
freeMem(dupe);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
callq 0x5ede
movq %rsp, %r15
leaq 0xa266(%rip), %r12      # 0x18900
xorl %ebp, %ebp
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x722d
testq %rax, %rax
je 0xe722
movq %rax, %r13
movzbl (%rax), %r14d
cmpl $0x22, %r14d
je 0xe6e6
cmpl $0x27, %r14d
je 0xe6e6
testl %r14d, %r14d
je 0xe722
movq %r13, %rdi
callq 0x827c
movq %rax, (%rsp)
testq %rax, %rax
je 0xe709
movq %rax, %rcx
incq %rcx
movq %rcx, (%rsp)
movb $0x0, (%rax)
jmp 0xe709
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe37f
testl %eax, %eax
jne 0xe709
movsbl %r14b, %esi
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa61f
movq %r13, %rdi
callq 0x6692
movq %rbp, (%rax)
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq %rax, %rbp
jmp 0xe6a4
movq 0x10(%rsp), %rdi
callq 0xd8f9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: charSepToSlNames
struct slName *charSepToSlNames(char *string, char c)
/* Convert character-separated list of items to slName list. 
 * Note that the last occurence of c is optional.  (That
 * is for a comma-separated list a,b,c and a,b,c, are
 * equivalent. */
{
struct slName *list = NULL, *el;
char *s, *e;

s = string;
while (s != NULL && s[0] != 0)
    {
    e = strchr(s, c);
    if (e == NULL)
        {
	el = slNameNew(s);
	slAddHead(&list, el);
	break;
	}
    else
        {
	el = slNameNewN(s, e - s);
	slAddHead(&list, el);
	s = e+1;
	}
    }
slReverse(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
andq $0x0, (%rsp)
xorl %r12d, %r12d
testq %r14, %r14
je 0xe7ac
cmpb $0x0, (%r14)
je 0xe7ac
movq %r14, %rdi
movl %ebx, %esi
callq 0x3260
testq %rax, %rax
je 0xe79d
movq %rax, %r15
movl %r15d, %esi
subl %r14d, %esi
movq %r14, %rdi
callq 0x66d1
movq %r12, (%rax)
movq %rax, (%rsp)
incq %r15
movq %rax, %r12
movq %r15, %r14
jmp 0xe760
movq %r14, %rdi
callq 0x6692
movq %r12, (%rax)
movq %rax, (%rsp)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x613f
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: sprintWithGreekByte
void sprintWithGreekByte(char *s, int slength, long long size)
/* Numbers formatted with PB, TB, GB, MB, KB, B */
{
char *greek[] = {"B", "KB", "MB", "GB", "TB", "PB"};
int i = 0;
long long d = 1;
while ((size/d) >= 1024)
    {
    ++i;
    d *= 1024;
    }
double result = ((double)size)/d;
if (result < 10)
    safef(s,slength,"%3.1f %s",((double)size)/d, greek[i]);
else
    safef(s,slength,"%3.0f %s",((double)size)/d, greek[i]);
}

// Assembly:
movq %rdx, %rcx
pushq $0x1
popq %r9
leaq 0xa079(%rip), %r8       # 0x18a0c
movq %rcx, %rax
cqto
idivq %r9
cmpq $0x400, %rax            # imm = 0x400
jl 0xe9ad
shlq $0xa, %r9
addq $0x4, %r8
jmp 0xe993
cvtsi2sd %rcx, %xmm0
cvtsi2sd %r9, %xmm1
divsd %xmm1, %xmm0
movslq (%r8), %rax
leaq 0xa047(%rip), %rcx      # 0x18a0c
addq %rax, %rcx
movsd 0x9e18(%rip), %xmm1     # 0x187e8
ucomisd %xmm0, %xmm1
leaq 0x9fa7(%rip), %rax      # 0x18982
leaq 0x9fa9(%rip), %rdx      # 0x1898b
cmovaq %rax, %rdx
movb $0x1, %al
jmp 0x939d
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: shuffleArrayOfChars
void shuffleArrayOfChars(char *array, int arraySize)
/* Shuffle array of characters of given size given number of times. */
{
char c;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    c = array[i];
    array[i] = array[randIx];
    array[randIx] = c;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
subq $0x1, %r15
jb 0xea26
callq 0x3780
cltd
idivl %ebx
movb (%r14), %al
movslq %edx, %rcx
movb (%r14,%rcx), %dl
movb %dl, (%r14)
movb %al, (%r14,%rcx)
decl %ebx
incq %r14
jmp 0xea00
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/JimKent[P]linearSat/lib/obscure.c
// Function: shuffleArrayOfPointers
void shuffleArrayOfPointers(void *pointerArray, int arraySize)
/* Shuffle array of pointers of given size given number of times. */
{
void **array = pointerArray, *pt;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    pt = array[i];
    array[i] = array[randIx];
    array[randIx] = pt;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r12d
cmovgl %esi, %r12d
cmpq %r15, %r12
je 0xea72
callq 0x3780
cltd
idivl %ebx
movq (%r14,%r15,8), %rax
movslq %edx, %rcx
addq %r15, %rcx
movq (%r14,%rcx,8), %rdx
movq %rdx, (%r14,%r15,8)
movq %rax, (%r14,%rcx,8)
incq %r15
decl %ebx
jmp 0xea48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq