LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x80, %ebp
testq %r15, %r15
je 0x3c93a
cmpb $0x0, (%r15)
je 0x3c93a
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3c941
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3c944
xorl %eax, %eax
movq %r15, %r13
jmp 0x3c99c
xorl %r13d, %r13d
movl 0x87866(%rip), %eax     # 0xc41b0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3c97f
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87850(%rip)     # 0xc41b0
movq 0x87841(%rip), %rdi     # 0xc41a8
leaq (,%rbx,4), %rsi
shlq $0x2, %rdx
callq 0x2dd03
movq %rax, 0x87829(%rip)     # 0xc41a8
movq %r15, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
movq 0x87816(%rip), %rax     # 0xc41a8
incl %r12d
movss %xmm0, (%rax,%rbx,4)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3c912
movl %r12d, (%r14)
movq 0x877f7(%rip), %rax     # 0xc41a8
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: 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 0x3ca3e
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3ca46
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bcea
movsd %xmm0, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3ca39
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3ca0b
incl %r12d
jmp 0x3ca49
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3ca49
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: 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 0x3cad4
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3cadc
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bc2c
movss %xmm0, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3cacf
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3caa1
incl %r12d
jmp 0x3cadf
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3cadf
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: 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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3cb1e
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3cb22
xorl %eax, %eax
jmp 0x3cb59
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cb3f
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cb42
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3b838
movl %r15d, %ecx
incl %r15d
movl %eax, (%r14,%rcx,4)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3cb07
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: 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)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3cbaf
cmpb $0x0, (%r15)
je 0x3cbaf
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cbb6
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cbb9
xorl %eax, %eax
movq %r15, %r13
jmp 0x3cc0b
xorl %r13d, %r13d
movl 0x87601(%rip), %eax     # 0xc41c0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3cbf4
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x875eb(%rip)     # 0xc41c0
movq 0x875dc(%rip), %rdi     # 0xc41b8
leaq (,%rbx,4), %rsi
shlq $0x2, %rdx
callq 0x2dd03
movq %rax, 0x875c4(%rip)     # 0xc41b8
movq %r15, %rdi
callq 0x3b838
movq 0x875b5(%rip), %rcx     # 0xc41b8
incl %r12d
movl %eax, (%rcx,%rbx,4)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3cb87
movl %r12d, (%r14)
movq 0x87598(%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_O1/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 0x3ccab
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3ccb3
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3b841
movl %eax, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3cca6
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3cc7a
incl %r12d
jmp 0x3ccb6
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3ccb6
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: 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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3ccf5
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3ccf9
xorl %eax, %eax
jmp 0x3cd30
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cd16
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cd19
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3b9a8
movslq %r15d, %rcx
incl %r15d
movl %eax, (%r14,%rcx,4)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3ccde
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: 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, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3cd86
cmpb $0x0, (%r15)
je 0x3cd86
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cd8d
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cd90
xorl %eax, %eax
movq %r15, %r13
jmp 0x3cde6
xorl %r13d, %r13d
movl 0x8743a(%rip), %eax     # 0xc41d0
movslq %r12d, %rbx
cmpl %eax, %r12d
jl 0x3cdce
leal (%rax,%rax), %ecx
testl %eax, %eax
cmovel %ebp, %ecx
movl %ecx, 0x87424(%rip)     # 0xc41d0
movq 0x87415(%rip), %rdi     # 0xc41c8
leaq (,%rbx,4), %rsi
movslq %ecx, %rdx
shlq $0x2, %rdx
callq 0x2dd03
movq %rax, 0x873fa(%rip)     # 0xc41c8
movq %r15, %rdi
callq 0x3b9a8
movq 0x873eb(%rip), %rcx     # 0xc41c8
leal 0x1(%rbx), %r12d
movl %eax, (%rcx,%rbx,4)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3cd5e
movl %r12d, (%r14)
movq 0x873cd(%rip), %rax     # 0xc41c8
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: 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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x3ced0
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3ced4
xorl %eax, %eax
jmp 0x3cf0b
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cef1
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cef4
xorl %r13d, %r13d
movq %r12, %rdi
callq 0x3bac8
movl %r15d, %ecx
incl %r15d
movq %rax, (%r14,%rcx,8)
movb $0x1, %al
movq %r13, %r12
testb %al, %al
jne 0x3ceb9
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: 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)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3cf61
cmpb $0x0, (%r15)
je 0x3cf61
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3cf68
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3cf6b
xorl %eax, %eax
movq %r15, %r13
jmp 0x3cfbe
xorl %r13d, %r13d
movl 0x8726f(%rip), %eax     # 0xc41e0
movl %r12d, %ebx
cmpl %eax, %r12d
jb 0x3cfa6
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %ebp, %edx
movl %edx, 0x87259(%rip)     # 0xc41e0
movq 0x8724a(%rip), %rdi     # 0xc41d8
leaq (,%rbx,8), %rsi
shlq $0x3, %rdx
callq 0x2dd03
movq %rax, 0x87232(%rip)     # 0xc41d8
movq %r15, %rdi
callq 0x3bac8
movq 0x87223(%rip), %rcx     # 0xc41d8
incl %r12d
movq %rax, (%rcx,%rbx,8)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3cf39
movl %r12d, (%r14)
movq 0x87205(%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_O1/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 0x3d05e
movl $0x2c, %esi
callq 0x22225
movl %eax, %r12d
testl %eax, %eax
jle 0x3d066
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x2db04
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3bb43
movq %rax, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x3d059
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x3d02d
incl %r12d
jmp 0x3d069
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x3d069
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: 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:
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 0x3d0a7
cmpb $0x0, (%r12)
sete %al
cmpl %ebx, %r15d
sete %cl
orb %al, %cl
je 0x3d0ab
xorl %eax, %eax
jmp 0x3d0d9
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d0c8
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x3d0ca
xorl %ecx, %ecx
movslq %r15d, %rax
incl %r15d
movq %r12, (%r14,%rax,8)
movb $0x1, %al
movq %rcx, %r12
testb %al, %al
jne 0x3d090
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: 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, (%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x40, %ebp
testq %r15, %r15
je 0x3d131
cmpb $0x0, (%r15)
je 0x3d131
movq %r15, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d138
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x3d13b
xorl %eax, %eax
movq %r15, %r13
jmp 0x3d18a
xorl %r13d, %r13d
movl 0x870af(%rip), %eax     # 0xc41f0
movslq %r12d, %rbx
cmpl %eax, %r12d
jl 0x3d179
leal (%rax,%rax), %ecx
testl %eax, %eax
cmovel %ebp, %ecx
movl %ecx, 0x87099(%rip)     # 0xc41f0
movq 0x8708a(%rip), %rdi     # 0xc41e8
leaq (,%rbx,8), %rsi
movslq %ecx, %rdx
shlq $0x3, %rdx
callq 0x2dd03
movq %rax, 0x8706f(%rip)     # 0xc41e8
movq 0x87068(%rip), %rax     # 0xc41e8
leal 0x1(%rbx), %r12d
movq %r15, (%rax,%rbx,8)
movb $0x1, %al
movq %r13, %r15
testb %al, %al
jne 0x3d109
movl %r12d, (%r14)
movq 0x87049(%rip), %rax     # 0xc41e8
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: sqlStringDynamicArray
void sqlStringDynamicArray(char *s, char ***retArray, int *retSize)
/* Convert comma separated list of strings to an dynamically allocated
 * array, which should be freeMem()'d when done. As a speed option all
 * of the elements in the array are needMem()'d at the same time. This 
 * means that all the entries are free()'d by calling freeMem() on the
 * first element. For example:
 * sqlStringDynamicArray(s, &retArray, &retSize);
 * DoSomeFunction(retArray, retSize);
 * freeMem(retArray[0]);
 * freeMem(retArray);
 * Thread-safe. */
{
char **array = NULL;
int count = 0;
if (s)
    {
    count = countSeparatedItems(s, ',');
    if (count > 0)
	{
	AllocArray(array, count);
	count = 0;
	s = cloneString(s);
	for (;;)
	    {
	    char *e;
	    if (s == NULL || s[0] == 0)
		break;
	    e = strchr(s, ',');
	    if (e != NULL)
		*e++ = 0;
	    array[count++] = s;
	    s = e;
	    }
	}
    }
*retArray = array;
*retSize = count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x3d23a
movq %rdi, %r12
movl $0x2c, %esi
callq 0x22225
xorl %r13d, %r13d
testl %eax, %eax
jle 0x3d242
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2db04
movq %rax, %r15
movq %r12, %rdi
callq 0x1f9f6
movq %rax, %r12
testq %r12, %r12
je 0x3d21f
cmpb $0x0, (%r12)
je 0x3d21f
movq %r12, %rdi
movl $0x2c, %esi
callq 0x6270
testq %rax, %rax
je 0x3d223
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x3d225
xorl %eax, %eax
jmp 0x3d234
xorl %ecx, %ecx
movslq %r13d, %rax
incl %r13d
movq %r12, (%r15,%rax,8)
movb $0x1, %al
movq %rcx, %r12
testb %al, %al
jne 0x3d1f6
jmp 0x3d248
xorl %r15d, %r15d
xorl %r13d, %r13d
jmp 0x3d248
xorl %r15d, %r15d
movl %eax, %r13d
movq %r15, (%r14)
movl %r13d, (%rbx)
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: sqlDoubleArrayToString
char *sqlDoubleArrayToString( double *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%f,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d2a6
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x574a6(%rip), %r14     # 0x9472f
movq 0x8(%rsp), %rdi
movsd (%rbx,%r12,8), %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d289
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlFloatArrayToString
char *sqlFloatArrayToString( float *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%f,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d30e
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x57441(%rip), %r14     # 0x9472f
movq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r12,4), %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d2ee
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlUnsignedArrayToString
char *sqlUnsignedArrayToString( unsigned *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%u,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d371
movl %ebp, %r15d
leaq 0x573e0(%rip), %r14     # 0x94733
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movl (%rbx,%r12,4), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d356
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlSignedArrayToString
char *sqlSignedArrayToString( int *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%d,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d3d4
movl %ebp, %r15d
leaq 0x50ef1(%rip), %r14     # 0x8e2a7
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movl (%rbx,%r12,4), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d3b9
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortArrayToString
char *sqlShortArrayToString( short *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%d,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d438
movl %ebp, %r15d
leaq 0x50e8e(%rip), %r14     # 0x8e2a7
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movswl (%rbx,%r12,2), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d41c
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlUshortArrayToString
char *sqlUshortArrayToString( unsigned short *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%u,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d49c
movl %ebp, %r15d
leaq 0x572b6(%rip), %r14     # 0x94733
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movzwl (%rbx,%r12,2), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d480
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteArrayToString
char *sqlByteArrayToString( signed char *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%d,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d500
movl %ebp, %r15d
leaq 0x50dc6(%rip), %r14     # 0x8e2a7
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movsbl (%rbx,%r12), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d4e4
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteArrayToString
char *sqlUbyteArrayToString( unsigned char *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%u,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d564
movl %ebp, %r15d
leaq 0x571ee(%rip), %r14     # 0x94733
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movzbl (%rbx,%r12), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d548
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharArrayToString
char *sqlCharArrayToString( char *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%c,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d5c8
movl %ebp, %r15d
leaq 0x5718e(%rip), %r14     # 0x94737
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movsbl (%rbx,%r12), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d5ac
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlLongLongArrayToString
char *sqlLongLongArrayToString( long long *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%lld,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d62b
movl %ebp, %r15d
leaq 0x5712e(%rip), %r14     # 0x9473b
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movq (%rbx,%r12,8), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d610
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlStringArrayToString
char *sqlStringArrayToString( char **array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
    {
    dyStringPrintf(string, "%s,", array[i]);
    }
return dyStringCannibalize(&string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x261d0
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
jle 0x3d68e
movl %ebp, %r15d
leaq 0x51283(%rip), %r14     # 0x8e8f3
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movq (%rbx,%r12,8), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2656a
incq %r12
cmpq %r12, %r15
jne 0x3d673
leaq 0x8(%rsp), %rdi
callq 0x2622c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlUnsignedComma
int sqlUnsignedComma(char **pS)
/* Return signed number at *pS.  Advance *pS past comma at end */
{
char *s = *pS;
char *e = strchr(s, ',');
unsigned ret;

*e++ = 0;
*pS = e;
ret = sqlUnsigned(s);
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
movb $0x0, (%rax)
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b838
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharComma
char sqlCharComma(char **pS)
/* Return char at *pS.  Advance *pS past comma after char */
{
char *s = *pS;
char *e = strchr(s, ',');
int ret;

*e++ = 0;
*pS = e;
ret = s[0];
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
movb $0x0, (%rax)
incq %rax
movq %rax, (%rbx)
movb (%r14), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlFloatComma
float sqlFloatComma(char **pS)
/* Return signed number at *pS.  Advance *pS past comma at end */
{
char *s = *pS;
char *e = strchr(s, ',');
float ret;

*e++ = 0;
*pS = e;
ret = atof(s);
return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
movb $0x0, (%rax)
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x6920
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlGetOptQuoteString
static char *sqlGetOptQuoteString(char **pS)
/* Return string at *pS.  (Either quoted or not.)  Advance *pS. */
{
char *s = *pS;
char *e;
char c = *s;

if (c  == '"' || c == '\'')
    {
    s += 1;
    e = findStringEnd(s, c);
    *e++ = 0;
    if (*e++ != ',')
	errAbort("Expecting comma after string");
    }
else
    {
    e = strchr(s, ',');
    *e++ = 0;
    }
*pS = e;
return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movzbl (%r14), %ebp
cmpl $0x27, %ebp
je 0x3d809
cmpl $0x22, %ebp
jne 0x3d85f
movb 0x1(%r14), %al
incq %r14
movq %r14, %r12
cmpb %bpl, %al
je 0x3d83d
leaq 0x56f64(%rip), %r15     # 0x94783
movq %r14, %r12
testb %al, %al
jne 0x3d830
movq %r15, %rdi
xorl %eax, %eax
callq 0x26b6f
movb 0x1(%r12), %al
incq %r12
cmpb %bpl, %al
jne 0x3d822
movb $0x0, (%r12)
leaq 0x2(%r12), %r15
cmpb $0x2c, 0x1(%r12)
je 0x3d875
leaq 0x56f10(%rip), %rdi     # 0x94766
xorl %eax, %eax
callq 0x26b6f
jmp 0x3d875
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6270
movq %rax, %r15
movb $0x0, (%rax)
incq %r15
movq %r15, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: buildSymHash
static struct hash *buildSymHash(char **values, boolean isEnum)
/* build a hash of values for either enum or set symbolic column */
{
struct hash *valHash = hashNew(0);
unsigned setVal = 1; /* not used for enum */
int iVal;
for (iVal = 0; values[iVal] != NULL; iVal++)
    {
    if (isEnum)
        hashAddInt(valHash, values[iVal], iVal);
    else
        {
        hashAddInt(valHash, values[iVal], setVal);
        setVal = setVal << 1;
        }
    }
return valHash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %ebp
xorl %edi, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, %r15
movq (%r14), %rsi
testq %rsi, %rsi
je 0x3d954
xorl %r12d, %r12d
movq %r15, %rdi
testl %ebx, %ebx
je 0x3d93e
movl %r12d, %edx
callq 0x2909b
jmp 0x3d947
movl %ebp, %edx
callq 0x2909b
addl %ebp, %ebp
movq 0x8(%r14,%r12,8), %rsi
incq %r12
testq %rsi, %rsi
jne 0x3d92d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlSetParse
unsigned sqlSetParse(char *valStr, char **values, struct hash **valHashPtr)
/* parse a set column value */
{
if (*valHashPtr == NULL)
    *valHashPtr = buildSymHash(values, FALSE);
/* parse comma separated string */
unsigned value = 0;
char *val = strtok(valStr, ",");
while (val != NULL)
    {
    value |= hashIntVal(*valHashPtr, val);
    val = strtok(NULL, ",");
    }

return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdx)
jne 0x3d9b3
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3d901
movq %rax, (%rbx)
leaq 0x5202d(%rip), %rsi     # 0x8f9e7
movq %r14, %rdi
callq 0x6be0
xorl %r14d, %r14d
testq %rax, %rax
je 0x3d9ee
leaq 0x52016(%rip), %r15     # 0x8f9e7
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x28fce
orl %eax, %r14d
xorl %edi, %edi
movq %r15, %rsi
callq 0x6be0
testq %rax, %rax
jne 0x3d9d1
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/sqlList.c
// Function: sqlSetPrint
void sqlSetPrint(FILE *f, unsigned value, char **values)
/* print a set column value */
{
int iVal;
unsigned curVal = 1;
int cnt = 0;
for (iVal = 0; values[iVal] != NULL; iVal++, curVal = curVal << 1)
    {
    if (curVal & value)
        {
        if (cnt > 0)
            fputc(',', f);
        fputs(values[iVal], f);
        cnt++;
        }
    }
}

// Assembly:
cmpq $0x0, (%rdx)
je 0x3da76
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
addq $0x8, %r14
movl $0x1, %ebp
xorl %r12d, %r12d
testl %ebx, %ebp
je 0x3da62
testl %r12d, %r12d
jle 0x3da53
movl $0x2c, %edi
movq %r15, %rsi
callq 0x6930
movq -0x8(%r14), %rdi
movq %r15, %rsi
callq 0x6810
incl %r12d
addl %ebp, %ebp
cmpq $0x0, (%r14)
leaq 0x8(%r14), %r14
jne 0x3da3d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitWriteOne
void twoBitWriteOne(struct twoBit *twoBit, FILE *f)
/* Write out one twoBit sequence to binary file. 
 * Note this does not include the name, which is
 * stored only in index. */
{
writeOne(f, twoBit->size);
writeOne(f, twoBit->nBlockCount);
if (twoBit->nBlockCount > 0)
    {
    fwrite(twoBit->nStarts, sizeof(twoBit->nStarts[0]), 
    	twoBit->nBlockCount, f);
    fwrite(twoBit->nSizes, sizeof(twoBit->nSizes[0]), 
    	twoBit->nBlockCount, f);
    }
writeOne(f, twoBit->maskBlockCount);
if (twoBit->maskBlockCount > 0)
    {
    fwrite(twoBit->maskStarts, sizeof(twoBit->maskStarts[0]), 
    	twoBit->maskBlockCount, f);
    fwrite(twoBit->maskSizes, sizeof(twoBit->maskSizes[0]), 
    	twoBit->maskBlockCount, f);
    }
writeOne(f, twoBit->reserved);
mustWrite(f, twoBit->data, packedSize(twoBit->size));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x22e1e
leaq 0x1c(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x22e1e
movl 0x1c(%r14), %edx
testq %rdx, %rdx
je 0x3dd60
movq 0x20(%r14), %rdi
movl $0x4, %esi
movq %rbx, %rcx
callq 0x6e70
movq 0x28(%r14), %rdi
movl 0x1c(%r14), %edx
movl $0x4, %esi
movq %rbx, %rcx
callq 0x6e70
leaq 0x30(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x22e1e
movl 0x30(%r14), %edx
testq %rdx, %rdx
je 0x3dda0
movq 0x38(%r14), %rdi
movl $0x4, %esi
movq %rbx, %rcx
callq 0x6e70
movq 0x40(%r14), %rdi
movl 0x30(%r14), %edx
movl $0x4, %esi
movq %rbx, %rcx
callq 0x6e70
leaq 0x48(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x22e1e
movq 0x10(%r14), %rsi
movl 0x18(%r14), %eax
addl $0x3, %eax
sarl $0x2, %eax
movslq %eax, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22e1e
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitClose
void twoBitClose(struct twoBitFile **pTbf)
/* Free up resources associated with twoBitFile. */
{
struct twoBitFile *tbf = *pTbf;
if (tbf != NULL)
    {
    twoBitFree(&tbf->seqCache);
    freez(&tbf->fileName);
    (*tbf->ourClose)(&tbf->f);
    hashFree(&tbf->hash);
    /* The indexList is allocated out of the hash's memory pool. */
    bptFileClose(&tbf->bpt);
    freez(pTbf);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x3dfe3
movq %rdi, %rbx
leaq 0x40(%r14), %rdi
callq 0x3dfeb
leaq 0x8(%r14), %rdi
callq 0x2dd51
leaq 0x10(%r14), %rdi
callq *0x78(%r14)
leaq 0x30(%r14), %rdi
callq 0x29565
addq $0x38, %r14
movq %r14, %rdi
callq 0x42e05
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/twoBit.c
// Function: twoBitFree
void twoBitFree(struct twoBit **pTwoBit)
/* Free up a two bit structure. */
{
struct twoBit *twoBit = *pTwoBit;
if (twoBit != NULL)
    {
    freeMem(twoBit->nStarts);
    freeMem(twoBit->nSizes);
    freeMem(twoBit->maskStarts);
    freeMem(twoBit->maskSizes);
    freeMem(twoBit->data);
    freez(pTwoBit);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x3e036
movq %rdi, %rbx
movq 0x20(%r14), %rdi
callq 0x2dd41
movq 0x28(%r14), %rdi
callq 0x2dd41
movq 0x38(%r14), %rdi
callq 0x2dd41
movq 0x40(%r14), %rdi
callq 0x2dd41
movq 0x10(%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/twoBit.c
// Function: twoBitSigRead
boolean twoBitSigRead(struct twoBitFile *tbf, boolean *isSwapped)
/* read twoBit signature, return FALSE if not good 
 * set isSwapped to TRUE if twoBit file is byte swapped */
{
bits32 sig;

*isSwapped = FALSE;
(*tbf->ourMustRead)(tbf->f, &sig, sizeof(sig));
if (sig == twoBitSwapSig)
    *isSwapped = TRUE;
else if (sig != twoBitSig)
    return FALSE;

return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
movl $0x0, (%rsi)
movq 0x10(%rdi), %rdi
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %r14, %rsi
callq *0x88(%rax)
movl (%r14), %ecx
cmpl $0x1a412743, %ecx       # imm = 0x1A412743
je 0x3e080
xorl %eax, %eax
cmpl $0x4327411a, %ecx       # imm = 0x4327411A
jne 0x3e085
movl $0x1, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOpen
struct twoBitFile *twoBitOpen(char *fileName)
/* Open file, read in header and index.  
 * Squawk and die if there is a problem. */
{
boolean useUdc = FALSE;
if (hasProtocol(fileName))
    useUdc = TRUE;
struct twoBitFile *tbf = twoBitOpenReadHeader(fileName, useUdc);
struct twoBitIndex *index;
boolean isSwapped = tbf->isSwapped;
int i;
struct hash *hash;
void *f = tbf->f;

/* Read in index. */
hash = tbf->hash = hashNew(digitsBaseTwo(tbf->seqCount));
for (i=0; i<tbf->seqCount; ++i)
    {
    char name[256];
    if (!(*tbf->ourFastReadString)(f, name))
        errAbort("%s is truncated", fileName);
    lmAllocVar(hash->lm, index);
    if (tbf->version == 1)
        index->offset = (*tbf->ourReadBits64)(f, isSwapped);
    else
        index->offset = (*tbf->ourReadBits32)(f, isSwapped);
    hashAddSaveName(hash, name, index, &index->name);
    slAddHead(&tbf->indexList, index);
    }
slReverse(&tbf->indexList);
return tbf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
callq 0x31296
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3e19f
movq %rax, %r14
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%r14), %r15
movl 0x20(%r14), %edi
callq 0x324a3
movl %eax, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, 0x30(%r14)
cmpl $0x0, 0x20(%r14)
je 0x3e17e
movq %rax, %r12
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq *0x80(%r14)
testl %eax, %eax
jne 0x3e11b
leaq 0x5673a(%rip), %rdi     # 0x94849
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x26b6f
movq 0x20(%r12), %rdi
movl $0x18, %esi
callq 0x2bfa9
movq %rax, %rbx
cmpl $0x1, 0x1c(%r14)
jne 0x3e141
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq *0x70(%r14)
jmp 0x3e14e
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq *0x68(%r14)
movl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rbx, %rcx
addq $0x8, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x28f16
movq 0x28(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x28(%r14)
incl %ebp
cmpl 0x20(%r14), %ebp
jb 0x3e0f7
movq %r14, %rdi
addq $0x28, %rdi
callq 0x1fcb3
movq %r14, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOpenReadHeader
static struct twoBitFile *twoBitOpenReadHeader(char *fileName, boolean useUdc)
/* Open file, read in header but not index.  
 * Squawk and die if there is a problem. */
{
struct twoBitFile *tbf;
boolean isSwapped = FALSE;

tbf = getTbfAndOpen(fileName, useUdc);

/* Allocate header verify signature, and read in
 * the constant-length bits. */

if (!twoBitSigRead(tbf, &isSwapped))
    errAbort("%s doesn't have a valid twoBitSig", fileName);

tbf->isSwapped = isSwapped;
tbf->fileName = cloneString(fileName);
tbf->version = (*tbf->ourReadBits32)(tbf->f, isSwapped);
if ((tbf->version != 0) && (tbf->version != 1))
    {
    errAbort("Can only handle version 0 or version 1 of this file. This is version %d",
    	(int)tbf->version);
    }
tbf->seqCount = (*tbf->ourReadBits32)(tbf->f, isSwapped);
tbf->reserved = (*tbf->ourReadBits32)(tbf->f, isSwapped);
return tbf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3ecb7
movq %rax, %rbx
movq 0x10(%rax), %rdi
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %r15, %rsi
callq *0x88(%rax)
movl (%r15), %eax
cmpl $0x1a412743, %eax       # imm = 0x1A412743
je 0x3e1e0
cmpl $0x4327411a, %eax       # imm = 0x4327411A
jne 0x3e1e6
movl $0x1, %ebp
jmp 0x3e1e2
xorl %ebp, %ebp
xorl %eax, %eax
jmp 0x3e1ea
movb $0x1, %al
xorl %ebp, %ebp
testb %al, %al
je 0x3e1ff
leaq 0x5676b(%rip), %rdi     # 0x94960
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b6f
movl %ebp, 0x18(%rbx)
movq %r14, %rdi
callq 0x1f9f6
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x2, %eax
jb 0x3e22f
leaq 0x5675c(%rip), %rdi     # 0x94982
movl %eax, %esi
xorl %eax, %eax
callq 0x26b6f
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x24(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOpenExternalBptIndex
struct twoBitFile *twoBitOpenExternalBptIndex(char *twoBitName, char *bptName)
/* Open file, read in header, but not regular index.  Instead use
 * bpt index.   Beware if you use this the indexList field will be NULL
 * as will the hash. */
{
struct twoBitFile *tbf = twoBitOpenReadHeader(twoBitName, FALSE);
tbf->bpt = bptFileOpen(bptName);
if (tbf->seqCount != tbf->bpt->itemCount)
    errAbort("%s and %s don't have same number of sequences!", twoBitName, bptName);
return tbf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x3e19f
movq %rax, %r14
movq %rbx, %rdi
callq 0x42dd2
movq %rax, 0x38(%r14)
movl 0x20(%r14), %ecx
cmpq %rcx, 0x28(%rax)
je 0x3e294
leaq 0x565d2(%rip), %rdi     # 0x94859
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26b6f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/lib/twoBit.c
// Function: twoBitOneFromFile
struct twoBit *twoBitOneFromFile(struct twoBitFile *tbf, char *name)
/* Get single sequence as two bit. */
{
struct twoBit *twoBit = readTwoBitSeqHeader(tbf, name);
bits32 packByteCount;
void *f = tbf->f;

/* Read in data. */
packByteCount = packedSize(twoBit->size);
twoBit->data = needLargeMem(packByteCount);
(*tbf->ourMustRead)(f, twoBit->data, packByteCount);

return twoBit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3e2ea
movq %rax, %r14
movq 0x10(%rbx), %r15
movl 0x18(%rax), %r12d
addl $0x3, %r12d
sarl $0x2, %r12d
movq %r12, %rdi
callq 0x2da9d
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq *0x88(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq