LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/fa.c
// Function: faReadAllMixableInLf
static struct dnaSeq *faReadAllMixableInLf(struct lineFile *lf,
        boolean isDna, boolean mixed, DNA **faFastBuf, unsigned *faFastBufSize)
/* Return list of all sequences from open fa file.
 * Mixed case parameter overrides isDna.  If mixed is false then
 * will return DNA in lower case and non-DNA in upper case. */
{
    struct dnaSeq *seqList = NULL, *seq;
    DNA *dna;
    char buf[512];
    char *name=buf;
    int size;
    boolean ok;

    for (;;)
    {
        if (mixed)
            ok = faMixedSpeedReadNext(lf, &dna, &size, &name, faFastBuf, faFastBufSize);
        else
            ok = faSomeSpeedReadNext(lf, &dna, &size, &name, isDna, faFastBuf, faFastBufSize);
        if (!ok)
            break;
        AllocVar(seq);
        seq->name = cloneString(name);
        seq->size = size;
        seq->dna = cloneMem(dna, size+1);
        slAddHead(&seqList, seq);
    }
    slReverse(&seqList);
    faFreeFastBuf(faFastBuf, faFastBufSize);
    return seqList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, 0x1c(%rsp)
andq $0x0, 0x28(%rsp)
movq %rdi, %r12
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
xorl %r13d, %r13d
testl %ebp, %ebp
je 0x2358a
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x2311f
jmp 0x235ad
movq %rbx, (%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %r8d
movq %r14, %r9
callq 0x233a0
testl %eax, %eax
je 0x235f4
pushq $0x28
popq %rdi
callq 0x28bb0
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x1c306
movq %rax, 0x8(%r15)
movslq 0xc(%rsp), %rsi
movl %esi, 0x18(%r15)
movq 0x20(%rsp), %rdi
incq %rsi
callq 0x1c27c
movq %rax, 0x10(%r15)
movq %r13, (%r15)
movq %r15, 0x28(%rsp)
movq %r15, %r13
jmp 0x23567
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1c567
movq %r14, %rdi
callq 0x28c3d
andl $0x0, (%rbx)
movq (%r15), %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffAli.c
// Function: ffFreeAli
void ffFreeAli(struct ffAli **pAli)
/* Dispose of memory gotten from fuzzyFind(). */
{
struct ffAli *ali = *pAli;
if (ali != NULL)
    {
    while (ali->right)
        ali = ali->right;
    slFreeList(&ali);
    }
*pAli = NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2364d
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x23634
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
callq 0x1c583
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffAli.c
// Function: ffIntronOrientation
int ffIntronOrientation(struct ffAli *ali)
/* Return + for positive orientation overall, - for negative,
 * 0 if can't tell. */
{
struct ffAli *left = ali, *right;
int orient = 0;

if (left != NULL)
    {
    while((right = left->right) != NULL)
	{
	orient += intronOrientation(left->hEnd, right->hStart);
	left = right;
	}
    }
return orient;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x23699
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x23699
movq 0x28(%rdi), %rdi
movq 0x20(%r14), %rsi
callq 0x212bb
addl %eax, %ebx
movq %r14, %rdi
jmp 0x2367c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffAli.c
// Function: ffCountGoodEnds
void ffCountGoodEnds(struct ffAli *aliList)
/* Fill in the goodEnd and badEnd scores. */
{
struct ffAli *ali;
for (ali = aliList; ali != NULL; ali = ali->right)
    {
    ali->startGood = countGoodStart(ali);
    ali->endGood = countGoodEnd(ali);
    }
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x23732
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %r8
movl %edx, %ecx
subl %esi, %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
xorl %r9d, %r9d
cmpl %r9d, %ecx
je 0x236fa
movb (%rsi,%r9), %r10b
cmpb (%r8,%r9), %r10b
jne 0x236fd
incq %r9
jmp 0x236e6
movl %ecx, %r9d
movl %r9d, 0x30(%rdi)
movq 0x28(%rdi), %rsi
decq %rsi
decq %rdx
xorl %r8d, %r8d
cmpl %r8d, %ecx
je 0x23729
movb (%rdx), %r9b
cmpb (%rsi), %r9b
jne 0x23726
incl %r8d
decq %rsi
decq %rdx
jmp 0x2370e
movl %r8d, %ecx
movl %ecx, 0x34(%rdi)
movq 0x8(%rdi), %rdi
jmp 0x236c9
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffAli.c
// Function: ffAliFromSym
struct ffAli *ffAliFromSym(int symCount, char *nSym, char *hSym,
	struct lm *lm, char *nStart, char *hStart)
/* Convert symbol representation of alignments (letters plus '-')
 * to ffAli representation.  If lm is nonNULL, ffAli result 
 * will be lmAlloced, else it will be needMemed. This routine
 * depends on nSym/hSym being zero terminated. */
{
struct ffAli *ffList = NULL, *ff = NULL;
char n, h;
int i;

for (i=0; i<=symCount; ++i)
    {
    boolean isGap;
    n = nSym[i];
    h = hSym[i];
    isGap = (n == '-' || n == 0 || h == '-' || h == 0);
    if (isGap)
	{
	if (ff != NULL)
	    {
	    ff->nEnd = nStart;
	    ff->hEnd = hStart;
	    ff->left = ffList;
	    ffList = ff;
	    ff = NULL;
	    }
	}
    else
	{
	if (ff == NULL)
	    {
	    if (lm != NULL)
		{
		lmAllocVar(lm, ff);
		}
	    else
		{
		AllocVar(ff);
		}
	    ff->nStart = nStart;
	    ff->hStart = hStart;
	    }
	}
    if (n != '-')
	{
	++nStart;
	}
    if (h != '-')
	{
	++hStart;
	}
    }
ffList = ffMakeRightLinks(ffList);
return ffList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movslq %edi, %r15
xorl %ebp, %ebp
xorl %r8d, %r8d
xorl %edi, %edi
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %r15, %rbp
jg 0x2381c
movzbl (%rsi,%rbp), %r12d
movb (%rdx,%rbp), %r13b
cmpb $0x2d, %r13b
je 0x237a2
testl %r12d, %r12d
je 0x237a2
cmpl $0x2d, %r12d
je 0x237a2
testb %r13b, %r13b
je 0x237a2
testq %r8, %r8
je 0x237df
movq %r8, %rax
jmp 0x237bb
testq %r8, %r8
jne 0x237ab
xorl %eax, %eax
jmp 0x237bb
movq %r14, 0x18(%r8)
movq %rbx, 0x28(%r8)
movq %rdi, (%r8)
xorl %eax, %eax
movq %r8, %rdi
xorl %r8d, %r8d
cmpb $0x2d, %r13b
setne %r8b
xorl %r9d, %r9d
cmpl $0x2d, %r12d
setne %r9b
addq %r9, %r14
addq %r8, %rbx
incq %rbp
movq %rax, %r8
jmp 0x23770
movq %rdi, 0x20(%rsp)
testq %rcx, %rcx
je 0x237f6
movq %rcx, %rdi
pushq $0x38
popq %rsi
callq 0x26ff4
jmp 0x237fe
pushq $0x38
popq %rdi
callq 0x28bb0
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
jmp 0x237bb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x236b0
nop
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreMatch
int ffScoreMatch(DNA *a, DNA *b, int size)
/* Compare two pieces of DNA base by base. Total mismatches are
 * subtracted from total matches and returned as score. 'N's 
 * neither hurt nor help score. */
{
int i;
int score = 0;
for (i=0; i<size; ++i)
    {
    DNA aa = a[i];
    DNA bb = b[i];
    if (aa == 'n' || bb == 'n')
        continue;
    if (aa == bb)
        ++score;
    else
        score -= 1;
    }
return score;
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %r8, %rdx
je 0x23877
movb (%rdi,%r8), %r9b
movb (%rsi,%r8), %r10b
xorl %r11d, %r11d
cmpb %r10b, %r9b
sete %r11b
cmpb $0x6e, %r10b
leal -0x1(%r11,%r11), %r10d
cmovel %ecx, %r10d
cmpb $0x6e, %r9b
cmovel %ecx, %r10d
addl %r10d, %eax
incq %r8
jmp 0x23843
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcCdnaGapPenalty
int ffCalcCdnaGapPenalty(int hGap, int nGap)
/* Return gap penalty for given h and n gaps. */
{
int acc = 2;
if (hGap > 400000)	/* Discourage really long introns. */
    {
    acc += (hGap - 400000)/3000;
    if (hGap > ffIntronMax)
        acc += (hGap - ffIntronMax)/2000;
    }
if (hGap < 0)   /* Discourage jumping back in haystack. */
    {
    hGap = -8*hGap;
    if (hGap > 48)
        hGap = (hGap*hGap);
    }
if (nGap < 0)   /* Jumping back in needle gets rid of previous alignment. */
    {
    acc += -nGap;
    nGap = 0;
    }
acc += digitsBaseTwo(hGap)/2;
if (nGap != 0)
    {
    acc += digitsBaseTwo(nGap);
    }
else
    {
    if (hGap > 30)
	acc -= 1;
    }
return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
cmpl $0x61a81, %edi          # imm = 0x61A81
jl 0x238b8
leal -0x61a80(%r14), %eax
movl $0xbb8, %ecx            # imm = 0xBB8
xorl %edx, %edx
divl %ecx
movl %eax, %ebp
addl $0x2, %ebp
movl %r14d, %eax
subl 0x912c6(%rip), %eax     # 0xb4b70
jle 0x238da
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
addl %eax, %ebp
jmp 0x238da
pushq $0x2
popq %rbp
testl %r14d, %r14d
jns 0x238da
leal (,%r14,8), %eax
negl %eax
cmpl $-0x6, %r14d
pushq $0x1
popq %r14
cmovbl %eax, %r14d
imull %eax, %r14d
movl %r14d, %edi
callq 0x2d0c4
movl %eax, %r15d
testl %ebx, %ebx
jle 0x238f4
movl %ebx, %edi
callq 0x2d0c4
movl %eax, %ecx
jmp 0x238fd
xorl %ecx, %ecx
cmpl $0x1f, %r14d
adcl $-0x1, %ecx
movl %ebx, %eax
sarl $0x1f, %eax
andl %ebx, %eax
subl %eax, %ebp
pushq $0x2
popq %rsi
movl %r15d, %eax
cltd
idivl %esi
addl %ecx, %ebp
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcGapPenalty
int ffCalcGapPenalty(int hGap, int nGap, enum ffStringency stringency)
/* Return gap penalty for given h and n gaps. */
{
switch (stringency)
    {
    case ffCdna:
	return ffCalcCdnaGapPenalty(hGap, nGap);
    case ffTight:
	return calcTightGap(hGap,nGap);
    case ffLoose:
	return calcLooseGap(hGap,nGap);
    default:
        errAbort("Unknown stringency type %d", stringency);
	return 0;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %edx
je 0x23979
cmpl $0x2, %edx
je 0x2393f
cmpl $0x1, %edx
jne 0x239d7
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x23878
movl %esi, %eax
orl %edi, %eax
je 0x239eb
cmpl %esi, %edi
movl %esi, %eax
cmovll %edi, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
leal (,%rdi,8), %eax
negl %eax
testl %edi, %edi
cmovnsl %edi, %eax
leal (%rsi,%rsi), %edx
negl %edx
testl %esi, %esi
cmovnsl %esi, %edx
subl %ecx, %eax
leal (%rax,%rdx), %ebx
addl $0x8, %ebx
jmp 0x239ed
movl %esi, %eax
orl %edi, %eax
je 0x239eb
cmpl %esi, %edi
movl %esi, %eax
cmovll %edi, %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
leal (,%rdi,8), %eax
negl %eax
testl %edi, %edi
cmovnsl %edi, %eax
leal (%rsi,%rsi), %ebp
negl %ebp
testl %esi, %esi
cmovnsl %esi, %ebp
subl %ebx, %eax
incl %eax
cvtsi2sd %eax, %xmm0
callq 0x6550
movsd %xmm0, (%rsp)
subl %ebx, %ebp
incl %ebp
cvtsi2sd %ebp, %xmm0
callq 0x6550
addsd (%rsp), %xmm0
addsd 0x5c1b7(%rip), %xmm0    # 0x7fb88
cvttsd2si %xmm0, %ebx
jmp 0x239ed
leaq 0x5c1b2(%rip), %rdi     # 0x7fb90
xorl %ebx, %ebx
movl %edx, %esi
xorl %eax, %eax
callq 0x223fb
jmp 0x239ed
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreSomeAlis
int ffScoreSomeAlis(struct ffAli *ali, int count, enum ffStringency stringency)
/* Figure out score of count alis. */
{
int score = 0;
int oneScore;

while (--count >= 0)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = dnaScoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (count > 0)  /* Calculate gap penalty */
        score -= ffGapPenalty(ali, right,stringency);
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
testl %ebp, %ebp
jle 0x23a75
movl 0x28(%r14), %edx
movq 0x20(%r14), %rdi
subl %edi, %edx
movq 0x8(%r14), %r15
movq 0x10(%r14), %rsi
callq 0x21317
movl %eax, %r13d
addl %r12d, %r13d
cmpl $0x1, %ebp
je 0x23a6b
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x23a0b
subl %eax, %r13d
decl %ebp
movl %r13d, %r12d
movq %r15, %r14
jmp 0x23a35
movl %r12d, %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/ffScore.c
// Function: ffScoreSomething
int ffScoreSomething(struct ffAli *ali, enum ffStringency stringency,
   boolean isProt)
/* Score alignment. */
{
int score = 0;
int oneScore;
int (*scoreMatch)(char *a, char *b, int size);

if (ali == NULL)
    return -0x7FFFFFFF;
scoreMatch = (isProt ? aaScoreMatch : dnaScoreMatch );
while (ali->left != NULL) ali = ali->left;
while (ali != NULL)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = scoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (right)  /* Calculate gap penalty */
        {
        score -= ffGapPenalty(ali, right, stringency);
        }
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x23aae
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x23a96
testl %edx, %edx
jne 0x23abe
leaq -0x2795(%rip), %r12     # 0x21317
jmp 0x23ac5
movl $0x80000001, %ebp       # imm = 0x80000001
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2781(%rip), %r12     # 0x21344
xorl %ebp, %ebp
testq %r14, %r14
je 0x23ab3
movq %r14, %r15
movl 0x28(%r14), %edx
movq 0x20(%r14), %rdi
subl %edi, %edx
movq 0x8(%r14), %r14
movq 0x10(%r15), %rsi
callq *%r12
addl %eax, %ebp
testq %r14, %r14
je 0x23ac7
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x23a0b
subl %eax, %ebp
jmp 0x23ac7
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/filePath.c
// Function: splitPath
void splitPath(char *path, char dir[PATH_LEN], char name[FILENAME_LEN],
	       char extension[FILEEXT_LEN])
/* Split a full path into components.  The dir component will include the
 * trailing / if any.  The extension component will include the starting
 * . if any.   Pass in NULL for dir, name, or extension if you don't care about
 * that part. */
{
char *dirStart, *nameStart, *extStart, *extEnd;
int dirSize, nameSize, extSize;

undosPath(path);
dirStart = path;
nameStart = strrchr(path,'/');
if (nameStart == NULL)
    nameStart = path;
else
    nameStart += 1;
extStart = strrchr(nameStart, '.');
if (extStart == NULL)
    extStart = nameStart + strlen(nameStart);
extEnd = extStart + strlen(extStart);
if ((dirSize = (nameStart - dirStart)) >= PATH_LEN)
    errAbort("Directory too long in %s", path);
if ((nameSize = (extStart - nameStart)) >= FILENAME_LEN)
    errAbort("Name too long in %s", path);
if ((extSize = (extEnd - extStart)) >= FILEEXT_LEN)
    errAbort("Extension too long in %s", path);
if (dir != NULL)
    {
    memcpy(dir, dirStart, dirSize);
    dir[dirSize] = 0;
    }
if (name != NULL)
    {
    memcpy(name, nameStart, nameSize);
    name[nameSize] = 0;
    }
if (extension != NULL)
    {
    memcpy(extension, extStart, extSize);
    extension[extSize] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
callq 0x23b14
pushq $0x2f
popq %rsi
movq %rbp, %rdi
callq 0x67c0
leaq 0x1(%rax), %r12
testq %rax, %rax
cmoveq %rbp, %r12
pushq $0x2e
popq %rsi
movq %r12, %rdi
callq 0x67c0
movq %rax, %r15
testq %rax, %rax
jne 0x23b88
movq %r12, %rdi
callq 0x62d0
movq %rax, %r15
addq %r12, %r15
movq %r15, %rdi
callq 0x62d0
movq %rax, (%rsp)
movq %r12, %r14
subq %rbp, %r14
cmpl $0x200, %r14d           # imm = 0x200
jl 0x23bb4
leaq 0x5c001(%rip), %rdi     # 0x7fbab
movq %rbp, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r15, %r13
subq %r12, %r13
cmpl $0x80, %r13d
jl 0x23bd4
leaq 0x5bffa(%rip), %rdi     # 0x7fbc4
movq %rbp, %rsi
xorl %eax, %eax
callq 0x223fb
cmpl $0x40, (%rsp)
jl 0x23beb
leaq 0x5bff7(%rip), %rdi     # 0x7fbd8
movq %rbp, %rsi
xorl %eax, %eax
callq 0x223fb
testq %rbx, %rbx
je 0x23c06
movslq %r14d, %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x6570
movb $0x0, (%rbx,%r14)
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x23c26
movslq %r13d, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6570
movb $0x0, (%rbx,%r14)
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x23c47
movslq (%rsp), %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6570
movb $0x0, (%r14,%rbx)
addq $0x18, %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/filePath.c
// Function: expandRelativePath
char *expandRelativePath(char *baseDir, char *relPath)
/* Expand relative path to more absolute one. */
{
if (relPath[0] == '/')
   // hey, it's absolute actually... 
   return cloneString(relPath);

char *e = baseDir + strlen(baseDir);
int slashCount;
char *rel = relPath;
char *result;
int size, baseSize;
undosPath(baseDir);
undosPath(relPath);
slashCount = countChars(baseDir, '/');
if (baseDir[0] == 0)
    slashCount = -1;
while (startsWith("../", rel))
    {
    if (slashCount < 0)
        {
	warn("More ..'s in \"%s\" than directories in \"%s\"", relPath, baseDir);
	return NULL;
	}
    else if (slashCount == 0)
        e = baseDir;
    else
        e = findSlashBefore(baseDir, e);
    slashCount -= 1;
    rel += 3;
    }
baseSize = e - baseDir;
size = strlen(rel) + 1;
if (baseSize > 0)
    size += baseSize + 1;
if (baseSize > 0)
    {
    result = needMem(size);
    memcpy(result, baseDir, baseSize);
    result[baseSize] = '/';
    strcpy(result + baseSize + 1, rel);
    }
else
    result = cloneString(rel);
return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
cmpb $0x2f, (%rsi)
jne 0x23c7f
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c306
movq %rdi, %rbx
callq 0x62d0
movq %rax, %r14
addq %rbx, %r14
movq %rbx, %rdi
callq 0x23b14
movq %r15, %rdi
callq 0x23b14
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x1e3ef
xorl %ebp, %ebp
cmpb $0x1, (%rbx)
sbbl %ebp, %ebp
orl %eax, %ebp
leaq 0x5e7fe(%rip), %r13     # 0x824b6
movq %r15, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x1db41
testl %eax, %eax
je 0x23cfc
testl %ebp, %ebp
js 0x23d47
movq %rbx, %rax
subl $0x1, %ebp
jb 0x23cf3
decq %r14
cmpq %rbx, %r14
jb 0x23cf0
leaq -0x1(%r14), %rax
cmpb $0x2f, (%r14)
movq %rax, %r14
jne 0x23cd9
incq %rax
jmp 0x23cf3
movq %rbx, %rax
addq $0x3, %r12
movq %rax, %r14
jmp 0x23cbb
subq %rbx, %r14
testl %r14d, %r14d
jle 0x23d70
movq %r12, %rdi
callq 0x62d0
addl %r14d, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x28bb0
movq %rax, %r13
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6570
leaq (%r14,%r13), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq %r12, %rsi
callq 0x6680
jmp 0x23d5e
leaq 0x5bea3(%rip), %rdi     # 0x7fbf1
xorl %r13d, %r13d
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22186
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
jmp 0x23c6c
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/filePath.c
// Function: mustExpandRelativePath
char *mustExpandRelativePath(char *dir, char* relPath)
/* Given a dir and relative path, expand path.
 * Handy for processing symlinks. errAbort if expand fails.
 * Result should be freeMem'd.*/
{
char *path = expandRelativePath(dir, relPath);
verbose(3, "dir=%s\nrelPath=%s\npath=%s\n", dir, relPath, path);
if (!path)
    errAbort("Too many .. in path %s to make relative to submitDir %s\n", relPath, dir);
return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23c56
movq %rax, %r15
leaq 0x5be8a(%rip), %rsi     # 0x7fc1c
pushq $0x3
popq %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x3c521
testq %r15, %r15
jne 0x23dbe
leaq 0x5be86(%rip), %rdi     # 0x7fc37
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x223fb
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/filePath.c
// Function: pathRelativeToFile
char *pathRelativeToFile(char *baseFile, char *relPath)
/* Given a base file name and a path relative to that, return
 * relative path interpreted as if it were seen from the
 * same directory holding the baseFile.  
 *   An example of using this would be in processing include
 * files.  In this case the baseFile would be the current
 * source file, and the relPath would be from the include
 * statement.  The returned result could then be used to
 * open the include file. */
{
char dir[PATH_LEN];
splitPath(baseFile, dir, NULL, NULL);
int dirLen = strlen(dir);
if (dirLen > 0 && dir[dirLen-1] == '/')
     dir[dirLen-1] = 0;
return expandRelativePath(dir, relPath);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x23b2e
movq %r14, %rdi
callq 0x62d0
testl %eax, %eax
jle 0x23dfb
decl %eax
cmpb $0x2f, (%rsp,%rax)
jne 0x23dfb
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x23c56
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/filePath.c
// Function: mustPathRelativeToFile
char *mustPathRelativeToFile(char *baseFile, char *relPath)
/* Make Path Relative To File or Abort. */
{
char *path = pathRelativeToFile(baseFile, relPath);
verbose(3, "baseFile=%s\nrelPath=%s\npath=%s\n", baseFile, relPath, path);
if (!path)
    errAbort("Too many .. in symlink path %s to make relative to %s\n", relPath, baseFile);
return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23dc7
movq %rax, %r15
leaq 0x5be45(%rip), %rsi     # 0x7fc70
pushq $0x3
popq %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x3c521
testq %r15, %r15
jne 0x23e57
leaq 0x5be46(%rip), %rdi     # 0x7fc90
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x223fb
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashResize
void hashResize(struct hash *hash, int powerOfTwoSize)
/* Resize the hash to a new size */
{
int oldHashSize = hash->size;
struct hashEl **oldTable = hash->table;

if (powerOfTwoSize == 0)
    powerOfTwoSize = 12;
if (powerOfTwoSize > hashMaxSize)
    powerOfTwoSize =  hashMaxSize;
if (hash->powerOfTwoSize == powerOfTwoSize)
    return;

assert(powerOfTwoSize <= hashMaxSize && powerOfTwoSize > 0);
hash->powerOfTwoSize = powerOfTwoSize;
hash->size = (1<<powerOfTwoSize);
hash->mask = hash->size-1;

AllocArray(hash->table, hash->size);

int i;
struct hashEl *hel, *next;
for (i=0; i<oldHashSize; ++i)
    {
    for (hel = oldTable[i]; hel != NULL; hel = next)
	{
	next = hel->next;
	int hashVal = hel->hashVal & hash->mask;
	hel->next = hash->table[hashVal];
	hash->table[hashVal] = hel;
	}
    }
/* restore original list order */
hashReverseAllBucketLists(hash);

freeMem(oldTable);
hash->numResizes++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1c, %esi
pushq $0x1c
popq %rax
cmovll %esi, %eax
testl %esi, %esi
pushq $0xc
popq %rcx
cmovnel %eax, %ecx
cmpl %ecx, 0x18(%rdi)
je 0x242ab
testl %ecx, %ecx
jle 0x242b1
movq %rdi, %rbx
movl 0x1c(%rdi), %r15d
movq 0x10(%rdi), %r14
movl %ecx, 0x18(%rdi)
pushq $0x1
popq %rdi
shll %cl, %edi
movl %edi, 0x1c(%rbx)
leal -0x1(%rdi), %eax
movl %eax, 0x8(%rbx)
shlq $0x3, %rdi
callq 0x28a1f
movq %rax, 0x10(%rbx)
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %r15, %rax
je 0x24298
movq (%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0x24293
movq (%rcx), %rdx
movl 0x8(%rbx), %esi
andl 0x18(%rcx), %esi
movslq %esi, %rsi
movq 0x10(%rbx), %rdi
movq (%rdi,%rsi,8), %r8
movq %r8, (%rcx)
movq %rcx, (%rdi,%rsi,8)
movq %rdx, %rcx
jmp 0x2426e
incq %rax
jmp 0x24265
movq %rbx, %rdi
callq 0x24668
movq %r14, %rdi
callq 0x28c2d
incl 0x34(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5ba94(%rip), %rdi     # 0x7fd4c
leaq 0x5bac1(%rip), %rsi     # 0x7fd80
leaq 0x5bae7(%rip), %rcx     # 0x7fdad
movl $0x191, %edx            # imm = 0x191
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashReverseAllBucketLists
void hashReverseAllBucketLists(struct hash *hash)
/* Reverse all hash bucket list.  You might do this to
 * get them back in the same order things were added to the hash */
{
int i;
for (i=0; i<hash->size; ++i)
    {
    struct hashEl *hel = hash->table[i];
    if (hel != NULL && hel->next != NULL)	    
	slReverse(&hash->table[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jge 0x246a3
movq 0x10(%rbx), %rdi
movq (%rdi,%r14), %rax
testq %rax, %rax
je 0x2469a
cmpq $0x0, (%rax)
je 0x2469a
addq %r14, %rdi
callq 0x1c567
incq %r15
addq $0x8, %r14
jmp 0x24676
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashFromSlNameList
struct hash *hashFromSlNameList(void *list)
/* Create a hash out of a list of slNames. */
{
struct hash *hash = NULL;
struct slName *namedList = list, *item;
if (!list)
    return NULL;
hash = newHash(0);
for (item = namedList; item != NULL; item = item->next)
    hashAdd(hash, item->name, item);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x246db
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %r14
testq %rbx, %rbx
je 0x246de
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x242d0
movq (%rbx), %rbx
jmp 0x246c2
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashSetFromSlNameList
struct hash *hashSetFromSlNameList(void *list)
/* Create a hashSet (hash with only keys) out of a list of slNames. */
{
struct hash *hash = NULL;
struct slName *namedList = list, *item;
if (!list)
    return NULL;
hash = newHash(0);
for (item = namedList; item != NULL; item = item->next)
    hashAdd(hash, item->name, NULL);
return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2471a
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %r14
testq %rbx, %rbx
je 0x2471d
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x242d0
movq (%rbx), %rbx
jmp 0x24702
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashFromString
struct hash *hashFromString(char *string)
/* parse a whitespace-separated string with tuples in the format name=val or
 * name="val" to a hash name->val */
{
if (string==NULL)
    return NULL;

struct slPair *keyVals = slPairListFromString(string, TRUE);
if (keyVals==NULL)
    return NULL;

struct hash *nameToVal = newHash(0);
struct slPair *kv;
for (kv = keyVals; kv != NULL; kv = kv->next)
    hashAdd(nameToVal, kv->name, kv->val);
return nameToVal;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24d32
pushq $0x1
popq %rsi
callq 0x1d42c
testq %rax, %rax
je 0x24d32
movq %rax, %r14
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %rbx
testq %r14, %r14
je 0x24d34
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x242d0
movq (%r14), %r14
jmp 0x24d18
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashFromNameArray
struct hash *hashFromNameArray(char **nameArray, int nameCount)
/* Create a NULL valued hash on all names in array */
{
struct hash *hash = hashNew(0);
int i;
for (i=0; i<nameCount; ++i)
    hashAdd(hash, nameArray[i], NULL);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %r15
testl %ebx, %ebx
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0x24d7a
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x242d0
incq %r12
jmp 0x24d62
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/hash.c
// Function: hashFromNameValArray
struct hash *hashFromNameValArray(char *nameVal[][2], int nameValCount)
/* Make up a hash from nameVal array */
{
struct hash *hash = newHash(0);
int i;
for (i=0; i<nameValCount; ++i)
    hashAdd(hash, nameVal[i][0], nameVal[i][1]);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %r15
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x4, %rbx
cmpq %r12, %rbx
je 0x24dcc
movq (%r14,%r12), %rsi
movq 0x8(%r14,%r12), %rdx
movq %r15, %rdi
callq 0x242d0
addq $0x10, %r12
jmp 0x24db0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: lineFileSetTabixRegion
boolean lineFileSetTabixRegion(struct lineFile *lf, char *seqName, int start, int end)
/* Assuming lf was created by lineFileTabixMayOpen, tell tabix to seek to the specified region
 * and return TRUE (or if there are no items in region, return FALSE). */
{
if (lf->tabix == NULL)
    errAbort("lineFileSetTabixRegion: lf->tabix is NULL.  Did you open lf with lineFileTabixMayOpen?");
if (seqName == NULL)
    return FALSE;
int tabixSeqId = ti_get_tid(lf->tabix, seqName);
if (tabixSeqId < 0 && startsWith("chr", seqName))
    // We will get some files that have chr-less Ensembl chromosome names:
    tabixSeqId = ti_get_tid(lf->tabix, seqName+strlen("chr"));
if (tabixSeqId < 0)
    return FALSE;
ti_iter_t *iter = ti_queryi((tbx_t *)lf->tabix, tabixSeqId, start, end);
if (iter == NULL)
    return FALSE;
if (lf->tabixIter != NULL)
    ti_iter_destroy(lf->tabixIter);
lf->tabixIter = iter;
lf->bytesInBuf = 0;
lf->lineIx = -1;
lf->lineStart = 0;
lf->lineEnd = 0;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
jne 0x25336
leaq 0x5abb8(%rip), %rdi     # 0x7fee7
xorl %eax, %eax
callq 0x223fb
xorl %ebp, %ebp
testq %r12, %r12
je 0x253c4
movq 0x70(%rbx), %rdi
movq %r12, %rsi
callq 0x4aeb0
testl %eax, %eax
js 0x2539d
movq 0x70(%rbx), %rcx
movq 0x18(%rcx), %rdi
leaq 0x25e9f(%rip), %r8      # 0x4b1ff
movl %eax, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x49973
testq %rax, %rax
je 0x253c4
movq %rax, %r14
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x25383
callq 0x49e67
movq %r14, 0x78(%rbx)
andl $0x0, 0x20(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x28(%rbx)
andl $0x0, 0x30(%rbx)
pushq $0x1
popq %rbp
jmp 0x253c4
leaq 0x5ab9a(%rip), %rdi     # 0x7ff3e
movq %r12, %rsi
callq 0x1db41
testl %eax, %eax
je 0x253c4
movq 0x70(%rbx), %rdi
addq $0x3, %r12
movq %r12, %rsi
callq 0x4aeb0
testl %eax, %eax
jns 0x25351
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: lineFileUdcMayOpen
struct lineFile *lineFileUdcMayOpen(char *fileOrUrl, bool zTerm)
/* Create a line file object with an underlying UDC cache. NULL if not found. */
{
if (fileOrUrl == NULL)
    errAbort("lineFileUdcMayOpen: fileOrUrl is NULL");

if (udcIsLocal(fileOrUrl))
     return lineFileOpen(fileOrUrl, zTerm);
else
    {
    struct udcFile *udcFile = udcFileMayOpen(fileOrUrl, NULL);
    if (udcFile == NULL)
	return NULL;
    struct lineFile *lf;
    AllocVar(lf);
    lf->fileName = cloneString(fileOrUrl);
    lf->fd = -1;
    lf->bufSize = 0;
    lf->buf = NULL;
    lf->zTerm = zTerm;
    lf->udcFile = udcFile;
    return lf;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x253ef
leaq 0x5ab5a(%rip), %rdi     # 0x7ff42
xorl %eax, %eax
callq 0x223fb
movq %r14, %rdi
callq 0x3beeb
testl %eax, %eax
je 0x25411
movsbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25467
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3a42e
testq %rax, %rax
je 0x25458
movq %rax, %r12
movl $0xc8, %edi
callq 0x28bb0
movq %rax, %r15
movq %r14, %rdi
callq 0x1c306
movq %rax, 0x8(%r15)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%r15)
andq $0x0, 0x40(%r15)
movb %bl, 0x34(%r15)
movq %r12, 0x88(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: lineFileSeek
void lineFileSeek(struct lineFile *lf, off_t offset, int whence)
/* Seek to read next line from given position. */
{
noTabixSupport(lf, "lineFileSeek");
if (lf->checkSupport)
    lf->checkSupport(lf, "lineFileSeek");
if (lf->pl != NULL)
    errnoAbort("Can't lineFileSeek on a compressed file: %s", lf->fileName);
lf->reuse = FALSE;
if (lf->udcFile)
    {
    udcSeek(lf->udcFile, offset);
    return;
    }
lf->lineStart = lf->lineEnd = lf->bytesInBuf = 0;
if ((lf->bufOffsetInFile = lseek(lf->fd, offset, whence)) == -1)
    errnoAbort("Couldn't lineFileSeek %s", lf->fileName);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x255c0
leaq 0x5b016(%rip), %rsi     # 0x805c5
leaq 0x5aa1c(%rip), %rdx     # 0x7ffd2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x25c2a
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x255d8
leaq 0x5a9ff(%rip), %rsi     # 0x7ffd2
movq %rbx, %rdi
callq *%rax
cmpq $0x0, 0x48(%rbx)
je 0x255f1
movq 0x8(%rbx), %rsi
leaq 0x5a9f5(%rip), %rdi     # 0x7ffdf
xorl %eax, %eax
callq 0x22504
movb $0x0, 0x3c(%rbx)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2560d
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3bb5a
andl $0x0, 0x20(%rbx)
andq $0x0, 0x2c(%rbx)
movl 0x10(%rbx), %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x65b0
movq %rax, 0x18(%rbx)
cmpq $-0x1, %rax
je 0x25632
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rsi
leaq 0x5a9ce(%rip), %rdi     # 0x8000b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x22504
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: determineNlType
static void determineNlType(struct lineFile *lf, char *buf, int bufSize)
/* determine type of newline used for the file, assumes buffer not empty */
{
char *c = buf;
if (bufSize==0) return;
if (lf->nlType != nlt_undet) return;  /* if already determined just exit */
while (c < buf+bufSize)
    {
    if (*c=='\r')
	{
    	lf->nlType = nlt_mac;
	if (++c < buf+bufSize)
    	    if (*c == '\n')
    		lf->nlType = nlt_dos;
	return;
	}
    if (*(c++) == '\n')
	{
        lf->nlType = nlt_unix;
	return;
	}
    }
}

// Assembly:
testl %edx, %edx
je 0x25ac3
cmpl $0x0, 0x38(%rdi)
je 0x25ac4
retq
movslq %edx, %rax
addq %rsi, %rax
incq %rsi
pushq $0x1
popq %rcx
leaq -0x1(%rsi), %rdx
cmpq %rax, %rdx
jae 0x25ac3
movb (%rdx), %dl
cmpb $0xd, %dl
je 0x25aea
incq %rsi
cmpb $0xa, %dl
jne 0x25ad0
jmp 0x25afe
movl $0x3, 0x38(%rdi)
cmpq %rax, %rsi
jae 0x25ac3
cmpb $0xa, (%rsi)
jne 0x25ac3
pushq $0x2
popq %rcx
movl %ecx, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: findNextNewline
static boolean findNextNewline(struct lineFile *lf, char *buf, int bytesInBuf, int *pEndIx)
/* Return TRUE if able to find next end of line in buf, starting at buf[*pEndIx], up to bytesInBuf.
 * When done set *pEndIx to the start of the next line if applicable, otherwise bytesInBuf. */
{
boolean gotLf = FALSE;
int endIx = *pEndIx;
switch (lf->nlType)
    {
    case nlt_unix:
    case nlt_dos:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            if (buf[endIx] == '\n')
                {
                gotLf = TRUE;
                endIx += 1;
                break;
                }
            }
        break;
    case nlt_mac:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            if (buf[endIx] == '\r')
                {
                gotLf = TRUE;
                endIx += 1;
                break;
                }
            }
        break;
    case nlt_mixed:
    case nlt_undet:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            char c = buf[endIx];
            if (c == '\r' || c == '\n')
                {
                gotLf = TRUE;
                if (lf->zTerm)
                    buf[endIx] = '\0';
                endIx += 1;
                if (c == '\r' && buf[endIx] == '\n')
                    {
                    if (lf->zTerm)
                        buf[endIx] = '\0';
                    endIx += 1;
                    }
                break;
                }
            }
        break;
    }
*pEndIx = endIx;
return gotLf;
}

// Assembly:
movl (%rcx), %r8d
movl 0x38(%rdi), %r9d
xorl %eax, %eax
cmpq $0x4, %r9
ja 0x25bad
movslq %r8d, %r8
leaq 0x5a311(%rip), %r10     # 0x7fe30
movslq (%r10,%r9,4), %r9
addq %r10, %r9
jmpq *%r9
movslq %edx, %rdx
cmpq %rdx, %r8
jge 0x25bad
movzbl (%rsi,%r8), %r9d
cmpl $0xd, %r9d
je 0x25b5b
cmpl $0xa, %r9d
je 0x25b5b
incq %r8
jmp 0x25b2c
movslq %edx, %rdx
cmpq %rdx, %r8
jge 0x25bad
cmpb $0xa, (%rsi,%r8)
je 0x25ba2
incq %r8
jmp 0x25b4a
cmpb $0x0, 0x34(%rdi)
je 0x25b66
movb $0x0, (%rsi,%r8)
leal 0x1(%r8), %edx
pushq $0x1
popq %rax
cmpb $0xd, %r9b
jne 0x25baa
movslq %edx, %r9
cmpb $0xa, (%rsi,%r9)
jne 0x25baa
cmpb $0x0, 0x34(%rdi)
je 0x25b88
movb $0x0, (%rsi,%r9)
addl $0x2, %r8d
jmp 0x25bad
movslq %edx, %rdx
cmpq %rdx, %r8
jge 0x25bad
cmpb $0xd, (%rsi,%r8)
je 0x25ba2
incq %r8
jmp 0x25b91
incl %r8d
pushq $0x1
popq %rax
jmp 0x25bad
movl %edx, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/linefile.c
// Function: lineFileClose
void lineFileClose(struct lineFile **pLf)
/* Close up a line file. */
{
struct lineFile *lf;
if ((lf = *pLf) != NULL)
    {
    struct pipeline *pl = lf->pl;
    if (pl != NULL)
        {
        pipelineClose(&lf->pl);
        }
    else if (lf->fd > 0 && lf->fd != fileno(stdin))
	{
	close(lf->fd);
	freeMem(lf->buf);
	}
    else if (lf->tabix != NULL)
	{
	if (lf->tabixIter != NULL)
	    ti_iter_destroy(lf->tabixIter);
	ti_close(lf->tabix);
        hts_close(lf->htsFile);
        kstring_t *kline = lf->kline;
        free(kline->s);
	}
    else if (lf->udcFile != NULL)
        udcFileClose(&lf->udcFile);

    if (lf->closeCallBack)
        lf->closeCallBack(lf);
    freeMem(lf->fileName);
    metaDataFree(lf);
    freez(pLf);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x25cfc
movq %rdi, %rbx
cmpq $0x0, 0x48(%r14)
je 0x25d01
leaq 0x48(%r14), %rdi
callq 0x3040b
jmp 0x25d84
popq %rbx
popq %r14
popq %rbp
retq
movl 0x10(%r14), %ebp
testl %ebp, %ebp
jle 0x25d1c
movq 0x8d2c0(%rip), %rax     # 0xb2fd0
movq (%rax), %rdi
callq 0x6750
cmpl %eax, %ebp
jne 0x25d5a
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x25d6e
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x25d3a
movq %rax, %rdi
callq 0x49e67
movq 0x70(%r14), %rdi
callq 0x4b5f9
movq 0x68(%r14), %rdi
callq 0x4780a
movq 0x80(%r14), %rax
movq 0x10(%rax), %rdi
callq 0x68a0
jmp 0x25d84
movl 0x10(%r14), %edi
callq 0x6e80
movq 0x40(%r14), %rdi
callq 0x28c2d
jmp 0x25d84
cmpq $0x0, 0x88(%r14)
je 0x25d84
leaq 0x88(%r14), %rdi
callq 0x3adfd
movq 0xc0(%r14), %rax
testq %rax, %rax
je 0x25d95
movq %r14, %rdi
callq *%rax
movq 0x8(%r14), %rdi
callq 0x28c2d
cmpb $0x0, 0x58(%r14)
je 0x25db8
cmpq $0x0, 0x60(%r14)
je 0x25db8
addq $0x60, %r14
movq %r14, %rdi
callq 0x2494c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x28c3d
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/localmem.c
// Function: lmCloneRowExt
char **lmCloneRowExt(struct lm *lm, char **row, int rowOutSize, int rowInSize)
/* Allocate an array of strings with rowOutSize elements.  Clone the first rowInSize elements
 * of row into the new array, leaving others NULL if rowOutSize is greater than rowInSize.
 * rowOutSize must be greater than or equal to rowInSize. */
{
if (rowOutSize < rowInSize)
    errAbort("lmCloneRowExt: rowOutSize (%d) must be greater than or equal to rowInSize (%d)",
             rowOutSize, rowInSize);
char **rowClone = NULL;
lmAllocArray(lm, rowClone, rowOutSize);
int i;
for (i = 0;  i < rowInSize;  i++)
    rowClone[i] = lmCloneString(lm, row[i]);
return rowClone;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpl %ecx, %edx
jge 0x27224
leaq 0x593ef(%rip), %rdi     # 0x80608
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x223fb
movslq %ebp, %rsi
shlq $0x3, %rsi
movq %r15, %rdi
callq 0x26ff4
movq %rax, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x27259
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
callq 0x270f3
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0x2723f
movq %r12, %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/maf.c
// Function: mafMayOpen
struct mafFile *mafMayOpen(char *fileName)
/* Open up a maf file and verify header. */
{
struct mafFile *mf;
struct lineFile *lf;
char *line, *word;
char *sig = "##maf";

if ( hasProtocol(fileName))
    lf = lineFileUdcMayOpen(fileName, TRUE);
else
    lf = lineFileMayOpen(fileName, TRUE);

if (lf == NULL)
    return NULL;
AllocVar(mf);
mf->lf = lf;

lineFileNeedNext(lf, &line, NULL);
if (!startsWith(sig, line))
    {
    errAbort("%s does not start with %s", fileName, sig);
    }
line += strlen(sig);

while ((word = nextWord(&line)) != NULL)
    {
    /* Parse name=val. */
    char *name = word;
    char *val = strchr(word, '=');
    if (val == NULL)
       errAbort("Missing = after %s line 1 of %s\n", name, fileName);
    *val++ = 0;

    if (sameString(name, "version"))
        mf->version = atoi(val);
    else if (sameString(name, "scoring"))
        mf->scoring = cloneString(val);
    }
if (mf->version == 0)
    errAbort("No version line 1 of %s\n", fileName);
return mf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
callq 0x2bf85
pushq $0x1
popq %rsi
movq %r12, %rdi
testl %eax, %eax
je 0x2729b
callq 0x253cf
jmp 0x272a0
callq 0x2551a
movq %rax, %rbx
testq %rax, %rax
je 0x273ab
pushq $0x28
popq %rdi
callq 0x28bb0
movq %rax, %r14
movq %rbx, 0x20(%rax)
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x25cc0
movq (%r15), %rsi
leaq 0x593a8(%rip), %rdi     # 0x8067f
callq 0x1db41
testl %eax, %eax
jne 0x272f8
leaq 0x5939e(%rip), %rdi     # 0x80685
leaq 0x59391(%rip), %rdx     # 0x8067f
movq %r12, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r12, 0x8(%rsp)
leaq 0x10(%rsp), %r15
addq $0x5, (%r15)
pushq $0x3d
popq %rbp
leaq 0x5bb48(%rip), %r13     # 0x82e58
movq %r15, %rdi
callq 0x1e9c1
testq %rax, %rax
je 0x2738f
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
callq 0x6270
movq %rax, %rbx
testq %rax, %rax
jne 0x27348
leaq 0x59366(%rip), %rdi     # 0x8069f
movq %r12, %rsi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x223fb
movq %rbx, %rax
incq %rbx
movb $0x0, (%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x6a50
testl %eax, %eax
je 0x27381
movq %r12, %rdi
leaq 0x59356(%rip), %rsi     # 0x806c0
callq 0x6a50
testl %eax, %eax
jne 0x27310
movq %rbx, %rdi
callq 0x1c306
movq %rax, 0x10(%r14)
jmp 0x27310
movq %rbx, %rdi
callq 0x6bd0
movl %eax, 0x8(%r14)
jmp 0x27310
cmpl $0x0, 0x8(%r14)
jne 0x273ae
leaq 0x5932b(%rip), %rdi     # 0x806c8
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x223fb
jmp 0x273ae
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %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/maf.c
// Function: mafOpen
struct mafFile *mafOpen(char *fileName)
/* Open up a maf file.  Squawk and die if there's a problem. */
{
struct mafFile *mf = mafMayOpen(fileName);
if (mf == NULL)
    errnoAbort("Couldn't open %s\n", fileName);
return mf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x27274
movq %rax, %rbx
testq %rax, %rax
jne 0x273e5
leaq 0x59306(%rip), %rdi     # 0x806e1
movq %r14, %rsi
xorl %eax, %eax
callq 0x22504
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafReadAll
struct mafFile *mafReadAll(char *fileName)
/* Read all elements in a maf file */
{
struct mafFile *mf = mafOpen(fileName);
struct mafAli *ali;
while ((ali = mafNext(mf)) != NULL)
    {
    slAddHead(&mf->alignments, ali);
    }
slReverse(&mf->alignments);
return mf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x273c0
movq %rax, %rbx
movq %rax, %r14
addq $0x18, %r14
movq %rbx, %rdi
callq 0x2791d
testq %rax, %rax
je 0x2794f
movq (%r14), %rcx
movq %rcx, (%rax)
movq %rax, (%r14)
jmp 0x27937
movq %r14, %rdi
callq 0x1c567
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafWriteStart
void mafWriteStart(FILE *f, char *scoring)
/* Write maf header and scoring scheme name (may be null) */
{
fprintf(f, "##maf version=1");
if (scoring != NULL)
    fprintf(f, " scoring=%s", scoring);
fprintf(f, "\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58e93(%rip), %rdi     # 0x80806
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x6e70
testq %r14, %r14
je 0x2799a
leaq 0x58e89(%rip), %rsi     # 0x80816
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6a90
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6930
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafWriteAll
void mafWriteAll(struct mafFile *mf, char *fileName)
/* Write out full mafFile. */
{
FILE *f = mustOpen(fileName, "w");
struct mafAli *ali;
mafWriteStart(f, mf->scoring);
for (ali = mf->alignments; ali != NULL; ali = ali->next)
    mafWrite(f, ali);
mafWriteEnd(f);
carefulClose(&f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x56051(%rip), %rsi     # 0x7dc79
movq %rax, %rdi
callq 0x1ec79
movq %rax, %r14
movq %rax, (%rsp)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x27962
addq $0x18, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x27c5c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27bf6
jmp 0x27c47
movq %rsp, %rdi
callq 0x1f2ea
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafCompFree
void mafCompFree(struct mafComp **pObj)
/* Free up a maf component. */
{
struct mafComp *obj = *pObj;
if (obj == NULL)
    return;
freeMem(obj->src);
freeMem(obj->text);
freeMem(obj->quality);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x27ca5
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x28c2d
movq 0x20(%r14), %rdi
callq 0x28c2d
movq 0x28(%r14), %rdi
callq 0x28c2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafCompFreeList
void mafCompFreeList(struct mafComp **pList)
/* Free up a list of maf components. */
{
struct mafComp *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x27cd8
movq (%r15), %r15
movq %r14, %rdi
callq 0x27c6c
jmp 0x27cc1
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq