LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_soundex
static int jx9Builtin_soundex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn;
	char zResult[8];
	int i, j;
	static const unsigned char iCode[] = {
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
		0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 
		1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 
		0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 
		1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 
	};
	if( nArg < 1 ){
		/* Missing arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	zIn = (unsigned char *)jx9_value_to_string(apArg[0], 0);
	for(i=0; zIn[i] && zIn[i] < 0xc0 && !SyisAlpha(zIn[i]); i++){}
	if( zIn[i] ){
		unsigned char prevcode = iCode[zIn[i]&0x7f];
		zResult[0] = (char)SyToUpper(zIn[i]);
		for(j=1; j<4 && zIn[i]; i++){
			int code = iCode[zIn[i]&0x7f];
			if( code>0 ){
				if( code!=prevcode ){
					prevcode = (unsigned char)code;
					zResult[j++] = (char)code + '0';
				}
			}else{
				prevcode = 0;
			}
		}
		while( j<4 ){
			zResult[j++] = '0';
		}
		jx9_result_string(pCtx, zResult, 4);
	}else{
	  jx9_result_string(pCtx, "?000", 4);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
testl %esi, %esi
jle 0x5706d
movq (%rdx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x30577
movq %rax, %r14
movb (%rax), %r12b
leal -0x1(%r12), %eax
cmpb $-0x42, %al
ja 0x5705e
callq 0xc170
movq (%rax), %rax
xorl %r15d, %r15d
movzbl %r12b, %ebx
testb $0x4, 0x1(%rax,%rbx,2)
jne 0x5708f
movb 0x1(%r14,%r15), %r12b
incq %r15
leal -0x1(%r12), %ecx
cmpb $-0x41, %cl
jb 0x57041
testb %r12b, %r12b
je 0x5707f
movq %r13, -0x38(%rbp)
movzbl %r12b, %ebx
jmp 0x57093
movq 0x8(%r13), %rdi
leaq 0x205fa(%rip), %rsi     # 0x77672
xorl %edx, %edx
jmp 0x57129
movq 0x8(%r13), %rdi
leaq 0x1fefd(%rip), %rsi     # 0x76f87
jmp 0x57124
movq %r13, -0x38(%rbp)
movzbl %r12b, %eax
andl $0x7f, %eax
leaq 0x1be2f(%rip), %r12     # 0x72ed0
movb (%rax,%r12), %r13b
callq 0xc350
movq (%rax), %rax
movb (%rax,%rbx,4), %al
movb %al, -0x30(%rbp)
movl %r15d, %eax
addq %rax, %r14
movl $0x1, %eax
movzbl (%r14), %ecx
testq %rcx, %rcx
je 0x570f9
andl $0x7f, %ecx
movb (%rcx,%r12), %cl
testb %cl, %cl
je 0x570dc
cmpb %r13b, %cl
jne 0x570e0
movl %r13d, %ecx
jmp 0x570ec
xorl %ecx, %ecx
jmp 0x570ec
leal 0x30(%rcx), %edx
movslq %eax, %rsi
incl %eax
movb %dl, -0x30(%rbp,%rsi)
incq %r14
movl %ecx, %r13d
cmpl $0x4, %eax
jl 0x570be
jmp 0x57118
movslq %eax, %rcx
leaq (%rcx,%rbp), %rdi
addq $-0x30, %rdi
movl $0x3, %edx
subl %eax, %edx
incq %rdx
movl $0x30, %esi
callq 0xc360
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_wordwrap
static int jx9Builtin_wordwrap(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd, *zBreak;
	int iLen, iBreaklen, iChunk;
	if( nArg < 1 ){
		/* Missing arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &iLen);
	if( iLen < 1 ){
		/* Nothing to process, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Chunk length */
	iChunk = 75;
	iBreaklen = 0;
	zBreak = ""; /* cc warning */
	if( nArg > 1 ){
		iChunk = jx9_value_to_int(apArg[1]);
		if( iChunk < 1 ){
			iChunk = 75;
		}
		if( nArg > 2 ){
			zBreak = jx9_value_to_string(apArg[2], &iBreaklen);
		}
	}
	if( iBreaklen < 1 ){
		/* Set a default column break */
#ifdef __WINNT__
		zBreak = "\r\n";
		iBreaklen = (int)sizeof("\r\n")-1;
#else
		zBreak = "\n";
		iBreaklen = (int)sizeof(char);
#endif
	}
	/* Perform the requested operation */
	zEnd = &zIn[iLen];
	for(;;){
		int nMax;
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		nMax = (int)(zEnd-zIn);
		if( iChunk > nMax ){
			iChunk = nMax;
		}
		/* Append the column first */
		jx9_result_string(pCtx, zIn, iChunk); /* Will make it's own copy */
		/* Advance the cursor */
		zIn += iChunk;
		if( zIn < zEnd ){
			/* Append the line break */
			jx9_result_string(pCtx, zBreak, iBreaklen);
		}
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x571ca
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x30577
cmpl $0x0, (%r13)
jle 0x571ca
movl $0x0, -0x2c(%rbp)
movl $0x4b, %r13d
cmpl $0x1, %r12d
je 0x571f0
movq %rax, %r14
movq 0x8(%r15), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
testl %eax, %eax
movl $0x4b, %r13d
cmovgl %eax, %r13d
cmpl $0x3, %r12d
jb 0x571ed
movq 0x10(%r15), %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x571ed
movq %rax, %r15
movq %r14, %rax
jmp 0x571fe
movq 0x8(%rbx), %rdi
leaq 0x2049d(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
movl $0x1, -0x2c(%rbp)
leaq 0x210e3(%rip), %r15     # 0x782e1
movslq -0x30(%rbp), %r14
testq %r14, %r14
jle 0x571dc
cmpl %r14d, %r13d
movl %r14d, %r12d
cmovll %r13d, %r12d
movq 0x8(%rbx), %rdi
movq %rax, %rsi
movl %r12d, %edx
movq %rax, -0x38(%rbp)
callq 0x302f6
movq -0x38(%rbp), %rax
cmpl %r14d, %r13d
jge 0x571dc
addq %rax, %r14
movslq %r12d, %r13
addq %rax, %r13
movl -0x2c(%rbp), %edx
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x302f6
movl %r14d, %eax
subl %r13d, %eax
cmpl %eax, %r12d
cmovgel %eax, %r12d
movq 0x8(%rbx), %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x302f6
movslq %r12d, %rax
addq %rax, %r13
cmpq %r14, %r13
jb 0x57236
jmp 0x571dc
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_parse_ini_string
static int jx9Builtin_parse_ini_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIni;
	int nByte;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the raw INI buffer */
	zIni = jx9_value_to_string(apArg[0], &nByte);
	/* Process the INI buffer*/
	jx9ParseIniString(pCtx, zIni, (sxu32)nByte, (nArg > 1) ? jx9_value_to_bool(apArg[1]) : 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x57c45
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x57c68
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x57ca3
movl %esi, %r15d
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x30577
movq %rax, %r12
movl (%r13), %r13d
xorl %ecx, %ecx
cmpl $0x1, %r15d
je 0x57c95
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x438dd
movl (%r14), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x5bb37
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_alnum
static int jx9Builtin_ctype_alnum(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( !SyisAlphaNum(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x57d11
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x57d11
movq %rax, %r14
addq %rax, %r15
callq 0xc170
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x8, (%rax,%rcx,2)
je 0x57d11
incq %r14
cmpq %r15, %r14
jb 0x57cea
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x57d24
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_alpha
static int jx9Builtin_ctype_alpha(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( !SyisAlpha(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x57d9d
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x57d9d
movq %rax, %r14
addq %rax, %r15
callq 0xc170
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x57d9d
incq %r14
cmpq %r15, %r14
jb 0x57d75
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x57db0
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_cntrl
static int jx9Builtin_ctype_cntrl(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( zIn[0] >= 0xc0 ){
			/* UTF-8 stream  */
			break;
		}
		if( !SyisCtrl(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x57e37
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x57e37
movq %rax, %r14
addq %rax, %r15
movzbl (%r14), %r12d
cmpq $0xbf, %r12
ja 0x57e37
callq 0xc170
movq (%rax), %rax
testb $0x2, (%rax,%r12,2)
je 0x57e37
incq %r14
cmpq %r15, %r14
jb 0x57dfe
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x57e4a
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ctype_print
static int jx9Builtin_ctype_print(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn  = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* If we reach the end of the string, then the test succeeded. */
			jx9_result_bool(pCtx, 1);
			return JX9_OK;
		}
		if( zIn[0] >= 0xc0 ){
			/* UTF-8 stream  */
			break;
		}
		if( !SyisPrint(zIn[0]) ){
			break;
		}
		/* Point to the next character */
		zIn++;
	}
	/* The test failed, return FALSE */
	jx9_result_bool(pCtx, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x580ab
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x580ab
movq %rax, %r14
addq %rax, %r15
movzbl (%r14), %r12d
cmpq $0xbf, %r12
ja 0x580ab
callq 0xc170
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r12,2)
je 0x580ab
incq %r14
cmpq %r15, %r14
jb 0x58071
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x580be
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_microtime
static int jx9Builtin_microtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bFloat = 0;
	sytime sTime;	
#if defined(__UNIXES__)
	struct timeval tv;
	gettimeofday(&tv, 0);
	sTime.tm_sec  = (long)tv.tv_sec;
	sTime.tm_usec = (long)tv.tv_usec;
#else
	time_t tt;
	time(&tt);
	sTime.tm_sec  = (long)tt;
	sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
	if( nArg > 0 ){
		bFloat = jx9_value_to_bool(apArg[0]);
	}
	if( bFloat ){
		/* Return as float */
		jx9_result_double(pCtx, (double)sTime.tm_sec);
	}else{
		/* Return as string */
		jx9_result_string_format(pCtx, "%ld %ld", sTime.tm_usec, sTime.tm_sec);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xc5a0
movq (%r15), %r14
movq 0x8(%r15), %r15
testl %r13d, %r13d
jle 0x583ef
movq (%r12), %r12
movq %r12, %rdi
callq 0x438dd
cmpl $0x0, (%r12)
je 0x583ef
cvtsi2sd %r14, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x43f5f
jmp 0x58406
leaq 0x1959f(%rip), %rsi     # 0x71995
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x44e00
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_gettimeofday
static int jx9Builtin_gettimeofday(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bFloat = 0;
	sytime sTime;
#if defined(__UNIXES__)
	struct timeval tv;
	gettimeofday(&tv, 0);
	sTime.tm_sec  = (long)tv.tv_sec;
	sTime.tm_usec = (long)tv.tv_usec;
#else
	time_t tt;
	time(&tt);
	sTime.tm_sec  = (long)tt;
	sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
	if( nArg > 0 ){
		bFloat = jx9_value_to_bool(apArg[0]);
	}
	if( bFloat ){
		/* Return as float */
		jx9_result_double(pCtx, (double)sTime.tm_sec);
	}else{
		/* Return an associative array */
		jx9_value *pValue, *pArray;
		/* Create a new array */
		pArray = jx9_context_new_array(pCtx);
		/* Element value */
		pValue = jx9_context_new_scalar(pCtx);
		if( pValue == 0 || pArray == 0 ){
			/* Return NULL */
			jx9_result_null(pCtx);
			return JX9_OK;
		}
		/* Fill the array */
		/* sec */
		jx9_value_int64(pValue, sTime.tm_sec);
		jx9_array_add_strkey_elem(pArray, "sec", pValue);
		/* usec */
		jx9_value_int64(pValue, sTime.tm_usec);
		jx9_array_add_strkey_elem(pArray, "usec", pValue);
		/* Return the array */
		jx9_result_value(pCtx, pArray);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xc5a0
movq (%r12), %r13
movq 0x8(%r12), %r12
testl %r15d, %r15d
jle 0x58809
movq (%r14), %r14
movq %r14, %rdi
callq 0x438dd
cmpl $0x0, (%r14)
je 0x58809
cvtsi2sd %r13, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x43f5f
jmp 0x5889f
movq %rbx, %rdi
callq 0x31231
movq %rax, %r14
movq %rbx, %rdi
callq 0x311eb
movq %rax, %r15
testq %rax, %rax
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
je 0x58896
movq %r15, %rdi
callq 0x30465
movq %r13, (%r15)
movl $0xfffffe90, %r13d      # imm = 0xFFFFFE90
movl 0x8(%r15), %eax
andl %r13d, %eax
orl $0x2, %eax
movl %eax, 0x8(%r15)
leaq 0x1e8ba(%rip), %rsi     # 0x7710f
movq %r14, %rdi
movq %r15, %rdx
callq 0x30ad3
movq %r15, %rdi
callq 0x30465
movq %r12, (%r15)
andl 0x8(%r15), %r13d
orl $0x2, %r13d
movl %r13d, 0x8(%r15)
leaq 0x1e7c7(%rip), %rsi     # 0x77045
movq %r14, %rdi
movq %r15, %rdx
callq 0x30ad3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x307f4
jmp 0x5889f
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_date
static int jx9Builtin_date(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	int nLen;
	Sytm sTm;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Don't bother processing return the empty string */
		jx9_result_string(pCtx, "", 0);
	}
	if( nArg < 2 ){
#ifdef __WINNT__
		SYSTEMTIME sOS;
		GetSystemTime(&sOS);
		SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
		struct tm *pTm;
		time_t t;
		time(&t);
		pTm = localtime(&t);
		STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	}else{
		/* Use the given timestamp */
		time_t t;
		struct tm *pTm;
		if( jx9_value_is_int(apArg[1]) ){
			t = (time_t)jx9_value_to_int64(apArg[1]);
			pTm = localtime(&t);
			if( pTm == 0 ){
				time(&t);
			}
		}else{
			time(&t);
		}
		pTm = localtime(&t);
		STRUCT_TM_TO_SYTM(pTm, &sTm);
	}
	/* Format the given string */
	DateFormat(pCtx, zFormat, nLen, &sTm);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x588d4
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x588fa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x589c8
movl %esi, %r12d
leaq -0x34(%rbp), %r13
movq %r13, %rsi
callq 0x30577
movq %rax, %r14
cmpl $0x0, (%r13)
jg 0x58925
movq 0x8(%rbx), %rdi
leaq 0x1ed54(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
cmpl $0x1, %r12d
jne 0x5893c
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0xc820
movq %r15, %rdi
jmp 0x58970
movq 0x8(%r15), %r15
testb $0x2, 0x8(%r15)
je 0x58963
movq %r15, %rdi
callq 0x3f362
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0xc770
testq %rax, %rax
jne 0x5896c
leaq -0x30(%rbp), %rdi
callq 0xc820
leaq -0x30(%rbp), %rdi
callq 0xc770
movl 0x8(%rax), %ecx
movl %ecx, -0x68(%rbp)
movl 0x4(%rax), %ecx
movl %ecx, -0x6c(%rbp)
movl (%rax), %ecx
movl %ecx, -0x70(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x60(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x64(%rbp)
movl $0x76c, %ecx            # imm = 0x76C
addl 0x14(%rax), %ecx
movl %ecx, -0x5c(%rbp)
movl 0x1c(%rax), %ecx
movl %ecx, -0x54(%rbp)
movl 0x18(%rax), %ecx
movl %ecx, -0x58(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x50(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
movl -0x34(%rbp), %edx
leaq -0x70(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c347
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_mktime
static int jx9Builtin_mktime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFunction;
	jx9_int64 iVal = 0;
	struct tm *pTm;
	time_t t;
	/* Extract function name */
	zFunction = jx9_function_name(pCtx);
	/* Get the current time */
	time(&t);
	if( zFunction[0] == 'g' /* gmmktime */ ){
		pTm = gmtime(&t);
	}else{
		/* localtime */
		pTm = localtime(&t);
	}
	if( nArg > 0 ){
		int iVal;
		/* Hour */
		iVal = jx9_value_to_int(apArg[0]);
		pTm->tm_hour = iVal;
		if( nArg > 1 ){
			/* Minutes */
			iVal = jx9_value_to_int(apArg[1]);
			pTm->tm_min = iVal;
			if( nArg > 2 ){
				/* Seconds */
				iVal = jx9_value_to_int(apArg[2]);
				pTm->tm_sec = iVal;
				if( nArg > 3 ){
					/* Month */
					iVal = jx9_value_to_int(apArg[3]);
					pTm->tm_mon = iVal - 1;
					if( nArg > 4 ){
						/* mday */
						iVal = jx9_value_to_int(apArg[4]);
						pTm->tm_mday = iVal;
						if( nArg > 5 ){
							/* Year */
							iVal = jx9_value_to_int(apArg[5]);
							if( iVal > 1900 ){
								iVal -= 1900;
							}
							pTm->tm_year = iVal;
							if( nArg > 6 ){
								/* is_dst */
								iVal = jx9_value_to_bool(apArg[6]);
								pTm->tm_isdst = iVal;
							}
						}
					}
				}
			}
		}
	}
	/* Make the time */
	iVal = (jx9_int64)mktime(pTm);
	/* Return the timesatmp as a 64bit integer */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r12
leaq -0x30(%rbp), %rdi
callq 0xc820
cmpb $0x67, (%r12)
jne 0x59751
leaq -0x30(%rbp), %rdi
callq 0xc2f0
jmp 0x5975a
leaq -0x30(%rbp), %rdi
callq 0xc770
movq %rax, %r12
testl %r15d, %r15d
jle 0x59832
movq (%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
movl %eax, 0x8(%r12)
cmpl $0x1, %r15d
je 0x59832
movq 0x8(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
movl %eax, 0x4(%r12)
cmpl $0x3, %r15d
jb 0x59832
movq 0x10(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
movl %eax, (%r12)
cmpl $0x3, %r15d
je 0x59832
movq 0x18(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
decl %eax
movl %eax, 0x10(%r12)
cmpl $0x5, %r15d
jb 0x59832
movq 0x20(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
movl %eax, 0xc(%r12)
cmpl $0x5, %r15d
je 0x59832
movq 0x28(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %eax
leal -0x76c(%rax), %ecx
cmpl $0x76d, %eax            # imm = 0x76D
cmovll %eax, %ecx
movl %ecx, 0x14(%r12)
cmpl $0x7, %r15d
jb 0x59832
movq 0x30(%r14), %r14
movq %r14, %rdi
callq 0x438dd
movl (%r14), %eax
movl %eax, 0x20(%r12)
movq %r12, %rdi
callq 0xc450
movq %rax, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base64_encode
static int jx9Builtin_base64_encode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the BASE64 encoding */
	SyBase64Encode(zIn, (sxu32)nLen, Consumer, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x59980
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movl (%r15), %r12d
testl %r12d, %r12d
jle 0x59980
movq %rax, %r14
xorl %r13d, %r13d
cmpl $0x3, %r12d
jb 0x59938
movl $0x2, %r13d
leaq 0x1e5e4(%rip), %r15     # 0x77ea0
leal -0x2(%r13), %eax
movzbl (%r14,%rax), %eax
movl %eax, %ecx
shrl $0x2, %ecx
movb (%rcx,%r15), %cl
movb %cl, -0x2c(%rbp)
leal -0x1(%r13), %ecx
movb (%r14,%rcx), %cl
shlb $0x4, %al
movl %ecx, %edx
shrb $0x4, %dl
orb %al, %dl
movzbl %dl, %eax
andl $0x3f, %eax
movb (%rax,%r15), %al
movb %al, -0x2b(%rbp)
movl %r13d, %eax
movzbl (%r14,%rax), %eax
shlb $0x2, %cl
movl %eax, %edx
shrb $0x6, %dl
orb %cl, %dl
movzbl %dl, %ecx
andl $0x3f, %ecx
movb (%rcx,%r15), %cl
movb %cl, -0x2a(%rbp)
andl $0x3f, %eax
movb (%rax,%r15), %al
movb %al, -0x29(%rbp)
movq 0x8(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
movl $0x4, %edx
callq 0x302f6
addl $0x3, %r13d
cmpl %r12d, %r13d
jb 0x598bc
addl $-0x2, %r13d
leal 0x1(%r13), %eax
cmpl %r12d, %eax
jae 0x599a3
movl %r13d, %ecx
movzbl (%r14,%rcx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
leaq 0x1e54b(%rip), %rsi     # 0x77ea0
movb (%rdx,%rsi), %dl
movb %dl, -0x2c(%rbp)
movl %eax, %eax
movzbl (%r14,%rax), %eax
shlb $0x4, %cl
movl %eax, %edx
shrb $0x4, %dl
orb %cl, %dl
movzbl %dl, %ecx
andl $0x3f, %ecx
movb (%rcx,%rsi), %cl
movb %cl, -0x2b(%rbp)
andl $0xf, %eax
movb (%rsi,%rax,4), %al
jmp 0x599d0
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x599e9
cmpl %r12d, %r13d
jae 0x599e9
movl %r13d, %eax
movzbl (%r14,%rax), %eax
movl %eax, %ecx
shrl $0x2, %ecx
leaq 0x1e4e4(%rip), %rdx     # 0x77ea0
movb (%rcx,%rdx), %cl
movb %cl, -0x2c(%rbp)
shll $0x4, %eax
andl $0x30, %eax
movb (%rax,%rdx), %al
movb %al, -0x2b(%rbp)
movb $0x3d, %al
leaq -0x2c(%rbp), %rsi
movb %al, 0x2(%rsi)
movb $0x3d, 0x3(%rsi)
movq 0x8(%rbx), %rdi
movl $0x4, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base64_decode
static int jx9Builtin_base64_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the BASE64 decoding */
	SyBase64Decode(zIn, (sxu32)nLen, Consumer, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x59a3b
movq (%rdx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r12
testq %r12, %r12
jle 0x59a3b
movq %rax, %r14
cmpb $0x3d, -0x1(%r14,%r12)
jne 0x59a6d
decq %r12
jne 0x59a2c
jmp 0x59a5c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cmpq $0x4, %r12
jb 0x59b16
xorl %r15d, %r15d
leaq 0x1953d(%rip), %r13     # 0x72fc0
leal 0x3(%r15), %esi
movl %r15d, %eax
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
movl (%r13,%rax,4), %edx
leal 0x1(%r15), %eax
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
movl (%r13,%rax,4), %eax
leal 0x2(%r15), %ecx
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%r13,%rcx,4), %ecx
movzbl (%r14,%rsi), %esi
andl $0x7f, %esi
movl (%r13,%rsi,4), %esi
movl %eax, %edi
shrl $0x4, %edi
andl $0x3, %edi
leal (%rdi,%rdx,4), %edx
movb %dl, -0x32(%rbp)
shll $0x4, %eax
movl %ecx, %edx
shrl $0x2, %edx
andl $0xf, %edx
orl %eax, %edx
movb %dl, -0x31(%rbp)
shll $0x6, %ecx
andl $0x3f, %esi
orl %ecx, %esi
movb %sil, -0x30(%rbp)
movq 0x8(%rbx), %rdi
leaq -0x32(%rbp), %rsi
movl $0x3, %edx
callq 0x302f6
leal 0x4(%r15), %eax
addl $0x7, %r15d
cmpl %r12d, %r15d
movl %eax, %r15d
jb 0x59a83
movl %eax, %eax
movq %rax, %rcx
orq $0x2, %rcx
cmpl %r12d, %ecx
jae 0x59b70
movzbl (%r14,%rax), %edx
andl $0x7f, %edx
leaq 0x1948d(%rip), %rsi     # 0x72fc0
movl (%rsi,%rdx,4), %edx
movzbl 0x1(%r14,%rax), %eax
andl $0x7f, %eax
movl (%rsi,%rax,4), %eax
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%rsi,%rcx,4), %ecx
movl %eax, %esi
shrl $0x4, %esi
andl $0x3, %esi
leal (%rsi,%rdx,4), %edx
movb %dl, -0x32(%rbp)
shll $0x4, %eax
shrl $0x2, %ecx
andl $0xf, %ecx
orl %eax, %ecx
movb %cl, -0x31(%rbp)
movl $0x2, %edx
jmp 0x59bae
movq %rax, %rcx
orq $0x1, %rcx
cmpl %r12d, %ecx
jae 0x59a5c
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
leaq 0x19431(%rip), %rdx     # 0x72fc0
movl (%rdx,%rax,4), %eax
movzbl (%r14,%rcx), %ecx
andl $0x7f, %ecx
movl (%rdx,%rcx,4), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leal (%rcx,%rax,4), %eax
movb %al, -0x32(%rbp)
movl $0x1, %edx
movq 0x8(%rbx), %rdi
leaq -0x32(%rbp), %rsi
callq 0x302f6
jmp 0x59a5c
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_urlencode
static int jx9Builtin_urlencode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the URL encoding */
	SyUriEncode(zIn, (sxu32)nLen, Consumer, pCtx);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x59ce1
movq (%rdx), %rdi
leaq -0x44(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movslq (%r15), %r15
testq %r15, %r15
jle 0x59ce1
movq %rax, %r14
leaq -0x2c(%rbp), %rax
movb $0x0, 0x2(%rax)
movw $0x25, (%rax)
addq %r14, %r15
callq 0xc170
leaq 0x19c2b(%rip), %rsi     # 0x73841
movabsq $0x800000000000601, %r12 # imm = 0x800000000000601
movq %rbx, -0x38(%rbp)
movq (%rax), %rdx
xorl %r13d, %r13d
movzbl (%r14,%r13), %ebx
movzwl (%rdx,%rbx,2), %ecx
testb $0x8, %cl
jne 0x59c48
movl %ebx, %ecx
addl $-0x24, %ecx
cmpl $0x3b, %ecx
ja 0x59c5c
btq %rcx, %r12
jae 0x59c5c
leaq (%r14,%r13), %rcx
incq %rcx
incq %r13
cmpq %r15, %rcx
jb 0x59c2a
jmp 0x59d04
movq %rax, -0x40(%rbp)
testq %r13, %r13
je 0x59c7f
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x302f6
leaq 0x19bc2(%rip), %rsi     # 0x73841
cmpl $0x20, %ebx
jne 0x59c9b
movb $0x2b, -0x2e(%rbp)
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rdi
leaq -0x2e(%rbp), %rsi
movl $0x1, %edx
jmp 0x59cc0
movl %ebx, %eax
shrl $0x4, %eax
movb (%rax,%rsi), %al
movb %al, -0x2b(%rbp)
andl $0xf, %ebx
movb (%rbx,%rsi), %al
movb %al, -0x2a(%rbp)
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
movl $0x3, %edx
callq 0x302f6
addq %r13, %r14
incq %r14
cmpq %r15, %r14
movq -0x40(%rbp), %rax
leaq 0x19b68(%rip), %rsi     # 0x73841
jb 0x59c24
jmp 0x59d17
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x59d17
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x302f6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_urldecode
static int jx9Builtin_urldecode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the input string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the URL decoding */
	SyUriDecode(zIn, (sxu32)nLen, Consumer, pCtx, TRUE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x59d64
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %esi
testl %esi, %esi
jle 0x59d64
leaq 0x2b0c(%rip), %rdx      # 0x5c863
movq %rax, %rdi
movq %rbx, %rcx
callq 0x473ab
jmp 0x59d85
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyStrncmp
JX9_PRIVATE sxi32 SyStrncmp(const char *zLeft, const char *zRight, sxu32 nLen)
{
	const unsigned char *zP = (const unsigned char *)zLeft;
	const unsigned char *zQ = (const unsigned char *)zRight;

	if( SX_EMPTY_STR(zP) || SX_EMPTY_STR(zQ)  ){
			return SX_EMPTY_STR(zP) ? (SX_EMPTY_STR(zQ) ? 0 : -1) :1;
	}
	if( nLen <= 0 ){
		return 0;
	}
	for(;;){
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
		if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
	}
	return (sxi32)(zP[0] - zQ[0]);
}

// Assembly:
testq %rdi, %rdi
je 0x59db2
movb (%rdi), %cl
testb %cl, %cl
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
je 0x59dc2
movl $0x1, %eax
testb %cl, %cl
je 0x59db2
retq
testq %rsi, %rsi
je 0x59e40
xorl %eax, %eax
cmpb (%rsi), %al
sbbl %eax, %eax
retq
cmpb $0x0, (%rsi)
je 0x59e43
testl %edx, %edx
je 0x59e40
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %edx, %r8d
leaq -0x1(%r8), %r9
leaq -0x2(%r8), %r10
leaq -0x3(%r8), %r11
xorl %edx, %edx
movq %rsi, %rcx
movb (%rdi,%rdx), %bl
testb %bl, %bl
je 0x59e49
cmpb (%rsi,%rdx), %bl
jne 0x59e85
cmpl %edx, %r9d
je 0x59e53
movb 0x1(%rdi,%rdx), %bl
testb %bl, %bl
je 0x59e57
cmpb 0x1(%rsi,%rdx), %bl
jne 0x59e5c
xorl %eax, %eax
cmpl %edx, %r10d
je 0x59e8d
movb 0x2(%rdi,%rdx), %bl
testb %bl, %bl
je 0x59e65
cmpb 0x2(%rsi,%rdx), %bl
jne 0x59e6f
cmpl %edx, %r11d
je 0x59e8d
movb 0x3(%rdi,%rdx), %bl
testb %bl, %bl
je 0x59e75
cmpb 0x3(%rsi,%rdx), %bl
jne 0x59e7d
addq $0x4, %rcx
addq $0x4, %rdx
xorl %eax, %eax
cmpl %edx, %r8d
jne 0x59de4
jmp 0x59e8d
xorl %eax, %eax
retq
movl $0x1, %eax
retq
addq %rdx, %rsi
xorl %ebx, %ebx
movq %rsi, %rcx
jmp 0x59e85
xorl %eax, %eax
jmp 0x59e8d
incq %rcx
jmp 0x59e79
leaq (%rsi,%rdx), %rcx
incq %rcx
jmp 0x59e85
leaq (%rsi,%rdx), %rcx
addq $0x2, %rcx
jmp 0x59e79
addq $0x2, %rcx
jmp 0x59e85
addq $0x3, %rcx
xorl %ebx, %ebx
jmp 0x59e85
leaq (%rsi,%rdx), %rcx
addq $0x3, %rcx
movzbl %bl, %eax
movzbl (%rcx), %ecx
subl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: implode_callback
static int implode_callback(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	struct implode_data *pData = (struct implode_data *)pUserData;
	const char *zData;
	int nLen;
	if( pData->bRecursive && jx9_value_is_json_array(pValue) && pData->nRecCount < 32 ){
		if( pData->nSeplen > 0 ){
			if( !pData->bFirst ){
				/* append the separator first */
				jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
			}else{
				pData->bFirst = 0;
			}
		}
		/* Recurse */
		pData->bFirst = 1;
		pData->nRecCount++;
		jx9HashmapWalk((jx9_hashmap *)pValue->x.pOther, implode_callback, pData);
		pData->nRecCount--;
		return JX9_OK;
	}
	/* Extract the string representation of the entry value */
	zData = jx9_value_to_string(pValue, &nLen);
	if( nLen > 0 ){
		if( pData->nSeplen > 0 ){
			if( !pData->bFirst ){
				/* append the separator first */
				jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
			}else{
				pData->bFirst = 0;
			}
		}
		jx9_result_string(pData->pCtx, zData, nLen);
	}else{
		SXUNUSED(pKey); /* cc warning */
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x8(%rdx)
je 0x5a133
testb $0x40, 0x8(%r14)
je 0x5a133
movl 0x20(%rbx), %eax
cmpl $0x1f, %eax
jg 0x5a133
movl 0x18(%rbx), %edx
testl %edx, %edx
jle 0x5a110
cmpl $0x0, 0x1c(%rbx)
jne 0x5a110
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
movq 0x8(%rax), %rdi
callq 0x302f6
movl 0x20(%rbx), %eax
movl $0x1, 0x1c(%rbx)
incl %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rdi
leaq -0x5b(%rip), %rsi       # 0x5a0cb
movq %rbx, %rdx
callq 0x5134a
decl 0x20(%rbx)
jmp 0x5a186
leaq -0x1c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30577
movl (%r15), %edx
testl %edx, %edx
jle 0x5a186
movq %rax, %r14
movl 0x18(%rbx), %eax
testl %eax, %eax
jle 0x5a177
cmpl $0x0, 0x1c(%rbx)
je 0x5a162
movl $0x0, 0x1c(%rbx)
jmp 0x5a177
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movq 0x8(%rcx), %rdi
movl %eax, %edx
callq 0x302f6
movl -0x1c(%rbp), %edx
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x302f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: iPatternMatch
static sxi32 iPatternMatch(const void *pText, sxu32 nLen, const void *pPattern, sxu32 iPatLen, sxu32 *pOfft)
{
	const char *zpIn = (const char *)pPattern;
	const char *zIn = (const char *)pText;
	const char *zpEnd = &zpIn[iPatLen];
	const char *zEnd = &zIn[nLen];
	const char *zPtr, *zPtr2;
	int c, d;
	if( iPatLen > nLen ){
		/* Don't bother processing */
		return SXERR_NOTFOUND;
	}
	for(;;){
		if( zIn >= zEnd ){
			break;
		}
		c = SyToLower(zIn[0]);
		d = SyToLower(zpIn[0]);
		if( c == d ){
			zPtr   = &zIn[1];
			zPtr2  = &zpIn[1];
			for(;;){
				if( zPtr2 >= zpEnd ){
					/* Pattern found */
					if( pOfft ){ *pOfft = (sxu32)(zIn-(const char *)pText); }
					return SXRET_OK;
				}
				if( zPtr >= zEnd ){
					break;
				}
				c = SyToLower(zPtr[0]);
				d = SyToLower(zPtr2[0]);
				if( c != d ){
					break;
				}
				zPtr++; zPtr2++;
			}
		}
		zIn++;
	}
	/* Pattern not found */
	return SXERR_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
cmpl %esi, %ecx
seta %al
testl %esi, %esi
sete %dl
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
orb %al, %dl
jne 0x5a232
movq %rdi, %r15
movq %r8, -0x30(%rbp)
movl %ecx, %r13d
addq %r12, %r13
movl %esi, %r14d
addq %rdi, %r14
callq 0xc4a0
movq (%rax), %rcx
movsbq (%r12), %rax
movl (%rcx,%rax,4), %edx
incq %r12
leaq 0x1(%r15), %rsi
movq %r15, %rax
movsbq (%rax), %rdi
cmpl %edx, (%rcx,%rdi,4)
jne 0x5a215
movq %rsi, %rdi
movq %r12, %r8
cmpq %r13, %r8
jae 0x5a222
cmpq %r14, %rdi
jae 0x5a215
movsbq (%rdi), %r9
movl (%rcx,%r9,4), %r9d
movsbq (%r8), %r10
incq %r8
incq %rdi
cmpl (%rcx,%r10,4), %r9d
je 0x5a1f3
incq %rax
incq %rsi
cmpq %r14, %rax
jb 0x5a1e4
jmp 0x5a232
xorl %ebx, %ebx
movq -0x30(%rbp), %rcx
testq %rcx, %rcx
je 0x5a232
subl %r15d, %eax
movl %eax, (%rcx)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapValuesToSet
JX9_PRIVATE int jx9HashmapValuesToSet(jx9_hashmap *pMap, SySet *pOut)
{
	jx9_hashmap_node *pEntry = pMap->pFirst;
	jx9_value *pValue;
	sxu32 n;
	/* Initialize the container */
	SySetInit(pOut, &pMap->pVm->sAllocator, sizeof(jx9_value *));
	for(n = 0 ; n < pMap->nEntry ; n++ ){
		/* Extract node value */
		pValue = HashmapExtractNodeValue(pEntry);
		if( pValue ){
			SySetPut(pOut, (const void *)&pValue);
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	/* Total inserted entries */
	return (int)SySetUsed(pOut);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
movq (%rdi), %rcx
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x14(%rsi)
xorl %eax, %eax
movl %eax, 0x10(%rsi)
movl %eax, 0x1c(%rsi)
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq %rax, 0x20(%rsi)
movl 0x2c(%rdi), %ecx
testl %ecx, %ecx
je 0x5b1c7
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
movq (%r12), %rdx
movl 0x38(%r12), %eax
movq (%rdx), %rdx
cmpl %eax, 0x218(%rdx)
jbe 0x5b1b7
imull 0x220(%rdx), %eax
movq 0x210(%rdx), %rdx
addq %rdx, %rax
movq %rax, -0x30(%rbp)
testq %rdx, %rdx
je 0x5b1b7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33094
movl 0x2c(%r14), %ecx
movq 0x48(%r12), %r12
incl %r13d
cmpl %ecx, %r13d
jb 0x5b17a
movl 0x10(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9ProcessCsv
JX9_PRIVATE sxi32 jx9ProcessCsv(
	const char *zInput, /* Raw input */
	int nByte,  /* Input length */
	int delim,  /* Delimiter */
	int encl,   /* Enclosure */
	int escape,  /* Escape character */
	sxi32 (*xConsumer)(const char *, int, void *), /* User callback */
	void *pUserData /* Last argument to xConsumer() */
	)
{
	const char *zEnd = &zInput[nByte];
	const char *zIn = zInput;
	const char *zPtr;
	int isEnc;
	/* Start processing */
	for(;;){
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		isEnc = 0;
		zPtr = zIn;
		/* Find the first delimiter */
		while( zIn < zEnd ){
			if( zIn[0] == delim && !isEnc){
				/* Delimiter found, break imediately */
				break;
			}else if( zIn[0] == encl ){
				/* Inside enclosure? */
				isEnc = !isEnc;
			}else if( zIn[0] == escape ){
				/* Escape sequence */
				zIn++;
			}
			/* Advance the cursor */
			zIn++;
		}
		if( zIn > zPtr ){
			int nByte = (int)(zIn-zPtr);
			sxi32 rc;
			/* Invoke the supllied callback */
			if( zPtr[0] == encl ){
				zPtr++;
				nByte-=2;
			}
			if( nByte > 0 ){
				rc = xConsumer(zPtr, nByte, pUserData);
				if( rc == SXERR_ABORT ){
					/* User callback request an operation abort */
					break;
				}
			}
		}
		/* Ignore trailing delimiter */
		while( zIn < zEnd && zIn[0] == delim ){
			zIn++;
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
testl %esi, %esi
jle 0x5b288
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movslq %esi, %r13
addq %rdi, %r13
movq %rdi, %rbx
xorl %eax, %eax
movsbl (%rbx), %ecx
cmpl %r12d, %ecx
jne 0x5b210
testl %eax, %eax
je 0x5b238
xorl %edx, %edx
testl %eax, %eax
sete %dl
cmpl %r14d, %ecx
sete %sil
cmpl %r15d, %ecx
setne %cl
cmovel %edx, %eax
andb %sil, %cl
movzbl %cl, %ecx
addq %rcx, %rbx
incq %rbx
cmpq %r13, %rbx
jb 0x5b204
cmpq %rdi, %rbx
jbe 0x5b26a
movl %ebx, %ecx
subl %edi, %ecx
movsbl (%rdi), %eax
leal -0x2(%rcx), %esi
cmpl %r15d, %eax
cmovnel %ecx, %esi
testl %esi, %esi
jle 0x5b26a
xorl %ecx, %ecx
cmpl %r15d, %eax
sete %cl
addq %rcx, %rdi
movq -0x30(%rbp), %rdx
callq 0x5b297
cmpl $-0xa, %eax
je 0x5b288
cmpq %r13, %rbx
jae 0x5b27c
movsbl (%rbx), %eax
cmpl %r12d, %eax
jne 0x5b27c
incq %rbx
jmp 0x5b26a
movq %rbx, %rdi
cmpq %r13, %rbx
jb 0x5b202
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9CsvConsumer
JX9_PRIVATE sxi32 jx9CsvConsumer(const char *zToken, int nTokenLen, void *pUserData)
{
	jx9_value *pArray = (jx9_value *)pUserData;
	jx9_value sEntry;
	SyString sToken;
	/* Insert the token in the given array */
	SyStringInitFromBuf(&sToken, zToken, nTokenLen);
	/* Remove trailing and leading white spcaces and null bytes */
	SyStringFullTrimSafe(&sToken);
	if( sToken.nByte < 1){
		return SXRET_OK;
	}
	jx9MemObjInitFromString(pArray->pVm, &sEntry, &sToken);
	jx9_array_add_elem(pArray, 0, &sEntry);
	jx9MemObjRelease(&sEntry);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x40(%rbp)
movl %esi, -0x38(%rbp)
testl %esi, %esi
je 0x5b3b6
movq %rdx, %rbx
movq %rdi, %r14
movl -0x38(%rbp), %r15d
movb (%rdi), %r12b
cmpb $-0x41, %r12b
ja 0x5b31b
incq %r14
decl %esi
movl %esi, %r13d
testb %r12b, %r12b
je 0x5b2ee
callq 0xc170
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5b3c7
movq %r14, -0x40(%rbp)
movl %r13d, %esi
subl $0x1, %esi
jb 0x5b3ad
movb (%r14), %r12b
incq %r14
movl %r13d, %r15d
cmpb $-0x41, %r12b
jbe 0x5b2cf
movq %rbx, -0x30(%rbp)
decq %r14
incl %esi
movl %esi, %r15d
jmp 0x5b31f
movq %rbx, -0x30(%rbp)
movl %r15d, -0x38(%rbp)
leal -0x1(%rsi), %eax
movb (%r14,%rax), %r13b
cmpb $-0x41, %r13b
ja 0x5b375
movl %esi, %r12d
leal -0x1(%r12), %eax
addq $-0x2, %r12
movl %eax, %ebx
testb %r13b, %r13b
je 0x5b356
callq 0xc170
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5b375
movl %ebx, %eax
subl $0x1, %eax
jb 0x5b3b3
movl %r12d, %ecx
movb (%r14,%rcx), %r13b
decq %r12
movl %ebx, %r15d
cmpb $-0x41, %r13b
jbe 0x5b33c
incl %eax
movl %eax, %r15d
leaq -0x40(%rbp), %rdx
movl %r15d, 0x8(%rdx)
movq -0x30(%rbp), %rbx
movq 0x10(%rbx), %rdi
leaq -0x80(%rbp), %rsi
callq 0x44c17
testb $0x40, 0x8(%rbx)
je 0x5b3a2
movq (%rbx), %rdi
leaq -0x80(%rbp), %rdx
xorl %esi, %esi
callq 0x3ef1d
leaq -0x80(%rbp), %rdi
callq 0x30465
jmp 0x5b3b6
movl %r13d, -0x38(%rbp)
jmp 0x5b3b6
movl %ebx, -0x38(%rbp)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, -0x30(%rbp)
decq %r14
incl %r13d
movl %r13d, %esi
jmp 0x5b31f