LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutCommaIn
struct repeatMaskOut *repeatMaskOutCommaIn(char **pS)
/* Create a repeatMaskOut out of a comma separated string. */
{
struct repeatMaskOut *ret;
char *s = *pS;

AllocVar(ret);
ret->score = sqlUnsignedComma(&s);
ret->percDiv = sqlSignedComma(&s);
ret->percDel = sqlSignedComma(&s);
ret->percInc = sqlSignedComma(&s);
ret->qName = sqlStringComma(&s);
ret->qStart = sqlSignedComma(&s);
ret->qEnd = sqlSignedComma(&s);
ret->qLeft = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->rName = sqlStringComma(&s);
ret->rFamily = sqlStringComma(&s);
ret->rStart = sqlStringComma(&s);
ret->rEnd = sqlUnsignedComma(&s);
ret->rLeft = sqlStringComma(&s);
*pS = s;
return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
pushq $0x60
popq %rdi
callq 0x28bb0
movq %rax, %r15
movq %r14, %rdi
callq 0x37a9b
movl %eax, 0x8(%r15)
movq %r14, %rdi
callq 0x37ac8
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%r15)
movq %r14, %rdi
callq 0x37ac8
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x10(%r15)
movq %r14, %rdi
callq 0x37ac8
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x14(%r15)
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x18(%r15)
movq %r14, %rdi
callq 0x37ac8
movl %eax, 0x20(%r15)
movq %r14, %rdi
callq 0x37ac8
movl %eax, 0x24(%r15)
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x28(%r15)
leaq 0x30(%r15), %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x37c50
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x38(%r15)
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x40(%r15)
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x48(%r15)
movq %r14, %rdi
callq 0x37a9b
movl %eax, 0x50(%r15)
movq %r14, %rdi
callq 0x37baa
movq %rax, 0x58(%r15)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFree
void repeatMaskOutFree(struct repeatMaskOut **pEl)
/* Free a single dynamically allocated repeatMaskOut such as created
 * with repeatMaskOutLoad(). */
{
struct repeatMaskOut *el;

if ((el = *pEl) == NULL) return;
freeMem(el->qName);
freeMem(el->qLeft);
freeMem(el->rName);
freeMem(el->rFamily);
freeMem(el->rStart);
freeMem(el->rLeft);
freez(pEl);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x35916
movq %rdi, %rbx
movq 0x18(%r14), %rdi
callq 0x28c2d
movq 0x28(%r14), %rdi
callq 0x28c2d
movq 0x38(%r14), %rdi
callq 0x28c2d
movq 0x40(%r14), %rdi
callq 0x28c2d
movq 0x48(%r14), %rdi
callq 0x28c2d
movq 0x58(%r14), %rdi
callq 0x28c2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFreeList
void repeatMaskOutFreeList(struct repeatMaskOut **pList)
/* Free a list of dynamically allocated repeatMaskOut's */
{
struct repeatMaskOut *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    repeatMaskOutFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x35949
movq (%r15), %r15
movq %r14, %rdi
callq 0x358c2
jmp 0x35932
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedOrError
unsigned sqlUnsignedOrError(char *s, char *format, ...)
/* Convert series of digits to unsigned integer about
 * twice as fast as atoi (by not having to skip white 
 * space or stop except at the null byte.) 
 * like sqlUnsigned, with an optional error message as a printf-style vararg
 * */
{
unsigned res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
/* test for invalid character or empty */
if ((c != '\0') || (p == s))
    {
    if (format==NULL)
        errAbort("invalid unsigned integer: \"%s\"", s);
    else
        {
        //errAbort("%s", errorMsg);
        va_list args;
        va_start(args, format);
        vaErrAbort(format, args);
        va_end(args);
        }
    }
return res;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x35c92
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
xorl %eax, %eax
xorl %ebx, %ebx
movzbl (%r10,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35cb1
imull $0xa, %ebx, %edx
leal (%rdx,%rcx), %ebx
addl $-0x30, %ebx
incq %rax
jmp 0x35c96
testl %ecx, %ecx
sete %cl
testq %rax, %rax
setne %al
testb %cl, %al
jne 0x35d08
testq %rsi, %rsi
je 0x35cf7
leaq 0x20(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x224d7
jmp 0x35d08
leaq 0x4d910(%rip), %rdi     # 0x8360e
movq %r10, %rsi
xorl %eax, %eax
callq 0x223fb
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedInList
unsigned sqlUnsignedInList(char **pS)
/* Convert series of digits to unsigned integer about
 * twice as fast as atoi (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if (!(c == '\0' || c == ',') || (p == s))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid unsigned integer: \"%s\"", s);
    }
*pS = p;
return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
xorl %eax, %eax
xorl %ebp, %ebp
movzbl (%r14,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35d48
imull $0xa, %ebp, %edx
leal (%rdx,%rcx), %ebp
addl $-0x30, %ebp
incq %rax
jmp 0x35d2d
leaq (%r14,%rax), %r15
cmpl $0x2c, %ecx
je 0x35d55
testl %ecx, %ecx
jne 0x35d5a
testq %rax, %rax
jne 0x35d7e
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x35d6d
movb $0x0, (%rax)
leaq 0x4d89a(%rip), %rdi     # 0x8360e
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r15, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLong
unsigned long sqlUnsignedLong(char *s)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) */
{
unsigned long res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if ((c != '\0') || (p == s))
    errAbort("invalid unsigned long: \"%s\"", s);
return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
xorl %eax, %eax
xorl %ebx, %ebx
movzbl (%rsi,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35db4
imulq $0xa, %rbx, %rdx
andl $0xf, %ecx
addq %rdx, %rcx
incq %rax
movq %rcx, %rbx
jmp 0x35d96
testq %rcx, %rcx
sete %cl
testq %rax, %rax
setne %al
testb %cl, %al
jne 0x35dd2
leaq 0x4d862(%rip), %rdi     # 0x8362d
xorl %eax, %eax
callq 0x223fb
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLongInList
unsigned long sqlUnsignedLongInList(char **pS)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned long res = 0;
char *p = s;
char c;

while (((c = *(p++)) >= '0') && (c <= '9'))
    {
    res *= 10;
    res += c - '0';
    }
--p;
if (!(c == '\0' || c == ',') || (p == s))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid unsigned long: \"%s\"", s);
    }
*pS = p;
return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
xorl %eax, %eax
xorl %r15d, %r15d
movzbl (%r14,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35e09
imulq $0xa, %r15, %rdx
andl $0xf, %ecx
addq %rdx, %rcx
incq %rax
movq %rcx, %r15
jmp 0x35dea
leaq (%r14,%rax), %r12
cmpq $0x2c, %rcx
je 0x35e17
testl %ecx, %ecx
jne 0x35e1c
testq %rax, %rax
jne 0x35e40
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x35e2f
movb $0x0, (%rax)
leaq 0x4d7f7(%rip), %rdi     # 0x8362d
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r12, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSigned
int sqlSigned(char *s)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. */
{
int res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if ((*p != '\0') || (p == p0))
    errAbort("invalid signed integer: \"%s\"", s);
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
xorl %eax, %eax
cmpb $0x2d, %cl
sete %al
addq %rdi, %rax
xorl %edx, %edx
xorl %ebp, %ebp
movb (%rax,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x35e84
imull $0xa, %ebp, %esi
movzbl %dil, %ebp
addl %esi, %ebp
incq %rdx
jmp 0x35e69
testb %sil, %sil
setne %al
testq %rdx, %rdx
sete %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x35eaa
leaq 0x4d7ab(%rip), %rdi     # 0x83649
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movb (%rbx), %cl
movl %ebp, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSignedInList
int sqlSignedInList(char **pS)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
int res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if (!(*p == '\0' || *p == ',') || (p == p0))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid signed integer: \"%s\"", s);
    }
*pS = p;
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
xorl %r15d, %r15d
cmpb $0x2d, (%rbx)
sete %r15b
addq %rbx, %r15
xorl %eax, %eax
xorl %ebp, %ebp
movzbl (%r15,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35ef3
imull $0xa, %ebp, %ecx
movzbl %dl, %ebp
addl %ecx, %ebp
incq %rax
jmp 0x35ed9
addq %rax, %r15
cmpl $0x2c, %ecx
je 0x35eff
testl %ecx, %ecx
jne 0x35f04
testq %rax, %rax
jne 0x35f28
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x6270
testq %rax, %rax
je 0x35f17
movb $0x0, (%rax)
leaq 0x4d72b(%rip), %rdi     # 0x83649
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r15, (%r14)
movl %ebp, %eax
negl %eax
cmpb $0x2d, (%rbx)
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLong
long long sqlLongLong(char *s)
/* Convert string to a long long.  Unlike atol assumes all of string is
 * number. */
{
long long res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if ((*p != '\0') || (p == p0))
    errAbort("invalid signed long long: \"%s\"", s);
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
xorl %eax, %eax
cmpb $0x2d, %cl
sete %al
addq %rdi, %rax
xorl %edx, %edx
xorl %r14d, %r14d
movb (%rax,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x35f76
imulq $0xa, %r14, %rsi
movzbl %dil, %r14d
addq %rsi, %r14
incq %rdx
jmp 0x35f59
testb %sil, %sil
setne %al
testq %rdx, %rdx
sete %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x35f9c
leaq 0x4d6d6(%rip), %rdi     # 0x83666
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movb (%rbx), %cl
movq %r14, %rax
negq %rax
cmpb $0x2d, %cl
cmovneq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLongInList
long long sqlLongLongInList(char **pS)
/* Convert string to a long long.  Unlike atol, assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
long long res = 0;
char *p, *p0 = s;

if (*p0 == '-')
    p0++;
p = p0;
while ((*p >= '0') && (*p <= '9'))
    {
    res *= 10;
    res += *p - '0';
    p++;
    }
/* test for invalid character, empty, or just a minus */
if (!(*p == '\0' || *p == ',') || (p == p0))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid signed long long: \"%s\"", s);
    }
*pS = p;
if (*s == '-')
    return -res;
else
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
xorl %r15d, %r15d
cmpb $0x2d, (%rbx)
sete %r15b
addq %rbx, %r15
xorl %eax, %eax
xorl %r12d, %r12d
movzbl (%r15,%rax), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x35fee
imulq $0xa, %r12, %rcx
movzbl %dl, %r12d
addq %rcx, %r12
incq %rax
jmp 0x35fd1
addq %rax, %r15
cmpl $0x2c, %ecx
je 0x35ffa
testl %ecx, %ecx
jne 0x35fff
testq %rax, %rax
jne 0x36023
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x6270
testq %rax, %rax
je 0x36012
movb $0x0, (%rax)
leaq 0x4d64d(%rip), %rdi     # 0x83666
movq %rbx, %rsi
xorl %eax, %eax
callq 0x223fb
movq %r15, (%r14)
movq %r12, %rax
negq %rax
cmpb $0x2d, (%rbx)
cmovneq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlFloat
float sqlFloat(char *s)
/* Convert string to a float.  Assumes all of string is number
 * and aborts on an error. */
{
char* end;
/*	used to have an ifdef here to use strtof() but that doesn't
 *	actually exist on all systems and since strtod() does, may as
 *	well use it since it will do the job here.
 */
float val = (float) strtod(s, &end);

if ((end == s) || (*end != '\0'))
    errAbort("invalid float: %s", s);
return val;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x6500
movq (%r14), %rax
cmpq %rbx, %rax
je 0x36063
cmpb $0x0, (%rax)
je 0x36080
leaq 0x4d61b(%rip), %rdi     # 0x83685
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x223fb
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlFloatInList
float sqlFloatInList(char **pS)
/* Convert string to a float.  Assumes all of string is number
 * and aborts on an error. 
 * Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
char* end;
/*	used to have an ifdef here to use strtof() but that doesn't
 *	actually exist on all systems and since strtod() does, may as
 *	well use it since it will do the job here.
 */
float val = (float) strtod(s, &end);

if ((end == s) || !(*end == '\0' || *end == ','))
    {
    char *e = strchr(s, ',');
    if (e)
	*e = 0;
    errAbort("invalid float: %s", s);
    }
*pS = end;
return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6500
movq (%r15), %r15
cmpq %r14, %r15
je 0x360c0
movzbl (%r15), %eax
testl %eax, %eax
je 0x360ee
cmpl $0x2c, %eax
je 0x360ee
movsd %xmm0, (%rsp)
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x360d8
movb $0x0, (%rax)
leaq 0x4d5a6(%rip), %rdi     # 0x83685
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movsd (%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlDouble
double sqlDouble(char *s)
/* Convert string to a double.  Assumes all of string is number
 * and aborts on an error. */
{
char* end;
double val = strtod(s, &end);

if ((end == s) || (*end != '\0'))
    errAbort("invalid double: %s", s);
return val;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x6500
movq (%r14), %rax
cmpq %rbx, %rax
je 0x36123
cmpb $0x0, (%rax)
je 0x36140
leaq 0x4d56d(%rip), %rdi     # 0x83697
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x223fb
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlNum.c
// Function: sqlDoubleInList
double sqlDoubleInList(char **pS)
/* Convert string to a double.  Assumes all of string is number
 * and aborts on an error.
 * Number may be delimited by a comma.
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
char* end;
double val = strtod(s, &end);

if ((end == s) || !(*end == '\0' || *end == ','))
    {
    char *e = strchr(s, ',');
    if (e)
        *e = 0;
    errAbort("invalid double: %s", s);
    }
*pS = end;
return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6500
movq (%r15), %r15
cmpq %r14, %r15
je 0x3617c
movzbl (%r15), %eax
testl %eax, %eax
je 0x361aa
cmpl $0x2c, %eax
je 0x361aa
movsd %xmm0, (%rsp)
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x6270
testq %rax, %rax
je 0x36194
movb $0x0, (%rax)
leaq 0x4d4fc(%rip), %rdi     # 0x83697
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movsd (%rsp), %xmm0
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteArray
int sqlByteArray(char *s, signed char *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlSigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36213
cmpb $0x0, (%r15)
je 0x36213
cmpq %r14, %r12
je 0x36213
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x361fc
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x361ff
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35e52
movb %al, (%rbx,%r14)
incq %r14
movq %r13, %r15
jmp 0x361d2
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteStaticArray
void sqlByteStaticArray(char *s, signed char **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static signed char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = sqlSigned(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x2c
popq %rbp
pushq $0x40
popq %rbx
testq %r15, %r15
je 0x362be
cmpb $0x0, (%r15)
je 0x362be
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x3626e
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x36271
xorl %r14d, %r14d
movl 0x81ef9(%rip), %eax     # 0xb8170
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x362a3
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebx, %edx
movl %edx, 0x81ee3(%rip)     # 0xb8170
movq 0x81ed4(%rip), %rdi     # 0xb8168
movq %r12, %rsi
callq 0x28c1e
movq %rax, 0x81ec5(%rip)     # 0xb8168
movq %r15, %rdi
callq 0x35e52
movq 0x81eb6(%rip), %rcx     # 0xb8168
incl %r13d
movb %al, (%rcx,%r12)
movq %r14, %r15
jmp 0x36249
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x81e9b(%rip), %rax     # 0xb8168
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteDynamicArray
void sqlByteDynamicArray(char *s, signed char **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
signed char *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlSignedInList(&s);
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x36353
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x3635b
movl %r12d, %edi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x35ebb
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3634e
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x36322
incl %r12d
jmp 0x3635e
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3635e
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteArray
int sqlUbyteArray(char *s, unsigned char *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlUnsigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x363cd
cmpb $0x0, (%r15)
je 0x363cd
cmpq %r14, %r12
je 0x363cd
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x363b6
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x363b9
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35d13
movb %al, (%rbx,%r14)
incq %r14
movq %r13, %r15
jmp 0x3638c
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteStaticArray
void sqlUbyteStaticArray(char *s, unsigned char **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static unsigned char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = sqlUnsigned(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x2c
popq %rbp
pushq $0x40
popq %rbx
testq %r15, %r15
je 0x36478
cmpb $0x0, (%r15)
je 0x36478
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36428
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x3642b
xorl %r14d, %r14d
movl 0x81d4f(%rip), %eax     # 0xb8180
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3645d
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebx, %edx
movl %edx, 0x81d39(%rip)     # 0xb8180
movq 0x81d2a(%rip), %rdi     # 0xb8178
movq %r12, %rsi
callq 0x28c1e
movq %rax, 0x81d1b(%rip)     # 0xb8178
movq %r15, %rdi
callq 0x35d13
movq 0x81d0c(%rip), %rcx     # 0xb8178
incl %r13d
movb %al, (%rcx,%r12)
movq %r14, %r15
jmp 0x36403
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x81cf1(%rip), %rax     # 0xb8178
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteDynamicArray
void sqlUbyteDynamicArray(char *s, unsigned char **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
unsigned char *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlUnsignedInList(&s);
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x3650d
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x36515
movl %r12d, %edi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x35d1c
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x36508
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x364dc
incl %r12d
jmp 0x36518
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x36518
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharArray
int sqlCharArray(char *s, char *array, int arraySize)
/* Convert comma separated list of chars to an array.  Pass in 
 * array and max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = s[0];
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36581
movb (%r15), %r13b
testb %r13b, %r13b
je 0x36581
cmpq %r14, %r12
je 0x36581
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36575
movb $0x0, (%rax)
movb (%r15), %r13b
movq %rax, %r15
incq %r15
jmp 0x36578
xorl %r15d, %r15d
movb %r13b, (%rbx,%r14)
incq %r14
jmp 0x36546
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharStaticArray
void sqlCharStaticArray(char *s, char **retArray, int *retSize)
/* Convert comma separated list of chars to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = s[0];
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x2c
popq %rbp
pushq $0x40
popq %rbx
testq %r15, %r15
je 0x36623
cmpb $0x0, (%r15)
je 0x36623
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x365dc
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x365df
xorl %r14d, %r14d
movl 0x81bab(%rip), %ecx     # 0xb8190
movq 0x81b9c(%rip), %rax     # 0xb8188
movl %r13d, %r12d
cmpl %ecx, %r13d
jb 0x36614
leal (%rcx,%rcx), %edx
testl %ecx, %ecx
cmovel %ebx, %edx
movl %edx, 0x81b8e(%rip)     # 0xb8190
movq %rax, %rdi
movq %r12, %rsi
callq 0x28c1e
movq %rax, 0x81b74(%rip)     # 0xb8188
movb (%r15), %cl
incl %r13d
movb %cl, (%rax,%r12)
movq %r14, %r15
jmp 0x365b7
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x81b56(%rip), %rax     # 0xb8188
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharDynamicArray
void sqlCharDynamicArray(char *s, char **retArray, int *retSize)
/* Convert comma separated list of chars to a dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
char *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    if (*s == ',')
		errAbort("Empty element in list. Each element should contain one character.");
	    array[count++] = *s++;
	    if (!(*s == 0 || *s == ','))
		{
		--s;
		char *e = strchr(s, ',');
		if (e)
		    *e = 0;
		errAbort("Invalid character: %s", s);
		}
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x36702
movq %rdi, %r13
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x3670a
movl %r12d, %edi
callq 0x28a1f
movq %rax, %r15
movb (%r13), %al
leaq 0x4d01b(%rip), %rbp     # 0x836aa
xorl %edx, %edx
movq %rdx, %r12
cmpb $0x2c, %al
jne 0x366a6
movq %rbp, %rdi
xorl %eax, %eax
callq 0x223fb
movb (%r13), %al
leaq 0x1(%r13), %rcx
movb %al, (%r15,%r12)
movzbl 0x1(%r13), %eax
testl %eax, %eax
je 0x366e7
cmpl $0x2c, %eax
je 0x366e7
movq %r13, %rdi
pushq $0x2c
popq %rsi
callq 0x6270
testq %rax, %rax
je 0x366cf
movb $0x0, (%rax)
leaq 0x4d016(%rip), %rdi     # 0x836ec
movq %r13, %rsi
xorl %eax, %eax
callq 0x223fb
movb (%r13), %al
movq %r13, %rcx
testb %al, %al
je 0x366fd
movb 0x1(%rcx), %al
incq %rcx
leaq 0x1(%r12), %rdx
movq %rcx, %r13
testb %al, %al
jne 0x36691
incl %r12d
jmp 0x3670d
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3670d
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortArray
int sqlShortArray(char *s, short *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlSigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x3677e
cmpb $0x0, (%r15)
je 0x3677e
cmpq %r14, %r12
je 0x3677e
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36766
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x36769
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35e52
movw %ax, (%rbx,%r14,2)
incq %r14
movq %r13, %r15
jmp 0x3673c
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortStaticArray
void sqlShortStaticArray(char *s, short **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static short *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = sqlSigned(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x2c
popq %rbp
pushq $0x40
popq %r13
testq %r15, %r15
je 0x3682f
cmpb $0x0, (%r15)
je 0x3682f
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x367da
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x367dc
xorl %ebx, %ebx
movl 0x819be(%rip), %eax     # 0xb81a0
movl %r12d, %r14d
cmpl %eax, %r12d
jb 0x36813
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %r13d, %edx
movl %edx, 0x819a7(%rip)     # 0xb81a0
movq 0x81998(%rip), %rdi     # 0xb8198
leaq (%r14,%r14), %rsi
addq %rdx, %rdx
callq 0x28c1e
movq %rax, 0x81985(%rip)     # 0xb8198
movq %r15, %rdi
callq 0x35e52
movq 0x81976(%rip), %rcx     # 0xb8198
incl %r12d
movw %ax, (%rcx,%r14,2)
movq %rbx, %r15
jmp 0x367b5
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
movq 0x8195a(%rip), %rax     # 0xb8198
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortDynamicArray
void sqlShortDynamicArray(char *s, short **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
short *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlSignedInList(&s);
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x368c7
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r15d
testl %eax, %eax
jle 0x368cf
addl %r15d, %r15d
movq %r15, %rdi
callq 0x28a1f
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x35ebb
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x368c2
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x36896
incl %r15d
jmp 0x368d2
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x368d2
xorl %r12d, %r12d
movq %r12, (%r14)
movl %r15d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlUshortStaticArray
void sqlUshortStaticArray(char *s, unsigned short **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static unsigned short *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = sqlUnsigned(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x2c
popq %rbp
pushq $0x40
popq %r13
testq %r15, %r15
je 0x369f3
cmpb $0x0, (%r15)
je 0x369f3
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x3699e
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x369a0
xorl %ebx, %ebx
movl 0x8180a(%rip), %eax     # 0xb81b0
movl %r12d, %r14d
cmpl %eax, %r12d
jb 0x369d7
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %r13d, %edx
movl %edx, 0x817f3(%rip)     # 0xb81b0
movq 0x817e4(%rip), %rdi     # 0xb81a8
leaq (%r14,%r14), %rsi
addq %rdx, %rdx
callq 0x28c1e
movq %rax, 0x817d1(%rip)     # 0xb81a8
movq %r15, %rdi
callq 0x35d13
movq 0x817c2(%rip), %rcx     # 0xb81a8
incl %r12d
movw %ax, (%rcx,%r14,2)
movq %rbx, %r15
jmp 0x36979
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
movq 0x817a6(%rip), %rax     # 0xb81a8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlUshortDynamicArray
void sqlUshortDynamicArray(char *s, unsigned short **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
unsigned short *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlUnsignedInList(&s);
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x36a8b
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r15d
testl %eax, %eax
jle 0x36a93
addl %r15d, %r15d
movq %r15, %rdi
callq 0x28a1f
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x35d1c
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x36a86
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x36a5a
incl %r15d
jmp 0x36a96
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x36a96
xorl %r12d, %r12d
movq %r12, (%r14)
movl %r15d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlDoubleArray
int sqlDoubleArray(char *s, double *array, int maxArraySize)
/* Convert comma separated list of floating point numbers to an array.  
 * Pass in array and max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == maxArraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = atof(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36b07
cmpb $0x0, (%r15)
je 0x36b07
cmpq %r14, %r12
je 0x36b07
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36aee
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x36af1
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x6920
movsd %xmm0, (%rbx,%r14,8)
incq %r14
movq %r13, %r15
jmp 0x36ac4
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlSumDoublesCommaSep
double sqlSumDoublesCommaSep(char *s)
/* Return sum of double values in a comma-separated list */
{
int count = 0;
char *p = s;
while (*p)
    if (*p++ == ',')
        count++;
double *array = NULL;
int arraySize = count + 1;
AllocArray(array, arraySize);
char *t = cloneString(s);
count = sqlDoubleArray(cloneString(s), array, arraySize);
freez(&t);
int i;
double sum = 0.0;
for (i = 0; i < count; i++)
    sum += array[i];
return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %ebx, %ebx
movq %rdi, %rax
movb (%rax), %cl
testb %cl, %cl
je 0x36b3e
incq %rax
xorl %edx, %edx
cmpb $0x2c, %cl
sete %dl
addl %edx, %ebx
jmp 0x36b29
movl %ebx, %eax
incl %ebx
leaq 0x8(,%rax,8), %rdi
callq 0x28a1f
movq %rax, %r14
movq %r15, %rdi
callq 0x1c306
movq %rsp, %r12
movq %rax, (%r12)
movq %r15, %rdi
callq 0x1c306
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x36aaa
movl %eax, %ebx
movq %r12, %rdi
callq 0x28c3d
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
xorpd %xmm0, %xmm0
cmpq %rax, %rbx
je 0x36b9b
addsd (%r14,%rax,8), %xmm0
incq %rax
jmp 0x36b8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlFloatArray
int sqlFloatArray(char *s, float *array, int maxArraySize)
/* Convert comma separated list of floating point numbers to an array.  
 * Pass in array and max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == maxArraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = atof(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36c08
cmpb $0x0, (%r15)
je 0x36c08
cmpq %r14, %r12
je 0x36c08
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36beb
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x36bee
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx,%r14,4)
incq %r14
movq %r13, %r15
jmp 0x36bc1
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlDoubleStaticArray
void sqlDoubleStaticArray(char *s, double **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static double *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 64;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = atof(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36cc4
cmpb $0x0, (%r15)
je 0x36cc4
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36c64
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x36c67
xorl %r14d, %r14d
movl 0x81553(%rip), %eax     # 0xb81c0
movq 0x81544(%rip), %r12     # 0xb81b8
movl %r13d, %ebx
cmpl %eax, %r13d
jb 0x36cab
leal (%rax,%rax), %edx
testl %eax, %eax
pushq $0x40
popq %rax
cmovel %eax, %edx
movl %edx, 0x81533(%rip)     # 0xb81c0
leaq (,%rbx,8), %rsi
shlq $0x3, %rdx
movq %r12, %rdi
callq 0x28c1e
movq %rax, %r12
movq %rax, 0x8150d(%rip)     # 0xb81b8
movq %r15, %rdi
callq 0x6920
incl %r13d
movsd %xmm0, (%r12,%rbx,8)
movq %r14, %r15
jmp 0x36c3b
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x814e5(%rip), %rax     # 0xb81b8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlFloatStaticArray
void sqlFloatStaticArray(char *s, float **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static float *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    if (count >= alloc)
	{
	if (alloc == 0)
	    alloc = 128;
	else
	    alloc <<= 1;
	ExpandArray(array, count, alloc);
	}
    array[count++] = atof(s);
    s = e;
    }
*retSize = count;
*retArray = array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36d9e
cmpb $0x0, (%r15)
je 0x36d9e
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36d38
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x36d3b
xorl %r14d, %r14d
movl 0x8148f(%rip), %eax     # 0xb81d0
movq 0x81480(%rip), %r12     # 0xb81c8
movl %r13d, %ebx
cmpl %eax, %r13d
jb 0x36d81
leal (%rax,%rax), %edx
testl %eax, %eax
movl $0x80, %eax
cmovel %eax, %edx
movl %edx, 0x8146d(%rip)     # 0xb81d0
leaq (,%rbx,4), %rsi
shlq $0x2, %rdx
movq %r12, %rdi
callq 0x28c1e
movq %rax, %r12
movq %rax, 0x81447(%rip)     # 0xb81c8
movq %r15, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
incl %r13d
movss %xmm0, (%r12,%rbx,4)
movq %r14, %r15
jmp 0x36d0b
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x8141b(%rip), %rax     # 0xb81c8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: sqlDoubleDynamicArray
void sqlDoubleDynamicArray(char *s, double **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe.*/
{
double *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlDoubleInList(&s);
	    if (*s++ == 0)
		break;
	    if (*s == 0)
		break;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x36e39
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x36e41
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x36148
movsd %xmm0, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x36e34
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x36e06
incl %r12d
jmp 0x36e44
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x36e44
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq