LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x45ede
movq (%rdx), %rdi
leaq -0x3c(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movq %rax, -0x38(%rbp)
movslq (%r14), %r14
testq %r14, %r14
jle 0x45ede
movq %rax, %rdi
addq %rax, %r14
leaq -0x38(%rbp), %r15
leaq -0x2c(%rbp), %r12
pushq $0x1
popq %r13
cmpq %r14, %rdi
jae 0x45ee6
movq %r14, %rsi
movq %r15, %rdx
callq 0x46e25
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x45ee6
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x29903
movq -0x38(%rbp), %rdi
jmp 0x45eb3
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x4612b
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x4612b
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4725e
testl %eax, %eax
je 0x46133
leaq 0x202d5(%rip), %rdx     # 0x663e3
pushq $0x2
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
jmp 0x46133
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x46189
movq (%rdx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movq %rax, -0x8(%r14)
cmpl $0x0, (%r14)
je 0x46189
leaq -0x20(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x4725e
testl %eax, %eax
je 0x461b5
cmpl $-0xb, %eax
jne 0x46193
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x461b0
movq %rbx, %rdi
callq 0x298e8
jmp 0x461b5
leaq 0x20249(%rip), %rdx     # 0x663e3
pushq $0x2
popq %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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), %r14
movl 0x8(%rdi), %r12d
addq %r14, %r12
leaq 0x20cfc(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29588
leaq -0x2c(%rbp), %r13
leaq 0x1(%r14), %r15
xorl %edx, %edx
leaq -0x1(%r15), %rax
cmpq %r12, %rax
jae 0x4697f
cmpb $0x5c, (%rax)
je 0x4697f
incq %r15
incl %edx
jmp 0x4696a
cmpq %r14, %rax
jbe 0x4698f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29588
cmpq %r12, %r15
jae 0x469d8
movsbl (%r15), %eax
movl %eax, -0x2c(%rbp)
addl $-0x66, %eax
rorb %al
movq %r13, %rsi
cmpb $0x7, %al
ja 0x469c5
movzbl %al, %eax
movl $0xd1, %ecx
btl %eax, %ecx
movq %r13, %rsi
jae 0x469c5
leaq 0x1cbba(%rip), %rcx     # 0x63578
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x29588
incq %r15
movq %r15, %r14
jmp 0x46964
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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:
xorl %eax, %eax
testb $0x1, 0x8(%rsi)
je 0x46a5c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1c(%rbp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x297ed
movq %rax, %r14
leaq 0x308(%rbx), %rdi
movl (%r15), %edx
movq %rax, %rsi
callq 0x3ae09
testq %rax, %rax
jne 0x46a4f
addq $0x2c8, %rbx            # imm = 0x2C8
movl -0x1c(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ae09
testq %rax, %rax
je 0x46a5d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x46a52
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyHashForEach
JX9_PRIVATE sxi32 SyHashForEach(SyHash *pHash, sxi32 (*xStep)(SyHashEntry *, void *), void *pUserData)
{
	SyHashEntry_Pr *pEntry;
	sxi32 rc;
	sxu32 n;
#if defined(UNTRUST)
	if( INVALID_HASH(pHash) || xStep == 0){
		return 0;
	}
#endif
	pEntry = pHash->pList;
	for( n = 0 ; n < pHash->nEntry ; n++ ){
		/* Invoke the callback */
		rc = xStep((SyHashEntry *)pEntry, pUserData);
		if( rc != SXRET_OK ){
			return rc;
		}
		/* Point to the next entry */
		pEntry = pEntry->pNext;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %r12
xorl %r13d, %r13d
cmpl 0x28(%r15), %r13d
jae 0x46a9f
movq (%r12), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *%r14
testl %eax, %eax
jne 0x46a9f
addq $0x28, %r12
incl %r13d
jmp 0x46a7f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
leaq -0x58(%rbp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x3bbfe
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %r15, %rdi
callq 0x3689a
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x29c4b
movl %eax, %ebx
movq %r15, %rdi
callq 0x296af
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmRandomString
JX9_PRIVATE void jx9VmRandomString(jx9_vm *pVm, char *zBuf, int nLen)
{
	static const char zBase[] = {"abcdefghijklmnopqrstuvwxyz"}; /* English Alphabet */
	int i;
	/* Generate a binary string first */
	SyRandomness(&pVm->sPrng, zBuf, (sxu32)nLen);
	/* Turn the binary string into english based alphabet */
	for( i = 0 ; i < nLen ; ++i ){
		 zBuf[i] = zBase[zBuf[i] % (sizeof(zBase)-1)];
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
addq $0x100, %rdi            # imm = 0x100
callq 0x321c8
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
pushq $0x1a
popq %rsi
leaq 0x21254(%rip), %rdi     # 0x67e00
cmpq %rcx, %rbx
je 0x46bc7
movsbq (%r14,%rcx), %rax
xorl %edx, %edx
divq %rsi
movb (%rdx,%rdi), %al
movb %al, (%r14,%rcx)
incq %rcx
jmp 0x46bac
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x46bfe
testb $0x2, %al
jne 0x46c06
testb $0x4, %al
jne 0x46c0e
testb $0x1, %al
jne 0x46c16
testb $0x8, %al
jne 0x46c1e
testb $0x40, %al
jne 0x46c26
btl $0x8, %eax
leaq 0x20a60(%rip), %rcx     # 0x67652
leaq 0x1fef6(%rip), %rax     # 0x66aef
cmovaeq %rcx, %rax
retq
leaq 0x1feba(%rip), %rax     # 0x66abf
retq
leaq 0x1fe8e(%rip), %rax     # 0x66a9b
retq
leaq 0x1fe6b(%rip), %rax     # 0x66a80
retq
leaq 0x20164(%rip), %rax     # 0x66d81
retq
leaq 0x1fe53(%rip), %rax     # 0x66a78
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testb $0x1, 0x40(%rax)
leaq 0x1f6d2(%rip), %rcx     # 0x6630a
leaq 0x1f6bf(%rip), %rax     # 0x662fe
cmoveq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq (%rdi), %rdi
leaq -0xb8(%rbp), %r12
movq %r12, %rsi
callq 0x35772
movq (%r15), %rdi
leaq -0x78(%rbp), %r13
movq %r13, %rsi
callq 0x35772
movl 0x2c(%r15), %r14d
addq $0x10, %r15
subl $0x1, %r14d
jb 0x46cd7
movq (%r15), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x35e0a
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3b0ba
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
callq *-0x30(%rbp)
movl %eax, %ebx
movq %r12, %rdi
callq 0x296af
movq %r13, %rdi
callq 0x296af
testl %ebx, %ebx
jne 0x46cdb
addq $0x48, %r15
jmp 0x46c8d
xorl %eax, %eax
jmp 0x46cde
pushq $-0xa
popq %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x46ea3
pushq %rbp
movq %rsp, %rbp
addl $0xffffff40, %eax       # imm = 0xFFFFFF40
leaq 0x1bffe(%rip), %rcx     # 0x62e40
movzbl (%rax,%rcx), %ecx
cmpq %rsi, %rdi
je 0x46e6b
movzbl (%rdi), %eax
movl %eax, %r8d
andl $-0x40, %r8d
cmpl $0x80, %r8d
jne 0x46e6e
shll $0x6, %ecx
incq %rdi
andl $0x3f, %eax
orl %eax, %ecx
jmp 0x46e46
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
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmProcessLongOpt
static int VmProcessLongOpt(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	struct getopt_long_opt *pOpt = (struct getopt_long_opt *)pUserData;
	const char *zArg, *zOpt, *zEnd;
	int need_value = 0;
	int nByte;
	/* Value must be of type string */
	if( !jx9_value_is_string(pValue) ){
		/* Simply ignore */
		return JX9_OK;
	}
	zOpt = jx9_value_to_string(pValue, &nByte);
	if( nByte < 1 ){
		/* Empty string, ignore */
		return JX9_OK;
	}
	zEnd = &zOpt[nByte - 1];
	if( zEnd[0] == ':' ){
		char *zTerm;
		/* Try to extract a value */
		need_value = 1;
		while( zEnd >= zOpt && zEnd[0] == ':' ){
			zEnd--;
		}
		if( zOpt >= zEnd ){
			/* Empty string, ignore */
			SXUNUSED(pKey);
			return JX9_OK;
		}
		zEnd++;
		zTerm = (char *)zEnd;
		zTerm[0] = 0;
	}else{
		zEnd = &zOpt[nByte];
	}
	/* Find the option */
	zArg = VmFindLongOpt(zOpt, (int)(zEnd-zOpt), pOpt->zArgIn, pOpt->zArgEnd);
	if( zArg == 0 ){
		/* No such option, return immediately */
		return JX9_OK;
	}
	/* Try to extract a value */
	VmExtractOptArgValue(pOpt->pArray, pOpt->pWorker, zArg, pOpt->zArgEnd, need_value, pOpt->pCtx, zOpt);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
testb $0x1, 0x8(%rsi)
je 0x4724d
leaq -0x3c(%rbp), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x297ed
movq %rax, %r14
movslq (%rbx), %rax
testq %rax, %rax
jle 0x4724d
leaq (%r14,%rax), %r15
cmpb $0x3a, -0x1(%r14,%rax)
jne 0x47183
leaq -0x1(%r15), %rax
cmpq %r14, %rax
jb 0x4718c
cmpb $0x3a, (%rax)
jne 0x4718c
movq %rax, %r15
jmp 0x47170
movl $0x0, -0x2c(%rbp)
jmp 0x471a3
leaq -0x1(%r15), %rax
cmpq %rax, %r14
jae 0x4724d
movb $0x0, (%r15)
pushq $0x1
popq %rax
movl %eax, -0x2c(%rbp)
subl %r14d, %r15d
movq -0x38(%rbp), %rax
movq (%rax), %r13
movq 0x8(%rax), %r12
cmpq %r12, %r13
jae 0x4724d
cmpb $0x2d, (%r13)
jne 0x47201
leaq 0x1(%r13), %rax
cmpq %r12, %rax
jae 0x47201
cmpb $0x2d, (%rax)
jne 0x47201
movq %r13, %rbx
addq $0x2, %rbx
movq %rbx, %r13
cmpq %r12, %r13
jae 0x47206
callq 0xc190
movsbq (%r13), %rcx
cmpq $0x3d, %rcx
je 0x47209
movq (%rax), %rax
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
jne 0x47209
incq %r13
jmp 0x471d9
incq %r13
jmp 0x471b1
movq %r12, %r13
movl %r13d, %eax
subl %ebx, %eax
cmpl %r15d, %eax
jne 0x471b1
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2d30e
testl %eax, %eax
jne 0x471b1
testq %r13, %r13
je 0x4724d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdi
movq 0x20(%rax), %r9
movq %r14, (%rsp)
movq %r13, %rdx
movq %r12, %rcx
movl -0x2c(%rbp), %r8d
callq 0x46ea7
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmExecIncludedFile
static sxi32 VmExecIncludedFile(
	 jx9_context *pCtx, /* Call Context */
	 SyString *pPath,   /* Script path or URL*/
	 int IncludeOnce    /* TRUE if called from import() or require_once() */
	 )
{
	sxi32 rc;
#ifndef JX9_DISABLE_BUILTIN_FUNC
	const jx9_io_stream *pStream;
	SyBlob sContents;
	void *pHandle;
	jx9_vm *pVm;
	int isNew;
	/* Initialize fields */
	pVm = pCtx->pVm;
	SyBlobInit(&sContents, &pVm->sAllocator);
	isNew = 0;
	/* Extract the associated stream */
	pStream = jx9VmGetStreamDevice(pVm, &pPath->zString, pPath->nByte);
	/*
	 * Open the file or the URL [i.e: http://jx9.symisc.net/example/hello.jx9.txt"] 
	 * in a read-only mode.
	 */
	pHandle = jx9StreamOpenHandle(pVm, pStream,pPath->zString, JX9_IO_OPEN_RDONLY, TRUE, 0, TRUE, &isNew);
	if( pHandle == 0 ){
		return SXERR_IO;
	}
	rc = SXRET_OK; /* Stupid cc warning */
	if( IncludeOnce && !isNew ){
		/* Already included */
		rc = SXERR_EXISTS;
	}else{
		/* Read the whole file contents */
		rc = jx9StreamReadWholeFile(pHandle, pStream, &sContents);
		if( rc == SXRET_OK ){
			SyString sScript;
			/* Compile and execute the script */
			SyStringInitFromBuf(&sScript, SyBlobData(&sContents), SyBlobLength(&sContents));
			VmEvalChunk(pCtx->pVm, &(*pCtx), &sScript, 0, TRUE);
		}
	}
	/* Pop from the set of included file */
	(void)SySetPop(&pVm->aFiles);
	/* Close the handle */
	jx9StreamCloseHandle(pStream, pHandle);
	/* Release the working buffer */
	SyBlobRelease(&sContents);
#else
	pCtx = 0; /* cc warning */
	pPath = 0;
	IncludeOnce = 0;
	rc = SXERR_IO;
#endif /* JX9_DISABLE_BUILTIN_FUNC */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movq 0x60(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x50(%rbp)
movq %rbx, -0x58(%rbp)
andl $0x0, -0x40(%rbp)
leaq -0x2c(%rbp), %r15
andl $0x0, (%r15)
movl 0x8(%rsi), %edx
movq %rbx, %rdi
callq 0x47354
movq %rax, %r14
movq (%r12), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl %ecx, %r8d
xorl %r9d, %r9d
pushq %r15
pushq $0x1
callq 0x474a5
addq $0x10, %rsp
testq %rax, %rax
je 0x472d9
movq %rax, %r12
testl %r13d, %r13d
je 0x472df
cmpl $0x0, -0x2c(%rbp)
jne 0x472df
pushq $-0xb
jmp 0x472f4
pushq $-0x2
popq %r15
jmp 0x4731c
leaq -0x58(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x4769f
testl %eax, %eax
je 0x4732e
pushq $-0x1
popq %r15
addq $0x3e8, %rbx            # imm = 0x3E8
movq %rbx, %rdi
callq 0x374f7
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x47313
movq %r12, %rdi
callq *%rax
leaq -0x58(%rbp), %rdi
callq 0x2a72f
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x50(%rbp), %rax
leaq -0x68(%rbp), %rdx
movq %rax, (%rdx)
movl -0x48(%rbp), %eax
movl %eax, 0x8(%rdx)
movq -0x38(%rbp), %rsi
movq 0x60(%rsi), %rdi
pushq $0x1
popq %rcx
callq 0x3ec7d
xorl %r15d, %r15d
jmp 0x472f6
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9StreamReadWholeFile
JX9_PRIVATE sxi32 jx9StreamReadWholeFile(void *pHandle, const jx9_io_stream *pStream, SyBlob *pOut)
{
	jx9_int64 nRead;
	char zBuf[8192]; /* 8K */
	int rc;
	/* Perform the requested operation */
	for(;;){
		nRead = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
		if( nRead < 1 ){
			/* EOF or IO error */
			break;
		}
		/* Append contents */
		rc = SyBlobAppend(pOut, zBuf, (sxu32)nRead);
		if( rc != SXRET_OK ){
			break;
		}
	}
	return SyBlobLength(pOut) > 0 ? SXRET_OK : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x2020(%rbp), %r12
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
movq %r12, %rsi
callq *0x30(%r14)
testq %rax, %rax
jle 0x476e6
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x2e250
testl %eax, %eax
je 0x476c1
xorl %eax, %eax
cmpl $0x1, 0x10(%rbx)
sbbl %eax, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_TIME_Const
static void JX9_TIME_Const(jx9_value *pVal, void *pUnused)
{
	Sytm sTm;
#ifdef __WINNT__
	SYSTEMTIME sOS;
	GetSystemTime(&sOS);
	SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
	struct tm *pTm;
	time_t t;
	time(&t);
	pTm = gmtime(&t);
	STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	SXUNUSED(pUnused); /* cc warning */
	/* Expand */
	jx9_value_string_format(pVal, "%02d:%02d:%02d", sTm.tm_hour, sTm.tm_min, sTm.tm_sec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xc850
movq %r14, %rdi
callq 0xc2f0
movl 0x8(%rax), %edx
movl (%rax), %r8d
movl 0x4(%rax), %ecx
leaq 0x1cd8c(%rip), %rsi     # 0x64592
movq %rbx, %rdi
xorl %eax, %eax
callq 0x48095
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_DATE_Const
static void JX9_DATE_Const(jx9_value *pVal, void *pUnused)
{
	Sytm sTm;
#ifdef __WINNT__
	SYSTEMTIME sOS;
	GetSystemTime(&sOS);
	SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
	struct tm *pTm;
	time_t t;
	time(&t);
	pTm = gmtime(&t);
	STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
	SXUNUSED(pUnused); /* cc warning */
	/* Expand */
	jx9_value_string_format(pVal, "%04d-%02d-%02d", sTm.tm_year, sTm.tm_mon+1, sTm.tm_mday);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0xc850
movq %r14, %rdi
callq 0xc2f0
movl 0xc(%rax), %r8d
movl 0x10(%rax), %ecx
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
incl %ecx
leaq 0x1f1b0(%rip), %rsi     # 0x66a03
movq %rbx, %rdi
xorl %eax, %eax
callq 0x48095
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_FILE_Const
static void JX9_FILE_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	SyString *pFile;
	/* Peek the top entry */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile == 0 ){
		/* Expand the magic word: ":MEMORY:" */
		jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
	}else{
		jx9_value_string(pVal, pFile->zString, pFile->nByte);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3f8(%rsi), %eax
testl %eax, %eax
je 0x47893
movq 0x3f0(%rsi), %rcx
testq %rcx, %rcx
je 0x47893
decl %eax
imull 0x400(%rsi), %eax
movq (%rcx,%rax), %rsi
movl 0x8(%rcx,%rax), %edx
jmp 0x4789f
leaq 0x1f178(%rip), %rsi     # 0x66a12
movl $0x8, %edx
popq %rbp
jmp 0x29588
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_DIR_Const
static void JX9_DIR_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	SyString *pFile;
	/* Peek the top entry */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile == 0 ){
		/* Expand the magic word: ":MEMORY:" */
		jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
	}else{
		if( pFile->nByte > 0 ){
			const char *zDir;
			int nLen;
			zDir = jx9ExtractDirName(pFile->zString, (int)pFile->nByte, &nLen);
			jx9_value_string(pVal, zDir, nLen);
		}else{
			/* Expand '.' as the current directory*/
			jx9_value_string(pVal, ".", (int)sizeof(char));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x3f8(%rsi), %eax
testl %eax, %eax
je 0x478f5
movq 0x3f0(%rsi), %rcx
testq %rcx, %rcx
je 0x478f5
decl %eax
imull 0x400(%rsi), %eax
movl 0x8(%rcx,%rax), %esi
testl %esi, %esi
je 0x4790f
movq (%rcx,%rax), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rdx
callq 0x4814e
movl (%r14), %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x47902
leaq 0x1f116(%rip), %rsi     # 0x66a12
pushq $0x8
popq %rdx
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x29588
leaq 0x1dd82(%rip), %rsi     # 0x65698
pushq $0x1
jmp 0x478fe
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDIN_Const
static void JX9_STDIN_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdin(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rsi), %r15
testq %r15, %r15
jne 0x47ee9
movq %rsi, %r14
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2ca19
testq %rax, %rax
je 0x47ee6
movq %rax, %r15
leaq 0x3d534(%rip), %rax     # 0x853e0
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %r14, 0x10(%r15)
andl $0x0, 0x28(%r15)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r15)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x481b2
movq %rax, 0x8(%r15)
movq %r15, 0x4d0(%r14)
jmp 0x47ee9
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29732
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDOUT_Const
static void JX9_STDOUT_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStdout(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d8(%rsi), %r15
testq %r15, %r15
jne 0x47f71
movq %rsi, %r14
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2ca19
testq %rax, %rax
je 0x47f6e
movq %rax, %r15
leaq 0x3d4ac(%rip), %rax     # 0x853e0
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %r14, 0x10(%r15)
andl $0x0, 0x28(%r15)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x481b2
movq %rax, 0x8(%r15)
movq %r15, 0x4d8(%r14)
jmp 0x47f71
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29732
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9_STDERR_Const
static void JX9_STDERR_Const(jx9_value *pVal, void *pUserData)
{
	jx9_vm *pVm = (jx9_vm *)pUserData;
	void *pResource;
	pResource = jx9ExportStderr(pVm);
	jx9_value_resource(pVal, pResource);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4e0(%rsi), %r15
testq %r15, %r15
jne 0x47ff9
movq %rsi, %r14
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2ca19
testq %rax, %rax
je 0x47ff6
movq %rax, %r15
leaq 0x3d424(%rip), %rax     # 0x853e0
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %r14, 0x10(%r15)
andl $0x0, 0x28(%r15)
movabsq $0xfeac1400000000, %rax # imm = 0xFEAC1400000000
movq %rax, 0x30(%r15)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x481b2
movq %rax, 0x8(%r15)
movq %r15, 0x4e0(%r14)
jmp 0x47ff9
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29732
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_value_string_format
JX9_PRIVATE int jx9_value_string_format(jx9_value *pVal, const char *zFormat, ...)
{
	va_list ap;
	int rc;
	if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
		/* Invalidate any prior representation */
		jx9MemObjRelease(pVal);
		MemObjSetType(pVal, MEMOBJ_STRING);
	}
	va_start(ap, zFormat);
	rc = SyBlobFormatAp(&pVal->sBlob, zFormat, ap);
	va_end(ap);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x480f2
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
testb $0x1, 0x8(%rdi)
jne 0x4810f
movq %r14, %rdi
callq 0x296af
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%r14), %eax
incl %eax
movl %eax, 0x8(%r14)
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x296e2
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9StreamDataInit
static jx9_stream_data * JX9StreamDataInit(jx9_vm *pVm, int iType)
{
	jx9_stream_data *pData;
	if( pVm == 0 ){
		return 0;
	}
	/* Allocate a new instance */
	pData = (jx9_stream_data *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(jx9_stream_data));
	if( pData == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pData, sizeof(jx9_stream_data));
	/* Initialize fields */
	pData->iType = iType;
	if( iType == JX9_IO_STREAM_OUTPUT ){
		/* Point to the default VM consumer routine. */
		pData->x.sConsumer = pVm->sVmConsumer; 
	}else{
#ifdef __WINNT__
		DWORD nChannel;
		switch(iType){
		case JX9_IO_STREAM_STDOUT:	nChannel = STD_OUTPUT_HANDLE; break;
		case JX9_IO_STREAM_STDERR:  nChannel = STD_ERROR_HANDLE; break;
		default:
			nChannel = STD_INPUT_HANDLE; 
			break;
		}
		pData->x.pHandle = GetStdHandle(nChannel);
#else
		/* Assume an UNIX system */
		int ifd = STDIN_FILENO;
		switch(iType){
		case JX9_IO_STREAM_STDOUT:  ifd = STDOUT_FILENO; break;
		case JX9_IO_STREAM_STDERR:  ifd = STDERR_FILENO; break;
		default:
			break;
		}
		pData->x.pHandle = SX_INT_TO_PTR(ifd);
#endif
	}
	pData->pVm = pVm;
	return pData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x48212
movl %esi, %r15d
movq %rdi, %r14
pushq $0x30
popq %rsi
callq 0x2ca19
testq %rax, %rax
je 0x48212
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x27aea
movl %r15d, 0x8(%rbx)
cmpl $0x2, %r15d
je 0x4821a
cmpl $0x3, %r15d
je 0x48216
cmpl $0x4, %r15d
jne 0x4821f
movups 0x4f8(%r14), %xmm0
movups 0x508(%r14), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0x48225
xorl %ebx, %ebx
jmp 0x48228
pushq $0x2
jmp 0x4821c
pushq $0x1
popq %rax
jmp 0x48221
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: JX9StreamData_Open
static int JX9StreamData_Open(const char *zName, int iMode, jx9_value *pResource, void ** ppHandle)
{
	jx9_stream_data *pData;
	SyString sStream;
	SyStringInitFromBuf(&sStream, zName, SyStrlen(zName));
	/* Trim leading and trailing white spaces */
	SyStringFullTrim(&sStream);
	/* Stream to open */
	if( SyStrnicmp(sStream.zString, "stdin", sizeof("stdin")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDIN;
	}else if( SyStrnicmp(sStream.zString, "output", sizeof("output")-1) == 0 ){
		iMode = JX9_IO_STREAM_OUTPUT;
	}else if( SyStrnicmp(sStream.zString, "stdout", sizeof("stdout")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDOUT;
	}else if( SyStrnicmp(sStream.zString, "stderr", sizeof("stderr")-1) == 0 ){
		iMode = JX9_IO_STREAM_STDERR;
	}else{
		/* unknown stream name */
		return -1;
	}
	/* Create our handle */
	pData = JX9StreamDataInit(pResource?pResource->pVm:0, iMode);
	if( pData == 0 ){
		return -1;
	}
	/* Make the handle public */
	*ppHandle = (void *)pData;
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r14
movq %rdi, %r15
callq 0x28e24
movl %eax, %r13d
movl %eax, %r12d
addq %r15, %r12
subl $0x1, %r13d
jb 0x48283
movsbq (%r15), %rbx
cmpq $-0x41, %rbx
ja 0x48280
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x48280
incq %r15
jmp 0x4825c
movq %r15, %r12
leaq 0x1e6c1(%rip), %rsi     # 0x6694b
pushq $0x5
popq %rdx
movq %r12, %rdi
callq 0x32436
pushq $-0x1
popq %r15
testl %eax, %eax
je 0x482e3
leaq 0x1e7ca(%rip), %rsi     # 0x66a6e
pushq $0x6
popq %rdx
movq %r12, %rdi
callq 0x32436
testl %eax, %eax
je 0x482e7
leaq 0x1e69e(%rip), %rsi     # 0x66958
pushq $0x6
popq %rdx
movq %r12, %rdi
callq 0x32436
testl %eax, %eax
je 0x482eb
leaq 0x1e696(%rip), %rsi     # 0x66966
pushq $0x6
popq %rdx
movq %r12, %rdi
callq 0x32436
testl %eax, %eax
jne 0x4830f
pushq $0x3
jmp 0x482ed
pushq $0x1
jmp 0x482ed
pushq $0x4
jmp 0x482ed
pushq $0x2
popq %rsi
testq %r14, %r14
je 0x482f9
movq 0x10(%r14), %rdi
jmp 0x482fb
xorl %edi, %edi
callq 0x481b2
testq %rax, %rax
je 0x4830f
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_bool
static int jx9Builtin_is_bool(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_bool(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x483cb
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl $0x3, %esi
andl $0x1, %esi
jmp 0x483cd
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_float
static int jx9Builtin_is_float(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_float(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x483ec
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl $0x2, %esi
andl $0x1, %esi
jmp 0x483ee
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_int
static int jx9Builtin_is_int(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_int(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x4840c
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl %esi
andl $0x1, %esi
jmp 0x4840e
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_string
static int jx9Builtin_is_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_string(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x4842a
movq (%rdx), %rax
movl 0x8(%rax), %esi
andl $0x1, %esi
jmp 0x4842c
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_null
static int jx9Builtin_is_null(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_null(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x4844b
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl $0x5, %esi
andl $0x1, %esi
jmp 0x4844d
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_numeric
static int jx9Builtin_is_numeric(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_numeric(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x48473
movq (%rdx), %rdi
callq 0x29a60
movl %eax, %esi
jmp 0x48475
xorl %esi, %esi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_scalar
static int jx9Builtin_is_scalar(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_scalar(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x48499
movq (%rdx), %rax
xorl %esi, %esi
testb $0x2f, 0x8(%rax)
setne %sil
jmp 0x4849b
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_array
static int jx9Builtin_is_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_json_array(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x484ba
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl $0x6, %esi
andl $0x1, %esi
jmp 0x484bc
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_object
static int jx9Builtin_is_object(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_json_object(apArg[0]);
	}
	/* Query result */
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
movl %esi, %eax
xorl %esi, %esi
testl %eax, %eax
jle 0x484e3
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x484e3
movq (%rax), %rax
movl 0x40(%rax), %esi
andl $0x1, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_is_resource
static int jx9Builtin_is_resource(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 0; /* Assume false by default */
	if( nArg > 0 ){
		res = jx9_value_is_resource(apArg[0]);
	}
	jx9_result_bool(pCtx, res);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x48502
movq (%rdx), %rax
movl 0x8(%rax), %esi
shrl $0x8, %esi
andl $0x1, %esi
jmp 0x48504
xorl %esi, %esi
pushq %rbp
movq %rsp, %rbp
callq 0x298b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_intval
static int jx9Builtin_intval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* return 0 */
		jx9_result_int(pCtx, 0);
	}else{
		sxi64 iVal;
		/* Perform the cast */
		iVal = jx9_value_to_int64(apArg[0]);
		jx9_result_int64(pCtx, iVal);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4855e
movq (%rdx), %rdi
callq 0x297ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29897
jmp 0x48568
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_strval
static int jx9Builtin_strval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* return NULL */
		jx9_result_null(pCtx);
	}else{
		const char *zVal;
		int iLen = 0; /* cc -O6 warning */
		/* Perform the cast */
		zVal = jx9_value_to_string(apArg[0], &iLen);
		jx9_result_string(pCtx, zVal, iLen);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x485a6
leaq -0x14(%rbp), %r14
andl $0x0, (%r14)
movq (%rdx), %rdi
movq %r14, %rsi
callq 0x297ed
movl (%r14), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29903
jmp 0x485ae
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_empty
static int jx9Builtin_empty(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int res = 1; /* Assume empty by default */
	if( nArg > 0 ){
		res = jx9_value_is_empty(apArg[0]);
	}
	jx9_result_bool(pCtx, res);
	return JX9_OK;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x485d2
movq (%rdx), %rdi
callq 0x29afd
movl %eax, %esi
jmp 0x485d5
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_round
static int jx9Builtin_round(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int n = 0;
	double r;
	if( nArg < 1 ){
		/* Missing argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Extract the precision if available */
	if( nArg > 1 ){
		n = jx9_value_to_int(apArg[1]);
		if( n>30 ){
			n = 30;
		}
		if( n<0 ){
			n = 0;
		}
	}
	r = jx9_value_to_double(apArg[0]);
	/* If Y==0 and X will fit in a 64-bit int, 
     * handle the rounding directly.Otherwise 
	 * use our own cutsom printf [i.e:SyBufferFormat()].
     */
  if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
    r = (double)((jx9_int64)(r+0.5));
  }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
    r = -(double)((jx9_int64)((-r)+0.5));
  }else{
	  char zBuf[256];
	  sxu32 nLen;
	  nLen = SyBufferFormat(zBuf, sizeof(zBuf), "%.*f", n, r);
	  /* Convert the string to real number */
	  SyStrToReal(zBuf, nLen, (void *)&r, 0);
  }
  /* Return thr rounded value */
  jx9_result_double(pCtx, r);
  return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
testl %esi, %esi
jle 0x48669
movq %rdx, %r15
xorl %r14d, %r14d
cmpl $0x1, %esi
je 0x48623
movq 0x8(%r15), %rdi
callq 0x29772
cmpl $0x1e, %eax
pushq $0x1e
popq %rcx
cmovll %eax, %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovgl %ecx, %r14d
movq (%r15), %rdi
callq 0x297cd
movsd %xmm0, -0x20(%rbp)
testl %r14d, %r14d
jne 0x48675
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x48675
movsd 0x1af81(%rip), %xmm1    # 0x635c8
ucomisd %xmm0, %xmm1
jbe 0x48675
addsd 0x1af43(%rip), %xmm0    # 0x63598
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x486e9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
jmp 0x486f1
testl %r14d, %r14d
jne 0x486b3
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x486b3
ucomisd 0x1af4c(%rip), %xmm0    # 0x635d8
jbe 0x486b3
movsd 0x1af02(%rip), %xmm1    # 0x63598
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
cvtsi2sd %rax, %xmm0
xorpd 0x1af44(%rip), %xmm0    # 0x635f0
movlpd %xmm0, -0x20(%rbp)
jmp 0x486e9
leaq 0x1e7f3(%rip), %rdx     # 0x66ead
leaq -0x120(%rbp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movl %r14d, %ecx
movb $0x1, %al
callq 0x2d4b8
leaq -0x20(%rbp), %r14
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x36406
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x298cd
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_dechex
static int jx9Builtin_dechex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%x", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4872b
movq (%rdx), %rdi
callq 0x29772
leaq 0x1e795(%rip), %rsi     # 0x66eb2
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3bdad
jmp 0x48733
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_decoct
static int jx9Builtin_decoct(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%o", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x48766
movq (%rdx), %rdi
callq 0x29772
leaq 0x1e75d(%rip), %rsi     # 0x66eb5
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3bdad
jmp 0x4876e
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Builtin_decbin
static int jx9Builtin_decbin(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iVal;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the given number */
	iVal = jx9_value_to_int(apArg[0]);
	/* Format */
	jx9_result_string_format(pCtx, "%B", iVal);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x487a1
movq (%rdx), %rdi
callq 0x29772
leaq 0x1e725(%rip), %rsi     # 0x66eb8
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3bdad
jmp 0x487a9
movq %rbx, %rdi
callq 0x298e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq