LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x50881
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x50881
cmpl $0x2, %esi
movq %rdi, -0x30(%rbp)
movq %rdx, -0x40(%rbp)
jne 0x507f7
movq $0x0, -0x38(%rbp)
jmp 0x507ff
movq 0x10(%rdx), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %r15
movq (%r15), %rdi
leaq -0x80(%rbp), %r12
movq %r12, %rsi
callq 0x35772
leaq 0x10(%r15), %r13
xorl %r14d, %r14d
cmpl 0x2c(%r15), %r14d
jae 0x50874
movq (%r13), %r13
movq %r13, %rdi
callq 0x35e71
testq %rax, %rax
je 0x5086b
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x35e0a
movq (%r15), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
andl $0x0, (%rsp)
movq %rbx, %rcx
movq %r12, %r8
movq -0x38(%rbp), %r9
xorl %eax, %eax
callq 0x50f6f
movl %eax, %ebx
movq %r12, %rdi
callq 0x296af
testl %ebx, %ebx
jne 0x5087d
addq $0x48, %r13
incl %r14d
jmp 0x50818
pushq $0x1
popq %rsi
movq -0x30(%rbp), %rdi
jmp 0x50883
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x68, %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_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
xorl %r14d, %r14d
testl %esi, %esi
jle 0x508fa
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x508fa
movq (%rax), %r15
pushq $0x1
popq %r14
cmpl $0x2, 0x2c(%r15)
jb 0x508fa
xorl %r12d, %r12d
cmpl $0x1, %esi
je 0x508e0
movq 0x8(%rdx), %rdi
callq 0x29772
cmpl $0x3, %eax
cmovnel %eax, %r12d
movslq %r12d, %r12
leaq 0x882(%rip), %rsi       # 0x51169
movq %r15, %rdi
movq %r12, %rdx
callq 0x51087
movq %r15, %rdi
callq 0x5126a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
jle 0x509f4
movq %rdx, %r13
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x509f4
movq (%rax), %r15
pushq $0x1
popq %r14
cmpl $0x2, 0x2c(%r15)
jb 0x509f4
leaq 0x7a9(%rip), %r12       # 0x51169
cmpl $0x1, %esi
je 0x509df
movq 0x8(%r13), %rdi
callq 0x29aa1
testl %eax, %eax
je 0x509df
movq 0x8(%r13), %rdx
leaq 0xa80(%rip), %r12       # 0x5145d
jmp 0x509e1
xorl %edx, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x51087
movq %r15, %rdi
callq 0x5126a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x298b2
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_O2/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
testl %esi, %esi
jle 0x50a21
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x50a2a
xorl %esi, %esi
callq 0x298b2
jmp 0x50a34
movq (%rax), %rsi
xorl %edx, %edx
callq 0x514f0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_each
static int jx9_hashmap_each(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_hashmap_node *pCur;
	jx9_hashmap *pMap;
	jx9_value *pArray;
	jx9_value *pVal;
	jx9_value sKey;
	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 that describe the input hashmap */
	pMap = (jx9_hashmap *)apArg[0]->x.pOther;
	if( pMap->pCur == 0 ){
		/* Cursor does not point to anything, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pCur = pMap->pCur;
	/* Create a new array */
	pArray = jx9_context_new_array(pCtx);
	if( pArray == 0 ){
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	pVal = HashmapExtractNodeValue(pCur);
	/* Insert the current value */
	jx9_array_add_strkey_elem(pArray, "1", pVal);
	jx9_array_add_strkey_elem(pArray, "value", pVal);
	/* Make the key */
	if( pCur->iType == HASHMAP_INT_NODE ){
		jx9MemObjInitFromInt(pMap->pVm, &sKey, pCur->xKey.iKey);
	}else{
		jx9MemObjInitFromString(pMap->pVm, &sKey, 0);
		jx9MemObjStringAppend(&sKey, (const char *)SyBlobData(&pCur->xKey.sKey), SyBlobLength(&pCur->xKey.sKey));
	}
	/* Insert the current key */
	jx9_array_add_elem(pArray, 0, &sKey);
	jx9_array_add_strkey_elem(pArray, "key", &sKey);
	jx9MemObjRelease(&sKey);
	/* Advance the cursor */
	pMap->pCur = pCur->pPrev; /* Reverse link */
	/* Return the current entry */
	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 $0x48, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x50abe
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x50abe
movq (%rax), %r13
movq 0x20(%r13), %r14
testq %r14, %r14
je 0x50abe
movq %rbx, %rdi
callq 0x2a2b0
testq %rax, %rax
je 0x50abe
movq %rax, %r15
movq %r14, %rdi
callq 0x35e71
movq %rax, %r12
leaq 0x15c35(%rip), %rsi     # 0x666bc
movq %r15, %rdi
movq %rax, %rdx
callq 0x29c6c
leaq 0x13a21(%rip), %rsi     # 0x644ba
movq %r15, %rdi
movq %r12, %rdx
callq 0x29c6c
cmpl $0x1, 0x8(%r14)
movq (%r13), %rdi
jne 0x50ad9
movq 0x10(%r14), %rdx
leaq -0x68(%rbp), %rsi
callq 0x3c0cd
jmp 0x50af7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x68(%rbp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x3bbfe
movq 0x18(%r14), %rsi
movl 0x20(%r14), %edx
movq %r12, %rdi
callq 0x3689a
leaq -0x68(%rbp), %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x29c4b
leaq 0x152f2(%rip), %rsi     # 0x65e01
movq %r15, %rdi
movq %r12, %rdx
callq 0x29c6c
movq %r12, %rdi
callq 0x296af
movq 0x48(%r14), %rax
movq %rax, 0x20(%r13)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x299d3
jmp 0x50ac8
// File: /workspace/github_c_makefile_star2_O2/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
testl %esi, %esi
jle 0x50b48
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x50b51
xorl %esi, %esi
callq 0x298b2
jmp 0x50b5c
movq (%rax), %rsi
pushq $0x1
popq %rdx
callq 0x514f0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
testl %esi, %esi
jle 0x50b71
movq (%rdx), %rax
testb $0x40, 0x8(%rax)
jne 0x50b7a
xorl %esi, %esi
callq 0x298b2
jmp 0x50b85
movq (%rax), %rsi
pushq $-0x1
popq %rdx
callq 0x514f0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r15
testl %esi, %esi
je 0x50cb8
movl %edx, %r14d
leaq 0x18(%r15), %r13
movl 0x2c(%r15), %eax
leal 0x1(%r14), %ecx
movl %ecx, -0x2c(%rbp)
xorl %ebx, %ebx
movq %rax, -0x38(%rbp)
movl %eax, %r12d
subl $0x1, %r12d
jb 0x50cb2
movq (%r13), %r13
movq (%r15), %rdx
movl 0x38(%r13), %eax
cmpl %eax, 0x218(%rdx)
jbe 0x50cac
movq 0x210(%rdx), %rcx
testq %rcx, %rcx
je 0x50cac
imull 0x220(%rdx), %eax
testb $0x40, 0x8(%rcx,%rax)
je 0x50cac
cmpl $0x1f, %r14d
jg 0x50cbc
movq (%rcx,%rax), %rdi
pushq $0x1
popq %rsi
movl -0x2c(%rbp), %edx
callq 0x50c2e
addq %rax, %rbx
addq $0x40, %r13
jmp 0x50c61
addq -0x38(%rbp), %rbx
jmp 0x50cbc
movl 0x2c(%r15), %ebx
movq %rbx, %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: jx9HashmapUnlinkNode
static void jx9HashmapUnlinkNode(jx9_hashmap_node *pNode)
{
	jx9_hashmap *pMap = pNode->pMap;
	jx9_vm *pVm = pMap->pVm;
	/* Unlink from the corresponding bucket */
	if( pNode->pPrevCollide == 0 ){
		pMap->apBucket[pNode->nHash & (pMap->nSize - 1)] = pNode->pNextCollide;
	}else{
		pNode->pPrevCollide->pNextCollide = pNode->pNextCollide;
	}
	if( pNode->pNextCollide ){
		pNode->pNextCollide->pPrevCollide = pNode->pPrevCollide;
	}
	if( pMap->pFirst == pNode ){
		pMap->pFirst = pNode->pPrev;
	}
	if( pMap->pCur == pNode ){
		/* Advance the node cursor */
		pMap->pCur = pMap->pCur->pPrev; /* Reverse link */
	}
	/* Unlink from the map list */
	MACRO_LD_REMOVE(pMap->pLast, pNode);
	/* Restore to the free list */
	jx9VmUnsetMemObj(pVm, pNode->nValIdx);	
	if( pNode->iType == HASHMAP_BLOB_NODE ){
		SyBlobRelease(&pNode->xKey.sKey);
	}
	SyMemBackendPoolFree(&pVm->sAllocator, pNode);
	pMap->nEntry--;
	if( pMap->nEntry < 1 ){
		/* Free the hash-bucket */
		SyMemBackendFree(&pVm->sAllocator, pMap->apBucket);
		pMap->apBucket = 0;
		pMap->nSize = 0;
		pMap->pFirst = pMap->pLast = pMap->pCur = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
testq %rcx, %rcx
je 0x50cf1
addq $0x50, %rcx
jmp 0x50d02
movl 0x28(%r15), %ecx
decl %ecx
andl 0x34(%rbx), %ecx
shlq $0x3, %rcx
addq 0x8(%r15), %rcx
movq (%r15), %r14
movq %rax, (%rcx)
testq %rax, %rax
je 0x50d15
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%rax)
cmpq %rbx, 0x10(%r15)
jne 0x50d23
movq 0x48(%rbx), %rax
movq %rax, 0x10(%r15)
movq 0x20(%r15), %rax
cmpq %rbx, %rax
jne 0x50d34
movq 0x48(%rax), %rax
movq %rax, 0x20(%r15)
movq 0x18(%r15), %rax
cmpq %rbx, %rax
jne 0x50d45
movq 0x40(%rax), %rax
movq %rax, 0x18(%r15)
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x50d56
movq %rax, 0x40(%rcx)
testq %rax, %rax
je 0x50d5f
movq %rcx, 0x48(%rax)
movl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x35f66
cmpl $0x2, 0x8(%rbx)
jne 0x50d79
leaq 0x10(%rbx), %rdi
callq 0x2a72f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27bf8
decl 0x2c(%r15)
jne 0x50da8
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2d420
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
andl $0x0, 0x28(%r15)
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: HashmapRehashIntNode
static void HashmapRehashIntNode(jx9_hashmap_node *pEntry)
{
	jx9_hashmap *pMap = pEntry->pMap;
	sxu32 nBucket;
	/* Remove old collision links */
	if( pEntry->pPrevCollide ){
		pEntry->pPrevCollide->pNextCollide = pEntry->pNextCollide;
	}else{
		pMap->apBucket[pEntry->nHash & (pMap->nSize - 1)] = pEntry->pNextCollide;
	}
	if( pEntry->pNextCollide ){
		pEntry->pNextCollide->pPrevCollide = pEntry->pPrevCollide;
	}
	pEntry->pNextCollide = pEntry->pPrevCollide = 0;
	/* Compute the new hash */
	pEntry->nHash = pMap->xIntHash(pMap->iNextIdx);
	pEntry->xKey.iKey = pMap->iNextIdx;
	nBucket = pEntry->nHash & (pMap->nSize - 1);
	/* Link to the new bucket */
	pEntry->pNextCollide = pMap->apBucket[nBucket];
	if( pMap->apBucket[nBucket] ){
		pMap->apBucket[nBucket]->pPrevCollide = pEntry;
	}
	pEntry->pNextCollide = pMap->apBucket[nBucket];
	pMap->apBucket[nBucket] = pEntry;
	/* Increment the automatic index */
	pMap->iNextIdx++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
testq %rcx, %rcx
je 0x50dd3
addq $0x50, %rcx
jmp 0x50de4
movl 0x28(%r14), %ecx
decl %ecx
andl 0x34(%rbx), %ecx
shlq $0x3, %rcx
addq 0x8(%r14), %rcx
movq %rax, (%rcx)
leaq 0x50(%rbx), %rcx
testq %rax, %rax
je 0x50df8
movq 0x58(%rbx), %rdx
movq %rdx, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq 0x48(%r14), %rdi
callq *0x30(%r14)
movl %eax, 0x34(%rbx)
movq 0x48(%r14), %rcx
movq %rcx, 0x10(%rbx)
movl 0x28(%r14), %edx
decl %edx
andl %eax, %edx
movq 0x8(%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x50(%rbx)
testq %rsi, %rsi
je 0x50e34
movq %rbx, 0x58(%rsi)
movq (%rax,%rdx,8), %rsi
jmp 0x50e36
xorl %esi, %esi
movq %rsi, 0x50(%rbx)
movq %rbx, (%rax,%rdx,8)
incq %rcx
movq %rcx, 0x48(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapFindValue
static int HashmapFindValue(
	jx9_hashmap *pMap,   /* Target hashmap */
	jx9_value *pNeedle,  /* Lookup key */
	jx9_hashmap_node **ppNode, /* OUT: target node on success  */
	int bStrict      /* TRUE for strict comparison */
	)
{
	jx9_hashmap_node *pEntry;
	jx9_value sVal, *pVal;
	jx9_value sNeedle;
	sxi32 rc;
	sxu32 n;
	/* Perform a linear search since we cannot sort the hashmap based on values */
	pEntry = pMap->pFirst;
	n = pMap->nEntry;
	jx9MemObjInit(pMap->pVm, &sVal);
	jx9MemObjInit(pMap->pVm, &sNeedle);
	for(;;){
		if( n < 1 ){
			break;
		}
		/* Extract node value */
		pVal = HashmapExtractNodeValue(pEntry);
		if( pVal ){
			if( (pVal->iFlags|pNeedle->iFlags) & MEMOBJ_NULL ){
				sxi32 iF1 = pVal->iFlags;
				sxi32 iF2 = pNeedle->iFlags;
				if( iF1 == iF2 ){
					/* NULL values are equals */
					if( ppNode ){
						*ppNode = pEntry;
					}
					return SXRET_OK;
				}
			}else{
				/* Duplicate value */
				jx9MemObjLoad(pVal, &sVal);
				jx9MemObjLoad(pNeedle, &sNeedle);
				rc = jx9MemObjCmp(&sNeedle, &sVal, bStrict, 0);
				jx9MemObjRelease(&sVal);
				jx9MemObjRelease(&sNeedle);
				if( rc == 0 ){
					if( ppNode ){
						*ppNode = pEntry;
					}
					/* Match found*/
					return SXRET_OK;
				}
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pPrev; /* Reverse link */
		n--;
	}
	/* No such entry */
	return SXERR_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %rbx
movq %rdi, %r13
movq (%rdi), %rdi
movq 0x10(%r13), %r15
movl 0x2c(%r13), %r12d
leaq -0x70(%rbp), %rsi
callq 0x35772
movq (%r13), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x35772
subl $0x1, %r12d
jb 0x50f06
movq %r15, %rdi
callq 0x35e71
testq %rax, %rax
je 0x50f00
movl 0x8(%rax), %ecx
movl 0x8(%rbx), %edx
movl %edx, %esi
orl %ecx, %esi
testb $0x20, %sil
jne 0x50efc
movq %rax, %rdi
leaq -0x70(%rbp), %r13
movq %r13, %rsi
callq 0x38492
movq %rbx, %rdi
leaq -0xb0(%rbp), %r14
movq %r14, %rsi
callq 0x38492
movq %r14, %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
callq 0x3b31c
movq %rbx, %r13
movl %eax, %ebx
leaq -0x70(%rbp), %rdi
callq 0x296af
movq %r14, %rdi
callq 0x296af
testl %ebx, %ebx
movq %r13, %rbx
jne 0x50f00
jmp 0x50f0b
cmpl %edx, %ecx
je 0x50f0b
movq 0x48(%r15), %r15
jmp 0x50e8b
pushq $-0x6
popq %rax
jmp 0x50f0d
xorl %eax, %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: HashmapInsertNode
static sxi32 HashmapInsertNode(jx9_hashmap *pMap, jx9_hashmap_node *pNode, int bPreserve)
{
	jx9_value *pObj;
	sxi32 rc;
	/* Extract the node value */
	pObj = HashmapExtractNodeValue(&(*pNode));
	if( pObj == 0 ){
		return SXERR_EMPTY;
	}
	/* Preserve key */
	if( pNode->iType == HASHMAP_INT_NODE){
		/* Int64 key */
		if( !bPreserve ){
			/* Assign an automatic index */
			rc = HashmapInsert(&(*pMap), 0, pObj);
		}else{
			rc = HashmapInsertIntKey(&(*pMap), pNode->xKey.iKey, pObj);
		}
	}else{
		/* Blob key */
		rc = HashmapInsertBlobKey(&(*pMap), SyBlobData(&pNode->xKey.sKey), 
			SyBlobLength(&pNode->xKey.sKey), pObj);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x35e71
testq %rax, %rax
je 0x50f53
cmpl $0x1, 0x8(%r14)
jne 0x50f58
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x36ec2
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%r14), %rsi
movl 0x20(%r14), %edx
movq %rbx, %rdi
movq %rax, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x36cac
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmCallUserFunctionAp
JX9_PRIVATE sxi32 jx9VmCallUserFunctionAp(
	jx9_vm *pVm,       /* Target VM */
	jx9_value *pFunc,  /* Callback name */
	jx9_value *pResult, /* Store callback return value here. NULL otherwise */
	...                /* 0 (Zero) or more Callback arguments */ 
	)
{
	jx9_value *pArg;
	SySet aArg;
	va_list ap;
	sxi32 rc;
	SySetInit(&aArg, &pVm->sAllocator, sizeof(jx9_value *));
	/* Copy arguments one after one */
	va_start(ap, pResult);
	for(;;){
		pArg = va_arg(ap, jx9_value *);
		if( pArg == 0 ){
			break;
		}
		SySetPut(&aArg, (const void *)&pArg);
	}
	/* Call the core routine */
	rc = jx9VmCallUserFunction(&(*pVm), pFunc, (int)SySetUsed(&aArg), (jx9_value **)SySetBasePtr(&aArg), pResult);
	/* Cleanup */
	SySetRelease(&aArg);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq -0x120(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x50fd0
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
leaq -0x70(%rbp), %r15
andl $0x0, 0x14(%r15)
andl $0x0, 0x10(%r15)
movq $0x8, 0x18(%r15)
movq %rdi, (%r15)
andq $0x0, 0x8(%r15)
andq $0x0, 0x20(%r15)
movq %rsi, %r14
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x48(%rbp), %r12
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x5102c
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x51038
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0x51051
movq %r15, %rdi
movq %r12, %rsi
callq 0x2be00
jmp 0x51014
leaq -0x70(%rbp), %r15
movl 0x10(%r15), %edx
movq 0x8(%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x38181
movl %eax, %ebx
movq %r15, %rdi
callq 0x31feb
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
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: HashmapMergeSort
static sxi32 HashmapMergeSort(jx9_hashmap *pMap, ProcNodeCmp xCmp, void *pCmpData)
{
	jx9_hashmap_node *a[N_SORT_BUCKET], *p, *pIn;
	sxu32 i;
	SyZero(a, sizeof(a));
	/* Point to the first inserted entry */
	pIn = pMap->pFirst;
	while( pIn ){
		p = pIn;
		pIn = p->pPrev;
		p->pPrev = 0;
		for(i=0; i<N_SORT_BUCKET-1; i++){
			if( a[i]==0 ){
				a[i] = p;
				break;
			}else{
				p = HashmapNodeMerge(a[i], p, xCmp, pCmpData);
				a[i] = 0;
			}
		}
		if( i==N_SORT_BUCKET-1 ){
			/* To get here, there need to be 2^(N_SORT_BUCKET) elements in he input list.
			 * But that is impossible.
			 */
			a[i] = HashmapNodeMerge(a[i], p, xCmp, pCmpData);
		}
	}
	p = a[0];
	for(i=1; i<N_SORT_BUCKET; i++){
		p = HashmapNodeMerge(p, a[i], xCmp, pCmpData);
	}
	p->pNext = 0;
	/* Reflect the change */
	pMap->pFirst = p;
	/* Reset the loop cursor */
	pMap->pCur = pMap->pFirst;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x130(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x27aea
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x5111e
movq 0x48(%rsi), %r12
andq $0x0, 0x48(%rsi)
xorl %r13d, %r13d
cmpq $0x1f, %r13
je 0x510f9
movq -0x130(%rbp,%r13,8), %rdi
testq %rdi, %rdi
je 0x51111
movq %r15, %rdx
movq %r14, %rcx
callq 0x512c9
movq %rax, %rsi
andq $0x0, -0x130(%rbp,%r13,8)
incq %r13
jmp 0x510ca
movq -0x38(%rbp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x512c9
movq %rax, -0x38(%rbp)
movq %r12, %rsi
jmp 0x510b9
movq %rsi, -0x130(%rbp,%r13,8)
movq %r12, %rsi
jmp 0x510b9
pushq $0x1
popq %r12
movq -0x130(%rbp), %rax
cmpq $0x20, %r12
je 0x5114a
movq -0x130(%rbp,%r12,8), %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x512c9
incq %r12
jmp 0x51129
andq $0x0, 0x40(%rax)
movq %rax, 0x10(%rbx)
movq %rax, 0x20(%rbx)
addq $0x108, %rsp            # imm = 0x108
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: HashmapCmpCallback1
static sxi32 HashmapCmpCallback1(jx9_hashmap_node *pA, jx9_hashmap_node *pB, void *pCmpData)
{
	jx9_value sA, sB;
	sxi32 iFlags;
	int rc;
	if( pCmpData == 0 ){
		/* Perform a standard comparison */
		rc = HashmapNodeCmp(pA, pB, FALSE);
		return rc;
	}
	iFlags = SX_PTR_TO_INT(pCmpData);
	/* Duplicate node values */
	jx9MemObjInit(pA->pMap->pVm, &sA);
	jx9MemObjInit(pA->pMap->pVm, &sB);
	jx9HashmapExtractNodeValue(pA, &sA, FALSE);
	jx9HashmapExtractNodeValue(pB, &sB, FALSE);
	if( iFlags == 5 ){
		/* String cast */
		if( (sA.iFlags & MEMOBJ_STRING) == 0 ){
			jx9MemObjToString(&sA);
		}
		if( (sB.iFlags & MEMOBJ_STRING) == 0 ){
			jx9MemObjToString(&sB);
		}
	}else{
		/* Numeric cast */
		jx9MemObjToNumeric(&sA);
		jx9MemObjToNumeric(&sB);
	}
	/* Perform the comparison */
	rc = jx9MemObjCmp(&sA, &sB, FALSE, 0);
	jx9MemObjRelease(&sA);
	jx9MemObjRelease(&sB);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x511f7
movq %rdx, %rbx
movq (%r15), %rax
movq (%rax), %rdi
leaq -0xa8(%rbp), %r12
movq %r12, %rsi
callq 0x35772
movq (%r15), %rax
movq (%rax), %rdi
leaq -0x68(%rbp), %r13
movq %r13, %rsi
callq 0x35772
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3b0ba
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3b0ba
cmpl $0x5, %ebx
jne 0x51215
testb $0x1, -0xa0(%rbp)
jne 0x511e6
leaq -0xa8(%rbp), %rdi
callq 0x36bcf
testb $0x1, -0x60(%rbp)
jne 0x5122a
leaq -0x68(%rbp), %rdi
callq 0x36bcf
jmp 0x5122a
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bc56
leaq -0xa8(%rbp), %rdi
callq 0x3acd2
leaq -0x68(%rbp), %rdi
callq 0x3acd2
leaq -0xa8(%rbp), %rbx
leaq -0x68(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3b31c
movl %eax, %r15d
movq %rbx, %rdi
callq 0x296af
movq %r14, %rdi
callq 0x296af
movl %r15d, %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: HashmapSortRehash
static void HashmapSortRehash(jx9_hashmap *pMap)
{
	jx9_hashmap_node *p, *pLast;
	sxu32 i;
	/* Rehash all entries */
	pLast = p = pMap->pFirst;
	pMap->iNextIdx = 0; /* Reset the automatic index */
	i = 0;
	for( ;; ){
		if( i >= pMap->nEntry ){
			pMap->pLast = pLast; /* Fix the last link broken by the merge-sort */
			break;
		}
		if( p->iType == HASHMAP_BLOB_NODE ){
			/* Do not maintain index association as requested by the JX9 specification */
			SyBlobRelease(&p->xKey.sKey);
			/* Change key type */
			p->iType = HASHMAP_INT_NODE;
		}
		HashmapRehashIntNode(p);
		/* Point to the next entry */
		i++;
		pLast = p;
		p = p->pPrev; /* Reverse link */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
andq $0x0, 0x48(%rdi)
xorl %r15d, %r15d
movq %rax, %rcx
cmpl 0x2c(%rbx), %r15d
jae 0x512ba
movq %rax, %r14
cmpl $0x2, 0x8(%rax)
jne 0x512a6
leaq 0x10(%r14), %rdi
callq 0x2a72f
movl $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x50db3
incl %r15d
movq 0x48(%r14), %rax
movq %r14, %rcx
jmp 0x51286
movq %rcx, 0x18(%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: HashmapNodeMerge
static jx9_hashmap_node * HashmapNodeMerge(jx9_hashmap_node *pA, jx9_hashmap_node *pB, ProcNodeCmp xCmp, void *pCmpData)
{
	jx9_hashmap_node result, *pTail;
    /* Prevent compiler warning */
	result.pNext = result.pPrev = 0;
	pTail = &result;
	while( pA && pB ){
		if( xCmp(pA, pB, pCmpData) < 0 ){
			pTail->pPrev = pA;
			pA->pNext = pTail;
			pTail = pA;
			pA = pA->pPrev;
		}else{
			pTail->pPrev = pB;
			pB->pNext = pTail;
			pTail = pB;
			pB = pB->pPrev;
		}
	}
	if( pA ){
		pTail->pPrev = pA;
		pA->pNext = pTail;
	}else if( pB ){
		pTail->pPrev = pB;
		pB->pNext = pTail;
	}else{
		pTail->pPrev = pTail->pNext = 0;
	}
	return result.pPrev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x88(%rbp), %rbx
movups %xmm0, 0x40(%rbx)
movq %rbx, %r13
movq %rsi, %rbx
testq %r14, %r14
je 0x51330
testq %rbx, %rbx
je 0x51330
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *%r12
testl %eax, %eax
jns 0x51322
movq %r14, 0x48(%r13)
movq %r13, 0x40(%r14)
movq %r14, %r13
movq 0x48(%r14), %r14
jmp 0x512f7
movq %rbx, 0x48(%r13)
movq %r13, 0x40(%rbx)
movq 0x48(%rbx), %rsi
jmp 0x512f1
testq %r14, %r14
je 0x5133f
movq %r14, 0x48(%r13)
movq %r13, 0x40(%r14)
jmp 0x51356
testq %rbx, %rbx
je 0x5134e
movq %rbx, 0x48(%r13)
movq %r13, 0x40(%rbx)
jmp 0x51356
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r13)
movq -0x40(%rbp), %rax
addq $0x68, %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: HashmapCmpCallback4
static sxi32 HashmapCmpCallback4(jx9_hashmap_node *pA, jx9_hashmap_node *pB, void *pCmpData)
{
	jx9_value sResult, *pCallback;
	jx9_value *pV1, *pV2;
	jx9_value *apArg[2];  /* Callback arguments */
	sxi32 rc;
	/* Point to the desired callback */
	pCallback = (jx9_value *)pCmpData;
	/* initialize the result value */
	jx9MemObjInit(pA->pMap->pVm, &sResult);
	/* Extract nodes values */
	pV1 = HashmapExtractNodeValue(pA);
	pV2 = HashmapExtractNodeValue(pB);
	apArg[0] = pV1;
	apArg[1] = pV2;
	/* Invoke the callback */
	rc = jx9VmCallUserFunction(pA->pMap->pVm, pCallback, 2, apArg, &sResult);
	if( rc != SXRET_OK ){
		/* An error occured while calling user defined function [i.e: not defined] */
		rc = -1; /* Set a dummy result */
	}else{
		/* Extract callback result */
		if((sResult.iFlags & MEMOBJ_INT) == 0 ){
			/* Perform an int cast */
			jx9MemObjToInteger(&sResult);
		}
		rc = (sxi32)sResult.x.iVal;
	}
	jx9MemObjRelease(&sResult);
	/* Callback result */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq (%rax), %rdi
leaq -0x68(%rbp), %r12
movq %r12, %rsi
callq 0x35772
movq %r15, %rdi
callq 0x35e71
movq %rax, %r13
movq %r14, %rdi
callq 0x35e71
leaq -0x80(%rbp), %rcx
movq %r13, (%rcx)
movq %rax, 0x8(%rcx)
movq (%r15), %rax
movq (%rax), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
movq %r12, %r8
callq 0x38181
testl %eax, %eax
je 0x514c4
pushq $-0x1
popq %rbx
jmp 0x514d6
testb $0x2, -0x60(%rbp)
jne 0x514d3
leaq -0x68(%rbp), %rdi
callq 0x36daa
movl -0x68(%rbp), %ebx
leaq -0x68(%rbp), %rdi
callq 0x296af
movl %ebx, %eax
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: jx9Vfs_chdir
static int jx9Vfs_chdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xChdir == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xChdir(zPath);
	/* IO return value */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x515a2
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x515a2
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5158a
cmpq $0x0, 0x10(%r14)
je 0x5158a
xorl %esi, %esi
callq 0x297ed
movq %rax, %rdi
callq *0x10(%r14)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x515a7
movq 0x8(%rax), %rcx
leaq 0x15fa8(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_chroot
static int jx9Vfs_chroot(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xChroot == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xChroot(zPath);
	/* IO return value */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x51610
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x51610
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x515f8
cmpq $0x0, 0x18(%r14)
je 0x515f8
xorl %esi, %esi
callq 0x297ed
movq %rax, %rdi
callq *0x18(%r14)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x51615
movq 0x8(%rax), %rcx
leaq 0x15f3a(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_getcwd
static int jx9Vfs_getcwd(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	int rc;
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xGetcwd == 0 ){
		SXUNUSED(nArg); /* cc warning */
		SXUNUSED(apArg);
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	jx9_result_string(pCtx, "", 0);
	/* Perform the requested operation */
	rc = pVfs->xGetcwd(pCtx);
	if( rc != JX9_OK ){
		/* Error, return FALSE */
		jx9_result_bool(pCtx, 0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5165c
cmpq $0x0, 0x20(%r14)
je 0x5165c
leaq 0x1600d(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
movq %rbx, %rdi
callq *0x20(%r14)
testl %eax, %eax
jne 0x51674
jmp 0x5167e
movq 0x8(%rax), %rcx
leaq 0x15ed6(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_rmdir
static int jx9Vfs_rmdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xRmdir == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xRmdir(zPath);
	/* IO return value */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x516e2
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x516e2
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x516ca
cmpq $0x0, 0x30(%r14)
je 0x516ca
xorl %esi, %esi
callq 0x297ed
movq %rax, %rdi
callq *0x30(%r14)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x516e7
movq 0x8(%rax), %rcx
leaq 0x15e68(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_is_dir
static int jx9Vfs_is_dir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xIsdir == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
	/* Perform the requested operation */
	rc = pVfs->xIsdir(zPath);
	/* IO return value */
	jx9_result_bool(pCtx, rc == JX9_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x51750
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x51750
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x51738
cmpq $0x0, 0x38(%r14)
je 0x51738
xorl %esi, %esi
callq 0x297ed
movq %rax, %rdi
callq *0x38(%r14)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x51755
movq 0x8(%rax), %rcx
leaq 0x15dfa(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_mkdir
static int jx9Vfs_mkdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	int iRecursive = 0;
	const char *zPath;
	jx9_vfs *pVfs;
	int iMode, rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xMkdir == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the desired directory */
	zPath = jx9_value_to_string(apArg[0], 0);
#ifdef __WINNT__
	iMode = 0;
#else
	/* Assume UNIX */
	iMode = 0777;
#endif
	if( nArg > 1 ){
		iMode = jx9_value_to_int(apArg[1]);
		if( nArg > 2 ){
			iRecursive = jx9_value_to_bool(apArg[2]);
		}
	}
	/* Perform the requested operation */
	rc = pVfs->xMkdir(zPath, iMode, iRecursive);
	/* IO return value */
	jx9_result_bool(pCtx, rc == JX9_OK);
	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 0x517c8
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x517c8
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x517b0
cmpq $0x0, 0x28(%r12)
je 0x517b0
movl %esi, %r15d
xorl %esi, %esi
callq 0x297ed
movl $0x1ff, %r13d           # imm = 0x1FF
cmpl $0x1, %r15d
jne 0x517e3
xorl %edx, %edx
jmp 0x5180c
movq 0x8(%rax), %rcx
leaq 0x15d82(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %rdi
callq 0x29772
movl %eax, %r13d
cmpl $0x3, %r15d
jb 0x51806
movq 0x10(%r14), %rdi
callq 0x29790
movl %eax, %edx
jmp 0x51808
xorl %edx, %edx
movq -0x30(%rbp), %rax
movq %rax, %rdi
movl %r13d, %esi
callq *0x28(%r12)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x517cd
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_rename
static int jx9Vfs_rename(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zOld, *zNew;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
		/* Missing/Invalid arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xRename == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation */
	zOld = jx9_value_to_string(apArg[0], 0);
	zNew = jx9_value_to_string(apArg[1], 0);
	rc = pVfs->xRename(zOld, zNew);
	/* IO result */
	jx9_result_bool(pCtx, rc == JX9_OK );
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x518a6
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x518a6
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
je 0x518a6
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5188e
cmpq $0x0, 0x40(%r12)
je 0x5188e
xorl %esi, %esi
callq 0x297ed
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %r15, %rdi
movq %rax, %rsi
callq *0x40(%r12)
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
jmp 0x518ab
movq 0x8(%rax), %rcx
leaq 0x15ca4(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
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: jx9Vfs_realpath
static int jx9Vfs_realpath(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
        int rc;
	if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xRealpath == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Set an empty string untnil the underlying OS interface change that */
	jx9_result_string(pCtx, "", 0);
	/* Perform the requested operation */
	zPath = jx9_value_to_string(apArg[0], 0);
	rc = pVfs->xRealpath(zPath, pCtx);
	if( rc != JX9_OK ){
	 jx9_result_bool(pCtx, 0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5192e
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x8(%rax)
je 0x5192e
movq (%rbx), %rax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x51916
cmpq $0x0, 0x48(%r15)
je 0x51916
leaq 0x15d60(%rip), %rsi     # 0x67652
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29903
movq (%r14), %rdi
xorl %esi, %esi
callq 0x297ed
movq %rax, %rdi
movq %rbx, %rsi
callq *0x48(%r15)
testl %eax, %eax
jne 0x5192e
jmp 0x51938
movq 0x8(%rax), %rcx
leaq 0x15c1c(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %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: jx9Vfs_sleep
static int jx9Vfs_sleep(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	int rc, nSleep;
	if( nArg < 1 || !jx9_value_is_int(apArg[0]) ){
		/* Missing/Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Point to the underlying vfs */
	pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
	if( pVfs == 0 || pVfs->xSleep == 0 ){
		/* IO routine not implemented, return NULL */
		jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, 
			"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE", 
			jx9_function_name(pCtx)
			);
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Amount to sleep */
	nSleep = jx9_value_to_int(apArg[0]);
	if( nSleep < 0 ){
		/* Invalid value, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Perform the requested operation (Microseconds) */
	rc = pVfs->xSleep((unsigned int)(nSleep * SX_USEC_PER_SEC));
	if( rc != JX9_OK ){
		/* Return FALSE */
		jx9_result_bool(pCtx, 0);
	}else{
		/* Return zero */
		jx9_result_int(pCtx, 0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x519aa
movq (%rdx), %rdi
testb $0x2, 0x8(%rdi)
je 0x519aa
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x51992
cmpq $0x0, 0x50(%r14)
je 0x51992
callq 0x29772
testl %eax, %eax
js 0x519aa
imull $0xf4240, %eax, %edi    # imm = 0xF4240
callq *0x50(%r14)
testl %eax, %eax
jne 0x519aa
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2987c
jmp 0x519b4
movq 0x8(%rax), %rcx
leaq 0x15ba0(%rip), %rdx     # 0x6753d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq