LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ExprFreeTree
static void ExprFreeTree(jx9_gen_state *pGen, jx9_expr_node *pNode)
{
	if( pNode->pLeft ){
		/* Release the left tree */
		ExprFreeTree(&(*pGen), pNode->pLeft);
	}
	if( pNode->pRight ){
		/* Release the right tree */
		ExprFreeTree(&(*pGen), pNode->pRight);
	}
	if( pNode->pCond ){
		/* Release the conditional tree used by the ternary operator */
		ExprFreeTree(&(*pGen), pNode->pCond);
	}
	if( SySetUsed(&pNode->aNodeArgs) > 0 ){
		jx9_expr_node **apArg;
		sxu32 n;
		/* Release node arguments */
		apArg = (jx9_expr_node **)SySetBasePtr(&pNode->aNodeArgs);
		for( n = 0 ; n < SySetUsed(&pNode->aNodeArgs) ; ++n ){
			ExprFreeTree(&(*pGen), apArg[n]);
		}
		SySetRelease(&pNode->aNodeArgs);
	}
	/* Finally, release this node */
	SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x89f3c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x89f10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x89f58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x89f10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x89f74
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x89f10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jbe 0x89fc9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jae 0x89fbc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x89f10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x89f91
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x66980
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54490
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ExprIsModifiableValue
static int ExprIsModifiableValue(jx9_expr_node *pNode)
{
	sxi32 iExprOp;
	if( pNode->pOp == 0 ){
		return pNode->xCode == jx9CompileVariable ? TRUE : FALSE;
	}
	iExprOp = pNode->pOp->iOp;
	if( iExprOp == EXPR_OP_DOT /*'.' */  ){
			return TRUE;
	}
	if( iExprOp == EXPR_OP_SUBSCRIPT/*'[]'*/ ){
		if( pNode->pLeft->pOp ) {
			if( pNode->pLeft->pOp->iOp != EXPR_OP_SUBSCRIPT /*'['*/ && pNode->pLeft->pOp->iOp != EXPR_OP_DOT /*'.'*/){
				return FALSE;
			}
		}else if( pNode->pLeft->xCode != jx9CompileVariable ){
			return FALSE;
		}
		return TRUE;
	}
	/* Not a modifiable l or r-value */
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8a276
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x50f1(%rip), %rsi     # 0x85170
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8a303
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8a292
movl $0x1, -0x4(%rbp)
jmp 0x8a303
cmpl $0x2, -0x14(%rbp)
jne 0x8a2fc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
je 0x8a2d3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
je 0x8a2d1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x8a2d1
movl $0x0, -0x4(%rbp)
jmp 0x8a303
jmp 0x8a2f3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
leaq -0x5172(%rip), %rcx     # 0x85170
cmpq %rcx, 0x30(%rax)
je 0x8a2f1
movl $0x0, -0x4(%rbp)
jmp 0x8a303
jmp 0x8a2f3
movl $0x1, -0x4(%rbp)
jmp 0x8a303
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmRegisterSpecialFunction
static sxi32 VmRegisterSpecialFunction(jx9_vm *pVm)
{
	sxi32 rc;
	sxu32 n;
	for( n = 0 ; n < SX_ARRAYSIZE(aVmFunc) ; ++n ){
		/* Note that these special functions have access
		 * to the underlying virtual machine as their
		 * private data.
		 */
		rc = jx9_create_function(&(*pVm), aVmFunc[n].zName, aVmFunc[n].xFunc, &(*pVm));
		if( rc != SXRET_OK ){
			return rc;
		}
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpq $0x1e, %rax
jae 0x8a3b4
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x618e4(%rip), %rax     # 0xebc50
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x618ce(%rip), %rax     # 0xebc50
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0x6d240
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x8a3a7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8a3bb
jmp 0x8a3a9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8a353
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapLoadBuiltin
JX9_PRIVATE sxi32 jx9HashmapLoadBuiltin(jx9_vm *pVm)
{
	static const char * azSuper[] = {
		"_SERVER",   /* $_SERVER */
		"_GET",      /* $_GET */
		"_POST",     /* $_POST */
		"_FILES",    /* $_FILES */
		"_REQUEST",  /* $_REQUEST */
		"_COOKIE",   /* $_COOKIE */
		"_ENV",      /* $_ENV */
		"_HEADER",   /* $_HEADER */
		"argv"       /* $argv */
	};
	SyString *pFile;
	sxi32 rc;
	sxu32 n;
	/* Install globals variable now */
	for( n =  0 ; n < SX_ARRAYSIZE(azSuper)  ; n++ ){
		jx9_value *pSuper;
		/* Request an empty array */
		pSuper = jx9_new_array(&(*pVm));
		if( pSuper == 0 ){
			return SXERR_MEM;
		}
		/* Install */
		rc = jx9_vm_config(&(*pVm),JX9_VM_CONFIG_CREATE_VAR, azSuper[n]/* Super-global name*/, pSuper/* Super-global value */);
		if( rc != SXRET_OK ){
			return rc;
		}
		/* Release the value now it have been installed */
		jx9_release_value(&(*pVm), pSuper);
	}
	/* Set some $_SERVER entries */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	/*
	 * 'SCRIPT_FILENAME'
	 * The absolute pathname of the currently executing script.
	 */
	jx9_vm_config(pVm, JX9_VM_CONFIG_SERVER_ATTR, 
		"SCRIPT_FILENAME", 
		pFile ? pFile->zString : ":Memory:", 
		pFile ? pFile->nByte : sizeof(":Memory:") - 1
		);
	/* All done, all global variables are installed now */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpq $0x9, %rax
jae 0x8a45c
movq -0x10(%rbp), %rdi
callq 0x57ce0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8a40c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a4e6
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x64654(%rip), %rax     # 0xeea70
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rcx
movl $0x6, %esi
movb $0x0, %al
callq 0x7ba50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8a444
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8a4e6
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x57e60
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8a3e3
movq -0x10(%rbp), %rdi
addq $0x3e8, %rdi            # imm = 0x3E8
callq 0x70f20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8a48c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x8a499
leaq 0x3a48e(%rip), %rax     # 0xc4921
movq %rax, -0x38(%rbp)
jmp 0x8a499
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8a4b5
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x48(%rbp)
jmp 0x8a4c0
movl $0x8, %eax
movq %rax, -0x48(%rbp)
jmp 0x8a4c0
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %r8
movl $0x8, %esi
leaq 0x3a439(%rip), %rdx     # 0xc4911
movb $0x0, %al
callq 0x7ba50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9RegisterBuiltInFunction
JX9_PRIVATE void jx9RegisterBuiltInFunction(jx9_vm *pVm)
{
	sxu32 n;
	for( n = 0 ; n < SX_ARRAYSIZE(aBuiltInFunc) ; ++n ){
		jx9_create_function(&(*pVm), aBuiltInFunc[n].zName, aBuiltInFunc[n].xFunc, 0);
	}
	/* Register hashmap functions [i.e: sort(), count(), array_diff(), ...] */
	jx9RegisterHashmapFunctions(&(*pVm));
	/* Register IO functions [i.e: fread(), fwrite(), chdir(), mkdir(), file(), ...] */
	jx9RegisterIORoutine(&(*pVm));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x76, %rax
jae 0x8a5c1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x620c4(%rip), %rax     # 0xec650
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x620ae(%rip), %rax     # 0xec650
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x6d240
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8a573
movq -0x8(%rbp), %rdi
callq 0x90d60
movq -0x8(%rbp), %rdi
callq 0x90dd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8a60d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8a64e
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x58bb0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x70570
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x57180
leaq -0x40(%rbp), %rdi
callq 0x58c00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8a68a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
jne 0x8a69c
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8a6df
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x8a6c8
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8a6df
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x8c050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8a74e
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x8a76e
movq -0x28(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8a7ce
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8a7fa
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x39ff0(%rip), %rdx     # 0xc47ce
callq 0x580b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8a89d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x56c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x8a81e
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x90(%rcx), %eax
jl 0x8a832
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8a89d
movq -0x38(%rbp), %rdi
addq $0x80, %rdi
movl -0x14(%rbp), %esi
callq 0x6ea60
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8a88b
movq -0x40(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x6ea60
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8a87e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x572c0
jmp 0x8a889
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
jmp 0x8a896
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8a914
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x39ed6(%rip), %rdx     # 0xc47ce
callq 0x580b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8a9d4
movq -0x10(%rbp), %rdi
callq 0x58570
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8a94e
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8a9d4
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x90(%rcx), %eax
jae 0x8a9c0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x208, %rdi            # imm = 0x208
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x6ea60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8a9b3
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x57920
jmp 0x8a9b5
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8a964
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x572c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8aa0d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8aa88
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq $0x308, %rdi            # imm = 0x308
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x76c30
cmpq $0x0, %rax
jne 0x8aa6e
movq -0x30(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x76c30
cmpq $0x0, %rax
je 0x8aa75
movl $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8aacd
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8aaff
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x8d380
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8ab58
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8abaa
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movq -0x28(%rbp), %rdx
leaq 0x291e(%rip), %rsi      # 0x8d490
callq 0x8d410
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x308, %rdi            # imm = 0x308
movq -0x28(%rbp), %rdx
leaq 0x28ff(%rip), %rsi      # 0x8d490
callq 0x8d410
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x572c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8ac10
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0x39bf2(%rip), %rdx     # 0xc47e9
callq 0x580b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8ac65
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x8ac52
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x288, %rdi            # imm = 0x288
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x76c30
cmpq $0x0, %rax
je 0x8ac52
movl $0x1, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8acb8
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8aceb
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x288, %rdi            # imm = 0x288
movq -0x28(%rbp), %rdx
leaq 0x282e(%rip), %rsi      # 0x8d500
callq 0x8d410
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x572c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x8d570
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x8ad89
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x56c90
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x56c90
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x8ad72
movl -0x24(%rbp), %eax
addl $0x1, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jbe 0x8ad70
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl -0x28(%rbp)
addl -0x20(%rbp), %edx
movl %edx, -0x1c(%rbp)
jmp 0x8ad87
cmpl $0x0, -0x24(%rbp)
jbe 0x8ad85
movl -0x24(%rbp), %ecx
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
jmp 0x8ad87
jmp 0x8ad89
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x57010
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, -0x424(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x8adf9
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x56c90
movl %eax, -0x424(%rbp)
cmpl $0x1, -0x424(%rbp)
jl 0x8aded
cmpl $0x400, -0x424(%rbp)    # imm = 0x400
jle 0x8adf7
movl $0x10, -0x424(%rbp)
jmp 0x8adf9
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
leaq -0x420(%rbp), %rsi
movl -0x424(%rbp), %edx
callq 0x8d5a0
movq -0x8(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl -0x424(%rbp), %edx
callq 0x57180
xorl %eax, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57010
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8af27
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x8af1a
movq -0x38(%rbp), %rax
movq 0x4f8(%rax), %rax
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rcx
movq 0x500(%rcx), %rdx
callq *%rax
movl %eax, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
addl 0x4f4(%rax), %ecx
movl %ecx, 0x4f4(%rax)
cmpl $-0xa, -0x40(%rbp)
jne 0x8af18
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x8af2e
jmp 0x8af1a
jmp 0x8af1c
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8aead
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x8afcc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x57480
cmpl $0x0, %eax
je 0x8af97
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x24(%rbp), %rsi
callq 0x56e20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x57ef0
jmp 0x8afca
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x57390
cmpl $0x0, %eax
je 0x8afc8
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x56c90
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, 0x560(%rax)
jmp 0x8afca
jmp 0x8afcc
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x39fc6(%rip), %rax     # 0xc4fc0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x8b014
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8d620
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x57180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8b05a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x576d0
cmpl $0x0, %eax
jne 0x8b06e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8b091
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x39793(%rip), %rsi     # 0xc4816
movb $0x0, %al
callq 0x794a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x58bb0
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8b11c
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x65e00
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8d740
cmpl $0x0, -0x28(%rbp)
jbe 0x8b10f
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x57ef0
jmp 0x8b111
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8b0cb
leaq -0x38(%rbp), %rdi
callq 0x58c00
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: vm_builtin_jx9_version
static int vm_builtin_jx9_version(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	SXUNUSED(nArg);
	SXUNUSED(apArg); /* cc warning */
	/* Current engine version, signature and cipyright notice */
	jx9_result_string_format(pCtx,"%s %s, %s",JX9_VERSION,JX9_SIG,JX9_COPYRIGHT);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x396cc(%rip), %rsi     # 0xc4829
leaq 0x396d3(%rip), %rdx     # 0xc4837
leaq 0x396c8(%rip), %rcx     # 0xc4833
leaq 0x396cb(%rip), %r8      # 0xc483d
movb $0x0, %al
callq 0x794a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8b1bd
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57610
cmpl $0x0, %eax
jne 0x8b1d4
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x8b299
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x448(%rbp)
movq -0x448(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jae 0x8b209
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
jmp 0x8b299
leaq -0x440(%rbp), %rdi
movl $0x20, %esi
callq 0x54280
cmpl $0x1, -0x14(%rbp)
jle 0x8b25a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x56c90
movl %eax, -0x424(%rbp)
cmpl $0x2, -0x14(%rbp)
jle 0x8b258
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x440(%rbp), %rsi
addq $0x18, %rsi
callq 0x56e20
movq %rax, -0x430(%rbp)
jmp 0x8b25a
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x440(%rbp)
movq -0x448(%rbp), %rdi
leaq 0x2739(%rip), %rsi      # 0x8d9b0
leaq -0x440(%rbp), %rdx
callq 0x8d8b0
movq -0x10(%rbp), %rdi
movl -0x438(%rbp), %esi
callq 0x56fb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8bb9b
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8bc17
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x56e20
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x8bbc7
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8bc17
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x8bc10
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x8dbf0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x8bbfc
jmp 0x8bc10
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x57180
jmp 0x8bbd6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8befb
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8bf70
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x28(%rbp)
jae 0x8bf2b
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8bf70
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x8e430
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x8bf69
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x38991(%rip), %rdx     # 0xc48e4
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0x79580
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x8bfae
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8c043
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x28(%rbp)
jae 0x8bfde
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8c043
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x8e430
movl %eax, -0x34(%rbp)
cmpl $-0xb, -0x34(%rbp)
jne 0x8c010
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x8c043
cmpl $0x0, -0x34(%rbp)
je 0x8c03c
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x388be(%rip), %rdx     # 0xc48e4
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0x79580
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9JsonDecode
JX9_PRIVATE int jx9JsonDecode(jx9_context *pCtx,const char *zJSON,int nByte)
{
	jx9_vm *pVm = pCtx->pVm;
	json_decoder sDecoder;
	SySet sToken;
	SyLex sLex;
	sxi32 rc;
	/* Tokenize the input */
	SySetInit(&sToken, &pVm->sAllocator, sizeof(SyToken));
	rc = SXRET_OK;
	SyLexInit(&sLex, &sToken, VmJsonTokenize, &rc);
	SyLexTokenizeInput(&sLex,zJSON,(sxu32)nByte, 0, 0, 0);
	if( rc != SXRET_OK ){
		/* Something goes wrong while tokenizing input. [i.e: Unexpected token] */
		SyLexRelease(&sLex);
		SySetRelease(&sToken);
		/* return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Fill the decoder */
	sDecoder.pCtx = pCtx;
	sDecoder.pErr = &rc;
	sDecoder.pIn = (SyToken *)SySetBasePtr(&sToken);
	sDecoder.pEnd = &sDecoder.pIn[SySetUsed(&sToken)];
	sDecoder.iFlags = 0;
	sDecoder.rec_count = 0;
	/* Set a default consumer */
	sDecoder.xConsumer = VmJsonDefaultDecoder;
	sDecoder.pUserData = 0;
	/* Decode the raw JSON input */
	rc = VmJsonDecode(&sDecoder, 0);
	if( rc == SXERR_ABORT ){
		/* 
		 * Something goes wrong while decoding JSON input.Return NULL.
		 */
		jx9_result_null(pCtx);
	}
	/* Clean-up the mess left behind */
	SyLexRelease(&sLex);
	SySetRelease(&sToken);
	/* All done */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x20, %edx
callq 0x5b470
movl $0x0, -0xd4(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq 0x10a(%rip), %rdx       # 0x8c1b0
leaq -0xd4(%rbp), %rcx
callq 0x7eea0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0xd0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
movq %r9, %r8
callq 0x80580
cmpl $0x0, -0xd4(%rbp)
je 0x8c106
leaq -0xd0(%rbp), %rdi
callq 0x80700
leaq -0x90(%rbp), %rdi
callq 0x66980
movq -0x10(%rbp), %rdi
callq 0x57120
movl $0x0, -0x4(%rbp)
jmp 0x8c19b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0xd4(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x80(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x38(%rbp)
leaq 0x995(%rip), %rax       # 0x8cae0
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
leaq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8cb20
movl %eax, -0xd4(%rbp)
cmpl $-0xa, -0xd4(%rbp)
jne 0x8c17c
movq -0x10(%rbp), %rdi
callq 0x57120
leaq -0xd0(%rbp), %rdi
callq 0x80700
leaq -0x90(%rbp), %rdi
callq 0x66980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonDefaultDecoder
static int VmJsonDefaultDecoder(jx9_context *pCtx, jx9_value *pKey, jx9_value *pWorker, void *pUserData)
{
	/* Return the value directly */
	jx9_result_value(pCtx, pWorker); /* Will make it's own copy */
	SXUNUSED(pKey); /* cc warning */
	SXUNUSED(pUserData);
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x572c0
movq $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonArrayDecoder
static int VmJsonArrayDecoder(jx9_context *pCtx, jx9_value *pKey, jx9_value *pWorker, void *pUserData)
{
	jx9_value *pArray = (jx9_value *)pUserData;
	/* Insert the entry */
	jx9_array_add_elem(pArray, pKey, pWorker); /* Will make it's own copy */
	SXUNUSED(pCtx); /* cc warning */
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x57920
movq $0x0, -0x8(%rbp)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)