LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslComputeInsertCounts
void pslComputeInsertCounts(struct psl *psl)
/* compute numInsert and baseInsert fields from the blocks */
{
psl->qNumInsert = psl->qBaseInsert = 0;
psl->tNumInsert = psl->tBaseInsert = 0;
int iBlk;

for (iBlk = 1; iBlk < psl->blockCount; iBlk++)
    {
    unsigned qGapSize = psl->qStarts[iBlk] - (psl->qStarts[iBlk-1]+psl->blockSizes[iBlk-1]);
    if (qGapSize != 0)
        {
        psl->qNumInsert++;
        psl->qBaseInsert += qGapSize;
        }
    unsigned tGapSize = psl->tStarts[iBlk] - (psl->tStarts[iBlk-1]+psl->blockSizes[iBlk-1]);
    if (tGapSize != 0)
        {
        psl->tNumInsert++;
        psl->tBaseInsert += tGapSize;
        }
    }
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl 0x5c(%rdi), %eax
cmpq $0x2, %rax
jb 0x3a030
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdx
movq 0x70(%rdi), %rsi
decq %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
movl 0x4(%rdx,%r8,4), %r14d
movl (%rcx,%r8,4), %ebp
movl (%rdx,%r8,4), %r15d
addl %ebp, %r15d
subl %r15d, %r14d
je 0x3a006
incl %ebx
movl %ebx, 0x18(%rdi)
addl %r14d, %r11d
movl %r11d, 0x1c(%rdi)
movl (%rcx,%r8,4), %ebp
movl 0x4(%rsi,%r8,4), %r14d
addl (%rsi,%r8,4), %ebp
subl %ebp, %r14d
je 0x3a022
incl %r10d
movl %r10d, 0x20(%rdi)
addl %r14d, %r9d
movl %r9d, 0x24(%rdi)
incq %r8
cmpq %r8, %rax
jne 0x39fe1
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslRangeTreeOverlap
int pslRangeTreeOverlap(struct psl *psl, struct rbTree *rangeTree)
/* Return amount that psl overlaps (on target side) with rangeTree. */
{
int i;
int overlap = 0;
boolean isRc = (psl->strand[1] == '-');
for (i=0; i<psl->blockCount; ++i)
    {
    int start = psl->tStarts[i];
    int end = start + psl->blockSizes[i];
    if (isRc)
        reverseIntRange(&start, &end, psl->tSize);
    overlap += rangeTreeOverlapSize(rangeTree, start, end);
    }
return overlap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x5c(%rdi)
je 0x3a3d8
movq %rsi, %rbx
movq %rdi, %r14
movb 0x29(%rdi), %r13b
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
movq 0x70(%r14), %rax
movl (%rax,%r15,4), %esi
movl %esi, 0x4(%rsp)
movq 0x60(%r14), %rax
movl (%rax,%r15,4), %edx
addl %esi, %edx
movl %edx, (%rsp)
cmpb $0x2d, %r13b
jne 0x3a3c0
movl 0x50(%r14), %edx
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
callq 0x25472
movl 0x4(%rsp), %esi
movl (%rsp), %edx
movq %rbx, %rdi
callq 0x3aa62
addl %eax, %ebp
incq %r15
movl 0x5c(%r14), %eax
cmpq %rax, %r15
jb 0x3a389
jmp 0x3a3da
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslClone
struct psl* pslClone(struct psl *psl)
/* clone a psl */
{
struct psl* pslCp = pslNew(psl->qName, psl->qSize, psl->qStart, psl->qEnd,
                           psl->tName, psl->tSize, psl->tStart, psl->tEnd,
                           psl->strand, psl->blockCount,
                           ((psl->tSequence != NULL) ? PSL_XA_FORMAT : 0));
pslCp->match = psl->match;
pslCp->misMatch = psl->misMatch;
pslCp->repMatch = psl->repMatch;
pslCp->nCount = psl->nCount;
pslCp->qNumInsert = psl->qNumInsert;
pslCp->qBaseInsert = psl->qBaseInsert;
pslCp->tNumInsert = psl->tNumInsert;
pslCp->tBaseInsert = psl->tBaseInsert;
int iBlk;
for (iBlk = 0; iBlk < psl->blockCount; iBlk++)
    {
    pslCp->blockSizes[iBlk] = psl->blockSizes[iBlk];
    pslCp->qStarts[iBlk] = psl->qStarts[iBlk];
    pslCp->tStarts[iBlk] = psl->tStarts[iBlk];
    if (psl->qSequence != NULL)
        pslCp->qSequence[iBlk] = cloneString(psl->qSequence[iBlk]);
    if (psl->tSequence != NULL)
        pslCp->tSequence[iBlk] = cloneString(psl->tSequence[iBlk]);
    pslCp->blockCount++;
    }
return pslCp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movl 0x38(%rbx), %esi
movl 0x3c(%rbx), %edx
movl 0x40(%rbx), %ecx
movq 0x48(%rbx), %r8
movl 0x50(%rbx), %r9d
movl 0x54(%rbx), %eax
movl 0x58(%rbx), %r10d
leaq 0x28(%rbx), %r11
movl 0x5c(%rbx), %r14d
xorl %r15d, %r15d
cmpq $0x0, 0x80(%rbx)
setne %r15b
shll $0x2, %r15d
subq $0x8, %rsp
pushq %r15
pushq %r14
pushq %r11
pushq %r10
pushq %rax
callq 0x39d7e
addq $0x30, %rsp
movq %rax, %r14
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%rbx), %xmm0
movups %xmm0, 0x18(%rax)
cmpl $0x0, 0x5c(%rbx)
je 0x3a512
xorl %r15d, %r15d
movq 0x60(%rbx), %rax
movl (%rax,%r15,4), %eax
movq 0x60(%r14), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x68(%rbx), %rax
movl (%rax,%r15,4), %eax
movq 0x68(%r14), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x70(%rbx), %rax
movl (%rax,%r15,4), %eax
movq 0x70(%r14), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x3a4e3
movq (%rax,%r15,8), %rdi
callq 0x1feba
movq 0x78(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x3a503
movq (%rax,%r15,8), %rdi
callq 0x1feba
movq 0x80(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incl 0x5c(%r14)
incq %r15
movl 0x5c(%rbx), %eax
cmpq %rax, %r15
jb 0x3a499
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslCmpTargetScore
int pslCmpTargetScore(const void *va, const void *vb)
/* Compare to sort based on target then score. */
{
const struct psl *a = *((struct psl **)va);
const struct psl *b = *((struct psl **)vb);
int diff = cmpChrom(a->tName, b->tName);
if (diff == 0)
    diff = pslScore(b) - pslScore(a);
return diff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq (%rsi), %r14
movq 0x48(%rbx), %rdi
movq 0x48(%r14), %rsi
callq 0x208e5
movl %eax, %ebp
testl %eax, %eax
jne 0x3a59a
movq %r14, %rdi
callq 0x3808e
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal 0x1(,%rcx,2), %eax
movl 0x10(%r14), %ebp
shrl %ebp
addl 0x8(%r14), %ebp
subl 0xc(%r14), %ebp
movl 0x20(%r14), %r15d
imull %eax, %ebp
addl 0x18(%r14), %r15d
movq %rbx, %rdi
callq 0x3808e
xorl %ecx, %ecx
cmpl $0x1, %eax
sbbl %ecx, %ecx
movl 0x10(%rbx), %eax
shrl %eax
addl 0x8(%rbx), %eax
subl 0xc(%rbx), %eax
orl $-0x3, %ecx
subl %r15d, %ebp
addl 0x18(%rbx), %ebp
imull %ecx, %eax
addl 0x20(%rbx), %ebp
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslCmpTargetStart
int pslCmpTargetStart(const void *va, const void *vb)
/* Compare to sort based on target start. */
{
const struct psl *a = *((struct psl **)va);
const struct psl *b = *((struct psl **)vb);
int diff = cmpChrom(a->tName, b->tName);
if (diff == 0)
    diff = a->tStart - b->tStart;
return diff;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x48(%r14), %rdi
movq 0x48(%rbx), %rsi
callq 0x208e5
testl %eax, %eax
jne 0x3a5c9
movl 0x54(%r14), %eax
subl 0x54(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslSortListByVar
void pslSortListByVar(struct psl **pslList, char *sort)
/* Sort a list of psls using the method definied in the sort string. */
{
if (sameString(sort, "query,start"))
    {
    slSort(pslList, pslCmpQuery);
    }
else if (sameString(sort, "query,score"))
    {
    slSort(pslList, pslCmpQueryScore);
    }
else if (sameString(sort, "score"))
    {
    slSort(pslList, pslCmpScore);
    }
else if (sameString(sort, "chrom,start"))
    {
    slSort(pslList, pslCmpTargetStart);
    }
else if (sameString(sort, "chrom,score"))
    {
    slSort(pslList, pslCmpTargetScore);
    }
else
    {
    slSort(pslList, pslCmpQueryScore);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x59d0c(%rip), %rsi     # 0x942ee
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3a64c
leaq 0x59ced(%rip), %rsi     # 0x942e2
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3a655
leaq 0x55600(%rip), %rsi     # 0x8fc08
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3a65e
leaq 0x59ceb(%rip), %rsi     # 0x94306
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3a667
leaq 0x59ccc(%rip), %rsi     # 0x942fa
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
leaq -0x11f(%rip), %rax      # 0x3a520
leaq -0x2dc6(%rip), %rsi     # 0x37880
cmoveq %rax, %rsi
jmp 0x3a66e
leaq -0x2f05(%rip), %rsi     # 0x3774e
jmp 0x3a66e
leaq -0x2ddc(%rip), %rsi     # 0x37880
jmp 0x3a66e
leaq -0x2e88(%rip), %rsi     # 0x377dd
jmp 0x3a66e
leaq -0xc7(%rip), %rsi       # 0x3a5a7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x201c4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeAddVal
struct range *rangeTreeAddVal(struct rbTree *tree, int start, int end, void *val, void *(*mergeVals)(void *existingVal, void *newVal) )
/* Add range to tree, merging with existing ranges if need be. 
 * If this is a new range, set the value to this val.
 * If there are existing items for this range, and if mergeVals function is not null, 
 * apply mergeVals to the existing values and this new val, storing the result as the val
 * for this range (see rangeTreeAddValCount() and rangeTreeAddValList() below for examples). */
{
struct range *r, *existing;
r = lmAlloc(tree->lm, sizeof(*r)); /* alloc new zeroed range */
r->start = start;
r->end = end;
r->val = val;
while ((existing = rbTreeRemove(tree, r)) != NULL)
    {
    r->start = min(r->start, existing->start);
    r->end = max(r->end, existing->end);
    if (mergeVals)
	r->val = mergeVals(existing->val, r->val);
    }
rbTreeAdd(tree, r);
return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movl $0x18, %esi
callq 0x2c325
movq %rax, %r15
movl %r13d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %r12, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x3ae89
testq %rax, %rax
je 0x3a719
movl 0x8(%rax), %ecx
movl 0x8(%r15), %edx
cmpl %ecx, %edx
cmovll %edx, %ecx
movl 0xc(%r15), %edx
movl %ecx, 0x8(%r15)
movl 0xc(%rax), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movl %ecx, 0xc(%r15)
testq %rbx, %rbx
je 0x3a711
movq 0x10(%rax), %rdi
movq 0x10(%r15), %rsi
callq *%rbx
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
jmp 0x3a6d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ac3d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeAllOverlapping
struct range *rangeTreeAllOverlapping(struct rbTree *tree, int start, int end)
/* Return list of all items in range tree that overlap interval start-end.
 * Do not free this list, it is owned by tree.  However it is only good until
 * next call to rangeTreeFindInRange or rangeTreeList. Not thread safe. */
{
struct range tempR;
tempR.start = start;
tempR.end = end;
struct range *rangeList = NULL;
rbTreeTraverseRangeWithContext(tree, &tempR, &tempR, rangeListAdd, &rangeList);
slReverse(&rangeList);
return rangeList;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rax
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
movq %rsp, %rbx
movq $0x0, (%rbx)
leaq 0x7c(%rip), %rcx        # 0x3a9bf
movq %rax, %rsi
movq %rax, %rdx
movq %rbx, %r8
callq 0x3b278
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeOverlaps
boolean rangeTreeOverlaps(struct rbTree *tree, int start, int end)
/* Return TRUE if start-end overlaps anything in tree */
{
struct range tempR;
tempR.start = start;
tempR.end = end;
tempR.val = NULL;
return rbTreeFind(tree, &tempR) != NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rsp, %rax
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rsi
callq 0x3ae3a
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeList
struct range *rangeTreeList(struct rbTree *tree)
/* Return list of all ranges in tree in order.  Not thread safe. 
 * No need to free this when done, memory is local to tree. */
{
struct range *rangeList = NULL;
rbTreeTraverseWithContext(tree, rangeListAdd, &rangeList);
slReverse(&rangeList);
return rangeList;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x19(%rip), %rsi        # 0x3a9bf
movq %rbx, %rdx
callq 0x3b3cf
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeFindEnclosing
struct range *rangeTreeFindEnclosing(struct rbTree *tree, int start, int end)
/* Find item in range tree that encloses range between start and end 
 * if there is any such item. */
{
struct range tempR, *r;
tempR.start = start;
tempR.end = end;
r = rbTreeFind(tree, &tempR);
if (r != NULL && r->start <= start && r->end >= end)
    {
    r->next = NULL; /* this can be set by previous calls to the List functions */
    return r;
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rsp, %rsi
movl %ebp, 0x8(%rsi)
movl %edx, 0xc(%rsi)
callq 0x3ae3a
testq %rax, %rax
je 0x3a9f0
cmpl %ebp, 0x8(%rax)
jg 0x3a9f0
cmpl %ebx, 0xc(%rax)
jge 0x3a9f9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq $0x0, (%rax)
jmp 0x3a9f2
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeMaxOverlapping
struct range *rangeTreeMaxOverlapping(struct rbTree *tree, int start, int end)
/* Return item that overlaps most with start-end. Not thread safe.  Trashes list used
 * by rangeTreeAllOverlapping. */
{
struct range *range, *best = NULL;
int bestOverlap = 0; 
for (range  = rangeTreeAllOverlapping(tree, start, end); range != NULL; range = range->next)
    {
    int overlap = rangeIntersection(range->start, range->end, start, end);
    if (overlap > bestOverlap)
        {
	bestOverlap = overlap;
	best = range;
	}
    }
if (best)
    best->next = NULL; /* could be set by calls to List functions */
return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
callq 0x3a922
xorl %r12d, %r12d
testq %rax, %rax
je 0x3aa53
movq %rax, %r15
xorl %r14d, %r14d
movl 0x8(%r15), %edi
movl 0xc(%r15), %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2394c
cmpl %r12d, %eax
cmovgq %r15, %r14
cmovgl %eax, %r12d
movq (%r15), %r15
testq %r15, %r15
jne 0x3aa21
testq %r14, %r14
je 0x3aa53
movq $0x0, (%r14)
jmp 0x3aa56
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rangeTree.c
// Function: rangeTreeOverlapSize
int rangeTreeOverlapSize(struct rbTree *tree, int start, int end)
/* Return the total size of intersection between interval
 * from start to end, and items in range tree. Sadly not
 * thread-safe. 
 * On 32 bit machines be careful not to overflow
 * range of start, end or total size return value. */
{
struct range tempR;
tempR.start = overlapStart = start;
tempR.end = overlapEnd = end;
totalOverlap = 0;
rbTreeTraverseRange(tree, &tempR, &tempR, addOverlap);
return totalOverlap;
}

// Assembly:
subq $0x18, %rsp
movl %esi, 0x8968c(%rip)     # 0xc40f8
movq %rsp, %rax
movl %esi, 0x8(%rax)
movl %edx, 0x89684(%rip)     # 0xc40fc
movl %edx, 0xc(%rax)
movl $0x0, 0x8967b(%rip)     # 0xc4100
leaq 0x16(%rip), %rcx        # 0x3aaa2
movq %rax, %rsi
movq %rax, %rdx
callq 0x3b314
movl 0x89663(%rip), %eax     # 0xc4100
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeNewDetailed
struct rbTree *rbTreeNewDetailed(int (*compare)(void *, void *), struct lm *lm, 
	struct rbTreeNode *stack[128])
/* Allocate rbTree on an existing local memory & stack.  This is for cases
 * where you want a lot of trees, and don't want the overhead for each one. 
 * Note, to clean these up, just do freez(&rbTree) rather than rbFreeTree(&rbTree). */
{
struct rbTree *t;
AllocVar(t);
t->root = NULL;
t->compare = compare;
t->lm = lm;
t->stack = stack;	
t->n = 0;
return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x2dff4
movq $0x0, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
movl $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeNew
struct rbTree *rbTreeNew(int (*compare)(void *, void *))
/* rbTreeNew() - Allocates space for a red-black tree and returns a pointer
 * to it.  The function compare compares they keys of two items, and returns a
 * negative, zero, or positive integer depending on whether the first item is
 * less than, equal to, or greater than the second.  */
{
/* The stack keeps us from having to keep explicit
 * parent, grandparent, greatgrandparent variables.
 * It needs to be big enough for the maximum depth
 * of tree.  Since the whole point of rb trees is
 * that they are self-balancing, this is not all
 * that deep, just 2*log2(N).  Therefore a stack of
 * 128 is good for up to 2^64 items in stack, which
 * should keep us for the next couple of decades... */
struct lm *lm = lmInit(0);
struct rbTreeNode **stack = lmAlloc(lm, 128 * sizeof(stack[0]));	
return rbTreeNewDetailed(compare, lm, stack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2c220
movq %rax, %r14
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
callq 0x2c325
movq %rax, %r15
movl $0x38, %edi
callq 0x2dff4
movq $0x0, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %r15, 0x20(%rax)
movl $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeFree
void rbTreeFree(struct rbTree **pTree)
/* rbTreeFree() - Frees space used by the red-black tree pointed to by t. */
{
struct rbTree *tree = *pTree;
if (tree != NULL)
    {
    lmCleanup(&tree->lm);
    freez(pTree);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3ac0c
addq $0x28, %rdi
callq 0x2c2c7
movq %rbx, %rdi
popq %rbx
jmp 0x2e0b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeFreeList
void rbTreeFreeList(struct rbTree **pList)
/* Free up a list of rbTrees. */
{
struct rbTree *tree, *next;
for (tree = *pList; tree != NULL; tree = next)
    {
    next = tree->next;
    rbTreeFree(&tree);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq %r14, (%rsp)
testq %r14, %r14
je 0x3ac35
movq %rsp, %rbx
movq (%r14), %r14
movq %rbx, %rdi
callq 0x3abee
movq %r14, (%rsp)
testq %r14, %r14
jne 0x3ac21
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeFind
void *rbTreeFind(struct rbTree *t, void *item)
/* rbTreeFind() - Find an item in the red-black tree with the same key as the
 * item pointed to by `item'.  Returns a pointer to the item found, or NULL
 * if no item was found.
 */
{
struct rbTreeNode *p, *nextP;
int (*compare)(void *, void *) = t->compare;
int cmpResult;
    
/* Repeatedly explore either the left or right branch, depending on the
 * value of the key, until the correct item is found.  */
for (p = t->root; p != NULL; p = nextP)
    {
    cmpResult = compare(item, p->item);
    if(cmpResult < 0) 
	nextP = p->left;
    else if(cmpResult > 0) 
	nextP = p->right;
    else 
	return p->item;
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x3ae72
movq %rsi, %r14
movq 0x18(%rdi), %r12
xorl %ebx, %ebx
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq *%r12
testl %eax, %eax
js 0x3ae68
je 0x3ae76
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x3ae54
jmp 0x3ae7a
xorl %ebx, %ebx
jmp 0x3ae7a
movq 0x18(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeDump
void rbTreeDump(struct rbTree *tree, FILE *f, 
	void (*dumpItem)(void *item, FILE *f))
/* Dump out rb tree to file, mostly for debugging. */
{
dumpFile = f;
dumpLevel = 0;
dumpIt = dumpItem;
fprintf(f, "rbTreeDump\n");
rTreeDump(tree->root);
}

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, 0x88f43(%rip)     # 0xc4108
movl $0x0, 0x88f41(%rip)     # 0xc4110
movq %rdx, 0x88f42(%rip)     # 0xc4118
leaq 0x594f7(%rip), %rdi     # 0x946d4
movl $0xb, %esi
movl $0x1, %edx
callq 0x6e70
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x3b1f3
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rTreeDump
static void rTreeDump(struct rbTreeNode *n)
/* Recursively dump. */
{
if (n == NULL)
    return;
spaceOut(dumpFile, ++dumpLevel * 3);
fprintf(dumpFile, "%c ", (n->color ==  rbTreeRed ? 'r' : 'b'));
dumpIt(n->item, dumpFile);
fprintf(dumpFile, "\n");
rTreeDump(n->left);
rTreeDump(n->right);
--dumpLevel;
}

// Assembly:
testq %rdi, %rdi
je 0x3b277
pushq %rbx
movq %rdi, %rbx
movq 0x88f05(%rip), %rdi     # 0xc4108
movl 0x88f07(%rip), %eax     # 0xc4110
incl %eax
movl %eax, 0x88eff(%rip)     # 0xc4110
leal (%rax,%rax,2), %esi
callq 0x22ad1
xorl %edx, %edx
cmpl $0x0, 0x10(%rbx)
movq 0x88ee2(%rip), %rdi     # 0xc4108
sete %dl
shll $0x4, %edx
orl $0x62, %edx
leaq 0x594aa(%rip), %rsi     # 0x946e0
xorl %eax, %eax
callq 0x6a90
movq 0x18(%rbx), %rdi
movq 0x88ec0(%rip), %rsi     # 0xc4108
callq *0x88eca(%rip)          # 0xc4118
movq 0x88eb3(%rip), %rsi     # 0xc4108
movl $0xa, %edi
callq 0x6930
movq (%rbx), %rdi
callq 0x3b1f3
movq 0x8(%rbx), %rdi
callq 0x3b1f3
decl 0x88e9a(%rip)           # 0xc4110
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeTraverseRangeWithContext
void rbTreeTraverseRangeWithContext(struct rbTree *tree, void *minItem, void *maxItem,
	void (*doItem)(void *item, void *context), void *context)
/* Apply doItem function to all items in tree such that
 * minItem <= item <= maxItem.  THREAD SAFE */
{
struct rangeParams ourParams;
ourParams.doIt = doItem;
ourParams.minIt = minItem;
ourParams.maxIt = maxItem;
ourParams.compareIt = tree->compare;
rTreeTraverseRangeWithContext(tree->root, &ourParams, context);
}

// Assembly:
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rdi), %rdi
movq %rax, %rsi
movq %r8, %rdx
callq 0x3b2a8
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rTreeTraverseRangeWithContext
static void rTreeTraverseRangeWithContext(struct rbTreeNode *n, struct rangeParams *rp, void *context)
/* Recursively traverse tree in range applying doIt with context. */
{
if (n != NULL)
   {
   int minCmp = rp->compareIt(n->item, rp->minIt);
   int maxCmp = rp->compareIt(n->item, rp->maxIt);
   if (minCmp >= 0)
       rTreeTraverseRangeWithContext(n->left, rp, context);
   if (minCmp >= 0 && maxCmp <= 0)
       rp->doIt(n->item, context);
   if (maxCmp <= 0)
       rTreeTraverseRangeWithContext(n->right, rp, context);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x3b313
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%r15), %rdi
movq 0x8(%r14), %rsi
callq *0x18(%r14)
movl %eax, %r12d
movq 0x18(%r15), %rdi
movq 0x10(%r14), %rsi
callq *0x18(%r14)
movl %eax, %ebp
testl %r12d, %r12d
js 0x3b2fe
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b2a8
testl %ebp, %ebp
jg 0x3b30b
movq 0x18(%r15), %rdi
movq %rbx, %rsi
callq *(%r14)
jmp 0x3b302
testl %ebp, %ebp
jg 0x3b30b
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x3b2be
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rTreeTraverseRange
static void rTreeTraverseRange(struct rbTreeNode *n)
/* Recursively traverse tree in range applying doIt. */
{
if (n != NULL)
   {
   int minCmp = compareIt(n->item, minIt);
   int maxCmp = compareIt(n->item, maxIt);
   if (minCmp >= 0)
       rTreeTraverseRange(n->left);
   if (minCmp >= 0 && maxCmp <= 0)
       doIt(n->item);
   if (maxCmp <= 0)
       rTreeTraverseRange(n->right);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x3b39b
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
movq 0x88dd7(%rip), %rsi     # 0xc4128
callq *0x88de1(%rip)          # 0xc4138
movl %eax, %r14d
movq 0x18(%rbx), %rdi
movq 0x88dcb(%rip), %rsi     # 0xc4130
callq *0x88dcd(%rip)          # 0xc4138
movl %eax, %ebp
testl %r14d, %r14d
js 0x3b38a
movq (%rbx), %rdi
callq 0x3b33a
testl %ebp, %ebp
jg 0x3b397
movq 0x18(%rbx), %rdi
callq *0x88d98(%rip)          # 0xc4120
jmp 0x3b38e
testl %ebp, %ebp
jg 0x3b397
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3b346
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rTreeTraverse
static void rTreeTraverse(struct rbTreeNode *n)
/* Recursively traverse full tree applying doIt. */
{
if (n != NULL)
    {
    rTreeTraverse(n->left);
    doIt(n->item);
    rTreeTraverse(n->right);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3b3ce
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x3b3a9
movq 0x18(%rbx), %rdi
callq *0x88d5c(%rip)          # 0xc4120
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3b3b2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rTreeTraverseWithContext
static void rTreeTraverseWithContext(struct rbTreeNode *n, struct rTreeContext *context)
/* Traverse tree with a little context so don't need little static variables that
 * prevent reentrancy of callback functions. */
{
if (n != NULL)
    {
    rTreeTraverseWithContext(n->left, context);
    context->doItem(n->item, context->context);
    rTreeTraverseWithContext(n->right, context);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3b424
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3b3f0
movq 0x18(%r14), %rdi
movq (%rbx), %rsi
callq *0x8(%rbx)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x3b3ff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeItemsInRange
struct slRef *rbTreeItemsInRange(struct rbTree *tree, void *minItem, void *maxItem)
/* Return a sorted list of references to items in tree between range.
 * slFreeList this list when done. */
{
itList = NULL;
rbTreeTraverseRange(tree, minItem, maxItem, addRef);
slReverse(&itList);
return itList;
}

// Assembly:
pushq %rbx
movq $0x0, 0x88d0f(%rip) # 0xc4140
leaq 0x88d08(%rip), %rbx     # 0xc4140
leaq 0x3a(%rip), %rax        # 0x3b479
movq %rax, 0x88cda(%rip)     # 0xc4120
movq %rsi, 0x88cdb(%rip)     # 0xc4128
movq %rdx, 0x88cdc(%rip)     # 0xc4130
movq 0x18(%rdi), %rax
movq %rax, 0x88cd9(%rip)     # 0xc4138
movq 0x8(%rdi), %rdi
callq 0x3b33a
movq %rbx, %rdi
callq 0x20173
movq 0x88cc9(%rip), %rax     # 0xc4140
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeItems
struct slRef *rbTreeItems(struct rbTree *tree)
/* Return sorted list of items.  slFreeList this when done.*/
{
struct slRef *list = NULL;
rbTreeTraverseWithContext(tree, addRefWithContext, &list);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x1e(%rip), %rax        # 0x3b4c6
movq %rax, 0x8(%rsi)
movq 0x8(%rdi), %rdi
callq 0x3b3f0
movq %rbx, %rdi
callq 0x20173
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutStaticLoad
void repeatMaskOutStaticLoad(char **row, struct repeatMaskOut *ret)
/* Load a row from repeatMaskOut table into ret.  The contents of ret will
 * be replaced at the next call to this function. */
{
int i;

ret->score = sqlUnsigned(row[0]);
ret->percDiv = atof(row[1]);
ret->percDel = atof(row[2]);
ret->percInc = atof(row[3]);
ret->qName = row[4];
ret->qStart = sqlSigned(row[5]);
ret->qEnd = sqlSigned(row[6]);
ret->qLeft = row[7];
strcpy(ret->strand, row[8]);
ret->rName = row[9];
ret->rFamily = row[10];
ret->rStart = row[11];	/* sometimes this number is enclosed in (parens) */
/* This row[12] is interpreted as an Unsigned - but I can find no good reason
 * for it to be an error exit when there is a negative number here.
 * The only programs that use this routine are blat, psLayout and
 * maskOutFa and none of them even use this number for anything.
 * For data base loading of the rmsk tracks, these .out files are parsed
 * by hgLoadOut and none of this business is referenced.
 */
i = sqlSigned(row[12]);
if( i < 0 ) {
    warn("WARNING: negative rEnd: %d %s:%d-%d %s", i, ret->qName, ret->qStart, ret->qEnd, ret->rName);
    ret->rEnd = 0;
} else {
ret->rEnd = sqlUnsigned(row[12]);
}
ret->rLeft = row[13];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x3bc10
movl %eax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rbx)
movq 0x10(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rdi
callq 0x3bd74
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rdi
callq 0x3bd74
movl %eax, 0x24(%rbx)
movq 0x38(%r14), %rax
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x6680
movq 0x48(%r14), %rax
movq %rax, 0x38(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x40(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x48(%rbx)
movq 0x60(%r14), %rdi
callq 0x3bd74
testl %eax, %eax
js 0x3b592
movq 0x60(%r14), %rdi
callq 0x3bc10
movl %eax, %ebp
jmp 0x3b5b3
movq 0x18(%rbx), %rdx
movl 0x20(%rbx), %ecx
movl 0x24(%rbx), %r8d
movq 0x38(%rbx), %r9
leaq 0x5913c(%rip), %rdi     # 0x946e4
xorl %ebp, %ebp
movl %eax, %esi
xorl %eax, %eax
callq 0x26bea
movl %ebp, 0x50(%rbx)
movq 0x68(%r14), %rax
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutLoad
struct repeatMaskOut *repeatMaskOutLoad(char **row)
/* Load a repeatMaskOut from row fetched with select * from repeatMaskOut
 * from database.  Dispose of this with repeatMaskOutFree(). */
{
struct repeatMaskOut *ret;

AllocVar(ret);
ret->score = sqlUnsigned(row[0]);
ret->percDiv = atof(row[1]);
ret->percDel = atof(row[2]);
ret->percInc = atof(row[3]);
ret->qName = cloneString(row[4]);
ret->qStart = sqlSigned(row[5]);
ret->qEnd = sqlSigned(row[6]);
ret->qLeft = cloneString(row[7]);
strcpy(ret->strand, row[8]);
ret->rName = cloneString(row[9]);
ret->rFamily = cloneString(row[10]);
ret->rStart = cloneString(row[11]);
ret->rEnd = sqlUnsigned(row[12]);
ret->rLeft = cloneString(row[13]);
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x2dff4
movq %rax, %rbx
movq (%r14), %rdi
callq 0x3bc10
movl %eax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rbx)
movq 0x10(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
movq 0x20(%r14), %rdi
callq 0x1feba
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rdi
callq 0x3bd74
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rdi
callq 0x3bd74
movl %eax, 0x24(%rbx)
movq 0x38(%r14), %rdi
callq 0x1feba
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x6680
movq 0x48(%r14), %rdi
callq 0x1feba
movq %rax, 0x38(%rbx)
movq 0x50(%r14), %rdi
callq 0x1feba
movq %rax, 0x40(%rbx)
movq 0x58(%r14), %rdi
callq 0x1feba
movq %rax, 0x48(%rbx)
movq 0x60(%r14), %rdi
callq 0x3bc10
movl %eax, 0x50(%rbx)
movq 0x68(%r14), %rdi
callq 0x1feba
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutCommaIn
struct repeatMaskOut *repeatMaskOutCommaIn(char **pS)
/* Create a repeatMaskOut out of a comma separated string. */
{
struct repeatMaskOut *ret;
char *s = *pS;

AllocVar(ret);
ret->score = sqlUnsignedComma(&s);
ret->percDiv = sqlSignedComma(&s);
ret->percDel = sqlSignedComma(&s);
ret->percInc = sqlSignedComma(&s);
ret->qName = sqlStringComma(&s);
ret->qStart = sqlSignedComma(&s);
ret->qEnd = sqlSignedComma(&s);
ret->qLeft = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->rName = sqlStringComma(&s);
ret->rFamily = sqlStringComma(&s);
ret->rStart = sqlStringComma(&s);
ret->rEnd = sqlUnsignedComma(&s);
ret->rLeft = sqlStringComma(&s);
*pS = s;
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl $0x60, %edi
callq 0x2dff4
movq %rax, %r15
movq %r14, %rdi
callq 0x3da0b
movl %eax, 0x8(%r15)
movq %r14, %rdi
callq 0x3da3a
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%r15)
movq %r14, %rdi
callq 0x3da3a
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x10(%r15)
movq %r14, %rdi
callq 0x3da3a
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x14(%r15)
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x18(%r15)
movq %r14, %rdi
callq 0x3da3a
movl %eax, 0x20(%r15)
movq %r14, %rdi
callq 0x3da3a
movl %eax, 0x24(%r15)
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x28(%r15)
leaq 0x30(%r15), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x3dbcc
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x38(%r15)
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x40(%r15)
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x48(%r15)
movq %r14, %rdi
callq 0x3da0b
movl %eax, 0x50(%r15)
movq %r14, %rdi
callq 0x3db26
movq %rax, 0x58(%r15)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFree
void repeatMaskOutFree(struct repeatMaskOut **pEl)
/* Free a single dynamically allocated repeatMaskOut such as created
 * with repeatMaskOutLoad(). */
{
struct repeatMaskOut *el;

if ((el = *pEl) == NULL) return;
freeMem(el->qName);
freeMem(el->qLeft);
freeMem(el->rName);
freeMem(el->rFamily);
freeMem(el->rStart);
freeMem(el->rLeft);
freez(pEl);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x3b7f2
movq %rdi, %rbx
movq 0x18(%r14), %rdi
callq 0x2e0a0
movq 0x28(%r14), %rdi
callq 0x2e0a0
movq 0x38(%r14), %rdi
callq 0x2e0a0
movq 0x40(%r14), %rdi
callq 0x2e0a0
movq 0x48(%r14), %rdi
callq 0x2e0a0
movq 0x58(%r14), %rdi
callq 0x2e0a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFreeList
void repeatMaskOutFreeList(struct repeatMaskOut **pList)
/* Free a list of dynamically allocated repeatMaskOut's */
{
struct repeatMaskOut *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    repeatMaskOutFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x3b82d
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x3b79e
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x3b818
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedOrError
unsigned sqlUnsignedOrError(char *s, char *format, ...)
/* Convert series of digits to unsigned integer about
 * twice as fast as atoi (by not having to skip white 
 * space or stop except at the null byte.) 
 * like sqlUnsigned, with an optional error message as a printf-style vararg
 * */
{
unsigned res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
/* test for invalid character or empty */
if ((c != '\0') || (p == s))
    {
    if (format==NULL)
        errAbort("invalid unsigned integer: \"%s\"", s);
    else
        {
        //errAbort("%s", errorMsg);
        va_list args;
        va_start(args, format);
        vaErrAbort(format, args);
        va_end(args);
        }
    }
return res;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3bb7f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb (%rdi), %al
leal -0x30(%rax), %ecx
xorl %ebx, %ebx
cmpb $0x9, %cl
ja 0x3bbbd
leaq 0x1(%r10), %rcx
xorl %ebx, %ebx
movzbl %al, %eax
leal (%rbx,%rbx,4), %edx
leal (%rax,%rdx,2), %ebx
addl $-0x30, %ebx
movb (%rcx), %al
leal -0x30(%rax), %edx
incq %rcx
cmpb $0xa, %dl
jb 0x3bba0
testb %al, %al
je 0x3bc05
testq %rsi, %rsi
je 0x3bbf4
leaq 0x20(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x26f72
jmp 0x3bc05
leaq 0x58b13(%rip), %rdi     # 0x9470e
movq %r10, %rsi
xorl %eax, %eax
callq 0x26e94
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedInList
unsigned sqlUnsignedInList(char **pS)
/* Convert series of digits to unsigned integer about
 * twice as fast as atoi (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if (!(c == '\0' || c == ',') || (p == s))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid unsigned integer: \"%s\"", s);
    }
*pS = p;
return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movb (%r14), %al
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
cmpb $0x9, %cl
ja 0x3bc5c
xorl %r15d, %r15d
movq %r14, %r12
movzbl %al, %eax
leal (%r15,%r15,4), %ecx
leal (%rax,%rcx,2), %r15d
addl $-0x30, %r15d
movb 0x1(%r12), %al
incq %r12
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x3bc3b
jmp 0x3bc5f
movq %r14, %r12
cmpb $0x2c, %al
je 0x3bc6a
movzbl %al, %eax
testl %eax, %eax
jne 0x3bc6f
cmpq %r14, %r12
jne 0x3bc95
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bc84
movb $0x0, (%rax)
leaq 0x58a83(%rip), %rdi     # 0x9470e
movq %r14, %rsi
xorl %eax, %eax
callq 0x26e94
movq %r12, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLong
unsigned long sqlUnsignedLong(char *s)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) */
{
unsigned long res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if ((c != '\0') || (p == s))
    errAbort("invalid unsigned long: \"%s\"", s);
return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x3bcdb
leaq 0x1(%rsi), %rcx
xorl %ebx, %ebx
leaq (%rbx,%rbx,4), %rdx
andb $0xf, %al
movzbl %al, %eax
leaq (%rax,%rdx,2), %rbx
movb (%rcx), %al
leal -0x30(%rax), %edx
incq %rcx
cmpb $0xa, %dl
jb 0x3bcbb
testb %al, %al
jne 0x3bcdd
jmp 0x3bceb
xorl %ebx, %ebx
leaq 0x58a49(%rip), %rdi     # 0x9472d
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLongInList
unsigned long sqlUnsignedLongInList(char **pS)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned long res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if (!(c == '\0' || c == ',') || (p == s))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid unsigned long: \"%s\"", s);
    }
*pS = p;
return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movb (%r14), %al
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
movq %r14, %r12
cmpb $0x9, %cl
ja 0x3bd2c
leaq (%r15,%r15,4), %rcx
andb $0xf, %al
movzbl %al, %eax
leaq (%rax,%rcx,2), %r15
movb 0x1(%r12), %al
incq %r12
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x3bd0f
cmpb $0x2c, %al
je 0x3bd37
movzbl %al, %eax
testl %eax, %eax
jne 0x3bd3c
cmpq %r14, %r12
jne 0x3bd62
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bd51
movb $0x0, (%rax)
leaq 0x589d5(%rip), %rdi     # 0x9472d
movq %r14, %rsi
xorl %eax, %eax
callq 0x26e94
movq %r12, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSigned
int sqlSigned(char *s)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. */
{
int res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if ((*p != '\0') || (p == p0))
    errAbort("invalid signed integer: \"%s\"", s);
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
xorl %edx, %edx
cmpb $0x2d, %cl
sete %dl
movb (%rdi,%rdx), %al
leal -0x30(%rax), %esi
xorl %r14d, %r14d
cmpb $0x9, %sil
ja 0x3bdbc
addq %rbx, %rdx
incq %rdx
xorl %r14d, %r14d
leal (%r14,%r14,4), %esi
addb $-0x30, %al
movzbl %al, %eax
leal (%rax,%rsi,2), %r14d
movb (%rdx), %al
leal -0x30(%rax), %esi
incq %rdx
cmpb $0xa, %sil
jb 0x3bd9d
testb %al, %al
je 0x3bdcf
leaq 0x58986(%rip), %rdi     # 0x94749
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26e94
movb (%rbx), %cl
movl %r14d, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSignedInList
int sqlSignedInList(char **pS)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
int res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if (!(*p == '\0' || *p == ',') || (p == p0))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid signed integer: \"%s\"", s);
    }
*pS = p;
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
xorl %ecx, %ecx
cmpb $0x2d, (%rbx)
sete %cl
leaq (%rbx,%rcx), %rax
movb (%rbx,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r15d, %r15d
cmpb $0x9, %dl
ja 0x3be31
xorl %r15d, %r15d
movq %rax, %r12
leal (%r15,%r15,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %r15d
movb 0x1(%r12), %cl
incq %r12
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x3be11
jmp 0x3be34
movq %rax, %r12
cmpb $0x2c, %cl
je 0x3be40
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x3be45
cmpq %rax, %r12
jne 0x3be6b
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3be5a
movb $0x0, (%rax)
leaq 0x588e8(%rip), %rdi     # 0x94749
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26e94
movq %r12, (%r14)
movl %r15d, %eax
negl %eax
cmpb $0x2d, (%rbx)
cmovnel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLong
long long sqlLongLong(char *s)
/* Convert string to a long long.  Unlike atol assumes all of string is
 * number. */
{
long long res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if ((*p != '\0') || (p == p0))
    errAbort("invalid signed long long: \"%s\"", s);
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
xorl %edx, %edx
cmpb $0x2d, %cl
sete %dl
movb (%rdi,%rdx), %al
leal -0x30(%rax), %esi
cmpb $0x9, %sil
ja 0x3becd
addq %rbx, %rdx
incq %rdx
xorl %r14d, %r14d
leaq (%r14,%r14,4), %rsi
addb $-0x30, %al
movzbl %al, %eax
leaq (%rax,%rsi,2), %r14
movb (%rdx), %al
leal -0x30(%rax), %esi
incq %rdx
cmpb $0xa, %sil
jb 0x3beac
testb %al, %al
jne 0x3bed0
jmp 0x3bee3
xorl %r14d, %r14d
leaq 0x5888f(%rip), %rdi     # 0x94766
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26e94
movb (%rbx), %cl
movq %r14, %rax
negq %rax
cmpb $0x2d, %cl
cmovneq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLongInList
long long sqlLongLongInList(char **pS)
/* Convert string to a long long.  Unlike atol, assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
long long res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if (!(*p == '\0' || *p == ',') || (p == p0))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid signed long long: \"%s\"", s);
    }
*pS = p;
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
xorl %ecx, %ecx
cmpb $0x2d, (%rbx)
sete %cl
leaq (%rbx,%rcx), %rax
movb (%rbx,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r15d, %r15d
movq %rax, %r12
cmpb $0x9, %dl
ja 0x3bf41
leaq (%r15,%r15,4), %rdx
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rdx,2), %r15
movb 0x1(%r12), %cl
incq %r12
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x3bf23
cmpb $0x2c, %cl
je 0x3bf4d
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x3bf52
cmpq %rax, %r12
jne 0x3bf78
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bf67
movb $0x0, (%rax)
leaq 0x587f8(%rip), %rdi     # 0x94766
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26e94
movq %r12, (%r14)
movq %r15, %rax
negq %rax
cmpb $0x2d, (%rbx)
cmovneq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlNum.c
// Function: sqlFloat
float sqlFloat(char *s)
/* Convert string to a float.  Assumes all of string is number
 * and aborts on an error. */
{
char* end;
/*	used to have an ifdef here to use strtof() but that doesn't
 *	actually exist on all systems and since strtod() does, may as
 *	well use it since it will do the job here.
 */
float val = (float) strtod(s, &end);

if ((end == s) || (*end != '\0'))
    errAbort("invalid float: %s", s);
return val;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x6500
movq (%r14), %rax
cmpq %rbx, %rax
je 0x3bfb8
cmpb $0x0, (%rax)
je 0x3bfd5
leaq 0x587c6(%rip), %rdi     # 0x94785
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x26e94
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq