LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netWaitForData
int netWaitForData(int sd, int microseconds)
/* Wait for descriptor to have some data to read, up to given number of
 * microseconds.  Returns amount of data there or zero if timed out. */
{
struct timeval tv;
fd_set set;
int readyCount;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jl 0x429cf
movl -0x8(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x10(%rbp)
jmp 0x429df
movq $0x0, -0x18(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x429e1
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
cmpq $0x10, %rax
jae 0x42a2b
movq -0xa8(%rbp), %rax
movl -0xa0(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xa0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa0(%rbp)
jmp 0x429f9
jmp 0x42a2d
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x4(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x98(%rbp,%rax,8), %rcx
movq %rcx, -0x98(%rbp,%rax,8)
movl -0x4(%rbp), %edi
addl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rdx
callq 0x66b0
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
jge 0x42abe
callq 0x6060
cmpl $0x4, (%rax)
jne 0x42a9f
jmp 0x429a1
callq 0x6060
movl (%rax), %edi
callq 0x6220
movq %rax, %rsi
leaq 0x992e5(%rip), %rdi     # 0xdbd9a
movb $0x0, %al
callq 0x358e0
jmp 0x42acd
movl -0x9c(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
jmp 0x429a1
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: openFtpControlSocket
static int openFtpControlSocket(char *host, int port, char *user, char *password)
/* Open a socket to host,port; authenticate anonymous ftp; set type to I; 
 * return socket desc or -1 if there was an error. */
{
int sd = netConnect(host, port);
if (sd < 0)
    return -1;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x41710
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x42d5b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e68
movl -0x2c(%rbp), %edi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x45e00
cmpl $0x0, %eax
je 0x42d83
movl -0x2c(%rbp), %edi
leaq 0xa268f(%rip), %rsi     # 0xe5406
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x42e80
movl $0x0, -0x134(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x99903(%rip), %rdx     # 0xdc6a7
movb $0x0, %al
callq 0x31090
movl -0x2c(%rbp), %edi
leaq -0x130(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x134(%rbp), %rcx
callq 0x42e80
cmpl $0x0, %eax
jne 0x42dde
movl -0x2c(%rbp), %edi
callq 0x6e90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e68
cmpl $0x14b, -0x134(%rbp)    # imm = 0x14B
jne 0x42e36
leaq -0x130(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x998b0(%rip), %rdx     # 0xdc6b1
movb $0x0, %al
callq 0x31090
movl -0x2c(%rbp), %edi
leaq -0x130(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x42e80
cmpl $0x0, %eax
jne 0x42e34
movl -0x2c(%rbp), %edi
callq 0x6e90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e68
jmp 0x42e36
movl -0x2c(%rbp), %edi
leaq 0x9987b(%rip), %rsi     # 0xdc6bb
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x42e80
cmpl $0x0, %eax
jne 0x42e62
movl -0x2c(%rbp), %edi
callq 0x6e90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e68
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: parseFtpSIZE
static long long parseFtpSIZE(char *rs)
/* parse reply to SIZE and return it */
{
char *words[3];
int wordCount;
char *rsStart = rs;
long long result = 0;
wordCount = chopString(rsStart, " ", words, ArraySize(words));
if (wordCount != 2)
    errAbort("SIZE reply does not parse correctly");
result = atoll(words[1]);    
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq 0x9543f(%rip), %rsi     # 0xd832a
movl $0x3, %ecx
callq 0x2e840
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
je 0x42f0c
leaq 0x99816(%rip), %rdi     # 0xdc71b
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rdi
callq 0x6520
movq %rax, -0x38(%rbp)
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/net.c
// Function: connectNpu
int connectNpu(struct netParsedUrl npu, char *url, boolean noProxy)
/* Connect using NetParsedUrl. */
{
int sd = -1;
if (sameString(npu.protocol, "http"))
    {
    sd = netConnect(npu.host, atoi(npu.port));
    }
else if (sameString(npu.protocol, "https"))
    {
    sd = netConnectHttps(npu.host, atoi(npu.port), noProxy);
    }
else
    {
    errAbort("netHttpConnect: url (%s) is not for http.", url);
    return -1;  /* never gets here, fixes compiler complaint */
    }
return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq 0x98aa2(%rip), %rsi     # 0xdbd4a
callq 0x6a40
cmpl $0x0, %eax
jne 0x432df
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x28(%rbp)
addq $0x1810, %rdi           # imm = 0x1810
callq 0x6bd0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x41710
movl %eax, -0x18(%rbp)
jmp 0x43341
movq -0x20(%rbp), %rdi
leaq 0x98a65(%rip), %rsi     # 0xdbd4f
callq 0x6a40
cmpl $0x0, %eax
jne 0x43324
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x30(%rbp)
addq $0x1810, %rdi           # imm = 0x1810
callq 0x6bd0
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl -0x14(%rbp), %edx
callq 0x6c100
movl %eax, -0x18(%rbp)
jmp 0x4333f
movq -0x10(%rbp), %rsi
leaq 0x98ab9(%rip), %rdi     # 0xdbde8
movb $0x0, %al
callq 0x35d40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43347
jmp 0x43341
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: setAuthorization
void setAuthorization(struct netParsedUrl npu, char *authHeader, struct dyString *dy)
/* Set the specified authorization header with BASIC auth base64-encoded user and password */
{
if (!sameString(npu.user,""))
    {
    char up[256];
    char *b64up = NULL;
    safef(up, sizeof(up), "%s:%s", npu.user, npu.password);
    b64up = base64Encode(up, strlen(up));
    dyStringPrintf(dy, "%s: Basic %s\r\n", authHeader, b64up);
    freez(&b64up);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x120(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
addq $0x10, %rdi
leaq 0xa208a(%rip), %rsi     # 0xe5406
callq 0x6a40
cmpl $0x0, %eax
je 0x4341d
movq -0x120(%rbp), %r8
movq $0x0, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
movq %r8, %rcx
addq $0x10, %rcx
addq $0x810, %r8             # imm = 0x810
movl $0x100, %esi            # imm = 0x100
leaq 0x994b4(%rip), %rdx     # 0xdc871
movb $0x0, %al
callq 0x31090
leaq -0x110(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x62c0
movq -0x128(%rbp), %rdi
movq %rax, %rsi
callq 0x608c0
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x118(%rbp), %rcx
leaq 0x98a08(%rip), %rsi     # 0xdbe12
movb $0x0, %al
callq 0x35540
leaq -0x118(%rbp), %rdi
callq 0x40d70
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: checkNoProxy
boolean checkNoProxy(char *host)
/* See if host endsWith element on no_proxy list. Elements are comma-separated. */
{
char *list = cloneString(getenv("no_proxy"));
if (!list)
    return FALSE;
replaceChar(list, ',', ' ');
char *word;
while((word=nextWord(&list)))
    {
    if (endsWith(host, word))
	return TRUE;
    }
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x989de(%rip), %rdi     # 0xdbe21
callq 0x68d0
movq %rax, %rdi
callq 0x2a450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x43464
movl $0x0, -0x4(%rbp)
jmp 0x434ae
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
movl $0x20, %edx
callq 0x2dde0
leaq -0x18(%rbp), %rdi
callq 0x2f230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x434a7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2d9a0
cmpl $0x0, %eax
je 0x434a5
movl $0x1, -0x4(%rbp)
jmp 0x434ae
jmp 0x43477
movl $0x0, -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/net.c
// Function: netUrlHeadExt
int netUrlHeadExt(char *url, char *method, struct hash *hash)
/* Go get head and return status.  Return negative number if
 * can't get head. If hash is non-null, fill it with header
 * lines with upper cased keywords for case-insensitive lookup, 
 * including hopefully CONTENT-TYPE: . */
{
int sd = netOpenHttpExt(url, method, NULL);
int status = EIO;
if (sd >= 0)
    {
    char *line, *word;
    struct lineFile *lf = lineFileAttach(url, TRUE, sd);

    if (lineFileNext(lf, &line, NULL))
	{
	if (startsWith("HTTP/", line))
	    {
	    word = nextWord(&line);
	    word = nextWord(&line);
	    if (word != NULL && isdigit(word[0]))
	        {
		status = atoi(word);
		if (hash != NULL)
		    {
		    while (lineFileNext(lf, &line, NULL))
		        {
			word = nextWord(&line);
			if (word == NULL)
			    break;
			hashAdd(hash, strUpper(word), cloneString(skipLeadingSpaces(line)));
			}
		    }
		}
	    }
	}
    lineFileClose(&lf);
    }
else
    status = errno;
return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x439a0
movl %eax, -0x1c(%rbp)
movl $0x5, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x43b32
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x1, %esi
callq 0x3abf0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b660
cmpl $0x0, %eax
je 0x43b27
movq -0x28(%rbp), %rsi
leaq 0x97857(%rip), %rdi     # 0xdb2aa
callq 0x2d3d0
cmpl $0x0, %eax
je 0x43b25
leaq -0x28(%rbp), %rdi
callq 0x2f230
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f230
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x43b23
callq 0x6780
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x43b23
movq -0x30(%rbp), %rdi
callq 0x6bd0
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x43b21
jmp 0x43abb
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b660
cmpl $0x0, %eax
je 0x43b1f
leaq -0x28(%rbp), %rdi
callq 0x2f230
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x43ae7
jmp 0x43b1f
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2dd90
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2ca80
movq %rax, %rdi
callq 0x2a450
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x39230
jmp 0x43abb
jmp 0x43b21
jmp 0x43b23
jmp 0x43b25
jmp 0x43b27
leaq -0x38(%rbp), %rdi
callq 0x3c110
jmp 0x43b3c
callq 0x6060
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netUrlOpenSockets
int netUrlOpenSockets(char *url, int *retCtrlSocket)
/* Return socket descriptor (low-level file handle) for read()ing url data,
 * or -1 if error. 
 * If retCtrlSocket is non-NULL and url is FTP, set *retCtrlSocket
 * to the FTP control socket which is left open for a persistent connection.
 * close(result) (and close(*retCtrlSocket) if applicable) when done. 
 * If url is missing :// then it's just treated as a file. */
{
if (stringIn("://", url) == NULL)
    return open(url, O_RDONLY);
else
    {
    if (startsWith("http://",url) || startsWith("https://",url))
	return netGetOpenHttp(url);
    else if (startsWith("ftp://",url))
	return netGetOpenFtpSockets(url, retCtrlSocket);
    else    
	errAbort("Sorry, can only netUrlOpen http, https and ftp currently, not '%s'", url);
    }
return -1;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x97879(%rip), %rsi     # 0xdb474
callq 0x6170
cmpq $0x0, %rax
jne 0x43c18
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6d10
movl %eax, -0x4(%rbp)
jmp 0x43c94
movq -0x10(%rbp), %rsi
leaq 0x9783d(%rip), %rdi     # 0xdb460
callq 0x2d3d0
cmpl $0x0, %eax
jne 0x43c42
movq -0x10(%rbp), %rsi
leaq 0x97830(%rip), %rdi     # 0xdb468
callq 0x2d3d0
cmpl $0x0, %eax
je 0x43c50
movq -0x10(%rbp), %rdi
callq 0x43ca0
movl %eax, -0x4(%rbp)
jmp 0x43c94
movq -0x10(%rbp), %rsi
leaq 0x97816(%rip), %rdi     # 0xdb471
callq 0x2d3d0
cmpl $0x0, %eax
je 0x43c77
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43cd0
movl %eax, -0x4(%rbp)
jmp 0x43c94
movq -0x10(%rbp), %rsi
leaq 0x98299(%rip), %rdi     # 0xdbf1b
movb $0x0, %al
callq 0x35d40
jmp 0x43c8b
jmp 0x43c8d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netSlurpFile
struct dyString *netSlurpFile(int sd)
/* Slurp file into dynamic string and return. */
{
char buf[4*1024];
int readSize;
struct dyString *dy = newDyString(4*1024);

/* Slurp file into dy and return. */
while ((readSize = read(sd, buf, sizeof(buf))) > 0)
    dyStringAppendN(dy, buf, readSize);
return dy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl %edi, -0x4(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x35020
movq %rax, -0x1020(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6a90
movl %eax, -0x1014(%rbp)
cmpl $0x0, %eax
jle 0x44369
movq -0x1020(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
movl -0x1014(%rbp), %edx
callq 0x351f0
jmp 0x4432f
movq -0x1020(%rbp), %rax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netSlurpUrl
struct dyString *netSlurpUrl(char *url)
/* Go grab all of URL and return it as dynamic string. */
{
int sd = netUrlOpen(url);
if (sd < 0)
    errAbort("netSlurpUrl: failed to open socket for [%s]", url);
struct dyString *dy = netSlurpFile(sd);
close(sd);
return dy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x442f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x443b0
movq -0x8(%rbp), %rsi
leaq 0x97bb5(%rip), %rdi     # 0xdbf5e
movb $0x0, %al
callq 0x35d40
movl -0xc(%rbp), %edi
callq 0x44310
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x6e90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: parseContentRange
static void parseContentRange(char *x, ssize_t *rangeStart, ssize_t *rangeEnd)
/* parse the content range information from response header value 
	"bytes 763400000-763400112/763400113"
 */
{
/* default to no byte range specified */
*rangeStart = -1;
*rangeEnd = -1;
if (startsWith("bytes ", x))
    {
    char *y=strchr(x, ' ');
    ++y;
    char *z=strchr(y, '-');
    if (z)
	{
	++z;
	// TODO: use something better than atoll() ?
	*rangeStart = atoll(y); 
	if (z[0] != '\0')
	    *rangeEnd = atoll(z);
	}    
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $-0x1, (%rax)
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
movq -0x8(%rbp), %rsi
leaq 0x97dd1(%rip), %rdi     # 0xdc9a6
callq 0x2d3d0
cmpl $0x0, %eax
je 0x44c58
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2d, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x44c56
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x44c54
movq -0x28(%rbp), %rdi
callq 0x6520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x44c56
jmp 0x44c58
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: transferParamsToRedirectedUrl
char *transferParamsToRedirectedUrl(char *url, char *newUrl)
/* Transfer password, byteRange, and any other parameters from url to newUrl and return result.
 * freeMem result. */
{
struct netParsedUrl npu, newNpu;
/* Parse the old URL to make parts available for graft onto the redirected url. */
/* This makes redirection work with byterange urls and user:password@ */
netParseUrl(url, &npu);
netParseUrl(newUrl, &newNpu);
if (npu.byteRangeStart != -1)
    {
    newNpu.byteRangeStart = npu.byteRangeStart;
    newNpu.byteRangeEnd = npu.byteRangeEnd;
    }
if ((npu.user[0] != 0) && (newNpu.user[0] == 0))
    {
    safecpy(newNpu.user,     sizeof newNpu.user,     npu.user);
    safecpy(newNpu.password, sizeof newNpu.password, npu.password);
    }
return urlFromNetParsedUrl(&newNpu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5070, %rsp           # imm = 0x5070
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2840(%rbp), %rsi
callq 0x42160
movq -0x10(%rbp), %rdi
leaq -0x5070(%rbp), %rsi
callq 0x42160
cmpq $-0x1, -0x20(%rbp)
je 0x44cb0
movq -0x20(%rbp), %rax
movq %rax, -0x2850(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x2848(%rbp)
movsbl -0x2830(%rbp), %eax
cmpl $0x0, %eax
je 0x44d0e
movsbl -0x5060(%rbp), %eax
cmpl $0x0, %eax
jne 0x44d0e
leaq -0x5070(%rbp), %rdi
addq $0x10, %rdi
leaq -0x2840(%rbp), %rdx
addq $0x10, %rdx
movl $0x800, %esi            # imm = 0x800
callq 0x2caf0
leaq -0x5070(%rbp), %rdi
addq $0x810, %rdi            # imm = 0x810
leaq -0x2840(%rbp), %rdx
addq $0x810, %rdx            # imm = 0x810
movl $0x800, %esi            # imm = 0x800
callq 0x2caf0
leaq -0x5070(%rbp), %rdi
callq 0x42770
addq $0x5070, %rsp           # imm = 0x5070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netUrlMustOpenPastHeader
int netUrlMustOpenPastHeader(char *url)
/* Get socket descriptor for URL.  Process header, handling any forwarding and
 * the like.  Do errAbort if there's a problem, which includes anything but a 200
 * return from http after forwarding. */
{
int sd = netUrlOpen(url);
if (sd < 0)
    noWarnAbort();
int newSd = 0;
if (startsWith("http://",url) || startsWith("https://",url))
    {  
    char *newUrl = NULL;
    if (!netSkipHttpHeaderLinesHandlingRedirect(sd, url, &newSd, &newUrl))
	noWarnAbort();
    if (newUrl != NULL)
	{
	sd = newSd;
	freeMem(newUrl); 
	}
    }
return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x442f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x45095
movb $0x0, %al
callq 0x35e40
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x963b9(%rip), %rdi     # 0xdb460
callq 0x2d3d0
cmpl $0x0, %eax
jne 0x450c6
movq -0x8(%rbp), %rsi
leaq 0x963ac(%rip), %rdi     # 0xdb468
callq 0x2d3d0
cmpl $0x0, %eax
je 0x45106
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x44d30
cmpl $0x0, %eax
jne 0x450ee
movb $0x0, %al
callq 0x35e40
cmpq $0x0, -0x18(%rbp)
je 0x45104
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40d40
jmp 0x45106
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netLineFileSilentOpen
struct lineFile *netLineFileSilentOpen(char *url)
/* Open a lineFile on a URL.  Just return NULL without any user
 * visible warning message if there's a problem. */
{
pushSilentWarnHandler();
struct lineFile *lf = netLineFileMayOpen(url);
popWarnHandler();
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x36120
movq -0x8(%rbp), %rdi
callq 0x44ec0
movq %rax, -0x10(%rbp)
movb $0x0, %al
callq 0x35de0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netReadTextFileIfExists
char *netReadTextFileIfExists(char *url)
/* Read entire URL and return it as a string.  URL should be text (embedded zeros will be
 * interpreted as end of string).  If the url doesn't exist or has other problems,
 * returns NULL. */
{
struct lineFile *lf = netLineFileSilentOpen(url);
if (lf == NULL)
    return NULL;
char *text = lineFileReadAll(lf);
lineFileClose(&lf);
return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4517a
movq $0x0, -0x8(%rbp)
jmp 0x45198
movq -0x18(%rbp), %rdi
callq 0x3d4e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c110
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netLineFileOpen
struct lineFile *netLineFileOpen(char *url)
/* Return a lineFile attached to url.  This one
 * will skip any headers.   Free this with
 * lineFileClose(). */
{
struct lineFile *lf = netLineFileMayOpen(url);
if (lf == NULL)
    noWarnAbort();
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44ec0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x451d7
movb $0x0, %al
callq 0x35e40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netSendString
boolean netSendString(int sd, char *s)
/* Send a string down a socket - length byte first. */
{
int length = strlen(s);
UBYTE len;

if (length > 255)
    errAbort("Trying to send a string longer than 255 bytes (%d bytes)", length);
len = length;
if (write(sd, &len, 1)<0)
    {
    warn("Couldn't send string to socket");
    return FALSE;
    }
if (write(sd, s, length)<0)
    {
    warn("Couldn't send string to socket");
    return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movl %eax, -0x14(%rbp)
cmpl $0xff, -0x14(%rbp)
jle 0x45225
movl -0x14(%rbp), %esi
leaq 0x9702b(%rip), %rdi     # 0xdc249
movb $0x0, %al
callq 0x35d40
movl -0x14(%rbp), %eax
movb %al, -0x15(%rbp)
movl -0x8(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x6250
cmpq $0x0, %rax
jge 0x45259
leaq 0x97039(%rip), %rdi     # 0xdc282
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x4528d
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x6250
cmpq $0x0, %rax
jge 0x45286
leaq 0x9700c(%rip), %rdi     # 0xdc282
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x4528d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netSendLongString
boolean netSendLongString(int sd, char *s)
/* Send a long string down socket: two bytes for length. */
{
unsigned length = strlen(s);
UBYTE b[2];

if (length >= 64*1024)
    {
    warn("Trying to send a string longer than 64k bytes (%d bytes)", length);
    return FALSE;
    }
b[0] = (length>>8);
b[1] = (length&0xff);
if (write(sd, b, 2) < 0)
    {
    warn("Couldn't send long string to socket");
    return FALSE;
    }
if (write(sd, s, length)<0)
    {
    warn("Couldn't send long string to socket");
    return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movl %eax, -0x14(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jb 0x452de
movl -0x14(%rbp), %esi
leaq 0x96fd3(%rip), %rdi     # 0xdc2a1
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x45355
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x16(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x8(%rbp), %edi
leaq -0x16(%rbp), %rsi
movl $0x2, %edx
callq 0x6250
cmpq $0x0, %rax
jge 0x45320
leaq 0x96fca(%rip), %rdi     # 0xdc2da
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x45355
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x6250
cmpq $0x0, %rax
jge 0x4534e
leaq 0x96f9c(%rip), %rdi     # 0xdc2da
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x45355
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netSendHugeString
boolean netSendHugeString(int sd, char *s)
/* Send a long string down socket: four bytes for length. */
{
unsigned long length = strlen(s);
unsigned long l = length;
UBYTE b[4];
int i;
for (i=3; i>=0; --i)
    {
    b[i] = l & 0xff;
    l >>= 8;
    }
if (write(sd, b, 4) < 0)
    {
    warn("Couldn't send huge string to socket");
    return FALSE;
    }
if (write(sd, s, length) < 0)
    {
    warn("Couldn't send huge string to socket");
    return FALSE;
    }
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x453bc
movq -0x20(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x24(%rbp,%rax)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4538b
movl -0x8(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x6250
cmpq $0x0, %rax
jge 0x453ea
leaq 0x96f24(%rip), %rdi     # 0xdc2fe
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x4541e
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6250
cmpq $0x0, %rax
jge 0x45417
leaq 0x96ef7(%rip), %rdi     # 0xdc2fe
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x4541e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netGetString
char *netGetString(int sd, char buf[256])
/* Read string into buf and return it.  If buf is NULL
 * an internal buffer will be used. Print warning message
 * and return NULL if any problem. */
{
static char sbuf[256];
UBYTE len = 0;
int length;
int sz;
if (buf == NULL) buf = sbuf;
sz = netReadAll(sd, &len, 1);
if (sz == 0)
    return NULL;
if (sz < 0)
    {
    warn("Couldn't read string length");
    return NULL;
    }
length = len;
if (length > 0)
    if (netReadAll(sd, buf, length) < 0)
	{
	warn("Couldn't read string body");
	return NULL;
	}
buf[length] = 0;
return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x45455
leaq 0xc46ff(%rip), %rax     # 0x109b50
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x41f40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x45479
movq $0x0, -0x8(%rbp)
jmp 0x454e8
cmpl $0x0, -0x24(%rbp)
jge 0x45497
leaq 0x96e9c(%rip), %rdi     # 0xdc322
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x454e8
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x454d4
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x41f40
cmpq $0x0, %rax
jge 0x454d2
leaq 0x96e7d(%rip), %rdi     # 0xdc33e
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x454e8
jmp 0x454d4
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%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/net.c
// Function: netGetLongString
char *netGetLongString(int sd)
/* Read string and return it.  freeMem
 * the result when done. */
{
UBYTE b[2];
char *s = NULL;
int length = 0;
int sz;
b[0] = b[1] = 0;
sz = netReadAll(sd, b, 2);
if (sz == 0)
    return NULL;
if (sz < 0)
    {
    warn("Couldn't read long string length");
    return NULL;
    }
length = (b[0]<<8) + b[1];
s = needMem(length+1);
if (length > 0)
    if (netReadAll(sd, s, length) < 0)
	{
	warn("Couldn't read long string body");
	return NULL;
	}
s[length] = 0;
return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, -0xd(%rbp)
movb $0x0, -0xe(%rbp)
movl -0xc(%rbp), %edi
leaq -0xe(%rbp), %rsi
movl $0x2, %edx
callq 0x41f40
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x45549
movq $0x0, -0x8(%rbp)
jmp 0x455d3
cmpl $0x0, -0x20(%rbp)
jge 0x45567
leaq 0x96e02(%rip), %rdi     # 0xdc358
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x455d3
movzbl -0xe(%rbp), %eax
shll $0x8, %eax
movzbl -0xd(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x40c50
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x455bf
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x41f40
cmpq $0x0, %rax
jge 0x455bd
leaq 0x96dcd(%rip), %rdi     # 0xdc379
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x455d3
jmp 0x455bf
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netGetHugeString
char *netGetHugeString(int sd)
/* Read string and return it.  freeMem
 * the result when done. */
{
UBYTE b[4];
char *s = NULL;
unsigned long length = 0;
int sz, i;
sz = netReadAll(sd, b, 4);
if (sz == 0)
    return NULL;
if (sz < 4)
    {
    warn("Couldn't read huge string length");
    return NULL;
    }
for (i=0; i<4; ++i)
    {
    length <<= 8;
    length += b[i];
    }
s = needMem(length+1);
if (length > 0)
    {
    if (netReadAll(sd, s, length) < 0)
	{
	warn("Couldn't read huge string body");
	return NULL;
	}
    }
s[length] = 0;
return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x41f40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x45622
movq $0x0, -0x8(%rbp)
jmp 0x456d4
cmpl $0x4, -0x24(%rbp)
jge 0x45643
leaq 0x96d69(%rip), %rdi     # 0xdc398
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x456d4
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x45678
movq -0x20(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rbp)
movslq -0x28(%rbp), %rax
movzbl -0x10(%rbp,%rax), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4564a
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x40c50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x456c0
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41f40
cmpq $0x0, %rax
jge 0x456be
leaq 0x96d0c(%rip), %rdi     # 0xdc3b9
movb $0x0, %al
callq 0x358e0
movq $0x0, -0x8(%rbp)
jmp 0x456d4
jmp 0x456c0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netRecieveString
char *netRecieveString(int sd, char buf[256])
/* Read string into buf and return it.  If buf is NULL
 * an internal buffer will be used. Abort if any problem. */
{
char *s = netGetString(sd, buf);
if (s == NULL)
     noWarnAbort();   
return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x45430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4570d
movb $0x0, %al
callq 0x35e40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netRecieveLongString
char *netRecieveLongString(int sd)
/* Read string and return it.  freeMem
 * the result when done. Abort if any problem*/
{
char *s = netGetLongString(sd);
if (s == NULL)
     noWarnAbort();   
return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x45500
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x45745
movb $0x0, %al
callq 0x35e40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netRecieveHugeString
char *netRecieveHugeString(int sd)
/* Read string and return it.  freeMem
 * the result when done. Abort if any problem*/
{
char *s = netGetHugeString(sd);
if (s == NULL)
     noWarnAbort();   
return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x455e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x45775
movb $0x0, %al
callq 0x35e40
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netHttpLineFileMayOpen
struct lineFile *netHttpLineFileMayOpen(char *url, struct netParsedUrl **npu)
/* Parse URL and open an HTTP socket for it but don't send a request yet. */
{
int sd;
struct lineFile *lf;

/* Parse the URL and try to connect. */
AllocVar(*npu);
netParseUrl(url, *npu);
if (!sameString((*npu)->protocol, "http"))
    errAbort("netHttpLineFileMayOpen: url (%s) is not for http.", url);
sd = netConnect((*npu)->host, atoi((*npu)->port));
if (sd < 0)
    return NULL;

/* Return handle. */
lf = lineFileAttach(url, TRUE, sd);
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x2830, %edi           # imm = 0x2830
callq 0x40c50
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x42160
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x96588(%rip), %rsi     # 0xdbd4a
callq 0x6a40
cmpl $0x0, %eax
je 0x457de
movq -0x10(%rbp), %rsi
leaq 0x96c01(%rip), %rdi     # 0xdc3d8
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x1810, %rdi           # imm = 0x1810
callq 0x6bd0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x41710
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x45820
movq $0x0, -0x8(%rbp)
jmp 0x4583d
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x1, %esi
callq 0x3abf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netHttpGet
void netHttpGet(struct lineFile *lf, struct netParsedUrl *npu,
		boolean keepAlive)
/* Send a GET request, possibly with Keep-Alive. */
{
struct dyString *dy = newDyString(512);

/* Ask remote server for the file/query. */
dyStringPrintf(dy, "GET %s HTTP/1.1\r\n", npu->file);
dyStringPrintf(dy, "User-Agent: genome.ucsc.edu/net.c\r\n");
dyStringPrintf(dy, "Host: %s:%s\r\n", npu->host, npu->port);
if (!sameString(npu->user,""))
    {
    char up[256];
    char *b64up = NULL;
    safef(up,sizeof(up), "%s:%s", npu->user, npu->password);
    b64up = base64Encode(up, strlen(up));
    dyStringPrintf(dy, "Authorization: Basic %s\r\n", b64up);
    freez(&b64up);
    }
dyStringAppend(dy, "Accept: */*\r\n");
if (keepAlive)
  {
    dyStringAppend(dy, "Connection: Keep-Alive\r\n");
    dyStringAppend(dy, "Connection: Persist\r\n");
  }
else
    dyStringAppend(dy, "Connection: close\r\n");
dyStringAppend(dy, "\r\n");
mustWriteFd(lf->fd, dy->string, dy->stringSize);
/* Clean up. */
dyStringFree(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0x35020
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x1820, %rdx           # imm = 0x1820
leaq 0x96b80(%rip), %rsi     # 0xdc40a
movb $0x0, %al
callq 0x35540
movq -0x20(%rbp), %rdi
leaq 0x96b80(%rip), %rsi     # 0xdc41c
movb $0x0, %al
callq 0x35540
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x1010, %rdx           # imm = 0x1010
movq -0x10(%rbp), %rcx
addq $0x1810, %rcx           # imm = 0x1810
leaq 0x965c4(%rip), %rsi     # 0xdbe88
movb $0x0, %al
callq 0x35540
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x9fb2c(%rip), %rsi     # 0xe5406
callq 0x6a40
cmpl $0x0, %eax
je 0x45975
movq $0x0, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %r8
addq $0x810, %r8             # imm = 0x810
movl $0x100, %esi            # imm = 0x100
leaq 0x96f58(%rip), %rdx     # 0xdc871
movb $0x0, %al
callq 0x31090
leaq -0x120(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x62c0
movq -0x130(%rbp), %rdi
movq %rax, %rsi
callq 0x608c0
movq %rax, -0x128(%rbp)
movq -0x20(%rbp), %rdi
movq -0x128(%rbp), %rdx
leaq 0x96ade(%rip), %rsi     # 0xdc440
movb $0x0, %al
callq 0x35540
leaq -0x128(%rbp), %rdi
callq 0x40d70
movq -0x20(%rbp), %rdi
leaq 0x9652a(%rip), %rsi     # 0xdbeaa
callq 0x353b0
cmpl $0x0, -0x14(%rbp)
je 0x459ad
movq -0x20(%rbp), %rdi
leaq 0x96ac4(%rip), %rsi     # 0xdc45a
callq 0x353b0
movq -0x20(%rbp), %rdi
leaq 0x96acd(%rip), %rsi     # 0xdc473
callq 0x353b0
jmp 0x459bd
movq -0x20(%rbp), %rdi
leaq 0x96ad1(%rip), %rsi     # 0xdc489
callq 0x353b0
movq -0x20(%rbp), %rdi
leaq 0x9c1ac(%rip), %rsi     # 0xe1b74
callq 0x353b0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x2fe40
leaq -0x20(%rbp), %rdi
callq 0x35080
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: setSocketNonBlocking
static int setSocketNonBlocking(int sd, boolean set)
/* Use socket control flags to set O_NONBLOCK if set==TRUE,
 * or clear it if set==FALSE.
 * Return -1 if there are any errors, 0 if successful. */
{
long fcntlFlags;
// Set or clear non-blocking
if ((fcntlFlags = fcntl(sd, F_GETFL, NULL)) < 0) 
    {
    warn("Error fcntl(..., F_GETFL) (%s)", strerror(errno));
    return -1;
    }
if (set)
    fcntlFlags |= O_NONBLOCK;
else
    fcntlFlags &= (~O_NONBLOCK);
if (fcntl(sd, F_SETFL, fcntlFlags) < 0) 
    {
    warn("Error fcntl(..., F_SETFL) (%s)", strerror(errno));
    return -1;
    }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x6c50
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jge 0x45cd3
callq 0x6060
movl (%rax), %edi
callq 0x6220
movq %rax, %rsi
leaq 0x96911(%rip), %rdi     # 0xdc5d4
movb $0x0, %al
callq 0x358e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45d3c
cmpl $0x0, -0xc(%rbp)
je 0x45ce9
movq -0x18(%rbp), %rax
orq $0x800, %rax            # imm = 0x800
movq %rax, -0x18(%rbp)
jmp 0x45cf7
movq -0x18(%rbp), %rax
andq $-0x801, %rax           # imm = 0xF7FF
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rdx
movl $0x4, %esi
movb $0x0, %al
callq 0x6c50
cmpl $0x0, %eax
jge 0x45d35
callq 0x6060
movl (%rax), %edi
callq 0x6220
movq %rax, %rsi
leaq 0x968ce(%rip), %rdi     # 0xdc5f3
movb $0x0, %al
callq 0x358e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45d3c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: tvMinus
static struct timeval tvMinus(struct timeval a, struct timeval b)
/* Return the result of a - b; this handles wrapping of milliseconds. 
 * result.tv_usec will always be positive. 
 * result.tv_sec will be negative if b > a. */
{
// subtract b from a.
if (a.tv_usec < b.tv_usec)
    {
    a.tv_usec += 1000000;
    a.tv_sec--;
    }
a.tv_usec -= b.tv_usec;
a.tv_sec -= b.tv_sec;
return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x45d88
movq -0x18(%rbp), %rax
addq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: netStreamSocket
static int netStreamSocket()
/* Create a TCP/IP streaming socket.  Complain and return something
 * negative if can't */
{
int sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd < 0)
    warn("Couldn't make AF_INET socket.");
return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6180
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x45df0
leaq 0x96829(%rip), %rdi     # 0xdc612
movb $0x0, %al
callq 0x358e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/net.c
// Function: parsePasvPort
static int parsePasvPort(char *rs)
/* parse PASV reply to get the port and return it */
{
char *words[7];
int wordCount;
char *rsStart = strchr(rs,'(');
char *rsEnd = strchr(rs,')');
int result = 0;
rsStart++;
*rsEnd=0;
wordCount = chopString(rsStart, ",", words, ArraySize(words));
if (wordCount != 6)
    errAbort("PASV reply does not parse correctly");
result = atoi(words[4])*256+atoi(words[5]);    
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x6260
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x6260
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq 0x93716(%rip), %rsi     # 0xd985f
movl $0x7, %ecx
callq 0x2e840
movl %eax, -0x44(%rbp)
cmpl $0x6, -0x44(%rbp)
je 0x4616a
leaq 0x967e7(%rip), %rdi     # 0xdc94a
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rdi
callq 0x6bd0
shll $0x8, %eax
movl %eax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6bd0
movl %eax, %ecx
movl -0x60(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibParseName
void nibParseName(unsigned options, char *fileSpec, char *filePath,
                         char *name, unsigned *start, unsigned *end)
/* Parse the nib name, getting the file name, seq name to use, and
 * optionally the start and end positions. Zero is return for start
 * and end if they are not specified. Return the path to the file
 * and the name to use for the sequence. */
{
char *subrange = findNibSubrange(fileSpec);
if (subrange != NULL)
    {
    *subrange = '\0';
    parseSubrange(subrange, name, start, end);
    strcpy(filePath, fileSpec);
    *subrange = ':';
    if (strlen(name) == 0)
        {
        /* no name in spec, generate one */
        if (options & NIB_BASE_NAME)
            splitPath(filePath, NULL, name, NULL);
        else
            strcpy(name, filePath);
        sprintf(name+strlen(name), ":%u-%u", *start, *end);
        }
    }
else
    {
    *start = 0;
    *end = 0;
    strcpy(filePath, fileSpec);
    if (options & NIB_BASE_NAME)
        splitPath(fileSpec, NULL, name, NULL);
    else
        strcpy(name, fileSpec);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46470
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x46418
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x464d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6680
movq -0x38(%rbp), %rax
movb $0x3a, (%rax)
movq -0x20(%rbp), %rdi
callq 0x62c0
cmpq $0x0, %rax
jne 0x46416
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x463d7
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x385d0
jmp 0x463e4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6680
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62c0
movq -0x40(%rbp), %rdi
addq %rax, %rdi
movq -0x28(%rbp), %rax
movl (%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %ecx
leaq 0x965b5(%rip), %rsi     # 0xdc9c4
movb $0x0, %al
callq 0x6160
jmp 0x46469
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6680
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4645a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x385d0
jmp 0x46467
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6680
jmp 0x46469
addq $0x40, %rsp
popq %rbp
retq
nop