LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafCompGetSrcDb
char *mafCompGetSrcDb(struct mafComp *mc, char *buf, int bufSize)
/* parse the srcDb name from the mafComp src name, return NULL if no srcDb */
{
char *e = strchr(mc->src, '.');
if (e == NULL)
    return NULL;
int len = e - mc->src;
if (len >= bufSize-1)
    errAbort("srcDb name in \"%s\" overflows buffer length of %d", mc->src, bufSize);
strncpy(buf, mc->src, len);
buf[len] = '\0';
return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %r14
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x27d4c
movq %rax, %r15
subq %r14, %r15
leal -0x1(%r13), %eax
cmpl %r15d, %eax
jg 0x27d34
leaq 0x58b7d(%rip), %rdi     # 0x8089f
movq %r14, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x223fb
movq 0x8(%r12), %r14
movslq %r15d, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6380
movb $0x0, (%rbx,%r15)
jmp 0x27d4e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafAliFree
void mafAliFree(struct mafAli **pObj)
/* Free up a maf alignment. */
{
struct mafAli *obj = *pObj;
if (obj == NULL)
    return;
mafCompFreeList(&obj->components);
mafRegDefFree(&obj->regDef);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x27dc4
movq %rdi, %rbx
leaq 0x10(%r14), %rdi
callq 0x27cad
addq $0x20, %r14
movq %r14, %rdi
callq 0x27dcc
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: mafRegDefFree
void mafRegDefFree(struct mafRegDef **mrdPtr)
/* Free a mafRegDef object */
{
struct mafRegDef *mrd = *mrdPtr;
if (mrd != NULL)
    {
    freeMem(mrd->id);
    freeMem(mrd);
    *mrdPtr = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x27df0
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x28c2d
movq %r14, %rdi
callq 0x28c2d
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/maf.c
// Function: mafAliFreeList
void mafAliFreeList(struct mafAli **pList)
/* Free up a list of maf alignmentx. */
{
struct mafAli *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafAliFree(&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 0x27e23
movq (%r15), %r15
movq %r14, %rdi
callq 0x27d91
jmp 0x27e0c
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27e6d
movq %rdi, %rbx
leaq 0x20(%r14), %rdi
callq 0x25cd8
movq 0x10(%r14), %rdi
callq 0x28c2d
addq $0x18, %r14
movq %r14, %rdi
callq 0x27df8
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: 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
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x27ea0
movq (%r15), %r15
movq %r14, %rdi
callq 0x27e31
jmp 0x27e89
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27f18
movq 0x8(%rax), %rcx
xorl %edi, %edi
movb (%rcx,%rdi), %dl
movb (%rsi,%rdi), %r8b
testb %dl, %dl
je 0x27f13
cmpb %r8b, %dl
jne 0x27f09
incq %rdi
jmp 0x27ef4
movl %edx, %ecx
xorb $0x2e, %cl
orb %r8b, %cl
je 0x27f18
cmpb %r8b, %dl
jne 0x27ee6
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x27eae
movq %rax, %r14
testq %rax, %rax
jne 0x27f3e
leaq 0x5899c(%rip), %rdi     # 0x808d0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x62d0
addq $0x10, %rbx
movslq %eax, %r15
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x27f92
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1db41
testl %eax, %eax
je 0x27f67
movq 0x8(%rbx), %rax
movb (%rax,%r15), %al
testb %al, %al
je 0x27f94
cmpb %bpl, %al
jne 0x27f67
jmp 0x27f94
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27f49
movq %rax, %r14
testq %rax, %rax
jne 0x27fd0
movsbl %bpl, %edx
leaq 0x58925(%rip), %rdi     # 0x808e8
movq %rbx, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x223fb
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5f38b(%rip), %r8      # 0x8737d
cmovneq %rdx, %r8
leaq 0x58347(%rip), %rdx     # 0x80344
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 0x2802b
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1db41
testl %eax, %eax
je 0x28013
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27fd8
movq %rax, %r15
testq %rax, %rax
jne 0x28065
leaq 0x588b8(%rip), %rdi     # 0x80910
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/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, %r15
movq %rdi, %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x280f5
movq 0x8(%r14), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x6270
movq %rax, %r12
testq %rax, %rax
je 0x280dc
movb $0x0, (%r12)
movq 0x8(%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x244c6
testq %r12, %r12
je 0x280f0
movb %bl, (%r12)
testq %rax, %rax
je 0x280b5
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
callq 0x27f19
movq %rax, %rbx
cmpb $0x2d, 0x14(%rax)
jne 0x2839d
movl 0x10(%rbx), %edx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20d61
movl (%r14), %ebp
movl 0x18(%rbx), %ecx
cmpl %ecx, %ebp
jle 0x283a9
pushq $0x1
popq %rax
jmp 0x283b5
addl 0x1c(%rbx), %ecx
xorl %eax, %eax
cmpl %ecx, 0x8(%rsp)
setl %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
leaq 0x10(%rdi), %r15
leaq 0xc(%rsp), %r14
movq (%r15), %r15
testq %r15, %r15
je 0x2844e
leaq 0x18(%r15), %rdi
movl 0x1c(%r15), %eax
addl 0x18(%r15), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%r15), %edx
movq %r14, %rsi
callq 0x20d61
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x28409
movslq 0x18(%rbx), %rsi
callq 0x20d38
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x2841b
movslq 0x18(%rbx), %rsi
callq 0x1c3c3
cmpb $0x2d, 0x14(%r15)
movb 0x30(%r15), %al
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)
jmp 0x283d3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2e
popq %rsi
callq 0x6270
testq %rax, %rax
je 0x28478
subq %r14, %rax
jmp 0x28480
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_O2/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 0x284d6
addq $0x10, %rdi
movslq %esi, %rcx
pushq $0x1
popq %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x284d4
movq 0x20(%rdi), %rdx
testq %rdx, %rdx
je 0x284b6
movb (%rdx,%rcx), %dl
addb $-0x2d, %dl
cmpb $0x2, %dl
jb 0x284b6
xorl %eax, %eax
popq %rcx
retq
leaq 0x58450(%rip), %rdi     # 0x8092d
leaq 0x5845d(%rip), %rsi     # 0x80941
leaq 0x58460(%rip), %rcx     # 0x8094b
movl $0x315, %edx            # imm = 0x315
callq 0x6460
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
xorl %r14d, %r14d
xorl %ebp, %ebp
movslq 0x18(%rbx), %rax
movslq %ebp, %r12
cmpq %rax, %r14
jge 0x28576
movq %rbx, %rdi
movl %r14d, %esi
callq 0x284a6
testl %eax, %eax
jne 0x28555
movq %r15, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x28553
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x28540
movb (%rcx,%r14), %dl
movb %dl, (%rcx,%r12)
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x28527
movb (%rcx,%r14), %dl
movb %dl, (%rcx,%r12)
jmp 0x28527
incl %ebp
incq %r14
jmp 0x28509
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x28568
movb $0x0, (%rax,%r12)
movq 0x28(%r15), %rax
testq %rax, %rax
je 0x28576
movb $0x0, (%rax,%r12)
movq (%r15), %r15
testq %r15, %r15
jne 0x2855a
movl %ebp, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x28bb0
movq %rax, %r14
movq 0x8c64c(%rip), %r12     # 0xb4bf8
movq %r15, %rdi
movq %r12, %rsi
callq 0x6a50
testl %eax, %eax
je 0x285ce
leaq 0x583b2(%rip), %rdi     # 0x80974
movq %r15, %rsi
xorl %eax, %eax
callq 0x223fb
jmp 0x285d1
movq %r12, (%r14)
movl %ebp, 0x8(%r14)
movq %rbx, %rdi
callq 0x1c306
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/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
pushq $0x40
popq %rdi
callq 0x28bb0
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x1c306
movq %rax, 0x8(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
movb 0x14(%rbx), %al
movb %al, 0x14(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rbx), %rdi
callq 0x1c306
movq %rax, 0x20(%r14)
movq 0x28(%rbx), %rdi
callq 0x1c306
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_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x28bb0
movq %rax, %rbx
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x10(%r14), %r12
movq %rax, %r15
addq $0x10, %r15
movq (%r12), %r12
testq %r12, %r12
je 0x286bf
movq %r12, %rdi
callq 0x28601
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
jmp 0x286a3
movq %r15, %rdi
callq 0x1c567
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x286ea
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
callq 0x2858a
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %r12d
movq %rdx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x28bb0
cvtsi2sdl 0x34(%r14), %xmm0
movq %rax, %rbx
movsd %xmm0, 0x8(%rax)
movl 0x38(%r14), %eax
movl %eax, 0x18(%rbx)
pushq $0x40
popq %rdi
callq 0x28bb0
movq %rax, %r13
movq 0x8(%r14), %r8
testq %rbp, %rbp
je 0x2886e
leaq 0x58174(%rip), %rdx     # 0x809c6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1fab2
movq %r15, %rdi
jmp 0x28871
movq %r8, %rdi
callq 0x1c306
movq %rax, 0x8(%r13)
movl %r12d, 0x10(%r13)
movb 0x18(%r14), %al
movb %al, 0x14(%r13)
movl 0x10(%r14), %eax
movl %eax, 0x18(%r13)
movl 0x14(%r14), %ecx
subl %eax, %ecx
movl %ecx, 0x1c(%r13)
movq 0x40(%r14), %rdi
movl 0x38(%r14), %esi
callq 0x1c2a3
movq %rax, 0x20(%r13)
movq 0x10(%rbx), %rax
movq %rax, (%r13)
movq %r13, 0x10(%rbx)
pushq $0x40
popq %rdi
callq 0x28bb0
movq %rax, %r12
movq 0x20(%r14), %r8
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x288ee
leaq 0x580f1(%rip), %rdx     # 0x809c6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x1fab2
movq %r15, %rdi
jmp 0x288f1
movq %r8, %rdi
callq 0x1c306
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 0x1c2a3
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
// File: /workspace/github_c_makefile_star2_O2/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, 0x8ea52(%rip)     # 0xb76b8
je 0x28d56
leaq 0x8ea4d(%rip), %rdi     # 0xb76c0
callq 0x6ae0
movq 0x8ea69(%rip), %rax     # 0xb76e8
movq (%rax), %r10
movl $0xff676980, %eax       # imm = 0xFF676980
movl 0x8bfa3(%rip), %edx     # 0xb4c30
movq (%r10), %rsi
testq %rsi, %rsi
je 0x28ccd
movl 0x14(%r10), %ecx
cmpl %edx, %ecx
jne 0x28ce0
movslq 0x10(%r10), %rcx
movl 0x18(%r10,%rcx), %edi
cmpl 0x8bf88(%rip), %edi     # 0xb4c34
jne 0x28cfe
movq %rsi, %r10
incl %eax
jne 0x28c8d
leaq 0x57fa1(%rip), %rdx     # 0x80c5d
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x1fab2
jmp 0x28d39
leaq 0x8e9ec(%rip), %rdi     # 0xb76c0
addq $0x408, %rsp            # imm = 0x408
jmp 0x64f0
incq %r10
leaq 0x57f29(%rip), %rdx     # 0x80c13
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r10, %r8
xorl %eax, %eax
callq 0x1fab2
jmp 0x28d39
leaq (%r10,%rcx), %rax
addq $0x18, %rax
movsbl (%rax), %ecx
movsbl 0x1(%rax), %r8d
movsbl 0x2(%rax), %r9d
movsbl 0x3(%rax), %r11d
incq %r10
leaq 0x57f14(%rip), %rdx     # 0x80c36
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x1fab2
addq $0x10, %rsp
leaq 0x8e980(%rip), %rdi     # 0xb76c0
callq 0x64f0
leaq 0x5643d(%rip), %rdi     # 0x7f189
movq %rsp, %rsi
xorl %eax, %eax
callq 0x223fb
addq $0x408, %rsp            # imm = 0x408
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8e958(%rip), %rbx     # 0xb76c0
movq %rbx, %rdi
callq 0x6ae0
movq 0x8e971(%rip), %rdi     # 0xb76e8
callq 0x20513
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_O2/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 0x8e926(%rip), %rbx     # 0xb76c0
movq %rbx, %rdi
callq 0x6ae0
movq 0x8e947(%rip), %r14     # 0xb76f0
movq %rbx, %rdi
callq 0x64f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8e60d(%rip), %rdi     # 0xb76c0
callq 0x6ae0
movslq -0x8(%rbx), %r14
subq %r14, 0x8e62d(%rip)     # 0xb76f0
addq %rbx, %r14
movl -0x4(%rbx), %eax
cmpl 0x8bb61(%rip), %eax     # 0xb4c30
je 0x290f1
leaq 0x8e5e8(%rip), %rdi     # 0xb76c0
callq 0x64f0
movl -0x4(%rbx), %esi
leaq 0x57c2e(%rip), %rdi     # 0x80d15
movq %rbx, %rdx
xorl %eax, %eax
callq 0x223fb
movl (%r14), %eax
cmpl 0x8bb3a(%rip), %eax     # 0xb4c34
je 0x2912c
leaq 0x8e5bd(%rip), %rdi     # 0xb76c0
callq 0x64f0
movsbl (%r14), %esi
movsbl 0x1(%r14), %edx
movsbl 0x2(%r14), %ecx
movsbl 0x3(%r14), %r8d
leaq 0x57c15(%rip), %rdi     # 0x80d37
movq %rbx, %r9
xorl %eax, %eax
callq 0x223fb
addq $-0x18, %rbx
movq %rbx, %rdi
callq 0x2046a
movq 0x8e579(%rip), %rax     # 0xb76b8
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x8e574(%rip), %rdi     # 0xb76c0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64f0
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x8(%rcx)
pushq $0x1
popq %rsi
pushq $0x14
popq %rdx
pushq $0x10
popq %r8
callq 0x6d80
testl %eax, %eax
js 0x291e1
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %rsp, %rcx
pushq $0x10
popq %r8
movl %ebx, %edi
callq 0x6d80
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x291f2
leaq 0x57bb0(%rip), %rdi     # 0x80d8f
jmp 0x291e8
leaq 0x57b75(%rip), %rdi     # 0x80d5d
xorl %eax, %eax
callq 0x22186
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x291f8
movl %eax, %ebx
testl %eax, %eax
jns 0x294f0
xorl %eax, %eax
callq 0x224b6
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r14d
movl $0x1, 0xc(%rsp)
callq 0x296d3
callq 0x2c014
movl %eax, %ebx
testl %eax, %eax
js 0x295b7
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movl %r14d, %esi
callq 0x4425a
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0x295b9
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
leaq 0xc(%rsp), %rcx
pushq $0x4
popq %r8
movl %ebx, %edi
callq 0x6d80
testl %eax, %eax
jne 0x295b9
leaq 0x10(%rsp), %rsi
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x6140
cmpl $-0x1, %eax
je 0x295c8
movl %ebx, %edi
movl %r15d, %esi
callq 0x6820
movl %ebx, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6060
movl (%rax), %edi
callq 0x6230
leaq 0x57811(%rip), %rdi     # 0x80dec
movl %r14d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22186
movl %ebx, %edi
callq 0x6e80
jmp 0x295b9
// File: /workspace/github_c_makefile_star2_O2/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)
leaq 0x8(%rsp), %r15
leaq 0xc(%rsp), %r12
movl $0x10, 0x8(%rsp)
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x61f0
testl %eax, %eax
js 0x29636
movl %eax, %r13d
testq %rbx, %rbx
je 0x2967e
movl 0x14(%rsp), %edi
bswapl %edi
movq %r12, %rsi
callq 0x4434a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4435f
testl %eax, %eax
jne 0x2967e
movl %r13d, %edi
callq 0x6e80
jmp 0x29636
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/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 0x296aa
leaq 0x57768(%rip), %rdi     # 0x80e0b
xorl %eax, %eax
callq 0x22504
leaq 0x57784(%rip), %rsi     # 0x80e35
movl %ebx, %edi
callq 0x6760
movq %rax, %rbx
testq %rax, %rax
jne 0x296ce
leaq 0x57771(%rip), %rdi     # 0x80e38
xorl %eax, %eax
callq 0x22504
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %r15
movl %edi, %ebp
cmpb $0x0, 0x8e016(%rip)     # 0xb7720
jne 0x29711
callq 0x296d3
xorl %ebx, %ebx
movq %r14, %rdx
subq %rbx, %rdx
jle 0x29739
leaq (%r15,%rbx), %rsi
movl %ebp, %edi
callq 0x6aa0
testl %eax, %eax
js 0x29736
je 0x29739
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %rbx
jmp 0x29713
movslq %eax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x296f4
movq %rax, %rbx
testq %rax, %rax
jns 0x29763
leaq 0x57708(%rip), %rdi     # 0x80e64
xorl %eax, %eax
callq 0x22504
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
orl $-0x1, (%rsi)
testq %rdi, %rdi
je 0x29827
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6dd0
movq %rax, 0x8(%rsp)
leaq 0x560df(%rip), %rsi     # 0x7f878
leaq 0x10(%rsp), %rdx
pushq $0x5
popq %rcx
movq %rax, %rdi
callq 0x1e51d
movl %eax, %r15d
leal -0x4(%r15), %eax
cmpl $-0x4, %eax
ja 0x297bd
movq %r14, %rdi
callq 0x29828
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x2980f
movq 0x10(%rsp,%r13,8), %r12
callq 0x6790
movq (%rax), %rax
movsbq (%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x297ed
movq %r14, %rdi
callq 0x29828
movq %r12, %rdi
callq 0x6bd0
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jl 0x29806
movq %r14, %rdi
callq 0x29828
movb %bpl, (%rbx,%r13)
incq %r13
jmp 0x297c7
leaq 0x8(%rsp), %rdi
callq 0x28c3d
addq $0x38, %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/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
orq $-0x1, (%rsi)
orq $-0x1, (%rdx)
pushq $0x3b
popq %rsi
callq 0x67c0
testq %rax, %rax
je 0x29c2f
movq %rax, %r15
leaq 0x573d1(%rip), %rdi     # 0x80fa8
movq %rax, %rsi
callq 0x1db41
testl %eax, %eax
je 0x29c2f
pushq $0x3d
popq %rsi
movq %r15, %rdi
callq 0x6270
movq %rax, %r13
incq %r13
pushq $0x2d
popq %rsi
movq %r13, %rdi
callq 0x6270
testq %rax, %rax
je 0x29c2f
movq %rax, %r12
incq %r12
testl %ebp, %ebp
je 0x29c12
movb $0x0, (%r15)
movq %r13, %rdi
callq 0x6520
movq %rax, (%r14)
cmpb $0x0, (%r12)
je 0x29c2f
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_O2/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 $0x98, %rsp
movl %edi, %ebx
pushq $0x40
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movslq %eax, %rbp
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %r12
shlq %cl, %r12
movl $0xf4240, %ecx          # imm = 0xF4240
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r14d
movl %edx, %r15d
incl %ebx
xorl %eax, %eax
cmpl %ecx, %esi
cmovll %eax, %r14d
movslq %esi, %rax
cmovlq %rax, %r15
leaq 0x8(%rsp), %r13
movq %r14, 0x8(%rsp)
movq %r15, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x29e89
andq $0x0, 0x18(%rsp,%rax,8)
incq %rax
jmp 0x29e78
orq %r12, 0x18(%rsp,%rbp,8)
movl %ebx, %edi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r8
callq 0x66b0
testl %eax, %eax
jns 0x29ec9
callq 0x6060
movl (%rax), %edi
cmpl $0x4, %edi
je 0x29e6c
callq 0x6230
leaq 0x57025(%rip), %rdi     # 0x80ee2
movq %rax, %rsi
xorl %eax, %eax
callq 0x22186
jmp 0x29e6c
addq $0x98, %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/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 0x291f8
testl %eax, %eax
js 0x2a26a
movl %eax, %ebx
movl %eax, %edi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2c03a
testl %eax, %eax
je 0x2a1d8
leaq 0x5d1b0(%rip), %rsi     # 0x8737d
movl %ebx, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2a280
leaq 0xc(%rsp), %r12
andl $0x0, (%r12)
leaq 0x57606(%rip), %rdx     # 0x817ef
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rcx
xorl %eax, %eax
callq 0x1fab2
movl %ebx, %edi
movq %r13, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2a280
testl %eax, %eax
je 0x2a263
cmpl $0x14b, 0xc(%rsp)       # imm = 0x14B
jne 0x2a24d
leaq 0x575d5(%rip), %rdx     # 0x817f9
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
xorl %eax, %eax
callq 0x1fab2
movl %ebx, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2a280
testl %eax, %eax
je 0x2a263
leaq 0x575af(%rip), %rsi     # 0x81803
movl %ebx, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2a280
testl %eax, %eax
jne 0x2a26d
movl %ebx, %edi
callq 0x6e80
pushq $-0x1
popq %rbx
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_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
leaq 0x20(%rsp), %r14
leaq 0x56bcb(%rip), %rsi     # 0x80e92
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x6710
testl %eax, %eax
je 0x2a302
leaq 0x56bba(%rip), %rsi     # 0x80e97
pushq $0x6
popq %rdx
movq %r14, %rdi
callq 0x6710
testl %eax, %eax
je 0x2a324
leaq 0x56c3d(%rip), %rdi     # 0x80f30
movq %r15, %rsi
xorl %eax, %eax
callq 0x223fb
pushq $-0x1
popq %rax
jmp 0x2a346
leaq 0x1010(%r14), %rbx
addq $0x1810, %r14           # imm = 0x1810
movq %r14, %rdi
callq 0x6bd0
movq %rbx, %rdi
movl %eax, %esi
callq 0x291f8
jmp 0x2a346
leaq 0x1010(%r14), %r15
addq $0x1810, %r14           # imm = 0x1810
movq %r14, %rdi
callq 0x6bd0
movq %r15, %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x4404c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x110, %rsp            # imm = 0x110
cmpb $0x0, 0x140(%rsp)
je 0x2a3d4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x130(%rsp), %r8
leaq 0x140(%rsp), %rcx
addq $0x810, %r8             # imm = 0x810
leaq 0x57633(%rip), %rdx     # 0x819b9
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x1fab2
movq %r15, %rdi
callq 0x62d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x3ca30
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x56b9e(%rip), %rsi     # 0x80f5a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21ec7
movq %r15, %rdi
callq 0x28c3d
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x56b77(%rip), %rdi     # 0x80f69
callq 0x68f0
movq %rax, %rdi
callq 0x1c306
movq %rax, (%rsp)
xorl %ebp, %ebp
testq %rax, %rax
je 0x2a43e
pushq $0x2c
popq %rsi
pushq $0x20
popq %rdx
movq %rax, %rdi
callq 0x1e053
movq %rsp, %r14
pushq $0x1
popq %r15
movq %r14, %rdi
callq 0x1e9c1
testq %rax, %rax
je 0x2a43e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1de0f
testl %eax, %eax
je 0x2a41f
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq