LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3e3f2
movl %r15d, -0x2c(%rbp)
movq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq 0x48(%r12), %r15
movl 0x38(%r12), %esi
movq %r14, %rdi
callq 0x3e434
cmpl $0x2, 0x8(%r12)
jne 0x3e3c5
leaq 0x10(%r12), %rdi
callq 0x317be
movq %r14, %rdi
movq %r12, %rsi
callq 0x2e659
incl %r13d
movl 0x2c(%rbx), %eax
movq %r15, %r12
cmpl %eax, %r13d
jb 0x3e3a1
testl %eax, %eax
movl -0x2c(%rbp), %r15d
je 0x3e3f2
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3490d
testl %r15d, %r15d
je 0x3e410
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e659
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_O3/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:
cmpl %esi, 0x218(%rdi)
jbe 0x3e490
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x210(%rdi), %rdi
testq %rdi, %rdi
je 0x3e488
movl %esi, %r14d
movl 0x220(%rbx), %eax
imull %esi, %eax
addq %rax, %rdi
callq 0x30465
leaq -0x20(%rbp), %rsi
movl %r14d, (%rsi)
movq $0x0, 0x8(%rsi)
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
callq 0x33094
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ee22
movq %r15, %rdi
callq 0x30465
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 0x359ad
// File: /workspace/github_c_makefile_star2_O3/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 0x2e481
testq %rax, %rax
je 0x3ee8e
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x54, %rcx
jb 0x3ee5c
movq %rbx, (%rax)
movl $0x1, 0x50(%rax)
leaq 0x16(%rip), %rcx        # 0x3ee95
movq %rcx, 0x30(%rax)
leaq 0x21(%rip), %rcx        # 0x3eeab
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f1b4
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 0x3f199
movq $0x0, 0x20(%rbx)
movl $0x0, 0x2c(%rbx)
andl $-0x5, %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rsi
callq 0x3f581
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_O3/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 0x3f239
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 0x3f239
cmpl $0x2, 0x8(%r14)
jne 0x3f225
cmpl %r13d, 0x34(%r14)
jne 0x3f225
cmpl %r15d, 0x20(%r14)
jne 0x3f225
movq 0x18(%r14), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x347f1
testl %eax, %eax
je 0x3f22b
movq 0x50(%r14), %r14
jmp 0x3f1fa
xorl %ebx, %ebx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x3f239
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_O3/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, %r13
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3f956
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3f350
testq %r13, %r13
je 0x3f29f
movq %r13, %rdi
movq %rax, %rsi
callq 0x3e19f
movq %r15, %rdi
movl %r14d, %esi
callq *0x38(%rbx)
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq (%rbx), %rdi
movl $0x60, %esi
callq 0x2e481
testq %rax, %rax
je 0x3f350
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x3c(%rax)
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0xc(%rax)
movl $0x0, 0x5c(%rax)
movq %rbx, (%rax)
movl $0x2, 0x8(%rax)
movl -0x2c(%rbp), %eax
movl %eax, 0x34(%r13)
movq %r13, %rdi
addq $0x10, %rdi
movq (%rbx), %rax
movups %xmm0, 0x18(%r13)
movq %rax, 0x10(%r13)
movq %r15, %rsi
movl %r14d, %edx
callq 0x359ad
movl -0x30(%rbp), %eax
movl %eax, 0x38(%r13)
movq %rbx, %rdi
callq 0x3fa0e
testl %eax, %eax
je 0x3f33a
movl %eax, %r12d
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x2e659
jmp 0x3f350
movl 0x28(%rbx), %edx
decl %edx
andl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3fb11
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3f40b
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x4, %al
jne 0x3f39e
testb $0x8, %al
jne 0x3f3cb
testb $0x1, %al
jne 0x3f3d0
testb $0x20, %al
jne 0x3f399
testb $0x40, %al
jne 0x3f40e
btl $0x8, %eax
jb 0x3f42f
xorl %r14d, %r14d
jmp 0x3f3e9
movsd (%rbx), %xmm0
movapd 0x34276(%rip), %xmm1    # 0x73620
andpd %xmm0, %xmm1
ucomisd 0x34242(%rip), %xmm1    # 0x735f8
cvttsd2si %xmm0, %rax
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
cmovbeq %rax, %r14
jmp 0x3f3e9
movq (%rbx), %r14
jmp 0x3f3e9
movq 0x20(%rbx), %rax
movl 0x28(%rbx), %ecx
leaq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movl %ecx, 0x8(%rdi)
callq 0x3fbb7
movq %rax, %r14
movq %r14, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x317be
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 0x3f3e9
movl $0x1, %esi
callq 0x3e379
jmp 0x3f3e9
xorl %r14d, %r14d
cmpq $0x0, (%rbx)
setne %r14b
jmp 0x3f3e9
// File: /workspace/github_c_makefile_star2_O3/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 0x3f49b
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 0x3f49b
cmpl $0x1, 0x8(%rcx)
jne 0x3f48b
cmpl %eax, 0x34(%rcx)
jne 0x3f48b
cmpq %r15, 0x10(%rcx)
je 0x3f491
movq 0x50(%rcx), %rcx
jmp 0x3f475
xorl %ebx, %ebx
testq %r14, %r14
je 0x3f49b
movq %rcx, (%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 -0x30(%rbp), %rsi
callq 0x3f956
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3f570
testq %r12, %r12
je 0x3f4e7
movq %r12, %rdi
movq %rax, %rsi
callq 0x3e19f
movq %r15, %rdi
callq *0x30(%r14)
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %r12d
movq (%r14), %rdi
movl $0x60, %esi
callq 0x2e481
testq %rax, %rax
je 0x3f570
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x3c(%rax)
movups %xmm0, 0x1c(%rax)
movl $0x0, 0x5c(%rax)
movq %r14, (%rax)
movl $0x1, 0x8(%rax)
movl -0x2c(%rbp), %eax
movl %eax, 0x34(%r13)
movq %r15, 0x10(%r13)
movl %r12d, 0x38(%r13)
movq %r14, %rdi
callq 0x3fa0e
testl %eax, %eax
je 0x3f55a
movq (%r14), %rdi
movq %r13, %rsi
callq 0x2e659
jmp 0x3f570
movl 0x28(%r14), %edx
decl %edx
andl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3fb11
xorl %ebx, %ebx
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_O3/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 0x3f5b6
testb $0x2, %al
jne 0x3f5ce
testb $0x8, %al
jne 0x3f5e5
testb $0x40, %al
jne 0x3f5f9
btl $0x8, %eax
jae 0x3f632
movq (%rbx), %rdx
leaq 0x34ad0(%rip), %rsi     # 0x74084
jmp 0x3f5d8
movsd (%rbx), %xmm0
leaq 0x34abd(%rip), %rsi     # 0x7407e
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3e26d
movq (%rbx), %rdx
leaq 0x34b03(%rip), %rsi     # 0x740db
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3e26d
cmpq $0x0, (%rbx)
je 0x3f639
leaq 0x32682(%rip), %rsi     # 0x71c74
movl $0x4, %edx
jmp 0x3f645
leaq -0x20(%rbp), %rsi
movl $0x0, 0x10(%rsi)
movq %rdi, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3f650
movq (%rbx), %rdi
movl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rdi)
cmpl $0x1, %eax
jg 0x3f632
movl $0x1, %esi
callq 0x3e379
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x32639(%rip), %rsi     # 0x71c79
movl $0x5, %edx
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x359ad
// File: /workspace/github_c_makefile_star2_O3/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 0x3f900
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 0x3f86c
movq (%rbx), %rdi
leaq 0x320ed(%rip), %rsi     # 0x7194f
movl $0x1, %edx
callq 0x359ad
leaq -0x24(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
movq (%rbx), %rdi
jle 0x3f8b7
movq %rax, %r15
leaq 0x323e0(%rip), %r12     # 0x71c6f
movq %r12, %rsi
movl $0x1, %edx
callq 0x359ad
movq (%rbx), %rdi
movl -0x24(%rbp), %edx
movq %r15, %rsi
callq 0x359ad
movq (%rbx), %rdi
movq %r12, %rsi
movl $0x1, %edx
jmp 0x3f8c3
leaq 0x37221(%rip), %rsi     # 0x76adf
movl $0x4, %edx
callq 0x359ad
movq (%rbx), %rdi
leaq 0x323a0(%rip), %rsi     # 0x71c72
movl $0x1, %edx
callq 0x359ad
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f650
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_O3/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:
movl 0x10(%rdx), %eax
cmpl $0x1f, %eax
jg 0x3f953
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x8(%rdx)
jne 0x3f935
movq (%rbx), %rdi
leaq 0x32027(%rip), %rsi     # 0x7194f
movl $0x1, %edx
callq 0x359ad
movl 0x10(%rbx), %eax
incl %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f650
decl 0x10(%rbx)
movl $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3f9c2
movq 0x268(%r14), %rcx
decl %eax
movl %eax, 0x270(%r14)
testq %rcx, %rcx
je 0x3f9c2
imull 0x278(%r14), %eax
movl (%rcx,%rax), %ecx
cmpl %ecx, 0x218(%r14)
jbe 0x3f9bf
movq 0x210(%r14), %rax
movl 0x220(%r14), %edx
imull %ecx, %edx
movl %ecx, -0x14(%rbp)
testq %rax, %rax
je 0x3f9c2
addq %rdx, %rax
jmp 0x3f9d6
movl %ecx, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x3fb65
testq %rax, %rax
je 0x3fa03
movl -0x14(%rbp), %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x20, 0x8(%rax)
testq %rbx, %rbx
je 0x3f9fe
movl %ecx, (%rbx)
movl %ecx, 0x38(%rax)
jmp 0x3fa05
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rdi), %eax
leal (%rax,%rax,2), %ecx
xorl %ebx, %ebx
cmpl %ecx, 0x2c(%rdi)
jb 0x3fb00
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r15
addl %eax, %eax
movl $0x10, %r13d
cmovnel %eax, %r13d
leal (,%r13,8), %r12d
movl %r12d, %esi
callq 0x33d86
testq %rax, %rax
je 0x3faf7
testl %r12d, %r12d
je 0x3fa99
movl %r12d, %edx
movq %rax, %rcx
addq %rdx, %rcx
movq %rax, %rdx
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3fa99
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3fa99
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3fa99
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jb 0x3fa6d
movq %rax, 0x8(%r14)
movl %r13d, 0x28(%r14)
testq %r15, %r15
je 0x3fb00
movl 0x2c(%r14), %eax
testl %eax, %eax
je 0x3faea
leaq 0x10(%r14), %rcx
decl %r13d
xorps %xmm0, %xmm0
movq (%rcx), %rcx
movups %xmm0, 0x50(%rcx)
movl 0x34(%rcx), %edx
andl %r13d, %edx
movq 0x8(%r14), %rsi
movq (%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x3fade
movq %rdi, 0x50(%rcx)
movq (%rsi,%rdx,8), %rdi
movq %rcx, 0x58(%rdi)
movq %rcx, (%rsi,%rdx,8)
addq $0x48, %rcx
decl %eax
jne 0x3fab8
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3490d
jmp 0x3fb00
xorl %ebx, %ebx
cmpl $0x1, 0x28(%r14)
sbbl %ebx, %ebx
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_O3/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 0x3fb30
movq %rdx, 0x50(%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x58(%rdx)
movq %rsi, (%rax,%rcx,8)
cmpq $0x0, 0x10(%rdi)
je 0x3fb51
leaq 0x18(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x3fb5d
movq %rcx, 0x40(%rsi)
movq %rsi, 0x48(%rcx)
jmp 0x3fb5d
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_O3/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 0x3fb7b
movl 0x218(%rbx), %eax
movl %eax, (%rsi)
leaq 0x208(%rbx), %rdi
leaq 0x330a7(%rip), %rsi     # 0x72c30
callq 0x33094
testl %eax, %eax
je 0x3fb96
xorl %eax, %eax
jmp 0x3fbb0
movl 0x218(%rbx), %eax
testl %eax, %eax
je 0x3fb92
decl %eax
imull 0x220(%rbx), %eax
addq 0x210(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3fbdb
movq (%rdi), %rdi
cmpb $0x30, (%rdi)
jne 0x3fbdf
cmpl $0x1, %esi
jne 0x3fbf2
xorl %eax, %eax
jmp 0x3fbec
leaq -0x8(%rbp), %rdx
callq 0x40206
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 0x3fc0e
cmpl $0x58, %eax
jne 0x3fc15
callq 0x3fc1c
jmp 0x3fbe8
callq 0x3fe7d
jmp 0x3fbe8
callq 0x4002a
jmp 0x3fbe8
// File: /workspace/github_c_makefile_star2_O3/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(%rdi), %rsi
cmpq 0xa8(%rbx), %rsi
jge 0x404af
movq %rbx, %rdi
movq %r14, %rdx
callq 0x404c4
movq 0xb0(%rbx), %rsi
incq %rsi
movq %rsi, 0xb0(%rbx)
cmpl $-0x6, %eax
je 0x40483
jmp 0x404bf
movq $0x0, 0xb0(%rbx)
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xd8(%rdi), %eax
testl %eax, %eax
je 0x40a71
pushq %rbp
movq %rsp, %rbp
movq 0xc8(%rdi), %rdx
movl 0xdc(%rdi), %r8d
decl %r8d
movl %esi, %ecx
andl %r8d, %ecx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x40a70
cmpq %rsi, 0x8(%rcx)
je 0x40a0c
movq 0x50(%rcx), %rcx
jmp 0x409fb
movq 0x58(%rcx), %r9
testq %r9, %r9
je 0x40a1f
movq 0x50(%rcx), %rsi
movq %rsi, 0x50(%r9)
jmp 0x40a2a
andl %esi, %r8d
movq 0x50(%rcx), %rsi
movq %rsi, (%rdx,%r8,8)
testq %rsi, %rsi
je 0x40a37
movq 0x58(%rcx), %rdx
movq %rdx, 0x58(%rsi)
movq 0xd0(%rdi), %rdx
cmpq %rcx, %rdx
jne 0x40a4e
movq 0x60(%rdx), %rdx
movq %rdx, 0xd0(%rdi)
movq 0x60(%rcx), %rdx
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x40a5f
movq %rdx, 0x60(%rcx)
testq %rdx, %rdx
je 0x40a68
movq %rcx, 0x68(%rdx)
decl %eax
movl %eax, 0xd8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33d86
testq %rax, %rax
sete %cl
testl %r15d, %r15d
sete %dl
orb %cl, %dl
jne 0x40aef
addl $0xf, %ebx
movl %r15d, %ecx
shlq $0x6, %rcx
leaq -0x38(%rax), %rdx
shlq $0x6, %rbx
addq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r14, 0x8(%rdx,%rcx)
movups %xmm0, 0x18(%rdx,%rcx)
movq %r14, 0x10(%rdx,%rcx)
movl $0x0, 0x28(%rdx,%rcx)
movl $0x20, (%rdx,%rcx)
addq $-0x40, %rbx
addq $-0x40, %rcx
jne 0x40ab8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x34893
testb $0x40, 0x8(%r14)
je 0x40ceb
movq (%r14), %rax
incl 0x50(%rax)
cmpl $0x0, 0x28(%rbx)
je 0x40cfa
leaq 0x18(%rbx), %rdi
callq 0x317be
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x40d18
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_O3/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 0x439f4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x4, %al
jne 0x43923
testb $0x2, %al
jne 0x43917
testb $0x1, %al
jne 0x43939
testb $0x20, %al
jne 0x439cb
testb $0x40, %al
jne 0x4397b
btl $0x8, %eax
jae 0x439cb
cmpq $0x0, (%rbx)
setne %al
jmp 0x439cd
xorpd %xmm0, %xmm0
cmpneqsd (%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x439cd
movl 0x28(%rbx), %r15d
testq %r15, %r15
je 0x439cb
movq 0x20(%rbx), %r14
leal -0x2(%r15), %eax
cmpl $0x3, %eax
ja 0x43a0f
leaq 0x2edae(%rip), %rcx     # 0x7270c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x34fa6(%rip), %rsi     # 0x78914
movq %r14, %rdi
movl $0x2, %edx
jmp 0x43a06
movq (%rbx), %rdi
movl 0x2c(%rdi), %r14d
movl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rdi)
cmpl $0x1, %eax
jg 0x4399a
movl $0x1, %esi
callq 0x3e379
testl %r14d, %r14d
jmp 0x4391b
leaq 0x2e2cb(%rip), %rsi     # 0x71c74
movq %r14, %rdi
movl $0x4, %edx
jmp 0x43a06
leaq 0x2e2bf(%rip), %rsi     # 0x71c79
movq %r14, %rdi
movl $0x5, %edx
callq 0x39f3f
testl %eax, %eax
jne 0x43a0f
xorl %eax, %eax
movzbl %al, %eax
movq %rax, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x317be
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
leaq 0x30b75(%rip), %rsi     # 0x74573
movq %r14, %rdi
movl $0x3, %edx
callq 0x39f3f
testl %eax, %eax
je 0x43a2d
addq %r14, %r15
incq %r14
cmpb $0x30, -0x1(%r14)
setne %al
jne 0x439cd
leaq 0x1(%r14), %rcx
cmpq %r15, %r14
movq %rcx, %r14
jb 0x43a15
jmp 0x439cd
movb $0x1, %al
jmp 0x439cd
// File: /workspace/github_c_makefile_star2_O3/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 0x43a72
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0xa, %al
je 0x43a75
cvtsi2sdq (%rbx), %xmm0
movsd %xmm0, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x317be
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
testb $0x1, %al
jne 0x43a9b
xorpd %xmm0, %xmm0
testb $0x20, %al
jne 0x43a4f
testb $0x40, %al
jne 0x43ac7
btl $0x8, %eax
jae 0x43a4f
cmpq $0x0, (%rbx)
je 0x43a4f
movsd 0x2fb57(%rip), %xmm0    # 0x735f0
jmp 0x43a4f
movq $0x0, -0x20(%rbp)
movl 0x28(%rbx), %esi
testl %esi, %esi
je 0x43ac1
movq 0x20(%rbx), %rdi
leaq -0x20(%rbp), %r14
movq %r14, %rdx
callq 0x3e968
movsd (%r14), %xmm0
jmp 0x43a4f
xorpd %xmm0, %xmm0
jmp 0x43a4f
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 0x43a4f
movl $0x1, %esi
movsd %xmm0, -0x18(%rbp)
callq 0x3e379
movsd -0x18(%rbp), %xmm0
jmp 0x43a4f
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %r13d
testb $0x2e, %r13b
je 0x43b49
testb $0x28, %r13b
je 0x43bd2
testb $0x20, %r13b
je 0x43b35
movq $0x0, (%rbx)
andl $0xfffffe90, %r13d      # imm = 0xFFFFFE90
orl $0x2, %r13d
movl %r13d, 0x8(%rbx)
jmp 0x43bd2
testb $0x1, %r13b
jne 0x43b6e
movq %rbx, %rdi
addq $0x18, %rsp
testl $0x140, %r13d           # imm = 0x140
je 0x43ba2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3f362
movb $0x0, -0x29(%rbp)
movl 0x28(%rbx), %r14d
testl %r14d, %r14d
je 0x43bb5
movq 0x20(%rbx), %r15
leaq -0x29(%rbp), %r12
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x44783
cmpb $0x0, (%r12)
je 0x43bb1
movq %rbx, %rdi
callq 0x43a31
jmp 0x43bd2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43a31
testl %eax, %eax
je 0x43be1
xorl %eax, %eax
leaq 0x18(%rbx), %rdi
movq %rax, (%rbx)
andl $0xfffffe90, %r13d      # imm = 0xFFFFFE90
orl $0x2, %r13d
movl %r13d, 0x8(%rbx)
callq 0x317be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
movl %r14d, 0x8(%rdi)
callq 0x3fbb7
movl 0x8(%rbx), %r13d
jmp 0x43bb7
// File: /workspace/github_c_makefile_star2_O3/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
xorl %ebx, %ebx
testb $0x40, 0x8(%rdi)
jne 0x43c58
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x3ee3d
testq %rax, %rax
je 0x43c53
movq %rax, %r15
movl 0x8(%r14), %eax
testl $0x120, %eax            # imm = 0x120
jne 0x43c42
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3ef1d
leaq 0x18(%r14), %rdi
callq 0x317be
movl 0x8(%r14), %eax
andl $0xfffffe90, %eax       # imm = 0xFFFFFE90
orl $0x40, %eax
movl %eax, 0x8(%r14)
movq %r15, (%r14)
jmp 0x43c58
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x43ed5
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 0x43edf
testb $0x1, %al
jne 0x43ebb
movq %r15, %rdi
callq 0x3f163
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x43edb
movq 0x20(%r15), %rsi
leaq -0x20(%rbp), %rcx
movq %r14, %rdi
callq 0x3f1b7
jmp 0x43efa
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
retq
movl 0x8(%r15), %eax
testb $0x2, %al
jne 0x43eeb
movq %r15, %rdi
callq 0x3f362
movq (%r15), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x3f43c
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testl %ecx, %ecx
jne 0x43f13
xorl %eax, %eax
testq %rbx, %rbx
je 0x43f13
movq -0x20(%rbp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9HashmapExtractNodeValue
JX9_PRIVATE void jx9HashmapExtractNodeValue(jx9_hashmap_node *pNode, jx9_value *pValue, int bStore)
{
	jx9_value *pEntry = HashmapExtractNodeValue(pNode);
	if( pEntry ){
		if( bStore ){
			jx9MemObjStore(pEntry, pValue);
		}else{
			jx9MemObjLoad(pEntry, pValue);
		}
	}else{
		jx9MemObjRelease(pValue);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %esi, 0x218(%rdi)
jbe 0x43f50
movq %rdi, %rax
movq 0x210(%rdi), %rdi
testq %rdi, %rdi
je 0x43f50
imull 0x220(%rax), %esi
addq %rsi, %rdi
movq %rdx, %rsi
testl %ecx, %ecx
je 0x43f59
popq %rbp
jmp 0x3e19f
movq %rdx, %rdi
popq %rbp
jmp 0x30465
popq %rbp
jmp 0x40cc7
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjTryInteger
JX9_PRIVATE sxi32 jx9MemObjTryInteger(jx9_value *pObj)
{
	if( pObj->iFlags & MEMOBJ_REAL ){
		/* Work only with reals */
		MemObjTryIntger(&(*pObj));
	}
	return SXRET_OK;
}

// Assembly:
testb $0x4, 0x8(%rdi)
je 0x43fc8
pushq %rbp
movq %rsp, %rbp
movsd (%rdi), %xmm0
movapd 0x2f6ab(%rip), %xmm1    # 0x73620
andpd %xmm0, %xmm1
ucomisd 0x2f677(%rip), %xmm1    # 0x735f8
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cvttsd2si %xmm0, %rax
leaq 0x1(%rcx), %rdx
cmovaq %rdx, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
ucomisd %xmm0, %xmm1
setp %dl
setne %sil
orb %dl, %sil
addq %rax, %rcx
cmpq $-0x2, %rcx
setae %cl
orb %sil, %cl
jne 0x43fc7
movq %rax, (%rdi)
movl $0x2, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmLocalExec
static sxi32 VmLocalExec(jx9_vm *pVm, SySet *pByteCode,jx9_value *pResult)
{
	jx9_value *pStack;
	sxi32 rc;
	/* Allocate a new operand stack */
	pStack = VmNewOperandStack(&(*pVm), SySetUsed(pByteCode));
	if( pStack == 0 ){
		return SXERR_MEM;
	}
	/* Execute the program */
	rc = VmByteCodeExec(&(*pVm), (VmInstr *)SySetBasePtr(pByteCode), pStack, -1, &(*pResult));
	/* Free the operand stack */
	SyMemBackendFree(&pVm->sAllocator, pStack);
	/* Execution result */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x10(%rsi), %esi
callq 0x40a72
testq %rax, %rax
je 0x44504
movq %rax, %r15
movq 0x8(%r12), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r14, %r8
callq 0x40d1d
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3490d
movl %r14d, %eax
jmp 0x44509
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: VmEnterFrame
static sxi32 VmEnterFrame(
	jx9_vm *pVm,               /* Target VM */
	void *pUserData,           /* Upper-layer private data */
	VmFrame **ppFrame          /* OUT: Top most active frame */
	)
{
	VmFrame *pFrame;
	/* Allocate a new frame */
	pFrame = VmNewFrame(&(*pVm), pUserData);
	if( pFrame == 0 ){
		return SXERR_MEM;
	}
	/* Link to the list of active VM frame */
	pFrame->pParent = pVm->pFrame;
	pVm->pFrame = pFrame;
	if( ppFrame ){
		/* Write a pointer to the new VM frame */
		*ppFrame = pFrame;
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movl $0xb0, %esi
callq 0x2e481
testq %rax, %rax
je 0x445dc
movq %rax, %r12
xorl %r14d, %r14d
movl $0xb0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc360
movq %r13, 0x8(%r12)
movq %r15, 0x38(%r12)
movq %r12, %rdi
addq $0x40, %rdi
movq %r15, %rsi
callq 0x44d43
movabsq $0x1000000000, %rax     # imm = 0x1000000000
movq %rax, 0x94(%r12)
movl %r14d, 0x90(%r12)
movl %r14d, 0x9c(%r12)
movq %r15, 0x80(%r12)
movq %r14, 0x88(%r12)
movq %r14, 0xa0(%r12)
movq $0x10, 0x28(%r12)
movq %r15, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movq %r14, 0x30(%r12)
movq 0xf8(%r15), %rax
movq %rax, (%r12)
movq %r12, 0xf8(%r15)
testq %rbx, %rbx
je 0x445e2
movq %r12, (%rbx)
jmp 0x445e2
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq