LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x5df07
addq $0x50, %rcx
jmp 0x5df18
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 0x5df2b
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%rax)
cmpq %rbx, 0x10(%r15)
jne 0x5df39
movq 0x48(%rbx), %rax
movq %rax, 0x10(%r15)
movq 0x20(%r15), %rax
cmpq %rbx, %rax
jne 0x5df4a
movq 0x48(%rax), %rax
movq %rax, 0x20(%r15)
movq 0x18(%r15), %rax
cmpq %rbx, %rax
jne 0x5df5b
movq 0x40(%rax), %rax
movq %rax, 0x18(%r15)
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x5df6c
movq %rax, 0x40(%rcx)
testq %rax, %rax
je 0x5df75
movq %rcx, 0x48(%rax)
movl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x3e434
cmpl $0x2, 0x8(%rbx)
jne 0x5df8f
leaq 0x10(%rbx), %rdi
callq 0x317be
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e659
decl 0x2c(%r15)
jne 0x5dfc1
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3490d
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movl $0x0, 0x28(%r15)
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: 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 (%rdi), %rax
movq 0x10(%rdi), %rbx
movl 0x2c(%rdi), %r12d
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movl $0x20, %ecx
movl %ecx, -0x68(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0x80(%rbp)
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
movl %ecx, -0xa8(%rbp)
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testl %r12d, %r12d
je 0x5e184
movq %rsi, %r14
movq (%rbx), %rcx
movl 0x38(%rbx), %eax
movq (%rcx), %rcx
cmpl %eax, 0x218(%rcx)
jbe 0x5e16e
movq 0x210(%rcx), %rdi
testq %rdi, %rdi
je 0x5e16e
imull 0x220(%rcx), %eax
addq %rax, %rdi
movl 0x8(%rdi), %eax
movl 0x8(%r14), %ecx
movl %ecx, %edx
orl %eax, %edx
testb $0x20, %dl
jne 0x5e16a
leaq -0x70(%rbp), %r15
movq %r15, %rsi
callq 0x40cc7
movq %r14, %rdi
movq %r14, %r13
leaq -0xb0(%rbp), %r14
movq %r14, %rsi
callq 0x40cc7
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0x44270
movl %eax, %r15d
leaq -0x70(%rbp), %rdi
callq 0x30465
movq %r14, %rdi
movq %r13, %r14
callq 0x30465
testl %r15d, %r15d
jne 0x5e16e
jmp 0x5e182
cmpl %ecx, %eax
je 0x5e182
movq 0x48(%rbx), %rbx
decl %r12d
jne 0x5e0e6
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x5e184
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_O3/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
movq (%rsi), %rcx
movl 0x38(%rsi), %eax
movq (%rcx), %rdx
cmpl %eax, 0x218(%rdx)
jbe 0x5e1d4
movq 0x210(%rdx), %rcx
testq %rcx, %rcx
je 0x5e1d4
imull 0x220(%rdx), %eax
addq %rax, %rcx
cmpl $0x1, 0x8(%rsi)
jne 0x5e1d6
movq 0x10(%rsi), %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x3f4a6
popq %rbp
retq
movq 0x18(%rsi), %rax
movl 0x20(%rsi), %edx
movq %rax, %rsi
popq %rbp
jmp 0x3f257
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rbx
movq %rdi, %r14
leaq -0x120(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x5e24a
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)
xorl %eax, %eax
leaq -0x70(%rbp), %r15
movl %eax, 0x14(%r15)
movl %eax, 0x10(%r15)
movq $0x8, 0x18(%r15)
movq %rdi, (%r15)
movq %rax, 0x8(%r15)
movq %rax, 0x20(%r15)
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 0x5e2a1
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5e2ad
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0x5e2c6
movq %r15, %rdi
movq %r12, %rsi
callq 0x33094
jmp 0x5e289
movl -0x60(%rbp), %edx
movq -0x68(%rbp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x4089b
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x5e2fc
movq %r15, %rsi
callq 0x3490d
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_O3/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
movq $-0x4, %rax
movl $0x0, -0x12c(%rbp,%rax)
addq $0x4, %rax
cmpq $0xfc, %rax
jb 0x5e332
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x5e3b7
movq %r12, %rax
movq 0x48(%r12), %r12
movq $0x0, 0x48(%rax)
xorl %r13d, %r13d
movq -0x130(%rbp,%r13,8), %rdi
testq %rdi, %rdi
je 0x5e3ad
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5e590
movq $0x0, -0x130(%rbp,%r13,8)
incq %r13
cmpq $0x1f, %r13
jne 0x5e365
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5e590
movq %rax, -0x38(%rbp)
jmp 0x5e34d
movq %rax, -0x130(%rbp,%r13,8)
jmp 0x5e34d
movl $0x1, %r12d
movq -0x130(%rbp), %rax
movq -0x130(%rbp,%r12,8), %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5e590
incq %r12
cmpq $0x20, %r12
jne 0x5e3c4
movq $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_O3/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 %rbx
subq $0x88, %rsp
movq %rsi, %r14
testq %rdx, %rdx
je 0x5e4c2
movq %rdx, %rbx
movq (%rdi), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movq %rax, 0x10(%rdx)
movq %rax, 0x18(%rdx)
movl $0x20, %ecx
movl %ecx, 0x8(%rdx)
leaq -0x60(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x30(%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x18(%r15)
movl %ecx, 0x8(%r15)
movl 0x38(%rdi), %esi
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x43f1e
movq (%r14), %rax
movl 0x38(%r14), %esi
movq (%rax), %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x43f1e
cmpl $0x5, %ebx
jne 0x5e4d9
testb $0x1, -0x98(%rbp)
jne 0x5e4b1
leaq -0xa0(%rbp), %rdi
callq 0x3f163
testb $0x1, -0x58(%rbp)
jne 0x5e4ee
leaq -0x60(%rbp), %rdi
callq 0x3f163
jmp 0x5e4ee
movq %r14, %rsi
xorl %edx, %edx
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44c71
leaq -0xa0(%rbp), %rdi
callq 0x43b00
leaq -0x60(%rbp), %rdi
callq 0x43b00
leaq -0xa0(%rbp), %rbx
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x44270
movl %eax, %r15d
movq %rbx, %rdi
callq 0x30465
movq %r14, %rdi
callq 0x30465
movl %r15d, %eax
addq $0x88, %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: 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), %r14
movq $0x0, 0x48(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0x5e57e
xorl %r15d, %r15d
cmpl $0x2, 0x8(%r14)
jne 0x5e564
leaq 0x10(%r14), %rdi
callq 0x317be
movl $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x5dfcc
incl %r15d
movq %r14, %rax
movq 0x48(%r14), %r14
cmpl 0x2c(%rbx), %r15d
jb 0x5e54c
jmp 0x5e581
movq %r14, %rax
movq %rax, 0x18(%rbx)
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: 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, %rbx
movq %rdx, %r14
testq %rdi, %rdi
setne %cl
testq %rsi, %rsi
setne %al
movl %ecx, %edx
andb %al, %dl
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
leaq -0x88(%rbp), %r13
cmpb $0x1, %dl
jne 0x5e621
movq %rdi, %r15
movq %rsi, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
js 0x5e5f6
movq %r12, 0x48(%r13)
movq %r13, 0x40(%r12)
movq 0x48(%r12), %rsi
movq %r15, %rdi
movq %r12, %r13
jmp 0x5e608
movq %r15, 0x48(%r13)
movq %r13, 0x40(%r15)
movq 0x48(%r15), %rdi
movq %r12, %rsi
movq %r15, %r13
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
je 0x5e621
movq %rdi, %r15
movq %rsi, %r12
testq %rsi, %rsi
jne 0x5e5d0
testb %cl, %cl
je 0x5e62f
movq %rdi, 0x48(%r13)
movq %r13, 0x40(%rdi)
jmp 0x5e645
testb %al, %al
je 0x5e63d
movq %rsi, 0x48(%r13)
movq %r13, 0x40(%rsi)
jmp 0x5e645
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_O3/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 %rbx
subq $0x58, %rsp
movq %rdi, %rax
movq (%rdi), %rcx
movq (%rcx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movl $0x20, -0x48(%rbp)
movl 0x38(%rax), %eax
cmpl %eax, 0x218(%rdi)
jbe 0x5e7bf
imull 0x220(%rdi), %eax
addq 0x210(%rdi), %rax
jmp 0x5e7c1
xorl %eax, %eax
movq (%rsi), %rcx
movl 0x38(%rsi), %esi
movq (%rcx), %rcx
cmpl %esi, 0x218(%rcx)
jbe 0x5e7e2
imull 0x220(%rcx), %esi
addq 0x210(%rcx), %rsi
jmp 0x5e7e4
xorl %esi, %esi
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
leaq -0x50(%rbp), %r8
movq %rdx, %rsi
movl $0x2, %edx
callq 0x4089b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x5e81b
testb $0x2, -0x48(%rbp)
jne 0x5e818
leaq -0x50(%rbp), %rdi
callq 0x3f362
movl -0x50(%rbp), %ebx
leaq -0x50(%rbp), %rdi
callq 0x30465
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapCurrentValue
static sxi32 HashmapCurrentValue(jx9_context *pCtx, jx9_hashmap *pMap, int iDirection)
{
	jx9_hashmap_node *pCur = pMap->pCur;
	jx9_value *pVal;
	if( pCur == 0 ){
		/* Cursor does not point to anything, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	if( iDirection != 0 ){
		if( iDirection > 0 ){
			/* Point to the next entry */
			pMap->pCur = pCur->pPrev; /* Reverse link */
			pCur = pMap->pCur;
		}else{
			/* Point to the previous entry */
			pMap->pCur = pCur->pNext; /* Reverse link */
			pCur = pMap->pCur;
		}
		if( pCur == 0 ){
			/* End of input reached, return FALSE */
			jx9_result_bool(pCtx, 0);
			return JX9_OK;
		}
	}		
	/* Point to the desired element */
	pVal = HashmapExtractNodeValue(pCur);
	if( pVal ){
		jx9_result_value(pCtx, pVal);
	}else{
		jx9_result_bool(pCtx, 0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x5e88d
testl %edx, %edx
je 0x5e854
setg %cl
movzbl %cl, %ecx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, 0x20(%rsi)
testq %rax, %rax
je 0x5e88d
movq (%rax), %rdx
movl 0x38(%rax), %ecx
movq (%rdx), %rdx
cmpl %ecx, 0x218(%rdx)
jbe 0x5e88d
movq 0x210(%rdx), %rax
testq %rax, %rax
je 0x5e88d
imull 0x220(%rdx), %ecx
addq %rcx, %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3e19f
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)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5e921
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5e921
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5e907
cmpq $0x0, 0x10(%r14)
je 0x5e907
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x10(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5e934
movq 0x8(%rax), %rcx
leaq 0x18c4b(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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
// File: /workspace/github_c_makefile_star2_O3/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 0x5e9b5
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5e9b5
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5e99b
cmpq $0x0, 0x18(%r14)
je 0x5e99b
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x18(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5e9c8
movq 0x8(%rax), %rcx
leaq 0x18bb7(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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
// File: /workspace/github_c_makefile_star2_O3/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 0x5ea19
cmpq $0x0, 0x20(%r14)
je 0x5ea19
movq 0x8(%rbx), %rdi
leaq 0x18c6d(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
movq %rbx, %rdi
callq *0x20(%r14)
testl %eax, %eax
jne 0x5ea33
jmp 0x5ea57
movq 0x8(%rax), %rcx
leaq 0x18b39(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
addq $0x8, %rbx
movq (%rbx), %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
// File: /workspace/github_c_makefile_star2_O3/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 0x5eaca
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5eaca
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5eab0
cmpq $0x0, 0x30(%r14)
je 0x5eab0
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x30(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5eadd
movq 0x8(%rax), %rcx
leaq 0x18aa2(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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
// File: /workspace/github_c_makefile_star2_O3/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 0x5eb5e
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5eb5e
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5eb44
cmpq $0x0, 0x38(%r14)
je 0x5eb44
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x38(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5eb71
movq 0x8(%rax), %rcx
leaq 0x18a0e(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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
// File: /workspace/github_c_makefile_star2_O3/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 0x5ebef
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5ebef
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5ebd5
cmpq $0x0, 0x28(%r12)
je 0x5ebd5
movl %esi, %r15d
xorl %esi, %esi
callq 0x30577
movl $0x1ff, %r13d           # imm = 0x1FF
cmpl $0x1, %r15d
jne 0x5ec21
xorl %edx, %edx
jmp 0x5ec52
movq 0x8(%rax), %rcx
leaq 0x1897d(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %r13
movq %r13, %rdi
callq 0x3f362
movl (%r13), %r13d
cmpl $0x3, %r15d
jb 0x5ec4c
movq 0x10(%r14), %r14
movq %r14, %rdi
callq 0x438dd
movl (%r14), %edx
jmp 0x5ec4e
xorl %edx, %edx
movq -0x30(%rbp), %rax
movq %rax, %rdi
movl %r13d, %esi
callq *0x28(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5ec02
// File: /workspace/github_c_makefile_star2_O3/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 0x5ed08
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5ed08
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
je 0x5ed08
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5ecee
cmpq $0x0, 0x40(%r12)
je 0x5ecee
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
callq *0x40(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5ed1b
movq 0x8(%rax), %rcx
leaq 0x18864(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5edaa
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x8(%rax)
je 0x5edaa
movq (%rbx), %rax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x5ed90
cmpq $0x0, 0x48(%r15)
je 0x5ed90
movq 0x8(%rbx), %rdi
leaq 0x18903(%rip), %rsi     # 0x77672
xorl %edx, %edx
callq 0x302f6
movq (%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
movq %rbx, %rsi
callq *0x48(%r15)
testl %eax, %eax
jne 0x5edaa
jmp 0x5edce
movq 0x8(%rax), %rcx
leaq 0x187c2(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
addq $0x8, %rbx
movq (%rbx), %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 %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x5ee64
movq (%rdx), %r14
testb $0x2, 0x8(%r14)
je 0x5ee64
movq (%rbx), %rax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x5ee4a
cmpq $0x0, 0x50(%r15)
je 0x5ee4a
movq %r14, %rdi
callq 0x3f362
movl (%r14), %eax
testl %eax, %eax
js 0x5ee64
imull $0xf4240, %eax, %edi    # imm = 0xF4240
callq *0x50(%r15)
movl %eax, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
movq $0x0, (%rbx)
testl %r14d, %r14d
jne 0x5ee7f
orl $0x2, %eax
jmp 0x5ee82
movq 0x8(%rax), %rcx
leaq 0x18708(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_usleep
static int jx9Vfs_usleep(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	jx9_vfs *pVfs;
	int nSleep;
	if( nArg < 1 || !jx9_value_is_int(apArg[0]) ){
		/* Missing/Invalid argument, return immediately */
		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_function_name(pCtx)
			);
		return JX9_OK;
	}
	/* Amount to sleep */
	nSleep = jx9_value_to_int(apArg[0]);
	if( nSleep < 0 ){
		/* Invalid value, return immediately */
		return JX9_OK;
	}
	/* Perform the requested operation (Microseconds) */
	pVfs->xSleep((unsigned int)nSleep);
	return JX9_OK;
}

// Assembly:
testl %esi, %esi
jle 0x5eee8
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdx), %rbx
testb $0x2, 0x8(%rbx)
je 0x5eee4
movq (%rdi), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5eecd
cmpq $0x0, 0x50(%r14)
je 0x5eecd
movq %rbx, %rdi
callq 0x3f362
movl (%rbx), %edi
testl %edi, %edi
js 0x5eee4
callq *0x50(%r14)
jmp 0x5eee4
movq 0x8(%rax), %rcx
leaq 0x186d2(%rip), %rdx     # 0x775aa
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_chmod
static int jx9Vfs_chmod(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_vfs *pVfs;
	int iMode;
	int rc;
	if( nArg < 2 || !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->xChmod == 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);
	/* Extract the mode */
	iMode = jx9_value_to_int(apArg[1]);
	/* Perform the requested operation */
	rc = pVfs->xChmod(zPath, iMode);
	/* IO return value */
	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 0x5f007
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5f007
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5efed
cmpq $0x0, 0x68(%r12)
je 0x5efed
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3f362
movl (%r14), %esi
movq %r15, %rdi
callq *0x68(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5f01a
movq 0x8(%rax), %rcx
leaq 0x18565(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_chown
static int jx9Vfs_chown(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath, *zUser;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
		/* 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->xChown == 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);
	/* Extract the user */
	zUser = jx9_value_to_string(apArg[1], 0);
	/* Perform the requested operation */
	rc = pVfs->xChown(zPath, zUser);
	/* IO return value */
	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 0x5f0ba
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5f0ba
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5f0a0
cmpq $0x0, 0x70(%r12)
je 0x5f0a0
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
callq *0x70(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5f0cd
movq 0x8(%rax), %rcx
leaq 0x184b2(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_chgrp
static int jx9Vfs_chgrp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath, *zGroup;
	jx9_vfs *pVfs;
	int rc;
	if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
		/* 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->xChgrp == 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);
	/* Extract the user */
	zGroup = jx9_value_to_string(apArg[1], 0);
	/* Perform the requested operation */
	rc = pVfs->xChgrp(zPath, zGroup);
	/* IO return value */
	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 0x5f16d
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x5f16d
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x5f153
cmpq $0x0, 0x78(%r12)
je 0x5f153
xorl %esi, %esi
callq 0x30577
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30577
movq %r15, %rdi
movq %rax, %rsi
callq *0x78(%r12)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x5f180
movq 0x8(%rax), %rcx
leaq 0x183ff(%rip), %rdx     # 0x7755d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9Vfs_disk_free_space
static int jx9Vfs_disk_free_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	const char *zPath;
	jx9_int64 iSize;
	jx9_vfs *pVfs;
	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->xFreeSpace == 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 */
	iSize = pVfs->xFreeSpace(zPath);
	/* IO return value */
	jx9_result_int64(pCtx, iSize);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r15d
testl %esi, %esi
jle 0x5f1b9
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x5f1be
xorl %r14d, %r14d
jmp 0x5f20d
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x5f1f0
cmpq $0x0, 0x80(%r14)
je 0x5f1f0
xorl %esi, %esi
callq 0x30577
movq %rax, %rdi
callq *0x80(%r14)
movq %rax, %r14
movl $0x2, %r15d
jmp 0x5f20d
movq 0x8(%rax), %rcx
leaq 0x18362(%rip), %rdx     # 0x7755d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r15d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq