LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendStrDup
JX9_PRIVATE char * SyMemBackendStrDup(SyMemBackend *pBackend, const char *zSrc, sxu32 nSize)
{
	char *zDest;
	zDest = (char *)SyMemBackendAlloc(&(*pBackend), nSize + 1);
	if( zDest ){
		Systrcpy(zDest, nSize+1, zSrc, nSize);
	}
	return zDest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
leal 0x1(%rbx), %r15d
movl %r15d, %esi
callq 0x343ed
movq %rax, %r12
testq %rax, %rax
je 0x3e459
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x34438
movq %r12, %rax
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: SyBlobAppendBig32
JX9_PRIVATE sxi32 SyBlobAppendBig32(SyBlob *pBlob,sxu32 n32)
{
	unsigned char zBuf[4];
	sxi32 rc;
	SyBigEndianPack32(zBuf,n32);
	rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
bswapl %esi
leaq -0x4(%rbp), %rax
movl %esi, (%rax)
movq %rax, %rsi
movl $0x4, %edx
callq 0x360ae
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjStore
JX9_PRIVATE sxi32 jx9MemObjStore(jx9_value *pSrc, jx9_value *pDest)
{
	jx9_hashmap *pMap = 0;
	sxi32 rc;
	if( pSrc->iFlags & MEMOBJ_HASHMAP ){
		/* Increment reference count */
		((jx9_hashmap *)pSrc->x.pOther)->iRef++;
	}
	if( pDest->iFlags & MEMOBJ_HASHMAP ){
		pMap = (jx9_hashmap *)pDest->x.pOther;
	}
	SyMemcpy((const void *)&(*pSrc), &(*pDest), sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
	rc = SXRET_OK;
	if( SyBlobLength(&pSrc->sBlob) > 0 ){
		SyBlobReset(&pDest->sBlob);
		rc = SyBlobDup(&pSrc->sBlob, &pDest->sBlob);
	}else{
		if( SyBlobLength(&pDest->sBlob) > 0 ){
			SyBlobRelease(&pDest->sBlob);
		}
	}
	if( pMap ){
		jx9HashmapUnref(pMap);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
testb $0x40, 0x8(%rdi)
je 0x3ebe4
movq (%r15), %rax
incl 0x50(%rax)
testb $0x40, 0x8(%r14)
jne 0x3ebef
xorl %ebx, %ebx
jmp 0x3ebf2
movq (%r14), %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq 0x34fc5
cmpl $0x0, 0x28(%r15)
je 0x3ec4d
movl $0x0, 0x28(%r14)
movl 0x30(%r14), %eax
testb $0x4, %al
je 0x3ec30
movq $0x0, 0x20(%r14)
movl $0x0, 0x2c(%r14)
andl $-0x5, %eax
movl %eax, 0x30(%r14)
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x3ec65
addq $0x18, %r14
movq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x360ae
movl %eax, %r15d
jmp 0x3ec68
xorl %r15d, %r15d
cmpl $0x0, 0x28(%r14)
je 0x3ec68
addq $0x18, %r14
movq %r14, %rdi
callq 0x31d8f
jmp 0x3ec68
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x3ec88
movl 0x50(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rbx)
cmpl $0x1, %eax
jg 0x3ec88
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3eda2
movl %r15d, %eax
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: jx9HashmapExtractNodeKey
JX9_PRIVATE void jx9HashmapExtractNodeKey(jx9_hashmap_node *pNode,jx9_value *pKey)
{
	/* Fill with the current key */
	if( pNode->iType == HASHMAP_INT_NODE ){
		if( SyBlobLength(&pKey->sBlob) > 0 ){
			SyBlobRelease(&pKey->sBlob);
		}
		pKey->x.iVal = pNode->xKey.iKey;
		MemObjSetType(pKey, MEMOBJ_INT);
	}else{
		SyBlobReset(&pKey->sBlob);
		SyBlobAppend(&pKey->sBlob, SyBlobData(&pNode->xKey.sKey), SyBlobLength(&pNode->xKey.sKey));
		MemObjSetType(pKey, MEMOBJ_STRING);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x8(%rdi)
jne 0x3ed57
cmpl $0x0, 0x28(%rbx)
je 0x3ed49
leaq 0x18(%rbx), %rdi
callq 0x31d8f
movq 0x10(%r14), %rax
movq %rax, (%rbx)
movl $0x2, %eax
jmp 0x3ed90
leaq 0x18(%rbx), %rdi
movl $0x0, 0x28(%rbx)
movl 0x30(%rbx), %eax
testb $0x4, %al
je 0x3ed7e
movq $0x0, 0x20(%rbx)
movl $0x0, 0x2c(%rbx)
andl $-0x5, %eax
movl %eax, 0x30(%rbx)
movq 0x18(%r14), %rsi
movl 0x20(%r14), %edx
callq 0x360ae
movl $0x1, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapRelease
JX9_PRIVATE sxi32 jx9HashmapRelease(jx9_hashmap *pMap, int FreeDS)
{
	jx9_hashmap_node *pEntry, *pNext;
	jx9_vm *pVm = pMap->pVm;
	sxu32 n;
	/* Start the release process */
	n = 0;
	pEntry = pMap->pFirst;
	for(;;){
		if( n >= pMap->nEntry ){
			break;
		}
		pNext = pEntry->pPrev; /* Reverse link */
		/* Restore the jx9_value to the free list */
		jx9VmUnsetMemObj(pVm, pEntry->nValIdx);
		/* Release the node */
		if( pEntry->iType == HASHMAP_BLOB_NODE ){
			SyBlobRelease(&pEntry->xKey.sKey);
		}
		SyMemBackendPoolFree(&pVm->sAllocator, pEntry);
		/* Point to the next entry */
		pEntry = pNext;
		n++;
	}
	if( pMap->nEntry > 0 ){
		/* Release the hash bucket */
		SyMemBackendFree(&pVm->sAllocator, pMap->apBucket);
	}
	if( FreeDS ){
		/* Free the whole instance */
		SyMemBackendPoolFree(&pVm->sAllocator, pMap);
	}else{
		/* Keep the instance but reset it's fields */
		pMap->apBucket = 0;
		pMap->iNextIdx = 0;
		pMap->nEntry = pMap->nSize = 0;
		pMap->pFirst = pMap->pLast = pMap->pCur = 0;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0x2c(%rdi)
je 0x3ee1b
movl %r15d, -0x2c(%rbp)
movq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq 0x48(%r12), %r15
movl 0x38(%r12), %esi
movq %r14, %rdi
callq 0x3ee5d
cmpl $0x2, 0x8(%r12)
jne 0x3edee
leaq 0x10(%r12), %rdi
callq 0x31d8f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2eb38
incl %r13d
movl 0x2c(%rbx), %eax
movq %r15, %r12
cmpl %eax, %r13d
jb 0x3edca
testl %eax, %eax
movl -0x2c(%rbp), %r15d
je 0x3ee1b
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3503f
testl %r15d, %r15d
je 0x3ee39
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2eb38
xorl %eax, %eax
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movq %rax, 0x28(%rbx)
addq $0x8, %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: jx9VmUnsetMemObj
JX9_PRIVATE sxi32 jx9VmUnsetMemObj(jx9_vm *pVm,sxu32 nObjIdx)
{
	jx9_value *pObj;
	pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nObjIdx);
	if( pObj ){
		VmSlot sFree;
		/* Release the object */
		jx9MemObjRelease(pObj);
		/* Restore to the free list */
		sFree.nIdx = nObjIdx;
		sFree.pUserData = 0;
		SySetPut(&pVm->aFreeObj, (const void *)&sFree);
	}				
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x218(%rdi)
jbe 0x3ee89
movl 0x220(%rbx), %edi
imull %r14d, %edi
addq 0x210(%rbx), %rdi
jmp 0x3ee8b
xorl %edi, %edi
testq %rdi, %rdi
je 0x3eeb3
callq 0x309f2
leaq -0x20(%rbp), %rsi
movl %r14d, (%rsi)
movq $0x0, 0x8(%rsi)
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
callq 0x336fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjStringAppend
JX9_PRIVATE sxi32 jx9MemObjStringAppend(jx9_value *pObj, const char *zData, sxu32 nLen)
{
	sxi32 rc;
	if( (pObj->iFlags & MEMOBJ_STRING) == 0 ){
		/* Invalidate any prior representation */
		jx9MemObjRelease(pObj);
		MemObjSetType(pObj, MEMOBJ_STRING);
	}
	/* Append contents */
	rc = SyBlobAppend(&pObj->sBlob, zData, nLen);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testb $0x1, 0x8(%rdi)
jne 0x3f825
movq %r15, %rdi
callq 0x309f2
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%r15), %eax
incl %eax
movl %eax, 0x8(%r15)
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x360ae
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9NewHashmap
JX9_PRIVATE jx9_hashmap * jx9NewHashmap(
	jx9_vm *pVm,              /* VM that trigger the hashmap creation */
	sxu32 (*xIntHash)(sxi64), /* Hash function for int keys.NULL otherwise*/
	sxu32 (*xBlobHash)(const void *, sxu32) /* Hash function for BLOB keys.NULL otherwise */
	)
{
	jx9_hashmap *pMap;
	/* Allocate a new instance */
	pMap = (jx9_hashmap *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_hashmap));
	if( pMap == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pMap, sizeof(jx9_hashmap));
	/* Fill in the structure */
	pMap->pVm = &(*pVm);
	pMap->iRef = 1;
	/* pMap->iFlags = 0; */
	/* Default hash functions */
	pMap->xIntHash  = xIntHash ? xIntHash : IntHash;
	pMap->xBlobHash = xBlobHash ? xBlobHash : BinHash;
	return pMap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x58, %esi
callq 0x2e951
testq %rax, %rax
je 0x3f893
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x54, %rcx
jb 0x3f85f
movq %rbx, (%rax)
movl $0x1, 0x50(%rax)
leaq 0x1a(%rip), %rcx        # 0x3f89c
movq %rcx, 0x30(%rax)
leaq 0x25(%rip), %rcx        # 0x3f8b2
movq %rcx, 0x38(%rax)
jmp 0x3f895
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: jx9MemObjToString
JX9_PRIVATE sxi32 jx9MemObjToString(jx9_value *pObj)
{
	sxi32 rc = SXRET_OK;
	if( (pObj->iFlags & MEMOBJ_STRING) == 0 ){
		/* Perform the conversion */
		SyBlobReset(&pObj->sBlob); /* Reset the internal buffer */
		rc = MemObjStringValue(&pObj->sBlob, &(*pObj));
		MemObjSetType(pObj, MEMOBJ_STRING);
	}
	return rc;
}

// Assembly:
testb $0x1, 0x8(%rdi)
jne 0x3fb9e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movl $0x0, 0x28(%rbx)
movl 0x30(%rbx), %eax
testb $0x4, %al
je 0x3fb83
movq $0x0, 0x20(%rbx)
movl $0x0, 0x2c(%rbx)
andl $-0x5, %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rsi
callq 0x3ff83
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapLookupBlobKey
static sxi32 HashmapLookupBlobKey(
	jx9_hashmap *pMap,          /* Target hashmap */
	const void *pKey,           /* Lookup key */
	sxu32 nKeyLen,              /* Key length in bytes */
	jx9_hashmap_node **ppNode   /* OUT: target node on success */
	)
{
	jx9_hashmap_node *pNode;
	sxu32 nHash;
	if( pMap->nEntry < 1 ){
		/* Don't bother hashing, there is no entry anyway */
		return SXERR_NOTFOUND;
	}
	/* Hash the key first */
	nHash = pMap->xBlobHash(pKey, nKeyLen);
	/* Point to the appropriate bucket */
	pNode = pMap->apBucket[nHash & (pMap->nSize - 1)];
	/* Perform the lookup */
	for(;;){
		if( pNode == 0 ){
			break;
		}
		if( pNode->iType == HASHMAP_BLOB_NODE 
			&& pNode->nHash == nHash
			&& SyBlobLength(&pNode->xKey.sKey) == nKeyLen 
			&& SyMemcmp(SyBlobData(&pNode->xKey.sKey), pKey, nKeyLen) == 0 ){
				/* Node found */
				if( ppNode ){
					*ppNode = pNode;
				}
				return SXRET_OK;
		}
		/* Follow the collision link */
		pNode = pNode->pNextCollide;
	}
	/* No such entry */
	return SXERR_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
cmpl $0x0, 0x2c(%rdi)
je 0x3fc23
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, -0x30(%rbp)
movq %rsi, %rdi
movl %edx, %esi
callq *0x38(%r14)
movl %eax, %r13d
movq 0x8(%r14), %rax
movl 0x28(%r14), %ecx
decl %ecx
andl %r13d, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x3fc23
cmpl $0x2, 0x8(%r14)
jne 0x3fc0f
cmpl %r13d, 0x34(%r14)
jne 0x3fc0f
cmpl %r15d, 0x20(%r14)
jne 0x3fc0f
movq 0x18(%r14), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x34ebe
testl %eax, %eax
je 0x3fc15
movq 0x50(%r14), %r14
jmp 0x3fbe4
xorl %ebx, %ebx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x3fc23
movq %r14, (%rax)
movl %ebx, %eax
addq $0x8, %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: HashmapInsertBlobKey
static sxi32 HashmapInsertBlobKey(jx9_hashmap *pMap,const void *pKey,sxu32 nKeyLen,jx9_value *pValue)
{
	jx9_hashmap_node *pNode;
	jx9_value *pObj;
	sxu32 nHash;
	sxu32 nIdx;
	sxi32 rc;
	/* Reserve a jx9_value for the value */
	pObj = jx9VmReserveMemObj(pMap->pVm,&nIdx);
	if( pObj == 0 ){
		return SXERR_MEM;
	}
	if( pValue ){
		/* Duplicate the value */
		jx9MemObjStore(pValue, pObj);
	}
	/* Hash the key */
	nHash = pMap->xBlobHash(pKey, nKeyLen);
	/* Allocate a new blob node */
	pNode = HashmapNewBlobNode(&(*pMap), pKey, nKeyLen, nHash, nIdx);
	if( pNode == 0 ){
		return SXERR_MEM;
	}
	/* Make sure the bucket is big enough to hold the new entry */
	rc = HashmapGrowBucket(&(*pMap));
	if( rc != SXRET_OK ){
		SyMemBackendPoolFree(&pMap->pVm->sAllocator, pNode);
		return rc;
	}
	/* Perform the insertion */
	HashmapNodeLink(&(*pMap), pNode, nHash & (pMap->nSize - 1));
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0x38(%rbp), %rsi
callq 0x40355
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3fd4d
testq %r12, %r12
je 0x3fc89
movq %r12, %rdi
movq %rax, %rsi
callq 0x3ebc8
movq %r13, %rdi
movl %r15d, %esi
callq *0x38(%rbx)
movl %r15d, -0x30(%rbp)
movl %eax, %r15d
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movq (%rbx), %rdi
movl $0x60, %esi
callq 0x2e951
testq %rax, %rax
movl %r15d, -0x2c(%rbp)
je 0x3fd13
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
addq $0x10, %rdi
movq %rbx, (%rax)
movl $0x2, 0x8(%rax)
movl %r15d, 0x34(%rax)
movq (%rbx), %rax
movups %xmm0, 0x18(%r12)
movq %rax, 0x10(%r12)
movl $0x0, 0x28(%r12)
movq %r13, %rsi
movl -0x30(%rbp), %edx
callq 0x360ae
movl -0x34(%rbp), %eax
movl %eax, 0x38(%r12)
jmp 0x3fd16
xorl %r12d, %r12d
testq %r12, %r12
je 0x3fd4d
movq %rbx, %rdi
callq 0x4041a
testl %eax, %eax
je 0x3fd37
movl %eax, %r14d
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x2eb38
jmp 0x3fd4d
movl 0x28(%rbx), %edx
decl %edx
andl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40521
xorl %r14d, %r14d
movl %r14d, %eax
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: jx9MemObjToInteger
JX9_PRIVATE sxi32 jx9MemObjToInteger(jx9_value *pObj)
{
	if( (pObj->iFlags & MEMOBJ_INT) == 0 ){
		/* Preform the conversion */
		pObj->x.iVal = MemObjIntValue(&(*pObj));
		/* Invalidate any prior representations */
		SyBlobRelease(&pObj->sBlob);
		MemObjSetType(pObj, MEMOBJ_INT);
	}
	return SXRET_OK;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x2, %al
jne 0x3fe08
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x4, %al
jne 0x3fd9b
testb $0x8, %al
jne 0x3fdc8
testb $0x1, %al
jne 0x3fdcd
testb $0x20, %al
jne 0x3fd96
testb $0x40, %al
jne 0x3fe0b
btl $0x8, %eax
jb 0x3fe2c
xorl %r14d, %r14d
jmp 0x3fde6
movsd (%rbx), %xmm0
movapd 0x35819(%rip), %xmm1    # 0x755c0
andpd %xmm0, %xmm1
ucomisd 0x3589d(%rip), %xmm1    # 0x75650
cvttsd2si %xmm0, %rax
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
cmovbeq %rax, %r14
jmp 0x3fde6
movq (%rbx), %r14
jmp 0x3fde6
movq 0x20(%rbx), %rax
leaq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movl 0x28(%rbx), %eax
movl %eax, 0x8(%rdi)
callq 0x405c7
movq %rax, %r14
movq %r14, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x31d8f
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
movq (%rbx), %rdi
movl 0x2c(%rdi), %r14d
movl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rdi)
cmpl $0x1, %eax
jg 0x3fde6
movl $0x1, %esi
callq 0x3eda2
jmp 0x3fde6
xorl %r14d, %r14d
cmpq $0x0, (%rbx)
setne %r14b
jmp 0x3fde6
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapLookupIntKey
static sxi32 HashmapLookupIntKey(
	jx9_hashmap *pMap,         /* Target hashmap */
	sxi64 iKey,                /* lookup key */
	jx9_hashmap_node **ppNode  /* OUT: target node on success */
	)
{
	jx9_hashmap_node *pNode;
	sxu32 nHash;
	if( pMap->nEntry < 1 ){
		/* Don't bother hashing, there is no entry anyway */
		return SXERR_NOTFOUND;
	}
	/* Hash the key first */
	nHash = pMap->xIntHash(iKey);
	/* Point to the appropriate bucket */
	pNode = pMap->apBucket[nHash & (pMap->nSize - 1)];
	/* Perform the lookup */
	for(;;){
		if( pNode == 0 ){
			break;
		}
		if( pNode->iType == HASHMAP_INT_NODE
			&& pNode->nHash == nHash
			&& pNode->xKey.iKey == iKey ){
				/* Node found */
				if( ppNode ){
					*ppNode = pNode;
				}
				return SXRET_OK;
		}
		/* Follow the collision link */
		pNode = pNode->pNextCollide;
	}
	/* No such entry */
	return SXERR_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
cmpl $0x0, 0x2c(%rdi)
je 0x3fe98
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq *0x30(%r12)
movq 0x8(%r12), %rcx
movl 0x28(%r12), %edx
decl %edx
andl %eax, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x3fe98
cmpl $0x1, 0x8(%rcx)
jne 0x3fe88
cmpl %eax, 0x34(%rcx)
jne 0x3fe88
cmpq %r15, 0x10(%rcx)
je 0x3fe8e
movq 0x50(%rcx), %rcx
jmp 0x3fe72
xorl %ebx, %ebx
testq %r14, %r14
je 0x3fe98
movq %rcx, (%r14)
movl %ebx, %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: HashmapInsertIntKey
static sxi32 HashmapInsertIntKey(jx9_hashmap *pMap,sxi64 iKey,jx9_value *pValue)
{
	jx9_hashmap_node *pNode;
	jx9_value *pObj;
	sxu32 nIdx;
	sxu32 nHash;
	sxi32 rc;
	/* Reserve a jx9_value for the value */
	pObj = jx9VmReserveMemObj(pMap->pVm,&nIdx);
	if( pObj == 0 ){
		return SXERR_MEM;
	}
	if( pValue ){
		/* Duplicate the value */
		jx9MemObjStore(pValue, pObj);
	}	
	/* Hash the key */
	nHash = pMap->xIntHash(iKey);
	/* Allocate a new int node */
	pNode = HashmapNewIntNode(&(*pMap), iKey, nHash, nIdx);
	if( pNode == 0 ){
		return SXERR_MEM;
	}
	/* Make sure the bucket is big enough to hold the new entry */
	rc = HashmapGrowBucket(&(*pMap));
	if( rc != SXRET_OK ){
		SyMemBackendPoolFree(&pMap->pVm->sAllocator, pNode);
		return rc;
	}
	/* Perform the insertion */
	HashmapNodeLink(&(*pMap), pNode, nHash & (pMap->nSize - 1));
	/* All done */
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x40355
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3ff72
testq %r12, %r12
je 0x3fee4
movq %r12, %rdi
movq %rax, %rsi
callq 0x3ebc8
movq %r15, %rdi
callq *0x30(%r14)
movl %eax, %ebx
movl -0x2c(%rbp), %r12d
movq (%r14), %rdi
movl $0x60, %esi
callq 0x2e951
testq %rax, %rax
je 0x3ff37
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x20(%rax)
movq %r14, (%rax)
movl $0x1, 0x8(%rax)
movl %ebx, 0x34(%rax)
movq %r15, 0x10(%rax)
movl %r12d, 0x38(%rax)
jmp 0x3ff3a
xorl %r13d, %r13d
testq %r13, %r13
je 0x3ff56
movq %r14, %rdi
callq 0x4041a
testl %eax, %eax
je 0x3ff5d
movq (%r14), %rdi
movq %r13, %rsi
callq 0x2eb38
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x3ff72
movl 0x28(%r14), %edx
decl %edx
andl %ebx, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x40521
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %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: MemObjStringValue
static sxi32 MemObjStringValue(SyBlob *pOut,jx9_value *pObj)
{
	if( pObj->iFlags & MEMOBJ_REAL ){
		SyBlobFormat(&(*pOut), "%.15g", pObj->x.rVal);
	}else if( pObj->iFlags & MEMOBJ_INT ){
		SyBlobFormat(&(*pOut), "%qd", pObj->x.iVal);
		/* %qd (BSD quad) is equivalent to %lld in the libc printf */
	}else if( pObj->iFlags & MEMOBJ_BOOL ){
		if( pObj->x.iVal ){
			SyBlobAppend(&(*pOut),"true", sizeof("true")-1);
		}else{
			SyBlobAppend(&(*pOut),"false", sizeof("false")-1);
		}
	}else if( pObj->iFlags & MEMOBJ_HASHMAP ){
		/* Serialize JSON object or array */
		jx9JsonSerialize(pObj,pOut);
		jx9HashmapUnref((jx9_hashmap *)pObj->x.pOther);
	}else if(pObj->iFlags & MEMOBJ_RES ){
		SyBlobFormat(&(*pOut), "ResourceID_%#x", pObj->x.pOther);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x8(%rsi), %eax
testb $0x4, %al
jne 0x3ffb8
testb $0x2, %al
jne 0x3ffd0
testb $0x8, %al
jne 0x3ffe7
testb $0x40, %al
jne 0x3fffb
btl $0x8, %eax
jae 0x40034
movq (%rbx), %rdx
leaq 0x360c6(%rip), %rsi     # 0x7607c
jmp 0x3ffda
movsd (%rbx), %xmm0
leaq 0x360b3(%rip), %rsi     # 0x76076
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3ec96
movq (%rbx), %rdx
leaq 0x360f9(%rip), %rsi     # 0x760d3
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3ec96
cmpq $0x0, (%rbx)
je 0x4003b
leaq 0x33c83(%rip), %rsi     # 0x73c77
movl $0x4, %edx
jmp 0x40047
leaq -0x20(%rbp), %rsi
movl $0x0, 0x10(%rsi)
movq %rdi, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0x40052
movq (%rbx), %rdi
movl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rdi)
cmpl $0x1, %eax
jg 0x40034
movl $0x1, %esi
callq 0x3eda2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x33c3a(%rip), %rsi     # 0x73c7c
movl $0x5, %edx
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x360ae
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonObjectEncode
static int VmJsonObjectEncode(jx9_value *pKey,jx9_value *pValue,void *pUserData)
{
	json_private_data *pJson = (json_private_data *)pUserData;
	const char *zKey;
	int nByte;
	if( pJson->nRecCount > 31 ){
		/* Recursion limit reached, return immediately */
		return JX9_OK;
	}
	if( !pJson->isFirst ){
		/* Append the colon first */
		SyBlobAppend(pJson->pOut,",",sizeof(char));
	}
	/* Extract a string representation of the key */
	zKey = jx9_value_to_string(pKey, &nByte);
	/* Append the key and the double colon */
	if( nByte > 0 ){
		SyBlobAppend(pJson->pOut,"\"",sizeof(char));
		SyBlobAppend(pJson->pOut,zKey,(sxu32)nByte);
		SyBlobAppend(pJson->pOut,"\"",sizeof(char));
	}else{
		/* Can't happen */
		SyBlobAppend(pJson->pOut,"null",sizeof("null")-1);
	}
	SyBlobAppend(pJson->pOut,":",sizeof(char));
	/* Encode the value */
	pJson->nRecCount++;
	VmJsonEncode(pValue, pJson);
	pJson->nRecCount--;
	pJson->isFirst = 0;
	return JX9_OK;
}

// Assembly:
cmpl $0x1f, 0x10(%rdx)
jg 0x40306
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x8(%rdx)
jne 0x40272
movq (%rbx), %rdi
leaq 0x336e7(%rip), %rsi     # 0x7394f
movl $0x1, %edx
callq 0x360ae
leaq -0x24(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30b04
cmpl $0x0, (%r12)
movq (%rbx), %rdi
jle 0x402bd
movq %rax, %r15
leaq 0x339dd(%rip), %r12     # 0x73c72
movq %r12, %rsi
movl $0x1, %edx
callq 0x360ae
movq (%rbx), %rdi
movl -0x24(%rbp), %edx
movq %r15, %rsi
callq 0x360ae
movq (%rbx), %rdi
movq %r12, %rsi
movl $0x1, %edx
jmp 0x402c9
leaq 0x38810(%rip), %rsi     # 0x78ad4
movl $0x4, %edx
callq 0x360ae
movq (%rbx), %rdi
leaq 0x3399d(%rip), %rsi     # 0x73c75
movl $0x1, %edx
callq 0x360ae
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40052
decl 0x10(%rbx)
movl $0x0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmJsonArrayEncode
static int VmJsonArrayEncode(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
	json_private_data *pJson = (json_private_data *)pUserData;
	if( pJson->nRecCount > 31 ){
		/* Recursion limit reached, return immediately */
		SXUNUSED(pKey); /* cc warning */
		return JX9_OK;
	}
	if( !pJson->isFirst ){
		/* Append the colon first */
		SyBlobAppend(pJson->pOut,",",(int)sizeof(char));
	}
	/* Encode the value */
	pJson->nRecCount++;
	VmJsonEncode(pValue, pJson);
	pJson->nRecCount--;
	pJson->isFirst = 0;
	return JX9_OK;
}

// Assembly:
cmpl $0x1f, 0x10(%rdx)
jg 0x40352
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x8(%rdx)
jne 0x40336
movq (%rbx), %rdi
leaq 0x33623(%rip), %rsi     # 0x7394f
movl $0x1, %edx
callq 0x360ae
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40052
decl 0x10(%rbx)
movl $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9VmReserveMemObj
JX9_PRIVATE jx9_value * jx9VmReserveMemObj(jx9_vm *pVm,sxu32 *pIdx)
{
	jx9_value *pObj = 0;
	VmSlot *pSlot;
	sxu32 nIdx;
	/* Check for a free slot */
	nIdx = SXU32_HIGH; /* cc warning */
	pSlot = (VmSlot *)SySetPop(&pVm->aFreeObj);
	if( pSlot ){
		pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pSlot->nIdx);
		nIdx = pSlot->nIdx;
	}
	if( pObj == 0 ){
		/* Reserve a new memory object */
		pObj = VmReserveMemObj(&(*pVm), &nIdx);
		if( pObj == 0 ){
			return 0;
		}
	}
	/* Set a null default value */
	jx9MemObjInit(&(*pVm), pObj);
	if( pIdx ){
		*pIdx = nIdx;
	}
	pObj->nIdx = nIdx;
	return pObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl 0x270(%rdi), %eax
testl %eax, %eax
je 0x40391
decl %eax
movl %eax, 0x270(%r14)
imull 0x278(%r14), %eax
addq 0x268(%r14), %rax
jmp 0x40393
xorl %eax, %eax
testq %rax, %rax
je 0x403b6
movl (%rax), %ecx
cmpl %ecx, 0x218(%r14)
jbe 0x403ba
movl 0x220(%r14), %eax
imull %ecx, %eax
addq 0x210(%r14), %rax
jmp 0x403bc
xorl %eax, %eax
jmp 0x403bf
xorl %eax, %eax
movl %ecx, -0x14(%rbp)
testq %rax, %rax
jne 0x403d5
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x40575
testq %rax, %rax
je 0x40416
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x0, 0x30(%rax)
movl $0x20, 0x8(%rax)
testq %rbx, %rbx
je 0x40407
movl -0x14(%rbp), %ecx
movl %ecx, (%rbx)
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x4040d
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapGrowBucket
static sxi32 HashmapGrowBucket(jx9_hashmap *pMap)
{
	if( pMap->nEntry >= pMap->nSize * HASHMAP_FILL_FACTOR ){
		jx9_hashmap_node **apOld = pMap->apBucket;
		jx9_hashmap_node *pEntry, **apNew;
		sxu32 nNew = pMap->nSize << 1;
		sxu32 nBucket;
		sxu32 n;
		if( nNew < 1 ){
			nNew = 16;
		}
		/* Allocate a new bucket */
		apNew = (jx9_hashmap_node **)SyMemBackendAlloc(&pMap->pVm->sAllocator, nNew * sizeof(jx9_hashmap_node *));
		if( apNew == 0 ){
			if( pMap->nSize < 1 ){
				return SXERR_MEM; /* Fatal */
			}
			/* Not so fatal here, simply a performance hit */
			return SXRET_OK;
		}
		/* Zero the table */
		SyZero((void *)apNew, nNew * sizeof(jx9_hashmap_node *));
		/* Reflect the change */
		pMap->apBucket = apNew;
		pMap->nSize = nNew;
		if( apOld == 0 ){
			/* First allocated table [i.e: no entry], return immediately */
			return SXRET_OK;
		}
		/* Rehash old entries */
		pEntry = pMap->pFirst;
		n = 0;
		for( ;; ){
			if( n >= pMap->nEntry ){
				break;
			}
			/* Clear the old collision link */
			pEntry->pNextCollide = pEntry->pPrevCollide = 0;
			/* Link to the new bucket */
			nBucket = pEntry->nHash & (nNew - 1);
			if( pMap->apBucket[nBucket] != 0 ){
				pEntry->pNextCollide = pMap->apBucket[nBucket];
				pMap->apBucket[nBucket]->pPrevCollide = pEntry;
			}
			pMap->apBucket[nBucket] = pEntry;
			/* Point to the next entry */
			pEntry = pEntry->pPrev; /* Reverse link */
			n++;
		}
		/* Free the old table */
		SyMemBackendFree(&pMap->pVm->sAllocator, (void *)apOld);
	}
	return SXRET_OK;
}

// Assembly:
movl 0x28(%rdi), %eax
leal (%rax,%rax,2), %ecx
cmpl %ecx, 0x2c(%rdi)
jb 0x4051e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r14
addl %eax, %eax
movl $0x10, %r12d
cmovnel %eax, %r12d
leal (,%r12,8), %r15d
movl %r15d, %esi
callq 0x343ed
testq %rax, %rax
je 0x404ff
testl %r15d, %r15d
je 0x404a0
movl %r15d, %edx
movq %rax, %rcx
addq %rdx, %rcx
movq %rax, %rdx
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x404a0
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x404a0
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x404a0
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jb 0x40474
movq %rax, 0x8(%rbx)
movl %r12d, 0x28(%rbx)
testq %r14, %r14
je 0x4050e
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0x404f0
leaq 0x10(%rbx), %rcx
decl %r12d
xorps %xmm0, %xmm0
movq (%rcx), %rcx
movups %xmm0, 0x50(%rcx)
movl 0x34(%rcx), %edx
andl %r12d, %edx
movq 0x8(%rbx), %rsi
movq (%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x404e4
movq %rdi, 0x50(%rcx)
movq (%rsi,%rdx,8), %rdi
movq %rcx, 0x58(%rdi)
movq %rcx, (%rsi,%rdx,8)
addq $0x48, %rcx
decl %eax
jne 0x404be
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3503f
movb $0x1, %cl
jmp 0x40512
xorl %ecx, %ecx
cmpl $0x1, 0x28(%rbx)
movl $0x0, %eax
sbbl %eax, %eax
jmp 0x40512
xorl %eax, %eax
xorl %ecx, %ecx
testb %cl, %cl
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
je 0x40520
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapNodeLink
static void HashmapNodeLink(jx9_hashmap *pMap, jx9_hashmap_node *pNode, sxu32 nBucketIdx)
{
	/* Link */
	if( pMap->apBucket[nBucketIdx] != 0 ){
		pNode->pNextCollide = pMap->apBucket[nBucketIdx];
		pMap->apBucket[nBucketIdx]->pPrevCollide = pNode;
	}
	pMap->apBucket[nBucketIdx] = pNode;
	/* Link to the map list */
	if( pMap->pFirst == 0 ){
		pMap->pFirst = pMap->pLast = pNode;
		/* Point to the first inserted node */
		pMap->pCur = pNode;
	}else{
		MACRO_LD_PUSH(pMap->pLast, pNode);
	}
	++pMap->nEntry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x40540
movq %rdx, 0x50(%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x58(%rdx)
movq %rsi, (%rax,%rcx,8)
cmpq $0x0, 0x10(%rdi)
je 0x40561
leaq 0x18(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x4056d
movq %rcx, 0x40(%rsi)
movq %rsi, 0x48(%rcx)
jmp 0x4056d
movq %rsi, 0x18(%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x20(%rdi), %rax
movq %rsi, (%rax)
incl 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmReserveMemObj
static jx9_value * VmReserveMemObj(jx9_vm *pVm, sxu32 *pIndex)
{
	jx9_value *pObj;
	sxi32 rc;
	if( pIndex ){
		/* Object index in the object table */
		*pIndex = SySetUsed(&pVm->aMemObj);
	}
	/* Reserve a slot for the new object */
	rc = SySetPut(&pVm->aMemObj, (const void *)zDummy);
	if( rc != SXRET_OK ){
		/* If the supplied memory subsystem is so sick that we are unable to allocate
		 * a tiny chunk of memory, there is no much we can do here.
		 */
		return 0;
	}
	pObj = (jx9_value *)SySetPeek(&pVm->aMemObj);
	return pObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4058b
movl 0x218(%rbx), %eax
movl %eax, (%rsi)
leaq 0x208(%rbx), %rdi
leaq 0x34687(%rip), %rsi     # 0x74c20
callq 0x336fc
testl %eax, %eax
je 0x405a6
xorl %eax, %eax
jmp 0x405c0
movl 0x218(%rbx), %eax
testl %eax, %eax
je 0x405a2
decl %eax
imull 0x220(%rbx), %eax
addq 0x210(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9TokenValueToInt64
JX9_PRIVATE sxi64 jx9TokenValueToInt64(SyString *pVal)
{
	sxi64 iVal = 0;
	if( pVal->nByte <= 0 ){
		return 0;
	}
	if( pVal->zString[0] == '0' ){
		sxi32 c;
		if( pVal->nByte == sizeof(char) ){
			return 0;
		}
		c = pVal->zString[1];
		if( c  == 'x' || c == 'X' ){
			/* Hex digit stream */
			SyHexStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
		}else if( c == 'b' || c == 'B' ){
			/* Binary digit stream */
			SyBinaryStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
		}else{
			/* Octal digit stream */
			SyOctalStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
		}
	}else{
		/* Decimal digit stream */
		SyStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
	}
	return iVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl 0x8(%rdi), %esi
testl %esi, %esi
je 0x405eb
movq (%rdi), %rdi
cmpb $0x30, (%rdi)
jne 0x405ef
cmpl $0x1, %esi
jne 0x40602
xorl %eax, %eax
jmp 0x405fc
leaq -0x8(%rbp), %rdx
callq 0x40c31
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movzbl 0x1(%rdi), %eax
andl $-0x21, %eax
leaq -0x8(%rbp), %rdx
cmpl $0x42, %eax
je 0x4061e
cmpl $0x58, %eax
jne 0x40625
callq 0x4062c
jmp 0x405f8
callq 0x40895
jmp 0x405f8
callq 0x40a4e
jmp 0x405f8
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCollectionFetchNextRecord
UNQLITE_PRIVATE int unqliteCollectionFetchNextRecord(unqlite_col *pCol,jx9_value *pValue)
{
	int rc;
	for(;;){
		if( pCol->nCurid >= pCol->nLastid ){
			/* No more records, reset the record cursor ID */
			pCol->nCurid = 0;
			/* Return to the caller */
			return SXERR_EOF;
		}
		rc = unqliteCollectionFetchRecordById(pCol,pCol->nCurid,pValue);
		/* Increment the record ID */
		pCol->nCurid++;
		/* Lookup result */
		if( rc == UNQLITE_OK || rc != UNQLITE_NOTFOUND ){
			break;
		}
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
jge 0x40ecc
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40ee1
incq 0xb0(%rbx)
cmpl $-0x6, %eax
je 0x40ea3
jmp 0x40edc
movq $0x0, 0xb0(%rbx)
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCollectionCacheRemoveRecord
UNQLITE_PRIVATE int unqliteCollectionCacheRemoveRecord(
	unqlite_col *pCol, /* Target collection */
	jx9_int64 nId      /* Unique record ID */
	)
{
	unqlite_col_record *pRecord;
	/* Fetch the record first */
	pRecord = CollectionCacheFetchRecord(pCol,nId);
	if( pRecord == 0 ){
		/* No such record */
		return UNQLITE_NOTFOUND;
	}
	if( pRecord->pPrevCol ){
		pRecord->pPrevCol->pNextCol = pRecord->pNextCol;
	}else{
		sxu32 iBucket = COL_RECORD_HASH(nId) & (pCol->nRecSize - 1);
		pCol->apRecord[iBucket] = pRecord->pNextCol;
	}
	if( pRecord->pNextCol ){
		pRecord->pNextCol->pPrevCol = pRecord->pPrevCol;
	}
	/* Unlink */
	MACRO_LD_REMOVE(pCol->pList,pRecord);
	pCol->nRec--;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xd8(%rdi), %eax
testl %eax, %eax
je 0x41435
movq 0xc8(%rdi), %rcx
movl 0xdc(%rdi), %edx
decl %edx
movl %esi, %r8d
andl %edx, %r8d
movq (%rcx,%r8,8), %rcx
testq %rcx, %rcx
je 0x41435
cmpq %rsi, 0x8(%rcx)
je 0x41437
movq 0x50(%rcx), %rcx
jmp 0x41424
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x414b6
movq 0x58(%rcx), %rdx
testq %rdx, %rdx
je 0x4144f
movq 0x50(%rcx), %rsi
movq %rsi, 0x50(%rdx)
jmp 0x41468
movl 0xdc(%rdi), %edx
decl %edx
andl %edx, %esi
movq 0x50(%rcx), %rdx
movq 0xc8(%rdi), %r8
movq %rdx, (%r8,%rsi,8)
movq 0x50(%rcx), %rdx
testq %rdx, %rdx
je 0x41479
movq 0x58(%rcx), %rsi
movq %rsi, 0x58(%rdx)
movq 0xd0(%rdi), %rdx
cmpq %rcx, %rdx
jne 0x41490
movq 0x60(%rdx), %rdx
movq %rdx, 0xd0(%rdi)
movq 0x68(%rcx), %rdx
testq %rdx, %rdx
je 0x414a1
movq 0x60(%rcx), %rsi
movq %rsi, 0x60(%rdx)
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
je 0x414ae
movq %rdx, 0x68(%rcx)
decl %eax
movl %eax, 0xd8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmNewOperandStack
static jx9_value * VmNewOperandStack(
	jx9_vm *pVm, /* Target VM */
	sxu32 nInstr /* Total numer of generated bytecode instructions */
	)
{
	jx9_value *pStack;
  /* No instruction ever pushes more than a single element onto the
  ** stack and the stack never grows on successive executions of the
  ** same loop. So the total number of instructions is an upper bound
  ** on the maximum stack depth required.
  **
  ** Allocation all the stack space we will ever need.
  */
	nInstr += VM_STACK_GUARD;
	pStack = (jx9_value *)SyMemBackendAlloc(&pVm->sAllocator, nInstr * sizeof(jx9_value));
	if( pStack == 0 ){
		return 0;
	}
	/* Initialize the operand stack */
	while( nInstr > 0 ){
		jx9MemObjInit(&(*pVm), &pStack[nInstr - 1]);
		--nInstr;
	}
	/* Ready for bytecode execution */
	return pStack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x10(%rbx), %r15d
movl %r15d, %esi
shll $0x6, %esi
callq 0x343ed
testq %rax, %rax
je 0x4152f
testl %r15d, %r15d
je 0x41531
addl $0xf, %ebx
movl %r15d, %ecx
shlq $0x6, %rcx
shlq $0x6, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax,%rbx)
movups %xmm0, 0x20(%rax,%rbx)
movups %xmm0, 0x10(%rax,%rbx)
movups %xmm0, (%rax,%rbx)
movq %r14, -0x30(%rax,%rcx)
movups %xmm0, -0x20(%rax,%rcx)
movq %r14, -0x28(%rax,%rcx)
movl $0x0, -0x10(%rax,%rcx)
movl $0x20, -0x38(%rax,%rcx)
addq $-0x40, %rbx
addq $-0x40, %rcx
jne 0x414f1
jmp 0x41531
xorl %eax, %eax
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: jx9MemObjLoad
JX9_PRIVATE sxi32 jx9MemObjLoad(jx9_value *pSrc, jx9_value *pDest)
{
	SyMemcpy((const void *)&(*pSrc), &(*pDest), 
		sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
	if( pSrc->iFlags & MEMOBJ_HASHMAP ){
		/* Increment reference count */
		((jx9_hashmap *)pSrc->x.pOther)->iRef++;
	}
	if( SyBlobLength(&pDest->sBlob) > 0 ){
		SyBlobRelease(&pDest->sBlob);
	}
	if( SyBlobLength(&pSrc->sBlob) > 0 ){
		SyBlobReadOnly(&pDest->sBlob, SyBlobData(&pSrc->sBlob), SyBlobLength(&pSrc->sBlob));
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x14, %edx
callq 0x34fc5
testb $0x40, 0x8(%r14)
je 0x4172b
movq (%r14), %rax
incl 0x50(%rax)
cmpl $0x0, 0x28(%rbx)
je 0x4173a
leaq 0x18(%rbx), %rdi
callq 0x31d8f
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x41758
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rbx)
movl %eax, 0x28(%rbx)
movl $0x0, 0x2c(%rbx)
orb $0x4, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjToBool
JX9_PRIVATE sxi32 jx9MemObjToBool(jx9_value *pObj)
{
	if( (pObj->iFlags & MEMOBJ_BOOL) == 0 ){
		/* Preform the conversion */
		pObj->x.iVal = MemObjBooleanValue(&(*pObj));
		/* Invalidate any prior representations */
		SyBlobRelease(&pObj->sBlob);
		MemObjSetType(pObj, MEMOBJ_BOOL);
	}
	return SXRET_OK;
}

// Assembly:
movl 0x8(%rdi), %eax
testb $0x8, %al
jne 0x4488a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x4, %al
jne 0x44739
testb $0x2, %al
jne 0x4472d
testb $0x1, %al
jne 0x4474f
testb $0x20, %al
jne 0x44861
testb $0x40, %al
jne 0x447ae
btl $0x8, %eax
jae 0x44861
cmpq $0x0, (%rbx)
setne %al
jmp 0x44863
xorpd %xmm0, %xmm0
cmpneqsd (%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x44863
movl 0x28(%rbx), %r15d
testq %r15, %r15
je 0x44861
movq 0x20(%rbx), %r14
leal -0x2(%r15), %eax
cmpl $0x3, %eax
ja 0x4483f
leaq 0x2ff8c(%rip), %rcx     # 0x74700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x36190(%rip), %rsi     # 0x7a914
movq %r14, %rdi
movl $0x2, %edx
callq 0x3a837
testl %eax, %eax
je 0x4488d
cmpq $0x5, %r15
je 0x44827
cmpl $0x3, %r15d
je 0x44809
jmp 0x4483f
movq (%rbx), %rdi
movl 0x2c(%rdi), %r14d
movl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rdi)
cmpl $0x1, %eax
jg 0x447cd
movl $0x1, %esi
callq 0x3eda2
testl %r14d, %r14d
jmp 0x44731
leaq 0x2f49b(%rip), %rsi     # 0x73c77
movq %r14, %rdi
movl $0x4, %edx
callq 0x3a837
testl %eax, %eax
je 0x4488d
cmpq $0x5, %r15
je 0x44827
cmpl $0x3, %r15d
je 0x44809
cmpl $0x2, %r15d
je 0x4477d
jmp 0x4483f
leaq 0x31d5b(%rip), %rsi     # 0x7656b
movq %r14, %rdi
movl $0x3, %edx
callq 0x3a837
testl %eax, %eax
je 0x4488d
cmpl $0x5, %r15d
jne 0x4483f
leaq 0x2f44e(%rip), %rsi     # 0x73c7c
movq %r14, %rdi
movl $0x5, %edx
callq 0x3a837
testl %eax, %eax
je 0x44861
movb $0x1, %al
cmpb $0x30, (%r14)
jne 0x44863
addq %r14, %r15
incq %r14
cmpq %r15, %r14
setb %al
jae 0x44863
cmpb $0x30, (%r14)
leaq 0x1(%r14), %r14
je 0x4484d
jmp 0x44863
xorl %eax, %eax
movzbl %al, %eax
movq %rax, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x31d8f
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
movb $0x1, %al
jmp 0x44863
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjToReal
JX9_PRIVATE sxi32 jx9MemObjToReal(jx9_value *pObj)
{
	if((pObj->iFlags & MEMOBJ_REAL) == 0 ){
		/* Preform the conversion */
		pObj->x.rVal = MemObjRealValue(&(*pObj));
		/* Invalidate any prior representations */
		SyBlobRelease(&pObj->sBlob);
		MemObjSetType(pObj, MEMOBJ_REAL);
	}
	return SXRET_OK;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testb $0x2e, %al
je 0x44986
testb $0x28, %al
je 0x44a1d
testb $0x20, %al
je 0x44976
movq $0x0, (%rbx)
andl $0xfffffe90, %eax       # imm = 0xFFFFFE90
orl $0x2, %eax
movl %eax, 0x8(%rbx)
jmp 0x44a1d
testb $0x1, %al
jne 0x449a3
movq %rbx, %rdi
addq $0x18, %rsp
testl $0x140, %eax            # imm = 0x140
je 0x449c7
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3fd5f
movb $0x0, -0x19(%rbp)
movl 0x28(%rbx), %r14d
testl %r14d, %r14d
je 0x449d2
movq 0x20(%rbx), %rdi
leaq -0x19(%rbp), %rdx
movl %r14d, %esi
callq 0x455c3
testl %eax, %eax
sete %al
jmp 0x449d4
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44891
xorl %eax, %eax
cmpb $0x0, -0x19(%rbp)
je 0x449e4
movq %rbx, %rdi
callq 0x44891
jmp 0x44a1d
leaq 0x18(%rbx), %r15
testb %al, %al
je 0x44a02
movq 0x20(%rbx), %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
movl %r14d, 0x8(%rdi)
callq 0x405c7
jmp 0x44a04
xorl %eax, %eax
movq %rax, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x31d8f
addq $0x18, %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: jx9MemObjToHashmap
JX9_PRIVATE sxi32 jx9MemObjToHashmap(jx9_value *pObj)
{
	if( (pObj->iFlags & MEMOBJ_HASHMAP) == 0 ){
		jx9_hashmap *pMap;
		/* Allocate a new hashmap instance */
		pMap = jx9NewHashmap(pObj->pVm, 0, 0);
		if( pMap == 0 ){
			return SXERR_MEM;
		}
		if( (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_RES)) == 0 ){
			/* 
			 * According to the JX9 language reference manual.
			 *   For any of the types: integer, float, string, boolean converting a value
			 *   to an array results in an array with a single element with index zero 
			 *   and the value of the scalar which was converted.
			 */
			/* Insert a single element */
			jx9HashmapInsert(pMap, 0/* Automatic index assign */, &(*pObj));
			SyBlobRelease(&pObj->sBlob);
		}
		/* Invalidate any prior representation */
		MemObjSetType(pObj, MEMOBJ_HASHMAP);
		pObj->x.pOther = pMap;
	}
	return SXRET_OK;
}

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

// Assembly:
cmpl $0x0, 0x2c(%rdi)
je 0x44d52
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq $0x0, -0x20(%rbp)
movl 0x8(%rsi), %eax
testl $0x141, %eax            # imm = 0x141
je 0x44d10
testb $0x1, %al
jne 0x44cf6
movq %r15, %rdi
callq 0x3fb4d
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x44d10
movq 0x20(%r15), %rsi
leaq -0x20(%rbp), %rcx
movq %r14, %rdi
callq 0x3fba1
jmp 0x44d2e
testb $0x2, 0x8(%r15)
jne 0x44d1f
movq %r15, %rdi
callq 0x3fd5f
movq (%r15), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x3fe39
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testl %ecx, %ecx
jne 0x44d47
xorl %eax, %eax
testq %rbx, %rbx
je 0x44d47
movq -0x20(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
retq