LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: mustFindVarData
static char *mustFindVarData(char *varName)
/* Find variable and associated data or die trying. */
{
char *res = findVarData(varName);
if (res == NULL)
    cgiBadVar(varName);
return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x139f0
movq %rax, %rbx
testq %rax, %rax
jne 0x13a49
testq %r14, %r14
leaq 0x629b(%rip), %rsi      # 0x19cd2
cmovneq %r14, %rsi
leaq 0x7d8f(%rip), %rdi      # 0x1b7d1
xorl %eax, %eax
callq 0xb6c8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiStringList
struct slName *cgiStringList(char *varName)
/* Find list of cgi variables with given name.  This
 * may be empty.  Free result with slFreeList(). */
{
struct hashEl *hel;
struct slName *stringList = NULL, *string;

initCgiInput();
for (hel = hashLookup(inputHash, varName); hel != NULL; hel = hel->next)
    {
    if (sameString(hel->name, varName))
        {
	struct cgiVar *var = hel->val;
	string = newSlName(var->val);
	slAddHead(&stringList, string);
	}
    }
return stringList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1587c
movq 0x1485e(%rip), %rdi     # 0x282d8
movq %rbx, %rsi
callq 0xbb8c
testq %rax, %rax
je 0x13aba
movq %rax, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3440
testl %eax, %eax
jne 0x13ab0
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdi
callq 0x6cb2
movq %r15, (%rax)
movq %rax, %r15
movq (%r14), %r14
testq %r14, %r14
jne 0x13a8d
jmp 0x13abd
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiInt
int cgiInt(char *varName)
/* Return int value of cgi variable. */
{
char *data;
char c;

data = mustFindVarData(varName);
data = skipLeadingSpaces(data);
c = data[0];
if (!(isdigit(c) || (c == '-' && isdigit(data[1]))))
     errAbort("Expecting number in %s, got \"%s\"\n", varName, data);
return atoi(data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x13a19
movq %rax, %rdi
callq 0x7b0d
movq %rax, %r14
movsbq (%rax), %r15
callq 0x37a0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
jne 0x13b18
cmpb $0x2d, %r15b
jne 0x13b04
movsbq 0x1(%r14), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x13b18
leaq 0x7cfa(%rip), %rdi      # 0x1b805
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb6c8
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36a0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiOptionalInt
int cgiOptionalInt(char *varName, int defaultVal)
/* This returns integer value of varName if it exists in cgi environment
 * and it's not just the empty string otherwise it returns defaultVal. */
{
char *s = cgiOptionalString(varName);
s = skipLeadingSpaces(s);
if (isEmpty(s))
    return defaultVal;
return cgiInt(varName);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x139f0
movq %rax, %rdi
callq 0x7b0d
testq %rax, %rax
je 0x13b63
cmpb $0x0, (%rax)
je 0x13b63
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13ac6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiDouble
double cgiDouble(char *varName)
/* Returns double value. */
{
char *data;
double x;

data = mustFindVarData(varName);
if (sscanf(data, "%lf", &x)<1)
     errAbort("Expecting real number in %s, got \"%s\"\n", varName, data);
return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13a19
movq %rax, %r14
leaq 0x7ca4(%rip), %rsi      # 0x1b827
movq %rsp, %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x3530
testl %eax, %eax
jg 0x13ba8
leaq 0x7c90(%rip), %rdi      # 0x1b82b
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb6c8
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiOneChoice
int cgiOneChoice(char *varName, struct cgiChoice *choices, int choiceSize)
/* Returns value associated with string variable in choice table. */
{
char *key = cgiString(varName);
int i;
int val = -1;

for (i=0; i<choiceSize; ++i)
    {
    if (sameWord(choices[i].name, key))
        {
        val =  choices[i].value;
        return val;
        }
    }
errAbort("Unknown key %s for variable %s\n", key, varName);
return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13a19
movq %rax, %r15
testl %ebp, %ebp
jle 0x13c7f
movl %ebp, %r12d
shlq $0x4, %r12
xorl %r13d, %r13d
movq (%r14,%r13), %rdi
movq %r15, %rsi
callq 0x6e58
testl %eax, %eax
je 0x13c9a
addq $0x10, %r13
cmpq %r13, %r12
jne 0x13c66
leaq 0x7bcc(%rip), %rdi      # 0x1b852
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb6c8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x13c9f
movl 0x8(%r14,%r13), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeOptionalButton
void cgiMakeOptionalButton(char *name, char *value, boolean disabled)
/* Make 'submit' type button that can be disabled. */
{
printf("<INPUT TYPE=SUBMIT NAME=\"%s\" VALUE=\"%s\"", name, value);
if (disabled)
    printf(" DISABLED");
printf(">");
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x7bc3(%rip), %rdi      # 0x1b9bf
xorl %eax, %eax
callq 0x3270
testl %ebx, %ebx
je 0x13e15
leaq 0x7bd9(%rip), %rdi      # 0x1b9e7
xorl %eax, %eax
callq 0x3270
movl $0x3e, %edi
popq %rbx
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeCheckBoxUtil
void cgiMakeCheckBoxUtil(char *name, boolean checked, char *msg, char *id)
/* Make check box - can be called directly, though it was originally meant
 * as the common code for all lower level checkbox routines.
 * However, it's util functionality has been taken over by
 * cgiMakeCheckBoxWithIdAndOptionalHtml() */
{
char buf[256];

if (msg)
    safef(buf, sizeof(buf), "TITLE=\"%s\"", msg);
else
    buf[0] = 0;

cgiMakeCheckBox2Bool(name, checked, TRUE, id, buf);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdx, %rdx
je 0x13fc6
movq %rdx, %rcx
leaq 0x7b00(%rip), %rdx      # 0x1bab5
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0xa0ca
jmp 0x13fca
movb $0x0, (%rsp)
movq %rsp, %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13fe6
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeCheckBox2Bool
static void cgiMakeCheckBox2Bool(char *name, boolean checked, boolean enabled,
                                 char *id, char *moreHtml)
/* Make check box - designed to be called by the variously overloaded
 * cgiMakeCheckBox functions, and should NOT be called directly.
 * moreHtml: optional additional html like javascript call or mouseover msg (may be NULL)
 * id: button id (may be NULL)
 * Also make a shadow hidden variable and support 2 boolean states:
 *    checked/unchecked and enabled/disabled. */
{
char buf[256], idBuf[256];

if(id)
    safef(idBuf, sizeof(idBuf), " id=\"%s\"", id);
else
    idBuf[0] = 0;

printf("<INPUT TYPE=CHECKBOX NAME=\"%s\"%s VALUE=on %s%s%s>", name, idBuf,
        (moreHtml ? moreHtml : ""),
        (checked ? " CHECKED" : ""),
        (enabled ? "" : " DISABLED"));
safef(buf, sizeof(buf), "%s%s", cgiBooleanShadowPrefix(), name);
cgiMakeHiddenVarWithExtra(buf, ( enabled ? "0" : (checked ? "-1" : "-2")),BOOLSHAD_EXTRA);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x14019
movq %rdx, %rcx
leaq 0x83b4(%rip), %rdx      # 0x1c3bc
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0xa0ca
jmp 0x1401d
movb $0x0, (%rsp)
testq %r14, %r14
leaq 0x5cab(%rip), %r9       # 0x19cd2
cmoveq %r9, %r14
testl %ebp, %ebp
leaq 0x7ab4(%rip), %r8       # 0x1bae8
cmoveq %r9, %r8
leaq 0x8386(%rip), %rdi      # 0x1c3c5
movq %rsp, %rdx
movq %rbx, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x3270
leaq 0x6151(%rip), %rdx      # 0x1a1a7
leaq 0x7a4e(%rip), %rcx      # 0x1baab
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %r8
xorl %eax, %eax
callq 0xa0ca
leaq 0x7f17(%rip), %rdi      # 0x1bf95
leaq 0x71ed(%rip), %rdx      # 0x1b272
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7dbb(%rip), %rdi      # 0x1be51
leaq 0x7a6f(%rip), %rsi      # 0x1bb0c
xorl %eax, %eax
callq 0x3270
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeCheckBoxFourWay
void cgiMakeCheckBoxFourWay(char *name, boolean checked, boolean enabled, char *id,
                            char *classes, char *moreHtml)
/* Make check box - with fourWay functionality (checked/unchecked by enabled/disabled)
 * Also makes a shadow hidden variable that supports the 2 boolean states. */
{
char shadName[256];

printf("<INPUT TYPE=CHECKBOX NAME='%s'", name);
if (id)
    printf(" id='%s'", id);
if (checked)
    printf(" CHECKED");
if (!enabled)
    {
    if (findWordByDelimiter("disabled",' ', classes) == NULL) // fauxDisabled ?
        printf(" DISABLED");
    }
if (classes)
    printf(" class='%s'",classes);
if (moreHtml)
    printf(" %s",moreHtml);
printf(">");

// The hidden var needs to hold the 4way state
safef(shadName, sizeof(shadName), "%s%s", cgiBooleanShadowPrefix(), name);
cgiMakeHiddenVarWithExtra(shadName, ( enabled ? "0" : (checked ? "-1" : "-2")),BOOLSHAD_EXTRA);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x7980(%rip), %rdi      # 0x1bac0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x14160
leaq 0x7989(%rip), %rdi      # 0x1badf
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
testl %ebp, %ebp
je 0x14172
leaq 0x797d(%rip), %rdi      # 0x1bae8
xorl %eax, %eax
callq 0x3270
testl %ebx, %ebx
jne 0x1419d
leaq 0x7974(%rip), %rdi      # 0x1baf1
movl $0x20, %esi
movq %r12, %rdx
callq 0x8110
testq %rax, %rax
jne 0x1419d
leaq 0x7851(%rip), %rdi      # 0x1b9e7
xorl %eax, %eax
callq 0x3270
testq %r12, %r12
je 0x141b3
leaq 0x7951(%rip), %rdi      # 0x1bafa
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
testq %r15, %r15
je 0x141c9
leaq 0x5c9c(%rip), %rdi      # 0x19e5b
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
movl $0x3e, %edi
callq 0x3080
leaq 0x5fcd(%rip), %rdx      # 0x1a1a7
leaq 0x78ca(%rip), %rcx      # 0x1baab
movq %rsp, %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %r8
xorl %eax, %eax
callq 0xa0ca
testl %ebp, %ebp
leaq 0x790a(%rip), %rax      # 0x1bb09
leaq 0x7900(%rip), %rcx      # 0x1bb06
cmoveq %rax, %rcx
testl %ebx, %ebx
leaq 0x705f(%rip), %rdx      # 0x1b272
cmoveq %rcx, %rdx
leaq 0x7d77(%rip), %rdi      # 0x1bf95
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7c22(%rip), %rdi      # 0x1be51
leaq 0x78d6(%rip), %rsi      # 0x1bb0c
xorl %eax, %eax
callq 0x3270
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeHiddenVarWithExtra
void cgiMakeHiddenVarWithExtra(char *varName, char *string,char *extra)
/* Store string in hidden input for next time around. */
{
printf("<INPUT TYPE=HIDDEN NAME='%s' VALUE='%s'", varName, string);
if (extra)
    printf(" %s>\n",extra);
else
    puts(">");
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x7d35(%rip), %rdi      # 0x1bf95
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x1427e
leaq 0x7bde(%rip), %rdi      # 0x1be51
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x3270
leaq 0x7622(%rip), %rdi      # 0x1b8a7
popq %rbx
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeHiddenBoolean
void cgiMakeHiddenBoolean(char *name, boolean on)
/* Make hidden boolean variable. Also make a shadow hidden variable so we
 * can distinguish between variable not present and
 * variable set to false. */
{
char buf[256];
cgiMakeHiddenVar(name, on ? "on" : "off");
safef(buf, sizeof(buf), "%s%s", cgiBooleanShadowPrefix(), name);
cgiMakeHiddenVarWithExtra(buf, "1",BOOLSHAD_EXTRA);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
testl %esi, %esi
leaq 0x787a(%rip), %rax      # 0x1bb1d
leaq 0x7d2b(%rip), %rdx      # 0x1bfd5
cmoveq %rax, %rdx
leaq 0x7ce0(%rip), %r14      # 0x1bf95
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x75de(%rip), %rdi      # 0x1b8a7
callq 0x3100
leaq 0x5ed2(%rip), %rdx      # 0x1a1a7
leaq 0x77cf(%rip), %rcx      # 0x1baab
movq %rsp, %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %r8
xorl %eax, %eax
callq 0xa0ca
leaq 0x780f(%rip), %rdx      # 0x1bb07
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7b45(%rip), %rdi      # 0x1be51
leaq 0x77f9(%rip), %rsi      # 0x1bb0c
xorl %eax, %eax
callq 0x3270
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeOnKeypressTextVar
void cgiMakeOnKeypressTextVar(char *varName, char *initialVal, int charSize,
			      char *script)
/* Make a text control filled with initial value, with a (java)script
 * to execute every time a key is pressed.  If charSize is zero it's
 * calculated from initialVal size. */
{
if (initialVal == NULL)
    initialVal = "";
if (charSize == 0) charSize = strlen(initialVal);
if (charSize == 0) charSize = 8;

printf("<INPUT TYPE=TEXT NAME=\"%s\" SIZE=%d VALUE=\"%s\"", varName,
        charSize, initialVal);
if (isNotEmpty(script))
    printf(" onkeypress=\"%s\"", script);
printf(">\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r15
testq %rsi, %rsi
leaq 0x5944(%rip), %r14      # 0x19cd2
cmovneq %rsi, %r14
testl %edx, %edx
jne 0x143a1
movq %r14, %rdi
callq 0x3200
movq %rax, %rdx
testl %edx, %edx
movl $0x8, %eax
cmovnel %edx, %eax
leaq 0x77a4(%rip), %rdi      # 0x1bb56
movq %r15, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x143dc
cmpb $0x0, (%rbx)
je 0x143dc
leaq 0x77b2(%rip), %rdi      # 0x1bb84
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x74c4(%rip), %rdi      # 0x1b8a7
popq %rbx
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeTextVarWithExtraHtml
void cgiMakeTextVarWithExtraHtml(char *varName, char *initialVal, int width, char *extra)
/* Make a text control filled with initial value. */
{
if (initialVal == NULL)
    initialVal = "";
if (width==0)
    width=strlen(initialVal)*10;
if (width==0)
    width = 100;

printf("<INPUT TYPE=TEXT class='inputBox' NAME=\"%s\" style='width: %dpx' VALUE=\"%s\"",
       varName,width, initialVal);
if (isNotEmpty(extra))
    printf(" %s",extra);
printf(">\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r15
testq %rsi, %rsi
leaq 0x58c9(%rip), %r14      # 0x19cd2
cmovneq %rsi, %r14
testl %edx, %edx
jne 0x1441e
movq %r14, %rdi
callq 0x3200
addl %eax, %eax
leal (%rax,%rax,4), %edx
testl %edx, %edx
movl $0x64, %eax
cmovnel %edx, %eax
leaq 0x7766(%rip), %rdi      # 0x1bb95
movq %r15, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x14459
cmpb $0x0, (%rbx)
je 0x14459
leaq 0x5a0c(%rip), %rdi      # 0x19e5b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7447(%rip), %rdi      # 0x1b8a7
popq %rbx
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeIntVarInRange
void cgiMakeIntVarInRange(char *varName, int initialVal, char *title, int width,
                          char *min, char *max)
/* Make a integer control filled with initial value.
   If min and/or max are non-NULL will enforce range
   Requires utils.js jQuery.js and inputBox class */
{
if (width==0)
    {
    if (max)
        width=strlen(max)*10;
    else
        {
        int sz=initialVal+1000;
        if (min)
            sz=atoi(min) + 1000;
        width = 10;
        while (sz/=10)
            width+=10;
        }
    }
if (width < 65)
    width = 65;

printf("<INPUT TYPE=TEXT class='inputBox' name=\"%s\" style='width: %dpx' value=%d",
       varName,width,initialVal);
printf(" onChange='return validateInt(this,%s,%s);'",
       (min ? min : "\"null\""),(max ? max : "\"null\""));
if (title)
    printf(" title='%s'",title);
printf(">\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
testl %ecx, %ecx
jne 0x144fd
testq %r14, %r14
je 0x144b5
movq %r14, %rdi
callq 0x3200
addl %eax, %eax
leal (%rax,%rax,4), %ecx
jmp 0x144fd
movl %ebp, %eax
testq %r15, %r15
je 0x144c4
movq %r15, %rdi
callq 0x36a0
leal 0x3f1(%rax), %edx
movl $0xa, %ecx
cmpl $0x13, %edx
jb 0x144fd
addl $0x3e8, %eax            # imm = 0x3E8
cltq
imulq $0x66666667, %rax, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
leal (%rdx,%rsi), %eax
addl $0xa, %ecx
addl %esi, %edx
addl $0x9, %edx
cmpl $0x12, %edx
ja 0x144d9
cmpl $0x42, %ecx
movl $0x41, %edx
cmovgel %ecx, %edx
leaq 0x76fe(%rip), %rdi      # 0x1bc0d
movq %r12, %rsi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3270
testq %r15, %r15
leaq 0x775d(%rip), %rax      # 0x1bc82
cmoveq %rax, %r15
testq %r14, %r14
cmoveq %rax, %r14
leaq 0x771f(%rip), %rdi      # 0x1bc56
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x1455a
leaq 0x7739(%rip), %rdi      # 0x1bc89
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7346(%rip), %rdi      # 0x1b8a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeIntVarWithLimits
void cgiMakeIntVarWithLimits(char *varName, int initialVal, char *title, int width,
                             int min, int max)
{
char minLimit[20];
char maxLimit[20];
char *minStr=NULL;
char *maxStr=NULL;
if (min != NO_VALUE)
    {
    safef(minLimit,sizeof(minLimit),"%d",min);
    minStr = minLimit;
    }
if (max != NO_VALUE)
    {
    safef(maxLimit,sizeof(maxLimit),"%d",max);
    maxStr = maxLimit;
    }
cgiMakeIntVarInRange(varName,initialVal,title,width,minStr,maxStr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0xfffe8663, %r8d       # imm = 0xFFFE8663
jne 0x14599
xorl %r12d, %r12d
jmp 0x145b7
leaq 0x6f8d(%rip), %rdx      # 0x1b52d
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl $0x14, %esi
movl %r8d, %ecx
xorl %eax, %eax
callq 0xa0ca
cmpl $0xfffe8663, %r13d      # imm = 0xFFFE8663
jne 0x145c4
xorl %ebx, %ebx
jmp 0x145e2
leaq 0x6f62(%rip), %rdx      # 0x1b52d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x14, %esi
movl %r13d, %ecx
xorl %eax, %eax
callq 0xa0ca
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl 0xc(%rsp), %ecx
movq %r12, %r8
movq %rbx, %r9
callq 0x14487
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeIntVarWithMin
void cgiMakeIntVarWithMin(char *varName, int initialVal, char *title, int width, int min)
{
char minLimit[20];
char *minStr=NULL;
if (min != NO_VALUE)
    {
    safef(minLimit,sizeof(minLimit),"%d",min);
    minStr = minLimit;
    }
cgiMakeIntVarInRange(varName,initialVal,title,width,minStr,NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0xfffe8663, %r8d       # imm = 0xFFFE8663
jne 0x1462c
xorl %r12d, %r12d
jmp 0x14648
leaq 0x6efa(%rip), %rdx      # 0x1b52d
movq %rsp, %r12
movq %r12, %rdi
movl $0x14, %esi
movl %r8d, %ecx
xorl %eax, %eax
callq 0xa0ca
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x14487
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeIntVarWithMax
void cgiMakeIntVarWithMax(char *varName, int initialVal, char *title, int width, int max)
{
char maxLimit[20];
char *maxStr=NULL;
if (max != NO_VALUE)
    {
    safef(maxLimit,sizeof(maxLimit),"%d",max);
    maxStr = maxLimit;
    }
cgiMakeIntVarInRange(varName,initialVal,title,width,NULL,maxStr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0xfffe8663, %r8d       # imm = 0xFFFE8663
jne 0x1468e
xorl %r12d, %r12d
jmp 0x146aa
leaq 0x6e98(%rip), %rdx      # 0x1b52d
movq %rsp, %r12
movq %r12, %rdi
movl $0x14, %esi
movl %r8d, %ecx
xorl %eax, %eax
callq 0xa0ca
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x14487
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDoubleVarInRange
void cgiMakeDoubleVarInRange(char *varName, double initialVal, char *title, int width,
                             char *min, char *max)
/* Make a floating point control filled with initial value.
   If min and/or max are non-NULL will enforce range
   Requires utils.js jQuery.js and inputBox class */
{
if (width==0)
    {
    if (max)
        width=strlen(max)*10;
    }
if (width < 65)
    width = 65;

printf("<INPUT TYPE=TEXT class='inputBox' name=\"%s\" style='width: %dpx' value=%g",
       varName,width,initialVal);
printf(" onChange='return validateFloat(this,%s,%s);'",
       (min ? min : "\"null\""),(max ? max : "\"null\""));
if (title)
    printf(" title='%s'",title);
printf(">\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
testl %edx, %edx
setne %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x14724
movq %r15, %rdi
movsd %xmm0, (%rsp)
callq 0x3200
movsd (%rsp), %xmm0
addl %eax, %eax
leal (%rax,%rax,4), %edx
cmpl $0x42, %edx
movl $0x41, %eax
cmovgel %edx, %eax
leaq 0x758c(%rip), %rdi      # 0x1bcc2
movq %r12, %rsi
movl %eax, %edx
movb $0x1, %al
callq 0x3270
testq %r14, %r14
leaq 0x7536(%rip), %rdx      # 0x1bc82
cmoveq %rdx, %r14
testq %r15, %r15
cmovneq %r15, %rdx
leaq 0x75ad(%rip), %rdi      # 0x1bd0b
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x1477e
leaq 0x7515(%rip), %rdi      # 0x1bc89
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x7122(%rip), %rdi      # 0x1b8a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDoubleVarWithLimits
void cgiMakeDoubleVarWithLimits(char *varName, double initialVal, char *title, int width,
                                double min, double max)
{
char minLimit[20];
char maxLimit[20];
char *minStr=NULL;
char *maxStr=NULL;
if ((int)min != NO_VALUE)
    {
    safef(minLimit,sizeof(minLimit),"%g",min);
    minStr = minLimit;
    }
if ((int)max != NO_VALUE)
    {
    safef(maxLimit,sizeof(maxLimit),"%g",max);
    maxStr = maxLimit;
    }
cgiMakeDoubleVarInRange(varName,initialVal,title,width,minStr,maxStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r14
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
cvttsd2si %xmm1, %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
jne 0x147c0
xorl %r12d, %r12d
jmp 0x147e9
leaq 0x7541(%rip), %rdx      # 0x1bd08
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl $0x14, %esi
movapd %xmm1, %xmm0
movb $0x1, %al
movsd %xmm2, (%rsp)
callq 0xa0ca
movsd (%rsp), %xmm2
cvttsd2si %xmm2, %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
jne 0x147f9
xorl %r13d, %r13d
jmp 0x14818
leaq 0x7508(%rip), %rdx      # 0x1bd08
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x14, %esi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0xa0ca
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
movq %r13, %r8
callq 0x146ea
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDoubleVarWithMin
void cgiMakeDoubleVarWithMin(char *varName, double initialVal, char *title, int width, double min)
{
char minLimit[20];
char *minStr=NULL;
if ((int)min != NO_VALUE)
    {
    safef(minLimit,sizeof(minLimit),"%g",min);
    minStr = minLimit;
    }
cgiMakeDoubleVarInRange(varName,initialVal,title,width,minStr,NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvttsd2si %xmm1, %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
jne 0x14862
xorl %r12d, %r12d
jmp 0x1488d
leaq 0x749f(%rip), %rdx      # 0x1bd08
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x14, %esi
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0xa0ca
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x146ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDoubleVarWithMax
void cgiMakeDoubleVarWithMax(char *varName, double initialVal, char *title, int width, double max)
{
char maxLimit[20];
char *maxStr=NULL;
if ((int)max != NO_VALUE)
    {
    safef(maxLimit,sizeof(maxLimit),"%g",max);
    maxStr = maxLimit;
    }
cgiMakeDoubleVarInRange(varName,initialVal,title,width,NULL,maxStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvttsd2si %xmm1, %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
jne 0x148cf
xorl %r12d, %r12d
jmp 0x148fa
leaq 0x7432(%rip), %rdx      # 0x1bd08
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x14, %esi
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0xa0ca
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x146ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDropListClassWithStyleAndJavascript
void cgiMakeDropListClassWithStyleAndJavascript(char *name, char *menu[],
        int menuSize, char *checked, char *class, char *style,char *javascript)
/* Make a drop-down list with names, text class, style and javascript. */
{
int i;
char *selString;
if (checked == NULL) checked = menu[0];
printf("<SELECT");
if (name)
    printf(" NAME='%s'", name);
if (class)
    printf(" class='%s'", class);
if (style)
    printf(" style='%s'", style);
if (javascript)
    printf(" %s", javascript);
printf(">\n");
for (i=0; i<menuSize; ++i)
    {
    if (sameWord(menu[i], checked))
        selString = " SELECTED";
    else
        selString = "";
    printf("<OPTION%s>%s</OPTION>\n", selString, menu[i]);
    }
printf("</SELECT>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbp
testq %rcx, %rcx
jne 0x1493b
movq (%r14), %rcx
movq %rcx, %rbx
movq 0x40(%rsp), %r12
leaq 0x73ef(%rip), %rdi      # 0x1bd39
xorl %eax, %eax
callq 0x3270
testq %rbp, %rbp
je 0x14967
leaq 0x7177(%rip), %rdi      # 0x1bad4
movq %rbp, %rsi
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x1497d
leaq 0x7187(%rip), %rdi      # 0x1bafa
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
testq %r15, %r15
je 0x14993
leaq 0x73b8(%rip), %rdi      # 0x1bd41
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
testq %r12, %r12
je 0x149a9
leaq 0x54bc(%rip), %rdi      # 0x19e5b
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6ef7(%rip), %rdi      # 0x1b8a7
callq 0x3100
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x14a05
movq %rbx, %r13
movl %eax, %r12d
leaq 0x5308(%rip), %rbp      # 0x19cd2
leaq 0x7386(%rip), %r15      # 0x1bd57
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
movq %r13, %rsi
callq 0x6e58
testl %eax, %eax
movq %rbp, %rsi
leaq 0x7362(%rip), %rax      # 0x1bd4d
cmoveq %rax, %rsi
movq (%r14,%rbx,8), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbx
cmpq %rbx, %r12
jne 0x149d3
leaq 0x79f9(%rip), %rdi      # 0x1c405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeMultList
void cgiMakeMultList(char *name, char *menu[], int menuSize, struct slName *checked, int length)
/* Make a list of names with window height equalt to length,
 * which can have multiple selections. Same as drop-down list
 * except "multiple" is added to select tag. */
{
int i;
char *selString;
if (checked == NULL) checked = slNameNew(menu[0]);
printf("<SELECT MULTIPLE SIZE=%d ALIGN=CENTER NAME=\"%s\">\n", length, name);
for (i=0; i<menuSize; ++i)
    {
    if (slNameInList(checked, menu[i]))
        selString = " SELECTED";
    else
        selString = "";
    printf("<OPTION%s>%s</OPTION>\n", selString, menu[i]);
    }
printf("</SELECT>\n");
char buf[512];
safef(buf, sizeof(buf), "%s%s", cgiMultListShadowPrefix(), name);
cgiMakeHiddenVar(buf, "1");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
jne 0x14a9c
movq (%r14), %rdi
callq 0x6cb2
movq %rax, %r15
leaq 0x72ec(%rip), %rdi      # 0x1bd8f
movl %r12d, %esi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
testl %ebp, %ebp
jle 0x14afe
movl %ebp, %r13d
leaq 0x728a(%rip), %rbx      # 0x1bd4d
leaq 0x728d(%rip), %r12      # 0x1bd57
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rsi
movq %r15, %rdi
callq 0x6e1f
testl %eax, %eax
movq %rbx, %rsi
leaq 0x51ee(%rip), %rax      # 0x19cd2
cmoveq %rax, %rsi
movq (%r14,%rbp,8), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
cmpq %rbp, %r13
jne 0x14acc
leaq 0x7900(%rip), %rdi      # 0x1c405
callq 0x3100
leaq 0x5696(%rip), %rdx      # 0x1a1a7
leaq 0x726c(%rip), %rcx      # 0x1bd84
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq 0x8(%rsp), %r8
xorl %eax, %eax
callq 0xa0ca
leaq 0x745d(%rip), %rdi      # 0x1bf95
leaq 0x6fc8(%rip), %rdx      # 0x1bb07
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6d57(%rip), %rdi      # 0x1b8a7
callq 0x3100
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeCheckboxGroupWithVals
void cgiMakeCheckboxGroupWithVals(char *name, char *menu[], char *values[], int menuSize,
				  struct slName *checked, int tableColumns)
/* Make a table of checkboxes that have the same variable name but different
 * values (same behavior as a multi-select input), with nice labels in menu[]. */
{
int i;
if (values == NULL) values = menu;
if (menu == NULL) menu = values;
puts("<TABLE BORDERWIDTH=0><TR>");
for (i = 0;  i < menuSize;  i++)
    {
    if (i > 0 && (i % tableColumns) == 0)
	printf("</TR><TR>");
    printf("<TD><INPUT TYPE=CHECKBOX NAME=\"%s\" VALUE=\"%s\" %s></TD>"
	   "<TD>%s</TD>\n",
	   name, values[i], (slNameInList(checked, values[i]) ? "CHECKED" : ""),
	   menu[i]);
    }
if ((i % tableColumns) != 0)
    while ((i++ % tableColumns) != 0)
	printf("<TD></TD>");
puts("</TR></TABLE>");
char buf[512];
safef(buf, sizeof(buf), "%s%s", cgiMultListShadowPrefix(), name);
cgiMakeHiddenVar(buf, "0");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movl %r9d, %ebx
movq %r8, 0x18(%rsp)
movl %ecx, %r14d
movq %rsi, %r12
testq %rdx, %rdx
movq %rdx, %r15
cmoveq %rsi, %r15
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
cmoveq %rdx, %r12
leaq 0x721e(%rip), %rdi      # 0x1bdc1
callq 0x3100
testl %r14d, %r14d
jle 0x14c23
movl %ebx, 0xc(%rsp)
movl %r14d, %ebp
xorl %r13d, %r13d
testq %r13, %r13
je 0x14bd6
movl %r13d, %eax
cltd
idivl 0xc(%rsp)
testl %edx, %edx
jne 0x14bd6
leaq 0x720c(%rip), %rdi      # 0x1bddb
xorl %eax, %eax
callq 0x3270
movq (%r15,%r13,8), %rbx
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x6e1f
testl %eax, %eax
leaq 0x6ef9(%rip), %rcx      # 0x1bae9
leaq 0x50db(%rip), %rax      # 0x19cd2
cmoveq %rax, %rcx
movq (%r12,%r13,8), %r8
leaq 0x71df(%rip), %rdi      # 0x1bde5
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
incq %r13
cmpq %r13, %rbp
jne 0x14bb7
movl 0xc(%rsp), %ebx
jmp 0x14c26
xorl %r14d, %r14d
movl %r14d, %eax
cltd
idivl %ebx
testl %edx, %edx
je 0x14c51
incl %r14d
leaq 0x71ee(%rip), %r15      # 0x1be28
movq %r15, %rdi
xorl %eax, %eax
callq 0x3270
movl %r14d, %eax
cltd
idivl %ebx
incl %r14d
testl %edx, %edx
jne 0x14c3a
leaq 0x71da(%rip), %rdi      # 0x1be32
callq 0x3100
leaq 0x5543(%rip), %rdx      # 0x1a1a7
leaq 0x7119(%rip), %rcx      # 0x1bd84
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
movq 0x10(%rsp), %r8
xorl %eax, %eax
callq 0xa0ca
leaq 0x730a(%rip), %rdi      # 0x1bf95
leaq 0x65e0(%rip), %rdx      # 0x1b272
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c04(%rip), %rdi      # 0x1b8a7
callq 0x3100
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDropListFull
void cgiMakeDropListFull(char *name, char *menu[], char *values[],
                         int menuSize, char *checked, char *extraAttribs)
/* Make a drop-down list with names and values. */
{
int i;
char *selString;
if (checked == NULL) checked = menu[0];

if (NULL != extraAttribs)
    {
    printf("<SELECT NAME=\"%s\" %s>\n", name, extraAttribs);
    }
else
    {
    printf("<SELECT NAME=\"%s\">\n", name);
    }

for (i=0; i<menuSize; ++i)
    {
    if (sameWord(values[i], checked))
        selString = " SELECTED";
    else
        selString = "";
    printf("<OPTION%s VALUE=\"%s\">%s</OPTION>\n", selString, values[i], menu[i]);
    }
printf("</SELECT>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
testq %r8, %r8
jne 0x14cea
movq (%r15), %rbx
testq %r9, %r9
je 0x14d02
leaq 0x714a(%rip), %rdi      # 0x1be40
movq %r9, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x14d10
leaq 0x714e(%rip), %rdi      # 0x1be57
xorl %eax, %eax
callq 0x3270
testl %ebp, %ebp
jle 0x14d5a
movl %ebp, %r13d
leaq 0x714d(%rip), %r12      # 0x1be6b
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x6e58
testl %eax, %eax
leaq 0x4f9d(%rip), %rsi      # 0x19cd2
leaq 0x7011(%rip), %rax      # 0x1bd4d
cmoveq %rax, %rsi
movq (%r14,%rbp,8), %rdx
movq (%r15,%rbp,8), %rcx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
cmpq %rbp, %r13
jne 0x14d20
leaq 0x76a4(%rip), %rdi      # 0x1c405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeDropListWithVals
void cgiMakeDropListWithVals(char *name, char *menu[], char *values[],
                         int menuSize, char *checked)
/* Make a drop-down list with names and values. In this case checked
 * corresponds to a value, not a menu. */
{
int i;
char *selString;
if (checked == NULL) checked = values[0];

printf("<SELECT NAME=\"%s\">\n", name);
for (i=0; i<menuSize; ++i)
    {
    if (sameWord(values[i], checked))
        selString = " SELECTED";
    else
        selString = "";
    printf("<OPTION%s VALUE=\"%s\">%s</OPTION>\n", selString, values[i], menu[i]);
    }
printf("</SELECT>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
testq %r8, %r8
jne 0x14ff8
movq (%r14), %rbx
leaq 0x6e58(%rip), %rdi      # 0x1be57
xorl %eax, %eax
callq 0x3270
testl %ebp, %ebp
jle 0x15050
movl %ebp, %r13d
leaq 0x6e57(%rip), %r12      # 0x1be6b
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x6e58
testl %eax, %eax
leaq 0x4ca7(%rip), %rsi      # 0x19cd2
leaq 0x6d1b(%rip), %rax      # 0x1bd4d
cmoveq %rax, %rsi
movq (%r14,%rbp,8), %rdx
movq (%r15,%rbp,8), %rcx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
cmpq %rbp, %r13
jne 0x15016
leaq 0x73ae(%rip), %rdi      # 0x1c405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiDropDownWithTextValsAndExtra
void cgiDropDownWithTextValsAndExtra(char *name, char *text[], char *values[],
                                     int count, char *selected, char *extra)
/* Make a drop-down list with both text and values. */
{
int i;
char *selString;
assert(values != NULL && text != NULL);
if (selected == NULL)
    selected = values[0];
printf("<SELECT");
if (name)
    printf(" NAME='%s'", name);
if (extra)
    printf("%s", extra);
printf(">\n");
for (i=0; i<count; ++i)
    {
    if (sameWord(values[i], selected))
        selString = " SELECTED";
    else
        selString = "";
    printf("<OPTION%s value='%s'>%s</OPTION>\n", selString, values[i], text[i]);
    }
printf("</SELECT>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1514a
movq %rdx, %r14
testq %rdx, %rdx
je 0x1514a
movq %r9, %r12
movl %ecx, %ebx
movq %rdi, %r13
movq %rsi, %r15
testq %r8, %r8
jne 0x1509d
movq (%r14), %r8
movq %r8, %rbp
leaq 0x6c92(%rip), %rdi      # 0x1bd39
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x150c4
leaq 0x6a1a(%rip), %rdi      # 0x1bad4
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
testq %r12, %r12
je 0x150da
leaq 0x44ec(%rip), %rdi      # 0x195bc
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x67c6(%rip), %rdi      # 0x1b8a7
callq 0x3100
testl %ebx, %ebx
jle 0x15130
movl %ebx, %r13d
leaq 0x6e7f(%rip), %r12      # 0x1bf73
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
movq %rbp, %rsi
callq 0x6e58
testl %eax, %eax
leaq 0x4bc7(%rip), %rsi      # 0x19cd2
leaq 0x6c3b(%rip), %rax      # 0x1bd4d
cmoveq %rax, %rsi
movq (%r14,%rbx,8), %rdx
movq (%r15,%rbx,8), %rcx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbx
cmpq %rbx, %r13
jne 0x150f6
leaq 0x72ce(%rip), %rdi      # 0x1c405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
leaq 0x6da4(%rip), %rdi      # 0x1bef5
leaq 0x6dbc(%rip), %rsi      # 0x1bf14
leaq 0x6dc0(%rip), %rcx      # 0x1bf1f
movl $0x735, %edx            # imm = 0x735
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiVarExcludeExcept
void cgiVarExcludeExcept(char **varNames)
/* Exclude all variables except for those in NULL
 * terminated array varNames.  varNames may be NULL
 * in which case nothing is excluded. */
{
struct hashEl *list, *el;
struct hash *exclude = newHash(8);
char *s;

/* Build up hash of things to exclude */
if (varNames != NULL)
   {
   while ((s = *varNames++) != NULL)
       hashAdd(exclude, s, NULL);
   }

/* Step through variable list and remove them if not
 * excluded. */
initCgiInput();
list = hashElListHash(inputHash);
for (el = list; el != NULL; el = el->next)
    {
    if (!hashLookup(exclude, el->name))
        cgiVarExclude(el->name);
    }
hashElFreeList(&list);
freeHash(&exclude);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x8, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x15237
movq (%r14), %rsi
testq %rsi, %rsi
je 0x15237
addq $0x8, %r14
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbe46
movq (%r14), %rsi
addq $0x8, %r14
testq %rsi, %rsi
jne 0x15221
callq 0x1587c
movq 0x13095(%rip), %rdi     # 0x282d8
callq 0xc3e8
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x15277
movq %rax, %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xbb8c
testq %rax, %rax
jne 0x1526f
movq 0x8(%r14), %rdi
callq 0x151b1
movq (%r14), %r14
testq %r14, %r14
jne 0x15255
leaq 0x10(%rsp), %rdi
callq 0xc449
leaq 0x8(%rsp), %rdi
callq 0xc51f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiVarSet
void cgiVarSet(char *varName, char *val)
/* Set a cgi variable to a particular value. */
{
struct cgiVar *var;
initCgiInput();
AllocVar(var);
var->val = cloneString(val);
hashAddSaveName(inputHash, varName, var, &var->name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1587c
movl $0x20, %edi
callq 0xee10
movq %rax, %r15
movq %rbx, %rdi
callq 0x6402
movq %rax, 0x10(%r15)
movq 0x13015(%rip), %rdi     # 0x282d8
leaq 0x8(%r15), %rcx
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xbf9e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %edi, %edi
callq 0xad14
movq %rax, %rbx
movq 0x12fdb(%rip), %r13     # 0x282d0
testq %r13, %r13
je 0x1535e
leaq 0x4131(%rip), %r14      # 0x19432
leaq 0x8(%rsp), %r15
leaq 0x6cb0(%rip), %r12      # 0x1bfbd
cmpq 0x12fbc(%rip), %r13     # 0x282d0
je 0x15321
movq %rbx, %rdi
movq %r12, %rsi
callq 0xaf83
movq 0x10(%r13), %rdi
callq 0x137af
movq %rax, 0x8(%rsp)
movq 0x8(%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xb0b7
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xaf83
movq %r15, %rdi
callq 0xeecc
movq (%r13), %r13
testq %r13, %r13
jne 0x1530d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x14(%rdx)
je 0x15394
movq %rbx, %rdi
movl $0x26, %esi
callq 0xaeab
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaf83
movq %rbx, %rdi
movl $0x3d, %esi
callq 0xaeab
movq %r14, %rdi
callq 0x137af
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaf83
movq %r14, %rdi
callq 0xeecc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x1, %r12d
movl $0x1, %esi
callq 0xcef9
movq %rax, %r15
movq %rax, 0x20(%rsp)
movl $0x50, %edi
callq 0xec7f
movq %rax, %rbx
movq %rax, 0x10(%rsp)
movl $0x1, 0x1c(%rsp)
movq %r14, %rdi
callq 0x6402
movq %rax, (%rbx)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
je 0x156ee
movl $0xa, %ebp
movl $0x1, %r12d
leaq 0x8(%rsp), %r14
movq %r12, %r13
movq 0x8(%rsp), %rdi
movzbl (%rdi), %eax
cmpl $0x23, %eax
je 0x15689
testl %eax, %eax
jne 0x1569c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
jne 0x15678
jmp 0x156eb
leaq 0x1(%r13), %r12
cmpl %r12d, %ebp
jg 0x156ca
movslq %ebp, %rsi
shlq $0x3, %rsi
addl %ebp, %ebp
movslq %ebp, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
callq 0xee7e
movq %rax, %rbx
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x6402
movq %rax, (%rbx,%r13,8)
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd043
testl %eax, %eax
jne 0x15675
jmp 0x156ee
movl %r13d, %r12d
leaq 0x1c(%rsp), %r14
movl %r12d, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x15420
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0xd560
movslq (%r14), %r15
testq %r15, %r15
jle 0x15730
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xeecc
addq $0x8, %r14
decq %r15
jne 0x1571f
leaq 0x10(%rsp), %rdi
callq 0xeecc
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x12a9d(%rip), %rdi     # 0x281f0
callq 0xeecc
movq $0x0, 0x12a8d(%rip) # 0x281f0
cmpq $0x0, 0x12b6d(%rip)     # 0x282d8
je 0x15779
leaq 0x12b64(%rip), %rdi     # 0x282d8
callq 0xc51f
xorl %eax, %eax
movq %rax, 0x12b56(%rip)     # 0x282d8
movq %rax, 0x12b47(%rip)     # 0x282d0
movb $0x0, 0x22d50(%rip)     # 0x384e0
cmpq %rax, 0x12a61(%rip)     # 0x281f8
je 0x157a5
leaq 0x12a58(%rip), %rdi     # 0x281f8
callq 0xc51f
xorl %eax, %eax
movq %rax, 0x12a4a(%rip)     # 0x281f8
movq %rax, 0x12a1b(%rip)     # 0x281d0
popq %rax
retq