LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCollectionCacheRemoveRecord
UNQLITE_PRIVATE int unqliteCollectionCacheRemoveRecord(
	unqlite_col *pCol, /* Target collection */
	jx9_int64 nId      /* Unique record ID */
	)
{
	unqlite_col_record *pRecord;
	/* Fetch the record first */
	pRecord = CollectionCacheFetchRecord(pCol,nId);
	if( pRecord == 0 ){
		/* No such record */
		return UNQLITE_NOTFOUND;
	}
	if( pRecord->pPrevCol ){
		pRecord->pPrevCol->pNextCol = pRecord->pNextCol;
	}else{
		sxu32 iBucket = COL_RECORD_HASH(nId) & (pCol->nRecSize - 1);
		pCol->apRecord[iBucket] = pRecord->pNextCol;
	}
	if( pRecord->pNextCol ){
		pRecord->pNextCol->pPrevCol = pRecord->pPrevCol;
	}
	/* Unlink */
	MACRO_LD_REMOVE(pCol->pList,pRecord);
	pCol->nRec--;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x37fa6
testq %rax, %rax
je 0x3832a
movq 0x58(%rax), %rdx
testq %rdx, %rdx
je 0x382cc
movq 0x50(%rax), %rcx
movq %rcx, 0x50(%rdx)
jmp 0x382e6
movl 0xdc(%rbx), %ecx
decl %ecx
andl %ecx, %r14d
movq 0x50(%rax), %rcx
movq 0xc8(%rbx), %rdx
movq %rcx, (%rdx,%r14,8)
testq %rcx, %rcx
je 0x382f3
movq 0x58(%rax), %rdx
movq %rdx, 0x58(%rcx)
movq 0xd0(%rbx), %rcx
cmpq %rax, %rcx
jne 0x3830a
movq 0x60(%rcx), %rcx
movq %rcx, 0xd0(%rbx)
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x3831b
movq %rcx, 0x60(%rax)
testq %rcx, %rcx
je 0x38324
movq %rax, 0x68(%rcx)
decl 0xd8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmNewOperandStack
static jx9_value * VmNewOperandStack(
	jx9_vm *pVm, /* Target VM */
	sxu32 nInstr /* Total numer of generated bytecode instructions */
	)
{
	jx9_value *pStack;
  /* No instruction ever pushes more than a single element onto the
  ** stack and the stack never grows on successive executions of the
  ** same loop. So the total number of instructions is an upper bound
  ** on the maximum stack depth required.
  **
  ** Allocation all the stack space we will ever need.
  */
	nInstr += VM_STACK_GUARD;
	pStack = (jx9_value *)SyMemBackendAlloc(&pVm->sAllocator, nInstr * sizeof(jx9_value));
	if( pStack == 0 ){
		return 0;
	}
	/* Initialize the operand stack */
	while( nInstr > 0 ){
		jx9MemObjInit(&(*pVm), &pStack[nInstr - 1]);
		--nInstr;
	}
	/* Ready for bytecode execution */
	return pStack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
addl $0x10, %r15d
movl %r15d, %esi
shll $0x6, %esi
callq 0x2ca19
movq %rax, %r14
testq %rax, %rax
je 0x3837c
movl %r15d, %r15d
movq %r14, %r12
addq $-0x40, %r12
shlq $0x6, %r15
testq %r15, %r15
je 0x3837c
leaq (%r12,%r15), %rsi
movq %rbx, %rdi
callq 0x35772
addq $-0x40, %r15
jmp 0x38365
movq %r14, %rax
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: jx9VmThrowError
JX9_PRIVATE sxi32 jx9VmThrowError(
	jx9_vm *pVm,         /* Target VM */
	SyString *pFuncName, /* Function name. NULL otherwise */
	sxi32 iErr,          /* Severity level: [i.e: Error, Warning or Notice]*/
	const char *zMessage /* Null terminated error message */
	)
{
	SyBlob *pWorker = &pVm->sWorker;
	SyString *pFile;
	char *zErr;
	sxi32 rc;
	if( !pVm->bErrReport ){
		/* Don't bother reporting errors */
		return SXRET_OK;
	}
	/* Reset the working buffer */
	SyBlobReset(pWorker);
	/* Peek the processed file if available */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile ){
		/* Append file name */
		SyBlobAppend(pWorker, pFile->zString, pFile->nByte);
		SyBlobAppend(pWorker, (const void *)" ", sizeof(char));
	}
	zErr = "Error: ";
	switch(iErr){
	case JX9_CTX_WARNING: zErr = "Warning: "; break;
	case JX9_CTX_NOTICE:  zErr = "Notice: ";  break;
	default:
		iErr = JX9_CTX_ERR;
		break;
	}
	SyBlobAppend(pWorker, zErr, SyStrlen(zErr));
	if( pFuncName ){
		/* Append function name first */
		SyBlobAppend(pWorker, pFuncName->zString, pFuncName->nByte);
		SyBlobAppend(pWorker, "(): ", sizeof("(): ")-1);
	}
	SyBlobAppend(pWorker, zMessage, SyStrlen(zMessage));
	/* Consume the error message */
	rc = VmCallErrorHandler(&(*pVm), pWorker);
	return rc;
}

// Assembly:
cmpl $0x0, 0x4e8(%rdi)
je 0x3848f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3a8(%rdi), %r15
movq %r15, %rdi
callq 0x31b1e
movl 0x3f8(%rbx), %eax
testl %eax, %eax
je 0x383ff
movq 0x3f0(%rbx), %rcx
testq %rcx, %rcx
je 0x383ff
decl %eax
imull 0x400(%rbx), %eax
movq (%rcx,%rax), %rsi
movl 0x8(%rcx,%rax), %edx
movq %r15, %rdi
callq 0x2e250
leaq 0x2f70d(%rip), %rsi     # 0x67b01
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x2e250
cmpl $0x3, %r13d
leaq 0x2bd3d(%rip), %rax     # 0x64147
leaq 0x2bd24(%rip), %rcx     # 0x64135
cmoveq %rax, %rcx
cmpl $0x2, %r13d
leaq 0x2bd1d(%rip), %r13     # 0x6413d
cmovneq %rcx, %r13
movq %r13, %rdi
callq 0x28e24
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x2e250
testq %r12, %r12
je 0x38461
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq %r15, %rdi
callq 0x2e250
leaq 0x2bcfa(%rip), %rsi     # 0x64150
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x2e250
movq %r14, %rdi
callq 0x28e24
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x2e250
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3aa86
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjLoad
JX9_PRIVATE sxi32 jx9MemObjLoad(jx9_value *pSrc, jx9_value *pDest)
{
	SyMemcpy((const void *)&(*pSrc), &(*pDest), 
		sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
	if( pSrc->iFlags & MEMOBJ_HASHMAP ){
		/* Increment reference count */
		((jx9_hashmap *)pSrc->x.pOther)->iRef++;
	}
	if( SyBlobLength(&pDest->sBlob) > 0 ){
		SyBlobRelease(&pDest->sBlob);
	}
	if( SyBlobLength(&pSrc->sBlob) > 0 ){
		SyBlobReadOnly(&pDest->sBlob, SyBlobData(&pSrc->sBlob), SyBlobLength(&pSrc->sBlob));
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x14
popq %rdx
callq 0x2d3b0
testb $0x40, 0x8(%r14)
je 0x384b4
movq (%r14), %rax
incl 0x50(%rax)
cmpl $0x0, 0x28(%rbx)
je 0x384c3
leaq 0x18(%rbx), %rdi
callq 0x2a72f
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x384de
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rbx)
movl %eax, 0x28(%rbx)
andl $0x0, 0x2c(%rbx)
orb $0x4, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmCallErrorHandler
static sxi32 VmCallErrorHandler(jx9_vm *pVm, SyBlob *pMsg)
{
	jx9_output_consumer *pCons = &pVm->sVmConsumer;
	sxi32 rc = SXRET_OK;
	/* Append a new line */
#ifdef __WINNT__
	SyBlobAppend(pMsg, "\r\n", sizeof("\r\n")-1);
#else
	SyBlobAppend(pMsg, "\n", sizeof(char));
#endif
	/* Invoke the output consumer callback */
	rc = pCons->xConsumer(SyBlobData(pMsg), SyBlobLength(pMsg), pCons->pUserData);
	/* Increment output length */
	pVm->nOutputLen += SyBlobLength(pMsg);
	
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d827(%rip), %rsi     # 0x682c1
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2e250
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movq 0x500(%r14), %rdx
callq *0x4f8(%r14)
movl 0x10(%rbx), %ecx
addl %ecx, 0x4f4(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmPopOperand
static void VmPopOperand(
	jx9_value **ppTos, /* Operand stack */
	sxi32 nPop         /* Total number of memory objects to pop */
	)
{
	jx9_value *pTos = *ppTos;
	while( nPop > 0 ){
		jx9MemObjRelease(pTos);
		pTos--;
		nPop--;
	}
	/* Top of the stack */
	*ppTos = pTos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
testl %r14d, %r14d
jle 0x3aaf2
movq %r15, %rdi
callq 0x296af
addq $-0x40, %r15
decl %r14d
jmp 0x3aadc
movq %r15, (%rbx)
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: jx9MemObjToBool
JX9_PRIVATE sxi32 jx9MemObjToBool(jx9_value *pObj)
{
	if( (pObj->iFlags & MEMOBJ_BOOL) == 0 ){
		/* Preform the conversion */
		pObj->x.iVal = MemObjBooleanValue(&(*pObj));
		/* Invalidate any prior representations */
		SyBlobRelease(&pObj->sBlob);
		MemObjSetType(pObj, MEMOBJ_BOOL);
	}
	return SXRET_OK;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x8, %al
jne 0x3abea
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testb $0x4, %al
jne 0x3ab45
testb $0x2, %al
jne 0x3ab3b
testb $0x1, %al
jne 0x3ab59
testb $0x20, %al
jne 0x3abc1
testb $0x40, %al
jne 0x3ab8e
btl $0x8, %eax
jae 0x3abc1
cmpq $0x0, (%rbx)
setne %r12b
jmp 0x3abc4
xorpd %xmm0, %xmm0
cmpneqsd (%rbx), %xmm0
movq %xmm0, %r12
andl $0x1, %r12d
jmp 0x3abc4
movl 0x28(%rbx), %r15d
testq %r15, %r15
je 0x3abc1
movq 0x20(%rbx), %r14
leal -0x2(%r15), %eax
cmpl $0x3, %eax
ja 0x3ac03
leaq 0x27b76(%rip), %rcx     # 0x626f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2dd6a(%rip), %rsi     # 0x688f4
pushq $0x2
jmp 0x3abf6
movq (%rbx), %rdi
cmpl $0x0, 0x2c(%rdi)
setne %r12b
callq 0x35e9a
jmp 0x3abc4
leaq 0x270c7(%rip), %rsi     # 0x61c6e
pushq $0x4
jmp 0x3abf6
leaq 0x270c1(%rip), %rsi     # 0x61c73
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x32436
testl %eax, %eax
jne 0x3ac03
xorl %r12d, %r12d
movzbl %r12b, %eax
movq %rax, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x2a72f
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
leaq 0x2995f(%rip), %rsi     # 0x64553
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x32436
testl %eax, %eax
je 0x3ac1b
addq %r14, %r15
cmpq %r15, %r14
setb %r12b
jae 0x3abc4
cmpb $0x30, (%r14)
leaq 0x1(%r14), %r14
je 0x3ac06
jmp 0x3abc4
movb $0x1, %r12b
jmp 0x3abc4
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjToReal
JX9_PRIVATE sxi32 jx9MemObjToReal(jx9_value *pObj)
{
	if((pObj->iFlags & MEMOBJ_REAL) == 0 ){
		/* Preform the conversion */
		pObj->x.rVal = MemObjRealValue(&(*pObj));
		/* Invalidate any prior representations */
		SyBlobRelease(&pObj->sBlob);
		MemObjSetType(pObj, MEMOBJ_REAL);
	}
	return SXRET_OK;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x4, %al
jne 0x3ac61
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0xa, %al
je 0x3ac64
cvtsi2sdq (%rbx), %xmm0
movsd %xmm0, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x2a72f
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
testb $0x1, %al
jne 0x3ac8a
xorpd %xmm0, %xmm0
testb $0x20, %al
jne 0x3ac3e
testb $0x40, %al
jne 0x3acb3
btl $0x8, %eax
jae 0x3ac3e
cmpq $0x0, (%rbx)
je 0x3ac3e
movsd 0x28938(%rip), %xmm0    # 0x635c0
jmp 0x3ac3e
andq $0x0, -0x20(%rbp)
movl 0x28(%rbx), %esi
testl %esi, %esi
je 0x3acad
movq 0x20(%rbx), %rdi
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x36406
movsd (%r14), %xmm0
jmp 0x3ac3e
xorpd %xmm0, %xmm0
jmp 0x3ac3e
movq (%rbx), %rdi
movl 0x2c(%rdi), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x35e9a
movsd -0x18(%rbp), %xmm0
jmp 0x3ac3e
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjToNumeric
JX9_PRIVATE sxi32 jx9MemObjToNumeric(jx9_value *pObj)
{
	if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_REAL|MEMOBJ_BOOL|MEMOBJ_NULL) ){
		if( pObj->iFlags & (MEMOBJ_BOOL|MEMOBJ_NULL) ){
			if( pObj->iFlags & MEMOBJ_NULL ){
				pObj->x.iVal = 0;
			}
			MemObjSetType(pObj, MEMOBJ_INT);
		}
		/* Already numeric */
		return  SXRET_OK;
	}
	if( pObj->iFlags & MEMOBJ_STRING ){
		sxi32 rc = SXERR_INVALID;
		sxu8 bReal = FALSE;
		SyString sString;
		SyStringInitFromBuf(&sString, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
		/* Check if the given string looks like a numeric number */
		if( sString.nByte > 0 ){
			rc = SyStrIsNumeric(sString.zString, sString.nByte, &bReal, 0);
		}
		if( bReal ){
			jx9MemObjToReal(&(*pObj));
		}else{
			if( rc != SXRET_OK ){
				/* The input does not look at all like a number, set the value to 0 */
				pObj->x.iVal = 0;
			}else{
				/* Convert as much as we can */
				pObj->x.iVal = MemObjStringToInt(&(*pObj));
			}
			MemObjSetType(pObj, MEMOBJ_INT);
			SyBlobRelease(&pObj->sBlob);
		}
	}else if(pObj->iFlags & (MEMOBJ_HASHMAP|MEMOBJ_RES)){
		jx9MemObjToInteger(pObj);
	}else{
		/* Perform a blind cast */
		jx9MemObjToReal(&(*pObj));
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
testb $0x2e, %r15b
je 0x3ad0e
testb $0x28, %r15b
je 0x3ad85
testb $0x20, %r15b
je 0x3acfd
andq $0x0, (%rbx)
andl $0xfffffe90, %r15d      # imm = 0xFFFFFE90
orl $0x2, %r15d
movl %r15d, 0x8(%rbx)
jmp 0x3ad85
testb $0x1, %r15b
jne 0x3ad2e
movq %rbx, %rdi
addq $0x8, %rsp
testw $0x140, %r15w           # imm = 0x140
je 0x3ad59
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36daa
movb $0x0, -0x19(%rbp)
movl 0x28(%rbx), %esi
testl %esi, %esi
je 0x3ad68
movq 0x20(%rbx), %rdi
leaq -0x19(%rbp), %r14
movq %r14, %rdx
callq 0x3b812
cmpb $0x0, (%r14)
je 0x3ad64
movq %rbx, %rdi
callq 0x3ac20
jmp 0x3ad85
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3ac20
testl %eax, %eax
je 0x3ad90
xorl %eax, %eax
leaq 0x18(%rbx), %rdi
movq %rax, (%rbx)
andl $0xfffffe90, %r15d      # imm = 0xFFFFFE90
orl $0x2, %r15d
movl %r15d, 0x8(%rbx)
callq 0x2a72f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x37567
movl 0x8(%rbx), %r15d
jmp 0x3ad6a
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjToHashmap
JX9_PRIVATE sxi32 jx9MemObjToHashmap(jx9_value *pObj)
{
	if( (pObj->iFlags & MEMOBJ_HASHMAP) == 0 ){
		jx9_hashmap *pMap;
		/* Allocate a new hashmap instance */
		pMap = jx9NewHashmap(pObj->pVm, 0, 0);
		if( pMap == 0 ){
			return SXERR_MEM;
		}
		if( (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_RES)) == 0 ){
			/* 
			 * According to the JX9 language reference manual.
			 *   For any of the types: integer, float, string, boolean converting a value
			 *   to an array results in an array with a single element with index zero 
			 *   and the value of the scalar which was converted.
			 */
			/* Insert a single element */
			jx9HashmapInsert(pMap, 0/* Automatic index assign */, &(*pObj));
			SyBlobRelease(&pObj->sBlob);
		}
		/* Invalidate any prior representation */
		MemObjSetType(pObj, MEMOBJ_HASHMAP);
		pObj->x.pOther = pMap;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testb $0x40, 0x8(%rdi)
jne 0x3adfc
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x368e4
testq %rax, %rax
je 0x3adf9
movq %rax, %r15
movl 0x8(%r14), %eax
testw $0x120, %ax             # imm = 0x120
jne 0x3ade8
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x36999
leaq 0x18(%r14), %rdi
callq 0x2a72f
movl 0x8(%r14), %eax
andl $0xfffffe90, %eax       # imm = 0xFFFFFE90
orl $0x40, %eax
movl %eax, 0x8(%r14)
movq %r15, (%r14)
jmp 0x3adfc
pushq $-0x1
popq %rbx
movl %ebx, %eax
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: jx9HashmapLookup
JX9_PRIVATE sxi32 jx9HashmapLookup(
	jx9_hashmap *pMap,        /* Target hashmap */
	jx9_value *pKey,          /* Lookup key */
	jx9_hashmap_node **ppNode /* OUT: Target node on success */
	)
{
	sxi32 rc;
	if( pMap->nEntry < 1 ){
		/* TICKET 1433-25: Don't bother hashing, the hashmap is empty anyway.
		 */
		return SXERR_NOTFOUND;
	}
	rc = HashmapLookup(&(*pMap), &(*pKey), ppNode);
	return rc;
}

// Assembly:
cmpl $0x0, 0x2c(%rdi)
je 0x3b075
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
andq $0x0, -0x20(%rbp)
movl 0x8(%rsi), %eax
testw $0x141, %ax             # imm = 0x141
je 0x3b07d
testb $0x1, %al
jne 0x3b05b
movq %r15, %rdi
callq 0x36bcf
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x3b079
movq 0x20(%r15), %rsi
leaq -0x20(%rbp), %rcx
movq %r14, %rdi
callq 0x36c0a
jmp 0x3b098
pushq $-0x6
popq %rax
retq
movl 0x8(%r15), %eax
testb $0x2, %al
jne 0x3b089
movq %r15, %rdi
callq 0x36daa
movq (%r15), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x36e57
testl %eax, %eax
je 0x3b0a1
pushq $-0x6
popq %rax
jmp 0x3b0af
xorl %eax, %eax
testq %rbx, %rbx
je 0x3b0af
movq -0x20(%rbp), %rcx
movq %rcx, (%rbx)
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: jx9HashmapExtractNodeValue
JX9_PRIVATE void jx9HashmapExtractNodeValue(jx9_hashmap_node *pNode, jx9_value *pValue, int bStore)
{
	jx9_value *pEntry = HashmapExtractNodeValue(pNode);
	if( pEntry ){
		if( bStore ){
			jx9MemObjStore(pEntry, pValue);
		}else{
			jx9MemObjLoad(pEntry, pValue);
		}
	}else{
		jx9MemObjRelease(pValue);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
callq 0x35e71
testq %rax, %rax
je 0x3b0e5
movq %rax, %rdi
movq %rbx, %rsi
testl %r14d, %r14d
je 0x3b0f1
popq %rbx
popq %r14
popq %rbp
jmp 0x35ceb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x296af
popq %rbx
popq %r14
popq %rbp
jmp 0x38492
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmLocalExec
static sxi32 VmLocalExec(jx9_vm *pVm, SySet *pByteCode,jx9_value *pResult)
{
	jx9_value *pStack;
	sxi32 rc;
	/* Allocate a new operand stack */
	pStack = VmNewOperandStack(&(*pVm), SySetUsed(pByteCode));
	if( pStack == 0 ){
		return SXERR_MEM;
	}
	/* Execute the program */
	rc = VmByteCodeExec(&(*pVm), (VmInstr *)SySetBasePtr(pByteCode), pStack, -1, &(*pResult));
	/* Free the operand stack */
	SyMemBackendFree(&pVm->sAllocator, pStack);
	/* Execution result */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x10(%rsi), %esi
callq 0x3832f
testq %rax, %rax
je 0x3b5a9
movq %rax, %r15
movq 0x8(%r12), %rsi
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
movq %r14, %r8
callq 0x384e3
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d420
movl %r14d, %eax
jmp 0x3b5ac
pushq $-0x1
popq %rax
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: VmEnterFrame
static sxi32 VmEnterFrame(
	jx9_vm *pVm,               /* Target VM */
	void *pUserData,           /* Upper-layer private data */
	VmFrame **ppFrame          /* OUT: Top most active frame */
	)
{
	VmFrame *pFrame;
	/* Allocate a new frame */
	pFrame = VmNewFrame(&(*pVm), pUserData);
	if( pFrame == 0 ){
		return SXERR_MEM;
	}
	/* Link to the list of active VM frame */
	pFrame->pParent = pVm->pFrame;
	pVm->pFrame = pFrame;
	if( ppFrame ){
		/* Write a pointer to the new VM frame */
		*ppFrame = pFrame;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0xb0, %esi
callq 0x279f7
testq %rax, %rax
je 0x3b671
movq %rax, %r15
movq %rax, %rdi
movl $0xb0, %esi
callq 0x27aea
movq %r12, 0x8(%r15)
movq %r14, 0x38(%r15)
movq %r15, %rdi
addq $0x40, %rdi
movq %r14, %rsi
callq 0x3bcf0
movabsq $0x1000000000, %rax     # imm = 0x1000000000
movq %rax, 0x94(%r15)
andl $0x0, 0x90(%r15)
andl $0x0, 0x9c(%r15)
movq %r14, 0x80(%r15)
andq $0x0, 0x88(%r15)
andq $0x0, 0xa0(%r15)
movq $0x10, 0x28(%r15)
movq %r14, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
andq $0x0, 0x30(%r15)
movq 0xf8(%r14), %rax
movq %rax, (%r15)
movq %r15, 0xf8(%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x3b674
movq %r15, (%rbx)
jmp 0x3b674
pushq $-0x1
popq %rax
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: SyHashInsert
JX9_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void *pUserData)
{
	SyHashEntry_Pr *pEntry;
	sxi32 rc;
#if defined(UNTRUST)
	if( INVALID_HASH(pHash) || pKey == 0 ){
		return SXERR_CORRUPT;
	}
#endif
	if( pHash->nEntry >= pHash->nBucketSize * SXHASH_FILL_FACTOR ){
		rc = HashGrowTable(&(*pHash));
		if( rc != SXRET_OK ){
			return rc;
		}
	}
	/* Allocate a new hash entry */
	pEntry = (SyHashEntry_Pr *)SyMemBackendPoolAlloc(pHash->pAllocator, sizeof(SyHashEntry_Pr));
	if( pEntry == 0 ){
		return SXERR_MEM;
	}
	/* Zero the entry */
	SyZero(pEntry, sizeof(SyHashEntry_Pr));
	pEntry->pHash = pHash;
	pEntry->pKey = pKey;
	pEntry->nKeyLen = nKeyLen;
	pEntry->pUserData = pUserData;
	pEntry->nHash = pHash->xHash(pEntry->pKey, pEntry->nKeyLen);
	/* Finally insert the entry in its corresponding bucket */
	rc = HashInsert(&(*pHash), pEntry);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
movl 0x38(%rdi), %r14d
leal (%r14,%r14,2), %eax
cmpl %eax, 0x28(%rdi)
jb 0x3b720
movq (%rbx), %rdi
movl %r14d, %r12d
shll $0x4, %r12d
movl %r12d, %esi
callq 0x2ca19
testq %rax, %rax
je 0x3b720
movq %rax, %r13
addl %r14d, %r14d
movq %rax, %rdi
movl %r12d, %esi
callq 0x27aea
leaq 0x18(%rbx), %rax
movl 0x28(%rbx), %ecx
leal -0x1(%r14), %edx
xorps %xmm0, %xmm0
subl $0x1, %ecx
jb 0x3b70c
movq (%rax), %rax
movups %xmm0, 0x38(%rax)
movl 0x18(%rax), %esi
andl %edx, %esi
movq (%r13,%rsi,8), %rdi
movq %rdi, 0x38(%rax)
testq %rdi, %rdi
je 0x3b701
movq %rax, 0x40(%rdi)
movq %rax, (%r13,%rsi,8)
addq $0x28, %rax
jmp 0x3b6de
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x2d420
movq %r13, 0x30(%rbx)
movl %r14d, 0x38(%rbx)
movq (%rbx), %rdi
pushq $0x48
popq %rsi
callq 0x279f7
testq %rax, %rax
je 0x3b7a8
movq %rax, %r13
pushq $0x48
popq %rsi
movq %rax, %rdi
callq 0x27aea
movq %rbx, 0x20(%r13)
movq %r15, (%r13)
movl -0x2c(%rbp), %esi
movl %esi, 0x8(%r13)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%r13)
movq %r15, %rdi
callq *0x8(%rbx)
movl %eax, 0x18(%r13)
movl 0x38(%rbx), %ecx
decl %ecx
andl %eax, %ecx
movq 0x30(%rbx), %rax
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x38(%r13)
testq %rdx, %rdx
je 0x3b77b
movq %r13, 0x40(%rdx)
movq %r13, (%rax,%rcx,8)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x3b790
movq %rax, 0x28(%r13)
movq %r13, 0x30(%rax)
movq %r13, 0x18(%rbx)
movl 0x28(%rbx), %eax
testl %eax, %eax
jne 0x3b79f
movq %r13, 0x20(%rbx)
incl %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
jmp 0x3b7ab
pushq $-0x1
popq %rax
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: jx9MemObjCastMethod
JX9_PRIVATE ProcMemObjCast jx9MemObjCastMethod(sxi32 iFlags)
{
	if( iFlags & MEMOBJ_STRING ){
		return jx9MemObjToString;
	}else if( iFlags & MEMOBJ_INT ){
		return jx9MemObjToInteger;
	}else if( iFlags & MEMOBJ_REAL ){
		return jx9MemObjToReal;
	}else if( iFlags & MEMOBJ_BOOL ){
		return jx9MemObjToBool;
	}else if( iFlags & MEMOBJ_HASHMAP ){
		return jx9MemObjToHashmap;
	}
	/* NULL cast */
	return jx9MemObjToNull;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, %dil
jne 0x3b7ee
testb $0x2, %dil
jne 0x3b7f7
testb $0x4, %dil
jne 0x3b800
testb $0x8, %dil
jne 0x3b809
testb $0x40, %dil
leaq -0x4b42(%rip), %rcx     # 0x36c9f
leaq -0xa4a(%rip), %rax      # 0x3ad9e
cmoveq %rcx, %rax
jmp 0x3b810
leaq -0x4c26(%rip), %rax     # 0x36bcf
jmp 0x3b810
leaq -0x4a54(%rip), %rax     # 0x36daa
jmp 0x3b810
leaq -0xbe7(%rip), %rax      # 0x3ac20
jmp 0x3b810
leaq -0xd10(%rip), %rax      # 0x3ab00
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashGetEntry
static SyHashEntry_Pr * HashGetEntry(SyHash *pHash, const void *pKey, sxu32 nKeyLen)
{
	SyHashEntry_Pr *pEntry;
	sxu32 nHash;

	nHash = pHash->xHash(pKey, nKeyLen);
	pEntry = pHash->apBucket[nHash & (pHash->nBucketSize - 1)];
	for(;;){
		if( pEntry == 0 ){
			break;
		}
		if( pEntry->nHash == nHash && pEntry->nKeyLen == nKeyLen && 
			pHash->xCmp(pEntry->pKey, pKey, nKeyLen) == 0 ){
				return pEntry;
		}
		pEntry = pEntry->pNextCollide;
	}
	/* Entry not found */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq *0x8(%r15)
movl %eax, %r13d
movl 0x38(%r15), %r12d
decl %r12d
andl %eax, %r12d
shlq $0x3, %r12
addq 0x30(%r15), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x3b9ca
cmpl %r13d, 0x18(%r12)
jne 0x3b9c4
cmpl %ebx, 0x8(%r12)
jne 0x3b9c4
movq (%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0x10(%r15)
testl %eax, %eax
je 0x3b9ca
addq $0x38, %r12
jmp 0x3b99c
movq %r12, %rax
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: VmThrowErrorAp
static sxi32 VmThrowErrorAp(
	jx9_vm *pVm,         /* Target VM */
	SyString *pFuncName, /* Function name. NULL otherwise */
	sxi32 iErr,          /* Severity level: [i.e: Error, Warning or Notice] */
	const char *zFormat, /* Format message */
	va_list ap           /* Variable list of arguments */
	)
{
	SyBlob *pWorker = &pVm->sWorker;
	SyString *pFile;
	char *zErr;
	sxi32 rc;
	if( !pVm->bErrReport ){
		/* Don't bother reporting errors */
		return SXRET_OK;
	}
	/* Reset the working buffer */
	SyBlobReset(pWorker);
	/* Peek the processed file if available */
	pFile = (SyString *)SySetPeek(&pVm->aFiles);
	if( pFile ){
		/* Append file name */
		SyBlobAppend(pWorker, pFile->zString, pFile->nByte);
		SyBlobAppend(pWorker, (const void *)" ", sizeof(char));
	}
	zErr = "Error: ";
	switch(iErr){
	case JX9_CTX_WARNING: zErr = "Warning: "; break;
	case JX9_CTX_NOTICE:  zErr = "Notice: ";  break;
	default:
		iErr = JX9_CTX_ERR;
		break;
	}
	SyBlobAppend(pWorker, zErr, SyStrlen(zErr));
	if( pFuncName ){
		/* Append function name first */
		SyBlobAppend(pWorker, pFuncName->zString, pFuncName->nByte);
		SyBlobAppend(pWorker, "(): ", sizeof("(): ")-1);
	}
	SyBlobFormatAp(pWorker, zFormat, ap);
	/* Consume the error message */
	rc = VmCallErrorHandler(&(*pVm), pWorker);
	return rc;
}

// Assembly:
cmpl $0x0, 0x4e8(%rdi)
je 0x3badf
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
movq %r8, -0x30(%rbp)
leaq 0x3a8(%rdi), %r12
movq %r12, %rdi
callq 0x31b1e
movl 0x3f8(%r14), %eax
testl %eax, %eax
je 0x3ba58
movq 0x3f0(%r14), %rcx
testq %rcx, %rcx
je 0x3ba58
decl %eax
imull 0x400(%r14), %eax
movq (%rcx,%rax), %rsi
movl 0x8(%rcx,%rax), %edx
movq %r12, %rdi
callq 0x2e250
leaq 0x2c0b4(%rip), %rsi     # 0x67b01
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x2e250
cmpl $0x3, %ebx
leaq 0x286e5(%rip), %rax     # 0x64147
leaq 0x286cc(%rip), %rcx     # 0x64135
cmoveq %rax, %rcx
cmpl $0x2, %ebx
leaq 0x286c6(%rip), %rbx     # 0x6413d
cmovneq %rcx, %rbx
movq %rbx, %rdi
callq 0x28e24
movq %r12, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2e250
testq %r13, %r13
je 0x3bab7
movq (%r13), %rsi
movl 0x8(%r13), %edx
movq %r12, %rdi
callq 0x2e250
leaq 0x286a4(%rip), %rsi     # 0x64150
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x2e250
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x296e2
movq %r14, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3aa86
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemObjTryIntger
static sxi32 MemObjTryIntger(jx9_value *pObj)
{
	sxi64 iVal = MemObjRealToInt(&(*pObj));
  /* Only mark the value as an integer if
  **
  **    (1) the round-trip conversion real->int->real is a no-op, and
  **    (2) The integer is neither the largest nor the smallest
  **        possible integer
  **
  ** The second and third terms in the following conditional enforces
  ** the second condition under the assumption that addition overflow causes
  ** values to wrap around.  On x86 hardware, the third term is always
  ** true and could be omitted.  But we leave it in because other
  ** architectures might behave differently.
  */
	if( pObj->x.rVal ==(jx9_real)iVal && iVal>SMALLEST_INT64 && iVal<LARGEST_INT64 ){
		pObj->x.iVal = iVal; 
		pObj->iFlags = MEMOBJ_INT;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd (%rdi), %xmm0
movapd 0x27b0e(%rip), %xmm1    # 0x63600
andpd %xmm0, %xmm1
ucomisd 0x27aca(%rip), %xmm1    # 0x635c8
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cvttsd2si %xmm0, %rax
leaq 0x1(%rcx), %rdx
cmovaq %rdx, %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm0, %xmm1
setp %dl
setne %sil
orb %dl, %sil
addq %rax, %rcx
cmpq $-0x2, %rcx
setae %cl
orb %sil, %cl
jne 0x3bb41
movq %rax, (%rdi)
movl $0x2, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapDup
JX9_PRIVATE sxi32 jx9HashmapDup(jx9_hashmap *pSrc, jx9_hashmap *pDest)
{
	jx9_hashmap_node *pEntry;
	jx9_value sKey, *pVal;
	sxi32 rc;
	sxu32 n;
	if( pSrc == pDest ){
		/* Same map. This can easily happen since hashmaps are passed by reference.
		 * Unlike the  engine.
		 */
		return SXRET_OK;
	}
	/* Point to the first inserted entry in the source */
	pEntry = pSrc->pFirst;
	/* Perform the duplication */
	for( n = 0 ; n < pSrc->nEntry ; ++n ){
		/* Extract the node value */
		pVal = HashmapExtractNodeValue(pEntry);
		if( pEntry->iType == HASHMAP_BLOB_NODE ){
			/* Blob key insertion */
			jx9MemObjInitFromString(pDest->pVm, &sKey, 0);
			jx9MemObjStringAppend(&sKey, (const char *)SyBlobData(&pEntry->xKey.sKey), SyBlobLength(&pEntry->xKey.sKey));
			rc = jx9HashmapInsert(&(*pDest), &sKey, pVal);
			jx9MemObjRelease(&sKey);
		}else{
			/* Int key insertion */
			rc = HashmapInsertIntKey(&(*pDest), pEntry->xKey.iKey, pVal);
		}
		if( rc != SXRET_OK ){
			return rc;
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x30(%rbp)
cmpq %rsi, %rdi
je 0x3bbef
movq %rdi, %r14
leaq 0x10(%rdi), %r15
xorl %r12d, %r12d
movq %rdi, -0x38(%rbp)
movq -0x30(%rbp), %rbx
cmpl 0x2c(%r14), %r12d
jae 0x3bbef
movq (%r15), %r15
movq %r15, %rdi
callq 0x35e71
movq %rax, %r13
cmpl $0x2, 0x8(%r15)
jne 0x3bbce
movq (%rbx), %rdi
leaq -0x78(%rbp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3bbfe
movq 0x18(%r15), %rsi
movl 0x20(%r15), %edx
movq %r14, %rdi
callq 0x3689a
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x36999
movl %eax, %r13d
movq %r14, %rdi
movq -0x38(%rbp), %r14
callq 0x296af
jmp 0x3bbe1
movq 0x10(%r15), %rsi
movq -0x30(%rbp), %rdi
movq %r13, %rdx
callq 0x36ec2
movl %eax, %r13d
testl %r13d, %r13d
jne 0x3bbef
addq $0x48, %r15
incl %r12d
jmp 0x3bb73
addq $0x58, %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: jx9MemObjInitFromString
JX9_PRIVATE sxi32 jx9MemObjInitFromString(jx9_vm *pVm, jx9_value *pObj, const SyString *pVal)
{
	/* Zero the structure */
	SyZero(pObj, sizeof(jx9_value));
	/* Initialize fields */
	pObj->pVm = pVm;
	SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
	if( pVal ){
		/* Append contents */
		SyBlobAppend(&pObj->sBlob, (const void *)pVal->zString, pVal->nByte);
	}
	/* Set the desired type */
	pObj->iFlags = MEMOBJ_STRING;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x27aea
movq %r15, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %r15, 0x18(%rbx)
andl $0x0, 0x30(%rbx)
testq %r14, %r14
je 0x3bc44
leaq 0x18(%rbx), %rdi
movq (%r14), %rsi
movl 0x8(%r14), %edx
callq 0x2e250
movl $0x1, 0x8(%rbx)
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: HashmapNodeCmp
static sxi32 HashmapNodeCmp(jx9_hashmap_node *pLeft, jx9_hashmap_node *pRight, int bStrict)
{
	jx9_value sObj1, sObj2;
	sxi32 rc;
	if( pLeft == pRight ){
		/*
		 * Same node.Refer to the sort() implementation defined
		 * below for more information on this sceanario.
		 */
		return 0;
	}
	/* Do the comparison */
	jx9MemObjInit(pLeft->pMap->pVm, &sObj1);
	jx9MemObjInit(pLeft->pMap->pVm, &sObj2);
	jx9HashmapExtractNodeValue(pLeft, &sObj1, FALSE);
	jx9HashmapExtractNodeValue(pRight, &sObj2, FALSE);
	rc = jx9MemObjCmp(&sObj1, &sObj2, bStrict, 0);
	jx9MemObjRelease(&sObj1);
	jx9MemObjRelease(&sObj2);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpq %rsi, %rdi
je 0x3bcda
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq (%rax), %rdi
leaq -0xa8(%rbp), %r14
movq %r14, %rsi
callq 0x35772
movq (%r13), %rax
movq (%rax), %rdi
leaq -0x68(%rbp), %r15
movq %r15, %rsi
callq 0x35772
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3b0ba
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3b0ba
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x3b31c
movl %eax, %ebx
movq %r14, %rdi
callq 0x296af
movq %r15, %rdi
callq 0x296af
jmp 0x3bcdc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x88, %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: SyHashInit
JX9_PRIVATE sxi32 SyHashInit(SyHash *pHash, SyMemBackend *pAllocator, ProcHash xHash, ProcCmp xCmp)
{
	SyHashEntry_Pr **apNew;
#if defined(UNTRUST)
	if( pHash == 0 ){
		return SXERR_EMPTY;
	}
#endif
	/* Allocate a new table */
	apNew = (SyHashEntry_Pr **)SyMemBackendAlloc(&(*pAllocator), sizeof(SyHashEntry_Pr *) * SXHASH_BUCKET_SIZE);
	if( apNew == 0 ){
		return SXERR_MEM;
	}
	SyZero((void *)apNew, sizeof(SyHashEntry_Pr *) * SXHASH_BUCKET_SIZE);
	pHash->pAllocator = &(*pAllocator);
	pHash->xHash = xHash ? xHash : SyBinHash;
	pHash->xCmp = xCmp ? xCmp : SyMemcmp;
	pHash->pCurrent = pHash->pList = 0;
	pHash->nEntry = 0;
	pHash->apBucket = apNew;
	pHash->nBucketSize = SXHASH_BUCKET_SIZE;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x80, %esi
callq 0x2ca19
testq %rax, %rax
je 0x3bd51
movq %rax, %r14
movq %rax, %rdi
movl $0x80, %esi
callq 0x27aea
movq %r15, (%rbx)
leaq -0x664c(%rip), %rax     # 0x356e0
movq %rax, 0x8(%rbx)
leaq -0xea29(%rip), %rax     # 0x2d30e
movq %rax, 0x10(%rbx)
andl $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %r14, 0x30(%rbx)
movl $0x10, 0x38(%rbx)
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: SyHashRelease
JX9_PRIVATE sxi32 SyHashRelease(SyHash *pHash)
{
	SyHashEntry_Pr *pEntry, *pNext;
#if defined(UNTRUST)
	if( INVALID_HASH(pHash)  ){
		return SXERR_EMPTY;
	}
#endif
	pEntry = pHash->pList;
	for(;;){
		if( pHash->nEntry == 0 ){
			break;
		}
		pNext = pEntry->pNext;
		SyMemBackendPoolFree(pHash->pAllocator, pEntry);
		pEntry = pNext;
		pHash->nEntry--;
	}
	if( pHash->apBucket ){
		SyMemBackendFree(pHash->pAllocator, (void *)pHash->apBucket);
	}
	pHash->apBucket = 0;
	pHash->nBucketSize = 0;
	pHash->pAllocator = 0;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
movl 0x28(%rdi), %eax
testl %eax, %eax
je 0x3bd8a
movq 0x28(%rsi), %r14
movq (%rbx), %rdi
callq 0x27bf8
movl 0x28(%rbx), %eax
decl %eax
movl %eax, 0x28(%rbx)
movq %r14, %rsi
jmp 0x3bd6d
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x3bd9b
movq (%rbx), %rdi
callq 0x2d420
andq $0x0, 0x30(%rbx)
andl $0x0, 0x38(%rbx)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjInitFromInt
JX9_PRIVATE sxi32 jx9MemObjInitFromInt(jx9_vm *pVm, jx9_value *pObj, sxi64 iVal)
{
	/* Zero the structure */
	SyZero(pObj, sizeof(jx9_value));
	/* Initialize fields */
	pObj->pVm = pVm;
	SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
	/* Set the desired type */
	pObj->x.iVal = iVal;
	pObj->iFlags = MEMOBJ_INT;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x27aea
movq %r15, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq %r15, 0x18(%r14)
andl $0x0, 0x30(%r14)
movq %rbx, (%r14)
movl $0x2, 0x8(%r14)
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: unqliteCollectionDropRecord
UNQLITE_PRIVATE int unqliteCollectionDropRecord(
	unqlite_col *pCol,  /* Target collection */
	jx9_int64 nId,      /* Unique ID of the record to be droped */
	int wr_header,      /* True to alter collection header */
	int log_err         /* True to log error */
	)
{
	SyBlob *pWorker = &pCol->sWorker;
	int rc;		
	/* Reset the working buffer */
	SyBlobReset(pWorker);
	/* Prepare the unique ID for this record */
	SyBlobFormat(pWorker,"%z_%qd",&pCol->sName,nId);
	/* Reset the cursor */
	unqlite_kv_cursor_reset(pCol->pCursor);
	/* Seek the cursor to the desired location */
	rc = unqlite_kv_cursor_seek(pCol->pCursor,
		SyBlobData(pWorker),SyBlobLength(pWorker),
		UNQLITE_CURSOR_MATCH_EXACT
		);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Remove the record from the storage engine */
	rc = unqlite_kv_cursor_delete_entry(pCol->pCursor);
	/* Finally, Remove the record from the cache */
	unqliteCollectionCacheRemoveRecord(pCol,nId);
	if( rc == UNQLITE_OK ){
		pCol->nTotRec--;
		if( wr_header ){
			/* Relect in the collection header */
			rc = CollectionSetHeader(0,pCol,-1,pCol->nTotRec,0);
		}
	}else if( rc == UNQLITE_NOTIMPLEMENTED ){
		if( log_err ){
			unqliteGenErrorFormat(pCol->pVm->pDb,
				"Cannot delete record from collection '%z' due to a read-only Key/Value storage engine",
				&pCol->sName
				);
		}
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x68(%rdi), %r15
movq %r15, %rdi
callq 0x31b1e
leaq 0x8(%rbx), %r14
leaq 0x27f71(%rip), %rsi     # 0x640b8
movq %r15, %rdi
movq %r14, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x35d7b
movq 0x118(%rbx), %rdi
callq 0x2b1d8
movq 0x118(%rbx), %rdi
movq 0x70(%rbx), %rsi
movl 0x78(%rbx), %edx
pushq $0x1
popq %rcx
callq 0x2b1fc
testl %eax, %eax
je 0x3c192
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x118(%rbx), %rdi
callq 0x2b1b4
movl %eax, %r15d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x382a2
testl %r15d, %r15d
je 0x3c1e0
cmpl $-0x11, %r15d
setne %al
cmpl $0x0, -0x2c(%rbp)
sete %cl
orb %al, %cl
jne 0x3c180
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x2853f(%rip), %rsi     # 0x6470f
movq %r14, %rdx
xorl %eax, %eax
callq 0x32836
pushq $-0x11
popq %r15
jmp 0x3c180
movq 0xb8(%rbx), %rcx
decq %rcx
movq %rcx, 0xb8(%rbx)
testl %r12d, %r12d
je 0x3c214
pushq $-0x1
popq %rdx
xorl %edi, %edi
movq %rbx, %rsi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x357a9
xorl %r15d, %r15d
jmp 0x3c180
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmExtractSuper
static jx9_value * VmExtractSuper(
	jx9_vm *pVm,       /* Target VM */
	const char *zName, /* Superglobal name: NOT NULL TERMINATED */
	sxu32 nByte        /* zName length */
	)
{
	SyHashEntry *pEntry;
	jx9_value *pValue;
	sxu32 nIdx;
	/* Query the superglobal table */
	pEntry = SyHashGet(&pVm->hSuper, (const void *)zName, nByte);
	if( pEntry == 0 ){
		/* No such entry */
		return 0;
	}
	/* Extract the superglobal index in the global object pool */
	nIdx = SX_PTR_TO_INT(pEntry->pUserData);
	/* Extract the variable value  */
	pValue = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
	return pValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x348, %rdi            # imm = 0x348
callq 0x3ae09
testq %rax, %rax
je 0x3d423
movl 0x10(%rax), %eax
cmpl %eax, 0x218(%rbx)
jbe 0x3d423
imull 0x220(%rbx), %eax
addq 0x210(%rbx), %rax
jmp 0x3d425
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: VmHashmapInsert
static sxi32 VmHashmapInsert(
	jx9_hashmap *pMap,  /* Target hashmap  */
	const char *zKey,   /* Entry key */
	int nKeylen,        /* zKey length*/
	const char *zData,  /* Entry data */
	int nLen            /* zData length */
	)
{
	jx9_value sKey,sValue;
	jx9_value *pKey;
	sxi32 rc;
	pKey = 0;
	jx9MemObjInit(pMap->pVm, &sKey);
	jx9MemObjInitFromString(pMap->pVm, &sValue, 0);
	if( zKey ){
		if( nKeylen < 0 ){
			nKeylen = (int)SyStrlen(zKey);
		}
		jx9MemObjStringAppend(&sKey, zKey, (sxu32)nKeylen);
		pKey = &sKey;
	}
	if( zData ){
		if( nLen < 0 ){
			/* Compute length automatically */
			nLen = (int)SyStrlen(zData);
		}
		jx9MemObjStringAppend(&sValue, zData, (sxu32)nLen);
	}
	/* Perform the insertion */
	rc = jx9HashmapInsert(&(*pMap),pKey,&sValue);
	jx9MemObjRelease(&sKey);
	jx9MemObjRelease(&sValue);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x35772
movq (%rbx), %rdi
xorl %r12d, %r12d
leaq -0x70(%rbp), %rsi
xorl %edx, %edx
callq 0x3bbfe
testq %r13, %r13
je 0x3d49a
testl %r15d, %r15d
jns 0x3d485
movq %r13, %rdi
callq 0x28e24
movl %eax, %r15d
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x3689a
testq %r14, %r14
je 0x3d4bc
movl -0x2c(%rbp), %edx
testl %edx, %edx
jns 0x3d4b0
movq %r14, %rdi
callq 0x28e24
movl %eax, %edx
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x3689a
leaq -0x70(%rbp), %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x36999
movl %eax, %ebx
leaq -0xb0(%rbp), %rdi
callq 0x296af
movq %r14, %rdi
callq 0x296af
movl %ebx, %eax
addq $0x88, %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: jx9_vm_config
JX9_PRIVATE int jx9_vm_config(jx9_vm *pVm, int iConfigOp, ...)
{
	va_list ap;
	int rc;
	/* Ticket 1433-002: NULL VM is harmless operation */
	if ( JX9_VM_MISUSE(pVm) ){
		return JX9_CORRUPT;
	}
#if defined(JX9_ENABLE_THREADS)
	 /* Acquire VM mutex */
	 SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
	 if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE && 
		 JX9_THRD_VM_RELEASE(pVm) ){
			 return JX9_ABORT; /* Another thread have released this instance */
	 }
#endif
	/* Confiugure the virtual machine */
	va_start(ap, iConfigOp);
	rc = jx9VmConfigure(&(*pVm), iConfigOp, ap);
	va_end(ap);
#if defined(JX9_ENABLE_THREADS)
	 /* Leave VM mutex */
	 SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x3d551
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)
pushq $-0x18
popq %r15
testq %rdi, %rdi
je 0x3d5e9
movq %rdi, %rbx
cmpl $0xdead2bad, 0x6e8(%rdi) # imm = 0xDEAD2BAD
je 0x3d5e9
movl %esi, %r14d
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d586
movq 0x4ab3d(%rip), %rax     # 0x880c0
callq *0x20(%rax)
cmpl $0x2, 0x4ab43(%rip)     # 0x880d0
jb 0x3d5a1
cmpl $0xdead2bad, 0x6e8(%rbx) # imm = 0xDEAD2BAD
jne 0x3d5a1
pushq $-0xa
popq %r15
jmp 0x3d5e9
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)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3c21c
movl %eax, %r15d
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d5e9
movq 0x4aada(%rip), %rax     # 0x880c0
callq *0x30(%rax)
movl %r15d, %eax
addq $0xc8, %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: VmHttpExtractHeaderValue
static SyString * VmHttpExtractHeaderValue(SySet *pSet, const char *zMime, sxu32 nByte)
 {
	 SyhttpHeader *aMime, *pMime;
	 SyString sMime;
	 sxu32 n;
	 SyStringInitFromBuf(&sMime, zMime, nByte);
	 /* Point to the MIME entries */
	 aMime = (SyhttpHeader *)SySetBasePtr(pSet);
	 /* Perform the lookup */
	 for( n = 0 ; n < SySetUsed(pSet) ; ++n ){
		 pMime = &aMime[n];
		 if( SyStringCmp(&sMime, &pMime->sName, SyStrnicmp) == 0 ){
			 /* Header found, return it's associated value */
			 return &pMime->sValue;
		 }
	 }
	 /* No such MIME header */
	 return 0;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq 0x8(%rdi), %rbx
movl 0x10(%rdi), %r12d
incq %r12
addq $-0x10, %rbx
decq %r12
je 0x3d7f1
movl %r14d, %eax
subl 0x18(%rbx), %eax
jne 0x3d7e7
movq 0x10(%rbx), %rsi
movq %r15, %rdi
movl %r14d, %edx
callq 0x32436
addq $0x20, %rbx
testl %eax, %eax
jne 0x3d7cb
jmp 0x3d7f3
xorl %ebx, %ebx
movq %rbx, %rax
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: SySetGetNextEntry
JX9_PRIVATE sxi32 SySetGetNextEntry(SySet *pSet, void **ppEntry)
{
	register unsigned char *zSrc;
	if( pSet->nCursor >= pSet->nUsed ){
		/* Reset cursor */
		pSet->nCursor = 0;
		return SXERR_EOF;
	}
	zSrc = (unsigned char *)SySetBasePtr(pSet);
	if( ppEntry ){
		*ppEntry = (void *)&zSrc[pSet->nCursor * pSet->eSize];
	}
	pSet->nCursor++;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1c(%rdi), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x3d823
testq %rsi, %rsi
je 0x3d81d
movl 0x18(%rdi), %eax
imull %ecx, %eax
addq 0x8(%rdi), %rax
movq %rax, (%rsi)
incl %ecx
xorl %eax, %eax
jmp 0x3d82a
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
xorl %ecx, %ecx
movl %ecx, 0x1c(%rdi)
popq %rbp
retq