LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainReadBlocks
void chainReadBlocks(struct lineFile *lf, struct chain *chain)
/* Read in chain blocks from file. */
{
char *row[3];
int q,t;

/* Now read in block list. */
q = chain->qStart;
t = chain->tStart;
for (;;)
    {
    int wordCount = lineFileChop(lf, row);
    int size = lineFileNeedNum(lf, row, 0);
    struct cBlock *b;
    AllocVar(b);
    slAddHead(&chain->blockList, b);
    b->qStart = q;
    b->tStart = t;
    q += size;
    t += size;
    b->qEnd = q;
    b->tEnd = t;
    if (wordCount == 1)
        break;
    else if (wordCount < 3)
        errAbort("Expecting 1 or 3 words line %d of %s\n", 
		lf->lineIx, lf->fileName);
    t += lineFileNeedNum(lf, row, 1);
    q += lineFileNeedNum(lf, row, 2);
    }
if (q != chain->qEnd)
    errAbort("q end mismatch %d vs %d line %d of %s\n", 
    	q, chain->qEnd, lf->lineIx, lf->fileName);
if (t != chain->tEnd)
    errAbort("t end mismatch %d vs %d line %d of %s\n", 
    	t, chain->tEnd, lf->lineIx, lf->fileName);
slReverse(&chain->blockList);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x24(%rsi), %r15d
movl 0x40(%rsi), %ebp
movq %rsi, 0x8(%rsp)
leaq 0x8(%rsi), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
pushq $0x3
popq %rdx
callq 0x2619f
movl %eax, %ebx
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x263ca
movl %eax, %r13d
pushq $0x28
popq %rdi
callq 0x28bb0
movq (%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, (%rax)
movq %rax, (%rdx)
movl %ebp, 0x10(%rax)
movl %r15d, 0x8(%rax)
addl %r13d, %ebp
addl %r15d, %r13d
movl %ebp, 0x14(%rax)
movl %r13d, 0xc(%rax)
cmpl $0x1, %ebx
je 0x1b393
cmpl $0x2, %ebx
jg 0x1b36a
movl 0x28(%r14), %esi
movq 0x8(%r14), %rdx
leaq 0x638d8(%rip), %rdi     # 0x7ec3b
xorl %eax, %eax
callq 0x223fb
movq %r14, %rdi
movq %r12, %rsi
pushq $0x1
popq %rdx
callq 0x263ca
movl %eax, %r15d
addl %r13d, %r15d
movq %r14, %rdi
movq %r12, %rsi
pushq $0x2
popq %rdx
callq 0x263ca
addl %eax, %ebp
jmp 0x1b301
movq 0x8(%rsp), %rbx
movl 0x44(%rbx), %edx
cmpl %edx, %ebp
je 0x1b3b7
movl 0x28(%r14), %ecx
movq 0x8(%r14), %r8
leaq 0x638b3(%rip), %rdi     # 0x7ec61
movl %ebp, %esi
xorl %eax, %eax
callq 0x223fb
movl 0x28(%rbx), %edx
cmpl %edx, %r13d
je 0x1b3d8
movl 0x28(%r14), %ecx
movq 0x8(%r14), %r8
leaq 0x638ba(%rip), %rdi     # 0x7ec88
movl %r13d, %esi
xorl %eax, %eax
callq 0x223fb
movq (%rsp), %rdi
callq 0x1c567
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainRead
struct chain *chainRead(struct lineFile *lf)
/* Read next chain from file.  Return NULL at EOF. 
 * Note that chain block scores are not filled in by
 * this. */
{
struct chain *chain = chainReadChainLine(lf);
if (chain != NULL)
    chainReadBlocks(lf, chain);
return chain;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1b110
movq %rax, %rbx
testq %rax, %rax
je 0x1b40f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainSwap
void chainSwap(struct chain *chain)
/* Swap target and query side of chain. */
{
struct chain old = *chain;
struct cBlock *b;

/* Copy basic stuff swapping t and q. */
chain->qName = old.tName;
chain->tName = old.qName;
chain->qStart = old.tStart;
chain->qEnd = old.tEnd;
chain->tStart = old.qStart;
chain->tEnd = old.qEnd;
chain->qSize = old.tSize;
chain->tSize = old.qSize;

/* Swap t and q in blocks. */
for (b = chain->blockList; b != NULL; b = b->next)
    {
    struct cBlock old = *b;
    b->qStart = old.tStart;
    b->qEnd = old.tEnd;
    b->tStart = old.qStart;
    b->tEnd = old.qEnd;
    }

/* Cope with the minus strand. */
if (chain->qStrand == '-')
    {
    /* chain's are really set up so that the target is on the
     * + strand and the query is on the minus strand.
     * Therefore we need to reverse complement both 
     * strands while swapping to preserve this. */
    for (b = chain->blockList; b != NULL; b = b->next)
        {
	reverseIntRange(&b->tStart, &b->tEnd, chain->tSize);
	reverseIntRange(&b->qStart, &b->qEnd, chain->qSize);
	}
    reverseIntRange(&chain->tStart, &chain->tEnd, chain->tSize);
    reverseIntRange(&chain->qStart, &chain->qEnd, chain->qSize);
    slReverse(&chain->blockList);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movl 0x20(%rdi), %ecx
leaq 0x24(%rdi), %r12
leaq 0x28(%rdi), %r13
movq 0x30(%rdi), %rdx
movl 0x38(%rdi), %esi
leaq 0x40(%rdi), %rdi
leaq 0x44(%rbx), %r15
movq %rax, 0x30(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x40(%rbx), %rax
movq 0x24(%rbx), %rdx
movq %rdx, 0x40(%rbx)
movq %rax, 0x24(%rbx)
movl %ecx, 0x38(%rbx)
movl %esi, 0x20(%rbx)
leaq 0x8(%rbx), %r14
movq %r14, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1b484
movdqu 0x8(%rax), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x8(%rax)
jmp 0x1b46b
cmpb $0x2d, 0x3c(%rbx)
jne 0x1b4bc
movq %rdi, (%rsp)
movq %r14, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x1b4cb
leaq 0x8(%rbp), %rdi
leaq 0xc(%rbp), %rsi
movl 0x20(%rbx), %edx
callq 0x20d61
leaq 0x10(%rbp), %rdi
leaq 0x14(%rbp), %rsi
movl 0x38(%rbx), %edx
callq 0x20d61
jmp 0x1b491
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%rbx), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x20d61
movl 0x38(%rbx), %edx
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x20d61
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c567
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainReadUsedSwapLf
struct hash *chainReadUsedSwapLf(char *fileName, boolean swapQ, Bits *bits, struct lineFile *lf)
/* Read chains that are marked as used in the 
 * bits array (which may be NULL) into a hash keyed by id. */
{
char nameBuf[16];
struct hash *hash = hashNew(18);
struct chain *chain;
int usedCount = 0, count = 0;

while ((chain = chainRead(lf)) != NULL)
    {
    ++count;
    if (bits != NULL && !bitReadOne(bits, chain->id))
	{
	chainFree(&chain);
        continue;
	}
    safef(nameBuf, sizeof(nameBuf), "%x", chain->id);
    if (hashLookup(hash, nameBuf))
        errAbort("Duplicate chain %d ending line %d of %s", 
		chain->id, lf->lineIx, lf->fileName);
    if (swapQ)
        chainSwap(chain);
    hashAdd(hash, nameBuf, chain);
    ++usedCount;
    }
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
pushq $0x12
popq %rdi
pushq $0x1
popq %rsi
callq 0x245c9
movq %rax, %r15
leaq 0x10(%rsp), %r13
pushq $0x10
popq %r12
movq %rbx, %rdi
callq 0x1b3f0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1b5d0
testq %r14, %r14
je 0x1b55a
movl 0x48(%rax), %esi
movq %r14, %rdi
callq 0x1854e
testl %eax, %eax
je 0x1b5c1
movq 0x8(%rsp), %rax
movl 0x48(%rax), %ecx
movq %r13, %rdi
movl %r12d, %esi
leaq 0x66e87(%rip), %rdx     # 0x823f1
xorl %eax, %eax
callq 0x1fab2
movq %r15, %rdi
movq %r13, %rsi
callq 0x24088
testq %rax, %rax
je 0x1b59e
movq 0x8(%rsp), %rax
movl 0x48(%rax), %esi
movl 0x28(%rbx), %edx
movq 0x8(%rbx), %rcx
leaq 0x63718(%rip), %rdi     # 0x7ecaf
xorl %eax, %eax
callq 0x223fb
testl %ebp, %ebp
je 0x1b5ac
movq 0x8(%rsp), %rdi
callq 0x1b41a
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x242d0
jmp 0x1b52b
leaq 0x8(%rsp), %rdi
callq 0x1accc
jmp 0x1b52b
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainReadUsedSwap
struct hash *chainReadUsedSwap(char *fileName, boolean swapQ, Bits *bits)
/* Read chains that are marked as used in the 
 * bits array (which may be NULL) into a hash keyed by id. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = chainReadUsedSwapLf(fileName, swapQ, NULL, lf);
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
pushq $0x1
popq %rsi
callq 0x25467
movq %rsp, %r14
movq %rax, (%r14)
movl %ebx, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x1b4fe
movq %rax, %rbx
movq %r14, %rdi
callq 0x25cd8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainReadAllWithMeta
struct hash *chainReadAllWithMeta(char *fileName, FILE *f)
/* Read chains into a hash keyed by id. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = NULL;
lineFileSetMetaDataOutput(lf, f);
hash = chainReadUsedSwapLf(fileName, FALSE, NULL, lf);
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
pushq $0x1
popq %rsi
callq 0x25467
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x24e7b
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1b4fe
movq %rax, %rbx
movq %r15, %rdi
callq 0x25cd8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chain.c
// Function: chainRangeQPlusStrand
void chainRangeQPlusStrand(struct chain *chain, int *retQs, int *retQe)
/* Return range of bases covered by chain on q side on the plus
 * strand. */
{
if (chain == NULL)
    errAbort("chain::chainRangeQPlusStrand() - Can't find range in null query chain.");
if (chain->qStrand == '-')
    {
    *retQs = chain->qSize - chain->qEnd;
    *retQe = chain->qSize - chain->qStart;
    }
else
    {
    *retQs = chain->qStart;
    *retQe = chain->qEnd;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
jne 0x1ba59
leaq 0x63285(%rip), %rdi     # 0x7ecd7
xorl %eax, %eax
callq 0x223fb
cmpb $0x2d, 0x3c(%r14)
jne 0x1ba75
movl 0x38(%r14), %eax
subl 0x44(%r14), %eax
movl %eax, (%r15)
movl 0x38(%r14), %eax
subl 0x40(%r14), %eax
jmp 0x1ba80
movl 0x40(%r14), %eax
movl %eax, (%r15)
movl 0x44(%r14), %eax
movl %eax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chainBlock.c
// Function: kdLeafCmpTotal
static int kdLeafCmpTotal(const void *va, const void *vb)
/* Compare to sort based on total score. */
{
const struct kdLeaf *a = *((struct kdLeaf **)va);
const struct kdLeaf *b = *((struct kdLeaf **)vb);
double diff = b->totalScore - a->totalScore;
if (diff < 0) return -1;
else if (diff > 0) return 1;
else return 0;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
movsd 0x18(%rcx), %xmm0
subsd 0x18(%rax), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
ucomisd %xmm0, %xmm1
pushq $-0x1
popq %rax
cmovbel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chainBlock.c
// Function: kdBuild
static struct kdBranch *kdBuild(int nodeCount, struct dlList *lists[2], int dim,
	struct lm *lm)
/* Build up kd-tree recursively. */
{
struct kdBranch *branch;
lmAllocVar(lm, branch);
if (nodeCount == 1)
    {
    struct kdLeaf *leaf = lists[0]->head->val;
    branch->leaf = leaf;
    branch->maxQ = leaf->cb->qEnd;
    branch->maxT = leaf->cb->tEnd;
    }
else
    {
    int newCount;
    struct dlList *newLists[2];
    struct dlList newQ, newT;
    int nextDim = 1-dim;

    /* Subdivide lists along median.  */
    newLists[0] = &newQ;
    newLists[1] = &newT;
    clearHits(lists[0]);
    branch->cutCoord = medianVal(lists[dim], nodeCount/2, dim);
    newCount = splitList(lists[0], newLists[0]);
    splitList(lists[1], newLists[1]);

    /* Recurse on each side. */
    branch->lo = kdBuild(nodeCount - newCount, lists, nextDim, lm);
    branch->hi = kdBuild(newCount, newLists, nextDim, lm);
    branch->maxQ = max(branch->lo->maxQ, branch->hi->maxQ);
    branch->maxT = max(branch->lo->maxT, branch->hi->maxT);
    }
return branch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movl %edi, %ebp
pushq $0x30
popq %rsi
movq %rcx, %rdi
callq 0x26ff4
movq %rax, %rbx
cmpl $0x1, %ebp
jne 0x1bf6f
movq (%r15), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rax), %rax
movl 0x14(%rax), %ecx
movl %ecx, 0x28(%rbx)
movl 0xc(%rax), %eax
movl %eax, 0x2c(%rbx)
jmp 0x1c04b
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%r15), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1bf9d
movq 0x10(%rax), %rax
movb $0x0, 0x20(%rax)
movq %rcx, %rax
jmp 0x1bf88
movl %r12d, %eax
movq (%r15,%rax,8), %rcx
pushq $0x2
popq %rsi
movl %ebp, %eax
cltd
idivl %esi
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
subl $0x1, %eax
jb 0x1bfc5
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movb $0x1, 0x20(%rdx)
jmp 0x1bfb3
pushq $0x1
popq %r13
subl %r12d, %r13d
xorl %eax, %eax
testl %r12d, %r12d
sete %al
movq 0x8(%rdx), %rcx
movl 0x8(%rcx,%rax,8), %eax
movl %eax, 0x18(%rbx)
leaq 0x30(%rsp), %rsi
callq 0x1c05d
movl %eax, %r12d
movq 0x8(%r15), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1c05d
subl %r12d, %ebp
movl %ebp, %edi
movq %r15, %rsi
movl %r13d, %edx
movq %r14, %rcx
callq 0x1bf20
movq %rax, (%rbx)
movq %rsp, %rsi
movl %r12d, %edi
movl %r13d, %edx
movq %r14, %rcx
callq 0x1bf20
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x28(%rcx), %xmm0
movq 0x28(%rax), %xmm1
movdqa %xmm0, %xmm2
pcmpgtd %xmm1, %xmm2
pand %xmm2, %xmm0
pandn %xmm1, %xmm2
por %xmm0, %xmm2
movq %xmm2, 0x28(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chainBlock.c
// Function: splitList
static int splitList(struct dlList *oldList, struct dlList *newList)
/* Peel off members of oldList that are not hit onto new list. */
{
struct dlNode *node, *next;
struct kdLeaf *leaf;
int newCount = 0;
dlListInit(newList);
for (node = oldList->head; !dlEnd(node); node = next)
    {
    next = node->next;
    leaf = node->val;
    if (!leaf->hit)
	{
	dlRemove(node);
	dlAddTail(newList, node);
	++newCount;
	}
    }
return newCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20294
movq (%r14), %r15
xorl %ebp, %ebp
movq %r15, %r14
movq (%r15), %r15
testq %r15, %r15
je 0x1c0a3
movq 0x10(%r14), %rax
cmpb $0x0, 0x20(%rax)
jne 0x1c077
movq %r14, %rdi
callq 0x2046a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2038f
incl %ebp
jmp 0x1c077
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/chainBlock.c
// Function: updateScoresOnWay
static void updateScoresOnWay(struct kdBranch *branch, 
	int dim, struct kdLeaf *leaf)
/* Traverse kd-tree to find leaf.  Update all maxScores on the way
 * to reflect leaf->totalScore. */
{
int newDim = 1-dim;
int dimCoord = (dim == 0 ? leaf->cb->qStart : leaf->cb->tStart);
if (branch->maxScore < leaf->totalScore) branch->maxScore = leaf->totalScore;
if (branch->leaf == NULL)
    {
    if (dimCoord <= branch->cutCoord)
	updateScoresOnWay(branch->lo, newDim, leaf);
    if (dimCoord >= branch->cutCoord)
	updateScoresOnWay(branch->hi, newDim, leaf);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
xorl %eax, %eax
testl %esi, %esi
sete %al
movq 0x8(%rbx), %rcx
movl 0x8(%rcx,%rax,8), %r12d
movsd 0x18(%rbx), %xmm0
ucomisd 0x20(%r14), %xmm0
jbe 0x1c23d
movsd %xmm0, 0x20(%r14)
cmpq $0x0, 0x10(%r14)
jne 0x1c270
movl %r15d, %ebp
subl %esi, %ebp
movl 0x18(%r14), %eax
cmpl %eax, %r12d
jg 0x1c263
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1c208
movl 0x18(%r14), %eax
cmpl %eax, %r12d
jl 0x1c270
movq 0x8(%r14), %r14
movl %ebp, %esi
jmp 0x1c21a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: doubleBoxWhiskerCalc
void doubleBoxWhiskerCalc(int count, double *array, double *retMin,
                          double *retQ1, double *retMedian, double *retQ3, double *retMax)
/* Calculate what you need to draw a box and whiskers plot from an array of doubles. */
{
if (count <= 0)
    errAbort("doubleBoxWhiskerCalc needs a positive number, not %d for count", count);
if (count == 1)
    {
    *retMin = *retQ1 = *retMedian = *retQ3 = *retMax = array[0];
    return;
    }
doubleSort(count, array);
double min = array[0];
double max = array[count-1];
double median;
int halfCount = count>>1;
if ((count&1) == 1)
    median = array[halfCount];
else
    {
    median = (array[halfCount] + array[halfCount-1]) * 0.5;
    }
double q1, q3;
if (count <= 3)
    {
    q1 = 0.5 * (median + min);
    q3 = 0.5 * (median + max);
    }
else
    {
    int q1Ix = count/4;
    int q3Ix = count - 1 - q1Ix;
    verbose(4, "count %d, q1Ix %d, q3Ix %d\n", count, q1Ix, q3Ix);
    q1 = array[q1Ix];
    q3 = array[q3Ix];
    }
*retMin = min;
*retQ1 = q1;
*retMedian = median;
*retQ3 = q3;
*retMax = max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebp
testl %edi, %edi
jle 0x1c8b5
cmpl $0x1, %ebp
jne 0x1c8c5
movsd (%r13), %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
movsd %xmm0, (%rbx)
movsd %xmm0, (%r14)
movsd %xmm0, (%r15)
movsd %xmm0, (%r12)
jmp 0x1c9b3
leaq 0x6247e(%rip), %rdi     # 0x7ed3a
movl %ebp, %esi
xorl %eax, %eax
callq 0x223fb
movl %ebp, %edi
movq %r13, %rsi
callq 0x1c7f5
movslq %ebp, %rax
movl %ebp, %ecx
sarl %ecx
movslq %ecx, %rcx
movsd (%r13,%rcx,8), %xmm3
testb $0x1, %bpl
jne 0x1c8f5
addsd -0x8(%r13,%rcx,8), %xmm3
mulsd 0x614a3(%rip), %xmm3    # 0x7dd98
movsd (%r13), %xmm5
movsd -0x8(%r13,%rax,8), %xmm4
cmpl $0x3, %ebp
jg 0x1c929
movapd %xmm5, %xmm0
addsd %xmm3, %xmm0
movsd 0x61481(%rip), %xmm2    # 0x7dd98
mulsd %xmm2, %xmm0
movapd %xmm4, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
jmp 0x1c996
movq %rbx, 0x20(%rsp)
leal -0x1(%rbp), %ebx
movq %r14, 0x18(%rsp)
movl %ebp, %r14d
shrl $0x2, %r14d
subl %r14d, %ebx
leaq 0x62432(%rip), %rsi     # 0x7ed79
pushq $0x4
popq %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
movsd %xmm3, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm5, (%rsp)
callq 0x3c521
movsd (%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm3
movsd (%r13,%r14,8), %xmm0
movq 0x18(%rsp), %r14
movslq %ebx, %rax
movq 0x20(%rsp), %rbx
movsd (%r13,%rax,8), %xmm1
movsd %xmm5, (%r12)
movsd %xmm0, (%r15)
movsd %xmm3, (%r14)
movsd %xmm1, (%rbx)
movq 0x60(%rsp), %rax
movsd %xmm4, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: slNameListFromCommaEscaped
struct slName *slNameListFromCommaEscaped(char *s)
/* Return list of slNames gotten from parsing comma delimited string.
 * The final comma is optional. a,b,c  and a,b,c, are equivalent
 * for comma-delimited lists. To escape commas, put two in a row, 
 * which eliminates the possibility for null names 
 * (eg.  a,,b,c will parse to two elements a,b and c). */
{
if (s == NULL)
    return NULL;

struct slName *list = NULL;
char buffer[strlen(s) + 1], *ptr = buffer;

for (; *s != 0; s++)
    {
    *ptr++ = *s;
    if (*s == ',')
        {
        if (s[1] != ',') // if next character not also a ,
            {
            // we found the delimeter, add the string to the list
            slAddHead(&list, slNameNewN(buffer, ptr - buffer - 1));
            ptr = buffer;   // start a new buffer
            }
        else
            s++; // skip the quoting comma and continue
        }
    }

if (ptr > buffer)  // is there something in the buffer
    slAddHead(&list, slNameNewN(buffer, ptr - buffer)); // add it to the list

slReverse(&list);
return list;
}

// Assembly:
testq %rdi, %rdi
je 0x1d002
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, -0x28(%rbp)
callq 0x62d0
movq %rsp, %r15
movq %rsp, %r14
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %r14, %r12
notq %r12
movq %r14, %rsi
movb (%rbx), %al
testb %al, %al
je 0x1cfc8
movb %al, (%rsi)
incq %rsi
cmpb $0x2c, (%rbx)
jne 0x1cfc3
cmpb $0x2c, 0x1(%rbx)
jne 0x1cfaa
incq %rbx
jmp 0x1cfc3
addl %r12d, %esi
movq %r14, %rdi
callq 0x1cbc5
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x28(%rbp)
movq %r14, %rsi
incq %rbx
jmp 0x1cf8f
cmpq %r14, %rsi
jbe 0x1cfe3
subl %r14d, %esi
movq %r14, %rdi
callq 0x1cbc5
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
movq %r15, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: slNameListToString
char *slNameListToString(struct slName *list, char delimiter)
/* Return string created by joining all names with the delimiter. */
{
struct slName *el;
int elCount = 0;
int len = 0;
char del[2];
char *s;

if (list == NULL)
    return cloneString("");

del[0] = delimiter;
del[1] = '\0';

for (el = list; el != NULL; el = el->next, elCount++)
	len += strlen(el->name);
len += elCount;

AllocArray(s, len);

for (el = list; el != NULL; el = el->next)
	{
	strcat(s, el->name);
	if (el->next != NULL)
		strcat(s, del);
	}
return s;
}

// Assembly:
testq %rdi, %rdi
je 0x1d0f6
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb %sil, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
xorl %ebp, %ebp
movq %rdi, %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x1d0a3
leaq 0x8(%r15), %rdi
callq 0x62d0
addl %eax, %r14d
movq (%r15), %r15
incl %ebp
jmp 0x1d08b
addl %r14d, %ebp
movslq %ebp, %rdi
callq 0x28a1f
movq %rax, %r14
leaq 0xe(%rsp), %r15
testq %rbx, %rbx
je 0x1d0e6
movq %rbx, %r12
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6d60
cmpq $0x0, (%rbx)
movl $0x0, %ebx
je 0x1d0b6
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d60
movq (%r12), %rbx
jmp 0x1d0b6
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a280(%rip), %rdi     # 0x8737d
jmp 0x1c306
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: slPairFreeValsExt
void slPairFreeValsExt(struct slPair *list, void (*freeFunc)())
/* Free up all values on list using freeFunc.
 * freeFunc should take a simple pointer to free an item, and can be NULL. */
{
struct slPair *el;
for (el = list; el != NULL; el = el->next)
    {
    if (freeFunc)
        freeFunc(el->val);
    else
        freez(&el->val);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x1d3aa
leaq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x1d3a0
movq (%rdi), %rdi
xorl %eax, %eax
callq *%rbx
jmp 0x1d3a5
callq 0x28c3d
movq (%r14), %r14
jmp 0x1d389
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: startsWithNoCase
boolean startsWithNoCase(const char *start, const char *string)
/* Returns TRUE if string begins with start, case-insensitive. */
{
char c;
int i;

for (i=0; ;i += 1)
    {
    if ((c = tolower(start[i])) == 0)
        return TRUE;
    if (tolower(string[i]) != c)
        return FALSE;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6160
movq (%rax), %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
movsbq (%r14,%rdx), %rsi
movl (%rcx,%rsi,4), %esi
shll $0x18, %esi
je 0x1db92
sarl $0x18, %esi
movsbq (%rbx,%rdx), %rdi
incq %rdx
cmpl %esi, (%rcx,%rdi,4)
je 0x1db73
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: nextStringBetween
char *nextStringBetween(char *start, char *end, char **pHaystack)
/* Return next string that occurs between start and end strings
 * starting seach at *pHaystack.  This will update *pHaystack to after 
 * end, so it can be called repeatedly. Returns NULL when
 * no more to be found*/
{
char *pos, *p;
int len;
char *haystack = *pHaystack;
if (isEmpty(haystack))
    return NULL;
if ((p = stringIn(start, haystack)) != NULL)
    {
    pos = p + strlen(start);
    if ((p = stringIn(end, pos)) != NULL)
        {
        len = p - pos;
        pos = cloneMem(pos, len + 1);
        pos[len] = 0;
	*pHaystack = p;
        return pos;
        }
    }
*pHaystack = NULL;
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x1ddde
cmpb $0x0, (%rdi)
je 0x1ddde
movq %rdx, %rbx
movq %rsi, %r14
movq %r12, %rsi
callq 0x6180
testq %rax, %rax
je 0x1dde3
movq %rax, %r15
movq %r12, %rdi
callq 0x62d0
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6180
testq %rax, %rax
je 0x1dde3
movq %rax, %r14
movq %rax, %rbp
subq %r15, %rbp
leal 0x1(%rbp), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x289b8
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6570
movslq %ebp, %rax
movb $0x0, (%r12,%rax)
jmp 0x1dde9
xorl %r12d, %r12d
jmp 0x1ddec
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r14, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: chopByWhiteRespectDoubleQuotes
int chopByWhiteRespectDoubleQuotes(char *in, char *outArray[], int outSize)
// NOTE: this routine does not do what this comment says.  It did not ever remove quotes due to
// a coding error so I took out the code that pretended to be doing this.
/* Like chopString, but specialized for white space separators.
 * Further, any doubleQuotes (") are respected.
 * If doubleQuote is encloses whole string, then they are removed:
 *   "Fred and Ethyl" results in word [Fred and Ethyl]
 * If doubleQuotes exist inside string they are retained:
 *   Fred" and Ethyl" results in word [Fred" and Ethyl"]
 * Special note "" is a valid, though empty word. */
{
int recordCount = 0;
char c;
boolean quoting = FALSE;
for (;;)
    {
    if (outArray != NULL && recordCount >= outSize)
        break;

    /* Skip initial separators. */
    while (isspace(*in)) ++in;
    if (*in == 0)
        break;

    /* Store start of word and look for end of word. */
    if (outArray != NULL)
        outArray[recordCount] = in;
    recordCount += 1;
    quoting = FALSE;
    for (;;)
        {
        if ((c = *in) == 0)
            break;
        if (quoting)
            {
            if (c == '"')
                quoting = FALSE;
            }
        else
            {
            quoting = (c == '"');
            if (isspace(c))
                break;
            }
        ++in;
        }
    if (*in == 0)
        break;

    /* Tag end of word with zero. */
    if (outArray != NULL)
        *in = 0;
    /* And skip over the zero. */
    in += 1;
    }
return recordCount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r12
xorl %ebx, %ebx
testq %r14, %r14
sete %al
cmpq %r12, %rbx
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1e6c9
callq 0x6790
movq (%rax), %rdx
leaq -0x1(%r15), %rcx
incq %r15
movq %r15, %rdi
movq %rdi, %r15
movsbq 0x1(%rcx), %rsi
incq %rcx
incq %rdi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x1e664
testb %sil, %sil
je 0x1e6c9
testq %r14, %r14
je 0x1e687
movq %rcx, (%r14,%rbx,8)
incq %rbx
xorl %ecx, %ecx
movsbq -0x1(%r15), %rdx
testq %rdx, %rdx
je 0x1e6c9
testl %ecx, %ecx
je 0x1e6a2
cmpb $0x22, %dl
setne %cl
jmp 0x1e6b2
cmpb $0x22, %dl
sete %cl
movq (%rax), %rsi
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0x1e6ba
movzbl %cl, %ecx
incq %r15
jmp 0x1e68c
testq %r14, %r14
je 0x1e63f
movb $0x0, -0x1(%r15)
jmp 0x1e63f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: eraseTrailingSpaces
int eraseTrailingSpaces(char *s)
/* Replace trailing white space with zeroes. Returns number of
 * spaces erased. */
{
int len = strlen(s);
int i;
char c;
int erased = 0;

for (i=len-1; i>=0; --i)
    {
    c = s[i];
    if (isspace(c))
	{
	s[i] = 0;
	++erased;
	}
    else
	break;
    }
return erased;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x62d0
movq %rax, %rbx
movl %ebx, %eax
leaq (%rax,%r14), %r15
decq %r15
xorl %r14d, %r14d
leal (%rbx,%r14), %eax
testl %eax, %eax
jle 0x1e7de
movsbq (%r15,%r14), %r12
callq 0x6790
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x1e7de
movb $0x0, (%r15,%r14)
decq %r14
jmp 0x1e7b7
negl %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: eraseNonDigits
void eraseNonDigits(char *s)
{
char *in, *out;
char c;

in = out = s;
for (;;)
    {
    c = *in++;
    if (c == 0)
        break;
    if (isdigit(c))
        *out++ = c;
    }
*out = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movsbq (%r14), %r15
testq %r15, %r15
je 0x1e857
incq %r14
callq 0x6790
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
je 0x1e833
movb %r15b, (%rbx)
incq %rbx
jmp 0x1e833
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: cloneFirstWordByDelimiterNoSkip
char *cloneFirstWordByDelimiterNoSkip(char *line,char delimit)
/* Returns a cloned first word, not harming the memory passed in. Does not skip leading white space.*/
{
if (line == NULL || *line == 0)
    return NULL;
int size=0;
char *e;
for (e=line;*e!=0;e++)
    {
    if (*e==delimit)
        break;
    else if (delimit == ' ' && isspace(*e))
        break;
    size++;
    }
if (size == 0)
    return NULL;
char *new = needMem(size + 2); // Null terminated by 2
memcpy(new, line, size);
return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1eae1
movq %rdi, %rbx
movb (%rdi), %r15b
testb %r15b, %r15b
je 0x1eae1
movl %esi, %ebp
xorl %r14d, %r14d
testb %r15b, %r15b
je 0x1eabb
cmpb %bpl, %r15b
je 0x1eabb
cmpb $0x20, %bpl
jne 0x1eab1
callq 0x6790
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x1eabb
movb 0x1(%rbx,%r14), %r15b
incq %r14
jmp 0x1ea8e
testl %r14d, %r14d
je 0x1eae1
leaq 0x2(%r14), %rdi
callq 0x28bb0
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6570
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: cmpStringOrder
int cmpStringOrder(char *a, char *b, char **orderFields, int orderCount)
/* Compare two strings to sort in same order as orderedFields.  If strings are
 * not in order, will sort them to be after all ordered fields, alphabetically */
{
int aIx = stringArrayIx(a, orderFields, orderCount);
int bIx = stringArrayIx(b, orderFields, orderCount);
if (aIx < 0)	// A not in list?
    {
    if (bIx < 0)	// Neither in list, be alphabetical
	return(strcmp(a, b));
    else		// Only b in list, move a towards end
	return 1;
    }
else if (bIx < 0)	// Only a in list, move b towards end
    return -1;
else
    return aIx - bIx;   // Both in ordered list, just subtract indexes to sort
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
movl %ecx, %edx
callq 0x1ebb7
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x1ebb7
testl %ebp, %ebp
js 0x1ec39
subl %eax, %ebp
testl %eax, %eax
pushq $-0x1
popq %rax
cmovnsl %ebp, %eax
jmp 0x1ec40
testl %eax, %eax
js 0x1ec49
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6a50
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: mustOpen
FILE *mustOpen(char *fileName, char *mode)
/* Open a file - or squawk and die. */
{
FILE *f;

if (sameString(fileName, "stdin"))
    return stdin;
if (sameString(fileName, "stdout"))
    return stdout;
if ((f = fopen(fileName, mode)) == NULL)
    {
    char *modeName = "";
    if (mode)
        {
        if (mode[0] == 'r')
            modeName = " to read";
        else if (mode[0] == 'w')
            modeName = " to write";
        else if (mode[0] == 'a')
            modeName = " to append";
        }
    errAbort("mustOpen: Can't open %s%s: %s", fileName, modeName, strerror(errno));
    }
return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x63d6b(%rip), %rsi     # 0x829f9
callq 0x6a50
testl %eax, %eax
je 0x1ece5
leaq 0x63d6f(%rip), %rsi     # 0x82a0d
movq %rbx, %rdi
callq 0x6a50
testl %eax, %eax
je 0x1ecee
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6800
movq %rax, %r12
testq %rax, %rax
jne 0x1ecf8
leaq 0x686b9(%rip), %r14     # 0x8737d
testq %r15, %r15
je 0x1ed17
movzbl (%r15), %eax
cmpl $0x61, %eax
je 0x1ed10
cmpl $0x72, %eax
je 0x1ed07
cmpl $0x77, %eax
jne 0x1ed17
leaq 0x603ee(%rip), %r14     # 0x7f0d1
jmp 0x1ed17
movq 0x942e4(%rip), %rax     # 0xb2fd0
jmp 0x1ecf5
movq 0x942bb(%rip), %rax     # 0xb2fb0
movq (%rax), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x603ba(%rip), %r14     # 0x7f0c8
jmp 0x1ed17
leaq 0x603c4(%rip), %r14     # 0x7f0db
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x603bc(%rip), %rdi     # 0x7f0e6
xorl %r12d, %r12d
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x223fb
jmp 0x1ecf8
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: carefulCloseWarn
boolean carefulCloseWarn(FILE **pFile)
/* Close file if open and null out handle to it.
 * Return FALSE and print a warning message if there
 * is a problem.*/
{
FILE *f;
boolean ok = TRUE;
if ((pFile != NULL) && ((f = *pFile) != NULL))
    {
    if (f != stdin && f != stdout)
        {
        if (fclose(f) != 0)
	    {
            errnoWarn("fclose failed");
	    ok = FALSE;
	    }
        }
    else if (f == stdout)
        {
        // One expects close() to actually flush the file and close it.  If
        // the file was opened using the magic name "stdout" and then does a
        // setvbuf(), writes to file, calls carefulClose, then frees the
        // buffer, the FILE object points to invalid memory.  Then the exit()
        // I/O cleanup causes the invalid memory to be written to the file,
        // possible outputting corruption data.  If would be consistent with
        // stdio behavior to have "stdout" magic name open "/dev/stdout".
        fflush(f);
        }
    *pFile = NULL;
    }
return ok;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rbp
testq %rdi, %rdi
je 0x1f2e1
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1f2e1
movq 0x93d37(%rip), %rax     # 0xb2fd0
cmpq (%rax), %rdi
sete %cl
movq 0x93d0a(%rip), %rax     # 0xb2fb0
movq (%rax), %rax
cmpq %rax, %rdi
sete %dl
orb %cl, %dl
je 0x1f2bf
cmpq %rax, %rdi
jne 0x1f2dd
callq 0x6870
jmp 0x1f2dd
callq 0x66e0
testl %eax, %eax
je 0x1f2da
leaq 0x60022(%rip), %rdi     # 0x7f2f1
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x222ea
jmp 0x1f2dd
pushq $0x1
popq %rbp
andq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: safememset
void safememset(char *buf, size_t bufSize, const char c, size_t n)
/* Append a character to a buffer repeatedly, n times with bounds checking.*/
{
size_t blen = strlen(buf);
if (blen+n+1 > bufSize)
    errAbort("buffer overflow, size %lld, new string size: %lld", (long long)bufSize, (long long)(blen+n));
memset(buf+blen, c, n);
buf[blen+n] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
callq 0x62d0
movq %rax, %r12
leaq (%rax,%r14), %r15
addq %r14, %rax
incq %rax
cmpq %r13, %rax
jbe 0x1fc98
leaq 0x5f81f(%rip), %rdi     # 0x7f4aa
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x223fb
addq %rbx, %r12
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x63b0
movb $0x0, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: isSymbolString
boolean isSymbolString(char *s)
/* Return TRUE if s can be used as a symbol in the C language */
{
char c = *s++;
if (!isalpha(c) && (c != '_'))
    return FALSE;
while ((c = *s++) != 0)
    {
    if (!(isalnum(c) || (c == '_')))
	return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbq (%rdi), %r14
callq 0x6790
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x5f, %r14
je 0x1fe9f
movzwl (%rcx,%r14,2), %edx
andl $0x400, %edx            # imm = 0x400
je 0x1fec4
incq %rbx
pushq $0x1
popq %rdx
movsbq (%rbx), %rsi
testq %rsi, %rsi
je 0x1fec2
incq %rbx
cmpb $0x5f, %sil
je 0x1fea5
movzwl (%rcx,%rsi,2), %esi
andl $0x8, %esi
jne 0x1fea5
jmp 0x1fec4
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/common.c
// Function: isAllDigits
boolean isAllDigits(char *s)
/* Return TRUE if string is non-empty and contains only digits (i.e. is a nonnegative integer). */
{
if (isEmpty(s))
    return FALSE;
char c;
while ((c = *s++) != 0)
    if (!isdigit(c))
        return FALSE;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1ffb1
movq %rdi, %r14
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x1ffb1
incq %r14
pushq $0x1
popq %r15
testb %bpl, %bpl
je 0x1ffae
callq 0x6790
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x1ffb1
movb (%r14), %bpl
incq %r14
jmp 0x1ff8e
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: newDnaSeq
struct dnaSeq *newDnaSeq(DNA *dna, int size, char *name)
/* Create a new DNA seq. */
{
struct dnaSeq *seq;

seq = needMem(sizeof(*seq));
if (name != NULL)
    seq->name = cloneString(name);
seq->dna = dna;
seq->size = size;
seq->mask = NULL;
return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x28bb0
movq %rax, %r15
testq %r12, %r12
je 0x206b4
movq %r12, %rdi
callq 0x1c306
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movl %ebx, 0x18(%r15)
andq $0x0, 0x20(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: cloneDnaSeq
struct dnaSeq *cloneDnaSeq(struct dnaSeq *orig)
/* Duplicate dna sequence in RAM. */
{
struct dnaSeq *seq = CloneVar(orig);
seq->name = cloneString(seq->name);
seq->dna = needHugeMem(seq->size+1);
memcpy(seq->dna, orig->dna, seq->size+1);
seq->mask = NULL;
if (orig->mask != NULL)
    {
    seq->mask = bitClone(orig->mask, seq->size);
    }
return seq;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x28
popq %rsi
callq 0x1c27c
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x1c306
movq %rax, 0x8(%rbx)
movslq 0x18(%rbx), %rdi
incq %rdi
callq 0x28ad7
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rsi
movslq 0x18(%rbx), %rdx
incq %rdx
movq %rax, %rdi
callq 0x6570
andq $0x0, 0x20(%rbx)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x2072c
movl 0x18(%rbx), %esi
callq 0x183d0
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: freeDnaSeq
void freeDnaSeq(struct dnaSeq **pSeq)
/* Free up DNA seq. (And unlink underlying resource node.) */
{
struct dnaSeq *seq = *pSeq;
if (seq == NULL)
    return;
freeMem(seq->name);
freeMem(seq->dna);
bitFree(&seq->mask);
freez(pSeq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x20773
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x28c2d
movq 0x10(%r14), %rdi
callq 0x28c2d
addq $0x20, %r14
movq %r14, %rdi
callq 0x183fd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: freeDnaSeqList
void freeDnaSeqList(struct dnaSeq **pSeqList)
/* Free up list of DNA sequences. */
{
struct dnaSeq *seq, *next;

for (seq = *pSeqList; seq != NULL; seq = next)
    {
    next = seq->next;
    freeDnaSeq(&seq);
    }
*pSeqList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x207a6
movq (%r15), %r15
movq %r14, %rdi
callq 0x20737
jmp 0x2078f
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: dnaSeqCannibalize
char *dnaSeqCannibalize(struct dnaSeq **pSeq)
/* Return the already-allocated dna string and free the dnaSeq container. */
{
char *seq = NULL;
if (pSeq && *pSeq)
    {
    struct dnaSeq *dnaSeq = *pSeq;
    seq = dnaSeq->dna;
    dnaSeq->dna = NULL;
    freeDnaSeq(pSeq);
    }
return seq;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x207d2
movq (%rdi), %rax
testq %rax, %rax
je 0x207d2
movq 0x10(%rax), %rbx
andq $0x0, 0x10(%rax)
callq 0x20737
jmp 0x207d4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: seqIsLower
boolean seqIsLower(bioSeq *seq)
/* Return TRUE if sequence is all lower case. */
{
int size = seq->size, i;
char *poly = seq->dna;
for (i=0; i<size; ++i)
    if (!islower(poly[i]))
        return FALSE;
return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r14d
movq 0x10(%rdi), %r15
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
pushq $0x1
popq %rbx
cmpq %r12, %r14
je 0x20814
callq 0x6790
movq (%rax), %rax
movsbq (%r15,%r12), %rcx
incq %r12
testb $0x2, 0x1(%rax,%rcx,2)
jne 0x207f6
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: translateSeqN
aaSeq *translateSeqN(struct dnaSeq *inSeq, unsigned offset, unsigned inSize, boolean stop)
/* Return a translated sequence.  Offset is position of first base to
 * translate. If size is 0 then use length of inSeq. */
{
aaSeq *seq;
DNA *dna = inSeq->dna;
AA *pep, aa;
int i, lastCodon;
int actualSize = 0;

assert(offset <= inSeq->size);
if ((inSize == 0) || (inSize > (inSeq->size - offset)))
    inSize = inSeq->size - offset;
lastCodon = offset + inSize - 3;

AllocVar(seq);
seq->dna = pep = needLargeMem(inSize/3+1);
for (i=offset; i <= lastCodon; i += 3)
    {
    aa = lookupCodon(dna+i);
    if (aa == 0)
	{
        if (stop)
	    break;
	else
	    aa = 'Z';
	}
    *pep++ = aa;
    ++actualSize;
    }
*pep = 0;
assert(actualSize <= inSize/3+1);
seq->size = actualSize;
seq->name = cloneString(inSeq->name);
return seq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0xc(%rsp)
movl 0x18(%rdi), %r15d
subl %esi, %r15d
jb 0x2091e
movl %esi, %r13d
movq %rdi, 0x18(%rsp)
movq 0x10(%rdi), %rbx
leal -0x1(%rdx), %eax
cmpl %r15d, %eax
cmovbl %edx, %r15d
leal (%r15,%r13), %eax
addl $-0x3, %eax
movl %eax, 0x8(%rsp)
pushq $0x28
popq %rdi
callq 0x28bb0
movq %rax, %rbp
xorl %r14d, %r14d
pushq $0x3
popq %rcx
movl %r15d, %eax
xorl %edx, %edx
divl %ecx
incl %eax
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x289b8
movq %rax, %r12
movq %rbp, 0x10(%rsp)
movq %rax, 0x10(%rbp)
movslq %r13d, %r13
movslq 0x8(%rsp), %r15
cmpq %r15, %r13
jg 0x208e5
cmpl $0x0, 0xc(%rsp)
setne %bpl
leaq (%rbx,%r13), %rdi
callq 0x20a8c
testb %al, %al
sete %cl
testb %bpl, %cl
jne 0x208e5
testb %al, %al
movzbl %al, %eax
pushq $0x5a
popq %rcx
cmovel %ecx, %eax
movb %al, (%r12,%r14)
addq $0x3, %r13
incq %r14
jmp 0x208ac
movb $0x0, (%r12,%r14)
cmpl 0x20(%rsp), %r14d
ja 0x2093b
movq 0x10(%rsp), %rbx
movl %r14d, 0x18(%rbx)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1c306
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ec07(%rip), %rdi     # 0x7f52c
leaq 0x5ec16(%rip), %rsi     # 0x7f542
leaq 0x5ec1c(%rip), %rcx     # 0x7f54f
pushq $0x6e
popq %rdx
callq 0x6460
leaq 0x5ec54(%rip), %rdi     # 0x7f596
leaq 0x5ebf9(%rip), %rsi     # 0x7f542
leaq 0x5ebff(%rip), %rcx     # 0x7f54f
movl $0x83, %edx
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: aaSeqZToX
void aaSeqZToX(aaSeq *aa)
/* If seq has a 'Z' for stop codon, possibly followed by other bases, change the 'Z' to an X
 * (compatible with dnautil's aminoAcidTable) and truncate there. */
{
char *p = strchr(aa->dna, 'Z');
if (p)
    {
    *p++ = 'X';
    *p = '\0';
    aa->size = p - aa->dna;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x5a
popq %rsi
callq 0x6270
testq %rax, %rax
je 0x20987
movw $0x58, (%rax)
movl 0x10(%rbx), %ecx
subl %ecx, %eax
incl %eax
movl %eax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: whichSeqIn
bioSeq *whichSeqIn(bioSeq **seqs, int seqCount, char *letters)
/* Figure out which if any sequence letters is in. */
{
aaSeq *seq;
int i;

for (i=0; i<seqCount; ++i)
    {
    seq = seqs[i];
    if (seq->dna <= letters && letters < seq->dna + seq->size)
        return seq;
    }
internalErr();
return NULL;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rax, %rsi
je 0x209b4
movq (%rdi,%rax,8), %rbx
movq 0x10(%rbx), %rcx
cmpq %rdx, %rcx
ja 0x209af
movslq 0x18(%rbx), %r8
addq %r8, %rcx
cmpq %rdx, %rcx
ja 0x209d0
incq %rax
jmp 0x20991
leaq 0x5c1e0(%rip), %rdi     # 0x7cb9b
leaq 0x5eb80(%rip), %rsi     # 0x7f542
xorl %ebx, %ebx
movl $0xaa, %edx
xorl %eax, %eax
callq 0x223fb
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: maskFromUpperCaseSeq
Bits *maskFromUpperCaseSeq(bioSeq *seq)
/* Allocate a mask for sequence and fill it in based on
 * sequence case. */
{
int size = seq->size, i;
char *poly = seq->dna;
Bits *b = bitAlloc(size);
for (i=0; i<size; ++i)
    {
    if (isupper(poly[i]))
        bitSetOne(b, i);
    }
return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x18(%rdi), %ebx
movq 0x10(%rdi), %r12
movl %ebx, %edi
callq 0x183ab
movq %rax, %r14
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x20a20
callq 0x6790
movq (%rax), %rax
movsbq (%r12,%r15), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x20a1b
movq %r14, %rdi
movl %r15d, %esi
callq 0x184bc
incq %r15
jmp 0x209f7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/dnaseq.c
// Function: dnaSeqHash
struct hash *dnaSeqHash(struct dnaSeq *seqList)
/* Return hash of sequences keyed by name. */
{
int size = slCount(seqList)+1;
int sizeLog2 = digitsBaseTwo(size);
struct hash *hash = hashNew(sizeLog2);
struct dnaSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
    hashAddUnique(hash, seq->name, seq);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1c4aa
incl %eax
movslq %eax, %rdi
callq 0x2d0c4
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x245c9
movq %rax, %r14
testq %rbx, %rbx
je 0x20a6b
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x243b8
movq (%rbx), %rbx
jmp 0x20a52
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq