LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcCachePreload
static boolean udcCachePreload(struct udcFile *file, bits64 offset, bits64 size)
/* Make sure that given data is in cache - fetching it remotely if need be. 
 * Return TRUE on success. */
{
if (!udcCacheEnabled())
    return TRUE;

boolean ok = TRUE;
/* Original comment said:
 *  "We'll break this operation into blocks of a reasonable size to allow
 *   other processes to get cache access, since we have to lock the cache files."
 * However there is no locking done, so this whole splitting might be unnecessary
 * complexity.
 */
bits64 s,e, endPos=offset+size;
for (s = offset; s < endPos; s = e)
    {
    /* Figure out bounds of this section. */
    e = s + udcMaxBytesPerRemoteFetch;
    if (e > endPos)
	e = endPos;

    struct udcBitmap *bits = file->bits;
    if (bits->version == file->bitmapVersion)
	{
        udcFetchMissing(file, bits, s, e);
	}
    else
	{
	ok = FALSE;
	verbose(4, "udcCachePreload version check failed %d vs %d", 
		bits->version, file->bitmapVersion);
	}
    if (!ok)
        break;
    }
return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x5f810
cmpb $0x0, %al
jne 0x5e419
movl $0x1, -0x4(%rbp)
jmp 0x5e4e0
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x5e4da
movq -0x30(%rbp), %rax
addq $0x40000, %rax          # imm = 0x40000
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0x5e462
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jne 0x5e498
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x5fa60
jmp 0x5e4c3
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
movl $0x4, %edi
leaq 0x80e2e(%rip), %rsi     # 0xdf2ea
movb $0x0, %al
callq 0x60040
cmpl $0x0, -0x24(%rbp)
jne 0x5e4cb
jmp 0x5e4da
jmp 0x5e4cd
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5e434
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadBits64
bits64 udcReadBits64(struct udcFile *file, boolean isSwapped)
/* Read and optionally byte-swap 64 bit entity. */
{
bits64 val;
udcMustRead(file, &val, sizeof(val));
if (isSwapped)
    val = byteSwap64(val);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x5c730
cmpl $0x0, -0xc(%rbp)
je 0x5e5a4
movq -0x18(%rbp), %rdi
callq 0x30650
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadBits32
bits32 udcReadBits32(struct udcFile *file, boolean isSwapped)
/* Read and optionally byte-swap 32 bit entity. */
{
bits32 val;
udcMustRead(file, &val, sizeof(val));
if (isSwapped)
    val = byteSwap32(val);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x5c730
cmpl $0x0, -0xc(%rbp)
je 0x5e5e2
movl -0x10(%rbp), %edi
callq 0x30770
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadBits16
bits16 udcReadBits16(struct udcFile *file, boolean isSwapped)
/* Read and optionally byte-swap 16 bit entity. */
{
bits16 val;
udcMustRead(file, &val, sizeof(val));
if (isSwapped)
    val = byteSwap16(val);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xe(%rbp), %rsi
movl $0x2, %edx
callq 0x5c730
cmpl $0x0, -0xc(%rbp)
je 0x5e624
movzwl -0xe(%rbp), %edi
callq 0x30870
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadFloat
float udcReadFloat(struct udcFile *file, boolean isSwapped)
/* Read and optionally byte-swap floating point number. */
{
float val;
udcMustRead(file, &val, sizeof(val));
if (isSwapped)
    val = byteSwapFloat(val);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x5c730
cmpl $0x0, -0xc(%rbp)
je 0x5e666
movss -0x10(%rbp), %xmm0
callq 0x30a60
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadDouble
double udcReadDouble(struct udcFile *file, boolean isSwapped)
/* Read and optionally byte-swap double-precision floating point number. */
{
double val;
udcMustRead(file, &val, sizeof(val));
if (isSwapped)
    val = byteSwapDouble(val);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x5c730
cmpl $0x0, -0xc(%rbp)
je 0x5e6b6
movsd -0x18(%rbp), %xmm0
callq 0x30970
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadLine
char *udcReadLine(struct udcFile *file)
/* Fetch next line from udc cache or NULL. */
{
char shortBuf[2], *longBuf = NULL, *buf = shortBuf;
int i, bufSize = sizeof(shortBuf);
for (i=0; ; ++i)
    {
    /* See if need to expand buffer, which is initially on stack, but if it gets big goes into 
     * heap. */
    if (i >= bufSize)
        {
	int newBufSize = bufSize*2;
	char *newBuf = needLargeMem(newBufSize);
	memcpy(newBuf, buf, bufSize);
	freeMem(longBuf);
	buf = longBuf = newBuf;
	bufSize = newBufSize;
	}

    char c;
    bits64 sizeRead = udcRead(file, &c, 1);
    if (sizeRead == 0)
	return NULL;
    buf[i] = c;
    if (c == '\n')
	{
	buf[i] = 0;
	break;
	}
    }
char *retString = cloneString(buf);
freeMem(longBuf);
return retString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x12(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x2, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jl 0x5e743
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
callq 0x40950
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x6570
movq -0x20(%rbp), %rdi
callq 0x40d40
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x41(%rbp), %rsi
movl $0x1, %edx
callq 0x5c350
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x5e76a
movq $0x0, -0x8(%rbp)
jmp 0x5e7bd
movb -0x41(%rbp), %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movsbl -0x41(%rbp), %eax
cmpl $0xa, %eax
jne 0x5e78f
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5e79f
jmp 0x5e791
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5e6fa
movq -0x28(%rbp), %rdi
callq 0x2a450
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40d40
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadStringAndZero
char *udcReadStringAndZero(struct udcFile *file)
/* Read in zero terminated string from file.  Do a freeMem of result when done. */
{
char shortBuf[2], *longBuf = NULL, *buf = shortBuf;
int i, bufSize = sizeof(shortBuf);
for (i=0; ; ++i)
    {
    /* See if need to expand buffer, which is initially on stack, but if it gets big goes into 
     * heap. */
    if (i >= bufSize)
        {
	int newBufSize = bufSize*2;
	char *newBuf = needLargeMem(newBufSize);
	memcpy(newBuf, buf, bufSize);
	freeMem(longBuf);
	buf = longBuf = newBuf;
	bufSize = newBufSize;
	}
    char c = udcGetChar(file);
    buf[i] = c;
    if (c == 0)
        break;
    }
char *retString = cloneString(buf);
freeMem(longBuf);
return retString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0xa(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x5e843
movl -0x28(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0x40950
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x6570
movq -0x18(%rbp), %rdi
callq 0x40d40
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5e540
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movsbl -0x39(%rbp), %eax
cmpl $0x0, %eax
jne 0x5e868
jmp 0x5e875
jmp 0x5e86a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5e7fa
movq -0x20(%rbp), %rdi
callq 0x2a450
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40d40
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcFileReadAll
char *udcFileReadAll(char *url, char *cacheDir, size_t maxSize, size_t *retSize)
/* Read a complete file via UDC. The cacheDir may be null in which case udcDefaultDir()
 * will be used.  If maxSize is non-zero, check size against maxSize
 * and abort if it's bigger.  Returns file data (with an extra terminal for the
 * common case where it's treated as a C string).  If retSize is non-NULL then
 * returns size of file in *retSize. Do a freeMem or freez of the returned buffer
 * when done. */
{
struct udcFile  *file = udcFileOpen(url, cacheDir);
size_t size = file->size;
if (maxSize != 0 && size > maxSize)
    errAbort("%s is %lld bytes, but maxSize to udcFileReadAll is %lld",
    	url, (long long)size, (long long)maxSize);
char *buf = needLargeMem(size+1);
udcMustRead(file, buf, size);
buf[size] = 0;	// add trailing zero for string processing
udcFileClose(&file);
if (retSize != NULL)
    *retSize = size;
return buf;
}

// 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)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d6d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e900
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5e900
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x804ba(%rip), %rdi     # 0xdedb3
movb $0x0, %al
callq 0x35d40
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x40950
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5c730
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
leaq -0x28(%rbp), %rdi
callq 0x5d870
cmpq $0x0, -0x20(%rbp)
je 0x5e949
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%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: udcSeekCur
void udcSeekCur(struct udcFile *file, bits64 offset)
/* Seek to a particular position in file. */
{
file->ios.udc.numSeeks++;
file->offset += offset;
if (udcCacheEnabled())
    ourMustLseek(&file->ios.sparse,file->fdSparse, offset, SEEK_CUR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
callq 0x5f810
cmpb $0x0, %al
je 0x5ea23
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x5e3b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcSeek
void udcSeek(struct udcFile *file, bits64 offset)
/* Seek to a particular position in file. */
{
file->ios.udc.numSeeks++;
file->offset = offset;
if (udcCacheEnabled())
    ourMustLseek(&file->ios.sparse,file->fdSparse, offset, SEEK_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
callq 0x5f810
cmpb $0x0, %al
je 0x5ea8c
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5e3b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcCleanup
bits64 udcCleanup(char *cacheDir, double maxDays, boolean testOnly)
/* Remove cached files older than maxDays old. If testOnly is set
 * no clean up is done, but the size of the files that would be
 * cleaned up is still. */

{
time_t maxSeconds = maxDays * 24 * 60 * 60;
char *curPath = cloneString(getCurrentDir());
setCurrentDir(cacheDir);
time_t deleteTime = time(NULL) - maxSeconds;
bits64 result = rCleanup(deleteTime, testOnly);
setCurrentDir(curPath);
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd 0x7fdcc(%rip), %xmm0    # 0xde8a8
mulsd -0x10(%rbp), %xmm0
movsd 0x7fdb7(%rip), %xmm1    # 0xde8a0
mulsd %xmm1, %xmm0
movsd 0x7fdab(%rip), %xmm1    # 0xde8a0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x20(%rbp)
movb $0x0, %al
callq 0x4a5b0
movq %rax, %rdi
callq 0x2a450
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4a5f0
xorl %eax, %eax
movl %eax, %edi
callq 0x6660
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5eb60
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4a5f0
movq -0x38(%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: udcUpdateTime
time_t udcUpdateTime(struct udcFile *udc)
/* return udc->updateTime */
{
if (sameString("transparent", udc->protocol))
    {
    struct stat status;
    int ret = stat(udc->url, &status);
    if (ret < 0)
	return 0;
    else
	return  status.st_mtime;
    }
return udc->updateTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x7fe9c(%rip), %rdi     # 0xdec2a
callq 0x6a40
cmpl $0x0, %eax
jne 0x5edcf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6d00
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jge 0x5edc5
movq $0x0, -0x8(%rbp)
jmp 0x5eddb
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eddb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcFileSize
off_t udcFileSize(char *url)
/* fetch file size from given URL or local path 
 * returns -1 if not found. */
{
if (udcIsLocal(url))
    return fileSize(url);

// don't go to the network if we can avoid it
int cacheSize = udcSizeFromCache(url, NULL);
if (cacheSize!=-1)
    return cacheSize;

off_t ret = -1;
struct udcRemoteFileInfo info;

if (startsWith("http://",url) || startsWith("https://",url))
    {
    if (udcInfoViaHttp(url, &info))
	ret = info.size;
    }
else if (startsWith("ftp://",url))
    {
    if (udcInfoViaFtp(url, &info))
	ret = info.size;
    }
else
    errAbort("udc/udcFileSize: invalid protocol for url %s, can only do http/https/ftp", url);

return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5eef0
cmpl $0x0, %eax
je 0x5ee1c
movq -0x10(%rbp), %rdi
callq 0x4a3e0
movq %rax, -0x8(%rbp)
jmp 0x5eeda
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5de40
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x5ee3f
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eeda
movq $-0x1, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7c60e(%rip), %rdi     # 0xdb460
callq 0x2d3d0
cmpl $0x0, %eax
jne 0x5ee71
movq -0x10(%rbp), %rsi
leaq 0x7c601(%rip), %rdi     # 0xdb468
callq 0x2d3d0
cmpl $0x0, %eax
je 0x5ee8d
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5beb0
cmpl $0x0, %eax
je 0x5ee8b
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5eed2
movq -0x10(%rbp), %rsi
leaq 0x7c5d9(%rip), %rdi     # 0xdb471
callq 0x2d3d0
cmpl $0x0, %eax
je 0x5eebe
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5c220
cmpl $0x0, %eax
je 0x5eebc
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5eed0
movq -0x10(%rbp), %rsi
leaq 0x7ff22(%rip), %rdi     # 0xdedeb
movb $0x0, %al
callq 0x35d40
jmp 0x5eed2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcIsLocal
boolean udcIsLocal(char *url) 
/* return true if file is not a http or ftp file, just a local file */
{
// copied from above
char *protocol = NULL, *afterProtocol = NULL, *colon;
udcParseUrl(url, &protocol, &afterProtocol, &colon);
freez(&protocol);
freez(&afterProtocol);
return colon==NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x5ca20
leaq -0x10(%rbp), %rdi
callq 0x40d70
leaq -0x18(%rbp), %rdi
callq 0x40d70
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcMMap
void udcMMap(struct udcFile *file)
/* Enable access to underlying file as memory using mmap.  udcMMapFetch
 * must be called to actually access regions of the file. */
{
if (file->mmapBase != NULL)
    errAbort("File is already mmaped: %s", file->url);
file->mmapBase = mmap(NULL, file->size, PROT_READ, MAP_SHARED, file->fdSparse, 0);
if (file->mmapBase == MAP_FAILED)
    errnoAbort("mmap() failed for %s", file->url);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x5efb0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7fe8b(%rip), %rdi     # 0xdee34
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x66c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, %rcx
cmpq %rcx, 0xb0(%rax)
jne 0x5f00c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7fe4a(%rip), %rdi     # 0xdee4f
movb $0x0, %al
callq 0x35ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcMMapFetch
void *udcMMapFetch(struct udcFile *file, bits64 offset, bits64 size)
/* Return pointer to a region of the file in memory, ensuring that regions is
 * cached. udcMMap must have been called to enable access.  This must be
 * called for first access to a range of the file or erroneous (zeros) data
 * maybe returned.  Maybe called multiple times on a range or overlapping
 * returns. */
{
if (file->mmapBase == NULL)
    errAbort("udcMMap() has not been called for: %s", file->url);
if ((offset + size) > file->size)
    errAbort("udcMMapFetch on offset %lld for %lld bytes exceeds length of file %lld on %s",
             offset, size, file->size, file->url);
if (udcCacheEnabled() && !sameString(file->protocol, "transparent"))
    udcCachePreload(file, offset, size);
return ((char*)file->mmapBase) + offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0x5f058
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7fe13(%rip), %rdi     # 0xdee64
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x5f090
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x7fe01(%rip), %rdi     # 0xdee8a
movb $0x0, %al
callq 0x35d40
callq 0x5f810
movsbl %al, %eax
cmpl $0x0, %eax
je 0x5f0c7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x7fb7e(%rip), %rsi     # 0xdec2a
callq 0x6a40
cmpl $0x0, %eax
je 0x5f0c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5e3f0
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
addq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcReadAndIgnore
static void udcReadAndIgnore(struct ioStats *ioStats, int sd, bits64 size)
/* Read size bytes from sd and return. */
{
static char *buf = NULL;
if (buf == NULL)
    buf = needMem(udcBlockSize);
bits64 remaining = size, total = 0;
while (remaining > 0)
    {
    bits64 chunkSize = min(remaining, udcBlockSize);
    ssize_t rd = ourRead(ioStats, sd, buf, chunkSize);
    if (rd < 0)
	errnoAbort("udcReadAndIgnore: error reading socket after %lld bytes", total);
    remaining -= rd;
    total += rd;
    }
if (total < size)
    errAbort("udcReadAndIgnore: got EOF at %lld bytes (wanted %lld)", total, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0xab54d(%rip)     # 0x10a648
jne 0x5f10e
movl $0x2000, %edi           # imm = 0x2000
callq 0x40c50
movq %rax, 0xab53a(%rip)     # 0x10a648
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x5f19d
cmpq $0x2000, -0x20(%rbp)    # imm = 0x2000
jae 0x5f139
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5f144
movl $0x2000, %eax           # imm = 0x2000
movq %rax, -0x40(%rbp)
jmp 0x5f144
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0xab4ee(%rip), %rdx     # 0x10a648
movq -0x30(%rbp), %rcx
callq 0x5be50
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x5f180
movq -0x28(%rbp), %rsi
leaq 0x7fdf7(%rip), %rdi     # 0xdef70
movb $0x0, %al
callq 0x35ee0
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5f11e
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5f1bd
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x7fdf2(%rip), %rdi     # 0xdefa8
movb $0x0, %al
callq 0x35d40
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: qEscaped
static boolean qEscaped(char c)
/* Returns TRUE if character needs to be escaped in q-encoding. */
{
if (isalnum(c))
    return c == 'Q';
else
    return c != '_' && c != '-' && c != '/' && c != '.';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
callq 0x6780
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5f20d
movsbl -0x5(%rbp), %eax
cmpl $0x51, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5f24f
movsbl -0x5(%rbp), %ecx
xorl %eax, %eax
cmpl $0x5f, %ecx
movb %al, -0x6(%rbp)
je 0x5f244
movsbl -0x5(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x6(%rbp)
je 0x5f244
movsbl -0x5(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x6(%rbp)
je 0x5f244
movsbl -0x5(%rbp), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: addElementToDy
static void addElementToDy(struct dyString *dy, char *name)
/* add one element of a path to a dyString, hashing it if it's longer 
 * than MAXNAMLEN */
{
if (strlen(name) > MAXNAMLEN)
    {
    unsigned char hash[SHA_DIGEST_LENGTH];
    char newName[(SHA_DIGEST_LENGTH + 1) * 2];

    SHA1((const unsigned char *)name, strlen(name), hash);
    hexBinaryString(hash,  SHA_DIGEST_LENGTH, newName, (SHA_DIGEST_LENGTH + 1) * 2);
    
    dyStringAppend(dy, newName);
    }
else
    dyStringAppend(dy, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
cmpq $0xff, %rax
jbe 0x5f2c8
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
leaq -0x30(%rbp), %rdx
callq 0x6120
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movl $0x14, %esi
movl $0x2a, %ecx
callq 0x68030
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x353b0
jmp 0x5f2d5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x353b0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcDataViaLocal
static int udcDataViaLocal(char *url, bits64 offset, int size, void *buffer, struct udcFile *file)
/* Fetch a block of data of given size into buffer using the http: protocol.
* Returns number of bytes actually read.  Does an errAbort on
* error.  Typically will be called with size in the 8k - 64k range. */
{
/* Need to check time stamp here. */
verbose(4, "reading remote data - %d bytes at %lld - on %s\n", size, offset, url);
url = assertLocalUrl(url);
FILE *f = mustOpen(url, "rb");
fseek(f, offset, SEEK_SET);
int sizeRead = ourFread(&file->ios.net, buffer, 1, size, f);
if (ferror(f))
    {
    warn("udcDataViaLocal failed to fetch %d bytes at %lld", size, offset);
    errnoAbort("file %s", url);
    }
carefulClose(&f);
return sizeRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
movl $0x4, %edi
leaq 0x7fdab(%rip), %rsi     # 0xdf0bd
movb $0x0, %al
callq 0x60040
movq -0x8(%rbp), %rdi
callq 0x5f6e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7900d(%rip), %rsi     # 0xd833e
callq 0x2f780
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x67c0
movq -0x28(%rbp), %rdi
addq $0xb8, %rdi
addq $0x78, %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x1, %edx
callq 0x5f7b0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6e10
cmpl $0x0, %eax
je 0x5f3a6
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq 0x7fca1(%rip), %rdi     # 0xdf02e
movb $0x0, %al
callq 0x358e0
movq -0x8(%rbp), %rsi
leaq 0x8214b(%rip), %rdi     # 0xe14ea
movb $0x0, %al
callq 0x35ee0
leaq -0x30(%rbp), %rdi
callq 0x301d0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcInfoViaLocal
static boolean udcInfoViaLocal(char *url, struct udcRemoteFileInfo *retInfo)
/* Fill in *retTime with last modified time for file specified in url.
 * Return FALSE if file does not even exist. */
{
verbose(4, "checking remote info on %s\n", url);
url = assertLocalUrl(url);
struct stat status;
int ret = stat(url, &status);
if (ret < 0)
    return FALSE;
retInfo->updateTime = status.st_mtime;
retInfo->size = status.st_size;
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movl $0x4, %edi
leaq 0x7fd55(%rip), %rsi     # 0xdf138
movb $0x0, %al
callq 0x60040
movq -0x10(%rbp), %rdi
callq 0x5f6e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6d00
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jge 0x5f41f
movl $0x0, -0x4(%rbp)
jmp 0x5f43d
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcDataViaSlow
static int udcDataViaSlow(char *url, bits64 offset, int size, void *buffer, struct udcFile *file)
/* Fetch a block of data of given size into buffer using the http: protocol.
* Returns number of bytes actually read.  Does an errAbort on
* error.  Typically will be called with size in the 8k - 64k range. */
{
verbose(4, "slow reading remote data - %d bytes at %lld - on %s\n", size, offset, url);
sleep1000(500);
char *fileName = url + 5;  /* skip over 'slow:' */
FILE *f = mustOpen(fileName, "rb");
fseek(f, offset, SEEK_SET);
char *pt = buffer;
int i, step=1024;
int sizeRead = 0;
for (i=0; i<size; i += step)
    {
    sleep1000(250);
    int readChunk = size - i;
    if (readChunk > step)
        readChunk = step;
    int oneReadSize = ourFread(&file->ios.net, pt, 1, readChunk, f);
    verbose(4, "slowly read %d bytes\n", oneReadSize);
    if (ferror(f))
	{
	warn("udcDataViaSlow failed to fetch %d bytes at %lld", size, offset);
	errnoAbort("file %s", fileName);
	}
    pt += step;
    sizeRead += oneReadSize;
    }
carefulClose(&f);
return sizeRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
movl $0x4, %edi
leaq 0x7fc36(%rip), %rsi     # 0xdf0b8
movb $0x0, %al
callq 0x60040
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x4a520
movq -0x8(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x78e94(%rip), %rsi     # 0xd833e
callq 0x2f780
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x67c0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x400, -0x48(%rbp)     # imm = 0x400
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5f5a7
movl $0xfa, %edi
callq 0x4a520
movl -0x14(%rbp), %eax
subl -0x44(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x5f50c
movl -0x48(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
addq $0xb8, %rdi
addq $0x78, %rdi
movq -0x40(%rbp), %rsi
movslq -0x50(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x1, %edx
callq 0x5f7b0
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %edx
movl $0x4, %edi
leaq 0x7fbaa(%rip), %rsi     # 0xdf0ed
movb $0x0, %al
callq 0x60040
movq -0x38(%rbp), %rdi
callq 0x6e10
cmpl $0x0, %eax
je 0x5f57f
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq 0x7fb9d(%rip), %rdi     # 0xdf103
movb $0x0, %al
callq 0x358e0
movq -0x30(%rbp), %rsi
leaq 0x81f72(%rip), %rdi     # 0xe14ea
movb $0x0, %al
callq 0x35ee0
movl -0x48(%rbp), %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x54(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x48(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x5f4df
leaq -0x38(%rbp), %rdi
callq 0x301d0
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcInfoViaSlow
static boolean udcInfoViaSlow(char *url, struct udcRemoteFileInfo *retInfo)
/* Fill in *retTime with last modified time for file specified in url.
 * Return FALSE if file does not even exist. */
{
char *fileName = url + 5;  /* skip over 'slow:' */
verbose(4, "slow checking remote info on %s\n", url);
sleep1000(500);
struct stat status;
int ret = stat(fileName, &status);
if (ret < 0)
    return FALSE;
retInfo->updateTime = status.st_mtime;
retInfo->size = status.st_size;
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movl $0x4, %edi
leaq 0x7fb44(%rip), %rsi     # 0xdf133
movb $0x0, %al
callq 0x60040
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x4a520
movq -0x20(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6d00
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
jge 0x5f628
movl $0x0, -0x4(%rbp)
jmp 0x5f646
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x80(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: assertLocalUrl
static char *assertLocalUrl(char *url)
/* Make sure that url is local and return bits past the protocol. */
{
if (startsWith("local:", url))
    url += 6;
if (url[0] != '/')
    errAbort("Local urls must start at /");
if (stringIn("..", url) || stringIn("~", url) || stringIn("//", url) ||
    stringIn("/./", url) || endsWith("/.", url))
    {
    errAbort("relative paths not allowed in local urls (%s)", url);
    }
return url;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x7f968(%rip), %rdi     # 0xdf05f
callq 0x2d3d0
cmpl $0x0, %eax
je 0x5f70d
movq -0x8(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x5f727
leaq 0x7f946(%rip), %rdi     # 0xdf066
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rdi
leaq 0x7de51(%rip), %rsi     # 0xdd583
callq 0x6170
cmpq $0x0, %rax
jne 0x5f794
movq -0x8(%rbp), %rdi
leaq 0x7f939(%rip), %rsi     # 0xdf081
callq 0x6170
cmpq $0x0, %rax
jne 0x5f794
movq -0x8(%rbp), %rdi
leaq 0x84a3d(%rip), %rsi     # 0xe419b
callq 0x6170
cmpq $0x0, %rax
jne 0x5f794
movq -0x8(%rbp), %rdi
leaq 0x7f90f(%rip), %rsi     # 0xdf083
callq 0x6170
cmpq $0x0, %rax
jne 0x5f794
movq -0x8(%rbp), %rsi
leaq 0x7f8fd(%rip), %rdi     # 0xdf087
callq 0x2d9a0
cmpl $0x0, %eax
je 0x5f7a6
movq -0x8(%rbp), %rsi
leaq 0x7f8eb(%rip), %rdi     # 0xdf08a
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: udcFetchMissing
static void udcFetchMissing(struct udcFile *file, struct udcBitmap *bits, bits64 start, bits64 end)
/* Fetch missing pieces of data from file */
{
/* Call lower level routine fetch remote data that is not already here. */
bits64 fetchedStart, fetchedEnd;
if (fetchMissingBits(file, bits, start, end, &fetchedStart, &fetchedEnd))
    return;

/* Update file startData/endData members to include new data (and old as well if
 * the new data overlaps the old). */
if (rangeIntersectOrTouch64(file->startData, file->endData, fetchedStart, fetchedEnd))
    {
    if (fetchedStart > file->startData)
        fetchedStart = file->startData;
    if (fetchedEnd < file->endData)
        fetchedEnd = file->endData;
    }
file->startData = fetchedStart;
file->endData = fetchedEnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0x5fb20
cmpl $0x0, %eax
je 0x5fa9c
jmp 0x5fb18
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x5fd20
cmpl $0x0, %eax
je 0x5fafd
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jbe 0x5fadb
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x5fafb
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5fafd
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: rangeIntersectOrTouch64
static boolean rangeIntersectOrTouch64(bits64 start1, bits64 end1, bits64 start2, bits64 end2)
/* Return true if two 64-bit ranges intersect or touch. */
{  // cannot use the version of this function that is in common.c since it only handles integers.
bits64 s = max(start1,start2);
bits64 e = min(end1,end2);
return e >= s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5fd48
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5fd50
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5fd6c
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5fd74
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: allBitsSetInFile
static boolean allBitsSetInFile(int bitStart, int bitEnd, int partOffset, Bits *bits)
/* Return TRUE if all bits in file between start and end are set. */
{
int partBitStart = bitStart - partOffset;
int partBitEnd = bitEnd - partOffset;
int nextClearBit = bitFindClear(bits, partBitStart, partBitEnd);
boolean allSet = (nextClearBit >= partBitEnd);
return allSet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x240b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: fetchMissingBlocks
static void fetchMissingBlocks(struct udcFile *file, struct udcBitmap *bits, 
	int startBlock, int blockCount, int blockSize)
/* Fetch missing blocks from remote and put them into file.  errAbort if trouble. */
{
bits64 startPos = (bits64)startBlock * blockSize;
bits64 endPos = startPos + (bits64)blockCount * blockSize;
if (endPos > file->size)
    endPos = file->size;
if (endPos > startPos)
    {
    bits64 readSize = endPos - startPos;
    void *buf = needLargeMem(readSize);
    
    int actualSize = file->prot->fetchData(file->url, startPos, readSize, buf, file);
    if (actualSize != readSize)
	errAbort("unable to fetch %lld bytes from %s @%lld (got %d bytes)",
		 readSize, file->url, startPos, actualSize);
    ourMustLseek(&file->ios.sparse, file->fdSparse, startPos, SEEK_SET);
    ourMustWrite(&file->ios.sparse, file->fdSparse, buf, readSize);
    freez(&buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movslq -0x14(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x5fe4b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x5ff16
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40950
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rcx
movl %ecx, %edx
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %r8
callq *%rax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x5fec9
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rcx
movl -0x44(%rbp), %r8d
leaq 0x7f456(%rip), %rdi     # 0xdf318
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5e3b0
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x5fa10
leaq -0x40(%rbp), %rdi
callq 0x40d70
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/udc.c
// Function: bitRealDataSize
static long bitRealDataSize(char *fileName)
/* Return number of real bytes indicated by bitmaps */
{
struct udcBitmap *bits = udcBitmapOpen(fileName);
int blockSize = bits->blockSize;
long byteSize = 0;
int blockCount = (bits->fileSize + blockSize - 1)/blockSize;
if (blockCount > 0)
    {
    int bitmapSize = bitToByteSize(blockCount);
    Bits *b = needLargeMem(bitmapSize);
    mustReadFd( bits->fd, b, bitmapSize);
    int bitsSet = bitCountRange(b, 0, blockCount);
    byteSize = (long)bitsSet*blockSize;
    freez(&b);
    }
udcBitmapClose(&bits);
return byteSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5e100
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
subq $0x1, %rax
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x5ffcc
movl -0x24(%rbp), %eax
addl $0x7, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
callq 0x40950
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edi
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x2fdb0
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
xorl %esi, %esi
callq 0x23e00
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x40d70
leaq -0x10(%rbp), %rdi
callq 0x5dbd0
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/wildcmp.c
// Function: wildExpandList
struct slName *wildExpandList(struct slName *allList, struct slName *wildList, boolean abortMissing)
/* Wild list is a list of names, possibly including * and ? wildcard characters.  This 
 * function returns names taken from allList that match patterns in wildList.  Works much
 * like wildcard expansion over a file system but expands over allList instead. */
{
/* Build hash of allList */
struct hash *allHash = hashNew(0);
struct slName *name;
for (name = allList; name != NULL; name = name->next)
    hashAdd(allHash, name->name, NULL);

/* Expand any field names with wildcards. */
struct slName *expandedList = NULL;
struct slName *field;
for (field = wildList; field != NULL; field = field->next)
    {
    char *name = field->name;
    if (anyWild(name))
        {
	int addCount = addMatching(name, allList, &expandedList);
	if (addCount == 0 && abortMissing)
	    errAbort("No match for %s", name);
	}
    else
        {
	if (abortMissing && !hashLookup(allHash, name))
	    errAbort("No match for %s", name);
	slNameAddHead(&expandedList, name);
	}
    }
hashFree(&allHash);
slReverse(&expandedList);
return expandedList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x606b4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x39230
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6068b
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x60767
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x60410
cmpl $0x0, %eax
je 0x6071d
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x60790
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x6071b
cmpl $0x0, -0x14(%rbp)
je 0x6071b
movq -0x40(%rbp), %rsi
leaq 0x7eca5(%rip), %rdi     # 0xdf3b9
movb $0x0, %al
callq 0x35d40
jmp 0x60755
cmpl $0x0, -0x14(%rbp)
je 0x60748
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x38e20
cmpq $0x0, %rax
jne 0x60748
movq -0x40(%rbp), %rsi
leaq 0x7ec78(%rip), %rdi     # 0xdf3b9
movb $0x0, %al
callq 0x35d40
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2bc40
jmp 0x60757
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x606c4
leaq -0x20(%rbp), %rdi
callq 0x3a080
leaq -0x30(%rbp), %rdi
callq 0x2aad0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/wildcmp.c
// Function: addMatching
static int addMatching(char *pattern, struct slName *itemList, struct slName **retMatchList)
/* Add all items that match pattern to retMatchList */
{
int count = 0;
struct slName *item;
for (item = itemList; item != NULL; item = item->next)
    {
    char *name = item->name;
    if (wildMatch(pattern, name))
         {
	 slNameAddHead(retMatchList, name);
	 ++count;
	 }
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x607fd
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x60460
cmpl $0x0, %eax
je 0x607ee
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2bc40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x607f0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x607b3
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/base64.c
// Function: base64Validate
boolean base64Validate(char *input)
/* Return true if input is valid base64.
 * Note that the input string is changed by 
 * eraseWhiteSpace(). */
{
size_t i = 0, l = 0;
char *p = input;
boolean validB64 = TRUE;

/* remove whitespace which is unnecessary and  */
eraseWhiteSpace(input);  

l = strlen(p);
for(i=0;i<l;i++)
    {
    char c = ' ';
    if (!strchr(B64CHARS,c=*p++))
        {
        if (c != '=')
            {
            validB64 = FALSE;
            break;
            }
        }
    }
if (l%4)
    validB64 = FALSE;
return validB64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ee00
movq -0x20(%rbp), %rdi
callq 0x62c0
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x60bd4
movb $0x20, -0x25(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl %al, %esi
leaq 0x7e86c(%rip), %rdi     # 0xdf411
callq 0x6260
cmpq $0x0, %rax
jne 0x60bc4
movsbl -0x25(%rbp), %eax
cmpl $0x3d, %eax
je 0x60bc2
movl $0x0, -0x24(%rbp)
jmp 0x60bd4
jmp 0x60bc4
jmp 0x60bc6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x60b79
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x60be9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)