LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x57f81
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x57f81
movq 0x8(%r14), %rax
testb $0x40, 0x8(%rax)
je 0x57f81
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
cmpl $0x0, (%r12)
jle 0x57f81
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %r12
movq %r12, %rsi
callq 0x5ca8b
movl -0x24(%rbp), %ecx
movq 0x8(%r12), %r14
leaq 0x4b21(%rip), %rdi      # 0x5ca5b
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %r8d
movq %r14, %r9
pushq $0x1
pushq $0x0
callq 0x5bbf2
addq $0x10, %rsp
movq (%r12), %rdi
testq %rdi, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x57f6f
movq %r14, %rsi
callq 0x3503f
movq $0x0, -0x48(%rbp)
xorl %eax, %eax
movl %eax, -0x40(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x57f93
movq 0x8(%rbx), %rdi
leaq 0x216db(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x57fd6
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rdx
cmpq $0x64, %rdx
jge 0x57fea
movq 0x8(%rbx), %rdi
leaq 0x20f9c(%rip), %rsi     # 0x78f6b
movl $0x6, %edx
jmp 0x57fe3
movq 0x8(%rbx), %rdi
leaq 0x21686(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
jmp 0x58054
xorl %eax, %eax
movq %rdx, %rsi
shrq $0xa, %rdx
incl %eax
cmpq $0xfffff, %rsi          # imm = 0xFFFFF
ja 0x57fec
movl %esi, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
imulq $0x28f5c29, %rcx, %rcx  # imm = 0x28F5C29
shrq $0x20, %rcx
movl $0x9, %edi
cmpl %edi, %ecx
cmovael %edi, %ecx
leal -0x1(%rax), %r8d
xorl %r9d, %r9d
cmpq $0xfa000, %rsi          # imm = 0xFA000
cmovael %edi, %ecx
cmovael %eax, %r8d
cmovael %r9d, %edx
movslq %r8d, %rax
leaq 0x20f25(%rip), %rsi     # 0x78f63
movsbl (%rax,%rsi), %r8d
leaq 0x20f28(%rip), %rsi     # 0x78f72
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45c53
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_str_getcsv
static int jx9Builtin_str_getcsv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zInput, *zPtr;
	jx9_value *pArray;
	int delim  = ',';   /* Delimiter */
	int encl   = '"' ;  /* Enclosure */
	int escape = '\\';  /* Escape character */
	int nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the raw input */
	zInput = jx9_value_to_string(apArg[0], &nLen);
	if( nArg > 1 ){
		int i;
		if( jx9_value_is_string(apArg[1]) ){
			/* Extract the delimiter */
			zPtr = jx9_value_to_string(apArg[1], &i);
			if( i > 0 ){
				delim = zPtr[0];
			}
		}
		if( nArg > 2 ){
			if( jx9_value_is_string(apArg[2]) ){
				/* Extract the enclosure */
				zPtr = jx9_value_to_string(apArg[2], &i);
				if( i > 0 ){
					encl = zPtr[0];
				}
			}
			if( nArg > 3 ){
				if( jx9_value_is_string(apArg[3]) ){
					/* Extract the escape character */
					zPtr = jx9_value_to_string(apArg[3], &i);
					if( i > 0 ){
						escape = zPtr[0];
					}
				}
			}
		}
	}
	/* Create our array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Parse the raw input */
	jx9ProcessCsv(zInput, nLen, delim, encl, escape, jx9CsvConsumer, pArray);
	/* Return the freshly created 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 %rdi, %rbx
testl %esi, %esi
jle 0x58169
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x58169
movl %esi, %r15d
leaq -0x34(%rbp), %rsi
callq 0x30b04
movq %rax, -0x40(%rbp)
cmpl $0x1, %r15d
jne 0x580b1
movl $0x5c, %r12d
movl $0x22, %r13d
movl $0x2c, %r15d
jmp 0x58117
movq 0x8(%r14), %rdi
movl $0x2c, -0x2c(%rbp)
testb $0x1, 0x8(%rdi)
je 0x580db
leaq -0x30(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
cmpl $0x0, (%r12)
jle 0x580db
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x5c, %r12d
movl $0x22, %r13d
cmpl $0x3, %r15d
jl 0x58113
movq 0x10(%r14), %rdi
testb $0x1, 0x8(%rdi)
je 0x5810d
leaq -0x30(%rbp), %rsi
callq 0x30b04
leaq -0x30(%rbp), %rcx
cmpl $0x0, (%rcx)
jle 0x5810d
movsbl (%rax), %r13d
cmpl $0x3, %r15d
jne 0x58183
movl -0x2c(%rbp), %r15d
movq %rbx, %rdi
callq 0x317eb
testq %rax, %rax
je 0x5814d
movq %rax, %r14
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdi
movl %r15d, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movq %rax, %r9
callq 0x5cb2e
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3ebc8
jmp 0x58172
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x20166(%rip), %rcx     # 0x782c5
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rdi
testb $0x1, 0x8(%rdi)
movl -0x2c(%rbp), %r15d
je 0x58117
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
cmpl $0x0, (%r14)
jle 0x58117
movsbl (%rax), %r12d
jmp 0x58117
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, -0x24(%rbp)
testl %esi, %esi
jle 0x581d9
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x581ed
movq 0x8(%rbx), %rdi
leaq 0x21483(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
jmp 0x5822e
movl %esi, %r12d
leaq -0x28(%rbp), %rsi
callq 0x30b04
movq %rax, %r14
cmpl $0x1, %r12d
je 0x5820c
movq 0x8(%r15), %rdi
testb $0x1, 0x8(%rdi)
jne 0x58210
xorl %ecx, %ecx
jmp 0x5821c
leaq -0x24(%rbp), %rsi
callq 0x30b04
movq %rax, %rcx
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %r8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ccd8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x587cb
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x38(%rbp), %r13
movq %r13, %rsi
callq 0x30b04
movq %rax, %r14
movq 0x8(%r15), %rdi
leaq -0x30(%rbp), %rsi
callq 0x30b04
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
jle 0x587cb
movl %eax, -0x34(%rbp)
movq %rbx, -0x40(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x30(%rbp)
jle 0x587fd
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %ebx, %ebx
leaq -0x2c(%rbp), %r13
movsbl (%r12,%rbx), %edx
movl -0x38(%rbp), %esi
movq %r14, %rdi
movq %r13, %rcx
callq 0x4838e
movl -0x2c(%rbp), %ecx
cmpl %r15d, %ecx
cmovael %r15d, %ecx
testl %eax, %eax
cmovel %ecx, %r15d
incq %rbx
movslq -0x30(%rbp), %rax
cmpq %rax, %rbx
jl 0x5879a
jmp 0x58803
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x58827
movl %r15d, %eax
addq %rax, %r14
movl -0x34(%rbp), %edx
subl %r15d, %edx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3087c
jmp 0x587ec
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rbx
jmp 0x587cf
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
testl %esi, %esi
jle 0x58933
movq (%rdx), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x30b04
movq %rax, %r14
movb (%rax), %r15b
leal -0x1(%r15), %eax
cmpb $-0x42, %al
ja 0x58891
callq 0xc170
movq (%rax), %rcx
xorl %eax, %eax
movzbl %r15b, %edx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0x5888e
movb 0x1(%r14,%rax), %r15b
incq %rax
leal -0x1(%r15), %edx
cmpb $-0x41, %dl
jb 0x58872
movl %eax, %r12d
testb %r15b, %r15b
je 0x58942
movq %rbx, -0x38(%rbp)
movzbl %r15b, %ebx
movl %ebx, %eax
andl $0x7f, %eax
leaq 0x1c612(%rip), %r15     # 0x74ec0
movb (%rax,%r15), %r13b
callq 0xc350
movq (%rax), %rax
movb (%rax,%rbx,4), %al
movb %al, -0x30(%rbp)
addq %r12, %r14
movl $0x1, %eax
movzbl (%r14), %ecx
testq %rcx, %rcx
je 0x58901
andl $0x7f, %ecx
movb (%rcx,%r15), %cl
testb %cl, %cl
je 0x588e6
cmpb %r13b, %cl
jne 0x588ea
movl %r13d, %ecx
jmp 0x588f6
xorl %ecx, %ecx
jmp 0x588f6
leal 0x30(%rcx), %edx
movslq %eax, %rsi
incl %eax
movb %dl, -0x30(%rbp,%rsi)
incq %r14
movl %ecx, %r13d
cmpl $0x4, %eax
jl 0x588c8
cmpl $0x3, %eax
movq -0x38(%rbp), %rbx
jg 0x58929
movslq %eax, %rcx
leaq (%rcx,%rbp), %rdi
addq $-0x30, %rdi
movl $0x3, %edx
subl %eax, %edx
incq %rdx
movl $0x30, %esi
callq 0xc360
movq 0x8(%rbx), %rdi
leaq -0x30(%rbp), %rsi
jmp 0x5894d
movq 0x8(%rbx), %rdi
leaq 0x20d29(%rip), %rsi     # 0x79667
xorl %edx, %edx
jmp 0x58952
movq 0x8(%rbx), %rdi
leaq 0x2062f(%rip), %rsi     # 0x78f7c
movl $0x4, %edx
callq 0x3087c
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_O1/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 $0x28, %rsp
movq %rdi, -0x48(%rbp)
testl %esi, %esi
jle 0x58a67
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x3c(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
cmpl $0x0, (%r15)
jle 0x58a67
movq %rax, %rbx
movl $0x0, -0x2c(%rbp)
movl $0x4b, %r15d
leaq 0x20cac(%rip), %rax     # 0x79667
movq %rax, -0x38(%rbp)
cmpl $0x1, %r13d
je 0x589f3
movq 0x8(%r12), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %eax
testl %eax, %eax
cmovgl %eax, %r15d
cmpl $0x3, %r13d
jl 0x589f3
movq 0x10(%r12), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x30b04
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x58a0b
movl $0x1, -0x2c(%rbp)
leaq 0x218da(%rip), %rax     # 0x7a2e1
movq %rax, -0x38(%rbp)
movslq -0x3c(%rbp), %r13
addq %rbx, %r13
cmpq %r13, %rbx
jae 0x58a54
movl %r13d, %r12d
subl %ebx, %r12d
cmpl %r12d, %r15d
cmovll %r15d, %r12d
movq -0x48(%rbp), %r15
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x3087c
movslq %r12d, %r14
addq %rbx, %r14
cmpq %r13, %r14
jae 0x58a5a
movl -0x2c(%rbp), %edx
movq 0x8(%r15), %rdi
movq -0x38(%rbp), %rsi
callq 0x3087c
jmp 0x58a5a
movq %rbx, %r14
movl %r15d, %r12d
movl %r12d, %r15d
cmpq %r13, %rbx
movq %r14, %rbx
jb 0x58a12
jmp 0x58a7d
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x20bf1(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
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_O1/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 0x59457
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5947a
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x594b5
movl %esi, %r15d
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x30b04
movq %rax, %r12
movl (%r13), %r13d
xorl %ecx, %ecx
cmpl $0x1, %r15d
je 0x594a7
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x446ef
movl (%r14), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x5d477
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_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x5951e
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movslq (%r15), %r12
testq %r12, %r12
jle 0x5951e
movq %rax, %r14
addq %rax, %r12
callq 0xc170
movq (%rax), %rax
xorl %r15d, %r15d
movzbl (%r14), %ecx
testb $0x8, (%rax,%rcx,2)
je 0x59521
incq %r14
cmpq %r12, %r14
jb 0x59504
movl $0x1, %r15d
jmp 0x59521
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%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_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x595a6
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movslq (%r15), %r12
testq %r12, %r12
jle 0x595a6
movq %rax, %r14
addq %rax, %r12
callq 0xc170
movq (%rax), %rax
xorl %r15d, %r15d
movzbl (%r14), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x595a9
incq %r14
cmpq %r12, %r14
jb 0x5958b
movl $0x1, %r15d
jmp 0x595a9
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x59636
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movslq (%r15), %r12
testq %r12, %r12
jle 0x59636
movq %rax, %r14
addq %rax, %r12
xorl %r15d, %r15d
movzbl (%r14), %r13d
cmpq $0xbf, %r13
ja 0x59639
callq 0xc170
movq (%rax), %rax
testb $0x2, (%rax,%r13,2)
je 0x59639
incq %r14
cmpq %r12, %r14
jb 0x5960a
movl $0x1, %r15d
jmp 0x59639
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%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 %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x59882
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movslq (%r15), %r12
testq %r12, %r12
jle 0x59882
movq %rax, %r14
addq %rax, %r12
xorl %r15d, %r15d
movzbl (%r14), %r13d
cmpq $0xbf, %r13
ja 0x59885
callq 0xc170
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r13,2)
je 0x59885
incq %r14
cmpq %r12, %r14
jb 0x59855
movl $0x1, %r15d
jmp 0x59885
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%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 %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xc820
movq (%r14), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59bab
movq (%r12), %r12
movq %r12, %rdi
callq 0x446ef
cmpl $0x0, (%r12)
je 0x59bab
cvtsi2sd %r14, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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 0x44d9d
jmp 0x59bc2
leaq 0x19de3(%rip), %rsi     # 0x73995
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x45c53
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_O1/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 0x59fc5
movq (%r14), %r14
movq %r14, %rdi
callq 0x446ef
cmpl $0x0, (%r14)
je 0x59fc5
cvtsi2sd %r13, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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 0x44d9d
jmp 0x5a05b
movq %rbx, %rdi
callq 0x317eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x317a5
movq %rax, %r15
testq %rax, %rax
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
je 0x5a052
movq %r15, %rdi
callq 0x309f2
movq %r13, (%r15)
movl $0xfffffe90, %r13d      # imm = 0xFFFFFE90
movl 0x8(%r15), %eax
andl %r13d, %eax
orl $0x2, %eax
movl %eax, 0x8(%r15)
leaq 0x1f0f3(%rip), %rsi     # 0x79104
movq %r14, %rdi
movq %r15, %rdx
callq 0x3106a
movq %r15, %rdi
callq 0x309f2
movq %r12, (%r15)
andl 0x8(%r15), %r13d
orl $0x2, %r13d
movl %r13d, 0x8(%r15)
leaq 0x1f000(%rip), %rsi     # 0x7903a
movq %r14, %rdi
movq %r15, %rdx
callq 0x3106a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30d83
jmp 0x5a05b
movq 0x8(%rbx), %rdi
callq 0x309f2
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_O1/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 0x5a090
movq %rdx, %r15
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5a0b6
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5a184
movl %esi, %r12d
leaq -0x34(%rbp), %r13
movq %r13, %rsi
callq 0x30b04
movq %rax, %r14
cmpl $0x0, (%r13)
jg 0x5a0e1
movq 0x8(%rbx), %rdi
leaq 0x1f58d(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
cmpl $0x1, %r12d
jne 0x5a0f8
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0xc820
movq %r15, %rdi
jmp 0x5a12c
movq 0x8(%r15), %r15
testb $0x2, 0x8(%r15)
je 0x5a11f
movq %r15, %rdi
callq 0x3fd5f
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0xc770
testq %rax, %rax
jne 0x5a128
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 0x5dc3b
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_O1/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 0x5aed1
leaq -0x30(%rbp), %rdi
callq 0xc2f0
jmp 0x5aeda
leaq -0x30(%rbp), %rdi
callq 0xc770
movq %rax, %r12
testl %r15d, %r15d
jle 0x5afb2
movq (%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl %eax, 0x8(%r12)
cmpl $0x1, %r15d
je 0x5afb2
movq 0x8(%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl %eax, 0x4(%r12)
cmpl $0x3, %r15d
jl 0x5afb2
movq 0x10(%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl %eax, (%r12)
cmpl $0x3, %r15d
je 0x5afb2
movq 0x18(%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
decl %eax
movl %eax, 0x10(%r12)
cmpl $0x5, %r15d
jl 0x5afb2
movq 0x20(%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl %eax, 0xc(%r12)
cmpl $0x5, %r15d
je 0x5afb2
movq 0x28(%r14), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
leal -0x76c(%rax), %ecx
cmpl $0x76d, %eax            # imm = 0x76D
cmovll %eax, %ecx
movl %ecx, 0x14(%r12)
cmpl $0x7, %r15d
jl 0x5afb2
movq 0x30(%r14), %r14
movq %r14, %rdi
callq 0x446ef
movl (%r14), %eax
movl %eax, 0x20(%r12)
movq %r12, %rdi
callq 0xc450
movq %rax, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x5b100
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movl (%r15), %r12d
testl %r12d, %r12d
jle 0x5b100
movq %rax, %r14
xorl %r13d, %r13d
cmpl $0x3, %r12d
jb 0x5b0b8
movl $0x2, %r13d
leaq 0x1ee64(%rip), %r15     # 0x79ea0
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 0x3087c
addl $0x3, %r13d
cmpl %r12d, %r13d
jb 0x5b03c
addl $-0x2, %r13d
leal 0x1(%r13), %eax
cmpl %r12d, %eax
jae 0x5b123
movl %r13d, %ecx
movzbl (%r14,%rcx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
leaq 0x1edcb(%rip), %rsi     # 0x79ea0
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 0x5b150
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5b169
cmpl %r12d, %r13d
jae 0x5b169
movl %r13d, %eax
movzbl (%r14,%rax), %eax
movl %eax, %ecx
shrl $0x2, %ecx
leaq 0x1ed64(%rip), %rdx     # 0x79ea0
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 0x3087c
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_O1/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 0x5b2c7
movq (%rdx), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movslq (%r15), %r12
testq %r12, %r12
jle 0x5b2c7
movq %rax, %r14
cmpb $0x3d, -0x1(%r14,%r12)
jne 0x5b1c4
decq %r12
jne 0x5b1b4
xorl %r12d, %r12d
xorl %eax, %eax
cmpl $0x4, %r12d
jb 0x5b26d
xorl %r15d, %r15d
leaq 0x19dd6(%rip), %r13     # 0x74fb0
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 0x3087c
leal 0x4(%r15), %eax
addl $0x7, %r15d
cmpl %r12d, %r15d
movl %eax, %r15d
jb 0x5b1da
movl %eax, %eax
movq %rax, %rcx
orq $0x2, %rcx
cmpl %r12d, %ecx
jae 0x5b2ea
movzbl (%r14,%rax), %edx
andl $0x7f, %edx
leaq 0x19d26(%rip), %rsi     # 0x74fb0
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 0x5b324
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5b331
movq %rax, %rcx
orq $0x1, %rcx
cmpl %r12d, %ecx
jae 0x5b331
movzbl (%r14,%rax), %eax
andl $0x7f, %eax
leaq 0x19cab(%rip), %rdx     # 0x74fb0
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 0x3087c
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_O1/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 0x5b476
movq (%rdx), %rdi
leaq -0x44(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movslq (%r14), %r13
testq %r13, %r13
jle 0x5b476
movq %rax, %r12
movq %rbx, -0x38(%rbp)
leaq -0x2c(%rbp), %rax
movb $0x0, 0x2(%rax)
movw $0x25, (%rax)
addq %r12, %r13
callq 0xc170
leaq 0x1a49d(%rip), %rsi     # 0x75839
movabsq $0x800000000000601, %rbx # imm = 0x800000000000601
movq %r12, %r14
movq (%rax), %rdx
xorl %r15d, %r15d
movzbl (%r14,%r15), %r12d
movzwl (%rdx,%r12,2), %ecx
testb $0x8, %cl
jne 0x5b3cf
movl %r12d, %ecx
addl $-0x24, %ecx
cmpl $0x3b, %ecx
ja 0x5b3e3
btq %rcx, %rbx
jae 0x5b3e3
leaq (%r14,%r15), %rcx
incq %rcx
incq %r15
cmpq %r13, %rcx
jb 0x5b3af
jmp 0x5b499
movq %rax, -0x40(%rbp)
testq %r15, %r15
je 0x5b406
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3087c
leaq 0x1a433(%rip), %rsi     # 0x75839
cmpl $0x20, %r12d
jne 0x5b423
movb $0x2b, -0x2e(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x2e(%rbp), %rsi
movl $0x1, %edx
jmp 0x5b44b
movl %r12d, %eax
shrl $0x4, %eax
movb (%rax,%rsi), %al
movb %al, -0x2b(%rbp)
andl $0xf, %r12d
movb (%r12,%rsi), %al
movb %al, -0x2a(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x2c(%rbp), %rsi
movl $0x3, %edx
callq 0x3087c
leaq (%r14,%r15), %r12
incq %r12
cmpq %r13, %r12
movq -0x40(%rbp), %rax
leaq 0x1a3d4(%rip), %rsi     # 0x75839
jb 0x5b3a6
addq %r15, %r14
incq %r14
movq %r14, %r15
jmp 0x5b49c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5b4b7
addq %r14, %r15
cmpq %r14, %r15
je 0x5b4b7
subl %r14d, %r15d
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3087c
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_O1/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 0x5b504
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %esi
testl %esi, %esi
jle 0x5b504
leaq 0x2c60(%rip), %rdx      # 0x5e157
movq %rax, %rdi
movq %rbx, %rcx
callq 0x48412
jmp 0x5b525
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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