LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiUrlString
struct dyString *cgiUrlString()
/* Get URL-formatted that expresses current CGI variable state. */
{
struct dyString *dy = newDyString(0);
struct cgiVar *cv;
char *e;


for (cv = inputList; cv != NULL; cv = cv->next)
    {
    if (cv != inputList)
       dyStringAppend(dy, "&");
    e = cgiEncode(cv->val);
    dyStringPrintf(dy, "%s=", cv->name);
    dyStringAppend(dy, e);
    freez(&e);
    }
return dy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %edi, %edi
callq 0xf030
movq %rax, -0x8(%rbp)
movq 0x14546(%rip), %rax     # 0x33300
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ee30
movq -0x10(%rbp), %rax
cmpq 0x14530(%rip), %rax     # 0x33300
je 0x1ede2
movq -0x8(%rbp), %rdi
leaq 0x8251(%rip), %rsi      # 0x2702e
callq 0xf3c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c480
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x561c(%rip), %rsi      # 0x24422
movb $0x0, %al
callq 0xf550
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf3c0
leaq -0x18(%rbp), %rdi
callq 0x15410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1edbe
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiEncodeIntoDy
void cgiEncodeIntoDy(char *var, char *val, struct dyString *dy)
/* Add a CGI-encoded &var=val string to dy. */
{
if (dy->stringSize != 0)
    dyStringAppendC(dy, '&');
dyStringAppend(dy, var);
dyStringAppendC(dy, '=');
char *s = cgiEncode(val);
dyStringAppend(dy, s);
freez(&s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x1ee6c
movq -0x18(%rbp), %rdi
movl $0x26, %esi
callq 0xf2b0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xf3c0
movq -0x18(%rbp), %rdi
movl $0x3d, %esi
callq 0xf2b0
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf3c0
leaq -0x20(%rbp), %rdi
callq 0x15410
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiFromFile
boolean cgiFromFile(char *fileName)
/* Set up a cgi environment using parameters stored in a file.
 * Takes file with arguments in the form:
 *       argument1=someVal
 *       # This is a comment
 *       argument2=someOtherVal
 *       ...
 * and puts them into the cgi environment so that the usual
 * cgiGetVar() commands can be used. Useful when a program
 * has a lot of possible parameters.
 */
{
char **argv = NULL;
int argc = 0;
int maxArgc = 10;
int i;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line;
boolean spoof= FALSE;
AllocArray(argv, maxArgc);
/* Remember that first arg is program name.
   Put filename there instead. */
argc = 1;
argv[0] = cloneString(fileName);
for(;;)
    {
    /* If we are at the end we're done. */
    if(!lineFileNext(lf, &line, NULL))
	break;
    /* If it is a comment or blank line skip it. */
    if (line[0] == '#' || sameString(line, ""))
        continue;
    /* If our argv array is full expand it. */
    if((argc+1) >= maxArgc)
	{
	ExpandArray(argv, maxArgc, 2*maxArgc);
	maxArgc *= 2;
	}
    /* Fill in another argument to our psuedo arguments. */
    argv[argc++] = cloneString(line);
    }
spoof = cgiSpoof(&argc, argv);
/* Cleanup. */
lineFileClose(&lf);
for(i=0; i<argc; i++)
    freez(&argv[i]);
freez(&argv);
return spoof;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xa, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12400
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x15070
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
cmpl $0x0, %eax
jne 0x1f25e
jmp 0x1f2dc
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x1f27f
movq -0x30(%rbp), %rdi
leaq 0x5a85(%rip), %rsi      # 0x24cfa
callq 0x3410
cmpl $0x0, %eax
jne 0x1f281
jmp 0x1f246
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0x18(%rbp), %eax
jl 0x1f2b5
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x3, %rsi
movl -0x18(%rbp), %eax
shll %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x15380
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7530
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1f246
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdi
callq 0x1f1b0
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12ea0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f323
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15410
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f2fc
leaq -0x10(%rbp), %rdi
callq 0x15410
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: logCgiToStderr
void logCgiToStderr()
/* Log useful CGI info to stderr */
{
char *ip = getenv("REMOTE_ADDR");
char *cgiBinary = getenv("SCRIPT_FILENAME");
char *requestUri = getenv("REQUEST_URI");
char *hgsid = cgiOptionalString("hgsid");
char *cgiFileName = NULL;
time_t nowTime = time(NULL);
struct tm *tm;
tm = localtime(&nowTime);
char *ascTime = asctime(tm);
size_t len = strlen(ascTime);
if (cgiBinary)
    cgiFileName = basename(cgiBinary);
else
    cgiFileName = "cgi-bin";
if (len > 3) ascTime[len-2] = '\0';
if (!ip)
    ip = "unknown";
if (!hgsid)
    hgsid = "unknown";
if (!requestUri)
    requestUri = "unknown";
fprintf(stderr, "[%s] [%s] [client %s] [hgsid=%.24s] [%.1024s] ", ascTime, cgiFileName, ip,
	hgsid, requestUri);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x741c(%rip), %rdi      # 0x2676b
callq 0x3030
movq %rax, -0x8(%rbp)
leaq 0x7d0c(%rip), %rdi      # 0x2706b
callq 0x3030
movq %rax, -0x10(%rbp)
leaq 0x73b0(%rip), %rdi      # 0x2671f
callq 0x3030
movq %rax, -0x18(%rbp)
leaq 0x7cfc(%rip), %rdi      # 0x2707b
callq 0x1c7f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x34a0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3080
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3210
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x31f0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f3da
movq -0x10(%rbp), %rdi
callq 0x3490
movq %rax, -0x28(%rbp)
jmp 0x1f3e5
leaq 0x7ca0(%rip), %rax      # 0x27081
movq %rax, -0x28(%rbp)
cmpq $0x3, -0x48(%rbp)
jbe 0x1f3fc
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x2, %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x8(%rbp)
jne 0x1f40e
leaq 0x6a77(%rip), %rax      # 0x25e81
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1f420
leaq 0x6a65(%rip), %rax      # 0x25e81
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f432
leaq 0x6a53(%rip), %rax      # 0x25e81
movq %rax, -0x18(%rbp)
movq 0x12bb7(%rip), %rax     # 0x31ff0
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
leaq 0x7c32(%rip), %rsi      # 0x27089
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3440
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiResetState
void cgiResetState()
/* This is for reloading CGI settings multiple times in the same program
 * execution.  No effect if state has not yet been initialized. */
{
freez(&inputString);
inputString = NULL;
if (inputHash != NULL)
    hashFree(&inputHash);
inputHash = NULL;
inputList = NULL;

haveCookiesHash = FALSE;
if (cookieHash != NULL)
    hashFree(&cookieHash);
cookieHash = NULL;
cookieList = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13d9d(%rip), %rdi     # 0x33218
callq 0x15410
movq $0x0, 0x13d8d(%rip) # 0x33218
cmpq $0x0, 0x13e75(%rip)     # 0x33308
je 0x1f4a1
leaq 0x13e6c(%rip), %rdi     # 0x33308
callq 0x11620
movq $0x0, 0x13e5c(%rip) # 0x33308
movq $0x0, 0x13e49(%rip) # 0x33300
movl $0x0, 0x2404f(%rip)     # 0x43510
cmpq $0x0, 0x13d57(%rip)     # 0x33220
je 0x1f4d7
leaq 0x13d4e(%rip), %rdi     # 0x33220
callq 0x11620
movq $0x0, 0x13d3e(%rip) # 0x33220
movq $0x0, 0x13d03(%rip) # 0x331f0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiParsedVarsNew
struct cgiParsedVars *cgiParsedVarsNew(char *cgiString)
/* Build structure containing parsed out cgiString */
{
struct cgiParsedVars *tags;
AllocVar(tags);
tags->stringBuf = cloneString(cgiString);
cgiParseInputAbort(tags->stringBuf, &tags->hash, &tags->list);
hashTraverseEls(tags->hash, turnCgiVarsToVals);
return tags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x152f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
callq 0x1bda0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x16(%rip), %rsi        # 0x1f5a0
callq 0x11100
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiParsedVarsFree
void cgiParsedVarsFree(struct cgiParsedVars **pTags)
/* Free up memory associated with cgiParsedVars */
{
struct cgiParsedVars *tags = *pTags;
if (tags != NULL)
    {
    slFreeList(&tags->list);
    hashFree(&tags->hash);
    freeMem(tags->stringBuf);
    freez(pTags);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f61e
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x7c10
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x11620
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x153e0
movq -0x8(%rbp), %rdi
callq 0x15410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: initCgiInput
static void initCgiInput()
/* Initialize CGI input stuff.  After this CGI vars are
 * stored in an internal hash/list regardless of how they
 * were passed to the program. */
{
char* s;

if (inputString != NULL)
    return;

_cgiFindInput(NULL);

#ifndef GBROWSE
/* check to see if the input is a multipart form */
s = getenv("CONTENT_TYPE");
if (s != NULL && startsWith("multipart/form-data", s))
    {
    cgiParseMultipart(&inputHash, &inputList);
    }
#endif /* GBROWSE */

cgiParseInputAbort(inputString, &inputHash, &inputList);

/* now parse the cookies */
parseCookies(&cookieHash, &cookieList);

/* Set enviroment variables CGIs to enable sql tracing and/or profiling */
s = cgiOptionalString("JKSQL_TRACE");
if (s != NULL)
    envUpdate("JKSQL_TRACE", s);
s = cgiOptionalString("JKSQL_PROF");
if (s != NULL)
    envUpdate("JKSQL_PROF", s);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x13bb8(%rip)     # 0x33218
je 0x1f667
jmp 0x1f72a
xorl %eax, %eax
movl %eax, %edi
callq 0x1f730
leaq 0x7b1b(%rip), %rdi      # 0x27192
callq 0x3030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f6af
movq -0x8(%rbp), %rsi
leaq 0x7b0d(%rip), %rdi      # 0x2719f
callq 0xa4b0
cmpl $0x0, %eax
je 0x1f6af
leaq 0x13c65(%rip), %rdi     # 0x33308
leaq 0x13c56(%rip), %rsi     # 0x33300
callq 0x1f7c0
movq 0x13b62(%rip), %rdi     # 0x33218
leaq 0x13c4b(%rip), %rsi     # 0x33308
leaq 0x13c3c(%rip), %rdx     # 0x33300
callq 0x1bda0
leaq 0x13b50(%rip), %rdi     # 0x33220
leaq 0x13b19(%rip), %rsi     # 0x331f0
callq 0x1bbc0
leaq 0x7ad0(%rip), %rdi      # 0x271b3
callq 0x1c7f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f703
movq -0x8(%rbp), %rsi
leaq 0x7ab5(%rip), %rdi      # 0x271b3
callq 0x220e0
leaq 0x7ab5(%rip), %rdi      # 0x271bf
callq 0x1c7f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f72a
movq -0x8(%rbp), %rsi
leaq 0x7a9a(%rip), %rdi      # 0x271bf
callq 0x220e0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiFindInput
static void _cgiFindInput(char *method)
/* Get raw CGI input into inputString.  Method can be "POST", "QUERY", "GET" or NULL
 * for unknown. */
{
if (inputString == NULL)
    {
    method = cgiInputSource(method);
    if (sameWord(method, "POST"))
        getPostInput();
    else if (sameWord(method, "QUERY") || sameWord(method, "GET"))
        getQueryInput();
    else
        errAbort("Unknown form method");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x13ad4(%rip)     # 0x33218
jne 0x1f7b2
movq -0x8(%rbp), %rdi
callq 0x1fec0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7a6c(%rip), %rsi      # 0x271ca
callq 0x89d0
cmpl $0x0, %eax
jne 0x1f76f
callq 0x1ff50
jmp 0x1f7b0
movq -0x8(%rbp), %rdi
leaq 0x7a55(%rip), %rsi      # 0x271cf
callq 0x89d0
cmpl $0x0, %eax
je 0x1f799
movq -0x8(%rbp), %rdi
leaq 0x78c9(%rip), %rsi      # 0x27058
callq 0x89d0
cmpl $0x0, %eax
jne 0x1f7a0
callq 0x20150
jmp 0x1f7ae
leaq 0x7a2e(%rip), %rdi      # 0x271d5
movb $0x0, %al
callq 0xfd50
jmp 0x1f7b0
jmp 0x1f7b2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiInputSource
static char *cgiInputSource(char *s)
/* For NULL sources make a guess as to real source. */
{
char *qs;
if (s != NULL)
    return s;
qs = getenv("QUERY_STRING");
if (qs == NULL)
    return "POST";
char *cl = getenv("CONTENT_LENGTH");
if (cl != NULL && atoi(cl) > 0)
    return "POST";
return "QUERY";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1fedd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ff3e
leaq 0x7305(%rip), %rdi      # 0x271e9
callq 0x3030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ff01
leaq 0x72cf(%rip), %rax      # 0x271ca
movq %rax, -0x8(%rbp)
jmp 0x1ff3e
leaq 0x6823(%rip), %rdi      # 0x2672b
callq 0x3030
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ff33
movq -0x20(%rbp), %rdi
callq 0x3670
cmpl $0x0, %eax
jle 0x1ff33
leaq 0x729d(%rip), %rax      # 0x271ca
movq %rax, -0x8(%rbp)
jmp 0x1ff3e
leaq 0x7295(%rip), %rax      # 0x271cf
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: getPostInput
static void getPostInput()
/* Get input from file if they've used POST method.
 * Grab any GET QUERY_STRING input first. */
{
char *s;
long i;
int r;

getQueryInputExt(FALSE);
int getSize = strlen(inputString);

s = getenv("CONTENT_LENGTH");
if (s == NULL)
    errAbort("No CONTENT_LENGTH in environment.");
if (sscanf(s, "%lu", &inputSize) != 1)
    errAbort("CONTENT_LENGTH isn't a number.");
s = getenv("CONTENT_TYPE");
if (s != NULL && startsWith("multipart/form-data", s))
    {
    /* use MIME parse on input stream instead, can handle large uploads */
    /* inputString must not be NULL so it knows it was set */
    return;
    }
int len = getSize + inputSize;
if (getSize > 0)
    ++len;
char *temp = needMem((size_t)len+1);
for (i=0; i<inputSize; ++i)
    {
    r = getc(stdin);
    if (r == EOF)
	errAbort("Short POST input.");
    temp[i] = r;
    }
if (getSize > 0)
  temp[i++] = '&';
strncpy(temp+i, inputString, getSize);
temp[len] = 0;
freeMem(inputString);
inputString = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %edi, %edi
callq 0x200e0
movq 0x132b2(%rip), %rdi     # 0x33218
callq 0x31f0
movl %eax, -0x18(%rbp)
leaq 0x67b6(%rip), %rdi      # 0x2672b
callq 0x3030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1ff93
leaq 0x726a(%rip), %rdi      # 0x271f6
movb $0x0, %al
callq 0xfd50
movq -0x8(%rbp), %rdi
leaq 0x727a(%rip), %rsi      # 0x27218
leaq 0x23573(%rip), %rdx     # 0x43518
movb $0x0, %al
callq 0x3510
cmpl $0x1, %eax
je 0x1ffbf
leaq 0x7264(%rip), %rdi      # 0x2721c
movb $0x0, %al
callq 0xfd50
leaq 0x71cc(%rip), %rdi      # 0x27192
callq 0x3030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1fff0
movq -0x8(%rbp), %rsi
leaq 0x71be(%rip), %rdi      # 0x2719f
callq 0xa4b0
cmpl $0x0, %eax
je 0x1fff0
jmp 0x200cf
movslq -0x18(%rbp), %rax
addq 0x2351d(%rip), %rax     # 0x43518
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x2000d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
addq $0x1, %rdi
callq 0x152f0
movq %rax, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x234e7(%rip), %rax     # 0x43518
jae 0x20077
movq 0x11f8e(%rip), %rax     # 0x31fc8
movq (%rax), %rdi
callq 0x3710
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x20059
leaq 0x71e9(%rip), %rdi      # 0x2723b
movb $0x0, %al
callq 0xfd50
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x20026
cmpl $0x0, -0x18(%rbp)
jle 0x20094
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb $0x26, (%rax,%rcx)
movq -0x28(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq 0x13175(%rip), %rsi     # 0x33218
movslq -0x18(%rbp), %rdx
callq 0x30b0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x13159(%rip), %rdi     # 0x33218
callq 0x153e0
movq -0x28(%rbp), %rax
movq %rax, 0x13149(%rip)     # 0x33218
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: getQueryInputExt
static void getQueryInputExt(boolean abortOnErr)
/* Get query string from environment if they've used GET method. */
{
inputString = getenv("QUERY_STRING");
if (inputString == NULL)
    {
    if (abortOnErr)
	errAbort("No QUERY_STRING in environment.");
    inputString = cloneString("");
    return;
    }
inputString = cloneString(inputString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x70f7(%rip), %rdi      # 0x271e9
callq 0x3030
movq %rax, 0x1311a(%rip)     # 0x33218
cmpq $0x0, 0x13112(%rip)     # 0x33218
jne 0x20131
cmpl $0x0, -0x4(%rbp)
je 0x2011c
leaq 0x7138(%rip), %rdi      # 0x2724d
movb $0x0, %al
callq 0xfd50
leaq 0x4bd7(%rip), %rdi      # 0x24cfa
callq 0x7530
movq %rax, 0x130e9(%rip)     # 0x33218
jmp 0x20144
movq 0x130e0(%rip), %rdi     # 0x33218
callq 0x7530
movq %rax, 0x130d4(%rip)     # 0x33218
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: doubleExp
double doubleExp(char *text)
/* Convert text to double expression and evaluate. */
{
double val;
struct kxTok *tokList = tok = kxTokenize(text, FALSE);
val = expression();
slFreeList(&tokList);
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20b10
movq %rax, 0x233a2(%rip)     # 0x43520
movq %rax, -0x18(%rbp)
callq 0x201d0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7c10
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: addSub
static double addSub()
/* Addition or subtraction. */
{
double val;
val = mulDiv();
for (;;)
    {
    if (tok->type == kxtAdd)
	{
	nextTok();
	val += mulDiv();
	}
    else if (tok->type == kxtSub)
	{
	nextTok();
	val -= mulDiv();
	}
    else
        break;
    }
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x20270
movsd %xmm0, -0x8(%rbp)
movq 0x23327(%rip), %rax     # 0x43520
cmpl $0xe, 0x8(%rax)
jne 0x20221
movq 0x2331a(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x23310(%rip)     # 0x43520
callq 0x20270
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2025b
movq 0x232f8(%rip), %rax     # 0x43520
cmpl $0xf, 0x8(%rax)
jne 0x20257
movq 0x232eb(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x232e1(%rip)     # 0x43520
callq 0x20270
movaps %xmm0, %xmm1
movsd -0x8(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x20259
jmp 0x2025d
jmp 0x2025b
jmp 0x201f2
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: mulDiv
static double mulDiv()
/* Multiplication or division. */
{
double val = uMinus();
for (;;)
    {
    if (tok->type == kxtMul)
	{
	nextTok();
	val *= uMinus();
	}
    else if (tok->type == kxtDiv)
	{
	nextTok();
	val /= uMinus();
	}
    else
        break;
    }
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x20300
movsd %xmm0, -0x8(%rbp)
movq 0x23297(%rip), %rax     # 0x43520
cmpl $0x11, 0x8(%rax)
jne 0x202b1
movq 0x2328a(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x23280(%rip)     # 0x43520
callq 0x20300
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x202eb
movq 0x23268(%rip), %rax     # 0x43520
cmpl $0x10, 0x8(%rax)
jne 0x202e7
movq 0x2325b(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x23251(%rip)     # 0x43520
callq 0x20300
movaps %xmm0, %xmm1
movsd -0x8(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x202e9
jmp 0x202ed
jmp 0x202eb
jmp 0x20282
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: uMinus
static double uMinus()
/* Unary minus. */
{
double val;
if (tok->type == kxtSub)
    {
    nextTok();
    val = -atom();
    return val;
    }
else
    return atom();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x23211(%rip), %rax     # 0x43520
cmpl $0xf, 0x8(%rax)
jne 0x20353
movq 0x23204(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x231fa(%rip)     # 0x43520
callq 0x20370
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2035d
callq 0x20370
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: atom
static double atom()
/* Return parenthetical expression or number. */
{
double val;
if (tok->type == kxtOpenParen)
    {
    nextTok();
    val = expression();
    if (tok->type == kxtCloseParen)
	{
        nextTok();
	return val;
	}
    else
	{
        errAbort("Unmatched parenthesis");
	return 0;
	}
    }
else
    return number();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x231a1(%rip), %rax     # 0x43520
cmpl $0xc, 0x8(%rax)
jne 0x203e2
movq 0x23194(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x2318a(%rip)     # 0x43520
callq 0x201d0
movsd %xmm0, -0x10(%rbp)
movq 0x23179(%rip), %rax     # 0x43520
cmpl $0xd, 0x8(%rax)
jne 0x203ca
movq 0x2316c(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x23162(%rip)     # 0x43520
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x203ec
leaq 0x7097(%rip), %rdi      # 0x27468
movb $0x0, %al
callq 0xfd50
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x203ec
callq 0x20400
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/intExp.c
// Function: number
static double number()
/* Return number. */
{
double val;
if (tok == NULL)
    errAbort("Parse error in numerical expression");
if (!isdigit(tok->string[0]))
    errAbort("Expecting number, got %s", tok->string);
val = atof(tok->string);
nextTok();
return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x23110(%rip)     # 0x43520
jne 0x20420
leaq 0x7065(%rip), %rdi      # 0x2747e
movb $0x0, %al
callq 0xfd50
callq 0x3760
movq (%rax), %rax
movq 0x230f1(%rip), %rcx     # 0x43520
movsbl 0xd(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x2045d
movq 0x230d5(%rip), %rsi     # 0x43520
addq $0xd, %rsi
leaq 0x704c(%rip), %rdi      # 0x274a2
movb $0x0, %al
callq 0xfd50
movq 0x230bc(%rip), %rdi     # 0x43520
addq $0xd, %rdi
callq 0x3170
movsd %xmm0, -0x8(%rbp)
movq 0x230a7(%rip), %rax     # 0x43520
movq (%rax), %rax
movq %rax, 0x2309d(%rip)     # 0x43520
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/kxTok.c
// Function: kxTokNew
static struct kxTok *kxTokNew(enum kxTokType type, char *string, int stringSize,
	boolean spaceBefore)
/* Allocate and initialize a new token. */
{
struct kxTok *tok;
int totalSize = stringSize + sizeof(*tok);
tok = needMem(totalSize);
tok->type = type;
tok->spaceBefore = spaceBefore;
memcpy(tok->string, string, stringSize);
return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movslq -0x14(%rbp), %rax
addq $0x10, %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
callq 0x152f0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x20(%rbp), %rdi
addq $0xd, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3470
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: initMimeBuf
struct mimeBuf * initMimeBuf(int d)
/* d is a descriptor for a file or socket or some other descriptor 
   that the MIME input can be read from. 
   Initializes the mimeBuf structure. */
{
struct mimeBuf *b=AllocA(*b);
b->d = d;
b->boundary = NULL;
b->blen = 0;
b->eom = b->buf+MIMEBUFSIZE;
b->eoi = b->eom;
b->eod = b->eom;
b->i = b->eom;
moreMimeBuf(b);
return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x8040, %edi           # imm = 0x8040
callq 0x152f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8018(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8020(%rax)
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
addq $0x8000, %rcx           # imm = 0x8000
movq -0x10(%rbp), %rax
movq %rcx, 0x8038(%rax)
movq -0x10(%rbp), %rax
movq 0x8038(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8030(%rax)
movq -0x10(%rbp), %rax
movq 0x8038(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8028(%rax)
movq -0x10(%rbp), %rax
movq 0x8038(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8008(%rax)
movq -0x10(%rbp), %rdi
callq 0x20c10
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: moreMimeBuf
static void moreMimeBuf(struct mimeBuf *b)
{
int bytesRead = 0, bytesToRead = 0;
if (b->blen > 1)
    {
    int r = b->eoi - b->i;
    memmove(b->buf, b->i, r);
    b->eoi = b->buf+r;
    }
else
    {
    b->eoi = b->buf;
    }
b->i = b->buf+0;
bytesToRead = b->eom - b->eoi;
while (bytesToRead > 0)
    {
    bytesRead = read(b->d, b->eoi, bytesToRead);
    if (bytesRead < 0)
        errnoAbort("moreMimeBuf: error reading MIME input descriptor");
    b->eoi += bytesRead;
    if (bytesRead == 0)
        break;
    bytesToRead = bytesToRead - bytesRead;
    }
setEopMB(b);
setEodMB(b);
//debug
//fprintf(stderr,"post-moreMime dumpMB: ");
//dumpMB(b);  //debug
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8020(%rax)
jle 0x20c8b
movq -0x8(%rbp), %rax
movq 0x8030(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8008(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rax
movq 0x8008(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x35a0
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8030(%rax)
jmp 0x20c9e
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8030(%rax)
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8008(%rax)
movq -0x8(%rbp), %rax
movq 0x8038(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8030(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x20d32
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x8030(%rax), %rsi
movslq -0x10(%rbp), %rdx
callq 0x33a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x20d04
leaq 0x6a8e(%rip), %rdi      # 0x2778b
movb $0x0, %al
callq 0xfed0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8030(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8030(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x20d27
jmp 0x20d32
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x20ccd
movq -0x8(%rbp), %rdi
callq 0x21e30
movq -0x8(%rbp), %rdi
callq 0x21f70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getMimeHeaderMainVal
char *getMimeHeaderMainVal(char *header)
/* Parse a typical mime header line returning the first
 * main value up to whitespace, punctuation, or end. 
 * freeMem the returned string when done */
{
char value[1024]; 
char *h = header;
int i = 0;
char *puncChars = ",;: \t\r\n"; /* punctuation chars */
i=0;
/* The header should have already been trimmed of leading and trailing spaces */
while(TRUE)
    {
    char c = *h++;
    if (c==0 || strchr(puncChars,c))
	break;
    value[i++] = c;
    if (i >= sizeof(value))
	errAbort("error: main value too long (>%lu) in MIME header Content-type:%s",(unsigned long)sizeof(value),header);
    }
value[i] = 0;    

return cloneString(value);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x418(%rbp)
movl $0x0, -0x41c(%rbp)
leaq 0x675a(%rip), %rax      # 0x274d5
movq %rax, -0x428(%rbp)
movl $0x0, -0x41c(%rbp)
movq -0x418(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x418(%rbp)
movb (%rax), %al
movb %al, -0x429(%rbp)
movsbl -0x429(%rbp), %eax
cmpl $0x0, %eax
je 0x20dce
movq -0x428(%rbp), %rdi
movsbl -0x429(%rbp), %esi
callq 0x3250
cmpq $0x0, %rax
je 0x20dd0
jmp 0x20e1b
movb -0x429(%rbp), %cl
movl -0x41c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x41c(%rbp)
cltq
movb %cl, -0x410(%rbp,%rax)
movslq -0x41c(%rbp), %rax
cmpq $0x400, %rax            # imm = 0x400
jb 0x20e16
movq -0x8(%rbp), %rdx
leaq 0x66d3(%rip), %rdi      # 0x274dd
movl $0x400, %esi            # imm = 0x400
movb $0x0, %al
callq 0xfd50
jmp 0x20d8c
movslq -0x41c(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
leaq -0x410(%rbp), %rdi
callq 0x7530
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getMimeHeaderFieldVal
char *getMimeHeaderFieldVal(char *header, char *field)
/* Parse a typical mime header line looking for field=
 * and return the value which may be quoted.
 * freeMem the returned string when done */
{
char value[1024]; 
char *fld = header;
int i = 0;
char *puncChars = ",;: \t\r\n"; /* punctuation chars */
while (TRUE)
    {
    fld = strstr(fld,field);
    if (!fld)
	return NULL;
    if (fld > header && strchr(puncChars,fld[-1]))
	{
	fld+=strlen(field);
	if (*fld == '=')
	    {
	    ++fld;
	    break;
	    }
	}    
    else
	{
	++fld;
	}
    }	
if (*fld == '"')
    {
    puncChars = "\"";  /* quoted */
    ++fld;
    }
i=0;
while(TRUE)
    {
    char c = *fld++;
    if (c==0 || strchr(puncChars,c))
	break;
    value[i++] = c;
    if (i >= sizeof(value))
	errAbort("error: %s= value too long (>%lu) in MIME header Content-type:%s",field,(unsigned long)sizeof(value),header);
    }
value[i] = 0;    

return cloneString(value);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x428(%rbp)
movl $0x0, -0x42c(%rbp)
leaq 0x6666(%rip), %rax      # 0x274d5
movq %rax, -0x438(%rbp)
movq -0x428(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3730
movq %rax, -0x428(%rbp)
cmpq $0x0, -0x428(%rbp)
jne 0x20ea4
movq $0x0, -0x8(%rbp)
jmp 0x2100c
movq -0x428(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x20f0a
movq -0x438(%rbp), %rdi
movq -0x428(%rbp), %rax
movsbl -0x1(%rax), %esi
callq 0x3250
cmpq $0x0, %rax
je 0x20f0a
movq -0x18(%rbp), %rdi
callq 0x31f0
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x20f08
movq -0x428(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x428(%rbp)
jmp 0x20f21
jmp 0x20f1c
movq -0x428(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x428(%rbp)
jmp 0x20e76
movq -0x428(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x20f50
leaq 0x5a34(%rip), %rax      # 0x2696b
movq %rax, -0x438(%rbp)
movq -0x428(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x428(%rbp)
movl $0x0, -0x42c(%rbp)
movq -0x428(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x428(%rbp)
movb (%rax), %al
movb %al, -0x439(%rbp)
movsbl -0x439(%rbp), %eax
cmpl $0x0, %eax
je 0x20f9c
movq -0x438(%rbp), %rdi
movsbl -0x439(%rbp), %esi
callq 0x3250
cmpq $0x0, %rax
je 0x20f9e
jmp 0x20fed
movb -0x439(%rbp), %cl
movl -0x42c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x42c(%rbp)
cltq
movb %cl, -0x420(%rbp,%rax)
movslq -0x42c(%rbp), %rax
cmpq $0x400, %rax            # imm = 0x400
jb 0x20fe8
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x6542(%rip), %rdi      # 0x2751e
movl $0x400, %edx            # imm = 0x400
movb $0x0, %al
callq 0xfd50
jmp 0x20f5a
movslq -0x42c(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
leaq -0x420(%rbp), %rdi
callq 0x7530
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getNewLineByType
char *getNewLineByType()
/* just use global nlType setting */
{
switch (nlType)
    {
    case nlt_dos:
	//debug
    	//fprintf(stderr,"nlType=nlt_dos\n");
	return "\x0d\x0a";
    case nlt_mac:
	//debug
    	//fprintf(stderr,"nlType=nlt_mac\n");
	return "\x0d";
    case nlt_unix:
    default:
	//debug
    	//fprintf(stderr,"nlType=nlt_unix\n");
	return "\x0a";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x22502(%rip), %eax     # 0x4352c
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x21062
jmp 0x21034
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x21048
jmp 0x2103e
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x21055
jmp 0x21064
leaq 0x648b(%rip), %rax      # 0x274da
movq %rax, -0x8(%rbp)
jmp 0x2106f
leaq 0x6502(%rip), %rax      # 0x2755e
movq %rax, -0x8(%rbp)
jmp 0x2106f
jmp 0x21064
leaq 0x6470(%rip), %rax      # 0x274db
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getLineMB
static char *getLineMB(struct mimeBuf *b)
/* Reads one line up to CRLF, returned string does not include CRLF however. 
   Use freeMem when done with string. */
{
char line[MAXPARTLINESIZE];
int i = 0;
char c = 0;
line[0]=0;
while(TRUE)
    {
    c =getcMB(b);
    if ((c == 0x0d) || (c == 0x0a))  /* CR or LF is end of line */
	break;
    line[i++] = c;
    if (i >= MAXPARTLINESIZE)
	errAbort("getLineMB error - MIME input header too long, "
		    "greater than %d chars",MAXPARTLINESIZE);
    }
line[i] = 0; /* terminate string */ 
if (nlType == nlt_undet)  /* determine newline type */
    {
    if (c == 0x0d)
	{
	nlType = nlt_mac;
	c = getcMB(b);
	if (c == 0x0a)
	    nlType = nlt_dos;
	else
    	    putBackMB(b);
	}
    else
	{
	nlType = nlt_unix;
	}
    }
else if (nlType == nlt_dos)
    {
    if (c == 0x0d)
    	getcMB(b); /* just waste the LF */
    else
	nlType = nlt_unix;
    }
return cloneString(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl $0x0, -0x414(%rbp)
movb $0x0, -0x415(%rbp)
movb $0x0, -0x410(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21d80
movb %al, -0x415(%rbp)
movsbl -0x415(%rbp), %eax
cmpl $0xd, %eax
je 0x2198e
movsbl -0x415(%rbp), %eax
cmpl $0xa, %eax
jne 0x21990
jmp 0x219d1
movb -0x415(%rbp), %cl
movl -0x414(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x414(%rbp)
cltq
movb %cl, -0x410(%rbp,%rax)
cmpl $0x400, -0x414(%rbp)    # imm = 0x400
jl 0x219cf
leaq 0x5df9(%rip), %rdi      # 0x277bc
movl $0x400, %esi            # imm = 0x400
movb $0x0, %al
callq 0xfd50
jmp 0x21967
movslq -0x414(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
cmpl $0x0, 0x21b45(%rip)     # 0x4352c
jne 0x21a3d
movsbl -0x415(%rbp), %eax
cmpl $0xd, %eax
jne 0x21a31
movl $0x3, 0x21b2d(%rip)     # 0x4352c
movq -0x8(%rbp), %rdi
callq 0x21d80
movb %al, -0x415(%rbp)
movsbl -0x415(%rbp), %eax
cmpl $0xa, %eax
jne 0x21a26
movl $0x2, 0x21b08(%rip)     # 0x4352c
jmp 0x21a2f
movq -0x8(%rbp), %rdi
callq 0x21ff0
jmp 0x21a3b
movl $0x1, 0x21af1(%rip)     # 0x4352c
jmp 0x21a6b
cmpl $0x2, 0x21ae8(%rip)     # 0x4352c
jne 0x21a69
movsbl -0x415(%rbp), %eax
cmpl $0xd, %eax
jne 0x21a5d
movq -0x8(%rbp), %rdi
callq 0x21d80
jmp 0x21a67
movl $0x1, 0x21ac5(%rip)     # 0x4352c
jmp 0x21a69
jmp 0x21a6b
leaq -0x410(%rbp), %rdi
callq 0x7530
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: setBoundaryMB
static void setBoundaryMB(struct mimeBuf *b, char *boundary)
/* set boundary in b */
{
b->boundary = boundary;
b->blen = boundary ? strlen(b->boundary) : 0;
setEopMB(b);
setEodMB(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8018(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x21d0c
movq -0x8(%rbp), %rax
movq 0x8018(%rax), %rdi
callq 0x31f0
movq %rax, -0x18(%rbp)
jmp 0x21d14
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x21d14
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8020(%rax)
movq -0x8(%rbp), %rdi
callq 0x21e30
movq -0x8(%rbp), %rdi
callq 0x21f70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getcMB
static char getcMB(struct mimeBuf *b)
/* read just one char from MIME buffer */
{
if (b->i >= b->eoi && b->eoi < b->eom)  /* at end of input */
    errAbort("getcMB error - requested input beyond end of MIME input.");
if (b->i >= b->eod && b->eoi == b->eom) /* at end of buffer */
    moreMimeBuf(b);
    
//fprintf(stderr,"b->buf:%lu b->i:%lu %c \n",
//    (unsigned long) b->buf,
//    (unsigned long) b->i,
//    *b->i
//    );
//fprintf(stderr,"%c",*b->i);
//fflush(stderr); 
return *b->i++;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8008(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8030(%rcx), %rax
jb 0x21dca
movq -0x8(%rbp), %rax
movq 0x8030(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8038(%rcx), %rax
jae 0x21dca
leaq 0x5ac7(%rip), %rdi      # 0x2788a
movb $0x0, %al
callq 0xfd50
movq -0x8(%rbp), %rax
movq 0x8008(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8028(%rcx), %rax
jb 0x21e03
movq -0x8(%rbp), %rax
movq 0x8030(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8038(%rcx), %rax
jne 0x21e03
movq -0x8(%rbp), %rdi
callq 0x20c10
movq -0x8(%rbp), %rcx
movq 0x8008(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8008(%rcx)
movb (%rax), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/mime.c
// Function: getChunkMB
static void getChunkMB(struct mimeBuf *b, char **address, int *size, boolean *hasZeros)
/* Pass back address and size of chunk, and whether it contains embedded zeros.
   The chunk is the largest piece of data left in the buffer up to the eod or eop. */
{
char *eoc = b->eop ? b->eop : b->eod; /* end of chunk */
//debug
//fprintf(stderr,"pre-getChunkMB dumpMB: ");
//dumpMB(b);  //debug
*address=b->i;
*size=eoc - b->i;
*hasZeros = (memMatch("", 1,*address, *size) != NULL);
b->i = eoc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8010(%rax)
je 0x21ee7
movq -0x8(%rbp), %rax
movq 0x8010(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x21ef6
movq -0x8(%rbp), %rax
movq 0x8028(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8008(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8008(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
leaq 0x2dbc(%rip), %rdi      # 0x24cfa
movl $0x1, %esi
callq 0xab90
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8008(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/portimpl.c
// Function: envUpdate
void envUpdate(char *name, char *value)
/* Update an environment string */
{
int size = strlen(name) + strlen(value) + 2;
char *s = needMem(size);
safef(s, size, "%s=%s", name, value);
putenv(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $0x2, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x152f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x5789(%rip), %rdx      # 0x278c3
movb $0x0, %al
callq 0xdc90
movq -0x20(%rbp), %rdi
callq 0x33f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/portimpl.c
// Function: mkdirTrashDirectory
void mkdirTrashDirectory(char *prefix)
/*	create the specified trash directory if it doesn't exist */
{
struct stat buf;
char trashDirName[128];
safef(trashDirName, sizeof(trashDirName), "%s/%s", trashDir(), prefix);
if (stat(trashDirName,&buf))
    {
    int result = mkdir (trashDirName, S_IRWXU | S_IRWXG | S_IRWXO);
    if (0 != result)
	errnoAbort("failed to create directory %s", trashDirName);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x130(%rbp)
callq 0x220a0
movq -0x130(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x80, %esi
leaq 0x573d(%rip), %rdx      # 0x278c9
movb $0x0, %al
callq 0xdc90
leaq -0x120(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x221e3
leaq -0x120(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x30d0
movl %eax, -0x124(%rbp)
xorl %eax, %eax
cmpl -0x124(%rbp), %eax
je 0x221e1
leaq -0x120(%rbp), %rsi
leaq 0x56f5(%rip), %rdi      # 0x278cf
movb $0x0, %al
callq 0xfed0
jmp 0x221e3
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/portimpl.c
// Function: makeDirsOnPath
void makeDirsOnPath(char *pathName)
/* Create directory specified by pathName.  If pathName contains
 * slashes, create directory at each level of path if it doesn't
 * already exist.  Abort with error message if there's a problem.
 * (It's not considered a problem for the directory to already
 * exist. ) */
{

/* shortcut for paths that already exist */
if (fileExists(pathName))
    return;

/* Make local copy of pathName. */
int len = strlen(pathName);
char pathCopy[len+1];
strcpy(pathCopy, pathName);

/* Tolerate double-slashes in path, everyone else does it. */

/* Start at root if it's an absolute path name. */
char *s = pathCopy, *e;
while (*s++ == '/')
    /* do nothing */;

/* Step through it one slash at a time 
 * making directory if possible, else dying. */
for (; !isEmpty(s); s = e)
    {
    /* Find end of this section and terminate string there. */
    e = strchr(s, '/');
    if (e != NULL)
	*e = 0;
    makeDir(pathCopy);
    if (e != NULL)
	*e++ = '/';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xda10
cmpl $0x0, %eax
je 0x2220f
jmp 0x222eb
movq -0x8(%rbp), %rdi
callq 0x31f0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rsp
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
callq 0x30c0
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2226d
jmp 0x22254
jmp 0x2226f
movb $0x1, %al
cmpq $0x0, -0x28(%rbp)
movb %al, -0x39(%rbp)
je 0x2228b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x22296
jmp 0x222e4
movq -0x28(%rbp), %rdi
movl $0x2f, %esi
callq 0x3250
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x222b6
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
callq 0x187a0
cmpq $0x0, -0x30(%rbp)
je 0x222d8
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x2f, (%rax)
jmp 0x222da
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2226f
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/abdalazizrashid[P]st-HiDPI/x.c
// Function: mouseaction
int
mouseaction(XEvent *e, uint release)
{
	MouseShortcut *ms;

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
		if (ms->release == release &&
		    ms->button == e->xbutton.button &&
		    (!ms->altscrn || (ms->altscrn == (tisaltscr() ? 1 : -1))) &&
		    (match(ms->mod, e->xbutton.state) ||  /* exact or forced */
		     match(ms->mod, e->xbutton.state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x892a(%rip), %rax      # 0x19d00
movq %rax, -0x20(%rbp)
leaq 0x891f(%rip), %rax      # 0x19d00
addq $0xa0, %rax
cmpq %rax, -0x20(%rbp)
jae 0x114ae
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1149b
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x1149b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x11447
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x7df0
movl %eax, %esi
movl -0x24(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x1149b
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x10d30
cmpl $0x0, %eax
jne 0x11480
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
movl 0x887f(%rip), %eax      # 0x19cf0
xorl $-0x1, %eax
andl %eax, %esi
callq 0x10d30
cmpl $0x0, %eax
je 0x1149b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x114b5
jmp 0x1149d
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x113da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop