LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3c015
movzbl (%r15), %eax
testl %eax, %eax
je 0x3c045
cmpl $0x2c, %eax
je 0x3c045
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c02f
movb $0x0, (%rax)
leaq 0x5874f(%rip), %rdi     # 0x94785
movq %r14, %rsi
xorl %eax, %eax
callq 0x26e94
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_O3/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 0x3c07a
cmpb $0x0, (%rax)
je 0x3c097
leaq 0x58716(%rip), %rdi     # 0x94797
movq %rbx, %rsi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x26e94
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c0d3
movzbl (%r15), %eax
testl %eax, %eax
je 0x3c103
cmpl $0x2c, %eax
je 0x3c103
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c0ed
movb $0x0, (%rax)
leaq 0x586a3(%rip), %rdi     # 0x94797
movq %r14, %rsi
xorl %eax, %eax
callq 0x26e94
movsd (%rsp), %xmm0
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x3c16d
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3c16f
cmpq %rbx, %r12
je 0x3c16f
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c151
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c154
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3bd74
movb %al, (%r14,%rbx)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3c129
jmp 0x3c16f
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
testq %rdi, %rdi
je 0x3c218
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3c21b
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c1c4
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3c1c6
xorl %ebx, %ebx
movl 0x87f84(%rip), %eax     # 0xc4150
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3c1f8
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87f6e(%rip)     # 0xc4150
movq 0x87f5f(%rip), %rdi     # 0xc4148
movq %r12, %rsi
callq 0x2e062
movq %rax, 0x87f50(%rip)     # 0xc4148
movq %r15, %rdi
callq 0x3bd74
movq 0x87f41(%rip), %rcx     # 0xc4148
incl %r13d
movb %al, (%rcx,%r12)
movq %rbx, %r15
testq %rbx, %rbx
jne 0x3c1a1
jmp 0x3c21b
xorl %r13d, %r13d
movl %r13d, (%r14)
movq 0x87f23(%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_O3/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 0x3c2ac
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3c2b4
movl %r12d, %edi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bde3
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c2a7
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3c27b
incl %r12d
jmp 0x3c2b7
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3c2b7
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_O3/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
testq %rdi, %rdi
je 0x3c328
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3c32a
cmpq %rbx, %r12
je 0x3c32a
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c30c
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c30f
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3bc10
movb %al, (%r14,%rbx)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3c2e4
jmp 0x3c32a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
testq %rdi, %rdi
je 0x3c3d3
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3c3d6
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c37f
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3c381
xorl %ebx, %ebx
movl 0x87dd9(%rip), %eax     # 0xc4160
movl %r13d, %r12d
cmpl %eax, %r13d
jb 0x3c3b3
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87dc3(%rip)     # 0xc4160
movq 0x87db4(%rip), %rdi     # 0xc4158
movq %r12, %rsi
callq 0x2e062
movq %rax, 0x87da5(%rip)     # 0xc4158
movq %r15, %rdi
callq 0x3bc10
movq 0x87d96(%rip), %rcx     # 0xc4158
incl %r13d
movb %al, (%rcx,%r12)
movq %rbx, %r15
testq %rbx, %rbx
jne 0x3c35c
jmp 0x3c3d6
xorl %r13d, %r13d
movl %r13d, (%r14)
movq 0x87d78(%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_O3/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 0x3c467
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3c46f
movl %r12d, %edi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bc19
movb %al, (%r15,%r12)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c462
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3c436
incl %r12d
jmp 0x3c472
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3c472
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_O3/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:
testq %rdi, %rdi
je 0x3c4ac
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movb (%rdi), %bpl
testb %bpl, %bpl
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
je 0x3c4af
xorl %eax, %eax
jmp 0x3c502
xorl %eax, %eax
retq
movq %rsi, %rbx
movl %edx, %r15d
decq %r15
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c4f8
movq %rax, %rcx
movb $0x0, (%rax)
movb (%r14), %dl
leaq 0x1(%r12), %rax
movb %dl, (%rbx,%r12)
movb 0x1(%rcx), %bpl
testb %bpl, %bpl
je 0x3c502
incq %rcx
movq %rcx, %r14
cmpq %r12, %r15
movq %rax, %r12
jne 0x3c4bb
jmp 0x3c502
movb %bpl, (%rbx,%r12)
incq %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
testq %rdi, %rdi
je 0x3c59b
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3c59e
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c550
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3c552
xorl %ebx, %ebx
movl 0x87c18(%rip), %ecx     # 0xc4170
movq 0x87c09(%rip), %rax     # 0xc4168
movl %r13d, %r12d
cmpl %ecx, %r13d
jb 0x3c587
leal (%rcx,%rcx), %edx
testl %ecx, %ecx
cmovel %ebp, %edx
movl %edx, 0x87bfb(%rip)     # 0xc4170
movq %rax, %rdi
movq %r12, %rsi
callq 0x2e062
movq %rax, 0x87be1(%rip)     # 0xc4168
movb (%r15), %cl
incl %r13d
movb %cl, (%rax,%r12)
movq %rbx, %r15
testq %rbx, %rbx
jne 0x3c52d
jmp 0x3c59e
xorl %r13d, %r13d
movl %r13d, (%r14)
movq 0x87bc0(%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_O3/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 0x3c67b
movq %rdi, %r13
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3c683
movl %r12d, %edi
callq 0x2de63
movq %rax, %r15
movb (%r13), %al
leaq 0x581a4(%rip), %rbp     # 0x947aa
xorl %edx, %edx
movq %rdx, %r12
cmpb $0x2c, %al
jne 0x3c61d
movq %rbp, %rdi
xorl %eax, %eax
callq 0x26e94
movb (%r13), %al
leaq 0x1(%r13), %rcx
movb %al, (%r15,%r12)
movzbl 0x1(%r13), %eax
testl %eax, %eax
je 0x3c660
cmpl $0x2c, %eax
je 0x3c660
movq %r13, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c648
movb $0x0, (%rax)
leaq 0x5819d(%rip), %rdi     # 0x947ec
movq %r13, %rsi
xorl %eax, %eax
callq 0x26e94
movb (%r13), %al
movq %r13, %rcx
testb %al, %al
je 0x3c676
movb 0x1(%rcx), %al
incq %rcx
leaq 0x1(%r12), %rdx
movq %rcx, %r13
testb %al, %al
jne 0x3c608
incl %r12d
jmp 0x3c686
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3c686
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_O3/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
testq %rdi, %rdi
je 0x3c6f9
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3c6fb
cmpq %rbx, %r12
je 0x3c6fb
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c6dc
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c6df
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3bd74
movw %ax, (%r14,%rbx,2)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3c6b4
jmp 0x3c6fb
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
testq %rdi, %rdi
je 0x3c7a9
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3c7ac
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c750
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c753
xorl %r13d, %r13d
movl 0x87a27(%rip), %eax     # 0xc4180
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c789
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87a11(%rip)     # 0xc4180
movq 0x87a02(%rip), %rdi     # 0xc4178
leaq (%rbx,%rbx), %rsi
addq %rdx, %rdx
callq 0x2e062
movq %rax, 0x879ef(%rip)     # 0xc4178
movq %r15, %rdi
callq 0x3bd74
movq 0x879e0(%rip), %rcx     # 0xc4178
incl %r12d
movw %ax, (%rcx,%rbx,2)
movq %r13, %r15
testq %r13, %r13
jne 0x3c72d
jmp 0x3c7ac
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x879c2(%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_O3/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 0x3c840
movl $0x2c, %esi
callq 0x22578
movl %eax, %r15d
testl %eax, %eax
jle 0x3c848
addl %r15d, %r15d
movq %r15, %rdi
callq 0x2de63
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x3bde3
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c83b
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x3c80f
incl %r15d
jmp 0x3c84b
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x3c84b
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_O3/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)
testq %rdi, %rdi
je 0x3c96d
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3c970
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c914
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c917
xorl %r13d, %r13d
movl 0x87873(%rip), %eax     # 0xc4190
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c94d
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x8785d(%rip)     # 0xc4190
movq 0x8784e(%rip), %rdi     # 0xc4188
leaq (%rbx,%rbx), %rsi
addq %rdx, %rdx
callq 0x2e062
movq %rax, 0x8783b(%rip)     # 0xc4188
movq %r15, %rdi
callq 0x3bc10
movq 0x8782c(%rip), %rcx     # 0xc4188
incl %r12d
movw %ax, (%rcx,%rbx,2)
movq %r13, %r15
testq %r13, %r13
jne 0x3c8f1
jmp 0x3c970
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x8780e(%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_O3/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 0x3ca04
movl $0x2c, %esi
callq 0x22578
movl %eax, %r15d
testl %eax, %eax
jle 0x3ca0c
addl %r15d, %r15d
movq %r15, %rdi
callq 0x2de63
movq %rax, %r12
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r15
movq %r13, %rdi
callq 0x3bc19
movw %ax, (%r12,%r15,2)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3c9ff
leaq 0x1(%r15), %rax
cmpb $0x0, (%rcx)
jne 0x3c9d3
incl %r15d
jmp 0x3ca0f
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0x3ca0f
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_O3/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
testq %rdi, %rdi
je 0x3ca82
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3ca84
cmpq %rbx, %r12
je 0x3ca84
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3ca64
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3ca67
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x6920
movsd %xmm0, (%r14,%rbx,8)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3ca3c
jmp 0x3ca84
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3cabd
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 0x3caa6
incl %ebp
jmp 0x3cac2
movl $0x1, %ebp
movl %ebp, %edi
shlq $0x3, %rdi
callq 0x2de63
movq %rax, %r14
movq %rbx, %rdi
callq 0x1feba
movq %rsp, %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x1feba
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3ca23
movl %eax, %ebx
movq %r15, %rdi
callq 0x2e0b0
testl %ebx, %ebx
jle 0x3cb19
movl %ebx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%r14,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x3cb09
jmp 0x3cb1d
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x3cb8b
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3cb8d
cmpq %rbx, %r12
je 0x3cb8d
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cb69
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cb6c
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14,%rbx,4)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3cb41
jmp 0x3cb8d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
testq %rdi, %rdi
je 0x3cc46
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3cc49
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cbe8
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3cbea
xorl %ebx, %ebx
movl 0x875b0(%rip), %eax     # 0xc41a0
movq 0x875a1(%rip), %r12     # 0xc4198
movl %r13d, %r14d
cmpl %eax, %r13d
jb 0x3cc2b
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87593(%rip)     # 0xc41a0
leaq (,%r14,8), %rsi
shlq $0x3, %rdx
movq %r12, %rdi
callq 0x2e062
movq %rax, %r12
movq %rax, 0x8756d(%rip)     # 0xc4198
movq %r15, %rdi
callq 0x6920
incl %r13d
movsd %xmm0, (%r12,%r14,8)
movq %rbx, %r15
testq %rbx, %rbx
jne 0x3cbc5
jmp 0x3cc49
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x87540(%rip), %rax     # 0xc4198
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_O3/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)
testq %rdi, %rdi
je 0x3cd28
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x80, %ebp
cmpb $0x0, (%r15)
je 0x3cd2b
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3ccc2
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x3ccc4
xorl %ebx, %ebx
movl 0x874e6(%rip), %eax     # 0xc41b0
movq 0x874d7(%rip), %r12     # 0xc41a8
movl %r13d, %r14d
cmpl %eax, %r13d
jb 0x3cd05
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x874c9(%rip)     # 0xc41b0
leaq (,%r14,4), %rsi
shlq $0x2, %rdx
movq %r12, %rdi
callq 0x2e062
movq %rax, %r12
movq %rax, 0x874a3(%rip)     # 0xc41a8
movq %r15, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
incl %r13d
movss %xmm0, (%r12,%r14,4)
movq %rbx, %r15
testq %rbx, %rbx
jne 0x3cc9b
jmp 0x3cd2b
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x8746e(%rip), %rax     # 0xc41a8
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_O3/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 0x3cdc8
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3cdd0
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3c09f
movsd %xmm0, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3cdc3
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3cd95
incl %r12d
jmp 0x3cdd3
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3cdd3
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlFloatDynamicArray
void sqlFloatDynamicArray(char *s, float **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
float *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlFloatInList(&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 0x3ce5e
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3ce66
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bfe1
movss %xmm0, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3ce59
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3ce2b
incl %r12d
jmp 0x3ce69
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3ce69
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlUnsignedArray
int sqlUnsignedArray(char *s, unsigned *array, int arraySize)
/* Convert comma separated list of 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 == 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
testq %rdi, %rdi
je 0x3ceda
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3cedc
cmpq %rbx, %r12
je 0x3cedc
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cebe
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cec1
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3bc10
movl %eax, (%r14,%rbx,4)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3ce96
jmp 0x3cedc
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlUnsignedStaticArray
void sqlUnsignedStaticArray(char *s, unsigned **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 *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)
testq %rdi, %rdi
je 0x3cf8e
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3cf91
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cf31
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cf34
xorl %r13d, %r13d
movl 0x87286(%rip), %eax     # 0xc41c0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3cf6f
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87270(%rip)     # 0xc41c0
movq 0x87261(%rip), %rdi     # 0xc41b8
leaq (,%rbx,4), %rsi
shlq $0x2, %rdx
callq 0x2e062
movq %rax, 0x87249(%rip)     # 0xc41b8
movq %r15, %rdi
callq 0x3bc10
movq 0x8723a(%rip), %rcx     # 0xc41b8
incl %r12d
movl %eax, (%rcx,%rbx,4)
movq %r13, %r15
testq %r13, %r13
jne 0x3cf0e
jmp 0x3cf91
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x8721d(%rip), %rax     # 0xc41b8
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlUnsignedDynamicArray
void sqlUnsignedDynamicArray(char *s, unsigned **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
unsigned *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 0x3d026
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3d02e
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bc19
movl %eax, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3d021
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3cff5
incl %r12d
jmp 0x3d031
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3d031
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlSignedArray
int sqlSignedArray(char *s, int *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
int 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
testq %rdi, %rdi
je 0x3d0a2
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3d0a4
cmpq %rbx, %r12
je 0x3d0a4
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d086
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d089
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3bd74
movl %eax, (%r14,%rbx,4)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3d05e
jmp 0x3d0a4
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlSignedStaticArray
void sqlSignedStaticArray(char *s, int **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 int *array = NULL;
static int alloc = 0;
int 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, %rbx
testq %rdi, %rdi
je 0x3d157
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3d15a
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d0f8
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d0fb
xorl %r13d, %r13d
movslq 0x870ce(%rip), %rax     # 0xc41d0
cmpq %rax, %r12
jl 0x3d137
leal (%rax,%rax), %ecx
testl %eax, %eax
cmovel %ebp, %ecx
movl %ecx, 0x870bb(%rip)     # 0xc41d0
movq 0x870ac(%rip), %rdi     # 0xc41c8
leaq (,%r12,4), %rsi
movslq %ecx, %rdx
shlq $0x2, %rdx
callq 0x2e062
movq %rax, 0x87091(%rip)     # 0xc41c8
movq %r15, %rdi
callq 0x3bd74
movq 0x87082(%rip), %rcx     # 0xc41c8
movl %eax, (%rcx,%r12,4)
incq %r12
movq %r13, %r15
testq %r13, %r13
jne 0x3d0d5
jmp 0x3d15a
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x87064(%rip), %rax     # 0xc41c8
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlLongLongArray
int sqlLongLongArray(char *s, long long *array, int arraySize)
/* Convert comma separated list of 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 == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlLongLong(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3d267
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x3d269
cmpq %rbx, %r12
je 0x3d269
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d24b
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d24e
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3be86
movq %rax, (%r14,%rbx,8)
incq %rbx
movq %r13, %r15
testq %r13, %r13
jne 0x3d223
jmp 0x3d269
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlLongLongStaticArray
void sqlLongLongStaticArray(char *s, long long **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 long long *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++] = sqlLongLong(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)
testq %rdi, %rdi
je 0x3d31c
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3d31f
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d2be
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d2c1
xorl %r13d, %r13d
movl 0x86f19(%rip), %eax     # 0xc41e0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3d2fc
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x86f03(%rip)     # 0xc41e0
movq 0x86ef4(%rip), %rdi     # 0xc41d8
leaq (,%rbx,8), %rsi
shlq $0x3, %rdx
callq 0x2e062
movq %rax, 0x86edc(%rip)     # 0xc41d8
movq %r15, %rdi
callq 0x3be86
movq 0x86ecd(%rip), %rcx     # 0xc41d8
incl %r12d
movq %rax, (%rcx,%rbx,8)
movq %r13, %r15
testq %r13, %r13
jne 0x3d29b
jmp 0x3d31f
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x86eaf(%rip), %rax     # 0xc41d8
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlLongLongDynamicArray
void sqlLongLongDynamicArray(char *s, long long **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
long long *array = NULL;
int count = 0;

if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	for (;;)
	    {
	    array[count++] = sqlLongLongInList(&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 0x3d3b4
movl $0x2c, %esi
callq 0x22578
movl %eax, %r12d
testl %eax, %eax
jle 0x3d3bc
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x2de63
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bef8
movq %rax, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3d3af
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3d383
incl %r12d
jmp 0x3d3bf
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3d3bf
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_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlStringArray
int sqlStringArray(char *s, char **array, int maxArraySize)
/* Convert comma separated list of strings to an array.  Pass in 
 * array and max size of array.  Returns actual size*/
{
int count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == maxArraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = s;
    s = e;
    }
return count;
}

// Assembly:
testq %rdi, %rdi
je 0x3d3f6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, (%rdi)
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
je 0x3d3f9
xorl %eax, %eax
jmp 0x3d446
xorl %eax, %eax
retq
movq %rsi, %rbx
movl %edx, %r15d
decq %r15
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d43c
movq %rax, %rcx
movb $0x0, (%rax)
leaq 0x1(%r12), %rax
movq %r14, (%rbx,%r12,8)
cmpb $0x0, 0x1(%rcx)
je 0x3d446
incq %rcx
movq %rcx, %r14
cmpq %r12, %r15
movq %rax, %r12
jne 0x3d405
jmp 0x3d446
movq %r14, (%rbx,%r12,8)
incq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/sqlList.c
// Function: sqlStringStaticArray
void sqlStringStaticArray(char *s, char  ***retArray, int *retSize)
/* Convert comma separated list of strings to an array which will be
 * overwritten next call to this function,  but need not be freed. */
{
static char **array = NULL;
static int alloc = 0;
int 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;
    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, %rbx
testq %rdi, %rdi
je 0x3d4ed
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
cmpb $0x0, (%r15)
je 0x3d4f0
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d49a
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d49d
xorl %r13d, %r13d
movslq 0x86d4c(%rip), %rcx     # 0xc41f0
movq 0x86d3d(%rip), %rax     # 0xc41e8
cmpq %rcx, %r12
jl 0x3d4dc
leal (%rcx,%rcx), %edx
testl %ecx, %ecx
cmovel %ebp, %edx
movl %edx, 0x86d32(%rip)     # 0xc41f0
leaq (,%r12,8), %rsi
movslq %edx, %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x2e062
movq %rax, 0x86d0c(%rip)     # 0xc41e8
movq %r15, (%rax,%r12,8)
incq %r12
movq %r13, %r15
testq %r13, %r13
jne 0x3d477
jmp 0x3d4f0
xorl %r12d, %r12d
movl %r12d, (%r14)
movq 0x86cee(%rip), %rax     # 0xc41e8
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq