LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutLoad
struct repeatMaskOut *repeatMaskOutLoad(char **row)
/* Load a repeatMaskOut from row fetched with select * from repeatMaskOut
 * from database.  Dispose of this with repeatMaskOutFree(). */
{
struct repeatMaskOut *ret;

AllocVar(ret);
ret->score = sqlUnsigned(row[0]);
ret->percDiv = atof(row[1]);
ret->percDel = atof(row[2]);
ret->percInc = atof(row[3]);
ret->qName = cloneString(row[4]);
ret->qStart = sqlSigned(row[5]);
ret->qEnd = sqlSigned(row[6]);
ret->qLeft = cloneString(row[7]);
strcpy(ret->strand, row[8]);
ret->rName = cloneString(row[9]);
ret->rFamily = cloneString(row[10]);
ret->rStart = cloneString(row[11]);
ret->rEnd = sqlUnsigned(row[12]);
ret->rLeft = cloneString(row[13]);
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x60, %edi
callq 0x2dc95
movq %rax, %rbx
movq (%r14), %rdi
callq 0x3b838
movl %eax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rbx)
movq 0x10(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
movq 0x20(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rdi
callq 0x3b9a8
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rdi
callq 0x3b9a8
movl %eax, 0x24(%rbx)
movq 0x38(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x6680
movq 0x48(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x38(%rbx)
movq 0x50(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x40(%rbx)
movq 0x58(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x48(%rbx)
movq 0x60(%r14), %rdi
callq 0x3b838
movl %eax, 0x50(%rbx)
movq 0x68(%r14), %rdi
callq 0x1f9f6
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0x60, %edi
callq 0x2dc95
movq %rax, %r15
movq %r14, %rdi
callq 0x3d6c3
movl %eax, 0x8(%r15)
movq %r14, %rdi
callq 0x3d6f2
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%r15)
movq %r14, %rdi
callq 0x3d6f2
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x10(%r15)
movq %r14, %rdi
callq 0x3d6f2
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x14(%r15)
movq %r14, %rdi
callq 0x3d7de
movq %rax, 0x18(%r15)
movq %r14, %rdi
callq 0x3d6f2
movl %eax, 0x20(%r15)
movq %r14, %rdi
callq 0x3d6f2
movl %eax, 0x24(%r15)
movq %r14, %rdi
callq 0x3d7de
movq %rax, 0x28(%r15)
leaq 0x30(%r15), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x3d884
movq %r14, %rdi
callq 0x3d7de
movq %rax, 0x38(%r15)
movq %r14, %rdi
callq 0x3d7de
movq %rax, 0x40(%r15)
movq %r14, %rdi
callq 0x3d7de
movq %rax, 0x48(%r15)
movq %r14, %rdi
callq 0x3d6c3
movl %eax, 0x50(%r15)
movq %r14, %rdi
callq 0x3d7de
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_O1/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 0x3b41a
movq %rdi, %rbx
movq 0x18(%r14), %rdi
callq 0x2dd41
movq 0x28(%r14), %rdi
callq 0x2dd41
movq 0x38(%r14), %rdi
callq 0x2dd41
movq 0x40(%r14), %rdi
callq 0x2dd41
movq 0x48(%r14), %rdi
callq 0x2dd41
movq 0x58(%r14), %rdi
callq 0x2dd41
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd51
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x3b455
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x3b3c6
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x3b440
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r9, 0x48(%rsp)
testb %al, %al
je 0x3b797
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)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb (%rdi), %al
leal -0x30(%rax), %ecx
xorl %ebx, %ebx
cmpb $0x9, %cl
ja 0x3b7d3
xorl %ebx, %ebx
movq %r10, %rcx
movzbl %al, %eax
leal (%rbx,%rbx,4), %edx
leal (%rax,%rdx,2), %ebx
addl $-0x30, %ebx
movb 0x1(%rcx), %al
incq %rcx
leal -0x30(%rax), %edx
cmpb $0xa, %dl
jb 0x3b7b7
jmp 0x3b7d6
movq %r10, %rcx
testb %al, %al
sete %al
cmpq %r10, %rcx
setne %cl
testb %al, %cl
jne 0x3b82d
testq %rsi, %rsi
je 0x3b81c
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 0x26c4a
jmp 0x3b82d
leaq 0x58e18(%rip), %rdi     # 0x9463b
movq %r10, %rsi
xorl %eax, %eax
callq 0x26b6f
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movb (%r14), %al
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
cmpb $0x9, %cl
ja 0x3b884
xorl %r15d, %r15d
movq %r14, %r12
movzbl %al, %eax
leal (%r15,%r15,4), %ecx
leal (%rax,%rcx,2), %r15d
addl $-0x30, %r15d
movb 0x1(%r12), %al
incq %r12
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x3b863
jmp 0x3b887
movq %r14, %r12
cmpb $0x2c, %al
je 0x3b892
movzbl %al, %eax
testl %eax, %eax
jne 0x3b897
cmpq %r14, %r12
jne 0x3b8bd
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3b8ac
movb $0x0, (%rax)
leaq 0x58d88(%rip), %rdi     # 0x9463b
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r12, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
leal -0x30(%rax), %ecx
xorl %ebx, %ebx
cmpb $0x9, %cl
ja 0x3b8ff
movq %rsi, %rcx
leaq (%rbx,%rbx,4), %rdx
andb $0xf, %al
movzbl %al, %eax
leaq (%rax,%rdx,2), %rbx
movb 0x1(%rcx), %al
incq %rcx
leal -0x30(%rax), %edx
cmpb $0xa, %dl
jb 0x3b8e2
jmp 0x3b902
movq %rsi, %rcx
testb %al, %al
sete %al
cmpq %rsi, %rcx
setne %cl
testb %al, %cl
jne 0x3b91f
leaq 0x58d42(%rip), %rdi     # 0x9465a
xorl %eax, %eax
callq 0x26b6f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%r14), %al
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
movq %r14, %r12
cmpb $0x9, %cl
ja 0x3b960
leaq (%r15,%r15,4), %rcx
andb $0xf, %al
movzbl %al, %eax
leaq (%rax,%rcx,2), %r15
movb 0x1(%r12), %al
incq %r12
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x3b943
cmpb $0x2c, %al
je 0x3b96b
movzbl %al, %eax
testl %eax, %eax
jne 0x3b970
cmpq %r14, %r12
jne 0x3b996
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3b985
movb $0x0, (%rax)
leaq 0x58cce(%rip), %rdi     # 0x9465a
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r12, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
cmpb $0x2d, (%rdi)
sete %cl
leaq (%rdi,%rcx), %rax
movb (%rdi,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r14d, %r14d
cmpb $0x9, %dl
ja 0x3b9ee
xorl %r14d, %r14d
movq %rax, %rdx
leal (%r14,%r14,4), %esi
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rsi,2), %r14d
movb 0x1(%rdx), %cl
incq %rdx
leal -0x30(%rcx), %esi
cmpb $0xa, %sil
jb 0x3b9cf
jmp 0x3b9f1
movq %rax, %rdx
testb %cl, %cl
sete %cl
cmpq %rax, %rdx
setne %al
testb %al, %cl
jne 0x3ba11
leaq 0x58c6f(%rip), %rdi     # 0x94676
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
movl %r14d, %eax
negl %eax
cmpb $0x2d, (%rbx)
cmovnel %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
xorl %ecx, %ecx
cmpb $0x2d, (%rbx)
sete %cl
leaq (%rbx,%rcx), %rax
movb (%rbx,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r15d, %r15d
cmpb $0x9, %dl
ja 0x3ba73
xorl %r15d, %r15d
movq %rax, %r12
leal (%r15,%r15,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %r15d
movb 0x1(%r12), %cl
incq %r12
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x3ba53
jmp 0x3ba76
movq %rax, %r12
cmpb $0x2c, %cl
je 0x3ba82
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x3ba87
cmpq %rax, %r12
jne 0x3baad
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3ba9c
movb $0x0, (%rax)
leaq 0x58bd3(%rip), %rdi     # 0x94676
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r12, (%r14)
movl %r15d, %eax
negl %eax
cmpb $0x2d, (%rbx)
cmovnel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ecx, %ecx
cmpb $0x2d, (%rdi)
sete %cl
leaq (%rdi,%rcx), %rax
movb (%rdi,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r14d, %r14d
cmpb $0x9, %dl
ja 0x3bb0b
movq %rax, %rdx
leaq (%r14,%r14,4), %rsi
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rsi,2), %r14
movb 0x1(%rdx), %cl
incq %rdx
leal -0x30(%rcx), %esi
cmpb $0xa, %sil
jb 0x3baec
jmp 0x3bb0e
movq %rax, %rdx
testb %cl, %cl
sete %cl
cmpq %rax, %rdx
setne %al
testb %al, %cl
jne 0x3bb2e
leaq 0x58b6f(%rip), %rdi     # 0x94693
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r14, %rax
negq %rax
cmpb $0x2d, (%rbx)
cmovneq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %ecx, %ecx
cmpb $0x2d, (%rbx)
sete %cl
leaq (%rbx,%rcx), %rax
movb (%rbx,%rcx), %cl
leal -0x30(%rcx), %edx
xorl %r15d, %r15d
movq %rax, %r12
cmpb $0x9, %dl
ja 0x3bb8c
leaq (%r15,%r15,4), %rdx
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rdx,2), %r15
movb 0x1(%r12), %cl
incq %r12
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x3bb6e
cmpb $0x2c, %cl
je 0x3bb98
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x3bb9d
cmpq %rax, %r12
jne 0x3bbc3
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bbb2
movb $0x0, (%rax)
leaq 0x58ada(%rip), %rdi     # 0x94693
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r12, (%r14)
movq %r15, %rax
negq %rax
cmpb $0x2d, (%rbx)
cmovneq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bc03
cmpb $0x0, (%rax)
je 0x3bc20
leaq 0x58aa8(%rip), %rdi     # 0x946b2
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x26b6f
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bc60
movzbl (%r15), %eax
testl %eax, %eax
je 0x3bc90
cmpl $0x2c, %eax
je 0x3bc90
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bc7a
movb $0x0, (%rax)
leaq 0x58a31(%rip), %rdi     # 0x946b2
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
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_O1/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 0x3bcc5
cmpb $0x0, (%rax)
je 0x3bce2
leaq 0x589f8(%rip), %rdi     # 0x946c4
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x26b6f
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bd1e
movzbl (%r15), %eax
testl %eax, %eax
je 0x3bd4e
cmpl $0x2c, %eax
je 0x3bd4e
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bd38
movb $0x0, (%rax)
leaq 0x58985(%rip), %rdi     # 0x946c4
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movsd (%rsp), %xmm0
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3bd87
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3bd8b
xorl %eax, %eax
jmp 0x3bdc2
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bda8
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3bdab
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3b9a8
movl %r15d, %ecx
incl %r15d
movb %al, (%r14,%rcx)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3bd70
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
testq %r15, %r15
je 0x3be18
cmpb $0x0, (%r15)
je 0x3be18
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3be1f
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3be21
xorl %eax, %eax
movq %r15, %rbx
jmp 0x3be6b
xorl %ebx, %ebx
movl 0x88329(%rip), %eax     # 0xc4150
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3be53
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x88313(%rip)     # 0xc4150
movq 0x88304(%rip), %rdi     # 0xc4148
movq %r12, %rsi
callq 0x2dd03
movq %rax, 0x882f5(%rip)     # 0xc4148
movq %r15, %rdi
callq 0x3b9a8
movq 0x882e6(%rip), %rcx     # 0xc4148
incl %r13d
movb %al, (%rcx,%r12)
movb $0x1, %al
movq %rbx, %r15
testb %al, %al
jne 0x3bdf0
movl %r13d, (%r14)
movq 0x882c8(%rip), %rax     # 0xc4148
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bf07
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3bf0f
movl %r12d, %edi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3ba25
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3bf02
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3bed6
incl %r12d
jmp 0x3bf12
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3bf12
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3bf51
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3bf55
xorl %eax, %eax
jmp 0x3bf8c
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bf72
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3bf75
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3b838
movl %r15d, %ecx
incl %r15d
movb %al, (%r14,%rcx)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3bf3a
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
testq %r15, %r15
je 0x3bfe2
cmpb $0x0, (%r15)
je 0x3bfe2
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3bfe9
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3bfeb
xorl %eax, %eax
movq %r15, %rbx
jmp 0x3c035
xorl %ebx, %ebx
movl 0x8816f(%rip), %eax     # 0xc4160
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3c01d
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x88159(%rip)     # 0xc4160
movq 0x8814a(%rip), %rdi     # 0xc4158
movq %r12, %rsi
callq 0x2dd03
movq %rax, 0x8813b(%rip)     # 0xc4158
movq %r15, %rdi
callq 0x3b838
movq 0x8812c(%rip), %rcx     # 0xc4158
incl %r13d
movb %al, (%rcx,%r12)
movb $0x1, %al
movq %rbx, %r15
testb %al, %al
jne 0x3bfba
movl %r13d, (%r14)
movq 0x8810e(%rip), %rax     # 0xc4158
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c0d1
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3c0d9
movl %r12d, %edi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3b841
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c0cc
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3c0a0
incl %r12d
jmp 0x3c0dc
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3c0dc
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3c11a
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3c11e
xorl %eax, %eax
jmp 0x3c150
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c13b
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x3c13d
xorl %ecx, %ecx
movb (%r12), %al
movl %r15d, %edx
incl %r15d
movb %al, (%r14,%rdx)
movb $0x1, %al
movq %rcx, %r12
testb %al, %al
jne 0x3c103
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
testq %r15, %r15
je 0x3c1a8
cmpb $0x0, (%r15)
je 0x3c1a8
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c1af
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3c1b1
xorl %eax, %eax
movq %r15, %rbx
jmp 0x3c1f6
xorl %ebx, %ebx
movl 0x87fb9(%rip), %eax     # 0xc4170
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3c1e3
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87fa3(%rip)     # 0xc4170
movq 0x87f94(%rip), %rdi     # 0xc4168
movq %r12, %rsi
callq 0x2dd03
movq %rax, 0x87f85(%rip)     # 0xc4168
movb (%r15), %al
movq 0x87f7b(%rip), %rcx     # 0xc4168
incl %r13d
movb %al, (%rcx,%r12)
movb $0x1, %al
movq %rbx, %r15
testb %al, %al
jne 0x3c180
movl %r13d, (%r14)
movq 0x87f61(%rip), %rax     # 0xc4168
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c2d3
movq %rdi, %r13
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3c2db
movl %r12d, %edi
callq 0x2db04
movq %rax, %r15
leaq 0x58476(%rip), %rbp     # 0x946d7
xorl %ecx, %ecx
movq %rcx, %r12
cmpb $0x2c, (%r13)
jne 0x3c277
movq %rbp, %rdi
xorl %eax, %eax
callq 0x26b6f
leaq 0x1(%r13), %rax
movb (%r13), %cl
movb %cl, (%r15,%r12)
movzbl 0x1(%r13), %ecx
testl %ecx, %ecx
je 0x3c2ba
cmpl $0x2c, %ecx
je 0x3c2ba
movq %r13, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c2a6
movb $0x0, (%rax)
leaq 0x5846c(%rip), %rdi     # 0x94719
movq %r13, %rsi
xorl %eax, %eax
callq 0x26b6f
movq %r13, %rax
cmpb $0x0, (%rax)
je 0x3c2ce
leaq 0x1(%rax), %r13
leaq 0x1(%r12), %rcx
cmpb $0x0, 0x1(%rax)
jne 0x3c263
incl %r12d
jmp 0x3c2de
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3c2de
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3c31e
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3c322
xorl %eax, %eax
jmp 0x3c35a
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c33f
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c342
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3b9a8
movl %r15d, %ecx
incl %r15d
movw %ax, (%r14,%rcx,2)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3c307
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3c3b0
cmpb $0x0, (%r15)
je 0x3c3b0
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c3b7
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c3ba
xorl %eax, %eax
movq %r15, %r13
jmp 0x3c408
xorl %r13d, %r13d
movl 0x87dc0(%rip), %eax     # 0xc4180
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c3f0
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87daa(%rip)     # 0xc4180
movq 0x87d9b(%rip), %rdi     # 0xc4178
leaq (%rbx,%rbx), %rsi
addq %rdx, %rdx
callq 0x2dd03
movq %rax, 0x87d88(%rip)     # 0xc4178
movq %r15, %rdi
callq 0x3b9a8
movq 0x87d79(%rip), %rcx     # 0xc4178
incl %r12d
movw %ax, (%rcx,%rbx,2)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3c388
movl %r12d, (%r14)
movq 0x87d5b(%rip), %rax     # 0xc4178
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c4a7
movl $0x2c, %esi
callq 0x22225
movl %eax, %r15d
testl %eax, %eax
jle 0x3c4af
addl %r15d, %r15d
movq %r15, %rdi
callq 0x2db04
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x3ba25
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c4a2
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x3c476
incl %r15d
jmp 0x3c4b2
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x3c4b2
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_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3c583
cmpb $0x0, (%r15)
je 0x3c583
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c58a
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c58d
xorl %eax, %eax
movq %r15, %r13
jmp 0x3c5db
xorl %r13d, %r13d
movl 0x87bfd(%rip), %eax     # 0xc4190
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c5c3
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87be7(%rip)     # 0xc4190
movq 0x87bd8(%rip), %rdi     # 0xc4188
leaq (%rbx,%rbx), %rsi
addq %rdx, %rdx
callq 0x2dd03
movq %rax, 0x87bc5(%rip)     # 0xc4188
movq %r15, %rdi
callq 0x3b838
movq 0x87bb6(%rip), %rcx     # 0xc4188
incl %r12d
movw %ax, (%rcx,%rbx,2)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3c55b
movl %r12d, (%r14)
movq 0x87b98(%rip), %rax     # 0xc4188
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c67a
movl $0x2c, %esi
callq 0x22225
movl %eax, %r15d
testl %eax, %eax
jle 0x3c682
addl %r15d, %r15d
movq %r15, %rdi
callq 0x2db04
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x3b841
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c675
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x3c649
incl %r15d
jmp 0x3c685
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x3c685
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3c6c4
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3c6c8
xorl %eax, %eax
jmp 0x3c701
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c6e5
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c6e8
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x6920
movl %r15d, %eax
incl %r15d
movsd %xmm0, (%r14,%rax,8)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3c6ad
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x3c73f
leaq 0x1(%rbx), %rax
xorl %ebp, %ebp
xorl %edx, %edx
cmpb $0x2c, %cl
sete %dl
addl %edx, %ebp
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x3c728
incl %ebp
jmp 0x3c744
movl $0x1, %ebp
movl %ebp, %edi
shlq $0x3, %rdi
callq 0x2db04
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f9f6
movq %rsp, %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x1f9f6
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3c699
movl %eax, %ebx
movq %r15, %rdi
callq 0x2dd51
testl %ebx, %ebx
jle 0x3c79b
movl %ebx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%r14,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x3c78b
jmp 0x3c79f
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3c7d5
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3c7d9
xorl %eax, %eax
jmp 0x3c816
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c7f6
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c7f9
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movl %r15d, %eax
incl %r15d
movss %xmm0, (%r14,%rax,4)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3c7be
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3c86c
cmpb $0x0, (%r15)
je 0x3c86c
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c873
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c876
xorl %eax, %eax
movq %r15, %r13
jmp 0x3c8ca
xorl %r13d, %r13d
movl 0x87924(%rip), %eax     # 0xc41a0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c8b1
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x8790e(%rip)     # 0xc41a0
movq 0x878ff(%rip), %rdi     # 0xc4198
leaq (,%rbx,8), %rsi
shlq $0x3, %rdx
callq 0x2dd03
movq %rax, 0x878e7(%rip)     # 0xc4198
movq %r15, %rdi
callq 0x6920
movq 0x878d8(%rip), %rax     # 0xc4198
incl %r12d
movsd %xmm0, (%rax,%rbx,8)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3c844
movl %r12d, (%r14)
movq 0x878b9(%rip), %rax     # 0xc4198
movq (%rsp), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq