LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteOsCloseFree
UNQLITE_PRIVATE int unqliteOsCloseFree(SyMemBackend *pAlloc,unqlite_file *pId)
{
	int rc = UNQLITE_OK;
	if( pId ){
		rc = pId->pMethods->xClose(pId);
		SyMemBackendFree(pAlloc,pId);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x697ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d6b0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ReadInt32
static int ReadInt32(unqlite_file *pFd,sxu32 *pOut,sxi64 iOfft)
{
	unsigned char zBuf[4];
	int rc;
	rc = unqliteOsRead(pFd,zBuf,sizeof(zBuf),iOfft);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	SyBigEndianUnpack32(zBuf,pOut);
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x4, %edx
callq 0x69cd0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x69d4b
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69d5f
leaq -0x24(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61d60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: ReadInt64
static int ReadInt64(unqlite_file *pFd,sxu64 *pOut,sxi64 iOfft)
{
	unsigned char zBuf[8];
	int rc;
	rc = unqliteOsRead(pFd,zBuf,sizeof(zBuf),iOfft);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	SyBigEndianUnpack64(zBuf,pOut);
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x8, %edx
callq 0x69cd0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x69dab
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69dbf
leaq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61db0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_cksum
static sxu32 pager_cksum(Pager *pPager,const unsigned char *zData)
{
  sxu32 cksum = pPager->cksumInit;         /* Checksum value to return */
  int i = pPager->iPageSize-200;          /* Loop counter */
  while( i>0 ){
    cksum += zData[i];
    i -= 200;
  }
  return cksum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x168(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x208(%rax), %eax
subl $0xc8, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x69e20
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
subl $0xc8, %eax
movl %eax, -0x18(%rbp)
jmp 0x69dfb
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x68930
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x69ea5
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x69ec6
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x208(%rax), %edx
callq 0x5d570
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: GetSectorSize
static int GetSectorSize(unqlite_file *pFd)
{
	int iSectorSize = UNQLITE_DEFAULT_SECTOR_SIZE;
	if( pFd ){
		iSectorSize = unqliteOsSectorSize(pFd);
		if( iSectorSize < 32 ){
			iSectorSize = 512;
		}
		if( iSectorSize > MAX_SECTOR_SIZE ){
			iSectorSize = MAX_SECTOR_SIZE;
		}
	}
	return iSectorSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x200, -0xc(%rbp)      # imm = 0x200
cmpq $0x0, -0x8(%rbp)
je 0x6a125
movq -0x8(%rbp), %rdi
callq 0x6a1e0
movl %eax, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x6a113
movl $0x200, -0xc(%rbp)      # imm = 0x200
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jle 0x6a123
movl $0x10000, -0xc(%rbp)    # imm = 0x10000
jmp 0x6a125
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyDosTimeFormat
JX9_PRIVATE void SyDosTimeFormat(sxu32 nDosDate, Sytm *pOut)
{
	sxu16 nDate;
	sxu16 nTime;
	nDate = nDosDate >> 16;
	nTime = nDosDate & 0xFFFF;
	pOut->tm_isdst  = 0;
	pOut->tm_year 	= 1980 + (nDate >> 9);
	pOut->tm_mon	= (nDate % (1<<9))>>5;
	pOut->tm_mday	= (nDate % (1<<9))&0x1F;
	pOut->tm_hour	= nTime >> 11;
	pOut->tm_min	= (nTime % (1<<11)) >> 5;
	pOut->tm_sec	= ((nTime % (1<<11))& 0x1F )<<1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x12(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movzwl -0x12(%rbp), %ecx
sarl $0x9, %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movzwl -0x12(%rbp), %eax
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
sarl $0x5, %edx
movq -0x10(%rbp), %rax
movl %edx, 0x10(%rax)
movzwl -0x12(%rbp), %eax
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
andl $0x1f, %edx
movq -0x10(%rbp), %rax
movl %edx, 0xc(%rax)
movzwl -0x14(%rbp), %ecx
sarl $0xb, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movzwl -0x14(%rbp), %eax
movl $0x800, %ecx            # imm = 0x800
cltd
idivl %ecx
sarl $0x5, %edx
movq -0x10(%rbp), %rax
movl %edx, 0x4(%rax)
movzwl -0x14(%rbp), %eax
movl $0x800, %ecx            # imm = 0x800
cltd
idivl %ecx
movl %edx, %ecx
andl $0x1f, %ecx
shll %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlitePageWrite
static int unqlitePageWrite(unqlite_page *pMyPage)
{
	Page *pPage = (Page *)pMyPage;
	Pager *pPager = pPage->pPager;
	int rc;
	/* Begin the write transaction */
	rc = unqlitePagerBegin(pPager);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	if( pPager->iState == PAGER_WRITER_LOCKED ){
		/* The journal file needs to be opened. Higher level routines have already
		 ** obtained the necessary locks to begin the write-transaction, but the
		 ** rollback journal might not yet be open. Open it now if this is the case.
		 */
		rc = unqliteOpenJournal(pPager);
		if( rc != UNQLITE_OK ){
			return rc;
		}
	}
	if( pPager->nHot > 127 ){
		/* Write hot dirty pages */
		rc = pager_dirty_commit(pPager);
		if( rc != UNQLITE_OK ){
			/* A rollback must be done */
			unqliteGenError(pPager->pDb,"Please perform a rollback");
			return rc;
		}
	}
	/* Write the page to the journal file */
	rc = page_write(pPager,pPage);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x59ee0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a28a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a306
movq -0x20(%rbp), %rax
cmpl $0x2, 0x1f0(%rax)
jne 0x6a2b3
movq -0x20(%rbp), %rdi
callq 0x6a310
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a2b1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a306
jmp 0x6a2b3
movq -0x20(%rbp), %rax
cmpl $0x7f, 0x240(%rax)
jbe 0x6a2f0
movq -0x20(%rbp), %rdi
callq 0x6a4c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a2ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x57ee5(%rip), %rsi     # 0xc21c6
callq 0x58950
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a306
jmp 0x6a2f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a5e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_dirty_commit
static int pager_dirty_commit(Pager *pPager)
{
	int get_excl = 0;
	Page *pHot;
	int rc;
	/* Finalize the journal file without closing it */
	rc = unqliteFinalizeJournal(pPager,&get_excl,0);
	if( rc != UNQLITE_OK ){
		/* It's not a fatal error if something goes wrong here since
		 * its not the final commit.
		 */
		return UNQLITE_OK;
	}
	/* Point to the list of hot pages */
	pHot = pager_get_hot_pages(pPager);
	if( pHot == 0 ){
		return UNQLITE_OK;
	}
	if( get_excl ){
		/* Wait one last time for the exclusive lock */
		rc = pager_wait_on_lock(pPager,EXCLUSIVE_LOCK);
		if( rc != UNQLITE_OK ){
			/* Not so fatal, will try another time */
			return UNQLITE_OK;
		}
	}
	/* Tell that a dirty commit happen */
	pPager->iFlags |= PAGER_CTRL_DIRTY_COMMIT;
	/* Write the hot pages now */
	rc = pager_write_hot_dirty_pages(pPager,pHot);
	if( rc != UNQLITE_OK ){
		pPager->iFlags |= PAGER_CTRL_COMMIT_ERR;
		unqliteGenError(pPager->pDb,"IO error while writing hot dirty pages, rollback your database");
		return rc;
	}
	pPager->pFirstHot = pPager->pHotDirty = 0;
	pPager->nHot = 0;
	/* No need to sync the database file here, since the journal is already
	 * open here and this is not the final commit.
	 */
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x6a8d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a4f7
movl $0x0, -0x4(%rbp)
jmp 0x6a5cd
movq -0x10(%rbp), %rdi
callq 0x6aa00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6a517
movl $0x0, -0x4(%rbp)
jmp 0x6a5cd
cmpl $0x0, -0x14(%rbp)
je 0x6a542
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x68eb0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a540
movl $0x0, -0x4(%rbp)
jmp 0x6a5cd
jmp 0x6a542
movq -0x10(%rbp), %rax
movl 0x1f8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1f8(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6abc0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6a59a
movq -0x10(%rbp), %rax
movl 0x1f8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x1f8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x57c7b(%rip), %rsi     # 0xc2208
callq 0x58950
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a5cd
movq -0x10(%rbp), %rax
movq $0x0, 0x230(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x238(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x240(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x569b3(%rip), %rdi     # 0xc11d6
movl $0x8, %edx
callq 0x5d570
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x61bf0
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x168(%rax), %esi
callq 0x61bf0
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x61c60
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x20c(%rax), %esi
callq 0x61bf0
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x208(%rax), %esi
callq 0x61bf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x69410
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x6a915
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x204(%rax)
je 0x6a92e
movl $0x0, -0x4(%rbp)
jmp 0x6a9f0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
movl $0x8, %edx
callq 0x6acf0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x6a96e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jbe 0x6a965
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a9f0
movl $0x0, -0x20(%rbp)
jmp 0x6a96e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x2, %esi
callq 0x695e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6a9c1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x697c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x6a9b5
cmpl $0x0, -0x20(%rbp)
je 0x6a9b3
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a9f0
jmp 0x6a9b5
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6a9e9
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x69410
cmpl $0x0, %eax
jne 0x6a9e7
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x6a9e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_get_hot_pages
static Page * pager_get_hot_pages(Pager *pPager)
{
	Page *a[N_SORT_BUCKET], *p, *pIn;
	sxu32 i;
	if( pPager->pFirstHot == 0 ){
		/* Don't bother sorting, the list is already empty */
		return 0;
	}
	SyZero(a, sizeof(a));
	/* Point to the first inserted entry */
	pIn = pPager->pFirstHot;
	while( pIn ){
		p = pIn;
		pIn = p->pPrevHot;
		p->pPrevHot = 0;
		for(i=0; i<N_SORT_BUCKET-1; i++){
			if( a[i]==0 ){
				a[i] = p;
				break;
			}else{
				p = page_merge_hot(a[i], p);
				a[i] = 0;
			}
		}
		if( i==N_SORT_BUCKET-1 ){
			/* To get here, there need to be 2^(N_SORT_BUCKET) elements in he input list.
			 * But that is impossible.
			 */
			a[i] = page_merge_hot(a[i], p);
		}
	}
	p = a[0];
	for(i=1; i<N_SORT_BUCKET; i++){
		p = page_merge_hot(p,a[i]);
	}
	p->pNextHot = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x6aa2a
movq $0x0, -0x8(%rbp)
jmp 0x6abb1
leaq -0x110(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x54280
movq -0x10(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x120(%rbp)
je 0x6ab44
movq -0x120(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rax
movq $0x0, 0x60(%rax)
movl $0x0, -0x124(%rbp)
cmpl $0x1f, -0x124(%rbp)
jae 0x6ab0b
movl -0x124(%rbp), %eax
cmpq $0x0, -0x110(%rbp,%rax,8)
jne 0x6aac5
movq -0x118(%rbp), %rcx
movl -0x124(%rbp), %eax
movq %rcx, -0x110(%rbp,%rax,8)
jmp 0x6ab0b
movl -0x124(%rbp), %eax
movq -0x110(%rbp,%rax,8), %rdi
movq -0x118(%rbp), %rsi
callq 0x6ad40
movq %rax, -0x118(%rbp)
movl -0x124(%rbp), %eax
movq $0x0, -0x110(%rbp,%rax,8)
jmp 0x6aafa
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x6aa94
cmpl $0x1f, -0x124(%rbp)
jne 0x6ab3f
movl -0x124(%rbp), %eax
movq -0x110(%rbp,%rax,8), %rdi
movq -0x118(%rbp), %rsi
callq 0x6ad40
movq %rax, %rcx
movl -0x124(%rbp), %eax
movq %rcx, -0x110(%rbp,%rax,8)
jmp 0x6aa4d
movq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
movl $0x1, -0x124(%rbp)
cmpl $0x20, -0x124(%rbp)
jae 0x6ab97
movq -0x118(%rbp), %rdi
movl -0x124(%rbp), %eax
movq -0x110(%rbp,%rax,8), %rsi
callq 0x6ad40
movq %rax, -0x118(%rbp)
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x6ab5c
movq -0x118(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x118(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_write_hot_dirty_pages
static int pager_write_hot_dirty_pages(Pager *pPager,Page *pDirty)
{
	int rc = UNQLITE_OK;
	Page *pNext;
	for(;;){
		if( pDirty == 0 ){
			break;
		}
		/* Point to the next page */
		pNext = pDirty->pPrevHot; /* Not a bug: Reverse link */
		if( (pDirty->flags & PAGE_DONT_WRITE) == 0 ){
			rc = unqliteOsWrite(pPager->pfd,pDirty->zData,pPager->iPageSize,pDirty->iPage * pPager->iPageSize);
			if( rc != UNQLITE_OK ){
				break;
			}
		}
		/* Remove stale flags */
		pDirty->flags &= ~(PAGE_DIRTY|PAGE_DONT_WRITE|PAGE_NEED_SYNC|PAGE_IN_JOURNAL|PAGE_HOT_DIRTY);
		/* Unlink from the list of dirty pages */
		if( pDirty->pDirtyPrev ){
			pDirty->pDirtyPrev->pDirtyNext = pDirty->pDirtyNext;
		}else{
			pPager->pDirty = pDirty->pDirtyNext;
		}
		if( pDirty->pDirtyNext ){
			pDirty->pDirtyNext->pDirtyPrev = pDirty->pDirtyPrev;
		}else{
			pPager->pFirstDirty = pDirty->pDirtyPrev;
		}
		/* Discard */
		pager_unlink_page(pPager,pDirty);
		/* Release the page */
		pager_release_page(pPager,pDirty);
		/* Next hot page */
		pDirty = pNext;
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6abe3
jmp 0x6ace0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x6ac44
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x208(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movslq 0x208(%rax), %rax
imulq %rax, %rcx
callq 0x69e30
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6ac42
jmp 0x6ace0
jmp 0x6ac44
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
andl $-0x6f, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x6ac72
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x38(%rax)
jmp 0x6ac85
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x220(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x6aca6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
jmp 0x6acb9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ae70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6af80
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x6abd7
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
pushq %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x81(%rbp)
je 0x6ad82
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x6ad8e
jmp 0x6adff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x6adce
movq -0x8(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6adfa
movq -0x10(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6ad65
cmpq $0x0, -0x8(%rbp)
je 0x6ae20
movq -0x8(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x6ae5b
cmpq $0x0, -0x10(%rbp)
je 0x6ae41
movq -0x10(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x6ae59
movq -0x80(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x80(%rbp), %rax
movq $0x0, 0x60(%rax)
jmp 0x6ae5b
movq -0x18(%rbp), %rax
addq $0x8, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x6ae9b
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x6aebc
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x6aef3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x250(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
andq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x228(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6af1e
movq -0x8(%rbp), %rax
movq 0x228(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x228(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6af3d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6af5c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x254(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x254(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x6aff2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x188(%rax)
je 0x6afd4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6afd4
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54490
jmp 0x6aff9
movl $0xfffffffc, -0x14(%rbp) # imm = 0xFFFFFFFC
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBitvecTest
UNQLITE_PRIVATE int unqliteBitvecTest(Bitvec *p,pgno i)
{  
	bitvec_rec *pRec;
	/* Point to the desired bucket */
	pRec = p->apRec[i & (p->nSize - 1)];
	for(;;){
		if( pRec == 0 ){ break; }
		if( pRec->iPage == i ){
			/* Page found */
			return 1;
		}
		/* Point to the next entry */
		pRec = pRec->pNextCol;

		if( pRec == 0 ){ break; }
		if( pRec->iPage == i ){
			/* Page found */
			return 1;
		}
		/* Point to the next entry */
		pRec = pRec->pNextCol;


		if( pRec == 0 ){ break; }
		if( pRec->iPage == i ){
			/* Page found */
			return 1;
		}
		/* Point to the next entry */
		pRec = pRec->pNextCol;


		if( pRec == 0 ){ break; }
		if( pRec->iPage == i ){
			/* Page found */
			return 1;
		}
		/* Point to the next entry */
		pRec = pRec->pNextCol;
	}
	/* No such entry */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
andq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b04b
jmp 0x6b0f6
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6b064
movl $0x1, -0x4(%rbp)
jmp 0x6b0fd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b079
jmp 0x6b0f6
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6b08f
movl $0x1, -0x4(%rbp)
jmp 0x6b0fd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b0a4
jmp 0x6b0f6
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6b0ba
movl $0x1, -0x4(%rbp)
jmp 0x6b0fd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b0cf
jmp 0x6b0f6
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6b0e5
movl $0x1, -0x4(%rbp)
jmp 0x6b0fd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6b03f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_page_to_dirty_list
static void pager_page_to_dirty_list(Pager *pPager,Page *pPage)
{
	if( pPage->flags & PAGE_DIRTY ){
		/* Already set */
		return;
	}
	/* Mark the page as dirty */
	pPage->flags |= PAGE_DIRTY|PAGE_NEED_SYNC|PAGE_IN_JOURNAL;
	/* Link to the list */
	pPage->pDirtyPrev = 0;
	pPage->pDirtyNext = pPager->pDirty;
	if( pPager->pDirty ){
		pPager->pDirty->pDirtyPrev = pPage;
	}
	pPager->pDirty = pPage;
	if( pPager->pFirstDirty == 0 ){
		pPager->pFirstDirty = pPage;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6b35d
jmp 0x6b3d6
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
orl $0x26, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0x6b3aa
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
jne 0x6b3d6
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlitePagerDontWrite
static int unqlitePagerDontWrite(unqlite_page *pMyPage)
{
	Page *pPage = (Page *)pMyPage;
	if( pPage->iPage > 0 /* Page 0 is always writeable */ ){
		pPage->flags |= PAGE_DONT_WRITE;
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x6b408
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: page_unref
static void page_unref(Page *pPage)
{
	pPage->nRef--;
	if( pPage->nRef < 1	){
		Pager *pPager = pPage->pPager;
		if( !(pPage->flags & PAGE_DIRTY)  ){
			pager_unlink_page(pPager,pPage);
			/* Release the page */
			pager_release_page(pPager,pPage);
		}else{
			if( pPage->flags & PAGE_DONT_MAKE_HOT ){
				/* Do not add this page to the hot dirty list */
				return;
			}
			if( !(pPage->flags & PAGE_HOT_DIRTY) ){
				/* Add to the hot dirty list */
				pPage->pPrevHot = 0;
				if( pPager->pFirstHot == 0 ){
					pPager->pFirstHot = pPager->pHotDirty = pPage;
				}else{
					pPage->pNextHot = pPager->pHotDirty;
					if( pPager->pHotDirty ){
						pPager->pHotDirty->pPrevHot = pPage;
					}
					pPager->pHotDirty = pPage;
				}
				pPager->nHot++;
				pPage->flags |= PAGE_HOT_DIRTY;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jge 0x6b537
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x6b471
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6ae70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6af80
jmp 0x6b535
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x6b487
jmp 0x6b537
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x6b533
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x6b4d0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x230(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x238(%rax)
jmp 0x6b513
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x230(%rax)
je 0x6b504
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x230(%rax)
movq -0x10(%rbp), %rax
movl 0x240(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x240(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x20(%rax)
jmp 0x6b535
jmp 0x6b537
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: jx9EngineConfig
JX9_PRIVATE sxi32 jx9EngineConfig(jx9 *pEngine, sxi32 nOp, va_list ap)
{
	jx9_conf *pConf = &pEngine->xConf;
	int rc = JX9_OK;
	/* Perform the requested operation */
	switch(nOp){									 
	case JX9_CONFIG_ERR_LOG:{
		/* Extract compile-time error log if any */
		const char **pzPtr = va_arg(ap, const char **);
		int *pLen = va_arg(ap, int *);
		if( pzPtr == 0 ){
			rc = JX9_CORRUPT;
			break;
		}
		/* NULL terminate the error-log buffer */
		SyBlobNullAppend(&pConf->sErrConsumer);
		/* Point to the error-log buffer */
		*pzPtr = (const char *)SyBlobData(&pConf->sErrConsumer);
		if( pLen ){
			if( SyBlobLength(&pConf->sErrConsumer) > 1 /* NULL '\0' terminator */ ){
				*pLen = (int)SyBlobLength(&pConf->sErrConsumer);
			}else{
				*pLen = 0;
			}
		}
		break;
							}
	case JX9_CONFIG_ERR_ABORT:
		/* Reserved for future use */
		break;
	default:
		/* Unknown configuration verb */
		rc = JX9_CORRUPT;
		break;
	} /* Switch() */
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x6b82b
jmp 0x6b729
movl -0x3c(%rbp), %eax
subl $0x2, %eax
jne 0x6b82d
jmp 0x6b737
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $0x28, %eax
ja 0x6b762
movq -0x48(%rbp), %rcx
movl -0x40(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x6b779
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl (%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x28, %eax
ja 0x6b7af
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6b7c6
movq -0x60(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6b7e1
movl $0xffffffe8, -0x24(%rbp) # imm = 0xFFFFFFE8
jmp 0x6b834
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x6b880
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x6b829
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jbe 0x6b81d
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6b827
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
jmp 0x6b829
jmp 0x6b834
jmp 0x6b834
movl $0xffffffe8, -0x24(%rbp) # imm = 0xFFFFFFE8
movl -0x24(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlitePagerSetCachesize
UNQLITE_PRIVATE int unqlitePagerSetCachesize(Pager *pPager,int mxPage)
{
	if( mxPage < 256 ){
		return UNQLITE_INVALID;
	}
	pPager->nCacheMax = mxPage;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x6b85d
movl $0xfffffff7, -0x4(%rbp) # imm = 0xFFFFFFF7
jmp 0x6b871
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x258(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBlobNullAppend
JX9_PRIVATE sxi32 SyBlobNullAppend(SyBlob *pBlob)
{
	sxi32 rc;
	sxu32 n;
	n = pBlob->nByte;
	rc = SyBlobAppend(&(*pBlob), (const void *)"\0", sizeof(char));
	if (rc == SXRET_OK ){
		pBlob->nByte = n;
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55933(%rip), %rsi     # 0xc11d4
movl $0x1, %edx
callq 0x5d9d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6b8be
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlitePagerClose
UNQLITE_PRIVATE int unqlitePagerClose(Pager *pPager)
{
	/* Release the KV engine */
	pager_release_kv_engine(pPager);
	if( pPager->iOpenFlags & UNQLITE_OPEN_MMAP ){
		const jx9_vfs *pVfs = jx9ExportBuiltinVfs();
		if( pVfs && pVfs->xUnmap && pPager->pMmap ){
			pVfs->xUnmap(pPager->pMmap,pPager->dbByteSize);
		}
	}
	if( !pPager->is_mem && pPager->iState > PAGER_OPEN ){
		/* Release all lock on this database handle */
		pager_unlock_db(pPager,NO_LOCK);
		/* Close the file  */
		unqliteOsCloseFree(pPager->pAllocator,pPager->pfd);
	}
	if( pPager->pVec ){
		unqliteBitvecDestroy(pPager->pVec);
		pPager->pVec = 0;
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67ed0
movq -0x8(%rbp), %rax
movl 0x16c(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x6b941
callq 0x5a4c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b93f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0x6b93f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x6b93f
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rsi
callq *%rax
jmp 0x6b941
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1fc(%rax)
jne 0x6b97a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1f0(%rax)
jle 0x6b97a
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x693c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x697c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x198(%rax)
je 0x6b9a7
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0x6bb80
movq -0x8(%rbp), %rax
movq $0x0, 0x198(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jae 0x6bbb2
jmp 0x6bc96
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54490
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jae 0x6bbef
jmp 0x6bc96
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54490
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jae 0x6bc29
jmp 0x6bc96
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54490
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jae 0x6bc63
jmp 0x6bc96
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54490
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x6bba3
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5d6b0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5d6b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_version
static int unqliteBuiltin_db_version(jx9_context *pCtx,int argc,jx9_value **argv)
{
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	jx9_result_string(pCtx,UNQLITE_VERSION,(int)sizeof(UNQLITE_VERSION)-1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55dcb(%rip), %rsi     # 0xc1b38
movl $0x5, %edx
callq 0x57180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_credits
static int unqliteBuiltin_db_credits(jx9_context *pCtx,int argc,jx9_value **argv)
{
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	jx9_result_string(pCtx,UNQLITE_COPYRIGHT,(int)sizeof(UNQLITE_COPYRIGHT)-1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55dc2(%rip), %rsi     # 0xc1b6f
movl $0x6b, %edx
callq 0x57180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_sig
static int unqliteBuiltin_db_sig(jx9_context *pCtx,int argc,jx9_value **argv)
{
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);
	jx9_result_string(pCtx,UNQLITE_IDENT,sizeof(UNQLITE_IDENT)-1);
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55d51(%rip), %rsi     # 0xc1b3e
movl $0x30, %edx
callq 0x57180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteBuiltin_db_errlog
static int unqliteBuiltin_db_errlog(jx9_context *pCtx,int argc,jx9_value **argv)
{
	unqlite_vm *pVm;
	SyBlob *pErr;
	
	SXUNUSED(argc); /* cc warning */
	SXUNUSED(argv);

	pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
	/* Point to the error log */
	pErr = &pVm->pDb->sErr;
	/* Return the log */
	jx9_result_string(pCtx,(const char *)SyBlobData(pErr),(int)SyBlobLength(pErr));
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x58300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0xb8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x57180
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x6bea5
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x565ac(%rip), %rdx     # 0xc2435
callq 0x580b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x6bf3b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x56e20
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x4c(%rbp)
jge 0x6bee8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x5657e(%rip), %rdx     # 0xc244d
callq 0x580b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
jmp 0x6bf3b
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58300
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x4, %edx
callq 0x6d410
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
xorl %esi, %esi
movl $0x1, %eax
cmpq $0x0, %rcx
cmovnel %eax, %esi
callq 0x57070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)