LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileSkip
void lineFileSkip(struct lineFile *lf, int lineCount)
/* Skip a number of lines. */
{
int i, lineSize;
char *line;

for (i=0; i<lineCount; ++i)
    {
    if (!lineFileNext(lf, &line, &lineSize))
        errAbort("Premature end of file in %s", lf->fileName);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14127
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x12650
cmpl $0x0, %eax
jne 0x1411a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1114e(%rip), %rdi     # 0x25261
movb $0x0, %al
callq 0xfd50
jmp 0x1411c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x140e6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileSkipToLineStartingWith
char *lineFileSkipToLineStartingWith(struct lineFile *lf, char *start, int maxCount)
/* Skip to next line that starts with given string.  Return NULL
 * if no such line found, otherwise return the line. */
{
char *line;
while (lineFileNext(lf, &line, NULL) && --maxCount >= 0)
    {
    if (startsWith(start, line))
        return line;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x14172
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setge %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1417b
jmp 0x14199
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa4b0
cmpl $0x0, %eax
je 0x14197
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x141a1
jmp 0x14143
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileReadAll
char *lineFileReadAll(struct lineFile *lf)
/* Read remainder of lineFile and return it as a string. */
{
struct dyString *dy = dyStringNew(1024*4);
lf->zTerm = 0;
int size;
char *line;
while (lineFileNext(lf, &line, &size))
    dyStringAppendN(dy, line, size);
return dyStringCannibalize(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0xf030
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x34(%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x12650
cmpl $0x0, %eax
je 0x141fa
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xf200
jmp 0x141d2
leaq -0x10(%rbp), %rdi
callq 0xf0d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileRemoveInitialCustomTrackLines
void lineFileRemoveInitialCustomTrackLines(struct lineFile *lf)
/* remove initial browser and track lines */
{
char *line;
while (lineFileNextReal(lf, &line))
    {
    if (!(startsWith("browser", line) || startsWith("track", line) ))
        {
        verbose(2, "found line not browser or track: %s\n", line);
        lineFileReuse(lf);
        break;
        }
    verbose(2, "skipping %s\n", line);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x13510
cmpl $0x0, %eax
je 0x148e3
movq -0x10(%rbp), %rsi
leaq 0x10b61(%rip), %rdi     # 0x253ea
callq 0xa4b0
cmpl $0x0, %eax
jne 0x148ca
movq -0x10(%rbp), %rsi
leaq 0x10b54(%rip), %rdi     # 0x253f2
callq 0xa4b0
cmpl $0x0, %eax
jne 0x148ca
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x10b40(%rip), %rsi     # 0x253f8
movb $0x0, %al
callq 0x1adf0
movq -0x8(%rbp), %rdi
callq 0x12460
jmp 0x148e3
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x10b43(%rip), %rsi     # 0x2541d
movb $0x0, %al
callq 0x1adf0
jmp 0x1486c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: lmInit
struct lm *lmInit(int blockSize)
/* Create a local memory pool. */
{
struct lm *lm;
int aliSize = sizeof(long);
if (aliSize < sizeof(double))
    aliSize = sizeof(double);
if (aliSize < sizeof(void *))
    aliSize = sizeof(void *);
lm = needMem(sizeof(*lm));
lm->blocks = NULL;
if (blockSize <= 0)
    blockSize = (1<<14);    /* 16k default. */
lm->blockSize = blockSize;
lm->allignAdd = (aliSize-1);
lm->allignMask = ~lm->allignAdd;
newBlock(lm, blockSize);
return lm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x8, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jae 0x14913
movl $0x8, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x8, %rax
jae 0x14924
movl $0x8, -0x14(%rbp)
movl $0x20, %edi
callq 0x152f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x0, -0x4(%rbp)
jg 0x1494a
movl $0x4000, -0x4(%rbp)     # imm = 0x4000
movslq -0x4(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
xorq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movslq -0x4(%rbp), %rsi
callq 0x149a0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: newBlock
static struct lmBlock *newBlock(struct lm *lm, size_t reqSize)
/* Allocate a new block of at least reqSize */
{
size_t size = (reqSize > lm->blockSize ? reqSize : lm->blockSize);
size_t fullSize = size + sizeof(struct lmBlock);
struct lmBlock *mb = needLargeZeroedMem(fullSize);
if (mb == NULL)
    errAbort("Couldn't allocate %lld bytes", (long long)fullSize);
mb->free = (char *)(mb+1);
mb->end = ((char *)mb) + fullSize;
mb->next = lm->blocks;
lm->blocks = mb;
return mb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x149c8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x149d4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x15070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14a0e
movq -0x20(%rbp), %rsi
leaq 0x10a5b(%rip), %rdi     # 0x25462
movb $0x0, %al
callq 0xfd50
movq -0x28(%rbp), %rcx
addq $0x20, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: lmCleanup
void lmCleanup(struct lm **pLm)
/* Clean up a local memory pool. */
{
    struct lm *lm = *pLm;
    if (lm == NULL)
        return;
    slFreeList(&lm->blocks);
    freeMem(lm);
    *pLm = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14a80
jmp 0x14a9d
movq -0x10(%rbp), %rdi
callq 0x7c10
movq -0x10(%rbp), %rdi
callq 0x153e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: lmSize
size_t lmSize(struct lm *lm)
// Returns current size of pool, even for memory already allocated
{
size_t fullSize = 0;

struct lmBlock *mb = lm->blocks;
for (;mb != NULL;mb = mb->next)
    fullSize += (mb->end - (char *)(mb+1));

return fullSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14b2a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x14afb
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: lmAlloc
void *lmAlloc(struct lm *lm, size_t size)
/* Allocate memory from local pool. */
{
struct lmBlock *mb = lm->blocks;
void *ret;
size_t memLeft = mb->end - mb->free;
if (memLeft < size)
    mb = newBlock(lm, size);
ret = mb->free;
mb->free += ((size+lm->allignAdd)&lm->allignMask);
if (mb->free > mb->end)
    mb->free = mb->end;
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x14b7d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x149a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
andq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x14bcb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x14c4b
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x14c4b
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x14c41
movq -0x18(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14c75
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14b30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3470
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/localmem.c
// Function: lmCloneStringZ
char *lmCloneStringZ(struct lm *lm, char *string, int size)
/* Return local mem copy of string. */
{
if (string == NULL)
    return NULL;
else
    {
    char *s = lmAlloc(lm, size+1);
    memcpy(s, string, size);
    return s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14ce4
movq $0x0, -0x8(%rbp)
jmp 0x14d13
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x14b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3470
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14dae
movq $0x0, -0x8(%rbp)
jmp 0x14df3
movq -0x20(%rbp), %rdi
callq 0xbcd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x14dd5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14d20
movq %rax, -0x8(%rbp)
jmp 0x14df3
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x14cc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x14e23
movq $0x0, -0x8(%rbp)
jmp 0x14e7b
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x14e6a
movq -0x18(%rbp), %rdi
callq 0x9bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbcd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14e5d
movq $0x0, -0x8(%rbp)
jmp 0x14e7b
jmp 0x14e5f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x14e2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14d80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
addq $0x10, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x14b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x30c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1d5c9(%rip), %rax     # 0x32538
movq %rax, -0x8(%rbp)
leaq 0x1d5c6(%rip), %rax     # 0x32540
cmpq %rax, 0x1d5b7(%rip)     # 0x32538
jne 0x14f91
leaq 0x104f5(%rip), %rdi     # 0x2547f
movb $0x0, %al
callq 0xfd50
movq 0x1d5a0(%rip), %rax     # 0x32538
movq (%rax), %rax
movq %rax, 0x1d596(%rip)     # 0x32538
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15010
movq -0x8(%rbp), %rax
cmpq 0x1d552(%rip), %rax     # 0x32560
jb 0x15029
movq -0x8(%rbp), %rsi
movq 0x1d545(%rip), %rdx     # 0x32560
leaq 0x10477(%rip), %rdi     # 0x25499
movb $0x0, %al
callq 0xfd50
movq 0x1d508(%rip), %rax     # 0x32538
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x15065
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x30a0
movq -0x18(%rbp), %rsi
movl (%rax), %edx
leaq 0x10475(%rip), %rdi     # 0x254d3
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x150d4
movq -0x10(%rbp), %rax
cmpq 0x1d48e(%rip), %rax     # 0x32560
jb 0x150ed
movq -0x10(%rbp), %rsi
movq 0x1d481(%rip), %rdx     # 0x32560
leaq 0x1042f(%rip), %rdi     # 0x25515
movb $0x0, %al
callq 0xfd50
movq 0x1d444(%rip), %rax     # 0x32538
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1512d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x30a0
movq -0x20(%rbp), %rsi
movl (%rax), %edx
leaq 0x1042f(%rip), %rdi     # 0x25555
movb $0x0, %al
callq 0xfd50
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x150b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x15186
movq -0x20(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x32e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x151b1
leaq 0x103f3(%rip), %rdi     # 0x2559d
movb $0x0, %al
callq 0xfd50
movq 0x1d380(%rip), %rax     # 0x32538
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x151ed
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x30a0
movq -0x18(%rbp), %rsi
movl (%rax), %edx
leaq 0x103df(%rip), %rdi     # 0x255c5
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1d2e1(%rip), %rax     # 0x32538
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x15290
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x30a0
movq -0x20(%rbp), %rsi
movl (%rax), %edx
leaq 0x10382(%rip), %rdi     # 0x2560b
movb $0x0, %al
callq 0xfd50
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x152e6
movq -0x20(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x32e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1530d
cmpq $0x1dcd6500, -0x8(%rbp) # imm = 0x1DCD6500
jbe 0x15324
movq -0x8(%rbp), %rsi
leaq 0x1033c(%rip), %rdi     # 0x25654
movl $0x1dcd6500, %edx       # imm = 0x1DCD6500
movb $0x0, %al
callq 0xfd50
movq 0x1d20d(%rip), %rax     # 0x32538
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x15360
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x30a0
movq -0x18(%rbp), %rsi
movl (%rax), %edx
leaq 0x10330(%rip), %rdi     # 0x25689
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x32e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x153e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x989680, -0x4(%rbp)   # imm = 0x989680
cmpq $0x0, 0x1d469(%rip)     # 0x328d0
jne 0x1546e
jmp 0x1554f
movq 0x1d463(%rip), %rax     # 0x328d8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1554f
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl 0x1d0b5(%rip), %eax     # 0x32568
je 0x154d2
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
leaq 0x101fb(%rip), %rdi     # 0x256c6
movb $0x0, %al
callq 0xfd50
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl 0x1d08e(%rip), %ecx     # 0x3256c
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x15521
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %edx
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %r8d
movq -0x10(%rbp), %r9
addq $0x1, %r9
leaq 0x101cf(%rip), %rdi     # 0x256e9
movb $0x0, %al
callq 0xfd50
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x1553d
leaq 0x101da(%rip), %rdi     # 0x25710
movb $0x0, %al
callq 0xfd50
jmp 0x1553f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1547c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/memalloc.c
// Function: carefulMemInit
static void carefulMemInit(size_t maxToAlloc)
/* Initialize careful memory system */
{
carefulMaxToAlloc = maxToAlloc;
cmbAllocedList = newDlList();
carefulAlignSize = sizeof(double);
if (sizeof(void *) > carefulAlignSize)
    carefulAlignSize = sizeof(void *);
if (sizeof(long) > carefulAlignSize)
    carefulAlignSize = sizeof(long);
if (sizeof(off_t) > carefulAlignSize)
    carefulAlignSize = sizeof(off_t);
if (sizeof(long long) > carefulAlignSize)
    carefulAlignSize = sizeof(long long);
carefulAlignAdd = carefulAlignSize-1;
carefulAlignMask = ~carefulAlignAdd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x1d319(%rip)     # 0x328f0
movb $0x0, %al
callq 0xe7b0
movq %rax, 0x1d2f3(%rip)     # 0x328d8
movl $0x8, 0x1d309(%rip)     # 0x328f8
movslq 0x1d302(%rip), %rcx     # 0x328f8
movl $0x8, %eax
cmpq %rcx, %rax
jbe 0x1560a
movl $0x8, 0x1d2ee(%rip)     # 0x328f8
movslq 0x1d2e7(%rip), %rcx     # 0x328f8
movl $0x8, %eax
cmpq %rcx, %rax
jbe 0x15625
movl $0x8, 0x1d2d3(%rip)     # 0x328f8
movslq 0x1d2cc(%rip), %rcx     # 0x328f8
movl $0x8, %eax
cmpq %rcx, %rax
jbe 0x15640
movl $0x8, 0x1d2b8(%rip)     # 0x328f8
movslq 0x1d2b1(%rip), %rcx     # 0x328f8
movl $0x8, %eax
cmpq %rcx, %rax
jbe 0x1565b
movl $0x8, 0x1d29d(%rip)     # 0x328f8
movl 0x1d297(%rip), %eax     # 0x328f8
subl $0x1, %eax
movl %eax, 0x1d292(%rip)     # 0x328fc
movl 0x1d28c(%rip), %eax     # 0x328fc
xorl $-0x1, %eax
cltq
movq %rax, 0x1d284(%rip)     # 0x32900
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x1d248(%rip)     # 0x328e8
je 0x156b0
leaq 0x10098(%rip), %rdi     # 0x25741
movb $0x0, %al
callq 0xfd50
movl $0x20, %edi
callq 0x152f0
movq %rax, -0x8(%rbp)
movl $0x20, %edi
callq 0x152f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x6e(%rip), %rcx        # 0x15750
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0xcb(%rip), %rcx        # 0x157c0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x108(%rip), %rcx       # 0x15810
movq %rcx, 0x18(%rax)
movb $0x0, %al
callq 0xe7b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x14ee0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x1d1a7(%rip)     # 0x328e8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq 0x1d179(%rip), %rax     # 0x328e8
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15792
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x157b2
movq 0x1d14f(%rip), %rax     # 0x328e8
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xe9e0
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/memalloc.c
// Function: memTrackerFree
static void memTrackerFree(void *vpt)
/* Check cookies and free. */
{
struct dlNode *node = vpt;
node -= 1;
dlRemove(node);
memTracker->parent->free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xeb60
movq 0x1d0f8(%rip), %rax     # 0x328e8
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15836
movq -0x18(%rbp), %rdi
callq 0x15750
movq %rax, -0x8(%rbp)
jmp 0x158a5
movq -0x10(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0xeb60
movq 0x1d08a(%rip), %rax     # 0x328e8
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15885
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x158a5
movq 0x1d05c(%rip), %rax     # 0x328e8
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xe9e0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1d029(%rip), %rax     # 0x328e8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x158d8
leaq 0xfe8f(%rip), %rdi      # 0x25760
movb $0x0, %al
callq 0xfd50
movq $0x0, 0x1d005(%rip) # 0x328e8
callq 0x14f60
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xe860
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x153e0
movq -0x8(%rbp), %rdi
callq 0x153e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq 0x1cf39(%rip), %rax     # 0x328e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x1cf3a(%rip), %rax     # 0x328f0
jbe 0x159eb
leaq -0x50(%rbp), %rdi
movq 0x1cf2d(%rip), %rsi     # 0x328f0
callq 0x16c20
leaq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16c20
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq 0xfda2(%rip), %rdi      # 0x25786
movb $0x0, %al
callq 0xfd50
movq -0x20(%rbp), %rax
movq %rax, 0x1ceea(%rip)     # 0x328e0
movq -0x8(%rbp), %rax
addq $0x18, %rax
addq $0x4, %rax
movslq 0x1cef3(%rip), %rcx     # 0x328fc
addq %rcx, %rax
andq 0x1ceed(%rip), %rax     # 0x32900
movq %rax, -0x28(%rbp)
movq 0x1ceb2(%rip), %rax     # 0x328d0
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x1cb29(%rip), %ecx     # 0x32568
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1cb04(%rip), %ecx     # 0x3256c
movl %ecx, (%rax)
movq 0x1ce67(%rip), %rdi     # 0x328d8
movq -0x10(%rbp), %rsi
callq 0xe9a0
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x1ce21(%rip), %rax     # 0x328e0
subq %rcx, %rax
movq %rax, 0x1ce17(%rip)     # 0x328e0
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl 0x1ca82(%rip), %eax     # 0x32568
je 0x15b01
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x8(%rbp), %rdx
leaq 0xfcce(%rip), %rdi      # 0x257c8
movb $0x0, %al
callq 0xfd50
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl 0x1ca5f(%rip), %ecx     # 0x3256c
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x15b4c
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %edx
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %ecx
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %r8d
movq -0x8(%rbp), %r9
leaq 0xfca5(%rip), %rdi      # 0x257ea
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rdi
callq 0xeb60
movq 0x1cd74(%rip), %rax     # 0x328d0
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15bbe
movq -0x8(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rdx
callq 0x3470
movq -0x8(%rbp), %rdi
callq 0x15a90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfc29(%rip), %rsi      # 0x25818
callq 0x3450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15c1c
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0xc690
movq -0x18(%rbp), %rdi
callq 0x3270
jmp 0x15c30
movq -0x8(%rbp), %rdi
leaq 0xfbf5(%rip), %rsi      # 0x2581c
callq 0x3450
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15c78
movq -0x18(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x36c0
movq -0x18(%rbp), %rdi
callq 0x31b0
cmpl $0x0, %eax
je 0x15c76
leaq 0xea99(%rip), %rdi      # 0x24708
movb $0x0, %al
callq 0xfed0
jmp 0x15c78
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/obscure.c
// Function: digitsBaseTwo
int digitsBaseTwo(unsigned long x)
/* Return base two # of digits. */
{
int digits = 0;
while (x)
    {
    digits += 1;
    x >>= 1;
    }
return digits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15cbc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
jmp 0x15c9f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x15cf3
movl $0x2, -0x8(%rbp)
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15cf5
cmpl $0xa, -0x4(%rbp)
jl 0x15d14
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x15cf5
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x181f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfa83(%rip), %rsi      # 0x2581f
callq 0xc4f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x14ff0
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc690
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
callq 0x31b0
cmpq $0x0, -0x18(%rbp)
je 0x15df8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x15d70
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xb840
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x15e72
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x152f0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xb840
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
cmpl $0x0, %eax
je 0x15ef2
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xb840
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ec5
leaq -0x10(%rbp), %rdi
callq 0x12ea0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
cmpl $0x0, %eax
je 0x15f82
jmp 0x15f5a
leaq -0x28(%rbp), %rdi
callq 0x9050
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x15f80
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10900
jmp 0x15f5a
jmp 0x15f42
leaq -0x20(%rbp), %rdi
callq 0x12ea0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x10(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x137c0
cmpl $0x0, %eax
je 0x1601b
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x13930
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
callq 0x10e40
jmp 0x15fd1
leaq -0x10(%rbp), %rdi
callq 0x12ea0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop