LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslNext
struct psl *pslNext(struct lineFile *lf)
/* Read next line from file and convert it to psl.  Return
 * NULL at eof. */
{
char *line;
int lineSize;
char *words[32];
int wordCount;
static int lineAlloc = 0;
static char *chopBuf = NULL;

if (!lineFileNextReal(lf, &line))
    {
    return NULL;
    }
lineSize = strlen(line);
if (lineSize >= lineAlloc)
    {
    lineAlloc = lineSize+256;
    chopBuf = needMoreMem(chopBuf, 0, lineAlloc);
    }
memcpy(chopBuf, line, lineSize+1);
wordCount = chopLine(chopBuf, words);
if (wordCount == 21)
    {
    return pslLoad(words);
    }
if (wordCount == 23)
    {
    return pslxLoad(words);
    }
else
    {
    errAbort("Bad line %d of %s wordCount is %d instead of 21 or 23\n", lf->lineIx, lf->fileName, wordCount);
    return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x2b2c6
testl %eax, %eax
je 0x37710
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x62d0
movq %rax, %r15
movq 0x8ca4b(%rip), %r14     # 0xc40f0
cmpl %r15d, 0x8ca3c(%rip)    # 0xc40e8
jg 0x376d6
movl %r15d, %edx
addl $0x100, %edx            # imm = 0x100
movl %edx, 0x8ca2b(%rip)     # 0xc40e8
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e062
movq %rax, %r14
movq %rax, 0x8ca1f(%rip)     # 0xc40f0
movq 0x8(%rsp), %r12
leal 0x1(%r15), %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6570
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x20, %edx
callq 0x226f5
cmpl $0x17, %eax
je 0x37714
cmpl $0x15, %eax
jne 0x37723
leaq 0x10(%rsp), %rdi
callq 0x36627
jmp 0x3771e
xorl %ebx, %ebx
jmp 0x3773c
leaq 0x10(%rsp), %rdi
callq 0x365d8
movq %rax, %rbx
jmp 0x3773c
movl 0x28(%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x5c8ac(%rip), %rdi     # 0x93fdd
xorl %ebx, %ebx
movl %eax, %ecx
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslCmpQuery
int pslCmpQuery(const void *va, const void *vb)
/* Compare to sort based on query start. */
{
const struct psl *a = *((struct psl **)va);
const struct psl *b = *((struct psl **)vb);
int dif;
dif = strcmp(a->qName, b->qName);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x30(%r14), %rdi
movq 0x30(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x37770
movl 0x3c(%r14), %eax
subl 0x3c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslCmpTargetAndStrand
int pslCmpTargetAndStrand(const void *va, const void *vb)
/* Compare to sort based on target, strand,  tStart. */
{
const struct psl *a = *((struct psl **)va);
const struct psl *b = *((struct psl **)vb);
int dif;
dif = strcmp(a->tName, b->tName);
if (dif == 0)
    dif = strcmp(a->strand, b->strand);
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq 0x48(%r14), %rdi
movq 0x48(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x377d5
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x6a50
testl %eax, %eax
jne 0x377d5
movl 0x54(%r14), %eax
subl 0x54(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslWriteAll
void pslWriteAll(struct psl *pslList, char *fileName, boolean writeHeader)
/* Write a psl file from list. */
{
FILE *f;
struct psl *psl;

f = mustOpen(fileName, "w");
if (writeHeader)
    pslWriteHead(f);
for (psl = pslList; psl != NULL; psl = psl->next)
    pslTabOut(psl, f);
fclose(f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x573b9(%rip), %rsi     # 0x8ed49
movq %rax, %rdi
callq 0x23072
movq %rax, %r14
testl %ebp, %ebp
je 0x379d7
leaq 0x5c589(%rip), %rdi     # 0x93f2f
movq %r14, %rsi
callq 0x6810
leaq 0x5c95d(%rip), %rdi     # 0x94312
movq %r14, %rsi
callq 0x6810
jmp 0x379d7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9, %edx
movl $0xa, %ecx
callq 0x36b72
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x379bf
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x66e0
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslxFileOpen
void pslxFileOpen(char *fileName, enum gfType *retQueryType, enum gfType *retTargetType, struct lineFile **retLf)
/* Read header part of psl and make sure it's right.  Return
 * sequence types and file handle. */
{
char *line;
int lineSize;
char *words[30];
char *version;
int wordCount;
int i;
enum gfType qt = gftRna,  tt = gftDna;
struct lineFile *lf = lineFileOpen(fileName, TRUE);

if (!lineFileNext(lf, &line, &lineSize))
    warn("%s is empty", fileName);
else
    {
    if (startsWith("psLayout version", line))
	{
	wordCount = chopLine(line, words);
	if (wordCount < 3)
	    errAbort("%s is not a psLayout file", fileName);
	version = words[2];
	if (sameString(version, "3"))
	    {
	    }
	else if (sameString(version, "4"))
	    {
	    qt = gfTypeFromName(words[3]);
	    tt = gfTypeFromName(words[4]);
	    }
	else
	    {
	    errAbort("%s is version %s of psLayout, this program can only handle through version 4",
		fileName,  version);
	    }
	for (i=0; i<4; ++i)
	    {
	    if (!lineFileNext(lf, &line, &lineSize))
		errAbort("%s severely truncated", fileName);
	    }
	}
    else
	lineFileReuse(lf); 
    }
*retQueryType = qt;
*retTargetType = tt;
*retLf = lf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl $0x1, %ebp
movl $0x1, %esi
callq 0x2a550
movq %rax, %r12
leaq 0x8(%rsp), %rsi
leaq 0x14(%rsp), %rdx
movq %rax, %rdi
callq 0x2a7a9
testl %eax, %eax
je 0x37a9c
movq 0x8(%rsp), %rsi
leaq 0x5c516(%rip), %rdi     # 0x93f4f
callq 0x21b23
testl %eax, %eax
je 0x37ab4
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x1e, %edx
callq 0x226f5
cmpl $0x2, %eax
jg 0x37a6c
leaq 0x5c4fe(%rip), %rdi     # 0x93f60
movq %r13, %rsi
xorl %eax, %eax
callq 0x26e94
movq 0x40(%rsp), %rdx
movzbl (%rdx), %eax
cmpl $0x34, %eax
movq %rbx, 0x28(%rsp)
movq %r14, 0x20(%rsp)
movq %r15, 0x18(%rsp)
je 0x37ac5
cmpl $0x33, %eax
jne 0x37acf
cmpb $0x0, 0x1(%rdx)
jne 0x37acf
movl $0x0, (%rsp)
jmp 0x37ae7
leaq 0x5c4a0(%rip), %rdi     # 0x93f43
movq %r13, %rsi
xorl %eax, %eax
callq 0x26bea
xorl %eax, %eax
jmp 0x37b3e
movq %r12, %rdi
callq 0x2a685
xorl %eax, %eax
movl $0x1, %ebp
jmp 0x37b3e
cmpb $0x0, 0x1(%rdx)
je 0x37b59
leaq 0x5c4a4(%rip), %rdi     # 0x93f7a
movl $0x0, (%rsp)
movq %r13, %rsi
xorl %eax, %eax
callq 0x26e94
movl $0x1, 0x4(%rsp)
movl $0x4, %ebp
leaq 0x8(%rsp), %r14
leaq 0x14(%rsp), %r15
leaq 0x5c4c2(%rip), %rbx     # 0x93fc7
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2a7a9
testl %eax, %eax
jne 0x37b24
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x26e94
decl %ebp
jne 0x37b05
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %r14
movq 0x18(%rsp), %r15
movl 0x4(%rsp), %ebp
movl (%rsp), %eax
movl %ebp, (%r15)
movl %eax, (%r14)
movq %r12, (%rbx)
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rdi
callq 0x19add
movl %eax, 0x4(%rsp)
movq 0x50(%rsp), %rdi
callq 0x19add
movl %eax, (%rsp)
jmp 0x37aef
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslxLoadLm
struct psl *pslxLoadLm(char **row, struct lm *lm)
/* Load row into local memory pslx. */
{
struct psl *ret = pslLoadLm(row, lm);
ret->qSequence = lmAlloc(lm, sizeof(ret->qSequence[0]) * ret->blockCount);
sqlStringArray(lmCloneString(lm,row[21]),ret->qSequence, ret->blockCount);
ret->tSequence = lmAlloc(lm, sizeof(ret->tSequence[0]) * ret->blockCount);
sqlStringArray(lmCloneString(lm,row[22]),ret->tSequence, ret->blockCount);
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x37f15
movq %rax, %rbx
movl 0x5c(%rax), %esi
shlq $0x3, %rsi
movq %r14, %rdi
callq 0x2c325
movq %rax, 0x78(%rbx)
movq 0xa8(%r15), %rsi
movq %r14, %rdi
callq 0x2c424
movq 0x78(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %rax, %rdi
callq 0x3d3d3
movl 0x5c(%rbx), %esi
shlq $0x3, %rsi
movq %r14, %rdi
callq 0x2c325
movq %rax, 0x80(%rbx)
movq 0xb0(%r15), %rsi
movq %r14, %rdi
callq 0x2c424
movq 0x80(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %rax, %rdi
callq 0x3d3d3
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslLoadLm
struct psl *pslLoadLm(char **row, struct lm *lm)
/* Load row into local memory psl. */
{
struct psl *ret;

ret = lmAlloc(lm, sizeof(*ret));
ret->blockCount = sqlUnsigned(row[17]);
ret->match = sqlUnsigned(row[0]);
ret->misMatch = sqlUnsigned(row[1]);
ret->repMatch = sqlUnsigned(row[2]);
ret->nCount = sqlUnsigned(row[3]);
ret->qNumInsert = sqlUnsigned(row[4]);
ret->qBaseInsert = sqlSigned(row[5]);
ret->tNumInsert = sqlUnsigned(row[6]);
ret->tBaseInsert = sqlSigned(row[7]);
strcpy(ret->strand, row[8]);
ret->qName = lmCloneString(lm,row[9]);
ret->qSize = sqlUnsigned(row[10]);
ret->qStart = sqlUnsigned(row[11]);
ret->qEnd = sqlUnsigned(row[12]);
ret->tName = lmCloneString(lm, row[13]);
ret->tSize = sqlUnsigned(row[14]);
ret->tStart = sqlUnsigned(row[15]);
ret->tEnd = sqlUnsigned(row[16]);
ret->blockSizes = lmAlloc(lm, sizeof(ret->blockSizes[0]) * ret->blockCount);
sqlUnsignedArray(row[18], ret->blockSizes, ret->blockCount);
ret->qStarts = lmAlloc(lm, sizeof(ret->qStarts[0]) * ret->blockCount);
sqlUnsignedArray(row[19], ret->qStarts, ret->blockCount);
ret->tStarts = lmAlloc(lm, sizeof(ret->tStarts[0]) * ret->blockCount);
sqlUnsignedArray(row[20], ret->tStarts, ret->blockCount);
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x88, %esi
movq %r15, %rdi
callq 0x2c325
movq %rax, %rbx
movq 0x88(%r14), %rdi
callq 0x3bc10
movl %eax, 0x5c(%rbx)
movq (%r14), %rdi
callq 0x3bc10
movl %eax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x3bc10
movl %eax, 0xc(%rbx)
movq 0x10(%r14), %rdi
callq 0x3bc10
movl %eax, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x3bc10
movl %eax, 0x14(%rbx)
movq 0x20(%r14), %rdi
callq 0x3bc10
movl %eax, 0x18(%rbx)
movq 0x28(%r14), %rdi
callq 0x3bd74
movl %eax, 0x1c(%rbx)
movq 0x30(%r14), %rdi
callq 0x3bc10
movl %eax, 0x20(%rbx)
movq 0x38(%r14), %rdi
callq 0x3bd74
movl %eax, 0x24(%rbx)
leaq 0x28(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x6680
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x2c424
movq %rax, 0x30(%rbx)
movq 0x50(%r14), %rdi
callq 0x3bc10
movl %eax, 0x38(%rbx)
movq 0x58(%r14), %rdi
callq 0x3bc10
movl %eax, 0x3c(%rbx)
movq 0x60(%r14), %rdi
callq 0x3bc10
movl %eax, 0x40(%rbx)
movq 0x68(%r14), %rsi
movq %r15, %rdi
callq 0x2c424
movq %rax, 0x48(%rbx)
movq 0x70(%r14), %rdi
callq 0x3bc10
movl %eax, 0x50(%rbx)
movq 0x78(%r14), %rdi
callq 0x3bc10
movl %eax, 0x54(%rbx)
movq 0x80(%r14), %rdi
callq 0x3bc10
movl %eax, 0x58(%rbx)
movl 0x5c(%rbx), %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0x2c325
movq %rax, 0x60(%rbx)
movq 0x90(%r14), %rdi
movl 0x5c(%rbx), %edx
movq %rax, %rsi
callq 0x3ce7d
movl 0x5c(%rbx), %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0x2c325
movq %rax, 0x68(%rbx)
movq 0x98(%r14), %rdi
movl 0x5c(%rbx), %edx
movq %rax, %rsi
callq 0x3ce7d
movl 0x5c(%rbx), %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0x2c325
movq %rax, 0x70(%rbx)
movq 0xa0(%r14), %rdi
movl 0x5c(%rbx), %edx
movq %rax, %rsi
callq 0x3ce7d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslIsProtein
boolean pslIsProtein(const struct psl *psl)
/* is psl a protein psl (are it's blockSizes and scores in protein space) */
{
int lastBlock = psl->blockCount - 1;

return  (((psl->strand[1] == '+' ) &&
    (psl->tEnd == psl->tStarts[lastBlock] + 3*psl->blockSizes[lastBlock])) ||
   ((psl->strand[1] == '-') && 
    (psl->tStart == (psl->tSize-(psl->tStarts[lastBlock] + 3*psl->blockSizes[lastBlock])))));
}

// Assembly:
movl 0x5c(%rdi), %eax
decl %eax
movzbl 0x29(%rdi), %ecx
cmpl $0x2d, %ecx
je 0x380b9
cmpl $0x2b, %ecx
jne 0x380d9
movq 0x70(%rdi), %rcx
cltq
movq 0x60(%rdi), %rdx
movl (%rdx,%rax,4), %edx
leal (%rdx,%rdx,2), %edx
addl (%rcx,%rax,4), %edx
cmpl %edx, 0x58(%rdi)
jmp 0x380d4
movl 0x50(%rdi), %ecx
movq 0x70(%rdi), %rdx
cltq
movq 0x60(%rdi), %rsi
movl (%rsi,%rax,4), %esi
leal (%rsi,%rsi,2), %esi
subl (%rdx,%rax,4), %ecx
subl %esi, %ecx
cmpl %ecx, 0x54(%rdi)
sete %al
jmp 0x380db
xorl %eax, %eax
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslCalcMilliBad
int pslCalcMilliBad(struct psl *psl, boolean isMrna)
/* Calculate badness in parts per thousand. */
{
int sizeMul = pslIsProtein(psl) ? 3 : 1;
int qAliSize, tAliSize, aliSize;
int milliBad = 0;
int sizeDif;
int insertFactor;
int total;

qAliSize = sizeMul * (psl->qEnd - psl->qStart);
tAliSize = psl->tEnd - psl->tStart;
aliSize = min(qAliSize, tAliSize);
if (aliSize <= 0)
    return 0;
sizeDif = qAliSize - tAliSize;
if (sizeDif < 0)
    {
    if (isMrna)
	sizeDif = 0;
    else
	sizeDif = -sizeDif;
    }
insertFactor = psl->qNumInsert;
if (!isMrna)
    insertFactor += psl->tNumInsert;

total = (sizeMul * (psl->match + psl->repMatch + psl->misMatch));
if (total != 0)
    milliBad = (1000 * (psl->misMatch*sizeMul + insertFactor + round(3*log(1+sizeDif)))) / total;
return milliBad;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3808e
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal 0x1(,%rcx,2), %ecx
movl 0x40(%rbx), %eax
movl 0x58(%rbx), %edx
subl 0x3c(%rbx), %eax
imull %ecx, %eax
subl 0x54(%rbx), %edx
movl %eax, %esi
subl %edx, %esi
cmovll %eax, %edx
testl %edx, %edx
jle 0x38176
movl %esi, %edx
negl %edx
xorl %eax, %eax
testl %ebp, %ebp
cmovnel %eax, %edx
testl %esi, %esi
cmovnsl %esi, %edx
movl 0x18(%rbx), %esi
testl %ebp, %ebp
jne 0x3812f
addl 0x20(%rbx), %esi
movl 0xc(%rbx), %r14d
movl 0x10(%rbx), %ebp
addl 0x8(%rbx), %ebp
addl %r14d, %ebp
je 0x38178
imull %ecx, %ebp
imull %ecx, %r14d
addl %esi, %r14d
incl %edx
cvtsi2sd %edx, %xmm0
callq 0x6550
mulsd 0x5bc8d(%rip), %xmm0    # 0x93de8
addsd 0x56d05(%rip), %xmm0    # 0x8ee68
cvttsd2si %xmm0, %eax
addl %r14d, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
xorl %edx, %edx
divl %ebp
jmp 0x38178
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslToFakeFfAli
struct ffAli *pslToFakeFfAli(struct psl *psl, DNA *needle, DNA *haystack)
/* Convert from psl to ffAli format.  In some cases you can pass NULL
 * for needle and haystack - depending what the post-processing is going
 * to be. */
{
struct ffAli *ffList = NULL, *ff;
int blockCount = psl->blockCount;
unsigned *blockSizes = psl->blockSizes;
unsigned *qStarts = psl->qStarts;
unsigned *tStarts = psl->tStarts;
int size;
int i;

for (i=0; i<blockCount; ++i)
    {
    size = blockSizes[i];
    AllocVar(ff);
    ff->left = ffList;
    ffList = ff;
    ff->nStart = ff->nEnd = needle + qStarts[i];
    ff->nEnd += size;
    ff->hStart = ff->hEnd = haystack + tStarts[i];
    ff->hEnd += size;
    }
ffList = ffMakeRightLinks(ffList);
return ffList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x5c(%rdi), %rbp
testq %rbp, %rbp
jle 0x3827b
movq %rdx, %r15
movq %rsi, %r13
movq 0x60(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rdi), %rax
movq %rax, (%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
movslq (%rax,%rbx,4), %r12
movl $0x38, %edi
callq 0x2dff4
movq %r14, (%rax)
movq 0x8(%rsp), %rcx
movl (%rcx,%rbx,4), %ecx
addq %r13, %rcx
movq %rcx, 0x10(%rax)
addq %r12, %rcx
movq %rcx, 0x18(%rax)
movq (%rsp), %rcx
movl (%rcx,%rbx,4), %ecx
addq %r15, %rcx
movq %rcx, 0x20(%rax)
addq %r12, %rcx
movq %rcx, 0x28(%rax)
incq %rbx
movq %rax, %r14
cmpq %rbx, %rbp
jne 0x3822d
jmp 0x3827d
xorl %eax, %eax
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28293
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslFromFakeFfAli
struct psl *pslFromFakeFfAli(struct ffAli *ff, 
	DNA *needle, DNA *haystack, char strand,
	char *qName, int qSize, char *tName, int tSize)
/* This will create a basic psl structure from a sorted series of ffAli
 * blocks.  The fields that would need actual sequence to be filled in
 * are left zero however - fields including match, repMatch, mismatch. */
{
struct psl *psl;
unsigned *blockSizes;
unsigned *qStarts;
unsigned *tStarts;
int blockCount;
int i;
int nStart, hStart;
int nEnd, hEnd;

AllocVar(psl);
psl->blockCount = blockCount = ffAliCount(ff);
psl->blockSizes = AllocArray(blockSizes, blockCount);
psl->qStarts = AllocArray(qStarts, blockCount);
psl->tStarts = AllocArray(tStarts, blockCount);
psl->qName = cloneString(qName);
psl->qSize = qSize;
psl->tName = cloneString(tName);
psl->tSize = tSize;
psl->strand[0] = strand;

for (i=0; i<blockCount; ++i)
    {
    nStart = ff->nStart - needle;
    nEnd = ff->nEnd - needle;
    hStart = ff->hStart - haystack;
    hEnd = ff->hEnd - haystack;
    blockSizes[i] = nEnd - nStart;
    qStarts[i] = nStart;
    tStarts[i] = hStart;
    if (i == 0)
       {
       psl->qStart = nStart;
       psl->tStart = hStart;
       }
    if (i == blockCount-1)
       {
       psl->qEnd = nEnd;
       psl->tEnd = hEnd;
       }
    ff = ff->right;
    }
if (strand == '-')
    {
    reverseIntRange(&psl->qStart, &psl->qEnd, psl->qSize);
    }
return psl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x88, %edi
callq 0x2dff4
movq %rax, %rbx
movq %r12, %rdi
callq 0x2831c
movl %eax, 0x5c(%rbx)
movq %rax, 0x8(%rsp)
cltq
movq %rax, 0x10(%rsp)
leaq (,%rax,4), %r13
movq %r13, %rdi
callq 0x2de63
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rbx)
movq %r13, %rdi
callq 0x2de63
movq %rax, %rbp
movq %rax, 0x68(%rbx)
movq %r13, %rdi
callq 0x2de63
movq %rax, %r13
movq %rax, 0x70(%rbx)
movq 0x18(%rsp), %rdi
callq 0x1feba
movq %rax, 0x30(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x38(%rbx)
movq 0x60(%rsp), %rdi
callq 0x1feba
movq %rax, 0x48(%rbx)
movl 0x68(%rsp), %eax
movl %eax, 0x50(%rbx)
movl (%rsp), %eax
movb %al, 0x28(%rbx)
cmpl $0x0, 0x10(%rsp)
jle 0x383b3
movq 0x8(%rsp), %rcx
leal -0x1(%rcx), %eax
movl %ecx, %ecx
xorl %edx, %edx
movq 0x20(%rsp), %r11
movl 0x10(%r12), %r8d
movl 0x18(%r12), %esi
subl %r15d, %r8d
subl %r15d, %esi
movl 0x20(%r12), %r9d
subl %r14d, %r9d
movl 0x28(%r12), %edi
movl %esi, %r10d
subl %r8d, %r10d
movl %r10d, (%r11,%rdx,4)
movl %r8d, (%rbp,%rdx,4)
movl %r9d, (%r13,%rdx,4)
testq %rdx, %rdx
jne 0x38398
movl %r8d, 0x3c(%rbx)
movl %r9d, 0x54(%rbx)
cmpq %rdx, %rax
jne 0x383a6
subl %r14d, %edi
movl %esi, 0x40(%rbx)
movl %edi, 0x58(%rbx)
movq 0x8(%r12), %r12
incq %rdx
cmpq %rdx, %rcx
jne 0x3835a
cmpb $0x2d, (%rsp)
jne 0x383cc
leaq 0x3c(%rbx), %rdi
movq %rbx, %rsi
addq $0x40, %rsi
movl 0x38(%rbx), %edx
callq 0x25472
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslToFfAli
struct ffAli *pslToFfAli(struct psl *psl, struct dnaSeq *query, struct dnaSeq *target,
	int targetOffset)
/* Convert from psl to ffAli format.  Clip to parts that we actually
 * have sequence for. */
{
struct ffAli *ffList = NULL, *ff;
DNA *needle = query->dna;
DNA *haystack = target->dna;
int blockCount = psl->blockCount;
unsigned *blockSizes = psl->blockSizes;
unsigned *qStarts = psl->qStarts;
unsigned *tStarts = psl->tStarts;
int size;
int i;
int tMin = targetOffset;
int tMax = targetOffset + target->size;
int tStart, tEnd;
int clipStart, clipEnd, clipOffset, clipSize;

for (i=0; i<blockCount; ++i)
    {
    clipStart = tStart = tStarts[i];
    size = blockSizes[i];
    clipEnd = tEnd = tStart + size;
    if (tStart < tMax && tEnd > tMin)
	{
	if (clipStart < tMin) clipStart = tMin;
	if (clipEnd > tMax) clipEnd = tMax;
	clipOffset = clipStart - tStart;
	clipSize = clipEnd - clipStart;
	AllocVar(ff);
	ff->left = ffList;
	ffList = ff;
	ff->nStart = ff->nEnd = needle + qStarts[i] + clipOffset;
	ff->nEnd += clipSize;
	ff->hStart = ff->hEnd = haystack + clipStart - targetOffset;
	ff->hEnd += clipSize;
	}
    }
ffList = ffMakeRightLinks(ffList);
ffCountGoodEnds(ffList);
return ffList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq 0x5c(%rdi), %r8
testq %r8, %r8
jle 0x384d2
movl %ecx, %ebx
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rdx), %r15d
addl %ecx, %r15d
movq 0x60(%rdi), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rdi), %rsi
movq 0x10(%rdx), %rdx
movslq %ecx, %rax
subq %rax, %rdx
movq %rdx, 0x8(%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r8, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
movl (%rsi,%r13,4), %eax
cmpl %r15d, %eax
jge 0x384c4
movq 0x30(%rsp), %rdx
movl (%rdx,%r13,4), %ebp
addl %eax, %ebp
cmpl %ebx, %ebp
jle 0x384c4
cmpl %ebx, %eax
cmovgl %eax, %ebx
cmpl %r15d, %ebp
jl 0x38469
movl %r15d, %ebp
movl %ebx, %r14d
subl %eax, %r14d
subl %ebx, %ebp
movl $0x38, %edi
callq 0x2dff4
movq %r12, (%rax)
movq 0x18(%rsp), %rcx
movl (%rcx,%r13,4), %ecx
addq 0x20(%rsp), %rcx
movslq %r14d, %rdx
addq %rcx, %rdx
movq %rdx, 0x10(%rax)
movslq %ebp, %rcx
addq %rcx, %rdx
movq %rdx, 0x18(%rax)
movslq %ebx, %rdx
addq 0x8(%rsp), %rdx
movq %rdx, 0x20(%rax)
addq %rcx, %rdx
movq %rdx, 0x28(%rax)
movq %rax, %r12
movq 0x28(%rsp), %r8
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %ebx
incq %r13
cmpq %r13, %r8
jne 0x38444
jmp 0x384d5
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x28293
movq %rax, %rbx
movq %rax, %rdi
callq 0x282b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslWeightedIntronOrientation
int pslWeightedIntronOrientation(struct psl *psl, struct dnaSeq *genoSeq, int offset)
/* Return >0 if introns make it look like alignment is on + strand,
 *        <0 if introns make it look like alignment is on - strand,
 *        0 if can't tell.  The absolute value of the return indicates
 * how many splice sites we've seen supporting the orientation.
 * Sequence should NOT be reverse complemented.  */
{
int intronDir = 0;
int oneDir;
int i;
DNA *dna = genoSeq->dna;

/* code below doesn't support negative target strand (translated blat) */
if (psl->strand[1] == '-')
    errAbort("pslWeightedIntronOrientation doesn't support a negative target strand");

for (i=1; i<psl->blockCount; ++i)
    {
    int iStart, iEnd, blockSize = psl->blockSizes[i-1];
    if (psl->qStarts[i-1] + blockSize == psl->qStarts[i])
	{
	iStart = psl->tStarts[i-1] + psl->blockSizes[i-1] - offset;
	iEnd = psl->tStarts[i] - offset;
	oneDir = intronOrientation(dna+iStart, dna+iEnd);
	intronDir += oneDir;
	}
    }
return intronDir;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movq 0x10(%rsi), %r15
cmpb $0x2d, 0x29(%rdi)
jne 0x38542
leaq 0x5bad9(%rip), %rdi     # 0x94014
xorl %eax, %eax
callq 0x26e94
movl 0x5c(%r14), %eax
xorl %ebp, %ebp
cmpl $0x2, %eax
jb 0x3859f
xorl %ebp, %ebp
movl $0x1, %r12d
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rdx
movl -0x4(%rcx,%r12,4), %ecx
movl -0x4(%rdx,%r12,4), %esi
addl %ecx, %esi
cmpl (%rdx,%r12,4), %esi
jne 0x38597
movq 0x70(%r14), %rax
subl %ebx, %ecx
addl -0x4(%rax,%r12,4), %ecx
movl (%rax,%r12,4), %eax
subl %ebx, %eax
movslq %ecx, %rdi
addq %r15, %rdi
movslq %eax, %rsi
addq %r15, %rsi
callq 0x25b12
addl %eax, %ebp
movl 0x5c(%r14), %eax
incq %r12
cmpl %r12d, %eax
ja 0x38555
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslHasIntron
boolean pslHasIntron(struct psl *psl, struct dnaSeq *seq, int seqOffset)
/* Return TRUE if there's a probable intron. Sequence should NOT be
 * reverse complemented.*/
{
int blockCount = psl->blockCount, i;
unsigned *tStarts = psl->tStarts;
unsigned *blockSizes = psl->blockSizes;
unsigned *qStarts = psl->qStarts;
int blockSize, start, end;
DNA *dna = seq->dna;

for (i=1; i<blockCount; ++i)
    {
    blockSize = blockSizes[i-1];
    start = qStarts[i-1]+blockSize;
    end = qStarts[i];
    if (start == end)
        {
        start = tStarts[i-1] + blockSize;
        end = tStarts[i];
        if (psl->strand[1] == '-')
            reverseIntRange(&start, &end, psl->tSize);
        start -= seqOffset;
        end -= seqOffset;
	if (intronOrientation(dna+start, dna+end) != 0)
	    return TRUE;
	}
    }
return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movslq 0x5c(%rdi), %r13
cmpq $0x2, %r13
jl 0x38676
movq 0x70(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rdi), %r15
movq 0x68(%rdi), %r12
movq 0x10(%rsi), %rbx
decq %r13
xorl %r14d, %r14d
movl (%r15,%r14,4), %eax
movl (%r12,%r14,4), %ecx
addl %eax, %ecx
cmpl 0x4(%r12,%r14,4), %ecx
jne 0x3866e
movq 0x10(%rsp), %rcx
addl (%rcx,%r14,4), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rcx,%r14,4), %ecx
movl %ecx, 0x4(%rsp)
movq %rdi, %rbp
cmpb $0x2d, 0x29(%rdi)
jne 0x38646
movl 0x50(%rbp), %edx
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x25472
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
movl 0xc(%rsp), %edx
subl %edx, %eax
movl %eax, 0x8(%rsp)
subl %edx, %ecx
movl %ecx, 0x4(%rsp)
movslq %eax, %rdi
addq %rbx, %rdi
movslq %ecx, %rsi
addq %rbx, %rsi
callq 0x25b12
testl %eax, %eax
movq %rbp, %rdi
jne 0x38687
incq %r14
cmpq %r14, %r13
jne 0x385fc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x38678
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslTailSizes
void pslTailSizes(struct psl *psl, int *retStartTail, int *retEndTail)
/* Find the length of "tails" (rather than extensions) implied by psl. */
{
int orientation = pslOrientation(psl);
int qFloppyStart, qFloppyEnd;
int tFloppyStart, tFloppyEnd;

if (orientation > 0)
    {
    qFloppyStart = psl->qStart;
    qFloppyEnd = psl->qSize - psl->qEnd;
    }
else
    {
    qFloppyStart = psl->qSize - psl->qEnd;
    qFloppyEnd = psl->qStart;
    }
tFloppyStart = psl->tStart;
tFloppyEnd = psl->tSize - psl->tEnd;
*retStartTail = min(qFloppyStart, tFloppyStart);
*retEndTail = min(qFloppyEnd, tFloppyEnd);
}

// Assembly:
movb 0x28(%rdi), %al
movb 0x29(%rdi), %cl
xorl %r8d, %r8d
cmpb %cl, %al
sete %r8b
xorl %r9d, %r9d
cmpb $0x2d, %al
setne %r9b
testb %cl, %cl
cmovel %r9d, %r8d
cmpb $0x1, %r8b
jne 0x386bd
movl 0x38(%rdi), %eax
movl 0x3c(%rdi), %ecx
subl 0x40(%rdi), %eax
jmp 0x386c6
movl 0x38(%rdi), %ecx
movl 0x3c(%rdi), %eax
subl 0x40(%rdi), %ecx
movl 0x50(%rdi), %r8d
movl 0x54(%rdi), %r9d
subl 0x58(%rdi), %r8d
cmpl %r9d, %ecx
cmovll %ecx, %r9d
movl %r9d, (%rsi)
cmpl %r8d, %eax
cmovll %eax, %r8d
movl %r8d, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: pslRc
void pslRc(struct psl *psl)
/* Reverse-complement a PSL alignment.  This makes the target strand explicit. */
{
unsigned tSize = psl->tSize, qSize = psl->qSize;
unsigned blockCount = psl->blockCount, i;
unsigned *tStarts = psl->tStarts, *qStarts = psl->qStarts, *blockSizes = psl->blockSizes;
int mult = pslIsProtein(psl) ? 3 : 1;

/* swap strand, forcing target to have an explict strand */
psl->strand[0] = (psl->strand[0] != '-') ? '-' : '+';
psl->strand[1] = (psl->strand[1] != '-') ? '-' : '+';
psl->strand[2] = 0;

for (i=0; i<blockCount; ++i)
    {
    tStarts[i] = tSize - (tStarts[i] + mult * blockSizes[i]);
    qStarts[i] = qSize - (qStarts[i] + blockSizes[i]);
    }
reverseUnsigned(tStarts, blockCount);
reverseUnsigned(qStarts, blockCount);
reverseUnsigned(blockSizes, blockCount);
if (psl->qSequence != NULL)
    {
    rcSeqs(psl->qSequence, blockCount, blockSizes);
    rcSeqs(psl->tSequence, blockCount, blockSizes);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl 0x38(%rdi), %ebp
movl 0x50(%rdi), %ebx
movl 0x5c(%rdi), %eax
movq %rax, 0x8(%rsp)
movq 0x70(%rdi), %r13
movq 0x68(%rdi), %r12
movq 0x60(%rdi), %r15
callq 0x3808e
cmpb $0x2d, 0x28(%r14)
setne %dl
addb %dl, %dl
addb $0x2b, %dl
cmpb $0x2d, 0x29(%r14)
setne %sil
addb %sil, %sil
addb $0x2b, %sil
xorl %ecx, %ecx
cmpl $0x1, %eax
sbbl %ecx, %ecx
movb %dl, 0x28(%r14)
movb %sil, 0x29(%r14)
movq %r14, 0x10(%rsp)
movb $0x0, 0x2a(%r14)
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x38789
orl $-0x3, %ecx
xorl %eax, %eax
movl (%r15,%rax,4), %edx
imull %ecx, %edx
movl %ebx, %esi
subl (%r13,%rax,4), %esi
addl %edx, %esi
movl %esi, (%r13,%rax,4)
movl (%r12,%rax,4), %edx
addl (%r15,%rax,4), %edx
movl %ebp, %esi
subl %edx, %esi
movl %esi, (%r12,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x3875c
movq %r13, %rdi
movl %r14d, %esi
callq 0x1fffd
movq %r12, %rdi
movl %r14d, %esi
callq 0x1fffd
movq %r15, %rdi
movl %r14d, %esi
callq 0x1fffd
movq 0x10(%rsp), %rbx
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x387e0
movl %r14d, %esi
movq %r15, %rdx
callq 0x387ef
movq 0x80(%rbx), %rdi
movl %r14d, %esi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x387ef
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: rcSeqs
static void rcSeqs(char **seqs, unsigned blockCount, unsigned *blockSizes)
/* reverses complement sequences in list, maintain property that all strings
 * are in one malloc block.   blockSizes should already be reversed. */
{
char *buf, *next;
int i, memSz = 0;

/* get a new memory block for strings */
for (i = 0; i < blockCount; i++)
    memSz += blockSizes[i]+1;
next = buf = needLargeMem(memSz);

/* reverse compliment and copy to new memory block */
for (i = blockCount-1; i >= 0; i--)
    {
    int len = strlen(seqs[i]);
    reverseComplement(seqs[i], len);
    memcpy(next, seqs[i], len+1);
    next += len+1;
    }

/* swap memory and update pointers */
freeMem(seqs[0]);
seqs[0] = buf;
next = buf;

for (i = 0; i < blockCount; i++)
    {
    seqs[i] = next;
    next += blockSizes[i]+1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x388ad
movl %esi, %ebp
movl %esi, %edi
xorl %eax, %eax
xorl %ecx, %ecx
movl (%rdx,%rax,4), %esi
addl %esi, %ecx
incl %ecx
incq %rax
cmpq %rax, %rdi
jne 0x38810
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movslq %ecx, %rdi
callq 0x2ddfc
movq %rax, %r15
movl %ebp, 0x4(%rsp)
decl %ebp
js 0x38879
movl %ebp, %r14d
movq %r15, %r12
movq (%rbx,%r14,8), %r13
movq %r13, %rdi
callq 0x62d0
movslq %eax, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x25423
movq (%rbx,%r14,8), %rsi
incl %ebp
movslq %ebp, %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x6570
addq %r13, %r12
addq $-0x1, %r14
jb 0x38842
movq (%rbx), %rdi
callq 0x2e0a0
movq %r15, (%rbx)
cmpl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
je 0x388c2
xorl %eax, %eax
movq %r15, (%rbx,%rax,8)
movl (%rdx,%rax,4), %ecx
incl %ecx
addq %rcx, %r15
incq %rax
cmpq %rax, %rsi
jne 0x38897
jmp 0x388c2
xorl %edi, %edi
callq 0x2ddfc
movq %rax, %r14
movq (%rbx), %rdi
callq 0x2e0a0
movq %r14, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: 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 0x38914
movb 0x28(%rbx), %cl
movb %al, 0x28(%rbx)
movb %cl, 0x29(%rbx)
jmp 0x38928
movb 0x28(%rbx), %al
testl %esi, %esi
je 0x38924
movb %al, 0x29(%rbx)
movb $0x2b, 0x28(%rbx)
jmp 0x38928
cmpb $0x2b, %al
jne 0x38931
movq %rbx, %rdi
popq %rbx
jmp 0x389d8
movq 0x70(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1fffd
movq 0x68(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1fffd
movq 0x60(%rbx), %rdi
movl 0x5c(%rbx), %esi
callq 0x1fffd
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq %rax, 0x70(%rbx)
movq %rcx, 0x68(%rbx)
cmpl $0x0, 0x5c(%rbx)
je 0x389a0
movq 0x60(%rbx), %rdx
xorl %edi, %edi
movl (%rcx,%rdi,4), %esi
addl (%rdx,%rdi,4), %esi
movl 0x38(%rbx), %r8d
subl %esi, %r8d
movl %r8d, (%rcx,%rdi,4)
movl 0x50(%rbx), %esi
movl (%rax,%rdi,4), %r8d
addl (%rdx,%rdi,4), %r8d
subl %r8d, %esi
movl %esi, (%rax,%rdi,4)
incq %rdi
movl 0x5c(%rbx), %esi
cmpq %rsi, %rdi
jb 0x38971
jmp 0x389a2
xorl %esi, %esi
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x389d6
movq 0x60(%rbx), %rdx
callq 0x387ef
movq 0x80(%rbx), %rdi
movl 0x5c(%rbx), %esi
movq 0x60(%rbx), %rdx
callq 0x387ef
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_O3/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:
cmpl $0x0, 0x5c(%rdi)
je 0x38a28
xorl %eax, %eax
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 0x38a1d
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
movl 0x5c(%rdi), %ecx
cmpq %rcx, %rax
jb 0x389e0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x5c(%rdi), %rax
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)
testq %rax, %rax
jle 0x38a5a
xorl %edx, %edx
addl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x38a4f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b5ea(%rip), %rdi     # 0x9405a
movl $0x6, %esi
movl $0x1, %edx
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 0x5b5bc(%rip), %rsi     # 0x94061
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
pushq 0x48(%r14)
callq 0x6a90
addq $0x20, %rsp
cmpl $0x0, 0x5c(%r14)
je 0x38aff
leaq 0x5b5b3(%rip), %r15     # 0x9407e
xorl %r12d, %r12d
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
movl 0x5c(%r14), %eax
cmpq %rax, %r12
jb 0x38ace
leaq 0x5b599(%rip), %rdi     # 0x9409f
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6e70
// File: /workspace/github_c_makefile_star2_O3/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 0x38b7e
movl 0x38(%rbx), %edx
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x25472
cmpb $0x2d, 0x29(%rbx)
jne 0x38ba2
movl 0x50(%rbx), %edx
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25472
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_O3/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, (%rsp)
movq %rdx, %r14
movl 0x40(%rsp), %r10d
movl 0x5c(%rdx), %eax
xorl %ebp, %ebp
movl $0x0, %r11d
cmpq $0x2, %rax
jb 0x395e3
movq 0x60(%r14), %rcx
movl (%r9), %r15d
decq %rax
xorl %edx, %edx
xorl %r11d, %r11d
xorl %ebp, %ebp
movl 0x4(%r9,%rdx,4), %r12d
addl (%rcx,%rdx,4), %r15d
xorl %ebx, %ebx
cmpl %r15d, %r12d
setne %bl
addl %r12d, %ebp
subl %r15d, %ebp
addl %ebx, %r11d
incq %rdx
movl %r12d, %r15d
cmpq %rdx, %rax
jne 0x395be
movq 0x50(%rsp), %r15
movl 0x48(%rsp), %ebx
movzbl %r8b, %r13d
cmpl %r10d, %r11d
je 0x3962c
subq $0x8, %rsp
leaq 0x5b043(%rip), %r8      # 0x94643
movq %r14, %rdx
movq %rdi, %rbx
movq %rsi, %r12
movq %r15, %rcx
movq 0x8(%rsp), %r9
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r13
callq 0x3911e
movq %r12, %rsi
movq %rbx, %rdi
movl 0x68(%rsp), %ebx
addq $0x20, %rsp
cmpl %ebx, %ebp
jne 0x39636
addq $0x8, %rsp
jmp 0x3965b
subq $0x8, %rsp
leaq 0x5b025(%rip), %r8      # 0x94666
movq %r14, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r9
xorl %eax, %eax
pushq %rbp
pushq %rbx
pushq %r13
callq 0x3911e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/psl.c
// Function: 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
movl $0x1, %esi
callq 0x2a550
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2a550
movq %rax, %r14
movq %rax, (%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x2, %edx
callq 0x2b505
testl %eax, %eax
je 0x3974b
leaq 0x10(%rsp), %r12
movq 0x10(%rsp), %rbp
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2b605
movl %eax, %r13d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x28eb0
testq %rax, %rax
je 0x39715
leaq 0x5a9cb(%rip), %rdi     # 0x940d4
movq %rbp, %rsi
xorl %eax, %eax
callq 0x26bea
jmp 0x39737
xorl %edi, %edi
movl %r13d, %esi
callq 0x1c35f
cmpl $0x1, %r13d
jle 0x397cd
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x29142
movq %r15, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x2b505
testl %eax, %eax
jne 0x396da
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movl $0x15, %edx
callq 0x2b505
testl %eax, %eax
je 0x397a6
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x36627
movq %rax, %r12
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x29361
movl 0x54(%r12), %esi
movl 0x58(%r12), %edx
movq %rax, %rdi
movq %r12, %rcx
callq 0x1c47e
movq %r14, %rdi
movq %r15, %rsi
movl $0x15, %edx
callq 0x2b505
testl %eax, %eax
jne 0x39766
movq %rsp, %rdi
callq 0x2ae73
leaq 0x8(%rsp), %rdi
callq 0x2ae73
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a926(%rip), %rdi     # 0x940fa
leaq 0x5a656(%rip), %rsi     # 0x93e31
leaq 0x5a921(%rip), %rcx     # 0x94103
movl $0x64b, %edx            # imm = 0x64B
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x2dff4
cmpl $0x0, 0x58(%rsp)
je 0x39e6e
movq %rax, %rbx
movq %rbp, %rdi
callq 0x1feba
movq %rax, 0x30(%rbx)
movl %r13d, 0x38(%rbx)
movl %r12d, 0x3c(%rbx)
movl %r15d, 0x40(%rbx)
movq %r14, %rdi
callq 0x1feba
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
movl $0x2, %edx
movq 0x50(%rsp), %rsi
callq 0x6380
movl 0x58(%rsp), %r14d
leaq (,%r14,4), %r15
movq %r15, %rdi
callq 0x2de63
movq %rax, 0x60(%rbx)
movq %r15, %rdi
callq 0x2de63
movq %rax, 0x68(%rbx)
movq %r15, %rdi
callq 0x2de63
movq %rax, 0x70(%rbx)
movl 0x60(%rsp), %eax
testb $0x4, %al
je 0x39e5c
shlq $0x3, %r14
movq %r14, %rdi
callq 0x2de63
movq %rax, 0x78(%rbx)
movq %r14, %rdi
callq 0x2de63
movq %rax, 0x80(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a2f7(%rip), %rdi     # 0x9416c
leaq 0x59fb5(%rip), %rsi     # 0x93e31
leaq 0x5a2f8(%rip), %rcx     # 0x9417b
movl $0x719, %edx            # imm = 0x719
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/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 0x39eef
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x5c(%rdi), %eax
cmpl (%r9), %eax
jne 0x39ec0
movq %r14, %rdi
movq %r9, %rsi
callq 0x39f0e
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 0x5a794(%rip), %rdi     # 0x9468a
leaq 0x59f34(%rip), %rsi     # 0x93e31
leaq 0x5a799(%rip), %rcx     # 0x9469d
movl $0x686, %edx            # imm = 0x686
callq 0x6460