LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_hashmap_current
static int jx9_hashmap_current(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
	if( nArg < 1 ){
		/* Missing arguments, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	/* Make sure we are dealing with a valid hashmap */
	if( !jx9_value_is_json_array(apArg[0]) ){
		/* Invalid argument, return FALSE */
		jx9_result_bool(pCtx, 0);
		return JX9_OK;
	}
	HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, 0);
	return JX9_OK;
}

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl 0x2c(%rdi), %eax
testl %esi, %esi
je 0x5f812
testl %eax, %eax
movq %rax, -0x40(%rbp)
je 0x5f817
movq %rdi, %r14
movq (%rdi), %r13
addq $0x18, %r14
movl 0x218(%r13), %r12d
movq -0x38(%rbp), %rcx
incl %ecx
movl %ecx, -0x2c(%rbp)
xorl %r15d, %r15d
movl %eax, %ebx
movq (%r14), %r14
movl 0x38(%r14), %eax
cmpl %eax, %r12d
jbe 0x5f7e2
imull 0x220(%r13), %eax
addq 0x210(%r13), %rax
jmp 0x5f7e4
xorl %eax, %eax
testq %rax, %rax
je 0x5f808
testb $0x40, 0x8(%rax)
je 0x5f808
cmpl $0x1f, -0x38(%rbp)
jg 0x5f81e
movq (%rax), %rdi
movl $0x1, %esi
movl -0x2c(%rbp), %edx
callq 0x5f782
addq %rax, %r15
addq $0x40, %r14
decl %ebx
jne 0x5f7c5
jmp 0x5f81a
movq %rax, %r15
jmp 0x5f81e
xorl %r15d, %r15d
addq -0x40(%rbp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5f853
addq $0x50, %rcx
jmp 0x5f864
movl 0x28(%r15), %ecx
decl %ecx
andl 0x34(%rbx), %ecx
shlq $0x3, %rcx
addq 0x8(%r15), %rcx
movq (%r15), %r14
movq %rax, (%rcx)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x5f87b
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%rax)
cmpq %rbx, 0x10(%r15)
jne 0x5f889
movq 0x48(%rbx), %rax
movq %rax, 0x10(%r15)
movq 0x20(%r15), %rax
cmpq %rbx, %rax
jne 0x5f89a
movq 0x48(%rax), %rax
movq %rax, 0x20(%r15)
movq 0x18(%r15), %rax
cmpq %rbx, %rax
jne 0x5f8ab
movq 0x40(%rax), %rax
movq %rax, 0x18(%r15)
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x5f8bc
movq 0x40(%rbx), %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rbx), %rcx
testq %rcx, %rcx
je 0x5f8c9
movq %rax, 0x48(%rcx)
movl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x3ee5d
cmpl $0x2, 0x8(%rbx)
jne 0x5f8e3
leaq 0x10(%rbx), %rdi
callq 0x31d8f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb38
decl 0x2c(%r15)
jne 0x5f915
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3503f
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_O1/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 0x5f940
addq $0x50, %rcx
jmp 0x5f951
movl 0x28(%r14), %ecx
decl %ecx
andl 0x34(%rbx), %ecx
shlq $0x3, %rcx
addq 0x8(%r14), %rcx
movq %rax, (%rcx)
leaq 0x50(%rbx), %rax
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x5f969
movq 0x58(%rbx), %rdx
movq %rdx, 0x58(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x48(%r14), %rdi
callq *0x30(%r14)
movl %eax, 0x34(%rbx)
movq 0x48(%r14), %rcx
movq %rcx, 0x10(%rbx)
movl 0x28(%r14), %ecx
decl %ecx
andl %eax, %ecx
movq 0x8(%r14), %rax
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x50(%rbx)
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x5f9a3
movq %rbx, 0x58(%rdx)
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x50(%rbx)
movq %rbx, (%rax,%rcx,8)
incq 0x48(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, -0x40(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq %rax, -0x58(%rbp)
xorl %ecx, %ecx
movl %ecx, -0x40(%rbp)
movl $0x20, %edx
movl %edx, -0x68(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0x90(%rbp)
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
movl %ecx, -0x80(%rbp)
movl %edx, -0xa8(%rbp)
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testl %r12d, %r12d
je 0x5fae2
movq %rsi, %r14
movq (%rbx), %rax
movq (%rax), %rax
movl 0x38(%rbx), %edi
cmpl %edi, 0x218(%rax)
jbe 0x5fa64
imull 0x220(%rax), %edi
addq 0x210(%rax), %rdi
jmp 0x5fa66
xorl %edi, %edi
testq %rdi, %rdi
je 0x5facc
movl 0x8(%rdi), %eax
movl 0x8(%r14), %ecx
movl %ecx, %edx
orl %eax, %edx
testb $0x20, %dl
jne 0x5fac8
leaq -0x70(%rbp), %r15
movq %r15, %rsi
callq 0x41707
movq %r14, %rdi
movq %r14, %r13
leaq -0xb0(%rbp), %r14
movq %r14, %rsi
callq 0x41707
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0x450b0
movl %eax, %r15d
leaq -0x70(%rbp), %rdi
callq 0x309f2
movq %r14, %rdi
movq %r13, %r14
callq 0x309f2
testl %r15d, %r15d
jne 0x5facc
jmp 0x5fae0
cmpl %ecx, %eax
je 0x5fae0
movq 0x48(%rbx), %rbx
decl %r12d
jne 0x5fa43
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x5fae2
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_O1/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), %rax
movq (%rax), %rax
movl 0x38(%rsi), %ecx
cmpl %ecx, 0x218(%rax)
jbe 0x5fb19
imull 0x220(%rax), %ecx
addq 0x210(%rax), %rcx
jmp 0x5fb1b
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x5fb33
cmpl $0x1, 0x8(%rsi)
jne 0x5fb35
movq 0x10(%rsi), %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x3fea3
popq %rbp
retq
movq 0x18(%rsi), %rax
movl 0x20(%rsi), %edx
movq %rax, %rsi
popq %rbp
jmp 0x3fc41
// File: /workspace/github_c_makefile_star2_O1/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 0x5fba9
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 0x5fc00
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5fc0c
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0x5fc25
movq %r15, %rdi
movq %r12, %rsi
callq 0x336fc
jmp 0x5fbe8
movl -0x60(%rbp), %edx
movq -0x68(%rbp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x412d9
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x5fc5b
movq %r15, %rsi
callq 0x3503f
movl $0x0, -0x60(%rbp)
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_O1/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 0x5fc98
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x5fd2a
movq %r12, %rax
movq 0x48(%r12), %r12
movq $0x0, 0x48(%rax)
xorl %r13d, %r13d
movq -0x130(%rbp,%r13,8), %rdi
testq %rdi, %rdi
je 0x5fcff
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ff02
movq $0x0, -0x130(%rbp,%r13,8)
incq %r13
cmpq $0x1f, %r13
jne 0x5fccb
movb $0x1, %cl
jmp 0x5fd0e
movq %rax, -0x130(%rbp,%r13,8)
cmpq $0x1f, %r13
sete %cl
testb %cl, %cl
je 0x5fcb3
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ff02
movq %rax, -0x38(%rbp)
jmp 0x5fcb3
movl $0x1, %r12d
movq -0x130(%rbp), %rax
movq -0x130(%rbp,%r12,8), %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ff02
incq %r12
cmpq $0x20, %r12
jne 0x5fd37
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_O1/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 0x5fe34
movq %rdx, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, (%rsi)
movaps %xmm0, 0x20(%rsi)
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
xorl %ecx, %ecx
movl %ecx, 0x30(%rsi)
movl $0x20, %edx
movl %edx, 0x8(%rsi)
movq (%rax), %rax
leaq -0x60(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, (%r15)
movaps %xmm0, 0x20(%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x18(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x8(%r15)
xorl %edx, %edx
callq 0x44d58
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x44d58
cmpl $0x5, %ebx
jne 0x5fe4b
testb $0x1, -0x98(%rbp)
jne 0x5fe23
leaq -0xa0(%rbp), %rdi
callq 0x3fb4d
testb $0x1, -0x58(%rbp)
jne 0x5fe60
leaq -0x60(%rbp), %rdi
callq 0x3fb4d
jmp 0x5fe60
movq %r14, %rsi
xorl %edx, %edx
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x45abe
leaq -0xa0(%rbp), %rdi
callq 0x4494c
leaq -0x60(%rbp), %rdi
callq 0x4494c
leaq -0xa0(%rbp), %rbx
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x450b0
movl %eax, %r15d
movq %rbx, %rdi
callq 0x309f2
movq %r14, %rdi
callq 0x309f2
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5fef0
xorl %r15d, %r15d
cmpl $0x2, 0x8(%r14)
jne 0x5fed6
leaq 0x10(%r14), %rdi
callq 0x31d8f
movl $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x5f920
incl %r15d
movq %r14, %rax
movq 0x48(%r14), %r14
cmpl 0x2c(%rbx), %r15d
jb 0x5febe
jmp 0x5fef3
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_O1/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 0x5ff93
movq %rdi, %r15
movq %rsi, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
js 0x5ff68
movq %r12, 0x48(%r13)
movq %r13, 0x40(%r12)
movq 0x48(%r12), %rsi
movq %r15, %rdi
movq %r12, %r13
jmp 0x5ff7a
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 0x5ff93
movq %rdi, %r15
movq %rsi, %r12
testq %rsi, %rsi
jne 0x5ff42
testb %cl, %cl
je 0x5ffa1
movq %rdi, 0x48(%r13)
movq %r13, 0x40(%rdi)
jmp 0x5ffb7
testb %al, %al
je 0x5ffaf
movq %rsi, 0x48(%r13)
movq %r13, 0x40(%rsi)
jmp 0x5ffb7
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_O1/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, -0x20(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x20, -0x48(%rbp)
movq (%rcx), %rdi
movl 0x38(%rax), %eax
cmpl %eax, 0x218(%rdi)
jbe 0x6013a
imull 0x220(%rdi), %eax
addq 0x210(%rdi), %rax
jmp 0x6013c
xorl %eax, %eax
movq (%rsi), %rcx
movq (%rcx), %rcx
movl 0x38(%rsi), %esi
cmpl %esi, 0x218(%rcx)
jbe 0x6015d
imull 0x220(%rcx), %esi
addq 0x210(%rcx), %rsi
jmp 0x6015f
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 0x412d9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x60196
testb $0x2, -0x48(%rbp)
jne 0x60193
leaq -0x50(%rbp), %rdi
callq 0x3fd5f
movl -0x50(%rbp), %ebx
leaq -0x50(%rbp), %rdi
callq 0x309f2
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x601f0
testl %edx, %edx
je 0x601cf
setg %cl
movzbl %cl, %ecx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, 0x20(%rsi)
testq %rax, %rax
je 0x601f0
movq (%rax), %rcx
movq (%rcx), %rcx
movl 0x38(%rax), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x601f6
imull 0x220(%rcx), %eax
addq 0x210(%rcx), %rax
jmp 0x601f8
movq 0x8(%rdi), %rbx
jmp 0x60212
xorl %eax, %eax
movq 0x8(%rdi), %rbx
testq %rax, %rax
je 0x60212
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ebc8
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x602a2
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x602a2
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x60288
cmpq $0x0, 0x10(%r14)
je 0x60288
xorl %esi, %esi
callq 0x30b04
movq %rax, %rdi
callq *0x10(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x602b5
movq 0x8(%rax), %rcx
leaq 0x192bf(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x60336
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60336
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x6031c
cmpq $0x0, 0x18(%r14)
je 0x6031c
xorl %esi, %esi
callq 0x30b04
movq %rax, %rdi
callq *0x18(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x60349
movq 0x8(%rax), %rcx
leaq 0x1922b(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x6039a
cmpq $0x0, 0x20(%r14)
je 0x6039a
movq 0x8(%rbx), %rdi
leaq 0x192e1(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
movq %rbx, %rdi
callq *0x20(%r14)
testl %eax, %eax
jne 0x603b4
jmp 0x603d8
movq 0x8(%rax), %rcx
leaq 0x191ad(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
addq $0x8, %rbx
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x6044b
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x6044b
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x60431
cmpq $0x0, 0x30(%r14)
je 0x60431
xorl %esi, %esi
callq 0x30b04
movq %rax, %rdi
callq *0x30(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x6045e
movq 0x8(%rax), %rcx
leaq 0x19116(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x604df
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x604df
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x604c5
cmpq $0x0, 0x38(%r14)
je 0x604c5
xorl %esi, %esi
callq 0x30b04
movq %rax, %rdi
callq *0x38(%r14)
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x604f2
movq 0x8(%rax), %rcx
leaq 0x19082(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x60570
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60570
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x60556
cmpq $0x0, 0x28(%r12)
je 0x60556
movl %esi, %r15d
xorl %esi, %esi
callq 0x30b04
movl $0x1ff, %r13d           # imm = 0x1FF
cmpl $0x1, %r15d
jne 0x605a2
xorl %edx, %edx
jmp 0x605d3
movq 0x8(%rax), %rcx
leaq 0x18ff1(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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 0x3fd5f
movl (%r13), %r13d
cmpl $0x3, %r15d
jl 0x605cd
movq 0x10(%r14), %r14
movq %r14, %rdi
callq 0x446ef
movl (%r14), %edx
jmp 0x605cf
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 0x309f2
movq %r14, (%rbx)
jmp 0x60583
// File: /workspace/github_c_makefile_star2_O1/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 0x60689
movq %rdx, %r14
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x60689
movq 0x8(%r14), %rax
testb $0x1, 0x8(%rax)
je 0x60689
movq (%rbx), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x6066f
cmpq $0x0, 0x40(%r12)
je 0x6066f
xorl %esi, %esi
callq 0x30b04
movq %rax, %r15
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x30b04
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 0x309f2
movq %r14, (%rbx)
jmp 0x6069c
movq 0x8(%rax), %rcx
leaq 0x18ed8(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x6072b
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x8(%rax)
je 0x6072b
movq (%rbx), %rax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x60711
cmpq $0x0, 0x48(%r15)
je 0x60711
movq 0x8(%rbx), %rdi
leaq 0x18f77(%rip), %rsi     # 0x79667
xorl %edx, %edx
callq 0x3087c
movq (%r14), %rdi
xorl %esi, %esi
callq 0x30b04
movq %rax, %rdi
movq %rbx, %rsi
callq *0x48(%r15)
testl %eax, %eax
jne 0x6072b
jmp 0x6074f
movq 0x8(%rax), %rcx
leaq 0x18e36(%rip), %rdx     # 0x79552
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
addq $0x8, %rbx
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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