LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNeedNum
int lineFileNeedNum(struct lineFile *lf, char *words[], int wordIx)
/* Make sure that words[wordIx] is an ascii integer, and return
 * binary representation of it. Conversion stops at first non-digit char. */
{
char *ascii = words[wordIx];
char c = ascii[0];
if (c != '-' && !isdigit(c))
    errAbort("Expecting number field %d line %d of %s, got %s",
    	wordIx+1, lf->lineIx, lf->fileName, ascii);
return atoi(ascii);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %edx, %rax
movq (%rsi,%rax,8), %rbx
movsbq (%rbx), %r15
cmpq $0x2d, %r15
je 0xdcc0
movl %edx, %ebp
movq %rdi, %r14
callq 0x37a0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
jne 0xdcc0
incl %ebp
movl 0x28(%r14), %edx
movq 0x8(%r14), %rcx
leaq 0xc39b(%rip), %rdi      # 0x1a04f
movl %ebp, %esi
movq %rbx, %r8
xorl %eax, %eax
callq 0xb6c8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36a0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileAllInts
void lineFileAllInts(struct lineFile *lf, char *words[], int wordIx, void *val,
  boolean isSigned,  int byteCount, char *typeString, boolean noNeg)
/* Returns long long integer from converting the input string. Aborts on error. */
{
char *s = words[wordIx];
char errMsg[256];
int res = lineFileCheckAllIntsNoAbort(s, val, isSigned, byteCount, typeString, noNeg, errMsg, sizeof errMsg);
if (res > 0)
    {
    errAbort("%s in field %d line %d of %s, got %s",
	errMsg, wordIx+1, lf->lineIx, lf->fileName, s);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl %r9d, %r10d
movl %r8d, %eax
movl %edx, %ebx
movq %rdi, %r15
movq 0x120(%rsp), %r8
movl 0x128(%rsp), %r9d
movslq %edx, %rdx
movq (%rsi,%rdx,8), %r14
movq %rsp, %r11
movq %r14, %rdi
movq %rcx, %rsi
movl %eax, %edx
movl %r10d, %ecx
pushq $0x100                  # imm = 0x100
pushq %r11
callq 0xdcd2
addq $0x10, %rsp
testl %eax, %eax
je 0xdfa5
incl %ebx
movl 0x28(%r15), %ecx
movq 0x8(%r15), %r8
leaq 0xc216(%rip), %rdi      # 0x1a1ac
movq %rsp, %rsi
movl %ebx, %edx
movq %r14, %r9
xorl %eax, %eax
callq 0xb6c8
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileAllIntsArray
int lineFileAllIntsArray(struct lineFile *lf, char *words[], int wordIx, void *array, int arraySize,
  boolean isSigned,  int byteCount, char *typeString, boolean noNeg)
/* Convert comma separated list of numbers to an array.  Pass in
 * array and max size of array. Aborts on error. Returns number of elements in parsed array. */
{
char *s = words[wordIx];
char errMsg[256];
unsigned count = 0;
char *cArray = array;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
        break;
    e = strchr(s, ',');
    if (e)
        *e = 0;
    int res = lineFileCheckAllIntsNoAbort(s, cArray, isSigned, byteCount, typeString, noNeg, errMsg, sizeof errMsg);
    if (res > 0)
	{
	errAbort("%s in column %d of array field %d line %d of %s, got %s",
	    errMsg, count, wordIx+1, lf->lineIx, lf->fileName, s);
	}
    if (cArray) // NULL means validation only.
	cArray += byteCount;  
    count++;
    if (e)  // restore input string
        *e++ = ',';
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %r9d, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
movl %edx, 0x8(%rsp)
movslq %edx, %rax
movq (%rsi,%rax,8), %rbx
xorl %r13d, %r13d
testq %rbx, %rbx
je 0xdff6
movl %r8d, %r12d
movq %rcx, %r14
cmpb $0x0, (%rbx)
sete %al
testl %r8d, %r8d
sete %cl
orb %al, %cl
je 0xe00b
movl %r13d, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x8(%rsp)
movslq 0x160(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x1, %eax
movl %eax, %r13d
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x3260
movq %rax, %r15
testq %rax, %rax
je 0xe03d
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
movl 0x160(%rsp), %ecx
movq 0x168(%rsp), %r8
movl 0x170(%rsp), %r9d
pushq $0x100                  # imm = 0x100
leaq 0x28(%rsp), %rbp
pushq %rbp
callq 0xdcd2
addq $0x10, %rsp
testl %eax, %eax
je 0xe0a5
leal -0x1(%r13), %edx
movq 0x10(%rsp), %rax
movl 0x28(%rax), %r8d
movq 0x8(%rax), %r9
subq $0x8, %rsp
leaq 0xc13f(%rip), %rdi      # 0x1a1d1
movq %rbp, %rsi
movl 0x10(%rsp), %ecx
xorl %eax, %eax
pushq %rbx
callq 0xb6c8
addq $0x10, %rsp
testq %r15, %r15
je 0xdff6
movq 0x18(%rsp), %rax
addq %r14, %rax
testq %r14, %r14
cmovneq %rax, %r14
movb $0x2c, (%r15)
cmpb $0x0, 0x1(%r15)
je 0xdff6
incq %r15
leal 0x1(%r13), %eax
movq %r15, %rbx
cmpl %r13d, %r12d
jne 0xe021
jmp 0xdff6
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNeedDouble
double lineFileNeedDouble(struct lineFile *lf, char *words[], int wordIx)
/* Make sure that words[wordIx] is an ascii double value, and return
 * binary representation of it. */
{
char *valEnd;
char *val = words[wordIx];
double doubleValue;

doubleValue = strtod(val, &valEnd);
if ((*val == '\0') || (*valEnd != '\0'))
    errAbort("Expecting double field %d line %d of %s, got %s",
    	wordIx+1, lf->lineIx, lf->fileName, val);
return doubleValue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r15
movslq %edx, %rax
movq (%rsi,%rax,8), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3160
cmpb $0x0, (%r14)
je 0xe116
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0xe13d
incl %ebx
movl 0x28(%r15), %edx
movq 0x8(%r15), %rcx
leaq 0xc0e2(%rip), %rdi      # 0x1a209
movl %ebx, %esi
movq %r14, %r8
xorl %eax, %eax
movsd %xmm0, (%rsp)
callq 0xb6c8
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xe19f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
leaq 0xc0cb(%rip), %r13      # 0x1a239
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd043
testl %eax, %eax
jne 0xe18e
movq 0x8(%r14), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0xb6c8
decl %ebx
jne 0xe16e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0xad14
movq %rax, %r14
movq %rax, 0x10(%rsp)
movb $0x0, 0x34(%rbx)
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xd043
testl %eax, %eax
je 0xe25f
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
movq %r14, %rdi
callq 0xae1e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd043
testl %eax, %eax
jne 0xe23c
leaq 0x10(%rsp), %rdi
callq 0xad70
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0xd937
testl %eax, %eax
je 0xe882
leaq 0xbbb6(%rip), %r14      # 0x1a3c2
leaq 0xbbb7(%rip), %r15      # 0x1a3ca
leaq 0xbbdb(%rip), %r12      # 0x1a3f5
leaq 0x8(%rsp), %r13
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8038
testl %eax, %eax
jne 0xe841
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x8038
testl %eax, %eax
je 0xe866
movq 0x8(%rsp), %rdx
movl $0x2, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x12a31
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd937
testl %eax, %eax
jne 0xe81f
jmp 0xe882
movq 0x8(%rsp), %rdx
leaq 0xbb5e(%rip), %rsi      # 0x1a3d0
movl $0x2, %edi
xorl %eax, %eax
callq 0x12a31
movb $0x1, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x20, %edi
callq 0xee10
movq %rax, %r14
testl %ebx, %ebx
movl $0x4000, %esi           # imm = 0x4000
cmovgl %ebx, %esi
movq $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq $0x7, 0x18(%rax)
movq $-0x8, 0x10(%rax)
movq %rax, %rdi
callq 0xe8db
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
cmovaq %rax, %r14
addq $0x20, %r14
movq %r14, %rdi
callq 0xec7f
movq %rax, %r15
testq %rax, %rax
jne 0xe916
leaq 0xbb2e(%rip), %rdi      # 0x1a43a
movq %r14, %rsi
xorl %eax, %eax
callq 0xb6c8
leaq 0x20(%r15), %rax
movq %rax, 0x8(%r15)
addq %r15, %r14
movq %r14, 0x10(%r15)
movq (%rbx), %rax
movq %rax, (%r15)
movq %r15, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0xe95d
movq %rdi, %rbx
movq %r14, %rdi
callq 0x66de
movq %r14, %rdi
callq 0xeebc
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xe994
movq 0x10(%rcx), %rdx
subq %rcx, %rax
movq (%rcx), %rsi
addq %rdx, %rax
addq $-0x20, %rax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0xe97b
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
cmpq %rbx, %rsi
jae 0xe9c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe8db
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
addq 0x18(%r14), %rbx
andq 0x10(%r14), %rbx
addq %rcx, %rbx
cmpq %rdx, %rbx
cmovaq %rdx, %rbx
movq %rbx, 0x8(%rax)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea09
leaq (%rbx,%rcx), %rdx
cmpq 0x10(%rax), %rdx
jbe 0xea26
movq %rcx, %rsi
callq 0xe995
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34a0
cmpq %r14, %rcx
jbe 0xea2f
movq %rdx, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/localmem.c
// Function: lmCloneString
char *lmCloneString(struct lm *lm, char *string)
/* Return local mem copy of string. */
{
if (string == NULL)
    return NULL;
else
    return lmCloneStringZ(lm, string, strlen(string));
}

// Assembly:
testq %rsi, %rsi
je 0xeacf
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3200
movq %rax, %r15
incl %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0xe995
movslq %r15d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x34a0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7b0d
testq %rax, %rax
je 0xeaff
movq %rax, %rbx
movq %rax, %rdi
callq 0x8dcc
testq %rax, %rax
je 0xeb07
movq %rax, %r15
subq %rbx, %r15
jmp 0xeb12
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x3200
movq %rax, %r15
leal 0x1(%r15), %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0xe995
movslq %r15d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
testl %edx, %edx
js 0xeb6f
movq %rsi, %rax
movq %rdi, %rbx
je 0xeb5e
movl %edx, %ebp
movq %rax, %rdi
callq 0x7b0d
movq %rax, %rdi
callq 0x8dcc
testq %rax, %rax
je 0xeb6f
decl %ebp
jne 0xeb45
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xead2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe995
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x30e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1897a(%rip), %rbx     # 0x27548
leaq 0x1897b(%rip), %rcx     # 0x27550
movq %rbx, %rax
cmpq %rcx, %rbx
jne 0xebf2
leaq 0xb873(%rip), %rdi      # 0x1a457
xorl %eax, %eax
callq 0xb6c8
movq 0x18956(%rip), %rax     # 0x27548
movq (%rax), %rax
movq %rax, 0x1894c(%rip)     # 0x27548
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18944(%rip), %rdx     # 0x27570
cmpq %rdi, %rdx
seta %cl
testb %cl, %al
jne 0xec47
leaq 0xb834(%rip), %rdi      # 0x1a471
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq 0x188fa(%rip), %rax     # 0x27548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xec74
callq 0x30c0
movl (%rax), %edx
leaq 0xb841(%rip), %rdi      # 0x1a4ab
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x188c3(%rip), %rdx     # 0x27570
cmpq %rsi, %rdx
seta %cl
testb %cl, %al
jne 0xecc8
leaq 0xb82f(%rip), %rdi      # 0x1a4ed
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq 0x18879(%rip), %rax     # 0x27548
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xecf8
callq 0x30c0
movl (%rax), %edx
leaq 0xb83f(%rip), %rdi      # 0x1a52d
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xec96
movq %rax, %r14
subq %r15, %rbx
jbe 0xed2e
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_O3/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 0xed51
leaq 0xb82b(%rip), %rdi      # 0x1a575
xorl %eax, %eax
callq 0xb6c8
movq 0x187f0(%rip), %rax     # 0x27548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xed7e
callq 0x30c0
movl (%rax), %edx
leaq 0xb829(%rip), %rdi      # 0x1a59d
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1879a(%rip), %rax     # 0x27548
callq *0x18(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xedd1
callq 0x30c0
movl (%rax), %edx
leaq 0xb81c(%rip), %rdi      # 0x1a5e3
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeda0
movq %rax, %r14
subq %r15, %rbx
jbe 0xee07
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_O3/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 0xee3d
leaq 0xb7fe(%rip), %rdi      # 0x1a62c
movl $0x1dcd6500, %edx       # imm = 0x1DCD6500
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq 0x18704(%rip), %rax     # 0x27548
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
jne 0xee6a
callq 0x30c0
movl (%rax), %edx
leaq 0xb801(%rip), %rdi      # 0x1a661
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%rax)
testq %rdi, %rdi
je 0xeee8
movq 0x18663(%rip), %rax     # 0x27548
jmpq *0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x189bf(%rip)     # 0x278b0
je 0xefaf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x189af(%rip), %rax     # 0x278b8
movq (%rax), %r12
cmpq $0x0, (%r12)
je 0xefa1
movl $0xff676981, %ebp       # imm = 0xFF676981
leaq 0xb7c5(%rip), %rbx      # 0x1a6e8
leaq 0xb797(%rip), %r14      # 0x1a6c1
leaq 0xb76d(%rip), %r15      # 0x1a69e
movslq 0x10(%r12), %r13
movl 0x14(%r12), %esi
cmpl 0x18637(%rip), %esi     # 0x27578
je 0xef52
leaq 0x1(%r12), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0xb6c8
movl 0x18(%r12,%r13), %eax
cmpl 0x1861f(%rip), %eax     # 0x2757c
je 0xef86
movsbl 0x18(%r12,%r13), %esi
movsbl 0x19(%r12,%r13), %edx
movsbl 0x1a(%r12,%r13), %ecx
movsbl 0x1b(%r12,%r13), %r8d
leaq 0x1(%r12), %r9
movq %r14, %rdi
xorl %eax, %eax
callq 0xb6c8
testl %ebp, %ebp
jne 0xef94
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb6c8
movq (%r12), %r12
incl %ebp
cmpq $0x0, (%r12)
jne 0xef31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/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 %rbx
cmpq $0x0, 0x188b2(%rip)     # 0x278c8
je 0xf026
leaq 0xb6fa(%rip), %rdi      # 0x1a719
xorl %eax, %eax
callq 0xb6c8
movl $0x20, %edi
callq 0xee10
movq %rax, %rbx
movl $0x20, %edi
callq 0xee10
movq %rax, 0x18(%rbx)
leaq 0x47(%rip), %rcx        # 0xf08f
movq %rcx, 0x8(%rax)
leaq 0x77(%rip), %rcx        # 0xf0ca
movq %rcx, 0x10(%rax)
leaq 0x8e(%rip), %rcx        # 0xf0ec
movq %rcx, 0x18(%rax)
xorl %eax, %eax
callq 0xa904
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rax
movq 0x184d0(%rip), %rcx     # 0x27548
movq %rcx, (%rax)
movq %rax, 0x184c6(%rip)     # 0x27548
movq %rcx, 0x10(%rbx)
movq %rbx, 0x1883b(%rip)     # 0x278c8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1882d(%rip), %rax     # 0x278c8
movq 0x10(%rax), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xf0c3
movq %rax, %rbx
movq 0x18817(%rip), %rax     # 0x278c8
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0xa9f5
addq $0x18, %rbx
jmp 0xf0c5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf140
movq %rdi, %r14
addq $-0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
callq 0xaad8
movq 0x187b6(%rip), %rax     # 0x278c8
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
testq %rax, %rax
je 0xf14f
movq %rax, %rbx
movq 0x1879a(%rip), %rax     # 0x278c8
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0xa9f5
addq $0x18, %rbx
jmp 0xf151
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf08f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18764(%rip), %rbx     # 0x278c8
testq %rbx, %rbx
jne 0xf177
leaq 0xb5c8(%rip), %rdi      # 0x1a738
xorl %eax, %eax
callq 0xb6c8
movq $0x0, 0x18746(%rip) # 0x278c8
movq 0x183bf(%rip), %rax     # 0x27548
leaq 0x183c0(%rip), %rcx     # 0x27550
cmpq %rcx, %rax
jne 0xf1aa
leaq 0xb2bb(%rip), %rdi      # 0x1a457
xorl %eax, %eax
callq 0xb6c8
movq 0x1839e(%rip), %rax     # 0x27548
movq (%rax), %rax
movq %rax, 0x18394(%rip)     # 0x27548
leaq 0x8(%rbx), %rdi
callq 0xa959
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf1d0
movq 0x1837b(%rip), %rax     # 0x27548
callq *0x10(%rax)
movq 0x18371(%rip), %rax     # 0x27548
movq %rbx, %rdi
popq %rbx
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x186be(%rip), %r14     # 0x278c0
addq %rdi, %r14
movq 0x186c4(%rip), %rsi     # 0x278d0
cmpq %rsi, %r14
jbe 0xf240
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xfece
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xfece
leaq 0xb52b(%rip), %rdi      # 0x1a75e
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb6c8
movq %r14, 0x18679(%rip)     # 0x278c0
leaq 0x7(%rbx), %rax
cmpb $0x0, 0x18686(%rip)     # 0x278d8
cmoveq %rbx, %rax
addq $0x1c, %rax
movzbl 0x1867f(%rip), %ecx     # 0x278e0
xorl $0x1, %ecx
leaq -0x8(,%rcx,8), %rdi
andq %rax, %rdi
movq 0x1863a(%rip), %rax     # 0x278b0
callq *0x8(%rax)
movl %ebx, 0x10(%rax)
movl 0x182f6(%rip), %ecx     # 0x27578
movl %ecx, 0x14(%rax)
leaq 0x18(%rax), %r14
movl 0x182ed(%rip), %ecx     # 0x2757c
movl %ecx, 0x18(%rax,%rbx)
movq 0x1861e(%rip), %rdi     # 0x278b8
movq %rax, %rsi
callq 0xa9df
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x185fd(%rip)     # 0x278c0
movl -0x4(%rdi), %esi
cmpl 0x182ac(%rip), %esi     # 0x27578
je 0xf2df
leaq 0xb4cb(%rip), %rdi      # 0x1a7a0
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb6c8
movl (%rbx,%r14), %eax
cmpl 0x18293(%rip), %eax     # 0x2757c
je 0xf313
movsbl (%rbx,%r14), %esi
movsbl 0x1(%rbx,%r14), %edx
movsbl 0x2(%rbx,%r14), %ecx
movsbl 0x3(%rbx,%r14), %r8d
leaq 0xb4b9(%rip), %rdi      # 0x1a7c2
movq %rbx, %r9
xorl %eax, %eax
callq 0xb6c8
addq $-0x18, %rbx
movq %rbx, %rdi
callq 0xaad8
movq 0x1858a(%rip), %rax     # 0x278b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xf1ed
movq %rax, %r14
testq %rbx, %rbx
je 0xf361
movslq -0x8(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34a0
movq %rbx, %rdi
callq 0xf2b1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%rsp)
leaq 0xb46e(%rip), %rsi      # 0x1a7f0
callq 0x3480
testq %rax, %rax
je 0xf3af
movq %rax, %rbx
movq %rsp, %r14
movl $0x8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x944b
movq %rbx, %rdi
callq 0x3280
incq (%r14)
jmp 0xf3ce
leaq 0xb43e(%rip), %rsi      # 0x1a7f4
movq %r14, %rdi
callq 0x3480
movq %rax, %rbx
movq $0x1, (%rsp)
testq %rax, %rax
je 0xf3fd
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x36f0
movq %rbx, %rdi
callq 0x31c0
testl %eax, %eax
je 0xf3fd
leaq 0xa322(%rip), %rdi      # 0x19718
xorl %eax, %eax
callq 0xb7f4
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl %edi, %ecx
negl %ecx
cmovsl %edi, %ecx
shrl $0x1f, %eax
incl %eax
cmpl $0xa, %ecx
jb 0xf447
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
incl %eax
movl %ecx, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
cmpl $0x63, %ecx
movl %esi, %ecx
ja 0xf434
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10d40
movq %rax, %r14
leaq 0xb34c(%rip), %rsi      # 0x1a7f7
movq %r12, %rdi
callq 0x932b
movq %rax, %r12
leaq 0x1(%r14), %rdi
callq 0xec18
movq %rax, %r13
movq %rax, (%r15)
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x944b
movb $0x0, (%r13,%r14)
movq %r12, %rdi
callq 0x31c0
testq %rbx, %rbx
je 0xf4e9
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%r12)
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0xf48a
movq (%r12), %r12
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b48
movl %eax, %ebp
testl %eax, %eax
je 0xf559
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0xee10
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x8b48
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_O3/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
movl $0x1, %esi
callq 0xcef9
movq %rax, %r14
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
movq %rsp, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
je 0xf5c4
xorl %ebx, %ebx
movq %rsp, %r15
movq (%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b48
addl %eax, %ebx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
jne 0xf5a4
leaq 0x8(%rsp), %rdi
callq 0xd560
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl %esi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %rbx
movq %r14, %rdi
movl $0x1, %esi
callq 0xcef9
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq %rsp, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
je 0xf64b
movq %rsp, %r15
movq %r15, %rdi
callq 0x7292
testq %rax, %rax
je 0xf63a
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xbe46
jmp 0xf61e
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
jne 0xf61e
leaq 0x8(%rsp), %rdi
callq 0xd560
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x1, %esi
callq 0xcef9
movq %rax, %rbx
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0xdb76
testl %eax, %eax
je 0xf6e2
leaq 0x10(%rsp), %r15
movq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xdc76
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xc123
movq %rbx, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0xdb76
testl %eax, %eax
jne 0xf6ac
leaq 0x8(%rsp), %rdi
callq 0xd560
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %esi
callq 0xcef9
movq %rax, %rbx
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0xdb76
testl %eax, %eax
je 0xf775
movq %rsp, %r15
movq 0x20(%r14), %rdi
movq (%rsp), %r12
movq 0x8(%rsp), %rsi
callq 0xea94
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xbe46
movq %rbx, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0xdb76
testl %eax, %eax
jne 0xf741
leaq 0x10(%rsp), %rdi
callq 0xd560
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %esi
callq 0xcef9
movq %rax, %rbx
movq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
je 0xf7f3
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rdi
callq 0x6cb2
movq %rax, %r15
movq %r12, (%rax)
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd043
movq %r15, %r12
testl %eax, %eax
jne 0xf7ca
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x66bb
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee10
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x35b0
movl %eax, %ebp
testl %eax, %eax
jns 0xf85c
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xafab(%rip), %rdi      # 0x1a7fa
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x35f0
movl %eax, %r15d
testl %eax, %eax
jns 0xf897
movl %ebp, %edi
callq 0x3350
callq 0x30c0
movl (%rax), %edi
callq 0x3720
leaq 0xaf70(%rip), %rdi      # 0x1a7fa
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb6c8
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x33d0
testl %eax, %eax
jle 0xf8f8
leaq 0xaf5f(%rip), %r12      # 0x1a810
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %r15d, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31a0
testq %rax, %rax
jns 0xf8e5
callq 0x30c0
movl (%rax), %edi
callq 0x3720
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb6c8
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x33d0
testl %eax, %eax
jg 0xf8b1
movl %ebp, %edi
callq 0x3350
movl %r15d, %edi
callq 0x3350
testl %eax, %eax
je 0xf919
leaq 0x9e07(%rip), %rdi      # 0x19719
xorl %eax, %eax
callq 0xb7f4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xeebc
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x3340
cmpl $-0x1, %eax
je 0xf94c
movl %eax, %edi
movq %rbx, %rsi
callq 0x33a0
movq %r14, %rdi
jmp 0xf933
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0xf966
leaq 0xaec8(%rip), %rdi      # 0x1a827
xorl %eax, %eax
callq 0xb7f4
movq %rbx, %rdi
callq 0x3110
testl %eax, %eax
je 0xf987
leaq 0xaebf(%rip), %rdi      # 0x1a838
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq