LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainCmpTarget
int chainCmpTarget(const void *va, const void *vb)
/* Compare to sort based on target position. */
{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
int dif = strcmp(a->tName, b->tName);
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6a40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x28165
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x24(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainCmpQuery
int chainCmpQuery(const void *va, const void *vb)
/* Compare to sort based on query chrom and target position. */
{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
int dif;                                                                        

dif = strcmp(a->qName, b->qName);                                               
if (dif == 0)                                                                   
    dif = a->qStart - b->qStart;                                                
return dif;                       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x6a40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x281c5
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainWriteHead
void chainWriteHead(struct chain *chain, FILE *f)
/* Write chain before block/insert list. */
{
if (chain->id == 0)
    chainIdNext(chain);
fprintf(f, "chain %1.0f %s %d + %d %d %s %d %c %d %d %d\n", chain->score,
    chain->tName, chain->tSize, chain->tStart, chain->tEnd,
    chain->qName, chain->qSize, chain->qStrand, chain->qStart, chain->qEnd,
    chain->id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x28258
movq -0x20(%rbp), %rdi
callq 0x28200
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x24(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x28(%rax), %r9d
movq -0x20(%rbp), %rax
movq 0x30(%rax), %r15
movq -0x20(%rbp), %rax
movl 0x38(%rax), %r14d
movq -0x20(%rbp), %rax
movsbl 0x3c(%rax), %ebx
movq -0x20(%rbp), %rax
movl 0x40(%rax), %r11d
movq -0x20(%rbp), %rax
movl 0x44(%rax), %r10d
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
leaq 0xb1723(%rip), %rsi     # 0xd99dd
movq %r15, (%rsp)
movl %r14d, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movb $0x1, %al
callq 0x6a80
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainWrite
void chainWrite(struct chain *chain, FILE *f)
/* Write out chain to file in usual format*/
{
struct cBlock *b, *nextB;

chainWriteHead(chain, f);
for (b = chain->blockList; b != NULL; b = nextB)
    {
    nextB = b->next;
    fprintf(f, "%d", b->qEnd - b->qStart);
    if (nextB != NULL)
	fprintf(f, "\t%d\t%d", 
		nextB->tStart - b->tEnd, nextB->qStart - b->qEnd);
    fputc('\n', f);
    }
fputc('\n', f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28398
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
subl 0x10(%rax), %edx
leaq 0xb16ca(%rip), %rsi     # 0xd9a0e
movb $0x0, %al
callq 0x6a80
cmpq $0x0, -0x20(%rbp)
je 0x28380
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
subl 0xc(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
subl 0x14(%rax), %ecx
leaq 0xb1691(%rip), %rsi     # 0xd9a0a
movb $0x0, %al
callq 0x6a80
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x6910
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x28319
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x6910
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainWriteLong
void chainWriteLong(struct chain *chain, FILE *f)
/* Write out chain to file in longer format*/
{
struct cBlock *b, *nextB;

chainWriteHead(chain, f);
for (b = chain->blockList; b != NULL; b = nextB)
    {
    nextB = b->next;
    fprintf(f, "%d\t%d\t", b->tStart, b->qStart);
    fprintf(f, "%d", b->qEnd - b->qStart);
    if (nextB != NULL)
	fprintf(f, "\t%d\t%d", 
		nextB->tStart - b->tEnd, nextB->qStart - b->qEnd);
    fputc('\n', f);
    }
fputc('\n', f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x284bf
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0xafd8b(%rip), %rsi     # 0xd81d3
movb $0x0, %al
callq 0x6a80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
subl 0x10(%rax), %edx
leaq 0xb15a6(%rip), %rsi     # 0xd9a0e
movb $0x0, %al
callq 0x6a80
cmpq $0x0, -0x20(%rbp)
je 0x284a4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
subl 0xc(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
subl 0x14(%rax), %ecx
leaq 0xb156d(%rip), %rsi     # 0xd9a0a
movb $0x0, %al
callq 0x6a80
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x6910
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x28419
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x6910
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x284e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2895d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x287b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x12, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x28930
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x28c02
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28b7f
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x23dc0
cmpl $0x0, %eax
jne 0x28b7f
leaq -0x40(%rbp), %rdi
callq 0x27cb0
jmp 0x28b38
leaq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x48(%rax), %ecx
movl $0x10, %esi
leaq 0xb4713(%rip), %rdx     # 0xdd2a9
movb $0x0, %al
callq 0x31090
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x38e20
cmpq $0x0, %rax
je 0x28bd4
movq -0x40(%rbp), %rax
movl 0x48(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xb0f6a(%rip), %rdi     # 0xd9b37
movb $0x0, %al
callq 0x35d40
cmpl $0x0, -0xc(%rbp)
je 0x28be3
movq -0x40(%rbp), %rdi
callq 0x28970
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x39230
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x28b38
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3b290
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x28b00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3c110
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3b290
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a860
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x28b00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c110
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chain.c
// Function: chainSubsetOnT
void chainSubsetOnT(struct chain *chain, int subStart, int subEnd, 
    struct chain **retSubChain,  struct chain **retChainToFree)
/* Get subchain of chain bounded by subStart-subEnd on 
 * target side.  Return result in *retSubChain.  In some
 * cases this may be the original chain, in which case
 * *retChainToFree is NULL.  When done call chainFree on
 * *retChainToFree.  The score and id fields are not really
 * properly filled in. */
{
/* Find first relevant block. */
struct cBlock *firstBlock;
for (firstBlock = chain->blockList; firstBlock != NULL; firstBlock = firstBlock->next)
    {
    if (firstBlock->tEnd > subStart)
	break;
    }
chainFastSubsetOnT(chain, firstBlock, subStart, subEnd, retSubChain, retChainToFree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28dea
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x28ddb
jmp 0x28dea
jmp 0x28ddd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x28dc6
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x28e10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x29359
leaq 0xb080d(%rip), %rdi     # 0xd9b5f
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
movsbl 0x3c(%rax), %eax
cmpl $0x2d, %eax
jne 0x29390
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x44(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x40(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x293aa
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chainBlock.c
// Function: kdTreeMake
static struct kdTree *kdTreeMake(struct kdLeaf *leafList, struct lm *lm)
/* Make a kd-tree containing leafList. */
{
struct kdLeaf *leaf;
int nodeCount = slCount(leafList);
struct kdTree *tree;
struct dlList qList, tList,*lists[2];
struct dlNode *qNodes, *tNodes;
int i;

/* Build lists sorted in each dimension. This
 * will let us quickly find medians while constructing
 * the kd-tree. */
dlListInit(&qList);
dlListInit(&tList);
AllocArray(qNodes, nodeCount);
AllocArray(tNodes, nodeCount);
for (i=0 , leaf=leafList; leaf != NULL; leaf = leaf->next, ++i)
    {
    qNodes[i].val = tNodes[i].val = leaf;
    dlAddTail(&qList, &qNodes[i]);
    dlAddTail(&tList, &tNodes[i]);
    }
/* Just sort qList since tList is sorted because it was
 * constructed from sorted leafList. */
dlSort(&qList, kdLeafCmpQ); 
lists[0] = &qList;
lists[1] = &tList;

/* Allocate master data structure and call recursive builder. */
lmAllocVar(lm, tree);
tree->root = kdBuild(nodeCount, lists, 0, lm);

/* Clean up and go home. */
freeMem(qNodes);
freeMem(tNodes);
return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a810
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31e00
leaq -0x58(%rbp), %rdi
callq 0x31e00
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0x409d0
movq %rax, -0x78(%rbp)
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0x409d0
movq %rax, -0x80(%rbp)
movl $0x0, -0x84(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x296e5
movq -0x18(%rbp), %rcx
movq -0x80(%rbp), %rax
movslq -0x84(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rax
movslq -0x84(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rsi
movslq -0x84(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x32070
movq -0x80(%rbp), %rsi
movslq -0x84(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x32070
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x29655
leaq -0x40(%rbp), %rdi
leaq 0x510(%rip), %rsi       # 0x29c00
callq 0x32390
leaq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3de60
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rcx
xorl %edx, %edx
callq 0x29c40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rdi
callq 0x40d40
movq -0x80(%rbp), %rdi
callq 0x40d40
movq -0x28(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chainBlock.c
// Function: findBestPredecessors
static void findBestPredecessors(struct kdTree *tree, struct kdLeaf *leafList, 
	ConnectCost connectCost, GapCost gapCost, void *gapData)
/* Find best predecessor for each leaf. */
{
static struct predScore noBest;
struct kdLeaf *leaf;
double bestScore = 0;

for (leaf = leafList; leaf != NULL; leaf = leaf->next)
    {
    struct predScore best;
    best = bestPredecessor(leaf, connectCost, gapCost, gapData, 0, tree->root, noBest);
    if (best.score > leaf->totalScore)
        {
	leaf->totalScore = best.score;
	leaf->bestPred = best.pred;
	}
    updateScoresOnWay(tree->root, 0, leaf);
    if (bestScore < leaf->totalScore)
        {
	bestScore = leaf->totalScore;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29856
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %r9
xorl %r8d, %r8d
leaq 0xde0b0(%rip), %rax     # 0x107868
movq (%rax), %r10
movq %r10, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x29f90
movq %rax, -0x58(%rbp)
movsd %xmm0, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jbe 0x29810
movsd -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x2a290
movsd -0x38(%rbp), %xmm1
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29844
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x29846
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2978c
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x298ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x298ca
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x298c3
movl $0x1, -0x4(%rbp)
jmp 0x298ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chainBlock.c
// Function: scoreBlocks
static double scoreBlocks(struct cBlock *blockList, ConnectCost connectCost,
	void *gapData)
/* Score list of blocks including gaps between blocks. */
{
struct cBlock *block, *lastBlock = NULL;
double score = 0;
for (block = blockList; block != NULL; block = block->next)
    {
    score += block->score;
    if (lastBlock != NULL)
	score -= connectCost(lastBlock, block, gapData);
    lastBlock = block;
    }
return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29be6
movq -0x20(%rbp), %rax
cvtsi2sdl 0x18(%rax), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x29bd1
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
cvtsi2sd %eax, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29b8c
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chainBlock.c
// Function: clearHits
static void clearHits(struct dlList *list)
/* Clear hit flags of all blocks on list. */
{
struct dlNode *node;
for (node = list->head; !dlEnd(node); node = node->next)
    {
    struct kdLeaf *leaf = node->val;
    leaf->hit = FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x29e36
jmp 0x29e57
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x29e23
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/chainBlock.c
// Function: medianVal
static int medianVal(struct dlList *list, int medianIx, int dim)
/* Return value of median block in list on given dimension 
 * Mark blocks up to median as hit. */
{
struct dlNode *node = list->head;
struct kdLeaf *leaf = NULL;
int i;

for (i=0; i<medianIx; ++i)
    {
    leaf = node->val;
    leaf->hit = TRUE;  
    node = node->next;
    }
return (dim == 0 ? leaf->cb->qStart : leaf->cb->tStart);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x29eba
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x29e88
cmpl $0x0, -0x10(%rbp)
jne 0x29ed0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x29ede
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e00
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x29f2e
jmp 0x29f7a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x20(%rax)
jne 0x29f6e
movq -0x18(%rbp), %rdi
callq 0x321f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32070
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x29f70
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x29f1b
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2a2c4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x2a2d2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2a302
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2a34e
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jg 0x2a32c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2a290
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x2a34c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2a290
jmp 0x2a34e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/common.c
// Function: slNameFind
void *slNameFind(void *list, char *string)
/* Return first element of slName list (or any other list starting
 * with next/name fields) that matches string. This is case insensitive. */
{
struct slName *el;
for (el = list; el != NULL; el = el->next)
    if (sameWord(string, el->name))
        return el;
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2bb2e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x2b9f0
cmpl $0x0, %eax
jne 0x2bb1f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2bb36
jmp 0x2bb21
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2baf8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2be10
movq $0x0, -0x8(%rbp)
jmp 0x2bf17
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movq %rax, %rdx
movq %rdx, %rcx
incq %rcx
movq %rsp, %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x38(%rbp)
movq %rax, %rsp
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2bed7
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x2bec4
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2c, %eax
je 0x2beb6
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
subq %rdi, %rax
subq $0x1, %rax
movl %eax, %esi
callq 0x2b6e0
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ad50
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2bec2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2bec4
jmp 0x2bec6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2be4e
movq -0x38(%rbp), %rax
cmpq %rax, -0x30(%rbp)
jbe 0x2beff
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
subq %rdi, %rax
movl %eax, %esi
callq 0x2b6e0
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ad50
leaq -0x18(%rbp), %rdi
callq 0x2aad0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2bfec
leaq 0xb9428(%rip), %rdi     # 0xe5406
callq 0x2a450
movq %rax, -0x8(%rbp)
jmp 0x2c09d
movb -0x11(%rbp), %al
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2c035
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x62c0
movq %rax, %rcx
movslq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bffe
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x409d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2c095
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x6d60
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2c086
movq -0x38(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0x6d60
jmp 0x2c088
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2c057
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c544
cmpq $0x0, -0x10(%rbp)
je 0x2c528
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movb $0x0, %al
callq *%rcx
jmp 0x2c535
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x40d70
jmp 0x2c537
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2c508
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6ab0
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x2d47c
movl $0x1, -0x4(%rbp)
jmp 0x2d4ab
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6ab0
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x2d49e
movl $0x0, -0x4(%rbp)
jmp 0x2d4ab
jmp 0x2d4a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2d457
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2d8b2
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2d8bf
movq $0x0, -0x8(%rbp)
jmp 0x2d966
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6170
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2d953
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6170
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2d951
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2a360
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d966
jmp 0x2d953
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/common.c
// Function: replaceChar
void replaceChar(char *s, char oldc, char newc)
/* Repace one char with another. Modifies original string. */
{
if (!s)
    return;
char c;
while((c=*s))
    {
    if (c == oldc)
       *s = newc;	
    ++s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2ddfc
jmp 0x2de2e
jmp 0x2ddfe
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0xb(%rbp)
cmpb $0x0, %al
je 0x2de2e
movsbl -0xb(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2de20
movb -0xa(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ddfe
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x2edef
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
callq 0x6780
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2ede0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2ede2
jmp 0x2edef
jmp 0x2ede4
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ed98
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x2eec7
jmp 0x2eefa
callq 0x6780
movq (%rax), %rax
movsbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2eef8
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x2eea8
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/common.c
// Function: cloneNotFirstWord
char *cloneNotFirstWord(char *s)
/* return part of string after first space, not changing s. Result has to be freed. */
{
if (s==NULL)
    return cloneString("");
char* spcPos = stringIn(" ", s);
if (spcPos==NULL)
    return cloneString("");
return cloneString(spcPos+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f155
leaq 0xb62bc(%rip), %rdi     # 0xe5406
callq 0x2a450
movq %rax, -0x8(%rbp)
jmp 0x2f193
movq -0x10(%rbp), %rdi
leaq 0xa91ca(%rip), %rsi     # 0xd832a
callq 0x6170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f182
leaq 0xb628f(%rip), %rdi     # 0xe5406
callq 0x2a450
movq %rax, -0x8(%rbp)
jmp 0x2f193
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x2a450
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f3b5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2f3c2
movq $0x0, -0x8(%rbp)
jmp 0x2f46d
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2f432
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2f3ee
jmp 0x2f432
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x2f419
callq 0x6780
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2f419
jmp 0x2f432
jmp 0x2f41b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f3d1
cmpl $0x0, -0x18(%rbp)
jne 0x2f442
movq $0x0, -0x8(%rbp)
jmp 0x2f46d
movl -0x18(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x40c50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x6570
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/common.c
// Function: cloneFirstWordByDelimiter
char *cloneFirstWordByDelimiter(char *line,char delimit)
/* Returns a cloned first word, not harming the memory passed in. Skips over leading white space. */
{
if (line == NULL || *line == 0)
    return NULL;
line = skipLeadingSpaces(line);
return cloneFirstWordByDelimiterNoSkip(line, delimit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f4a5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2f4af
movq $0x0, -0x8(%rbp)
jmp 0x2f4cd
movq -0x10(%rbp), %rdi
callq 0x2ca80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x2f390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x2f620
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x2f620
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x2f6f4
cmpl $0x0, -0x2c(%rbp)
jge 0x2f6eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a40
movl %eax, -0x4(%rbp)
jmp 0x2f70c
movl $0x1, -0x4(%rbp)
jmp 0x2f70c
cmpl $0x0, -0x2c(%rbp)
jge 0x2f703
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f70c
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xae11c(%rip), %rsi     # 0xdd8b7
callq 0x6a40
cmpl $0x0, %eax
jne 0x2f7b8
movq 0xd581c(%rip), %rax     # 0x104fc8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f899
movq -0x10(%rbp), %rdi
leaq 0xae108(%rip), %rsi     # 0xdd8cb
callq 0x6a40
cmpl $0x0, %eax
jne 0x2f7e0
movq 0xd57dc(%rip), %rax     # 0x104fb0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f899
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2f891
leaq 0xb5c04(%rip), %rax     # 0xe5406
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2f85c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x2f826
leaq 0xaa730(%rip), %rax     # 0xd9f50
movq %rax, -0x28(%rbp)
jmp 0x2f85a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
jne 0x2f83f
leaq 0xaa720(%rip), %rax     # 0xd9f59
movq %rax, -0x28(%rbp)
jmp 0x2f858
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x2f856
leaq 0xaa711(%rip), %rax     # 0xd9f63
movq %rax, -0x28(%rbp)
jmp 0x2f858
jmp 0x2f85a
jmp 0x2f85c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6060
movl (%rax), %edi
callq 0x6220
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xaa6e4(%rip), %rdi     # 0xd9f6e
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)