LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_fill_page
static int pager_fill_page(Pager *pPager,pgno iNum,void *pContents)
{
	Page *pPage;
	/* Fetch the page from the catch */
	pPage = pager_fetch_page(pPager,iNum);
	if( pPage == 0 ){
		return SXERR_NOTFOUND;
	}
	/* Reflect the change */
	SyMemcpy(pContents,pPage->zData,pPager->iPageSize);

	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x254(%rdi)
je 0x3bb65
movq 0x248(%rdi), %rax
movl 0x250(%rdi), %ecx
decl %ecx
movl %esi, %r8d
andl %ecx, %r8d
movq (%rax,%r8,8), %rax
testq %rax, %rax
je 0x3bb65
cmpq %rsi, 0x10(%rax)
je 0x3bb67
movq 0x48(%rax), %rax
jmp 0x3bb54
popq %rbp
retq
movq (%rax), %rsi
movl 0x208(%rdi), %eax
movq %rdx, %rdi
movl %eax, %edx
popq %rbp
jmp 0x34893
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_write_journal_header
static int pager_write_journal_header(Pager *pPager,unsigned char *zBuf)
{
	unsigned char *zPtr = zBuf;
	/* 8 bytes magic number */
	SyMemcpy(aJournalMagic,zPtr,sizeof(aJournalMagic));
	zPtr += sizeof(aJournalMagic);
	/* 4 bytes: Number of records in journal. */
	SyBigEndianPack32(zPtr,0);
	zPtr += 4;
	/* 4 bytes: Random number used to compute page checksum. */
	SyBigEndianPack32(zPtr,pPager->cksumInit);
	zPtr += 4;
	/* 8 bytes: Initial database page count. */
	SyBigEndianPack64(zPtr,pPager->dbOrigSize);
	zPtr += 8;
	/* 4 bytes: Sector size used by the process that wrote this journal. */
	SyBigEndianPack32(zPtr,(sxu32)pPager->iSectorSize);
	zPtr += 4;
	/* 4 bytes: Database page size. */
	SyBigEndianPack32(zPtr,(sxu32)pPager->iPageSize);
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x37043(%rip), %rdi     # 0x72bd2
movl $0x8, %edx
callq 0x34893
movl $0x0, 0x8(%rbx)
movl 0x168(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movq 0x48(%r14), %rax
bswapq %rax
movq %rax, 0x10(%rbx)
movl 0x20c(%r14), %eax
bswapl %eax
movl %eax, 0x18(%rbx)
movl 0x208(%r14), %eax
bswapl %eax
movl %eax, 0x1c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteFinalizeJournal
static int unqliteFinalizeJournal(Pager *pPager,int *pRetry,int close_jrnl)
{
	int rc;
	*pRetry = 0;
	/* Grab the exclusive lock first */
	rc = pager_lock_db(pPager,EXCLUSIVE_LOCK);
	if( rc != UNQLITE_OK ){
		/* Retry the excusive lock process */
		*pRetry = 1;
		rc = UNQLITE_OK;
	}
	if( pPager->no_jrnl ){
		/* Journaling is omitted, return immediately */
		return UNQLITE_OK;
	}
	/* Write the total number of database records */
	rc = WriteInt32(pPager->pjfd,pPager->nRec,8 /* sizeof(aJournalRec) */);
	if( rc != UNQLITE_OK ){
		if( pPager->nRec > 0 ){
			return rc;
		}else{
			/* Not so fatal */
			rc = UNQLITE_OK;
		}
	}
	/* Sync the journal and close it */
	rc = unqliteOsSync(pPager->pjfd,UNQLITE_SYNC_NORMAL);
	if( close_jrnl ){
		/* close the journal file */
		if( UNQLITE_OK != unqliteOsCloseFree(pPager->pAllocator,pPager->pjfd) ){
			if( rc != UNQLITE_OK /* unqliteOsSync */ ){
				return rc;
			}
		}
		pPager->pjfd = 0;
	}
	if( (*pRetry) == 1 ){
		if( pager_lock_db(pPager,EXCLUSIVE_LOCK) == UNQLITE_OK ){
			/* Got exclusive lock */
			*pRetry = 0;
		}
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rsi)
movl $0x4, %esi
callq 0x3ba70
testl %eax, %eax
je 0x3bc09
movl $0x1, (%r14)
xorl %ebx, %ebx
cmpl $0x0, 0x204(%r15)
je 0x3bc26
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r15), %rdi
movl 0x60(%r15), %eax
bswapl %eax
leaq -0x3c(%rbp), %rsi
movl %eax, (%rsi)
movq (%rdi), %rax
movl $0x4, %edx
movl $0x8, %ecx
callq *0x18(%rax)
testl %eax, %eax
je 0x3bc55
cmpl $0x0, 0x60(%r15)
je 0x3bc55
movl %eax, %ebx
jmp 0x3bc15
movq 0x38(%r15), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x28(%rax)
testl %r12d, %r12d
je 0x3bcb6
movq 0x38(%r15), %r12
testq %r12, %r12
je 0x3bcae
movl %eax, %r13d
movq (%r15), %rax
movq %rax, -0x38(%rbp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x3490d
cmpl $0x0, -0x2c(%rbp)
setne %al
testl %r13d, %r13d
setne %cl
testb %cl, %al
je 0x3bcae
movl %r13d, %ebx
jmp 0x3bc15
movq $0x0, 0x38(%r15)
cmpl $0x1, (%r14)
jne 0x3bc15
movq %r15, %rdi
movl $0x4, %esi
callq 0x3ba70
testl %eax, %eax
jne 0x3bc15
movl $0x0, (%r14)
jmp 0x3bc15
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: page_merge_hot
static Page * page_merge_hot(Page *pA, Page *pB)
{
	Page result, *pTail;
    /* Prevent compiler warning */
	result.pNextHot = result.pPrevHot = 0;
	pTail = &result;
	while( pA && pB ){
		if( pA->iPage < pB->iPage ){
			pTail->pPrevHot = pA;
			pA->pNextHot = pTail;
			pTail = pA;
			pA = pA->pPrevHot;
		}else{
			pTail->pPrevHot = pB;
			pB->pNextHot = pTail;
			pTail = pB;
			pB = pB->pPrevHot;
		}
	}
	if( pA ){
		pTail->pPrevHot = pA;
		pA->pNextHot = pTail;
	}else if( pB ){
		pTail->pPrevHot = pB;
		pB->pNextHot = pTail;
	}else{
		pTail->pPrevHot = pTail->pNextHot = 0;
	}
	return result.pPrevHot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
setne %dl
testq %rsi, %rsi
setne %cl
movl %edx, %eax
andb %cl, %al
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%rbp)
cmpb $0x1, %al
jne 0x3bd55
leaq -0x68(%rbp), %rax
movq %rsi, %r8
movq %rdi, %r9
movq 0x10(%r9), %rcx
cmpq 0x10(%r8), %rcx
jae 0x3bd28
movq %r9, 0x60(%rax)
movq %rax, 0x58(%r9)
movq 0x60(%r9), %rdi
movq %r8, %rsi
movq %r9, %rax
jmp 0x3bd3a
movq %r8, 0x60(%rax)
movq %rax, 0x58(%r8)
movq 0x60(%r8), %rsi
movq %r9, %rdi
movq %r8, %rax
testq %rsi, %rsi
setne %cl
testq %rdi, %rdi
setne %dl
je 0x3bd59
movq %rsi, %r8
movq %rdi, %r9
testq %rsi, %rsi
jne 0x3bd0a
jmp 0x3bd59
leaq -0x68(%rbp), %rax
testb %dl, %dl
je 0x3bd67
movq %rdi, 0x60(%rax)
movq %rax, 0x58(%rdi)
jmp 0x3bd7c
testb %cl, %cl
je 0x3bd75
movq %rsi, 0x60(%rax)
movq %rax, 0x58(%rsi)
jmp 0x3bd7c
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_unlink_page
static int pager_unlink_page(Pager *pPager,Page *pPage)
{
	if( pPage->pNextCollide ){
		pPage->pNextCollide->pPrevCollide = pPage->pPrevCollide;
	}
	if( pPage->pPrevCollide ){
		pPage->pPrevCollide->pNextCollide = pPage->pNextCollide;
	}else{
		sxu32 nBucket = PAGE_HASH(pPage->iPage) & (pPager->nSize - 1);
		pPager->apHash[nBucket] = pPage->pNextCollide;
	}
	MACRO_LD_REMOVE(pPager->pAll,pPage);
	pPager->nPage--;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rsi), %rax
movq 0x50(%rsi), %rcx
testq %rax, %rax
je 0x3bd97
movq %rcx, 0x50(%rax)
testq %rcx, %rcx
je 0x3bda2
addq $0x48, %rcx
jmp 0x3bdb8
movl 0x250(%rdi), %ecx
decl %ecx
andl 0x10(%rsi), %ecx
shlq $0x3, %rcx
addq 0x248(%rdi), %rcx
movq %rax, (%rcx)
movq 0x228(%rdi), %rax
cmpq %rsi, %rax
jne 0x3bdd2
movq 0x28(%rax), %rax
movq %rax, 0x228(%rdi)
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x3bde3
movq %rax, 0x28(%rcx)
testq %rax, %rax
je 0x3bdec
movq %rcx, 0x30(%rax)
decl 0x254(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_release_page
static int pager_release_page(Pager *pPager,Page *pPage)
{
	int rc = UNQLITE_OK;
	if( !(pPage->flags & PAGE_DIRTY)){
		/* Invoke the unpin callback if available */
		if( pPager->xPageUnpin && pPage->pUserData ){
			pPager->xPageUnpin(pPage->pUserData);
		}
		pPage->pUserData = 0;
		SyMemBackendPoolFree(pPager->pAllocator,pPage);
	}else{
		/* Dirty page, it will be released later when a dirty commit
		 * or the final commit have been applied.
		 */
		rc = UNQLITE_LOCKED;
	}
	return rc;
}

// Assembly:
testb $0x2, 0x20(%rsi)
jne 0x3be35
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x188(%rdi), %rax
testq %rax, %rax
je 0x3be1e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3be1e
callq *%rax
movq $0x0, 0x8(%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e659
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBitvecSet
UNQLITE_PRIVATE int unqliteBitvecSet(Bitvec *p,pgno i)
{
	bitvec_rec *pRec;
	sxi32 iBuck;
	/* Allocate a new instance */
	pRec = (bitvec_rec *)SyMemBackendPoolAlloc(p->pAlloc,sizeof(bitvec_rec));
	if( pRec == 0 ){
		return UNQLITE_NOMEM;
	}
	/* Zero the structure */
	SyZero(pRec,sizeof(bitvec_rec));
	/* Fill-in */
	pRec->iPage = i;
	iBuck = i & (p->nSize - 1);
	pRec->pNextCol = p->apRec[iBuck];
	p->apRec[iBuck] = pRec;
	pRec->pNext = p->pList;
	p->pList = pRec;
	p->nRec++;
	if( p->nRec >= (p->nSize * 3) && p->nRec < 100000 ){
		/* Grow the hashtable */
		sxu32 nNewSize = p->nSize << 1;
		bitvec_rec *pEntry,**apNew;
		sxu32 n;
		apNew = (bitvec_rec **)SyMemBackendAlloc(p->pAlloc, nNewSize * sizeof(bitvec_rec *));
		if( apNew ){
			sxu32 iBucket;
			/* Zero the new table */
			SyZero((void *)apNew, nNewSize * sizeof(bitvec_rec *));
			/* Rehash all entries */
			n = 0;
			pEntry = p->pList;
			for(;;){
				/* Loop one */
				if( n >= p->nRec ){
					break;
				}
				pEntry->pNextCol = 0;
				/* Install in the new bucket */
				iBucket = pEntry->iPage & (nNewSize - 1);
				pEntry->pNextCol = apNew[iBucket];
				apNew[iBucket] = pEntry;
				/* Point to the next entry */
				pEntry = pEntry->pNext;
				n++;
			}
			/* Release the old table and reflect the change */
			SyMemBackendFree(p->pAlloc,(void *)p->apRec);
			p->apRec = apNew;
			p->nSize  = nNewSize;
		}
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x18, %esi
callq 0x2e481
testq %rax, %rax
je 0x3bfeb
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x14, %rcx
jb 0x3bee5
movq %r14, (%rax)
movl 0xc(%rbx), %r12d
leal -0x1(%r12), %ecx
andl %ecx, %r14d
movq 0x10(%rbx), %rcx
movslq %r14d, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rsi, 0x10(%rax)
movq %rax, (%rcx,%rdx,8)
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rbx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
leal (%r12,%r12,2), %ecx
cmpl %ecx, %eax
setb %cl
cmpl $0x186a0, %eax          # imm = 0x186A0
setae %al
orb %cl, %al
jne 0x3bfeb
movq (%rbx), %rdi
movl %r12d, %r15d
shll $0x4, %r15d
movl %r15d, %esi
callq 0x33d86
testq %rax, %rax
je 0x3bfeb
movq %rax, %r14
testl %r15d, %r15d
je 0x3bfa1
movl %r15d, %ecx
movq %r14, %rax
addq %rcx, %rax
movq %r14, %rcx
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bfa1
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bfa1
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bfa1
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x3bf75
addl %r12d, %r12d
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x3bfd7
leaq 0x18(%rbx), %rcx
leal -0x1(%r12), %edx
movq (%rcx), %rcx
movq $0x0, 0x10(%rcx)
movl (%rcx), %esi
andl %edx, %esi
movq (%r14,%rsi,8), %rdi
movq %rdi, 0x10(%rcx)
movq %rcx, (%r14,%rsi,8)
addq $0x8, %rcx
decl %eax
jne 0x3bfb4
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3490d
movq %r14, 0x10(%rbx)
movl %r12d, 0xc(%rbx)
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: unqliteBitvecDestroy
UNQLITE_PRIVATE void unqliteBitvecDestroy(Bitvec *p)
{
	bitvec_rec *pNext,*pRec = p->pList;
	SyMemBackend *pAlloc = p->pAlloc;
	
	for(;;){
		if( p->nRec < 1 ){
			break;
		}
		pNext = pRec->pNext;
		SyMemBackendPoolFree(pAlloc,(void *)pRec);
		pRec = pNext;
		p->nRec--;

		if( p->nRec < 1 ){
			break;
		}
		pNext = pRec->pNext;
		SyMemBackendPoolFree(pAlloc,(void *)pRec);
		pRec = pNext;
		p->nRec--;


		if( p->nRec < 1 ){
			break;
		}
		pNext = pRec->pNext;
		SyMemBackendPoolFree(pAlloc,(void *)pRec);
		pRec = pNext;
		p->nRec--;


		if( p->nRec < 1 ){
			break;
		}
		pNext = pRec->pNext;
		SyMemBackendPoolFree(pAlloc,(void *)pRec);
		pRec = pNext;
		p->nRec--;
	}
	SyMemBackendFree(pAlloc,(void *)p->apRec);
	SyMemBackendFree(pAlloc,p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0x8(%rdi)
je 0x3c076
movq 0x18(%rbx), %r15
movq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e659
decl 0x8(%rbx)
je 0x3c076
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x2e659
decl 0x8(%rbx)
je 0x3c076
movq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e659
decl 0x8(%rbx)
je 0x3c076
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x2e659
decl 0x8(%rbx)
jne 0x3c024
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3490d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3490d
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_collection_exists
static int unqliteBuiltin_collection_exists(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");
		/* 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);
	/* Perform the lookup */
	pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
	/* Lookup result */
	jx9_result_bool(pCtx,pCol ? 1 : 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c16d
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3c181
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x3c1b0
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37de5(%rip), %rcx     # 0x73f64
jmp 0x3c193
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37de9(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_collection_create
static int unqliteBuiltin_collection_create(jx9_context *pCtx,int argc,jx9_value **argv)
{
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	int nByte;
	int rc;
	/* Extract collection name */
	if( argc < 1 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
		/* 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);
	/* Try to create the collection */
	rc = unqliteCreateCollection(pVm,&sName);
	/* Return the result to the caller */
	jx9_result_bool(pCtx,rc == UNQLITE_OK ? 1 : 0);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c21d
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x3c231
movq %rax, %r14
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movl %r15d, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %r12
movq %r12, %rdi
callq 0x3d436
testq %rax, %rax
je 0x3c262
xorl %r14d, %r14d
jmp 0x3c281
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37d35(%rip), %rcx     # 0x73f64
jmp 0x3c243
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37d39(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
jmp 0x3c290
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x3d4df
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
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: unqliteBuiltin_db_fetch_next
static int unqliteBuiltin_db_fetch_next(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	int nByte;
	int rc;
	/* Extract collection name */
	if( argc < 1 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
		/* Return null */
		jx9_result_null(pCtx);
		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 null */
		jx9_result_null(pCtx);
		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 ){
		/* Fetch the current record */
		jx9_value *pValue;
		pValue = jx9_context_new_scalar(pCtx);
		if( pValue == 0 ){
			jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Jx9 is running out of memory");
			jx9_result_null(pCtx);
			return JX9_OK;
		}else{
			rc = unqliteCollectionFetchNextRecord(pCol,pValue);
			if( rc == UNQLITE_OK ){
				jx9_result_value(pCtx,pValue);
				/* pValue will be automatically released as soon we return from this function */
			}else{
				/* Return null */
				jx9_result_null(pCtx);
			}
		}
	}else{
		/* No such collection, return null */
		jx9_result_null(pCtx);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c31d
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3c331
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3c361
movq %rax, %r15
movq %rbx, %rdi
callq 0x311eb
testq %rax, %rax
je 0x3c345
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x4046f
movq 0x8(%rbx), %rsi
testl %eax, %eax
je 0x3c377
movq %rsi, %rdi
jmp 0x3c365
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37c35(%rip), %rcx     # 0x73f64
jmp 0x3c357
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37c39(%rip), %rcx     # 0x73f7c
jmp 0x3c357
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37d64(%rip), %rcx     # 0x740bb
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3e19f
jmp 0x3c36a
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_fetch_by_id
static int unqliteBuiltin_db_fetch_by_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	jx9_int64 nId;
	int nByte;
	int rc;
	/* Extract collection name */
	if( argc < 2 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or record ID");
		/* Return NULL */
		jx9_result_null(pCtx);
		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 NULL */
		jx9_result_null(pCtx);
		return JX9_OK;
	}
	/* Extract the record ID */
	nId = jx9_value_to_int(argv[1]);
	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 ){
		/* Fetch the desired record */
		jx9_value *pValue;
		pValue = jx9_context_new_scalar(pCtx);
		if( pValue == 0 ){
			jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Jx9 is running out of memory");
			jx9_result_null(pCtx);
			return JX9_OK;
		}else{
			rc = unqliteCollectionFetchRecordById(pCol,nId,pValue);
			if( rc == UNQLITE_OK ){
				jx9_result_value(pCtx,pValue);
				/* pValue will be automatically released as soon we return from this function */
			}else{
				/* No such record, return null */
				jx9_result_null(pCtx);
			}
		}
	}else{
		/* No such collection, return null */
		jx9_result_null(pCtx);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x3c3af
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37d48(%rip), %rcx     # 0x740f2
jmp 0x3c44c
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30577
cmpl $0x0, (%r12)
jle 0x3c426
movq %rax, %r15
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3f362
movslq (%r14), %r14
leaq -0x38(%rbp), %rsi
movq %r15, (%rsi)
movl -0x24(%rbp), %eax
movl %eax, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3c456
movq %rax, %r12
movq %rbx, %rdi
callq 0x311eb
testq %rax, %rax
je 0x3c43a
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x404c4
movq 0x8(%rbx), %rsi
testl %eax, %eax
je 0x3c46e
movq %rsi, %rdi
jmp 0x3c45a
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37b44(%rip), %rcx     # 0x73f7c
jmp 0x3c44c
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37c6f(%rip), %rcx     # 0x740bb
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rdi
callq 0x30465
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x3e19f
jmp 0x3c45f
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_last_record_id
static int unqliteBuiltin_db_last_record_id(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");
		/* 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 ){
		jx9_result_int64(pCtx,unqliteCollectionLastRecordId(pCol));
	}else{
		/* No such collection, return FALSE */
		jx9_result_bool(pCtx,0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c6c4
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3c6d8
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3c6f4
movq 0xa8(%rax), %rax
xorl %r14d, %r14d
subq $0x1, %rax
cmovaeq %rax, %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0x2, %eax
jmp 0x3c70c
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3788e(%rip), %rcx     # 0x73f64
jmp 0x3c6ea
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37892(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0x8, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_total_records
static int unqliteBuiltin_db_total_records(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");
		/* 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 ){
		unqlite_int64 nRec;
		nRec = unqliteCollectionTotalRecords(pCol);
		jx9_result_int64(pCtx,nRec);
	}else{
		/* No such collection */
		jx9_result_bool(pCtx,0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c903
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3c917
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3c933
movq 0xb8(%rax), %r14
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0x2, %eax
jmp 0x3c94b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3764f(%rip), %rcx     # 0x73f64
jmp 0x3c929
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37653(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0x8, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_creation_date
static int unqliteBuiltin_db_creation_date(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");
		/* 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 ){
		Sytm *pTm = &pCol->sCreation;
		jx9_result_string_format(pCtx,"%d-%d-%d %02d:%02d:%02d",
			pTm->tm_year,pTm->tm_mon,pTm->tm_mday,
			pTm->tm_hour,pTm->tm_min,pTm->tm_sec
			);
	}else{
		/* No such collection */
		jx9_result_bool(pCtx,0);
	}
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c9e9
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3c9fd
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3ca19
movl 0xf4(%rax), %edx
movl 0xf0(%rax), %ecx
movl 0xec(%rax), %r8d
movl 0xe8(%rax), %r9d
movl 0xe0(%rax), %r10d
movl 0xe4(%rax), %r11d
leaq 0x37bd4(%rip), %rsi     # 0x745a9
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x44e00
addq $0x10, %rsp
jmp 0x3ca3a
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37569(%rip), %rcx     # 0x73f64
jmp 0x3ca0f
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3756d(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_store
static int unqliteBuiltin_db_store(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	int nByte;
	int rc;
	int i;
	/* Extract collection name */
	if( argc < 2 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or records");
		/* 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 == 0 ){
		jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
		/* Return false */
		jx9_result_bool(pCtx,0);
		return JX9_OK;
	}
	/* Store the given values */
	for( i = 1 ; i < argc ; ++i ){
		rc = unqliteCollectionPut(pCol,argv[i],0);
		if( rc != UNQLITE_OK){
			jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,
				"Error while storing record %d in collection '%z'",i,&sName
				);
			/* Return false */
			jx9_result_bool(pCtx,0);
			return JX9_OK;
		}
	}
	/* All done, return TRUE */
	jx9_result_bool(pCtx,1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x3ca75
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37b51(%rip), %rcx     # 0x745c1
jmp 0x3cb20
movq %rdx, %r14
movl %esi, %r15d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x30577
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x3cb0e
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3cb5c
movq %rax, %r12
movl %r15d, %r13d
movl $0x1, %r15d
movq (%r14,%r15,8), %rsi
testb $0x40, 0x8(%rsi)
je 0x3cae1
movq (%rsi), %rdi
testb $0x1, 0x40(%rdi)
jne 0x3cae1
leaq 0x8490(%rip), %rsi      # 0x44f67
movq %r12, %rdx
callq 0x5134a
jmp 0x3cae9
movq %r12, %rdi
callq 0x44f71
testl %eax, %eax
jne 0x3cb78
incq %r15
cmpq %r15, %r13
jne 0x3cabd
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x1, (%rbx)
jmp 0x3cb3d
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3745c(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37a85(%rip), %rdx     # 0x745e8
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x44ed3
jmp 0x3cb2a
leaq 0x37a81(%rip), %rdx     # 0x74600
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x44ed3
jmp 0x3cb2a
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_drop_record
static int unqliteBuiltin_db_drop_record(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	jx9_int64 nId;
	int nByte;
	int rc;
	/* Extract collection name */
	if( argc < 2 ){
		/* Missing arguments */
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or records");
		/* 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 == 0 ){
		jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
		/* Return false */
		jx9_result_bool(pCtx,0);
		return JX9_OK;
	}
	/* Extract the record ID */
	nId = jx9_value_to_int64(argv[1]);
	/* Drop the record */
	rc = unqliteCollectionDropRecord(pCol,nId,1,1);
	/* Processing result */
	jx9_result_bool(pCtx,rc == UNQLITE_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x3ceef
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x376d7(%rip), %rcx     # 0x745c1
jmp 0x3cf77
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x3cf65
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3cfaf
movq %rax, %r15
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3f362
movq (%r14), %rsi
movq %r15, %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x45192
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x3cf94
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37005(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37632(%rip), %rdx     # 0x745e8
leaq -0x30(%rbp), %rcx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x44ed3
jmp 0x3cf81
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_set_schema
static int unqliteBuiltin_db_set_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_col *pCol;
	const char *zName;
	unqlite_vm *pVm;
	SyString sName;
	int nByte;
	int rc;
	/* Extract collection name */
	if( argc < 2 ){
		/* 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;
	}
	if( !jx9_value_is_json_object(argv[1]) ){
		jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection 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 */
	rc = UNQLITE_NOOP;
	pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
	if( pCol ){
		/* Set the collection scheme */
		rc = unqliteCollectionSetSchema(pCol,argv[1]);
	}else{
		jx9_context_throw_error_format(pCtx,JX9_CTX_WARNING,
			"No such collection '%z'",
			&sName
			);
	}
	/* Processing result */
	jx9_result_bool(pCtx,rc == UNQLITE_OK);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x3cff4
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37793(%rip), %rcx     # 0x74785
jmp 0x3d01c
movq %rdx, %r14
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x3d00a
movq (%rax), %rax
testb $0x1, 0x40(%rax)
jne 0x3d054
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37792(%rip), %rcx     # 0x747ae
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30577
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x3d09e
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3d0b5
movq 0x8(%r14), %r8
testb $0x40, 0x8(%r8)
je 0x3d099
movq (%r8), %rcx
testb $0x1, 0x40(%rcx)
jne 0x3d0d4
xorl %r14d, %r14d
jmp 0x3d0f5
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x36ecc(%rip), %rcx     # 0x73f7c
jmp 0x3d01c
leaq 0x3752c(%rip), %rdx     # 0x745e8
xorl %r14d, %r14d
leaq -0x30(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
jmp 0x3d0f5
xorl %edi, %edi
movq %rax, %rsi
movq $-0x1, %rdx
movq $-0x1, %rcx
callq 0x3da9b
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
jmp 0x3d039
// File: /workspace/github_c_makefile_star2_O3/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 0x3d15e
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30577
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3d172
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3d436
testq %rax, %rax
je 0x3d1ba
addq $0x20, %rax
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3e19f
jmp 0x3d1af
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x37615(%rip), %rcx     # 0x74785
jmp 0x3d184
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x36df8(%rip), %rcx     # 0x73f7c
movl $0x1, %edx
callq 0x40afa
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq $0x0, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x37427(%rip), %rdx     # 0x745e8
leaq -0x28(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x44ed3
movq 0x8(%rbx), %rdi
callq 0x30465
jmp 0x3d1af
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x326c5
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x30465
movq %r14, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x8, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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, %rbx
cmpl $0x0, 0xd8(%rdi)
movq (%rsi), %r15
movl 0x8(%rsi), %r12d
je 0x3d4ab
movq %r15, %rdi
movl %r12d, %esi
callq 0x3d9e9
movl %eax, %r13d
movq 0xc8(%rbx), %rax
movl 0xdc(%rbx), %ecx
decl %ecx
andl %r13d, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x3d4ab
cmpl 0x18(%r14), %r13d
jne 0x3d4a2
movl %r12d, %eax
subl 0x10(%r14), %eax
jne 0x3d49e
movq 0x8(%r14), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x347f1
testl %eax, %eax
je 0x3d4cd
movq 0x130(%r14), %r14
jmp 0x3d47b
xorl %r14d, %r14d
leaq -0x30(%rbp), %r8
movq %r14, (%r8)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x3d4df
testl %eax, %eax
jne 0x3d4cd
movq -0x30(%rbp), %r14
movq %r14, %rax
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: 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:
testl %esi, %esi
je 0x3da4d
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
addq %rdi, %rcx
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %edx
shll $0x5, %edx
addl %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x3da59
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x3da53
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x3da57
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x3d9fb
jmp 0x3da59
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x3da59
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33d86
movq %rax, %r12
testq %rax, %rax
je 0x3da8f
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x33dd1
movq %r12, %rax
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: SyBlobAppendBig32
JX9_PRIVATE sxi32 SyBlobAppendBig32(SyBlob *pBlob,sxu32 n32)
{
	unsigned char zBuf[4];
	sxi32 rc;
	SyBigEndianPack32(zBuf,n32);
	rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
bswapl %esi
leaq -0x4(%rbp), %rax
movl %esi, (%rax)
movq %rax, %rsi
movl $0x4, %edx
callq 0x359ad
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e1bb
movq (%r15), %rax
incl 0x50(%rax)
testb $0x40, 0x8(%r14)
jne 0x3e1c6
xorl %ebx, %ebx
jmp 0x3e1c9
movq (%r14), %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq 0x34893
cmpl $0x0, 0x28(%r15)
je 0x3e224
movl $0x0, 0x28(%r14)
movl 0x30(%r14), %eax
testb $0x4, %al
je 0x3e207
movq $0x0, 0x20(%r14)
movl $0x0, 0x2c(%r14)
andl $-0x5, %eax
movl %eax, 0x30(%r14)
movl 0x28(%r15), %edx
testl %edx, %edx
je 0x3e23c
addq $0x18, %r14
movq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x359ad
movl %eax, %r15d
jmp 0x3e23f
xorl %r15d, %r15d
cmpl $0x0, 0x28(%r14)
je 0x3e23f
addq $0x18, %r14
movq %r14, %rdi
callq 0x317be
jmp 0x3e23f
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x3e25f
movl 0x50(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x50(%rbx)
cmpl $0x1, %eax
jg 0x3e25f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3e379
movl %r15d, %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: jx9HashmapExtractNodeKey
JX9_PRIVATE void jx9HashmapExtractNodeKey(jx9_hashmap_node *pNode,jx9_value *pKey)
{
	/* Fill with the current key */
	if( pNode->iType == HASHMAP_INT_NODE ){
		if( SyBlobLength(&pKey->sBlob) > 0 ){
			SyBlobRelease(&pKey->sBlob);
		}
		pKey->x.iVal = pNode->xKey.iKey;
		MemObjSetType(pKey, MEMOBJ_INT);
	}else{
		SyBlobReset(&pKey->sBlob);
		SyBlobAppend(&pKey->sBlob, SyBlobData(&pNode->xKey.sKey), SyBlobLength(&pNode->xKey.sKey));
		MemObjSetType(pKey, MEMOBJ_STRING);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x8(%rdi)
jne 0x3e32e
cmpl $0x0, 0x28(%rbx)
je 0x3e320
leaq 0x18(%rbx), %rdi
callq 0x317be
movq 0x10(%r14), %rax
movq %rax, (%rbx)
movl $0x2, %eax
jmp 0x3e367
leaq 0x18(%rbx), %rdi
movl $0x0, 0x28(%rbx)
movl 0x30(%rbx), %eax
testb $0x4, %al
je 0x3e355
movq $0x0, 0x20(%rbx)
movl $0x0, 0x2c(%rbx)
andl $-0x5, %eax
movl %eax, 0x30(%rbx)
movq 0x18(%r14), %rsi
movl 0x20(%r14), %edx
callq 0x359ad
movl $0x1, %eax
movl $0xfffffe90, %ecx       # imm = 0xFFFFFE90
andl 0x8(%rbx), %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq