LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: readTwoBitSeqHeader
static struct twoBit *readTwoBitSeqHeader(struct twoBitFile *tbf, char *name)
/* read a sequence header, nBlocks and maskBlocks from a twoBit file,
 * leaving file pointer at data block */
{
boolean isSwapped = tbf->isSwapped;
struct twoBit *twoBit;
AllocVar(twoBit);
twoBit->name = cloneString(name);
void *f = tbf->f;

/* Find offset in index and seek to it */
twoBitSeekTo(tbf, name);

/* Read in seqSize. */
twoBit->size = (*tbf->ourReadBits32)(f, isSwapped);

/* Read in blocks of N. */
readBlockCoords(tbf, isSwapped, &(twoBit->nBlockCount),
		&(twoBit->nStarts), &(twoBit->nSizes));

/* Read in masked blocks. */
readBlockCoords(tbf, isSwapped, &(twoBit->maskBlockCount),
		&(twoBit->maskStarts), &(twoBit->maskSizes));

/* Reserved word. */
twoBit->reserved = (*tbf->ourReadBits32)(f, isSwapped);

return twoBit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movl 0x18(%rdi), %ebp
movl $0x50, %edi
callq 0x2dc95
movq %rax, %r14
movq %r12, %rdi
callq 0x1f9f6
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e8c9
movq %r15, %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x18(%r14)
leaq 0x1c(%r14), %rdx
leaq 0x20(%r14), %rcx
leaq 0x28(%r14), %r8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3f3fc
leaq 0x30(%r14), %rdx
leaq 0x38(%r14), %rcx
leaq 0x40(%r14), %r8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3f3fc
movq %r15, %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x48(%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/twoBit.c
// Function: twoBitFromOpenFile
struct twoBit *twoBitFromOpenFile(struct twoBitFile *tbf)
/* Get twoBit list of all sequences in twoBit file. */
{
struct twoBitIndex *index;
struct twoBit *twoBitList = NULL;

for (index = tbf->indexList; index != NULL; index = index->next)
    {
    struct twoBit *twoBit = twoBitOneFromFile(tbf, index->name);
    slAddHead(&twoBitList, twoBit);
    }

twoBitClose(&tbf);
slReverse(&twoBitList);
return twoBitList;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3e3ac
movq 0x8(%rsp), %rdi
movq 0x8(%rbx), %rsi
callq 0x3e29d
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %rax, (%rsp)
movq (%rbx), %rbx
jmp 0x3e389
leaq 0x8(%rsp), %rdi
callq 0x3df96
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitFreeList
void twoBitFreeList(struct twoBit **pList)
/* Free a list of dynamically allocated twoBit's */
{
struct twoBit *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    twoBitFree(&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 0x3e40c
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x3dfeb
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x3e3f7
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitSeekTo
static void twoBitSeekTo(struct twoBitFile *tbf, char *name)
/* Seek to start of named record.  Abort if can't find it. */
{
if (tbf->bpt)
    {
    bits32 offset;
    if (!bptFileFind(tbf->bpt, name, strlen(name), &offset, sizeof(offset)))
	 errAbort("%s is not in %s", name, tbf->bpt->fileName);
    (*tbf->ourSeek)(tbf->f, offset);
    }
else
    {
    struct twoBitIndex *index = hashFindVal(tbf->hash, name);
    if (index == NULL)
	 errAbort("%s is not in %s", name, tbf->fileName);
    (*tbf->ourSeek)(tbf->f, index->offset);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %r15
testq %r15, %r15
je 0x3e933
movq %r14, %rdi
callq 0x62d0
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
movl $0x4, %r8d
callq 0x42f0c
testl %eax, %eax
jne 0x3e91e
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rdx
leaq 0x560b6(%rip), %rdi     # 0x949ca
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq 0x10(%rbx), %rdi
movl 0xc(%rsp), %esi
callq *0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x29029
movq %rax, %r15
testq %rax, %rax
jne 0x3e95c
movq 0x8(%rbx), %rdx
leaq 0x56078(%rip), %rdi     # 0x949ca
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq 0x10(%rbx), %rdi
movq 0x50(%rbx), %rax
movq 0x10(%r15), %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitTotalSize
long long twoBitTotalSize(struct twoBitFile *tbf)
/* Return total size of all sequences in two bit file. */
{
struct twoBitIndex *index;
long long totalSize = 0;
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    (*tbf->ourSeek)(tbf->f, index->offset);
    totalSize += (*tbf->ourReadBits32)(tbf->f, tbf->isSwapped);
    }
return totalSize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x3e9ad
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x10(%r14), %rdi
movq 0x10(%r15), %rsi
callq *0x50(%r14)
movq 0x10(%r14), %rdi
movl 0x18(%r14), %esi
callq *0x68(%r14)
movl %eax, %eax
addq %rax, %rbx
movq (%r15), %r15
testq %r15, %r15
jne 0x3e986
jmp 0x3e9af
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitLoadAll
struct dnaSeq *twoBitLoadAll(char *spec)
/* Return list of all sequences matching spec, which is in
 * the form:
 *
 *    file/path/input.2bit[:seqSpec1][,seqSpec2,...]
 *
 * where seqSpec is either
 *     seqName
 *  or
 *     seqName:start-end */
{
struct twoBitSpec *tbs = twoBitSpecNew(spec);
struct twoBitFile *tbf = twoBitOpen(tbs->fileName);
struct dnaSeq *list = NULL;
if (tbs->seqs != NULL)
    {
    struct twoBitSeqSpec *tbss;
    for (tbss = tbs->seqs; tbss != NULL; tbss = tbss->next)
        slSafeAddHead(&list, twoBitReadSeqFrag(tbf, tbss->name,
                                               tbss->start, tbss->end));
    }
else
    {
    struct twoBitIndex *index;
    for (index = tbf->indexList; index != NULL; index = index->next)
	slSafeAddHead(&list, twoBitReadSeqFrag(tbf, index->name, 0, 0));
    }
slReverse(&list);
twoBitClose(&tbf);
twoBitSpecFree(&tbs);
return list;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
callq 0x3ea7b
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movq (%rax), %rdi
callq 0x3e08d
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x3ea45
movq 0x10(%rsp), %rdi
movq 0x8(%rbx), %rsi
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x3e41d
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x3e9e9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1fcb3
leaq 0x10(%rsp), %rdi
callq 0x3df96
leaq 0x18(%rsp), %rdi
callq 0x3eb7b
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
retq
movq 0x28(%rax), %rbx
testq %rbx, %rbx
je 0x3ea1b
movq 0x10(%rsp), %rdi
movq 0x8(%rbx), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x3e41d
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq (%rbx), %rbx
jmp 0x3ea49
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitSpecNew
struct twoBitSpec *twoBitSpecNew(char *specStr)
/* Parse a .2bit file and sequence spec into an object.
 * The spec is a string in the form:
 *
 *    file/path/input.2bit[:seqSpec1][,seqSpec2,...]
 *
 * where seqSpec is either
 *     seqName
 *  or
 *     seqName:start-end
 *
 * free result with twoBitSpecFree().
 */
{
char *s, *e;
int i, numSeqs;
char **seqSpecs;
struct twoBitSpec *spec;
AllocVar(spec);
spec->fileName = cloneString(specStr);

/* start with final file name  */
s = strrchr(spec->fileName, '/');
if (s == NULL)
    s = spec->fileName;
else
    s++;

/* find end of file name and zero-terminate */
e = strchr(s, ':');
if (e == NULL)
    s = NULL; /* just file name */
else
    {
    *e++ = '\0';
    s = e;
    }

if (!twoBitIsFile(spec->fileName))
    {
    twoBitSpecFree(&spec);
    return NULL; /* not a 2bit file */
    }

if (s != NULL)
    {
    /* chop seqs at commas and parse */
    numSeqs = chopString(s, ",", NULL, 0);
    AllocArray(seqSpecs, numSeqs);
    chopString(s, ",", seqSpecs, numSeqs);
    for (i = 0; i< numSeqs; i++)
        slSafeAddHead(&spec->seqs, parseSeqSpec(seqSpecs[i]));
    slReverse(&spec->seqs);
    }
return spec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x10, %edi
callq 0x2dc95
movq %rax, %rbx
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x1f9f6
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, %rdi
movl $0x2f, %esi
callq 0x67c0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r14, %rdi
movl $0x3a, %esi
callq 0x6270
testq %rax, %rax
je 0x3eada
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x3eadd
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x3ec3e
testl %eax, %eax
je 0x3eb5f
testq %r14, %r14
je 0x3eb69
leaq 0x50ef2(%rip), %r12     # 0x8f9e7
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22314
movl %eax, %ebp
movslq %eax, %r13
leaq (,%r13,8), %rdi
callq 0x2db04
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x22314
testl %r13d, %r13d
jle 0x3eb51
movl %ebp, %r14d
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x3ef49
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
incq %r12
cmpq %r12, %r14
jne 0x3eb35
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x1fcb3
jmp 0x3eb69
movq %rsp, %rdi
callq 0x3eb7b
xorl %ebx, %ebx
movq %rbx, %rax
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/twoBit.c
// Function: twoBitSpecFree
void twoBitSpecFree(struct twoBitSpec **specPtr)
/* free a twoBitSpec object */
{
struct twoBitSpec *spec = *specPtr;
if (spec != NULL)
    {
    struct twoBitSeqSpec *seq;
    while ((seq = slPopHead(&spec->seqs)) != NULL)
        {
        freeMem(seq->name);
        freeMem(seq);
        }
    freeMem(spec->fileName);
    freeMem(spec);
    *specPtr = NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x3ebdb
movq %rdi, %rbx
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x1fc5b
testq %rax, %rax
je 0x3ebc4
movq %rax, %r12
movq 0x8(%r12), %rdi
callq 0x2dd41
movq %r12, %rdi
callq 0x2dd41
movq %r15, %rdi
callq 0x1fc5b
movq %rax, %r12
testq %rax, %rax
jne 0x3eba2
movq (%r14), %rdi
callq 0x2dd41
movq %r14, %rdi
callq 0x2dd41
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitSeqNames
struct slName *twoBitSeqNames(char *fileName)
/* Get list of all sequences in twoBit file. */
{
struct twoBitFile *tbf = twoBitOpen(fileName);
struct twoBitIndex *index;
struct slName *name, *list = NULL;
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    name = slNameNew(index->name);
    slAddHead(&list, name);
    }
twoBitClose(&tbf);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x3e08d
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x28(%rax), %rbx
testq %rbx, %rbx
je 0x3ec20
movq 0x8(%rbx), %rdi
callq 0x2037b
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %rax, (%rsp)
movq (%rbx), %rbx
jmp 0x3ec02
leaq 0x8(%rsp), %rdi
callq 0x3df96
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fcb3
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitIsFile
boolean twoBitIsFile(char *fileName)
/* Return TRUE if file is in .2bit format. */
{
boolean useUdc = FALSE;
if (hasProtocol(fileName))
    useUdc = TRUE;
else if (!isRegularFile(fileName))
    return FALSE;

struct twoBitFile *tbf = getTbfAndOpen(fileName, useUdc);
boolean isSwapped;
boolean isTwoBit = twoBitSigRead(tbf, &isSwapped);

(*tbf->ourClose)(&tbf->f);

return isTwoBit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x31296
movl $0x1, %ebp
testl %eax, %eax
jne 0x3ec64
movq %rbx, %rdi
callq 0x35326
xorl %ebp, %ebp
testl %eax, %eax
je 0x3ecaa
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ecb7
movq %rax, %rbx
leaq 0x10(%rax), %r14
movq 0x10(%rax), %rdi
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %r15, %rsi
callq *0x88(%rax)
movl (%r15), %eax
cmpl $0x4327411a, %eax       # imm = 0x4327411A
sete %cl
cmpl $0x1a412743, %eax       # imm = 0x1A412743
sete %al
orb %cl, %al
movzbl %al, %ebp
movq %r14, %rdi
callq *0x78(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: getTbfAndOpen
static struct twoBitFile *getTbfAndOpen(char *fileName, boolean useUdc)
{
struct twoBitFile *tbf;

AllocVar(tbf);
setFileFuncs(tbf, useUdc);

if (useUdc)
    tbf->f = udcFileOpen(fileName, NULL);
else
    tbf->f = mustOpen(fileName, "rb");

return tbf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x90, %edi
callq 0x2dc95
movq %rax, %rbx
leaq 0x81b(%rip), %rcx       # 0x3f4ef
leaq 0x7ec(%rip), %rax       # 0x3f4c7
testl %ebp, %ebp
cmoveq %rcx, %rax
leaq 0x811(%rip), %rcx       # 0x3f4f9
leaq 0x7dd(%rip), %rdx       # 0x3f4cc
cmoveq %rcx, %rdx
leaq 0x806(%rip), %rcx       # 0x3f500
leaq 0x7d0(%rip), %rsi       # 0x3f4d1
cmoveq %rcx, %rsi
leaq 0x7f9(%rip), %rcx       # 0x3f505
leaq 0x7c3(%rip), %rdi       # 0x3f4d6
cmoveq %rcx, %rdi
leaq 0x7ec(%rip), %rcx       # 0x3f50a
leaq 0x7b6(%rip), %r8        # 0x3f4db
cmoveq %rcx, %r8
leaq 0x7df(%rip), %rcx       # 0x3f50f
leaq 0x7a9(%rip), %r9        # 0x3f4e0
cmoveq %rcx, %r9
leaq 0x7d2(%rip), %rcx       # 0x3f514
leaq 0x79c(%rip), %r10       # 0x3f4e5
cmoveq %rcx, %r10
leaq 0x7c5(%rip), %rcx       # 0x3f519
leaq 0x78f(%rip), %r11       # 0x3f4ea
cmoveq %rcx, %r11
movq %rax, 0x58(%rbx)
movq %rdx, 0x50(%rbx)
movq %rsi, 0x60(%rbx)
movq %rdi, 0x68(%rbx)
movq %r8, 0x70(%rbx)
movq %r9, 0x80(%rbx)
movq %r10, 0x78(%rbx)
movq %r11, 0x88(%rbx)
je 0x3ed93
movq %r14, %rdi
xorl %esi, %esi
callq 0x40b69
jmp 0x3eda2
leaq 0x4f66c(%rip), %rsi     # 0x8e406
movq %r14, %rdi
callq 0x22d5a
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitParseRange
boolean twoBitParseRange(char *rangeSpec, char **retFile, 
	char **retSeq, int *retStart, int *retEnd)
/* Parse out something in format
 *    file/path/name:seqName:start-end
 * or
 *    file/path/name:seqName
 * or
 *    file/path/name:seqName1,seqName2,seqName3,...
 * This will destroy the input 'rangeSpec' in the process.  Returns FALSE if
 * it doesn't fit this format, setting retFile to rangeSpec, and retSet to
 * null.  If it is the shorter form then start and end will both be returned
 * as zero, which is ok by twoBitReadSeqFrag.  Any of the return arguments
 * maybe NULL.
 */
{
char *s, *e;
int n;

/* default returns */
if (retFile != NULL)
    *retFile = rangeSpec;
if (retSeq != NULL)
    *retSeq = NULL;
if (retStart != NULL)
    *retStart = 0;
if (retEnd != NULL)
    *retEnd = 0;

/* start with final name  */
s = strrchr(rangeSpec, '/');
if (s == NULL)
    s = rangeSpec;
else
    s++;

/* Grab seqName, zero terminate fileName. */
s = strchr(s, ':');
if (s == NULL)
    return FALSE;
*s++ = 0;
if (retSeq != NULL)
    *retSeq = s;

/* Grab start, zero terminate seqName. */
s = strchr(s, ':');
if (s == NULL)
    return TRUE;  /* no range spec */
*s++ = 0;
n = strtol(s, &e, 0);
if (*e != '-')
    return FALSE; /* not a valid range */
if (retStart != NULL)
    *retStart = n;
s = e+1;

/* Grab end. */
n = strtol(s, &e, 0);
if (*e != '\0')
    return FALSE; /* not a valid range */
if (retEnd != NULL)
    *retEnd = n;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
testq %rsi, %rsi
je 0x3edce
movq %r12, (%rsi)
testq %r15, %r15
je 0x3edda
movq $0x0, (%r15)
testq %r14, %r14
je 0x3ede6
movl $0x0, (%r14)
testq %rbx, %rbx
je 0x3edf1
movl $0x0, (%rbx)
movq %r12, %rdi
movl $0x2f, %esi
callq 0x67c0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r12, %rdi
movl $0x3a, %esi
callq 0x6270
testq %rax, %rax
je 0x3ee9f
movq %rax, %rcx
incq %rax
movb $0x0, (%rcx)
testq %r15, %r15
je 0x3ee2d
movq %rax, (%r15)
movq %rax, %rdi
movl $0x3a, %esi
callq 0x6270
movl $0x1, %ebp
testq %rax, %rax
je 0x3eeaa
movq %rax, %rdi
incq %rdi
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq %r15, %rsi
xorl %edx, %edx
callq 0x6a60
movq (%r15), %rdi
cmpb $0x2d, (%rdi)
jne 0x3eeaa
testq %r14, %r14
je 0x3ee6e
movl %eax, (%r14)
testq %rbx, %rbx
sete %r15b
incq %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x6a60
movq (%r14), %rcx
xorl %ebp, %ebp
cmpb $0x0, (%rcx)
sete %cl
setne %dl
orb %r15b, %dl
je 0x3eea3
movb %cl, %bpl
jmp 0x3eeaa
xorl %ebp, %ebp
jmp 0x3eeaa
movl %eax, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitIsRange
boolean twoBitIsRange(char *rangeSpec)
/* Return TRUE if it looks like a two bit range specifier. */
{
char *dupe = cloneString(rangeSpec);
char *file, *seq;
int start, end;
boolean isRange = twoBitParseRange(dupe, &file, &seq, &start, &end);
if (isRange)
    isRange = twoBitIsFile(file);
freeMem(dupe);
return isRange;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
callq 0x1f9f6
movq %rax, %rbx
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rax, %rdi
callq 0x3edae
testl %eax, %eax
je 0x3eef2
movq (%rsp), %rdi
callq 0x3ec3e
movl %eax, %ebp
jmp 0x3eef4
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2dd41
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitIsSpec
boolean twoBitIsSpec(char *spec)
/* Return TRUE spec is a valid 2bit spec (see twoBitSpecNew) */
{
struct twoBitSpec *tbs = twoBitSpecNew(spec);
boolean isSpec = (tbs != NULL);
twoBitSpecFree(&tbs);
return isSpec;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x3ea7b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
callq 0x3eb7b
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: parseSeqSpec
static struct twoBitSeqSpec *parseSeqSpec(char *seqSpecStr)
/* parse one sequence spec */
{
boolean isOk = TRUE;
char *s, *e;
struct twoBitSeqSpec *seq;
AllocVar(seq);
seq->name = cloneString(seqSpecStr);

/* Grab start */
s = strchr(seq->name, ':');
if (s == NULL)
    return seq;  /* no range spec */
*s++ = 0;
seq->start = strtol(s, &e, 0);
if (*e != '-')
    isOk = FALSE;
else
    {
    /* Grab end */
    s = e+1;
    seq->end = strtol(s, &e, 0);
    if (*e != '\0')
        isOk = FALSE;
    }
if (!isOk || (seq->end < seq->start))
    errAbort("invalid twoBit sequence specification: \"%s\"", seqSpecStr);
return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x18, %edi
callq 0x2dc95
movq %rax, %rbx
movq %r14, %rdi
callq 0x1f9f6
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movl $0x3a, %esi
callq 0x6270
testq %rax, %rax
je 0x3efd6
movq %rax, %rdi
incq %rdi
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x6a60
movl %eax, 0x10(%rbx)
movq (%r15), %rdi
cmpb $0x2d, (%rdi)
jne 0x3efc5
incq %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x6a60
movl %eax, 0x14(%rbx)
movq (%r15), %rcx
cmpb $0x0, (%rcx)
jne 0x3efc5
cmpl %eax, 0x10(%rbx)
jbe 0x3efd6
leaq 0x55a0e(%rip), %rdi     # 0x949da
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitSpecNewFile
struct twoBitSpec *twoBitSpecNewFile(char *twoBitFile, char *specFile)
/* parse a file containing a list of specifications for sequences in the
 * specified twoBit file. Specifications are one per line in forms:
 *     seqName
 *  or
 *     seqName:start-end
 */
{
struct lineFile *lf = lineFileOpen(specFile, TRUE);
char *line;
struct twoBitSpec *spec;
AllocVar(spec);
spec->fileName = cloneString(twoBitFile);
while (lineFileNextReal(lf, &line))
    slSafeAddHead(&spec->seqs, parseSeqSpec(trimSpaces(line)));
slReverse(&spec->seqs);
lineFileClose(&lf);
return spec;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x2a1fc
movq %rax, 0x8(%rsp)
movl $0x10, %edi
callq 0x2dc95
movq %rax, %rbx
movq %r14, %rdi
callq 0x1f9f6
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2afac
testl %eax, %eax
je 0x3f05d
leaq 0x10(%rsp), %r14
movq 0x10(%rsp), %rdi
callq 0x22732
movq %rax, %rdi
callq 0x3ef49
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2afac
testl %eax, %eax
jne 0x3f02f
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x1fcb3
leaq 0x8(%rsp), %rdi
callq 0x2ab48
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOutMaskBeds
void twoBitOutMaskBeds(struct twoBitFile *tbf, char *seqName, FILE *outF)
/* output a series of bed3's that enumerate the number of masked bases in a sequence*/
{
struct twoBit *header = readTwoBitSeqHeader(tbf, seqName);

int ii;
for (ii = 0; ii < header->maskBlockCount; ++ii)
    {
    fprintf(outF, "%s\t%d\t%d\n", seqName, header->maskStarts[ii], header->maskStarts[ii] + header->maskSizes[ii]);
    }

twoBitFree(&header);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x3e2ea
movq %rax, (%rsp)
cmpl $0x0, 0x30(%rax)
je 0x3f0d7
leaq 0x558b4(%rip), %r15     # 0x94956
xorl %r12d, %r12d
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rax
movl (%rcx,%r12,4), %ecx
movl (%rax,%r12,4), %r8d
addl %ecx, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6a90
incq %r12
movq (%rsp), %rax
movl 0x30(%rax), %ecx
cmpq %rcx, %r12
jb 0x3f0a5
movq %rsp, %rdi
callq 0x3dfeb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOutNBeds
void twoBitOutNBeds(struct twoBitFile *tbf, char *seqName, FILE *outF)
/* output a series of bed3's that enumerate the number of N's in a sequence*/
{
int nBlockCount;

twoBitSeekTo(tbf, seqName);

(*tbf->ourReadBits32)(tbf->f, tbf->isSwapped);

/* Read in blocks of N. */
nBlockCount = (*tbf->ourReadBits32)(tbf->f, tbf->isSwapped);

if (nBlockCount > 0)
    {
    bits32 *nStarts = NULL, *nSizes = NULL;
    int i;

    AllocArray(nStarts, nBlockCount);
    AllocArray(nSizes, nBlockCount);
    (*tbf->ourMustRead)(tbf->f, nStarts, sizeof(nStarts[0]) * nBlockCount);
    (*tbf->ourMustRead)(tbf->f, nSizes, sizeof(nSizes[0]) * nBlockCount);
    if (tbf->isSwapped)
	{
	for (i=0; i<nBlockCount; ++i)
	    {
	    nStarts[i] = byteSwap32(nStarts[i]);
	    nSizes[i] = byteSwap32(nSizes[i]);
	    }
	}

    for (i=0; i<nBlockCount; ++i)
	{
	fprintf(outF, "%s\t%d\t%d\n", seqName, nStarts[i], nStarts[i] + nSizes[i]);
	}

    freez(&nStarts);
    freez(&nSizes);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3e8c9
movq 0x10(%r15), %rdi
movl 0x18(%r15), %esi
callq *0x68(%r15)
movq 0x10(%r15), %rdi
movl 0x18(%r15), %esi
callq *0x68(%r15)
testl %eax, %eax
jle 0x3f218
movl %eax, %ebp
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl %ebp, %r13d
leaq (,%r13,4), %r12
movq %r12, %rdi
callq 0x2db04
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x2db04
movq %rax, 0x8(%rsp)
movq 0x10(%r15), %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq *0x88(%r15)
movq 0x10(%r15), %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq *0x88(%r15)
cmpl $0x0, 0x18(%r15)
je 0x3f1c0
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
movl (%rax,%r15,4), %edi
callq 0x236d8
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x8(%rsp), %rax
movl (%rax,%r15,4), %edi
callq 0x236d8
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
cmpq %r15, %r13
jne 0x3f18a
cmpl $0x2, %ebp
movl $0x1, %r12d
cmovgel %ebp, %r12d
leaq 0x55782(%rip), %r15     # 0x94956
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movl (%rax,%r13,4), %ecx
movq 0x8(%rsp), %rax
movl (%rax,%r13,4), %r8d
addl %ecx, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6a90
incq %r13
cmpq %r13, %r12
jne 0x3f1d7
leaq 0x10(%rsp), %rdi
callq 0x2dd51
leaq 0x8(%rsp), %rdi
callq 0x2dd51
addq $0x18, %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/twoBit.c
// Function: twoBitSeqSizeNoNs
int twoBitSeqSizeNoNs(struct twoBitFile *tbf, char *seqName)
/* return the size of the sequence, not counting N's*/
{
int nBlockCount;
int size;

twoBitSeekTo(tbf, seqName);

size = (*tbf->ourReadBits32)(tbf->f, tbf->isSwapped);

/* Read in blocks of N. */
nBlockCount = (*tbf->ourReadBits32)(tbf->f, tbf->isSwapped);

if (nBlockCount > 0)
    {
    bits32 *nStarts = NULL, *nSizes = NULL;
    
    int i;

    AllocArray(nStarts, nBlockCount);
    AllocArray(nSizes, nBlockCount);
    (*tbf->ourMustRead)(tbf->f, nStarts, sizeof(nStarts[0]) * nBlockCount);
    (*tbf->ourMustRead)(tbf->f, nSizes, sizeof(nSizes[0]) * nBlockCount);
    if (tbf->isSwapped)
	{
	for (i=0; i<nBlockCount; ++i)
	    {
	    nStarts[i] = byteSwap32(nStarts[i]);
	    nSizes[i] = byteSwap32(nSizes[i]);
	    }
	}

    for (i=0; i<nBlockCount; ++i)
	{
	size -= nSizes[i];
	}

    freez(&nStarts);
    freez(&nSizes);
    }

return(size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x3e8c9
movq 0x10(%r14), %rdi
movl 0x18(%r14), %esi
callq *0x68(%r14)
movl %eax, %ebx
movq 0x10(%r14), %rdi
movl 0x18(%r14), %esi
callq *0x68(%r14)
testl %eax, %eax
jle 0x3f31f
movl %eax, %ebp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movl %ebp, %r12d
leaq (,%r12,4), %r15
movq %r15, %rdi
callq 0x2db04
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x2db04
movq %rax, (%rsp)
movq 0x10(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq *0x88(%r14)
movq 0x10(%r14), %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq *0x88(%r14)
cmpl $0x0, 0x18(%r14)
je 0x3f2f1
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movl (%rax,%r14,4), %edi
callq 0x236d8
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r14,4)
movq (%rsp), %rax
movl (%rax,%r14,4), %edi
callq 0x236d8
movq (%rsp), %rcx
movl %eax, (%rcx,%r14,4)
incq %r14
cmpq %r14, %r12
jne 0x3f2bd
movq (%rsp), %rax
cmpl $0x2, %ebp
movl $0x1, %ecx
cmovgel %ebp, %ecx
xorl %edx, %edx
subl (%rax,%rdx,4), %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x3f302
leaq 0x8(%rsp), %rdi
callq 0x2dd51
movq %rsp, %rdi
callq 0x2dd51
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitTotalSizeNoN
long long twoBitTotalSizeNoN(struct twoBitFile *tbf)
/* return the size of the all the sequence in file, not counting N's*/
{
struct twoBitIndex *index;
long long totalSize = 0;
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    int size = twoBitSeqSizeNoNs(tbf, index->name);
    totalSize += size;
    }
return totalSize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x3f35c
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3f227
cltq
addq %rax, %rbx
movq (%r15), %r15
testq %r15, %r15
jne 0x3f341
jmp 0x3f35e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitChromHash
struct hash *twoBitChromHash(char *fileName)
/* Build a hash of chrom names with their sizes. */
{
struct twoBitFile *tbf = twoBitOpen(fileName);
struct twoBitIndex *index;
struct hash *hash = hashNew(digitsBaseTwo(tbf->seqCount));
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    hashAddInt(hash, index->name, twoBitSeqSize(tbf, index->name));
    }

twoBitClose(&tbf);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x3e08d
movq %rax, (%rsp)
movl 0x20(%rax), %edi
callq 0x324a3
movl %eax, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, %rbx
movq (%rsp), %rax
movq 0x28(%rax), %r12
testq %r12, %r12
je 0x3f3e5
movq 0x8(%r12), %r14
movq (%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e8c9
movq 0x10(%r15), %rdi
movl 0x18(%r15), %esi
callq *0x68(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x2909b
movq (%r12), %r12
jmp 0x3f3ad
movq %rsp, %rdi
callq 0x3df96
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: readBlockCoords
static void readBlockCoords(struct twoBitFile *tbf, boolean isSwapped, bits32 *retBlockCount,
			    bits32 **retBlockStarts, bits32 **retBlockSizes)
/* Read in blockCount, starts and sizes from file. (Same structure used for
 * both blocks of N's and masked blocks.) */
{
bits32 blkCount = (*tbf->ourReadBits32)(tbf->f, isSwapped);
*retBlockCount = blkCount;
if (blkCount == 0)
    {
    *retBlockStarts = NULL;
    *retBlockSizes = NULL;
    }
else
    {
    bits32 *nStarts, *nSizes;
    AllocArray(nStarts, blkCount);
    AllocArray(nSizes, blkCount);
    (*tbf->ourMustRead)(tbf->f, nStarts, sizeof(nStarts[0]) * blkCount);
    (*tbf->ourMustRead)(tbf->f, nSizes, sizeof(nSizes[0]) * blkCount);
    if (isSwapped)
	{
	int i;
	for (i=0; i<blkCount; ++i)
	    {
	    nStarts[i] = byteSwap32(nStarts[i]);
	    nSizes[i] = byteSwap32(nSizes[i]);
	    }
	}
    *retBlockStarts = nStarts;
    *retBlockSizes = nSizes;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r13
movq 0x10(%rdi), %rdi
callq *0x68(%r13)
movl %eax, (%r15)
testl %eax, %eax
je 0x3f4ac
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl %eax, %r14d
leaq (,%r14,4), %rbx
movq %rbx, %rdi
callq 0x2db04
movq %rax, %r15
movq %rbx, %rdi
callq 0x2db04
movq %rax, %r12
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x88(%r13)
movq 0x10(%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *0x88(%r13)
testl %ebp, %ebp
je 0x3f4a0
xorl %ebx, %ebx
movl (%r15,%rbx,4), %edi
callq 0x236d8
movl %eax, (%r15,%rbx,4)
movl (%r12,%rbx,4), %edi
callq 0x236d8
movl %eax, (%r12,%rbx,4)
incq %rbx
cmpq %rbx, %r14
jne 0x3f47e
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
jmp 0x3f4b2
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, (%r14)
movq %r12, (%rbx)
addq $0x18, %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/udc.c
// Function: udcInfoViaFtp
boolean udcInfoViaFtp(char *url, struct udcRemoteFileInfo *retInfo)
/* Gets size and last modified time of FTP URL */
{
verbose(4, "checking ftp remote info on %s\n", url);
long long size = 0;
time_t t, tUtc;
struct tm *tm = NULL;
// TODO: would be nice to add int *retCtrlSocket to netGetFtpInfo so we can stash 
// in retInfo->connInfo and keep socket open.
boolean ok = netGetFtpInfo(url, &size, &tUtc);
if (!ok)
    return FALSE;
// Convert UTC to localtime
tm = localtime(&tUtc);
t = mktimeFromUtc(tm);
if (t == -1)
    { /* Handle error */;
    errAbort("mktimeFromUtc failed while converting FTP UTC last-modified time %ld to local time", (long) tUtc);
    }
retInfo->size = size;
retInfo->updateTime = t;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x550d9(%rip), %rsi     # 0x94cbe
xorl %ebp, %ebp
movl $0x4, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4246e
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %rsp, %rdx
movq %r14, %rdi
callq 0x2f119
testl %eax, %eax
je 0x3fc4d
movq %rsp, %rdi
callq 0x64d0
movq %rax, %rdi
callq 0x24183
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x3fc3c
movq (%rsp), %rsi
leaq 0x550a9(%rip), %rdi     # 0x94cde
xorl %eax, %eax
callq 0x26b6f
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcFastReadString
boolean udcFastReadString(struct udcFile *f, char buf[256])
/* Read a string into buffer, which must be long enough
 * to hold it.  String is in 'writeString' format. */
{
UBYTE bLen;
int len;
if (!udcReadOne(f, bLen))
    return FALSE;
if ((len = bLen)> 0)
    udcMustRead(f, buf, len);
buf[len] = 0;
return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x3fcac
testq %rax, %rax
je 0x3fca0
movzbl 0xf(%rsp), %r15d
testq %r15, %r15
je 0x3fc94
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3fef4
movb $0x0, (%rbx,%r15)
movl $0x1, %eax
jmp 0x3fca2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcParseUrlFull
void udcParseUrlFull(char *url, char **retProtocol, char **retAfterProtocol, char **retColon,
		     char **retAuth)
/* Parse the URL into components that udc treats separately.
 * *retAfterProtocol is Q-encoded to keep special chars out of filenames.  
 * Free all *ret's except *retColon when done. */
{
char *protocol, *afterProtocol;
char *colon = strchr(url, ':');
if (!colon)
    {
    *retColon = NULL;
    return;
    }
int colonPos = colon - url;
protocol = cloneStringZ(url, colonPos);
afterProtocol = url + colonPos + 1;
while (afterProtocol[0] == '/')
   afterProtocol += 1;
char *userPwd = strchr(afterProtocol, '@');
if (userPwd)
    {
    if (retAuth)
	{
	char auth[1024];
	safencpy(auth, sizeof(auth), afterProtocol, userPwd+1-afterProtocol);
	*retAuth = qEncode(auth);
	}
    char *afterHost = strchr(afterProtocol, '/');
    if (!afterHost)
	{
	afterHost = afterProtocol+strlen(afterProtocol);
	}
    if (userPwd < afterHost)
	afterProtocol = userPwd + 1;
    }
else if (retAuth)
    *retAuth = NULL;
afterProtocol = qEncode(afterProtocol);
*retProtocol = protocol;
*retAfterProtocol = afterProtocol;
*retColon = colon;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl $0x3a, %esi
callq 0x6270
testq %rax, %rax
je 0x4000a
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %r12, 0x8(%rsp)
movq %rax, %rbp
subq %r14, %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f9a7
movq %rax, 0x10(%rsp)
movslq %ebp, %rax
leaq (%r14,%rax), %rbp
leaq (%r14,%rax), %r12
decq %r12
incq %r12
cmpb $0x2f, 0x1(%rbp)
leaq 0x1(%rbp), %rbp
je 0x3ff92
movq %rbp, %rdi
movl $0x40, %esi
callq 0x6270
testq %rax, %rax
je 0x4000f
movq %rax, %r14
testq %r13, %r13
je 0x3ffe0
movq %r14, %rcx
subq %r12, %rcx
leaq 0x20(%rsp), %r12
movl $0x400, %esi            # imm = 0x400
movq %r12, %rdi
movq %rbp, %rdx
callq 0x23c98
movq %r12, %rdi
callq 0x4004e
movq %rax, (%r13)
movq %rbp, %rdi
movl $0x2f, %esi
callq 0x6270
testq %rax, %rax
jne 0x3fffd
movq %rbp, %rdi
callq 0x62d0
addq %rbp, %rax
leaq 0x1(%r14), %rcx
cmpq %rax, %r14
cmovbq %rcx, %rbp
jmp 0x4001c
xorl %r15d, %r15d
jmp 0x40039
testq %r13, %r13
je 0x4001c
movq $0x0, (%r13)
movq 0x8(%rsp), %r14
movq %rbp, %rdi
callq 0x4004e
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rcx)
movq %rax, (%r14)
movq %r15, (%rbx)
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: qEncode
static char *qEncode(char *input)
/* Do a simple encoding to convert input string into "normal" characters.
 * Abnormal letters, and '!' get converted into Q followed by two hexadecimal digits. */
{
/* First go through and figure out encoded size. */
int size = 0;
char *s, *d, c;
s = input;
while ((c = *s++) != 0)
    {
    if (qEscaped(c))
	size += 3;
    else
	size += 1;
    }

/* Allocate and fill in output. */
char *output = needMem(size+1);
s = input;
d = output;
while ((c = *s++) != 0)
    {
    if (qEscaped(c))
        {
	sprintf(d, "Q%02X", (unsigned)c);
	d += 3;
	}
    else
        *d++ = c;
    }
return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x4008e
leaq 0x1(%rbx), %r15
xorl %r14d, %r14d
movsbl %al, %edi
callq 0x41f9f
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%r14,%rcx,2), %r14d
incl %r14d
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x40069
incl %r14d
jmp 0x40094
movl $0x1, %r14d
movq %r14, %rdi
callq 0x2dc95
movq %rax, %r14
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x400ea
incq %rbx
leaq 0x5503b(%rip), %r15     # 0x950ec
movq %r14, %r12
movsbl %r13b, %ebp
movl %ebp, %edi
callq 0x41f9f
testl %eax, %eax
je 0x400d8
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6170
addq $0x3, %r12
jmp 0x400df
movb %r13b, (%r12)
incq %r12
movb (%rbx), %r13b
incq %rbx
testb %r13b, %r13b
jne 0x400b4
movq %r14, %rax
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/udc.c
// Function: udcPathAndFileNames
void udcPathAndFileNames(struct udcFile *file, char *cacheDir, char *protocol, char *afterProtocol)
/* Initialize udcFile path and names */
{
if (cacheDir==NULL)
    return;
char *hashedAfterProtocol = longDirHash(afterProtocol);
int len = strlen(cacheDir) + 1 + strlen(protocol) + 1 + strlen(hashedAfterProtocol) + 1;
file->cacheDir = needMem(len);
safef(file->cacheDir, len, "%s/%s/%s", cacheDir, protocol, hashedAfterProtocol);

/* Create file names for bitmap and data portions. */
file->bitmapFileName = fileNameInCacheDir(file, bitmapName);
file->sparseFileName = fileNameInCacheDir(file, sparseDataName);
file->redirFileName = fileNameInCacheDir(file, redirName);
}

// Assembly:
testq %rsi, %rsi
je 0x4023d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x62d0
movl %eax, %edi
callq 0x261d0
movq %rax, (%rsp)
movq %r12, %rdi
movl $0x2f, %esi
callq 0x6270
testq %rax, %rax
je 0x4018a
movq %rax, %rbp
leaq 0x5503a(%rip), %r13     # 0x9518d
movb $0x0, (%rbp)
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x41fe1
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x26425
movq %rbp, %r12
incq %r12
movq %r12, %rdi
movl $0x2f, %esi
callq 0x6270
movq %rax, %rbp
testq %rax, %rax
jne 0x40153
movq %rsp, %r13
movq (%r13), %rdi
movq %r12, %rsi
callq 0x41fe1
movq %r13, %rdi
callq 0x2622c
movq %rax, %r12
movq %r15, %rdi
callq 0x62d0
movq %rax, %r13
movq %r14, %rdi
callq 0x62d0
movq %rax, %rbp
movq %r12, %rdi
callq 0x62d0
addl %r13d, %ebp
addl %ebp, %eax
addl $0x3, %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x2dc95
movq %rax, 0x38(%rbx)
leaq 0x52956(%rip), %rdx     # 0x92b36
movq %rax, %rdi
movl %r13d, %esi
movq %r15, %rcx
movq %r14, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0x23c18
leaq 0x54ef5(%rip), %rsi     # 0x950f2
movq %rbx, %rdi
callq 0x4023e
movq %rax, 0x40(%rbx)
leaq 0x54ee9(%rip), %rsi     # 0x950f9
movq %rbx, %rdi
callq 0x4023e
movq %rax, 0x48(%rbx)
leaq 0x54ee1(%rip), %rsi     # 0x95104
movq %rbx, %rdi
callq 0x4023e
movq %rax, 0x50(%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/udc.c
// Function: fileNameInCacheDir
static char *fileNameInCacheDir(struct udcFile *file, char *fileName)
/* Return the name of a file in the cache dir, from the cache root directory on down.
 * Do a freeMem on this when done. */
{
int dirLen = strlen(file->cacheDir);
int nameLen = strlen(fileName);
char *path = needMem(dirLen + nameLen + 2);
memcpy(path, file->cacheDir, dirLen);
path[dirLen] = '/';
memcpy(path+dirLen+1, fileName, nameLen);
return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %rdi
callq 0x62d0
movq %rax, %r15
movq %rbx, %rdi
callq 0x62d0
movq %rax, %r12
addl %r15d, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2dc95
movq %rax, %r13
movq 0x38(%r14), %rsi
movslq %r15d, %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x6570
leaq (%r14,%r13), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movslq %r12d, %rdx
movq %rbx, %rsi
callq 0x6570
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcProtocolNew
static struct udcProtocol *udcProtocolNew(char *upToColon)
/* Build up a new protocol around a string such as "http" or "local" */
{
struct udcProtocol *prot;
AllocVar(prot);
if (sameString(upToColon, "local"))
    {
    prot->fetchData = udcDataViaLocal;
    prot->fetchInfo = udcInfoViaLocal;
    prot->type = "local";
    }
else if (sameString(upToColon, "slow"))
    {
    prot->fetchData = udcDataViaSlow;
    prot->fetchInfo = udcInfoViaSlow;
    prot->type = "slow";
    }
else if (sameString(upToColon, "http") || sameString(upToColon, "https"))
    {
    prot->fetchData = udcDataViaHttpOrFtp;
    prot->fetchInfo = udcInfoViaHttp;
    prot->type = "http";
    }
else if (sameString(upToColon, "ftp"))
    {
    prot->fetchData = udcDataViaHttpOrFtp;
    prot->fetchInfo = udcInfoViaFtp;
    prot->type = "ftp";
    }
else if (sameString(upToColon, "transparent"))
    {
    prot->fetchData = udcDataViaTransparent;
    prot->fetchInfo = udcInfoViaTransparent;
    prot->type = "transparent";
    }
else
    {
    errAbort("Unrecognized protocol %s in udcProtNew", upToColon);
    }
return prot;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x2dc95
movq %rax, %rbx
leaq 0x5473a(%rip), %r15     # 0x9510a
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x40a65
leaq 0x54726(%rip), %r15     # 0x95110
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x40a8d
leaq 0x5149e(%rip), %r15     # 0x91ea2
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x40a79
leaq 0x5148d(%rip), %rsi     # 0x91ea7
movq %r14, %rdi
callq 0x6a50
testl %eax, %eax
je 0x40a79
leaq 0x54528(%rip), %r15     # 0x94f55
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x40ab0
leaq 0x5430c(%rip), %r15     # 0x94d4f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x40ac4
leaq 0x546bc(%rip), %rdi     # 0x95115
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
jmp 0x40aa7
leaq 0x15e8(%rip), %rax      # 0x42054
movq %rax, 0x8(%rbx)
leaq 0x16b0(%rip), %rax      # 0x42127
jmp 0x40a9f
leaq -0x151d(%rip), %rax     # 0x3f563
movq %rax, 0x8(%rbx)
leaq -0x11bc(%rip), %rax     # 0x3f8cf
jmp 0x40a9f
leaq 0x16f7(%rip), %rax      # 0x4218b
movq %rax, 0x8(%rbx)
leaq 0x1837(%rip), %rax      # 0x422d6
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq -0x1554(%rip), %rax     # 0x3f563
movq %rax, 0x8(%rbx)
leaq -0xef2(%rip), %rax      # 0x3fbd0
jmp 0x40a9f
leaq 0x1872(%rip), %rax      # 0x4233d
movq %rax, 0x8(%rbx)
leaq 0x1888(%rip), %rax      # 0x4235e
jmp 0x40a9f
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcCacheAge
unsigned long udcCacheAge(char *url, char *cacheDir)
/* Return the age in seconds of the oldest cache file.  If a cache file is
 * missing, return the current time (seconds since the epoch). */
{
unsigned long now = clock1(), oldestTime = now;
if (cacheDir == NULL)
    cacheDir = udcDefaultDir();
struct slName *sl, *slList = udcFileCacheFiles(url, cacheDir);
if (slList == NULL)
    return now;
for (sl = slList;  sl != NULL;  sl = sl->next)
    if (endsWith(sl->name, bitmapName))
	{
	if (fileExists(sl->name))
	    oldestTime = min(fileModTime(sl->name), oldestTime);
	else
	    return now;
	}
return (now - oldestTime);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
callq 0x34481
movq %rax, %rbx
testq %r14, %r14
jne 0x40afd
movq 0x8019b(%rip), %r14     # 0xc0c98
movq %r15, %rdi
movq %r14, %rsi
callq 0x40b99
testq %rax, %rax
je 0x40b5c
movq %rax, %r14
leaq 0x545db(%rip), %r15     # 0x950f2
movq %rbx, %r12
leaq 0x8(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x21aed
testl %eax, %eax
je 0x40b51
movq %r13, %rdi
callq 0x23942
testl %eax, %eax
je 0x40b5c
movq %r13, %rdi
callq 0x34970
cmpq %r12, %rax
jae 0x40b51
movq %r13, %rdi
callq 0x34970
movq %rax, %r12
movq (%r14), %r14
testq %r14, %r14
jne 0x40b1a
subq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcFileOpen
struct udcFile *udcFileOpen(char *url, char *cacheDir)
/* Open up a cached file.  cacheDir may be null in which case udcDefaultDir() will be
 * used.  Abort if file doesn't exist. */
{
struct udcFile *udcFile = udcFileMayOpen(url, cacheDir);
if (udcFile == NULL)
    errAbort("Couldn't open %s", url);
return udcFile;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x402aa
movq %rax, %r14
testq %rax, %rax
jne 0x40b8e
leaq 0x5180c(%rip), %rdi     # 0x92390
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcFileCacheFiles
struct slName *udcFileCacheFiles(char *url, char *cacheDir)
/* Return low-level list of files used in cache. */
{
char *protocol, *afterProtocol, *colon;
struct udcFile *file;
udcParseUrl(url, &protocol, &afterProtocol, &colon);
if (colon == NULL)
    return NULL;
AllocVar(file);
udcPathAndFileNames(file, cacheDir, protocol, afterProtocol);
struct slName *list = NULL;
slAddHead(&list, slNameNew(file->bitmapFileName));
slAddHead(&list, slNameNew(file->sparseFileName));
slAddHead(&list, slNameNew(file->redirFileName));
slReverse(&list);
freeMem(file->cacheDir);
freeMem(file->bitmapFileName);
freeMem(file->sparseFileName);
freeMem(file);
freeMem(protocol);
freeMem(afterProtocol);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x3ff2f
cmpq $0x0, (%r14)
je 0x40c7b
movl $0x168, %edi            # imm = 0x168
callq 0x2dc95
movq %rax, %r12
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x40104
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movq 0x40(%r12), %rdi
callq 0x2037b
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
movq 0x48(%r12), %rdi
callq 0x2037b
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
movq 0x50(%r12), %rdi
callq 0x2037b
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x1fcb3
movq 0x38(%r12), %rdi
callq 0x2dd41
movq 0x40(%r12), %rdi
callq 0x2dd41
movq 0x48(%r12), %rdi
callq 0x2dd41
movq %r12, %rdi
callq 0x2dd41
movq %r14, %rdi
callq 0x2dd41
movq %rbx, %rdi
callq 0x2dd41
movq (%r15), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/udc.c
// Function: udcBitmapClose
static void udcBitmapClose(struct udcBitmap **pBits)
/* Free up resources associated with udcBitmap. */
{
struct udcBitmap *bits = *pBits;
if (bits != NULL)
    {
    mustCloseFd(&(bits->fd));
    freez(pBits);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x40e46
addq $0x3c, %rdi
callq 0x232a1
movq %rbx, %rdi
popq %rbx
jmp 0x2dd51
popq %rbx
retq