LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c810
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c8a9
movq -0x8(%rbp), %rdi
callq 0x1c2a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiUsualString
char *cgiUsualString(char *varName, char *usual)
/* Return value of string if it exists in cgi environment.
 * Otherwise return 'usual' */
{
char *pt;
pt = findVarData(varName);
if (pt == NULL)
    pt = usual;
return pt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c810
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1c8ec
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x1f650
movq 0x169e8(%rip), %rdi     # 0x33308
movq -0x8(%rbp), %rsi
callq 0x104b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c983
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3410
cmpl $0x0, %eax
jne 0x1c974
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8650
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1c050
jmp 0x1c976
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1c92d
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c880
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9bb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
callq 0x3760
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1ca1c
movsbl -0x11(%rbp), %eax
cmpl $0x2d, %eax
jne 0x1ca06
callq 0x3760
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1ca1c
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9e41(%rip), %rdi      # 0x26856
movb $0x0, %al
callq 0xfd50
movq -0x10(%rbp), %rdi
callq 0x3670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c7f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9bb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ca9c
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1caa4
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cab0
movq -0x10(%rbp), %rdi
callq 0x1c990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c880
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9d94(%rip), %rsi      # 0x26878
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x3510
cmpl $0x1, %eax
jge 0x1cb0a
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9d79(%rip), %rdi      # 0x2687c
movb $0x0, %al
callq 0xfd50
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c860
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1cc50
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x89d0
cmpl $0x0, %eax
jne 0x1cc43
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cc6c
jmp 0x1cc45
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1cbfe
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9c44(%rip), %rdi      # 0x268a3
movb $0x0, %al
callq 0xfd50
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/cheapcgi.c
// Function: cgiMakeClearButton
void cgiMakeClearButton(char *form, char *field)
/* Make button to clear a text field. */
{
char javascript[1024];

safef(javascript, sizeof(javascript),
    "document.%s.%s.value = ''; document.%s.submit();", form, field, form);
cgiMakeOnClickButton(javascript, " Clear  ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %r9
movl $0x400, %esi            # imm = 0x400
leaq 0x9bd8(%rip), %rdx      # 0x268fa
movb $0x0, %al
callq 0xdc90
leaq -0x410(%rbp), %rdi
leaq 0x9bf4(%rip), %rsi      # 0x2692b
callq 0x1cd50
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9ace(%rip), %rdi      # 0x26a10
movb $0x0, %al
callq 0x3260
cmpl $0x0, -0x14(%rbp)
je 0x1cf5d
leaq 0x9ae2(%rip), %rdi      # 0x26a38
movb $0x0, %al
callq 0x3260
leaq 0x9994(%rip), %rdi      # 0x268f8
movb $0x0, %al
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1d2d1
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x985e(%rip), %rdx      # 0x26b26
movb $0x0, %al
callq 0xdc90
jmp 0x1d2d8
movb $0x0, -0x120(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x120(%rbp), %r8
movl $0x1, %edx
callq 0x1d300
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1d344
leaq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0xa0f2(%rip), %rdx      # 0x2742d
movb $0x0, %al
callq 0xdc90
jmp 0x1d34b
movb $0x0, -0x220(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x220(%rbp), %rax
movq %rax, -0x228(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1d378
movq -0x20(%rbp), %rax
movq %rax, -0x238(%rbp)
jmp 0x1d388
leaq 0x797b(%rip), %rax      # 0x24cfa
movq %rax, -0x238(%rbp)
jmp 0x1d388
movq -0x228(%rbp), %rdx
movq -0x230(%rbp), %rsi
movq -0x238(%rbp), %rcx
movl -0xc(%rbp), %edi
leaq 0x7953(%rip), %r8       # 0x24cfa
leaq 0x97ab(%rip), %rax      # 0x26b59
cmpl $0x0, %edi
cmovneq %rax, %r8
movl -0x10(%rbp), %edi
leaq 0x9679(%rip), %r9       # 0x26a38
leaq 0x7934(%rip), %rax      # 0x24cfa
cmpl $0x0, %edi
cmovneq %rax, %r9
leaq 0xa062(%rip), %rdi      # 0x27436
movb $0x0, %al
callq 0x3260
leaq -0x120(%rbp), %rax
movq %rax, -0x248(%rbp)
callq 0x1d220
movq -0x248(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x7dc7(%rip), %rdx      # 0x251cf
movb $0x0, %al
callq 0xdc90
leaq -0x120(%rbp), %rax
movq %rax, -0x240(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1d433
leaq 0x8e5f(%rip), %rax      # 0x26289
movq %rax, -0x250(%rbp)
jmp 0x1d452
movl -0xc(%rbp), %edx
leaq 0x973d(%rip), %rax      # 0x26b7a
leaq 0x9733(%rip), %rcx      # 0x26b77
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x250(%rbp)
movq -0x240(%rbp), %rdi
movq -0x250(%rbp), %rsi
leaq 0x9716(%rip), %rdx      # 0x26b7d
callq 0x1d740
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9535(%rip), %rdi      # 0x26b31
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x18(%rbp)
je 0x1d61c
movq -0x18(%rbp), %rsi
leaq 0x953b(%rip), %rdi      # 0x26b50
movb $0x0, %al
callq 0x3260
cmpl $0x0, -0xc(%rbp)
je 0x1d630
leaq 0x9530(%rip), %rdi      # 0x26b59
movb $0x0, %al
callq 0x3260
cmpl $0x0, -0x10(%rbp)
jne 0x1d661
movq -0x20(%rbp), %rdx
leaq 0x9521(%rip), %rdi      # 0x26b62
movl $0x20, %esi
callq 0xa670
cmpq $0x0, %rax
jne 0x1d65f
leaq 0x93e0(%rip), %rdi      # 0x26a38
movb $0x0, %al
callq 0x3260
jmp 0x1d661
cmpq $0x0, -0x20(%rbp)
je 0x1d67a
movq -0x20(%rbp), %rsi
leaq 0x94f8(%rip), %rdi      # 0x26b6b
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x28(%rbp)
je 0x1d693
movq -0x28(%rbp), %rsi
leaq 0x77f7(%rip), %rdi      # 0x24e83
movb $0x0, %al
callq 0x3260
leaq 0x925e(%rip), %rdi      # 0x268f8
movb $0x0, %al
callq 0x3260
leaq -0x130(%rbp), %rax
movq %rax, -0x140(%rbp)
callq 0x1d220
movq -0x140(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x7b01(%rip), %rdx      # 0x251cf
movb $0x0, %al
callq 0xdc90
leaq -0x130(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1d6f9
leaq 0x8b99(%rip), %rax      # 0x26289
movq %rax, -0x148(%rbp)
jmp 0x1d718
movl -0xc(%rbp), %edx
leaq 0x9477(%rip), %rax      # 0x26b7a
leaq 0x946d(%rip), %rcx      # 0x26b77
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x148(%rbp)
movq -0x138(%rbp), %rdi
movq -0x148(%rbp), %rsi
leaq 0x9450(%rip), %rdx      # 0x26b7d
callq 0x1d740
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x98a3(%rip), %rdi      # 0x27006
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x18(%rbp)
je 0x1d785
movq -0x18(%rbp), %rsi
leaq 0x9746(%rip), %rdi      # 0x26ec2
movb $0x0, %al
callq 0x3260
jmp 0x1d791
leaq 0x916c(%rip), %rdi      # 0x268f8
callq 0x30f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d929
leaq 0x73d5(%rip), %rax      # 0x24cfa
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1d93b
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1d948
movl $0x8, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x926d(%rip), %rdi      # 0x26bc7
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x20(%rbp)
je 0x1d986
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1d986
movq -0x20(%rbp), %rsi
leaq 0x9276(%rip), %rdi      # 0x26bf5
movb $0x0, %al
callq 0x3260
leaq 0x94a2(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d9f9
leaq 0x7305(%rip), %rax      # 0x24cfa
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1da0f
movq -0x10(%rbp), %rdi
callq 0x31f0
imulq $0xa, %rax, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1da1c
movl $0x64, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x91d8(%rip), %rdi      # 0x26c06
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x20(%rbp)
je 0x1da5a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1da5a
movq -0x20(%rbp), %rsi
leaq 0x7430(%rip), %rdi      # 0x24e83
movb $0x0, %al
callq 0x3260
leaq 0x93ce(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1db39
cmpq $0x0, -0x30(%rbp)
je 0x1daed
movq -0x30(%rbp), %rdi
callq 0x31f0
imulq $0xa, %rax, %rax
movl %eax, -0x1c(%rbp)
jmp 0x1db37
movl -0xc(%rbp), %eax
addl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1db10
movq -0x28(%rbp), %rdi
callq 0x3670
addl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x34(%rbp)
movl $0xa, -0x1c(%rbp)
movl -0x34(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x1db35
movl -0x1c(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1db17
jmp 0x1db37
jmp 0x1db39
cmpl $0x41, -0x1c(%rbp)
jge 0x1db46
movl $0x41, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x9127(%rip), %rdi      # 0x26c7e
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x28(%rbp)
je 0x1db6f
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1db7c
leaq 0x917d(%rip), %rax      # 0x26cf3
movq %rax, -0x40(%rbp)
jmp 0x1db7c
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1db95
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1dba2
leaq 0x9157(%rip), %rax      # 0x26cf3
movq %rax, -0x50(%rbp)
jmp 0x1dba2
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq 0x9116(%rip), %rdi      # 0x26cc7
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x18(%rbp)
je 0x1dbd1
movq -0x18(%rbp), %rsi
leaq 0x9130(%rip), %rdi      # 0x26cfa
movb $0x0, %al
callq 0x3260
leaq 0x9257(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
cmpl $0xfffe8663, -0x20(%rbp) # imm = 0xFFFE8663
je 0x1dc49
leaq -0x40(%rbp), %rdi
movl -0x20(%rbp), %ecx
movl $0x14, %esi
leaq 0x890a(%rip), %rdx      # 0x26544
movb $0x0, %al
callq 0xdc90
leaq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0xfffe8663, -0x24(%rbp) # imm = 0xFFFE8663
je 0x1dc74
leaq -0x60(%rbp), %rdi
movl -0x24(%rbp), %ecx
movl $0x14, %esi
leaq 0x88df(%rip), %rdx      # 0x26544
movb $0x0, %al
callq 0xdc90
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x68(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x1dab0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
cmpl $0xfffe8663, -0x20(%rbp) # imm = 0xFFFE8663
je 0x1dced
leaq -0x40(%rbp), %rdi
movl -0x20(%rbp), %ecx
movl $0x14, %esi
leaq 0x8866(%rip), %rdx      # 0x26544
movb $0x0, %al
callq 0xdc90
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x48(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x1dab0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
cmpl $0xfffe8663, -0x20(%rbp) # imm = 0xFFFE8663
je 0x1dd5d
leaq -0x40(%rbp), %rdi
movl -0x20(%rbp), %ecx
movl $0x14, %esi
leaq 0x87f6(%rip), %rdx      # 0x26544
movb $0x0, %al
callq 0xdc90
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x48(%rbp), %r9
xorl %eax, %eax
movl %eax, %r8d
callq 0x1dab0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1de0f
cmpq $0x0, -0x30(%rbp)
je 0x1de0d
movq -0x30(%rbp), %rdi
callq 0x31f0
imulq $0xa, %rax, %rax
movl %eax, -0x1c(%rbp)
jmp 0x1de0f
cmpl $0x41, -0x1c(%rbp)
jge 0x1de1c
movl $0x41, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x10(%rbp), %xmm0
leaq 0x8f04(%rip), %rdi      # 0x26d33
movb $0x1, %al
callq 0x3260
cmpq $0x0, -0x28(%rbp)
je 0x1de47
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1de54
leaq 0x8ea5(%rip), %rax      # 0x26cf3
movq %rax, -0x38(%rbp)
jmp 0x1de54
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1de6d
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1de7a
leaq 0x8e7f(%rip), %rax      # 0x26cf3
movq %rax, -0x48(%rbp)
jmp 0x1de7a
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq 0x8ef3(%rip), %rdi      # 0x26d7c
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x18(%rbp)
je 0x1dea9
movq -0x18(%rbp), %rsi
leaq 0x8e58(%rip), %rdi      # 0x26cfa
movb $0x0, %al
callq 0x3260
leaq 0x8f7f(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
cvttsd2si -0x28(%rbp), %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
je 0x1df25
leaq -0x50(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movl $0x14, %esi
leaq 0x8e63(%rip), %rdx      # 0x26d79
movb $0x1, %al
callq 0xdc90
leaq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
cvttsd2si -0x30(%rbp), %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
je 0x1df55
leaq -0x70(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movl $0x14, %esi
leaq 0x8e33(%rip), %rdx      # 0x26d79
movb $0x1, %al
callq 0xdc90
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %r8
callq 0x1ddd0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm1, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
cvttsd2si -0x28(%rbp), %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
je 0x1dfd5
leaq -0x40(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movl $0x14, %esi
leaq 0x8db3(%rip), %rdx      # 0x26d79
movb $0x1, %al
callq 0xdc90
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x48(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ddd0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm1, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
cvttsd2si -0x28(%rbp), %eax
cmpl $0xfffe8663, %eax       # imm = 0xFFFE8663
je 0x1e055
leaq -0x40(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movl $0x14, %esi
leaq 0x8d33(%rip), %rdx      # 0x26d79
movb $0x1, %al
callq 0xdc90
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x48(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ddd0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e0b5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x8cee(%rip), %rdi      # 0x26daa
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x8(%rbp)
je 0x1e0dc
movq -0x8(%rbp), %rsi
leaq 0x8a70(%rip), %rdi      # 0x26b45
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x28(%rbp)
je 0x1e0f5
movq -0x28(%rbp), %rsi
leaq 0x8a7d(%rip), %rdi      # 0x26b6b
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x30(%rbp)
je 0x1e10e
movq -0x30(%rbp), %rsi
leaq 0x8cab(%rip), %rdi      # 0x26db2
movb $0x0, %al
callq 0x3260
cmpq $0x0, 0x10(%rbp)
je 0x1e127
movq 0x10(%rbp), %rsi
leaq 0x6d63(%rip), %rdi      # 0x24e83
movb $0x0, %al
callq 0x3260
leaq 0x8d01(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e19f
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x89d0
cmpl $0x0, %eax
jne 0x1e16b
leaq 0x8c59(%rip), %rax      # 0x26dbe
movq %rax, -0x40(%rbp)
jmp 0x1e176
leaq 0x6b88(%rip), %rax      # 0x24cfa
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x8c3b(%rip), %rdi      # 0x26dc8
movb $0x0, %al
callq 0x3260
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e13c
leaq 0x8c39(%rip), %rdi      # 0x26ddf
movb $0x0, %al
callq 0x3260
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e2d5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8650
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0x8b1d(%rip), %rdi      # 0x26e00
movb $0x0, %al
callq 0x3260
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e354
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x8970
cmpl $0x0, %eax
je 0x1e320
leaq 0x8aa4(%rip), %rax      # 0x26dbe
movq %rax, -0x30(%rbp)
jmp 0x1e32b
leaq 0x69d3(%rip), %rax      # 0x24cfa
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x8a86(%rip), %rdi      # 0x26dc8
movb $0x0, %al
callq 0x3260
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1e2f1
leaq 0x8a84(%rip), %rdi      # 0x26ddf
movb $0x0, %al
callq 0x3260
leaq -0x230(%rbp), %rax
movq %rax, -0x238(%rbp)
callq 0x1e290
movq -0x238(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x200, %esi            # imm = 0x200
leaq 0x6e40(%rip), %rdx      # 0x251cf
movb $0x0, %al
callq 0xdc90
leaq -0x230(%rbp), %rdi
leaq 0x87d4(%rip), %rsi      # 0x26b78
xorl %eax, %eax
movl %eax, %edx
callq 0x1d740
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e3f1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e400
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x8a2b(%rip), %rdi      # 0x26e32
callq 0x30f0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1e4bf
cmpl $0x0, -0x30(%rbp)
jle 0x1e43f
movl -0x30(%rbp), %eax
cltd
idivl -0x2c(%rbp)
cmpl $0x0, %edx
jne 0x1e43f
leaq 0x8a14(%rip), %rdi      # 0x26e4c
movb $0x0, %al
callq 0x3260
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x238(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x8970
movq -0x240(%rbp), %rsi
movq -0x238(%rbp), %rdx
movl %eax, %edi
leaq 0x6871(%rip), %rcx      # 0x24cfa
leaq 0x86ca(%rip), %rax      # 0x26b5a
cmpl $0x0, %edi
cmovneq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rdi
movq (%rax,%rdi,8), %r8
leaq 0x89ac(%rip), %rdi      # 0x26e56
movb $0x0, %al
callq 0x3260
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1e413
movl -0x30(%rbp), %eax
cltd
idivl -0x2c(%rbp)
cmpl $0x0, %edx
je 0x1e4f3
jmp 0x1e4cd
movl -0x30(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x30(%rbp)
cltd
idivl -0x2c(%rbp)
cmpl $0x0, %edx
je 0x1e4f1
leaq 0x89b1(%rip), %rdi      # 0x26e99
movb $0x0, %al
callq 0x3260
jmp 0x1e4cd
jmp 0x1e4f3
leaq 0x89a9(%rip), %rdi      # 0x26ea3
callq 0x30f0
leaq -0x230(%rbp), %rax
movq %rax, -0x248(%rbp)
callq 0x1e290
movq -0x248(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %r8
movl $0x200, %esi            # imm = 0x200
leaq 0x6ca3(%rip), %rdx      # 0x251cf
movb $0x0, %al
callq 0xdc90
leaq -0x230(%rbp), %rdi
leaq 0x7d48(%rip), %rsi      # 0x26289
xorl %eax, %eax
movl %eax, %edx
callq 0x1d740
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e5d1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
je 0x1e5f1
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0x88c9(%rip), %rdi      # 0x26eb1
movb $0x0, %al
callq 0x3260
jmp 0x1e603
movq -0x8(%rbp), %rsi
leaq 0x88cc(%rip), %rdi      # 0x26ec8
movb $0x0, %al
callq 0x3260
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1e679
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x89d0
cmpl $0x0, %eax
jne 0x1e639
leaq 0x878b(%rip), %rax      # 0x26dbe
movq %rax, -0x40(%rbp)
jmp 0x1e644
leaq 0x66ba(%rip), %rax      # 0x24cfa
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x8875(%rip), %rdi      # 0x26edc
movb $0x0, %al
callq 0x3260
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e60a
leaq 0x875f(%rip), %rdi      # 0x26ddf
movb $0x0, %al
callq 0x3260
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e9ed
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x84d0(%rip), %rdi      # 0x26ec8
movb $0x0, %al
callq 0x3260
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1ea75
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x89d0
cmpl $0x0, %eax
jne 0x1ea35
leaq 0x838f(%rip), %rax      # 0x26dbe
movq %rax, -0x38(%rbp)
jmp 0x1ea40
leaq 0x62be(%rip), %rax      # 0x24cfa
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x8479(%rip), %rdi      # 0x26edc
movb $0x0, %al
callq 0x3260
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ea06
leaq 0x8363(%rip), %rdi      # 0x26ddf
movb $0x0, %al
callq 0x3260
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1eabf
cmpq $0x0, -0x10(%rbp)
je 0x1eabf
jmp 0x1eade
leaq 0x84a0(%rip), %rdi      # 0x26f66
leaq 0x84b8(%rip), %rsi      # 0x26f85
movl $0x735, %edx            # imm = 0x735
leaq 0x84b7(%rip), %rcx      # 0x26f90
callq 0x32d0
cmpq $0x0, -0x28(%rbp)
jne 0x1eaf0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x82b3(%rip), %rdi      # 0x26daa
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x8(%rbp)
je 0x1eb17
movq -0x8(%rbp), %rsi
leaq 0x8035(%rip), %rdi      # 0x26b45
movb $0x0, %al
callq 0x3260
cmpq $0x0, -0x30(%rbp)
je 0x1eb30
movq -0x30(%rbp), %rsi
leaq 0x5a83(%rip), %rdi      # 0x245ac
movb $0x0, %al
callq 0x3260
leaq 0x82f8(%rip), %rdi      # 0x26e2f
movb $0x0, %al
callq 0x3260
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1ebb4
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x89d0
cmpl $0x0, %eax
jne 0x1eb74
leaq 0x8250(%rip), %rax      # 0x26dbe
movq %rax, -0x40(%rbp)
jmp 0x1eb7f
leaq 0x617f(%rip), %rax      # 0x24cfa
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x8442(%rip), %rdi      # 0x26fe4
movb $0x0, %al
callq 0x3260
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1eb45
leaq 0x8224(%rip), %rdi      # 0x26ddf
movb $0x0, %al
callq 0x3260
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ecc9
jmp 0x1ec98
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1ecc7
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10900
jmp 0x1ec98
jmp 0x1ecc9
callq 0x1f650
movq 0x14633(%rip), %rdi     # 0x33308
callq 0x112f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ed20
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x104b0
cmpq $0x0, %rax
jne 0x1ed11
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ec20
jmp 0x1ed13
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ece6
leaq -0x10(%rbp), %rdi
callq 0x113e0
leaq -0x20(%rbp), %rdi
callq 0x11620
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1f650
movl $0x20, %edi
callq 0x152f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7530
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x1458a(%rip), %rdi     # 0x33308
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
callq 0x10b20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)