LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: pslSwap
void pslSwap(struct psl *psl, boolean noRc)
/* swap query and target in psl.  If noRc is TRUE, don't reverse-complement
 * PSL if needed, instead make target strand explict. */
{
int itmp;
unsigned utmp;
char ctmp, *stmp; 
swapVars(psl->qBaseInsert, psl->tBaseInsert, utmp);
swapVars(psl->tNumInsert, psl->qNumInsert, utmp);
swapVars(psl->qName, psl->tName, stmp);
swapVars(psl->qSize, psl->tSize, utmp);
swapVars(psl->qStart, psl->tStart, itmp);
swapVars(psl->qEnd, psl->tEnd, itmp);

/* handle strand and block copy */
if (psl->strand[1] != '\0')
    {
    /* translated */
    swapVars(psl->strand[0], psl->strand[1], ctmp);
    swapBlocks(psl);
    }
else if (noRc)
    {
    /* untranslated with no reverse complement */
    psl->strand[1] = psl->strand[0];
    psl->strand[0] = '+';
    swapBlocks(psl);
    }
else
    {
    /* untranslated */
    if (psl->strand[0] == '+')
        swapBlocks(psl);
    else
        swapRCBlocks(psl);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movdqu 0x18(%rdi), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x18(%rdi)
movdqu 0x30(%rdi), %xmm0
movups 0x48(%rdi), %xmm1
movups %xmm1, 0x30(%rdi)
movdqu %xmm0, 0x48(%rdi)
movl 0x40(%rdi), %eax
movl 0x58(%rdi), %ecx
movl %ecx, 0x40(%rdi)
movl %eax, 0x58(%rdi)
movb 0x29(%rdi), %al
testb %al, %al
je 0x32ca5
movb 0x28(%rbx), %cl
movb %al, 0x28(%rbx)
movb %cl, 0x29(%rbx)
jmp 0x32cb9
movb 0x28(%rbx), %al
testl %esi, %esi
je 0x32cb5
movb %al, 0x29(%rbx)
movb $0x2b, 0x28(%rbx)
jmp 0x32cb9
cmpb $0x2b, %al
jne 0x32cc2
movq %rbx, %rdi
popq %rbx
jmp 0x32d5d
movq 0x70(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1c40c
movq 0x68(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1c40c
movq 0x60(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1c40c
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq %rax, 0x70(%rbx)
movq %rcx, 0x68(%rbx)
xorl %edx, %edx
movl 0x5c(%rbx), %esi
cmpq %rsi, %rdx
jae 0x32d27
movl 0x38(%rbx), %esi
movl (%rcx,%rdx,4), %edi
movq 0x60(%rbx), %r8
addl (%r8,%rdx,4), %edi
subl %edi, %esi
movl %esi, (%rcx,%rdx,4)
movl (%rax,%rdx,4), %esi
addl (%r8,%rdx,4), %esi
movl 0x50(%rbx), %edi
subl %esi, %edi
movl %edi, (%rax,%rdx,4)
incq %rdx
jmp 0x32cf8
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x32d5b
movq 0x60(%rbx), %rdx
callq 0x32b86
movq 0x80(%rbx), %rdi
movl 0x5c(%rbx), %esi
movq 0x60(%rbx), %rdx
callq 0x32b86
movdqu 0x78(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x78(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: swapBlocks
static void swapBlocks(struct psl *psl)
/* Swap the blocks in a psl without reverse complementing them. */
{
int i;
unsigned utmp;
char *stmp; 
for (i = 0; i < psl->blockCount; i++)
    {
    swapVars(psl->qStarts[i], psl->tStarts[i], utmp);
    if (psl->qSequence != NULL)
        swapVars(psl->qSequence[i], psl->tSequence[i], stmp);
    }
}

// Assembly:
xorl %eax, %eax
movl 0x5c(%rdi), %ecx
cmpq %rcx, %rax
jae 0x32da9
movq 0x68(%rdi), %rcx
movq 0x70(%rdi), %rdx
movl (%rcx,%rax,4), %esi
movl (%rdx,%rax,4), %r8d
movl %r8d, (%rcx,%rax,4)
movl %esi, (%rdx,%rax,4)
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x32da4
movq (%rcx,%rax,8), %rdx
movq 0x80(%rdi), %rsi
movq (%rsi,%rax,8), %rsi
movq %rsi, (%rcx,%rax,8)
movq 0x80(%rdi), %rcx
movq %rdx, (%rcx,%rax,8)
incq %rax
jmp 0x32d5f
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: pslTargetOffset
void pslTargetOffset(struct psl *psl, int offset)
/* Add offset to target positions in psl. */
{
int i, blockCount = psl->blockCount;
unsigned *tStarts = psl->tStarts;
psl->tStart += offset;
psl->tEnd += offset;
for (i=0; i<blockCount; ++i)
   tStarts[i] += offset;
}

// Assembly:
movl 0x5c(%rdi), %eax
movq 0x70(%rdi), %rcx
movq 0x54(%rdi), %xmm0
movd %esi, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x54(%rdi)
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x32ddc
addl %esi, (%rcx,%rdx,4)
incq %rdx
jmp 0x32dcf
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: pslDump
void pslDump(struct psl *psl, FILE *f)
/* Dump most of PSL to file - for debugging. */
{
int i;
fprintf(f, "<PRE>\n");
fprintf(f, "psl %s:%d-%d %s %s:%d-%d %d\n", 
	psl->qName, psl->qStart, psl->qEnd, psl->strand,
	psl->tName, psl->tStart, psl->tEnd, psl->blockCount);
for (i=0; i<psl->blockCount; ++i)
    fprintf(f, "  size %d, qStart %d, tStart %d\n", 
    	psl->blockSizes[i], psl->qStarts[i], psl->tStarts[i]);
fprintf(f, "</PRE>");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50168(%rip), %rdi     # 0x82f5a
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x6e70
movq 0x30(%r14), %rdx
movl 0x3c(%r14), %ecx
movl 0x40(%r14), %r8d
leaq 0x28(%r14), %r9
movl 0x54(%r14), %r10d
movl 0x58(%r14), %r11d
movl 0x5c(%r14), %r15d
leaq 0x5013e(%rip), %rsi     # 0x82f61
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
pushq 0x48(%r14)
callq 0x6a90
addq $0x20, %rsp
leaq 0x5013c(%rip), %r15     # 0x82f7e
xorl %r12d, %r12d
movl 0x5c(%r14), %eax
cmpq %rax, %r12
jae 0x32e78
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
movl (%rax,%r12,4), %edx
movl (%rcx,%r12,4), %ecx
movq 0x70(%r14), %rax
movl (%rax,%r12,4), %r8d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x6a90
incq %r12
jmp 0x32e45
leaq 0x50120(%rip), %rdi     # 0x82f9f
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6e70
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: pslRecalcBounds
void pslRecalcBounds(struct psl *psl)
/* Calculate qStart/qEnd tStart/tEnd at top level to be consistent
 * with blocks. */
{
int qStart, qEnd, tStart, tEnd, size;
int last = psl->blockCount - 1;
qStart = psl->qStarts[0];
tStart = psl->tStarts[0];
size = psl->blockSizes[last];
qEnd = psl->qStarts[last] + size;
tEnd = psl->tStarts[last] + size;
if (psl->strand[0] == '-')
    reverseIntRange(&qStart, &qEnd, psl->qSize);
if (psl->strand[1] == '-')
    reverseIntRange(&tStart, &tEnd, psl->tSize);
psl->qStart = qStart;
psl->qEnd = qEnd;
psl->tStart = tStart;
psl->tEnd = tEnd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x5c(%rdi), %eax
decl %eax
movq 0x68(%rdi), %rcx
movl (%rcx), %edx
movl %edx, 0xc(%rsp)
movq 0x70(%rdi), %rdx
movl (%rdx), %ebp
movl %ebp, 0x14(%rsp)
movq 0x60(%rdi), %rsi
cltq
movl (%rsi,%rax,4), %r14d
movl (%rcx,%rax,4), %ecx
addl %r14d, %ecx
movl %ecx, 0x8(%rsp)
addl (%rdx,%rax,4), %r14d
movl %r14d, 0x10(%rsp)
cmpb $0x2d, 0x28(%rdi)
jne 0x32ef3
movl 0x38(%rbx), %edx
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20d61
cmpb $0x2d, 0x29(%rbx)
jne 0x32f17
movl 0x50(%rbx), %edx
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d61
movl (%r14), %ebp
movl (%r15), %r14d
movl 0xc(%rsp), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%rsp), %eax
movl %eax, 0x40(%rbx)
movl %ebp, 0x54(%rbx)
movl %r14d, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: chkInsertCounts
static void chkInsertCounts(char* pslDesc, FILE* out, struct psl* psl,
                            char* pName, char pCLabel, unsigned* pBlockStarts,
                            unsigned pNumInsert, unsigned pBaseInsert,
                            int* errCount)
/* check the insert counts, incrementing errorCnt */
{
unsigned numInsert = 0, baseInsert = 0;
int iBlk;

for (iBlk = 1; iBlk < psl->blockCount; iBlk++)
    {
    unsigned gapSize = pBlockStarts[iBlk] - (pBlockStarts[iBlk-1]+psl->blockSizes[iBlk-1]);
    if (gapSize > 0)
        {
        numInsert++;
        baseInsert += gapSize;
        }
    }
if (numInsert != pNumInsert)
    chkError(pslDesc, out, psl, errCount,
             "\t%s %cNumInsert %u != expected %u\n",
             pName, pCLabel, pNumInsert, numInsert);
if (baseInsert != pBaseInsert)
    chkError(pslDesc, out, psl, errCount,
             "\t%s %cBaseInsert %u != expected %u\n",
             pName, pCLabel, pBaseInsert, baseInsert);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x40(%rsp), %r10d
movl 0x5c(%rdx), %eax
xorl %r12d, %r12d
pushq $0x1
popq %rcx
xorl %r11d, %r11d
cmpq %rax, %rcx
jae 0x3394f
movq 0x60(%r14), %rdx
movl -0x4(%rdx,%rcx,4), %edx
addl -0x4(%r9,%rcx,4), %edx
movl (%r9,%rcx,4), %esi
xorl %edi, %edi
cmpl %edx, %esi
setne %dil
addl %esi, %r12d
subl %edx, %r12d
addl %edi, %r11d
incq %rcx
jmp 0x33923
movzbl %r8b, %ebp
cmpl %r10d, %r11d
je 0x33984
subq $0x8, %rsp
leaq 0x4fbe0(%rip), %r8      # 0x83543
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x58(%rsp), %rcx
movq %rbx, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %rbp
callq 0x3349c
addq $0x20, %rsp
movl 0x48(%rsp), %r10d
cmpl %r10d, %r12d
jne 0x33994
addq $0x8, %rsp
jmp 0x339c0
subq $0x8, %rsp
leaq 0x4fbc7(%rip), %r8      # 0x83566
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x58(%rsp), %rcx
movq %rbx, %r9
xorl %eax, %eax
pushq %r12
pushq %r10
pushq %rbp
callq 0x3349c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/psl.c
// Function: readPslToBinKeeper
struct hash *readPslToBinKeeper(char *sizeFileName, char *pslFileName)
/* read a list of psls and return results in hash of binKeeper structure for fast query*/
{
struct binKeeper *bk; 
struct psl *psl;
struct lineFile *sf = lineFileOpen(sizeFileName, TRUE);
struct lineFile *pf = lineFileOpen(pslFileName , TRUE);
struct hash *hash = newHash(0);
char *chromRow[2];
char *row[21] ;

while (lineFileRow(sf, chromRow))
    {
    char *name = chromRow[0];
    int size = lineFileNeedNum(sf, chromRow, 1);

    if (hashLookup(hash, name) != NULL)
        warn("Duplicate %s, ignoring all but first\n", name);
    else
        {
        bk = binKeeperNew(0, size);
        assert(size > 1);
	hashAdd(hash, name, bk);
        }
    }
while (lineFileNextRow(pf, row, ArraySize(row)))
    {
    psl = pslLoad(row);
    bk = hashMustFindVal(hash, psl->tName);
    binKeeperAdd(bk, psl->tStart, psl->tEnd, psl);
    }
lineFileClose(&pf);
lineFileClose(&sf);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x25467
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25467
movq %rax, %r14
movq %rax, (%rsp)
xorl %edi, %edi
movl %ebp, %esi
callq 0x245c9
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
pushq $0x2
popq %rdx
callq 0x262ec
testl %eax, %eax
je 0x33a8e
movq 0x10(%rsp), %rbp
movq %r15, %rdi
movq %r12, %rsi
pushq $0x1
popq %rdx
callq 0x263ca
movl %eax, %r13d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x24088
testq %rax, %rax
je 0x33a6e
leaq 0x4f572(%rip), %rdi     # 0x82fd4
movq %rbp, %rsi
xorl %eax, %eax
callq 0x22186
jmp 0x33a23
xorl %edi, %edi
movl %r13d, %esi
callq 0x18b9f
cmpl $0x1, %r13d
jle 0x33afc
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x242d0
jmp 0x33a23
leaq 0x20(%rsp), %r15
pushq $0x15
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x262ec
testl %eax, %eax
je 0x33ad5
movq %r15, %rdi
callq 0x30ba7
movq %rax, %r12
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x2447a
movl 0x54(%r12), %esi
movl 0x58(%r12), %edx
movq %rax, %rdi
movq %r12, %rcx
callq 0x18cb5
jmp 0x33a96
movq %rsp, %rdi
callq 0x25cd8
leaq 0x8(%rsp), %rdi
callq 0x25cd8
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f4f7(%rip), %rdi     # 0x82ffa
leaq 0x4f227(%rip), %rsi     # 0x82d31
leaq 0x4f4f2(%rip), %rcx     # 0x83003
movl $0x64b, %edx            # imm = 0x64B
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbp
movl $0x88, %edi
callq 0x28bb0
cmpl $0x0, 0x58(%rsp)
je 0x3412e
movq %rax, %rbx
movq %rbp, %rdi
callq 0x1c306
movq %rax, 0x30(%rbx)
movl %r13d, 0x38(%rbx)
movl %r12d, 0x3c(%rbx)
movl %r15d, 0x40(%rbx)
movq %r14, %rdi
callq 0x1c306
movq %rax, 0x48(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x50(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x54(%rbx)
movl 0x48(%rsp), %eax
movl %eax, 0x58(%rbx)
movq %rbx, %rdi
addq $0x28, %rdi
pushq $0x2
popq %rdx
movq 0x50(%rsp), %rsi
callq 0x6380
movl 0x58(%rsp), %r14d
leaq (,%r14,4), %r15
movq %r15, %rdi
callq 0x28a1f
movq %rax, 0x60(%rbx)
movq %r15, %rdi
callq 0x28a1f
movq %rax, 0x68(%rbx)
movq %r15, %rdi
callq 0x28a1f
movq %rax, 0x70(%rbx)
movl 0x60(%rsp), %eax
testb $0x4, %al
je 0x3411c
shlq $0x3, %r14
movq %r14, %rdi
callq 0x28a1f
movq %rax, 0x78(%rbx)
movq %r14, %rdi
callq 0x28a1f
movq %rax, 0x80(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ef37(%rip), %rdi     # 0x8306c
leaq 0x4ebf5(%rip), %rsi     # 0x82d31
leaq 0x4ef38(%rip), %rcx     # 0x8307b
movl $0x719, %edx            # imm = 0x719
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
subl %esi, %r15d
subl %ecx, %r8d
cmpl %r8d, %r15d
jne 0x341af
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x5c(%rdi), %eax
cmpl (%r9), %eax
jne 0x34180
movq %r14, %rdi
movq %r9, %rsi
callq 0x341ce
movl 0x5c(%r14), %eax
movq 0x60(%r14), %rcx
movl %eax, %eax
movl %r15d, (%rcx,%rax,4)
movq 0x68(%r14), %rax
movl 0x5c(%r14), %ecx
movl %ebp, (%rax,%rcx,4)
movq 0x70(%r14), %rax
movl 0x5c(%r14), %ecx
movl %ebx, (%rax,%rcx,4)
incl 0x5c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f3d4(%rip), %rdi     # 0x8358a
leaq 0x4eb74(%rip), %rsi     # 0x82d31
leaq 0x4f3d9(%rip), %rcx     # 0x8359d
movl $0x686, %edx            # imm = 0x686
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %r15
leaq (%r15,%r15), %r13
movq 0x60(%rdi), %rdi
leaq (,%r15,4), %r12
shlq $0x3, %r15
movq %r12, %rsi
movq %r15, %rdx
callq 0x28c1e
movq %rax, 0x60(%r14)
movq 0x68(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x28c1e
movq %rax, 0x68(%r14)
movq 0x70(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x28c1e
movq %rax, 0x70(%r14)
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x34261
movq %r13, %r12
shlq $0x3, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x28c1e
movq %rax, 0x78(%r14)
movq 0x80(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x28c1e
movq %rax, 0x80(%r14)
movl %r13d, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl 0x5c(%rdi), %eax
movabsq $0x1, %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rax, %rcx
jae 0x342e7
movq 0x60(%rdi), %r11
movq 0x68(%rdi), %r14
movl (%r14,%rcx,4), %ebx
movl -0x4(%r11,%rcx,4), %r10d
movl -0x4(%r14,%rcx,4), %ebp
addl %r10d, %ebp
subl %ebp, %ebx
je 0x342c5
incl %r9d
movl %r9d, 0x18(%rdi)
addl %ebx, %r8d
movl %r8d, 0x1c(%rdi)
movl -0x4(%r11,%rcx,4), %r10d
movq 0x70(%rdi), %rbx
movl (%rbx,%rcx,4), %r11d
addl -0x4(%rbx,%rcx,4), %r10d
subl %r10d, %r11d
je 0x342e2
incl %esi
movl %esi, 0x20(%rdi)
addl %r11d, %edx
movl %edx, 0x24(%rdi)
incq %rcx
jmp 0x34290
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movb 0x29(%rdi), %r13b
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
movl 0x5c(%r14), %eax
cmpq %rax, %r15
jae 0x34667
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 0x34658
movl 0x50(%r14), %edx
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
callq 0x20d61
movl 0x4(%rsp), %esi
movl (%rsp), %edx
movq %rbx, %rdi
callq 0x34c6c
addl %eax, %ebp
incq %r15
jmp 0x34618
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_O2/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 0x34040
addq $0x30, %rsp
movq %rax, %r14
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%rbx), %xmm0
movups %xmm0, 0x18(%rax)
xorl %r15d, %r15d
movl 0x5c(%rbx), %eax
cmpq %rax, %r15
jae 0x34798
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 0x3476f
movq (%rax,%r15,8), %rdi
callq 0x1c306
movq 0x78(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x3478f
movq (%rax,%r15,8), %rdi
callq 0x1c306
movq 0x80(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incl 0x5c(%r14)
incq %r15
jmp 0x3471d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq (%rdi), %rbx
movq (%rsi), %r14
movq 0x48(%rbx), %rdi
movq 0x48(%r14), %rsi
callq 0x1cc39
movl %eax, %ebp
testl %eax, %eax
jne 0x347d7
movq %r14, %rdi
callq 0x31d1c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x31d1c
subl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1cc39
testl %eax, %eax
jne 0x34800
movl 0x54(%r14), %eax
subl 0x54(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e9d5(%rip), %rsi     # 0x831ee
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x34883
leaq 0x4e9b6(%rip), %rsi     # 0x831e2
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3488c
leaq 0x4a2f9(%rip), %rsi     # 0x7eb38
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x34895
leaq 0x4e9b4(%rip), %rsi     # 0x83206
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x3489e
leaq 0x4e995(%rip), %rsi     # 0x831fa
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
leaq -0xd0(%rip), %rax       # 0x347a6
leaq -0x2b32(%rip), %rsi     # 0x31d4b
cmoveq %rax, %rsi
jmp 0x348a5
leaq -0x2c20(%rip), %rsi     # 0x31c6a
jmp 0x348a5
leaq -0x2b48(%rip), %rsi     # 0x31d4b
jmp 0x348a5
leaq -0x2ba3(%rip), %rsi     # 0x31cf9
jmp 0x348a5
leaq -0xc7(%rip), %rsi       # 0x347de
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c5ab
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rsi
callq 0x26ff4
movq %rax, %r15
movl %r13d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %r12, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x35003
testq %rax, %rax
je 0x34944
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 0x348ff
movq 0x10(%rax), %rdi
movq 0x10(%r15), %rsi
callq *%rbx
movq %rax, 0x10(%r15)
jmp 0x348ff
movq %r14, %rdi
movq %r15, %rsi
callq 0x34ddc
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_O2/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
andq $0x0, (%rbx)
leaq 0x76(%rip), %rcx        # 0x34bd7
movq %rax, %rsi
movq %rax, %rdx
movq %rbx, %r8
callq 0x353eb
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%rax)
movq %rax, %rsi
callq 0x34fba
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rbx)
leaq 0x19(%rip), %rsi        # 0x34bd7
movq %rbx, %rdx
callq 0x35539
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34fba
testq %rax, %rax
je 0x34c08
cmpl %ebp, 0x8(%rax)
jg 0x34c08
cmpl %ebx, 0xc(%rax)
jge 0x34c11
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
andq $0x0, (%rax)
jmp 0x34c0a
// File: /workspace/github_c_makefile_star2_O2/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 0x34b43
movq %rax, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
testq %r15, %r15
je 0x34c57
movl 0x8(%r15), %edi
movl 0xc(%r15), %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x1f506
cmpl %r12d, %eax
cmovgq %r15, %r14
cmovgl %eax, %r12d
movq (%r15), %r15
jmp 0x34c31
testq %r14, %r14
je 0x34c60
andq $0x0, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x834a2(%rip)     # 0xb8118
movq %rsp, %rax
movl %esi, 0x8(%rax)
movl %edx, 0x8349a(%rip)     # 0xb811c
movl %edx, 0xc(%rax)
andl $0x0, 0x83494(%rip)     # 0xb8120
leaq 0x16(%rip), %rcx        # 0x34ca9
movq %rax, %rsi
movq %rax, %rdx
callq 0x35484
movl 0x8347c(%rip), %eax     # 0xb8120
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x28bb0
andq $0x0, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
andl $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34db2
addq $0x28, %rdi
callq 0x26fa2
movq %rbx, %rdi
popq %rbx
jmp 0x28c3d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsp, %rbx
movq %r14, (%rsp)
testq %r14, %r14
je 0x34dd4
movq (%r14), %r14
movq %rbx, %rdi
callq 0x34d94
jmp 0x34dbe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %r12
addq $0x8, %r14
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x34ff4
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq *%r12
testl %eax, %eax
js 0x34fd2
je 0x34ff0
addq $0x8, %r14
jmp 0x34fd2
movq 0x18(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x82de7(%rip)     # 0xb8128
andl $0x0, 0x82de8(%rip)     # 0xb8130
movq %rdx, 0x82de9(%rip)     # 0xb8138
leaq 0x4e27e(%rip), %rdi     # 0x835d4
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x6e70
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x35368
// File: /workspace/github_c_makefile_star2_O2/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 0x353ea
pushq %rbx
movq %rdi, %rbx
movq 0x82db0(%rip), %rdi     # 0xb8128
movl 0x82db2(%rip), %eax     # 0xb8130
incl %eax
movl %eax, 0x82daa(%rip)     # 0xb8130
leal (%rax,%rax,2), %esi
callq 0x1e8d8
xorl %edx, %edx
cmpl $0x0, 0x10(%rbx)
movq 0x82d8d(%rip), %rdi     # 0xb8128
sete %dl
shll $0x4, %edx
orl $0x62, %edx
leaq 0x4e235(%rip), %rsi     # 0x835e0
xorl %eax, %eax
callq 0x6a90
movq 0x18(%rbx), %rdi
movq 0x82d6b(%rip), %rsi     # 0xb8128
callq *0x82d75(%rip)          # 0xb8138
movq 0x82d5e(%rip), %rsi     # 0xb8128
pushq $0xa
popq %rdi
callq 0x6930
movq (%rbx), %rdi
callq 0x35368
movq 0x8(%rbx), %rdi
callq 0x35368
decl 0x82d47(%rip)           # 0xb8130
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3541b
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0x3547b
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 0x35471
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3541b
testl %ebp, %ebp
jg 0x3547b
movq 0x18(%r15), %rdi
movq %rbx, %rsi
callq *(%r14)
jmp 0x35475
testl %ebp, %ebp
jg 0x3547b
movq 0x8(%r15), %r15
jmp 0x3542c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x35504
movq 0x18(%rbx), %rdi
movq 0x82c87(%rip), %rsi     # 0xb8148
callq *0x82c91(%rip)          # 0xb8158
movl %eax, %r14d
movq 0x18(%rbx), %rdi
movq 0x82c7b(%rip), %rsi     # 0xb8150
callq *0x82c7d(%rip)          # 0xb8158
movl %eax, %ebp
testl %r14d, %r14d
js 0x354fa
movq (%rbx), %rdi
callq 0x354aa
testl %ebp, %ebp
jg 0x35504
movq 0x18(%rbx), %rdi
callq *0x82c48(%rip)          # 0xb8140
jmp 0x354fe
testl %ebp, %ebp
jg 0x35504
movq 0x8(%rbx), %rbx
jmp 0x354b1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x35537
movq (%rbx), %rdi
callq 0x35516
movq 0x18(%rbx), %rdi
callq *0x82c0f(%rip)          # 0xb8140
movq 0x8(%rbx), %rbx
jmp 0x3551a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x35584
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3555a
movq 0x18(%r14), %rdi
movq (%rbx), %rsi
callq *0x8(%rbx)
movq 0x8(%r14), %r14
jmp 0x35564
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x82bcb(%rip)     # 0xb8160
leaq 0x82bc4(%rip), %rbx     # 0xb8160
leaq 0x16(%rip), %rcx        # 0x355b9
callq 0x35484
movq %rbx, %rdi
callq 0x1c567
movq 0x82ba9(%rip), %rax     # 0xb8160
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x19(%rip), %rsi        # 0x355f6
movq %rbx, %rdx
callq 0x35539
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35d13
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 0x35e52
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rdi
callq 0x35e52
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 0x35e52
testl %eax, %eax
js 0x356c2
movq 0x60(%r14), %rdi
callq 0x35d13
movl %eax, %ebp
jmp 0x356e3
movq 0x18(%rbx), %rdx
movl 0x20(%rbx), %ecx
movl 0x24(%rbx), %r8d
movq 0x38(%rbx), %r9
leaq 0x4df0c(%rip), %rdi     # 0x835e4
xorl %ebp, %ebp
movl %eax, %esi
xorl %eax, %eax
callq 0x22186
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_O2/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
pushq $0x60
popq %rdi
callq 0x28bb0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x35d13
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 0x1c306
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rdi
callq 0x35e52
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rdi
callq 0x35e52
movl %eax, 0x24(%rbx)
movq 0x38(%r14), %rdi
callq 0x1c306
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x6680
movq 0x48(%r14), %rdi
callq 0x1c306
movq %rax, 0x38(%rbx)
movq 0x50(%r14), %rdi
callq 0x1c306
movq %rax, 0x40(%rbx)
movq 0x58(%r14), %rdi
callq 0x1c306
movq %rax, 0x48(%rbx)
movq 0x60(%r14), %rdi
callq 0x35d13
movl %eax, 0x50(%rbx)
movq 0x68(%r14), %rdi
callq 0x1c306
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq