LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_json_encode
static int vm_builtin_json_encode(jx9_context *pCtx,int nArg,jx9_value **apArg)
{
	SyBlob sBlob;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Init the working buffer */
	SyBlobInit(&sBlob,&pCtx->pVm->sAllocator);
	/* Perform the encoding operation */
	jx9JsonSerialize(apArg[0],&sBlob);
	/* Return the serialized value */
	jx9_result_string(pCtx,(const char *)SyBlobData(&sBlob),(int)SyBlobLength(&sBlob));
	/* Cleanup */
	SyBlobRelease(&sBlob);
	/* All done */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x50923
movq 0x60(%rbx), %rax
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, -0x8(%r14)
xorl %eax, %eax
movl %eax, 0x10(%r14)
movq (%rdx), %rdi
leaq -0x50(%rbp), %rsi
movl %eax, 0x10(%rsi)
leaq -0x38(%rbp), %r15
movq %r15, (%rsi)
movq $0x1, 0x8(%rsi)
callq 0x40052
movq 0x8(%r15), %rsi
movl 0x10(%r15), %edx
movq 0x8(%rbx), %rdi
callq 0x3087c
testb $0x6, 0x18(%r15)
jne 0x50912
cmpl $0x0, -0x24(%rbp)
je 0x50912
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3503f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x0, 0x10(%r14)
jmp 0x50944
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 $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_json_decode
static int vm_builtin_json_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zJSON;
	int nByte;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the JSON string */
	zJSON = jx9_value_to_string(apArg[0], &nByte);
	if( nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Decode the raw JSON */
	jx9JsonDecode(pCtx,zJSON,nByte);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x50a1a
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x50a1a
leaq -0x44(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %edx
testl %edx, %edx
jle 0x50a1a
movq 0x60(%rbx), %rcx
leaq -0x40(%rbp), %rsi
movq $0x20, 0x18(%rsi)
movq %rcx, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x20(%rsi)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
leaq -0x88(%rbp), %rdi
movq %rsi, 0x38(%rdi)
leaq 0x157f(%rip), %rcx      # 0x51f4c
movq %rcx, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movq $0x1, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x20(%rdi)
movq %rax, %rsi
callq 0x4a216
cmpl $0x0, (%r14)
je 0x50a31
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x50a0a
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x50a0a
callq 0x3503f
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
movl %eax, -0x30(%rbp)
movl %eax, -0x24(%rbp)
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xc8(%rbp), %rdi
movq %rbx, (%rdi)
movq %r14, 0x38(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x30(%rbp), %ecx
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, 0x28(%rdi)
xorl %eax, %eax
movl %eax, 0x18(%rdi)
movl %eax, 0x30(%rdi)
leaq 0x19f8(%rip), %rax      # 0x5245c
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x5246c
movl %eax, -0x14(%rbp)
cmpl $-0xa, %eax
jne 0x50a88
movq 0x8(%rbx), %rdi
callq 0x309f2
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x50a9f
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0x50a9f
callq 0x3503f
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
movl %eax, -0x30(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x50a23
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_num_args
static int vm_builtin_func_num_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	VmFrame *pFrame;
	jx9_vm *pVm;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Current frame */
	pFrame = pVm->pFrame;
	if( pFrame->pParent == 0 ){
		SXUNUSED(nArg);
		SXUNUSED(apArg);
		/* Global frame, return -1 */
		jx9_result_int(pCtx, -1);
		return SXRET_OK;
	}
	/* Total number of arguments passed to the enclosing function */
	nArg = (int)SySetUsed(&pFrame->sArg);
	jx9_result_int(pCtx, nArg);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x60(%rdi), %rax
movq 0xf8(%rax), %rax
cmpq $0x0, (%rax)
je 0x50ae4
movslq 0x90(%rax), %r14
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x50af7
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $-0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
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: vm_builtin_func_get_arg
static int vm_builtin_func_get_arg(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pObj = 0;
	VmSlot *pSlot = 0;
	VmFrame *pFrame;
	jx9_vm *pVm;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Current frame */
	pFrame = pVm->pFrame;
	if( nArg < 1 || pFrame->pParent == 0 ){
		/* Global frame or Missing arguments, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract the desired index */
	nArg = jx9_value_to_int(apArg[0]);
	if( nArg < 0 || nArg >= (int)SySetUsed(&pFrame->sArg) ){
		/* Invalid index, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract the desired argument */
	if( (pSlot = (VmSlot *)SySetAt(&pFrame->sArg, (sxu32)nArg)) != 0 ){
		if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pSlot->nIdx)) != 0 ){
			/* Return the desired argument */
			jx9_result_value(pCtx, (jx9_value *)pObj);
		}else{
			/* No such argument, return false */
			jx9_result_bool(pCtx, 0);
		}
	}else{
		/* CAN'T HAPPEN */
		jx9_result_bool(pCtx, 0);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
testl %esi, %esi
jle 0x50b69
movq 0xf8(%r14), %r12
cmpq $0x0, (%r12)
je 0x50b69
movq (%rdx), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %eax
testl %eax, %eax
js 0x50b84
cmpl %eax, 0x90(%r12)
jle 0x50b84
cmpl %eax, 0x90(%r12)
jbe 0x50bb0
imull 0x98(%r12), %eax
addq 0x88(%r12), %rax
jmp 0x50bb2
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x2776b(%rip), %rcx     # 0x782e2
movq %r14, %rdi
movl $0x2, %edx
callq 0x4153c
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
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
testq %rax, %rax
je 0x50b84
movl (%rax), %edi
cmpl %edi, 0x218(%r14)
jbe 0x50bd3
imull 0x220(%r14), %edi
addq 0x210(%r14), %rdi
jmp 0x50bd5
xorl %edi, %edi
movq 0x8(%rbx), %rbx
testq %rdi, %rdi
je 0x50b88
movq %rbx, %rsi
callq 0x3ebc8
jmp 0x50ba5
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_func_get_args
static int vm_builtin_func_get_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pObj = 0;
	jx9_value *pArray;
	VmFrame *pFrame;
	VmSlot *aSlot;
	sxu32 n;
	/* Point to the current frame */
	pFrame = pCtx->pVm->pFrame;
	if( pFrame->pParent == 0 ){
		/* Global frame, return FALSE */
		jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Start filling the array with the given arguments */
	aSlot = (VmSlot *)SySetBasePtr(&pFrame->sArg);
	for( n = 0;  n < SySetUsed(&pFrame->sArg) ; n++ ){
		pObj = (jx9_value *)SySetAt(&pCtx->pVm->aMemObj, aSlot[n].nIdx);
		if( pObj ){
			jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pObj);
		}
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
movq 0xf8(%rdi), %r15
cmpq $0x0, (%r15)
je 0x50c8f
movq %rbx, %rdi
callq 0x317eb
testq %rax, %rax
je 0x50ca7
movq %rax, %r14
cmpl $0x0, 0x90(%r15)
je 0x50c81
movq 0x88(%r15), %r12
xorl %r13d, %r13d
movq 0x60(%rbx), %rax
movl (%r12), %edx
cmpl %edx, 0x218(%rax)
jbe 0x50c56
imull 0x220(%rax), %edx
addq 0x210(%rax), %rdx
jmp 0x50c58
xorl %edx, %edx
testq %rdx, %rdx
je 0x50c6e
testb $0x40, 0x8(%r14)
je 0x50c6e
movq (%r14), %rdi
xorl %esi, %esi
callq 0x3f924
incq %r13
movl 0x90(%r15), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x50c36
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3ebc8
jmp 0x50cc8
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0x27645(%rip), %rcx     # 0x782e2
movl $0x2, %edx
callq 0x4153c
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 $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: vm_builtin_func_exists
static int vm_builtin_func_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	jx9_vm *pVm;
	int nLen;
	int res;
	if( nArg < 1 ){
		/* Missing argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Extract the function name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Assume the function is not defined */
	res = 0;
	/* Perform the lookup */
	if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
		SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
			/* Function is defined */
			res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_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 0x50d5e
movq 0x60(%rbx), %r14
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
movq %rax, %r15
movl (%r12), %edx
testl %edx, %edx
je 0x50d2b
cmpl $0x0, 0x330(%r14)
je 0x50d2b
leaq 0x308(%r14), %rdi
movq %r15, %rsi
callq 0x4573a
testq %rax, %rax
jne 0x50d56
movl -0x24(%rbp), %edx
xorl %r12d, %r12d
testl %edx, %edx
je 0x50d61
cmpl $0x0, 0x2f0(%r14)
je 0x50d61
addq $0x2c8, %r14            # imm = 0x2C8
movq %r14, %rdi
movq %r15, %rsi
callq 0x4573a
testq %rax, %rax
je 0x50d5e
movl $0x1, %r12d
jmp 0x50d61
xorl %r12d, %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r12, (%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: vm_builtin_is_callable
static int vm_builtin_is_callable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vm *pVm;	
	int res;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Perform the requested operation */
	res = jx9VmIsCallable(pVm, apArg[0]);
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x50dbe
movq 0x60(%rbx), %rdi
movq (%rdx), %rsi
callq 0x52930
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movl %r14d, %eax
movq %rax, (%rbx)
jmp 0x50dd1
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
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_defined_func
static int vm_builtin_get_defined_func(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* NOTE:
	 * Don't worry about freeing memory here, every allocated resource will be released
	 * automatically by the engine as soon we return from this foreign function.
	 */
	pArray = jx9_context_new_array(pCtx);
 	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hHostFunction,VmHashFuncStep,pArray);
	/* Fill with the appropriate information */
	SyHashForEach(&pCtx->pVm->hFunction, VmHashFuncStep,pArray);
	/* Return a copy of the array array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x317eb
testq %rax, %rax
je 0x50e90
movq %rax, %r14
movq 0x60(%rbx), %r12
cmpl $0x0, 0x2f0(%r12)
je 0x50e45
leaq 0x2e0(%r12), %r15
xorl %r13d, %r13d
movq (%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x529ba
testl %eax, %eax
jne 0x50e45
addq $0x28, %r15
incl %r13d
cmpl 0x2f0(%r12), %r13d
jb 0x50e22
movq 0x60(%rbx), %r12
cmpl $0x0, 0x330(%r12)
je 0x50e82
leaq 0x320(%r12), %r15
xorl %r13d, %r13d
movq (%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x529ba
testl %eax, %eax
jne 0x50e82
addq $0x28, %r15
incl %r13d
cmpl 0x330(%r12), %r13d
jb 0x50e5f
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3ebc8
jmp 0x50e99
movq 0x8(%rbx), %rdi
callq 0x309f2
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: vm_builtin_defined
static int vm_builtin_defined(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zName;
	int nLen = 0;
	int res = 0;
	if( nArg < 1 ){
		/* Missing constant name, return FALSE */
		jx9_context_throw_error(pCtx,JX9_CTX_NOTICE,"Missing constant name");
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	/* Extract constant name */
	zName = jx9_value_to_string(apArg[0], &nLen);
	/* Perform the lookup */
	if( nLen > 0 && SyHashGet(&pCtx->pVm->hConstant, (const void *)zName, (sxu32)nLen) != 0 ){
		/* Already defined */
		res = 1;
	}
	jx9_result_bool(pCtx, res);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, -0x14(%rbp)
testl %esi, %esi
jle 0x50f01
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %edx
testl %edx, %edx
jle 0x50f1d
movq 0x60(%rbx), %rdi
cmpl $0x0, 0x2b0(%rdi)
je 0x50f1d
addq $0x288, %rdi            # imm = 0x288
movq %rax, %rsi
callq 0x4573a
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
jmp 0x50f20
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x273ea(%rip), %rcx     # 0x782fd
movl $0x3, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_defined_constants
static int vm_builtin_get_defined_constants(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pArray;
	/* Create the array first*/
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* Return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Fill the array with the defined constants */
	SyHashForEach(&pCtx->pVm->hConstant, VmHashConstStep, pArray);
	/* Return the created array */
	jx9_result_value(pCtx, pArray);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x317eb
testq %rax, %rax
je 0x51017
movq %rax, %r14
movq %rbx, -0x38(%rbp)
movq 0x60(%rbx), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x2b0(%rax)
je 0x5102b
movq -0x30(%rbp), %rax
leaq 0x2a0(%rax), %rbx
xorl %r13d, %r13d
leaq -0x80(%rbp), %r15
movq (%rbx), %rbx
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x80(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rcx
movups %xmm0, (%rcx)
movq %rax, -0x68(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x1, -0x78(%rbp)
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r15, %rdi
callq 0x3f7f6
testb $0x40, 0x8(%r14)
je 0x51022
movq (%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3f924
movl %eax, %r12d
movq %r15, %rdi
callq 0x309f2
testl %r12d, %r12d
jne 0x5102b
addq $0x28, %rbx
incl %r13d
movq -0x30(%rbp), %rax
cmpl 0x2b0(%rax), %r13d
jb 0x50f98
jmp 0x5102b
movq 0x8(%rbx), %rdi
callq 0x309f2
jmp 0x5103b
leaq -0x80(%rbp), %rdi
callq 0x309f2
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x3ebc8
xorl %eax, %eax
addq $0x58, %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: vm_builtin_rand
static int vm_builtin_rand(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	sxu32 iNum;
	/* Generate the random number */
	iNum = jx9VmRandomNum(pCtx->pVm);
	if( nArg > 1 ){
		sxu32 iMin, iMax;
		iMin = (sxu32)jx9_value_to_int(apArg[0]);
		iMax = (sxu32)jx9_value_to_int(apArg[1]);
		if( iMin < iMax ){
			sxu32 iDiv = iMax+1-iMin;
			if( iDiv > 0 ){
				iNum = (iNum % iDiv)+iMin;
			}
		}else if(iMax > 0 ){
			iNum %= iMax;
		}
	}
	/* Return the number */
	jx9_result_int64(pCtx, (jx9_int64)iNum);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
addq 0x60(%rbx), %rdi
leaq -0x24(%rbp), %r14
movq %r14, %rsi
movl $0x4, %edx
callq 0x3a4c2
movl (%r14), %r14d
cmpl $0x2, %r12d
jl 0x510ce
movq (%r15), %r12
movq %r12, %rdi
callq 0x3fd5f
movl (%r12), %r12d
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x3fd5f
movl (%r15), %ecx
cmpl %ecx, %r12d
jae 0x510c0
incl %ecx
subl %r12d, %ecx
je 0x510ce
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
addl %r12d, %r14d
jmp 0x510ce
testl %ecx, %ecx
je 0x510ce
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r14d
movl %r14d, %r14d
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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_rand_str
static int vm_builtin_rand_str(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	char zString[1024];
	int iLen = 0x10;
	if( nArg > 0 ){
		/* Get the desired length */
		iLen = jx9_value_to_int(apArg[0]);
		if( iLen < 1 || iLen > 1024 ){
			/* Default length */
			iLen = 0x10;
		}
	}
	/* Generate the random string */
	jx9VmRandomString(pCtx->pVm, zString, iLen);
	/* Return the generated string */
	jx9_result_string(pCtx, zString, iLen); /* Will make it's own copy */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
testl %esi, %esi
jle 0x51138
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %eax
leal -0x401(%rax), %ecx
cmpl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
movl $0x10, %r14d
cmovael %eax, %r14d
jmp 0x5113e
movl $0x10, %r14d
movl $0x100, %edi            # imm = 0x100
addq 0x60(%rbx), %rdi
leaq -0x410(%rbp), %rsi
movl %r14d, %edx
callq 0x3a4c2
testl %r14d, %r14d
jle 0x511a5
movl %r14d, %esi
xorl %edi, %edi
movabsq $0x4ec4ec4ec4ec4ec5, %r8 # imm = 0x4EC4EC4EC4EC4EC5
leaq 0x28caf(%rip), %r9      # 0x79e20
movsbq -0x410(%rbp,%rdi), %rcx
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rax,%rax,4), %rax
addq %rdx, %rax
subq %rax, %rcx
movb (%r9,%rcx), %al
movb %al, -0x410(%rbp,%rdi)
incq %rdi
cmpq %rdi, %rsi
jne 0x51171
movq 0x8(%rbx), %rdi
leaq -0x410(%rbp), %rsi
movl %r14d, %edx
callq 0x3087c
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_getrandmax
static int vm_builtin_getrandmax(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SXUNUSED(nArg); /* cc warning */
	SXUNUSED(apArg);
	jx9_result_int64(pCtx, SXU32_HIGH);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x309f2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%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 %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_print
static int vm_builtin_print(jx9_context *pCtx, int nArg,jx9_value **apArg)
{
	const char *zData;
	int nDataLen = 0;
	jx9_vm *pVm;
	int i, rc;
	/* Point to the target VM */
	pVm = pCtx->pVm;
	/* Output */
	for( i = 0 ; i < nArg ; ++i ){
		zData = jx9_value_to_string(apArg[i], &nDataLen);
		if( nDataLen > 0 ){
			rc = pVm->sVmConsumer.xConsumer((const void *)zData, (unsigned int)nDataLen, pVm->sVmConsumer.pUserData);
			/* Increment output length */
			pVm->nOutputLen += nDataLen;
			if( rc == SXERR_ABORT ){
				/* Output consumer callback request an operation abort */
				return JX9_ABORT;
			}
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, -0x2c(%rbp)
testl %esi, %esi
jle 0x5125c
movq %rdx, %rbx
movq 0x60(%rdi), %r15
movl %esi, %r12d
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r14
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x30b04
movl -0x2c(%rbp), %esi
testl %esi, %esi
jle 0x51254
movq 0x500(%r15), %rdx
movq %rax, %rdi
callq *0x4f8(%r15)
movl -0x2c(%rbp), %ecx
addl %ecx, 0x4f4(%r15)
cmpl $-0xa, %eax
je 0x51260
incq %r13
cmpq %r13, %r12
jne 0x51221
xorl %eax, %eax
jmp 0x51265
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
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: vm_builtin_exit
static int vm_builtin_exit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg > 0 ){
		if( jx9_value_is_string(apArg[0]) ){
			const char *zData;
			int iLen = 0;
			/* Print exit message */
			zData = jx9_value_to_string(apArg[0], &iLen);
			jx9_context_output(pCtx, zData, iLen);
		}else if(jx9_value_is_int(apArg[0]) ){
			sxi32 iExitStatus;
			/* Record exit status code */
			iExitStatus = jx9_value_to_int(apArg[0]);
			pCtx->pVm->iExitStatus = iExitStatus;
		}
	}
	/* Abort processing immediately */
	return JX9_ABORT;
}

// Assembly:
testl %esi, %esi
jle 0x512d9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %r14
movl 0x8(%r14), %eax
testb $0x1, %al
jne 0x512ab
testb $0x2, %al
je 0x512cf
movq %r14, %rdi
callq 0x3fd5f
movl (%r14), %eax
movq 0x60(%rbx), %rcx
movl %eax, 0x560(%rcx)
jmp 0x512cf
leaq -0x1c(%rbp), %r15
movl $0x0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b04
movl (%r15), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x31412
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_gettype
static int vm_builtin_gettype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zType = "null";
	if( nArg > 0 ){
		zType = jx9MemObjTypeDump(apArg[0]);
	}
	/* Return the variable type */
	jx9_result_string(pCtx, zType, -1/*Compute length automatically*/);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x512f9
movq (%rdx), %rdi
callq 0x52a38
movq %rax, %rsi
jmp 0x51300
leaq 0x277d4(%rip), %rsi     # 0x78ad4
movq 0x8(%rbx), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3087c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_get_resource_type
static int vm_builtin_get_resource_type(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return SXRET_OK;
	}
	jx9_result_string_format(pCtx, "resID_%#x", apArg[0]->x.pOther);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5132a
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
jne 0x5134d
movq 0x8(%rdi), %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 0x5135e
movq (%rax), %rdx
leaq 0x26fd3(%rip), %rsi     # 0x7832a
xorl %eax, %eax
callq 0x45c53
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_dump
static int vm_builtin_dump(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyBlob sDump; /* Generated dump is stored here */
	int i;
	SyBlobInit(&sDump,&pCtx->pVm->sAllocator);
	/* Dump one or more expressions */
	for( i = 0 ; i < nArg ; i++ ){
		jx9_value *pObj = apArg[i];
		/* Reset the working buffer */
		SyBlobReset(&sDump);
		/* Dump the given expression */
		jx9MemObjDump(&sDump,pObj);
		/* Output */
		if( SyBlobLength(&sDump) > 0 ){
			jx9_context_output(pCtx, (const char *)SyBlobData(&sDump), (int)SyBlobLength(&sDump));
		}
	}
	/* Release the working buffer */
	SyBlobRelease(&sDump);
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x50(%rbp)
movq 0x60(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movl $0x0, -0x30(%rbp)
testl %esi, %esi
jle 0x51517
movq %rdx, %rbx
movl %esi, %r12d
leaq -0x48(%rbp), %r15
xorl %r14d, %r14d
movq (%rbx,%r14,8), %r13
movl $0x0, -0x38(%rbp)
movl -0x30(%rbp), %eax
testb $0x4, %al
je 0x513ce
movq $0x0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
andl $-0x5, %eax
movl %eax, -0x30(%rbp)
movq %r13, %rdi
callq 0x52a38
cmpb $0x0, (%rax)
movq %rax, %rdx
je 0x51414
movq %rax, %rdx
addq $0x2, %rdx
cmpb $0x0, -0x1(%rdx)
je 0x5140c
cmpb $0x0, (%rdx)
je 0x51414
cmpb $0x0, 0x1(%rdx)
je 0x51411
leaq 0x4(%rdx), %rcx
cmpb $0x0, 0x2(%rdx)
movq %rcx, %rdx
jne 0x513e5
addq $-0x2, %rcx
movq %rcx, %rdx
jmp 0x51414
decq %rdx
jmp 0x51414
incq %rdx
subl %eax, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x360ae
testb $0x20, 0x8(%r13)
jne 0x514e3
movq %r15, %rdi
leaq 0x21fbe(%rip), %rsi     # 0x733f4
movl $0x1, %edx
callq 0x360ae
movl 0x8(%r13), %eax
testb $0x40, %al
jne 0x51459
testb $0x1, %al
jne 0x51492
movq %r15, %rdi
movq %r13, %rsi
callq 0x3ff83
jmp 0x514cf
movq (%r13), %rax
movl 0x2c(%rax), %edx
movq %r15, %rdi
leaq 0x26eca(%rip), %rsi     # 0x78334
xorl %eax, %eax
callq 0x3ec96
movl $0x0, -0x58(%rbp)
movq %r15, -0x68(%rbp)
movq $0x1, -0x60(%rbp)
movq %r13, %rdi
leaq -0x68(%rbp), %rsi
callq 0x40052
jmp 0x514cf
movl 0x28(%r13), %edx
movq %r15, %rdi
leaq 0x26e98(%rip), %rsi     # 0x78338
xorl %eax, %eax
callq 0x3ec96
movl 0x28(%r13), %edx
testl %edx, %edx
je 0x514bb
movq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x360ae
movq %r15, %rdi
leaq 0x26e76(%rip), %rsi     # 0x7833b
movl $0x1, %edx
callq 0x360ae
movq %r15, %rdi
leaq 0x227ee(%rip), %rsi     # 0x73cc7
movl $0x1, %edx
callq 0x360ae
movq %r15, %rdi
leaq 0x28df4(%rip), %rsi     # 0x7a2e1
movl $0x1, %edx
callq 0x360ae
movl -0x38(%rbp), %edx
testl %edx, %edx
je 0x5150b
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x31412
incq %r14
cmpq %r12, %r14
jne 0x513a7
leaq -0x40(%rbp), %rbx
testb $0x6, 0x10(%rbx)
jne 0x51534
cmpl $0x0, -0x34(%rbp)
je 0x51534
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3503f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
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: vm_builtin_extract
static int vm_builtin_extract(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	extract_aux_data sAux;
	jx9_hashmap *pMap;
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Empty map, return  0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Prepare the aux data */
	SyZero(&sAux, sizeof(extract_aux_data)-sizeof(sAux.zWorker));
	if( nArg > 1 ){
		sAux.iFlags = jx9_value_to_int(apArg[1]);
		if( nArg > 2 ){
			sAux.zPrefix = jx9_value_to_string(apArg[2], &sAux.Prefixlen);
		}
	}
	sAux.pVm = pCtx->pVm;
	/* Invoke the worker callback */
	jx9HashmapWalk(pMap, VmExtractCallback, &sAux);
	/* Number of variables successfully imported */
	jx9_result_int(pCtx, sAux.iCount);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rdi, %rbx
testl %esi, %esi
jle 0x51647
movq %rdx, %r15
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x51647
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x51647
movl %esi, %r12d
movq $-0x4, %rax
movl $0x0, -0x444(%rbp,%rax)
addq $0x4, %rax
cmpq $0x1c, %rax
jb 0x515c4
cmpl $0x1, %r12d
je 0x51612
movq 0x8(%r15), %r13
movq %r13, %rdi
callq 0x3fd5f
movl (%r13), %eax
movl %eax, -0x42c(%rbp)
cmpl $0x3, %r12d
jl 0x51612
movq 0x10(%r15), %rdi
leaq -0x430(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movq %rax, -0x8(%r15)
movq 0x60(%rbx), %rax
leaq -0x448(%rbp), %r15
movq %rax, (%r15)
leaq 0x1584(%rip), %rsi      # 0x52bab
movq %r14, %rdi
movq %r15, %rdx
callq 0x52ab1
movslq 0x8(%r15), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x5165a
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
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: vm_builtin_utf8_decode
static int vm_builtin_utf8_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const unsigned char *zIn, *zEnd;
	int nByte, c;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the target string */
	zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nByte);
	if( nByte < 1 ){
		/* Empty string, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	zEnd = &zIn[nByte];
	/* Start the decoding process */
	while( zIn < zEnd ){
		c = jx9Utf8Read(zIn, zEnd, &zIn);
		if( c == 0x0 ){
			break;
		}
		jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
	}
	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 0x51bf5
movq (%rdx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movq %rax, %r14
movq %rax, -0x28(%rbp)
movslq (%r15), %rax
testq %rax, %rax
jle 0x51bf5
addq %rax, %r14
movq -0x28(%rbp), %rdi
cmpq %r14, %rdi
jae 0x51bfe
leaq -0x28(%rbp), %r15
leaq -0x2c(%rbp), %r12
movq %r14, %rsi
movq %r15, %rdx
callq 0x52cee
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x51bfe
movq 0x8(%rbx), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x3087c
movq -0x28(%rbp), %rdi
cmpq %r14, %rdi
jb 0x51bc7
jmp 0x51bfe
movq 0x8(%rbx), %rdi
callq 0x309f2
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: vm_builtin_include
static int vm_builtin_include(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyString sFile;
	sxi32 rc;
	if( nArg < 1 ){
		/* Nothing to evaluate, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* File to include */
	sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
	if( sFile.nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Open, compile and execute the desired script */
	rc = VmExecIncludedFile(&(*pCtx), &sFile, FALSE);
	if( rc != SXRET_OK ){
		/* Emit a warning and return false */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
		jx9_result_bool(pCtx, 0);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x51e8d
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x51e8d
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x53240
testl %eax, %eax
je 0x51e96
leaq 0x265a1(%rip), %rdx     # 0x783f8
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
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 0x51e96
movq 0x8(%rbx), %rdi
callq 0x309f2
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: vm_builtin_import
static int vm_builtin_import(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SyString sFile;
	sxi32 rc;
	if( nArg < 1 ){
		/* Nothing to evaluate, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* File to include */
	sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
	if( sFile.nByte < 1 ){
		/* Empty string, return NULL */
		jx9_result_null(pCtx);
		return SXRET_OK;
	}
	/* Open, compile and execute the desired script */
	rc = VmExecIncludedFile(&(*pCtx), &sFile, TRUE);
	if( rc == SXERR_EXISTS ){
		/* File already included, return TRUE */
		jx9_result_bool(pCtx, 1);
		return SXRET_OK;
	}
	if( rc != SXRET_OK ){
		/* Emit a warning and return false */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
		jx9_result_bool(pCtx, 0);
 	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x51efb
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x51efb
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x53240
testl %eax, %eax
je 0x51f41
cmpl $-0xb, %eax
jne 0x51f06
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq $0x1, (%rbx)
jmp 0x51f33
movq 0x8(%rbx), %rdi
callq 0x309f2
jmp 0x51f41
leaq 0x264eb(%rip), %rdx     # 0x783f8
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
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
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonDequoteString
static void VmJsonDequoteString(const SyString *pStr, jx9_value *pWorker)
{
	const char *zIn = pStr->zString;
	const char *zEnd = &pStr->zString[pStr->nByte];
	const char *zCur;
	int c;
	/* Mark the value as a string */
	jx9_value_string(pWorker, "", 0); /* Empty string */
	for(;;){
		zCur = zIn;
		while( zIn < zEnd && zIn[0] != '\\' ){
			zIn++;
		}
		if( zIn > zCur ){
			/* Append chunk verbatim */
			jx9_value_string(pWorker, zCur, (int)(zIn-zCur));
		}
		zIn++;
		if( zIn >= zEnd ){
			/* End of the input reached */
			break;
		}
		c = zIn[0];
		/* Unescape the character */
		switch(c){
		case '"':  jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
		case '\\': jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
		case 'n':  jx9_value_string(pWorker, "\n", (int)sizeof(char)); break;
		case 'r':  jx9_value_string(pWorker, "\r", (int)sizeof(char)); break;
		case 't':  jx9_value_string(pWorker, "\t", (int)sizeof(char)); break;
		case 'f':  jx9_value_string(pWorker, "\f", (int)sizeof(char)); break;
		default:
			jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char));
			break;
		}
		/* Advance the stream cursor */
		zIn++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r13
movl 0x8(%rdi), %r15d
addq %r13, %r15
leaq 0x26de8(%rip), %rsi     # 0x79667
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3087c
leaq -0x2c(%rbp), %r12
movq %r13, %r14
cmpq %r15, %r13
jae 0x528a6
movq %r13, %r14
cmpb $0x5c, (%r14)
je 0x528a6
incq %r14
cmpq %r15, %r14
jb 0x52898
cmpq %r13, %r14
jbe 0x528bc
movl %r14d, %edx
subl %r13d, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3087c
leaq 0x1(%r14), %rax
cmpq %r15, %rax
jae 0x5290b
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x66, %eax
rorb %al
movq %r12, %rsi
cmpb $0x7, %al
ja 0x528f5
movzbl %al, %eax
movl $0xd1, %ecx
btl %eax, %ecx
movq %r12, %rsi
jae 0x528f5
leaq 0x22c9a(%rip), %rcx     # 0x75588
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x3087c
addq $0x2, %r14
movq %r14, %r13
jmp 0x52890
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: jx9VmIsCallable
JX9_PRIVATE int jx9VmIsCallable(jx9_vm *pVm, jx9_value *pValue)
{
	int res = 0;
	if( pValue->iFlags & MEMOBJ_STRING ){
		const char *zName;
		int nLen;
		/* Extract the name */
		zName = jx9_value_to_string(pValue, &nLen);
		/* Perform the lookup */
		if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
			SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
				/* Function is callable */
				res = 1;
		}
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testb $0x1, 0x8(%rsi)
je 0x529ac
movq %rdi, %rbx
leaq -0x1c(%rbp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x30b04
movq %rax, %r15
movl (%r14), %edx
testl %edx, %edx
je 0x5297c
cmpl $0x0, 0x330(%rbx)
je 0x5297c
leaq 0x308(%rbx), %rdi
movq %r15, %rsi
callq 0x4573a
testq %rax, %rax
jne 0x529a6
movl -0x1c(%rbp), %edx
xorl %r14d, %r14d
testl %edx, %edx
je 0x529ac
cmpl $0x0, 0x2f0(%rbx)
je 0x529ac
addq $0x2c8, %rbx            # imm = 0x2C8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4573a
testq %rax, %rax
je 0x529ac
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmHashFuncStep
static int VmHashFuncStep(SyHashEntry *pEntry, void *pUserData)
{
	jx9_value *pArray = (jx9_value *)pUserData;
	jx9_value sName;
	sxi32 rc;
	/* Prepare the function name for insertion */
	jx9MemObjInitFromString(pArray->pVm, &sName, 0);
	jx9MemObjStringAppend(&sName, (const char *)pEntry->pKey, pEntry->nKeyLen);
	/* Perform the insertion */
	rc = jx9_array_add_elem(pArray, 0/* Automatic index assign */, &sName); /* Will make it's own copy */
	jx9MemObjRelease(&sName);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq 0x10(%rsi), %rcx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x0, 0x30(%rax)
movl $0x1, 0x8(%rax)
movq (%rdi), %rsi
movl 0x8(%rdi), %edx
movq %rax, %rdi
callq 0x3f7f6
movl $0xffffffe8, %r14d      # imm = 0xFFFFFFE8
testb $0x40, 0x8(%rbx)
je 0x52a23
movq (%rbx), %rdi
leaq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0x3f924
movl %eax, %r14d
leaq -0x50(%rbp), %rdi
callq 0x309f2
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjTypeDump
JX9_PRIVATE const char * jx9MemObjTypeDump(jx9_value *pVal)
{
	const char *zType = "";
	if( pVal->iFlags & MEMOBJ_NULL ){
		zType = "null";
	}else if( pVal->iFlags & MEMOBJ_INT ){
		zType = "int";
	}else if( pVal->iFlags & MEMOBJ_REAL ){
		zType = "float";
	}else if( pVal->iFlags & MEMOBJ_STRING ){
		zType = "string";
	}else if( pVal->iFlags & MEMOBJ_BOOL ){
		zType = "bool";
	}else if( pVal->iFlags & MEMOBJ_HASHMAP ){
		jx9_hashmap *pMap = (jx9_hashmap *)pVal->x.pOther;
		if( pMap->iFlags & HASHMAP_JSON_OBJECT ){
			zType = "JSON Object";
		}else{
			zType = "JSON Array";
		}
	}else if( pVal->iFlags & MEMOBJ_RES ){
		zType = "resource";
	}
	return zType;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x20, %al
jne 0x52a6a
testb $0x2, %al
jne 0x52a72
testb $0x4, %al
jne 0x52a7a
testb $0x1, %al
jne 0x52a82
testb $0x8, %al
jne 0x52a8a
testb $0x40, %al
jne 0x52a92
btl $0x8, %eax
leaq 0x26c09(%rip), %rcx     # 0x79667
leaq 0x2609f(%rip), %rax     # 0x78b04
cmovaeq %rcx, %rax
retq
leaq 0x26063(%rip), %rax     # 0x78ad4
retq
leaq 0x26037(%rip), %rax     # 0x78ab0
retq
leaq 0x26014(%rip), %rax     # 0x78a95
retq
leaq 0x2630d(%rip), %rax     # 0x78d96
retq
leaq 0x25ffc(%rip), %rax     # 0x78a8d
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testb $0x1, 0x40(%rax)
leaq 0x2587b(%rip), %rcx     # 0x7831f
leaq 0x25868(%rip), %rax     # 0x78313
cmoveq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapWalk
JX9_PRIVATE sxi32 jx9HashmapWalk(
	jx9_hashmap *pMap, /* Target hashmap */
	int (*xWalk)(jx9_value *, jx9_value *, void *), /* Walker callback */
	void *pUserData /* Last argument to xWalk() */
	)
{
	jx9_hashmap_node *pEntry;
	jx9_value sKey, sValue;
	sxi32 rc;
	sxu32 n;
	/* Initialize walker parameter */
	rc = SXRET_OK;
	jx9MemObjInit(pMap->pVm, &sKey);
	jx9MemObjInit(pMap->pVm, &sValue);
	n = pMap->nEntry;
	pEntry = pMap->pFirst;
	/* Start the iteration process */
	for(;;){
		if( n < 1 ){
			break;
		}
		/* Extract a copy of the key and a copy the current value */
		jx9HashmapExtractNodeKey(pEntry, &sKey);
		jx9HashmapExtractNodeValue(pEntry, &sValue, FALSE);
		/* Invoke the user callback */
		rc = xWalk(&sKey, &sValue, pUserData);
		/* Release the copy of the key and the value */
		jx9MemObjRelease(&sKey);
		jx9MemObjRelease(&sValue);
		if( rc != JX9_OK ){
			/* Callback request an operation abort */
			return SXERR_ABORT;
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
		n--;
	}
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq (%rdi), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0xa0(%rbp)
movq %rcx, -0xb0(%rbp)
movq %rcx, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, -0x90(%rbp)
movl $0x20, %edx
movl %edx, -0xb8(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x60(%rbp)
movq %rcx, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movl %eax, -0x50(%rbp)
movl %edx, -0x78(%rbp)
movl 0x2c(%rdi), %r14d
testl %r14d, %r14d
je 0x52b99
movq %rdi, %r15
addq $0x10, %r15
leaq -0xc0(%rbp), %r12
leaq -0x80(%rbp), %r13
movq (%r15), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed27
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x44d58
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
callq *-0x30(%rbp)
movl %eax, %ebx
movq %r12, %rdi
callq 0x309f2
movq %r13, %rdi
callq 0x309f2
testl %ebx, %ebx
jne 0x52b94
addq $0x48, %r15
decl %r14d
jne 0x52b49
xorl %eax, %eax
jmp 0x52b99
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
addq $0x98, %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: jx9Utf8Read
JX9_PRIVATE int jx9Utf8Read(
  const unsigned char *z,         /* First byte of UTF-8 character */
  const unsigned char *zTerm,     /* Pretend this byte is 0x00 */
  const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
){
  int c;
  READ_UTF8(z, zTerm, c);
  *pzNext = z;
  return c;
}

// Assembly:
movzbl (%rdi), %eax
incq %rdi
cmpl $0xc0, %eax
jb 0x52d76
pushq %rbp
movq %rsp, %rbp
addl $0xffffff40, %eax       # imm = 0xFFFFFF40
leaq 0x22145(%rip), %rcx     # 0x74e50
movzbl (%rax,%rcx), %ecx
cmpq %rsi, %rdi
je 0x52d41
movzbl (%rdi), %eax
movl %eax, %r8d
andl $-0x40, %r8d
cmpl $0x80, %r8d
jne 0x52d41
movl %ecx, %r8d
shll $0x6, %r8d
incq %rdi
andl $0x3f, %eax
movl %eax, %ecx
orl %r8d, %ecx
cmpq %rsi, %rdi
jne 0x52d14
movq %rsi, %rdi
movl %ecx, %eax
andl $0x7ffff800, %eax       # imm = 0x7FFFF800
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
cmpl $0xd800, %eax           # imm = 0xD800
movl $0xfffd, %r8d           # imm = 0xFFFD
movl %ecx, %eax
cmovel %r8d, %eax
cmpl $0x80, %ecx
cmovll %r8d, %eax
cmpl $0xfffe, %esi           # imm = 0xFFFE
cmovel %r8d, %eax
popq %rbp
movq %rdi, (%rdx)
retq