LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_hexdec
static int jx9Builtin_hexdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zEnd;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		/* Delimit the string */
		zEnd = &zString[nLen];
		/* Ignore non hex-stream */
		while( zString < zEnd ){
			if( (unsigned char)zString[0] >= 0xc0 ){
				/* UTF-8 stream */
				zString++;
				while( zString < zEnd && (((unsigned char)zString[0] & 0xc0) == 0x80) ){
					zString++;
				}
			}else{
				if( SyisHex(zString[0]) ){
					break;
				}
				/* Ignore */
				zString++;
			}
		}
		if( zString < zEnd ){
			/* Cast */
			SyHexStrToInt64(zString, (sxu32)(zEnd-zString), (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	jx9_result_int64(pCtx, iVal);
	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 0x487e9
andq $0x0, -0x30(%rbp)
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x487f9
callq 0x297ae
movq %rax, %r14
movq %rax, -0x30(%rbp)
jmp 0x4886f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
jmp 0x4887a
leaq -0x34(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movq %rax, %r12
movslq (%r14), %r15
addq %rax, %r15
xorl %r14d, %r14d
cmpq %r15, %r12
jae 0x4886f
movsbq (%r12), %r13
cmpq $-0x40, %r13
jb 0x4883d
incq %r12
movq %r12, %rax
cmpq %r15, %rax
jae 0x48852
movb (%rax), %cl
andb $-0x40, %cl
movq %rax, %r12
incq %rax
negb %cl
jo 0x48827
jmp 0x48811
callq 0xc190
movq (%rax), %rax
testb $0x10, 0x1(%rax,%r13,2)
jne 0x48857
incq %r12
jmp 0x48811
movq %rax, %r12
jmp 0x48811
subl %r12d, %r15d
leaq -0x30(%rbp), %r14
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x375f0
movq (%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29897
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_bindec
static int jx9Builtin_bindec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		if( nLen > 0 ){
			/* Perform a binary cast */
			SyBinaryStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x488b9
andq $0x0, -0x18(%rbp)
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x488c6
callq 0x297ae
movq %rax, %rsi
movq %rax, -0x18(%rbp)
jmp 0x488ef
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
jmp 0x488f7
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %esi
testl %esi, %esi
jle 0x488ed
leaq -0x18(%rbp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x37826
movq (%r14), %rsi
jmp 0x488ef
xorl %esi, %esi
movq %rbx, %rdi
callq 0x29897
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_octdec
static int jx9Builtin_octdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	jx9_int64 iVal;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	iVal = 0;
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the given string */
		zString = jx9_value_to_string(apArg[0], &nLen);
		if( nLen > 0 ){
			/* Perform the cast */
			SyOctalStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
		}
	}else{
		/* Extract as a 64-bit integer */
		iVal = jx9_value_to_int64(apArg[0]);
	}
	/* Return the number */
	jx9_result_int64(pCtx, iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x48930
andq $0x0, -0x18(%rbp)
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4893d
callq 0x297ae
movq %rax, %rsi
movq %rax, -0x18(%rbp)
jmp 0x48966
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
jmp 0x4896e
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %esi
testl %esi, %esi
jle 0x48964
leaq -0x18(%rbp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x379bb
movq (%r14), %rsi
jmp 0x48966
xorl %esi, %esi
movq %rbx, %rdi
callq 0x29897
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_base_convert
static int jx9Builtin_base_convert(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int nLen, iFbase, iTobase;
	const char *zNum;
	jx9_int64 iNum;
	if( nArg < 3 ){
		/* Return the empty string*/
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Base numbers */
	iFbase  = jx9_value_to_int(apArg[1]);
	iTobase = jx9_value_to_int(apArg[2]);
	if( jx9_value_is_string(apArg[0]) ){
		/* Extract the target number */
		zNum = jx9_value_to_string(apArg[0], &nLen);
		if( nLen < 1 ){
			/* Return the empty string*/
			jx9_result_string(pCtx, "", 0);
			return JX9_OK;
		}
		/* Base conversion */
		switch(iFbase){
		case 16:
			/* Hex */
			SyHexStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		case 8:
			/* Octal */
			SyOctalStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		case 2:
			/* Binary */
			SyBinaryStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		default:
			/* Decimal */
			SyStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
			break;
		}
	}else{
		iNum = jx9_value_to_int64(apArg[0]);
	}
	switch(iTobase){
	case 16:
		/* Hex */
		jx9_result_string_format(pCtx, "%qx", iNum); /* Quad hex */
		break;
	case 8:
		/* Octal */
		jx9_result_string_format(pCtx, "%qo", iNum); /* Quad octal */
		break;
	case 2:
		/* Binary */
		jx9_result_string_format(pCtx, "%qB", iNum); /* Quad binary */
		break;
	default:
		/* Decimal */
		jx9_result_string_format(pCtx, "%qd", iNum); /* Quad decimal */
		break;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x489a6
leaq 0x1ecbb(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
jmp 0x48a4b
movq %rdx, %r12
movq 0x8(%rdx), %rdi
callq 0x29772
movl %eax, %r15d
movq 0x10(%r12), %rdi
callq 0x29772
movl %eax, %r14d
movq (%r12), %rdi
testb $0x1, 0x8(%rdi)
jne 0x489f4
callq 0x297ae
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
cmpl $0x2, %r14d
je 0x48a31
cmpl $0x8, %r14d
je 0x48a28
cmpl $0x10, %r14d
jne 0x48a3a
leaq 0x1e4c9(%rip), %rsi     # 0x66ebb
jmp 0x48a41
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
movl (%r12), %esi
testl %esi, %esi
jle 0x48990
leaq -0x28(%rbp), %rdx
movq %rax, %rdi
cmpl $0x2, %r15d
je 0x48a64
cmpl $0x8, %r15d
je 0x48a5a
cmpl $0x10, %r15d
jne 0x48a6e
callq 0x375f0
jmp 0x489d5
leaq 0x1e490(%rip), %rsi     # 0x66ebf
jmp 0x48a41
leaq 0x1e48b(%rip), %rsi     # 0x66ec3
jmp 0x48a41
leaq 0x1b67a(%rip), %rsi     # 0x640bb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3bdad
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x379bb
jmp 0x489d5
callq 0x37826
jmp 0x489d5
callq 0x37b90
jmp 0x489d5
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_substr
static int jx9Builtin_substr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zSource, *zOfft;
	int nOfft, nLen, nSrcLen;	
	if( nArg < 2 ){
		/* return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the target string */
	zSource = jx9_value_to_string(apArg[0], &nSrcLen);
	if( nSrcLen < 1 ){
		/* Empty string, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	nLen = nSrcLen; /* cc warning */
	/* Extract the offset */
	nOfft = jx9_value_to_int(apArg[1]);
	if( nOfft < 0 ){
		zOfft = &zSource[nSrcLen+nOfft]; 
		if( zOfft < zSource ){
			/* Invalid offset */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		nLen = (int)(&zSource[nSrcLen]-zOfft);
		nOfft = (int)(zOfft-zSource);
	}else if( nOfft >= nSrcLen ){
		/* Invalid offset */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}else{
		zOfft = &zSource[nOfft];
		nLen = nSrcLen - nOfft;
	}
	if( nArg > 2 ){
		/* Extract the length */
		nLen = jx9_value_to_int(apArg[2]);
		if( nLen == 0 ){
			/* Invalid length, return an empty string */
			jx9_result_string(pCtx, "", 0);
			return JX9_OK;
		}else if( nLen < 0 ){
			nLen = nSrcLen + nLen - nOfft;
			if( nLen < 1 ){
				/* Invalid  length */
				nLen = nSrcLen - nOfft;
			}
		}
		if( nLen + nOfft > nSrcLen ){
			/* Invalid length */
			nLen = nSrcLen - nOfft;
		}
	}
	/* Return the substring */
	jx9_result_string(pCtx, zOfft, nLen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x48ac4
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
cmpl $0x0, (%r13)
jle 0x48ac4
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x29772
movl -0x2c(%rbp), %edx
testl %eax, %eax
js 0x48adf
movl %eax, %r13d
cmpl %edx, %eax
jl 0x48aeb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl %eax, %edx
movl %edx, %r13d
movl $0x0, %edx
js 0x48ac4
cmpl $0x2, %r12d
jne 0x48af5
subl %eax, %edx
jmp 0x48b34
movq 0x10(%r15), %rdi
callq 0x29772
testl %eax, %eax
je 0x48b0e
movl -0x2c(%rbp), %ecx
js 0x48b1c
movl %ecx, %edx
subl %r13d, %edx
jmp 0x48b2b
leaq 0x1eb3d(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x48b40
subl %r13d, %eax
addl %ecx, %eax
movl %ecx, %edx
subl %r13d, %edx
testl %eax, %eax
cmovlel %edx, %eax
leal (%rax,%r13), %esi
cmpl %ecx, %esi
cmovlel %eax, %edx
movl %r13d, %eax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29903
jmp 0x48ace
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_chunk_split
static int jx9Builtin_chunk_split(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd, *zSep = "\r\n";
	int nSepLen, nChunkLen, nLen;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Nothing to split, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* initialize/Extract arguments */
	nSepLen = (int)sizeof("\r\n") - 1;
	nChunkLen = 76;
	zIn = jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	if( nArg > 1 ){
		/* Chunk length */
		nChunkLen = jx9_value_to_int(apArg[1]);
		if( nChunkLen < 1 ){
			/* Switch back to the default length */
			nChunkLen = 76;
		}
		if( nArg > 2 ){
			/* Separator */
			zSep = jx9_value_to_string(apArg[2], &nSepLen);
			if( nSepLen < 1 ){
				/* Switch back to the default separator */
				zSep = "\r\n";
				nSepLen = (int)sizeof("\r\n") - 1;
			}
		}
	}
	/* Perform the requested operation */
	if( nChunkLen > nLen ){
		/* Nothing to split, return the string and the separator */
		jx9_result_string_format(pCtx, "%.*s%.*s", nLen, zIn, nSepLen, zSep);
		return JX9_OK;
	}
	while( zIn < zEnd ){
		if( nChunkLen > (int)(zEnd-zIn) ){
			nChunkLen = (int)(zEnd - zIn);
		}
		/* Append the chunk and the separator */
		jx9_result_string_format(pCtx, "%.*s%.*s", nChunkLen, zIn, nSepLen, zSep);
		/* Point beyond the chunk */
		zIn += nChunkLen;
	}
	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 0x48d92
movq %rdx, %r12
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x48dab
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r13d
movl $0x2, -0x2c(%rbp)
leaq -0x3c(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r14
movslq (%r15), %rax
leaq 0x1f59c(%rip), %r15     # 0x6836a
pushq $0x2
popq %r8
cmpl $0x1, %r13d
jne 0x48dde
pushq $0x4c
popq %r12
jmp 0x48e2e
movq %rax, -0x38(%rbp)
movq 0x8(%r12), %rdi
callq 0x29772
testl %eax, %eax
movq %r12, %rcx
pushq $0x4c
popq %r12
cmovgl %eax, %r12d
cmpl $0x3, %r13d
jb 0x48e26
movq 0x10(%rcx), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movl (%r13), %ecx
testl %ecx, %ecx
jle 0x48e1f
movl %ecx, %r8d
movq %rax, %r15
jmp 0x48e2a
movl $0x2, -0x2c(%rbp)
pushq $0x2
popq %r8
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %edx
cmpl %edx, %r12d
jle 0x48e52
leaq 0x1e08a(%rip), %rsi     # 0x66ec7
movq %rbx, %rdi
movq %r14, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x3bdad
jmp 0x48d9a
movq %r14, %r13
addq %rax, %r13
cmpq %r13, %r14
jae 0x48d9a
movl %r13d, %eax
subl %r14d, %eax
cmpl %eax, %r12d
cmovgel %eax, %r12d
movl -0x2c(%rbp), %r8d
movq %rbx, %rdi
leaq 0x1e04b(%rip), %rsi     # 0x66ec7
movl %r12d, %edx
movq %r14, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x3bdad
movslq %r12d, %rax
addq %rax, %r14
jmp 0x48e58
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_get_html_translation_table
static int jx9Builtin_get_html_translation_table(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray, *pValue;
	sxu32 n;
	/* Element value */
	pValue = jx9_context_new_scalar(pCtx);
	if( pValue == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		/* Return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make the table */
	for( n = 0 ; n < SX_ARRAYSIZE(azHtmlEscape) ; n += 2 ){
		/* Prepare the value */
		jx9_value_string(pValue, azHtmlEscape[n], -1 /* Compute length automatically */);
		/* Insert the value */
		jx9_array_add_strkey_elem(pArray, azHtmlEscape[n+1], pValue);
		/* Reset the string cursor */
		jx9_value_reset_string_cursor(pValue);
	}
	/* 
	 * Return the array.
	 * Don't worry about freeing memory, everything will be automatically
	 * released upon we return from this function.
	 */
	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
callq 0x2a26a
testq %rax, %rax
je 0x4928a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a2b0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x4928a
movq %rbx, -0x38(%rbp)
movq %r14, %r12
addq $0x18, %r12
xorl %r13d, %r13d
leaq 0x3c96d(%rip), %r15     # 0x85bc0
cmpq $0x27, %r13
ja 0x49294
movq (%r15,%r13,8), %rsi
movq 0x8(%r15,%r13,8), %rbx
movq %r14, %rdi
pushq $-0x1
popq %rdx
callq 0x29588
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x29c6c
movq %r12, %rdi
callq 0x31b1e
addq $0x2, %r13
jmp 0x49253
movq %rbx, %rdi
callq 0x298e8
jmp 0x492a1
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x299d3
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_htmlentities
static int jx9Builtin_htmlentities(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iFlags = 0x01; /* ENT_COMPAT */
	const char *zIn, *zEnd;
	int nLen, c;
	sxu32 n;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	zEnd = &zIn[nLen];
	/* Extract the flags if available */
	if( nArg > 1 ){
		iFlags = jx9_value_to_int(apArg[1]);
		if( iFlags < 0 ){
			iFlags = 0x01;
		}
	}
	/* Perform the requested operation */
	for(;;){
		if( zIn >= zEnd ){
			/* No more input to process */
			break;
		}
		c = zIn[0];
		/* Perform a linear lookup on the decoding table */
		for( n = 0 ; n < SX_ARRAYSIZE(azHtmlEscape) ; n += 2 ){
			if( azHtmlEscape[n+1][0] == c ){
				/* Got one */
				break;
			}
		}
		if( n < SX_ARRAYSIZE(azHtmlEscape) ){
			/* Output the safe sequence [i.e: '<' ==> '&lt;"] */
			if( c == '"' && (iFlags & 0x04) /*ENT_NOQUOTES*/ ){
				/* Expand the double quote verbatim */
				jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
			}else if(c == '\'' && ((iFlags & 0x02 /*ENT_QUOTES*/) == 0 || (iFlags & 0x04) /*ENT_NOQUOTES*/) ){
				/* expand single quote verbatim */
				jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
			}else{
				jx9_result_string(pCtx, azHtmlEscape[n], -1/*Compute length automatically */);
			}
		}else{
			/* Output character verbatim */
			jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
		}
		zIn++;
	}
	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 0x492d6
movq %rdx, %r13
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x492ef
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r12d
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r14
movslq (%r15), %r15
cmpl $0x1, %r12d
jne 0x4930f
pushq $0x1
popq %rcx
jmp 0x49320
movq 0x8(%r13), %rdi
callq 0x29772
testl %eax, %eax
pushq $0x1
popq %rcx
cmovnsl %eax, %ecx
addq %r14, %r15
movl %ecx, %eax
andl $0x6, %eax
movl %eax, -0x30(%rbp)
leaq 0x3c88e(%rip), %r12     # 0x85bc0
andl $0x4, %ecx
movl %ecx, -0x34(%rbp)
pushq $0x1
popq %r13
cmpq %r15, %r14
jae 0x492de
movsbl (%r14), %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpq $0x27, %rax
ja 0x49375
movq 0x8(%r12,%rax,8), %rdx
cmpb (%rdx), %cl
je 0x4935f
addq $0x2, %rax
jmp 0x4934a
cmpb $0x22, %cl
jne 0x4936a
cmpl $0x0, -0x34(%rbp)
jne 0x49375
cmpb $0x27, %cl
jne 0x49389
cmpl $0x2, -0x30(%rbp)
je 0x49389
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
movl %r13d, %edx
callq 0x29903
incq %r14
jmp 0x4933c
movq (%r12,%rax,8), %rsi
movq %rbx, %rdi
pushq $-0x1
popq %rdx
jmp 0x4937f
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strlen
static int jx9Builtin_strlen(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iLen = 0;
	if( nArg > 0 ){
		jx9_value_to_string(apArg[0], &iLen);
	}
	/* String length */
	jx9_result_int(pCtx, iLen);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andl $0x0, -0x14(%rbp)
testl %esi, %esi
jle 0x49540
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %esi
jmp 0x49542
xorl %esi, %esi
movq %rbx, %rdi
callq 0x2987c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strcmp
static int jx9Builtin_strcmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *z1, *z2;
	int n1, n2;
	int res;
	if( nArg < 2 ){
		res = nArg == 0 ? 0 : 1;
		jx9_result_int(pCtx, res);
		return JX9_OK;
	}
	/* Perform the comparison */
	z1 = jx9_value_to_string(apArg[0], &n1);
	z2 = jx9_value_to_string(apArg[1], &n2);
	res = SyStrncmp(z1, z2, (sxu32)(SXMAX(n1, n2)));
	/* Comparison result */
	jx9_result_int(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x49575
xorl %eax, %eax
testl %esi, %esi
setne %al
jmp 0x495b0
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r12
movq 0x8(%r14), %rdi
leaq -0x24(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r15), %ecx
movl (%r14), %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x4d6c7
movq %rbx, %rdi
movl %eax, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strncmp
static int jx9Builtin_strncmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *z1, *z2;
	int res;
	int n;
	if( nArg < 3 ){
		/* Perform a standard comparison */
		return jx9Builtin_strcmp(pCtx, nArg, apArg);
	}
	/* Desired comparison length */
	n  = jx9_value_to_int(apArg[2]);
	if( n < 0 ){
		/* Invalid length */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the comparison */
	z1 = jx9_value_to_string(apArg[0], 0);
	z2 = jx9_value_to_string(apArg[1], 0);
	res = SyStrncmp(z1, z2, (sxu32)n);
	/* Comparison result */
	jx9_result_int(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x495ec
movq %rbx, %rdi
movq %r14, %rdx
callq 0x49555
jmp 0x49634
movq 0x10(%r14), %rdi
callq 0x29772
testl %eax, %eax
js 0x49629
movl %eax, %r15d
movq (%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %rax, %r12
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x4d6c7
movq %rbx, %rdi
movl %eax, %esi
jmp 0x4962f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strcasecmp
static int jx9Builtin_strcasecmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *z1, *z2;
	int n1, n2;
	int res;
	if( nArg < 2 ){
		res = nArg == 0 ? 0 : 1;
		jx9_result_int(pCtx, res);
		return JX9_OK;
	}
	/* Perform the comparison */
	z1 = jx9_value_to_string(apArg[0], &n1);
	z2 = jx9_value_to_string(apArg[1], &n2);
	res = SyStrnicmp(z1, z2, (sxu32)(SXMAX(n1, n2)));
	/* Comparison result */
	jx9_result_int(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x4965f
xorl %eax, %eax
testl %esi, %esi
setne %al
jmp 0x4969a
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r12
movq 0x8(%r14), %rdi
leaq -0x24(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r15), %ecx
movl (%r14), %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x32436
movq %rbx, %rdi
movl %eax, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strncasecmp
static int jx9Builtin_strncasecmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *z1, *z2;
	int res;
	int n;
	if( nArg < 3 ){
		/* Perform a standard comparison */
		return jx9Builtin_strcasecmp(pCtx, nArg, apArg);
	}
	/* Desired comparison length */
	n  = jx9_value_to_int(apArg[2]);
	if( n < 0 ){
		/* Invalid length */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Perform the comparison */
	z1 = jx9_value_to_string(apArg[0], 0);
	z2 = jx9_value_to_string(apArg[1], 0);
	res = SyStrnicmp(z1, z2, (sxu32)n);
	/* Comparison result */
	jx9_result_int(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x496d6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4963f
jmp 0x4971e
movq 0x10(%r14), %rdi
callq 0x29772
testl %eax, %eax
js 0x49713
movl %eax, %r15d
movq (%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %rax, %r12
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x32436
movq %rbx, %rdi
movl %eax, %esi
jmp 0x49719
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_implode
static int jx9Builtin_implode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	struct implode_data imp_data;
	int i = 1;
	if( nArg < 1 ){
		/* Missing argument, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Prepare the implode context */
	imp_data.pCtx = pCtx;
	imp_data.bRecursive = 0;
	imp_data.bFirst = 1;
	imp_data.nRecCount = 0;
	if( !jx9_value_is_json_array(apArg[0]) ){
		imp_data.zSep = jx9_value_to_string(apArg[0], &imp_data.nSeplen);
	}else{
		imp_data.zSep = 0;
		imp_data.nSeplen = 0;
		i = 0;
	}
	jx9_result_string(pCtx, "", 0); /* Set an empty stirng */
	/* Start the 'join' process */
	while( i < nArg ){
		if( jx9_value_is_json_array(apArg[i]) ){
			/* Iterate throw array entries */
			jx9_array_walk(apArg[i], implode_callback, &imp_data);
		}else{
			const char *zData;
			int nLen;
			/* Extract the string representation of the jx9 value */
			zData = jx9_value_to_string(apArg[i], &nLen);
			if( nLen > 0 ){
				if( imp_data.nSeplen > 0 ){
					if( !imp_data.bFirst ){
						/* append the separator first */
						jx9_result_string(pCtx, imp_data.zSep, imp_data.nSeplen);
					}else{
						imp_data.bFirst = 0;
					}
				}
				jx9_result_string(pCtx, zData, nLen);
			}
		}
		i++;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4976f
movq %rdx, %r14
movl %esi, %r15d
movq %rbx, -0x58(%rbp)
andl $0x0, -0x50(%rbp)
movq $0x1, -0x3c(%rbp)
movq (%rdx), %rdi
testb $0x40, 0x8(%rdi)
jne 0x49788
leaq -0x40(%rbp), %rsi
callq 0x297ed
pushq $0x1
popq %r12
jmp 0x49791
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $0x0, -0x40(%rbp)
xorl %eax, %eax
xorl %r12d, %r12d
leaq -0x58(%rbp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x1deb2(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
movl %r15d, %r13d
cmpq %r13, %r12
jae 0x49777
movq (%r14,%r12,8), %rdi
testb $0x40, 0x8(%rdi)
jne 0x497e2
leaq -0x2c(%rbp), %rsi
callq 0x297ed
movl -0x2c(%rbp), %edx
testl %edx, %edx
jle 0x49810
movq %rax, %r15
movl -0x40(%rbp), %eax
testl %eax, %eax
jle 0x49805
cmpl $0x0, -0x3c(%rbp)
je 0x497f4
andl $0x0, -0x3c(%rbp)
jmp 0x49805
leaq 0x421a(%rip), %rsi      # 0x4da03
leaq -0x58(%rbp), %rdx
callq 0x29c1e
jmp 0x49810
movq -0x48(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x29903
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29903
incq %r12
jmp 0x497ad
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ltrim
static int jx9Builtin_ltrim(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Start the trim process */
	if( nArg < 2 ){
		SyString sStr;
		/* Remove white spaces and NUL byte */
		SyStringInitFromBuf(&sStr, zString, nLen);
		SyStringLeftTrimSafe(&sStr);
		jx9_result_string(pCtx, sStr.zString, (int)sStr.nByte);
	}else{
		/* Char list */
		const char *zList;
		int nListlen;
		zList = jx9_value_to_string(apArg[1], &nListlen);
		if( nListlen < 1 ){
			/* Return the string unchanged */
			jx9_result_string(pCtx, zString, nLen);
		}else{
			const char *zEnd = &zString[nLen];
			const char *zCur = zString;
			const char *zPtr;
			int i;
			/* Left trim */
			for(;;){
				if( zCur >= zEnd ){
					break;
				}
				zPtr = zCur;
				for( i = 0 ; i < nListlen ; i++ ){
					if( zCur < zEnd && zCur[0] == zList[i] ){
						zCur++;
					}
				}
				if( zCur == zPtr ){
					/* No match, break immediately */
					break;
				}
			}
			if( zCur >= zEnd ){
				/* Return the empty string */
				jx9_result_string(pCtx, "", 0);
			}else{
				jx9_result_string(pCtx, zCur, (int)(zEnd-zCur));
			}
		}
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x49daa
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, -0x30(%rbp)
movq (%rdx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r15
testq %r15, %r15
jle 0x49e13
movq %rax, %r14
cmpl $0x1, %r13d
jne 0x49db4
movq %r14, %r12
addq %r15, %r12
movl %r15d, %r13d
subl $0x1, %r13d
jb 0x49e25
movsbq (%r14), %rbx
cmpq $-0x41, %rbx
ja 0x49e22
testb %bl, %bl
je 0x49da2
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x49e22
incq %r14
movl %r13d, %r15d
jmp 0x49d73
callq 0x298e8
jmp 0x49e3f
movq 0x8(%r12), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %rdi
movslq -0x34(%rbp), %rcx
testq %rdi, %rdi
jle 0x49e31
movq %r14, %rdx
addq %rcx, %rdx
cmpq %rdx, %r14
jae 0x49e13
movq %r14, %rsi
xorl %ecx, %ecx
cmpq %rcx, %rdi
je 0x49e01
cmpq %rdx, %r14
jae 0x49dfc
movb (%r14), %r8b
xorl %r9d, %r9d
cmpb (%rax,%rcx), %r8b
sete %r9b
addq %r9, %r14
incq %rcx
jmp 0x49de1
cmpq %rsi, %r14
jne 0x49dd7
cmpq %rdx, %rsi
jae 0x49e13
subl %esi, %edx
movq -0x30(%rbp), %rdi
jmp 0x49e3a
leaq 0x1d838(%rip), %rsi     # 0x67652
movq -0x30(%rbp), %rdi
xorl %edx, %edx
jmp 0x49e3a
movq %r14, %r12
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %r15d, %edx
jmp 0x49e3a
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x29903
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strtolower
static int jx9Builtin_strtolower(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString, *zCur, *zEnd;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	zEnd = &zString[nLen];
	for(;;){
		if( zString >= zEnd ){
			/* No more input, break immediately */
			break;
		}
		if( (unsigned char)zString[0] >= 0xc0 ){
			/* UTF-8 stream, output verbatim */
			zCur = zString;
			zString++;
			while( zString < zEnd && ((unsigned char)zString[0] & 0xc0) == 0x80){
				zString++;
			}
			/* Append UTF-8 stream */
			jx9_result_string(pCtx, zCur, (int)(zString-zCur));
		}else{
			int c = zString[0];
			if( SyisUpper(c) ){
				c = SyToLower(zString[0]);
			}
			/* Append character */
			jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
			/* Advance the cursor */
			zString++;
		}
	}
	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 0x49f0a
movq (%rdx), %rdi
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movslq (%r14), %r13
testq %r13, %r13
jle 0x49f14
movq %rax, %r15
addq %rax, %r13
pushq $0x1
popq %r12
cmpq %r13, %r15
jae 0x49f25
movsbl (%r15), %r14d
cmpl $-0x40, %r14d
jb 0x49ece
pushq $0x1
popq %rax
movq %rax, %rdx
leaq (%r15,%rax), %r14
cmpq %r13, %r14
jae 0x49ebe
movb (%r14), %cl
andb $-0x40, %cl
leaq 0x1(%rdx), %rax
negb %cl
jo 0x49ea4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29903
movq %r14, %r15
jmp 0x49e8e
movl %r14d, -0x2c(%rbp)
callq 0xc190
movq (%rax), %rax
movslq %r14d, %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x49ef6
callq 0xc4a0
movq (%rax), %rax
movsbq (%r15), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
movl %r12d, %edx
callq 0x29903
incq %r15
jmp 0x49e8e
movq %rbx, %rdi
callq 0x298e8
jmp 0x49f25
leaq 0x1d737(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_ord
static int jx9Builtin_ord(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen, c;
	if( nArg < 1 ){
		/* Missing arguments, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return -1 */
		jx9_result_int(pCtx, -1);
		return JX9_OK;
	}
	/* Extract the ASCII value of the first character */
	c = zString[0];
	/* Return that value */
	jx9_result_int(pCtx, c);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x4a048
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
cmpl $0x0, (%r14)
jle 0x4a048
movsbl (%rax), %esi
jmp 0x4a04b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x2987c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_chr
static int jx9Builtin_chr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int c;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the ASCII value */
	c = jx9_value_to_int(apArg[0]);
	/* Return the specified character */
	jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4a086
movq (%rdx), %rdi
callq 0x29772
leaq -0xc(%rbp), %rsi
movl %eax, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x29903
jmp 0x4a08e
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_bin2hex
static int jx9Builtin_bin2hex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zString;
	int nLen;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zString = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string, return */
		jx9_result_string(pCtx, "", 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	SyBinToHexConsumer((const void *)zString, (sxu32)nLen, HashConsumer, 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 0x4a107
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movslq (%r15), %r13
testq %r13, %r13
jle 0x4a111
movq %rax, %r14
addq %rax, %r13
leaq 0x1dd50(%rip), %r15     # 0x67e20
pushq $0x2
popq %r12
cmpq %r13, %r14
jae 0x4a122
movzbl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movb (%rcx,%r15), %cl
movb %cl, -0x2b(%rbp)
andl $0xf, %eax
movb (%rax,%r15), %al
movb %al, -0x2a(%rbp)
movq %rbx, %rdi
leaq -0x2b(%rbp), %rsi
movl %r12d, %edx
callq 0x29903
incq %r14
jmp 0x4a0d4
movq %rbx, %rdi
callq 0x298e8
jmp 0x4a122
leaq 0x1d53a(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strstr
static int jx9Builtin_strstr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	if( nLen > 0 && nPatLen > 0 ){
		int before = 0;
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the portion of the string */
		if( nArg > 2 ){
			before = jx9_value_to_int(apArg[2]);
		}
		if( before ){
			jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
		}else{
			jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
		}
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x4a1ab
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, -0x38(%rbp)
movq 0x8(%r15), %rdi
leaq -0x3c(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
andl $0x0, -0x2c(%rbp)
movl (%r13), %esi
testl %esi, %esi
setg %dl
movl (%r14), %ecx
testl %ecx, %ecx
setg %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x4a1ab
leaq -0x2c(%rbp), %r8
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x4d7da
testl %eax, %eax
je 0x4a1c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r12d
je 0x4a1de
movq 0x10(%r15), %rdi
callq 0x29772
testl %eax, %eax
je 0x4a1de
movl -0x2c(%rbp), %edx
jmp 0x4a1e9
movl -0x2c(%rbp), %eax
addq %rax, %r14
movl -0x30(%rbp), %edx
subl %eax, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29903
jmp 0x4a1b5
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_stristr
static int jx9Builtin_stristr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	if( nLen > 0 && nPatLen > 0 ){
		int before = 0;
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the portion of the string */
		if( nArg > 2 ){
			before = jx9_value_to_int(apArg[2]);
		}
		if( before ){
			jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
		}else{
			jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
		}
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x4a26e
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x297ed
movq %rax, -0x38(%rbp)
movq 0x8(%r15), %rdi
leaq -0x3c(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
andl $0x0, -0x2c(%rbp)
movl (%r13), %esi
testl %esi, %esi
setg %dl
movl (%r14), %ecx
testl %ecx, %ecx
setg %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x4a26e
leaq -0x2c(%rbp), %r8
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x4dabc
testl %eax, %eax
je 0x4a289
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r12d
je 0x4a2a1
movq 0x10(%r15), %rdi
callq 0x29772
testl %eax, %eax
je 0x4a2a1
movl -0x2c(%rbp), %edx
jmp 0x4a2ac
movl -0x2c(%rbp), %eax
addq %rax, %r14
movl -0x30(%rbp), %edx
subl %eax, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29903
jmp 0x4a278
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strpos
static int jx9Builtin_strpos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen, nStart;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	nStart = 0;
	/* Peek the starting offset if available */
	if( nArg > 2 ){
		nStart = jx9_value_to_int(apArg[2]);
		if( nStart < 0 ){
			nStart = -nStart;
		}
		if( nStart >= nLen ){
			/* Invalid offset */
			nStart = 0;
		}else{
			zBlob += nStart;
			nLen -= nStart;
		}
	}
	if( nLen > 0 && nPatLen > 0 ){
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the pattern position */
		jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x4a35f
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x297ed
movq %rax, %r14
movq 0x8(%r12), %rdi
leaq -0x34(%rbp), %rsi
callq 0x297ed
movq %rax, %r15
andl $0x0, -0x30(%rbp)
cmpl $0x2, %r13d
jne 0x4a30e
xorl %r12d, %r12d
movl -0x2c(%rbp), %esi
jmp 0x4a338
movq 0x10(%r12), %rdi
callq 0x29772
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl -0x2c(%rbp), %esi
xorl %r12d, %r12d
movl %esi, %eax
subl %ecx, %eax
jle 0x4a338
movl %ecx, %edx
addq %rdx, %r14
movl %eax, -0x2c(%rbp)
movl %eax, %esi
movl %ecx, %r12d
testl %esi, %esi
setg %al
movl -0x34(%rbp), %ecx
testl %ecx, %ecx
setg %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x4a35f
leaq -0x30(%rbp), %r8
movq %r14, %rdi
movq %r15, %rdx
callq 0x4d7da
testl %eax, %eax
je 0x4a37a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl -0x30(%rbp), %r12d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29897
jmp 0x4a369
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_stripos
static int jx9Builtin_stripos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
	const char *zBlob, *zPattern;
	int nLen, nPatLen, nStart;
	sxu32 nOfft;
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the needle and the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	zPattern = jx9_value_to_string(apArg[1], &nPatLen);
	nOfft = 0; /* cc warning */
	nStart = 0;
	/* Peek the starting offset if available */
	if( nArg > 2 ){
		nStart = jx9_value_to_int(apArg[2]);
		if( nStart < 0 ){
			nStart = -nStart;
		}
		if( nStart >= nLen ){
			/* Invalid offset */
			nStart = 0;
		}else{
			zBlob += nStart;
			nLen -= nStart;
		}
	}
	if( nLen > 0 && nPatLen > 0 ){
		/* Perform the lookup */
		rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
		if( rc != SXRET_OK ){
			/* Pattern not found, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the pattern position */
		jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
	}else{
		jx9_result_bool(pCtx, 0);
	}
	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 0x4a431
movq %rdx, %r12
movl %esi, %r13d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x297ed
movq %rax, %r14
movq 0x8(%r12), %rdi
leaq -0x34(%rbp), %rsi
callq 0x297ed
movq %rax, %r15
andl $0x0, -0x30(%rbp)
cmpl $0x2, %r13d
jne 0x4a3e0
xorl %r12d, %r12d
movl -0x2c(%rbp), %esi
jmp 0x4a40a
movq 0x10(%r12), %rdi
callq 0x29772
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl -0x2c(%rbp), %esi
xorl %r12d, %r12d
movl %esi, %eax
subl %ecx, %eax
jle 0x4a40a
movl %ecx, %edx
addq %rdx, %r14
movl %eax, -0x2c(%rbp)
movl %eax, %esi
movl %ecx, %r12d
testl %esi, %esi
setg %al
movl -0x34(%rbp), %ecx
testl %ecx, %ecx
setg %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x4a431
leaq -0x30(%rbp), %r8
movq %r14, %rdi
movq %r15, %rdx
callq 0x4dabc
testl %eax, %eax
je 0x4a44c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl -0x30(%rbp), %r12d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29897
jmp 0x4a43b
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strrchr
static int jx9Builtin_strrchr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zBlob;
	int nLen, c;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the haystack */
	zBlob = jx9_value_to_string(apArg[0], &nLen);
	c = 0; /* cc warning */
	if( nLen > 0 ){
		sxu32 nOfft;
		sxi32 rc;
		if( jx9_value_is_string(apArg[1]) ){
			const char *zPattern;
			zPattern = jx9_value_to_string(apArg[1], 0); /* Never fail, so there is no need to check
														 * for NULL pointer.
														 */
			c = zPattern[0];
		}else{
			/* Int cast */
			c = jx9_value_to_int(apArg[1]);
		}
		/* Perform the lookup */
		rc = SyByteFind2(zBlob, (sxu32)nLen, c, &nOfft);
		if( rc != SXRET_OK ){
			/* No such entry, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
		/* Return the string portion */
		jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
	}else{
		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
cmpl $0x1, %esi
jle 0x4a731
movq %rdx, %r15
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x297ed
cmpl $0x0, (%r12)
jle 0x4a731
movq %rax, %r14
movq 0x8(%r15), %rdi
testb $0x1, 0x8(%rdi)
jne 0x4a6d9
callq 0x29772
jmp 0x4a6e3
xorl %esi, %esi
callq 0x297ed
movsbl (%rax), %eax
movl -0x24(%rbp), %edx
leal -0x1(%rdx), %ecx
addq %r14, %rcx
decq %rcx
leaq 0x1(%rcx), %rdi
cmpq %r14, %rdi
jb 0x4a731
movsbl (%rdi), %esi
cmpl %esi, %eax
je 0x4a74d
cmpq %r14, %rcx
jb 0x4a731
movsbl (%rcx), %esi
cmpl %esi, %eax
je 0x4a74a
leaq -0x1(%rcx), %rdi
cmpq %r14, %rdi
jb 0x4a731
movsbl (%rdi), %esi
cmpl %esi, %eax
je 0x4a74d
leaq -0x2(%rcx), %rdi
cmpq %r14, %rdi
jb 0x4a731
movsbl (%rdi), %esi
cmpl %esi, %eax
je 0x4a74d
addq $-0x4, %rcx
jmp 0x4a6ef
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rdi
subq %r14, %rdi
movl %edi, %esi
addq %r14, %rsi
subl %edi, %edx
movq %rbx, %rdi
callq 0x29903
jmp 0x4a73b
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strrev
static int jx9Builtin_strrev(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zIn, *zEnd;
	int nLen, c;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = jx9_value_to_string(apArg[0], &nLen);
	if( nLen < 1 ){
		/* Empty string Return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Perform the requested operation */
	zEnd = &zIn[nLen - 1];
	for(;;){
		if( zEnd < zIn ){
			/* No more input to process */
			break;
		}
		/* Append current character */
		c = zEnd[0];
		jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
		zEnd--;
	}
	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 0x4a7bf
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x297ed
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0x4a7bf
leaq (%rax,%r14), %r13
decq %r13
leaq -0x2c(%rbp), %r15
pushq $0x1
popq %r12
cmpq %r14, %r13
jb 0x4a7c7
movsbl (%r13), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x29903
decq %r13
jmp 0x4a79f
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq