LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x90, %edi
callq 0x40c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5b590
cmpl $0x0, -0xc(%rbp)
je 0x5aad9
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d6d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5aaf4
movq -0x8(%rbp), %rdi
leaq 0x7d85a(%rip), %rsi     # 0xd833e
callq 0x2f780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a450
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x5ab00
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x5ace7
movq -0x18(%rbp), %rdi
callq 0x5aa00
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40d40
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5a750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5a900
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x18, %edi
callq 0x40c50
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3a, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5adef
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ae97
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x6a50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x5ae2e
movl $0x0, -0x14(%rbp)
jmp 0x5ae67
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x6a50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5ae65
movl $0x0, -0x14(%rbp)
jmp 0x5ae67
cmpl $0x0, -0x14(%rbp)
je 0x5ae7d
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x5ae8f
movq -0x10(%rbp), %rsi
leaq 0x839e6(%rip), %rdi     # 0xde86e
movb $0x0, %al
callq 0x35d40
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3b290
movq %rax, -0x18(%rbp)
movl $0x10, %edi
callq 0x40c50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3c840
cmpl $0x0, %eax
je 0x5af30
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ef90
movq %rax, %rdi
callq 0x5ad90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5a8d0
jmp 0x5aef3
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2aad0
leaq -0x18(%rbp), %rdi
callq 0x3c110
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59a00
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x5afd8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rsi
movl (%rax,%rsi,4), %r8d
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x24(%rbp), %rsi
addl (%rax,%rsi,4), %r8d
leaq 0x83824(%rip), %rsi     # 0xde7ea
movb $0x0, %al
callq 0x6a80
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5af7c
leaq -0x20(%rbp), %rdi
callq 0x59570
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a4e0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %esi
callq *%rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %esi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x5b302
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x28(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
callq *%rax
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x5b2c3
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5b2c1
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x30770
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x30770
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5b274
jmp 0x5b2c3
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5b2f0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5b2ca
leaq -0x20(%rbp), %rdi
callq 0x40d70
leaq -0x28(%rbp), %rdi
callq 0x40d70
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b364
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5b190
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5b330
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x59660
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %edi
callq 0x475f0
movl %eax, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5b43b
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5a4a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x39770
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5b3f3
leaq -0x10(%rbp), %rdi
callq 0x594f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl -0xc(%rbp), %esi
callq *%rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jne 0x5b4ad
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x5b587
movl -0x2c(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x409d0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
shlq $0x2, %rdx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x40(%rbp), %rsi
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
shlq $0x2, %rdx
callq *%rax
cmpl $0x0, -0xc(%rbp)
je 0x5b571
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x5b56f
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x30770
movl %eax, %edx
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x30770
movl %eax, %edx
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5b522
jmp 0x5b571
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/twoBit.c
// Function: setFileFuncs
static void setFileFuncs( struct twoBitFile *tbf, boolean useUdc)
/* choose the proper function pointers depending on whether
 * this open twoBit is using stdio or UDC
 */
{
if (useUdc)
    {
    tbf->ourSeekCur = udcSeekCurWrap;
    tbf->ourSeek = udcSeekWrap;
    tbf->ourTell = udcTellWrap;
    tbf->ourReadBits32 = udcReadBits32Wrap;
    tbf->ourReadBits64 = udcReadBits64Wrap;
    tbf->ourFastReadString = udcFastReadStringWrap;
    tbf->ourClose = udcFileCloseWrap;
    tbf->ourMustRead = udcMustReadWrap;
    }
else
    {
    tbf->ourSeekCur = seekCurWrap;
    tbf->ourSeek = seekWrap;
    tbf->ourTell = tellWrap;
    tbf->ourReadBits32 = readBits32Wrap;
    tbf->ourReadBits64 = readBits64Wrap;
    tbf->ourFastReadString = fastReadStringWrap;
    tbf->ourClose = fileCloseWrap;
    tbf->ourMustRead = mustReadWrap;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5b625
movq -0x8(%rbp), %rax
leaq 0x100(%rip), %rcx       # 0x5b6b0
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
leaq 0x121(%rip), %rcx       # 0x5b6e0
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq 0x142(%rip), %rcx       # 0x5b710
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq 0x153(%rip), %rcx       # 0x5b730
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0x174(%rip), %rcx       # 0x5b760
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
leaq 0x195(%rip), %rcx       # 0x5b790
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x1b3(%rip), %rcx       # 0x5b7c0
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0x1c4(%rip), %rcx       # 0x5b7e0
movq %rcx, 0x88(%rax)
jmp 0x5b6a3
movq -0x8(%rbp), %rax
leaq 0x1e0(%rip), %rcx       # 0x5b810
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
leaq 0x201(%rip), %rcx       # 0x5b840
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq 0x222(%rip), %rcx       # 0x5b870
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq 0x233(%rip), %rcx       # 0x5b890
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0x254(%rip), %rcx       # 0x5b8c0
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
leaq 0x275(%rip), %rcx       # 0x5b8f0
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x293(%rip), %rcx       # 0x5b920
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0x2a4(%rip), %rcx       # 0x5b940
movq %rcx, 0x88(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: ourRead
static size_t ourRead(struct ioStats *ioStats, int fd, void *buf, size_t size)
{
ioStats->numReads++;
size_t bytesRead = read(fd, buf, size);
ioStats->bytesRead += bytesRead;

return bytesRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6a90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movl $0x4, %edi
leaq 0x82959(%rip), %rsi     # 0xdeb99
movb $0x0, %al
callq 0x60040
movq $0x0, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x42ae0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x5c27a
movl $0x0, -0x4(%rbp)
jmp 0x5c2cb
leaq -0x30(%rbp), %rdi
callq 0x64c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x318f0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x5c2ad
movq -0x30(%rbp), %rsi
leaq 0x82913(%rip), %rdi     # 0xdebb9
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x5c350
cmpq $0x0, %rax
jne 0x5c311
movl $0x0, -0x4(%rbp)
jmp 0x5c341
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x5c32e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x5c730
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x5c98b
movsbl -0x21(%rbp), %edi
callq 0x5f1d0
cmpl $0x0, %eax
je 0x5c980
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xc(%rbp)
jmp 0x5c989
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5c94b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x40c50
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x5ca11
movsbl -0x21(%rbp), %edi
callq 0x5f1d0
cmpl $0x0, %eax
je 0x5c9fb
movq -0x20(%rbp), %rdi
movsbl -0x21(%rbp), %edx
leaq 0x825f8(%rip), %rsi     # 0xdefde
movb $0x0, %al
callq 0x6160
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x5ca0f
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x5c9ad
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5ca84
jmp 0x5cb61
movq -0x20(%rbp), %rdi
callq 0x5cb70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0x40c50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x7fecd(%rip), %rdx     # 0xdc9d6
movb $0x0, %al
callq 0x31090
movq -0x8(%rbp), %rdi
movq 0xaa355(%rip), %rsi     # 0x106e70
callq 0x5cc10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq 0xaa342(%rip), %rsi     # 0x106e78
callq 0x5cc10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq 0xaa32f(%rip), %rsi     # 0x106e80
callq 0x5cc10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: longDirHash
static char *longDirHash(char *name)
/* take a path and hash the elements that are longer than MAXNAMLEN */
{
struct dyString *dy = newDyString(strlen(name));
char *ptr = strchr(name, '/');

while(ptr)
    {
    *ptr = 0;
    addElementToDy(dy, name);

    dyStringAppend(dy, "/");

    name = ptr + 1;
    ptr = strchr(name, '/');
    }

addElementToDy(dy, name);

return dyStringCannibalize(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, %edi
callq 0x35020
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x6260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5cbed
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f260
movq -0x10(%rbp), %rdi
leaq 0x824b7(%rip), %rsi     # 0xdf07f
callq 0x353b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x6260
movq %rax, -0x18(%rbp)
jmp 0x5cba2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f260
leaq -0x10(%rbp), %rdi
callq 0x350c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x62c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x40c50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x6570
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x6570
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, %al
callq 0x4a580
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d1f3
callq 0x5b9a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d720
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x5d218
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5d2b8
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5d2ac
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq 0xa9c36(%rip), %rsi     # 0x106e70
callq 0x2d9a0
cmpl $0x0, %eax
je 0x5d29a
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x30cb0
cmpl $0x0, %eax
je 0x5d28e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ac30
cmpq -0x28(%rbp), %rax
jae 0x5d27c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x4ac30
movq %rax, -0x40(%rbp)
jmp 0x5d284
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5d298
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5d2b8
jmp 0x5d29a
jmp 0x5d29c
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5d220
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcTestAndSetRedirect
static void udcTestAndSetRedirect(struct udcFile *file, char *protocol, boolean useCacheInfo)
/* update redirect info */
{
if (startsWith("http", protocol))
    {
    char *newUrl = NULL;
    // read redir from cache if it exists
    if (fileExists(file->redirFileName))
	{
	readInGulp(file->redirFileName, &newUrl, NULL);
	}
    if (useCacheInfo)
	{
	file->connInfo.redirUrl = cloneString(newUrl);
	}
    else
	{
	if (file->connInfo.redirUrl)
	    {
	    if (!sameOk(file->connInfo.redirUrl, newUrl))
		{
		// write redir to cache
		char *temp = addSuffix(file->redirFileName, ".temp");
		writeGulp(temp, file->connInfo.redirUrl, strlen(file->connInfo.redirUrl));
		rename(temp, file->redirFileName);
		freeMem(temp);
		}
	    }
	else
	    {
	    // delete redir from cache (if it exists)
	    if (newUrl)
		remove(file->redirFileName);
	    }
	}
    freeMem(newUrl);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7e79c(%rip), %rdi     # 0xdbd4a
callq 0x2d3d0
cmpl $0x0, %eax
je 0x5d6c3
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x30cb0
cmpl $0x0, %eax
je 0x5d5eb
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x476d0
cmpl $0x0, -0x14(%rbp)
je 0x5d60d
movq -0x20(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
jmp 0x5d6ba
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x5d6a2
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2d310
cmpl $0x0, %eax
je 0x5d6a0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq 0x81c1d(%rip), %rsi     # 0xdf264
callq 0x2ffb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x62c0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
callq 0x47680
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x6420
movq -0x28(%rbp), %rdi
callq 0x40d40
jmp 0x5d6b8
cmpq $0x0, -0x20(%rbp)
je 0x5d6b6
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x6da0
jmp 0x5d6b8
jmp 0x5d6ba
movq -0x20(%rbp), %rdi
callq 0x40d40
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5cca0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d70a
movq -0x8(%rbp), %rsi
leaq 0x7eb35(%rip), %rdi     # 0xdc238
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x5ca20
cmpq $0x0, -0x30(%rbp)
jne 0x5d759
movq $0x0, -0x8(%rbp)
jmp 0x5d822
movl $0x168, %edi            # imm = 0x168
callq 0x40c50
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5ca60
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2b670
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5d830
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2b670
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5d830
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2b670
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5d830
leaq -0x40(%rbp), %rdi
callq 0x2aad0
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x40d40
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x40d40
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x40d40
movq -0x38(%rbp), %rdi
callq 0x40d40
movq -0x20(%rbp), %rdi
callq 0x40d40
movq -0x28(%rbp), %rdi
callq 0x40d40
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5dc04
movq -0x10(%rbp), %rdi
addq $0x3c, %rdi
callq 0x2ff60
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcPathToUrl
char *udcPathToUrl(const char *path, char *buf, size_t size, char *cacheDir)
/* Translate path into an URL, store in buf, return pointer to buf if successful
 * and NULL if not. */
{
if (cacheDir == NULL)
    cacheDir = udcDefaultDir();
int offset = 0;
if (startsWith(cacheDir, (char *)path))
    offset = strlen(cacheDir);
if (path[offset] == '/')
    offset++;
char protocol[16];
strncpy(protocol, path+offset, sizeof(protocol));
protocol[ArraySize(protocol)-1] = '\0';
char *p = strchr(protocol, '/');
if (p == NULL)
    {
    errAbort("unable to parse protocol (first non-'%s' directory) out of path '%s'\n",
	     cacheDir, path);
    return NULL;
    }
*p++ = '\0';
char afterProtocol[4096];
qDecode(path+1+strlen(protocol)+1, afterProtocol, sizeof(afterProtocol));
safef(buf, size, "%s://%s", protocol, afterProtocol);
return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp           # imm = 0x1060
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5dc3b
callq 0x5b9a0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d3d0
cmpl $0x0, %eax
je 0x5dc60
movq -0x28(%rbp), %rdi
callq 0x62c0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x5dc7a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movl $0x10, %edx
callq 0x6370
movb $0x0, -0x31(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x2f, %esi
callq 0x6260
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x5dcd0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x8101d(%rip), %rdi     # 0xdecdc
movb $0x0, %al
callq 0x35d40
movq $0x0, -0x8(%rbp)
jmp 0x5dd44
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1058(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x62c0
movq -0x1058(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
leaq -0x1050(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x5dd60
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
leaq -0x40(%rbp), %rcx
leaq -0x1050(%rbp), %r8
leaq 0x80fed(%rip), %rdx     # 0xded22
movb $0x0, %al
callq 0x31090
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1060, %rsp           # imm = 0x1060
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: qDecode
static void qDecode(const char *input, char *buf, size_t size)
/* Reverse the qEncode performed on afterProcotol above into buf or abort. */
{
safecpy(buf, size, input);
char c, *r = buf, *w = buf;
while ((c = *r++) != '\0')
    {
    if (c == 'Q')
	{
	int q;
	if (sscanf(r, "%02X", &q))
	    {
	    *w++ = (char)q;
	    r += 2;
	    }
	else
	    errAbort("qDecode: input \"%s\" does not appear to be properly formatted "
		     "starting at \"%s\"", input, r);
	}
    else
	*w++ = c;
    }
*w = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x2caf0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x5de2a
movsbl -0x19(%rbp), %eax
cmpl $0x51, %eax
jne 0x5de11
movq -0x28(%rbp), %rdi
leaq 0x8121a(%rip), %rsi     # 0xdefdf
leaq -0x34(%rbp), %rdx
movb $0x0, %al
callq 0x66d0
cmpl $0x0, %eax
je 0x5ddf9
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x5de0f
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x81462(%rip), %rdi     # 0xdf26a
movb $0x0, %al
callq 0x35d40
jmp 0x5de25
movb -0x19(%rbp), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x5dd95
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcSizeFromCache
long long int udcSizeFromCache(char *url, char *cacheDir)
/* Look up the file size from the local cache bitmap file, or -1 if there
 * is no cache for url. */
{
long long int ret = -1;
if (cacheDir == NULL)
    cacheDir = udcDefaultDir();
struct slName *sl, *slList = udcFileCacheFiles(url, cacheDir);
for (sl = slList;  sl != NULL;  sl = sl->next)
    if (endsWith(sl->name, bitmapName))
	{
	ret = udcSizeAndModTimeFromBitmap(sl->name, NULL);
	break;
	}
slNameFreeList(&slList);
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $-0x1, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5de68
callq 0x5b9a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d720
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5dec7
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq 0xa8fd9(%rip), %rsi     # 0x106e70
callq 0x2d9a0
cmpl $0x0, %eax
je 0x5deb8
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5dee0
movq %rax, -0x18(%rbp)
jmp 0x5dec7
jmp 0x5deba
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5de81
leaq -0x28(%rbp), %rdi
callq 0x2ab30
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcSizeAndModTimeFromBitmap
static long long int udcSizeAndModTimeFromBitmap(char *bitmapFileName, time_t *retTime)
/* Look up the file size from the local cache bitmap file, or -1 if there
 * is no cache for url. If retTime is non-null, store the remote update time in it. */
{
long long int ret = -1;
struct udcBitmap *bits = udcBitmapOpen(bitmapFileName);
if (bits != NULL)
    {
    ret = bits->fileSize;
    if (retTime)
	*retTime = bits->remoteUpdate;
    }
udcBitmapClose(&bits);
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $-0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5e100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5df30
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5df2e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5df30
leaq -0x20(%rbp), %rdi
callq 0x5dbd0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcTimeFromCache
time_t udcTimeFromCache(char *url, char *cacheDir)
/* Look up the file datetime from the local cache bitmap file, or 0 if there
 * is no cache for url. */
{
time_t t = 0;
long long int ret = -1;
if (cacheDir == NULL)
    cacheDir = udcDefaultDir();
struct slName *sl, *slList = udcFileCacheFiles(url, cacheDir);
for (sl = slList;  sl != NULL;  sl = sl->next)
    if (endsWith(sl->name, bitmapName))
	{
	ret = udcSizeAndModTimeFromBitmap(sl->name, &t);
	if (ret == -1)
	    t = 0;
	break;
	}
slNameFreeList(&slList);
return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5df80
callq 0x5b9a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d720
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5dfee
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq 0xa8ec1(%rip), %rsi     # 0x106e70
callq 0x2d9a0
cmpl $0x0, %eax
je 0x5dfdf
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x5dee0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x5dfdd
movq $0x0, -0x18(%rbp)
jmp 0x5dfee
jmp 0x5dfe1
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5df99
leaq -0x30(%rbp), %rdi
callq 0x2ab30
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcCheckCacheBits
boolean udcCheckCacheBits(struct udcFile *file, int startBlock, int endBlock)
/* Warn and return TRUE if any bit in (startBlock,endBlock] is not set. */
{
boolean gotUnset = FALSE;
struct udcBitmap *bitmap = udcBitmapOpen(file->bitmapFileName);
int partOffset;
Bits *bits;
readBitsIntoBuf(file, bitmap->fd, udcBitmapHeaderSize, startBlock, endBlock, &bits, &partOffset);

int partBitStart = startBlock - partOffset;
int partBitEnd = endBlock - partOffset;
int nextClearBit = bitFindClear(bits, partBitStart, partBitEnd);
while (nextClearBit < partBitEnd)
    {
    int clearBlock = nextClearBit + partOffset;
    warn("... udcFile 0x%04lx: bit for block %d (%lld..%lld] is not set",
	 (unsigned long)file, clearBlock,
	 ((long long)clearBlock * udcBlockSize), (((long long)clearBlock+1) * udcBlockSize));
    gotUnset = TRUE;
    int nextSetBit = bitFindSet(bits, nextClearBit, partBitEnd);
    nextClearBit = bitFindClear(bits, nextSetBit, partBitEnd);
    }
return gotUnset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x5e100
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %esi
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl $0x40, %edx
leaq -0x30(%rbp), %r9
leaq -0x24(%rbp), %rax
movq %rax, (%rsp)
callq 0x5e300
movl -0xc(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x240b0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x5e0ed
movl -0x3c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rsi
movl -0x40(%rbp), %edx
movslq -0x40(%rbp), %rcx
shlq $0xd, %rcx
movslq -0x40(%rbp), %r8
addq $0x1, %r8
shlq $0xd, %r8
leaq 0x80c71(%rip), %rdi     # 0xded2a
movb $0x0, %al
callq 0x358e0
movl $0x1, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x24080
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x240b0
movl %eax, -0x3c(%rbp)
jmp 0x5e086
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: readBitsIntoBuf
static void readBitsIntoBuf(struct udcFile *file, int fd, int headerSize, int bitStart, int bitEnd,
	Bits **retBits, int *retPartOffset)
/* Do some bit-to-byte offset conversions and read in all the bytes that
 * have information in the bits we're interested in. */
{
int byteStart = bitStart/8;
int byteEnd = bitToByteSize(bitEnd);
int byteSize = byteEnd - byteStart;
Bits *bits = needLargeMem(byteSize);
ourMustLseek(&file->ios.bit,fd, headerSize + byteStart, SEEK_SET);
ourMustRead(&file->ios.bit, fd, bits, byteSize);
*retBits = bits;
*retPartOffset = byteStart*8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
addl $0x7, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0x40950
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rdx
xorl %ecx, %ecx
callq 0x5e3b0
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movl -0xc(%rbp), %esi
movq -0x38(%rbp), %rdx
movslq -0x2c(%rbp), %rcx
callq 0x5e4f0
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
shll $0x3, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)