LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_get_schema
static int unqliteBuiltin_db_get_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	int nByte;
	/* Extract collection name */
	if( argc < 1 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or db scheme");
		/* Return false */
		jx9_result_bool(pCtx,0);
		return JX9_OK;
	}
	zName = jx9_value_to_string(argv[0],&nByte);
	if( nByte < 1){
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
		/* Return false */
		jx9_result_bool(pCtx,0);
		return JX9_OK;
	}
	SyStringInitFromBuf(&sName,zName,nByte);
	pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
	/* Fetch the collection */
	pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
	if( pCol ){
		/* Return the collection schema */
		jx9_result_value(pCtx,&pCol->sSchema);
	}else{
		jx9_context_throw_error_format(pCtx,JX9_CTX_WARNING,
			"No such collection '%z'",
			&sName
			);
		jx9_result_null(pCtx);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x34ed2
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x297ed
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x34edb
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x350f6
testq %rax, %rax
je 0x34f02
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x299d3
jmp 0x34ef7
leaq 0x2f88c(%rip), %rdx     # 0x64765
jmp 0x34ee2
leaq 0x2f07a(%rip), %rdx     # 0x63f5c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a0db
movq %rbx, %rdi
xorl %esi, %esi
callq 0x298b2
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2f6bf(%rip), %rdx     # 0x645c8
pushq $0x2
popq %rsi
leaq -0x28(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3be68
movq %rbx, %rdi
callq 0x298e8
jmp 0x34ef7
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_begin
static int unqliteBuiltin_db_begin(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_vm *pVm;
	unqlite *pDb;
	int rc;
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	/* Point to the unqlite Vm */
	pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
	/* Point to the underlying database handle  */
	pDb = pVm->pDb;
	/* Begin the transaction */
	rc = unqlitePagerBegin(pDb->sDB.pPager);
	/* result */
	jx9_result_bool(pCtx,rc == UNQLITE_OK );
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x2b42e
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_commit
static int unqliteBuiltin_db_commit(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_vm *pVm;
	unqlite *pDb;
	int rc;
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	/* Point to the unqlite Vm */
	pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
	/* Point to the underlying database handle  */
	pDb = pVm->pDb;
	/* Commit the transaction if any */
	rc = unqlitePagerCommit(pDb->sDB.pPager);
	/* Commit result */
	jx9_result_bool(pCtx,rc == UNQLITE_OK );
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x2b6e3
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_rollback
static int unqliteBuiltin_db_rollback(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_vm *pVm;
	unqlite *pDb;
	int rc;
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	/* Point to the unqlite Vm */
	pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
	/* Point to the underlying database handle  */
	pDb = pVm->pDb;
	/* Rollback the transaction if any */
	rc = unqlitePagerRollback(pDb->sDB.pPager,TRUE);
	/* Rollback result */
	jx9_result_bool(pCtx,rc == UNQLITE_OK );
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2ba31
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x298b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9_create_function
JX9_PRIVATE int jx9_create_function(jx9_vm *pVm, const char *zName, int (*xFunc)(jx9_context *, int, jx9_value **), void *pUserData)
{
	SyString sName;
	int rc;
	/* Ticket 1433-002: NULL VM is harmless operation */
	if ( JX9_VM_MISUSE(pVm) ){
		return JX9_CORRUPT;
	}
	SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
	/* Remove leading and trailing white spaces */
	SyStringFullTrim(&sName);
	/* Ticket 1433-003: NULL values are not allowed */
	if( sName.nByte < 1 || xFunc == 0 ){
		return JX9_CORRUPT;
	}
#if defined(JX9_ENABLE_THREADS)
	 /* Acquire VM mutex */
	 SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
	 if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE && 
		 JX9_THRD_VM_RELEASE(pVm) ){
			 return JX9_ABORT; /* Another thread have released this instance */
	 }
#endif
	/* Install the foreign function */
	rc = jx9VmInstallForeignFunction(&(*pVm), &sName, xFunc, pUserData); 
#if defined(JX9_ENABLE_THREADS)
	 /* Leave VM mutex */
	 SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $-0x18
popq %r14
testq %rdi, %rdi
je 0x350e4
movq %rdi, %rbx
cmpl $0xdead2bad, 0x6e8(%rdi) # imm = 0xDEAD2BAD
je 0x350e4
movq %rsi, %r13
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rsi, %rdi
callq 0x28e24
movl %eax, %r15d
leaq (%r15,%r13), %r12
testl %r15d, %r15d
je 0x35045
movsbq (%r13), %r14
cmpq $-0x41, %r14
ja 0x35042
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0x35042
incq %r13
decq %r15
jmp 0x3501a
movq %r13, %r12
movq %r12, -0x48(%rbp)
movl %r15d, -0x40(%rbp)
movq %r15, %r13
subq $0x1, %r15
jb 0x350b6
movsbq -0x1(%r12,%r13), %r14
cmpq $-0x41, %r14
ja 0x35072
callq 0xc190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x3504d
movl %r13d, -0x40(%rbp)
movq -0x38(%rbp), %r15
testq %r15, %r15
pushq $-0x18
popq %r14
je 0x350e4
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x35099
movq 0x5302a(%rip), %rax     # 0x880c0
callq *0x20(%rax)
cmpl $0x2, 0x53030(%rip)     # 0x880d0
movq -0x30(%rbp), %rcx
jb 0x350bc
cmpl $0xdead2bad, 0x6e8(%rbx) # imm = 0xDEAD2BAD
jne 0x350bc
pushq $-0xa
jmp 0x350b8
pushq $-0x18
popq %r14
jmp 0x350e4
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x28f91
movl %eax, %r14d
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x350e4
movq 0x52fdf(%rip), %rax     # 0x880c0
callq *0x30(%rax)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCollectionFetch
UNQLITE_PRIVATE unqlite_col * unqliteCollectionFetch(
	unqlite_vm *pVm, /* Target VM */
	SyString *pName, /* Lookup key */
	int iFlag        /* Control flag */
	)
{
	unqlite_col *pCol = 0; /* cc warning */
	int rc;
	/* Check if the collection is already loaded in memory */
	pCol = unqliteVmFetchCollection(pVm,pName);
	if( pCol ){
		/* Already loaded in memory*/
		return pCol;
	}
	if( (iFlag & UNQLITE_VM_AUTO_LOAD) == 0 ){
		return 0;
	}
	/* Ask the storage engine for the collection */
	rc = unqliteVmLoadCollection(pVm,pName->zString,pName->nByte,0,&pCol);
	/* Return to the caller */
	return rc == UNQLITE_OK ? pCol : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0xd8(%rdi)
movq (%rsi), %r15
movl 0x8(%rsi), %r12d
je 0x3516d
movq %r15, %rdi
movl %r12d, %esi
callq 0x356e0
movl %eax, %r13d
movl 0xdc(%r14), %ebx
decl %ebx
andl %eax, %ebx
shlq $0x3, %rbx
addq 0xc8(%r14), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3516d
cmpl 0x18(%rbx), %r13d
jne 0x35164
movl %r12d, %eax
subl 0x10(%rbx), %eax
jne 0x35160
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x2d30e
testl %eax, %eax
je 0x3518f
addq $0x130, %rbx            # imm = 0x130
jmp 0x3513b
leaq -0x30(%rbp), %r8
andq $0x0, (%r8)
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x351a1
testl %eax, %eax
jne 0x3518f
movq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBinHash
JX9_PRIVATE sxu32 SyBinHash(const void *pSrc, sxu32 nLen)
{
	register unsigned char *zIn = (unsigned char *)pSrc;
	unsigned char *zEnd;
	sxu32 nH = 5381;
	zEnd = &zIn[nLen];
	for(;;){
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
	}	
	return nH;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
addq %rdi, %rcx
movl $0x1505, %eax           # imm = 0x1505
cmpq %rcx, %rdi
jae 0x35730
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x35730
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x35730
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x35730
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
jmp 0x356ee
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ca19
movq %rax, %r12
testq %rax, %rax
je 0x35766
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x2ca64
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9MemObjInit
JX9_PRIVATE sxi32 jx9MemObjInit(jx9_vm *pVm, jx9_value *pObj)
{
	/* Zero the structure */
	SyZero(pObj, sizeof(jx9_value));
	/* Initialize fields */
	pObj->pVm = pVm;
	SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
	/* Set the NULL type */
	pObj->iFlags = MEMOBJ_NULL;
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x27aea
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %r14, 0x18(%rbx)
andl $0x0, 0x30(%rbx)
movl $0x20, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBlobAppendBig16
JX9_PRIVATE sxi32 SyBlobAppendBig16(SyBlob *pBlob,sxu16 n16)
{
	unsigned char zBuf[2];
	sxi32 rc;
	SyBigEndianPack16(zBuf,n16);
	rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
rolw $0x8, %si
leaq -0x2(%rbp), %rax
movw %si, (%rax)
pushq $0x2
popq %rdx
movq %rax, %rsi
callq 0x2e250
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35d07
movq (%r15), %rax
incl 0x50(%rax)
testb $0x40, 0x8(%r14)
jne 0x35d12
xorl %ebx, %ebx
jmp 0x35d15
movq (%r14), %rbx
pushq $0x14
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d3b0
cmpl $0x0, 0x28(%r15)
je 0x35d4a
addq $0x18, %r15
addq $0x18, %r14
movq %r14, %rdi
callq 0x31b1e
movq %r15, %rdi
movq %r14, %rsi
callq 0x31d24
movl %eax, %r15d
jmp 0x35d60
xorl %r15d, %r15d
cmpl $0x0, 0x28(%r14)
je 0x35d60
addq $0x18, %r14
movq %r14, %rdi
callq 0x2a72f
testq %rbx, %rbx
je 0x35d6d
movq %rbx, %rdi
callq 0x35e9a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x8(%rdi)
jne 0x35e3a
cmpl $0x0, 0x28(%rbx)
je 0x35e2f
leaq 0x18(%rbx), %rdi
callq 0x2a72f
movq 0x10(%r14), %rax
movq %rax, (%rbx)
pushq $0x2
jmp 0x35e58
leaq 0x18(%rbx), %r15
movq %r15, %rdi
callq 0x31b1e
movq 0x18(%r14), %rsi
movl 0x20(%r14), %edx
movq %r15, %rdi
callq 0x2e250
pushq $0x1
popq %rax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: HashmapExtractNodeValue
static jx9_value * HashmapExtractNodeValue(jx9_hashmap_node *pNode)
{
	/* Point to the desired object */
	jx9_value *pObj;
	pObj = (jx9_value *)SySetAt(&pNode->pMap->pVm->aMemObj, pNode->nValIdx);
	return pObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rax), %rcx
movl 0x38(%rdi), %eax
cmpl %eax, 0x218(%rcx)
jbe 0x35e96
imull 0x220(%rcx), %eax
addq 0x210(%rcx), %rax
jmp 0x35e98
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x2c(%rbp)
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %r12
xorl %r13d, %r13d
movl 0x2c(%rbx), %eax
cmpl %eax, %r13d
jae 0x35f13
movq 0x48(%r12), %r15
movl 0x38(%r12), %esi
movq %r14, %rdi
callq 0x35f66
cmpl $0x2, 0x8(%r12)
jne 0x35f00
leaq 0x10(%r12), %rdi
callq 0x2a72f
movq %r14, %rdi
movq %r12, %rsi
callq 0x27bf8
incl %r13d
movq %r15, %r12
jmp 0x35ed4
testl %eax, %eax
je 0x35f23
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2d420
cmpl $0x0, -0x2c(%rbp)
je 0x35f42
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27bf8
andq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
andq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x35fbf
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x210(%rdi), %rdi
testq %rdi, %rdi
je 0x35fb7
movl %esi, %r14d
movl 0x220(%rbx), %eax
imull %esi, %eax
addq %rax, %rdi
callq 0x296af
leaq -0x20(%rbp), %rsi
movl %r14d, (%rsi)
andq $0x0, 0x8(%rsi)
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
callq 0x2be00
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x368c9
movq %r15, %rdi
callq 0x296af
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 0x2e250
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r14
pushq $0x58
popq %rsi
callq 0x279f7
movq %rax, %rbx
testq %rax, %rax
je 0x36929
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x27aea
movq %r14, (%rbx)
movl $0x1, 0x50(%rbx)
leaq 0x17(%rip), %rax        # 0x36931
movq %rax, 0x30(%rbx)
leaq 0x22(%rip), %rax        # 0x36947
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36c07
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x31b1e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36f88
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $-0x6
popq %rax
cmpl $0x0, 0x2c(%rdi)
je 0x36c8e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
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
movl 0x28(%r14), %ebx
decl %ebx
andl %eax, %ebx
shlq $0x3, %rbx
addq 0x8(%r14), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x36c7d
cmpl $0x2, 0x8(%rbx)
jne 0x36c77
cmpl %r13d, 0x34(%rbx)
jne 0x36c77
cmpl %r15d, 0x20(%rbx)
jne 0x36c77
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x2d30e
testl %eax, %eax
je 0x36c8f
addq $0x50, %rbx
jmp 0x36c4a
pushq $-0x6
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq -0x30(%rbp), %rcx
testq %rcx, %rcx
je 0x36c80
movq %rbx, (%rcx)
jmp 0x36c80
// File: /workspace/github_c_makefile_star2_O2/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 0x37337
pushq $-0x1
popq %r12
testq %rax, %rax
je 0x36d98
testq %r13, %r13
je 0x36cf2
movq %r13, %rdi
movq %rax, %rsi
callq 0x35ceb
movq %r15, %rdi
movl %r14d, %esi
callq *0x38(%rbx)
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq (%rbx), %rdi
pushq $0x60
popq %rsi
callq 0x279f7
testq %rax, %rax
je 0x36d98
movq %rax, %r13
pushq $0x60
popq %rsi
movq %rax, %rdi
callq 0x27aea
movq %rbx, (%r13)
movl $0x2, 0x8(%r13)
movl -0x2c(%rbp), %eax
movl %eax, 0x34(%r13)
movq %r13, %rdi
addq $0x10, %rdi
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r13)
movq %rax, 0x10(%r13)
andl $0x0, 0x28(%r13)
movq %r15, %rsi
movl %r14d, %edx
callq 0x2e250
movl -0x30(%rbp), %eax
movl %eax, 0x38(%r13)
movq %rbx, %rdi
callq 0x373c8
testl %eax, %eax
je 0x36d82
movl %eax, %r12d
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x27bf8
jmp 0x36d98
movl 0x28(%rbx), %edx
decl %edx
andl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x374a3
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_O2/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 0x36e39
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0x4, %al
jne 0x36dde
testb $0x8, %al
jne 0x36e0b
testb $0x1, %al
jne 0x36e10
testb $0x20, %al
jne 0x36dd9
testb $0x40, %al
jne 0x36e3c
btl $0x8, %eax
jb 0x36e4a
xorl %r14d, %r14d
jmp 0x36e1b
movsd (%rbx), %xmm0
movapd 0x2c816(%rip), %xmm1    # 0x63600
andpd %xmm0, %xmm1
ucomisd 0x2c7d2(%rip), %xmm1    # 0x635c8
cvttsd2si %xmm0, %rax
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
cmovbeq %rax, %r14
jmp 0x36e1b
movq (%rbx), %r14
jmp 0x36e1b
movq %rbx, %rdi
callq 0x37567
movq %rax, %r14
movq %r14, (%rbx)
leaq 0x18(%rbx), %rdi
callq 0x2a72f
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
movq (%rbx), %rdi
movl 0x2c(%rdi), %r14d
callq 0x35e9a
jmp 0x36e1b
xorl %r14d, %r14d
cmpq $0x0, (%rbx)
setne %r14b
jmp 0x36e1b
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x6
popq %rbx
cmpl $0x0, 0x2c(%rdi)
je 0x36eb7
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq *0x30(%r12)
movl 0x28(%r12), %ecx
decl %ecx
andl %eax, %ecx
shlq $0x3, %rcx
addq 0x8(%r12), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x36eb7
cmpl $0x1, 0x8(%rcx)
jne 0x36ea7
cmpl %eax, 0x34(%rcx)
jne 0x36ea7
cmpq %r15, 0x10(%rcx)
je 0x36ead
addq $0x50, %rcx
jmp 0x36e8e
xorl %ebx, %ebx
testq %r14, %r14
je 0x36eb7
movq %rcx, (%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x37337
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x36f77
testq %r12, %r12
je 0x36f01
movq %r12, %rdi
movq %rax, %rsi
callq 0x35ceb
movq %r15, %rdi
callq *0x30(%r14)
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %r12d
movq (%r14), %rdi
pushq $0x60
popq %rsi
callq 0x279f7
testq %rax, %rax
je 0x36f77
movq %rax, %r13
pushq $0x60
popq %rsi
movq %rax, %rdi
callq 0x27aea
movq %r14, (%r13)
movl $0x1, 0x8(%r13)
movl -0x2c(%rbp), %eax
movl %eax, 0x34(%r13)
movq %r15, 0x10(%r13)
movl %r12d, 0x38(%r13)
movq %r14, %rdi
callq 0x373c8
testl %eax, %eax
je 0x36f61
movq (%r14), %rdi
movq %r13, %rsi
callq 0x27bf8
jmp 0x36f77
movl 0x28(%r14), %edx
decl %edx
andl -0x2c(%rbp), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x374a3
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_O2/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
movl 0x8(%rsi), %ecx
testb $0x4, %cl
jne 0x36fb8
testb $0x2, %cl
jne 0x36fd3
testb $0x8, %cl
jne 0x36fed
testb $0x40, %cl
jne 0x36ffe
btl $0x8, %ecx
jb 0x3702f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsd (%rbx), %xmm0
leaq 0x2d09b(%rip), %rsi     # 0x6405e
movq %rax, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35d7b
movq (%rbx), %rdx
leaq 0x2d0de(%rip), %rsi     # 0x640bb
movq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35d7b
cmpq $0x0, (%rbx)
je 0x37017
leaq 0x2ac74(%rip), %rsi     # 0x61c6e
pushq $0x4
jmp 0x37020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3703b
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35e9a
leaq 0x2ac55(%rip), %rsi     # 0x61c73
pushq $0x5
popq %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e250
movq (%rbx), %rdx
leaq 0x2d02b(%rip), %rsi     # 0x64064
jmp 0x36fdd
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9JsonSerialize
JX9_PRIVATE int jx9JsonSerialize(jx9_value *pValue,SyBlob *pOut)
{
	json_private_data sJson;
	/* Prepare the JSON data */
	sJson.nRecCount = 0;
	sJson.pOut = pOut;
	sJson.isFirst = 1;
	sJson.iFlags = 0;
	/* Perform the encoding operation */
	VmJsonEncode(pValue, &sJson);
	/* All done */
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x18(%rbp), %rax
andl $0x0, 0x10(%rax)
movq %rsi, (%rax)
movq $0x1, 0x8(%rax)
movq %rax, %rsi
callq 0x37064
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x372e6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x8(%rdx)
jne 0x37257
movq (%rbx), %rdi
leaq 0x2a6d0(%rip), %rsi     # 0x6191f
pushq $0x1
popq %rdx
callq 0x2e250
leaq -0x2c(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x297ed
cmpl $0x0, (%r12)
movq (%rbx), %rdi
jle 0x372a2
movq %rax, %r15
leaq 0x2a9ef(%rip), %r12     # 0x61c69
pushq $0x1
popq %r13
movq %r12, %rsi
movl %r13d, %edx
callq 0x2e250
movq (%rbx), %rdi
movl -0x2c(%rbp), %edx
movq %r15, %rsi
callq 0x2e250
movq (%rbx), %rdi
movq %r12, %rsi
movl %r13d, %edx
jmp 0x372ac
leaq 0x2f816(%rip), %rsi     # 0x66abf
pushq $0x4
popq %rdx
callq 0x2e250
movq (%rbx), %rdi
leaq 0x2a9b1(%rip), %rsi     # 0x61c6c
pushq $0x1
popq %rdx
callq 0x2e250
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37064
decl 0x10(%rbx)
andl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x37334
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x0, 0x8(%rdx)
jne 0x37319
movq (%rbx), %rdi
leaq 0x2a611(%rip), %rsi     # 0x6191f
pushq $0x1
popq %rdx
callq 0x2e250
movl 0x10(%rbx), %eax
incl %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37064
decl 0x10(%rbx)
andl $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
orl $-0x1, -0x1c(%rbp)
addq $0x260, %rdi            # imm = 0x260
callq 0x374f7
testq %rax, %rax
je 0x37388
movl (%rax), %eax
cmpl %eax, 0x218(%r14)
jbe 0x37385
movq 0x210(%r14), %r15
movl 0x220(%r14), %ecx
imull %eax, %ecx
movl %eax, -0x1c(%rbp)
testq %r15, %r15
je 0x37388
addq %rcx, %r15
jmp 0x3739c
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
movq %r14, %rdi
callq 0x37515
movq %rax, %r15
testq %rax, %rax
je 0x373b7
movq %r14, %rdi
movq %r15, %rsi
callq 0x35772
movl -0x1c(%rbp), %eax
testq %rbx, %rbx
je 0x373b1
movl %eax, (%rbx)
movl %eax, 0x38(%r15)
jmp 0x373ba
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r15d, %r15d
cmpl %ecx, 0x2c(%rdi)
jb 0x37491
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, -0x30(%rbp)
addl %eax, %eax
pushq $0x10
popq %r14
cmovnel %eax, %r14d
leal (,%r14,8), %r12d
movl %r12d, %esi
callq 0x2ca19
testq %rax, %rax
je 0x37487
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0x27aea
movq %r13, 0x8(%rbx)
movl %r14d, 0x28(%rbx)
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x37491
leaq 0x10(%rbx), %rax
movl 0x2c(%rbx), %ecx
decl %r14d
xorl %edx, %edx
xorps %xmm0, %xmm0
cmpl %ecx, %edx
jae 0x3747a
movq (%rax), %rax
movups %xmm0, 0x50(%rax)
movl 0x34(%rax), %r9d
andl %r14d, %r9d
movq 0x8(%rbx), %rdi
movq (%rdi,%r9,8), %r8
testq %r8, %r8
je 0x3746e
movq %r8, 0x50(%rax)
movq (%rdi,%r9,8), %r8
movq %rax, 0x58(%r8)
movq %rax, (%rdi,%r9,8)
addq $0x48, %rax
incl %edx
jmp 0x37443
movq (%rbx), %rdi
callq 0x2d420
xorl %r15d, %r15d
jmp 0x37491
xorl %r15d, %r15d
cmpl $0x1, 0x28(%rbx)
sbbl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x374c2
movq %rdx, 0x50(%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x58(%rdx)
movq %rsi, (%rax,%rcx,8)
cmpq $0x0, 0x10(%rdi)
je 0x374e3
leaq 0x18(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x374ef
movq %rcx, 0x40(%rsi)
movq %rsi, 0x48(%rcx)
jmp 0x374ef
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_O2/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 0x3752b
movl 0x218(%rbx), %eax
movl %eax, (%rsi)
leaq 0x208(%rbx), %rdi
leaq 0x2b6d7(%rip), %rsi     # 0x62c10
callq 0x2be00
testl %eax, %eax
je 0x37546
xorl %eax, %eax
jmp 0x37560
movl 0x218(%rbx), %eax
testl %eax, %eax
je 0x37542
decl %eax
imull 0x220(%rbx), %eax
addq 0x210(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, -0x8(%rbp)
movl 0x8(%rdi), %esi
testl %esi, %esi
je 0x375af
movq (%rdi), %rdi
cmpb $0x30, (%rdi)
jne 0x375b3
cmpl $0x1, %esi
jne 0x375c6
xorl %eax, %eax
jmp 0x375c0
leaq -0x8(%rbp), %rdx
callq 0x37b90
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 0x375e2
cmpl $0x58, %eax
jne 0x375e9
callq 0x375f0
jmp 0x375bc
callq 0x37826
jmp 0x375bc
callq 0x379bb
jmp 0x375bc
// File: /workspace/github_c_makefile_star2_O2/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 0x37e73
movq %rbx, %rdi
movq %r14, %rdx
callq 0x37e83
movq 0xb0(%rbx), %rsi
incq %rsi
movq %rsi, 0xb0(%rbx)
cmpl $-0x6, %eax
je 0x37e47
jmp 0x37e7e
andq $0x0, 0xb0(%rbx)
pushq $-0x12
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteCollectionFetchRecordById
UNQLITE_PRIVATE int unqliteCollectionFetchRecordById(
	unqlite_col *pCol, /* Target collection */
	jx9_int64 nId,     /* Unique record ID */
	jx9_value *pValue  /* OUT: record value */
	)
{
	SyBlob *pWorker = &pCol->sWorker;
	unqlite_col_record *pRec;
	int rc;
	jx9_value_null(pValue);
	/* Perform a cache lookup first */
	pRec = CollectionCacheFetchRecord(pCol,nId);
	if( pRec ){
		/* Copy record value */
		jx9MemObjStore(&pRec->sValue,pValue);
		return UNQLITE_OK;
	}
	/* Reset the working buffer */
	SyBlobReset(pWorker);
	/* Generate the unique ID */
	SyBlobFormat(pWorker,"%z_%qd",&pCol->sName,nId);
	/* Reset the cursor */
	unqlite_kv_cursor_reset(pCol->pCursor);
	/* Seek the cursor to the desired location */
	rc = unqlite_kv_cursor_seek(pCol->pCursor,
		SyBlobData(pWorker),SyBlobLength(pWorker),
		UNQLITE_CURSOR_MATCH_EXACT
		);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Consume the binary JSON */
	SyBlobReset(pWorker);
	unqlite_kv_cursor_data_callback(pCol->pCursor,unqliteDataConsumer,pWorker);
	if( SyBlobLength(pWorker) < 1 ){
		unqliteGenErrorFormat(pCol->pVm->pDb,
			"Empty record '%qd'",nId
			);
		jx9_value_null(pValue);
	}else{
		/* Decode the binary JSON */
		rc = FastJsonDecode(SyBlobData(pWorker),SyBlobLength(pWorker),pValue,0,0);
		if( rc == UNQLITE_OK ){
			/* Install the record in the cache */
			CollectionCacheInstallRecord(pCol,nId,pValue);
		}
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x296af
movq %r15, %rdi
movq %r14, %rsi
callq 0x37fa6
testq %rax, %rax
je 0x37ec6
addq $0x10, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35ceb
xorl %r13d, %r13d
jmp 0x37f14
leaq 0x68(%r15), %r12
movq %r12, %rdi
callq 0x31b1e
leaq 0x8(%r15), %rdx
leaq 0x2c1db(%rip), %rsi     # 0x640b8
movq %r12, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x35d7b
movq 0x118(%r15), %rdi
callq 0x2b1d8
movq 0x118(%r15), %rdi
movq 0x70(%r15), %rsi
movl 0x78(%r15), %edx
pushq $0x1
popq %rcx
callq 0x2b1fc
testl %eax, %eax
je 0x37f26
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x31b1e
movq 0x118(%r15), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq -0xd3bd(%rip), %rsi     # 0x2ab89
movq %r12, %rdx
callq *0xa0(%rax)
movl 0x78(%r15), %esi
testl %esi, %esi
je 0x37f7f
movq 0x70(%r15), %rdi
xorl %r13d, %r13d
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x35fc0
testl %eax, %eax
jne 0x37f11
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37fe5
jmp 0x37f14
movq (%r15), %rax
movq (%rax), %rdi
leaq 0x2c133(%rip), %rsi     # 0x640bf
xorl %r13d, %r13d
movq %r14, %rdx
xorl %eax, %eax
callq 0x32836
movq %rbx, %rdi
callq 0x296af
jmp 0x37f14