LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x2a7d4
testl %eax, %eax
js 0x2a8e6
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x25070
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq %rsp, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x256a7
pushq $0x5
popq %rbp
testl %eax, %eax
je 0x2a8da
movq (%rsp), %rsi
leaq 0x55baf(%rip), %rdi     # 0x803f2
callq 0x1db41
testl %eax, %eax
je 0x2a8da
movq %rsp, %r15
movq %r15, %rdi
callq 0x1e9c1
movq %r15, %rdi
callq 0x1e9c1
testq %rax, %rax
je 0x2a8da
movq %rax, %r15
callq 0x6790
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x2a8da
movq %r15, %rdi
callq 0x6bd0
movl %eax, %ebp
testq %rbx, %rbx
je 0x2a8da
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x256a7
testl %eax, %eax
je 0x2a8da
movq %r15, %rdi
callq 0x1e9c1
testq %rax, %rax
je 0x2a8da
movq %rax, %rdi
callq 0x1e022
movq %rax, %r12
movq (%rsp), %rdi
callq 0x1d6a7
movq %rax, %rdi
callq 0x1c306
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x242d0
jmp 0x2a890
leaq 0x8(%rsp), %rdi
callq 0x25cd8
jmp 0x2a8ed
callq 0x6060
movl (%rax), %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edi, %ebx
movl $0x1000, %edi           # imm = 0x1000
callq 0x21bcc
movq %rax, %r14
movq %rsp, %r15
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %r15, %rsi
callq 0x6aa0
testl %eax, %eax
jle 0x2ae6d
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x21cc8
jmp 0x2ae4b
movq %r14, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2ae26
movl %eax, %ebx
testl %eax, %eax
jns 0x2aea0
leaq 0x56210(%rip), %rdi     # 0x810a6
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movl %ebx, %edi
callq 0x2ae2d
movq %rax, %r14
movl %ebx, %edi
callq 0x6e80
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x5060, %rsp           # imm = 0x5060
movq %rsi, %r15
leaq 0x2830(%rsp), %rbx
movq %rbx, %rsi
callq 0x29839
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x29839
movq 0x2820(%rbx), %rax
cmpq $-0x1, %rax
je 0x2b4d3
movq %rax, 0x2820(%rsp)
movq 0x5058(%rsp), %rax
movq %rax, 0x2828(%rsp)
cmpb $0x0, 0x2840(%rsp)
je 0x2b516
cmpb $0x0, 0x10(%rsp)
jne 0x2b516
leaq 0x2840(%rsp), %rdx
leaq 0x10(%rsp), %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x1d6d3
movl $0x810, %eax            # imm = 0x810
addq %rax, %r14
addq %rax, %rbx
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d6d3
movq %rsp, %rdi
callq 0x29c3e
addq $0x5060, %rsp           # imm = 0x5060
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/net.c
// Function: netLineFileMayOpen
struct lineFile *netLineFileMayOpen(char *url)
/* Return a lineFile attached to url. http skips header.
 * Supports some compression formats.  Prints warning message, but
 * does not abort, just returning NULL if there's a problem. */
{
int sd = netUrlOpen(url);
if (sd < 0)
    {
    warn("Couldn't open %s", url);
    return NULL;
    }
else
    {
    struct lineFile *lf = NULL;
    char *newUrl = NULL;
    int newSd = 0;
    if (startsWith("http://",url) || startsWith("https://",url))
	{  
	if (!netSkipHttpHeaderLinesHandlingRedirect(sd, url, &newSd, &newUrl))
	    {
	    return NULL;
	    }
	if (newUrl != NULL)
	    {
    	    /*  Update sd with newSd, replace it with newUrl, etc. */
	    sd = newSd;
	    url = newUrl;
	    }
	}
    char *urlDecoded = cloneString(url);
    cgiDecode(url, urlDecoded, strlen(url));
    boolean isCompressed =
	(endsWith(urlDecoded,".gz") ||
   	 endsWith(urlDecoded,".Z")  ||
	 endsWith(urlDecoded,".bz2"));
    freeMem(urlDecoded);
    if (isCompressed)
	{
	lf = lineFileDecompressFd(url, TRUE, sd);
           /* url needed only for compress type determination */
	}
    else
	{
	lf = lineFileAttach(url, TRUE, sd);
	}
    if (newUrl) 
	freeMem(newUrl); 
    return lf;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2ae26
testl %eax, %eax
js 0x2b6ec
movl %eax, %ebp
andq $0x0, 0x8(%rsp)
andl $0x0, 0x4(%rsp)
leaq 0x54f06(%rip), %rdi     # 0x805a8
movq %rbx, %rsi
callq 0x1db41
testl %eax, %eax
jne 0x2b6c1
leaq 0x54efb(%rip), %rdi     # 0x805b0
movq %rbx, %rsi
callq 0x1db41
testl %eax, %eax
je 0x2b707
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2b52b
testl %eax, %eax
je 0x2b702
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x2b70a
movl 0x4(%rsp), %ebp
movq %r14, %rbx
jmp 0x2b70a
leaq 0x55c8d(%rip), %rdi     # 0x81380
xorl %r15d, %r15d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22186
jmp 0x2b775
xorl %r15d, %r15d
jmp 0x2b775
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1c306
movq %rax, %r15
movq %rbx, %rdi
callq 0x62d0
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x3e6ea
leaq 0x5bf05(%rip), %rsi     # 0x87636
movq %r15, %rdi
callq 0x1de0f
testl %eax, %eax
jne 0x2b750
leaq 0x5190c(%rip), %rsi     # 0x7d050
movq %r15, %rdi
callq 0x1de0f
testl %eax, %eax
je 0x2b785
movq %r15, %rdi
callq 0x28c2d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x250c3
movq %rax, %r15
testq %r14, %r14
je 0x2b775
movq %r14, %rdi
callq 0x28c2d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x518c7(%rip), %rsi     # 0x7d053
movq %r15, %rdi
callq 0x1de0f
movl %eax, %r12d
movq %r15, %rdi
callq 0x28c2d
testl %r12d, %r12d
jne 0x2b758
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x25070
jmp 0x2b765
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x2ae26
movl %eax, %ebx
testl %eax, %eax
jns 0x2b7cf
xorl %eax, %eax
callq 0x224b6
andl $0x0, 0xc(%rsp)
leaq 0x54dcd(%rip), %rdi     # 0x805a8
movq %r14, %rsi
callq 0x1db41
testl %eax, %eax
jne 0x2b7fa
leaq 0x54dc2(%rip), %rdi     # 0x805b0
movq %r14, %rsi
callq 0x1db41
testl %eax, %eax
je 0x2b830
leaq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0xc(%rsp), %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x2b52b
testl %eax, %eax
jne 0x2b81d
xorl %eax, %eax
callq 0x224b6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2b830
movl 0xc(%rsp), %ebx
callq 0x28c2d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x22669
movq %rbx, %rdi
callq 0x2b676
movq %rax, %rbx
xorl %eax, %eax
callq 0x2247b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
callq 0x2b83a
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2b88a
movq %rax, %rdi
callq 0x268ea
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25cd8
movq %rbx, %rax
jmp 0x2b88c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x2b676
movq %rax, %rbx
testq %rax, %rax
jne 0x2b8a7
xorl %eax, %eax
callq 0x224b6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x62d0
movq %rax, %r14
cmpl $0x100, %r14d           # imm = 0x100
jl 0x2b8de
leaq 0x55abd(%rip), %rdi     # 0x81391
movl %r14d, %esi
xorl %eax, %eax
callq 0x223fb
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
pushq $0x1
popq %rdx
movl %ebp, %edi
callq 0x6260
testq %rax, %rax
js 0x2b90c
movslq %r14d, %rdx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6260
testq %rax, %rax
js 0x2b90c
pushq $0x1
popq %rbx
jmp 0x2b91c
leaq 0x55ab7(%rip), %rdi     # 0x813ca
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22186
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x62d0
movq %rax, %r14
cmpl $0x10000, %r14d         # imm = 0x10000
jb 0x2b95d
leaq 0x55a9a(%rip), %rdi     # 0x813e9
xorl %ebx, %ebx
movl %r14d, %esi
xorl %eax, %eax
callq 0x22186
jmp 0x2b9a3
movl %r14d, %eax
rolw $0x8, %ax
leaq 0xe(%rsp), %rsi
movw %ax, (%rsi)
pushq $0x2
popq %rdx
movl %ebp, %edi
callq 0x6260
testq %rax, %rax
js 0x2b993
movzwl %r14w, %edx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6260
testq %rax, %rax
js 0x2b993
pushq $0x1
popq %rbx
jmp 0x2b9a3
leaq 0x55a88(%rip), %rdi     # 0x81422
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22186
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x62d0
movq %rax, %r14
pushq $0x3
popq %rax
movq %r14, %rcx
testl %eax, %eax
js 0x2b9de
movl %eax, %edx
movb %cl, 0xc(%rsp,%rdx)
shrq $0x8, %rcx
decl %eax
jmp 0x2b9cc
leaq 0xc(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebp, %edi
callq 0x6260
testq %rax, %rax
js 0x2ba09
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6260
testq %rax, %rax
js 0x2ba09
pushq $0x1
popq %rbx
jmp 0x2ba19
leaq 0x55a36(%rip), %rdi     # 0x81446
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22186
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
testq %rsi, %rsi
leaq 0x8bcf0(%rip), %rbx     # 0xb7730
cmovneq %rsi, %rbx
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x296f4
testl %eax, %eax
je 0x2ba7b
js 0x2ba7f
movzbl 0xf(%rsp), %r14d
testq %r14, %r14
je 0x2ba91
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x296f4
testq %rax, %rax
jns 0x2ba94
leaq 0x55a0d(%rip), %rdi     # 0x81486
jmp 0x2ba86
xorl %ebx, %ebx
jmp 0x2ba99
leaq 0x559e4(%rip), %rdi     # 0x8146a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22186
jmp 0x2ba99
xorl %r14d, %r14d
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
leaq 0xe(%rsp), %rsi
andw $0x0, (%rsi)
pushq $0x2
popq %rdx
callq 0x296f4
testl %eax, %eax
je 0x2bb03
js 0x2bb07
movzwl 0xe(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %r14d
leal 0x1(%r14), %edi
callq 0x28bb0
movq %rax, %rbx
testw %r14w, %r14w
je 0x2bb19
movl %r14d, %r14d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x296f4
testq %rax, %rax
jns 0x2bb1c
leaq 0x559c0(%rip), %rdi     # 0x814c1
jmp 0x2bb0e
xorl %ebx, %ebx
jmp 0x2bb21
leaq 0x55992(%rip), %rdi     # 0x814a0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22186
jmp 0x2bb21
xorl %r14d, %r14d
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x296f4
testl %eax, %eax
je 0x2bb61
cmpl $0x4, %eax
jge 0x2bb66
leaq 0x5598b(%rip), %rdi     # 0x814e0
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x22186
jmp 0x2bbaa
xorl %r15d, %r15d
jmp 0x2bbaa
xorl %eax, %eax
xorl %r14d, %r14d
cmpq $0x4, %rax
je 0x2bb82
shlq $0x8, %r14
movzbl 0xc(%rsp,%rax), %ecx
orq %rcx, %r14
incq %rax
jmp 0x2bb6b
leaq 0x1(%r14), %rdi
callq 0x28bb0
movq %rax, %r15
testq %r14, %r14
je 0x2bba5
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x296f4
testq %rax, %rax
js 0x2bbb7
movb $0x0, (%r15,%r14)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55943(%rip), %rdi     # 0x81501
jmp 0x2bb55
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x2ba24
movq %rax, %rbx
testq %rax, %rax
jne 0x2bbd5
xorl %eax, %eax
callq 0x224b6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x2baa5
movq %rax, %rbx
testq %rax, %rax
jne 0x2bbef
xorl %eax, %eax
callq 0x224b6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x2bb2d
movq %rax, %rbx
testq %rax, %rax
jne 0x2bc09
xorl %eax, %eax
callq 0x224b6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2830, %edi           # imm = 0x2830
callq 0x28bb0
movq %rax, (%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29839
movq (%r14), %r15
leaq 0x55257(%rip), %rsi     # 0x80e92
movq %r15, %rdi
callq 0x6a50
testl %eax, %eax
je 0x2bc5b
leaq 0x558d2(%rip), %rdi     # 0x81520
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movq (%r14), %r15
leaq 0x1010(%r15), %r14
addq $0x1810, %r15           # imm = 0x1810
movq %r15, %rdi
callq 0x6bd0
movq %r14, %rdi
movl %eax, %esi
callq 0x291f8
testl %eax, %eax
js 0x2bc91
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %eax, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x25070
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x200, %edi            # imm = 0x200
callq 0x21bcc
movq %rax, %r14
movq %rax, (%rsp)
leaq 0x1820(%r15), %rdx
leaq 0x55883(%rip), %rsi     # 0x81552
movq %rax, %rdi
xorl %eax, %eax
callq 0x21ec7
leaq 0x55884(%rip), %rsi     # 0x81564
movq %r14, %rdi
xorl %eax, %eax
callq 0x21ec7
leaq 0x1010(%r15), %rdx
leaq 0x1810(%r15), %rcx
leaq 0x552d1(%rip), %rsi     # 0x80fd0
movq %r14, %rdi
xorl %eax, %eax
callq 0x21ec7
cmpb $0x0, 0x10(%r15)
je 0x2bd70
leaq 0x10(%r15), %rcx
addq $0x810, %r15            # imm = 0x810
leaq 0x55c97(%rip), %rdx     # 0x819b9
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %r8
xorl %eax, %eax
callq 0x1fab2
movq %r12, %rdi
callq 0x62d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x3ca30
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x5582d(%rip), %rsi     # 0x81588
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21ec7
movq %r15, %rdi
callq 0x28c3d
leaq 0x5527b(%rip), %rsi     # 0x80ff2
movq %r14, %rdi
callq 0x21dda
testl %ebp, %ebp
je 0x2bd9b
leaq 0x55818(%rip), %rsi     # 0x815a2
movq %r14, %rdi
callq 0x21dda
leaq 0x55822(%rip), %rsi     # 0x815bb
jmp 0x2bda2
leaq 0x5582f(%rip), %rsi     # 0x815d1
movq %r14, %rdi
callq 0x21dda
leaq 0x5ae3e(%rip), %rsi     # 0x86bef
movq %r14, %rdi
callq 0x21dda
movl 0x10(%rbx), %edi
movq 0x8(%r14), %rsi
movslq 0x14(%r14), %rdx
callq 0x1f108
movq %rsp, %rdi
callq 0x21c07
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x6190
movl %eax, %ebx
testl %eax, %eax
jns 0x2c036
leaq 0x5572b(%rip), %rdi     # 0x8175a
xorl %eax, %eax
callq 0x22186
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/net.c
// Function: sendFtpDataToPipeThread
static void *sendFtpDataToPipeThread(void *threadParams)
/* This is to be executed by the child process after the fork in netGetOpenFtpSockets.
 * It keeps the ftp control socket alive while reading from the ftp data socket
 * and writing to the pipe to the parent process, which closes the ftp sockets
 * and reads from the pipe. */
{

struct netConnectFtpParams *params = threadParams;

pthread_detach(params->thread);  // this thread will never join back with it's progenitor

char buf[32768];
int rd = 0;
long long dataPos = 0; 
if (params->npu.byteRangeStart != -1)
    dataPos = params->npu.byteRangeStart;
while((rd = read(params->sdata, buf, 32768)) > 0) 
    {
    if (params->npu.byteRangeEnd != -1 && (dataPos + rd) > params->npu.byteRangeEnd)
	rd = params->npu.byteRangeEnd - dataPos + 1;
    int wt = write(params->pipefd[1], buf, rd);
    if (wt == -1 && params->npu.byteRangeEnd != -1)
	{
	// errAbort in child process is messy; let reader complain if
	// trouble.  If byterange was open-ended, we will hit this point
	// when the parent stops reading and closes the pipe.
	errnoWarn("error writing ftp data to pipe");
	break;
	}
    dataPos += rd;
    if (params->npu.byteRangeEnd != -1 && dataPos >= params->npu.byteRangeEnd)
	break;	    
    }
if (rd == -1)
    // Again, avoid abort in child process.
    errnoWarn("error reading ftp socket");
close(params->pipefd[1]);  /* we are done with it */
close(params->sd);
close(params->sdata);
return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8000, %rsp           # imm = 0x8000
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x64a0
movq 0x2838(%rbx), %rax
xorl %r13d, %r13d
cmpq $-0x1, %rax
cmovneq %rax, %r13
movq %rsp, %r14
movl 0x14(%rbx), %edi
movl $0x8000, %edx           # imm = 0x8000
movq %r14, %rsi
callq 0x6aa0
movq %rax, %r15
testl %r15d, %r15d
jle 0x2c2c3
movq 0x2840(%rbx), %rax
cmpq $-0x1, %rax
je 0x2c27c
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %r13, %rcx
cmpq %rax, %rcx
jle 0x2c27c
subl %r13d, %eax
incl %eax
movl %eax, %r15d
movl 0xc(%rbx), %edi
movslq %r15d, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x6260
cmpl $-0x1, %eax
setne %cl
movq 0x2840(%rbx), %rax
cmpq $-0x1, %rax
sete %dl
orb %cl, %dl
je 0x2c2b5
addq %r12, %r13
cmpq $-0x1, %rax
je 0x2c23e
cmpq %rax, %r13
jl 0x2c23e
jmp 0x2c2c3
leaq 0x557fa(%rip), %rdi     # 0x81ab6
xorl %eax, %eax
callq 0x222ea
cmpl $-0x1, %r15d
jne 0x2c2d7
leaq 0x55805(%rip), %rdi     # 0x81ad5
xorl %eax, %eax
callq 0x222ea
movl 0xc(%rbx), %edi
callq 0x6e80
movl 0x10(%rbx), %edi
callq 0x6e80
movl 0x14(%rbx), %edi
callq 0x6e80
xorl %eax, %eax
addq $0x8000, %rsp           # imm = 0x8000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, (%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movl %edi, %ebx
movq %rsi, %rdi
callq 0x2c48d
testq %rax, %rax
je 0x2c375
movq %rax, %r12
movq %rbp, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movb $0x0, (%rax)
movq %rax, %r14
incq %r14
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x2c3ab
movq %rax, %rbp
movb $0x0, (%rax)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x6680
movb $0x3a, (%rbp)
incq %rbp
movq %rbp, %r14
jmp 0x2c3b2
andl $0x0, (%r15)
andl $0x0, (%r14)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x6680
testb $0x4, %bl
jne 0x2c430
movq (%rsp), %rdi
movq %r13, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6680
movq (%rsp), %rax
movb $0x0, (%rax)
leaq 0x5573d(%rip), %rsi     # 0x81af6
movq %r14, %rdi
movq %r15, %rbp
movq %r15, %rdx
movq 0x10(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x66d0
cmpl $0x2, %eax
jne 0x2c3de
movl (%rbp), %eax
cmpl (%r14), %eax
jbe 0x2c3ef
leaq 0x55773(%rip), %rdi     # 0x81b58
movq %r12, %rsi
xorl %eax, %eax
callq 0x223fb
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x6680
movb $0x3a, (%r12)
movq (%rsp), %r12
cmpb $0x0, (%r12)
je 0x2c41e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x4, %bl
jne 0x2c44e
movq %r12, %rdi
movq %r15, %rsi
callq 0x6680
jmp 0x2c45d
movq %r13, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
xorl %ecx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23b2e
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x23b2e
movq %r12, %rdi
callq 0x62d0
addq %rax, %r12
movl (%rbp), %edx
movl (%r14), %ecx
leaq 0x55680(%rip), %rsi     # 0x81af5
movq %r12, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6170
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibLoadPartMasked
struct dnaSeq *nibLoadPartMasked(int options, char *fileName, int start, int size)
/* Load part of an .nib file, with control over handling of masked positions */
{
struct dnaSeq *seq;
FILE *f;
int seqSize;
nibOpenVerify(fileName, &f, &seqSize);
seq = nibLdPartMasked(options, fileName, f, seqSize, start, size);
fclose(f);
return seq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %rsi, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2c4ad
movq (%r12), %r12
movl (%r13), %ecx
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x2c6e4
movq %rax, %rbx
movq %r12, %rdi
callq 0x66e0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibLoadAllMasked
struct dnaSeq *nibLoadAllMasked(int options, char *fileName)
/* Load part of a .nib file, with control over handling of masked
 * positions. Subranges of nib files may specified in the file name
 * using the syntax:
 *    /path/file.nib:seqid:start-end
 * or\n"
 *    /path/file.nib:start-end
 * With the first form, seqid becomes the id of the subrange, with the second
 * form, a sequence id of file:start-end will be used.
 */
{
struct dnaSeq *seq;
FILE *f;
int seqSize;
char filePath[PATH_LEN];
char name[PATH_LEN];
unsigned start, end;

nibParseName(options, fileName, filePath, name, &start, &end);
nibOpenVerify(filePath, &f, &seqSize);
if (end == 0)
    end = seqSize;
seq = nibInput(options, fileName, name, f, seqSize, start, end-start);
fclose(f);
return seq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x220(%rsp), %r14
leaq 0x20(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r15
movq %r14, %rdx
movq %r15, %r9
callq 0x2c304
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x2c4ad
movl (%r15), %eax
movl (%r12), %r8d
testl %eax, %eax
jne 0x2caf6
movl %r8d, 0x8(%rsp)
movl %r8d, %eax
movq 0x10(%rsp), %r14
movl 0xc(%rsp), %r9d
subl %r9d, %eax
movl %eax, (%rsp)
leaq 0x20(%rsp), %rdx
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2c753
movq %rax, %rbx
movq %r14, %rdi
callq 0x66e0
movq %rbx, %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibStreamOpen
struct nibStream *nibStreamOpen(char *fileName)
/* Create a new nib stream.  Open file and stuff. */
{
struct nibStream *ns;
FILE *f;

dnaUtilOpen();
AllocVar(ns);
ns->f = f = mustOpen(fileName, "wb");
ns->fileName = cloneString(fileName);

/* Write header - initially zero.  Will fix it up when we close. */
writeOne(f, ns->size);
writeOne(f, ns->size);

return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x21578
pushq $0x20
popq %rdi
callq 0x28bb0
movq %rax, %r14
leaq 0x54e2e(%rip), %rsi     # 0x81b46
movq %rbx, %rdi
callq 0x1ec79
movq %rax, %r15
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x1c306
movq %rax, 0x8(%r14)
leaq 0x18(%r14), %rbx
pushq $0x4
popq %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1ed3f
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1ed3f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibStreamClose
void nibStreamClose(struct nibStream **pNs)
/* Close a nib stream.  Flush last nibble if need be.  Fix up header. */
{
struct nibStream *ns = *pNs;
FILE *f;
bits32 sig = nibSig;
if (ns == NULL)
    return;
f = ns->f;
if (ns->size&1)
    writeOne(f, ns->byte);
fseek(f,  0L, SEEK_SET);
writeOne(f, sig);
writeOne(f, ns->size);
fclose(f);
freeMem(ns->fileName);
freez(pNs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r13
movl $0x6be93d3a, 0xc(%rsp)  # imm = 0x6BE93D3A
testq %r13, %r13
je 0x2cdeb
movq %rdi, %rbx
movq 0x10(%r13), %r14
leaq 0x18(%r13), %r15
testb $0x1, 0x18(%r13)
je 0x2cda4
leaq 0x1c(%r13), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1ed3f
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x67d0
leaq 0xc(%rsp), %rsi
pushq $0x4
popq %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x1ed3f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1ed3f
movq %r14, %rdi
callq 0x66e0
movq 0x8(%r13), %rdi
callq 0x28c2d
movq %rbx, %rdi
callq 0x28c3d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibStreamOne
void nibStreamOne(struct nibStream *ns, DNA base)
/* Write out one base to nibStream. */
{
UBYTE ub = ntVal5[(int)base];

if ((++ns->size&1) == 0)
    {
    ub += ns->byte;
    writeOne(ns->f, ub);
    }
else
    {
    ns->byte = (ub<<4);
    }
}

// Assembly:
movslq %esi, %rax
leaq 0x89aad(%rip), %rcx     # 0xb68b0
movb (%rcx,%rax,4), %al
movl 0x18(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rdi)
testb $0x1, %cl
jne 0x2ce1b
shlb $0x4, %al
movb %al, 0x1c(%rdi)
retq
pushq %rax
addb 0x1c(%rdi), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq 0x10(%rdi), %rdi
pushq $0x1
popq %rdx
callq 0x1ed3f
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibIsFile
boolean nibIsFile(char *fileName)
/* Return TRUE if file is a nib file. */
{
boolean isANib;
char *subrange = findNibSubrange(fileName);
if (subrange != NULL)
    *subrange = '\0';
isANib = endsWith(fileName, ".nib") || endsWith(fileName, ".NIB");
if (subrange != NULL)
    *subrange = ':';
return isANib;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2c48d
movq %rax, %rbx
testq %rax, %rax
je 0x2ce8a
movb $0x0, (%rbx)
leaq 0x54cc2(%rip), %rsi     # 0x81b53
movq %r14, %rdi
callq 0x1de0f
testl %eax, %eax
je 0x2cea2
pushq $0x1
popq %rax
jmp 0x2ceba
leaq 0x54ca0(%rip), %rsi     # 0x81b49
movq %r14, %rdi
callq 0x1de0f
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
testq %rbx, %rbx
je 0x2cec2
movb $0x3a, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibIsRange
boolean nibIsRange(char *fileName)
/* Return TRUE if file specifies a subrange of a nib file. */
{
boolean isANib;
char *subrange = findNibSubrange(fileName);;
if (subrange == NULL)
    return FALSE;
*subrange = '\0';
isANib = endsWith(fileName, ".nib") || endsWith(fileName, ".NIB");
*subrange = ':';
return isANib;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2c48d
testq %rax, %rax
je 0x2cef9
movq %rax, %rbx
movb $0x0, (%rax)
leaq 0x54c6b(%rip), %rsi     # 0x81b53
movq %r14, %rdi
callq 0x1de0f
testl %eax, %eax
je 0x2cefd
pushq $0x1
popq %rax
jmp 0x2cf15
xorl %eax, %eax
jmp 0x2cf18
leaq 0x54c45(%rip), %rsi     # 0x81b49
movq %r14, %rdi
callq 0x1de0f
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
movb $0x3a, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibInfoNew
struct nibInfo *nibInfoNew(char *path)
/* Make a new nibInfo with open nib file. */
{
struct nibInfo *nib;
AllocVar(nib);
nib->fileName = cloneString(path);
nibOpenVerify(path, &nib->f, &nib->size);
return nib;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x28bb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c306
movq %rax, 0x8(%r14)
leaq 0x18(%r14), %rsi
leaq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x2c4ad
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibInfoFree
void nibInfoFree(struct nibInfo **pNib)
/* Free up nib info and close file if open. */
{
struct nibInfo *nib = *pNib;
if (nib != NULL)
    {
    carefulClose(&nib->f);
    freeMem(nib->fileName);
    freez(pNib);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2cf89
movq %rdi, %rbx
leaq 0x18(%r14), %rdi
callq 0x1f2ea
movq 0x8(%r14), %rdi
callq 0x28c2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/nib.c
// Function: nibInfoFromCache
struct nibInfo *nibInfoFromCache(struct hash *hash, char *nibDir, char *nibName)
/* Get nibInfo on nibDir/nibName.nib from cache, filling cache if need be. */
{
struct nibInfo *nib;
char path[PATH_LEN];
safef(path, sizeof(path), "%s/%s.nib", nibDir, nibName);
nib = hashFindVal(hash, path);
if (nib == NULL)
    {
    nib = nibInfoNew(path);
    hashAdd(hash, path, nib);
    }
return nib;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x54ba1(%rip), %rdx     # 0x81b4e
movq %rsp, %r14
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x1fab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x244c6
movq %rax, %r14
testq %rax, %rax
jne 0x2cfee
movq %rsp, %r15
movq %r15, %rdi
callq 0x2cf20
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x242d0
movq %r14, %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: hashTwoColumnFile
struct hash *hashTwoColumnFile(char *fileName)
/* Given a two column file (key, value) return a hash. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = hashNew(16);
char *row[3];
int fields = 0;
while ((fields = lineFileChop(lf, row)) != 0)
    {
    lineFileExpectWords(lf, 2, fields);
    char *name = row[0];
    char *value = lmCloneString(hash->lm, row[1]);
    hashAdd(hash, name, value);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x25467
movq %rax, %rbx
movq %rax, 0x8(%rsp)
pushq $0x10
popq %rdi
movl %ebp, %esi
callq 0x245c9
movq %rax, %r14
leaq 0x10(%rsp), %r15
pushq $0x3
popq %rbp
pushq $0x2
popq %r12
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2619f
testl %eax, %eax
je 0x2d3e5
movq %rbx, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x25dfd
movq 0x20(%r14), %rdi
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rsi
callq 0x270f3
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x242d0
jmp 0x2d3a4
leaq 0x8(%rsp), %rdi
callq 0x25cd8
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: slPairTwoColumnFile
struct slPair *slPairTwoColumnFile(char *fileName)
/* Read in a two column file into an slPair list */
{
char *row[2];
struct slPair *list = NULL;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
while (lineFileRow(lf, row))
    slPairAdd(&list, row[0], cloneString(row[1]));
lineFileClose(&lf);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x1
popq %rsi
callq 0x25467
movq %rax, %r14
movq %rax, (%rsp)
leaq 0x10(%rsp), %r15
pushq $0x2
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x262ec
testl %eax, %eax
je 0x2d45d
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rdi
callq 0x1c306
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1d30d
jmp 0x2d42d
movq %rsp, %rdi
callq 0x25cd8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: slNameListOfUniqueWords
struct slName *slNameListOfUniqueWords(char *text,boolean respectQuotes)
/* Return list of unique words found by parsing string delimited by whitespace.
 * If respectQuotes then ["Lucy and Ricky" 'Fred and Ethyl'] will yield 2 slNames no quotes */
{
struct slName *list = NULL;
char *word = NULL;
while (text != NULL)
    {
    if (respectQuotes)
        word = nextQuotedWord(&text);
    else
        word = nextWord(&text);
    if (word)
        slNameStore(&list, word);
    else
        break;
    }
slReverse(&list);
return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %rsp, %r15
andq $0x0, (%r15)
testq %rdi, %rdi
je 0x2d824
movq %r14, %rdi
testl %ebx, %ebx
je 0x2d808
callq 0x2d77f
jmp 0x2d80d
callq 0x1e9c1
testq %rax, %rax
je 0x2d824
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ce07
movq 0x8(%rsp), %rdi
jmp 0x2d7f5
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: shuffleArrayOfInts
void shuffleArrayOfInts(int *array, int arraySize)
/* Shuffle array of ints of given size given number of times. */
{
int c;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    c = array[i];
    array[i] = array[randIx];
    array[randIx] = c;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r12d
cmovgl %esi, %r12d
cmpq %r15, %r12
je 0x2de72
callq 0x61d0
cltd
idivl %ebx
movl (%r14,%r15,4), %eax
movslq %edx, %rcx
addq %r15, %rcx
movl (%r14,%rcx,4), %edx
movl %edx, (%r14,%r15,4)
movl %eax, (%r14,%rcx,4)
incq %r15
decl %ebx
jmp 0x2de48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: slListRandomReduce
void *slListRandomReduce(void *list, double reduceRatio)
/* Reduce list to approximately reduceRatio times original size. Destroys original list. */
{
if (reduceRatio >= 1.0)
    return list;
int threshold = RAND_MAX * reduceRatio;
struct slList *newList = NULL, *next, *el;
for (el = list; el != NULL; el = next)
    {
    next = el->next;
    if (rand() <= threshold)
        {
	slAddHead(&newList, el);
	}
    }
return newList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
ucomisd 0x4e8ef(%rip), %xmm0    # 0x7c878
jae 0x2dfb9
mulsd 0x53d05(%rip), %xmm0    # 0x81c98
cvttsd2si %xmm0, %ebp
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2dfb6
movq %rbx, %r15
movq (%rbx), %rbx
callq 0x61d0
cmpl %ebp, %eax
jg 0x2df9a
movq %r14, (%r15)
movq %r15, %r14
jmp 0x2df9a
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/obscure.c
// Function: slListRandomSample
void *slListRandomSample(void *list, int maxCount)
/* Return a sublist of list with at most maxCount. Destroy list in process */
{
if (list == NULL)
    return list;
int initialCount = slCount(list);
if (initialCount <= maxCount)
    return list;
double reduceRatio = (double)maxCount/initialCount;
if (reduceRatio < 0.9)
    {
    double conservativeReduceRatio = reduceRatio * 1.05;
    list = slListRandomReduce(list, conservativeReduceRatio);
    }
int midCount = slCount(list);
if (midCount <= maxCount)
    return list;
shuffleList(list);
struct slList *lastEl = slElementFromIx(list, maxCount-1);
lastEl->next = NULL;
return list;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2e030
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1c4aa
cmpl %ebp, %eax
jle 0x2e032
cvtsi2sd %ebp, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd 0x4f53f(%rip), %xmm1    # 0x7d530
ucomisd %xmm0, %xmm1
jbe 0x2e00a
mulsd 0x53ca1(%rip), %xmm0    # 0x81ca0
movq %rbx, %rdi
callq 0x2df77
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1c4aa
cmpl %ebp, %eax
jle 0x2e032
movq %rbx, %rdi
callq 0x2ded0
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c4b9
andq $0x0, (%rax)
jmp 0x2e032
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq