LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ExtractNonSpaceToken
static sxi32 ExtractNonSpaceToken(const char **pzIn, const char *zEnd, SyString *pOut)
{
	const char *zIn = *pzIn;
	const char *zPtr;
	/* Ignore leading white spaces */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
		zIn++;
	}
	if( zIn >= zEnd ){
		/* End of input */
		return SXERR_EOF;
	}
	zPtr = zIn;
	/* Extract the token */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && !SyisSpace(zIn[0]) ){
		zIn++;
	}
	SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
	/* Synchronize pointers */
	*pzIn = zIn;
	/* Return to the caller */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r13
movl $0xffffffee, %r12d      # imm = 0xFFFFFFEE
cmpq %rsi, %r13
jae 0x5b8b7
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl %r13d, %ebx
movsbq (%r13), %r14
cmpq $-0x41, %r14
ja 0x5b86d
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0x5b86d
incq %r13
incl %ebx
cmpq %r15, %r13
jne 0x5b846
jmp 0x5b8b7
movq %r13, %r12
cmpq %r15, %r13
jae 0x5b89e
movq %r13, %r12
movsbq (%r12), %r14
cmpq $-0x41, %r14
ja 0x5b89e
callq 0xc170
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x5b89e
incq %r12
cmpq %r15, %r12
jb 0x5b878
movq %r15, %r12
movq -0x38(%rbp), %rcx
movq %r13, (%rcx)
movl %r12d, %eax
subl %ebx, %eax
movl %eax, 0x8(%rcx)
movq -0x30(%rbp), %rax
movq %r12, (%rax)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ExtractToken
static sxi32 ExtractToken(const char **pzIn, const char *zEnd, const char *zMask, int nMasklen, SyString *pOut)
{
	const char *zIn = *pzIn;
	const char *zPtr;
	/* Ignore leading delimiter */
	while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && CheckMask(zIn[0], zMask, nMasklen, 0) ){
		zIn++;
	}
	if( zIn >= zEnd ){
		/* End of input */
		return SXERR_EOF;
	}
	zPtr = zIn;
	/* Extract the token */
	while( zIn < zEnd ){
		if( (unsigned char)zIn[0] >= 0xc0 ){
			/* UTF-8 stream */
			zIn++;
			SX_JMP_UTF8(zIn, zEnd);
		}else{
			if( CheckMask(zIn[0], zMask, nMasklen, 0) ){
				break;
			}
			zIn++;
		}
	}
	SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
	/* Update the cursor */
	*pzIn = zIn;
	/* Return to the caller */
	return SXRET_OK;
}

// Assembly:
movq (%rdi), %r9
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpq %rsi, %r9
jae 0x5b96b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %ecx, %r10d
testl %ecx, %ecx
jle 0x5b90b
movb (%r9), %r11b
cmpb $-0x41, %r11b
ja 0x5b90b
xorl %ebx, %ebx
cmpb %r11b, (%rdx,%rbx)
je 0x5b901
incq %rbx
cmpq %rbx, %r10
jne 0x5b8f1
jmp 0x5b90b
incq %r9
cmpq %rsi, %r9
jne 0x5b8e2
jmp 0x5b969
movq %r9, %rax
cmpq %rsi, %r9
jae 0x5b958
movq %r9, %rax
movb (%rax), %r11b
cmpb $-0x40, %r11b
jb 0x5b93c
incq %rax
movq %rax, %r11
movq %r11, %rax
cmpq %rsi, %r11
jae 0x5b953
movb (%rax), %bl
andb $-0x40, %bl
leaq 0x1(%rax), %r11
negb %bl
jo 0x5b925
jmp 0x5b953
testl %ecx, %ecx
jle 0x5b950
xorl %ebx, %ebx
cmpb %r11b, (%rdx,%rbx)
je 0x5b958
incq %rbx
cmpq %rbx, %r10
jne 0x5b942
incq %rax
cmpq %rsi, %rax
jb 0x5b916
movq %r9, (%r8)
movl %eax, %ecx
subl %r9d, %ecx
movl %ecx, 0x8(%r8)
movq %rax, (%rdi)
xorl %eax, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: StrReplaceWalker
static int StrReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
	str_replace_data *pRep = (str_replace_data *)pUserData;
	SyString sWorker;
	const char *zIn;
	int nByte;
	/* Extract a string representation of the given argument */
	zIn = jx9_value_to_string(pData, &nByte);
	SyStringInitFromBuf(&sWorker, 0, 0);
	if( nByte > 0 ){
		char *zDup;
		/* Duplicate the chunk */
		zDup = (char *)jx9_context_alloc_chunk(pRep->pCtx, (unsigned int)nByte, FALSE, 
			TRUE /* Release the chunk automatically, upon this context is destroyd */
			);
		if( zDup == 0 ){
			/* Ignore any memory failure problem */
			jx9_context_throw_error(pRep->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
			return JX9_OK;
		}
		SyMemcpy(zIn, zDup, (sxu32)nByte);
		/* Save the chunk */
		SyStringInitFromBuf(&sWorker, zDup, nByte);
	}
	/* Save for later processing */
	SySetPut(pRep->pCollector, (const void *)&sWorker);
	/* All done */
	SXUNUSED(pKey); /* cc warning */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl (%r15), %esi
testl %esi, %esi
jle 0x5b9d4
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x312d8
testq %rax, %rax
je 0x5b9e3
movq %rax, %r15
movl -0x1c(%rbp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x34893
movq %r15, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x10(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33094
jmp 0x5ba03
movq 0x18(%rbx), %rax
movq (%rax), %rsi
movq 0x60(%rax), %rdi
addq $0x8, %rsi
leaq 0x1a8d7(%rip), %rcx     # 0x762d0
movl $0x1, %edx
callq 0x40afa
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: StringReplace
static int StringReplace(SyBlob *pWorker, sxu32 nOfft, int nLen, const char *zReplace, int nReplen)
{
	char *zInput = (char *)SyBlobData(pWorker);
	sxu32 n, m;
	n = SyBlobLength(pWorker);
	m = nOfft;
	/* Delete the old entry */
	STRDEL(zInput, n, m, nLen);
	SyBlobLength(pWorker) -= nLen;
	if( nReplen > 0 ){
		sxi32 iRep = nReplen;
		sxi32 rc;
		/*
		 * Make sure the working buffer is big enough to hold the replacement
		 * string.
		 */
		rc = SyBlobAppend(pWorker, 0/* Grow without an append operation*/, (sxu32)nReplen);
		if( rc != SXRET_OK ){
			/* Simply ignore any memory failure problem */
			return SXRET_OK;
		}
		/* Perform the insertion now */
		zInput = (char *)SyBlobData(pWorker);
		n = SyBlobLength(pWorker);
		SHIFTRANDINSERT(zInput, n, nOfft, zReplace, iRep);
		SyBlobLength(pWorker) += nReplen;
	}	
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movl %esi, %r12d
movq %rdi, %r15
movl 0x10(%rdi), %eax
leal (%r12,%rdx), %esi
cmpl %eax, %esi
jae 0x5ba53
movq 0x8(%r15), %rcx
movl %esi, %esi
movl %r12d, %edi
movb (%rcx,%rsi), %r8b
movl %edi, %r9d
movb %r8b, (%rcx,%r9)
incl %edi
incq %rsi
cmpl %esi, %eax
ja 0x5ba3b
movl 0x10(%r15), %eax
subl %edx, %eax
movl %eax, 0x10(%r15)
testl %ebx, %ebx
jle 0x5bab4
movq %r15, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x359ad
testl %eax, %eax
jne 0x5bab4
movq 0x8(%r15), %rax
movl 0x10(%r15), %ecx
cmpl %r12d, %ecx
je 0x5ba97
movl %r12d, %edx
subl %ecx, %edx
xorl %esi, %esi
subl $0x1, %ecx
cmovbl %esi, %ecx
movb (%rax,%rcx), %dil
leal (%rcx,%rbx), %r8d
movb %dil, (%rax,%r8)
incl %edx
jne 0x5ba81
leal 0x1(%rbx), %ecx
movb (%r14), %dl
movl %r12d, %esi
movb %dl, (%rax,%rsi)
incl %r12d
incq %r14
decl %ecx
cmpl $0x1, %ecx
jg 0x5ba9a
addl %ebx, 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: StringReplaceWalker
static int StringReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
	str_replace_data *pRepData = (str_replace_data *)pUserData;
	const char *zTarget, *zReplace;
	SyBlob *pWorker;
	int tLen, nLen;
	sxu32 nOfft;
	sxi32 rc;
	/* Point to the working buffer */
	pWorker = pRepData->pWorker;
	if( !jx9_value_is_string(pKey) ){
		/* Target and replace must be a string */
		return JX9_OK;
	}
	/* Extract the target and the replace */
	zTarget = jx9_value_to_string(pKey, &tLen);
	if( tLen < 1 ){
		/* Empty target, return immediately */
		return JX9_OK;
	}
	/* Perform a pattern search */
	rc = pRepData->xMatch(SyBlobData(pWorker), SyBlobLength(pWorker), (const void *)zTarget, (sxu32)tLen, &nOfft);
	if( rc != SXRET_OK ){
		/* Pattern not found */
		return JX9_OK;
	}
	/* Extract the replace string */
	zReplace = jx9_value_to_string(pData, &nLen);
	/* Perform the replace process */
	StringReplace(pWorker, nOfft, tLen, zReplace, nLen);
	/* All done */
	return JX9_OK;
}

// Assembly:
testb $0x1, 0x8(%rdi)
je 0x5bb34
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq (%rdx), %rbx
leaq -0x28(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x5bb28
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
leaq -0x24(%rbp), %r8
movq %rax, %rdx
callq *0x8(%r15)
testl %eax, %eax
jne 0x5bb28
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30577
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl (%r15), %r8d
movq %rbx, %rdi
movq %rax, %rcx
callq 0x5ba10
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_count
static int jx9_hashmap_count(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int bRecursive = FALSE;
	sxi64 iCount;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* TICKET 1433-19: Handle objects */
		int res = !jx9_value_is_null(apArg[0]);
		jx9_result_int(pCtx, res);
		return JX9_OK;
	}
	if( nArg > 1 ){
		/* Recursive count? */
		bRecursive = jx9_value_to_int(apArg[1]) == 1 /* COUNT_RECURSIVE */;
	}
	/* Count */
	iCount = HashmapCount((jx9_hashmap *)apArg[0]->x.pOther, bRecursive, 0);
	jx9_result_int64(pCtx, iCount);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5c8a6
movq %rdx, %r14
movq (%rdx), %rcx
movl 0x8(%rcx), %edx
testb $0x40, %dl
jne 0x5c8bb
xorl %r14d, %r14d
testb $0x20, %dl
sete %r14b
jmp 0x5c8ea
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x5c8f9
movl %esi, %eax
xorl %esi, %esi
cmpl $0x1, %eax
je 0x5c8dd
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x3f362
xorl %esi, %esi
cmpl $0x1, (%r15)
sete %sil
movq (%r14), %rcx
movq (%rcx), %rdi
xorl %edx, %edx
callq 0x5de35
movq %rax, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_key_exists
static int jx9_hashmap_key_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	sxi32 rc;
	if( nArg < 2 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[1]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the lookup */
	rc = jx9HashmapLookup((jx9_hashmap *)apArg[1]->x.pOther, apArg[0], 0);
	/* lookup result */
	jx9_result_bool(pCtx, rc == SXRET_OK ? 1 : 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jle 0x5c92d
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5c942
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x5c967
movq (%rax), %rdi
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x43e84
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_pop
static int jx9_hashmap_pop(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Noting to pop, return NULL */
		jx9_result_null(pCtx);
	}else{
		jx9_hashmap_node *pLast = pMap->pLast;
		jx9_value *pObj;
		pObj = HashmapExtractNodeValue(pLast);
		if( pObj ){
			/* Node value */
			jx9_result_value(pCtx, pObj);
			/* Unlink the node */
			jx9HashmapUnlinkNode(pLast);
		}else{
			jx9_result_null(pCtx);
		}
		/* Reset the cursor */
		pMap->pCur = pMap->pFirst;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x5c9db
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5c9db
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x5c9db
movq 0x18(%r14), %rbx
movq (%rbx), %rax
movl 0x38(%rbx), %ecx
movq (%rax), %rdx
cmpl %ecx, 0x218(%rdx)
jbe 0x5c9eb
movq 0x210(%rdx), %rax
testq %rax, %rax
je 0x5c9eb
imull 0x220(%rdx), %ecx
addq %rcx, %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x3e19f
movq %rbx, %rdi
callq 0x5dee4
jmp 0x5c9f4
movq 0x8(%rdi), %rdi
callq 0x30465
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rdi), %rdi
callq 0x30465
movq 0x10(%r14), %rax
movq %rax, 0x20(%r14)
jmp 0x5c9e4
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_push
static int jx9_hashmap_push(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	sxi32 rc;
	int i;
	if( nArg < 1 ){
		/* Missing arguments, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return 0 */
		jx9_result_int(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Start pushing given values */
	for( i = 1 ; i < nArg ; ++i ){
		rc = jx9HashmapInsert(pMap, 0, apArg[i]);
		if( rc != SXRET_OK ){
			break;
		}
	}
	/* Return the new count */
	jx9_result_int64(pCtx, (sxi64)pMap->nEntry);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5ca1f
movq %rdx, %r14
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5ca24
xorl %r14d, %r14d
jmp 0x5ca59
movq (%rax), %r15
cmpl $0x1, %esi
je 0x5ca55
movl %esi, %r12d
addq $-0x2, %r12
xorl %r13d, %r13d
movq 0x8(%r14,%r13,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ef1d
testl %eax, %eax
jne 0x5ca55
leaq 0x1(%r13), %rax
cmpq %r13, %r12
movq %rax, %r13
jne 0x5ca36
movl 0x2c(%r15), %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_shift
static int jx9_hashmap_shift(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return null */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry < 1 ){
		/* Empty hashmap, return NULL */
		jx9_result_null(pCtx);
	}else{
		jx9_hashmap_node *pEntry = pMap->pFirst;
		jx9_value *pObj;
		sxu32 n;
		pObj = HashmapExtractNodeValue(pEntry);
		if( pObj ){
			/* Node value */
			jx9_result_value(pCtx, pObj);
			/* Unlink the first node */
			jx9HashmapUnlinkNode(pEntry);
		}else{
			jx9_result_null(pCtx);
		}
		/* Rehash all int keys */
		n = pMap->nEntry;
		pEntry = pMap->pFirst;
		pMap->iNextIdx = 0; /* Reset the automatic index */
		for(;;){
			if( n < 1 ){
				break;
			}
			if( pEntry->iType == HASHMAP_INT_NODE ){
				HashmapRehashIntNode(pEntry);
			}
			/* Point to the next entry */
			pEntry = pEntry->pPrev; /* Reverse link */
			n--;
		}
		/* Reset the cursor */
		pMap->pCur = pMap->pFirst;
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5cae9
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5cae9
movq (%rax), %r14
cmpl $0x0, 0x2c(%r14)
je 0x5cae9
movq 0x10(%r14), %rbx
movq (%rbx), %rax
movl 0x38(%rbx), %ecx
movq (%rax), %rdx
cmpl %ecx, 0x218(%rdx)
jbe 0x5caff
movq 0x210(%rdx), %rax
testq %rax, %rax
je 0x5caff
imull 0x220(%rdx), %ecx
addq %rcx, %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x3e19f
movq %rbx, %rdi
callq 0x5dee4
jmp 0x5cb08
movq 0x8(%rdi), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rdi), %rdi
callq 0x30465
movl 0x2c(%r14), %r15d
movq 0x10(%r14), %rbx
movq $0x0, 0x48(%r14)
testl %r15d, %r15d
je 0x5cb38
cmpl $0x1, 0x8(%rbx)
jne 0x5cb2b
movq %rbx, %rdi
callq 0x5dfcc
movq 0x48(%rbx), %rbx
decl %r15d
jne 0x5cb1d
movq 0x10(%r14), %rbx
movq %rbx, 0x20(%r14)
jmp 0x5caf2
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_values
static int jx9_hashmap_values(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pNode;
	jx9_hashmap *pMap;
	jx9_value *pArray;
	jx9_value *pObj;
	sxu32 n;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation that describe the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Perform the requested operation */
	pNode = pMap->pFirst;
	for( n = 0 ; n < pMap->nEntry ; ++n ){
		pObj = HashmapExtractNodeValue(pNode);
		if( pObj ){
			/* perform the insertion */
			jx9_array_add_elem(pArray, 0/* Automatic index assign */, pObj);
		}
		/* Point to the next entry */
		pNode = pNode->pPrev; /* Reverse link */
	}
	/* return the new array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5d053
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5d053
movq (%rax), %r15
movq %rbx, %rdi
callq 0x31231
testq %rax, %rax
je 0x5d053
movq %rax, %r14
movl 0x2c(%r15), %eax
testl %eax, %eax
je 0x5d045
leaq 0x10(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %r12
movq (%r12), %rdx
movl 0x38(%r12), %ecx
movq (%rdx), %rsi
cmpl %ecx, 0x218(%rsi)
jbe 0x5d039
movq 0x210(%rsi), %rdx
testq %rdx, %rdx
je 0x5d039
testb $0x40, 0x8(%r14)
je 0x5d039
imull 0x220(%rsi), %ecx
addq %rcx, %rdx
movq (%r14), %rdi
xorl %esi, %esi
callq 0x3ef1d
movl 0x2c(%r15), %eax
addq $0x48, %r12
incl %r13d
cmpl %eax, %r13d
jb 0x5cff6
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3e19f
jmp 0x5d05c
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_same
static int jx9_hashmap_same(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *p1, *p2;
	int rc;
	if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
		/* Missing or invalid arguments, return FALSE*/
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the hashmaps */
	p1 = (jx9_hashmap *)apArg[0]->x.pOther;
	p2 = (jx9_hashmap *)apArg[1]->x.pOther;
	rc = (p1 == p2);
	/* Same instance? */
	jx9_result_bool(pCtx, rc);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %esi
jl 0x5d08c
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5d08c
movq 0x8(%rdx), %rcx
testb $0x40, 0x8(%rcx)
jne 0x5d0b4
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rax), %rax
xorl %r14d, %r14d
cmpq (%rcx), %rax
sete %r14b
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5d09f
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_merge
static int jx9_hashmap_merge(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap, *pSrc;
	jx9_value *pArray;
	int i;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)pArray->x.pOther;
	/* Start merging */
	for( i = 0 ; i < nArg ; i++ ){
		/* Make sure we are dealing with a valid hashmap */
		if( !jx9_value_is_json_array(apArg[i]) ){
			/* Insert scalar value */
			jx9_array_add_elem(pArray, 0, apArg[i]);
		}else{
			pSrc = (jx9_hashmap *)apArg[i]->x.pOther;
			/* Merge the two hashmaps */
			HashmapMerge(pSrc, pMap);
		}
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
testl %esi, %esi
jle 0x5d267
movq %rdx, %r15
movl %esi, %ebx
movq %r14, %rdi
callq 0x31231
testq %rax, %rax
je 0x5d267
movq %rax, %r12
movq %r14, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl %ebx, %ebx
xorl %r14d, %r14d
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movq (%r15,%r14,8), %rdx
testb $0x40, 0x8(%rdx)
jne 0x5d149
testb $0x40, 0x8(%r12)
je 0x5d249
movq (%r12), %rdi
xorl %esi, %esi
callq 0x3ef1d
jmp 0x5d249
movq %r14, -0x58(%rbp)
movq (%rdx), %r14
cmpq -0x30(%rbp), %r14
je 0x5d239
cmpl $0x0, 0x2c(%r14)
je 0x5d239
leaq 0x10(%r14), %r13
xorl %r12d, %r12d
movq %r14, -0x60(%rbp)
movq (%r13), %r13
movq (%r13), %rax
movl 0x38(%r13), %ebx
movq (%rax), %rax
cmpl %ebx, 0x218(%rax)
jbe 0x5d197
imull 0x220(%rax), %ebx
addq 0x210(%rax), %rbx
jmp 0x5d199
xorl %ebx, %ebx
cmpl $0x2, 0x8(%r13)
jne 0x5d214
movq -0x30(%rbp), %r15
movq (%r15), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0xa0(%rbp)
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rcx
movups %xmm0, (%rcx)
movq %rax, -0x88(%rbp)
movl $0x1, -0x98(%rbp)
movq 0x18(%r13), %rsi
movl 0x20(%r13), %edx
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x3edf3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3ef1d
movl %eax, %ebx
movq %r14, %rdi
movq -0x60(%rbp), %r14
callq 0x30465
jmp 0x5d224
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3ef1d
movl %eax, %ebx
testl %ebx, %ebx
jne 0x5d239
addq $0x48, %r13
incl %r12d
cmpl 0x2c(%r14), %r12d
jb 0x5d170
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %rbx
movq -0x58(%rbp), %r14
incq %r14
cmpq %rbx, %r14
jne 0x5d123
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
callq 0x3e19f
jmp 0x5d270
movq 0x8(%r14), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_diff
static int jx9_hashmap_diff(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pEntry;
	jx9_hashmap *pSrc, *pMap;
	jx9_value *pArray;
	jx9_value *pVal;
	sxi32 rc;
	sxu32 n;
	int i;
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	if( nArg == 1 ){
		/* Return the first array since we cannot perform a diff */
		jx9_result_value(pCtx, apArg[0]);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the source hashmap */
	pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Perform the diff */
	pEntry = pSrc->pFirst;
	n = pSrc->nEntry;
	for(;;){
		if( n < 1 ){
			break;
		}
		/* Extract the node value */
		pVal = HashmapExtractNodeValue(pEntry);
		if( pVal ){
			for( i = 1 ; i < nArg ; i++ ){
				if( !jx9_value_is_json_array(apArg[i])) {
					/* ignore */
					continue;
				}
				/* Point to the internal representation of the hashmap */
				pMap = (jx9_hashmap *)apArg[i]->x.pOther;
				/* Perform the lookup */
				rc = HashmapFindValue(pMap, pVal, 0, TRUE);
				if( rc == SXRET_OK ){
					/* Value exist */
					break;
				}
			}
			if( i >= nArg ){
				/* Perform the insertion */
				HashmapInsertNode((jx9_hashmap *)pArray->x.pOther, pEntry, TRUE);
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
		n--;
	}
	/* Return the freshly created array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x5d2a5
movl %esi, %r13d
movq (%rdx), %rsi
testb $0x40, 0x8(%rsi)
jne 0x5d2bf
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %r13d
jne 0x5d2cf
movq %rbx, %rdi
callq 0x307f4
jmp 0x5d2ae
movq %rdx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x31231
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x5d2a5
movq %rbx, -0x40(%rbp)
movq -0x30(%rbp), %rdx
movq (%rdx), %rax
movq (%rax), %r12
movl 0x2c(%r12), %r15d
testl %r15d, %r15d
je 0x5d381
addq $0x10, %r12
movl %r13d, %ebx
movq (%r12), %r12
movq (%r12), %rcx
movl 0x38(%r12), %eax
movq (%rcx), %rcx
cmpl %eax, 0x218(%rcx)
jbe 0x5d378
movq 0x210(%rcx), %r13
testq %r13, %r13
je 0x5d378
imull 0x220(%rcx), %eax
addq %rax, %r13
movl $0x1, %r14d
movq (%rdx,%r14,8), %rax
testb $0x40, 0x8(%rax)
je 0x5d35d
movq (%rax), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x5e063
movq -0x30(%rbp), %rdx
testl %eax, %eax
je 0x5d378
incq %r14
cmpq %r14, %rbx
jne 0x5d33b
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq %r12, %rsi
callq 0x5e196
movq -0x30(%rbp), %rdx
addq $0x48, %r12
decl %r15d
jne 0x5d307
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rdi
callq 0x3e19f
jmp 0x5d2ae
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_in_array
static int jx9_hashmap_in_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pNeedle;
	int bStrict;
	int rc;
	if( nArg < 2 ){
		/* Missing argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pNeedle = apArg[0];
	bStrict = 0;
	if( nArg > 2 ){
		bStrict = jx9_value_to_bool(apArg[2]);
	}
	if( !jx9_value_is_json_array(apArg[1]) ){
		/* haystack must be an array, perform a standard comparison */ 
		rc = jx9_value_compare(pNeedle, apArg[1], bStrict);
		/* Set the comparison result */
		jx9_result_bool(pCtx, rc == 0);
		return JX9_OK;
	}
	/* Perform the lookup */
	rc = HashmapFindValue((jx9_hashmap *)apArg[1]->x.pOther, pNeedle, 0, bStrict);
	/* Lookup result */
	jx9_result_bool(pCtx, rc == SXRET_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x5d4d5
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x5d52e
movq %rdx, %r15
movq (%rdx), %r14
xorl %edx, %edx
cmpl $0x2, %esi
je 0x5d4f2
movq 0x10(%r15), %r12
movq %r12, %rdi
callq 0x438dd
movl (%r12), %edx
movq 0x8(%r15), %rsi
testb $0x40, 0x8(%rsi)
jne 0x5d50b
testq %r14, %r14
je 0x5d547
movq %r14, %rdi
callq 0x44270
jmp 0x5d516
movq (%rsi), %rdi
movq %r14, %rsi
callq 0x5e063
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x5d51f
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_copy
static int jx9_hashmap_copy(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	jx9_value *pArray;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Point to the internal representation of the hashmap */
	pMap = (jx9_hashmap *)pArray->x.pOther;
	if( jx9_value_is_json_array(apArg[0])){
		/* Point to the internal representation of the source */
		jx9_hashmap *pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
		/* Perform the copy */
		jx9HashmapDup(pSrc, pMap);
	}else{
		/* Simple insertion */
		jx9HashmapInsert(pMap, 0/* Automatic index assign*/, apArg[0]); 
	}
	/* Return the duplicated array */
	jx9_result_value(pCtx, pArray);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5d588
movq %rdx, %r15
movq %rbx, %rdi
callq 0x31231
testq %rax, %rax
je 0x5d588
movq %rax, %r14
movq (%rax), %rsi
movq (%r15), %rdx
testb $0x40, 0x8(%rdx)
jne 0x5d593
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3ef1d
jmp 0x5d59b
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x5d5a7
movq (%rdx), %rdi
callq 0x44b13
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3e19f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_erase
static int jx9_hashmap_erase(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the target hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Erase */
	jx9HashmapRelease(pMap, FALSE);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5d5cd
movq (%rdx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3e379
jmp 0x5d5ee
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_walk
static int jx9_hashmap_walk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_value *pValue, *pUserData, sKey;
	jx9_hashmap_node *pEntry;
	jx9_hashmap *pMap;
	sxi32 rc;
	sxu32 n;
	if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid/Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pUserData = nArg > 2 ? apArg[2] : 0;
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	jx9MemObjInit(pMap->pVm, &sKey);
	/* Perform the desired operation */
	pEntry = pMap->pFirst;
	for( n = 0 ; n < pMap->nEntry ; n++ ){
		/* Extract the node value */
		pValue = HashmapExtractNodeValue(pEntry);
		if( pValue ){
			/* Extract the entry key */
			jx9HashmapExtractNodeKey(pEntry, &sKey);
			/* Invoke the supplied callback */
			rc = jx9VmCallUserFunctionAp(pMap->pVm, apArg[1], 0, pValue, &sKey, pUserData, 0);
			jx9MemObjRelease(&sKey);
			if( rc != SXRET_OK ){
				/* An error occured while invoking the supplied callback [i.e: not defined] */
				jx9_result_bool(pCtx, 0); /* return FALSE */
				return JX9_OK;
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x2, %esi
jl 0x5d7da
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5d7f2
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x5d8e1
cmpl $0x2, %esi
movq %rdi, -0x30(%rbp)
movq %rdx, -0x40(%rbp)
jne 0x5d809
movq $0x0, -0x38(%rbp)
jmp 0x5d811
movq 0x10(%rdx), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rbx
movq (%rbx), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movq %rax, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movl $0x20, -0x78(%rbp)
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0x5d8ca
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq (%r12), %r12
movq (%r12), %rdx
movl 0x38(%r12), %ecx
movq (%rdx), %rdx
cmpl %ecx, 0x218(%rdx)
jbe 0x5d8be
movq 0x210(%rdx), %r15
testq %r15, %r15
je 0x5d8be
imull 0x220(%rdx), %ecx
addq %rcx, %r15
movq %r12, %rdi
leaq -0x80(%rbp), %r14
movq %r14, %rsi
callq 0x3e2fe
movq (%rbx), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x0, (%rsp)
movq %r15, %rcx
movq %r14, %r8
movq -0x38(%rbp), %r9
xorl %eax, %eax
callq 0x5e1e6
movl %eax, %r15d
movq %r14, %rdi
callq 0x30465
testl %r15d, %r15d
jne 0x5d900
movl 0x2c(%rbx), %eax
addq $0x48, %r12
incl %r13d
cmpl %eax, %r13d
jb 0x5d84b
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rbx
jmp 0x5d7de
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_sort
static int jx9_hashmap_sort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	/* Make sure we are dealing with a valid hashmap */
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry > 1 ){
		sxi32 iCmpFlags = 0;
		if( nArg > 1 ){
			/* Extract comparison flags */
			iCmpFlags = jx9_value_to_int(apArg[1]);
			if( iCmpFlags == 3 /* SORT_REGULAR */ ){
				iCmpFlags = 0; /* Standard comparison */
			}
		}
		/* Do the merge sort */
		HashmapMergeSort(pMap, HashmapCmpCallback1, SX_INT_TO_PTR(iCmpFlags));
		/* Rehash [Do not maintain index association as requested by the JX9 specification] */
		HashmapSortRehash(pMap);
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x5d928
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5d953
xorl %r12d, %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r12, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %r14
movl $0x1, %r12d
cmpl $0x2, 0x2c(%r14)
jb 0x5d92b
cmpl $0x1, %esi
jne 0x5d96c
xorl %edx, %edx
jmp 0x5d987
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x3f362
movl (%r15), %eax
xorl %edx, %edx
cmpq $0x3, %rax
cltq
cmovneq %rax, %rdx
leaq 0xa77(%rip), %rsi       # 0x5e405
movq %r14, %rdi
callq 0x5e30e
movq %r14, %rdi
callq 0x5e52a
jmp 0x5d92b
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_usort
static int jx9_hashmap_usort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	/* Make sure we are dealing with a valid hashmap */
	if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->nEntry > 1 ){
		jx9_value *pCallback = 0;
		ProcNodeCmp xCmp;
		xCmp = HashmapCmpCallback4; /* User-defined function as the comparison callback */
		if( nArg > 1 && jx9_value_is_callable(apArg[1]) ){
			/* Point to the desired callback */
			pCallback = apArg[1];
		}else{
			/* Use the default comparison function */
			xCmp = HashmapCmpCallback1;
		}
		/* Do the merge sort */
		HashmapMergeSort(pMap, xCmp, pCallback);
		/* Rehash [Do not maintain index association as requested by the JX9 specification] */
		HashmapSortRehash(pMap);
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x5da51
movq %rdx, %r15
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5da7c
xorl %r12d, %r12d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r12, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %r14
movl $0x1, %r12d
cmpl $0x2, 0x2c(%r14)
jb 0x5da54
cmpl $0x1, %esi
je 0x5dab2
movq 0x8(%r15), %rsi
movq 0x10(%rsi), %rdi
callq 0x511d0
testl %eax, %eax
je 0x5dab2
movq 0x8(%r15), %rdx
leaq 0xcc3(%rip), %rsi       # 0x5e770
movq %r14, %rdi
jmp 0x5dabe
leaq 0x94c(%rip), %rsi       # 0x5e405
movq %r14, %rdi
xorl %edx, %edx
callq 0x5e30e
movq %r14, %rdi
callq 0x5e52a
jmp 0x5da54
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_current
static int jx9_hashmap_current(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5dae0
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5db03
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5db0d
movq (%rax), %rsi
xorl %edx, %edx
callq 0x5e82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_next
static int jx9_hashmap_next(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, 1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5dca3
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5dcc6
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5dcd3
movq (%rax), %rsi
movl $0x1, %edx
callq 0x5e82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_prev
static int jx9_hashmap_prev(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, -1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5dcef
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5dd12
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5dd1f
movq (%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_end
static int jx9_hashmap_end(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Point to the last node */
	pMap->pCur = pMap->pLast;
	/* Return the last node value */
	HashmapCurrentValue(&(*pCtx), pMap, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5dd3b
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5dd5e
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5dd70
movq (%rax), %rsi
movq 0x18(%rsi), %rax
movq %rax, 0x20(%rsi)
xorl %edx, %edx
callq 0x5e82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_reset
static int jx9_hashmap_reset(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the internal representation of the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	/* Point to the first node */
	pMap->pCur = pMap->pFirst;
	/* Return the last node value if available */
	HashmapCurrentValue(&(*pCtx), pMap, 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x5dd8c
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x5ddaf
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
jmp 0x5ddc1
movq (%rax), %rsi
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsi)
xorl %edx, %edx
callq 0x5e82d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_simple_key
static int jx9_hashmap_simple_key(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pCur;
	jx9_hashmap *pMap;
	if( nArg < 1 ){
		/* Missing arguments, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	pCur = pMap->pCur;
	if( pCur == 0 ){
		/* Cursor does not point to anything, return NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	if( pCur->iType == HASHMAP_INT_NODE){
		/* Key is integer */
		jx9_result_int64(pCtx, pCur->xKey.iKey);
	}else{
		/* Key is blob */
		jx9_result_string(pCtx, 
			(const char *)SyBlobData(&pCur->xKey.sKey), (int)SyBlobLength(&pCur->xKey.sKey));
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x5de13
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x5de13
movq (%rax), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x5de13
cmpl $0x1, 0x8(%rax)
jne 0x5de23
movq 0x10(%rax), %r14
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
jmp 0x5de1c
movq 0x8(%rdi), %rdi
callq 0x30465
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%rax), %rsi
movl 0x20(%rax), %edx
movq 0x8(%rdi), %rdi
callq 0x302f6
jmp 0x5de1c
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapCount
static sxi64 HashmapCount(jx9_hashmap *pMap, int bRecursive, int iRecCount)
{
	sxi64 iCount = 0;
	if( !bRecursive ){
		iCount = pMap->nEntry;
	}else{
		/* Recursive hashmap walk */
		jx9_hashmap_node *pEntry = pMap->pLast;
		jx9_value *pElem;
		sxu32 n = 0;
		for(;;){
			if( n >= pMap->nEntry ){
				break;
			}
			/* Point to the element value */
			pElem = (jx9_value *)SySetAt(&pMap->pVm->aMemObj, pEntry->nValIdx);
			if( pElem ){
				if( pElem->iFlags & MEMOBJ_HASHMAP ){
					if( iRecCount > 31 ){
						/* Nesting limit reached */
						return iCount;
					}
					/* Recurse */
					iRecCount++;
					iCount += HashmapCount((jx9_hashmap *)pElem->x.pOther, TRUE, iRecCount);
					iRecCount--;
				}
			}
			/* Point to the next entry */
			pEntry = pEntry->pNext;
			++n;
		}
		/* Update count */
		iCount += pMap->nEntry;
	}
	return iCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl 0x2c(%rdi), %eax
testl %esi, %esi
je 0x5dec6
testl %eax, %eax
movq %rax, -0x40(%rbp)
je 0x5decb
movq %rdi, %r14
movq (%rdi), %r12
addq $0x18, %r14
movl 0x218(%r12), %r13d
movq -0x38(%rbp), %rcx
incl %ecx
movl %ecx, -0x2c(%rbp)
xorl %r15d, %r15d
movl %eax, %ebx
movq (%r14), %r14
movl 0x38(%r14), %eax
cmpl %eax, %r13d
jbe 0x5debc
movq 0x210(%r12), %rcx
testq %rcx, %rcx
je 0x5debc
imull 0x220(%r12), %eax
testb $0x40, 0x8(%rcx,%rax)
je 0x5debc
cmpl $0x1f, -0x38(%rbp)
jg 0x5ded2
movq (%rcx,%rax), %rdi
movl $0x1, %esi
movl -0x2c(%rbp), %edx
callq 0x5de35
addq %rax, %r15
addq $0x40, %r14
decl %ebx
jne 0x5de79
jmp 0x5dece
movq %rax, %r15
jmp 0x5ded2
xorl %r15d, %r15d
addq -0x40(%rbp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq