LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: pslNew
struct psl* pslNew(char *qName, unsigned qSize, int qStart, int qEnd,
                   char *tName, unsigned tSize, int tStart, int tEnd,
                   char *strand, unsigned blockSpace, unsigned opts)
/* create a new psl with space for the specified number of blocks allocated.
 * pslGrow maybe used to expand this space if needed.  Valid options are
 * PSL_XA_FORMAT. */
{
struct psl *psl;
AllocVar(psl);
assert(blockSpace > 0);
psl->qName = cloneString(qName);
psl->qSize = qSize;
psl->qStart = qStart;
psl->qEnd = qEnd;
psl->tName = cloneString(tName);
psl->tSize = tSize;
psl->tStart = tStart;
psl->tEnd = tEnd;
strncpy(psl->strand, strand, 2);
AllocArray(psl->blockSizes, blockSpace);
AllocArray(psl->qStarts, blockSpace);
AllocArray(psl->tStarts, blockSpace);
if (opts & PSL_XA_FORMAT)
    {
    AllocArray(psl->qSequence, blockSpace);
    AllocArray(psl->tSequence, blockSpace);
    }
return psl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x88, %edi
callq 0x40c50
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x28(%rbp)
jbe 0x51e93
jmp 0x51eb2
leaq 0x8c087(%rip), %rdi     # 0xddf21
leaq 0x8bd48(%rip), %rsi     # 0xddbe9
movl $0x719, %edx            # imm = 0x719
leaq 0x8c083(%rip), %rcx     # 0xddf30
callq 0x6450
movq -0x8(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x38(%rax)
movl -0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x20(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x50(%rax)
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x54(%rax)
movl 0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq 0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x6370
movl 0x28(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movl 0x28(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x68(%rax)
movl 0x28(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x70(%rax)
movl 0x30(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51fb7
movl 0x28(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x78(%rax)
movl 0x28(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: addBlock
static void addBlock(struct psl* psl, int qs, int qe, int ts, int te,
                     int *blockSpace)
/* add a block to the psl, growing if necessary */
{
assert((qe-qs) == (te-ts));  /* same lengths? */
if (psl->blockCount == *blockSpace)
    pslGrow(psl, blockSpace);
psl->blockSizes[psl->blockCount] = qe - qs;
psl->qStarts[psl->blockCount] = qs;
psl->tStarts[psl->blockCount] = ts;
psl->blockCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5221f
jmp 0x5223e
leaq 0x8c219(%rip), %rdi     # 0xde43f
leaq 0x8b9bc(%rip), %rsi     # 0xddbe9
movl $0x686, %edx            # imm = 0x686
leaq 0x8c219(%rip), %rcx     # 0xde452
callq 0x6450
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x5225a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52430
movl -0x10(%rbp), %edx
subl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: accumCounts
static void accumCounts(struct psl *psl, char prevQ, char prevT,
                        char q, char t, unsigned options)
/* accumulate block and base counts  */
{
if (!isDelChar(q) && !isDelChar(t))
    {
    /* aligned column. */
    char qu = toupper(q);
    char tu = toupper(t);
    if ((q == 'N') || (t == 'N'))
        psl->nCount++;
    else if (qu == tu)
        {
        if ((options & PSL_IS_SOFTMASK) && ((qu != q) || (tu != t)))
            psl->repMatch++;
        else
            psl->match++;
        }
    else
        psl->misMatch++;
    }
else if (isDelChar(q) && !isDelChar(t))
    {
    /* target insert */
    psl->tBaseInsert++;
    if (!isDelChar(prevQ))
        psl->tNumInsert++;
    }
else if (isDelChar(t) && !isDelChar(q))
    {
    /* query insert */
    psl->qBaseInsert++;
    if (!isDelChar(prevT))
        psl->qNumInsert++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movl %r9d, -0x10(%rbp)
movsbl -0xb(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x5238e
movsbl -0xc(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x5238e
movsbl -0xb(%rbp), %edi
callq 0x6de0
movb %al, -0x11(%rbp)
movsbl -0xc(%rbp), %edi
callq 0x6de0
movb %al, -0x12(%rbp)
movsbl -0xb(%rbp), %eax
cmpl $0x4e, %eax
je 0x5231e
movsbl -0xc(%rbp), %eax
cmpl $0x4e, %eax
jne 0x5232d
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x52389
movsbl -0x11(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5237a
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5236b
movsbl -0x11(%rbp), %eax
movsbl -0xb(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5235c
movsbl -0x12(%rbp), %eax
movsbl -0xc(%rbp), %ecx
cmpl %ecx, %eax
je 0x5236b
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x52378
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x52387
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x52389
jmp 0x5241e
movsbl -0xb(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
je 0x523d4
movsbl -0xc(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x523d4
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movsbl -0x9(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x523d2
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x5241c
movsbl -0xc(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
je 0x5241a
movsbl -0xb(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x5241a
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movsbl -0xa(%rbp), %edi
callq 0x521a0
cmpl $0x0, %eax
jne 0x52418
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x5241a
jmp 0x5241c
jmp 0x5241e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: pslGrow
void pslGrow(struct psl *psl, int *blockSpacePtr)
/* Increase memory allocated to a psl to hold more blocks.  blockSpacePtr
 * should point the the current maximum number of blocks and will be
 * updated to with the new amount of space. */
{
int blockSpace = *blockSpacePtr;
int newSpace = 2 * blockSpace;
ExpandArray(psl->blockSizes, blockSpace, newSpace);
ExpandArray(psl->qStarts, blockSpace, newSpace);
ExpandArray(psl->tStarts, blockSpace, newSpace);
if (psl->qSequence != NULL)
    {
    ExpandArray(psl->qSequence, blockSpace, newSpace);
    ExpandArray(psl->tSequence, blockSpace, newSpace);
    }
*blockSpacePtr = newSpace;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x40ce0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x40ce0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x40ce0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x5252a
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x3, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x40ce0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x3, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x40ce0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jae 0x52653
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movq -0x8(%rbp), %rdx
movq 0x60(%rdx), %rdx
movl -0xc(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
addl (%rdx,%rsi,4), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x525e7
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x70(%rcx), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movq -0x8(%rbp), %rdx
movq 0x60(%rdx), %rdx
movl -0xc(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
addl (%rdx,%rsi,4), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x52643
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
jmp 0x52645
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5257b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: getNextCigarOp
static boolean getNextCigarOp(char *startPtr, boolean reverse, char **ptr, char *op, int *size)
/* gets one cigar op out of the CIGAR string.  Reverse the order if asked */
{
char *str = *ptr;

if (str == NULL)
    return FALSE;

if ((!reverse && (*str == 0)) || (reverse && (str == startPtr)))
    return FALSE;

// between each cigar op there could be nothing, or a space, or a plus
if (reverse)
    {
    char *end = str - 1;
    for(;*end ; end--)
	{
	if (isalpha(*end))
	    break;
	}
    str = end;
    *ptr = end;
    }
else
    {
    char *end = str + 1;
    for(;*end ; end++)
	{
	if (! (isdigit(*end)  || (*end == ' ') || (*end == '+')))
	    break;
	}

    *ptr = end;
    }

*op = *str++;
*size = atoi(str);
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x52a79
movl $0x0, -0x4(%rbp)
jmp 0x52ba2
cmpl $0x0, -0x14(%rbp)
jne 0x52a8b
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x52a9b
cmpl $0x0, -0x14(%rbp)
je 0x52aa7
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x52aa7
movl $0x0, -0x4(%rbp)
jmp 0x52ba2
cmpl $0x0, -0x14(%rbp)
je 0x52b09
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x52af4
callq 0x6780
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x52ae4
jmp 0x52af4
jmp 0x52ae6
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x52ab9
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x52b73
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
je 0x52b68
callq 0x6780
movq (%rax), %rax
movq -0x48(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x52b58
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x52b58
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x52b58
jmp 0x52b68
jmp 0x52b5a
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x52b15
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rdi
callq 0x6bd0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x29(%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jae 0x52cb1
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rcx
movslq -0x14(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x52c91
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edx
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x33350
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x53cb0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52c44
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: pslIdent
float pslIdent(struct psl *psl)
/* computer fraction identity */
{
float aligned = psl->match + psl->misMatch + psl->repMatch;
if (aligned == 0.0)
    return 0.0;
else
    return ((float)(psl->match + psl->repMatch))/aligned;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %edx
addl %edx, %eax
movl 0x10(%rcx), %ecx
addl %ecx, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x52d01
jp 0x52d01
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x52d1c
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
movl 0x10(%rcx), %ecx
addl %ecx, %eax
cvtsi2ss %rax, %xmm0
divss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x52f90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x53023
movq -0x20(%rbp), %rdi
callq 0x4eba0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4eba0
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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 0x48(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x52f90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x53085
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x54(%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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8aff8(%rip), %rsi     # 0xde0a3
callq 0x6a40
cmpl $0x0, %eax
jne 0x530ca
movq -0x8(%rbp), %rdi
leaq -0x46b0(%rip), %rsi     # 0x4ea10
callq 0x2ab90
jmp 0x53181
movq -0x10(%rbp), %rdi
leaq 0x8afc2(%rip), %rsi     # 0xde097
callq 0x6a40
cmpl $0x0, %eax
jne 0x530f4
movq -0x8(%rbp), %rdi
leaq -0x44da(%rip), %rsi     # 0x4ec10
callq 0x2ab90
jmp 0x5317f
movq -0x10(%rbp), %rdi
leaq 0x868c1(%rip), %rsi     # 0xd99c0
callq 0x6a40
cmpl $0x0, %eax
jne 0x5311b
movq -0x8(%rbp), %rdi
leaq -0x45c4(%rip), %rsi     # 0x4eb50
callq 0x2ab90
jmp 0x5317d
movq -0x10(%rbp), %rdi
leaq 0x8af95(%rip), %rsi     # 0xde0bb
callq 0x6a40
cmpl $0x0, %eax
jne 0x53142
movq -0x8(%rbp), %rdi
leaq -0x10b(%rip), %rsi      # 0x53030
callq 0x2ab90
jmp 0x5317b
movq -0x10(%rbp), %rdi
leaq 0x8af62(%rip), %rsi     # 0xde0af
callq 0x6a40
cmpl $0x0, %eax
jne 0x53169
movq -0x8(%rbp), %rdi
leaq -0x1a2(%rip), %rsi      # 0x52fc0
callq 0x2ab90
jmp 0x53179
movq -0x8(%rbp), %rdi
leaq -0x4564(%rip), %rsi     # 0x4ec10
callq 0x2ab90
jmp 0x5317b
jmp 0x5317d
jmp 0x5317f
jmp 0x53181
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: printPslDesc
static void printPslDesc(char* pslDesc, FILE* out, struct psl* psl)
/* print description of a PSL on first error */
{
fprintf(out, "Error: invalid PSL: %s:%u-%u %s:%u-%u %s %s\n",
        psl->qName, psl->qStart, psl->qEnd,
        psl->tName, psl->tStart, psl->tEnd,
        psl->strand, pslDesc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x40(%rax), %r8d
movq -0x20(%rbp), %rax
movq 0x48(%rax), %r9
movq -0x20(%rbp), %rax
movl 0x54(%rax), %ebx
movq -0x20(%rbp), %rax
movl 0x58(%rax), %r11d
movq -0x20(%rbp), %r10
addq $0x28, %r10
movq -0x10(%rbp), %rax
leaq 0x8b076(%rip), %rsi     # 0xde260
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x6a80
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/rangeTree.c
// Function: rangeCmp
int rangeCmp(void *va, void *vb)
/* Return -1 if a before b,  0 if a and b overlap,
 * and 1 if a after b. */
{
struct range *a = va;
struct range *b = vb;
if (a->end <= b->start)
    return -1;
else if (b->end <= a->start)
    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, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x53515
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53535
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x5352e
movl $0x1, -0x4(%rbp)
jmp 0x53535
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %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 0x28(%rax), %rdi
movl $0x18, %esi
callq 0x3de60
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x544d0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x53638
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x535c7
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x535d1
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x535f7
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x53601
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x53633
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x53590
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x53fe0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
leaq 0xbb(%rip), %rcx        # 0x53b50
leaq -0x30(%rbp), %r8
movq %rdx, %rsi
callq 0x54ca0
leaq -0x30(%rbp), %rdi
callq 0x2aad0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x54430
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x21(%rip), %rsi        # 0x53b50
leaq -0x10(%rbp), %rdx
callq 0x54f40
leaq -0x10(%rbp), %rdi
callq 0x2aad0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x54430
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x53bf3
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jg 0x53bf3
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x18(%rbp), %eax
jl 0x53bf3
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53bfb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x53a60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x53c8c
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x305c0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x53c7d
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x53c7f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53c44
cmpq $0x0, -0x20(%rbp)
je 0x53c9e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0xb686d(%rip)     # 0x10a538
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, 0xb6865(%rip)     # 0x10a53c
movl %eax, -0x1c(%rbp)
movl $0x0, 0xb685c(%rip)     # 0x10a540
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
leaq 0x1d(%rip), %rcx        # 0x53d10
movq %rdx, %rsi
callq 0x54dc0
movl 0xb683f(%rip), %eax     # 0x10a540
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x40c50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x53f84
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3dd90
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x53fcc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x53f50
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x53fa7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x544b7
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x54487
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x544ab
cmpl $0x0, -0x34(%rbp)
jle 0x5449b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x544a9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x544bf
jmp 0x544ab
jmp 0x544ad
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x54458
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xb59a9(%rip)     # 0x10a548
movl $0x0, 0xb59a7(%rip)     # 0x10a550
movq -0x18(%rbp), %rax
movq %rax, 0xb59a4(%rip)     # 0x10a558
movq -0x10(%rbp), %rdi
leaq 0x898ca(%rip), %rsi     # 0xde489
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54be0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x54bf8
jmp 0x54c97
movq 0xb5949(%rip), %rdi     # 0x10a548
movl 0xb594b(%rip), %eax     # 0x10a550
addl $0x1, %eax
movl %eax, 0xb5942(%rip)     # 0x10a550
imull $0x3, %eax, %esi
callq 0x2f010
movq 0xb592b(%rip), %rdi     # 0x10a548
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movl $0x62, %edx
movl $0x72, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
leaq 0x8985a(%rip), %rsi     # 0xde495
movb $0x0, %al
callq 0x6a80
movq 0xb590f(%rip), %rax     # 0x10a558
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq 0xb58f0(%rip), %rsi     # 0x10a548
callq *%rax
movq 0xb58e7(%rip), %rdi     # 0x10a548
leaq 0x843b1(%rip), %rsi     # 0xd9019
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x54be0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54be0
movl 0xb58c2(%rip), %eax     # 0x10a550
addl $-0x1, %eax
movl %eax, 0xb58b9(%rip)     # 0x10a550
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x54d00
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54db1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x54d73
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54d00
cmpl $0x0, -0x1c(%rbp)
jl 0x54d94
cmpl $0x0, -0x20(%rbp)
jg 0x54d94
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, -0x20(%rbp)
jg 0x54daf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54d00
jmp 0x54db1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/rbTree.c
// Function: rbTreeTraverseRange
void rbTreeTraverseRange(struct rbTree *tree, void *minItem, void *maxItem,
	void (*doItem)(void *item))
/* Apply doItem function to all items in tree such that
 * minItem <= item <= maxItem */
{
doIt = doItem;
minIt = minItem;
maxIt = maxItem;
compareIt = tree->compare;
rTreeTraverseRange(tree->root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xb577d(%rip)     # 0x10a560
movq -0x10(%rbp), %rax
movq %rax, 0xb577a(%rip)     # 0x10a568
movq -0x18(%rbp), %rax
movq %rax, 0xb5777(%rip)     # 0x10a570
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xb5770(%rip)     # 0x10a578
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54e20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54ead
movq 0xb573e(%rip), %rax     # 0x10a578
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq 0xb571f(%rip), %rsi     # 0x10a568
callq *%rax
movl %eax, -0xc(%rbp)
movq 0xb5723(%rip), %rax     # 0x10a578
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq 0xb570c(%rip), %rsi     # 0x10a570
callq *%rax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x54e7b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x54e20
cmpl $0x0, -0xc(%rbp)
jl 0x54e98
cmpl $0x0, -0x10(%rbp)
jg 0x54e98
movq 0xb56d2(%rip), %rax     # 0x10a560
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
callq *%rax
cmpl $0x0, -0x10(%rbp)
jg 0x54eab
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54e20
jmp 0x54ead
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54f2d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x54ef0
movq 0xb564a(%rip), %rax     # 0x10a560
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x54ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54fd1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, 0xb5581(%rip) # 0x10a580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1e(%rip), %rcx        # 0x55030
callq 0x54dc0
leaq 0xb5562(%rip), %rdi     # 0x10a580
callq 0x2aad0
movq 0xb5556(%rip), %rax     # 0x10a580
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x21(%rip), %rsi        # 0x550a0
leaq -0x10(%rbp), %rdx
callq 0x54f40
leaq -0x10(%rbp), %rdi
callq 0x2aad0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)