LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x73ea(%rip), %rdi      # 0x19ac0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x126f6
leaq 0x73f3(%rip), %rdi      # 0x19adf
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
testl %ebp, %ebp
je 0x12708
leaq 0x73e7(%rip), %rdi      # 0x19ae8
xorl %eax, %eax
callq 0x3270
testl %ebx, %ebx
jne 0x12731
leaq 0x73de(%rip), %rdi      # 0x19af1
pushq $0x20
popq %rsi
movq %r12, %rdx
callq 0x7771
testq %rax, %rax
jne 0x12731
leaq 0x72bd(%rip), %rdi      # 0x199e7
xorl %eax, %eax
callq 0x3270
testq %r12, %r12
je 0x12747
leaq 0x73bd(%rip), %rdi      # 0x19afa
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
testq %r15, %r15
je 0x1275d
leaq 0x5708(%rip), %rdi      # 0x17e5b
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
pushq $0x3e
popq %rdi
callq 0x3080
leaq 0x5a3b(%rip), %rdx      # 0x181a7
leaq 0x7338(%rip), %rcx      # 0x19aab
movq %rsp, %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %r8
xorl %eax, %eax
callq 0x939d
testl %ebp, %ebp
leaq 0x7378(%rip), %rax      # 0x19b09
leaq 0x736e(%rip), %rcx      # 0x19b06
cmoveq %rax, %rcx
testl %ebx, %ebx
leaq 0x6acd(%rip), %rsi      # 0x19272
cmoveq %rcx, %rsi
leaq 0x735c(%rip), %rdx      # 0x19b0c
movq %r15, %rdi
callq 0x127ca
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x77ba(%rip), %rdi      # 0x19f95
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x127f9
leaq 0x7663(%rip), %rdi      # 0x19e51
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x3270
leaq 0x70a7(%rip), %rdi      # 0x198a7
popq %rbx
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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 0x5413(%rip), %r14      # 0x17cd2
cmovneq %rsi, %r14
testl %edx, %edx
jne 0x128d2
movq %r14, %rdi
callq 0x3200
movq %rax, %rdx
testl %edx, %edx
pushq $0x8
popq %rax
cmovnel %edx, %eax
leaq 0x7275(%rip), %rdi      # 0x19b56
movq %r15, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x1290b
cmpb $0x0, (%rbx)
je 0x1290b
leaq 0x7283(%rip), %rdi      # 0x19b84
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6f95(%rip), %rdi      # 0x198a7
popq %rbx
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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 0x539a(%rip), %r14      # 0x17cd2
cmovneq %rsi, %r14
testl %edx, %edx
jne 0x1294b
movq %r14, %rdi
callq 0x3200
imull $0xa, %eax, %edx
testl %edx, %edx
pushq $0x64
popq %rax
cmovnel %edx, %eax
leaq 0x723b(%rip), %rdi      # 0x19b95
movq %r15, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x12984
cmpb $0x0, (%rbx)
je 0x12984
leaq 0x54e1(%rip), %rdi      # 0x17e5b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6f1c(%rip), %rdi      # 0x198a7
popq %rbx
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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 0x129da
testq %r14, %r14
je 0x12a49
movq %r14, %rdi
callq 0x3200
imull $0xa, %eax, %ecx
cmpl $0x42, %ecx
pushq $0x41
popq %rdx
cmovgel %ecx, %edx
leaq 0x7223(%rip), %rdi      # 0x19c0d
movq %r12, %rsi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3270
testq %r15, %r15
leaq 0x7282(%rip), %rax      # 0x19c82
cmoveq %rax, %r15
testq %r14, %r14
cmoveq %rax, %r14
leaq 0x7244(%rip), %rdi      # 0x19c56
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x12a35
leaq 0x725e(%rip), %rdi      # 0x19c89
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6e6b(%rip), %rdi      # 0x198a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movl %ebp, %eax
testq %r15, %r15
je 0x12a58
movq %r15, %rdi
callq 0x36a0
addl $0x3e8, %eax            # imm = 0x3E8
pushq $0xa
popq %rsi
movl %esi, %ecx
leal 0x9(%rax), %edx
cmpl $0x13, %edx
jb 0x129da
cltd
idivl %esi
addl $0xa, %ecx
jmp 0x12a62
// File: /workspace/github_c_makefile_star2_O2/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 0x12aa1
xorl %r12d, %r12d
jmp 0x12abd
leaq 0x6a85(%rip), %rdx      # 0x1952d
leaq 0x30(%rsp), %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movl %r8d, %ecx
xorl %eax, %eax
callq 0x939d
cmpl $0xfffe8663, %r13d      # imm = 0xFFFE8663
jne 0x12aca
xorl %ebx, %ebx
jmp 0x12ae6
leaq 0x6a5c(%rip), %rdx      # 0x1952d
leaq 0x10(%rsp), %rbx
pushq $0x14
popq %rsi
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x939d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl 0xc(%rsp), %ecx
movq %r12, %r8
movq %rbx, %r9
callq 0x129b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12b30
xorl %r12d, %r12d
jmp 0x12b4a
leaq 0x69f6(%rip), %rdx      # 0x1952d
movq %rsp, %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movl %r8d, %ecx
xorl %eax, %eax
callq 0x939d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x129b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12b90
xorl %r12d, %r12d
jmp 0x12baa
leaq 0x6996(%rip), %rdx      # 0x1952d
movq %rsp, %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movl %r8d, %ecx
xorl %eax, %eax
callq 0x939d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x129b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12c20
movq %r15, %rdi
movsd %xmm0, (%rsp)
callq 0x3200
movsd (%rsp), %xmm0
imull $0xa, %eax, %edx
cmpl $0x42, %edx
pushq $0x41
popq %rax
cmovgel %edx, %eax
leaq 0x7092(%rip), %rdi      # 0x19cc2
movq %r12, %rsi
movl %eax, %edx
movb $0x1, %al
callq 0x3270
testq %r14, %r14
leaq 0x703c(%rip), %rdx      # 0x19c82
cmoveq %rdx, %r14
testq %r15, %r15
cmovneq %r15, %rdx
leaq 0x70b3(%rip), %rdi      # 0x19d0b
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
testq %rbx, %rbx
je 0x12c78
leaq 0x701b(%rip), %rdi      # 0x19c89
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c28(%rip), %rdi      # 0x198a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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 0x12cba
xorl %r12d, %r12d
jmp 0x12ce1
leaq 0x7047(%rip), %rdx      # 0x19d08
leaq 0x30(%rsp), %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movapd %xmm1, %xmm0
movb $0x1, %al
movsd %xmm2, (%rsp)
callq 0x939d
movsd (%rsp), %xmm2
cvttsd2si %xmm2, %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
jne 0x12cf1
xorl %r13d, %r13d
jmp 0x12d0e
leaq 0x7010(%rip), %rdx      # 0x19d08
leaq 0x10(%rsp), %r13
pushq $0x14
popq %rsi
movq %r13, %rdi
movapd %xmm2, %xmm0
movb $0x1, %al
callq 0x939d
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
movq %r13, %r8
callq 0x12be8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12d58
xorl %r12d, %r12d
jmp 0x12d81
leaq 0x6fa9(%rip), %rdx      # 0x19d08
leaq 0x10(%rsp), %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x939d
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x12be8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12dc3
xorl %r12d, %r12d
jmp 0x12dec
leaq 0x6f3e(%rip), %rdx      # 0x19d08
leaq 0x10(%rsp), %r12
pushq $0x14
popq %rsi
movq %r12, %rdi
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x939d
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x12be8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %r8, %rbp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, (%rsp)
testq %rcx, %rcx
jne 0x12e33
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %r13
leaq 0x6efa(%rip), %rdi      # 0x19d39
xorl %eax, %eax
callq 0x3270
testq %r12, %r12
je 0x12e5c
leaq 0x6c82(%rip), %rdi      # 0x19ad4
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
testq %rbp, %rbp
je 0x12e72
leaq 0x6c92(%rip), %rdi      # 0x19afa
movq %rbp, %rsi
xorl %eax, %eax
callq 0x3270
testq %r14, %r14
je 0x12e88
leaq 0x6ec3(%rip), %rdi      # 0x19d41
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x12e9e
leaq 0x4fc7(%rip), %rdi      # 0x17e5b
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6a02(%rip), %rdi      # 0x198a7
callq 0x3100
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x6e95(%rip), %r13      # 0x19d4d
leaq 0x4e13(%rip), %rbp      # 0x17cd2
leaq 0x6e91(%rip), %r12      # 0x19d57
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x12ef7
movq (%r15,%r14,8), %rdi
movq (%rsp), %rsi
callq 0x682f
testl %eax, %eax
movq %rbp, %rsi
cmoveq %r13, %rsi
movq (%r15,%r14,8), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3270
incq %r14
jmp 0x12ec9
leaq 0x7507(%rip), %rdi      # 0x1a405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movq %rcx, %r12
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r13
testq %rcx, %rcx
jne 0x12f70
movq (%r15), %rdi
callq 0x6692
movq %rax, %r12
leaq 0x6e18(%rip), %rdi      # 0x19d8f
xorl %ebx, %ebx
movl %ebp, %esi
movq %r13, 0x8(%rsp)
movq %r13, %rdx
xorl %eax, %eax
callq 0x3270
testl %r14d, %r14d
cmovlel %ebx, %r14d
leaq 0x6db5(%rip), %rbx      # 0x19d4d
leaq 0x6db8(%rip), %r13      # 0x19d57
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x12fd5
movq (%r15,%rbp,8), %rsi
movq %r12, %rdi
callq 0x67fd
testl %eax, %eax
movq %rbx, %rsi
leaq 0x4d14(%rip), %rax      # 0x17cd2
cmoveq %rax, %rsi
movq (%r15,%rbp,8), %rdx
movq %r13, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
jmp 0x12fa1
leaq 0x7429(%rip), %rdi      # 0x1a405
callq 0x3100
leaq 0x51bf(%rip), %rdx      # 0x181a7
leaq 0x6d95(%rip), %rcx      # 0x19d84
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq 0x8(%rsp), %r8
xorl %eax, %eax
callq 0x939d
leaq 0x6af8(%rip), %rsi      # 0x19b07
movq %r14, %rdi
xorl %edx, %edx
callq 0x127ca
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x218, %rsp            # imm = 0x218
movl %r9d, 0x4(%rsp)
movq %r8, %r15
movl %ecx, %r14d
movq %rsi, %r12
testq %rdx, %rdx
movq %rdx, %rbp
cmoveq %rsi, %rbp
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
cmoveq %rdx, %r12
leaq 0x6d5a(%rip), %rdi      # 0x19dc1
callq 0x3100
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x130df
testq %r13, %r13
je 0x1309c
movl %r13d, %eax
cltd
idivl 0x4(%rsp)
testl %edx, %edx
jne 0x1309c
leaq 0x6d46(%rip), %rdi      # 0x19ddb
xorl %eax, %eax
callq 0x3270
movq (%rbp,%r13,8), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x67fd
testl %eax, %eax
leaq 0x6a34(%rip), %rcx      # 0x19ae9
leaq 0x4c16(%rip), %rax      # 0x17cd2
cmoveq %rax, %rcx
movq (%r12,%r13,8), %r8
leaq 0x6d1a(%rip), %rdi      # 0x19de5
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
incq %r13
jmp 0x13078
movl %r14d, %eax
cltd
movl 0x4(%rsp), %ebx
idivl %ebx
testl %edx, %edx
je 0x1310d
leaq 0x6d34(%rip), %r15      # 0x19e28
movl %r14d, %eax
cltd
idivl %ebx
testl %edx, %edx
je 0x1310d
incl %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x3270
jmp 0x130f4
leaq 0x6d1e(%rip), %rdi      # 0x19e32
callq 0x3100
leaq 0x5087(%rip), %rdx      # 0x181a7
leaq 0x6c5d(%rip), %rcx      # 0x19d84
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
movq 0x8(%rsp), %r8
xorl %eax, %eax
callq 0x939d
leaq 0x612b(%rip), %rsi      # 0x19272
movq %rbx, %rdi
xorl %edx, %edx
callq 0x127ca
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
testq %r8, %r8
jne 0x13194
movq (%r12), %r14
testq %r9, %r9
je 0x131ac
leaq 0x6ca0(%rip), %rdi      # 0x19e40
movq %r9, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x131ba
leaq 0x6ca4(%rip), %rdi      # 0x19e57
xorl %eax, %eax
callq 0x3270
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x6ca3(%rip), %r13      # 0x19e6b
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x13206
movq (%r15,%rbp,8), %rdi
movq %r14, %rsi
callq 0x682f
testl %eax, %eax
leaq 0x4aee(%rip), %rsi      # 0x17cd2
leaq 0x6b62(%rip), %rax      # 0x19d4d
cmoveq %rax, %rsi
movq (%r15,%rbp,8), %rdx
movq (%r12,%rbp,8), %rcx
movq %r13, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
jmp 0x131ca
leaq 0x71f8(%rip), %rdi      # 0x1a405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
testq %r8, %r8
jne 0x1347a
movq (%r15), %r14
leaq 0x69d6(%rip), %rdi      # 0x19e57
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x3270
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x69d3(%rip), %r13      # 0x19e6b
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x134d6
movq (%r15,%rbp,8), %rdi
movq %r14, %rsi
callq 0x682f
testl %eax, %eax
leaq 0x481e(%rip), %rsi      # 0x17cd2
leaq 0x6892(%rip), %rax      # 0x19d4d
cmoveq %rax, %rsi
movq (%r15,%rbp,8), %rdx
movq (%r12,%rbp,8), %rcx
movq %r13, %rdi
xorl %eax, %eax
callq 0x3270
incq %rbp
jmp 0x1349a
leaq 0x6f28(%rip), %rdi      # 0x1a405
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x135ec
movq %rdx, %r15
testq %rdx, %rdx
je 0x135ec
movq %r9, %r13
movl %ecx, %ebx
movq %rdi, %rbp
cmpq $0x0, 0x8(%rsp)
jne 0x13535
movq (%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x67fd(%rip), %rdi      # 0x19d39
xorl %eax, %eax
callq 0x3270
testq %rbp, %rbp
je 0x13559
leaq 0x6585(%rip), %rdi      # 0x19ad4
movq %rbp, %rsi
xorl %eax, %eax
callq 0x3270
testq %r13, %r13
je 0x1356f
leaq 0x4057(%rip), %rdi      # 0x175bc
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6331(%rip), %rdi      # 0x198a7
callq 0x3100
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x67c4(%rip), %rbp      # 0x19d4d
leaq 0x4742(%rip), %r14      # 0x17cd2
leaq 0x69dc(%rip), %r13      # 0x19f73
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x135d2
movq (%r15,%r12,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x682f
testl %eax, %eax
movq %r14, %rsi
cmoveq %rbp, %rsi
movq (%r15,%r12,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rcx
movq %r13, %rdi
xorl %eax, %eax
callq 0x3270
incq %r12
jmp 0x1359a
leaq 0x6e2c(%rip), %rdi      # 0x1a405
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3100
leaq 0x6902(%rip), %rdi      # 0x19ef5
leaq 0x691a(%rip), %rsi      # 0x19f14
leaq 0x691e(%rip), %rcx      # 0x19f1f
movl $0x735, %edx            # imm = 0x735
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rdi
pushq $0x1
popq %rsi
callq 0xb010
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x13698
movq (%r14), %rsi
testq %rsi, %rsi
je 0x13698
addq $0x8, %r14
movq %rbx, %rdi
xorl %edx, %edx
callq 0xad17
jmp 0x13680
callq 0x13d67
movq 0x13c54(%rip), %rdi     # 0x272f8
callq 0xb1d8
movq %rax, %r14
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x136d5
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xaaa4
testq %rax, %rax
jne 0x136d0
movq 0x8(%r14), %rdi
callq 0x13630
movq (%r14), %r14
jmp 0x136b1
leaq 0x10(%rsp), %rdi
callq 0xb236
leaq 0x8(%rsp), %rdi
callq 0xb306
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13d67
pushq $0x20
popq %rdi
callq 0xd87c
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ede
movq %rax, 0x10(%r15)
movq 0x13bd9(%rip), %rdi     # 0x272f8
leaq 0x8(%r15), %rcx
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xae3b
// File: /workspace/github_c_makefile_star2_O2/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 0x9df0
movq %rax, %rbx
leaq 0x13b9f(%rip), %r13     # 0x272f0
leaq 0x3cda(%rip), %r14      # 0x17432
leaq 0x8(%rsp), %r15
leaq 0x6859(%rip), %r12      # 0x19fbd
movq (%r13), %r13
testq %r13, %r13
je 0x137b7
cmpq 0x13b7c(%rip), %r13     # 0x272f0
je 0x13781
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9ffe
movq 0x10(%r13), %rdi
callq 0x11e24
movq %rax, 0x8(%rsp)
movq 0x8(%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa0eb
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9ffe
movq %r15, %rdi
callq 0xd909
jmp 0x13764
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x137eb
pushq $0x26
popq %rsi
movq %rbx, %rdi
callq 0x9f5e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9ffe
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x9f5e
movq %r14, %rdi
callq 0x11e24
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9ffe
movq %r14, %rdi
callq 0xd909
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
pushq $0x1
popq %rsi
callq 0xbbad
movq %rax, %rbx
movq %rax, 0x20(%rsp)
pushq $0x50
popq %rdi
callq 0xd6eb
movq %rax, %r14
movq %rax, 0x8(%rsp)
movl $0x1, 0x14(%rsp)
movq %r15, %rdi
callq 0x5ede
movq %rax, (%r14)
pushq $0xa
popq %rbp
pushq $0x1
popq %r12
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbcea
testl %eax, %eax
je 0x13aef
movq 0x18(%rsp), %rdi
movzbl (%rdi), %eax
testl %eax, %eax
je 0x13a90
cmpl $0x23, %eax
je 0x13a90
leaq 0x1(%r12), %r13
cmpl %r13d, %ebp
jg 0x13ae1
movslq %ebp, %rsi
shlq $0x3, %rsi
addl %ebp, %ebp
movslq %ebp, %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xd8ea
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5ede
movq %rax, (%r14,%r12,8)
movq %r13, %r12
jmp 0x13a90
leaq 0x14(%rsp), %r15
movl %r12d, (%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x13a38
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0xc178
movl (%r15), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
shlq $0x3, %r14
cmpq %r15, %r14
je 0x13b37
movq 0x8(%rsp), %rdi
addq %r15, %rdi
callq 0xd909
addq $0x8, %r15
jmp 0x13b1f
leaq 0x8(%rsp), %rdi
callq 0xd909
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x5bb3(%rip), %rdi      # 0x1971a
callq 0x3040
movq %rax, %rbx
leaq 0x6484(%rip), %rdi      # 0x19ffa
callq 0x3040
movq %rax, %r13
leaq 0x5b49(%rip), %rdi      # 0x196ce
callq 0x3040
movq %rax, %r15
leaq 0x6476(%rip), %rdi      # 0x1a00a
callq 0x1203b
movq %rax, %r14
xorl %edi, %edi
callq 0x34d0
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x30a0
movq %rax, %rdi
callq 0x3220
movq %rax, %r12
movq %rax, %rdi
callq 0x3200
movq %rax, %rbp
testq %r13, %r13
jne 0x13bd4
leaq 0x643e(%rip), %rcx      # 0x1a010
jmp 0x13bdf
movq %r13, %rdi
callq 0x34c0
movq %rax, %rcx
cmpq $0x4, %rbp
jb 0x13beb
movb $0x0, -0x2(%r12,%rbp)
testq %rbx, %rbx
leaq 0x527b(%rip), %rax      # 0x18e70
cmoveq %rax, %rbx
testq %r14, %r14
cmoveq %rax, %r14
testq %r15, %r15
cmoveq %rax, %r15
movq 0x123ea(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq %r15, (%rsp)
leaq 0x63fc(%rip), %rsi      # 0x1a018
movq %r12, %rdx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x3470
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x135cd(%rip), %rdi     # 0x27210
callq 0xd909
andq $0x0, 0x135c0(%rip)     # 0x27210
cmpq $0x0, 0x136a0(%rip)     # 0x272f8
je 0x13c66
leaq 0x13697(%rip), %rdi     # 0x272f8
callq 0xb306
andq $0x0, 0x1368a(%rip)     # 0x272f8
andq $0x0, 0x1367a(%rip)     # 0x272f0
movb $0x0, 0x23883(%rip)     # 0x37500
xorl %eax, %eax
cmpq %rax, 0x13592(%rip)     # 0x27218
je 0x13c94
leaq 0x13589(%rip), %rdi     # 0x27218
callq 0xb306
andq $0x0, 0x1357c(%rip)     # 0x27218
andq $0x0, 0x1354c(%rip)     # 0x271f0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0xd87c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5ede
movq %rax, 0x8(%r14)
leaq 0x18(%r14), %rsi
leaq 0x10(%r14), %rdx
movq %rax, %rdi
callq 0x11a69
movq 0x18(%r14), %rdi
leaq 0x10(%rip), %rsi        # 0x13d09
callq 0xb0ef
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x13d4f
movq %rdi, %rbx
leaq 0x10(%r14), %rdi
callq 0x615b
leaq 0x18(%r14), %rdi
callq 0xb306
movq 0x8(%r14), %rdi
callq 0xd8f9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd909
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x5d7c(%rip), %rdi      # 0x1a178
callq 0x3040
movq %rax, %rbx
movq %rax, 0x12e05(%rip)     # 0x27210
testq %rax, %rax
jne 0x14429
leaq 0x38bb(%rip), %rbx      # 0x17cd2
testl %ebp, %ebp
je 0x14429
leaq 0x5dba(%rip), %rdi      # 0x1a1dc
xorl %eax, %eax
callq 0xa61f
movq %rbx, %rdi
callq 0x5ede
movq %rax, 0x12dd8(%rip)     # 0x27210
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
xorl %esi, %esi
callq 0x149e7
movq %rax, 0x230bd(%rip)     # 0x37510
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
callq 0x1448c
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x615b
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x1454a
movq 0x23018(%rip), %rax     # 0x37510
movl 0x8(%rax), %ecx
cmpl $0x10, %ecx
movsd %xmm0, (%rsp)
je 0x14524
cmpl $0x11, %ecx
jne 0x14548
movq (%rax), %rax
movq %rax, 0x22ffc(%rip)     # 0x37510
callq 0x1454a
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
jmp 0x1453c
movq (%rax), %rax
movq %rax, 0x22fe2(%rip)     # 0x37510
callq 0x1454a
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
jmp 0x144f1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x22f98(%rip), %rbx     # 0x37510
cmpl $0xc, 0x8(%rbx)
jne 0x1459f
movq (%rbx), %rax
movq %rax, 0x22f88(%rip)     # 0x37510
callq 0x1448c
movq 0x22f7c(%rip), %rax     # 0x37510
cmpl $0xd, 0x8(%rax)
jne 0x145e4
movq (%rax), %rax
jmp 0x145db
callq 0x37a0
movq (%rax), %rax
movsbq 0xd(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x145cf
addq $0xd, %rbx
leaq 0x5e78(%rip), %rdi      # 0x1a436
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa61f
movq 0x22f41(%rip), %rbx     # 0x37510
leaq 0xd(%rbx), %rdi
callq 0x3180
movq (%rbx), %rax
movq %rax, 0x22f2e(%rip)     # 0x37510
jmp 0x145f5
leaq 0x5e35(%rip), %rdi      # 0x1a420
xorl %eax, %eax
callq 0xa61f
xorps %xmm0, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r14
movl %edi, %ebp
movslq %edx, %r15
leal 0x10(%r15), %eax
movslq %eax, %rdi
callq 0xd87c
movq %rax, %r12
movl %ebp, 0x8(%rax)
movb %bl, 0xc(%rax)
leaq 0xd(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x34a0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x8040, %edi           # imm = 0x8040
callq 0xd87c
movq %rax, %r14
movl %ebx, (%rax)
andq $0x0, 0x8018(%rax)
andl $0x0, 0x8020(%rax)
addq $0x8004, %rax           # imm = 0x8004
movq %rax, 0x8038(%r14)
movq %rax, 0x8030(%r14)
movq %rax, 0x8028(%r14)
movq %rax, 0x8008(%r14)
movq %r14, %rdi
callq 0x14a51
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x8020(%rdi)
jl 0x14a8c
movl 0x8030(%rbx), %eax
movq 0x8008(%rbx), %rsi
subl %esi, %eax
leaq 0x4(%rbx), %rdi
movslq %eax, %r14
movq %r14, %rdx
callq 0x35d0
leaq (%rbx,%r14), %rsi
addq $0x4, %rsi
jmp 0x14a90
leaq 0x4(%rbx), %rsi
movq %rsi, 0x8030(%rbx)
leaq 0x4(%rbx), %rax
movq %rax, 0x8008(%rbx)
movl 0x8038(%rbx), %ebp
subl %esi, %ebp
leaq 0x5cc2(%rip), %r14      # 0x1a773
testl %ebp, %ebp
jle 0x14ae9
movl (%rbx), %edi
movl %ebp, %edx
callq 0x33d0
movq %rax, %r15
testl %r15d, %r15d
jns 0x14ad0
movq %r14, %rdi
xorl %eax, %eax
callq 0xa721
movslq %r15d, %rsi
addq 0x8030(%rbx), %rsi
movq %rsi, 0x8030(%rbx)
subl %r15d, %ebp
testl %r15d, %r15d
jne 0x14ab1
movq %rbx, %rdi
callq 0x15662
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x156f0