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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x60, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x55b40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6900
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6900
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6900
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x55e00
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x55e00
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x6680
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x55b40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutCommaIn
struct repeatMaskOut *repeatMaskOutCommaIn(char **pS)
/* Create a repeatMaskOut out of a comma separated string. */
{
struct repeatMaskOut *ret;
char *s = *pS;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x60, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x58520
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58580
cvtsi2ss %eax, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58580
cvtsi2ss %eax, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x10(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58580
cvtsi2ss %eax, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58580
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58580
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
leaq -0x18(%rbp), %rdi
movl $0x2, %edx
callq 0x58870
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58520
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFree
void repeatMaskOutFree(struct repeatMaskOut **pEl)
/* Free a single dynamically allocated repeatMaskOut such as created
 * with repeatMaskOutLoad(). */
{
struct repeatMaskOut *el;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x555af
jmp 0x55606
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/repMask.c
// Function: repeatMaskOutFreeList
void repeatMaskOutFreeList(struct repeatMaskOut **pList)
/* Free a list of dynamically allocated repeatMaskOut's */
{
struct repeatMaskOut *el, *next;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x55a2b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0xf1(%rbp)
jl 0x55a92
movsbl -0x21(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x55a9e
jmp 0x55ab4
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x55a5e
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x55ad3
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x55b25
cmpq $0x0, -0x10(%rbp)
jne 0x55aee
movq -0x8(%rbp), %rsi
leaq 0x889de(%rip), %rdi     # 0xde4c3
movb $0x0, %al
callq 0x35d40
jmp 0x55b23
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x35e80
leaq -0x40(%rbp), %rax
jmp 0x55b25
movl -0x14(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedInList
unsigned sqlUnsignedInList(char **pS)
/* Convert series of digits to unsigned integer about
 * twice as fast as atoi (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned res = 0;
char *p = s;
char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x31(%rbp)
jl 0x55bc4
movsbl -0x21(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x55bcd
jmp 0x55be3
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x55b96
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x55c01
movsbl -0x21(%rbp), %eax
cmpl $0x2c, %eax
jne 0x55c0b
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x55c3d
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x55c2b
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x8888d(%rip), %rdi     # 0xde4c3
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLong
unsigned long sqlUnsignedLong(char *s)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) */
{
unsigned long res = 0;
char *p = s;
char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x1a(%rbp)
jl 0x55caa
movsbl -0x19(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x55cb3
jmp 0x55ccf
imulq $0xa, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movsbl -0x19(%rbp), %eax
subl $0x30, %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x55c7c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x55cee
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x55d00
movq -0x8(%rbp), %rsi
leaq 0x887e9(%rip), %rdi     # 0xde4e2
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlUnsignedLongInList
unsigned long sqlUnsignedLongInList(char **pS)
/* Convert series of digits to unsigned long about
 * twice as fast as atol (by not having to skip white 
 * space or stop except at the null byte.) 
 * All of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
unsigned long res = 0;
char *p = s;
char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x31(%rbp)
jl 0x55d65
movsbl -0x21(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x55d6e
jmp 0x55d8a
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x55d37
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x55da8
movsbl -0x21(%rbp), %eax
cmpl $0x2c, %eax
jne 0x55db2
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x55de4
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x55dd2
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x88705(%rip), %rdi     # 0xde4e2
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSigned
int sqlSigned(char *s)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. */
{
int res = 0;
char *p, *p0 = s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x55e33
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x29(%rbp)
jl 0x55e5c
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x55e65
jmp 0x55e8a
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x55e3b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x55ea0
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x55eb2
movq -0x10(%rbp), %rsi
leaq 0x88653(%rip), %rdi     # 0xde4fe
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x55ec8
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x55ece
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlSignedInList
int sqlSignedInList(char **pS)
/* Convert string to signed integer.  Unlike atol assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
int res = 0;
char *p, *p0 = s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x55f1e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x39(%rbp)
jl 0x55f47
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x55f50
jmp 0x55f75
imull $0xa, -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x55f26
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x55f8d
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x55f97
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x55fc9
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x55fb7
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rsi
leaq 0x8853c(%rip), %rdi     # 0xde4fe
movb $0x0, %al
callq 0x35d40
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x55fea
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x55ff0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLong
long long sqlLongLong(char *s)
/* Convert string to a long long.  Unlike atol assumes all of string is
 * number. */
{
long long res = 0;
char *p, *p0 = s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x56034
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x29(%rbp)
jl 0x5605d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x56066
jmp 0x56091
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5603c
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x560a7
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x560b9
movq -0x10(%rbp), %rsi
leaq 0x88469(%rip), %rdi     # 0xde51b
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x560d1
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x560d9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlLongLongInList
long long sqlLongLongInList(char **pS)
/* Convert string to a long long.  Unlike atol, assumes 
 * all of string is number. Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
long long res = 0;
char *p, *p0 = s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5612f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x39(%rbp)
jl 0x56158
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x56161
jmp 0x5618c
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x56137
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x561a4
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x561ae
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x561e0
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x561ce
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rsi
leaq 0x88342(%rip), %rdi     # 0xde51b
movb $0x0, %al
callq 0x35d40
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x56203
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5620b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlFloat
float sqlFloat(char *s)
/* Convert string to a float.  Assumes all of string is number
 * and aborts on an error. */
{
char* end;
/*	used to have an ifdef here to use strtof() but that doesn't
 *	actually exist on all systems and since strtod() does, may as
 *	well use it since it will do the job here.
 */
float val = (float) strtod(s, &end);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6500
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x56258
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5626a
movq -0x8(%rbp), %rsi
leaq 0x882d7(%rip), %rdi     # 0xde53a
movb $0x0, %al
callq 0x35d40
movss -0x14(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlFloatInList
float sqlFloatInList(char **pS)
/* Convert string to a float.  Assumes all of string is number
 * and aborts on an error. 
 * Number may be delimited by a comma. 
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
char* end;
/*	used to have an ifdef here to use strtof() but that doesn't
 *	actually exist on all systems and since strtod() does, may as
 *	well use it since it will do the job here.
 */
float val = (float) strtod(s, &end);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6500
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x562cf
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56301
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x56301
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x562ef
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x88240(%rip), %rdi     # 0xde53a
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movss -0x1c(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlDouble
double sqlDouble(char *s)
/* Convert string to a double.  Assumes all of string is number
 * and aborts on an error. */
{
char* end;
double val = strtod(s, &end);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6500
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x56354
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56366
movq -0x8(%rbp), %rsi
leaq 0x881ed(%rip), %rdi     # 0xde54c
movb $0x0, %al
callq 0x35d40
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlNum.c
// Function: sqlDoubleInList
double sqlDoubleInList(char **pS)
/* Convert string to a double.  Assumes all of string is number
 * and aborts on an error.
 * Number may be delimited by a comma.
 * Returns the position of the delimiter or the terminating 0. */
{
char *s = *pS;
char* end;
double val = strtod(s, &end);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6500
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x563cb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x563fd
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x563fd
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x563eb
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x88156(%rip), %rdi     # 0xde54c
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteArray
int sqlByteArray(char *s, signed char *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlSigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56455
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56455
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x56457
jmp 0x564ab
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x56482
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x55e00
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5643a
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteStaticArray
void sqlByteStaticArray(char *s, signed char **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static signed char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x564ee
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x564f3
jmp 0x565a3
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5651e
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
cmpl 0xb4069(%rip), %eax     # 0x10a590
jb 0x56574
cmpl $0x0, 0xb4060(%rip)     # 0x10a590
jne 0x5653e
movl $0x40, 0xb4054(%rip)    # 0x10a590
jmp 0x5654c
movl 0xb404c(%rip), %eax     # 0x10a590
shll %eax
movl %eax, 0xb4044(%rip)     # 0x10a590
movq 0xb4035(%rip), %rdi     # 0x10a588
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x0, %rsi
movl 0xb402e(%rip), %eax     # 0x10a590
movl %eax, %edx
shlq $0x0, %rdx
callq 0x40ce0
movq %rax, 0xb4014(%rip)     # 0x10a588
movq -0x8(%rbp), %rdi
callq 0x55e00
movb %al, %dl
movq 0xb4002(%rip), %rax     # 0x10a588
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x564db
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0xb3fd5(%rip), %rcx     # 0x10a588
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlByteDynamicArray
void sqlByteDynamicArray(char *s, signed char **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
signed char *array = NULL;
int count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56666
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x2e6e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x56664
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x409d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x55ee0
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56652
jmp 0x56662
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56660
jmp 0x56662
jmp 0x56619
jmp 0x56664
jmp 0x56666
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteArray
int sqlUbyteArray(char *s, unsigned char *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlUnsigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x566b5
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x566b5
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x566b7
jmp 0x5670b
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x566e2
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x55b40
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5669a
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteStaticArray
void sqlUbyteStaticArray(char *s, unsigned char **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static unsigned char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5674e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56753
jmp 0x56803
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5677e
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
cmpl 0xb3e19(%rip), %eax     # 0x10a5a0
jb 0x567d4
cmpl $0x0, 0xb3e10(%rip)     # 0x10a5a0
jne 0x5679e
movl $0x40, 0xb3e04(%rip)    # 0x10a5a0
jmp 0x567ac
movl 0xb3dfc(%rip), %eax     # 0x10a5a0
shll %eax
movl %eax, 0xb3df4(%rip)     # 0x10a5a0
movq 0xb3de5(%rip), %rdi     # 0x10a598
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x0, %rsi
movl 0xb3dde(%rip), %eax     # 0x10a5a0
movl %eax, %edx
shlq $0x0, %rdx
callq 0x40ce0
movq %rax, 0xb3dc4(%rip)     # 0x10a598
movq -0x8(%rbp), %rdi
callq 0x55b40
movb %al, %dl
movq 0xb3db2(%rip), %rax     # 0x10a598
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5673b
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0xb3d85(%rip), %rcx     # 0x10a598
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlUbyteDynamicArray
void sqlUbyteDynamicArray(char *s, unsigned char **retArray, int *retSize)
/* Convert comma separated list of numbers to an dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
unsigned char *array = NULL;
int count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x568c6
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x2e6e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x568c4
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x409d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x55b70
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x568b2
jmp 0x568c2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x568c0
jmp 0x568c2
jmp 0x56879
jmp 0x568c4
jmp 0x568c6
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharArray
int sqlCharArray(char *s, char *array, int arraySize)
/* Convert comma separated list of chars to an array.  Pass in 
 * array and max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = s[0];
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56915
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56915
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x56917
jmp 0x56966
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x56942
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x568fa
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharStaticArray
void sqlCharStaticArray(char *s, char **retArray, int *retSize)
/* Convert comma separated list of chars to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static char *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5699e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x569a3
jmp 0x56a4e
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x569ce
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
cmpl 0xb3bd9(%rip), %eax     # 0x10a5b0
jb 0x56a24
cmpl $0x0, 0xb3bd0(%rip)     # 0x10a5b0
jne 0x569ee
movl $0x40, 0xb3bc4(%rip)    # 0x10a5b0
jmp 0x569fc
movl 0xb3bbc(%rip), %eax     # 0x10a5b0
shll %eax
movl %eax, 0xb3bb4(%rip)     # 0x10a5b0
movq 0xb3ba5(%rip), %rdi     # 0x10a5a8
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x0, %rsi
movl 0xb3b9e(%rip), %eax     # 0x10a5b0
movl %eax, %edx
shlq $0x0, %rdx
callq 0x40ce0
movq %rax, 0xb3b84(%rip)     # 0x10a5a8
movq -0x8(%rbp), %rax
movb (%rax), %dl
movq 0xb3b77(%rip), %rax     # 0x10a5a8
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5698b
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0xb3b4a(%rip), %rcx     # 0x10a5a8
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlCharDynamicArray
void sqlCharDynamicArray(char *s, char **retArray, int *retSize)
/* Convert comma separated list of chars to a dynamically allocated
 * array, which should be freeMem()'d when done. Thread-safe. */
{
char *array = NULL;
int count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56b97
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x2e6e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x56b95
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x409d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x56aeb
leaq 0x87a7b(%rip), %rdi     # 0xde55f
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56b67
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x56b67
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x56b55
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rsi
leaq 0x87a41(%rip), %rdi     # 0xde5a1
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56b80
jmp 0x56b93
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56b8e
jmp 0x56b93
jmp 0x56ad1
jmp 0x56b95
jmp 0x56b97
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortArray
int sqlShortArray(char *s, short *array, int arraySize)
/* Convert comma separated list of numbers to an array.  Pass in 
 * array an max size of array. */
{
unsigned count = 0;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
	break;
    e = strchr(s, ',');
    if (e != NULL)
	*e++ = 0;
    array[count++] = sqlSigned(s);
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56bf5
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56bf5
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x56bf7
jmp 0x56c4d
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x56c22
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x55e00
movw %ax, %dx
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56bda
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/sqlList.c
// Function: sqlShortStaticArray
void sqlShortStaticArray(char *s, short **retArray, int *retSize)
/* Convert comma separated list of numbers to an array which will be
 * overwritten next call to this function, but need not be freed. */
{
static short *array = NULL;
static unsigned alloc = 0;
unsigned count = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56c8e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x56c93
jmp 0x56d43
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x56cbe
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl -0x1c(%rbp), %eax
cmpl 0xb38f9(%rip), %eax     # 0x10a5c0
jb 0x56d12
cmpl $0x0, 0xb38f0(%rip)     # 0x10a5c0
jne 0x56cde
movl $0x40, 0xb38e4(%rip)    # 0x10a5c0
jmp 0x56cec
movl 0xb38dc(%rip), %eax     # 0x10a5c0
shll %eax
movl %eax, 0xb38d4(%rip)     # 0x10a5c0
movq 0xb38c5(%rip), %rdi     # 0x10a5b8
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq %rsi
movl 0xb38bf(%rip), %eax     # 0x10a5c0
movl %eax, %edx
shlq %rdx
callq 0x40ce0
movq %rax, 0xb38a6(%rip)     # 0x10a5b8
movq -0x8(%rbp), %rdi
callq 0x55e00
movw %ax, %dx
movq 0xb3893(%rip), %rax     # 0x10a5b8
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56c7b
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0xb3865(%rip), %rcx     # 0x10a5b8
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq