LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_sprintf
static int jx9Builtin_sprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Format the string */
	jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, nArg, apArg, 0, FALSE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x94e0a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
jne 0x94e25
movq -0x10(%rbp), %rdi
leaq 0x30d36(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x94e94
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x94e5a
movq -0x10(%rbp), %rdi
leaq 0x30d01(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x94e94
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
leaq 0x661c(%rip), %rdi      # 0x9b490
xorl %eax, %eax
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x99c50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_printf
static int jx9Builtin_printf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nCounter = 0;
	const char *zFormat;
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Format the string */
	jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, nArg, apArg, (void *)&nCounter, FALSE);
	/* Return the length of the outputted string */
	jx9_result_int64(pCtx, nCounter);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x94ed2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
jne 0x94ee6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x94f5a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x94f14
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x94f5a
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
leaq 0x6622(%rip), %rdi      # 0x9b550
leaq -0x28(%rbp), %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x99c50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x57010
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_vprintf
static int jx9Builtin_vprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_int64 nCounter = 0;
	const char *zFormat;
	jx9_hashmap *pMap;
	SySet sArg;
	int nLen, n;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the hashmap */
	pMap = (jx9_hashmap *)apArg[1]->x.pOther;
	/* Extract arguments from the hashmap */
	n = jx9HashmapValuesToSet(pMap, &sArg);
	/* Format the string */
	jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), (void *)&nCounter, TRUE);
	/* Return the length of the outputted string */
	jx9_result_int64(pCtx, nCounter);
	/* Release the container */
	SySetRelease(&sArg);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x2, -0x14(%rbp)
jl 0x94fb7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
je 0x94fb7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x57610
cmpl $0x0, %eax
jne 0x94fce
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x95067
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x64(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x64(%rbp)
jge 0x94ffc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x95067
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9b5a0
movl %eax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x68(%rbp), %r8d
movq -0x58(%rbp), %r9
leaq 0x651b(%rip), %rdi      # 0x9b550
leaq -0x28(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x99c50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x57010
leaq -0x60(%rbp), %rdi
callq 0x66980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_vsprintf
static int jx9Builtin_vsprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zFormat;
	jx9_hashmap *pMap;
	SySet sArg;
	int nLen, n;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the string format */
	zFormat = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Point to hashmap */
	pMap = (jx9_hashmap *)apArg[1]->x.pOther;
	/* Extract arguments from the hashmap */
	n = jx9HashmapValuesToSet(pMap, &sArg);
	/* Format the string */
	jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), 0, TRUE);
	/* Release the container */
	SySetRelease(&sArg);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jl 0x950bc
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
je 0x950bc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x57610
cmpl $0x0, %eax
jne 0x950da
movq -0x10(%rbp), %rdi
leaq 0x30a84(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x9516f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x5c(%rbp)
jge 0x9510f
movq -0x10(%rbp), %rdi
leaq 0x30a4c(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x9516f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9b5a0
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x5c(%rbp), %ecx
movl -0x60(%rbp), %r8d
movq -0x50(%rbp), %r9
leaq 0x6348(%rip), %rdi      # 0x9b490
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x99c50
leaq -0x58(%rbp), %rdi
callq 0x66980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_size_format
static int jx9Builtin_size_format(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	/*Kilo*/ /*Mega*/ /*Giga*/ /*Tera*/ /*Peta*/ /*Exa*/ /*Zeta*/
	static const char zUnit[] = {"KMGTPEZ"};
	sxi32 nRest, i_32;
	jx9_int64 iSize;
	int c = -1; /* index in zUnit[] */

	if( nArg < 1 ){
		/* Missing argument, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Extract the given size */
	iSize = jx9_value_to_int64(apArg[0]);
	if( iSize < 100 /* Bytes */ ){
		/* Don't bother formatting, return immediately */
		jx9_result_string(pCtx, "0.1 KB", (int)sizeof("0.1 KB")-1);
		return JX9_OK;
	}
	for(;;){
		nRest = (sxi32)(iSize & 0x3FF); 
		iSize >>= 10;
		c++;
		if( (iSize & (~0 ^ 1023)) == 0 ){
			break;
		}
	}
	nRest /= 100;
	if( nRest > 9 ){
		nRest = 9;
	}
	if( iSize > 999 ){
		c++;
		nRest = 9;
		iSize = 0;
	}
	i_32 = (sxi32)iSize;
	/* Format */
	jx9_result_string_format(pCtx, "%d.%d %cB", i_32, nRest, zUnit[c]);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
cmpl $0x1, -0x14(%rbp)
jge 0x951be
movq -0x10(%rbp), %rdi
leaq 0x309a0(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x952a1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x56d50
movq %rax, -0x30(%rbp)
cmpq $0x64, -0x30(%rbp)
jge 0x951f6
movq -0x10(%rbp), %rdi
leaq 0x3026f(%rip), %rsi     # 0xc544f
movl $0x6, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x952a1
jmp 0x951f8
movq -0x30(%rbp), %rax
andq $0x3ff, %rax            # imm = 0x3FF
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
sarq $0xa, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
andq $-0x400, %rax           # imm = 0xFC00
cmpq $0x0, %rax
jne 0x9522c
jmp 0x9522e
jmp 0x951f8
movl -0x24(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jle 0x95249
movl $0x9, -0x24(%rbp)
cmpq $0x3e7, -0x30(%rbp)     # imm = 0x3E7
jle 0x9526b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl $0x9, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movslq -0x34(%rbp), %rsi
leaq 0x2c2aa(%rip), %rax     # 0xc1531
movsbl (%rax,%rsi), %r8d
leaq 0x301c3(%rip), %rsi     # 0xc5456
movb $0x0, %al
callq 0x794a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strip_tags
static int jx9Builtin_strip_tags(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zTaglist = 0;
	const char *zString;
	int nTaglen = 0;
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return the empty string */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Point to the raw string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nArg > 1 && jx9_value_is_string(apArg[1]) ){
		/* Allowed tag */
		zTaglist = jx9_value_to_string(apArg[1], &nTaglen);		
	}
	/* Process input */
	jx9StripTagsFromString(pCtx, zString, nLen, zTaglist, nTaglen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x95499
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
jne 0x954b4
movq -0x10(%rbp), %rdi
leaq 0x306a7(%rip), %rsi     # 0xc5b4b
xorl %edx, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
jmp 0x95514
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x954f5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
je 0x954f5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %edx
movq -0x28(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x9b930
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strpbrk
static int jx9Builtin_strpbrk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zList, *zEnd;
	int iLen, iListLen, i, c;
	sxu32 nOfft, nMax;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the haystack and the char list */
	zString = jx9_value_to_string(apArg[0], &iLen);
	zList = jx9_value_to_string(apArg[1], &iListLen);
	if( iLen < 1 ){
		/* Nothing to process, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the end of the string */
	zEnd = &zString[iLen];
	nOfft = nMax = SXU32_HIGH;
	/* perform the requested operation */
	for( i = 0 ; i < iListLen ; i++ ){
		c = zList[i];
		rc = SyByteFind(zString, (sxu32)iLen, c, &nMax);
		if( rc == SXRET_OK ){
			if( nMax < nOfft ){
				nOfft = nMax;
			}
		}
	}
	if( nOfft == SXU32_HIGH ){
		/* No such substring, return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return the substring */
		jx9_result_string(pCtx, &zString[nOfft], (int)(zEnd-&zString[nOfft]));
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x95a80
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x95b7a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x3c(%rbp)
jge 0x95ac6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x95b7a
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x95b3a
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x48(%rbp), %edx
leaq -0x50(%rbp), %rcx
callq 0x7d040
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x95b2d
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jae 0x95b2b
movl -0x50(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x95b2d
jmp 0x95b2f
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x95aea
cmpl $-0x1, -0x4c(%rbp)
jne 0x95b4d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
jmp 0x95b73
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x4c(%rbp), %eax
addq %rax, %rsi
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x4c(%rbp), %edx
addq %rdx, %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x57180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x96a9a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
jne 0x96aae
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96b11
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x96af0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x56cf0
movl %eax, -0x44(%rbp)
jmp 0x96af7
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x96af7
movl -0x30(%rbp), %edx
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %ecx
callq 0x9c800
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x96b50
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96bf0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x96b8d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96bf0
jmp 0x96b8f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x96bb0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96bf0
callq 0xd1f0
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x96bd0
jmp 0x96bde
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x96b8f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x96c30
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96cd2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x96c6d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96cd2
jmp 0x96c6f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x96c90
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96cd2
callq 0xd1f0
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x96cb2
jmp 0x96cc0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x96c6f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x96d10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96dc0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x96d4d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96dc0
jmp 0x96d4f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x96d70
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x96dc0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xc0, %eax
jl 0x96d80
jmp 0x96dae
callq 0xd1f0
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x96da0
jmp 0x96dae
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x96d4f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x970d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x97182
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x9710d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x97182
jmp 0x9710f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x97130
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x97182
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xc0, %eax
jl 0x97140
jmp 0x97170
callq 0xd1f0
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x97162
jmp 0x97170
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9710f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_time
static int jx9Builtin_time(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	time_t tt;
	SXUNUSED(nArg); /* cc warning */
	SXUNUSED(apArg);
	/* Extract the current time */
	time(&tt);
	/* Return as 64-bit integer */
	jx9_result_int64(pCtx, (jx9_int64)tt);
	return  JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd980
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x57010
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6b0
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x975bc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x56cf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x975d3
movq -0x8(%rbp), %rdi
cvtsi2sdq -0x30(%rbp), %xmm0
callq 0x570d0
jmp 0x975ed
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0x28347(%rip), %rsi     # 0xbf92d
movb $0x0, %al
callq 0x794a0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6b0
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x97a0c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x56cf0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x97a26
movq -0x10(%rbp), %rdi
cvtsi2sdq -0x38(%rbp), %xmm0
callq 0x570d0
jmp 0x97aaf
movq -0x10(%rbp), %rdi
callq 0x58570
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58510
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x97a4e
cmpq $0x0, -0x58(%rbp)
jne 0x97a60
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x97ab6
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x56780
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2db6c(%rip), %rsi     # 0xc55e8
callq 0x579b0
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x56780
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2da81(%rip), %rsi     # 0xc551e
callq 0x579b0
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x572c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x98b6d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98bb9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x98b9b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98bb9
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq 0x57f3(%rip), %rdx      # 0x9e3a0
callq 0x9e130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x98bfd
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98c49
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x98c2b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98c49
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq 0x5763(%rip), %rdx      # 0x9e3a0
callq 0x9e3d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x98c8d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98cd9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x98cbb
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98cd9
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq 0x56d3(%rip), %rdx      # 0x9e3a0
callq 0x9e6b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x98d1d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98d6f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x98d4b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x98d6f
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq 0x5643(%rip), %rdx      # 0x9e3a0
movl $0x1, %r8d
callq 0x7d5c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x9982d
movq -0x18(%rbp), %rdi
callq 0x57610
cmpl $0x0, %eax
je 0x9982d
movq -0x28(%rbp), %rax
cmpl $0x20, 0x20(%rax)
jge 0x9982d
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x997e8
movq -0x28(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x997db
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x57180
jmp 0x997e6
movq -0x28(%rbp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x997e8
movq -0x28(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq -0xb2(%rip), %rsi       # 0x99760
callq 0x8d8b0
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x998a6
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x99897
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x99882
movq -0x28(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x99875
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x57180
jmp 0x99880
movq -0x28(%rbp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x99882
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x57180
jmp 0x9989f
movq $0x0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBinToHexConsumer
JX9_PRIVATE sxi32 SyBinToHexConsumer(const void *pIn, sxu32 nLen, ProcConsumer xConsumer, void *pConsumerData)
{
	static const unsigned char zHexTab[] = "0123456789abcdef";
	const unsigned char *zIn, *zEnd;
	unsigned char zOut[3];
	sxi32 rc;
#if defined(UNTRUST)
	if( pIn == 0 || xConsumer == 0 ){
		return SXERR_EMPTY;
	}
#endif
	zIn   = (const unsigned char *)pIn;
	zEnd  = &zIn[nLen];
	for(;;){
		if( zIn >= zEnd  ){
			break;
		}
		zOut[0] = zHexTab[zIn[0] >> 4];  zOut[1] = zHexTab[zIn[0] & 0x0F];
		rc = xConsumer((const void *)zOut, sizeof(char)*2, pConsumerData);
		if( rc != SXRET_OK ){
			return rc;
		}
		zIn++; 
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x998e9
jmp 0x9994f
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x27c23(%rip), %rax     # 0xc1520
movb (%rax,%rcx), %al
movb %al, -0x3b(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x27c09(%rip), %rax     # 0xc1520
movb (%rax,%rcx), %al
movb %al, -0x3a(%rbp)
movq -0x20(%rbp), %rax
leaq -0x3b(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x2, %esi
callq *%rax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x99941
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x99956
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x998dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x999ea
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x99ad2
jmp 0x999ec
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jb 0x999fb
jmp 0x99acb
movq -0x40(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf58
movl %eax, -0x64(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf58
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x68(%rbp), %eax
jne 0x99aba
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x99a6a
cmpq $0x0, -0x30(%rbp)
je 0x99a61
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x99ad2
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jb 0x99a76
jmp 0x99ab8
movq -0x58(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf58
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0xdf58
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x68(%rbp), %eax
je 0x99a9e
jmp 0x99ab8
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x99a3d
jmp 0x99aba
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x999ec
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyByteFind2
JX9_PRIVATE sxi32 SyByteFind2(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos)
{
	const char *zIn = zStr;
	const char *zEnd;
	
	zEnd = &zIn[nLen - 1];
	for( ;; ){
		if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos =  (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
		if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos =  (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
		if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos =  (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
		if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos =  (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
	}
	return SXERR_NOTFOUND; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x99b1c
jmp 0x99c3d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x99b4e
cmpq $0x0, -0x20(%rbp)
je 0x99b42
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x99c44
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x99b69
jmp 0x99c3d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x99b9b
cmpq $0x0, -0x20(%rbp)
je 0x99b8f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x99c44
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x99bb6
jmp 0x99c3d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x99be5
cmpq $0x0, -0x20(%rbp)
je 0x99bdc
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x99c44
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x99bfd
jmp 0x99c3d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x99c2c
cmpq $0x0, -0x20(%rbp)
je 0x99c23
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x99c44
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x99b0d
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vxGetdigit
static int vxGetdigit(sxlongreal *val, int *cnt)
{
  sxlongreal d;
  int digit;

  if( (*cnt)++ >= 16 ){
	  return '0';
  }
  digit = (int)*val;
  d = digit;
   *val = (*val - d)*10.0;
  return digit + '0' ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
cmpl $0x10, %eax
jl 0x9b4f7
movl $0x30, -0x4(%rbp)
jmp 0x9b546
movq -0x10(%rbp), %rax
fldt (%rax)
fnstcw -0x3e(%rbp)
movzwl -0x3e(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x40(%rbp)
fldcw -0x40(%rbp)
fistpl -0x3c(%rbp)
fldcw -0x3e(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
fildl -0x38(%rbp)
fstpt -0x30(%rbp)
movq -0x10(%rbp), %rax
fldt (%rax)
fldt -0x30(%rbp)
fsubrp %st, %st(1)
flds 0x265f3(%rip)           # 0xc1b2c
fmulp %st, %st(1)
fstpt (%rax)
movl -0x34(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: printfConsumer
static int printfConsumer(jx9_context *pCtx, const char *zInput, int nLen, void *pUserData)
{
	jx9_int64 *pCounter = (jx9_int64 *)pUserData;
	/* Call the VM output consumer directly */
	jx9_context_output(pCtx, zInput, nLen);
	/* Increment counter */
	*pCounter += nLen;
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x57ef0
movslq -0x14(%rbp), %rcx
movq -0x28(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)