LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFileFree
void mafFileFree(struct mafFile **pObj)
/* Free up a maf file. */
{
struct mafFile *obj = *pObj;
if (obj == NULL)
    return;
lineFileClose(&obj->lf);
freeMem(obj->scoring);
mafAliFreeList(&obj->alignments);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2ceb2
movq %rdi, %rbx
leaq 0x20(%r14), %rdi
callq 0x2ab48
movq 0x10(%r14), %rdi
callq 0x2dd41
addq $0x18, %r14
movq %r14, %rdi
callq 0x2ce32
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFileFreeList
void mafFileFreeList(struct mafFile **pList)
/* Free up a list of maf files. */
{
struct mafFile *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x2ceed
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2ce76
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x2ced8
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafMayFindComponentDb
struct mafComp *mafMayFindComponentDb(struct mafAli *maf, char *db)
/* Find component of given database, allowing component to be 
 * labeled "db", or "db.chrom" . Return NULL if not found. */
{
struct mafComp *mc;
char *p, *q;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    for (p = mc->src, q = db; *p && *q; p++, q++)
        {
        if (*p != *q)
            break;
        }
    if (*p == '.' && *q == 0)
        return mc;
    if (*p == *q)
        return mc;
    }
return NULL;
}

// Assembly:
movq %rdi, %rax
addq $0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2cf78
movq 0x8(%rax), %rdi
movb (%rdi), %cl
testb %cl, %cl
je 0x2cf64
incq %rdi
movq %rsi, %rdx
cmpb (%rdx), %cl
jne 0x2cf69
incq %rdx
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x2cf52
jmp 0x2cf73
movq %rsi, %rdx
jmp 0x2cf73
cmpb $0x2e, %cl
jne 0x2cf73
cmpb $0x0, (%rdx)
je 0x2cf77
cmpb (%rdx), %cl
jne 0x2cf3a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFindComponent
struct mafComp *mafFindComponent(struct mafAli *maf, char *src)
/* Find component of given source or die trying. */
{
struct mafComp *mc = mafMayFindComponent(maf, src);
if (mc == NULL)
    errAbort("Couldn't find %s in maf", src);
return mc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2cfa3
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
jne 0x2cf89
jmp 0x2cfa5
xorl %ebx, %ebx
testq %rbx, %rbx
jne 0x2cfbb
leaq 0x6492f(%rip), %rdi     # 0x918e0
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompSpecies
struct mafComp *mafMayFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species possibly followed by sepChar or \0 .
   Return NULL if not found. */
{
struct mafComp *mc;
int speciesLen = strlen(species);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(species, mc->src) )
	{
	char endChar = mc->src[speciesLen];

	if ((endChar == '\0') || (endChar == sepChar))
	    return mc;
	}
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x2d01f
movl %edx, %ebx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x62d0
movslq %eax, %r13
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x217c8
testl %eax, %eax
je 0x2d016
movq 0x8(%r12), %rax
movb (%rax,%r13), %al
testb %al, %al
setne %cl
cmpb %bl, %al
setne %al
andb %cl, %al
cmoveq %r12, %r15
cmpb $0x1, %al
jne 0x2d022
movq (%r12), %r12
testq %r12, %r12
jne 0x2cfe8
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFindCompSpecies
struct mafComp *mafFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species followed by sepChar
   or die trying. */
{
struct mafComp *mc = mafMayFindCompSpecies(maf, species, sepChar);
if (mc == NULL)
    errAbort("Couldn't find %s%c or just %s... in maf", species,sepChar,species);
return mc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
callq 0x2cfc6
movq %rax, %r14
testq %rax, %rax
jne 0x2d05d
movsbl %bpl, %edx
leaq 0x648a8(%rip), %rdi     # 0x918f8
movq %rbx, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26b6f
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompPrefix
struct mafComp *mafMayFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep.
   Return NULL if not found. */
{
struct mafComp *mc;
char prefix[256];

if (sep == NULL)
    sep = "";
snprintf(prefix, 256, "%s%s", pre, sep);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(prefix, mc->src))
        return mc;
    }
return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rcx
movq %rdi, %rbx
testq %rdx, %rdx
leaq 0x6b2e1(%rip), %r8      # 0x98360
cmovneq %rdx, %r8
leaq 0x642ca(%rip), %rdx     # 0x91354
movq %rsp, %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x6c20
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d0ba
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x217c8
testl %eax, %eax
je 0x2d0a0
jmp 0x2d0bc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFindCompPrefix
struct mafComp *mafFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep
   or die trying. */
{
struct mafComp *mc = mafMayFindCompPrefix(maf, pre, sep);
if (mc == NULL)
    errAbort("Couldn't find %s%s... in maf", pre,sep);
return mc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x2d065
movq %rax, %r15
testq %rax, %rax
jne 0x2d0f6
leaq 0x64837(%rip), %rdi     # 0x91920
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26b6f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafMayFindSpeciesInHash
struct mafComp *mafMayFindSpeciesInHash(struct mafAli *maf, struct hash *cHash, char sepChar) 
/* Find arbitrary component of given who's source prefix (ended by sep)
   matches matches any string in the cHash.  Return NULL if not found. */
{
struct mafComp *mc;

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    char *sep = strchr(mc->src, sepChar);
    if (sep != NULL)
        *sep = '\0';
    boolean hit = hashFindVal(cHash, mc->src) != NULL;
    if (sep != NULL)
        *sep = sepChar;
    if (hit)
        return mc;
    }
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2d18a
movq 0x8(%r15), %rdi
movl %ebx, %esi
callq 0x6270
movq %rax, %r13
testq %rax, %rax
je 0x2d16a
movb $0x0, (%r13)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x29029
testq %r13, %r13
je 0x2d17f
movb %bl, (%r13)
testq %rax, %rax
cmovneq %r15, %r12
je 0x2d14a
jmp 0x2d18d
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafMayFindAllComponents
boolean mafMayFindAllComponents(struct mafAli *maf, struct hash *cHash) 
/* Find component of given source that starts matches any string in the cHash.
   Return NULL if not found. */
{
struct hashCookie cookie = hashFirst(cHash);
struct hashEl *el;

while ((el = hashNext(&cookie)) != NULL)
    if (mafMayFindComponent(maf, el->name) == NULL)
	return FALSE;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x29455
addq $0x10, %rbx
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x294c4
testq %rax, %rax
je 0x2d1f1
movq 0x8(%rax), %r15
movq %rbx, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2d1f6
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
jne 0x2d1d0
testq %r12, %r12
jne 0x2d1bc
jmp 0x2d1f6
movl $0x1, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafNeedSubset
boolean mafNeedSubset(struct mafAli *maf, char *componentSource,
	int newStart, int newEnd)
/* Return TRUE if maf only partially fits between newStart/newEnd
 * in given component. */
{
struct mafComp *mcMaster = mafFindComponent(maf, componentSource);

/* Reverse complement input range if necessary. */
if (mcMaster->strand == '-')
    reverseIntRange(&newStart, &newEnd, mcMaster->srcSize);

return newStart > mcMaster->start || newEnd < mcMaster->start + mcMaster->size;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
callq 0x2cf7b
movq %rax, %rbx
cmpb $0x2d, 0x14(%rax)
jne 0x2d455
movl 0x10(%rbx), %edx
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x25145
movl 0x18(%rbx), %ecx
movl $0x1, %eax
cmpl %ecx, 0xc(%rsp)
jg 0x2d46f
addl 0x1c(%rbx), %ecx
xorl %eax, %eax
cmpl %ecx, 0x8(%rsp)
setl %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafFlipStrand
void mafFlipStrand(struct mafAli *maf)
/* Reverse complement maf. */
{
struct mafComp *mc;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    int e = mc->start + mc->size;
    reverseIntRange(&mc->start, &e, mc->srcSize);
    if (mc->text != NULL)
        reverseComplement(mc->text, maf->textSize);
    if (mc->quality != NULL)
	reverseBytes(mc->quality, maf->textSize);
    if (mc->strand == '-')
        mc->strand = '+';
    else
        mc->strand = '-';
    char holdStatus = mc->leftStatus;
    mc->leftStatus = mc->rightStatus;
    mc->rightStatus = holdStatus;
    int holdLen = mc->leftLen;
    mc->leftLen = mc->rightLen;
    mc->rightLen = holdLen;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x2d50c
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x18(%r15), %rdi
movl 0x1c(%r15), %eax
addl 0x18(%r15), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%r15), %edx
movq %r14, %rsi
callq 0x25145
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x2d4c1
movslq 0x18(%rbx), %rsi
callq 0x250f6
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x2d4d3
movslq 0x18(%rbx), %rsi
callq 0x1fade
movb 0x30(%r15), %al
cmpb $0x2d, 0x14(%r15)
setne %cl
addb %cl, %cl
addb $0x2b, %cl
movb %cl, 0x14(%r15)
movb 0x38(%r15), %cl
movb %cl, 0x30(%r15)
movb %al, 0x38(%r15)
movl 0x34(%r15), %eax
movl 0x3c(%r15), %ecx
movl %ecx, 0x34(%r15)
movl %eax, 0x3c(%r15)
movq (%r15), %r15
testq %r15, %r15
jne 0x2d493
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafSrcDb
void mafSrcDb(char *name, char *retDb, int retDbSize)
/* Parse out just database part of name (up to but not including
 * first dot). If dot found, return entire name */
{
int len;
char *e = strchr(name, '.');
/* Put prefix up to dot into buf. */
len = (e == NULL ? strlen(name) : e - name);
if (len >= retDbSize)
     len = retDbSize-1;
memcpy(retDb, name, len);
retDb[len] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2e, %esi
callq 0x6270
testq %rax, %rax
je 0x2d538
subq %r14, %rax
jmp 0x2d540
movq %r14, %rdi
callq 0x62d0
leal -0x1(%r15), %ecx
cmpl %r15d, %eax
cmovll %eax, %ecx
movslq %ecx, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6570
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafColumnEmpty
boolean mafColumnEmpty(struct mafAli *maf, int col)
/* Return TRUE if the column is all '-' or '.' */
{
assert(col < maf->textSize);
struct mafComp *comp;
for (comp = maf->components; comp != NULL; comp = comp->next)
    if (comp->text != NULL)
        {
        char c = comp->text[col];
        if (c != '.' && c != '-')
            return FALSE;
        }
return TRUE;
}

// Assembly:
pushq %rax
cmpl %esi, 0x18(%rdi)
jle 0x2d5a2
movq 0x10(%rdi), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x2d5a0
movslq %esi, %rdx
movq 0x20(%rcx), %rsi
testq %rsi, %rsi
je 0x2d594
movb (%rsi,%rdx), %sil
addb $-0x2d, %sil
cmpb $0x1, %sil
ja 0x2d59e
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x2d57d
jmp 0x2d5a0
xorl %eax, %eax
popq %rcx
retq
leaq 0x64394(%rip), %rdi     # 0x9193d
leaq 0x643a1(%rip), %rsi     # 0x91951
leaq 0x643a4(%rip), %rcx     # 0x9195b
movl $0x315, %edx            # imm = 0x315
callq 0x6460
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafStripEmptyColumns
void mafStripEmptyColumns(struct mafAli *maf)
/* Remove columns that are all '-' or '.' from  maf. */
{
/* Selectively copy over non-empty columns. */
int readIx=0, writeIx = 0;
struct mafComp *comp;
for (readIx=0; readIx < maf->textSize; ++readIx)
    {
    if (!mafColumnEmpty(maf, readIx))
        {
        for (comp = maf->components; comp != NULL; comp = comp->next) 
            {
            if(comp->text != NULL)
                comp->text[writeIx] = comp->text[readIx];
            if (comp->quality != NULL)
                comp->quality[writeIx] = comp->quality[readIx];
            }
        ++writeIx;
        }
    }
/* Zero terminate text, and update textSize. */
for (comp = maf->components; comp != NULL; comp = comp->next)
    {
    if (comp->text != NULL)
        comp->text[writeIx] = 0;
    if (comp->quality != NULL)
        comp->quality[writeIx] = 0;
    }
maf->textSize = writeIx;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x2d628
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2d566
testl %eax, %eax
jne 0x2d61a
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2d618
movslq %ebp, %rcx
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x2d5ff
movb (%rdx,%r14), %sil
movb %sil, (%rdx,%rcx)
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x2d610
movb (%rdx,%r14), %sil
movb %sil, (%rdx,%rcx)
movq (%rax), %rax
testq %rax, %rax
jne 0x2d5ee
incl %ebp
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x2d5d3
jmp 0x2d62a
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2d658
movslq %ebp, %rcx
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x2d643
movb $0x0, (%rdx,%rcx)
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x2d650
movb $0x0, (%rdx,%rcx)
movq (%rax), %rax
testq %rax, %rax
jne 0x2d636
movl %ebp, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafRegDefNew
struct mafRegDef *mafRegDefNew(char *type, int size, char *id)
/* construct a new mafRegDef object */
{
struct mafRegDef *mrd;
AllocVar(mrd);
if (sameString(type, mafRegDefTxUpstream))
    mrd->type = mafRegDefTxUpstream;
else
    errAbort("invalid mafRefDef type: %s", type);
mrd->size = size;
mrd->id = cloneString(id);
return mrd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl $0x18, %edi
callq 0x2dc95
movq %rax, %r14
movq 0x93574(%rip), %r12     # 0xc0bf8
movq %r15, %rdi
movq %r12, %rsi
callq 0x6a50
testl %eax, %eax
je 0x2d6a6
leaq 0x642ea(%rip), %rdi     # 0x91984
movq %r15, %rsi
xorl %eax, %eax
callq 0x26b6f
jmp 0x2d6a9
movq %r12, (%r14)
movl %ebp, 0x8(%r14)
movq %rbx, %rdi
callq 0x1f9f6
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafCompClone
struct mafComp *mafCompClone(struct mafComp *srcComp)
/* clone a mafComp */
{
struct mafComp *comp;
AllocVar(comp);
comp->src = cloneString(srcComp->src);
comp->srcSize = srcComp->srcSize;
comp->strand = srcComp->strand;
comp->start = srcComp->start;
comp->size = srcComp->size;
comp->text = cloneString(srcComp->text);
comp->quality = cloneString(srcComp->quality);
comp->leftStatus = srcComp->leftStatus;
comp->leftLen = srcComp->leftLen;
comp->rightStatus = srcComp->rightStatus;
comp->rightLen = srcComp->rightLen;
return comp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40, %edi
callq 0x2dc95
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x1f9f6
movq %rax, 0x8(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
movb 0x14(%rbx), %al
movb %al, 0x14(%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
movl 0x1c(%rbx), %eax
movl %eax, 0x1c(%r14)
movq 0x20(%rbx), %rdi
callq 0x1f9f6
movq %rax, 0x20(%r14)
movq 0x28(%rbx), %rdi
callq 0x1f9f6
movq %rax, 0x28(%r14)
movb 0x30(%rbx), %al
movb %al, 0x30(%r14)
movl 0x34(%rbx), %eax
movl %eax, 0x34(%r14)
movb 0x38(%rbx), %al
movb %al, 0x38(%r14)
movl 0x3c(%rbx), %eax
movl %eax, 0x3c(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/maf.c
// Function: mafAliClone
struct mafAli *mafAliClone(struct mafAli *srcAli)
/* clone a mafAli */
{
struct mafAli *ali;
AllocVar(ali);
ali->score = srcAli->score;
struct mafComp *srcComp;
for (srcComp = srcAli->components; srcComp != NULL; srcComp = srcComp->next)
    slAddHead(&ali->components, mafCompClone(srcComp));
slReverse(&ali->components);
ali->textSize = srcAli->textSize;
if (srcAli->regDef != NULL)
    ali->regDef = mafRegDefClone(srcAli->regDef);
return ali;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x28, %edi
callq 0x2dc95
movq %rax, %rbx
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x2d798
movq %r15, %rdi
callq 0x2d6d9
movq 0x10(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
movq (%r15), %r15
jmp 0x2d77b
movq %rbx, %rdi
addq $0x10, %rdi
callq 0x1fcb3
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2d7c7
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
callq 0x2d660
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/mafFromAxt.c
// Function: mafFromAxt
struct mafAli *mafFromAxt(struct axt *axt, int tSize, 
	char *tPrefix, int qSize, char *qPrefix)
/* Make up a maf file from axt.  Slower than mafFromAxtTemp,
 * but the axt and maf are independent afterwards. */
{
struct mafAli *maf;
struct mafComp *mc;
char name[256];
AllocVar(maf);
maf->score = axt->score;
maf->textSize = axt->symCount;
AllocVar(mc);
if (qPrefix == NULL)
    mc->src = cloneString(axt->qName);
else
    {
    safef(name, sizeof(name), "%s.%s", qPrefix, axt->qName);
    mc->src = cloneString(name);
    }
mc->srcSize = qSize;
mc->strand = axt->qStrand;
mc->start = axt->qStart;
mc->size = axt->qEnd - axt->qStart;
mc->text = cloneStringZ(axt->qSym, axt->symCount);
slAddHead(&maf->components, mc);
AllocVar(mc);
if (tPrefix == NULL)
    mc->src = cloneString(axt->tName);
else
    {
    safef(name, sizeof(name), "%s.%s", tPrefix, axt->tName);
    mc->src = cloneString(name);
    }
mc->srcSize = tSize;
mc->strand = axt->tStrand;
mc->start = axt->tStart;
mc->size = axt->tEnd - axt->tStart;
mc->text = cloneStringZ(axt->tSym, axt->symCount);
slAddHead(&maf->components, mc);
return maf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %r8, %rbp
movl %ecx, %r13d
movq %rdx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movl $0x28, %edi
callq 0x2dc95
cvtsi2sdl 0x34(%r14), %xmm0
movq %rax, %rbx
movsd %xmm0, 0x8(%rax)
movl 0x38(%r14), %eax
movl %eax, 0x18(%rbx)
movl $0x40, %edi
callq 0x2dc95
movq %rax, %r12
movq 0x8(%r14), %r8
testq %rbp, %rbp
je 0x2d94c
leaq 0x640a6(%rip), %rdx     # 0x919d6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rcx
xorl %eax, %eax
callq 0x23c18
movq %r15, %rdi
jmp 0x2d94f
movq %r8, %rdi
callq 0x1f9f6
movq %rax, 0x8(%r12)
movl %r13d, 0x10(%r12)
movb 0x18(%r14), %al
movb %al, 0x14(%r12)
movl 0x10(%r14), %eax
movl %eax, 0x18(%r12)
movl 0x14(%r14), %ecx
subl %eax, %ecx
movl %ecx, 0x1c(%r12)
movq 0x40(%r14), %rdi
movl 0x38(%r14), %esi
callq 0x1f9a7
movq %rax, 0x20(%r12)
movq 0x10(%rbx), %rax
movq %rax, (%r12)
movq %r12, 0x10(%rbx)
movl $0x40, %edi
callq 0x2dc95
movq %rax, %r12
movq 0x20(%r14), %r8
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x2d9d4
leaq 0x6401b(%rip), %rdx     # 0x919d6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x23c18
movq %r15, %rdi
jmp 0x2d9d7
movq %r8, %rdi
callq 0x1f9f6
movq %rax, 0x8(%r12)
movl 0x4(%rsp), %eax
movl %eax, 0x10(%r12)
movb 0x30(%r14), %al
movb %al, 0x14(%r12)
movl 0x28(%r14), %eax
movl %eax, 0x18(%r12)
movl 0x2c(%r14), %ecx
subl %eax, %ecx
movl %ecx, 0x1c(%r12)
movq 0x48(%r14), %rdi
movl 0x38(%r14), %esi
callq 0x1f9a7
movq %rax, 0x20(%r12)
movq 0x10(%rbx), %rax
movq %rax, (%r12)
movq %r12, 0x10(%rbx)
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/memalloc.c
// Function: carefulCheckHeap
void carefulCheckHeap()
/* Walk through allocated memory and make sure that all cookies are
 * in place. */
{
int maxPieces = 10000000;    /* Assume no more than this many pieces allocated. */
struct carefulMemBlock *cmb;
char *pEndCookie;
size_t size;
char errMsg[1024];
boolean errFound = FALSE;

if (carefulParent == NULL)
    return;

pthread_mutex_lock( &carefulMutex );
for (cmb = (struct carefulMemBlock *)(cmbAllocedList->head); cmb->next != NULL; cmb = cmb->next)
    {
    size = cmb->size;
    pEndCookie = (((char *)(cmb+1)) + size);
    if (cmb->startCookie != cmbStartCookie)
	{
        safef(errMsg, sizeof errMsg, "Bad start cookie %x checking %llx\n", cmb->startCookie,
                 ptrToLL(cmb+1));
	errFound = TRUE;
	break;
	}
    if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
	{
        safef(errMsg, sizeof errMsg, "Bad end cookie %x%x%x%x checking %llx\n", 
                 pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
                 ptrToLL(cmb+1));
	errFound = TRUE;
	break;
	}
    if (--maxPieces == 0)
	{
        safef(errMsg, sizeof errMsg, "Loop or more than 10000000 pieces in memory list");
	errFound = TRUE;
	break;
	}
    }
pthread_mutex_unlock( &carefulMutex );
if (errFound)
    errAbort("%s", errMsg);
}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
cmpq $0x0, 0x9591b(%rip)     # 0xc3698
je 0x2de6b
leaq 0x95916(%rip), %rdi     # 0xc36a0
callq 0x6ae0
movq 0x95932(%rip), %rax     # 0xc36c8
movq (%rax), %r10
movl $0xff676980, %eax       # imm = 0xFF676980
movl 0x92e8c(%rip), %edx     # 0xc0c30
movq (%r10), %rsi
testq %rsi, %rsi
je 0x2dde4
movl 0x14(%r10), %ecx
cmpl %edx, %ecx
jne 0x2ddf7
movslq 0x10(%r10), %rdi
movl 0x18(%r10,%rdi), %ecx
cmpl 0x92e71(%rip), %ecx     # 0xc0c34
jne 0x2de15
movq %rsi, %r10
incl %eax
jne 0x2dda4
leaq 0x63e9a(%rip), %rdx     # 0x91c6d
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x23c18
jmp 0x2de4e
leaq 0x958b5(%rip), %rdi     # 0xc36a0
addq $0x408, %rsp            # imm = 0x408
jmp 0x64f0
incq %r10
leaq 0x63e22(%rip), %rdx     # 0x91c23
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r10, %r8
xorl %eax, %eax
callq 0x23c18
jmp 0x2de4e
movsbl 0x18(%r10,%rdi), %ecx
movsbl 0x19(%r10,%rdi), %r8d
movsbl 0x1a(%r10,%rdi), %r9d
movsbl 0x1b(%r10,%rdi), %r11d
incq %r10
leaq 0x63e0f(%rip), %rdx     # 0x91c46
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x23c18
addq $0x10, %rsp
leaq 0x9584b(%rip), %rdi     # 0xc36a0
callq 0x64f0
leaq 0x62338(%rip), %rdi     # 0x90199
movq %rsp, %rsi
xorl %eax, %eax
callq 0x26b6f
addq $0x408, %rsp            # imm = 0x408
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/memalloc.c
// Function: carefulCountBlocksAllocated
int carefulCountBlocksAllocated()
/* How many memory items are allocated? */
{
pthread_mutex_lock( &carefulMutex );
int result = dlCount(cmbAllocedList);
pthread_mutex_unlock( &carefulMutex );
return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x95823(%rip), %rbx     # 0xc36a0
movq %rbx, %rdi
callq 0x6ae0
movq 0x9583c(%rip), %rdi     # 0xc36c8
callq 0x24865
movl %eax, %ebp
movq %rbx, %rdi
callq 0x64f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/memalloc.c
// Function: carefulTotalAllocated
size_t carefulTotalAllocated()
/* Return total bases allocated */
{
pthread_mutex_lock( &carefulMutex );
size_t result = carefulAlloced;
pthread_mutex_unlock( &carefulMutex );
return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x957f1(%rip), %rbx     # 0xc36a0
movq %rbx, %rdi
callq 0x6ae0
movq 0x95812(%rip), %r14     # 0xc36d0
movq %rbx, %rdi
callq 0x64f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/memalloc.c
// Function: carefulFree
static void carefulFree(void *vpt)
/* Check cookies and free. */
{
pthread_mutex_lock( &carefulMutex );
struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
size_t size = cmb->size;
char *pEndCookie;

carefulAlloced -= size;
pEndCookie = (((char *)(cmb+1)) + size);
if (cmb->startCookie != cmbStartCookie)
    {
    pthread_mutex_unlock( &carefulMutex );
    errAbort("Bad start cookie %x freeing %llx\n", cmb->startCookie,
             ptrToLL(vpt));
    }
if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
    {
    pthread_mutex_unlock( &carefulMutex );
    errAbort("Bad end cookie %x%x%x%x freeing %llx\n", 
        pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
             ptrToLL(vpt));
    }
dlRemove((struct dlNode *)cmb);
carefulParent->free(cmb);
pthread_mutex_unlock( &carefulMutex );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x954ac(%rip), %rdi     # 0xc36a0
callq 0x6ae0
movslq -0x8(%rbx), %r14
subq %r14, 0x954cc(%rip)     # 0xc36d0
movl -0x4(%rbx), %eax
cmpl 0x92a23(%rip), %eax     # 0xc0c30
je 0x2e22f
leaq 0x9548a(%rip), %rdi     # 0xc36a0
callq 0x64f0
movl -0x4(%rbx), %esi
leaq 0x63b00(%rip), %rdi     # 0x91d25
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26b6f
movl (%rbx,%r14), %eax
cmpl 0x929fb(%rip), %eax     # 0xc0c34
je 0x2e26f
leaq 0x9545e(%rip), %rdi     # 0xc36a0
callq 0x64f0
movsbl (%rbx,%r14), %esi
movsbl 0x1(%rbx,%r14), %edx
movsbl 0x2(%rbx,%r14), %ecx
movsbl 0x3(%rbx,%r14), %r8d
leaq 0x63ae2(%rip), %rdi     # 0x91d47
movq %rbx, %r9
xorl %eax, %eax
callq 0x26b6f
addq $-0x18, %rbx
movq %rbx, %rdi
callq 0x247bc
movq 0x95416(%rip), %rax     # 0xc3698
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x95411(%rip), %rdi     # 0xc36a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64f0
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: setReadWriteTimeouts
int setReadWriteTimeouts(int sd, int seconds)
/* Set read and write timeouts on socket sd 
 * Return -1 if there are any errors, 0 if successful. */
{
struct timeval timeout;      
timeout.tv_sec = seconds;
timeout.tv_usec = 0;

if (setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
    {
    warn("setsockopt failed setting socket receive timeout\n");
    return -1;
    }

if (setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
    {
    warn("setsockopt failed setting socket send timeout\n");
    return -1;
    }
return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movslq %esi, %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
movl $0x1, %esi
movl $0x14, %edx
movl $0x10, %r8d
callq 0x6d80
testl %eax, %eax
js 0x2e330
movq %rsp, %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x15, %edx
movl $0x10, %r8d
callq 0x6d80
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x2e343
leaq 0x63a71(%rip), %rdi     # 0x91d9f
jmp 0x2e337
leaq 0x63a36(%rip), %rdi     # 0x91d6d
xorl %eax, %eax
callq 0x268ca
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netMustConnect
int netMustConnect(char *hostName, int port)
/* Start connection with server or die. */
{
int sd = netConnect(hostName, port);
if (sd < 0)
   noWarnAbort();
return sd;
}

// Assembly:
pushq %rbx
callq 0x2e349
movl %eax, %ebx
testl %eax, %eax
jns 0x2e672
xorl %eax, %eax
callq 0x26c27
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netAcceptingSocketFrom
int netAcceptingSocketFrom(int port, int queueSize, char *host)
/* Create a socket that can accept connections from a 
 * IP address on the current machine if the current machine
 * has multiple IP addresses. */
{
struct sockaddr_in sai;
int sd;
int flag = 1;

netBlockBrokenPipes();
if ((sd = netStreamSocket()) < 0)
    return sd;
if (!internetFillInAddress(host, port, &sai))
    return -1;
if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int)))
    return -1;
if (bind(sd, (struct sockaddr*)&sai, sizeof(sai)) == -1)
    {
    warn("Couldn't bind socket to %d: %s", port, strerror(errno));
    close(sd);
    return -1;
    }
listen(sd, queueSize);
return sd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %ebx
movl $0x1, 0x4(%rsp)
cmpb $0x0, 0x95012(%rip)     # 0xc3700
jne 0x2e706
movl $0x1, %esi
movl $0xd, %edi
callq 0x6890
movb $0x1, 0x94ffa(%rip)     # 0xc3700
callq 0x3132b
movl %eax, %ebp
testl %eax, %eax
js 0x2e76a
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4a78e
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x2e76d
leaq 0x4(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x6d80
testl %eax, %eax
jne 0x2e76d
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
movl $0x10, %edx
callq 0x6140
cmpl $-0x1, %eax
je 0x2e77b
movl %ebp, %edi
movl %r15d, %esi
callq 0x6820
movl %ebp, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x6366e(%rip), %rdi     # 0x91dfc
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x268ca
movl %ebp, %edi
callq 0x6e80
jmp 0x2e76d
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netAcceptFrom
int netAcceptFrom(int acceptor, unsigned char subnet[4])
/* Wait for incoming connection from socket descriptor
 * from IP address in subnet.  Subnet is something
 * returned from netParseSubnet or internetParseDottedQuad. 
 * Subnet may be NULL. */
{
struct sockaddr_in sai;		/* Some system socket info. */
ZeroVar(&sai);
sai.sin_family = AF_INET;
for (;;)
    {
    socklen_t addrSize = sizeof(sai);
    int sd = accept(acceptor, (struct sockaddr *)&sai, &addrSize);
    if (sd >= 0)
	{
	if (subnet == NULL)
	    return sd;
	else
	    {
	    unsigned char unpacked[4]; 
	    internetUnpackIp(ntohl(sai.sin_addr.s_addr), unpacked);
	    if (internetIpInSubnet(unpacked, subnet))
		{
		return sd;
		}
	    else
		{
		close(sd);
		}
	    }
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movw $0x2, (%r14)
testq %rbx, %rbx
sete %r12b
movl $0x10, 0x8(%rsp)
movl %ebp, %edi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x61f0
movl %eax, %r13d
testl %eax, %eax
sets %cl
cmovsl %r15d, %eax
orb %r12b, %cl
je 0x2e819
shrl $0x1f, %r13d
movl %eax, %r15d
movl %r13d, %r12d
jmp 0x2e84c
movl 0x14(%rsp), %edi
bswapl %edi
leaq 0xc(%rsp), %r12
movq %r12, %rsi
callq 0x4a880
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4a893
testl %eax, %eax
sete %r12b
je 0x2e844
movl %r13d, %r15d
jmp 0x2e84c
movl %r13d, %edi
callq 0x6e80
testb %r12b, %r12b
jne 0x2e7de
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netFileFromSocket
FILE *netFileFromSocket(int socket)
/* Wrap a FILE around socket.  This should be fclose'd
 * and separately the socket close'd. */
{
FILE *f;
if ((socket = dup(socket)) < 0)
   errnoAbort("Couldn't dupe socket in netFileFromSocket");
f = fdopen(socket, "r+");
if (f == NULL)
   errnoAbort("Couldn't fdopen socket in netFileFromSocket");
return f;
}

// Assembly:
pushq %rbx
callq 0x6b60
movl %eax, %ebx
testl %eax, %eax
jns 0x2e87d
leaq 0x635a5(%rip), %rdi     # 0x91e1b
xorl %eax, %eax
callq 0x26c9f
leaq 0x635c1(%rip), %rsi     # 0x91e45
movl %ebx, %edi
callq 0x6760
movq %rax, %rbx
testq %rax, %rax
jne 0x2e8a1
leaq 0x635ae(%rip), %rdi     # 0x91e48
xorl %eax, %eax
callq 0x26c9f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netReadAll
ssize_t netReadAll(int sd, void *vBuf, ssize_t size)
/* Read given number of bytes into buffer.
 * Don't give up on first read! */
{
char *buf = vBuf;
ssize_t totalRead = 0;
int oneRead;

if (!plumberInstalled)
    netBlockBrokenPipes();
while (totalRead < size)
    {
    oneRead = read(sd, buf + totalRead, size - totalRead);
    if (oneRead < 0)
	return oneRead;
    if (oneRead == 0)
        break;
    totalRead += oneRead;
    }
return totalRead;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
cmpb $0x0, 0x94e1f(%rip)     # 0xc3700
jne 0x2e8f9
movl $0x1, %esi
movl $0xd, %edi
callq 0x6890
movb $0x1, 0x94e07(%rip)     # 0xc3700
xorl %r15d, %r15d
testq %rbx, %rbx
jle 0x2e92a
leaq (%r14,%r15), %rsi
movq %rbx, %rdx
subq %r15, %rdx
movl %ebp, %edi
callq 0x6aa0
testl %eax, %eax
js 0x2e927
je 0x2e92a
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
cmpq %rbx, %r15
jl 0x2e901
jmp 0x2e92a
movslq %eax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netMustReadAll
ssize_t netMustReadAll(int sd, void *vBuf, ssize_t size)
/* Read given number of bytes into buffer or die.
 * Don't give up if first read is short! */
{
ssize_t ret = netReadAll(sd, vBuf, size);
if (ret < 0)
    errnoAbort("Couldn't finish netReadAll");
return ret;
}

// Assembly:
pushq %rbx
callq 0x2e8cb
movq %rax, %rbx
testq %rax, %rax
jns 0x2e954
leaq 0x63527(%rip), %rdi     # 0x91e74
xorl %eax, %eax
callq 0x26c9f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netParseSubnet
void netParseSubnet(char *in, unsigned char out[4])
/* Parse subnet, which is a prefix of a normal dotted quad form.
 * Out will contain 255's for the don't care bits. */
{
out[0] = out[1] = out[2] = out[3] = 255;
if (in != NULL)
    {
    char *snsCopy = strdup(in);
    char *words[5];
    int wordCount, i;
    wordCount = chopString(snsCopy, ".", words, ArraySize(words));
    if (wordCount > 3 || wordCount < 1)
        notGoodSubnet(in);
    for (i=0; i<wordCount; ++i)
	{
	char *s = words[i];
	int x;
	if (!isdigit(s[0]))
	    notGoodSubnet(in);
	x = atoi(s);
	if (x > 255)
	    notGoodSubnet(in);
	out[i] = x;
	}
    freez(&snsCopy);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2ea31
movq %rdi, %r14
callq 0x6dd0
movq %rax, 0x8(%rsp)
leaq 0x61efa(%rip), %rsi     # 0x90888
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
movl $0x5, %ecx
callq 0x22314
movl %eax, %r12d
leal -0x4(%r12), %eax
cmpl $-0x4, %eax
ja 0x2e9be
leaq 0x63dd4(%rip), %rdi     # 0x92788
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
testl %r12d, %r12d
jle 0x2ea27
callq 0x6790
movq %rax, %r15
movl %r12d, %r12d
xorl %ebx, %ebx
movq 0x10(%rsp,%rbx,8), %r13
movq (%r15), %rax
movsbq (%r13), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x2e9f5
leaq 0x63d9d(%rip), %rdi     # 0x92788
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r13, %rdi
callq 0x6bd0
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jl 0x2ea17
leaq 0x63d7b(%rip), %rdi     # 0x92788
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq (%rsp), %rax
movb %bpl, (%rax,%rbx)
incq %rbx
cmpq %rbx, %r12
jne 0x2e9d0
leaq 0x8(%rsp), %rdi
callq 0x2dd51
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: parseByteRange
static void parseByteRange(char *url, ssize_t *rangeStart, ssize_t *rangeEnd, boolean terminateAtByteRange)
/* parse the byte range information from url */
{
char *x;
/* default to no byte range specified */
*rangeStart = -1;
*rangeEnd = -1;
x = strrchr(url, ';');
if (x)
    {
    if (startsWith(";byterange=", x))
	{
	char *y=strchr(x, '=');
	++y;
	char *z=strchr(y, '-');
	if (z)
	    {
	    ++z;
	    if (terminateAtByteRange)
		*x = 0;
	    // TODO: use something better than atoll() ?
	    *rangeStart = atoll(y); 
	    if (z[0] != '\0')
		*rangeEnd = atoll(z);
	    }    
	}
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq $-0x1, %rax
movq %rax, (%rsi)
movq %rax, (%rdx)
movl $0x3b, %esi
callq 0x67c0
testq %rax, %rax
je 0x2ee4f
movq %rax, %r15
leaq 0x631c5(%rip), %rdi     # 0x91fb8
movq %rax, %rsi
callq 0x217c8
testl %eax, %eax
je 0x2ee4f
movq %r15, %rdi
movl $0x3d, %esi
callq 0x6270
movq %rax, %r13
incq %r13
movq %r13, %rdi
movl $0x2d, %esi
callq 0x6270
testq %rax, %rax
je 0x2ee4f
movq %rax, %r12
incq %r12
testl %ebp, %ebp
je 0x2ee32
movb $0x0, (%r15)
movq %r13, %rdi
callq 0x6520
movq %rax, (%r14)
cmpb $0x0, (%r12)
je 0x2ee4f
movq %r12, %rdi
callq 0x6520
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: netWaitForData
int netWaitForData(int sd, int microseconds)
/* Wait for descriptor to have some data to read, up to given number of
 * microseconds.  Returns amount of data there or zero if timed out. */
{
struct timeval tv;
fd_set set;
int readyCount;

for (;;)
    {
    if (microseconds >= 1000000)
	{
	tv.tv_sec = microseconds/1000000;
	tv.tv_usec = microseconds%1000000;
	}
    else
	{
	tv.tv_sec = 0;
	tv.tv_usec = microseconds;
	}
    FD_ZERO(&set);
    FD_SET(sd, &set);
    readyCount = select(sd+1, &set, NULL, NULL, &tv);
    if (readyCount < 0) 
	{
	if (errno == EINTR)	/* Select interrupted, not timed out. */
	    continue;
    	else 
    	    warn("select failure %s", strerror(errno));
    	}
    else
	{
    	return readyCount;	/* Zero readyCount indicates time out */
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edi, %ebx
leal 0x3f(%rbx), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %r13d
shlq %cl, %r13
movl %esi, %ebp
sarl $0x6, %eax
movslq %eax, %r12
incl %ebx
movslq %esi, %r15
movl %r15d, %eax
imulq $0x431bde83, %rax, %r14 # imm = 0x431BDE83
shrq $0x32, %r14
imull $0xf4240, %r14d, %eax   # imm = 0xF4240
movq %r15, 0x18(%rsp)
subl %eax, %r15d
cmpl $0xf4240, %ebp          # imm = 0xF4240
jl 0x2f07a
movq %r14, 0x8(%rsp)
movq %r15, 0x10(%rsp)
jmp 0x2f08d
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
orq %r13, 0x20(%rsp,%r12,8)
movl %ebx, %edi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq 0x8(%rsp), %r8
callq 0x66b0
testl %eax, %eax
jns 0x2f107
callq 0x6060
movl (%rax), %edi
cmpl $0x4, %edi
je 0x2f066
callq 0x6230
leaq 0x62dfa(%rip), %rdi     # 0x91ef2
movq %rax, %rsi
xorl %eax, %eax
callq 0x268ca
jmp 0x2f066
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: openFtpControlSocket
static int openFtpControlSocket(char *host, int port, char *user, char *password)
/* Open a socket to host,port; authenticate anonymous ftp; set type to I; 
 * return socket desc or -1 if there was an error. */
{
int sd = netConnect(host, port);
if (sd < 0)
    return -1;

/* First read the welcome msg */
if (readReadyWait(sd, NET_FTP_TIMEOUT))
    sendFtpCommand(sd, "", NULL, NULL);

char cmd[256];
int retCode = 0;
safef(cmd,sizeof(cmd),"USER %s\r\n", user);
if (!sendFtpCommand(sd, cmd, NULL, &retCode))
    {
    close(sd);
    return -1;
    }

if (retCode == 331)
    {
    safef(cmd,sizeof(cmd),"PASS %s\r\n", password);
    if (!sendFtpCommand(sd, cmd, NULL, NULL))
	{
	close(sd);
	return -1;
	}
    }

if (!sendFtpCommand(sd, "TYPE I\r\n", NULL, NULL))
    {
    close(sd);
    return -1;
    }
/* 200 Type set to I */
/* (send the data as binary, so can support compressed files) */
return sd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rcx, %r14
movq %rdx, %r15
callq 0x2e349
testl %eax, %eax
js 0x2f4d4
movl %eax, %ebx
movl %eax, %edi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2f00f
testl %eax, %eax
je 0x2f43f
leaq 0x68f2c(%rip), %rsi     # 0x98360
movl %ebx, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f4ec
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x633ac(%rip), %rdx     # 0x927ff
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rcx
xorl %eax, %eax
callq 0x23c18
movl %ebx, %edi
movq %r13, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2f4ec
testl %eax, %eax
je 0x2f4cd
cmpl $0x14b, 0xc(%rsp)       # imm = 0x14B
jne 0x2f4b7
leaq 0x6337b(%rip), %rdx     # 0x92809
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
xorl %eax, %eax
callq 0x23c18
movl %ebx, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f4ec
testl %eax, %eax
je 0x2f4cd
leaq 0x63355(%rip), %rsi     # 0x92813
movl %ebx, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2f4ec
testl %eax, %eax
jne 0x2f4d9
movl %ebx, %edi
callq 0x6e80
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: connectNpu
int connectNpu(struct netParsedUrl npu, char *url, boolean noProxy)
/* Connect using NetParsedUrl. */
{
int sd = -1;
if (sameString(npu.protocol, "http"))
    {
    sd = netConnect(npu.host, atoi(npu.port));
    }
else if (sameString(npu.protocol, "https"))
    {
    sd = netConnectHttps(npu.host, atoi(npu.port), noProxy);
    }
else
    {
    errAbort("netHttpConnect: url (%s) is not for http.", url);
    return -1;  /* never gets here, fixes compiler complaint */
    }
return sd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x20(%rsp), %rdi
movl $0x70747468, %eax       # imm = 0x70747468
movl (%rdi), %ecx
xorl %eax, %ecx
movzbl 0x4(%rdi), %edx
orl %ecx, %edx
je 0x2f56e
xorl (%rdi), %eax
movzwl 0x4(%rdi), %ecx
xorl $0x73, %ecx
orl %eax, %ecx
je 0x2f58d
leaq 0x629e0(%rip), %rdi     # 0x91f40
xorl %eax, %eax
callq 0x26b6f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2f5ac
leaq 0x1010(%rdi), %rbx
addq $0x1810, %rdi           # imm = 0x1810
callq 0x6bd0
movq %rbx, %rdi
movl %eax, %esi
callq 0x2e349
jmp 0x2f5ac
leaq 0x1010(%rdi), %r14
addq $0x1810, %rdi           # imm = 0x1810
callq 0x6bd0
movq %r14, %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x4a581
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: setAuthorization
void setAuthorization(struct netParsedUrl npu, char *authHeader, struct dyString *dy)
/* Set the specified authorization header with BASIC auth base64-encoded user and password */
{
if (!sameString(npu.user,""))
    {
    char up[256];
    char *b64up = NULL;
    safef(up, sizeof(up), "%s:%s", npu.user, npu.password);
    b64up = base64Encode(up, strlen(up));
    dyStringPrintf(dy, "%s: Basic %s\r\n", authHeader, b64up);
    freez(&b64up);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
cmpb $0x0, 0x150(%rsp)
je 0x2f645
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x140(%rsp), %r8
leaq 0x150(%rsp), %rcx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
addq $0x810, %r8             # imm = 0x810
leaq 0x633cd(%rip), %rdx     # 0x929c9
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x23c18
movq %r12, %rdi
callq 0x62d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x42a2c
movq %rax, (%r15)
leaq 0x6293d(%rip), %rsi     # 0x91f6a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2656a
movq %r15, %rdi
callq 0x2dd51
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/net.c
// Function: checkNoProxy
boolean checkNoProxy(char *host)
/* See if host endsWith element on no_proxy list. Elements are comma-separated. */
{
char *list = cloneString(getenv("no_proxy"));
if (!list)
    return FALSE;
replaceChar(list, ',', ' ');
char *word;
while((word=nextWord(&list)))
    {
    if (endsWith(host, word))
	return TRUE;
    }
return FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x62913(%rip), %rdi     # 0x91f79
callq 0x68f0
movq %rax, %rdi
callq 0x1f9f6
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
testq %rax, %rax
je 0x2f6b7
movq %rax, %rdi
movl $0x2c, %esi
movl $0x20, %edx
callq 0x21d44
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x229cd
testq %rax, %rax
je 0x2f6b7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21aed
testl %eax, %eax
je 0x2f696
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq