LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x36ecd
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x36ed5
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x3608c
movss %xmm0, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x36ec8
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x36e9a
incl %r12d
jmp 0x36ed8
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x36ed8
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x36f47
cmpb $0x0, (%r15)
je 0x36f47
cmpq %r14, %r12
je 0x36f47
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36f30
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x36f33
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35d13
movl %eax, (%rbx,%r14,4)
incq %r14
movq %r13, %r15
jmp 0x36f06
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x2c
popq %rbp
pushq $0x40
popq %r13
testq %r15, %r15
je 0x36ffc
cmpb $0x0, (%r15)
je 0x36ffc
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x36fa3
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x36fa5
xorl %ebx, %ebx
movl 0x81235(%rip), %eax     # 0xb81e0
movl %r12d, %r14d
cmpl %eax, %r12d
jb 0x36fe1
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %r13d, %edx
movl %edx, 0x8121e(%rip)     # 0xb81e0
movq 0x8120f(%rip), %rdi     # 0xb81d8
leaq (,%r14,4), %rsi
shlq $0x2, %rdx
callq 0x28c1e
movq %rax, 0x811f7(%rip)     # 0xb81d8
movq %r15, %rdi
callq 0x35d13
movq 0x811e8(%rip), %rcx     # 0xb81d8
incl %r12d
movl %eax, (%rcx,%r14,4)
movq %rbx, %r15
jmp 0x36f7e
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
movq 0x811cd(%rip), %rax     # 0xb81d8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 0x37095
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x3709d
movl %r12d, %edi
shlq $0x2, %rdi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x35d1c
movl %eax, (%r15,%r12,4)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x37090
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x37064
incl %r12d
jmp 0x370a0
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x370a0
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x3710f
cmpb $0x0, (%r15)
je 0x3710f
cmpq %r14, %r12
je 0x3710f
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x370f8
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x370fb
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35e52
movl %eax, (%rbx,%r14,4)
incq %r14
movq %r13, %r15
jmp 0x370ce
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
xorl %r15d, %r15d
pushq $0x2c
popq %rbp
pushq $0x40
popq %rbx
xorl %r13d, %r13d
testq %r12, %r12
je 0x371c7
cmpb $0x0, (%r12)
je 0x371c7
movq %r12, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x3716e
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x37171
xorl %r14d, %r14d
movslq 0x81078(%rip), %rax     # 0xb81f0
cmpq %rax, %r13
jl 0x371a8
leal (%rax,%rax), %ecx
testl %eax, %eax
cmovel %ebx, %ecx
movl %ecx, 0x81065(%rip)     # 0xb81f0
movq 0x81056(%rip), %rdi     # 0xb81e8
movslq %ecx, %rdx
shlq $0x2, %rdx
movq %r15, %rsi
callq 0x28c1e
movq %rax, 0x81040(%rip)     # 0xb81e8
movq %r12, %rdi
callq 0x35e52
movq 0x81031(%rip), %rcx     # 0xb81e8
movl %eax, (%rcx,%r13,4)
incq %r13
addq $0x4, %r15
movq %r14, %r12
jmp 0x37148
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x81012(%rip), %rax     # 0xb81e8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x372da
cmpb $0x0, (%r15)
je 0x372da
cmpq %r14, %r12
je 0x372da
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x372c3
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
jmp 0x372c6
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x35f40
movq %rax, (%rbx,%r14,8)
incq %r14
movq %r13, %r15
jmp 0x37299
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x2c
popq %rbp
pushq $0x40
popq %r13
testq %r15, %r15
je 0x3738f
cmpb $0x0, (%r15)
je 0x3738f
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x37336
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
jmp 0x37338
xorl %ebx, %ebx
movl 0x80ec2(%rip), %eax     # 0xb8200
movl %r12d, %r14d
cmpl %eax, %r12d
jb 0x37374
leal (%rax,%rax), %edx
testl %eax, %eax
cmovel %r13d, %edx
movl %edx, 0x80eab(%rip)     # 0xb8200
movq 0x80e9c(%rip), %rdi     # 0xb81f8
leaq (,%r14,8), %rsi
shlq $0x3, %rdx
callq 0x28c1e
movq %rax, 0x80e84(%rip)     # 0xb81f8
movq %r15, %rdi
callq 0x35f40
movq 0x80e75(%rip), %rcx     # 0xb81f8
incl %r12d
movq %rax, (%rcx,%r14,8)
movq %rbx, %r15
jmp 0x37311
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
movq 0x80e5a(%rip), %rax     # 0xb81f8
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 0x37428
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x37430
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x28a1f
movq %rax, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movq %rax, %r12
movq %r13, %rdi
callq 0x35fb1
movq %rax, (%r15,%r12,8)
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, (%rax)
je 0x37423
leaq 0x1(%r12), %rax
cmpb $0x0, (%rcx)
jne 0x373f7
incl %r12d
jmp 0x37433
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x37433
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r12d
xorl %r14d, %r14d
pushq $0x2c
popq %rbp
testq %r15, %r15
je 0x37496
cmpb $0x0, (%r15)
je 0x37496
cmpq %r14, %r12
je 0x37496
movq %r15, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x37488
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x3748a
xorl %ecx, %ecx
movq %r15, (%rbx,%r14,8)
incq %r14
movq %rcx, %r15
jmp 0x3745e
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
xorl %r15d, %r15d
pushq $0x2c
popq %rbp
pushq $0x40
popq %rbx
xorl %r13d, %r13d
testq %r12, %r12
je 0x3753c
cmpb $0x0, (%r12)
je 0x3753c
movq %r12, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x374ef
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x374f2
xorl %r14d, %r14d
movslq 0x80d17(%rip), %rcx     # 0xb8210
movq 0x80d08(%rip), %rax     # 0xb8208
cmpq %rcx, %r13
jl 0x3752c
leal (%rcx,%rcx), %edx
testl %ecx, %ecx
cmovel %ebx, %edx
movl %edx, 0x80cfd(%rip)     # 0xb8210
movslq %edx, %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x28c1e
movq %rax, 0x80cdc(%rip)     # 0xb8208
movq %r12, (%rax,%r13,8)
incq %r13
addq $0x8, %r15
movq %r14, %r12
jmp 0x374c9
movq 0x8(%rsp), %rax
movl %r13d, (%rax)
movq 0x80cbd(%rip), %rax     # 0xb8208
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x375de
movq %rdi, %r13
pushq $0x2c
popq %rsi
callq 0x1e489
movl %eax, %r12d
testl %eax, %eax
jle 0x375e6
movl %r12d, %edi
shlq $0x3, %rdi
callq 0x28a1f
movq %rax, %r15
movq %r13, %rdi
callq 0x1c306
movq %rax, %r13
xorl %r12d, %r12d
pushq $0x2c
popq %rbp
testq %r13, %r13
je 0x375e9
cmpb $0x0, (%r13)
je 0x375e9
movq %r13, %rdi
movl %ebp, %esi
callq 0x6270
testq %rax, %rax
je 0x375d0
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0x375d2
xorl %ecx, %ecx
movq %r13, (%r15,%r12,8)
incq %r12
movq %rcx, %r13
jmp 0x375aa
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x375e9
xorl %r15d, %r15d
movq %r15, (%r14)
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x4c0d0(%rip), %r12     # 0x83702
cmpq %r13, %rbx
je 0x3764f
movsd (%r14,%r13,8), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x21ec7
incq %r13
jmp 0x37632
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x4c067(%rip), %r12     # 0x83702
cmpq %r13, %rbx
je 0x376b8
cvtss2sd (%r14,%r13,4), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x21ec7
incq %r13
jmp 0x3769b
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x4c004(%rip), %r12     # 0x83706
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x37720
movl (%r14,%r13,4), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x37705
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x45b1d(%rip), %r12     # 0x7d287
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x37788
movl (%r14,%r13,4), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x3776d
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x45ab5(%rip), %r12     # 0x7d287
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x377f1
movswl (%r14,%r13,2), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x377d5
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x4becb(%rip), %r12     # 0x83706
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x3785a
movzwl (%r14,%r13,2), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x3783e
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x459e3(%rip), %r12     # 0x7d287
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x378c3
movsbl (%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x378a7
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x4bdf9(%rip), %r12     # 0x83706
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x3792c
movzbl (%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x37910
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x4bd94(%rip), %r12     # 0x8370a
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x37995
movsbl (%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x37979
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x4bd2f(%rip), %r12     # 0x8370e
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x379fd
movq (%r14,%r13,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x379e2
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x21bcc
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x45ea2(%rip), %r12     # 0x7d8e9
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x37a65
movq (%r14,%r13,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21ec7
incq %r13
jmp 0x37a4a
leaq 0x8(%rsp), %rdi
callq 0x21c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x6270
movb $0x0, (%rax)
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35d13
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2c
popq %rsi
movq %r14, %rdi
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_O2/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
pushq $0x2c
popq %rsi
movq %r14, %rdi
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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movzbl (%r12), %ebp
cmpl $0x27, %ebp
je 0x37bd9
cmpl $0x22, %ebp
jne 0x37c24
leaq 0x1(%r12), %r14
addq $0x3, %r12
leaq 0x4bb6d(%rip), %r13     # 0x83756
movq %r12, %r15
movb -0x2(%r15), %al
cmpb %bpl, %al
je 0x37c08
testb %al, %al
jne 0x37c03
movq %r13, %rdi
xorl %eax, %eax
callq 0x223fb
incq %r15
jmp 0x37bec
movb $0x0, -0x2(%r15)
cmpb $0x2c, -0x1(%r15)
je 0x37c3b
leaq 0x4bb1e(%rip), %rdi     # 0x83739
xorl %eax, %eax
callq 0x223fb
jmp 0x37c3b
pushq $0x2c
popq %rsi
movq %r12, %rdi
callq 0x6270
movq %rax, %r15
movb $0x0, (%rax)
incq %r15
movq %r12, %r14
movq %r15, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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
xorl %r15d, %r15d
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x245c9
movq %rax, %r12
movq (%r14,%r15,8), %rsi
testq %rsi, %rsi
je 0x37d16
movq %r12, %rdi
testl %ebx, %ebx
je 0x37d08
movl %r15d, %edx
callq 0x24538
jmp 0x37d11
movl %ebp, %edx
callq 0x24538
addl %ebp, %ebp
incq %r15
jmp 0x37cee
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r12
cmpq $0x0, (%rdx)
jne 0x37d78
movq %rsi, %rdi
xorl %esi, %esi
callq 0x37ccf
movq %rax, (%rbx)
xorl %r14d, %r14d
leaq 0x46c55(%rip), %r15     # 0x7e9d7
movq %r12, %rdi
movq %r15, %rsi
callq 0x6be0
testq %rax, %rax
je 0x37da5
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x2446b
orl %eax, %r14d
xorl %r12d, %r12d
jmp 0x37d82
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/sqlList.c
// Function: 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %r13
pushq $0x2c
popq %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x37e2a
testl %ebp, %r13d
je 0x37e21
testl %r12d, %r12d
jle 0x37e16
movl %r15d, %edi
movq %r14, %rsi
callq 0x6930
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6810
incl %r12d
addl %r13d, %r13d
addq $0x8, %rbx
jmp 0x37df6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1ed3f
leaq 0x1c(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1ed3f
movl 0x1c(%r14), %edx
testq %rdx, %rdx
je 0x38119
movq 0x20(%r14), %rdi
pushq $0x4
popq %r15
movq %r15, %rsi
movq %rbx, %rcx
callq 0x6e70
movq 0x28(%r14), %rdi
movl 0x1c(%r14), %edx
movq %r15, %rsi
movq %rbx, %rcx
callq 0x6e70
leaq 0x30(%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1ed3f
movl 0x30(%r14), %edx
testq %rdx, %rdx
je 0x38157
movq 0x38(%r14), %rdi
pushq $0x4
popq %r15
movq %r15, %rsi
movq %rbx, %rcx
callq 0x6e70
movq 0x40(%r14), %rdi
movl 0x30(%r14), %edx
movq %r15, %rsi
movq %rbx, %rcx
callq 0x6e70
leaq 0x48(%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1ed3f
movq 0x10(%r14), %rsi
movl 0x18(%r14), %eax
addl $0x3, %eax
sarl $0x2, %eax
movslq %eax, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1ed3f
// File: /workspace/github_c_makefile_star2_O2/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 0x38388
movq %rdi, %rbx
leaq 0x40(%r14), %rdi
callq 0x38390
leaq 0x8(%r14), %rdi
callq 0x28c3d
leaq 0x10(%r14), %rdi
callq *0x78(%r14)
leaq 0x30(%r14), %rdi
callq 0x2494c
addq $0x38, %r14
movq %r14, %rdi
callq 0x3cdbb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/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 0x383db
movq %rdi, %rbx
movq 0x20(%r14), %rdi
callq 0x28c2d
movq 0x28(%r14), %rdi
callq 0x28c2d
movq 0x38(%r14), %rdi
callq 0x28c2d
movq 0x40(%r14), %rdi
callq 0x28c2d
movq 0x10(%r14), %rdi
callq 0x28c2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/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
andl $0x0, (%rsi)
movq 0x10(%rdi), %rdi
leaq 0x4(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rsi
callq *0x88(%rax)
movl (%r14), %ecx
cmpl $0x1a412743, %ecx       # imm = 0x1A412743
je 0x38420
xorl %eax, %eax
cmpl $0x4327411a, %ecx       # imm = 0x4327411A
jne 0x38423
movl $0x1, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2bf85
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x38536
movq %rax, %r14
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%r14), %r15
movl 0x20(%r14), %edi
callq 0x2d0c4
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x245c9
movq %rax, %r12
movq %rax, 0x30(%r14)
movq %r14, %r13
addq $0x28, %r13
xorl %ebx, %ebx
cmpl 0x20(%r14), %ebx
jae 0x38519
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq *0x80(%r14)
testl %eax, %eax
jne 0x384ba
leaq 0x4b36e(%rip), %rdi     # 0x8381c
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x223fb
movq 0x20(%r12), %rdi
pushq $0x18
popq %rsi
callq 0x26ff4
movq %rax, %rbp
cmpl $0x1, 0x1c(%r14)
jne 0x384de
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq *0x70(%r14)
jmp 0x384eb
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq *0x68(%r14)
movl %eax, %eax
movq %rax, 0x10(%rbp)
movq %rbp, %rcx
addq $0x8, %rcx
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0x243f4
movq (%r13), %rax
movq %rax, (%rbp)
movq %rbp, (%r13)
incl %ebx
jmp 0x3848a
movq %r13, %rdi
callq 0x1c567
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_O2/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
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
callq 0x38fae
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x383e3
testl %eax, %eax
jne 0x38571
leaq 0x4b3cc(%rip), %rdi     # 0x83933
movq %r14, %rsi
xorl %eax, %eax
callq 0x223fb
movl 0x4(%rsp), %ebp
movl %ebp, 0x18(%rbx)
movq %r14, %rdi
callq 0x1c306
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x2, %eax
jb 0x385a5
leaq 0x4b3b9(%rip), %rdi     # 0x83955
movl %eax, %esi
xorl %eax, %eax
callq 0x223fb
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_O2/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 0x38536
movq %rax, %r14
movq %rbx, %rdi
callq 0x3cd88
movq %rax, 0x38(%r14)
movl 0x20(%r14), %ecx
cmpq %rcx, 0x28(%rax)
je 0x3860a
leaq 0x4b22f(%rip), %rdi     # 0x8382c
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x223fb
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x38660
movq %rax, %r14
movq 0x10(%rbx), %r15
movl 0x18(%rax), %r12d
addl $0x3, %r12d
sarl $0x2, %r12d
movq %r12, %rdi
callq 0x289b8
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
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/twoBit.c
// Function: readTwoBitSeqHeader
static struct twoBit *readTwoBitSeqHeader(struct twoBitFile *tbf, char *name)
/* read a sequence header, nBlocks and maskBlocks from a twoBit file,
 * leaving file pointer at data block */
{
boolean isSwapped = tbf->isSwapped;
struct twoBit *twoBit;
AllocVar(twoBit);
twoBit->name = cloneString(name);
void *f = tbf->f;

/* Find offset in index and seek to it */
twoBitSeekTo(tbf, name);

/* Read in seqSize. */
twoBit->size = (*tbf->ourReadBits32)(f, isSwapped);

/* Read in blocks of N. */
readBlockCoords(tbf, isSwapped, &(twoBit->nBlockCount),
		&(twoBit->nStarts), &(twoBit->nSizes));

/* Read in masked blocks. */
readBlockCoords(tbf, isSwapped, &(twoBit->maskBlockCount),
		&(twoBit->maskStarts), &(twoBit->maskSizes));

/* Reserved word. */
twoBit->reserved = (*tbf->ourReadBits32)(f, isSwapped);

return twoBit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movl 0x18(%rdi), %ebp
pushq $0x50
popq %rdi
callq 0x28bb0
movq %rax, %r14
movq %r12, %rdi
callq 0x1c306
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x38bfd
movq %r15, %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x18(%r14)
leaq 0x1c(%r14), %rdx
leaq 0x20(%r14), %rcx
leaq 0x28(%r14), %r8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x39659
leaq 0x30(%r14), %rdx
leaq 0x38(%r14), %rcx
leaq 0x40(%r14), %r8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x39659
movq %r15, %rdi
movl %ebp, %esi
callq *0x68(%rbx)
movl %eax, 0x48(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/twoBit.c
// Function: twoBitFromOpenFile
struct twoBit *twoBitFromOpenFile(struct twoBitFile *tbf)
/* Get twoBit list of all sequences in twoBit file. */
{
struct twoBitIndex *index;
struct twoBit *twoBitList = NULL;

for (index = tbf->indexList; index != NULL; index = index->next)
    {
    struct twoBit *twoBit = twoBitOneFromFile(tbf, index->name);
    slAddHead(&twoBitList, twoBit);
    }

twoBitClose(&tbf);
slReverse(&twoBitList);
return twoBitList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, (%rsp)
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x28(%rdi), %r14
xorl %r15d, %r15d
movq (%r14), %r14
testq %r14, %r14
je 0x38724
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x38613
movq %r15, (%rax)
movq %rax, (%rsp)
movq %rax, %r15
jmp 0x38704
leaq 0x8(%rsp), %rdi
callq 0x3833b
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1c567
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/lib/twoBit.c
// Function: twoBitFreeList
void twoBitFreeList(struct twoBit **pList)
/* Free a list of dynamically allocated twoBit's */
{
struct twoBit *el, *next;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x38780
movq (%r15), %r15
movq %r14, %rdi
callq 0x38390
jmp 0x38769
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq